scai 0.1.114 → 0.1.116

package/dist/CHANGELOG.md

@@ -193,4 +193,10 @@ Type handling with the module pipeline
 
 ## 2025-09-13
 
-• Improve robustness of context update logic
+• Improve robustness of context update logic
+
+## 2025-09-18
+
+• Improved logic for handling PR approval and inline comments
+• Add function call table to graph edge functionality
+• Improve JSON validation and cleanup in pipeline module

package/dist/commands/ResetDbCmd.js

@@ -75,5 +75,5 @@ export async function resetDatabase() {
             console.warn('⚠️ Failed to remove lock directory:', err instanceof Error ? err.message : err);
         }
     }
-    console.log('✅ Database has been reset.' + chalk.yellow('You can now re-run: scai index'));
+    console.log('✅ Database has been reset.' + chalk.yellow('You can now re-run: scai index start'));
 }

package/dist/commands/ReviewCmd.js

@@ -330,7 +330,7 @@ async function promptAIReviewSuggestions(aiOutput, chunkContent) {
         else if (trimmed === 'c') {
             selected = await promptCustomReview();
         }
-        else if (trimmed === 's') {
+        else if (trimmed === 's' || trimmed === '' || trimmed === ' ') {
             return "skip";
         }
         else if (trimmed === 'q') {
@@ -545,23 +545,25 @@ export async function reviewPullRequestCmd(branch = 'main', showAll = false) {
             });
             const shouldApprove = allApproved;
             const hasInlineComments = reviewComments.length > 0;
-            // We always submit comments first if any
-            const initialReviewState = shouldApprove ? 'APPROVE' : 'REQUEST_CHANGES';
-            const initialReviewBody = shouldApprove
-                ? '✅ Reviewed.'
-                : '⛔ Requested changes based on review.';
-            console.log(shouldApprove && !hasInlineComments
-                ? chalk.green('✔️ All chunks approved. Submitting final PR approval.')
-                : !shouldApprove
-                    ? chalk.red('❌ Not all chunks were approved. Changes requested.')
-                    : chalk.green('📝 Submitting inline comments before approval.') // ✅ NEW
-            );
-            // ✅ Submit review with inline comments or direct approval/request
-            await submitReview(pr.number, initialReviewBody, initialReviewState, reviewComments);
-            // ✅ Then submit separate approval if needed
-            if (shouldApprove && hasInlineComments) {
-                await submitReview(pr.number, 'PR approved after inline comments.', 'APPROVE');
+            let reviewState;
+            let reviewBody;
+            if (shouldApprove) {
+                reviewState = "APPROVE";
+                reviewBody = hasInlineComments
+                    ? "PR approved after inline comments."
+                    : "✅ Reviewed.";
             }
+            else {
+                reviewState = "REQUEST_CHANGES";
+                reviewBody = "⛔ Requested changes based on review.";
+            }
+            console.log(shouldApprove
+                ? hasInlineComments
+                    ? chalk.green("📝 Submitting inline comments with approval.")
+                    : chalk.green("✔️ All chunks approved. Submitting final PR approval.")
+                : chalk.red("❌ Not all chunks were approved. Changes requested."));
+            // ✅ Only one submission, inline comments are preserved
+            await submitReview(pr.number, reviewBody, reviewState, reviewComments);
         }
     }
     catch (err) {

package/dist/daemon/daemonBatch.js

@@ -7,12 +7,11 @@ import lockfile from 'proper-lockfile';
 import { summaryModule } from '../pipeline/modules/summaryModule.js';
 import { classifyFile } from '../fileRules/classifyFile.js';
 import { getDbForRepo, getDbPathForRepo } from '../db/client.js';
-import { markFileAsSkippedByPath, selectUnprocessedFiles, updateFileWithSummaryAndEmbedding, } from '../db/sqlTemplates.js';
+import { markFileAsSkippedByPath, selectUnprocessedFiles, updateFileWithSummaryAndEmbedding, insertGraphTagTemplate, selectGraphTagIdTemplate, insertGraphEntityTagTemplate, } from '../db/sqlTemplates.js';
 import { kgModule } from '../pipeline/modules/kgModule.js';
 const MAX_FILES_PER_BATCH = 5;
 /**
- * Acquires a lock on the database to ensure that only one daemon batch
- * can modify it at a time.
+ * Acquire a lock on the DB so only one daemon batch modifies it at a time
  */
 async function lockDb() {
     try {
@@ -24,12 +23,10 @@ async function lockDb() {
     }
 }
 /**
- * Runs a daemon batch to process up to MAX_FILES_PER_BATCH unprocessed files.
- * This includes:
- * - Verifying file existence and validity
- * - Generating summaries and embeddings if needed
- * - Extracting functions from source files
- * - Marking skipped files as necessary
+ * Run a daemon batch to process up to MAX_FILES_PER_BATCH files.
+ * - Generates summaries & embeddings
+ * - Extracts functions
+ * - Builds Knowledge Graph (persisting entities, tags, and edges)
  */
 export async function runDaemonBatch() {
     log('🟡 Starting daemon batch...');
@@ -92,32 +89,22 @@ export async function runDaemonBatch() {
                     const kgResult = await kgModule.run(kgInput, content);
                     log(`✅ Knowledge Graph built for ${row.path}`);
                     log(`Entities: ${kgResult.entities.length}, Edges: ${kgResult.edges.length}`);
-                    // Persist KG entities + tags only if there are any
+                    // Persist KG entities + tags
                     if (kgResult.entities.length > 0) {
-                        const insertTag = db.prepare(`
-    INSERT OR IGNORE INTO tags_master (name) VALUES (:name)
-  `);
-                        const getTagId = db.prepare(`
-    SELECT id FROM tags_master WHERE name = :name
-  `);
-                        const insertEntityTag = db.prepare(`
-    INSERT OR IGNORE INTO entity_tags (entity_type, entity_id, tag_id)
-    VALUES (:entity_type, :entity_id, :tag_id)
-  `);
+                        const insertTag = db.prepare(insertGraphTagTemplate);
+                        const getTagId = db.prepare(selectGraphTagIdTemplate);
+                        const insertEntityTag = db.prepare(insertGraphEntityTagTemplate);
                         for (const entity of kgResult.entities) {
-                            // Skip entity if type or tags are missing
                             if (!entity.type || !Array.isArray(entity.tags) || entity.tags.length === 0) {
                                 console.warn(`⚠ Skipping entity due to missing type or tags:`, entity);
                                 continue;
                             }
                             for (const tag of entity.tags) {
-                                // Skip empty or invalid tags
                                 if (!tag || typeof tag !== 'string') {
                                     console.warn(`⚠ Skipping invalid tag for entity ${entity.type}:`, tag);
                                     continue;
                                 }
                                 try {
-                                    // ✅ Use :name in SQL and plain key in object
                                     insertTag.run({ name: tag });
                                     const tagRow = getTagId.get({ name: tag });
                                     if (!tagRow) {
@@ -126,7 +113,45 @@ export async function runDaemonBatch() {
                                     }
                                     insertEntityTag.run({
                                         entity_type: entity.type,
-                                        entity_id: row.id,
+                                        entity_unique_id: `${entity.name}@${row.path}`,
+                                        tag_id: tagRow.id,
+                                    });
+                                }
+                                catch (err) {
+                                    console.error(`❌ Failed to persist entity/tag:`, { entity, tag, error: err });
+                                }
+                            }
+                        }
+                        log(`✅ Persisted entities + tags for ${row.path}`);
+                    }
+                    else {
+                        log(`⚠️ No entities found for ${row.path}, skipping DB inserts`);
+                    }
+                    // Persist KG entities + tags (from LLM)
+                    if (kgResult.entities.length > 0) {
+                        const insertTag = db.prepare(insertGraphTagTemplate);
+                        const getTagId = db.prepare(selectGraphTagIdTemplate);
+                        const insertEntityTag = db.prepare(insertGraphEntityTagTemplate);
+                        for (const entity of kgResult.entities) {
+                            if (!entity.type || !Array.isArray(entity.tags) || entity.tags.length === 0) {
+                                console.warn(`⚠ Skipping entity due to missing type or tags:`, entity);
+                                continue;
+                            }
+                            for (const tag of entity.tags) {
+                                if (!tag || typeof tag !== 'string') {
+                                    console.warn(`⚠ Skipping invalid tag for entity ${entity.type}:`, tag);
+                                    continue;
+                                }
+                                try {
+                                    insertTag.run({ name: tag });
+                                    const tagRow = getTagId.get({ name: tag });
+                                    if (!tagRow) {
+                                        console.warn(`⚠ Could not find tag ID for: ${tag}`);
+                                        continue;
+                                    }
+                                    insertEntityTag.run({
+                                        entity_type: entity.type,
+                                        entity_unique_id: `${entity.name}@${row.path}`,
                                         tag_id: tagRow.id,
                                     });
                                 }
@@ -152,7 +177,8 @@ export async function runDaemonBatch() {
         catch (err) {
             log(`❌ Failed: ${row.path}: ${err instanceof Error ? err.message : String(err)}\n`);
         }
-        await new Promise(resolve => setTimeout(resolve, 200));
+        // Short delay between files
+        await new Promise((resolve) => setTimeout(resolve, 200));
     }
     await release();
     log('✅ Finished daemon batch.\n\n');

package/dist/db/fileIndex.js

@@ -5,7 +5,7 @@ import { sanitizeQueryForFts } from '../utils/sanitizeQuery.js';
 import * as sqlTemplates from './sqlTemplates.js';
 import { CANDIDATE_LIMIT } from '../constants.js';
 import { getDbForRepo } from './client.js';
-import { scoreFiles } from '../fileRules/scoreFiles.js'; // 👈 NEW
+import { scoreFiles } from '../fileRules/scoreFiles.js';
 import chalk from 'chalk';
 export function indexFile(filePath, summary, type) {
     const stats = fs.statSync(filePath);
@@ -23,10 +23,7 @@ export function indexFile(filePath, summary, type) {
         indexedAt,
         embedding: null
     });
-    db.prepare(`
-    INSERT OR REPLACE INTO files_fts (rowid, filename, summary, path)
-    VALUES ((SELECT id FROM files WHERE path = :path), :filename, :summary, :path)
-  `).run({
+    db.prepare(sqlTemplates.upsertFileFtsTemplate).run({
         path: normalizedPath,
         filename: fileName,
         summary,
@@ -36,13 +33,7 @@ export function indexFile(filePath, summary, type) {
 export function queryFiles(safeQuery, limit = 10) {
     console.log(`Executing search query: ${safeQuery}`);
     const db = getDbForRepo();
-    return db.prepare(`
-    SELECT f.id, f.path, f.filename, f.summary, f.type, f.last_modified, f.indexed_at
-    FROM files f
-    JOIN files_fts fts ON f.id = fts.rowid
-    WHERE fts.files_fts MATCH ?
-    LIMIT ?
-  `).all(safeQuery, limit);
+    return db.prepare(sqlTemplates.queryFilesTemplate).all(safeQuery, limit);
 }
 export async function searchFiles(query, topK = 5) {
     console.log(chalk.yellow(`🧠 Searching for query: "${query}"`));
@@ -54,14 +45,7 @@ export async function searchFiles(query, topK = 5) {
     const safeQuery = sanitizeQueryForFts(query);
     console.log(`Executing search query in FTS5: ${safeQuery}`);
     const db = getDbForRepo();
-    const ftsResults = db.prepare(`
-    SELECT fts.rowid AS id, f.path, f.filename, f.summary, f.type, bm25(files_fts) AS bm25Score, f.embedding
-    FROM files f
-    JOIN files_fts fts ON f.id = fts.rowid
-    WHERE fts.files_fts MATCH ?
-    ORDER BY bm25Score ASC
-    LIMIT ?
-  `).all(safeQuery, CANDIDATE_LIMIT);
+    const ftsResults = db.prepare(sqlTemplates.searchFilesTemplate).all(safeQuery, CANDIDATE_LIMIT);
     console.log(`FTS search returned ${ftsResults.length} results`);
     if (ftsResults.length === 0)
         return [];

package/dist/db/functionExtractors/extractFromJs.js

@@ -3,8 +3,9 @@ import { ancestor as walkAncestor } from 'acorn-walk';
 import { generateEmbedding } from '../../lib/generateEmbedding.js';
 import path from 'path';
 import { log } from '../../utils/log.js';
-import { markFileAsSkippedTemplate, markFileAsExtractedTemplate, markFileAsFailedTemplate } from '../sqlTemplates.js';
+import { markFileAsSkippedTemplate, markFileAsExtractedTemplate, markFileAsFailedTemplate, insertFunctionTemplate, insertGraphClassTemplate, insertEdgeTemplate, insertGraphEntityTagTemplate, insertGraphTagTemplate, selectGraphTagIdTemplate, } from '../sqlTemplates.js';
 import { getDbForRepo } from '../client.js';
+import { kgModule } from '../../pipeline/modules/kgModule.js';
 function getFunctionName(node, parent, fileName) {
     if (node.id?.name)
         return node.id.name;
@@ -16,69 +17,99 @@ function getFunctionName(node, parent, fileName) {
         return parent.left.name;
     if (parent?.type === 'MethodDefinition' && parent.key?.name)
         return parent.key.name;
-    return `${fileName}:<anon>`;
+    return '<anon>';
 }
 export async function extractFromJS(filePath, content, fileId) {
     const db = getDbForRepo();
+    const normalizedPath = path.normalize(filePath).replace(/\\/g, '/');
     try {
-        console.log(`[Debug] Attempting to parse: ${filePath}`);
-        console.log(`[Debug] First 3 lines:\n${content.split('\n').slice(0, 3).join('\n')}`);
-        const ast = parse(content, {
-            ecmaVersion: 'latest',
-            sourceType: 'module',
-            locations: true,
-        });
+        const ast = parse(content, { ecmaVersion: 'latest', sourceType: 'module', locations: true });
         const functions = [];
         const classes = [];
+        const imports = [];
+        const exports = [];
+        // --- Traverse AST ---
         walkAncestor(ast, {
+            ImportDeclaration(node) {
+                if (node.source?.value)
+                    imports.push(node.source.value);
+            },
+            ExportNamedDeclaration(node) {
+                if (node.source?.value)
+                    exports.push(node.source.value);
+            },
+            ExportAllDeclaration(node) {
+                if (node.source?.value)
+                    exports.push(node.source.value);
+            },
             FunctionDeclaration(node, ancestors) {
                 const parent = ancestors[ancestors.length - 2];
                 const name = getFunctionName(node, parent, path.basename(filePath));
+                const uniqueId = name !== '<anon>'
+                    ? `${name}@${normalizedPath}`
+                    : `${path.basename(filePath)}:<anon>@${normalizedPath}:${node.loc?.start.line}`;
                 functions.push({
                     name,
                     start_line: node.loc?.start.line ?? -1,
                     end_line: node.loc?.end.line ?? -1,
                     content: content.slice(node.start, node.end),
+                    uniqueId,
                 });
             },
             FunctionExpression(node, ancestors) {
                 const parent = ancestors[ancestors.length - 2];
                 const name = getFunctionName(node, parent, path.basename(filePath));
+                const uniqueId = name !== '<anon>'
+                    ? `${name}@${normalizedPath}`
+                    : `${path.basename(filePath)}:<anon>@${normalizedPath}:${node.loc?.start.line}`;
                 functions.push({
                     name,
                     start_line: node.loc?.start.line ?? -1,
                     end_line: node.loc?.end.line ?? -1,
                     content: content.slice(node.start, node.end),
+                    uniqueId,
                 });
             },
             ArrowFunctionExpression(node, ancestors) {
                 const parent = ancestors[ancestors.length - 2];
                 const name = getFunctionName(node, parent, path.basename(filePath));
+                const uniqueId = name !== '<anon>'
+                    ? `${name}@${normalizedPath}`
+                    : `${path.basename(filePath)}:<anon>@${normalizedPath}:${node.loc?.start.line}`;
                 functions.push({
                     name,
                     start_line: node.loc?.start.line ?? -1,
                     end_line: node.loc?.end.line ?? -1,
                     content: content.slice(node.start, node.end),
+                    uniqueId,
                 });
             },
             ClassDeclaration(node) {
-                const className = node.id?.name || `${path.basename(filePath)}:<anon-class>`;
+                const className = node.id?.name || '<anon-class>';
+                const uniqueId = className !== '<anon-class>'
+                    ? `${className}@${normalizedPath}`
+                    : `${path.basename(filePath)}:<anon-class>@${normalizedPath}:${node.loc?.start.line}`;
                 classes.push({
                     name: className,
                     start_line: node.loc?.start.line ?? -1,
                     end_line: node.loc?.end.line ?? -1,
                     content: content.slice(node.start, node.end),
                     superClass: node.superClass?.name ?? null,
+                    uniqueId,
                 });
             },
             ClassExpression(node) {
-                const className = node.id?.name || `${path.basename(filePath)}:<anon-class>`;
+                const className = node.id?.name || '<anon-class>';
+                const uniqueId = className !== '<anon-class>'
+                    ? `${className}@${normalizedPath}`
+                    : `${path.basename(filePath)}:<anon-class>@${normalizedPath}:${node.loc?.start.line}`;
                 classes.push({
                     name: className,
                     start_line: node.loc?.start.line ?? -1,
                     end_line: node.loc?.end.line ?? -1,
                     content: content.slice(node.start, node.end),
                     superClass: node.superClass?.name ?? null,
+                    uniqueId,
                 });
             },
         });
@@ -88,109 +119,144 @@ export async function extractFromJS(filePath, content, fileId) {
             return false;
         }
         log(`🔍 Found ${functions.length} functions and ${classes.length} classes in ${filePath}`);
-        // Insert functions
-        for (const fn of functions) {
-            const embedding = await generateEmbedding(fn.content);
-            const result = db
-                .prepare(`
-        INSERT INTO functions (
-          file_id, name, start_line, end_line, content, embedding, lang
-        ) VALUES (
-          @file_id, @name, @start_line, @end_line, @content, @embedding, @lang
-        )
-      `)
-                .run({
-                file_id: fileId,
-                name: fn.name,
-                start_line: fn.start_line,
-                end_line: fn.end_line,
-                content: fn.content,
-                embedding: JSON.stringify(embedding),
-                lang: 'js',
-            });
-            const functionId = result.lastInsertRowid;
-            // file → function edge
-            db.prepare(`INSERT INTO edges (source_type, source_id, target_type, target_id, relation)
-         VALUES (@source_type, @source_id, @target_type, @target_id, 'contains')`).run({
-                source_type: 'file',
-                source_id: fileId,
-                target_type: 'function',
-                target_id: functionId,
-            });
-            // Walk inside function to find calls
-            const fnAst = parse(fn.content, {
-                ecmaVersion: 'latest',
-                sourceType: 'module',
-                locations: true,
-            });
-            const calls = [];
-            walkAncestor(fnAst, {
-                CallExpression(node) {
-                    if (node.callee?.type === 'Identifier' && node.callee.name) {
-                        calls.push({ calleeName: node.callee.name });
+        // --- KG tagging ---
+        try {
+            const kgInput = { fileId, filepath: filePath, summary: undefined };
+            const kgResult = await kgModule.run(kgInput, content);
+            if (kgResult.entities?.length > 0) {
+                const insertTag = db.prepare(insertGraphTagTemplate);
+                const getTagId = db.prepare(selectGraphTagIdTemplate);
+                const insertEntityTag = db.prepare(insertGraphEntityTagTemplate);
+                for (const entity of kgResult.entities) {
+                    if (!entity.type || !Array.isArray(entity.tags) || entity.tags.length === 0)
+                        continue;
+                    for (const tag of entity.tags) {
+                        if (!tag || typeof tag !== 'string')
+                            continue;
+                        try {
+                            insertTag.run({ name: tag });
+                            const tagRow = getTagId.get({ name: tag });
+                            if (!tagRow)
+                                continue;
+                            const matchedUniqueId = functions.find(f => f.name === entity.name)?.uniqueId ||
+                                classes.find(c => c.name === entity.name)?.uniqueId ||
+                                `${entity.name}@${filePath}`;
+                            insertEntityTag.run({
+                                entity_type: entity.type,
+                                entity_unique_id: matchedUniqueId,
+                                tag_id: tagRow.id,
+                            });
+                        }
+                        catch (err) {
+                            console.error('❌ Failed to persist entity/tag', { entity, tag, error: err });
+                        }
                     }
-                },
-            });
-            for (const call of calls) {
-                // Store name for later resolution
-                db.prepare(`INSERT INTO function_calls (caller_id, callee_name) VALUES (@caller_id, @callee_name)`).run({ caller_id: functionId, callee_name: call.calleeName });
-                // Optional unresolved edge
-                db.prepare(`INSERT INTO edges (source_type, source_id, target_type, target_id, relation)
-           VALUES (@source_type, @source_id, @target_type, @target_id, 'calls')`).run({
-                    source_type: 'function',
-                    source_id: functionId,
+                }
+                log(`🏷 Persisted LLM-generated tags for ${filePath}`);
+            }
+        }
+        catch (kgErr) {
+            console.warn(`⚠️ KG tagging failed for ${filePath}:`, kgErr instanceof Error ? kgErr.message : kgErr);
+        }
+        // --- Insert functions + edges ---
+        for (const fn of functions) {
+            try {
+                const embedding = await generateEmbedding(fn.content);
+                db.prepare(insertFunctionTemplate).run({
+                    file_id: fileId,
+                    name: fn.name,
+                    start_line: fn.start_line,
+                    end_line: fn.end_line,
+                    content: fn.content,
+                    embedding: JSON.stringify(embedding),
+                    lang: 'js',
+                    unique_id: fn.uniqueId,
+                });
+                db.prepare(insertEdgeTemplate).run({
+                    source_type: 'file',
+                    source_unique_id: normalizedPath,
                     target_type: 'function',
-                    target_id: 0, // unresolved callee
+                    target_unique_id: fn.uniqueId,
+                    relation: 'contains',
+                });
+                const fnAst = parse(fn.content, { ecmaVersion: 'latest', sourceType: 'module', locations: true });
+                walkAncestor(fnAst, {
+                    CallExpression(node) {
+                        const calleeName = node.callee?.name || 'unresolved';
+                        const targetUniqueId = `${calleeName}@${normalizedPath}`;
+                        db.prepare(insertEdgeTemplate).run({
+                            source_type: 'function',
+                            source_unique_id: fn.uniqueId,
+                            target_type: 'function',
+                            target_unique_id: targetUniqueId,
+                            relation: 'calls',
+                        });
+                    },
                 });
+                log(`📌 Indexed JS function: ${fn.name}`);
+            }
+            catch (err) {
+                console.error('❌ Failed to insert function or call edges', { fn, error: err });
             }
-            log(`📌 Indexed function: ${fn.name} with ${calls.length} calls`);
         }
-        // Insert classes
+        // --- Insert classes + edges ---
         for (const cls of classes) {
-            const embedding = await generateEmbedding(cls.content);
-            const result = db
-                .prepare(`
-    INSERT INTO classes (
-      file_id, name, start_line, end_line, content, embedding, lang
-    ) VALUES (
-      @file_id, @name, @start_line, @end_line, @content, @embedding, @lang
-    )
-  `)
-                .run({
-                file_id: fileId,
-                name: cls.name,
-                start_line: cls.start_line,
-                end_line: cls.end_line,
-                content: cls.content,
-                embedding: JSON.stringify(embedding),
-                lang: 'js',
-            });
-            const classId = result.lastInsertRowid;
-            // file → class edge
-            db.prepare(`INSERT INTO edges (source_type, source_id, target_type, target_id, relation)
-     VALUES (@source_type, @source_id, @target_type, @target_id, 'contains')`).run({
-                source_type: 'file',
-                source_id: fileId,
-                target_type: 'class',
-                target_id: classId,
-            });
-            // superclass → store unresolved reference
-            if (cls.superClass) {
-                db.prepare(`INSERT INTO edges (source_type, source_id, target_type, target_id, relation)
-       VALUES (@source_type, @source_id, @target_type, @target_id, 'inherits')`).run({
-                    source_type: 'class',
-                    source_id: classId,
+            try {
+                const embedding = await generateEmbedding(cls.content);
+                db.prepare(insertGraphClassTemplate).run({
+                    file_id: fileId,
+                    name: cls.name,
+                    start_line: cls.start_line,
+                    end_line: cls.end_line,
+                    content: cls.content,
+                    embedding: JSON.stringify(embedding),
+                    lang: 'js',
+                    unique_id: cls.uniqueId,
+                });
+                db.prepare(insertEdgeTemplate).run({
+                    source_type: 'file',
+                    source_unique_id: normalizedPath,
                     target_type: 'class',
-                    target_id: 0, // unresolved superclass
+                    target_unique_id: cls.uniqueId,
+                    relation: 'contains',
                 });
-                console.log(`🔗 Class ${cls.name} inherits ${cls.superClass} (edge stored for later resolution)`);
+                if (cls.superClass) {
+                    db.prepare(insertEdgeTemplate).run({
+                        source_type: 'class',
+                        source_unique_id: cls.uniqueId,
+                        target_type: `unresolved:${cls.superClass}`,
+                        relation: 'inherits',
+                    });
+                    log(`🔗 Class ${cls.name} extends ${cls.superClass}`);
+                }
+                log(`🏷 Indexed JS class: ${cls.name}`);
             }
-            console.log(`🏷 Indexed class: ${cls.name} (id=${classId})`);
+            catch (err) {
+                console.error('❌ Failed to insert class or edges', { cls, error: err });
+            }
+        }
+        // --- Imports / Exports edges ---
+        for (const imp of imports) {
+            db.prepare(insertEdgeTemplate).run({
+                source_type: 'file',
+                source_unique_id: normalizedPath,
+                target_type: 'file',
+                target_unique_id: `file@${imp}`,
+                relation: 'imports',
+            });
+        }
+        for (const exp of exports) {
+            db.prepare(insertEdgeTemplate).run({
+                source_type: 'file',
+                source_unique_id: normalizedPath,
+                target_type: 'file',
+                target_unique_id: `file@${exp}`,
+                relation: 'exports',
+            });
         }
-        // Optional summary after extraction
-        console.log(`📊 Extraction summary for ${filePath}: ${functions.length} functions, ${classes.length} classes`);
+        log(`📊 Extraction summary for ${filePath}: ${functions.length} functions, ${classes.length} classes, ${imports.length} imports, ${exports.length} exports`);
         db.prepare(markFileAsExtractedTemplate).run({ id: fileId });
-        log(`✅ Marked functions/classes as extracted for ${filePath}`);
+        log(`✅ Marked JS functions/classes as extracted for ${filePath}`);
         return true;
     }
     catch (err) {