scai 0.1.45 → 0.1.47

package/dist/commands/AskCmd.js

@@ -7,8 +7,7 @@ import { generate } from '../lib/generate.js';
 import { buildContextualPrompt } from '../utils/buildContextualPrompt.js';
 import { generateFileTree } from '../utils/fileTree.js';
 import { log } from '../utils/log.js';
-import { PROMPT_LOG_PATH, SCAI_HOME, INDEX_DIR } from '../constants.js';
-const MAX_RELATED_FILES = 5;
+import { PROMPT_LOG_PATH, SCAI_HOME, INDEX_DIR, RELATED_FILES_LIMIT, MAX_SUMMARY_LINES } from '../constants.js';
 export async function runAskCommand(query) {
     if (!query) {
         query = await promptOnce('🧠 Ask your question:\n> ');
@@ -22,7 +21,7 @@ export async function runAskCommand(query) {
     console.log(`🔍 Searching for: "${query}"\n`);
     // 🟩 STEP 1: Semantic Search
     const start = Date.now();
-    const semanticResults = await searchFiles(query, MAX_RELATED_FILES); // RankedFile[]
+    const semanticResults = await searchFiles(query, RELATED_FILES_LIMIT); // RankedFile[]
     const duration = Date.now() - start;
     console.log(`⏱️ searchFiles took ${duration}ms and returned ${semanticResults.length} result(s)`);
     semanticResults.forEach((file, i) => {
@@ -37,7 +36,6 @@ export async function runAskCommand(query) {
     // 🟩 STEP 2: Merge results (de-duplicate by full resolved path)
     const seen = new Set();
     const combinedResults = [];
-    // Merging results now ensures all have `id`
     for (const file of semanticResults) {
         const resolved = path.resolve(file.path);
         seen.add(resolved);
@@ -48,7 +46,7 @@ export async function runAskCommand(query) {
         if (!seen.has(resolved)) {
             seen.add(resolved);
             combinedResults.push({
-                id: file.id, // Ensure the id is included here
+                id: file.id,
                 path: file.path,
                 summary: file.summary || '',
                 score: 0.0,
@@ -73,9 +71,12 @@ export async function runAskCommand(query) {
     let code = '';
     let topSummary = topFile.summary || '(No summary available)';
     let topFunctions = [];
-    // Gather all file IDs from the combined results
+    // Truncate summary if needed
+    if (topSummary) {
+        topSummary = topSummary.split('\n').slice(0, MAX_SUMMARY_LINES).join('\n');
+    }
     const allFileIds = combinedResults
-        .map(file => file.id) // Now file.id exists
+        .map(file => file.id)
         .filter((id) => typeof id === 'number');
     const allFunctionsMap = getFunctionsForFiles(allFileIds);
     try {
@@ -87,11 +88,15 @@ export async function runAskCommand(query) {
         console.warn(`⚠️ Failed to read or analyze top file (${filepath}):`, err);
     }
     // 🟩 STEP 5: Build relatedFiles with functions
-    const relatedFiles = combinedResults.slice(0, MAX_RELATED_FILES).map(file => {
+    const relatedFiles = combinedResults.slice(0, RELATED_FILES_LIMIT).map(file => {
         const fileId = file.id;
+        let summary = file.summary || '(No summary available)';
+        if (summary) {
+            summary = summary.split('\n').slice(0, MAX_SUMMARY_LINES).join('\n');
+        }
         return {
             path: file.path,
-            summary: file.summary || '(No summary available)',
+            summary,
             functions: allFunctionsMap[fileId]?.map(fn => fn.name) || [],
         };
     });

package/dist/commands/DaemonCmd.js

@@ -1,4 +1,4 @@
-import fsSync from 'fs';
+import fsSync, { mkdirSync } from 'fs';
 import { LOG_PATH, PID_PATH } from '../constants.js';
 import { log } from '../utils/log.js';
 import { spawn } from 'child_process';
@@ -20,13 +20,23 @@ export async function startDaemon() {
     }
     log('🚀 Starting summarizer daemon in background mode...');
     log(`📝 Logs will be saved to: ${LOG_PATH}`);
-    process.env.BACKGROUND_MODE = 'true';
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = path.dirname(__filename);
     const daemonWorkerPath = path.join(__dirname, '../daemon/daemonWorker.js');
     const child = spawn(process.execPath, [daemonWorkerPath], {
         detached: true,
         stdio: ['ignore', 'ignore', 'ignore'],
+        env: {
+            ...process.env,
+            BACKGROUND_MODE: 'true',
+        }
     });
     child.unref();
+    try {
+        mkdirSync(path.dirname(PID_PATH), { recursive: true });
+        fsSync.writeFileSync(PID_PATH, String(child.pid));
+    }
+    catch (err) {
+        log(`❌ Failed to write PID file: ${err instanceof Error ? err.message : err}`);
+    }
 }

package/dist/commands/ResetDbCmd.js

@@ -43,5 +43,15 @@ export async function resetDatabase() {
     catch (err) {
         console.warn('⚠️ Could not ensure DB directory exists:', err instanceof Error ? err.message : err);
     }
+    const lockDir = `${DB_PATH}.lock`;
+    if (fs.existsSync(lockDir)) {
+        try {
+            fs.rmSync(lockDir, { recursive: true, force: true });
+            console.log('🧹 Removed leftover lock directory.');
+        }
+        catch (err) {
+            console.warn('⚠️ Failed to remove lock directory:', err instanceof Error ? err.message : err);
+        }
+    }
     console.log('✅ Database has been reset. You can now re-run: scai index');
 }

package/dist/constants.js

@@ -52,3 +52,15 @@ export function getIndexDir() {
  * Used by indexing logic (`scai index`) to determine what folder to scan.
  */
 export const INDEX_DIR = getIndexDir();
+/**
+ * Limit for number of related files included in model prompt.
+ */
+export const RELATED_FILES_LIMIT = 3;
+/**
+ * Limit for number of candidate files to score.
+ */
+export const CANDIDATE_LIMIT = 100;
+/**
+ * Limit number of summery lines
+ */
+export const MAX_SUMMARY_LINES = 12;

package/dist/daemon/daemonBatch.js

@@ -75,14 +75,19 @@ export async function runDaemonBatch() {
                 log(`⚡ Skipped summary (up-to-date) for ${row.path}`);
             }
             // 🧩 Extract functions and update processing status
-            await indexFunctionsForFile(row.path, row.id);
-            db.prepare(`
-        UPDATE files
-        SET processing_status = 'extracted',
-            functions_extracted_at = datetime('now')
-        WHERE id = @id
-      `).run({ id: row.id });
-            log(`✅ Function extraction complete for ${row.path}\n`);
+            const extracted = await indexFunctionsForFile(row.path, row.id);
+            if (extracted) {
+                db.prepare(`
+          UPDATE files
+          SET processing_status = 'extracted',
+              functions_extracted_at = datetime('now')
+          WHERE id = @id
+        `).run({ id: row.id });
+                log(`✅ Function extraction complete for ${row.path}\n`);
+            }
+            else {
+                log(`ℹ️ No functions extracted for ${row.path}\n`);
+            }
         }
         catch (err) {
             log(`❌ Failed: ${row.path}: ${err instanceof Error ? err.message : String(err)}\n`);

package/dist/daemon/daemonWorker.js

@@ -1,45 +1,62 @@
 import { db } from '../db/client.js';
-import { runDaemonBatch } from './daemonBatch.js'; // assuming this function is already defined
+import { runDaemonBatch } from './daemonBatch.js';
 import { log } from '../utils/log.js';
-// Time between each batch in milliseconds
-const SLEEP_MS = 2000; // Adjust as needed
-const IDLE_SLEEP_MS = 5000; // Adjust as needed
-// Check if there are any files left to process
+const SLEEP_MS = 2000;
+const IDLE_SLEEP_MS = 5000;
+// 🚨 Immediate signal that the worker even starts
+log('🛠️ daemonWorker.js loaded');
 async function isQueueEmpty() {
-    // Query the database for the count of files with certain processing statuses
-    const row = db.prepare(`
-    SELECT COUNT(*) AS count
-    FROM files
-    WHERE processing_status IN ('unprocessed')
-  `).get();
-    // Cast the row to an object that has a `count` property of type number
-    const castRow = row;
-    // Check if the casted `row` has a valid `count` property (number)
-    if (typeof castRow.count !== 'number') {
-        console.error('Error: Invalid count value in the database query result.');
-        return true; // Assume queue is empty if the count is invalid
+    try {
+        const row = db.prepare(`
+      SELECT COUNT(*) AS count
+      FROM files
+      WHERE processing_status IN ('unprocessed')
+    `).get();
+        const castRow = row;
+        if (typeof castRow.count !== 'number') {
+            log('⚠️ Invalid count value in DB query result:', row);
+            return true;
+        }
+        log(`📦 Queue size: ${castRow.count}`);
+        return castRow.count === 0;
+    }
+    catch (error) {
+        log('❌ Error checking if queue is empty:', error);
+        return true;
     }
-    // Return true if count is 0, otherwise false
-    return castRow.count === 0;
 }
 export async function daemonWorker() {
+    log('🚀 Daemon worker starting up...');
     while (true) {
-        // Execute a batch job
-        const didWork = await runDaemonBatch();
-        if (!didWork) {
-            // Check if the queue is empty after a batch job
-            const queueEmpty = await isQueueEmpty();
-            if (queueEmpty) {
-                // If no files are left to process, stop the daemon
-                log("✅ No more work left. Stopping daemon.");
-                break;
+        try {
+            log('🔄 Running daemon batch...');
+            const didWork = await runDaemonBatch();
+            if (!didWork) {
+                const queueEmpty = await isQueueEmpty();
+                if (queueEmpty) {
+                    log('🕊️ No work found. Idling...');
+                    await sleep(IDLE_SLEEP_MS * 3);
+                    continue;
+                }
+                else {
+                    log('🟡 Work queue not empty, but no batch executed.');
+                }
             }
+            else {
+                log('✅ Batch executed, sleeping briefly...');
+            }
+            await sleep(didWork ? SLEEP_MS : IDLE_SLEEP_MS);
+        }
+        catch (err) {
+            log('🔥 Error in daemonWorker loop:', err);
+            await sleep(IDLE_SLEEP_MS * 2); // prevent tight error loop
         }
-        // Sleep for a set amount of time before checking again
-        await sleep(didWork ? SLEEP_MS : IDLE_SLEEP_MS);
     }
 }
-// Sleep function to control how often the worker checks
+// Run the daemon
+daemonWorker().catch(err => {
+    log('❌ daemonWorker failed to start:', err);
+});
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }

package/dist/db/fileIndex.js

@@ -4,6 +4,8 @@ import path from 'path';
 import { generateEmbedding } from '../lib/generateEmbedding.js';
 import { sanitizeQueryForFts } from '../utils/sanitizeQuery.js';
 import * as sqlTemplates from './sqlTemplates.js';
+import { stringSimilarity } from 'string-similarity-js';
+import { CANDIDATE_LIMIT } from '../constants.js';
 /**
  * 📄 Index a single file into the database.
  *
@@ -16,14 +18,26 @@ export function indexFile(filePath, summary, type) {
     const lastModified = stats.mtime.toISOString();
     const indexedAt = new Date().toISOString();
     const normalizedPath = path.normalize(filePath).replace(/\\/g, '/');
+    const fileName = path.basename(normalizedPath); // Extracting the filename
+    // Insert into files table
     db.prepare(sqlTemplates.upsertFileTemplate).run({
         path: normalizedPath,
+        filename: fileName, // Pass filename
         summary,
         type,
         lastModified,
         indexedAt,
         embedding: null
     });
+    // Insert into files_fts table for full-text search, including filename
+    db.prepare(`
+  INSERT OR REPLACE INTO files_fts (rowid, filename, summary, path)
+  VALUES ((SELECT id FROM files WHERE path = :path), :filename, :summary, :path)
+`).run({
+        path: normalizedPath,
+        filename: fileName,
+        summary: summary,
+    });
     console.log(`📄 Indexed: ${normalizedPath}`);
 }
 /**
@@ -38,7 +52,7 @@ export function indexFile(filePath, summary, type) {
 export function queryFiles(safeQuery, limit = 10) {
     console.log(`Executing search query: ${safeQuery}`);
     const results = db.prepare(`
-    SELECT f.id, f.path, f.summary, f.type, f.last_modified, f.indexed_at
+    SELECT f.id, f.path, f.filename, f.summary, f.type, f.last_modified, f.indexed_at
     FROM files f
     JOIN files_fts fts ON f.id = fts.rowid
     WHERE fts.files_fts MATCH ?
@@ -67,43 +81,51 @@ export async function searchFiles(query, topK = 5) {
     }
     const safeQuery = sanitizeQueryForFts(query);
     console.log(`Executing search query in FTS5: ${safeQuery}`);
-    // Step 1: Narrow candidate set using fast keyword match
     const ftsResults = db.prepare(`
-    SELECT fts.rowid AS id, f.path, f.summary, f.type, bm25(files_fts) AS bm25Score, f.embedding
+    SELECT fts.rowid AS id, f.path, f.filename, f.summary, f.type, bm25(files_fts) AS bm25Score, f.embedding
     FROM files f
     JOIN files_fts fts ON f.id = fts.rowid
     WHERE fts.files_fts MATCH ?
     ORDER BY bm25Score ASC
     LIMIT ?
-  `).all(safeQuery, 20);
+  `).all(safeQuery, CANDIDATE_LIMIT);
     console.log(`FTS search returned ${ftsResults.length} results`);
     if (ftsResults.length === 0) {
         return [];
     }
-    // Step 2: Compute score based on embedding similarity + BM25 score
     const bm25Min = Math.min(...ftsResults.map(r => r.bm25Score));
     const bm25Max = Math.max(...ftsResults.map(r => r.bm25Score));
     const scored = ftsResults.map(result => {
-        let finalScore = 0;
         let sim = 0;
+        let finalScore = 0;
+        const normalizedBm25 = 1 - ((result.bm25Score - bm25Min) / (bm25Max - bm25Min + 1e-5));
         if (result.embedding) {
             try {
                 const vector = JSON.parse(result.embedding);
                 sim = cosineSimilarity(embedding, vector);
-                const normalizedBm25 = 1 - ((result.bm25Score - bm25Min) / (bm25Max - bm25Min + 1e-5));
-                finalScore = 0.7 * sim + 0.3 * normalizedBm25;
             }
             catch (err) {
                 console.error(`❌ Failed to parse embedding for ${result.path}:`, err);
-                finalScore = 0;
             }
         }
-        else {
-            // Fallback to BM25-only score
-            finalScore = 1 - ((result.bm25Score - bm25Min) / (bm25Max - bm25Min + 1e-5));
+        const terms = query.toLowerCase().split(/\s+/);
+        const path = result.path.toLowerCase();
+        const summary = (result.summary || '').toLowerCase();
+        let termMatches = 0;
+        for (const term of terms) {
+            if (path.includes(term) || summary.includes(term)) {
+                termMatches += 1;
+            }
         }
+        const matchRatio = termMatches / terms.length;
+        const termBoost = matchRatio >= 1 ? 1.0 : matchRatio >= 0.5 ? 0.5 : 0;
+        // 🧠 Final score with hybrid weighting (BM25 + Embedding + Term Boost)
+        finalScore = 0.4 * normalizedBm25 + 0.4 * sim + 0.2 * termBoost;
+        // ✅ Fuzzy score using string-similarity-js
+        const fuzzyScore = stringSimilarity(query.toLowerCase(), `${path} ${summary}`);
+        finalScore += fuzzyScore * 10;
         return {
-            id: result.id, // Ensure the id is included here
+            id: result.id,
             path: result.path,
             summary: result.summary,
             score: finalScore,

package/dist/db/functionExtractors/extractFromJs.js

@@ -58,7 +58,7 @@ export async function extractFromJS(filePath, content, fileId) {
     });
     if (functions.length === 0) {
         log(`⚠️ No functions found in: ${filePath}`);
-        return;
+        return false;
     }
     log(`🔍 Found ${functions.length} functions in ${filePath}`);
     for (const fn of functions) {
@@ -109,4 +109,5 @@ export async function extractFromJS(filePath, content, fileId) {
     WHERE id = @fileId
   `).run({ fileId });
     log(`✅ Marked functions as extracted for ${filePath}`);
+    return true;
 }

package/dist/db/functionExtractors/index.js

@@ -12,8 +12,7 @@ export async function extractFunctionsFromFile(filePath, content, fileId) {
     try {
         if (type === 'js' || type === 'ts' || type === 'javascript' || type === 'typescript') {
             log(`✅ Attempting to extract JS functions from ${filePath}\n`);
-            await extractFromJS(filePath, content, fileId);
-            return true;
+            return await extractFromJS(filePath, content, fileId);
         }
         if (type === 'java') {
             log(`❌ Nothing extracted for ${filePath} due to missing implementation`);

package/dist/db/functionIndex.js

@@ -3,9 +3,10 @@ import path from 'path';
 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) {
     const normalizedPath = path.normalize(filePath).replace(/\\/g, '/');
     const content = fs.readFileSync(filePath, 'utf-8');
-    await extractFunctionsFromFile(normalizedPath, content, fileId);
+    return await extractFunctionsFromFile(normalizedPath, content, fileId);
 }

package/dist/db/schema.js

@@ -1,9 +1,11 @@
 import { db } from "./client.js";
 export function initSchema() {
     db.exec(`
+    -- Create the files table
     CREATE TABLE IF NOT EXISTS files (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       path TEXT UNIQUE,
+      filename TEXT,               -- ✅ Store extracted filename here
       summary TEXT,
       type TEXT,
       indexed_at TEXT,
@@ -13,27 +15,12 @@ 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(path, summary, content='files', content_rowid='id');
-
-    -- FTS Triggers to keep files_fts in sync
-    CREATE TRIGGER IF NOT EXISTS files_ai AFTER INSERT ON files BEGIN
-      INSERT INTO files_fts(rowid, path, summary)
-      VALUES (new.id, new.path, new.summary);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS files_au AFTER UPDATE ON files BEGIN
-      UPDATE files_fts SET
-        path = new.path,
-        summary = new.summary
-      WHERE rowid = new.id;
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS files_ad AFTER DELETE ON files BEGIN
-      DELETE FROM files_fts WHERE rowid = old.id;
-    END;
+    USING fts5(filename, summary, path, content='files', content_rowid='id');
   `);
-    console.log('✅ SQLite schema initialized with FTS5 triggers');
+    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,

package/dist/db/sqlTemplates.js

@@ -1,8 +1,9 @@
 // Upsert file metadata into `files`
 export const upsertFileTemplate = `
-  INSERT INTO files (path, summary, type, last_modified, indexed_at, embedding)
-  VALUES (:path, :summary, :type, :lastModified, :indexedAt, :embedding)
+  INSERT INTO files (path, filename, summary, type, last_modified, indexed_at, embedding)
+  VALUES (:path, :filename, :summary, :type, :lastModified, :indexedAt, :embedding)
   ON CONFLICT(path) DO UPDATE SET
+    filename = excluded.filename, -- Update filename when path conflicts
     summary = CASE
       WHEN excluded.summary IS NOT NULL AND excluded.summary != files.summary
       THEN excluded.summary
@@ -17,9 +18,10 @@ export const upsertFileTemplate = `
       ELSE files.embedding
     END
 `;
-// Fetch search results with BM25 ranking
+// 📌 CHANGE 1: Include `filename` in SELECT + weight `filename` highest in bm25
 export const fetchBm25ScoresTemplate = `
-  SELECT f.path, f.summary, f.type, bm25(files_fts) AS bm25Score
+  SELECT f.path, f.filename, f.summary, f.type,
+         bm25(files_fts, 10.0, 2.0, 1.0) AS bm25Score
   FROM files_fts
   JOIN files f ON files_fts.rowid = f.id
   WHERE files_fts MATCH :query
@@ -29,10 +31,10 @@ export const fetchBm25ScoresTemplate = `
 export const fetchEmbeddingTemplate = `
   SELECT embedding FROM files WHERE path = :path
 `;
-// Used for non-embedding query in `queryFiles()`
+// 📌 CHANGE 2: Also added weighted `bm25()` with explicit weights here
 export const rawQueryTemplate = `
-  SELECT f.path, f.summary, f.type, f.last_modified, f.indexed_at,
-         bm25(files_fts) AS rank
+  SELECT f.path, f.filename, f.summary, f.type, f.last_modified, f.indexed_at,
+         bm25(files_fts, 10.0, 2.0, 1.0) AS rank
   FROM files_fts
   JOIN files f ON files_fts.rowid = f.id
   WHERE files_fts MATCH :query

package/dist/pipeline/modules/summaryModule.js

@@ -28,7 +28,7 @@ Extension: ${ext}
 ${content}
 --- FILE CONTENT END ---
     `.trim();
-        const response = await generate({ content, filepath }, model);
+        const response = await generate({ content: prompt, filepath }, model);
         if (response.content) {
             response.summary = response.content;
             console.log('\n📝 Summary:\n');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scai",
-  "version": "0.1.45",
+  "version": "0.1.47",
   "type": "module",
   "bin": {
     "scai": "./dist/index.js"
@@ -30,7 +30,8 @@
     "better-sqlite3": "^12.1.1",
     "commander": "^11.0.0",
     "fast-glob": "^3.3.3",
-    "proper-lockfile": "^4.1.2"
+    "proper-lockfile": "^4.1.2",
+    "string-similarity-js": "^2.1.4"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",