scai 0.1.108 → 0.1.110

package/dist/db/functionExtractors/extractFromTs.js

@@ -1,15 +1,16 @@
-import { Project, SyntaxKind } from 'ts-morph';
+import { Project, SyntaxKind, } from 'ts-morph';
 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, } from '../sqlTemplates.js';
 export async function extractFromTS(filePath, content, fileId) {
     const db = getDbForRepo();
     try {
         const project = new Project({ useInMemoryFileSystem: true });
         const sourceFile = project.createSourceFile(filePath, content);
         const functions = [];
+        const classes = [];
         const allFuncs = [
             ...sourceFile.getDescendantsOfKind(SyntaxKind.FunctionDeclaration),
             ...sourceFile.getDescendantsOfKind(SyntaxKind.FunctionExpression),
@@ -22,45 +23,101 @@ export async function extractFromTS(filePath, content, fileId) {
             const code = fn.getText();
             functions.push({ name, start_line: start, end_line: end, content: code });
         }
-        if (functions.length === 0) {
-            log(`⚠️ No functions found in TS file: ${filePath}`);
+        const allClasses = [
+            ...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) {
+            log(`⚠️ No functions/classes found in TS file: ${filePath}`);
             db.prepare(markFileAsSkippedTemplate).run({ id: fileId });
             return false;
         }
-        log(`🔍 Found ${functions.length} TypeScript functions in ${filePath}`);
+        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(`
+            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({
+      `)
+                .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'
+                lang: 'ts',
             });
-            const callerId = result.lastInsertRowid;
-            // Simplified call detection (no walking for now)
+            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) {
-                db.prepare(`
-          INSERT INTO function_calls (caller_id, callee_name)
-          VALUES (@caller_id, @callee_name)
-        `).run({
-                    caller_id: callerId,
+                // 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(`📌 Indexed TS function: ${fn.name}`);
         }
+        // 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)`);
+            }
+            log(`🏷 Indexed TS class: ${cls.name} (id=${classId})`);
+        }
+        log(`📊 Extraction summary for ${filePath}: ${functions.length} functions, ${classes.length} classes`);
         db.prepare(markFileAsExtractedTemplate).run({ id: fileId });
-        log(`✅ Marked TS functions as extracted for ${filePath}`);
+        log(`✅ Marked TS functions/classes as extracted for ${filePath}`);
         return true;
     }
     catch (err) {

package/dist/db/functionExtractors/index.js

@@ -1,43 +1,44 @@
-import { log } from '../../utils/log.js';
-import { detectFileType } from '../../fileRules/detectFileType.js';
-import { extractFromJava } from './extractFromJava.js';
-import { extractFromJS } from './extractFromJs.js';
-import { extractFromXML } from './extractFromXML.js';
-import { getDbForRepo } from '../client.js';
-import { markFileAsFailedTemplate, markFileAsSkippedByPath } from '../sqlTemplates.js';
-import { extractFromTS } from './extractFromTs.js';
-/**
- * Detects file type and delegates to the appropriate extractor.
- */
+import { getDbForRepo } from "../client.js";
+import { markFileAsSkippedByPath, markFileAsFailedTemplate } from "../sqlTemplates.js";
+import { extractFromJava } from "./extractFromJava.js";
+import { extractFromJS } from "./extractFromJs.js";
+import { extractFromTS } from "./extractFromTs.js";
+import { extractFromXML } from "./extractFromXML.js";
+import { detectFileType } from "../../fileRules/detectFileType.js";
+import { log } from "../../utils/log.js";
 export async function extractFunctionsFromFile(filePath, content, fileId) {
     const type = detectFileType(filePath).trim().toLowerCase();
     const db = getDbForRepo();
     try {
-        if (type === 'js' || type === 'javascript') {
-            log(`✅ Attempting to extract JS functions from ${filePath}`);
-            return await extractFromJS(filePath, content, fileId);
+        let success = false;
+        switch (type) {
+            case 'js':
+            case 'javascript':
+                log(`📄 Extracting JS code from ${filePath}`);
+                success = await extractFromJS(filePath, content, fileId);
+                break;
+            case 'ts':
+            case 'typescript':
+                log(`📘 Extracting TS code from ${filePath}`);
+                success = await extractFromTS(filePath, content, fileId);
+                break;
+            case 'java':
+                log(`⚠️ Java extraction not implemented for ${filePath}`);
+                await extractFromJava(filePath, content, fileId);
+                return false;
+            case 'xml':
+                log(`⚠️ XML extraction not implemented for ${filePath}`);
+                await extractFromXML(filePath, content, fileId);
+                return false;
+            default:
+                log(`⚠️ Unsupported file type: ${type}. Skipping ${filePath}`);
+                db.prepare(markFileAsSkippedByPath).run({ path: filePath });
+                return false;
         }
-        if (type === 'ts' || type === 'typescript') {
-            log(`📘 Extracting TS functions from ${filePath}`);
-            return await extractFromTS(filePath, content, fileId);
-        }
-        if (type === 'java') {
-            log(`❌ Nothing extracted for ${filePath} due to missing implementation`);
-            await extractFromJava(filePath, content, fileId);
-            return false;
-        }
-        if (type === 'xml') {
-            log(`❌ Nothing extracted for ${filePath} due to missing implementation`);
-            await extractFromXML(filePath, content, fileId);
-            return false;
-        }
-        log(`⚠️ Unsupported file type: ${type} for function extraction. Skipping ${filePath}`);
-        db.prepare(markFileAsSkippedByPath).run({ path: filePath });
-        return false;
+        return success;
     }
     catch (error) {
-        log(`❌ Failed to extract functions from ${filePath}: ${error instanceof Error ? error.message : error}`);
-        // Use the sqlTemplate to mark the file as 'failed'
+        log(`❌ Failed to extract from ${filePath}: ${error instanceof Error ? error.message : error}`);
         db.prepare(markFileAsFailedTemplate).run({ id: fileId });
         return false;
     }

package/dist/db/functionIndex.js

@@ -5,7 +5,7 @@ import { extractFunctionsFromFile } from './functionExtractors/index.js';
  * Extracts functions from file if language is supported.
  * Returns true if functions were extracted, false otherwise.
  */
-export async function indexFunctionsForFile(filePath, fileId) {
+export async function indexCodeForFile(filePath, fileId) {
     const normalizedPath = path.normalize(filePath).replace(/\\/g, '/');
     const content = fs.readFileSync(filePath, 'utf-8');
     return await extractFunctionsFromFile(normalizedPath, content, fileId);

package/dist/db/schema.js

@@ -1,8 +1,8 @@
 import { getDbForRepo } from "./client.js";
 export function initSchema() {
     const db = getDbForRepo();
+    // --- Existing tables ---
     db.exec(`
-    -- Create the files table
     CREATE TABLE IF NOT EXISTS files (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       path TEXT UNIQUE,
@@ -16,12 +16,9 @@ export function initSchema() {
       functions_extracted_at TEXT
     );
 
-    -- Create the full-text search table, auto-updated via content=files
     CREATE VIRTUAL TABLE IF NOT EXISTS files_fts
     USING fts5(filename, summary, path, content='files', content_rowid='id');
   `);
-    console.log('✅ SQLite schema initialized with FTS5 auto-sync');
-    // Create additional tables for functions and function_calls
     db.exec(`
     CREATE TABLE IF NOT EXISTS functions (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -41,5 +38,54 @@ export function initSchema() {
       callee_name TEXT
     );
   `);
-    console.log('✅ Schema for functions and function_calls initialized');
+    // --- KG-specific additions ---
+    // Classes table
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS classes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_id INTEGER REFERENCES files(id),
+      name TEXT,
+      start_line INTEGER,
+      end_line INTEGER,
+      content TEXT,
+      embedding TEXT,
+      lang TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_class_file_id ON classes(file_id);
+  `);
+    // Edges table (function/class/file relations)
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS edges (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      source_type TEXT NOT NULL, -- 'function' | 'class' | 'file'
+      source_id INTEGER NOT NULL,
+      target_type TEXT NOT NULL,
+      target_id INTEGER NOT NULL,
+      relation TEXT NOT NULL -- e.g., 'calls', 'inherits', 'contains'
+    );
+
+    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);
+  `);
+    // --- Improved tags setup ---
+    // Master tag table
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS tags_master (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT UNIQUE NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS 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)
+    );
+
+    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);
+  `);
+    console.log('✅ KG schema initialized (files, functions, classes, edges, tags)');
 }

package/dist/index.js

@@ -193,9 +193,11 @@ const config = cmd.command('config').description('Manage SCAI configuration');
 config
     .command('set-model <model>')
     .description('Set the model to use')
-    .action(async (model) => {
+    .option('-g, --global', 'Set the global default model instead of the active repo')
+    .action(async (model, options) => {
     await withContext(async () => {
-        Config.setModel(model);
+        const scope = options.global ? 'global' : 'repo';
+        Config.setModel(model, scope);
         Config.show();
     });
 });
@@ -337,14 +339,8 @@ cmd.addHelpText('after', `
 💡 Use with caution and expect possible changes or instability.
 `);
 cmd.parse(process.argv);
-const opts = cmd.opts();
-if (opts.model)
-    Config.setModel(opts.model);
-if (opts.lang)
-    Config.setLanguage(opts.lang);
 async function withContext(action) {
     const ok = await updateContext();
-    if (!ok)
-        process.exit(1);
+    //if (!ok) process.exit(1);
     await action();
 }

package/dist/modelSetup.js

@@ -9,7 +9,7 @@ import { readConfig, writeConfig } from './config.js';
 import { CONFIG_PATH } from './constants.js';
 // Constants
 const MODEL_PORT = 11434;
-const REQUIRED_MODELS = ['llama3', 'mistral'];
+const REQUIRED_MODELS = ['llama3:8b'];
 const OLLAMA_URL = 'https://ollama.com/download';
 const isYesMode = process.argv.includes('--yes') || process.env.SCAI_YES === '1';
 let ollamaChecked = false;
@@ -30,16 +30,16 @@ export async function autoInitIfNeeded() {
         }
     }
 }
-// 🗨 Prompt user with 10-second timeout
-function promptUser(question) {
+// 🗨 Prompt user with configurable timeout
+function promptUser(question, timeout = 20000) {
     if (isYesMode)
         return Promise.resolve('y');
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     return new Promise((resolve) => {
         const timer = setTimeout(() => {
             rl.close();
-            resolve('');
-        }, 10000); // 10 second timeout
+            resolve(''); // treat empty as "continue"
+        }, timeout);
         rl.question(question, (answer) => {
             clearTimeout(timer);
             rl.close();
@@ -89,7 +89,7 @@ async function ensureOllamaRunning() {
             windowsHide: true,
         });
         child.unref();
-        await new Promise((res) => setTimeout(res, 10000));
+        await new Promise((res) => setTimeout(res, 10000)); // give more time
         if (await isOllamaRunning()) {
             console.log(chalk.green('✅ Ollama started successfully.'));
             ollamaAvailable = true;
@@ -102,23 +102,21 @@ async function ensureOllamaRunning() {
             process.exit(1);
         }
     }
-    // If we get here, Ollama likely isn't installed
+    // 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('🌐 Would you like to open the download page in your browser? (y/N): ');
+    const answer = await promptUser(`🌐 Recommended model: ${REQUIRED_MODELS.join(', ')}\nOpen download page in browser? (y/N): `);
     if (answer.toLowerCase() === 'y') {
         openBrowser(OLLAMA_URL);
     }
-    console.log(chalk.yellow('⏳ Waiting for you to install Ollama and press Enter to continue...'));
-    await promptUser('👉 Press Enter once Ollama is installed and ready: ');
-    // Retry once
+    await promptUser('⏳ Press Enter once Ollama is installed or to continue without it: ');
     if (await isOllamaRunning()) {
         console.log(chalk.green('✅ Ollama detected. Continuing...'));
         ollamaAvailable = true;
     }
     else {
-        console.log(chalk.red('❌ Ollama still not detected. Please check your installation.'));
-        process.exit(1);
+        console.log(chalk.yellow('⚠️  Ollama not running. Models will not be available until installed.'));
+        ollamaAvailable = false; // continue anyway
     }
 }
 // 🧰 List installed models
@@ -134,7 +132,7 @@ async function getInstalledModels() {
         return [];
     }
 }
-// 📥 Download missing models
+// 📥 Suggest required models but don’t block
 async function ensureModelsDownloaded() {
     if (!ollamaAvailable)
         return;
@@ -144,11 +142,11 @@ async function ensureModelsDownloaded() {
         console.log(chalk.green('✅ All required models are installed.'));
         return;
     }
-    console.log(chalk.yellow(`📦 Missing models: ${missing.join(', ')}`));
-    const answer = await promptUser('⬇️  Do you want to download them now? (y/N): ');
+    console.log(chalk.yellow(`📦 Suggested models: ${missing.join(', ')}`));
+    const answer = await promptUser('⬇️  Download them now? (y/N, continue anyway): ');
     if (answer.toLowerCase() !== 'y') {
-        console.log(chalk.red('🚫 Aborting due to missing models.'));
-        process.exit(1);
+        console.log(chalk.yellow('⚠️  Continuing without installing models. You can install later via config.'));
+        return;
     }
     for (const model of missing) {
         try {
@@ -157,8 +155,7 @@ async function ensureModelsDownloaded() {
             console.log(chalk.green(`✅ Pulled ${model}`));
         }
         catch {
-            console.log(chalk.red(`❌ Failed to pull ${model}.`));
-            process.exit(1);
+            console.log(chalk.red(`❌ Failed to pull ${model}, continuing...`));
         }
     }
 }

package/dist/pipeline/modules/cleanGeneratedTestsModule.js

@@ -7,16 +7,27 @@ export const cleanGeneratedTestsModule = {
         // normalize + strip markdown
         const normalized = normalizeText(content);
         const stripped = stripMarkdownFences(normalized);
-        // filter non-code lines
-        const lines = stripped.split("\n");
         // filter non-code lines, but keep blank ones
+        const lines = stripped.split("\n");
         const codeLines = lines.filter(line => line.trim() === "" || isCodeLike(line));
-        const cleanedCode = codeLines.join("\n");
+        // remove duplicate imports (normalize spacing/semicolon)
+        const seenImports = new Set();
+        const dedupedLines = codeLines.filter(line => {
+            if (line.trim().startsWith("import")) {
+                const key = line.trim().replace(/;$/, "");
+                if (seenImports.has(key)) {
+                    return false;
+                }
+                seenImports.add(key);
+            }
+            return true;
+        });
+        const cleanedCode = dedupedLines.join("\n").trimEnd();
         return {
             originalContent: content,
-            content: cleanedCode, // cleaned code for pipeline
-            filepath, // original file path
-            mode: "overwrite", // indicates overwrite existing file
+            content: cleanedCode,
+            filepath,
+            mode: "overwrite",
         };
     }
 };

package/dist/pipeline/modules/cleanupModule.js

@@ -29,25 +29,21 @@ function isTopOrBottomNoise(line) {
 }
 export const cleanupModule = {
     name: 'cleanup',
-    description: 'Remove markdown fences and fluff from top/bottom of each chunk with colored logging',
+    description: 'Remove markdown fences, fluff, and non-JSON lines with colored logging',
     async run(input) {
-        // Normalize line endings to \n to avoid issues with \r\n
+        // Normalize line endings to \n
         let content = input.content.replace(/\r\n/g, '\n');
         let lines = content.split('\n');
         // --- CLEAN TOP ---
-        // Remove noise lines before the first triple tick or end
         while (lines.length && (lines[0].trim() === '' || isTopOrBottomNoise(lines[0]))) {
             if (/^```(?:\w+)?$/.test(lines[0].trim()))
-                break; // Stop if opening fence found
+                break;
             console.log(chalk.red(`[cleanupModule] Removing noise from top:`), chalk.yellow(`"${lines[0].trim()}"`));
             lines.shift();
         }
-        // If opening fence found at top, find matching closing fence
         if (lines.length && /^```(?:\w+)?$/.test(lines[0].trim())) {
             console.log(chalk.red(`[cleanupModule] Found opening fenced block at top.`));
-            // Remove opening fence line
             lines.shift();
-            // Find closing fence index
             let closingIndex = -1;
             for (let i = 0; i < lines.length; i++) {
                 if (/^```(?:\w+)?$/.test(lines[i].trim())) {
@@ -57,26 +53,22 @@ export const cleanupModule = {
             }
             if (closingIndex !== -1) {
                 console.log(chalk.red(`[cleanupModule] Found closing fenced block at line ${closingIndex + 1}, removing fence lines.`));
-                // Remove closing fence line
                 lines.splice(closingIndex, 1);
             }
             else {
                 console.log(chalk.yellow(`[cleanupModule] No closing fenced block found, only removed opening fence.`));
             }
-            // NO removal of noise lines after fenced block here (to keep new comments intact)
         }
         // --- CLEAN BOTTOM ---
-        // If closing fence found at bottom, remove only that triple tick line
         if (lines.length && /^```(?:\w+)?$/.test(lines[lines.length - 1].trim())) {
             console.log(chalk.red(`[cleanupModule] Removing closing fenced block line at bottom.`));
             lines.pop();
         }
-        // Remove noise lines after closing fence (now bottom)
         while (lines.length && (lines[lines.length - 1].trim() === '' || isTopOrBottomNoise(lines[lines.length - 1]))) {
             console.log(chalk.red(`[cleanupModule] Removing noise from bottom after fenced block:`), chalk.yellow(`"${lines[lines.length - 1].trim()}"`));
             lines.pop();
         }
-        // --- FINAL CLEANUP: REMOVE ANY LINGERING TRIPLE TICK LINES ANYWHERE ---
+        // --- REMOVE ANY LINGERING TRIPLE TICK LINES ANYWHERE ---
         lines = lines.filter(line => {
             const trimmed = line.trim();
             if (/^```(?:\w+)?$/.test(trimmed)) {
@@ -85,6 +77,33 @@ export const cleanupModule = {
             }
             return true;
         });
-        return { content: lines.join('\n').trim() };
+        // --- FINAL CLEANUP: KEEP ONLY JSON LINES INSIDE BRACES ---
+        let jsonLines = [];
+        let braceDepth = 0;
+        let insideBraces = false;
+        for (let line of lines) {
+            const trimmed = line.trim();
+            // Detect start of JSON object/array
+            if (!insideBraces && (trimmed.startsWith('{') || trimmed.startsWith('['))) {
+                insideBraces = true;
+            }
+            if (insideBraces) {
+                // Track nested braces/brackets
+                for (const char of trimmed) {
+                    if (char === '{' || char === '[')
+                        braceDepth++;
+                    if (char === '}' || char === ']')
+                        braceDepth--;
+                }
+                // Skip lines that are clearly non-JSON inside braces
+                if (!trimmed.startsWith('//') && !/^\/\*/.test(trimmed) && trimmed !== '') {
+                    jsonLines.push(line);
+                }
+                // Stop collecting after outermost brace closed
+                if (braceDepth === 0)
+                    break;
+            }
+        }
+        return { content: jsonLines.join('\n').trim() };
     }
 };

package/dist/pipeline/modules/kgModule.js

@@ -0,0 +1,55 @@
+import { Config } from '../../config.js';
+import { generate } from '../../lib/generate.js';
+import path from 'path';
+import { cleanupModule } from './cleanupModule.js';
+export const kgModule = {
+    name: 'knowledge-graph',
+    description: 'Generates a knowledge graph of entities, tags, and relationships from file content.',
+    run: async (input, content) => {
+        const model = Config.getModel();
+        const ext = input.filepath ? path.extname(input.filepath).toLowerCase() : '';
+        const filename = input.filepath ? path.basename(input.filepath) : '';
+        const prompt = `
+You are an assistant specialized in building knowledge graphs from code or text.
+
+Your task is to extract structured information from the file content below.
+
+File: ${filename}
+Extension: ${ext}
+
+📋 Instructions:
+- Identify all entities (functions, classes, modules, or main concepts)
+- For each entity, generate tags describing its characteristics, purpose, or category
+- Identify relationships between entities (e.g., "uses", "extends", "calls")
+- Return output in JSON format with the following structure:
+
+{
+  "entities": [
+    { "name": "EntityName", "type": "class|function|module|concept", "tags": ["tag1", "tag2"] }
+  ],
+  "edges": [
+    { "from": "EntityName1", "to": "EntityName2", "type": "relationship_type" }
+  ]
+}
+
+Do NOT include raw content from the file. Only provide the structured JSON output.
+
+--- FILE CONTENT START ---
+${content}
+--- FILE CONTENT END ---
+    `.trim();
+        const response = await generate({ content: prompt, filepath: input.filepath }, model);
+        try {
+            // Clean the model output first
+            const cleaned = await cleanupModule.run({ content: response.content });
+            console.log("Cleaned knowledge graph data: ", cleaned);
+            const jsonString = cleaned.content;
+            const parsed = JSON.parse(jsonString);
+            return parsed;
+        }
+        catch (err) {
+            console.warn('⚠️ Failed to parse KG JSON:', err);
+            return { entities: [], edges: [] }; // fallback
+        }
+    }
+};

package/dist/pipeline/modules/repairTestsModule.js

@@ -0,0 +1,40 @@
+import { generate } from "../../lib/generate.js";
+import { Config } from "../../config.js";
+export const repairTestsModule = {
+    name: "repairTestsModule",
+    description: "Fix failing Jest tests using AI",
+    async run({ content, filepath, summary }) {
+        const model = Config.getModel();
+        const prompt = `
+You are a senior engineer tasked with repairing Jest tests.
+
+The following test file failed:
+
+--- BEGIN TEST FILE ---
+${content}
+--- END TEST FILE ---
+
+Failure summary:
+${summary || "No summary provided."}
+
+Instructions:
+- Keep the overall structure, imports, and test cases.
+- Only fix syntax errors, invalid Jest matchers, or broken references.
+- Do NOT remove or replace entire test suites unless strictly necessary.
+- Do NOT generate trivial placeholder tests (like add(2,3) examples).
+- Only return valid Jest code, no explanations, no markdown fences.
+
+Output the repaired test file:
+`.trim();
+        const response = await generate({ content: prompt }, model);
+        if (!response)
+            throw new Error("⚠️ No repaired test code returned from model");
+        return {
+            originalContent: content,
+            content: response.content, // repaired test code
+            filepath, // repair in-place
+            summary: `Repaired tests based on failure: ${summary || "unknown error"}`,
+            mode: "overwrite" // signal to overwrite existing test file
+        };
+    }
+};