@ophan/cli 0.0.1

package/dist/test-utils.js

@@ -0,0 +1,161 @@
+"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.createTempDb = createTempDb;
+exports.createMockSupabase = createMockSupabase;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const test_utils_1 = require("@ophan/core/test-utils");
+/**
+ * Creates a temp directory with a real .ophan/index.db file.
+ * Sync functions take rootPath and construct dbPath internally,
+ * so we need an actual file on disk.
+ */
+function createTempDb(setup) {
+    const rootPath = fs.mkdtempSync(path.join(os.tmpdir(), "ophan-test-"));
+    const ophanDir = path.join(rootPath, ".ophan");
+    fs.mkdirSync(ophanDir, { recursive: true });
+    const dbPath = path.join(ophanDir, "index.db");
+    // Create a real file-based DB with the current schema
+    const memDb = (0, test_utils_1.createTestDb)();
+    // Serialize the in-memory DB to a file
+    const db = new better_sqlite3_1.default(dbPath);
+    db.exec(memDb.prepare("SELECT sql FROM sqlite_master WHERE type='table'")
+        .all()
+        .map((row) => row.sql + ";")
+        .join("\n"));
+    // Run setup callback if provided
+    if (setup)
+        setup(db);
+    db.close();
+    memDb.close();
+    return {
+        dbPath,
+        rootPath,
+        cleanup: () => {
+            try {
+                fs.rmSync(rootPath, { recursive: true, force: true });
+            }
+            catch {
+                // best-effort cleanup
+            }
+        },
+    };
+}
+/**
+ * Creates a mock Supabase client that records calls and returns controlled responses.
+ *
+ * Usage:
+ *   const mock = createMockSupabase({
+ *     'repos.upsert': { data: [{ id: 'repo-1' }], error: null },
+ *     'function_analysis.select': { data: [], error: null },
+ *   })
+ *   await syncToSupabase(rootPath, mock.client, userId)
+ *   expect(mock.calls).toContainEqual(expect.objectContaining({ table: 'repos', method: 'upsert' }))
+ */
+function createMockSupabase(responses = {}) {
+    const calls = [];
+    function createChain(table) {
+        let primaryMethod = "";
+        const resolve = () => {
+            const key = `${table}.${primaryMethod}`;
+            return responses[key] ?? { data: [], error: null };
+        };
+        const chain = {};
+        const handler = {
+            get(_, prop) {
+                // Primary operations
+                if (["select", "insert", "upsert", "update", "delete"].includes(prop)) {
+                    return (...args) => {
+                        primaryMethod = prop;
+                        calls.push({ table, method: prop, args });
+                        return new Proxy(chain, handler);
+                    };
+                }
+                // Filter/modifier methods — chainable
+                if ([
+                    "eq",
+                    "in",
+                    "neq",
+                    "gt",
+                    "lt",
+                    "gte",
+                    "lte",
+                    "like",
+                    "ilike",
+                    "contains",
+                    "order",
+                    "limit",
+                    "range",
+                    "or",
+                    "not",
+                    "is",
+                    "head",
+                ].includes(prop)) {
+                    return (...args) => {
+                        calls.push({ table, method: prop, args });
+                        return new Proxy(chain, handler);
+                    };
+                }
+                // Terminal methods
+                if (prop === "single" || prop === "maybeSingle") {
+                    return (...args) => {
+                        calls.push({ table, method: prop, args });
+                        return Promise.resolve(resolve());
+                    };
+                }
+                // Thenable — allows `await supabase.from(...).select(...).eq(...)`
+                if (prop === "then") {
+                    const result = resolve();
+                    return Promise.resolve(result).then.bind(Promise.resolve(result));
+                }
+                return new Proxy(chain, handler);
+            },
+        };
+        return new Proxy(chain, handler);
+    }
+    const client = {
+        from: (table) => {
+            calls.push({ table, method: "from", args: [table] });
+            return createChain(table);
+        },
+    };
+    return { client: client, calls };
+}

package/dist/watch.js

@@ -0,0 +1,247 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startWatch = startWatch;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const core_1 = require("@ophan/core");
+function emit(event) {
+    process.stdout.write(JSON.stringify(event) + "\n");
+}
+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
+    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)
+            if (json)
+                emit({ event: "error", message: `Another watcher is running (PID ${pid})` });
+            else
+                console.error(`Another watcher is already running (PID ${pid}). Kill it or remove .ophan/watch.lock`);
+            process.exit(1);
+        }
+        catch {
+            // Process is dead — stale lock file, continue
+        }
+    }
+    // Write lock file
+    fs.mkdirSync(path.join(rootPath, ".ophan"), { recursive: true });
+    fs.writeFileSync(lockPath, String(process.pid));
+    const removeLock = () => {
+        try {
+            fs.unlinkSync(lockPath);
+        }
+        catch { }
+    };
+    process.on("exit", removeLock);
+    // Phase 1: Initial full scan (reuses analyzeRepository which opens/closes its own DB)
+    if (!json)
+        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}`);
+        }
+    }, 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);
+    }
+    // Phase 2: Open DB for incremental watching
+    const db = (0, core_1.initDb)(dbPath);
+    const extSet = new Set((0, core_1.getSupportedExtensions)().map((e) => e.toLowerCase()));
+    const DEBOUNCE_MS = 5000;
+    const SYNC_DEBOUNCE_MS = 10000;
+    // Per-file debounce timers
+    const timers = new Map();
+    // Sync debounce — batch rapid analyses into one sync
+    let syncTimer = null;
+    let pendingSync = false;
+    function scheduleSyncAfterAnalysis() {
+        if (!syncFn)
+            return;
+        pendingSync = true;
+        if (syncTimer)
+            clearTimeout(syncTimer);
+        syncTimer = setTimeout(async () => {
+            syncTimer = null;
+            if (pendingSync) {
+                pendingSync = false;
+                await runSync(syncFn, json);
+            }
+        }, SYNC_DEBOUNCE_MS);
+    }
+    // FIFO analysis queue
+    let analyzing = false;
+    const queue = [];
+    async function processQueue() {
+        if (analyzing || queue.length === 0)
+            return;
+        analyzing = true;
+        while (queue.length > 0) {
+            const file = queue.shift();
+            const relPath = path.relative(rootPath, file);
+            if (json)
+                emit({ event: "analyzing", file: relPath });
+            else
+                console.log(`  Analyzing ${relPath}...`);
+            const start = Date.now();
+            try {
+                const result = await (0, core_1.analyzeFiles)(db, rootPath, [file], { pullFn });
+                const duration = Date.now() - start;
+                if (json) {
+                    emit({
+                        event: "analyzed",
+                        file: relPath,
+                        analyzed: result.analyzed,
+                        cached: result.skipped,
+                        pulled: result.pulled,
+                        duration_ms: duration,
+                    });
+                }
+                else if (result.analyzed > 0 || result.skipped > 0) {
+                    console.log(`  ✅ ${relPath}: ${result.analyzed} analyzed, ${result.skipped} cached (${duration}ms)`);
+                }
+                // Schedule sync after analysis
+                if (result.analyzed > 0) {
+                    scheduleSyncAfterAnalysis();
+                }
+            }
+            catch (err) {
+                if (json) {
+                    emit({ event: "error", file: relPath, message: err.message });
+                }
+                else {
+                    console.error(`  ❌ ${relPath}: ${err.message}`);
+                }
+            }
+        }
+        analyzing = false;
+    }
+    const IGNORE_SEGMENTS = ["node_modules", ".ophan", "__pycache__", ".venv", "venv", ".tox", ".eggs", "dist"];
+    function onFileChange(filename) {
+        const ext = path.extname(filename).toLowerCase();
+        if (!extSet.has(ext))
+            return;
+        const absPath = path.isAbsolute(filename)
+            ? filename
+            : path.resolve(rootPath, filename);
+        // Skip ignored directories
+        if (IGNORE_SEGMENTS.some((seg) => absPath.includes(`/${seg}/`) || absPath.includes(`\\${seg}\\`)))
+            return;
+        // Skip if file was deleted
+        if (!fs.existsSync(absPath))
+            return;
+        // Reset per-file debounce
+        const existing = timers.get(absPath);
+        if (existing)
+            clearTimeout(existing);
+        timers.set(absPath, setTimeout(() => {
+            timers.delete(absPath);
+            if (!queue.includes(absPath)) {
+                queue.push(absPath);
+            }
+            processQueue();
+        }, DEBOUNCE_MS));
+    }
+    // Start recursive file watcher (macOS + Windows native, Linux may need chokidar)
+    const watcher = fs.watch(rootPath, { recursive: true }, (_eventType, filename) => {
+        if (!filename)
+            return;
+        onFileChange(filename);
+    });
+    watcher.on("error", (err) => {
+        if (json)
+            emit({ event: "error", message: `Watcher error: ${err.message}` });
+        else
+            console.error(`  Watcher error: ${err.message}`);
+    });
+    if (!json)
+        console.log("\n  Watching for changes... (Ctrl+C to stop)\n");
+    // Graceful shutdown
+    function shutdown() {
+        if (!json)
+            console.log("\n  Shutting down...");
+        watcher.close();
+        for (const timer of timers.values())
+            clearTimeout(timer);
+        timers.clear();
+        if (syncTimer)
+            clearTimeout(syncTimer);
+        db.close();
+        process.exit(0);
+    }
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}
+async function runSync(syncFn, json) {
+    try {
+        const result = await syncFn();
+        if (json) {
+            emit({ event: "synced", pushed: result.pushed, locations: result.locations });
+        }
+        else if (result.pushed > 0) {
+            console.log(`  ☁️  Synced: ${result.pushed} entries pushed`);
+        }
+    }
+    catch (err) {
+        if (json) {
+            emit({ event: "sync_error", message: err.message });
+        }
+        else {
+            console.error(`  ☁️  Sync failed: ${err.message}`);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@ophan/cli",
+  "version": "0.0.1",
+  "files": ["dist"],
+  "bin": {
+    "ophan": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@ophan/core": "workspace:*",
+    "@supabase/supabase-js": "^2.49.4",
+    "better-sqlite3": "^11.9.1",
+    "commander": "^14.0.2",
+    "dotenv": "^16.4.7",
+    "open": "^10.1.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.0.5"
+  }
+}