scai 0.1.18 → 0.1.20

package/dist/commands/AskCmd.js

@@ -0,0 +1,66 @@
+import { searchFiles } from "../db/fileIndex.js";
+import { generate } from "../lib/generate.js";
+import { summaryModule } from "../pipeline/modules/summaryModule.js";
+export async function runAskCommand(query) {
+    if (!query) {
+        console.error('❌ Please provide a search query.\n👉 Usage: scai ask "keyword"');
+        return;
+    }
+    console.log(`🔍 Searching for: "${query}"\n`);
+    // Use vector-based search
+    const results = await searchFiles(query, 5); // Or 3 if you want fewer
+    if (results.length === 0) {
+        console.log('⚠️ No similar embeddings found. Asking the model for context instead...');
+    }
+    else {
+        console.log('📊 Closest files based on semantic similarity:');
+        results.forEach(file => {
+            console.log(`📄 Path: ${file?.path}`);
+        });
+    }
+    let allSummaries = '';
+    for (const file of results) {
+        try {
+            if (!file?.summary) {
+                console.warn(`⚠️ No summary available for file: ${file?.path}`);
+                continue;
+            }
+            console.log(`📝 Using cached summary for file: ${file?.path}`);
+            const summaryResponse = await summaryModule.run({ content: file?.summary ? file.summary : '', filepath: file?.path });
+            if (summaryResponse.summary) {
+                allSummaries += `\n${summaryResponse.summary}`;
+            }
+        }
+        catch (err) {
+            console.error(`❌ Error processing file: ${file?.path}`, err instanceof Error ? err.message : err);
+        }
+    }
+    if (allSummaries.trim()) {
+        console.log('🧠 Summaries found, sending them to the model for synthesis...');
+        try {
+            const input = {
+                content: `${query}\n\n${allSummaries}`,
+                filepath: '',
+            };
+            const modelResponse = await generate(input, 'llama3');
+            console.log(`\n📝 Model response:\n${modelResponse.content}`);
+        }
+        catch (err) {
+            console.error('❌ Model request failed:', err);
+        }
+    }
+    else {
+        console.log('⚠️ No summaries found. Asking the model for context only...');
+        try {
+            const input = {
+                content: query,
+                filepath: '',
+            };
+            const modelResponse = await generate(input, 'llama3');
+            console.log(`\n📝 Model response:\n${modelResponse.content}`);
+        }
+        catch (err) {
+            console.error('❌ Model request failed:', err);
+        }
+    }
+}

package/dist/commands/ChangeLogUpdateCmd.js

@@ -14,8 +14,8 @@ export async function handleChangelogUpdate() {
             console.log("⚠️  No staged or unstaged changes to include in changelog.");
             return;
         }
-        const result = await runModulePipeline([changelogModule], { code: diff });
-        if (!result.code.trim()) {
+        const result = await runModulePipeline([changelogModule], { content: diff });
+        if (!result.content.trim()) {
             console.log("✅ No significant changes for changelog.");
             return;
         }
@@ -29,7 +29,7 @@ export async function handleChangelogUpdate() {
             console.log("📄 Creating new CHANGELOG.md");
         }
         const today = new Date().toISOString().split("T")[0];
-        const newEntry = `\n\n## ${today}\n\n${result.code}`;
+        const newEntry = `\n\n## ${today}\n\n${result.content}`;
         await fs.writeFile(changelogPath, existing + newEntry, "utf-8");
         console.log("📝 CHANGELOG.md updated.");
     }

package/dist/commands/CommitSuggesterCmd.js

@@ -60,8 +60,8 @@ export async function suggestCommitMessage(options) {
             console.log('⚠️  No staged changes to suggest a message for.');
             return;
         }
-        const output = await commitSuggesterModule.run({ code: diff });
-        const suggestions = output.suggestions || [];
+        const response = await commitSuggesterModule.run({ content: diff });
+        const suggestions = response.suggestions || [];
         if (!suggestions.length) {
             console.log('⚠️  No commit suggestions generated.');
             return;
@@ -80,8 +80,8 @@ export async function suggestCommitMessage(options) {
             const choice = await askUserToChoose(suggestions);
             if (choice === 'regenerate') {
                 console.log('\n🔄 Regenerating suggestions...\n');
-                const out = await commitSuggesterModule.run({ code: diff });
-                suggestions.splice(0, suggestions.length, ...(out.suggestions || []));
+                const response = await commitSuggesterModule.run({ content: diff });
+                suggestions.splice(0, suggestions.length, ...(response.suggestions || []));
                 continue;
             }
             if (choice === 'custom') {

package/dist/commands/DaemonCmd.js

@@ -0,0 +1,80 @@
+import { summaryModule } from '../pipeline/modules/summaryModule.js';
+import { db } from '../db/client.js';
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import os from 'os';
+import path from 'path';
+import { generateEmbedding } from '../lib/generateEmbedding.js';
+import { IGNORED_EXTENSIONS } from '../config/IgnoredExtensions.js';
+const MAX_FILES = 1000;
+const DAEMON_DURATION_MINUTES = 25;
+const DAEMON_INTERVAL_MINUTES = 30;
+const PID_PATH = path.join(os.homedir(), '.scai/daemon.pid');
+// Helper function to check if a file should be ignored
+const shouldIgnoreFile = (filePath) => {
+    const ext = path.extname(filePath).toLowerCase();
+    return IGNORED_EXTENSIONS.includes(ext);
+};
+export async function runDaemonBatch() {
+    console.log('📥 Daemon batch: scanning for files to summarize...');
+    const rows = db.prepare(`
+    SELECT path, type FROM files
+    WHERE summary IS NULL OR summary = ''
+    ORDER BY last_modified DESC
+    LIMIT ?
+    `).all(MAX_FILES);
+    if (rows.length === 0) {
+        console.log('✅ No files left to summarize.');
+        return;
+    }
+    for (const row of rows) {
+        if (shouldIgnoreFile(row.path)) {
+            console.log(`⚠️ Ignored file (unwanted extension): ${row.path}`);
+            continue;
+        }
+        try {
+            const content = await fs.readFile(row.path, 'utf-8');
+            const result = await summaryModule.run({ content, filepath: row.path });
+            const summary = result?.summary?.trim() ? result.summary : null;
+            let embedding = null;
+            if (summary) {
+                const vector = await generateEmbedding(summary);
+                if (vector)
+                    embedding = JSON.stringify(vector);
+            }
+            // Using named parameters for better readability and flexibility
+            db.prepare(`
+                UPDATE files
+                SET summary = @summary, embedding = @embedding, indexed_at = datetime('now')
+                WHERE path = @path
+            `).run({ summary, embedding, path: row.path });
+            console.log(`📝 Summarized: ${row.path}`);
+            console.log(`🔢 Embedded: ${row.path}`);
+        }
+        catch (err) {
+            console.warn(`⚠️ Failed: ${row.path}`, err instanceof Error ? err.message : err);
+        }
+    }
+}
+export async function runDaemonScheduler() {
+    // Write PID to file
+    fsSync.mkdirSync(path.dirname(PID_PATH), { recursive: true });
+    fsSync.writeFileSync(PID_PATH, process.pid.toString(), 'utf-8');
+    console.log('🧠 Daemon started. PID:', process.pid);
+    console.log('⏱️ Will run every 30 minutes for 10 minutes.');
+    console.log('🧠 Background summarizer started. Will run every 30 minutes for 10 minutes.');
+    const startDaemonCycle = async () => {
+        const startTime = Date.now();
+        const endTime = startTime + DAEMON_DURATION_MINUTES * 60 * 1000;
+        while (Date.now() < endTime) {
+            await runDaemonBatch();
+            await new Promise(res => setTimeout(res, 60 * 1000)); // 1 min pause between mini-batches
+        }
+        console.log(`⏱️ Daemon completed 10-minute cycle. Next in ${DAEMON_INTERVAL_MINUTES} min.`);
+    };
+    // Repeat every 30 minutes
+    while (true) {
+        await startDaemonCycle();
+        await new Promise(res => setTimeout(res, DAEMON_INTERVAL_MINUTES * 60 * 1000));
+    }
+}

package/dist/commands/IndexCmd.js

@@ -1,45 +1,44 @@
 import fg from 'fast-glob';
 import path from 'path';
-import { ModelConfig } from '../config/ModelConfig.js';
 import { initSchema } from '../db/schema.js';
 import { indexFile } from '../db/fileIndex.js';
-import { getSummary } from '../utils/getSummary.js';
-import { EXTENSIONS_BY_LANG } from '../utils/languageConfig.js';
+import { shouldIgnoreFile } from '../utils/shouldIgnoreFiles.js';
+import { detectFileType } from '../utils/detectFileType.js';
+import { runDaemonScheduler } from './DaemonCmd.js';
+import { IGNORED_FOLDER_GLOBS } from '../config/IgnoredPaths.js';
 const IGNORE = [
-    '**/node_modules/**',
-    '**/dist/**',
-    '**/build/**',
-    '**/coverage/**',
-    '**/.git/**',
-    '**/*.test.*'
+    '**/node_modules/**', '**/dist/**', '**/build/**',
+    '**/coverage/**', '**/.git/**', '**/*.test.*'
 ];
-export async function runIndexCommand(targetDir = process.cwd()) {
+export async function runIndexCommand(targetDir = process.cwd(), options = {}) {
     console.log(`📂 Indexing files in: ${targetDir}`);
     initSchema();
-    const lang = ModelConfig.getLanguage();
-    const exts = EXTENSIONS_BY_LANG[lang] || ['.txt'];
-    const patterns = exts.map(ext => `**/*${ext}`);
-    const files = await fg(patterns, {
+    const files = await fg('**/*.*', {
         cwd: targetDir,
-        ignore: IGNORE,
+        ignore: IGNORED_FOLDER_GLOBS,
         absolute: true,
     });
-    // Count file extensions (diagnostic)
     const countByExt = {};
-    files.forEach(file => {
-        const ext = path.extname(file);
-        countByExt[ext] = (countByExt[ext] || 0) + 1;
-    });
-    console.log('📊 Indexed files by extension:', countByExt);
+    let count = 0;
     for (const file of files) {
+        if (shouldIgnoreFile(file))
+            continue;
         try {
-            const summary = getSummary(file, lang);
-            indexFile(file, summary, lang);
+            const type = detectFileType(file);
+            indexFile(file, null, type); // empty summary for now
+            const ext = path.extname(file);
+            countByExt[ext] = (countByExt[ext] || 0) + 1;
             console.log(`📄 Indexed: ${path.relative(targetDir, file)}`);
+            count++;
         }
         catch (err) {
             console.warn(`⚠️ Skipped ${file}:`, err instanceof Error ? err.message : err);
         }
     }
-    console.log(`✅ Done. Indexed ${files.length} files.`);
+    console.log('📊 Indexed files by extension:', countByExt);
+    console.log(`✅ Done. Indexed ${count} files.`);
+    if (options.detached) {
+        console.log('🚀 Starting summarizer daemon in background mode...');
+        runDaemonScheduler(); // Infinite loop every 30 min
+    }
 }

package/dist/commands/ModulePipelineCmd.js

@@ -16,7 +16,7 @@ export async function runModulePipelineFromCLI(file, options) {
         console.error(`❌ Could not read file: ${file}`);
         process.exit(1);
     }
-    const input = { code: fileContent, filepath: file };
+    const input = { content: fileContent, filepath: file };
     // Retrieve modules from the registry
     const resolvedModules = moduleNames.map((name) => {
         const module = getModuleByName(name);

package/dist/commands/QueryCmd.js

@@ -0,0 +1,20 @@
+import { queryFiles } from '../db/fileIndex.js';
+import path from 'path';
+export async function runQueryCommand(query) {
+    if (!query) {
+        console.error('❌ Please provide a search query.\n👉 Usage: scai query "keyword"');
+        return;
+    }
+    console.log(`🔍 Searching for: "${query}"\n`);
+    const results = queryFiles(query);
+    if (results.length === 0) {
+        console.log('⚠️ No matching files found.');
+        return;
+    }
+    results.forEach((result, index) => {
+        console.log(`📄 [${index + 1}] ${path.relative(process.cwd(), result.path)}`);
+        console.log(`   📝 ${result.summary}`);
+        console.log();
+    });
+    console.log(`✅ Found ${results.length} result(s).`);
+}

package/dist/commands/RefactorCmd.js

@@ -25,17 +25,17 @@ export async function handleRefactor(filepath, options = {}) {
             return;
         }
         // Read source code
-        const originalCode = await fs.readFile(filepath, 'utf-8');
+        const content = await fs.readFile(filepath, 'utf-8');
         // Run through pipeline modules
-        const refactored = await runModulePipeline([addCommentsModule, cleanupModule], { code: originalCode });
-        if (!refactored.code.trim())
+        const response = await runModulePipeline([addCommentsModule, cleanupModule], { content });
+        if (!response.content.trim())
             throw new Error('⚠️ Model returned empty result');
         // Save refactored output
-        await fs.writeFile(refactoredPath, refactored.code, 'utf-8');
+        await fs.writeFile(refactoredPath, response.content, 'utf-8');
         console.log(`✅ Refactored code saved to: ${refactoredPath}`);
         console.log(`ℹ️ Run again with '--apply' to overwrite the original.`);
     }
     catch (err) {
-        console.error('❌ Error in refactor command:', err.message);
+        console.error('❌ Error in refactor command:', err instanceof Error ? err.message : err);
     }
 }

package/dist/commands/StopDaemonCmd.js

@@ -0,0 +1,23 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+const PID_PATH = path.join(os.homedir(), '.scai/daemon.pid');
+export async function runStopDaemonCommand() {
+    if (!fs.existsSync(PID_PATH)) {
+        console.log('🛑 No daemon is currently running.');
+        return;
+    }
+    const pid = parseInt(fs.readFileSync(PID_PATH, 'utf-8'), 10);
+    if (isNaN(pid)) {
+        console.error('⚠️ Invalid PID file.');
+        return;
+    }
+    try {
+        process.kill(pid);
+        fs.unlinkSync(PID_PATH);
+        console.log(`✅ Daemon process ${pid} stopped.`);
+    }
+    catch (err) {
+        console.error(`❌ Failed to stop process ${pid}:`, err instanceof Error ? err.message : err);
+    }
+}

package/dist/commands/SummaryCmd.js

@@ -3,10 +3,10 @@ import readline from 'readline';
 import { summaryModule } from '../pipeline/modules/summaryModule.js'; // Import summaryModule
 import { summarizeCode } from '../utils/summarizer.js'; // Import summarizeCode
 export async function summarizeFile(filepath) {
-    let code = '';
+    let content = '';
     if (filepath) {
         try {
-            code = await fs.readFile(filepath, 'utf-8');
+            content = await fs.readFile(filepath, 'utf-8');
         }
         catch (err) {
             console.error(`❌ Could not read or summarize ${filepath}:`, err.message);
@@ -24,14 +24,18 @@ export async function summarizeFile(filepath) {
             terminal: false,
         });
         for await (const line of rl) {
-            code += line + '\n';
+            content += line + '\n';
         }
     }
-    if (code.trim()) {
+    if (content.trim()) {
         // Call the summary module to get the raw summary
-        const summary = await summaryModule.run({ code, filepath });
+        const response = await summaryModule.run({ content, filepath });
         // Pass the summary text to the utility function for formatting
-        const formattedSummary = summarizeCode(summary.code);
+        if (!response.summary) {
+            console.warn("No summary available.");
+            return;
+        }
+        const formattedSummary = summarizeCode(response.summary);
         console.log(formattedSummary);
     }
     else {

package/dist/commands/TestGenCmd.js

@@ -4,8 +4,8 @@ import { cleanupModule } from '../pipeline/modules/cleanupModule.js';
 import { runModulePipeline } from '../pipeline/runModulePipeline.js';
 export async function generateTests(filepath) {
     try {
-        const code = await fs.readFile(filepath, 'utf-8');
-        const result = await runModulePipeline([generateTestsModule, cleanupModule], { code, filepath });
+        const content = await fs.readFile(filepath, 'utf-8');
+        const result = await runModulePipeline([generateTestsModule, cleanupModule], { content, filepath });
         console.log('✅ Test generated and cleaned up.');
     }
     catch (err) {

package/dist/config/IgnoredExtensions.js

@@ -0,0 +1,46 @@
+// src/config/IgnoredExtensions.ts
+export const IGNORED_EXTENSIONS = [
+    // 🖼 Media
+    '.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.ico',
+    '.mp4', '.mp3', '.mov', '.avi', '.mkv', '.flv', '.wav', '.flac',
+    '.aac', '.m4a', '.wma', '.3gp', '.webm', '.ogg', '.aiff', '.au',
+    // 📦 Archives & install packages
+    '.zip', '.tar', '.gz', '.bz2', '.xz', '.rar', '.7z',
+    '.jar', '.war', '.ear', '.deb', '.rpm', '.pkg', '.msi', '.dmg', '.cab', '.apk',
+    '.tar.gz', '.tar.bz2', '.tar.xz', '.tar.lzma', '.tar.zst',
+    // 🧱 Binaries & executables
+    '.exe', '.dll', '.bin', '.so', '.dylib', '.a', '.lib',
+    '.iso', '.img', '.elf', '.o', '.obj', '.msm', '.vbs', '.jscript',
+    '.cmd', '.bat', '.ps1', '.sh', '.bash', '.run',
+    // 🧪 Runtime / build / cache
+    '.log', '.tmp', '.map',
+    '.db', '.sqlite', '.pkl', '.sav', '.rdb', '.ldb',
+    '.pyc', '.class', '.tsbuildinfo', '.coverage', '.eslintcache',
+    '.yarn', '.webpack', '.babel', '.compilercache',
+    // 🔤 Fonts & styles
+    '.woff', '.woff2', '.ttf', '.eot', '.otf', '.css.map',
+    '.scss', '.sass', '.less', '.styl',
+    // 🔐 Certs, keys, credentials
+    '.crt', '.key', '.pem', '.pub', '.asc', '.gpg', '.p12', '.csr', '.der', '.pfx',
+    // ♻️ Backups / temp
+    '.bak', '.old', '.swp', '.swo', '.orig',
+    '.sublime-workspace', '.sublime-project', '.db-shm', '.db-wal',
+    // 🌐 System/config folders (still ignored by path, not extension)
+    '.DS_Store', '.bundle', '.npmrc',
+    // 🗺️ GIS / Geospatial
+    '.shp', '.shx', '.dbf', '.prj', '.qix', '.sbn', '.sbx', '.shp.xml', '.cpg', '.gpkg', '.mif', '.mid',
+    // 📊 Enterprise BI / Reporting
+    '.pbix', '.rdl', '.rpt', '.bqy', '.iqy',
+    // 🧪 ETL / DWH / Modeling
+    '.abf', '.dtsx', '.bim', '.xmi',
+    // 🏗️ CAD / Engineering
+    '.dwg', '.dxf', '.step', '.stp', '.sldprt', '.sldasm',
+    '.iges', '.igs', '.3ds', '.fbx',
+    // 🧾 Forms / Print / Publishing
+    '.xps', '.afpub', '.pub', '.indd', '.qxd', '.frm', '.frx', '.frl',
+    // 💰 ERP / Finance / Legacy DB
+    '.mbd', '.fdb', '.nav', '.accdb', '.mdb', '.gdb',
+    '.sap', '.sappkg', '.qbw', '.qbb',
+    // 🔒 Lock files (but NOT lock *configs*)
+    '.lck', '.lockfile', '.db-lock', '.pid', '.socket',
+];

package/dist/config/IgnoredPaths.js

@@ -0,0 +1,45 @@
+// List of folders and file globs to ignore during indexing and scanning.
+// These patterns are used by fast-glob in all commands.
+export const IGNORED_FOLDER_GLOBS = [
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/target/**',
+    '**/coverage/**',
+    '**/.git/**',
+    '**/.next/**',
+    '**/.vercel/**',
+    '**/.idea/**',
+    '**/.vscode/**',
+    '**/__pycache__/**',
+    '**/.venv/**',
+    '**/env/**',
+    '**/.gradle/**',
+    '**/.output/**',
+    '**/tmp/**',
+    '**/*.test.*',
+    '**/.m2/**',
+    '**/.gradle/**',
+    '**/.tox/**',
+    '**/.nox/**',
+    '**/.hypothesis/**',
+    '**/.npm/**',
+    '**/.yarn/**',
+    '**/*.o',
+    '**/*.out',
+    '**/*.exe',
+    '**/*.dll',
+    '**/.cache/**',
+    '**/.pylint.d/**',
+    '**/.eslintcache/**',
+    '**/.cache-loader/**',
+    '**/.serverless/**',
+    '**/.docker/**',
+    '**/.sublime-workspace',
+    '**/.sublime-project',
+    '**/*.log',
+    '**/npm-debug.log',
+    '**/yarn-error.log',
+    '**/debug.log',
+    '**/Dockerfile',
+];

package/dist/config/ModelConfig.js

@@ -19,5 +19,5 @@ export class ModelConfig {
         console.log(`   Language: ${this.language}`);
     }
 }
-ModelConfig.model = 'codellama:7b';
+ModelConfig.model = 'llama3';
 ModelConfig.language = 'ts';

package/dist/db/fileIndex.js

@@ -1,18 +1,114 @@
+// File: src/db/fileIndex.ts
 import { db } from './client.js';
-export function indexFile(filePath, summary, lang) {
-    const insertStmt = db.prepare(`
-    INSERT OR REPLACE INTO files (path, summary, lang, indexed_at)
-    VALUES (?, ?, ?, datetime('now'))
-  `);
-    insertStmt.run(filePath, summary, lang);
+import fs from 'fs';
+import { generateEmbedding } from '../lib/generateEmbedding.js';
+import * as sqlTemplates from './sqlTemplates.js'; // Import the SQL templates
+export function indexFile(filePath, summary, type) {
+    const stats = fs.statSync(filePath);
+    const lastModified = stats.mtime.toISOString();
+    // 1) INSERT new rows (only when path not present)
+    const insertStmt = db.prepare(sqlTemplates.insertFileTemplate);
+    insertStmt.run({ path: filePath, summary, type, lastModified });
+    // 2) UPDATE metadata if file already existed and changed
+    const updateStmt = db.prepare(sqlTemplates.updateFileTemplate);
+    updateStmt.run({ path: filePath, type, lastModified });
+    // Step 1: Delete from FTS where the path matches
+    db.prepare(sqlTemplates.deleteFromFtsTemplate).run({ path: filePath });
+    // Step 2: Insert into FTS with the same id
+    db.prepare(sqlTemplates.insertIntoFtsTemplate).run({ path: filePath, summary });
 }
-export function searchFiles(query, limit = 10) {
-    const stmt = db.prepare(`
-    SELECT path, summary FROM files
-    WHERE path LIKE ? OR summary LIKE ?
-    ORDER BY indexed_at DESC
-    LIMIT ?
-  `);
-    const wildcard = `%${query}%`;
-    return stmt.all(wildcard, wildcard, limit);
+export function queryFiles(query, limit = 3) {
+    // Sanitize the query by removing or escaping special characters
+    const safeQuery = query
+        .trim()
+        .split(/\s+/)
+        .map(token => {
+        token = token
+            .replace(/[?*\\"]/g, '') // Remove question marks, asterisks, backslashes, and double quotes
+            .replace(/'/g, "''"); // Escape single quotes for SQL safety
+        // For multi-word queries, wrap the token in quotes for exact phrase matching
+        if (token.includes(' ')) {
+            return `"${token}"`; // Exact phrase match for multi-word tokens
+        }
+        return `${token}*`; // Prefix match for single tokens
+    })
+        .join(' OR ');
+    // Log the constructed query for debugging purposes
+    console.log(`Executing search query: ${safeQuery}`);
+    // Execute the query with safeQuery and limit as parameters
+    const sql = `
+    SELECT f.path, f.summary, f.type, f.last_modified, f.indexed_at,
+           bm25(files_fts) AS rank
+    FROM files_fts
+    JOIN files f ON files_fts.rowid = f.id
+    WHERE files_fts MATCH :query
+    ORDER BY rank
+    LIMIT :limit
+  `;
+    const results = db.prepare(sql).all({ query: safeQuery, limit });
+    return results;
+}
+export function cosineSimilarity(a, b) {
+    const dot = a.reduce((sum, ai, i) => sum + ai * b[i], 0);
+    const magA = Math.sqrt(a.reduce((sum, ai) => sum + ai * ai, 0));
+    const magB = Math.sqrt(b.reduce((sum, bi) => sum + bi * bi, 0));
+    return dot / (magA * magB);
+}
+export async function searchFiles(query, topK = 5) {
+    // Generate the query embedding
+    const embedding = await generateEmbedding(query);
+    if (!embedding)
+        return [];
+    // Sanitize the query by removing or escaping special characters
+    const safeQuery = query
+        .trim()
+        .split(/\s+/)
+        .map(token => {
+        token = token
+            .replace(/[?*\\"]/g, '') // Remove question marks, asterisks, backslashes, and double quotes
+            .replace(/'/g, "''"); // Escape single quotes for SQL safety
+        // For multi-word queries, wrap the token in quotes for exact phrase matching
+        if (token.includes(' ')) {
+            return `"${token}"`; // Exact phrase match for multi-word tokens
+        }
+        return `${token}*`; // Prefix match for single tokens
+    })
+        .join(' OR ');
+    // Log the constructed query for debugging purposes
+    console.log(`Executing search query: ${safeQuery}`);
+    // Fetch BM25 scores from the FTS using the safeQuery string directly
+    const ftsResults = db.prepare(sqlTemplates.fetchBm25ScoresTemplate).all({ query: safeQuery });
+    const bm25Min = Math.min(...ftsResults.map(r => r.bm25Score));
+    const bm25Max = Math.max(...ftsResults.map(r => r.bm25Score));
+    // Calculate final score combining BM25 and cosine similarity
+    const scored = ftsResults.map(result => {
+        try {
+            // Fetch embedding for each file from the `files` table
+            const embResult = db.prepare(sqlTemplates.fetchEmbeddingTemplate).get({ path: result.path });
+            // Check if embedding exists and has the correct structure
+            if (!embResult || typeof embResult.embedding !== 'string')
+                return null;
+            // Parse the embedding
+            const vector = JSON.parse(embResult.embedding);
+            const sim = cosineSimilarity(embedding, vector);
+            // Normalize BM25 scores
+            const normalizedBm25 = 1 - ((result.bm25Score - bm25Min) / (bm25Max - bm25Min + 1e-5));
+            const normalizedSim = sim; // cosineSimilarity is already 0–1
+            const finalScore = 0.7 * normalizedSim + 0.3 * normalizedBm25;
+            return {
+                path: result.path,
+                summary: result.summary,
+                score: finalScore,
+                sim: normalizedSim,
+                bm25: normalizedBm25
+            };
+        }
+        catch (err) {
+            console.error(`Error processing embedding for file: ${result.path}`, err);
+            return null;
+        }
+    }).filter(Boolean)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, topK);
+    return scored;
 }

package/dist/db/schema.js

@@ -1,13 +1,19 @@
-import { db } from './client.js';
+import { db } from "./client.js";
 export function initSchema() {
     db.exec(`
     CREATE TABLE IF NOT EXISTS files (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       path TEXT UNIQUE,
       summary TEXT,
-      lang TEXT,
-      indexed_at TEXT
+      type TEXT,
+      indexed_at TEXT,
+      last_modified TEXT,
+      embedding TEXT
     );
+
+    -- FTS5 table for fast full‑text search of summaries and paths
+    CREATE VIRTUAL TABLE IF NOT EXISTS files_fts
+    USING fts5(path, summary, content='');
   `);
     console.log('✅ SQLite schema initialized');
 }

package/dist/db/sqlTemplates.js

@@ -0,0 +1,37 @@
+// Template for inserting or ignoring new file entries
+export const insertFileTemplate = `
+  INSERT OR IGNORE INTO files
+    (path, summary, type, indexed_at, last_modified)
+  VALUES (:path, :summary, :type, datetime('now'), :lastModified)
+`;
+// Template for updating file metadata if it has changed
+export const updateFileTemplate = `
+  UPDATE files
+  SET type = :type,
+      last_modified = :lastModified,
+      indexed_at = datetime('now')
+  WHERE path = :path
+    AND last_modified != :lastModified
+`;
+// Template for deleting a file from FTS
+export const deleteFromFtsTemplate = `
+  DELETE FROM files_fts
+  WHERE rowid = (SELECT id FROM files WHERE path = :path)
+`;
+// Template for inserting a file into FTS with its ID
+export const insertIntoFtsTemplate = `
+  INSERT INTO files_fts(rowid, path, summary)
+  VALUES((SELECT id FROM files WHERE path = :path), :path, :summary)
+`;
+// Template for fetching BM25 scores from FTS
+export const fetchBm25ScoresTemplate = `
+  SELECT f.path, f.summary, f.type, bm25(files_fts) AS bm25Score
+  FROM files_fts
+  JOIN files f ON files_fts.rowid = f.id
+  WHERE files_fts MATCH :query
+  LIMIT 50
+`;
+// Template for fetching embedding for a specific file
+export const fetchEmbeddingTemplate = `
+  SELECT embedding FROM files WHERE path = :path
+`;

package/dist/index.js

@@ -17,6 +17,10 @@ import { handleChangelogUpdate } from './commands/ChangeLogUpdateCmd.js';
 import { runModulePipelineFromCLI } from './commands/ModulePipelineCmd.js';
 import { runIndexCommand } from './commands/IndexCmd.js';
 import { resetDatabase } from './commands/ResetDbCmd.js';
+import { runQueryCommand } from './commands/QueryCmd.js';
+import { runDaemonBatch } from './commands/DaemonCmd.js';
+import { runStopDaemonCommand } from "./commands/StopDaemonCmd.js";
+import { runAskCommand } from './commands/AskCmd.js';
 // Create the CLI instance
 const cmd = new Command('scai')
     .version(version)
@@ -68,16 +72,39 @@ cmd
     .action(() => {
     ModelConfig.logCurrentConfig();
 });
+cmd
+    .command('daemon')
+    .description('Run background summarization of indexed files')
+    .action(runDaemonBatch);
+cmd
+    .command('stop-daemon')
+    .description('Stop the background summarizer daemon')
+    .action(runStopDaemonCommand);
 cmd
     .command('index [targetDir]')
     .description('Index supported files in the given directory (or current folder if none)')
-    .action((targetDir) => {
-    runIndexCommand(targetDir);
+    .option('-d, --detached', 'Run summarizer daemon after indexing')
+    .action((targetDir, options) => {
+    runIndexCommand(targetDir, { detached: options.detached });
+});
+cmd
+    .command('query <query>')
+    .description('Search indexed files by keyword')
+    .action(runQueryCommand);
+// Command structure using Commander
+cmd
+    .command('ask')
+    .description('Ask a question using file summaries and a local model')
+    .argument('<question...>', 'The question to ask')
+    .action((question) => {
+    const q = question.join(' ');
+    runAskCommand(q); // No model option, just pass the question
 });
 cmd
     .command('reset-db')
     .description('Delete and reset the SQLite database')
     .action(() => resetDatabase());
+// Default
 cmd
     .arguments('<file>')
     .option('-m, --modules <modules>', 'Comma-separated list of modules to run (e.g., comments,cleanup,summary)')

package/dist/lib/generate.js

@@ -1,5 +1,6 @@
+// File: lib/generate.ts
 import ora from 'ora';
-export async function generate(prompt, model) {
+export async function generate(input, model) {
     const spinner = ora(`🧠 Thinking with ${model}...`).start();
     try {
         const res = await fetch('http://localhost:11434/api/generate', {
@@ -7,16 +8,21 @@ export async function generate(prompt, model) {
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({
                 model,
-                prompt,
+                prompt: input.content,
                 stream: false,
             }),
         });
         const data = await res.json();
         spinner.succeed('✅ Model response received.');
-        return data.response?.trim() ?? '';
+        process.stdout.write('\n'); // ✅ Prevents terminal suppression bug
+        return {
+            content: data.response?.trim() ?? '',
+            filepath: input.filepath,
+        };
     }
     catch (err) {
         spinner.fail('❌ Model request failed.');
+        process.stdout.write('\n'); // In case of error flush output too
         throw err;
     }
 }

package/dist/lib/generateEmbedding.js

@@ -0,0 +1,22 @@
+export async function generateEmbedding(text) {
+    try {
+        const res = await fetch('http://localhost:11434/api/embeddings', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: 'mistral', // or 'llama3' — whatever works best
+                prompt: text,
+            }),
+        });
+        if (!res.ok) {
+            console.error('❌ Failed to generate embedding:', await res.text());
+            return null;
+        }
+        const data = await res.json();
+        return data.embedding;
+    }
+    catch (err) {
+        console.error('❌ Embedding error:', err instanceof Error ? err.message : err);
+        return null;
+    }
+}

package/dist/pipeline/modules/changeLogModule.js

@@ -9,13 +9,27 @@ export const changelogModule = {
 You're an experienced changelog writer. Based on this Git diff, write a markdown bullet-point entry suitable for CHANGELOG.md:
 
 --- DIFF START ---
-${input.code}
+${input.content}
 --- DIFF END ---
 
 ✅ If the changes are significant, return a changelog entry.
 ❌ If not, return ONLY: "NO UPDATE".
     `.trim();
-        const output = await generate(prompt, model);
-        return { code: output === 'NO UPDATE' ? '' : output };
+        const response = await generate({ content: prompt }, model);
+        const summary = response?.summary?.trim();
+        if (!summary || summary === 'NO UPDATE') {
+            // Return an empty summary and empty suggestions if there is no update.
+            return { content: response.content,
+                summary,
+                suggestions: response?.suggestions ?? [],
+                filepath: input.filepath };
+        }
+        // Return the actual changelog summary and any suggestions
+        return {
+            content: response.content,
+            summary,
+            suggestions: response?.suggestions ?? [],
+            filepath: input.filepath,
+        };
     },
 };

package/dist/pipeline/modules/cleanupModule.js

@@ -15,8 +15,8 @@ function isNaturalLanguageNoise(line) {
 export const cleanupModule = {
     name: 'cleanup',
     description: 'Remove markdown fences and natural language noise from top/bottom of code',
-    async run({ code }) {
-        let lines = code.trim().split('\n');
+    async run({ content }) {
+        let lines = content.trim().split('\n');
         // ───── Clean top ─────
         while (lines.length) {
             const line = lines[0].trim();
@@ -37,6 +37,6 @@ export const cleanupModule = {
                 break;
             }
         }
-        return { code: lines.join('\n').trim() };
+        return { content: lines.join('\n').trim() };
     }
 };

package/dist/pipeline/modules/commentModule.js

@@ -19,10 +19,10 @@ Your task is to add clear and insightful single-line comments to the code.
 - The code should be valid ${lang.toUpperCase()} after your changes.
 
 --- CODE START ---
-${input.code}
+${input.content}
 --- CODE END ---
 `.trim();
-        const output = await generate(prompt, model);
-        return { code: output === 'NO UPDATE' ? '' : output };
+        const response = await generate({ content: prompt }, model);
+        return { content: response.content === 'NO UPDATE' ? '' : response.content };
     },
 };

package/dist/pipeline/modules/commitSuggesterModule.js

@@ -3,7 +3,7 @@ import { ModelConfig } from '../../config/ModelConfig.js';
 export const commitSuggesterModule = {
     name: 'commitSuggester',
     description: 'Suggests conventional commit messages from Git diff',
-    async run({ code }) {
+    async run({ content }) {
         const model = ModelConfig.getModel();
         const prompt = `
 Suggest ALWAYS 3 concise, conventional Git commit messages based on the input code diff.
@@ -14,16 +14,16 @@ Use this format ONLY:
 3. refactor: ...
 
 Here is the diff:
-${code}
+${content}
 `.trim();
-        const raw = await generate(prompt, model);
-        const lines = raw
+        const response = await generate({ content: prompt }, model);
+        const lines = response.content
             .split('\n')
             .map(line => line.trim())
             .filter(line => /^\d+\.\s+/.test(line));
         const suggestions = lines.map(line => line.replace(/^\d+\.\s+/, '').replace(/^"(.*)"$/, '$1').trim());
         return {
-            code,
+            content,
             suggestions
         };
     }

package/dist/pipeline/modules/generateTestsModule.js

@@ -6,7 +6,7 @@ import { generate } from '../../lib/generate.js';
 export const generateTestsModule = {
     name: 'generateTests',
     description: 'Generate a Jest test file for the class/module',
-    async run({ code, filepath }) {
+    async run({ content, filepath }) {
         const model = ModelConfig.getModel();
         const lang = ModelConfig.getLanguage();
         if (!filepath)
@@ -21,16 +21,16 @@ Guidelines:
 - Only return valid TypeScript code
 
 --- CODE START ---
-${code}
+${content}
 --- CODE END ---
     `.trim();
-        const testCode = await generate(prompt, model);
-        if (!testCode)
+        const response = await generate({ content: prompt }, model);
+        if (!response)
             throw new Error('⚠️ No test code returned from model');
         const { dir, name } = path.parse(filepath);
         const testPath = path.join(dir, `${name}.test.ts`);
-        await fs.writeFile(testPath, testCode, 'utf-8');
+        await fs.writeFile(testPath, response.content, 'utf-8');
         console.log(`✅ Test file saved to: ${testPath}`);
-        return { code, filepath }; // unchanged input
+        return { content, filepath }; // unchanged input
     }
 };

package/dist/pipeline/modules/refactorModule.js

@@ -16,13 +16,13 @@ Refactor the following code:
 - Output the full, valid ${lang.toUpperCase()} code
 
 --- CODE START ---
-${input.code}
+${input.content}
 --- CODE END ---
     `.trim();
-        const response = await generate(prompt, model);
+        const response = await generate({ content: prompt }, model);
         if (!response) {
             throw new Error('❌ Model returned empty response for refactoring.');
         }
-        return { code: response };
+        return { content: response.content };
     }
 };

package/dist/pipeline/modules/summaryModule.js

@@ -1,64 +1,43 @@
 import { ModelConfig } from '../../config/ModelConfig.js';
 import { generate } from '../../lib/generate.js';
-import fs from 'fs/promises';
 import path from 'path';
 export const summaryModule = {
     name: 'summary',
-    description: 'Prints a summary of changes to the terminal',
-    async run({ code, filepath }) {
+    description: 'Generates a general summary of any file content.',
+    run: async ({ content, filepath }) => {
         const model = ModelConfig.getModel();
-        const lang = ModelConfig.getLanguage();
-        let contextString = '';
-        // Try to load and filter the flat context
-        try {
-            const raw = await fs.readFile('./.scai/context.flat.json', 'utf-8');
-            const flatContext = JSON.parse(raw);
-            if (filepath) {
-                const dir = path.dirname(filepath).replace(/\\/g, '/'); // Normalize slashes
-                console.log("Dir: ", dir);
-                const contextSubset = Object.entries(flatContext)
-                    .filter(([file]) => file.startsWith(dir))
-                    .slice(0, 10); // limit if needed
-                if (contextSubset.length) {
-                    contextString = '📁 Local Context:\n' + contextSubset
-                        .map(([file, summary]) => `- ${file}: ${summary}`)
-                        .join('\n');
-                    console.log("Context string input to prompt: ", contextString);
-                }
-            }
-        }
-        catch (err) {
-            console.warn('⚠️ Context file not found or failed to parse.');
-        }
+        const ext = filepath ? path.extname(filepath).toLowerCase() : '';
+        const filename = filepath ? path.basename(filepath) : '';
+        // More neutral prompt for general-purpose content
         const prompt = `
-You are a senior ${lang.toUpperCase()} engineer.
-
-Project Overview:
-${contextString ? contextString + '\n\n' : ''}
+You are an assistant specialized in summarizing files.
 
-Take the following source code and do NOT modify it in any way. Your task is:
+Your task is to summarize the contents of the following file as clearly and concisely as possible.
 
-// Summary of code:
-// - [What the code does at a high level]
-// - [Main features or components]
-// - [Any interesting logic or patterns]
+File: ${filename}
+Extension: ${ext}
 
-⚠️ IMPORTANT:
-- Do NOT include the original code in your summary
-- Remove the original code from you output
+📋 Instructions:
+- Identify the main topic and purpose of the file
+- Summarize key content and sections
+- Mention any technical, legal, or structural info if relevant
+- Do NOT include the raw content or repeat lines from it
+- Return a human-readable bullet-point summary
 
---- CODE START ---
-${code}
---- CODE END ---
+--- FILE CONTENT START ---
+${content}
+--- FILE CONTENT END ---
     `.trim();
-        const summary = await generate(prompt, model);
-        if (summary) {
-            console.log('\n📝 Code Summary:\n');
-            console.log(summary);
+        const response = await generate({ content, filepath }, model);
+        if (response.content) {
+            response.summary = response.content;
+            console.log('\n📝 Summary:\n');
+            console.log(response.summary);
         }
         else {
             console.warn('⚠️ No summary generated.');
+            response.summary = '⚠️ No summary generated.';
         }
-        return { code }; // passthrough
+        return response;
     }
 };

package/dist/pipeline/runModulePipeline.js

@@ -5,12 +5,13 @@ export async function runModulePipeline(modules, input) {
     if (isDebug) {
         console.log('Input: ', input);
     }
+    let response = { content: '' };
     for (const mod of modules) {
         try {
-            current = await mod.run(current);
+            response = await mod.run(current);
             if (isDebug) {
                 console.log(`⚙️ Running: ${mod.name}`);
-                console.log("Current: ", current);
+                console.log("Current: ", response.content);
             }
         }
         catch (error) {
@@ -19,5 +20,5 @@ export async function runModulePipeline(modules, input) {
         }
     }
     // Return the output, assuming 'code' holds the relevant transformed content
-    return { code: current.code }; // Ensure the return type matches PromptOutput
+    return response; // Ensure the return type matches PromptOutput
 }

package/dist/utils/detectFileType.js

@@ -0,0 +1,52 @@
+import path from 'path';
+export function detectFileType(filepath) {
+    const ext = path.extname(filepath).toLowerCase();
+    const map = {
+        // Programming languages
+        '.ts': 'typescript',
+        '.tsx': 'typescript',
+        '.js': 'javascript',
+        '.jsx': 'javascript',
+        '.java': 'java',
+        '.py': 'python',
+        '.rb': 'ruby',
+        '.php': 'php',
+        '.go': 'go',
+        '.rs': 'rust',
+        '.c': 'c',
+        '.cpp': 'cpp',
+        '.cs': 'csharp',
+        '.swift': 'swift',
+        '.kt': 'kotlin',
+        '.scala': 'scala',
+        // Markup & docs
+        '.md': 'markdown',
+        '.html': 'html',
+        '.htm': 'html',
+        '.xml': 'xml',
+        '.json': 'json',
+        '.yaml': 'yaml',
+        '.yml': 'yaml',
+        // Configs
+        '.ini': 'config',
+        '.toml': 'config',
+        '.env': 'config',
+        // Data
+        '.sql': 'sql',
+        '.csv': 'csv',
+        '.tsv': 'tsv',
+        // Text & writing
+        '.txt': 'text',
+        '.log': 'log',
+        '.rst': 'text',
+        // Office
+        '.doc': 'word',
+        '.docx': 'word',
+        '.pdf': 'pdf',
+        '.ppt': 'powerpoint',
+        '.pptx': 'powerpoint',
+        '.xls': 'excel',
+        '.xlsx': 'excel',
+    };
+    return map[ext] || ext.replace('.', '') || 'unknown';
+}

package/dist/utils/shouldIgnoreFiles.js

@@ -0,0 +1,6 @@
+import path from 'path';
+import { IGNORED_EXTENSIONS } from '../config/IgnoredExtensions.js';
+export function shouldIgnoreFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return IGNORED_EXTENSIONS.includes(ext);
+}

package/package.json

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

package/dist/utils/getSummary.js

@@ -1,31 +0,0 @@
-// src/utils/getSummary.ts
-import path from 'path';
-export function getSummary(filename, lang) {
-    const base = path.basename(filename).toLowerCase();
-    const ext = path.extname(base);
-    if (base === 'package.json')
-        return 'Defines project metadata and dependencies.';
-    if (base === 'tsconfig.json')
-        return 'TypeScript compiler settings.';
-    if (base === 'pyproject.toml')
-        return 'Python build and dependency configuration.';
-    if (base === 'Cargo.toml')
-        return 'Rust project configuration.';
-    if (base === 'pom.xml')
-        return 'Maven config for a Java project.';
-    if (base === 'README.md')
-        return 'Project documentation.';
-    if (base.startsWith('index'))
-        return 'Entry point module.';
-    if (lang === 'ts' || lang === 'js') {
-        if (base.includes('service'))
-            return 'Service logic module.';
-        if (base.includes('util'))
-            return 'Utility/helper module.';
-        if (base.includes('controller'))
-            return 'Handles request/response logic.';
-        if (base.includes('router'))
-            return 'Routing definitions.';
-    }
-    return `Generic ${ext.replace('.', '')} file.`;
-}

package/dist/utils/languageConfig.js

@@ -1,7 +0,0 @@
-export const EXTENSIONS_BY_LANG = {
-    ts: ['.ts', '.tsx'],
-    js: ['.js', '.jsx'],
-    java: ['.java'],
-    rust: ['.rs'],
-    python: ['.py'],
-};