scai 0.1.114 → 0.1.116

package/dist/db/functionExtractors/extractFromTs.js

@@ -3,120 +3,268 @@ import path from 'path';
 import { generateEmbedding } from '../../lib/generateEmbedding.js';
 import { log } from '../../utils/log.js';
 import { getDbForRepo } from '../client.js';
-import { markFileAsSkippedTemplate, markFileAsExtractedTemplate, markFileAsFailedTemplate, } from '../sqlTemplates.js';
+import { markFileAsSkippedTemplate, markFileAsExtractedTemplate, markFileAsFailedTemplate, insertFunctionTemplate, insertGraphClassTemplate, insertEdgeTemplate, insertGraphEntityTagTemplate, insertGraphTagTemplate, selectGraphTagIdTemplate, } from '../sqlTemplates.js';
+import { kgModule } from '../../pipeline/modules/kgModule.js';
 export async function extractFromTS(filePath, content, fileId) {
     const db = getDbForRepo();
+    const normalizedPath = path.normalize(filePath).replace(/\\/g, '/');
     try {
         const project = new Project({ useInMemoryFileSystem: true });
         const sourceFile = project.createSourceFile(filePath, content);
+        // DTO arrays used to store into functions / graph_classes later (FTS index)
         const functions = [];
         const classes = [];
-        const allFuncs = [
+        // --- Gather all function AST nodes (so we can both index and analyze calls) ---
+        const allFuncNodes = [
             ...sourceFile.getDescendantsOfKind(SyntaxKind.FunctionDeclaration),
             ...sourceFile.getDescendantsOfKind(SyntaxKind.FunctionExpression),
             ...sourceFile.getDescendantsOfKind(SyntaxKind.ArrowFunction),
         ];
-        for (const fn of allFuncs) {
-            const name = fn.getSymbol()?.getName() ?? `${path.basename(filePath)}:<anon>`;
-            const start = fn.getStartLineNumber();
-            const end = fn.getEndLineNumber();
-            const code = fn.getText();
-            functions.push({ name, start_line: start, end_line: end, content: code });
-        }
-        const allClasses = [
+        // --- Gather all class AST nodes ---
+        const allClassNodes = [
             ...sourceFile.getDescendantsOfKind(SyntaxKind.ClassDeclaration),
             ...sourceFile.getDescendantsOfKind(SyntaxKind.ClassExpression),
         ];
-        for (const cls of allClasses) {
-            const name = cls.getName() ?? `${path.basename(filePath)}:<anon-class>`;
-            const start = cls.getStartLineNumber();
-            const end = cls.getEndLineNumber();
-            const code = cls.getText();
-            const superClass = cls.getExtends()?.getText() ?? null;
-            classes.push({
-                name,
-                start_line: start,
-                end_line: end,
-                content: code,
-                superClass,
-            });
-        }
-        if (functions.length === 0 && classes.length === 0) {
+        // 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 ${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: 'ts',
-            });
-            const functionId = result.lastInsertRowid;
-            // file → function edge
-            db.prepare(`INSERT INTO edges (source_type, source_id, target_type, target_id, relation)
-         VALUES ('file', @source_id, 'function', @target_id, 'contains')`).run({ source_id: fileId, target_id: functionId });
-            // Simplified call detection (regex)
-            const callMatches = fn.content.matchAll(/(\w+)\s*\(/g);
-            for (const match of callMatches) {
-                // Store call by name (resolution happens later)
-                db.prepare(`INSERT INTO function_calls (caller_id, callee_name)
-           VALUES (@caller_id, @callee_name)`).run({
-                    caller_id: functionId,
-                    callee_name: match[1],
+        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 ---
+        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);
+                // 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;
+                    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;
+                            // 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 ||
+                                `${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 });
+                        }
+                    }
+                }
+                log(`🏷 Persisted LLM-generated tags for ${filePath}`);
+            }
+        }
+        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
+        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
+            try {
+                const embedding = await generateEmbedding(code);
+                db.prepare(insertFunctionTemplate).run({
+                    file_id: fileId,
+                    name,
+                    start_line: start,
+                    end_line: end,
+                    content: code,
+                    embedding: JSON.stringify(embedding),
+                    lang: 'ts',
+                    unique_id: uniqueId,
+                });
+            }
+            catch (err) {
+                console.error('❌ Failed to insert function row', { filePath, name, error: err });
+            }
+            // File -> Function 'contains' edge
+            try {
+                db.prepare(insertEdgeTemplate).run({
+                    source_type: 'file',
+                    source_unique_id: normalizedPath,
+                    target_type: 'function',
+                    target_unique_id: uniqueId,
+                    relation: 'contains',
+                });
+            }
+            catch (err) {
+                console.error('❌ Failed to persist file->function edge', { filePath, name, error: err });
+            }
+            // --- AST-based detection of calls inside the function ---
+            try {
+                const callExprs = funcNode.getDescendantsOfKind(SyntaxKind.CallExpression);
+                for (const callExpr of callExprs) {
+                    let calleeName;
+                    try {
+                        const expr = callExpr.getExpression();
+                        calleeName = expr.getSymbol()?.getName() ?? expr.getText();
+                    }
+                    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 });
+                    }
+                }
+            }
+            catch (err) {
+                console.warn(`⚠️ Failed to inspect call expressions for function ${name} in ${filePath}:`, err);
+            }
+            log(`📌 Indexed TS function: ${name} (uniqueId=${uniqueId})`);
+        }
+        // --- Process classes (index + contains edge + inherits) ---
+        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
+            try {
+                const embedding = await generateEmbedding(code);
+                db.prepare(insertGraphClassTemplate).run({
+                    file_id: fileId,
+                    name,
+                    start_line: start,
+                    end_line: end,
+                    content: code,
+                    embedding: JSON.stringify(embedding),
+                    lang: 'ts',
+                    unique_id: uniqueId,
+                });
+            }
+            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,
+                    relation: 'contains',
                 });
             }
-            log(`📌 Indexed TS function: ${fn.name}`);
+            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,
+                        target_type: 'class',
+                        target_unique_id: `unresolved:${superClass}`,
+                        relation: 'inherits',
+                    });
+                }
+                catch (err) {
+                    console.error('❌ Failed to persist inherits edge', { filePath, name, superClass, error: err });
+                }
+                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) ---
+        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
+                try {
+                    db.prepare(insertEdgeTemplate).run({
+                        source_type: 'file',
+                        source_unique_id: normalizedPath,
+                        target_type: 'file',
+                        target_unique_id: targetUniqueId,
+                        relation: 'imports',
+                    });
+                }
+                catch (err) {
+                    console.error('❌ Failed to persist import edge', { filePath, moduleSpecifier, error: err });
+                }
+            }
+        }
+        catch (err) {
+            console.warn(`⚠️ Import extraction failed for ${filePath}:`, err);
         }
-        // Insert classes
-        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: 'ts',
-            });
-            const classId = result.lastInsertRowid;
-            // file → class edge
-            db.prepare(`INSERT INTO edges (source_type, source_id, target_type, target_id, relation)
-     VALUES ('file', @source_id, 'class', @target_id, 'contains')`).run({ source_id: fileId, target_id: classId });
-            // superclass reference → store in helper table for later resolution
-            if (cls.superClass) {
-                db.prepare(`INSERT INTO class_inheritance (class_id, super_name)
-       VALUES (@class_id, @super_name)`).run({ class_id: classId, super_name: cls.superClass });
-                log(`🔗 Class ${cls.name} extends ${cls.superClass} (edge stored for later resolution)`);
+        // --- Handle exports (file-level) ---
+        try {
+            const exportDecls = sourceFile.getDescendantsOfKind(SyntaxKind.ExportDeclaration);
+            for (const exp of exportDecls) {
+                const moduleSpecifier = exp.getModuleSpecifierValue();
+                if (!moduleSpecifier)
+                    continue;
+                const targetUniqueId = `file@${moduleSpecifier}`;
+                try {
+                    db.prepare(insertEdgeTemplate).run({
+                        source_type: 'file',
+                        source_unique_id: normalizedPath,
+                        target_type: 'file',
+                        target_unique_id: targetUniqueId,
+                        relation: 'exports',
+                    });
+                }
+                catch (err) {
+                    console.error('❌ Failed to persist export edge', { filePath, moduleSpecifier, error: err });
+                }
             }
-            log(`🏷 Indexed TS class: ${cls.name} (id=${classId})`);
         }
-        log(`📊 Extraction summary for ${filePath}: ${functions.length} functions, ${classes.length} classes`);
+        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}`);
         return true;
     }

package/dist/db/schema.js

@@ -1,11 +1,11 @@
 import { getDbForRepo } from "./client.js";
 export function initSchema() {
     const db = getDbForRepo();
-    // --- Existing tables ---
+    // --- Core tables ---
     db.exec(`
     CREATE TABLE IF NOT EXISTS files (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
-      path TEXT UNIQUE,
+      path TEXT UNIQUE,  -- full path
       filename TEXT,
       summary TEXT,
       type TEXT,
@@ -24,6 +24,7 @@ export function initSchema() {
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       file_id INTEGER REFERENCES files(id),
       name TEXT,
+      unique_id TEXT UNIQUE,  -- e.g. "buildContextualPrompt@cli/src/utils/buildContextualPrompt.ts"
       start_line INTEGER,
       end_line INTEGER,
       content TEXT,
@@ -31,20 +32,16 @@ export function initSchema() {
       lang TEXT
     );
 
-    CREATE INDEX IF NOT EXISTS idx_file_id ON functions(file_id);
-
-    CREATE TABLE IF NOT EXISTS function_calls (
-      caller_id INTEGER REFERENCES functions(id),
-      callee_name TEXT
-    );
+    CREATE INDEX IF NOT EXISTS idx_functions_file_id ON functions(file_id);
+    CREATE INDEX IF NOT EXISTS idx_functions_unique_id ON functions(unique_id);
   `);
-    // --- KG-specific additions ---
-    // Classes table
+    // --- Graph-specific additions ---
     db.exec(`
-    CREATE TABLE IF NOT EXISTS classes (
+    CREATE TABLE IF NOT EXISTS graph_classes (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       file_id INTEGER REFERENCES files(id),
       name TEXT,
+      unique_id TEXT UNIQUE, -- e.g. "UserService@src/services/UserService.ts"
       start_line INTEGER,
       end_line INTEGER,
       content TEXT,
@@ -52,40 +49,41 @@ export function initSchema() {
       lang TEXT
     );
 
-    CREATE INDEX IF NOT EXISTS idx_class_file_id ON classes(file_id);
+    CREATE INDEX IF NOT EXISTS idx_graph_classes_file_id ON graph_classes(file_id);
+    CREATE INDEX IF NOT EXISTS idx_graph_classes_unique_id ON graph_classes(unique_id);
   `);
-    // Edges table (function/class/file relations)
+    // Edges table (all relationships live here: calls, inherits, contains, imports, exports, tests, etc.)
     db.exec(`
-    CREATE TABLE IF NOT EXISTS edges (
+    CREATE TABLE IF NOT EXISTS graph_edges (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
-      source_type TEXT NOT NULL, -- 'function' | 'class' | 'file'
-      source_id INTEGER NOT NULL,
+      source_type TEXT NOT NULL, -- 'function' | 'class' | 'file' | 'test'
+      source_unique_id TEXT NOT NULL, -- full unique_id (e.g., function@filePath, filePath)
       target_type TEXT NOT NULL,
-      target_id INTEGER NOT NULL,
-      relation TEXT NOT NULL -- e.g., 'calls', 'inherits', 'contains'
+      target_unique_id TEXT NOT NULL,
+      relation TEXT NOT NULL -- e.g., 'calls', 'imports', 'exports', 'tests'
     );
 
-    CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_type, source_id);
-    CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_type, target_id);
+    CREATE INDEX IF NOT EXISTS idx_graph_edges_source ON graph_edges(source_type, source_unique_id);
+    CREATE INDEX IF NOT EXISTS idx_graph_edges_target ON graph_edges(target_type, target_unique_id);
+    CREATE INDEX IF NOT EXISTS idx_graph_edges_relation ON graph_edges(relation);
   `);
-    // --- Improved tags setup ---
-    // Master tag table
+    // Tags setup
     db.exec(`
-    CREATE TABLE IF NOT EXISTS tags_master (
+    CREATE TABLE IF NOT EXISTS graph_tags_master (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       name TEXT UNIQUE NOT NULL
     );
 
-    CREATE TABLE IF NOT EXISTS entity_tags (
+    CREATE TABLE IF NOT EXISTS graph_entity_tags (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       entity_type TEXT NOT NULL,      -- 'function' | 'class' | 'file'
-      entity_id INTEGER NOT NULL,
-      tag_id INTEGER NOT NULL REFERENCES tags_master(id),
-      UNIQUE(entity_type, entity_id, tag_id)
+      entity_unique_id TEXT NOT NULL, -- match against functions.unique_id, classes.unique_id, or files.path
+      tag_id INTEGER NOT NULL REFERENCES graph_tags_master(id),
+      UNIQUE(entity_type, entity_unique_id, tag_id)
     );
 
-    CREATE INDEX IF NOT EXISTS idx_entity_tags_entity ON entity_tags(entity_type, entity_id);
-    CREATE INDEX IF NOT EXISTS idx_entity_tags_tag ON entity_tags(tag_id);
+    CREATE INDEX IF NOT EXISTS idx_graph_entity_tags_entity ON graph_entity_tags(entity_type, entity_unique_id);
+    CREATE INDEX IF NOT EXISTS idx_graph_entity_tags_tag ON graph_entity_tags(tag_id);
   `);
-    console.log('✅ KG schema initialized (files, functions, classes, edges, tags)');
+    console.log("✅ Graph schema initialized (files, functions, classes, edges, tags with unique_ids)");
 }

package/dist/db/sqlTemplates.js

@@ -1,9 +1,10 @@
+// --- Files ---
 // Upsert file metadata into `files`
 export const upsertFileTemplate = `
   INSERT INTO files (path, filename, summary, type, last_modified, indexed_at, embedding)
   VALUES (:path, :filename, :summary, :type, :lastModified, :indexedAt, :embedding)
   ON CONFLICT(path) DO UPDATE SET
-    filename = excluded.filename, -- Update filename when path conflicts
+    filename = excluded.filename,
     summary = CASE
       WHEN excluded.summary IS NOT NULL AND excluded.summary != files.summary
       THEN excluded.summary
@@ -18,61 +19,88 @@ export const upsertFileTemplate = `
       ELSE files.embedding
     END
 `;
-// 📌 CHANGE 1: Include `filename` in SELECT + weight `filename` highest in bm25
-export const fetchBm25ScoresTemplate = `
-  SELECT f.path, f.filename, f.summary, f.type,
-         bm25(files_fts, 10.0, 2.0, 1.0) AS bm25Score
-  FROM files_fts
-  JOIN files f ON files_fts.rowid = f.id
-  WHERE files_fts MATCH :query
-  LIMIT 50
-`;
-// Fetch embedding vector for a file
-export const fetchEmbeddingTemplate = `
-  SELECT embedding FROM files WHERE path = :path
-`;
-// 📌 CHANGE 2: Also added weighted `bm25()` with explicit weights here
-export const rawQueryTemplate = `
-  SELECT f.path, f.filename, f.summary, f.type, f.last_modified, f.indexed_at,
-         bm25(files_fts, 10.0, 2.0, 1.0) AS rank
-  FROM files_fts
-  JOIN files f ON files_fts.rowid = f.id
-  WHERE files_fts MATCH :query
-  ORDER BY rank
-  LIMIT :limit
-`;
-// Insert function metadata
+// Insert or replace into FTS
+export const upsertFileFtsTemplate = `
+  INSERT OR REPLACE INTO files_fts (rowid, filename, summary, path)
+  VALUES ((SELECT id FROM files WHERE path = :path), :filename, :summary, :path)
+`;
+// Simple file query (no scoring)
+export const queryFilesTemplate = `
+  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 ?
+`;
+// FTS search with bm25 scoring
+export const searchFilesTemplate = `
+  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 ?
+`;
+// --- 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 function call edge
-export const insertFunctionCallTemplate = `
-  INSERT INTO function_calls (caller_id, callee_name)
-  VALUES (:caller_id, :callee_name)
+// --- Graph ---
+export const insertGraphClassTemplate = `
+  INSERT INTO graph_classes (file_id, name, start_line, end_line, content, embedding, lang)
+  VALUES (:file_id, :name, :start_line, :end_line, :content, :embedding, :lang)
 `;
-// Mark a file as unprocessed
-export const markFileAsUnprocessedTemplate = `
-  UPDATE files
-  SET processing_status = 'unprocessed',
-      functions_extracted_at = NULL
-  WHERE id = :id
+export const insertEdgeTemplate = `
+  INSERT INTO graph_edges (
+    source_type, 
+    source_unique_id, 
+    target_type, 
+    target_unique_id, 
+    relation
+  )
+  VALUES (
+    :source_type, 
+    :source_unique_id, 
+    :target_type, 
+    :target_unique_id, 
+    :relation
+  )
+`;
+// --- New graph tag templates ---
+export const insertGraphTagTemplate = `
+  INSERT OR IGNORE INTO graph_tags_master (name) VALUES (:name)
 `;
-// Mark a file as extracted
+export const selectGraphTagIdTemplate = `
+  SELECT id FROM graph_tags_master WHERE name = :name
+`;
+export const insertGraphEntityTagTemplate = `
+  INSERT INTO graph_entity_tags (
+    entity_type,
+    entity_unique_id,
+    tag_id
+  )
+  VALUES (
+    :entity_type,
+    :entity_unique_id,
+    :tag_id
+  )
+  ON CONFLICT(entity_type, entity_unique_id, tag_id) DO NOTHING
+`;
+// --- File Processing Status ---
 export const markFileAsExtractedTemplate = `
   UPDATE files
   SET processing_status = 'extracted',
       functions_extracted_at = CURRENT_TIMESTAMP
   WHERE id = :id
 `;
-// Mark a file as skipped (not extractable)
 export const markFileAsSkippedTemplate = `
   UPDATE files
   SET processing_status = 'skipped',
       functions_extracted_at = NULL
   WHERE id = :id
 `;
-// Mark a file as failed
 export const markFileAsFailedTemplate = `
   UPDATE files
   SET processing_status = 'failed',
@@ -89,7 +117,7 @@ export const selectUnprocessedFiles = `
 export const markFileAsSkippedByPath = `
   UPDATE files
   SET processing_status = 'skipped',
-    functions_extracted_at = NULL
+      functions_extracted_at = NULL
   WHERE path = @path
 `;
 export const updateFileWithSummaryAndEmbedding = `

package/dist/index.js

@@ -15,7 +15,6 @@ import { startDaemon } from './commands/DaemonCmd.js';
 import { runStopDaemonCommand } from "./commands/StopDaemonCmd.js";
 import { runAskCommand } from './commands/AskCmd.js';
 import { runBackupCommand } from './commands/BackupCmd.js';
-import { runMigrateCommand } from "./commands/MigrateCmd.js";
 import { runInspectCommand } from "./commands/InspectCmd.js";
 import { reviewPullRequestCmd } from "./commands/ReviewCmd.js";
 import { promptForToken } from "./github/token.js";
@@ -276,12 +275,6 @@ db
     .action(async () => await withContext(async () => {
     await resetDatabase();
 }));
-db
-    .command('migrate')
-    .description('Run DB migration scripts')
-    .action(async () => await withContext(async () => {
-    await runMigrateCommand();
-}));
 db
     .command('inspect')
     .argument('<filepath>', 'Path to the file to inspect')