@ophan/cli 0.0.1 → 0.0.3

package/dist/watch.js

@@ -33,27 +33,90 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatError = formatError;
+exports.isGitIgnored = isGitIgnored;
+exports.withTimeout = withTimeout;
 exports.startWatch = startWatch;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
 const core_1 = require("@ophan/core");
 function emit(event) {
     process.stdout.write(JSON.stringify(event) + "\n");
 }
+function formatError(err) {
+    if (err instanceof Error)
+        return err.message || err.constructor.name;
+    if (typeof err === "string")
+        return err || "Empty error string";
+    // Handle non-Error objects (e.g. Supabase/Anthropic SDK errors with circular refs)
+    if (err && typeof err === "object") {
+        const obj = err;
+        if (typeof obj.message === "string" && obj.message)
+            return obj.message;
+        if (typeof obj.error === "string" && obj.error)
+            return obj.error;
+        try {
+            const json = JSON.stringify(err);
+            if (json && json !== "{}")
+                return json;
+        }
+        catch { /* circular — fall through */ }
+        // Last resort for objects: try toString, check it's not the useless default
+        const str = String(err);
+        if (str !== "[object Object]")
+            return str;
+        return "Unknown error (non-serializable object)";
+    }
+    if (err === undefined)
+        return "Unknown error (undefined)";
+    if (err === null)
+        return "Unknown error (null)";
+    return String(err);
+}
+/**
+ * Check if a file is ignored by git (respects all .gitignore files, global gitignore,
+ * and .git/info/exclude). Returns false if not in a git repo or git is unavailable.
+ */
+function isGitIgnored(filePath, cwd) {
+    try {
+        (0, child_process_1.execSync)(`git check-ignore -q "${filePath}"`, {
+            cwd,
+            stdio: "pipe",
+        });
+        return true; // exit code 0 = ignored
+    }
+    catch {
+        return false; // exit code 1 = not ignored, or git not available
+    }
+}
+/** Wraps a promise with a timeout. Rejects with a timeout error if not resolved within `ms`. */
+function withTimeout(promise, ms, label) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`Analysis timeout after ${ms / 1000}s for ${label}`)), ms);
+        promise.then((v) => { clearTimeout(timer); resolve(v); }, (e) => { clearTimeout(timer); reject(e); });
+    });
+}
 async function startWatch(options) {
     const { rootPath, pullFn, syncFn, json } = options;
     const dbPath = path.join(rootPath, ".ophan", "index.db");
     const lockPath = path.join(rootPath, ".ophan", "watch.lock");
-    // Check for existing watcher
+    // Check for existing watcher — kill it so only one instance runs at a time
     if (fs.existsSync(lockPath)) {
         try {
             const pid = parseInt(fs.readFileSync(lockPath, "utf-8").trim());
             process.kill(pid, 0); // Check if process is alive (signal 0 = no-op)
+            // Kill the existing watcher and take over
             if (json)
-                emit({ event: "error", message: `Another watcher is running (PID ${pid})` });
+                emit({ event: "replacing_watcher", oldPid: pid });
             else
-                console.error(`Another watcher is already running (PID ${pid}). Kill it or remove .ophan/watch.lock`);
-            process.exit(1);
+                console.log(`  Stopping previous watcher (PID ${pid})...`);
+            try {
+                process.kill(pid, "SIGTERM");
+            }
+            catch { /* already dying */ }
+            // Brief wait for process to exit and release resources
+            await new Promise((resolve) => setTimeout(resolve, 500));
         }
         catch {
             // Process is dead — stale lock file, continue
@@ -74,33 +137,78 @@ async function startWatch(options) {
         console.log("🔮 Ophan watching...\n");
     if (!json)
         console.log("  Running initial scan...");
-    const scanResult = await (0, core_1.analyzeRepository)(rootPath, (current, total, file) => {
-        if (!json && process.stdout.isTTY) {
-            process.stdout.clearLine(0);
-            process.stdout.cursorTo(0);
-            process.stdout.write(`  [${current}/${total}] ${file}`);
+    const INITIAL_SCAN_RETRIES = 2;
+    const PROGRESS_THROTTLE_MS = 500;
+    let scanSucceeded = false;
+    for (let attempt = 0; attempt <= INITIAL_SCAN_RETRIES; attempt++) {
+        try {
+            let lastProgressEmit = 0;
+            const scanResult = await (0, core_1.analyzeRepository)(rootPath, (current, total, file) => {
+                if (json) {
+                    const now = Date.now();
+                    if (now - lastProgressEmit > PROGRESS_THROTTLE_MS || current === total) {
+                        emit({ event: "scan_progress", current, total, file });
+                        lastProgressEmit = now;
+                    }
+                }
+                else if (process.stdout.isTTY) {
+                    process.stdout.clearLine(0);
+                    process.stdout.cursorTo(0);
+                    process.stdout.write(`  [${current}/${total}] ${file}`);
+                }
+            }, pullFn);
+            if (json) {
+                emit({
+                    event: "scan_complete",
+                    files: scanResult.files,
+                    analyzed: scanResult.analyzed,
+                    cached: scanResult.skipped,
+                    pulled: scanResult.pulled,
+                });
+            }
+            else {
+                console.log(`\n  Initial scan: ${scanResult.analyzed} analyzed, ${scanResult.skipped} cached` +
+                    (scanResult.pulled ? ` (${scanResult.pulled} from cloud)` : "") +
+                    ` across ${scanResult.files} files`);
+            }
+            // Sync after initial scan if anything was analyzed
+            if (syncFn && scanResult.analyzed > 0) {
+                await runSync(syncFn, json);
+            }
+            scanSucceeded = true;
+            break;
+        }
+        catch (err) {
+            const msg = formatError(err);
+            if (attempt < INITIAL_SCAN_RETRIES) {
+                const delay = (attempt + 1) * 3000;
+                if (json) {
+                    emit({ event: "retry", attempt: attempt + 1, maxAttempts: INITIAL_SCAN_RETRIES + 1, message: msg, delayMs: delay });
+                }
+                else {
+                    console.error(`\n  ❌ Initial scan failed: ${msg}. Retrying in ${delay / 1000}s...`);
+                }
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+            else {
+                if (json) {
+                    emit({ event: "error", message: `Initial scan failed after ${INITIAL_SCAN_RETRIES + 1} attempts: ${msg}` });
+                }
+                else {
+                    console.error(`\n  ❌ Initial scan failed after ${INITIAL_SCAN_RETRIES + 1} attempts: ${msg}`);
+                }
+            }
         }
-    }, pullFn);
-    if (json) {
-        emit({
-            event: "scan_complete",
-            files: scanResult.files,
-            analyzed: scanResult.analyzed,
-            cached: scanResult.skipped,
-            pulled: scanResult.pulled,
-        });
-    }
-    else {
-        console.log(`\n  Initial scan: ${scanResult.analyzed} analyzed, ${scanResult.skipped} cached` +
-            (scanResult.pulled ? ` (${scanResult.pulled} from cloud)` : "") +
-            ` across ${scanResult.files} files`);
     }
-    // Sync after initial scan if anything was analyzed
-    if (syncFn && scanResult.analyzed > 0) {
-        await runSync(syncFn, json);
+    if (!scanSucceeded) {
+        // Continue to file watching — incremental analysis can still work.
+        // Individual file changes will trigger re-analysis.
+        if (json)
+            emit({ event: "error", message: "Continuing in watch-only mode. File changes will trigger analysis." });
     }
     // Phase 2: Open DB for incremental watching
     const db = (0, core_1.initDb)(dbPath);
+    const practices = (0, core_1.loadPracticesFromDb)(db);
     const extSet = new Set((0, core_1.getSupportedExtensions)().map((e) => e.toLowerCase()));
     const DEBOUNCE_MS = 5000;
     const SYNC_DEBOUNCE_MS = 10000;
@@ -123,12 +231,20 @@ async function startWatch(options) {
             }
         }, SYNC_DEBOUNCE_MS);
     }
-    // FIFO analysis queue
+    // FIFO analysis queue with circuit breaker
     let analyzing = false;
     const queue = [];
+    const MAX_CONSECUTIVE_ERRORS = 3;
+    const CIRCUIT_BREAKER_COOLDOWN_MS = 30000;
+    const ANALYSIS_TIMEOUT_MS = 120000;
+    let consecutiveErrors = 0;
+    let circuitBrokenUntil = 0;
     async function processQueue() {
         if (analyzing || queue.length === 0)
             return;
+        // Circuit breaker: stop processing if too many consecutive errors
+        if (Date.now() < circuitBrokenUntil)
+            return;
         analyzing = true;
         while (queue.length > 0) {
             const file = queue.shift();
@@ -139,7 +255,8 @@ async function startWatch(options) {
                 console.log(`  Analyzing ${relPath}...`);
             const start = Date.now();
             try {
-                const result = await (0, core_1.analyzeFiles)(db, rootPath, [file], { pullFn });
+                const result = await withTimeout((0, core_1.analyzeFiles)(db, rootPath, [file], { pullFn, practices }), ANALYSIS_TIMEOUT_MS, relPath);
+                consecutiveErrors = 0; // Reset on success
                 const duration = Date.now() - start;
                 if (json) {
                     emit({
@@ -160,17 +277,38 @@ async function startWatch(options) {
                 }
             }
             catch (err) {
+                consecutiveErrors++;
+                const msg = formatError(err);
                 if (json) {
-                    emit({ event: "error", file: relPath, message: err.message });
+                    emit({ event: "error", file: relPath, message: msg });
                 }
                 else {
-                    console.error(`  ❌ ${relPath}: ${err.message}`);
+                    console.error(`  ❌ ${relPath}: ${msg}`);
+                }
+                // Circuit breaker: pause after repeated failures
+                if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+                    circuitBrokenUntil = Date.now() + CIRCUIT_BREAKER_COOLDOWN_MS;
+                    const remaining = queue.length;
+                    if (json) {
+                        emit({
+                            event: "error",
+                            message: `${MAX_CONSECUTIVE_ERRORS} consecutive failures — pausing analysis for ${CIRCUIT_BREAKER_COOLDOWN_MS / 1000}s. ${remaining} file(s) queued for retry.`,
+                        });
+                    }
+                    else {
+                        console.error(`  ⏸ ${MAX_CONSECUTIVE_ERRORS} consecutive failures — pausing for ${CIRCUIT_BREAKER_COOLDOWN_MS / 1000}s`);
+                    }
+                    break; // Leave remaining files in queue for retry after cooldown
                 }
             }
         }
         analyzing = false;
     }
-    const IGNORE_SEGMENTS = ["node_modules", ".ophan", "__pycache__", ".venv", "venv", ".tox", ".eggs", "dist"];
+    // Fast-path segments that are always ignored (avoids git subprocess for common cases)
+    const ALWAYS_IGNORE = ["node_modules", ".ophan"];
+    // Cache of directory prefixes known to be gitignored — avoids repeated git check-ignore calls
+    // for files in the same ignored directory (e.g. .output/public/assets/a.js, .output/public/assets/b.js)
+    const ignoredDirCache = new Set();
     function onFileChange(filename) {
         const ext = path.extname(filename).toLowerCase();
         if (!extSet.has(ext))
@@ -178,9 +316,21 @@ async function startWatch(options) {
         const absPath = path.isAbsolute(filename)
             ? filename
             : path.resolve(rootPath, filename);
-        // Skip ignored directories
-        if (IGNORE_SEGMENTS.some((seg) => absPath.includes(`/${seg}/`) || absPath.includes(`\\${seg}\\`)))
+        // Fast-path: skip universally-ignored directories without shelling out to git
+        if (ALWAYS_IGNORE.some((seg) => absPath.includes(`/${seg}/`) || absPath.includes(`\\${seg}\\`)))
             return;
+        // Check directory-level cache before calling git
+        const dir = path.dirname(absPath);
+        for (const cached of ignoredDirCache) {
+            if (dir.startsWith(cached))
+                return;
+        }
+        // Ask git whether this file is ignored (respects all .gitignore files + global)
+        if (isGitIgnored(absPath, rootPath)) {
+            // Cache the directory so sibling files skip the git call
+            ignoredDirCache.add(dir);
+            return;
+        }
         // Skip if file was deleted
         if (!fs.existsSync(absPath))
             return;
@@ -193,7 +343,13 @@ async function startWatch(options) {
             if (!queue.includes(absPath)) {
                 queue.push(absPath);
             }
-            processQueue();
+            processQueue().catch((err) => {
+                const msg = formatError(err);
+                if (json)
+                    emit({ event: "error", message: msg });
+                else
+                    console.error(`  ❌ Analysis error: ${msg}`);
+            });
         }, DEBOUNCE_MS));
     }
     // Start recursive file watcher (macOS + Windows native, Linux may need chokidar)

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@ophan/cli",
-  "version": "0.0.1",
-  "files": ["dist"],
+  "version": "0.0.3",
+  "files": [
+    "dist",
+    "ophan_logo.png"
+  ],
   "bin": {
     "ophan": "./dist/index.js"
   },
@@ -13,9 +16,10 @@
   "dependencies": {
     "@ophan/core": "workspace:*",
     "@supabase/supabase-js": "^2.49.4",
-    "better-sqlite3": "^11.9.1",
+    "better-sqlite3": "^12.6.2",
     "commander": "^14.0.2",
     "dotenv": "^16.4.7",
+    "p-limit": "^6.2.0",
     "open": "^10.1.0"
   },
   "devDependencies": {

package/dist/sync.test.js

@@ -1,288 +0,0 @@
-"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");
-    });
-});