@ophan/cli 0.0.1

package/dist/sync.js

@@ -0,0 +1,255 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncToSupabase = syncToSupabase;
+exports.pullFromSupabase = pullFromSupabase;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const core_1 = require("@ophan/core");
+function getGitRemoteUrl(rootPath) {
+    try {
+        return ((0, child_process_1.execSync)("git remote get-url origin", {
+            cwd: rootPath,
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim() || null);
+    }
+    catch {
+        return null;
+    }
+}
+async function syncToSupabase(rootPath, supabase, userId, onProgress) {
+    const dbPath = path.join(rootPath, ".ophan", "index.db");
+    if (!fs.existsSync(dbPath)) {
+        throw new Error(`No analysis database found at ${dbPath}\n  Run \`ophan analyze\` first.`);
+    }
+    const db = new better_sqlite3_1.default(dbPath);
+    // Ensure sync_meta table exists (may not if DB was created by older version)
+    db.exec("CREATE TABLE IF NOT EXISTS sync_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
+    try {
+        // 0. Detect user change — if different user, reset sync state
+        const lastUser = db
+            .prepare("SELECT value FROM sync_meta WHERE key = 'last_synced_user_id'")
+            .get();
+        if (lastUser && lastUser.value !== userId) {
+            onProgress?.(`Account changed (was ${lastUser.value.slice(0, 8)}...). Re-syncing all data...`);
+            db.exec("UPDATE function_analysis SET synced_at = NULL");
+            db.exec("DELETE FROM function_gc");
+        }
+        // Update last synced user
+        db.prepare("INSERT OR REPLACE INTO sync_meta (key, value) VALUES ('last_synced_user_id', ?)").run(userId);
+        // 1. Ensure repo exists
+        const repoName = path.basename(rootPath);
+        const remoteUrl = getGitRemoteUrl(rootPath);
+        onProgress?.("Registering repo...");
+        const { data: repo, error: repoError } = await supabase
+            .from("repos")
+            .upsert({
+            user_id: userId,
+            name: repoName,
+            remote_url: remoteUrl,
+        }, { onConflict: "user_id,name" })
+            .select("id")
+            .single();
+        if (repoError) {
+            throw new Error(`Failed to register repo: ${repoError.message}`);
+        }
+        const repoId = repo.id;
+        // 2. Push unsynced analysis (now includes analysis_type + schema_version)
+        onProgress?.("Pushing analysis...");
+        const unsynced = db
+            .prepare(`SELECT content_hash, analysis_type, analysis, model_version, schema_version, language, entity_type, created_at
+         FROM function_analysis WHERE synced_at IS NULL`)
+            .all();
+        if (unsynced.length > 0) {
+            const rows = unsynced.map((row) => ({
+                content_hash: row.content_hash,
+                analysis_type: row.analysis_type,
+                repo_id: repoId,
+                user_id: userId,
+                analysis: JSON.parse(row.analysis),
+                model_version: row.model_version,
+                schema_version: row.schema_version,
+                language: row.language,
+                entity_type: row.entity_type,
+            }));
+            // Batch upsert in chunks of 500 (Supabase limit)
+            for (let i = 0; i < rows.length; i += 500) {
+                const chunk = rows.slice(i, i + 500);
+                const { error } = await supabase
+                    .from("function_analysis")
+                    .upsert(chunk, { onConflict: "content_hash,repo_id,analysis_type" });
+                if (error) {
+                    throw new Error(`Failed to push analysis: ${error.message}`);
+                }
+            }
+            // Mark as synced locally
+            const now = Math.floor(Date.now() / 1000);
+            const markSynced = db.prepare("UPDATE function_analysis SET synced_at = ? WHERE content_hash = ? AND analysis_type = ?");
+            const markBatch = db.transaction(() => {
+                for (const row of unsynced) {
+                    markSynced.run(now, row.content_hash, row.analysis_type);
+                }
+            });
+            markBatch();
+        }
+        // 3. Replace function_locations (full sync each time)
+        onProgress?.("Syncing file locations...");
+        const { error: delError } = await supabase
+            .from("function_locations")
+            .delete()
+            .eq("repo_id", repoId);
+        if (delError) {
+            throw new Error(`Failed to clear locations: ${delError.message}`);
+        }
+        const locations = db
+            .prepare(`SELECT file_path, function_name, content_hash, language, entity_type
+         FROM file_functions`)
+            .all();
+        if (locations.length > 0) {
+            const locationRows = locations.map((row) => ({
+                repo_id: repoId,
+                user_id: userId,
+                file_path: row.file_path,
+                function_name: row.function_name,
+                content_hash: row.content_hash,
+                language: row.language,
+                entity_type: row.entity_type,
+            }));
+            for (let i = 0; i < locationRows.length; i += 500) {
+                const chunk = locationRows.slice(i, i + 500);
+                const { error } = await supabase
+                    .from("function_locations")
+                    .insert(chunk);
+                if (error) {
+                    throw new Error(`Failed to push locations: ${error.message}`);
+                }
+            }
+        }
+        // 4. Process GC tombstones
+        onProgress?.("Processing garbage collection...");
+        const gcRows = db
+            .prepare("SELECT content_hash, analysis_type FROM function_gc WHERE synced_at IS NULL")
+            .all();
+        if (gcRows.length > 0) {
+            for (const row of gcRows) {
+                if (row.analysis_type) {
+                    // Delete specific analysis type
+                    await supabase
+                        .from("function_analysis")
+                        .delete()
+                        .eq("content_hash", row.content_hash)
+                        .eq("repo_id", repoId)
+                        .eq("analysis_type", row.analysis_type);
+                }
+                else {
+                    // NULL analysis_type means delete all types (legacy GC entry)
+                    await supabase
+                        .from("function_analysis")
+                        .delete()
+                        .eq("content_hash", row.content_hash)
+                        .eq("repo_id", repoId);
+                }
+                await supabase
+                    .from("function_locations")
+                    .delete()
+                    .eq("content_hash", row.content_hash)
+                    .eq("repo_id", repoId);
+            }
+            // Mark GC rows as synced locally, then delete them
+            const now = Math.floor(Date.now() / 1000);
+            db.transaction(() => {
+                db.prepare("UPDATE function_gc SET synced_at = ? WHERE synced_at IS NULL").run(now);
+                db.prepare("DELETE FROM function_gc WHERE synced_at IS NOT NULL").run();
+            })();
+        }
+        return {
+            pushed: unsynced.length,
+            locations: locations.length,
+            gcProcessed: gcRows.length,
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+// ============ PULL SYNC ============
+/**
+ * Pull analysis from Supabase for content hashes missing locally.
+ * Used before `analyzeRepository()` to avoid re-running expensive Claude analysis.
+ */
+async function pullFromSupabase(rootPath, supabase, userId, repoId, missingHashes, onProgress) {
+    if (missingHashes.length === 0)
+        return { pulled: 0 };
+    const dbPath = path.join(rootPath, ".ophan", "index.db");
+    onProgress?.(`Pulling ${missingHashes.length} cached analyses from cloud...`);
+    const allRows = [];
+    // Batch queries in chunks of 200 to avoid URL length limits
+    for (let i = 0; i < missingHashes.length; i += 200) {
+        const chunk = missingHashes.slice(i, i + 200);
+        const { data, error } = await supabase
+            .from("function_analysis")
+            .select("content_hash, analysis_type, analysis, model_version, schema_version, language, entity_type")
+            .eq("repo_id", repoId)
+            .in("content_hash", chunk);
+        if (error) {
+            onProgress?.(`Warning: pull failed: ${error.message}`);
+            continue;
+        }
+        if (data) {
+            for (const row of data) {
+                allRows.push({
+                    content_hash: row.content_hash,
+                    analysis_type: row.analysis_type,
+                    analysis: typeof row.analysis === "string" ? row.analysis : JSON.stringify(row.analysis),
+                    model_version: row.model_version,
+                    schema_version: row.schema_version ?? 1,
+                    language: row.language ?? "typescript",
+                    entity_type: row.entity_type ?? "function",
+                });
+            }
+        }
+    }
+    if (allRows.length === 0)
+        return { pulled: 0 };
+    const imported = (0, core_1.importAnalysis)(dbPath, allRows);
+    onProgress?.(`Pulled ${imported} analyses from cloud`);
+    return { pulled: imported };
+}

package/dist/sync.test.js

@@ -0,0 +1,288 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const test_utils_1 = require("./test-utils");
+const sync_1 = require("./sync");
+const test_utils_2 = require("@ophan/core/test-utils");
+const USER_A = "user-aaaa-aaaa-aaaa-aaaaaaaaaaaa";
+const USER_B = "user-bbbb-bbbb-bbbb-bbbbbbbbbbbb";
+const REPO_ID = "repo-1";
+function defaultRepoResponse() {
+    return { data: { id: REPO_ID }, error: null };
+}
+// ============ syncToSupabase ============
+(0, vitest_1.describe)("syncToSupabase", () => {
+    const cleanups = [];
+    function tracked(result) {
+        cleanups.push(result.cleanup);
+        return result;
+    }
+    (0, vitest_1.afterEach)(() => {
+        cleanups.forEach((fn) => fn());
+        cleanups.length = 0;
+    });
+    (0, vitest_1.describe)("account change detection", () => {
+        (0, vitest_1.it)("first sync — stores user_id, no reset", async () => {
+            const { rootPath, dbPath } = tracked((0, test_utils_1.createTempDb)());
+            const mock = (0, test_utils_1.createMockSupabase)({
+                "repos.upsert": defaultRepoResponse(),
+            });
+            await (0, sync_1.syncToSupabase)(rootPath, mock.client, USER_A);
+            const db = new better_sqlite3_1.default(dbPath);
+            const row = db
+                .prepare("SELECT value FROM sync_meta WHERE key = 'last_synced_user_id'")
+                .get();
+            db.close();
+            (0, vitest_1.expect)(row.value).toBe(USER_A);
+        });
+        (0, vitest_1.it)("same user re-sync — no reset of synced_at", async () => {
+            const { rootPath, dbPath } = tracked((0, test_utils_1.createTempDb)((db) => {
+                db.prepare("INSERT INTO sync_meta (key, value) VALUES ('last_synced_user_id', ?)").run(USER_A);
+                (0, test_utils_2.insertAnalysisPair)(db, "hash1", { syncedAt: 1000 });
+            }));
+            const mock = (0, test_utils_1.createMockSupabase)({
+                "repos.upsert": defaultRepoResponse(),
+            });
+            await (0, sync_1.syncToSupabase)(rootPath, mock.client, USER_A);
+            // synced_at should still be set (not reset to NULL)
+            const db = new better_sqlite3_1.default(dbPath);
+            const row = db
+                .prepare("SELECT synced_at FROM function_analysis WHERE content_hash = 'hash1' AND analysis_type = 'documentation'")
+                .get();
+            db.close();
+            (0, vitest_1.expect)(row.synced_at).toBe(1000);
+        });
+        (0, vitest_1.it)("different user — resets synced_at to NULL and clears GC", async () => {
+            const { rootPath, dbPath } = tracked((0, test_utils_1.createTempDb)((db) => {
+                db.prepare("INSERT INTO sync_meta (key, value) VALUES ('last_synced_user_id', ?)").run(USER_A);
+                (0, test_utils_2.insertAnalysisPair)(db, "hash1", { syncedAt: 1000 });
+                db.prepare("INSERT INTO function_gc (content_hash, analysis_type, gc_at) VALUES ('old', 'documentation', 999)").run();
+            }));
+            const mock = (0, test_utils_1.createMockSupabase)({
+                "repos.upsert": defaultRepoResponse(),
+            });
+            await (0, sync_1.syncToSupabase)(rootPath, mock.client, USER_B);
+            const db = new better_sqlite3_1.default(dbPath);
+            // synced_at should be NULL (reset) then re-set by the push
+            const meta = db
+                .prepare("SELECT value FROM sync_meta WHERE key = 'last_synced_user_id'")
+                .get();
+            const gcCount = db
+                .prepare("SELECT count(*) as c FROM function_gc")
+                .get();
+            db.close();
+            (0, vitest_1.expect)(meta.value).toBe(USER_B);
+            (0, vitest_1.expect)(gcCount.c).toBe(0);
+        });
+    });
+    (0, vitest_1.describe)("push batching", () => {
+        (0, vitest_1.it)("pushes only unsynced rows (synced_at IS NULL)", async () => {
+            const { rootPath } = tracked((0, test_utils_1.createTempDb)((db) => {
+                (0, test_utils_2.insertAnalysisPair)(db, "hash-synced", { syncedAt: 1000 });
+                (0, test_utils_2.insertAnalysisPair)(db, "hash-unsynced", { syncedAt: null });
+            }));
+            const mock = (0, test_utils_1.createMockSupabase)({
+                "repos.upsert": defaultRepoResponse(),
+            });
+            const result = await (0, sync_1.syncToSupabase)(rootPath, mock.client, USER_A);
+            // Only hash-unsynced's 2 rows (doc + sec) should be pushed
+            (0, vitest_1.expect)(result.pushed).toBe(2);
+        });
+        (0, vitest_1.it)("marks synced_at after push", async () => {
+            const { rootPath, dbPath } = tracked((0, test_utils_1.createTempDb)((db) => {
+                (0, test_utils_2.insertAnalysisPair)(db, "hash1", { syncedAt: null });
+            }));
+            const mock = (0, test_utils_1.createMockSupabase)({
+                "repos.upsert": defaultRepoResponse(),
+            });
+            await (0, sync_1.syncToSupabase)(rootPath, mock.client, USER_A);
+            const db = new better_sqlite3_1.default(dbPath);
+            const rows = db
+                .prepare("SELECT synced_at FROM function_analysis WHERE content_hash = 'hash1'")
+                .all();
+            db.close();
+            for (const row of rows) {
+                (0, vitest_1.expect)(row.synced_at).not.toBeNull();
+                (0, vitest_1.expect)(row.synced_at).toBeGreaterThan(0);
+            }
+        });
+    });
+    (0, vitest_1.describe)("location full-sync", () => {
+        (0, vitest_1.it)("DELETE + INSERT pattern for file_functions", async () => {
+            const { rootPath } = tracked((0, test_utils_1.createTempDb)((db) => {
+                (0, test_utils_2.insertFileFunction)(db, "src/a.ts", "fn1", "hash1");
+                (0, test_utils_2.insertFileFunction)(db, "src/b.ts", "fn2", "hash2");
+            }));
+            const mock = (0, test_utils_1.createMockSupabase)({
+                "repos.upsert": defaultRepoResponse(),
+            });
+            const result = await (0, sync_1.syncToSupabase)(rootPath, mock.client, USER_A);
+            (0, vitest_1.expect)(result.locations).toBe(2);
+            // Verify DELETE was called before INSERT
+            const locationCalls = mock.calls.filter((c) => c.table === "function_locations");
+            const deleteIdx = locationCalls.findIndex((c) => c.method === "delete");
+            const insertIdx = locationCalls.findIndex((c) => c.method === "insert");
+            (0, vitest_1.expect)(deleteIdx).toBeLessThan(insertIdx);
+        });
+        (0, vitest_1.it)("empty file_functions — only deletes remote", async () => {
+            const { rootPath } = tracked((0, test_utils_1.createTempDb)());
+            const mock = (0, test_utils_1.createMockSupabase)({
+                "repos.upsert": defaultRepoResponse(),
+            });
+            const result = await (0, sync_1.syncToSupabase)(rootPath, mock.client, USER_A);
+            (0, vitest_1.expect)(result.locations).toBe(0);
+            // Should still call delete (clear remote)
+            const deleteCalls = mock.calls.filter((c) => c.table === "function_locations" && c.method === "delete");
+            (0, vitest_1.expect)(deleteCalls.length).toBe(1);
+            // Should NOT call insert
+            const insertCalls = mock.calls.filter((c) => c.table === "function_locations" && c.method === "insert");
+            (0, vitest_1.expect)(insertCalls.length).toBe(0);
+        });
+    });
+    (0, vitest_1.describe)("GC tombstone propagation", () => {
+        (0, vitest_1.it)("processes unsynced GC entries and cleans them up", async () => {
+            const { rootPath, dbPath } = tracked((0, test_utils_1.createTempDb)((db) => {
+                db.prepare("INSERT INTO function_gc (content_hash, analysis_type, gc_at) VALUES (?, ?, ?)").run("dead-hash", "documentation", Math.floor(Date.now() / 1000));
+            }));
+            const mock = (0, test_utils_1.createMockSupabase)({
+                "repos.upsert": defaultRepoResponse(),
+            });
+            const result = await (0, sync_1.syncToSupabase)(rootPath, mock.client, USER_A);
+            (0, vitest_1.expect)(result.gcProcessed).toBe(1);
+            // GC rows should be cleaned up (synced then deleted)
+            const db = new better_sqlite3_1.default(dbPath);
+            const gcCount = db
+                .prepare("SELECT count(*) as c FROM function_gc")
+                .get();
+            db.close();
+            (0, vitest_1.expect)(gcCount.c).toBe(0);
+        });
+        (0, vitest_1.it)("type-specific tombstone — deletes specific analysis_type", async () => {
+            const { rootPath } = tracked((0, test_utils_1.createTempDb)((db) => {
+                db.prepare("INSERT INTO function_gc (content_hash, analysis_type, gc_at) VALUES (?, ?, ?)").run("dead-hash", "security", Math.floor(Date.now() / 1000));
+            }));
+            const mock = (0, test_utils_1.createMockSupabase)({
+                "repos.upsert": defaultRepoResponse(),
+            });
+            await (0, sync_1.syncToSupabase)(rootPath, mock.client, USER_A);
+            // Should delete with analysis_type filter
+            const deleteCalls = mock.calls.filter((c) => c.table === "function_analysis" && c.method === "delete");
+            (0, vitest_1.expect)(deleteCalls.length).toBe(1);
+            // Should have eq('analysis_type', 'security') in the chain
+            const eqCalls = mock.calls.filter((c) => c.table === "function_analysis" &&
+                c.method === "eq" &&
+                c.args[0] === "analysis_type");
+            (0, vitest_1.expect)(eqCalls.length).toBe(1);
+            (0, vitest_1.expect)(eqCalls[0].args[1]).toBe("security");
+        });
+        (0, vitest_1.it)("NULL analysis_type (legacy) — deletes all types for hash", async () => {
+            const { rootPath } = tracked((0, test_utils_1.createTempDb)((db) => {
+                db.prepare("INSERT INTO function_gc (content_hash, analysis_type, gc_at) VALUES (?, ?, ?)").run("dead-hash", null, Math.floor(Date.now() / 1000));
+            }));
+            const mock = (0, test_utils_1.createMockSupabase)({
+                "repos.upsert": defaultRepoResponse(),
+            });
+            await (0, sync_1.syncToSupabase)(rootPath, mock.client, USER_A);
+            // Should delete WITHOUT analysis_type filter (no eq('analysis_type', ...))
+            const eqCalls = mock.calls.filter((c) => c.table === "function_analysis" &&
+                c.method === "eq" &&
+                c.args[0] === "analysis_type");
+            (0, vitest_1.expect)(eqCalls.length).toBe(0);
+        });
+    });
+});
+// ============ pullFromSupabase ============
+(0, vitest_1.describe)("pullFromSupabase", () => {
+    const cleanups = [];
+    function tracked(result) {
+        cleanups.push(result.cleanup);
+        return result;
+    }
+    (0, vitest_1.afterEach)(() => {
+        cleanups.forEach((fn) => fn());
+        cleanups.length = 0;
+    });
+    (0, vitest_1.it)("empty missing hashes — returns early with 0", async () => {
+        const { rootPath } = tracked((0, test_utils_1.createTempDb)());
+        const mock = (0, test_utils_1.createMockSupabase)();
+        const result = await (0, sync_1.pullFromSupabase)(rootPath, mock.client, USER_A, REPO_ID, []);
+        (0, vitest_1.expect)(result.pulled).toBe(0);
+        // Should NOT call supabase at all
+        (0, vitest_1.expect)(mock.calls.length).toBe(0);
+    });
+    (0, vitest_1.it)("applies defensive defaults for missing fields", async () => {
+        const { rootPath, dbPath } = tracked((0, test_utils_1.createTempDb)());
+        const mock = (0, test_utils_1.createMockSupabase)({
+            "function_analysis.select": {
+                data: [
+                    {
+                        content_hash: "hash1",
+                        analysis_type: "documentation",
+                        analysis: { description: "Test" },
+                        model_version: "claude-3",
+                        schema_version: null, // missing — should default to 1
+                        language: null, // missing — should default to 'typescript'
+                        entity_type: null, // missing — should default to 'function'
+                    },
+                ],
+                error: null,
+            },
+        });
+        const result = await (0, sync_1.pullFromSupabase)(rootPath, mock.client, USER_A, REPO_ID, ["hash1"]);
+        (0, vitest_1.expect)(result.pulled).toBe(1);
+        // Verify defaults were applied
+        const db = new better_sqlite3_1.default(dbPath);
+        const row = db
+            .prepare("SELECT language, entity_type, schema_version FROM function_analysis WHERE content_hash = 'hash1'")
+            .get();
+        db.close();
+        (0, vitest_1.expect)(row.language).toBe("typescript");
+        (0, vitest_1.expect)(row.entity_type).toBe("function");
+        (0, vitest_1.expect)(row.schema_version).toBe(1);
+    });
+    (0, vitest_1.it)("handles string vs object analysis field", async () => {
+        const { rootPath, dbPath } = tracked((0, test_utils_1.createTempDb)());
+        const mock = (0, test_utils_1.createMockSupabase)({
+            "function_analysis.select": {
+                data: [
+                    {
+                        content_hash: "hash-obj",
+                        analysis_type: "documentation",
+                        analysis: { description: "Object form" }, // object — should be stringified
+                        model_version: "claude-3",
+                        schema_version: 1,
+                        language: "typescript",
+                        entity_type: "function",
+                    },
+                    {
+                        content_hash: "hash-str",
+                        analysis_type: "documentation",
+                        analysis: '{"description":"String form"}', // already string
+                        model_version: "claude-3",
+                        schema_version: 1,
+                        language: "typescript",
+                        entity_type: "function",
+                    },
+                ],
+                error: null,
+            },
+        });
+        const result = await (0, sync_1.pullFromSupabase)(rootPath, mock.client, USER_A, REPO_ID, ["hash-obj", "hash-str"]);
+        (0, vitest_1.expect)(result.pulled).toBe(2);
+        // Both should be stored as valid JSON strings
+        const db = new better_sqlite3_1.default(dbPath);
+        const objRow = db
+            .prepare("SELECT analysis FROM function_analysis WHERE content_hash = 'hash-obj'")
+            .get();
+        const strRow = db
+            .prepare("SELECT analysis FROM function_analysis WHERE content_hash = 'hash-str'")
+            .get();
+        db.close();
+        (0, vitest_1.expect)(JSON.parse(objRow.analysis).description).toBe("Object form");
+        (0, vitest_1.expect)(JSON.parse(strRow.analysis).description).toBe("String form");
+    });
+});