scai 0.1.22 → 0.1.24

package/dist/commands/AskCmd.js

@@ -1,66 +1,63 @@
+import readline from 'readline';
 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"');
+        query = await promptOnce('🧠 Ask your question:\n> ');
+    }
+    query = query.trim();
+    if (!query) {
+        console.error('❌ No question provided.\n👉 Usage: scai ask "your question"');
         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 {
+    const start = Date.now();
+    const results = await searchFiles(query, 5);
+    const duration = Date.now() - start;
+    console.log(`⏱️ searchFiles took ${duration}ms and returned ${results.length} result(s)`);
+    if (results.length > 0) {
         console.log('📊 Closest files based on semantic similarity:');
-        results.forEach(file => {
-            console.log(`📄 Path: ${file?.path}`);
+        results.forEach((file, i) => {
+            console.log(`  ${i + 1}. 📄 Path: ${file?.path} | Score: ${file?.score?.toFixed(3)}`);
         });
     }
+    else {
+        console.log('⚠️ No similar embeddings found. Asking the model for context instead...');
+    }
+    // 🧠 Use stored summaries directly
     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 (!file?.summary) {
+            console.warn(`⚠️ No summary available for file: ${file?.path}`);
+            continue;
         }
+        console.log(`📝 Using stored summary for: ${file.path}`);
+        allSummaries += `\n${file.summary}`;
     }
-    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);
-        }
+    const input = {
+        content: allSummaries ? `${query}\n\n${allSummaries}` : query,
+        filepath: '',
+    };
+    try {
+        console.log(allSummaries.trim()
+            ? '🧠 Summaries found, sending them to the model for synthesis...'
+            : '⚠️ No summaries found. Asking the model for context only...');
+        const modelResponse = await generate(input, 'llama3');
+        console.log(`\n📝 Model response:\n${modelResponse.content}`);
     }
-    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);
-        }
+    catch (err) {
+        console.error('❌ Model request failed:', err);
     }
 }
+function promptOnce(promptText) {
+    return new Promise(resolve => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        rl.question(promptText, answer => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}

package/dist/commands/DaemonCmd.js

@@ -1,80 +1,28 @@
-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 { LOG_PATH, PID_PATH } from '../constants.js';
+import { log } from '../utils/log.js';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
 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;
+// 🚀 Ensure daemon starts in the background
+export async function startDaemon() {
+    if (fsSync.existsSync(PID_PATH)) {
+        log(`⚠️ Daemon already running (PID file found at ${PID_PATH}). Skipping launch.`);
     }
-    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));
+    else {
+        log('🚀 Starting summarizer daemon in background mode...');
+        log(`📝 Logs will be saved to: ${LOG_PATH}`);
+        // Before starting the background process, set the environment variable
+        process.env.BACKGROUND_MODE = 'true'; // Set the mode to background
+        // Compute absolute path to the background worker (adjust path if needed)
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        const daemonWorkerPath = path.join(__dirname, '../daemon/daemonWorker.js');
+        // Spawn the daemonWorker.js file in the background
+        const child = spawn(process.execPath, [daemonWorkerPath], {
+            detached: true, // Detach the process so it runs independently
+            stdio: ['ignore', 'ignore', 'ignore'], // Suppress the output
+        });
+        child.unref(); // Allow the parent process to exit without waiting for the child
     }
 }

package/dist/commands/IndexCmd.js

@@ -4,37 +4,48 @@ import { initSchema } from '../db/schema.js';
 import { indexFile } from '../db/fileIndex.js';
 import { shouldIgnoreFile } from '../utils/shouldIgnoreFiles.js';
 import { detectFileType } from '../utils/detectFileType.js';
-import { runDaemonScheduler } from './DaemonCmd.js';
+import { startDaemon } from './DaemonCmd.js';
 import { IGNORED_FOLDER_GLOBS } from '../config/IgnoredPaths.js';
-import { db } from '../db/client.js';
-const IGNORE = [
-    '**/node_modules/**', '**/dist/**', '**/build/**',
-    '**/coverage/**', '**/.git/**', '**/*.test.*'
-];
-export async function runIndexCommand(targetDir = process.cwd(), options = {}) {
-    const resolvedDir = path.resolve(targetDir);
-    console.log(`📂 Indexing files in: ${resolvedDir}`);
-    initSchema();
-    // 🧠 Check if another directory has already been indexed
-    const indexedPaths = db.prepare(`
-    SELECT DISTINCT path FROM files LIMIT 100
-  `).all();
-    const knownRoot = indexedPaths.length > 0
-        ? path.dirname(indexedPaths[0].path)
-        : null;
-    if (knownRoot && !resolvedDir.startsWith(knownRoot) && !options.force) {
-        console.warn(`⚠️ You're indexing a different folder than before:
-- Previously: ${knownRoot}
-- Now:        ${resolvedDir}
-
-This will add more files into the existing index and may reduce accuracy or performance.
-
-Use --force to continue, or consider clearing the index:
-  scai reset-db
-
-Aborting.`);
+import { Config } from '../config.js';
+import { DB_PATH } from '../constants.js';
+import { log } from '../utils/log.js';
+import lockfile from 'proper-lockfile';
+// 🧠 Lock the database to prevent simultaneous access
+async function lockDb() {
+    try {
+        const lock = await lockfile.lock(DB_PATH); // DB_PATH from constants.ts
+        return lock;
+    }
+    catch (err) {
+        log('❌ Failed to acquire DB lock: ' + err);
+        throw err;
+    }
+}
+export async function runIndexCommand(targetDir, options = {}) {
+    try {
+        initSchema();
+    }
+    catch (err) {
+        console.error('❌ Failed to initialize schema:', err);
         process.exit(1);
     }
+    let resolvedDir;
+    if (options.force) {
+        // Force: use passed dir or fallback to cwd, no config updates
+        resolvedDir = path.resolve(targetDir || process.cwd());
+        console.warn('⚠️ Running in --force mode. Config will not be updated.');
+    }
+    else if (targetDir) {
+        // User provided a directory: resolve and persist to config
+        resolvedDir = path.resolve(targetDir);
+        Config.setIndexDir(resolvedDir);
+    }
+    else {
+        // Use configured indexDir or fallback to cwd
+        resolvedDir = Config.getIndexDir() || process.cwd();
+        Config.setIndexDir(resolvedDir); // persist if not yet saved
+    }
+    log(`📂 Indexing files in: ${resolvedDir}`);
     const files = await fg('**/*.*', {
         cwd: resolvedDir,
         ignore: IGNORED_FOLDER_GLOBS,
@@ -42,25 +53,25 @@ Aborting.`);
     });
     const countByExt = {};
     let count = 0;
+    const release = await lockDb(); // Lock the DB before starting
     for (const file of files) {
         if (shouldIgnoreFile(file))
             continue;
         try {
             const type = detectFileType(file);
-            indexFile(file, null, type); // empty summary for now
+            indexFile(file, null, type); // Index file without summary
             const ext = path.extname(file);
             countByExt[ext] = (countByExt[ext] || 0) + 1;
-            console.log(`📄 Indexed: ${path.relative(resolvedDir, file)}`);
+            log(`📄 Indexed: ${path.relative(resolvedDir, file)}`);
             count++;
         }
         catch (err) {
-            console.warn(`⚠️ Skipped ${file}:`, err instanceof Error ? err.message : err);
+            log(`⚠️ Skipped in indexCmd ${file}: ${err instanceof Error ? err.message : err}`);
         }
     }
-    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();
-    }
+    log('📊 Indexed files by extension:', JSON.stringify(countByExt, null, 2));
+    log(`✅ Done. Indexed ${count} files.`);
+    await release(); // Release the DB lock after indexing is done
+    // Auto-start daemon if not already running
+    startDaemon();
 }

package/dist/commands/ResetDbCmd.js

@@ -1,19 +1,57 @@
 import fs from 'fs';
-import path from 'path';
+import fsp from 'fs/promises';
 import { db } from '../db/client.js';
-export function resetDatabase() {
-    const dbPath = path.resolve(process.cwd(), '.scai/db.sqlite');
+import { DB_PATH, SCAI_HOME } from '../constants.js';
+import lockfile from 'proper-lockfile';
+import path from 'path';
+function getBackupDir() {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return path.join(SCAI_HOME, `backup-${timestamp}`);
+}
+async function backupScaiFolder() {
+    const backupDir = getBackupDir();
+    try {
+        await fsp.mkdir(backupDir, { recursive: true });
+        const files = await fsp.readdir(SCAI_HOME);
+        for (const file of files) {
+            const srcPath = path.join(SCAI_HOME, file);
+            const destPath = path.join(backupDir, file);
+            const stat = await fsp.stat(srcPath);
+            if (stat.isFile()) {
+                await fsp.copyFile(srcPath, destPath);
+            }
+        }
+        console.log(`📦 Backed up .scai folder to: ${backupDir}`);
+        return backupDir;
+    }
+    catch (err) {
+        console.warn('⚠️ Failed to back up .scai folder:', err instanceof Error ? err.message : err);
+        return null;
+    }
+}
+export async function resetDatabase() {
+    console.log('🔁 Backing up existing .scai folder...');
+    await backupScaiFolder();
     try {
-        db.close(); // 🔒 Make sure the DB is closed
+        db.close();
         console.log('🔒 Closed SQLite database connection.');
     }
     catch (err) {
-        console.warn('⚠️ Could not close database:', err);
+        console.warn('⚠️ Could not close database:', err instanceof Error ? err.message : err);
     }
-    if (fs.existsSync(dbPath)) {
+    try {
+        const releaseLock = await lockfile.unlock(DB_PATH).catch(() => null);
+        if (releaseLock) {
+            console.log('🔓 Released database lock.');
+        }
+    }
+    catch (err) {
+        console.warn('⚠️ Failed to release database lock:', err instanceof Error ? err.message : err);
+    }
+    if (fs.existsSync(DB_PATH)) {
         try {
-            fs.unlinkSync(dbPath);
-            console.log('🧹 Deleted existing database.');
+            fs.unlinkSync(DB_PATH);
+            console.log(`🧹 Deleted existing database at ${DB_PATH}`);
         }
         catch (err) {
             console.error('❌ Failed to delete DB file:', err instanceof Error ? err.message : err);
@@ -21,7 +59,14 @@ export function resetDatabase() {
         }
     }
     else {
-        console.log('ℹ️ No existing database found.');
+        console.log('ℹ️ No existing database found at:', DB_PATH);
+    }
+    try {
+        fs.mkdirSync(path.dirname(DB_PATH), { recursive: true });
+        console.log('📁 Ensured that the database directory exists.');
+    }
+    catch (err) {
+        console.warn('⚠️ Could not ensure DB directory exists:', err instanceof Error ? err.message : err);
     }
     console.log('✅ Database has been reset. You can now re-run: scai index');
 }

package/dist/config/StopWords.js

@@ -0,0 +1,15 @@
+// src/config/StopWords.ts
+/**
+ * These common words are ignored from search queries
+ * to reduce noise and improve FTS and embedding match quality.
+ */
+export const STOP_WORDS = new Set([
+    'a', 'an', 'and', 'are', 'as', 'at', 'be', 'but', 'by',
+    'for', 'if', 'in', 'into', 'is', 'it', 'no', 'not',
+    'of', 'on', 'or', 'such', 'that', 'the', 'their',
+    'then', 'there', 'these', 'they', 'this', 'to', 'was',
+    'will', 'with', 'what', 'which', 'who', 'whom', 'where',
+    'when', 'why', 'how', 'from', 'all', 'any', 'can',
+    'did', 'do', 'has', 'have', 'i', 'me', 'my', 'you',
+    'your', 'we', 'us', 'our'
+]);

package/dist/constants.js

@@ -1,19 +1,49 @@
 import os from 'os';
 import path from 'path';
 import fs from 'fs';
+/**
+ * The base directory where internal SCAI config/state is stored:
+ * ~/.scai
+ */
 export const SCAI_HOME = path.join(os.homedir(), '.scai');
+/**
+ * Full path to the SQLite database used by SCAI:
+ * ~/.scai/db.sqlite
+ */
 export const DB_PATH = path.join(SCAI_HOME, 'db.sqlite');
+/**
+ * Path to the daemon process ID file (if running in background mode):
+ * ~/.scai/daemon.pid
+ */
 export const PID_PATH = path.join(SCAI_HOME, 'daemon.pid');
+/**
+ * Path to the config file that stores user settings like model, language, indexDir, etc.:
+ * ~/.scai/config.json
+ */
 export const CONFIG_PATH = path.join(SCAI_HOME, 'config.json');
-// Function to read config and get the indexDir on-demand
+/**
+ * Path to the daemon log file:
+ * ~/.scai/daemon.log
+ */
+export const LOG_PATH = path.join(SCAI_HOME, 'daemon.log');
+/**
+ * Get the active index directory.
+ *
+ * - If the user has configured an `indexDir`, use it.
+ * - If not, default to the user’s home directory (`~`), not `.scai`.
+ */
 export function getIndexDir() {
     try {
         const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
-        return config.indexDir || path.join(os.homedir(), 'defaultIndex'); // Default if not set
+        return config.indexDir || os.homedir(); // 🏠 Default: ~
     }
     catch (e) {
-        return path.join(os.homedir(), 'defaultIndex'); // Fallback if no config file
+        return os.homedir(); // 🏠 Fallback if config file is missing or invalid
     }
 }
-// On-demand index directory retrieval
+/**
+ * On-demand index directory to scan for files.
+ *
+ * Used by indexing logic (`scai index`) to determine what folder to scan.
+ */
 export const INDEX_DIR = getIndexDir();

package/dist/daemon/daemonBatch.js

@@ -0,0 +1,65 @@
+import { summaryModule } from '../pipeline/modules/summaryModule.js';
+import { db } from '../db/client.js';
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import { generateEmbedding } from '../lib/generateEmbedding.js';
+import { DB_PATH } from '../constants.js';
+import { log } from '../utils/log.js';
+import lockfile from 'proper-lockfile';
+import { shouldIgnoreFile } from '../utils/shouldIgnoreFiles.js';
+const MAX_FILES_PER_BATCH = 5;
+async function lockDb() {
+    try {
+        return await lockfile.lock(DB_PATH);
+    }
+    catch (err) {
+        log('❌ Failed to acquire DB lock: ' + err);
+        throw err;
+    }
+}
+export async function runDaemonBatch() {
+    const rows = db.prepare(`
+    SELECT path, type FROM files
+    WHERE summary IS NULL OR summary = ''
+    ORDER BY last_modified DESC
+    LIMIT ?
+  `).all(MAX_FILES_PER_BATCH);
+    if (rows.length === 0) {
+        log('✅ No files left to summarize.');
+        return false;
+    }
+    const release = await lockDb();
+    for (const row of rows) {
+        if (!fsSync.existsSync(row.path)) {
+            log(`⚠️ Skipped missing file: ${row.path}`);
+            continue;
+        }
+        if (shouldIgnoreFile(row.path)) {
+            log(`⚠️ Skipped (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() || null;
+            let embedding = null;
+            if (summary) {
+                const vector = await generateEmbedding(summary);
+                if (vector)
+                    embedding = JSON.stringify(vector);
+            }
+            db.prepare(`
+        UPDATE files
+        SET summary = @summary, embedding = @embedding, indexed_at = datetime('now')
+        WHERE path = @path
+      `).run({ summary, embedding, path: row.path });
+            log(`📝 Summarized: ${row.path}`);
+        }
+        catch (err) {
+            log(`❌ Failed: ${row.path}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        await new Promise(resolve => setTimeout(resolve, 200));
+    }
+    await release();
+    return true;
+}

package/dist/daemon/daemonWorker.js

@@ -0,0 +1,27 @@
+import fsSync from 'fs';
+import { LOG_PATH, PID_PATH, SCAI_HOME } from '../constants.js';
+import { log } from '../utils/log.js';
+import { runDaemonBatch } from '../daemon/daemonBatch.js'; // ✅ now from utils
+const SLEEP_MS = 30 * 1000;
+const IDLE_SLEEP_MS = 4 * SLEEP_MS;
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+async function runDaemonScheduler() {
+    fsSync.mkdirSync(SCAI_HOME, { recursive: true });
+    fsSync.writeFileSync(PID_PATH, process.pid.toString(), 'utf-8');
+    fsSync.appendFileSync(LOG_PATH, `\n\n🧠 Daemon started at ${new Date().toISOString()} — PID ${process.pid}\n`);
+    let cycles = 0;
+    while (true) {
+        const didWork = await runDaemonBatch();
+        cycles++;
+        if (cycles % 20 === 0) {
+            log(`🌀 Still running. Cycles: ${cycles}`);
+        }
+        await sleep(didWork ? SLEEP_MS : IDLE_SLEEP_MS);
+    }
+}
+runDaemonScheduler().catch(err => {
+    log(`❌ Daemon crashed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+});

package/dist/db/client.js

@@ -1,5 +1,9 @@
 import Database from 'better-sqlite3';
 import fs from 'fs';
 import { DB_PATH, SCAI_HOME } from '../constants.js';
+// Ensure the directory exists
 fs.mkdirSync(SCAI_HOME, { recursive: true });
+// Open the database connection
 export const db = new Database(DB_PATH);
+// Set journal_mode to WAL for better concurrency
+db.pragma('journal_mode = WAL');

package/dist/db/fileIndex.js

@@ -1,114 +1,123 @@
-// File: src/db/fileIndex.ts
 import { db } from './client.js';
 import fs from 'fs';
+import path from 'path';
 import { generateEmbedding } from '../lib/generateEmbedding.js';
-import * as sqlTemplates from './sqlTemplates.js'; // Import the SQL templates
+import * as sqlTemplates from './sqlTemplates.js';
+import { sanitizeQueryForFts } from '../utils/sanitizeQuery.js';
+/**
+ * Index a file into the local SQLite database.
+ *
+ * - Normalizes the file path for cross-platform compatibility.
+ * - Extracts file metadata (last modified time).
+ * - Performs an UPSERT into the `files` table with the latest summary/type/timestamp.
+ */
 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 });
+    const indexedAt = new Date().toISOString();
+    const normalizedPath = path.normalize(filePath).replace(/\\/g, '/');
+    db.prepare(sqlTemplates.upsertFileTemplate).run({
+        path: normalizedPath,
+        summary,
+        type,
+        lastModified,
+        indexedAt,
+        embedding: null
+    });
+    console.log(`📄 Indexed: ${normalizedPath}`);
 }
+/**
+ * Perform a raw keyword-based full-text search using the FTS5 index.
+ */
 export function queryFiles(query, limit = 10) {
-    // 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
+        token = token.replace(/[?*\\"]/g, '').replace(/'/g, "''");
+        return token.includes(' ') ? `"${token}"` : `${token}*`;
     })
         .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 });
+    const results = db.prepare(`
+    SELECT f.id, f.path, 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 ?
+    LIMIT ?
+  `).all(safeQuery, limit);
+    console.log(`Search returned ${results.length} results.`);
+    results.forEach(result => {
+        console.log(`📄 Found in FTS search: ${result.path}`);
+    });
     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);
-}
+/**
+ * Perform a hybrid semantic + keyword-based search.
+ */
 export async function searchFiles(query, topK = 5) {
-    // Generate the query embedding
+    console.log(`🧠 Searching for query: "${query}"`);
     const embedding = await generateEmbedding(query);
-    if (!embedding)
+    if (!embedding) {
+        console.log('⚠️ Failed to generate embedding for query');
         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 safeQuery = sanitizeQueryForFts(query);
+    console.log(`Executing search query in FTS5: ${safeQuery}`);
+    const ftsResults = db.prepare(`
+  SELECT fts.rowid AS id, f.path, f.summary, f.type, bm25(files_fts) AS bm25Score
+  FROM files f
+  JOIN files_fts fts ON f.id = fts.rowid
+  WHERE fts.files_fts MATCH ?
+  AND f.embedding IS NOT NULL
+  ORDER BY bm25Score DESC
+  LIMIT ?
+`).all(safeQuery, topK);
+    console.log(`FTS search returned ${ftsResults.length} results`);
+    if (ftsResults.length === 0) {
+        console.log('⚠️ No results found from FTS search');
+        return [];
+    }
+    ftsResults.forEach(result => {
+        console.log(`📄 FTS found: ${result.path}`);
+    });
     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')
+            const embResult = db.prepare(sqlTemplates.fetchEmbeddingTemplate).get({
+                path: result.path,
+            });
+            if (!embResult || typeof embResult.embedding !== 'string') {
+                console.log(`⚠️ No embedding for file: ${result.path}`);
                 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;
+            const finalScore = 0.7 * sim + 0.3 * normalizedBm25;
             return {
                 path: result.path,
                 summary: result.summary,
                 score: finalScore,
-                sim: normalizedSim,
-                bm25: normalizedBm25
+                sim,
+                bm25: normalizedBm25,
             };
         }
         catch (err) {
-            console.error(`Error processing embedding for file: ${result.path}`, err);
+            console.error(`❌ Error processing embedding for file: ${result.path}`, err);
             return null;
         }
-    }).filter(Boolean)
+    })
+        .filter((r) => r !== null)
         .sort((a, b) => b.score - a.score)
         .slice(0, topK);
+    console.log(`Returning top ${topK} results based on combined score`);
     return scored;
 }
+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);
+}

package/dist/db/schema.js

@@ -11,9 +11,25 @@ export function initSchema() {
       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='');
+    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;
   `);
-    console.log('✅ SQLite schema initialized');
+    console.log('✅ SQLite schema initialized with FTS5 triggers');
 }

package/dist/db/sqlTemplates.js

@@ -1,29 +1,23 @@
-// 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)
+// 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)
+  ON CONFLICT(path) DO UPDATE SET
+    summary = CASE
+      WHEN excluded.summary IS NOT NULL AND excluded.summary != files.summary
+      THEN excluded.summary
+      ELSE files.summary
+    END,
+    type = excluded.type,
+    last_modified = excluded.last_modified,
+    indexed_at = excluded.indexed_at,
+    embedding = CASE
+      WHEN excluded.embedding IS NOT NULL AND excluded.embedding != files.embedding
+      THEN excluded.embedding
+      ELSE files.embedding
+    END
 `;
-// 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
+// Fetch search results with BM25 ranking
 export const fetchBm25ScoresTemplate = `
   SELECT f.path, f.summary, f.type, bm25(files_fts) AS bm25Score
   FROM files_fts
@@ -31,7 +25,17 @@ export const fetchBm25ScoresTemplate = `
   WHERE files_fts MATCH :query
   LIMIT 50
 `;
-// Template for fetching embedding for a specific file
+// Fetch embedding vector for a file
 export const fetchEmbeddingTemplate = `
   SELECT embedding FROM files WHERE path = :path
 `;
+// Used for non-embedding query in `queryFiles()`
+export const rawQueryTemplate = `
+  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
+`;

package/dist/index.js

@@ -5,9 +5,6 @@ import { Config } from './config.js';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 const { version } = require('../package.json');
-// 🧠 Commands
-import { checkEnv } from "./commands/EnvCmd.js";
-import { checkGit } from "./commands/GitCmd.js";
 import { suggestCommitMessage } from "./commands/CommitSuggesterCmd.js";
 import { handleRefactor } from "./commands/RefactorCmd.js";
 import { generateTests } from "./commands/TestGenCmd.js";
@@ -18,7 +15,7 @@ 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 { startDaemon } from './commands/DaemonCmd.js';
 import { runStopDaemonCommand } from "./commands/StopDaemonCmd.js";
 import { runAskCommand } from './commands/AskCmd.js';
 // 🎛️ CLI Setup
@@ -34,12 +31,14 @@ cmd
     await bootstrap();
     console.log('✅ Model initialization completed!');
 });
+cmd
+    .command('sugg')
+    .description('Suggest a commit message from staged changes')
+    .option('-c, --commit', 'Automatically commit with suggested message')
+    .action(suggestCommitMessage);
 // 🔧 Group: Git-related commands
 const git = cmd.command('git').description('Git utilities');
-git
-    .command('status')
-    .description('Check Git status')
-    .action(checkGit);
+// The sugg command under the 'git' group
 git
     .command('sugg')
     .description('Suggest a commit message from staged changes')
@@ -66,16 +65,6 @@ gen
     .command('tests <file>')
     .description('Generate a Jest test file for the specified JS/TS module')
     .action((file) => generateTests(file));
-// 🔍 Indexing
-cmd
-    .command('index [targetDir]')
-    .description('Index supported files in the given directory (or current folder if none)')
-    .option('-d, --detached', 'Run summarizer daemon after indexing')
-    .option('--force', 'Force indexing even if another folder has already been indexed')
-    .action((targetDir, options) => {
-    const resolvedDir = targetDir ? path.resolve(targetDir) : process.cwd();
-    runIndexCommand(resolvedDir, { detached: options.detached, force: options.force });
-});
 // ⚙️ Group: Configuration settings
 const set = cmd.command('set').description('Set configuration values');
 set
@@ -100,34 +89,47 @@ set
     Config.show();
 });
 // 🧪 Diagnostics and info
-cmd
-    .command('env')
-    .description('Check environment variables')
-    .action(checkEnv);
 cmd
     .command('config')
     .description('Show the currently active model and language settings')
     .action(() => {
     Config.show();
 });
+// Add explanation about alpha features directly in the help menu
+cmd.addHelpText('after', `
+🚨 Alpha Features:
+  - The "index", "daemon", "stop-daemon", "reset-db" commands are considered alpha features.
+  - These commands are in active development and may change in the future.
+
+💡 Use with caution and expect possible changes or instability.
+`);
+// 🔍 Indexing
+cmd
+    .command('index [targetDir]')
+    .description('Index supported files in the given directory (or current folder if none)')
+    .option('--force', 'Force indexing even if another folder has already been indexed')
+    .action((targetDir, options) => {
+    runIndexCommand(targetDir, { force: options.force });
+});
 // 🧠 Query and assistant
 cmd
     .command('query <query>')
     .description('Search indexed files by keyword')
     .action(runQueryCommand);
 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);
+    .command('ask [question...]') // <- the ... makes it variadic
+    .description('Ask a question based on indexed files')
+    .action((questionParts) => {
+    const fullQuery = questionParts?.join(' ');
+    runAskCommand(fullQuery);
 });
 // 🛠️ Background tasks and maintenance
 cmd
     .command('daemon')
     .description('Run background summarization of indexed files')
-    .action(runDaemonBatch);
+    .action(async () => {
+    await startDaemon(); // ignore the return value
+});
 cmd
     .command('stop-daemon')
     .description('Stop the background summarizer daemon')

package/dist/utils/log.js

@@ -0,0 +1,15 @@
+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(' ');
+    const isBackground = process.env.BACKGROUND_MODE === 'true';
+    if (isBackground) {
+        // If running in background, log to a file
+        fs.appendFileSync(LOG_PATH, `[${timestamp}] ${message}\n`);
+    }
+    else {
+        // Otherwise, log to the console
+        console.log(`[${timestamp}] ${message}`);
+    }
+}

package/dist/utils/sanitizeQuery.js

@@ -0,0 +1,16 @@
+// src/utils/sanitizeQuery.ts
+import { STOP_WORDS } from '../config/StopWords.js';
+export function sanitizeQueryForFts(input) {
+    const tokens = input
+        .trim()
+        .split(/\s+/)
+        .map(token => token.toLowerCase())
+        .filter(token => token.length > 2 &&
+        !STOP_WORDS.has(token) &&
+        /^[a-z0-9]+$/.test(token))
+        .map(token => token.replace(/[?*\\"]/g, '').replace(/'/g, "''") + '*');
+    // 👇 Prevent FTS syntax errors by returning a catch-all query
+    if (tokens.length === 0)
+        return '*';
+    return tokens.join(' OR ');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scai",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "type": "module",
   "bin": {
     "scai": "./dist/index.js"
@@ -27,12 +27,14 @@
     "better-sqlite3": "^12.1.1",
     "commander": "^11.0.0",
     "fast-glob": "^3.3.3",
-    "ora": "^8.2.0"
+    "ora": "^8.2.0",
+    "proper-lockfile": "^4.1.2"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/jest": "^30.0.0",
     "@types/node": "^24.0.1",
+    "@types/proper-lockfile": "^4.1.4",
     "jest": "^30.0.2",
     "ts-jest": "^29.4.0",
     "typescript": "^5.8.3"