claude-ex 1.2.0 → 1.4.0

package/dist/query/engine.js

@@ -19,6 +19,8 @@ exports.getTypeHierarchy = getTypeHierarchy;
 exports.findDeadExports = findDeadExports;
 exports.getPkgUsages = getPkgUsages;
 exports.reviewDiff = reviewDiff;
+exports.transparentReview = transparentReview;
+exports.transparentReviewFromRoot = transparentReviewFromRoot;
 exports.searchFromRoot = searchFromRoot;
 exports.getCallersFromRoot = getCallersFromRoot;
 exports.getContextFromRoot = getContextFromRoot;
@@ -32,23 +34,44 @@ exports.preEditContextFromRoot = preEditContextFromRoot;
 exports.reviewDiffFromRoot = reviewDiffFromRoot;
 const child_process_1 = require("child_process");
 const schema_1 = require("../db/schema");
-// FTS5 query sanitizer
+// --- Prepared statement cache ---
+// Each db connection gets its own cache; WeakMap ensures cleanup when db is GCed.
+const stmtCache = new WeakMap();
+function cached(db, sql) {
+    let cache = stmtCache.get(db);
+    if (!cache) {
+        cache = new Map();
+        stmtCache.set(db, cache);
+    }
+    let stmt = cache.get(sql);
+    if (!stmt) {
+        stmt = db.prepare(sql);
+        cache.set(sql, stmt);
+    }
+    return stmt;
+}
+// FTS5 query sanitizer — uses NEAR for multi-token phrase matching
 function sanitizeFts(query) {
     const tokens = query.replace(/[^\w\s]/g, ' ').trim().split(/\s+/).filter(Boolean);
     if (tokens.length === 0)
         return '';
-    return tokens.map(t => `"${t}"`).join(' OR ');
+    if (tokens.length === 1)
+        return `"${tokens[0]}"`;
+    // Multi-token: prefer NEAR phrase match, fall back to OR for partial matches
+    const phrase = tokens.map(t => `"${t}"`).join(' NEAR ');
+    const orFallback = tokens.map(t => `"${t}"`).join(' OR ');
+    return `(${phrase}) OR (${orFallback})`;
 }
 // --- DB-direct functions (for MCP server hot path) ---
 function search(db, query, limit = 15) {
     const ftsQuery = sanitizeFts(query);
     if (!ftsQuery)
         return [];
-    const stmt = db.prepare(`
+    // Primary: FTS5 word-level search (fast, ranked)
+    const results = cached(db, `
         SELECT s.name, s.qualified_name, s.kind, f.path as file,
                s.line_start, s.line_end, s.signature,
-               COALESCE(r.pagerank, 0) as pagerank,
-               snippet(symbols_fts, 4, '>>>', '<<<', '...', 30) as snippet
+               COALESCE(r.pagerank, 0) as pagerank
         FROM symbols_fts fts
         JOIN symbols s ON s.id = fts.rowid
         JOIN files f ON f.id = s.file_id
@@ -56,11 +79,45 @@ function search(db, query, limit = 15) {
         WHERE symbols_fts MATCH ?
         ORDER BY r.pagerank DESC, fts.rank
         LIMIT ?
-    `);
-    return stmt.all(ftsQuery, limit);
+    `).all(ftsQuery, limit);
+    // If FTS has enough results, return immediately
+    if (results.length >= limit)
+        return results;
+    // Fallback: trigram substring search for partial/camelCase matches
+    try {
+        const seenIds = new Set(results.map(r => `${r.name}:${r.file}`));
+        const cleaned = query.replace(/[^\w\s]/g, '').trim();
+        if (cleaned.length < 3)
+            return results;
+        const trigramResults = cached(db, `
+            SELECT s.name, s.qualified_name, s.kind, f.path as file,
+                   s.line_start, s.line_end, s.signature,
+                   COALESCE(r.pagerank, 0) as pagerank
+            FROM symbols_trigram tri
+            JOIN symbols s ON s.id = tri.rowid
+            JOIN files f ON f.id = s.file_id
+            LEFT JOIN rankings r ON r.symbol_id = s.id
+            WHERE symbols_trigram MATCH ?
+            ORDER BY r.pagerank DESC
+            LIMIT ?
+        `).all(cleaned, limit);
+        for (const r of trigramResults) {
+            const key = `${r.name}:${r.file}`;
+            if (!seenIds.has(key)) {
+                results.push(r);
+                seenIds.add(key);
+                if (results.length >= limit)
+                    break;
+            }
+        }
+    }
+    catch {
+        // Trigram table may not exist on older DBs
+    }
+    return results;
 }
 function getCallers(db, symbolName) {
-    const stmt = db.prepare(`
+    return cached(db, `
         SELECT DISTINCT s.name, s.qualified_name, s.kind, f.path as file,
                s.line_start, s.line_end, s.signature,
                COALESCE(r.pagerank, 0) as pagerank
@@ -72,12 +129,10 @@ function getCallers(db, symbolName) {
         WHERE (target.name = ? OR target.qualified_name = ?)
           AND e.kind IN ('calls', 'references')
         ORDER BY r.pagerank DESC
-    `);
-    return stmt.all(symbolName, symbolName);
+    `).all(symbolName, symbolName);
 }
 function getContext(db, symbolName) {
-    // Find the symbol (prefer exported, highest pagerank)
-    const sym = db.prepare(`
+    const sym = cached(db, `
         SELECT s.id, s.name, s.qualified_name, s.kind, f.path as file,
                s.line_start, s.line_end, s.signature, s.docstring, s.content as code,
                s.file_id
@@ -90,8 +145,7 @@ function getContext(db, symbolName) {
     `).get(symbolName, symbolName);
     if (!sym)
         return null;
-    // Dependencies (edges FROM this symbol)
-    const deps = db.prepare(`
+    const deps = cached(db, `
         SELECT s.name, s.qualified_name, s.kind, f.path as file,
                s.line_start, s.line_end, s.signature,
                COALESCE(r.pagerank, 0) as pagerank
@@ -101,8 +155,7 @@ function getContext(db, symbolName) {
         LEFT JOIN rankings r ON r.symbol_id = s.id
         WHERE e.from_id = ?
     `).all(sym.id);
-    // Dependents (edges TO this symbol)
-    const dependents = db.prepare(`
+    const dependents = cached(db, `
         SELECT s.name, s.qualified_name, s.kind, f.path as file,
                s.line_start, s.line_end, s.signature,
                COALESCE(r.pagerank, 0) as pagerank
@@ -112,8 +165,7 @@ function getContext(db, symbolName) {
         LEFT JOIN rankings r ON r.symbol_id = s.id
         WHERE e.to_id = ?
     `).all(sym.id);
-    // Same-file siblings
-    const siblings = db.prepare(`
+    const siblings = cached(db, `
         SELECT s.name, s.qualified_name, s.kind, f.path as file,
                s.line_start, s.line_end, s.signature,
                COALESCE(r.pagerank, 0) as pagerank
@@ -141,7 +193,7 @@ function getContext(db, symbolName) {
     };
 }
 function getImpact(db, filePath, maxDepth = 10) {
-    const stmt = db.prepare(`
+    return cached(db, `
         WITH RECURSIVE impact(file_id, depth) AS (
             SELECT fd.from_file, 1
             FROM file_deps fd
@@ -159,11 +211,10 @@ function getImpact(db, filePath, maxDepth = 10) {
         JOIN files f ON f.id = i.file_id
         GROUP BY f.path
         ORDER BY depth, symbolCount DESC
-    `);
-    return stmt.all(filePath, maxDepth);
+    `).all(filePath, maxDepth);
 }
 function getDeps(db, symbolName) {
-    const stmt = db.prepare(`
+    return cached(db, `
         SELECT DISTINCT s.name, s.qualified_name, s.kind, f.path as file,
                s.line_start, s.line_end, s.signature,
                COALESCE(r.pagerank, 0) as pagerank
@@ -174,11 +225,10 @@ function getDeps(db, symbolName) {
         LEFT JOIN rankings r ON r.symbol_id = s.id
         WHERE (source.name = ? OR source.qualified_name = ?)
         ORDER BY r.pagerank DESC
-    `);
-    return stmt.all(symbolName, symbolName);
+    `).all(symbolName, symbolName);
 }
 function getRank(db, top = 20) {
-    const stmt = db.prepare(`
+    return cached(db, `
         SELECT s.name, s.qualified_name, s.kind, f.path as file,
                s.line_start, s.line_end, s.signature,
                r.pagerank
@@ -188,65 +238,64 @@ function getRank(db, top = 20) {
         WHERE s.kind IN ('function', 'class', 'method', 'interface', 'type')
         ORDER BY r.pagerank DESC
         LIMIT ?
-    `);
-    return stmt.all(top);
+    `).all(top);
 }
 function getModules(db) {
-    // Group files by top-level directory
-    const files = db.prepare(`
-        SELECT f.id, f.path,
-               CASE WHEN INSTR(f.path, '/') > 0
-                    THEN SUBSTR(f.path, 1, INSTR(f.path, '/') - 1)
-                    ELSE '.'
-               END as module
+    // Single query: files grouped by module with symbol counts
+    const moduleRows = cached(db, `
+        SELECT
+            CASE WHEN INSTR(f.path, '/') > 0
+                 THEN SUBSTR(f.path, 1, INSTR(f.path, '/') - 1)
+                 ELSE '.'
+            END as module,
+            COUNT(DISTINCT f.id) as fileCount,
+            COUNT(DISTINCT s.id) as symbolCount
         FROM files f
+        LEFT JOIN symbols s ON s.file_id = f.id
+        GROUP BY module
     `).all();
-    const moduleMap = new Map();
-    for (const f of files) {
-        if (!moduleMap.has(f.module)) {
-            moduleMap.set(f.module, { fileIds: new Set(), files: [] });
-        }
-        moduleMap.get(f.module).fileIds.add(f.id);
-        moduleMap.get(f.module).files.push(f.path);
-    }
-    const results = [];
-    for (const [name, data] of moduleMap) {
-        const symbolCount = db.prepare(`SELECT COUNT(*) as cnt FROM symbols WHERE file_id IN (${[...data.fileIds].join(',')})`).get();
-        // Find which other modules this module imports from
-        const deps = db.prepare(`
-            SELECT DISTINCT
-                CASE WHEN INSTR(f2.path, '/') > 0
-                     THEN SUBSTR(f2.path, 1, INSTR(f2.path, '/') - 1)
-                     ELSE '.'
-                END as target_module
-            FROM file_deps fd
-            JOIN files f2 ON f2.id = fd.to_file
-            WHERE fd.from_file IN (${[...data.fileIds].join(',')})
-        `).all();
-        results.push({
-            name,
-            fileCount: data.files.length,
-            symbolCount: symbolCount.cnt,
-            importsFrom: deps.map(d => d.target_module).filter(m => m !== name),
-        });
+    // Single query: all cross-module imports
+    const depRows = cached(db, `
+        SELECT DISTINCT
+            CASE WHEN INSTR(f1.path, '/') > 0
+                 THEN SUBSTR(f1.path, 1, INSTR(f1.path, '/') - 1)
+                 ELSE '.'
+            END as from_module,
+            CASE WHEN INSTR(f2.path, '/') > 0
+                 THEN SUBSTR(f2.path, 1, INSTR(f2.path, '/') - 1)
+                 ELSE '.'
+            END as to_module
+        FROM file_deps fd
+        JOIN files f1 ON f1.id = fd.from_file
+        JOIN files f2 ON f2.id = fd.to_file
+    `).all();
+    // Build dep map
+    const depMap = new Map();
+    for (const row of depRows) {
+        if (row.from_module === row.to_module)
+            continue;
+        if (!depMap.has(row.from_module))
+            depMap.set(row.from_module, new Set());
+        depMap.get(row.from_module).add(row.to_module);
     }
-    return results.sort((a, b) => b.symbolCount - a.symbolCount);
+    return moduleRows.map(m => ({
+        name: m.module,
+        fileCount: m.fileCount,
+        symbolCount: m.symbolCount,
+        importsFrom: [...(depMap.get(m.module) || [])],
+    })).sort((a, b) => b.symbolCount - a.symbolCount);
 }
 function findFiles(db, pattern, limit = 50) {
-    // Convert glob-like pattern to SQL GLOB pattern
-    // SQL GLOB uses * for any chars and ? for single char (same as shell glob)
-    // But we want ** to match path separators too, which GLOB * already does
     const sqlPattern = pattern
-        .replace(/\*\*/g, '*') // ** -> * (SQL GLOB * matches everything including /)
-        .replace(/\.\*/g, '.*'); // preserve .* as literal
-    const stmt = db.prepare(`
+        .replace(/\*\*/g, '*')
+        .replace(/\.\*/g, '.*');
+    return cached(db, `
         SELECT path, language, line_count as lineCount
         FROM files
         WHERE path GLOB ?
         ORDER BY path
         LIMIT ?
-    `);
-    return stmt.all(sqlPattern, limit);
+    `).all(sqlPattern, limit);
 }
 /** Directories to exclude from file map (dependencies, build output) */
 const FILE_MAP_SKIP = new Set(['node_modules', 'dist', 'build', 'out', '.next', '.nuxt', 'vendor', 'target', 'coverage']);
@@ -256,59 +305,50 @@ function isProjectFile(filePath) {
 }
 /** Returns a map of every project file → what it exports. This is the "memory" of the project. */
 function getFileMap(db) {
-    const files = db.prepare(`
-        SELECT f.id, f.path, f.language, f.line_count as lineCount
+    // Single query: all files with their exports via GROUP_CONCAT
+    const rows = cached(db, `
+        SELECT f.path, f.language, f.line_count as lineCount,
+               GROUP_CONCAT(s.name || ' [' || s.kind || ']', '|||') as exports_str
         FROM files f
+        LEFT JOIN symbols s ON s.file_id = f.id AND s.exported = 1
+        GROUP BY f.id
         ORDER BY f.path
     `).all();
-    const exportStmt = db.prepare(`
-        SELECT name, kind, signature FROM symbols
-        WHERE file_id = ? AND exported = 1
-        ORDER BY line_start
-    `);
-    const results = [];
-    for (const f of files) {
-        if (!isProjectFile(f.path))
-            continue;
-        const exports = exportStmt.all(f.id);
-        results.push({
-            path: f.path,
-            language: f.language,
-            lineCount: f.lineCount,
-            exports: exports.map(e => `${e.name} [${e.kind}]`),
-        });
-    }
-    return results;
+    return rows
+        .filter(r => isProjectFile(r.path))
+        .map(r => ({
+        path: r.path,
+        language: r.language,
+        lineCount: r.lineCount,
+        exports: r.exports_str ? r.exports_str.split('|||') : [],
+    }));
 }
 /** Compact file map string for embedding in CLAUDE.md / brief */
 function getFileMapCompact(db, maxFiles = 80) {
-    const files = db.prepare(`
-        SELECT f.id, f.path, f.language, f.line_count as lineCount
+    // Single query: files with top-8 exports by pagerank and total export count
+    const rows = cached(db, `
+        SELECT f.id, f.path,
+               (SELECT COUNT(*) FROM symbols WHERE file_id = f.id AND exported = 1) as totalExports,
+               (SELECT GROUP_CONCAT(name, ', ')
+                FROM (SELECT s.name FROM symbols s
+                      LEFT JOIN rankings r ON r.symbol_id = s.id
+                      WHERE s.file_id = f.id AND s.exported = 1
+                      ORDER BY COALESCE(r.pagerank, 0) DESC LIMIT 8)
+               ) as topNames
         FROM files f
         ORDER BY f.path
     `).all();
-    const projectFiles = files.filter(f => isProjectFile(f.path));
-    const exportStmt = db.prepare(`
-        SELECT name, kind FROM symbols
-        WHERE file_id = ? AND exported = 1
-        ORDER BY COALESCE((SELECT pagerank FROM rankings WHERE symbol_id = symbols.id), 0) DESC
-        LIMIT 8
-    `);
-    const allExportStmt = db.prepare(`
-        SELECT COUNT(*) as cnt FROM symbols WHERE file_id = ? AND exported = 1
-    `);
+    const projectFiles = rows.filter(r => isProjectFile(r.path));
     const lines = [];
     const shown = projectFiles.slice(0, maxFiles);
     for (const f of shown) {
-        const exports = exportStmt.all(f.id);
-        const totalExports = allExportStmt.get(f.id).cnt;
-        if (exports.length === 0) {
+        if (!f.topNames || f.totalExports === 0) {
             lines.push(`- \`${f.path}\``);
         }
         else {
-            const names = exports.map(e => e.name);
-            const suffix = totalExports > names.length ? ` +${totalExports - names.length} more` : '';
-            lines.push(`- \`${f.path}\` — ${names.join(', ')}${suffix}`);
+            const names = f.topNames.split(', ');
+            const suffix = f.totalExports > names.length ? ` +${f.totalExports - names.length} more` : '';
+            lines.push(`- \`${f.path}\` — ${f.topNames}${suffix}`);
         }
     }
     if (projectFiles.length > maxFiles) {
@@ -317,18 +357,20 @@ function getFileMapCompact(db, maxFiles = 80) {
     return lines.join('\n');
 }
 function getStats(db) {
-    const files = db.prepare('SELECT COUNT(*) as cnt FROM files').get().cnt;
-    const symbols = db.prepare('SELECT COUNT(*) as cnt FROM symbols').get().cnt;
-    const edges = db.prepare('SELECT COUNT(*) as cnt FROM edges').get().cnt;
-    const fileDeps = db.prepare('SELECT COUNT(*) as cnt FROM file_deps').get().cnt;
-    return { files, symbols, edges, fileDeps };
+    return cached(db, `
+        SELECT
+            (SELECT COUNT(*) FROM files) as files,
+            (SELECT COUNT(*) FROM symbols) as symbols,
+            (SELECT COUNT(*) FROM edges) as edges,
+            (SELECT COUNT(*) FROM file_deps) as fileDeps
+    `).get();
 }
 function brief(db) {
     const stats = getStats(db);
     const topSymbols = getRank(db, 10);
     const modules = getModules(db);
     // Language breakdown
-    const langs = db.prepare(`
+    const langs = cached(db, `
         SELECT language, COUNT(*) as cnt FROM files WHERE language IS NOT NULL GROUP BY language ORDER BY cnt DESC
     `).all();
     const lines = [];
@@ -358,12 +400,12 @@ function brief(db) {
     return lines.join('\n');
 }
 function preEditContext(db, filePath) {
-    const file = db.prepare('SELECT id FROM files WHERE path = ?').get(filePath);
+    const file = cached(db, 'SELECT id FROM files WHERE path = ?').get(filePath);
     if (!file)
         return `File ${filePath} not in index.`;
     const lines = [];
     // What this file exports
-    const exports = db.prepare(`
+    const exports = cached(db, `
         SELECT name, kind, signature FROM symbols WHERE file_id = ? AND exported = 1 ORDER BY line_start
     `).all(file.id);
     if (exports.length > 0) {
@@ -373,7 +415,7 @@ function preEditContext(db, filePath) {
         }
     }
     // What files import from this file
-    const dependents = db.prepare(`
+    const dependents = cached(db, `
         SELECT DISTINCT f.path FROM file_deps fd JOIN files f ON f.id = fd.from_file WHERE fd.to_file = ?
     `).all(file.id);
     if (dependents.length > 0) {
@@ -387,7 +429,7 @@ function preEditContext(db, filePath) {
         }
     }
     // What this file imports
-    const imports = db.prepare(`
+    const imports = cached(db, `
         SELECT f.path, fd.import_name FROM file_deps fd JOIN files f ON f.id = fd.to_file WHERE fd.from_file = ?
     `).all(file.id);
     if (imports.length > 0) {
@@ -401,19 +443,18 @@ function preEditContext(db, filePath) {
 }
 /** Get all symbols in a specific file */
 function getFileSymbols(db, filePath) {
-    const stmt = db.prepare(`
+    return cached(db, `
         SELECT s.name, s.qualified_name as qualifiedName, s.kind, s.line_start as lineStart,
                s.line_end as lineEnd, s.signature, s.exported, s.parameters
         FROM symbols s
         JOIN files f ON f.id = s.file_id
         WHERE f.path = ?
         ORDER BY s.line_start
-    `);
-    return stmt.all(filePath);
+    `).all(filePath);
 }
 /** Find symbols by kind (class, function, interface, type, enum, method, variable) */
 function findByKind(db, kind, limit = 50) {
-    const stmt = db.prepare(`
+    return cached(db, `
         SELECT s.name, s.qualified_name, s.kind, f.path as file,
                s.line_start, s.line_end, s.signature,
                COALESCE(r.pagerank, 0) as pagerank
@@ -423,12 +464,11 @@ function findByKind(db, kind, limit = 50) {
         WHERE s.kind = ?
         ORDER BY r.pagerank DESC
         LIMIT ?
-    `);
-    return stmt.all(kind, limit);
+    `).all(kind, limit);
 }
 /** Find all classes/interfaces that extend or implement a given name */
 function getTypeHierarchy(db, parentName) {
-    const stmt = db.prepare(`
+    return cached(db, `
         SELECT s.name, s.qualified_name as qualifiedName, s.kind, f.path as file,
                s.line_start as lineStart, tr.kind as relationKind
         FROM type_relations tr
@@ -436,12 +476,11 @@ function getTypeHierarchy(db, parentName) {
         JOIN files f ON f.id = s.file_id
         WHERE tr.parent_name = ?
         ORDER BY tr.kind, s.name
-    `);
-    return stmt.all(parentName);
+    `).all(parentName);
 }
 /** Find exported symbols that nothing references or imports */
 function findDeadExports(db, limit = 50) {
-    const stmt = db.prepare(`
+    return cached(db, `
         SELECT s.name, s.kind, f.path as file, s.line_start as lineStart
         FROM symbols s
         JOIN files f ON f.id = s.file_id
@@ -457,19 +496,17 @@ function findDeadExports(db, limit = 50) {
           )
         ORDER BY f.path, s.line_start
         LIMIT ?
-    `);
-    return stmt.all(limit);
+    `).all(limit);
 }
 /** Find all files that import from a given package */
 function getPkgUsages(db, packageName) {
-    const stmt = db.prepare(`
+    return cached(db, `
         SELECT f.path as file, pd.imported_names as importedNames
         FROM pkg_deps pd
         JOIN files f ON f.id = pd.file_id
         WHERE pd.package = ? OR pd.package LIKE ? || '/%'
         ORDER BY f.path
-    `);
-    return stmt.all(packageName, packageName);
+    `).all(packageName, packageName);
 }
 // --- review_diff helpers ---
 function getGitDiff(rootDir, target) {
@@ -549,7 +586,7 @@ function parseDiff(rawDiff) {
     return files;
 }
 function matchHunksToSymbols(db, diffFile) {
-    const allSymbols = db.prepare(`
+    const allSymbols = cached(db, `
         SELECT s.name, s.qualified_name, s.kind, f.path as file,
                s.line_start, s.line_end, s.signature, s.exported,
                COALESCE(r.pagerank, 0) as pagerank
@@ -610,11 +647,11 @@ function matchHunksToSymbols(db, diffFile) {
     return { changed, unchangedExports };
 }
 function getMedianPagerank(db) {
-    const count = db.prepare('SELECT COUNT(*) as cnt FROM rankings').get()?.cnt || 0;
+    const count = cached(db, 'SELECT COUNT(*) as cnt FROM rankings').get()?.cnt || 0;
     if (count === 0)
         return 0;
     const mid = Math.floor(count / 2);
-    const row = db.prepare('SELECT pagerank FROM rankings ORDER BY pagerank LIMIT 1 OFFSET ?').get(mid);
+    const row = cached(db, 'SELECT pagerank FROM rankings ORDER BY pagerank LIMIT 1 OFFSET ?').get(mid);
     return row?.pagerank || 0;
 }
 // --- review_diff main function ---
@@ -741,6 +778,572 @@ function reviewDiff(db, rootDir, target = 'last_commit') {
         risks,
     };
 }
+function getFileAtRef(rootDir, filePath, ref) {
+    try {
+        return (0, child_process_1.execSync)(`git show ${ref}:${filePath}`, {
+            cwd: rootDir,
+            maxBuffer: 5 * 1024 * 1024,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function getGitRef(rootDir, target) {
+    const opts = { cwd: rootDir, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] };
+    switch (target) {
+        case 'staged':
+        case 'last_commit':
+            return 'HEAD~1';
+        case 'branch': {
+            let baseBranch = 'main';
+            try {
+                (0, child_process_1.execSync)('git rev-parse --verify main', opts);
+            }
+            catch {
+                baseBranch = 'master';
+            }
+            return (0, child_process_1.execSync)(`git merge-base ${baseBranch} HEAD`, opts).trim();
+        }
+        default:
+            return `${target}~1`;
+    }
+}
+function extractSymbolCode(fileContent, lineStart, lineEnd) {
+    const lines = fileContent.split('\n');
+    return lines.slice(lineStart - 1, lineEnd).join('\n');
+}
+function findSymbolInOldFile(oldContent, symbolName, kind) {
+    // Try to find the symbol definition in the old file by matching typical patterns
+    const lines = oldContent.split('\n');
+    const escapedName = symbolName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    // Build patterns based on symbol kind
+    const patterns = [];
+    if (kind === 'function') {
+        patterns.push(new RegExp(`^\\s*(?:export\\s+)?(?:async\\s+)?function\\s+${escapedName}\\b`));
+        patterns.push(new RegExp(`^\\s*(?:export\\s+)?(?:const|let|var)\\s+${escapedName}\\s*=`));
+    }
+    else if (kind === 'class') {
+        patterns.push(new RegExp(`^\\s*(?:export\\s+)?(?:abstract\\s+)?class\\s+${escapedName}\\b`));
+    }
+    else if (kind === 'interface') {
+        patterns.push(new RegExp(`^\\s*(?:export\\s+)?interface\\s+${escapedName}\\b`));
+    }
+    else if (kind === 'type') {
+        patterns.push(new RegExp(`^\\s*(?:export\\s+)?type\\s+${escapedName}\\b`));
+    }
+    else if (kind === 'method') {
+        const methodName = symbolName.includes('.') ? symbolName.split('.').pop() : symbolName;
+        const escaped = methodName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        patterns.push(new RegExp(`^\\s*(?:async\\s+)?${escaped}\\s*\\(`));
+        patterns.push(new RegExp(`^\\s*(?:public|private|protected)?\\s*(?:async\\s+)?${escaped}\\s*\\(`));
+    }
+    else if (kind === 'variable') {
+        patterns.push(new RegExp(`^\\s*(?:export\\s+)?(?:const|let|var)\\s+${escapedName}\\b`));
+    }
+    else if (kind === 'enum') {
+        patterns.push(new RegExp(`^\\s*(?:export\\s+)?enum\\s+${escapedName}\\b`));
+    }
+    // Fallback: just look for the name
+    patterns.push(new RegExp(`\\b${escapedName}\\b`));
+    for (const pattern of patterns) {
+        for (let i = 0; i < lines.length; i++) {
+            if (pattern.test(lines[i])) {
+                // Found start, now find end by tracking braces
+                const startLine = i;
+                let braceDepth = 0;
+                let foundOpenBrace = false;
+                let endLine = i;
+                for (let j = i; j < lines.length; j++) {
+                    for (const ch of lines[j]) {
+                        if (ch === '{') {
+                            braceDepth++;
+                            foundOpenBrace = true;
+                        }
+                        else if (ch === '}') {
+                            braceDepth--;
+                        }
+                    }
+                    endLine = j;
+                    if (foundOpenBrace && braceDepth <= 0)
+                        break;
+                    // For single-line declarations without braces
+                    if (!foundOpenBrace && j > i && !lines[j + 1]?.match(/^\s/))
+                        break;
+                }
+                return lines.slice(startLine, endLine + 1).join('\n');
+            }
+        }
+    }
+    return null;
+}
+function extractDiffForRange(rawDiff, filePath, lineStart, lineEnd) {
+    // Find the diff section for this file
+    const fileSections = rawDiff.split(/^diff --git /m).filter(Boolean);
+    for (const section of fileSections) {
+        if (!section.includes(filePath))
+            continue;
+        const lines = section.split('\n');
+        const result = [];
+        let inRelevantHunk = false;
+        let currentNewLine = 0;
+        const hunkRegex = /^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/;
+        for (const line of lines) {
+            const hunkMatch = line.match(hunkRegex);
+            if (hunkMatch) {
+                currentNewLine = parseInt(hunkMatch[3], 10);
+                const newCount = parseInt(hunkMatch[4] ?? '1', 10);
+                const hunkEnd = currentNewLine + newCount - 1;
+                // Check if this hunk overlaps with symbol range
+                inRelevantHunk = (hunkEnd >= lineStart && currentNewLine <= lineEnd);
+                if (inRelevantHunk) {
+                    result.push(line);
+                }
+                continue;
+            }
+            if (inRelevantHunk) {
+                if (line.startsWith('+') || line.startsWith('-') || line.startsWith(' ')) {
+                    if (!line.startsWith('-'))
+                        currentNewLine++;
+                    // Only include lines within or near the symbol range
+                    if (currentNewLine >= lineStart - 2 && currentNewLine <= lineEnd + 2) {
+                        result.push(line);
+                    }
+                    else if (line.startsWith('+') || line.startsWith('-')) {
+                        // Always include actual changes
+                        result.push(line);
+                    }
+                }
+            }
+        }
+        if (result.length > 0)
+            return result.join('\n');
+    }
+    return '';
+}
+function describeChange(sym) {
+    const parts = [];
+    if (!sym.beforeCode && sym.afterCode) {
+        parts.push(`New ${sym.kind} added.`);
+        if (sym.exported)
+            parts.push('It is exported — other files can import it.');
+        if (sym.signature)
+            parts.push(`Signature: ${sym.signature}`);
+        return parts.join(' ');
+    }
+    if (sym.beforeCode && !sym.afterCode) {
+        parts.push(`This ${sym.kind} was deleted.`);
+        if (sym.exported)
+            parts.push('It was exported — anything importing it will break.');
+        return parts.join(' ');
+    }
+    if (!sym.beforeCode || !sym.afterCode) {
+        return `${sym.kind} was ${sym.hunkOverlap === 'full' ? 'fully rewritten' : 'partially modified'}.`;
+    }
+    const beforeLines = sym.beforeCode.split('\n');
+    const afterLines = sym.afterCode.split('\n');
+    const sizeDelta = afterLines.length - beforeLines.length;
+    // Analyze what changed between before and after
+    const beforeSig = beforeLines[0]?.trim() || '';
+    const afterSig = afterLines[0]?.trim() || '';
+    const sigChanged = beforeSig !== afterSig;
+    // Detect parameter changes
+    const paramRegex = /\(([^)]*)\)/;
+    const beforeParams = beforeSig.match(paramRegex)?.[1] || '';
+    const afterParams = afterSig.match(paramRegex)?.[1] || '';
+    const paramsChanged = beforeParams !== afterParams;
+    // Detect return type changes
+    const retRegex = /\):\s*(.+?)[\s{]/;
+    const beforeRet = beforeSig.match(retRegex)?.[1];
+    const afterRet = afterSig.match(retRegex)?.[1];
+    const retChanged = beforeRet !== afterRet && beforeRet && afterRet;
+    if (sym.hunkOverlap === 'full') {
+        parts.push(`Fully rewritten (${beforeLines.length} → ${afterLines.length} lines).`);
+    }
+    else {
+        parts.push(`Partially modified.`);
+        if (sizeDelta > 0)
+            parts.push(`${sizeDelta} lines added.`);
+        else if (sizeDelta < 0)
+            parts.push(`${Math.abs(sizeDelta)} lines removed.`);
+    }
+    if (sigChanged) {
+        parts.push(`Signature changed.`);
+        if (paramsChanged) {
+            const bCount = beforeParams ? beforeParams.split(',').length : 0;
+            const aCount = afterParams ? afterParams.split(',').length : 0;
+            if (aCount > bCount)
+                parts.push(`${aCount - bCount} new parameter(s) added.`);
+            else if (aCount < bCount)
+                parts.push(`${bCount - aCount} parameter(s) removed.`);
+            else
+                parts.push('Parameter types/names changed.');
+        }
+    }
+    if (retChanged) {
+        parts.push(`Return type changed: ${beforeRet} → ${afterRet}.`);
+    }
+    // Detect new error handling
+    const beforeHasTryCatch = /\btry\s*\{/.test(sym.beforeCode);
+    const afterHasTryCatch = /\btry\s*\{/.test(sym.afterCode);
+    if (!beforeHasTryCatch && afterHasTryCatch)
+        parts.push('Added error handling (try/catch).');
+    if (beforeHasTryCatch && !afterHasTryCatch)
+        parts.push('Removed error handling (try/catch).');
+    // Detect async changes
+    const wasAsync = /\basync\b/.test(sym.beforeCode);
+    const isAsync = /\basync\b/.test(sym.afterCode);
+    if (!wasAsync && isAsync)
+        parts.push('Now async.');
+    if (wasAsync && !isAsync)
+        parts.push('No longer async.');
+    // Detect new conditionals
+    const beforeIfs = (sym.beforeCode.match(/\bif\s*\(/g) || []).length;
+    const afterIfs = (sym.afterCode.match(/\bif\s*\(/g) || []).length;
+    if (afterIfs > beforeIfs)
+        parts.push(`${afterIfs - beforeIfs} new conditional branch(es).`);
+    if (afterIfs < beforeIfs)
+        parts.push(`${beforeIfs - afterIfs} conditional branch(es) removed.`);
+    // Detect loop changes
+    const beforeLoops = (sym.beforeCode.match(/\b(for|while|forEach)\b/g) || []).length;
+    const afterLoops = (sym.afterCode.match(/\b(for|while|forEach)\b/g) || []).length;
+    if (afterLoops > beforeLoops)
+        parts.push(`${afterLoops - beforeLoops} new loop(s).`);
+    if (afterLoops < beforeLoops)
+        parts.push(`${beforeLoops - afterLoops} loop(s) removed.`);
+    return parts.join(' ');
+}
+function describeCallerImpact(caller, sym) {
+    const parts = [];
+    parts.push(`${caller.callerName} (${caller.callerKind} in ${caller.callerFile})`);
+    parts.push(`calls ${sym.qualifiedName || sym.name}.`);
+    if (!sym.beforeCode && sym.afterCode) {
+        parts.push('This is a new symbol — caller was just added or is using new functionality.');
+    }
+    else if (sym.beforeCode && !sym.afterCode) {
+        parts.push('This symbol was DELETED — this caller WILL BREAK.');
+    }
+    else {
+        // Check if signature changed
+        const beforeSig = sym.beforeCode?.split('\n')[0]?.trim() || '';
+        const afterSig = sym.afterCode?.split('\n')[0]?.trim() || '';
+        if (beforeSig !== afterSig) {
+            parts.push(`Signature changed, so this caller may need updating.`);
+        }
+        else {
+            parts.push('Signature unchanged — caller compiles fine, but behavior changed.');
+        }
+    }
+    return parts.join(' ');
+}
+function transparentReview(db, rootDir, target = 'last_commit') {
+    const rawDiff = getGitDiff(rootDir, target);
+    if (!rawDiff.trim()) {
+        return '# Transparent Review\n\nNo changes found for target: ' + target;
+    }
+    const diffFiles = parseDiff(rawDiff);
+    const gitRef = getGitRef(rootDir, target);
+    const out = [];
+    out.push(`# Transparent Review — ${target}`);
+    out.push('');
+    // Quick stats
+    const added = diffFiles.filter(f => f.status === 'added').length;
+    const modified = diffFiles.filter(f => f.status === 'modified').length;
+    const deleted = diffFiles.filter(f => f.status === 'deleted').length;
+    const renamed = diffFiles.filter(f => f.status === 'renamed').length;
+    const totalAdded = diffFiles.reduce((s, f) => s + f.addedLines, 0);
+    const totalDeleted = diffFiles.reduce((s, f) => s + f.deletedLines, 0);
+    const statParts = [];
+    if (modified)
+        statParts.push(`${modified} modified`);
+    if (added)
+        statParts.push(`${added} added`);
+    if (deleted)
+        statParts.push(`${deleted} deleted`);
+    if (renamed)
+        statParts.push(`${renamed} renamed`);
+    out.push(`**${diffFiles.length} file(s):** ${statParts.join(', ')} — +${totalAdded} / -${totalDeleted} lines`);
+    out.push('');
+    // --- Per-file breakdown with full transparency ---
+    const allSymbolStories = [];
+    out.push('---');
+    out.push('## What Changed (file by file)');
+    out.push('');
+    for (const df of diffFiles) {
+        out.push(`### \`${df.path}\` — ${df.status}`);
+        if (df.oldPath)
+            out.push(`  (renamed from \`${df.oldPath}\`)`);
+        out.push(`  +${df.addedLines} / -${df.deletedLines} lines`);
+        out.push('');
+        // Get before and after file content
+        const beforeFile = getFileAtRef(rootDir, df.oldPath || df.path, gitRef);
+        let afterFile = null;
+        if (df.status !== 'deleted') {
+            try {
+                const fs = require('fs');
+                const fullPath = require('path').join(rootDir, df.path);
+                afterFile = fs.readFileSync(fullPath, 'utf-8');
+            }
+            catch {
+                // For committed changes, get from HEAD
+                afterFile = getFileAtRef(rootDir, df.path, 'HEAD');
+            }
+        }
+        // Match hunks to symbols
+        const { changed, unchangedExports } = matchHunksToSymbols(db, df);
+        if (changed.length === 0 && df.status === 'modified') {
+            out.push('No tracked symbols changed (changes may be in whitespace, comments, or untracked code).');
+            out.push('');
+            continue;
+        }
+        for (const sym of changed) {
+            // For before code: find by name in old file (line numbers shift between versions)
+            const beforeCode = beforeFile
+                ? findSymbolInOldFile(beforeFile, sym.qualifiedName?.split('.').pop() || sym.name, sym.kind)
+                : null;
+            const afterCode = afterFile
+                ? extractSymbolCode(afterFile, sym.lineStart, sym.lineEnd)
+                : null;
+            const diffSnippet = extractDiffForRange(rawDiff, df.path, sym.lineStart, sym.lineEnd);
+            const story = {
+                ...sym,
+                beforeCode: beforeCode && beforeCode.trim() ? beforeCode : null,
+                afterCode: afterCode && afterCode.trim() ? afterCode : null,
+                diffSnippet,
+            };
+            allSymbolStories.push(story);
+            const exportTag = sym.exported ? ' (exported)' : '';
+            out.push(`#### \`${sym.qualifiedName || sym.name}\` — ${sym.kind}${exportTag}`);
+            out.push('');
+            // Plain English description
+            const desc = describeChange(story);
+            out.push(`**What changed:** ${desc}`);
+            out.push('');
+            // Show before/after code
+            if (story.beforeCode && story.afterCode) {
+                out.push('<details><summary>Before</summary>');
+                out.push('');
+                out.push('```');
+                out.push(story.beforeCode);
+                out.push('```');
+                out.push('</details>');
+                out.push('');
+                out.push('<details><summary>After</summary>');
+                out.push('');
+                out.push('```');
+                out.push(story.afterCode);
+                out.push('```');
+                out.push('</details>');
+                out.push('');
+            }
+            else if (story.afterCode) {
+                out.push('**New code:**');
+                out.push('```');
+                out.push(story.afterCode.length > 1500
+                    ? story.afterCode.slice(0, 1500) + '\n// ... truncated'
+                    : story.afterCode);
+                out.push('```');
+                out.push('');
+            }
+            else if (story.beforeCode) {
+                out.push('**Deleted code:**');
+                out.push('```');
+                out.push(story.beforeCode.length > 1500
+                    ? story.beforeCode.slice(0, 1500) + '\n// ... truncated'
+                    : story.beforeCode);
+                out.push('```');
+                out.push('');
+            }
+            // Show the exact diff lines for this symbol
+            if (story.diffSnippet) {
+                out.push('<details><summary>Diff</summary>');
+                out.push('');
+                out.push('```diff');
+                out.push(story.diffSnippet);
+                out.push('```');
+                out.push('</details>');
+                out.push('');
+            }
+        }
+        if (unchangedExports.length > 0) {
+            out.push(`**Unchanged exports:** ${unchangedExports.join(', ')}`);
+            out.push('');
+        }
+    }
+    // --- Caller Impact Stories ---
+    out.push('---');
+    out.push('## Who Gets Affected');
+    out.push('');
+    const exportedChanged = allSymbolStories.filter(s => s.exported);
+    if (exportedChanged.length === 0) {
+        out.push('No exported symbols were changed — impact is contained to the files above.');
+        out.push('');
+    }
+    else {
+        const callerStories = [];
+        const seenCallers = new Set();
+        for (const sym of exportedChanged) {
+            const callers = getCallers(db, sym.qualifiedName || sym.name);
+            for (const caller of callers) {
+                if (caller.file === sym.file)
+                    continue;
+                const key = `${caller.name}:${caller.file}:${sym.name}`;
+                if (seenCallers.has(key))
+                    continue;
+                seenCallers.add(key);
+                // Get just the caller's code (1 query, not 4 via getContext)
+                const callerRow = cached(db, `
+                    SELECT s.content as code FROM symbols s
+                    WHERE s.name = ? OR s.qualified_name = ?
+                    ORDER BY s.exported DESC LIMIT 1
+                `).get(caller.qualifiedName || caller.name, caller.qualifiedName || caller.name);
+                const callerCode = callerRow?.code || null;
+                callerStories.push({
+                    callerName: caller.qualifiedName || caller.name,
+                    callerFile: caller.file,
+                    callerKind: caller.kind,
+                    callerPagerank: caller.pagerank,
+                    callerSignature: caller.signature,
+                    callerCode: callerCode && callerCode.length > 800
+                        ? callerCode.slice(0, 800) + '\n// ... truncated'
+                        : callerCode,
+                    changedSymbol: sym.qualifiedName || sym.name,
+                    changedFile: sym.file,
+                });
+            }
+        }
+        callerStories.sort((a, b) => b.callerPagerank - a.callerPagerank);
+        if (callerStories.length === 0) {
+            out.push('No cross-file callers found for the changed exports.');
+            out.push('');
+        }
+        else {
+            out.push(`**${callerStories.length} caller(s)** in other files use the changed exports:`);
+            out.push('');
+            for (const cs of callerStories.slice(0, 25)) {
+                const sym = allSymbolStories.find(s => (s.qualifiedName || s.name) === cs.changedSymbol);
+                if (!sym)
+                    continue;
+                const impact = describeCallerImpact(cs, sym);
+                out.push(`- **${cs.callerName}** in \`${cs.callerFile}\``);
+                out.push(`  ${impact}`);
+                if (cs.callerCode) {
+                    out.push(`  <details><summary>Caller code</summary>`);
+                    out.push('');
+                    out.push('  ```');
+                    out.push(cs.callerCode);
+                    out.push('  ```');
+                    out.push('  </details>');
+                }
+                out.push('');
+            }
+            if (callerStories.length > 25) {
+                out.push(`... and ${callerStories.length - 25} more callers.`);
+                out.push('');
+            }
+        }
+    }
+    // --- Transitive blast radius ---
+    out.push('---');
+    out.push('## Blast Radius');
+    out.push('');
+    const transitiveImpact = [];
+    const impactedFileSet = new Set();
+    for (const df of diffFiles) {
+        if (df.status === 'deleted')
+            continue;
+        const impact = getImpact(db, df.path, 3);
+        for (const imp of impact) {
+            if (!impactedFileSet.has(imp.file)) {
+                impactedFileSet.add(imp.file);
+                transitiveImpact.push(imp);
+            }
+        }
+    }
+    if (transitiveImpact.length === 0) {
+        out.push('No transitive file dependencies detected — these changes are self-contained.');
+    }
+    else {
+        out.push(`**${transitiveImpact.length} file(s)** could be transitively affected:`);
+        out.push('');
+        // Group by depth
+        const byDepth = new Map();
+        for (const imp of transitiveImpact) {
+            if (!byDepth.has(imp.depth))
+                byDepth.set(imp.depth, []);
+            byDepth.get(imp.depth).push(imp);
+        }
+        for (const [depth, files] of [...byDepth.entries()].sort((a, b) => a[0] - b[0])) {
+            const label = depth === 1 ? 'Direct importers' : `${depth} levels deep`;
+            out.push(`**${label}** (${files.length} file${files.length > 1 ? 's' : ''}):`);
+            for (const f of files.slice(0, 15)) {
+                out.push(`  - \`${f.file}\` (${f.symbolCount} symbols)`);
+            }
+            if (files.length > 15) {
+                out.push(`  - ... and ${files.length - 15} more`);
+            }
+            out.push('');
+        }
+    }
+    // --- Risk Summary ---
+    out.push('---');
+    out.push('## Risk Summary');
+    out.push('');
+    const medianPagerank = getMedianPagerank(db);
+    const risks = [];
+    // High-importance symbols
+    const highRank = allSymbolStories.filter(s => s.pagerank > medianPagerank && medianPagerank > 0);
+    if (highRank.length > 0) {
+        risks.push(`**High-importance code touched:** ${highRank.map(s => `\`${s.name}\` (rank #${s.pagerank.toFixed(6)})`).join(', ')} — these are among the most-referenced symbols in the project. Changes here ripple widely.`);
+    }
+    // Cascade risk
+    for (const sym of exportedChanged) {
+        const callerCount = allSymbolStories.length > 0
+            ? getCallers(db, sym.qualifiedName || sym.name).filter(c => c.file !== sym.file).length
+            : 0;
+        if (callerCount >= 5) {
+            risks.push(`**Cascade risk:** \`${sym.name}\` has ${callerCount} callers in other files. Behavioral changes will propagate to all of them.`);
+        }
+    }
+    // Large blast radius
+    if (transitiveImpact.length > 20) {
+        risks.push(`**Wide blast radius:** ${transitiveImpact.length} files could be transitively affected. Consider testing downstream modules.`);
+    }
+    // Deleted files with dependents
+    for (const df of diffFiles) {
+        if (df.status !== 'deleted')
+            continue;
+        const impact = getImpact(db, df.path, 1);
+        if (impact.length > 0) {
+            risks.push(`**Broken imports likely:** Deleted \`${df.path}\` still has ${impact.length} file(s) importing from it: ${impact.slice(0, 5).map(i => `\`${i.file}\``).join(', ')}`);
+        }
+    }
+    // Signature changes on exported symbols
+    for (const sym of exportedChanged) {
+        if (sym.beforeCode && sym.afterCode) {
+            const bSig = sym.beforeCode.split('\n')[0]?.trim();
+            const aSig = sym.afterCode.split('\n')[0]?.trim();
+            if (bSig !== aSig) {
+                risks.push(`**API change:** \`${sym.name}\` signature changed. Callers may need to update their call sites.`);
+            }
+        }
+    }
+    if (risks.length === 0) {
+        out.push('No significant risks detected. Changes look contained and low-impact.');
+    }
+    else {
+        for (const risk of risks) {
+            out.push(`- ${risk}`);
+        }
+    }
+    out.push('');
+    return out.join('\n');
+}
+function transparentReviewFromRoot(rootDir, target) {
+    return withDb(rootDir, db => transparentReview(db, rootDir, target));
+}
 // --- Convenience wrappers for CLI (open/close DB internally) ---
 function withDb(rootDir, fn) {
     const db = (0, schema_1.openDatabase)(rootDir);