doocus first ver

ui/doocus-app/src/store.ts

@@ -0,0 +1,120 @@
+/**
+ * Reactive app store for the doocus browser.
+ *
+ * Reads the local docs-output tree via /api/docs (see server/doocusApi.ts).
+ * Holds the doc list, the currently open doc (meta + textified content), and the
+ * selection used by the package builder. Read-only over the pipeline output —
+ * the UI never mutates extracted artifacts.
+ */
+import { reactive, computed } from 'vue'
+
+export interface DocSummary {
+  id: string
+  name: string
+  type: string | null
+  family: string | null
+  title: string | null
+  extractedAt: string | null
+  wordCount: number
+  bytes: number
+  hasThumb: boolean
+  warnings: number
+}
+
+export interface DocDetail {
+  id: string
+  meta: Record<string, unknown>
+  content: string
+  hasThumb: boolean
+  thumbUrl: string | null
+  hasOriginal: boolean
+  originalUrl: string | null
+}
+
+/** Package targets and their (soft) limits. Surfaced, not hard-enforced. */
+export interface Target {
+  key: string
+  label: string
+  maxFiles: number
+  maxBytes: number
+}
+
+export const TARGETS: Target[] = [
+  { key: 'gemini', label: 'Gemini web', maxFiles: 10, maxBytes: 100 * 1024 * 1024 },
+  { key: 'notebooklm', label: 'NotebookLM', maxFiles: 50, maxBytes: 200 * 1024 * 1024 },
+]
+
+interface State {
+  docs: DocSummary[]
+  outputDir: string
+  currentId: string | null
+  current: DocDetail | null
+  loading: boolean
+  selected: Set<string>
+  targetKey: string
+}
+
+export const store = reactive<State>({
+  docs: [],
+  outputDir: '',
+  currentId: null,
+  current: null,
+  loading: false,
+  selected: new Set<string>(),
+  targetKey: TARGETS[0].key,
+})
+
+export async function loadDocs(): Promise<void> {
+  const res = await fetch('/api/docs')
+  const data = await res.json()
+  store.docs = data.docs ?? []
+  store.outputDir = data.outputDir ?? ''
+  if (!store.currentId && store.docs.length) {
+    await openDoc(store.docs[0].id)
+  }
+}
+
+export async function openDoc(id: string): Promise<void> {
+  store.loading = true
+  try {
+    const res = await fetch(`/api/docs/${encodeURIComponent(id)}`)
+    if (!res.ok) throw new Error(`open failed: ${res.status}`)
+    store.current = await res.json()
+    store.currentId = id
+  } finally {
+    store.loading = false
+  }
+}
+
+export function toggleSelect(id: string): void {
+  if (store.selected.has(id)) store.selected.delete(id)
+  else store.selected.add(id)
+}
+
+export function isSelected(id: string): boolean {
+  return store.selected.has(id)
+}
+
+export const target = computed(() => TARGETS.find((t) => t.key === store.targetKey) ?? TARGETS[0])
+
+/** Rough package estimate: each doc contributes original + content.md + meta.json. */
+export const packageEstimate = computed(() => {
+  const chosen = store.docs.filter((d) => store.selected.has(d.id))
+  const files = chosen.length * 3 // original + content.md + meta.json
+  // originals dominate size; content/meta are small — approximate with wordCount.
+  const bytes = chosen.reduce((sum, d) => sum + d.bytes + d.wordCount * 6 + 512, 0)
+  const t = target.value
+  return {
+    docCount: chosen.length,
+    files,
+    bytes,
+    overFiles: files > t.maxFiles,
+    overBytes: bytes > t.maxBytes,
+  }
+})
+
+export function humanBytes(n: number): string {
+  if (n < 1024) return `${n} B`
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`
+  return `${(n / 1024 / 1024).toFixed(1)} MB`
+}