scai 0.1.116 → 0.1.117

package/dist/db/functionExtractors/extractFromJs.js

@@ -6,6 +6,8 @@ import { log } from '../../utils/log.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';
+import { BUILTINS } from '../../fileRules/builtins.js';
+import { getUniqueId } from '../../utils/sharedUtils.js';
 function getFunctionName(node, parent, fileName) {
     if (node.id?.name)
         return node.id.name;
@@ -45,76 +47,75 @@ export async function extractFromJS(filePath, content, fileId) {
             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}`;
+                const funcContent = content.slice(node.start, node.end);
+                const unique_id = getUniqueId(name, filePath, node.loc?.start.line ?? -1, node.start, funcContent);
                 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,
+                    content: funcContent,
+                    unique_id,
                 });
             },
             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}`;
+                const funcContent = content.slice(node.start, node.end);
+                const unique_id = getUniqueId(name, filePath, node.loc?.start.line ?? -1, node.start, funcContent);
                 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,
+                    content: funcContent,
+                    unique_id,
                 });
             },
             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}`;
+                const funcContent = content.slice(node.start, node.end);
+                const unique_id = getUniqueId(name, filePath, node.loc?.start.line ?? -1, node.start, funcContent);
                 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,
+                    content: funcContent,
+                    unique_id,
                 });
             },
             ClassDeclaration(node) {
-                const className = node.id?.name || '<anon-class>';
-                const uniqueId = className !== '<anon-class>'
+                const className = node.id?.name || `${path.basename(filePath)}:<anon-class>`;
+                const classContent = content.slice(node.start, node.end);
+                const unique_id = node.id?.name
                     ? `${className}@${normalizedPath}`
-                    : `${path.basename(filePath)}:<anon-class>@${normalizedPath}:${node.loc?.start.line}`;
+                    : getUniqueId(className, filePath, node.loc?.start.line ?? -1, node.start, classContent);
                 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),
+                    content: classContent,
                     superClass: node.superClass?.name ?? null,
-                    uniqueId,
+                    unique_id,
                 });
             },
             ClassExpression(node) {
-                const className = node.id?.name || '<anon-class>';
-                const uniqueId = className !== '<anon-class>'
+                const className = node.id?.name || `${path.basename(filePath)}:<anon-class>`;
+                const classContent = content.slice(node.start, node.end);
+                const unique_id = node.id?.name
                     ? `${className}@${normalizedPath}`
-                    : `${path.basename(filePath)}:<anon-class>@${normalizedPath}:${node.loc?.start.line}`;
+                    : getUniqueId(className, filePath, node.loc?.start.line ?? -1, node.start, classContent);
                 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),
+                    content: classContent,
                     superClass: node.superClass?.name ?? null,
-                    uniqueId,
+                    unique_id,
                 });
             },
         });
         if (functions.length === 0 && classes.length === 0) {
-            log(`⚠️ No functions/classes found in: ${filePath}`);
+            log(`⚠️ No functions/classes found in JS file: ${filePath}`);
             db.prepare(markFileAsSkippedTemplate).run({ id: fileId });
             return false;
         }
@@ -123,12 +124,12 @@ export async function extractFromJS(filePath, content, fileId) {
         try {
             const kgInput = { fileId, filepath: filePath, summary: undefined };
             const kgResult = await kgModule.run(kgInput, content);
-            if (kgResult.entities?.length > 0) {
+            if (kgResult.entities?.length) {
                 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)
+                    if (!entity.type || !Array.isArray(entity.tags) || !entity.tags.length)
                         continue;
                     for (const tag of entity.tags) {
                         if (!tag || typeof tag !== 'string')
@@ -138,8 +139,8 @@ export async function extractFromJS(filePath, content, fileId) {
                             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 ||
+                            const matchedUniqueId = functions.find(f => f.name === entity.name)?.unique_id ||
+                                classes.find(c => c.name === entity.name)?.unique_id ||
                                 `${entity.name}@${filePath}`;
                             insertEntityTag.run({
                                 entity_type: entity.type,
@@ -158,7 +159,8 @@ export async function extractFromJS(filePath, content, fileId) {
         catch (kgErr) {
             console.warn(`⚠️ KG tagging failed for ${filePath}:`, kgErr instanceof Error ? kgErr.message : kgErr);
         }
-        // --- Insert functions + edges ---
+        // --- Insert functions + call edges ---
+        const seenEdges = new Set();
         for (const fn of functions) {
             try {
                 const embedding = await generateEmbedding(fn.content);
@@ -170,27 +172,44 @@ export async function extractFromJS(filePath, content, fileId) {
                     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_unique_id: fn.uniqueId,
-                    relation: 'contains',
+                    unique_id: fn.unique_id,
                 });
+                // File -> Function 'contains' edge
+                const containsEdgeKey = `file->${fn.unique_id}`;
+                if (!seenEdges.has(containsEdgeKey)) {
+                    db.prepare(insertEdgeTemplate).run({
+                        source_type: 'file',
+                        source_unique_id: normalizedPath,
+                        target_type: 'function',
+                        target_unique_id: fn.unique_id,
+                        relation: 'contains',
+                    });
+                    seenEdges.add(containsEdgeKey);
+                }
+                // Call edges
                 const fnAst = parse(fn.content, { ecmaVersion: 'latest', sourceType: 'module', locations: true });
                 walkAncestor(fnAst, {
                     CallExpression(node) {
-                        const calleeName = node.callee?.name || 'unresolved';
+                        const calleeName = node.callee?.name;
+                        if (!calleeName || BUILTINS.has(calleeName))
+                            return;
                         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',
-                        });
+                        const edgeKey = `${fn.unique_id}->${targetUniqueId}`;
+                        if (!seenEdges.has(edgeKey)) {
+                            try {
+                                db.prepare(insertEdgeTemplate).run({
+                                    source_type: 'function',
+                                    source_unique_id: fn.unique_id,
+                                    target_type: 'function',
+                                    target_unique_id: targetUniqueId,
+                                    relation: 'calls',
+                                });
+                                seenEdges.add(edgeKey);
+                            }
+                            catch (err) {
+                                console.error('❌ Failed to persist call edge', { fn: fn.name, calleeName, error: err });
+                            }
+                        }
                     },
                 });
                 log(`📌 Indexed JS function: ${fn.name}`);
@@ -211,19 +230,19 @@ export async function extractFromJS(filePath, content, fileId) {
                     content: cls.content,
                     embedding: JSON.stringify(embedding),
                     lang: 'js',
-                    unique_id: cls.uniqueId,
+                    unique_id: cls.unique_id,
                 });
                 db.prepare(insertEdgeTemplate).run({
                     source_type: 'file',
                     source_unique_id: normalizedPath,
                     target_type: 'class',
-                    target_unique_id: cls.uniqueId,
+                    target_unique_id: cls.unique_id,
                     relation: 'contains',
                 });
                 if (cls.superClass) {
                     db.prepare(insertEdgeTemplate).run({
                         source_type: 'class',
-                        source_unique_id: cls.uniqueId,
+                        source_unique_id: cls.unique_id,
                         target_type: `unresolved:${cls.superClass}`,
                         relation: 'inherits',
                     });
@@ -237,22 +256,32 @@ export async function extractFromJS(filePath, content, fileId) {
         }
         // --- 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',
-            });
+            try {
+                db.prepare(insertEdgeTemplate).run({
+                    source_type: 'file',
+                    source_unique_id: normalizedPath,
+                    target_type: 'file',
+                    target_unique_id: `file@${imp}`,
+                    relation: 'imports',
+                });
+            }
+            catch (err) {
+                console.error('❌ Failed to persist import edge', { imp, error: err });
+            }
         }
         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',
-            });
+            try {
+                db.prepare(insertEdgeTemplate).run({
+                    source_type: 'file',
+                    source_unique_id: normalizedPath,
+                    target_type: 'file',
+                    target_unique_id: `file@${exp}`,
+                    relation: 'exports',
+                });
+            }
+            catch (err) {
+                console.error('❌ Failed to persist export edge', { exp, error: err });
+            }
         }
         log(`📊 Extraction summary for ${filePath}: ${functions.length} functions, ${classes.length} classes, ${imports.length} imports, ${exports.length} exports`);
         db.prepare(markFileAsExtractedTemplate).run({ id: fileId });
@@ -260,7 +289,7 @@ export async function extractFromJS(filePath, content, fileId) {
         return true;
     }
     catch (err) {
-        log(`❌ Failed to extract from: ${filePath}`);
+        log(`❌ Failed to extract from JS file: ${filePath}`);
         log(`   ↳ ${err.message}`);
         db.prepare(markFileAsFailedTemplate).run({ id: fileId });
         return false;

package/dist/db/functionExtractors/extractFromTs.js

@@ -5,6 +5,8 @@ import { log } from '../../utils/log.js';
 import { getDbForRepo } from '../client.js';
 import { markFileAsSkippedTemplate, markFileAsExtractedTemplate, markFileAsFailedTemplate, insertFunctionTemplate, insertGraphClassTemplate, insertEdgeTemplate, insertGraphEntityTagTemplate, insertGraphTagTemplate, selectGraphTagIdTemplate, } from '../sqlTemplates.js';
 import { kgModule } from '../../pipeline/modules/kgModule.js';
+import { BUILTINS } from '../../fileRules/builtins.js';
+import { getUniqueId } from '../../utils/sharedUtils.js';
 export async function extractFromTS(filePath, content, fileId) {
     const db = getDbForRepo();
     const normalizedPath = path.normalize(filePath).replace(/\\/g, '/');
@@ -14,7 +16,7 @@ export async function extractFromTS(filePath, content, fileId) {
         // DTO arrays used to store into functions / graph_classes later (FTS index)
         const functions = [];
         const classes = [];
-        // --- Gather all function AST nodes (so we can both index and analyze calls) ---
+        // --- Gather all function AST nodes ---
         const allFuncNodes = [
             ...sourceFile.getDescendantsOfKind(SyntaxKind.FunctionDeclaration),
             ...sourceFile.getDescendantsOfKind(SyntaxKind.FunctionExpression),
@@ -25,26 +27,20 @@ export async function extractFromTS(filePath, content, fileId) {
             ...sourceFile.getDescendantsOfKind(SyntaxKind.ClassDeclaration),
             ...sourceFile.getDescendantsOfKind(SyntaxKind.ClassExpression),
         ];
-        // If nothing found, mark as skipped
         if (allFuncNodes.length === 0 && allClassNodes.length === 0) {
             log(`⚠️ No functions/classes found in TS file: ${filePath}`);
             db.prepare(markFileAsSkippedTemplate).run({ id: fileId });
             return false;
         }
         log(`🔍 Found ${allFuncNodes.length} functions and ${allClassNodes.length} classes in ${filePath}`);
-        // --- Optionally ask LLM (kgModule) for tags for the file, persist them and associate with entities if possible ---
+        // --- LLM tagging ---
         try {
-            const kgInput = {
-                fileId,
-                filepath: filePath,
-                summary: undefined,
-            };
+            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);
-                // We'll map entity names from the LLM to unique ids if we can (functions/classes); fallback to name@file
                 for (const entity of kgResult.entities) {
                     if (!entity.type || !Array.isArray(entity.tags) || entity.tags.length === 0)
                         continue;
@@ -56,9 +52,8 @@ export async function extractFromTS(filePath, content, fileId) {
                             const tagRow = getTagId.get({ name: tag });
                             if (!tagRow)
                                 continue;
-                            // Try to match to an AST-extracted entity uniqueId, else fallback to name@filepath
-                            const matchedUniqueId = functions.find(f => f.name === entity.name)?.uniqueId ||
-                                classes.find(c => c.name === entity.name)?.uniqueId ||
+                            const matchedUniqueId = functions.find(f => f.name === entity.name)?.unique_id ||
+                                classes.find(c => c.name === entity.name)?.unique_id ||
                                 `${entity.name}@${filePath}`;
                             insertEntityTag.run({
                                 entity_type: entity.type,
@@ -75,25 +70,17 @@ export async function extractFromTS(filePath, content, fileId) {
             }
         }
         catch (kgErr) {
-            // tagging failure should not stop extraction; log and continue
             console.warn(`⚠️ KG tagging failed for ${filePath}:`, kgErr instanceof Error ? kgErr.message : kgErr);
         }
-        // --- Process functions: build DTOs (for FTS) and emit call edges (KG) using AST nodes ---
-        // inside the functions loop
+        // --- Process functions ---
         for (const funcNode of allFuncNodes) {
-            // Resolve a reasonable function name
             const symbolName = funcNode.getSymbol()?.getName();
             const name = symbolName ?? '<anon>';
             const start = funcNode.getStartLineNumber();
             const end = funcNode.getEndLineNumber();
             const code = funcNode.getText();
-            // --- updated uniqueId: include line number to make anonymous functions unique ---
-            const uniqueId = symbolName
-                ? `${symbolName}@${normalizedPath}`
-                : `${path.basename(filePath)}:<anon>@${normalizedPath}:${start}`;
-            // push DTO for later insertion into functions table
-            functions.push({ name, start_line: start, end_line: end, content: code, uniqueId });
-            // Persist function row
+            const unique_id = getUniqueId(name, filePath, start, funcNode.getStart(), code);
+            functions.push({ name, start_line: start, end_line: end, content: code, unique_id });
             try {
                 const embedding = await generateEmbedding(code);
                 db.prepare(insertFunctionTemplate).run({
@@ -104,7 +91,7 @@ export async function extractFromTS(filePath, content, fileId) {
                     content: code,
                     embedding: JSON.stringify(embedding),
                     lang: 'ts',
-                    unique_id: uniqueId,
+                    unique_id,
                 });
             }
             catch (err) {
@@ -116,16 +103,17 @@ export async function extractFromTS(filePath, content, fileId) {
                     source_type: 'file',
                     source_unique_id: normalizedPath,
                     target_type: 'function',
-                    target_unique_id: uniqueId,
+                    target_unique_id: unique_id,
                     relation: 'contains',
                 });
             }
             catch (err) {
                 console.error('❌ Failed to persist file->function edge', { filePath, name, error: err });
             }
-            // --- AST-based detection of calls inside the function ---
+            // AST-based calls
             try {
                 const callExprs = funcNode.getDescendantsOfKind(SyntaxKind.CallExpression);
+                const edgeSet = new Set();
                 for (const callExpr of callExprs) {
                     let calleeName;
                     try {
@@ -135,36 +123,41 @@ export async function extractFromTS(filePath, content, fileId) {
                     catch {
                         calleeName = undefined;
                     }
-                    const targetUniqueId = calleeName ? `${calleeName}@${normalizedPath}` : 'unresolved';
-                    try {
-                        db.prepare(insertEdgeTemplate).run({
-                            source_type: 'function',
-                            source_unique_id: uniqueId,
-                            target_type: 'function',
-                            target_unique_id: targetUniqueId,
-                            relation: 'calls',
-                        });
-                    }
-                    catch (err) {
-                        console.error('❌ Failed to persist call edge', { filePath, name, calleeName, error: err });
+                    if (!calleeName || BUILTINS.has(calleeName))
+                        continue;
+                    const targetUniqueId = `${calleeName}@${normalizedPath}`;
+                    const edgeKey = `${unique_id}->${targetUniqueId}`;
+                    if (!edgeSet.has(edgeKey)) {
+                        edgeSet.add(edgeKey);
+                        try {
+                            db.prepare(insertEdgeTemplate).run({
+                                source_type: 'function',
+                                source_unique_id: unique_id,
+                                target_type: 'function',
+                                target_unique_id: targetUniqueId,
+                                relation: 'calls',
+                            });
+                        }
+                        catch (err) {
+                            console.error('❌ Failed to persist call edge', { filePath, name, calleeName, error: err });
+                        }
                     }
                 }
             }
             catch (err) {
                 console.warn(`⚠️ Failed to inspect call expressions for function ${name} in ${filePath}:`, err);
             }
-            log(`📌 Indexed TS function: ${name} (uniqueId=${uniqueId})`);
+            log(`📌 Indexed TS function: ${name} (unique_id=${unique_id})`);
         }
-        // --- Process classes (index + contains edge + inherits) ---
+        // --- Process classes ---
         for (const clsNode of allClassNodes) {
             const name = clsNode.getName() ?? `${path.basename(filePath)}:<anon-class>`;
             const start = clsNode.getStartLineNumber();
             const end = clsNode.getEndLineNumber();
             const code = clsNode.getText();
             const superClass = clsNode.getExtends()?.getText() ?? null;
-            const uniqueId = `${name}@${normalizedPath}`;
-            classes.push({ name, start_line: start, end_line: end, content: code, superClass, uniqueId });
-            // persist class row
+            const unique_id = getUniqueId(name, filePath, start, clsNode.getStart(), code);
+            classes.push({ name, start_line: start, end_line: end, content: code, superClass, unique_id });
             try {
                 const embedding = await generateEmbedding(code);
                 db.prepare(insertGraphClassTemplate).run({
@@ -175,31 +168,29 @@ export async function extractFromTS(filePath, content, fileId) {
                     content: code,
                     embedding: JSON.stringify(embedding),
                     lang: 'ts',
-                    unique_id: uniqueId,
+                    unique_id,
                 });
             }
             catch (err) {
                 console.error('❌ Failed to insert graph class row', { filePath, name, error: err });
             }
-            // File -> Class 'contains' edge
             try {
                 db.prepare(insertEdgeTemplate).run({
                     source_type: 'file',
                     source_unique_id: normalizedPath,
                     target_type: 'class',
-                    target_unique_id: uniqueId,
+                    target_unique_id: unique_id,
                     relation: 'contains',
                 });
             }
             catch (err) {
                 console.error('❌ Failed to persist file->class edge', { filePath, name, error: err });
             }
-            // Inheritance edge (may be unresolved if superclass is in another file)
             if (superClass) {
                 try {
                     db.prepare(insertEdgeTemplate).run({
                         source_type: 'class',
-                        source_unique_id: uniqueId,
+                        source_unique_id: unique_id,
                         target_type: 'class',
                         target_unique_id: `unresolved:${superClass}`,
                         relation: 'inherits',
@@ -210,16 +201,16 @@ export async function extractFromTS(filePath, content, fileId) {
                 }
                 log(`🔗 Class ${name} extends ${superClass} (edge stored for later resolution)`);
             }
-            log(`🏷 Indexed TS class: ${name} (unique_id=${uniqueId})`);
-        } // end classes loop
-        // --- Handle imports (file-level) ---
+            log(`🏷 Indexed TS class: ${name} (unique_id=${unique_id})`);
+        }
+        // --- Imports ---
         try {
             const importDecls = sourceFile.getDescendantsOfKind(SyntaxKind.ImportDeclaration);
             for (const imp of importDecls) {
                 const moduleSpecifier = imp.getModuleSpecifierValue();
                 if (!moduleSpecifier)
                     continue;
-                const targetUniqueId = `file@${moduleSpecifier}`; // map to file unique id pattern
+                const targetUniqueId = `file@${moduleSpecifier}`;
                 try {
                     db.prepare(insertEdgeTemplate).run({
                         source_type: 'file',
@@ -237,7 +228,7 @@ export async function extractFromTS(filePath, content, fileId) {
         catch (err) {
             console.warn(`⚠️ Import extraction failed for ${filePath}:`, err);
         }
-        // --- Handle exports (file-level) ---
+        // --- Exports ---
         try {
             const exportDecls = sourceFile.getDescendantsOfKind(SyntaxKind.ExportDeclaration);
             for (const exp of exportDecls) {
@@ -262,7 +253,6 @@ export async function extractFromTS(filePath, content, fileId) {
         catch (err) {
             console.warn(`⚠️ Export extraction failed for ${filePath}:`, err);
         }
-        // --- Mark file as extracted and finish ---
         db.prepare(markFileAsExtractedTemplate).run({ id: fileId });
         log(`📊 Extraction summary for ${filePath}: ${functions.length} functions, ${classes.length} classes`);
         log(`✅ Marked TS functions/classes as extracted for ${filePath}`);

package/dist/db/sqlTemplates.js

@@ -44,8 +44,8 @@ export const searchFilesTemplate = `
 `;
 // --- Functions ---
 export const insertFunctionTemplate = `
-  INSERT INTO functions (file_id, name, start_line, end_line, content, embedding, lang)
-  VALUES (:file_id, :name, :start_line, :end_line, :content, :embedding, :lang)
+  INSERT INTO functions (file_id, name, start_line, end_line, content, embedding, lang, unique_id)
+  VALUES (:file_id, :name, :start_line, :end_line, :content, :embedding, :lang, :unique_id)
 `;
 // --- Graph ---
 export const insertGraphClassTemplate = `

package/dist/fileRules/builtins.js

@@ -0,0 +1,14 @@
+export const BUILTINS = new Set([
+    // String methods
+    "trim", "toLowerCase", "toUpperCase", "includes", "startsWith", "endsWith", "replace", "match", "split",
+    // Array methods
+    "map", "forEach", "filter", "reduce", "some", "every", "find", "findIndex", "push", "pop", "shift", "unshift", "slice", "splice",
+    // Object methods
+    "keys", "values", "entries", "assign",
+    // Number/Math
+    "parseInt", "parseFloat", "isNaN", "isFinite", "floor", "ceil", "round", "abs", "max", "min", "random",
+    // JSON / Promise / RegExp
+    "stringify", "parse", "then", "catch", "finally", "test",
+    // Console
+    "log", "error", "warn", "info",
+]);

package/dist/modelSetup.js

@@ -11,6 +11,7 @@ import { CONFIG_PATH } from './constants.js';
 const MODEL_PORT = 11434;
 const REQUIRED_MODELS = ['llama3:8b'];
 const OLLAMA_URL = 'https://ollama.com/download';
+const VSCODE_URL = 'https://code.visualstudio.com/download';
 const isYesMode = process.argv.includes('--yes') || process.env.SCAI_YES === '1';
 let ollamaChecked = false;
 let ollamaAvailable = false;
@@ -38,7 +39,7 @@ function promptUser(question, timeout = 20000) {
     return new Promise((resolve) => {
         const timer = setTimeout(() => {
             rl.close();
-            resolve(''); // treat empty as "continue"
+            resolve('');
         }, timeout);
         rl.question(question, (answer) => {
             clearTimeout(timer);
@@ -89,7 +90,7 @@ async function ensureOllamaRunning() {
             windowsHide: true,
         });
         child.unref();
-        await new Promise((res) => setTimeout(res, 10000)); // give more time
+        await new Promise((res) => setTimeout(res, 10000));
         if (await isOllamaRunning()) {
             console.log(chalk.green('✅ Ollama started successfully.'));
             ollamaAvailable = true;
@@ -102,13 +103,11 @@ async function ensureOllamaRunning() {
             process.exit(1);
         }
     }
-    // Ollama not detected; prompt user but allow continuing
     console.log(chalk.red('❌ Ollama is not installed or not in PATH.'));
     console.log(chalk.yellow(`📦 Ollama is required to run local AI models.`));
     const answer = await promptUser(`🌐 Recommended model: ${REQUIRED_MODELS.join(', ')}\nOpen download page in browser? (y/N): `);
-    if (answer.toLowerCase() === 'y') {
+    if (answer.toLowerCase() === 'y')
         openBrowser(OLLAMA_URL);
-    }
     await promptUser('⏳ Press Enter once Ollama is installed or to continue without it: ');
     if (await isOllamaRunning()) {
         console.log(chalk.green('✅ Ollama detected. Continuing...'));
@@ -116,7 +115,7 @@ async function ensureOllamaRunning() {
     }
     else {
         console.log(chalk.yellow('⚠️  Ollama not running. Models will not be available until installed.'));
-        ollamaAvailable = false; // continue anyway
+        ollamaAvailable = false;
     }
 }
 // 🧰 List installed models
@@ -159,9 +158,49 @@ async function ensureModelsDownloaded() {
         }
     }
 }
+// 🌟 Check if VSCode CLI is available
+async function isVSCodeAvailable() {
+    try {
+        execSync('code --version', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ⚡ Ensure VSCode CLI is installed
+async function ensureVSCodeInstalled() {
+    if (await isVSCodeAvailable()) {
+        console.log(chalk.green('✅ VSCode CLI is available.'));
+        return;
+    }
+    console.log(chalk.red('❌ VSCode CLI not found.'));
+    const answer = await promptUser('Do you want to open the VSCode download page? (y/N): ');
+    if (answer.toLowerCase() === 'y')
+        openBrowser(VSCODE_URL);
+    await promptUser('VSCode CLI was not found. If you want to use VSCode features, please install it manually. ' +
+        'Once installed, press Enter to continue. If you prefer to skip VSCode, just press Enter to continue without it: ');
+    if (await isVSCodeAvailable()) {
+        console.log(chalk.green('✅ VSCode CLI detected. Continuing...'));
+    }
+    else {
+        console.log(chalk.yellow('⚠️ VSCode CLI still not found. Some features may be disabled.'));
+    }
+}
 // 🏁 Main bootstrap logic
 export async function bootstrap() {
     await autoInitIfNeeded();
     await ensureOllamaRunning();
     await ensureModelsDownloaded();
+    await ensureVSCodeInstalled();
+}
+// 🔗 Helper: open file or diff in VSCode
+export function openInVSCode(filePath, options) {
+    const args = options?.diffWith ? ['--diff', options.diffWith, filePath] : [filePath];
+    try {
+        spawn('code', args, { stdio: 'inherit' });
+    }
+    catch {
+        console.log(chalk.red('❌ Failed to launch VSCode CLI. Make sure it is installed and in PATH.'));
+    }
 }

package/dist/scripts/dbcheck.js

@@ -116,4 +116,154 @@ const sampleEntityTags = db.prepare(`
 sampleEntityTags.forEach(et => {
     console.log(`   [${et.id}] ${et.entity_type}(${et.entity_id}) -> tag ${et.tag_id}`);
 });
+// === Function → Edges Check ===
+console.log("\n🕸 Function Calls / CalledBy consistency");
+// 1. Check for edges pointing to missing functions
+const missingFuncs = db.prepare(`
+  SELECT e.id, e.source_unique_id, e.target_unique_id
+  FROM graph_edges e
+  WHERE e.source_type = 'function'
+    AND NOT EXISTS (SELECT 1 FROM functions f WHERE f.unique_id = e.source_unique_id)
+  UNION
+  SELECT e.id, e.source_unique_id, e.target_unique_id
+  FROM graph_edges e
+  WHERE e.target_type = 'function'
+    AND NOT EXISTS (SELECT 1 FROM functions f WHERE f.unique_id = e.target_unique_id)
+  LIMIT 10
+`).all();
+if (missingFuncs.length === 0) {
+    console.log("✅ All edges reference valid functions.");
+}
+else {
+    console.log("❌ Found edges pointing to missing functions:");
+    missingFuncs.forEach(e => {
+        console.log(`   Edge ${e.id}: ${e.source_unique_id} -> ${e.target_unique_id}`);
+    });
+}
+// 2. Functions with outgoing calls
+const funcWithCalls = db.prepare(`
+  SELECT f.id, f.name, COUNT(e.id) AS callCount
+  FROM functions f
+  JOIN graph_edges e
+    ON e.source_type = 'function'
+   AND e.source_unique_id = f.unique_id
+  GROUP BY f.id
+  HAVING callCount > 0
+  ORDER BY callCount DESC
+  LIMIT 5
+`).all();
+funcWithCalls.forEach(f => {
+    console.log(`   🔹 Function [${f.id}] ${f.name} has ${f.callCount} outgoing calls`);
+});
+// 3. Functions with incoming calls
+const funcWithCalledBy = db.prepare(`
+  SELECT f.id, f.name, COUNT(e.id) AS calledByCount
+  FROM functions f
+  JOIN graph_edges e
+    ON e.target_type = 'function'
+   AND e.target_unique_id = f.unique_id
+  GROUP BY f.id
+  HAVING calledByCount > 0
+  ORDER BY calledByCount DESC
+  LIMIT 5
+`).all();
+funcWithCalledBy.forEach(f => {
+    console.log(`   🔸 Function [${f.id}] ${f.name} is called by ${f.calledByCount} functions`);
+});
+// 4. Check for duplicate edges (same source→target)
+const duplicateEdges = db.prepare(`
+  SELECT source_unique_id, target_unique_id, COUNT(*) as dupCount
+  FROM graph_edges
+  WHERE source_type = 'function' AND target_type = 'function'
+  GROUP BY source_unique_id, target_unique_id
+  HAVING dupCount > 1
+  LIMIT 5
+`).all();
+if (duplicateEdges.length > 0) {
+    console.log("⚠️ Duplicate function call edges found:");
+    duplicateEdges.forEach(d => {
+        console.log(`   ${d.source_unique_id} -> ${d.target_unique_id} (x${d.dupCount})`);
+    });
+}
+else {
+    console.log("✅ No duplicate function call edges.");
+}
+// === File-specific check (AskCmd.ts) ===
+const targetPath = "/Users/rzs/dev/repos/scai/cli/src/commands/AskCmd.ts";
+// --- MUST KEEP: find the file row ---
+const targetFile = db.prepare(`
+  SELECT id, path, filename, processing_status
+  FROM files
+  WHERE path = ?
+`).get(targetPath);
+if (!targetFile) {
+    console.log(`❌ File not found in DB: ${targetPath}`);
+}
+else {
+    console.log(`\n📂 File found: [${targetFile.id}] ${targetFile.filename} (${targetFile.processing_status})`);
+    // --- MUST KEEP: list functions in this file ---
+    const funcs = db.prepare(`
+    SELECT id, name, unique_id, start_line, end_line
+    FROM functions
+    WHERE file_id = ?
+    ORDER BY start_line
+  `).all(targetFile.id);
+    console.log(`   Functions (${funcs.length}):`);
+    funcs.forEach((f) => {
+        console.log(`     [${f.id}] ${f.name} (${f.unique_id}) lines ${f.start_line}-${f.end_line}`);
+    });
+    // --- OPTIONAL: outgoing calls from this file’s functions ---
+    const outgoing = db.prepare(`
+    SELECT f.name AS source_name, e.target_unique_id, e.relation
+    FROM functions f
+    JOIN graph_edges e
+      ON e.source_unique_id = f.unique_id
+     AND e.source_type = 'function'
+    WHERE f.file_id = ?
+  `).all(targetFile.id);
+    console.log(`   Outgoing calls (${outgoing.length}):`);
+    outgoing.forEach((o) => {
+        console.log(`     ${o.source_name} -[${o.relation}]-> ${o.target_unique_id}`);
+    });
+    // --- OPTIONAL: incoming calls to this file’s functions ---
+    const incoming = db.prepare(`
+    SELECT f.name AS target_name, e.source_unique_id, e.relation
+    FROM functions f
+    JOIN graph_edges e
+      ON e.target_unique_id = f.unique_id
+     AND e.target_type = 'function'
+    WHERE f.file_id = ?
+  `).all(targetFile.id);
+    console.log(`   Incoming calls (${incoming.length}):`);
+    incoming.forEach((i) => {
+        console.log(`     ${i.source_unique_id} -[${i.relation}]-> ${i.target_name}`);
+    });
+    // --- NICE TO HAVE: dangling edges check ---
+    const dangling = db.prepare(`
+    SELECT e.id, e.source_unique_id, e.target_unique_id, e.relation
+    FROM graph_edges e
+    WHERE e.source_unique_id IN (SELECT unique_id FROM functions WHERE file_id = ?)
+       OR e.target_unique_id IN (SELECT unique_id FROM functions WHERE file_id = ?)
+  `).all(targetFile.id, targetFile.id);
+    console.log(`   Edges referencing this file's functions (dangling check): ${dangling.length}`);
+    dangling.forEach((d) => {
+        console.log(`     Edge ${d.id}: ${d.source_unique_id} -[${d.relation}]-> ${d.target_unique_id}`);
+    });
+    // --- OPTIONAL: consistency check summary ---
+    if (funcs.length > 0 && outgoing.length === 0 && incoming.length === 0 && dangling.length === 0) {
+        console.log("⚠️  This file has functions but no graph edges. Possible causes:");
+        console.log("     - Edges were never extracted for this file, OR");
+        console.log("     - unique_id mismatch between functions and edges.");
+    }
+    else {
+        console.log("✅ Edges and functions are consistent for this file.");
+    }
+    const funcsDebug = db.prepare(`
+  SELECT id, name, unique_id
+  FROM functions
+  WHERE file_id = ?
+`).all(targetFile.id);
+    console.log("Funcsdebug:\n");
+    console.log(funcsDebug);
+}
 console.log("\n✅ DB check completed.\n");

package/dist/utils/buildContextualPrompt.js

@@ -106,20 +106,24 @@ export async function buildContextualPrompt({ topFile, query, kgDepth = 3, }) {
     const kgTree = buildFileTree({ id: topFile.id, path: topFile.path, summary: topFile.summary }, kgDepth);
     promptSections.push(`**KG-Related Files (JSON tree, depth ${kgDepth}):**\n\`\`\`json\n${JSON.stringify(kgTree, null, 2)}\n\`\`\``);
     const functionCallsAll = db.prepare(`
-    SELECT source_unique_id, target_unique_id
-    FROM graph_edges
-    WHERE source_type = 'function' AND relation = 'calls'
-      AND source_unique_id IN (
-        SELECT unique_id FROM functions WHERE file_id = ?
-      )
-  `).all(topFile.id);
+  SELECT source_unique_id, target_unique_id
+  FROM graph_edges
+  WHERE source_type = 'function' AND relation = 'calls'
+    AND source_unique_id IN (
+      SELECT unique_id FROM functions WHERE file_id = ?
+    )
+`).all(topFile.id);
     const callsByFunction = {};
     for (const fn of functionRows) {
         const rows = functionCallsAll
             .filter(r => r.source_unique_id === fn.unique_id)
             .slice(0, FUNCTION_LIMIT);
+        // Truncate function content for preview
+        const lines = fn.content?.split("\n").map(l => l.trim()).filter(Boolean) || ["[no content]"];
+        const preview = lines.slice(0, 3).map(l => l.slice(0, 200) + (l.length > 200 ? "…" : "")).join(" | ");
         callsByFunction[fn.name || fn.unique_id] = {
             calls: rows.map(r => ({ unique_id: r.target_unique_id })),
+            preview,
         };
     }
     if (Object.keys(callsByFunction).length > 0) {
@@ -127,20 +131,24 @@ export async function buildContextualPrompt({ topFile, query, kgDepth = 3, }) {
     }
     // --- Function-level "called by" overview (limited) ---
     const calledByAll = db.prepare(`
-    SELECT source_unique_id, target_unique_id
-    FROM graph_edges
-    WHERE target_type = 'function' AND relation = 'calls'
-      AND target_unique_id IN (
-        SELECT unique_id FROM functions WHERE file_id = ?
-      )
-  `).all(topFile.id);
+  SELECT source_unique_id, target_unique_id
+  FROM graph_edges
+  WHERE target_type = 'function' AND relation = 'calls'
+    AND target_unique_id IN (
+      SELECT unique_id FROM functions WHERE file_id = ?
+    )
+`).all(topFile.id);
     const calledByByFunction = {};
     for (const fn of functionRows) {
         const rows = calledByAll
             .filter(r => r.target_unique_id === fn.unique_id)
             .slice(0, FUNCTION_LIMIT);
+        // Reuse truncated preview
+        const lines = fn.content?.split("\n").map(l => l.trim()).filter(Boolean) || ["[no content]"];
+        const preview = lines.slice(0, 3).map(l => l.slice(0, 200) + (l.length > 200 ? "…" : "")).join(" | ");
         calledByByFunction[fn.name || fn.unique_id] = {
             calledBy: rows.map(r => ({ unique_id: r.source_unique_id })),
+            preview,
         };
     }
     if (Object.keys(calledByByFunction).length > 0) {

package/dist/utils/sharedUtils.js

@@ -0,0 +1,8 @@
+import path from 'path';
+import crypto from 'crypto';
+// put this helper at top-level (or import from shared utils)
+export function getUniqueId(name, filePath, startLine, startColumn, content) {
+    const normalizedPath = path.normalize(filePath).replace(/\\/g, '/');
+    const hash = crypto.createHash('md5').update(content).digest('hex').slice(0, 6);
+    return `${name}@${normalizedPath}:${startLine}:${startColumn}:${hash}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scai",
-  "version": "0.1.116",
+  "version": "0.1.117",
   "type": "module",
   "bin": {
     "scai": "./dist/index.js"