scai 0.1.109 → 0.1.110

package/dist/CHANGELOG.md

@@ -171,4 +171,22 @@ Type handling with the module pipeline
 ## 2025-09-02
 
 • Added test configuration for project and generated tests
-• Add runTestsModule and repairTestsModule for testing pipeline
+• Add runTestsModule and repairTestsModule for testing pipeline
+
+## 2025-09-05
+
+• Enable execution of files as executable files in the scripts
+• Remove context failure if models not installed
+• Add ability to set global model
+
+## 2025-09-08
+
+### Requires DB reset ('scai db reset' followed by 'scai index start')
+
+1. Improved daemon batch processing by skipping missing files, classifying unknown file types, and persisting entities/tags in the database.
+2. Invoke kgModule in daemonBatch to build knowledge graphs after indexing.
+3. Improved data modeling and extraction logic for functions and classes in TypeScript files.
+4. Updated Edge/Table schema for better query performance.
+5. Update package-lock.json to caniuse-lite@1.0.30001741.
+6. Enable execution of  as an executable file in the scripts.
+7. Remove context failure if models not installed. Add ability to set global model.

package/dist/commands/DaemonCmd.js

@@ -23,9 +23,11 @@ export async function startDaemon() {
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = path.dirname(__filename);
     const daemonWorkerPath = path.join(__dirname, '../daemon/daemonWorker.js');
+    const out = fsSync.openSync(LOG_PATH, 'a');
+    const err = fsSync.openSync(LOG_PATH, 'a');
     const child = spawn(process.execPath, [daemonWorkerPath], {
         detached: true,
-        stdio: ['ignore', 'ignore', 'ignore'],
+        stdio: ['ignore', out, err], // stdout/stderr -> log file
         env: {
             ...process.env,
             BACKGROUND_MODE: 'true',

package/dist/config.js

@@ -6,7 +6,7 @@ import { normalizePath } from './utils/contentUtils.js';
 import chalk from 'chalk';
 import { getHashedRepoKey } from './utils/repoKey.js';
 const defaultConfig = {
-    model: 'codellama:13b',
+    model: 'llama3:8b',
     contextLength: 4096,
     language: 'ts',
     indexDir: '',
@@ -55,18 +55,23 @@ export const Config = {
         const repoCfg = cfg.repos?.[cfg.activeRepo ?? ''];
         return repoCfg?.model || cfg.model;
     },
-    setModel(model) {
+    setModel(model, scope = 'repo') {
         const cfg = readConfig();
-        const active = cfg.activeRepo;
-        if (active) {
+        if (scope === 'repo') {
+            const active = cfg.activeRepo;
+            if (!active) {
+                console.error("❌ No active repo to set model for.");
+                return;
+            }
             cfg.repos[active] = { ...cfg.repos[active], model };
-            writeConfig(cfg);
-            console.log(`📦 Model set to: ${model}`);
+            console.log(`📦 Model set for repo '${active}': ${model}`);
         }
         else {
-            writeConfig({ model });
-            console.log(`📦 Default model set to: ${model}`);
+            // Set global default model
+            cfg.model = model;
+            console.log(`📦 Global default model set to: ${model}`);
         }
+        writeConfig(cfg);
     },
     getLanguage() {
         const cfg = readConfig();

package/dist/context.js

@@ -5,12 +5,25 @@ import { getHashedRepoKey } from "./utils/repoKey.js";
 import { getDbForRepo, getDbPathForRepo } from "./db/client.js";
 import fs from "fs";
 import chalk from "chalk";
+import { execSync } from "child_process";
+function modelExists(model) {
+    try {
+        const output = execSync("ollama list", { encoding: "utf-8" });
+        return output
+            .split("\n")
+            .map(line => line.trim())
+            .filter(Boolean)
+            .some(line => line.toLowerCase().startsWith(model.toLowerCase() + " ") || line.toLowerCase() === model.toLowerCase());
+    }
+    catch (err) {
+        console.error(chalk.red("❌ Failed to check models with `ollama list`"));
+        return false;
+    }
+}
 export async function updateContext() {
     const cwd = normalizePath(process.cwd());
     const cfg = readConfig();
-    // 🔑 Find repoKey by matching indexDir to cwd
     let repoKey = Object.keys(cfg.repos || {}).find((key) => normalizePath(cfg.repos[key]?.indexDir || "") === cwd);
-    // Initialize new repo config if not found
     let isNewRepo = false;
     if (!repoKey) {
         repoKey = getHashedRepoKey(cwd);
@@ -19,28 +32,23 @@ export async function updateContext() {
         cfg.repos[repoKey].indexDir = cwd;
         isNewRepo = true;
     }
-    // Check if active repo has changed
     const activeRepoChanged = cfg.activeRepo !== repoKey;
-    // Always set this as active repo
     cfg.activeRepo = repoKey;
     writeConfig(cfg);
     const repoCfg = cfg.repos[repoKey];
     let ok = true;
-    // Only log detailed info if new repo or active repo changed
     if (isNewRepo || activeRepoChanged) {
         console.log(chalk.yellow("\n🔁 Updating context...\n"));
         console.log(`✅ Active repo: ${chalk.green(repoKey)}`);
         console.log(`✅ Index dir: ${chalk.cyan(repoCfg.indexDir || cwd)}`);
     }
-    // GitHub token is optional
     const token = repoCfg.githubToken || cfg.githubToken;
     if (!token) {
-        console.log(`ℹ️ No GitHub token found. You can set one with the: ${chalk.bold(chalk.bgGreen("scai auth set"))} command`);
+        console.log(`ℹ️ No GitHub token found. You can set one with: ${chalk.bold(chalk.bgGreen("scai auth set"))}`);
     }
     else if (isNewRepo || activeRepoChanged) {
         console.log(`✅ GitHub token present`);
     }
-    // Ensure DB exists
     const dbPath = getDbPathForRepo();
     if (!fs.existsSync(dbPath)) {
         console.log(chalk.yellow(`📦 Initializing DB at ${dbPath}`));
@@ -48,13 +56,31 @@ export async function updateContext() {
             getDbForRepo();
         }
         catch {
-            ok = false; // DB init failed
+            ok = false;
         }
     }
     else if (isNewRepo || activeRepoChanged) {
         console.log(chalk.green("✅ Database present"));
     }
-    // Final context status
+    // 🧠 Model check
+    const model = cfg.model;
+    if (!model) {
+        console.log(chalk.red("❌ No model configured.") +
+            "\n➡️ Set one with: " +
+            chalk.bold(chalk.bgGreen("scai config set-model <model>")));
+        ok = false;
+    }
+    else if (!modelExists(model)) {
+        console.log(chalk.red(`❌ Model '${model}' not installed in Ollama.`) +
+            "\n➡️ Install with: " +
+            chalk.bold(chalk.yellow(`ollama pull ${model}`)) +
+            " or choose another with: " +
+            chalk.bold(chalk.yellow("scai config set-model <model>")));
+        ok = false;
+    }
+    else {
+        console.log(chalk.green(`✅ Model '${model}' available`));
+    }
     if (ok) {
         console.log(chalk.bold.green("\n✅ Context OK\n"));
     }

package/dist/daemon/daemonBatch.js

@@ -1,4 +1,4 @@
-import { indexFunctionsForFile } from '../db/functionIndex.js';
+import { indexCodeForFile } from '../db/functionIndex.js';
 import fs from 'fs/promises';
 import fsSync from 'fs';
 import { generateEmbedding } from '../lib/generateEmbedding.js';
@@ -8,6 +8,7 @@ import { summaryModule } from '../pipeline/modules/summaryModule.js';
 import { classifyFile } from '../fileRules/classifyFile.js';
 import { getDbForRepo, getDbPathForRepo } from '../db/client.js';
 import { markFileAsSkippedByPath, selectUnprocessedFiles, updateFileWithSummaryAndEmbedding, } from '../db/sqlTemplates.js';
+import { kgModule } from '../pipeline/modules/kgModule.js';
 const MAX_FILES_PER_BATCH = 5;
 /**
  * Acquires a lock on the database to ensure that only one daemon batch
@@ -32,7 +33,6 @@ async function lockDb() {
  */
 export async function runDaemonBatch() {
     log('🟡 Starting daemon batch...');
-    // Selects up to MAX_FILES_PER_BATCH files that haven't been processed yet
     const db = getDbForRepo();
     const rows = db.prepare(selectUnprocessedFiles).all(MAX_FILES_PER_BATCH);
     if (rows.length === 0) {
@@ -42,13 +42,11 @@ export async function runDaemonBatch() {
     const release = await lockDb();
     for (const row of rows) {
         log(`📂 Processing file: ${row.path}`);
-        // Skip if file is missing from the file system
         if (!fsSync.existsSync(row.path)) {
             log(`⚠️ Skipped missing file: ${row.path}`);
             db.prepare(markFileAsSkippedByPath).run({ path: row.path });
             continue;
         }
-        // Skip if file is classified as something we don't process
         const classification = classifyFile(row.path);
         if (classification !== 'valid') {
             log(`⏭️ Skipping (${classification}): ${row.path}`);
@@ -57,24 +55,20 @@ export async function runDaemonBatch() {
         }
         try {
             const content = await fs.readFile(row.path, 'utf-8');
-            // Determine whether the file needs to be re-summarized
             const needsResummary = !row.summary ||
                 !row.indexed_at ||
                 (row.last_modified && new Date(row.last_modified) > new Date(row.indexed_at));
             if (needsResummary) {
                 log(`📝 Generating summary for ${row.path}...`);
-                // Generate a summary using the summary pipeline
                 const summaryResult = await summaryModule.run({ content, filepath: row.path });
                 const summary = summaryResult?.summary?.trim() || null;
                 let embedding = null;
-                // Generate an embedding from the summary (if present)
                 if (summary) {
                     const vector = await generateEmbedding(summary);
                     if (vector) {
                         embedding = JSON.stringify(vector);
                     }
                 }
-                // Update the file record with the new summary and embedding
                 db.prepare(updateFileWithSummaryAndEmbedding).run({
                     summary,
                     embedding,
@@ -85,19 +79,79 @@ export async function runDaemonBatch() {
             else {
                 log(`⚡ Skipped summary (up-to-date) for ${row.path}`);
             }
-            // Extract top-level functions from the file and update the DB
-            const extracted = await indexFunctionsForFile(row.path, row.id);
-            if (extracted) {
-                log(`✅ Function extraction complete for ${row.path}\n`);
+            const success = await indexCodeForFile(row.path, row.id);
+            if (success) {
+                log(`✅ Indexed code for ${row.path}`);
+                try {
+                    log(`🔗 Building Knowledge Graph for ${row.path}...`);
+                    const kgInput = {
+                        fileId: row.id,
+                        filepath: row.path,
+                        summary: row.summary || undefined,
+                    };
+                    const kgResult = await kgModule.run(kgInput, content);
+                    log(`✅ Knowledge Graph built for ${row.path}`);
+                    log(`Entities: ${kgResult.entities.length}, Edges: ${kgResult.edges.length}`);
+                    // Persist KG entities + tags only if there are any
+                    if (kgResult.entities.length > 0) {
+                        const insertTag = db.prepare(`
+    INSERT OR IGNORE INTO tags_master (name) VALUES (:name)
+  `);
+                        const getTagId = db.prepare(`
+    SELECT id FROM tags_master WHERE name = :name
+  `);
+                        const insertEntityTag = db.prepare(`
+    INSERT OR IGNORE INTO entity_tags (entity_type, entity_id, tag_id)
+    VALUES (:entity_type, :entity_id, :tag_id)
+  `);
+                        for (const entity of kgResult.entities) {
+                            // Skip entity if type or tags are missing
+                            if (!entity.type || !Array.isArray(entity.tags) || entity.tags.length === 0) {
+                                console.warn(`⚠ Skipping entity due to missing type or tags:`, entity);
+                                continue;
+                            }
+                            for (const tag of entity.tags) {
+                                // Skip empty or invalid tags
+                                if (!tag || typeof tag !== 'string') {
+                                    console.warn(`⚠ Skipping invalid tag for entity ${entity.type}:`, tag);
+                                    continue;
+                                }
+                                try {
+                                    // ✅ Use :name in SQL and plain key in object
+                                    insertTag.run({ name: tag });
+                                    const tagRow = getTagId.get({ name: tag });
+                                    if (!tagRow) {
+                                        console.warn(`⚠ Could not find tag ID for: ${tag}`);
+                                        continue;
+                                    }
+                                    insertEntityTag.run({
+                                        entity_type: entity.type,
+                                        entity_id: row.id,
+                                        tag_id: tagRow.id,
+                                    });
+                                }
+                                catch (err) {
+                                    console.error(`❌ Failed to persist entity/tag:`, { entity, tag, error: err });
+                                }
+                            }
+                        }
+                        log(`✅ Persisted entities + tags for ${row.path}`);
+                    }
+                    else {
+                        log(`⚠️ No entities found for ${row.path}, skipping DB inserts`);
+                    }
+                }
+                catch (kgErr) {
+                    log(`❌ KG build failed for ${row.path}: ${kgErr instanceof Error ? kgErr.message : String(kgErr)}`);
+                }
             }
             else {
-                log(`ℹ️ No functions extracted for ${row.path}\n`);
+                log(`ℹ️ No code elements extracted for ${row.path}`);
             }
         }
         catch (err) {
             log(`❌ Failed: ${row.path}: ${err instanceof Error ? err.message : String(err)}\n`);
         }
-        // Add a small delay to throttle processing
         await new Promise(resolve => setTimeout(resolve, 200));
     }
     await release();

package/dist/daemon/daemonWorker.js

@@ -31,9 +31,26 @@ export async function daemonWorker() {
     while (true) {
         try {
             log('🔄 Running daemon batch...');
-            const didWork = await runDaemonBatch();
+            // Wrap the batch in debug
+            let didWork = false;
+            try {
+                log('🔹 Running runDaemonBatch()...');
+                didWork = await runDaemonBatch();
+                log('✅ runDaemonBatch() completed successfully');
+            }
+            catch (batchErr) {
+                log('🔥 Error inside runDaemonBatch():', batchErr);
+            }
             if (!didWork) {
-                const queueEmpty = await isQueueEmpty();
+                let queueEmpty = false;
+                try {
+                    log('🔹 Checking if queue is empty...');
+                    queueEmpty = await isQueueEmpty();
+                    log(`🔹 Queue empty status: ${queueEmpty}`);
+                }
+                catch (queueErr) {
+                    log('🔥 Error checking queue status:', queueErr);
+                }
                 if (queueEmpty) {
                     log('🕊️ No work found. Idling...');
                     await sleep(IDLE_SLEEP_MS * 3);

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/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/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/scripts/dbcheck.js

@@ -224,3 +224,101 @@ const functionRows = db.prepare(`
   LIMIT 50
 `).all();
 console.table(functionRows);
+// === Class Table Stats ===
+console.log('\n📊 Stats for Table: classes');
+console.log('-------------------------------------------');
+try {
+    const classCount = db.prepare(`SELECT COUNT(*) AS count FROM classes`).get().count;
+    const distinctClassFiles = db.prepare(`SELECT COUNT(DISTINCT file_id) AS count FROM classes`).get().count;
+    console.log(`🏷 Total classes:           ${classCount}`);
+    console.log(`📂 Distinct files:          ${distinctClassFiles}`);
+}
+catch (err) {
+    console.error('❌ Error accessing classes table:', err.message);
+}
+// === Example Classes ===
+console.log('\n🧪 Example extracted classes:');
+try {
+    const sampleClasses = db.prepare(`
+    SELECT id, name, file_id, start_line, end_line, substr(content, 1, 100) || '...' AS short_body
+    FROM classes
+    ORDER BY id DESC
+    LIMIT 5
+  `).all();
+    sampleClasses.forEach(cls => {
+        console.log(`🏷 ID: ${cls.id}`);
+        console.log(`   Name: ${cls.name}`);
+        console.log(`   File: ${cls.file_id}`);
+        console.log(`   Lines: ${cls.start_line}-${cls.end_line}`);
+        console.log(`   Body: ${cls.short_body}\n`);
+    });
+}
+catch (err) {
+    console.error('❌ Error printing class examples:', err.message);
+}
+// === Edge Table Stats ===
+console.log('\n📊 Stats for Table: edges');
+console.log('-------------------------------------------');
+try {
+    const edgeCount = db.prepare(`SELECT COUNT(*) AS count FROM edges`).get().count;
+    const distinctRelations = db.prepare(`SELECT COUNT(DISTINCT relation) AS count FROM edges`).get().count;
+    console.log(`🔗 Total edges:             ${edgeCount}`);
+    console.log(`🧩 Distinct relations:      ${distinctRelations}`);
+}
+catch (err) {
+    console.error('❌ Error accessing edges table:', err.message);
+}
+// === Example Edges ===
+console.log('\n🧪 Example edges:');
+try {
+    const sampleEdges = db.prepare(`
+    SELECT id, source_id, target_id, relation
+    FROM edges
+    ORDER BY id DESC
+    LIMIT 10
+  `).all();
+    sampleEdges.forEach(e => {
+        console.log(`🔗 Edge ${e.id}: ${e.source_id} -[${e.relation}]-> ${e.target_id}`);
+    });
+}
+catch (err) {
+    console.error('❌ Error printing edge examples:', err.message);
+}
+// === Tags Master Stats ===
+console.log('\n📊 Stats for Table: tags_master');
+console.log('-------------------------------------------');
+try {
+    const tagCount = db.prepare(`SELECT COUNT(*) AS count FROM tags_master`).get().count;
+    console.log(`🏷 Total tags: ${tagCount}`);
+    const sampleTags = db.prepare(`
+    SELECT id, name
+    FROM tags_master
+    ORDER BY id DESC
+    LIMIT 5
+  `).all();
+    sampleTags.forEach(tag => {
+        console.log(`🏷 Tag ${tag.id}: ${tag.name}`);
+    });
+}
+catch (err) {
+    console.error('❌ Error accessing tags_master table:', err.message);
+}
+// === Entity Tags Stats ===
+console.log('\n📊 Stats for Table: entity_tags');
+console.log('-------------------------------------------');
+try {
+    const entityTagCount = db.prepare(`SELECT COUNT(*) AS count FROM entity_tags`).get().count;
+    console.log(`🔗 Total entity-tags: ${entityTagCount}`);
+    const sampleEntityTags = db.prepare(`
+    SELECT id, entity_type, entity_id, tag_id
+    FROM entity_tags
+    ORDER BY id DESC
+    LIMIT 10
+  `).all();
+    sampleEntityTags.forEach(et => {
+        console.log(`🔗 EntityTag ${et.id}: ${et.entity_type} ${et.entity_id} -> tag ${et.tag_id}`);
+    });
+}
+catch (err) {
+    console.error('❌ Error accessing entity_tags table:', err.message);
+}

package/dist/utils/log.js

@@ -1,5 +1,5 @@
+import { LOG_PATH } from "../constants.js";
 import fs from 'fs';
-import { LOG_PATH } from '../constants.js';
 export function log(...args) {
     const timestamp = new Date().toISOString();
     const message = args.map(arg => typeof arg === 'string' ? arg : JSON.stringify(arg, null, 2)).join(' ');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scai",
-  "version": "0.1.109",
+  "version": "0.1.110",
   "type": "module",
   "bin": {
     "scai": "./dist/index.js"
@@ -34,7 +34,7 @@
     "workflow"
   ],
   "scripts": {
-    "build": "rm -rfd dist && tsc && git add .",
+    "build": "rm -rfd dist && tsc && chmod +x dist/index.js && git add .",
     "start": "node dist/index.js"
   },
   "dependencies": {