scai 0.1.117 → 0.1.119

package/dist/commands/CommitSuggesterCmd.js

@@ -1,14 +1,14 @@
 // File: src/commands/CommitSuggesterCmd.ts
-import { execSync } from 'child_process';
-import readline from 'readline';
-import { commitSuggesterModule } from '../pipeline/modules/commitSuggesterModule.js';
-import { handleChangelogWithCommitMessage } from './ChangeLogUpdateCmd.js';
-import os from 'os';
+import { execSync, spawnSync } from 'child_process';
 import fs from 'fs';
+import os from 'os';
 import path from 'path';
-import { spawnSync } from 'child_process';
 import chalk from 'chalk';
-function askUserToChoose(suggestions) {
+import { commitSuggesterModule } from '../pipeline/modules/commitSuggesterModule.js';
+import { handleChangelogWithCommitMessage } from './ChangeLogUpdateCmd.js';
+import { getRl } from './ReadlineSingleton.js';
+// --- Use the passed readline instance ---
+function askUserToChoose(rl, suggestions) {
     return new Promise((resolve) => {
         console.log('\n💡 AI-suggested commit messages:\n');
         suggestions.forEach((msg, i) => {
@@ -19,28 +19,18 @@ function askUserToChoose(suggestions) {
         console.log(`${suggestions.length + 2}) ✍️  Write your own commit message`);
         console.log(`${suggestions.length + 3}) 🖋️ Edit a suggested commit message`);
         console.log(`${suggestions.length + 4}) ❌ Cancel`);
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
         rl.question(`\n👉 Choose a commit message [1-${suggestions.length + 4}]: `, (answer) => {
-            rl.close();
             const choice = parseInt(answer, 10);
-            if (choice === suggestions.length + 1) {
+            if (choice === suggestions.length + 1)
                 resolve('regenerate');
-            }
-            else if (choice === suggestions.length + 2) {
+            else if (choice === suggestions.length + 2)
                 resolve('custom');
-            }
-            else if (choice === suggestions.length + 3) {
+            else if (choice === suggestions.length + 3)
                 resolve('edit');
-            }
-            else if (choice === suggestions.length + 4) {
+            else if (choice === suggestions.length + 4)
                 resolve('cancel');
-            }
-            else if (!isNaN(choice) && choice >= 1 && choice <= suggestions.length) {
+            else if (!isNaN(choice) && choice >= 1 && choice <= suggestions.length)
                 resolve(choice - 1);
-            }
             else {
                 console.log('⚠️ Invalid selection. Using the first suggestion by default.');
                 resolve(0);
@@ -48,39 +38,18 @@ function askUserToChoose(suggestions) {
         });
     });
 }
-async function promptEditCommitMessage(suggestedMessage) {
-    const tmpFilePath = path.join(os.tmpdir(), 'scai-commit-msg.txt');
-    fs.writeFileSync(tmpFilePath, `# Edit your commit message below.\n# Lines starting with '#' will be ignored.\n\n${suggestedMessage}`);
-    const editor = process.env.EDITOR || (process.platform === 'win32' ? 'notepad' : 'vi');
-    spawnSync(editor, [tmpFilePath], { stdio: 'inherit' });
-    const editedContent = fs.readFileSync(tmpFilePath, 'utf-8');
-    return editedContent
-        .split('\n')
-        .filter(line => !line.trim().startsWith('#'))
-        .join('\n')
-        .trim() || suggestedMessage;
-}
-function askWhichSuggestionToEdit(suggestions) {
+function askWhichSuggestionToEdit(rl, suggestions) {
     return new Promise((resolve) => {
         console.log('\n🖋️ Select a commit message to edit:\n');
-        suggestions.forEach((msg, i) => {
-            console.log(`${i + 1}) ${chalk.hex('#FFA500')(`\`${msg}\``)}`);
-        });
+        suggestions.forEach((msg, i) => console.log(`${i + 1}) ${chalk.hex('#FFA500')(`\`${msg}\``)}`));
         console.log(`${suggestions.length + 1}) ❌ Cancel`);
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        const editPrompt = chalk.magenta(`\n👉 Choose a commit message to edit [1-${suggestions.length + 1}]: `);
-        rl.question(editPrompt, (answer) => {
-            rl.close();
+        const promptText = chalk.magenta(`\n👉 Choose a commit message to edit [1-${suggestions.length + 1}]: `);
+        rl.question(promptText, (answer) => {
             const choice = parseInt(answer, 10);
-            if (!isNaN(choice) && choice >= 1 && choice <= suggestions.length) {
+            if (!isNaN(choice) && choice >= 1 && choice <= suggestions.length)
                 resolve(choice - 1);
-            }
-            else if (choice === suggestions.length + 1) {
+            else if (choice === suggestions.length + 1)
                 resolve('cancel');
-            }
             else {
                 console.log('⚠️ Invalid selection.');
                 resolve('cancel');
@@ -88,30 +57,38 @@ function askWhichSuggestionToEdit(suggestions) {
         });
     });
 }
-function promptCustomMessage() {
+function promptCustomMessage(rl) {
     return new Promise((resolve) => {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
         rl.question('\n📝 Enter your custom commit message:\n> ', (input) => {
-            rl.close();
             resolve(input.trim());
         });
     });
 }
+async function promptEditCommitMessage(suggestedMessage) {
+    const tmpFilePath = path.join(os.tmpdir(), 'scai-commit-msg.txt');
+    fs.writeFileSync(tmpFilePath, `# Edit your commit message below.\n# Lines starting with '#' will be ignored.\n\n${suggestedMessage}`);
+    const editor = process.env.EDITOR || (process.platform === 'win32' ? 'notepad' : 'vi');
+    spawnSync(editor, [tmpFilePath], { stdio: 'inherit' });
+    const editedContent = fs.readFileSync(tmpFilePath, 'utf-8');
+    return editedContent
+        .split('\n')
+        .filter(line => !line.trim().startsWith('#'))
+        .join('\n')
+        .trim() || suggestedMessage;
+}
+// --- Main function ---
 export async function suggestCommitMessage(options) {
+    const { rl, isTemporary } = getRl();
     try {
         let diff = execSync("git diff --cached", { encoding: "utf-8", stdio: "pipe" }).trim();
-        if (!diff) {
+        if (!diff)
             diff = execSync("git diff", { encoding: "utf-8", stdio: "pipe" }).trim();
-        }
         if (!diff) {
             console.log('⚠️ No staged changes to suggest a message for.');
             return;
         }
-        // Continue with commit suggestions
-        const response = await commitSuggesterModule.run({ content: diff });
+        const input = { query: 'Generate commit messages', content: diff };
+        const response = await commitSuggesterModule.run(input);
         const suggestions = response.suggestions || [];
         if (!suggestions.length) {
             console.log('⚠️ No commit suggestions generated.');
@@ -119,22 +96,19 @@ export async function suggestCommitMessage(options) {
         }
         let message = null;
         while (message === null) {
-            const choice = await askUserToChoose(suggestions);
+            const choice = await askUserToChoose(rl, suggestions);
             if (choice === 'regenerate') {
                 console.log('\n🔄 Regenerating suggestions...\n');
-                const response = await commitSuggesterModule.run({ content: diff });
-                suggestions.splice(0, suggestions.length, ...(response.suggestions || []));
+                const newResponse = await commitSuggesterModule.run(input);
+                suggestions.splice(0, suggestions.length, ...(newResponse.suggestions || []));
                 continue;
             }
-            if (choice === 'custom') {
-                message = await promptCustomMessage();
-            }
+            if (choice === 'custom')
+                message = await promptCustomMessage(rl);
             else if (choice === 'edit') {
-                // Ask which suggestion to edit using a dedicated prompt
-                const editChoice = await askWhichSuggestionToEdit(suggestions);
-                if (typeof editChoice === 'number') {
+                const editChoice = await askWhichSuggestionToEdit(rl, suggestions);
+                if (typeof editChoice === 'number')
                     message = await promptEditCommitMessage(suggestions[editChoice]);
-                }
                 else {
                     console.log('⚠️ Edit cancelled, returning to main menu.');
                     continue;
@@ -144,26 +118,27 @@ export async function suggestCommitMessage(options) {
                 console.log('❌ Commit cancelled.');
                 return;
             }
-            else {
+            else
                 message = suggestions[choice];
-            }
         }
         console.log(`\n✅ Selected commit message:\n${message}\n`);
-        // If changelog option is enabled, generate changelog including the selected commit message
-        if (options.changelog) {
+        if (options.changelog)
             await handleChangelogWithCommitMessage(message);
-        }
         const staged = execSync("git diff --cached", { encoding: "utf-8" }).trim();
         if (!staged) {
             console.log("⚠️ No files are currently staged for commit.");
             console.log("👉 Please stage your changes with 'git add <files>' and rerun the command.");
             return;
         }
-        // Automatically commit the suggested message
         execSync(`git commit -m "${message.replace(/"/g, '\\"')}"`, { stdio: 'inherit' });
         console.log('✅ Committed with selected message.');
     }
     catch (err) {
         console.error('❌ Error in commit message suggestion:', err.message);
     }
+    finally {
+        if (isTemporary) {
+            rl.close(); // 👈 THIS is what allows the process to exit
+        }
+    }
 }

package/dist/commands/DaemonCmd.js

@@ -1,44 +1,134 @@
-import fsSync, { mkdirSync } from 'fs';
-import { LOG_PATH, PID_PATH } from '../constants.js';
-import { log } from '../utils/log.js';
+import fs from 'fs';
+import path from 'path';
 import { spawn } from 'child_process';
 import { fileURLToPath } from 'url';
-import path from 'path';
+import { LOG_PATH, PID_PATH, CONFIG_LOCK_PATH } from '../constants.js';
+import { Config } from '../config.js';
+import { getDbPathForRepo } from '../db/client.js';
+// --- Helpers ---
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function lockConfig(repoKey) {
+    fs.writeFileSync(CONFIG_LOCK_PATH, repoKey, { encoding: 'utf8' });
+}
+function unlockConfigFile() {
+    if (fs.existsSync(CONFIG_LOCK_PATH)) {
+        fs.unlinkSync(CONFIG_LOCK_PATH);
+    }
+}
+function getLockedRepo() {
+    return fs.existsSync(CONFIG_LOCK_PATH)
+        ? fs.readFileSync(CONFIG_LOCK_PATH, 'utf8')
+        : null;
+}
+// --- Commands ---
 export async function startDaemon() {
-    // If there's a PID file, check if the process is still running
-    if (fsSync.existsSync(PID_PATH)) {
-        const pid = parseInt(fsSync.readFileSync(PID_PATH, 'utf8'));
-        try {
-            process.kill(pid, 0); // Check if process exists
-            log(`⚠️ Daemon already running with PID ${pid}.`);
+    const cfg = Config.getRaw();
+    const activeRepo = cfg.activeRepo;
+    if (!activeRepo) {
+        console.log('❌ No active repo configured. Use `askcmd repo set <path>` first.');
+        return;
+    }
+    const dbPath = getDbPathForRepo();
+    if (!fs.existsSync(dbPath)) {
+        console.log(`❌ Cannot start daemon. Index/database not initialized for repo '${activeRepo}'.`);
+        console.log(`   Run the index command first: scai index start`);
+        return;
+    }
+    const lockedRepo = getLockedRepo();
+    if (lockedRepo && lockedRepo !== activeRepo) {
+        console.log(`🔒 Daemon already locked to repo: ${lockedRepo}`);
+        console.log(`   Current active repo: ${activeRepo}`);
+        console.log(`   Stop the daemon before starting another.`);
+        return;
+    }
+    if (fs.existsSync(PID_PATH)) {
+        const pid = parseInt(fs.readFileSync(PID_PATH, 'utf8'), 10);
+        if (isProcessRunning(pid)) {
+            console.log(`⚠️  Daemon already running with PID ${pid}.`);
             return;
         }
-        catch {
-            log(`⚠️ Stale PID file found. Removing and restarting daemon...`);
-            fsSync.unlinkSync(PID_PATH);
+        else {
+            console.log(`🧹 Removing stale PID file...`);
+            fs.unlinkSync(PID_PATH);
         }
     }
-    log('🚀 Starting summarizer daemon in background mode...');
-    log(`📝 Logs will be saved to: ${LOG_PATH}`);
+    console.log(`🚀 Starting daemon for repo: ${activeRepo}`);
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = path.dirname(__filename);
-    const daemonWorkerPath = path.join(__dirname, '../daemon/daemonWorker.js');
-    const out = fsSync.openSync(LOG_PATH, 'a');
-    const err = fsSync.openSync(LOG_PATH, 'a');
-    const child = spawn(process.execPath, [daemonWorkerPath], {
+    const workerPath = path.join(__dirname, '../daemon/daemonWorker.js');
+    fs.mkdirSync(path.dirname(LOG_PATH), { recursive: true });
+    fs.mkdirSync(path.dirname(PID_PATH), { recursive: true });
+    const out = fs.openSync(LOG_PATH, 'a');
+    const err = fs.openSync(LOG_PATH, 'a');
+    const child = spawn(process.execPath, [workerPath], {
         detached: true,
-        stdio: ['ignore', out, err], // stdout/stderr -> log file
-        env: {
-            ...process.env,
-            BACKGROUND_MODE: 'true',
-        }
+        stdio: ['ignore', out, err],
+        env: { ...process.env, BACKGROUND_MODE: 'true' },
     });
     child.unref();
-    try {
-        mkdirSync(path.dirname(PID_PATH), { recursive: true });
-        fsSync.writeFileSync(PID_PATH, String(child.pid));
+    fs.writeFileSync(PID_PATH, String(child.pid));
+    lockConfig(activeRepo);
+    console.log(`✅ Daemon started (PID ${child.pid})`);
+}
+export async function stopDaemon() {
+    if (!fs.existsSync(PID_PATH)) {
+        console.log(`ℹ️  No PID file found.`);
+        return;
+    }
+    const pid = parseInt(fs.readFileSync(PID_PATH, 'utf8'), 10);
+    if (isProcessRunning(pid)) {
+        console.log(`🛑 Stopping daemon (PID ${pid})...`);
+        process.kill(pid);
+    }
+    else {
+        console.log(`⚠️  Stale PID ${pid}.`);
+    }
+    fs.unlinkSync(PID_PATH);
+    unlockConfigFile();
+    console.log(`✅ Daemon stopped and unlocked.`);
+}
+export async function statusDaemon() {
+    const lockedRepo = getLockedRepo();
+    if (!fs.existsSync(PID_PATH)) {
+        console.log(`🔴 Daemon not running.`);
+        if (lockedRepo)
+            console.log(`   (Locked to repo ${lockedRepo})`);
+        return;
+    }
+    const pid = parseInt(fs.readFileSync(PID_PATH, 'utf8'), 10);
+    if (isProcessRunning(pid)) {
+        console.log(`🟢 Daemon running (PID ${pid})`);
+        if (lockedRepo)
+            console.log(`   ↳ Repo: ${lockedRepo}`);
+    }
+    else {
+        console.log(`🟡 Stale PID file (${pid}) found.`);
     }
-    catch (err) {
-        log(`❌ Failed to write PID file: ${err instanceof Error ? err.message : err}`);
+}
+export async function restartDaemon() {
+    console.log(`♻️ Restarting daemon...`);
+    await stopDaemon();
+    await startDaemon();
+}
+export async function unlockConfig() {
+    unlockConfigFile();
+    console.log(`🔓 Configuration unlocked.`);
+}
+export async function showLogs(lines = 20) {
+    if (!fs.existsSync(LOG_PATH)) {
+        console.log(`ℹ️  No logs yet.`);
+        return;
     }
+    const content = fs.readFileSync(LOG_PATH, 'utf8');
+    const tail = content.split('\n').slice(-lines).join('\n');
+    console.log(`\n--- Daemon Logs (last ${lines} lines) ---\n`);
+    console.log(tail);
 }

package/dist/commands/IndexCmd.js

@@ -2,7 +2,6 @@
 import fg from 'fast-glob';
 import path from 'path';
 import { initSchema } from '../db/schema.js';
-import { indexFile } from '../db/fileIndex.js';
 import { detectFileType } from '../fileRules/detectFileType.js';
 import { startDaemon } from './DaemonCmd.js';
 import { IGNORED_FOLDER_GLOBS } from '../fileRules/ignoredPaths.js';
@@ -10,11 +9,11 @@ import { Config } from '../config.js';
 import { log } from '../utils/log.js';
 import lockfile from 'proper-lockfile';
 import { classifyFile } from '../fileRules/classifyFile.js';
-import { getDbPathForRepo } from '../db/client.js';
+import { getDbForRepo, getDbPathForRepo } from '../db/client.js';
+import { upsertFileTemplate } from '../db/sqlTemplates.js';
 async function lockDb() {
     try {
-        const lock = await lockfile.lock(getDbPathForRepo());
-        return lock;
+        return await lockfile.lock(getDbPathForRepo());
     }
     catch (err) {
         log('❌ Failed to acquire DB lock: ' + err);
@@ -37,29 +36,47 @@ export async function runIndexCommand() {
         ignore: IGNORED_FOLDER_GLOBS,
         absolute: true,
     });
+    const db = getDbForRepo();
+    const release = await lockDb();
     const countByExt = {};
     let count = 0;
-    const release = await lockDb();
-    for (const file of files) {
-        const classification = classifyFile(file);
-        if (classification !== 'valid') {
-            log(`⏭️ Skipping (${classification}): ${file}`);
-            continue;
-        }
-        try {
-            const type = detectFileType(file);
-            indexFile(file, null, type);
-            const ext = path.extname(file);
-            countByExt[ext] = (countByExt[ext] || 0) + 1;
-            log(`📄 Indexed: ${path.relative(indexDir, file)}`);
-            count++;
-        }
-        catch (err) {
-            log(`⚠️ Skipped in indexCmd ${file}: ${err instanceof Error ? err.message : err}`);
+    try {
+        for (const file of files) {
+            const classification = classifyFile(file);
+            if (classification !== 'valid') {
+                log(`⏭️ Skipping (${classification}): ${file}`);
+                continue;
+            }
+            try {
+                const normalizedPath = path.normalize(file).replace(/\\/g, '/');
+                const filename = path.basename(normalizedPath);
+                const type = detectFileType(file);
+                // -----------------------------
+                // ENQUEUE: mark file as unprocessed
+                // -----------------------------
+                db.prepare(upsertFileTemplate).run({
+                    path: normalizedPath,
+                    filename,
+                    summary: null,
+                    type,
+                    lastModified: null,
+                    indexedAt: null,
+                });
+                const ext = path.extname(file);
+                countByExt[ext] = (countByExt[ext] || 0) + 1;
+                log(`📄 Enqueued: ${path.relative(indexDir, file)}`);
+                count++;
+            }
+            catch (err) {
+                log(`⚠️ Skipped in indexCmd ${file}: ${err instanceof Error ? err.message : err}`);
+            }
         }
     }
-    log('📊 Indexed files by extension:', JSON.stringify(countByExt, null, 2));
-    log(`✅ Done. Indexed ${count} files.`);
-    await release();
+    finally {
+        await release();
+    }
+    log('📊 Files by extension:', JSON.stringify(countByExt, null, 2));
+    log(`✅ Done. Enqueued ${count} files for indexing.`);
+    // Kick the daemon — it now owns all processing
     startDaemon();
 }

package/dist/commands/InspectCmd.js

@@ -25,7 +25,6 @@ export async function runInspectCommand(fileArg) {
     console.log(`🆔 File ID:             ${file.id}`);
     console.log(`📄 Indexed at:          ${file.indexed_at || '❌ Not yet'}`);
     console.log(`🧠 Summary present:     ${file.summary ? '✅' : '❌'}`);
-    console.log(`🧠 Embedding present:   ${file.embedding ? '✅' : '❌'}`);
     const isExtracted = file.processing_status?.includes('extracted');
     console.log(`📌 Functions extracted: ${isExtracted ? '✅' : '❌'}`);
     console.log(`📆 Extracted at:        ${file.functions_extracted_at || '❌ Not yet'}`);

package/dist/commands/ReadlineSingleton.js

@@ -0,0 +1,18 @@
+// File: src/commands/ReadlineSingleton.ts
+import readline from 'readline';
+let currentRl = null;
+export function setRl(rl) {
+    currentRl = rl;
+}
+export function getRl() {
+    if (currentRl) {
+        return { rl: currentRl, isTemporary: false };
+    }
+    return {
+        rl: readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        }),
+        isTemporary: true
+    };
+}

package/dist/commands/ResetDbCmd.js

@@ -43,29 +43,28 @@ export async function resetDatabase() {
     catch (err) {
         console.warn('⚠️ Failed to release database lock:', err instanceof Error ? err.message : err);
     }
-    // Delete DB file
-    if (fs.existsSync(dbPath)) {
-        try {
-            fs.unlinkSync(dbPath);
-            console.log(`🧹 Deleted existing database at ${dbPath}`);
-        }
-        catch (err) {
-            console.error('❌ Failed to delete DB file:', err instanceof Error ? err.message : err);
+    // Delete DB and related files
+    const dbDir = path.dirname(dbPath);
+    const dbBase = path.basename(dbPath);
+    const dbPrefix = dbBase.replace(/\.sqlite$/, '');
+    const filesToDelete = [
+        `${dbPath}`,
+        path.join(dbDir, `${dbPrefix}.sqlite-wal`),
+        path.join(dbDir, `${dbPrefix}.sqlite-shm`),
+    ];
+    const lockDir = `${dbPath}.lock`;
+    for (const file of filesToDelete) {
+        if (fs.existsSync(file)) {
+            try {
+                fs.unlinkSync(file);
+                console.log(`🧹 Deleted ${path.basename(file)}`);
+            }
+            catch (err) {
+                console.error(`❌ Failed to delete ${file}:`, err instanceof Error ? err.message : err);
+            }
         }
     }
-    else {
-        console.log('ℹ️ No existing database found at:', dbPath);
-    }
-    // Ensure directory exists
-    try {
-        fs.mkdirSync(path.dirname(dbPath), { 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);
-    }
     // Clean up lock directory
-    const lockDir = `${dbPath}.lock`;
     if (fs.existsSync(lockDir)) {
         try {
             fs.rmSync(lockDir, { recursive: true, force: true });
@@ -75,5 +74,5 @@ export async function resetDatabase() {
             console.warn('⚠️ Failed to remove lock directory:', err instanceof Error ? err.message : err);
         }
     }
-    console.log('✅ Database has been reset.' + chalk.yellow('You can now re-run: scai index start'));
+    console.log('✅ Database has been fully reset. ' + chalk.yellow('You can now re-run: scai index start'));
 }