move scan utils into fs-sync plugin

Author: yujonglee

Cargo.lock

@@ -1,5 +1,13 @@
-- Persisters define both load/save. The call site decides what to use (e.g., startAutoSave vs startAutoLoad).
+## File naming conventions
+
+- `index.ts`: Controls load/save behavior, and should export single hook.
+- `persister.ts`: Defines both load and save regardless of actual usage.
+- `load.ts`: Reads from filesystem and parses data into store-compatible format (filesystem → store).
+- `collect.ts`: Extracts store data and prepares filesystem write operations (store → filesystem).
+- `transform.ts`: Bidirectional conversion between file format and store format (used by both load and collect).
+
+## Notes
+
 - `local.ts` and `settings.ts` do both save/load.
 - `folder.ts` is used as load-only (syncs filesystem → store for folders and session folder_id).
-- `session/` is the unified persister for session-related data (sessions, transcripts, notes, etc.). It combines load from multiple sources in a single scan and uses separate collectors for save.
 - Other persisters are used as save-only for now.

apps/desktop/src/store/tinybase/persister/AGENTS.md

@@ -1,7 +1,7 @@
 import { sep } from "@tauri-apps/api/path";
-import { readDir, readTextFile } from "@tauri-apps/plugin-fs";
 
-import { isFileNotFoundError, isUUID } from "../utils";
+import { commands as fsSyncCommands } from "@hypr/plugin-fs-sync";
+
 import {
   type ChatJson,
   chatJsonToData,
@@ -19,37 +19,27 @@ export async function loadAllChatData(
 ): Promise<LoadedChatData> {
   const chatsDir = [dataDir, "chats"].join(sep());
 
-  let entries: { name: string; isDirectory: boolean }[];
-  try {
-    entries = await readDir(chatsDir);
-  } catch (error) {
-    if (!isFileNotFoundError(error)) {
-      console.error(`[${LABEL}] load error:`, error);
-    }
+  const scanResult = await fsSyncCommands.scanAndRead(
+    chatsDir,
+    ["_messages.json"],
+    false,
+  );
+
+  if (scanResult.status === "error") {
+    console.error(`[${LABEL}] scan error:`, scanResult.error);
     return createEmptyLoadedData();
   }
 
+  const { files } = scanResult.data;
   const items: LoadedChatData[] = [];
 
-  for (const entry of entries) {
-    if (!entry.isDirectory) continue;
-    if (!isUUID(entry.name)) continue;
-
-    const chatGroupId = entry.name;
-    const messagesPath = [chatsDir, chatGroupId, "_messages.json"].join(sep());
-
+  for (const [, content] of Object.entries(files)) {
+    if (!content) continue;
     try {
-      const content = await readTextFile(messagesPath);
       const json = JSON.parse(content) as ChatJson;
       items.push(chatJsonToData(json));
     } catch (error) {
-      if (!isFileNotFoundError(error)) {
-        console.error(
-          `[${LABEL}] Failed to load chat from ${messagesPath}:`,
-          error,
-        );
-      }
-      continue;
+      console.error(`[${LABEL}] Failed to parse chat JSON:`, error);
     }
   }
 

apps/desktop/src/store/tinybase/persister/chat/load.ts

@@ -5,12 +5,16 @@ import type {
   MappingSessionParticipantStorage,
   MappingTagSession,
   SessionStorage,
+  SpeakerHintStorage,
   Tag,
+  TranscriptStorage,
+  WordStorage,
 } from "@hypr/store";
 
 import {
   type CollectorResult,
   getSessionDir,
+  iterateTableRows,
   type TablesContent,
 } from "../utils";
 
@@ -118,3 +122,79 @@ export function collectSessionWriteOps<Schemas extends OptionalSchemas>(
 
   return { dirs, operations, validSessionIds: new Set(sessionMetas.keys()) };
 }
+
+type TranscriptWithData = TranscriptStorage & {
+  id: string;
+  words: Array<WordStorage & { id: string }>;
+  speaker_hints: Array<SpeakerHintStorage & { id: string }>;
+};
+
+type TranscriptJson = {
+  transcripts: TranscriptWithData[];
+};
+
+export function collectTranscriptWriteOps(
+  _store: unknown,
+  tables: TablesContent,
+  dataDir: string,
+): CollectorResult {
+  const dirs = new Set<string>();
+  const operations: CollectorResult["operations"] = [];
+
+  const transcripts = iterateTableRows(tables, "transcripts");
+  const words = iterateTableRows(tables, "words");
+  const speakerHints = iterateTableRows(tables, "speaker_hints");
+
+  const wordsByTranscript = new Map<
+    string,
+    Array<WordStorage & { id: string }>
+  >();
+  for (const word of words) {
+    if (!word.transcript_id) continue;
+    const list = wordsByTranscript.get(word.transcript_id) ?? [];
+    list.push(word);
+    wordsByTranscript.set(word.transcript_id, list);
+  }
+
+  const hintsByTranscript = new Map<
+    string,
+    Array<SpeakerHintStorage & { id: string }>
+  >();
+  for (const hint of speakerHints) {
+    if (!hint.transcript_id) continue;
+    const list = hintsByTranscript.get(hint.transcript_id) ?? [];
+    list.push(hint);
+    hintsByTranscript.set(hint.transcript_id, list);
+  }
+
+  const transcriptsBySession = new Map<string, TranscriptWithData[]>();
+  for (const transcript of transcripts) {
+    const sessionId = transcript.session_id;
+    if (!sessionId) continue;
+    const transcriptData: TranscriptWithData = {
+      ...transcript,
+      words: wordsByTranscript.get(transcript.id) ?? [],
+      speaker_hints: hintsByTranscript.get(transcript.id) ?? [],
+    };
+
+    const list = transcriptsBySession.get(sessionId) ?? [];
+    list.push(transcriptData);
+    transcriptsBySession.set(sessionId, list);
+  }
+
+  for (const [sessionId, sessionTranscripts] of transcriptsBySession) {
+    const session = tables.sessions?.[sessionId];
+    const folderPath = session?.folder_id ?? "";
+    const sessionDir = getSessionDir(dataDir, sessionId, folderPath);
+    dirs.add(sessionDir);
+
+    const content: TranscriptJson = { transcripts: sessionTranscripts };
+    operations.push({
+      type: "json",
+      path: [sessionDir, "_transcript.json"].join(sep()),
+      content,
+    });
+  }
+
+  return { dirs, operations };
+}

apps/desktop/src/store/tinybase/persister/session/collect.ts

@@ -1,40 +1,20 @@
-import { BaseDirectory, exists, mkdir } from "@tauri-apps/plugin-fs";
 import * as _UI from "tinybase/ui-react/with-schemas";
 
 import { type Schemas } from "@hypr/store";
 
 import type { Store } from "../../store/main";
 import { createSessionPersister } from "./persister";
 
-export { createSessionPersister } from "./persister";
-export type { SessionDataLoad } from "./load";
-
 const { useCreatePersister } = _UI as _UI.WithSchemas<Schemas>;
 
 export function useSessionPersister(store: Store) {
   return useCreatePersister(
     store,
     async (store) => {
-      try {
-        const dirExists = await exists("hyprnote/sessions", {
-          baseDir: BaseDirectory.Data,
-        });
-        if (!dirExists) {
-          await mkdir("hyprnote/sessions", {
-            baseDir: BaseDirectory.Data,
-            recursive: true,
-          });
-        }
-      } catch (error) {
-        console.error("Failed to create sessions directory:", error);
-        throw error;
-      }
-
       const persister = createSessionPersister<Schemas>(store as Store);
       await persister.startAutoSave();
       return persister;
     },
     [],
   );
 }
-