scai 0.1.109 → 0.1.111

package/dist/db/functionExtractors/extractFromJs.js

@@ -29,6 +29,7 @@ export async function extractFromJS(filePath, content, fileId) {
             locations: true,
         });
         const functions = [];
+        const classes = [];
         walkAncestor(ast, {
             FunctionDeclaration(node, ancestors) {
                 const parent = ancestors[ancestors.length - 2];
@@ -60,31 +61,63 @@ export async function extractFromJS(filePath, content, fileId) {
                     content: content.slice(node.start, node.end),
                 });
             },
+            ClassDeclaration(node) {
+                const className = node.id?.name || `${path.basename(filePath)}:<anon-class>`;
+                classes.push({
+                    name: className,
+                    start_line: node.loc?.start.line ?? -1,
+                    end_line: node.loc?.end.line ?? -1,
+                    content: content.slice(node.start, node.end),
+                    superClass: node.superClass?.name ?? null,
+                });
+            },
+            ClassExpression(node) {
+                const className = node.id?.name || `${path.basename(filePath)}:<anon-class>`;
+                classes.push({
+                    name: className,
+                    start_line: node.loc?.start.line ?? -1,
+                    end_line: node.loc?.end.line ?? -1,
+                    content: content.slice(node.start, node.end),
+                    superClass: node.superClass?.name ?? null,
+                });
+            },
         });
-        if (functions.length === 0) {
-            log(`⚠️ No functions found in: ${filePath}`);
+        if (functions.length === 0 && classes.length === 0) {
+            log(`⚠️ No functions/classes found in: ${filePath}`);
             db.prepare(markFileAsSkippedTemplate).run({ id: fileId });
             return false;
         }
-        log(`🔍 Found ${functions.length} 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: 'js'
+                lang: 'js',
+            });
+            const functionId = result.lastInsertRowid;
+            // file → function edge
+            db.prepare(`INSERT INTO edges (source_type, source_id, target_type, target_id, relation)
+         VALUES (@source_type, @source_id, @target_type, @target_id, 'contains')`).run({
+                source_type: 'file',
+                source_id: fileId,
+                target_type: 'function',
+                target_id: functionId,
             });
-            const callerId = result.lastInsertRowid;
+            // Walk inside function to find calls
             const fnAst = parse(fn.content, {
                 ecmaVersion: 'latest',
                 sourceType: 'module',
@@ -96,26 +129,73 @@ export async function extractFromJS(filePath, content, fileId) {
                     if (node.callee?.type === 'Identifier' && node.callee.name) {
                         calls.push({ calleeName: node.callee.name });
                     }
-                }
+                },
             });
             for (const call of calls) {
-                db.prepare(`
-          INSERT INTO function_calls (caller_id, callee_name)
-          VALUES (@caller_id, @callee_name)
-        `).run({
-                    caller_id: callerId,
-                    callee_name: call.calleeName
+                // Store name for later resolution
+                db.prepare(`INSERT INTO function_calls (caller_id, callee_name) VALUES (@caller_id, @callee_name)`).run({ caller_id: functionId, callee_name: call.calleeName });
+                // Optional unresolved edge
+                db.prepare(`INSERT INTO edges (source_type, source_id, target_type, target_id, relation)
+           VALUES (@source_type, @source_id, @target_type, @target_id, 'calls')`).run({
+                    source_type: 'function',
+                    source_id: functionId,
+                    target_type: 'function',
+                    target_id: 0, // unresolved callee
                 });
             }
             log(`📌 Indexed function: ${fn.name} with ${calls.length} calls`);
         }
+        // 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: 'js',
+            });
+            const classId = result.lastInsertRowid;
+            // file → class edge
+            db.prepare(`INSERT INTO edges (source_type, source_id, target_type, target_id, relation)
+     VALUES (@source_type, @source_id, @target_type, @target_id, 'contains')`).run({
+                source_type: 'file',
+                source_id: fileId,
+                target_type: 'class',
+                target_id: classId,
+            });
+            // superclass → store unresolved reference
+            if (cls.superClass) {
+                db.prepare(`INSERT INTO edges (source_type, source_id, target_type, target_id, relation)
+       VALUES (@source_type, @source_id, @target_type, @target_id, 'inherits')`).run({
+                    source_type: 'class',
+                    source_id: classId,
+                    target_type: 'class',
+                    target_id: 0, // unresolved superclass
+                });
+                console.log(`🔗 Class ${cls.name} inherits ${cls.superClass} (edge stored for later resolution)`);
+            }
+            console.log(`🏷 Indexed class: ${cls.name} (id=${classId})`);
+        }
+        // Optional summary after extraction
+        console.log(`📊 Extraction summary for ${filePath}: ${functions.length} functions, ${classes.length} classes`);
         db.prepare(markFileAsExtractedTemplate).run({ id: fileId });
-        log(`✅ Marked functions as extracted for ${filePath}`);
+        log(`✅ Marked functions/classes as extracted for ${filePath}`);
         return true;
     }
     catch (err) {
         log(`❌ Failed to extract from: ${filePath}`);
-        log(`   ↳ ${String(err.message)}`);
+        log(`   ↳ ${err.message}`);
         db.prepare(markFileAsFailedTemplate).run({ id: fileId });
         return false;
     }

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/lib/generate.js

@@ -1,8 +1,9 @@
 // File: lib/generate.ts
 import { Spinner } from './spinner.js';
-import { readConfig } from '../config.js';
+import { Config, readConfig } from '../config.js';
 import { startModelProcess } from '../utils/checkModel.js';
-export async function generate(input, model) {
+export async function generate(input) {
+    const model = Config.getModel();
     const contextLength = readConfig().contextLength ?? 8192;
     let prompt = input.content;
     if (prompt.length > contextLength) {

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/changeLogModule.js

@@ -18,7 +18,7 @@ If no meaningful changes are present, return the text: "NO UPDATE".
 ${input.content}
 --- DIFF END ---
 `.trim();
-        const response = await generate({ content: prompt }, model);
+        const response = await generate({ content: prompt });
         // Check if we received a meaningful result or "NO UPDATE"
         const content = response?.content?.trim();
         if (content === 'NO UPDATE') {