@ophan/cli 0.0.1 → 0.0.3

package/dist/sync.js

@@ -36,13 +36,67 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitBranch = getGitBranch;
+exports.getGitCommitHash = getGitCommitHash;
+exports.getDefaultBranch = getDefaultBranch;
 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 p_limit_1 = __importDefault(require("p-limit"));
 const core_1 = require("@ophan/core");
+const supabaseLimit = (0, p_limit_1.default)(3);
+/** Run chunked Supabase operations in parallel with bounded concurrency. */
+async function parallelChunks(rows, chunkSize, fn) {
+    const chunks = [];
+    for (let i = 0; i < rows.length; i += chunkSize) {
+        chunks.push(rows.slice(i, i + chunkSize));
+    }
+    await Promise.all(chunks.map((chunk) => supabaseLimit(() => fn(chunk))));
+}
+function getGitBranch(rootPath) {
+    try {
+        return ((0, child_process_1.execSync)("git rev-parse --abbrev-ref HEAD", {
+            cwd: rootPath,
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim() || null);
+    }
+    catch {
+        return null;
+    }
+}
+function getGitCommitHash(rootPath) {
+    try {
+        return ((0, child_process_1.execSync)("git rev-parse HEAD", {
+            cwd: rootPath,
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim() || null);
+    }
+    catch {
+        return null;
+    }
+}
+function getDefaultBranch(rootPath) {
+    try {
+        const ref = (0, child_process_1.execSync)("git symbolic-ref refs/remotes/origin/HEAD", {
+            cwd: rootPath,
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        // ref = "refs/remotes/origin/main" → extract "main"
+        const match = ref.match(/refs\/remotes\/origin\/(.+)/);
+        if (match)
+            return match[1];
+    }
+    catch {
+        // No remote, shallow clone, or not a git repo
+    }
+    return "main";
+}
 function getGitRemoteUrl(rootPath) {
     try {
         return ((0, child_process_1.execSync)("git remote get-url origin", {
@@ -58,7 +112,7 @@ function getGitRemoteUrl(rootPath) {
 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.`);
+        throw new Error(`No analysis database found at ${dbPath}\n  Run \`npx @ophan/cli init\` first.`);
     }
     const db = new better_sqlite3_1.default(dbPath);
     // Ensure sync_meta table exists (may not if DB was created by older version)
@@ -86,12 +140,42 @@ async function syncToSupabase(rootPath, supabase, userId, onProgress) {
             name: repoName,
             remote_url: remoteUrl,
         }, { onConflict: "user_id,name" })
-            .select("id")
+            .select("id, docs_branch")
             .single();
         if (repoError) {
             throw new Error(`Failed to register repo: ${repoError.message}`);
         }
         const repoId = repo.id;
+        const docsBranch = repo.docs_branch ?? "main";
+        // Determine whether to sync architecture data (communities, edges, summaries).
+        // Gate: only sync when on the configured docs branch.
+        // Non-git repos (branch = null) bypass the gate — always sync.
+        const currentBranch = getGitBranch(rootPath);
+        const syncArchitecture = currentBranch === null || currentBranch === docsBranch;
+        if (!syncArchitecture) {
+            onProgress?.(`Skipping architecture sync (on '${currentBranch}', docs branch is '${docsBranch}')`);
+        }
+        // 1.5. Pull practices from Supabase → local SQLite
+        onProgress?.("Syncing practices...");
+        const { data: practiceRows } = await supabase
+            .from("repo_practices")
+            .select("practice_id, rule, severity")
+            .eq("repo_id", repoId);
+        const practicesSynced = practiceRows?.length ?? 0;
+        if (practiceRows && practiceRows.length > 0) {
+            (0, core_1.importPractices)(db, practiceRows.map((r) => ({
+                id: r.practice_id,
+                rule: r.rule,
+                severity: r.severity,
+            })));
+        }
+        else {
+            // No practices defined — clear local table
+            try {
+                db.prepare("DELETE FROM practices").run();
+            }
+            catch { }
+        }
         // 2. Push unsynced analysis (now includes analysis_type + schema_version)
         onProgress?.("Pushing analysis...");
         const unsynced = db
@@ -110,16 +194,15 @@ async function syncToSupabase(rootPath, supabase, userId, onProgress) {
                 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);
+            // Batch upsert in chunks of 500 with bounded concurrency
+            await parallelChunks(rows, 500, async (chunk) => {
                 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 = ?");
@@ -140,28 +223,37 @@ async function syncToSupabase(rootPath, supabase, userId, onProgress) {
             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`)
+            .prepare(`SELECT file_path, function_name, content_hash, language, entity_type, start_line
+         FROM file_functions
+         GROUP BY file_path, function_name`)
             .all();
         if (locations.length > 0) {
+            // Convert absolute paths to repo-relative for cloud storage
+            // (local DB stores absolute paths for file I/O, but cloud paths
+            // must be portable across machines)
+            const rootPrefix = rootPath.endsWith(path.sep)
+                ? rootPath
+                : rootPath + path.sep;
             const locationRows = locations.map((row) => ({
                 repo_id: repoId,
                 user_id: userId,
-                file_path: row.file_path,
+                file_path: row.file_path.startsWith(rootPrefix)
+                    ? row.file_path.slice(rootPrefix.length)
+                    : row.file_path,
                 function_name: row.function_name,
                 content_hash: row.content_hash,
                 language: row.language,
                 entity_type: row.entity_type,
+                start_line: row.start_line,
             }));
-            for (let i = 0; i < locationRows.length; i += 500) {
-                const chunk = locationRows.slice(i, i + 500);
+            await parallelChunks(locationRows, 500, async (chunk) => {
                 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...");
@@ -169,30 +261,36 @@ async function syncToSupabase(rootPath, supabase, userId, onProgress) {
             .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);
+            // Batch GC deletes using .in() for efficiency
+            const withType = gcRows.filter((r) => r.analysis_type);
+            const withoutType = gcRows.filter((r) => !r.analysis_type);
+            // Delete analysis rows with specific type (group by type)
+            if (withType.length > 0) {
+                const byType = new Map();
+                for (const row of withType) {
+                    const hashes = byType.get(row.analysis_type) || [];
+                    hashes.push(row.content_hash);
+                    byType.set(row.analysis_type, hashes);
                 }
-                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);
+                await Promise.all([...byType.entries()].map(([type, hashes]) => parallelChunks(hashes, 50, async (chunk) => {
+                    await supabase.from("function_analysis").delete()
+                        .eq("repo_id", repoId).eq("analysis_type", type).in("content_hash", chunk);
+                })));
             }
+            // Delete analysis rows without type (legacy GC entries)
+            if (withoutType.length > 0) {
+                const legacyHashes = withoutType.map((r) => r.content_hash);
+                await parallelChunks(legacyHashes, 50, async (chunk) => {
+                    await supabase.from("function_analysis").delete()
+                        .eq("repo_id", repoId).in("content_hash", chunk);
+                });
+            }
+            // Delete location rows for all GC'd hashes
+            const allGcHashes = gcRows.map((r) => r.content_hash);
+            await parallelChunks(allGcHashes, 50, async (chunk) => {
+                await supabase.from("function_locations").delete()
+                    .eq("repo_id", repoId).in("content_hash", chunk);
+            });
             // Mark GC rows as synced locally, then delete them
             const now = Math.floor(Date.now() / 1000);
             db.transaction(() => {
@@ -200,10 +298,145 @@ async function syncToSupabase(rootPath, supabase, userId, onProgress) {
                 db.prepare("DELETE FROM function_gc WHERE synced_at IS NOT NULL").run();
             })();
         }
+        // 5. Replace communities (full sync, like function_locations)
+        // Steps 5-7 are gated by syncArchitecture (only sync on docs branch)
+        let communitiesSynced = 0;
+        if (!syncArchitecture) {
+            return {
+                pushed: unsynced.length,
+                locations: locations.length,
+                gcProcessed: gcRows.length,
+                practices: practicesSynced,
+                communities: 0,
+                communityEdges: 0,
+                summaries: 0,
+                skippedArchitecture: true,
+                commitHash: null,
+            };
+        }
+        const hasCommunities = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='communities'").get();
+        if (hasCommunities) {
+            onProgress?.("Syncing community memberships...");
+            const { error: commDelError } = await supabase
+                .from("communities")
+                .delete()
+                .eq("repo_id", repoId);
+            if (commDelError) {
+                throw new Error(`Failed to clear communities: ${commDelError.message}`);
+            }
+            const communityRows = db.prepare("SELECT content_hash, level, community_id, algorithm FROM communities").all();
+            if (communityRows.length > 0) {
+                const rows = communityRows.map((row) => ({
+                    content_hash: row.content_hash,
+                    level: row.level,
+                    community_id: row.community_id,
+                    algorithm: row.algorithm,
+                    repo_id: repoId,
+                    user_id: userId,
+                }));
+                await parallelChunks(rows, 500, async (chunk) => {
+                    const { error } = await supabase.from("communities").insert(chunk);
+                    if (error) {
+                        throw new Error(`Failed to push communities: ${error.message}`);
+                    }
+                });
+                communitiesSynced = communityRows.length;
+            }
+        }
+        // 6. Replace community_edges (full sync, like communities)
+        let communityEdgesSynced = 0;
+        const hasCommunityEdges = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='community_edges'").get();
+        if (hasCommunityEdges) {
+            onProgress?.("Syncing community edges...");
+            const { error: ceDelError } = await supabase
+                .from("community_edges")
+                .delete()
+                .eq("repo_id", repoId);
+            if (ceDelError) {
+                throw new Error(`Failed to clear community edges: ${ceDelError.message}`);
+            }
+            const ceRows = db.prepare("SELECT source_community, target_community, algorithm, weight, edge_count FROM community_edges").all();
+            if (ceRows.length > 0) {
+                const rows = ceRows.map((row) => ({
+                    source_community: row.source_community,
+                    target_community: row.target_community,
+                    algorithm: row.algorithm,
+                    repo_id: repoId,
+                    user_id: userId,
+                    weight: row.weight,
+                    edge_count: row.edge_count,
+                }));
+                await parallelChunks(rows, 500, async (chunk) => {
+                    const { error } = await supabase.from("community_edges").insert(chunk);
+                    if (error) {
+                        throw new Error(`Failed to push community edges: ${error.message}`);
+                    }
+                });
+                communityEdgesSynced = ceRows.length;
+            }
+        }
+        // 7. Replace community summaries (full sync, like communities)
+        let summariesSynced = 0;
+        const hasSummaries = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='community_summaries'").get();
+        if (hasSummaries) {
+            onProgress?.("Syncing community summaries...");
+            const { error: sumDelError } = await supabase
+                .from("community_summaries")
+                .delete()
+                .eq("repo_id", repoId);
+            if (sumDelError) {
+                throw new Error(`Failed to clear summaries: ${sumDelError.message}`);
+            }
+            const summaryRows = db.prepare("SELECT community_id, level, algorithm, input_hash, summary, model_version, created_at FROM community_summaries").all();
+            if (summaryRows.length > 0) {
+                const rows = summaryRows.map((row) => ({
+                    community_id: row.community_id,
+                    level: row.level,
+                    algorithm: row.algorithm,
+                    repo_id: repoId,
+                    user_id: userId,
+                    input_hash: row.input_hash,
+                    summary: JSON.parse(row.summary),
+                    model_version: row.model_version,
+                }));
+                await parallelChunks(rows, 500, async (chunk) => {
+                    const { error } = await supabase
+                        .from("community_summaries")
+                        .insert(chunk);
+                    if (error) {
+                        throw new Error(`Failed to push summaries: ${error.message}`);
+                    }
+                });
+                summariesSynced = summaryRows.length;
+            }
+        }
+        // 8. Record docs sync commit hash (git repos only)
+        const commitHash = getGitCommitHash(rootPath);
+        if (commitHash && currentBranch) {
+            await supabase.from("docs_sync_history").insert({
+                repo_id: repoId,
+                user_id: userId,
+                commit_hash: commitHash,
+                branch: currentBranch,
+            });
+            await supabase
+                .from("repos")
+                .update({
+                last_docs_sync_commit: commitHash,
+                last_docs_sync_at: new Date().toISOString(),
+            })
+                .eq("id", repoId);
+        }
         return {
             pushed: unsynced.length,
             locations: locations.length,
             gcProcessed: gcRows.length,
+            practices: practicesSynced,
+            communities: communitiesSynced,
+            communityEdges: communityEdgesSynced,
+            summaries: summariesSynced,
+            skippedArchitecture: false,
+            commitHash,
         };
     }
     finally {
@@ -221,32 +454,41 @@ async function pullFromSupabase(rootPath, supabase, userId, repoId, missingHashe
     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",
-                });
+    // Batch queries in chunks of 50 with bounded concurrency
+    // (SHA256 hashes are 64 chars each; 50 × 64 ≈ 3.2KB fits within URI limits)
+    const pullChunks = [];
+    for (let i = 0; i < missingHashes.length; i += 50) {
+        pullChunks.push(missingHashes.slice(i, i + 50));
+    }
+    await Promise.all(pullChunks.map((chunk) => supabaseLimit(async () => {
+        try {
+            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}`);
+                return;
+            }
+            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",
+                    });
+                }
             }
         }
-    }
+        catch (err) {
+            onProgress?.(`Warning: pull request failed: ${err?.message ?? String(err)}`);
+        }
+    })));
     if (allRows.length === 0)
         return { pulled: 0 };
     const imported = (0, core_1.importAnalysis)(dbPath, allRows);