scai 0.1.117 → 0.1.118

package/dist/config.js

@@ -1,18 +1,22 @@
 import fs from 'fs';
 import path from 'path';
-import { CONFIG_PATH, SCAI_HOME, SCAI_REPOS } from './constants.js';
+import { CONFIG_LOCK_PATH, CONFIG_PATH, DEFAULT_DAEMON_IDLE_SLEEP_MS, DEFAULT_DAEMON_SLEEP_MS, PID_PATH, SCAI_HOME, SCAI_REPOS } from './constants.js';
 import { getDbForRepo } from './db/client.js';
 import { normalizePath } from './utils/contentUtils.js';
 import chalk from 'chalk';
 import { getHashedRepoKey } from './utils/repoKey.js';
 const defaultConfig = {
-    model: 'llama3:8b',
-    contextLength: 4096,
+    model: 'qwen3-coder:30b',
+    contextLength: 32768,
     language: 'ts',
     indexDir: '',
     githubToken: '',
     repos: {},
     activeRepo: null,
+    daemon: {
+        sleepMs: DEFAULT_DAEMON_SLEEP_MS,
+        idleSleepMs: DEFAULT_DAEMON_IDLE_SLEEP_MS,
+    },
 };
 function ensureConfigDir() {
     if (!fs.existsSync(SCAI_HOME)) {
@@ -49,6 +53,23 @@ export function writeConfig(newCfg) {
     }
     fs.writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2));
 }
+export function daemonIsRunning() {
+    if (!fs.existsSync(PID_PATH))
+        return false;
+    const pid = parseInt(fs.readFileSync(PID_PATH, 'utf8'), 10);
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function getDaemonLockedRepo() {
+    if (!fs.existsSync(CONFIG_LOCK_PATH))
+        return null;
+    return fs.readFileSync(CONFIG_LOCK_PATH, 'utf8');
+}
 export const Config = {
     getModel() {
         const cfg = readConfig();
@@ -67,7 +88,6 @@ export const Config = {
             console.log(`📦 Model set for repo '${active}': ${model}`);
         }
         else {
-            // Set global default model
             cfg.model = model;
             console.log(`📦 Global default model set to: ${model}`);
         }
@@ -99,18 +119,12 @@ export const Config = {
         return cfg.repos[activeRepo]?.indexDir ?? '';
     },
     async setIndexDir(indexDir) {
-        // Normalize the provided index directory
         const normalizedIndexDir = normalizePath(indexDir);
-        // Compute a stable repo key
         const repoKey = getHashedRepoKey(normalizedIndexDir);
         const scaiRepoRoot = path.join(SCAI_REPOS, repoKey);
-        // Ensure base folders exist
         fs.mkdirSync(scaiRepoRoot, { recursive: true });
-        // Set the active repo using the precomputed repoKey
         this.setActiveRepo(repoKey);
-        // Update the repo configuration with the normalized indexDir
         await this.setRepoIndexDir(repoKey, normalizedIndexDir);
-        // Initialize DB if it does not exist
         const dbPath = path.join(scaiRepoRoot, 'db.sqlite');
         if (!fs.existsSync(dbPath)) {
             console.log(`📦 Database not found. ${chalk.green('Initializing DB')} at ${normalizePath(dbPath)}`);
@@ -121,20 +135,28 @@ export const Config = {
         const cfg = readConfig();
         if (!cfg.repos[repoKey])
             cfg.repos[repoKey] = {};
-        cfg.repos[repoKey] = {
-            ...cfg.repos[repoKey],
-            indexDir, // Already normalized
-        };
-        await writeConfig(cfg);
+        cfg.repos[repoKey] = { ...cfg.repos[repoKey], indexDir };
+        writeConfig(cfg);
         console.log(`✅ Repo index directory set for ${repoKey} : ${indexDir}`);
     },
     setActiveRepo(repoKey) {
         const cfg = readConfig();
+        // 🔒 Check for running daemon lock
+        const lockedRepo = getDaemonLockedRepo();
+        if (daemonIsRunning() && lockedRepo && lockedRepo !== repoKey) {
+            const sps = lockedRepo.split('-')[0];
+            console.log(`❌ Cannot switch active repo while daemon is running.\n` +
+                `   Daemon is currently locked to repo: ${sps}\n` +
+                `   Go to repository: ${sps}, and stop the daemon first: scai daemon stop`);
+            return false;
+        }
+        // ✅ If allowed, switch
         cfg.activeRepo = repoKey;
         if (!cfg.repos[repoKey])
             cfg.repos[repoKey] = {};
         writeConfig(cfg);
         console.log(`✅ Active repo switched to: ${repoKey}`);
+        return true;
     },
     printAllRepos() {
         const cfg = readConfig();
@@ -175,6 +197,25 @@ export const Config = {
         writeConfig(cfg);
         console.log('✅ GitHub token updated');
     },
+    /* ------------------- 💤 Daemon Config ------------------- */
+    getDaemonConfig() {
+        const cfg = readConfig();
+        const daemonCfg = cfg.daemon ?? { sleepMs: DEFAULT_DAEMON_SLEEP_MS, idleSleepMs: DEFAULT_DAEMON_IDLE_SLEEP_MS };
+        const sleepMs = Number(process.env.SCAI_SLEEP_MS) || daemonCfg.sleepMs;
+        const idleSleepMs = Number(process.env.SCAI_IDLE_SLEEP_MS) || daemonCfg.idleSleepMs;
+        return { sleepMs, idleSleepMs };
+    },
+    setDaemonConfig(newCfg) {
+        const cfg = readConfig();
+        cfg.daemon = {
+            sleepMs: DEFAULT_DAEMON_SLEEP_MS,
+            idleSleepMs: DEFAULT_DAEMON_IDLE_SLEEP_MS,
+            ...cfg.daemon,
+            ...newCfg,
+        };
+        writeConfig(cfg);
+        console.log(`🕒 Daemon configuration updated: ${JSON.stringify(cfg.daemon, null, 2)}`);
+    },
     show() {
         const cfg = readConfig();
         const active = cfg.activeRepo;
@@ -184,6 +225,17 @@ export const Config = {
         console.log(`   Model           : ${repoCfg?.model || cfg.model}`);
         console.log(`   Language        : ${repoCfg?.language || cfg.language}`);
         console.log(`   GitHub Token    : ${cfg.githubToken ? '*****' : 'Not Set'}`);
+        const daemon = this.getDaemonConfig();
+        console.log(`   Daemon sleepMs  : ${daemon.sleepMs}ms`);
+        console.log(`   Daemon idleMs   : ${daemon.idleSleepMs}ms`);
+        // ✅ Show lock status
+        let lockStatus = 'Unlocked';
+        let lockedRepo = null;
+        if (fs.existsSync(CONFIG_LOCK_PATH)) {
+            lockedRepo = fs.readFileSync(CONFIG_LOCK_PATH, 'utf8');
+            lockStatus = `Locked to repo '${lockedRepo}'`;
+        }
+        console.log(`   Daemon Lock     : ${lockStatus}`);
     },
     getRaw() {
         return readConfig();

package/dist/constants.js

@@ -20,6 +20,12 @@ export const PID_PATH = path.join(SCAI_HOME, 'daemon.pid');
  * ~/.scai/config.json
  */
 export const CONFIG_PATH = path.join(SCAI_HOME, 'config.json');
+/**
+ * Path to the daemon lock file that prevents starting multiple daemons
+ * for different repos simultaneously:
+ * ~/.scai/daemon.lock
+ */
+export const CONFIG_LOCK_PATH = path.join(SCAI_HOME, 'daemon.lock');
 /**
  * Path to the daemon log file:
  * ~/.scai/daemon.log
@@ -30,6 +36,16 @@ export const LOG_PATH = path.join(SCAI_HOME, 'daemon.log');
  * ~/.scai/prompt.log
  */
 export const PROMPT_LOG_PATH = path.join(SCAI_HOME, 'prompt.log');
+/**
+ * Default sleep time for the daemon loop in milliseconds.
+ * This is used when no value is configured in the config file or via environment variables.
+ */
+export const DEFAULT_DAEMON_SLEEP_MS = 120000; // 1 minute
+/**
+ * Default idle sleep time for the daemon loop in milliseconds.
+ * Used when the daemon has nothing to process and is idle.
+ */
+export const DEFAULT_DAEMON_IDLE_SLEEP_MS = 300000; // 5 minutes
 /**
  * Get the active index directory based on the active repo.
  *
@@ -50,13 +66,13 @@ export function getIndexDir() {
     }
 }
 /**
- * Limit for number of related files included in model prompt.
+ * Highest ranked results
  */
-export const RELATED_FILES_LIMIT = 5;
+export const NUM_TOPFILES = 5;
 /**
- * Limit for number of candidate files to score.
+ * Limit for number of related files included in model prompt.
  */
-export const CANDIDATE_LIMIT = 100;
+export const RELATED_FILES_LIMIT = 50;
 /**
  * Limit number of summary lines
  */

package/dist/context.js

@@ -1,5 +1,5 @@
 // context.ts
-import { readConfig, writeConfig } from "./config.js";
+import { readConfig, Config } from "./config.js";
 import { normalizePath } from "./utils/contentUtils.js";
 import { getDbForRepo, getDbPathForRepo } from "./db/client.js";
 import fs from "fs";
@@ -37,8 +37,13 @@ export async function updateContext() {
         throw err;
     }
     const activeRepoChanged = cfg.activeRepo !== repoKey;
-    cfg.activeRepo = repoKey;
-    writeConfig(cfg);
+    if (activeRepoChanged) {
+        const switched = Config.setActiveRepo(repoKey);
+        if (switched === false) {
+            // ❗ If switching is denied by lock, stop updateContext completely
+            return false;
+        }
+    }
     const repoCfg = cfg.repos[repoKey];
     let ok = true;
     if (activeRepoChanged) {
@@ -84,14 +89,8 @@ export async function updateContext() {
             chalk.bold(chalk.yellow("scai config set-model <model>")));
         ok = false;
     }
-    else {
-        console.log(chalk.green(`✅ Model '${model}' available`));
-    }
-    if (ok) {
-        console.log(chalk.bold.green("\n✅ Context OK\n"));
-    }
-    else {
-        console.log(chalk.bold.red("\n⚠️ Context incomplete\n"));
+    if (!ok) {
+        console.log(chalk.bold.red("\n⚠️ Repositoriy context not set correctly\n"));
     }
     return ok;
 }

package/dist/daemon/daemonQueues.js

@@ -0,0 +1,63 @@
+import { getDbForRepo } from '../db/client.js';
+import { log } from '../utils/log.js';
+import { countUnprocessedFiles } from '../db/sqlTemplates.js';
+/**
+ * LOOP 1 — Fast indexing
+ */
+export function hasUnindexedFiles() {
+    try {
+        const db = getDbForRepo();
+        const row = db.prepare(countUnprocessedFiles).get();
+        return row.count > 0;
+    }
+    catch (err) {
+        log('❌ hasUnindexedFiles failed:', err);
+        return false;
+    }
+}
+/**
+ * LOOP 2 — Folder capsules
+ * Any folder that contains files but lacks a capsule
+ */
+export function hasUncapsuledFolders() {
+    try {
+        const db = getDbForRepo();
+        const row = db.prepare(`
+          SELECT COUNT(*) AS count
+          FROM (
+            SELECT DISTINCT
+              substr(path, 1, length(path) - length(filename) - 1) AS folder
+            FROM files
+            WHERE processing_status NOT IN ('skipped', 'failed')
+          ) folders
+          LEFT JOIN folder_capsules fc
+            ON fc.path = folders.folder
+          WHERE fc.path IS NULL
+        `).get();
+        return row.count > 0;
+    }
+    catch (err) {
+        log('❌ hasUncapsuledFolders failed:', err);
+        return false;
+    }
+}
+/**
+ * LOOP 3 — Knowledge graph
+ * Files indexed but KG not extracted yet
+ */
+export function hasPendingKgWork() {
+    try {
+        const db = getDbForRepo();
+        const row = db.prepare(`
+          SELECT COUNT(*) AS count
+          FROM files
+          WHERE functions_extracted_at IS NULL
+            AND processing_status NOT IN ('skipped', 'failed')
+        `).get();
+        return row.count > 0;
+    }
+    catch (err) {
+        log('❌ hasPendingKgWork failed:', err);
+        return false;
+    }
+}

package/dist/daemon/daemonWorker.js

@@ -1,80 +1,57 @@
-import { getDbForRepo } from '../db/client.js';
-import { runDaemonBatch } from './daemonBatch.js';
+import { hasUnindexedFiles, hasUncapsuledFolders, hasPendingKgWork, } from './daemonQueues.js';
 import { log } from '../utils/log.js';
-const SLEEP_MS = 2000;
-const IDLE_SLEEP_MS = 5000;
+import { Config } from '../config.js';
+import { runIndexingBatch } from './runIndexingBatch.js';
+import { runKgBatch } from './runKgBatch.js';
+import { runFolderCapsuleBatch } from './runFolderCapsuleBatch.js';
+import { sleep } from '../utils/sleep.js';
 // 🚨 Immediate signal that the worker even starts
 log('🛠️ daemonWorker.js loaded');
-async function isQueueEmpty() {
-    try {
-        const db = getDbForRepo();
-        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;
-    }
-}
 export async function daemonWorker() {
-    log('🚀 Daemon worker starting up...');
+    log('🚀 Daemon worker starting (3-loop mode)...');
+    const { sleepMs, idleSleepMs } = Config.getDaemonConfig();
     while (true) {
         try {
-            log('🔄 Running daemon batch...');
-            // Wrap the batch in debug
-            let didWork = false;
-            try {
-                log('🔹 Running runDaemonBatch()...');
-                didWork = await runDaemonBatch();
-                log('✅ runDaemonBatch() completed successfully');
-            }
-            catch (batchErr) {
-                log('🔥 Error inside runDaemonBatch():', batchErr);
+            // --------------------------------------------------
+            // LOOP 1: FAST FILE INDEXING (HIGHEST PRIORITY)
+            // --------------------------------------------------
+            if (await hasUnindexedFiles()) {
+                log('⚡ Indexing loop: processing files...');
+                const didWork = await runIndexingBatch();
+                if (didWork)
+                    continue; // process next batch immediately
             }
-            if (!didWork) {
-                let queueEmpty = false;
-                try {
-                    log('🔹 Checking if queue is empty...');
-                    queueEmpty = await isQueueEmpty();
-                    log(`🔹 Queue empty status: ${queueEmpty}`);
-                }
-                catch (queueErr) {
-                    log('🔥 Error checking queue status:', queueErr);
-                }
-                if (queueEmpty) {
-                    log('🕊️ No work found. Idling...');
-                    await sleep(IDLE_SLEEP_MS * 3);
-                    continue;
-                }
-                else {
-                    log('🟡 Work queue not empty, but no batch executed.');
-                }
+            // --------------------------------------------------
+            // LOOP 2: FOLDER CAPSULE GENERATION (BLOCKING, FINITE)
+            // --------------------------------------------------
+            if (await hasUncapsuledFolders()) {
+                log('📦 Folder capsule loop: generating capsules...');
+                const didWork = await runFolderCapsuleBatch();
+                if (didWork)
+                    continue; // process next folder batch immediately
             }
-            else {
-                log('✅ Batch executed, sleeping briefly...');
+            // --------------------------------------------------
+            // LOOP 3: KNOWLEDGE GRAPH (BACKGROUND / BEST EFFORT)
+            // --------------------------------------------------
+            if (await hasPendingKgWork()) {
+                log('🧠 KG loop: background enrichment...');
+                await runKgBatch(); // intentionally ignore didWork
+                await sleep(idleSleepMs);
+                continue;
             }
-            await sleep(didWork ? SLEEP_MS : IDLE_SLEEP_MS);
+            // --------------------------------------------------
+            // IDLE
+            // --------------------------------------------------
+            log('🕊️ All queues empty. Idling...');
+            await sleep(idleSleepMs * 6);
         }
         catch (err) {
-            log('🔥 Error in daemonWorker loop:', err);
-            await sleep(IDLE_SLEEP_MS * 2); // prevent tight error loop
+            log('🔥 Fatal error in daemon worker:', err);
+            await sleep(idleSleepMs);
         }
     }
 }
-// Run the daemon
+// Boot
 daemonWorker().catch(err => {
     log('❌ daemonWorker failed to start:', err);
 });
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}

package/dist/daemon/generateSummaries.js

@@ -0,0 +1,58 @@
+import { getDbForRepo } from "../db/client.js";
+import { generate } from "../lib/generate.js";
+export async function generateSummaries() {
+    const db = getDbForRepo();
+    const files = db
+        .prepare(`SELECT path, summary FROM files WHERE summary IS NOT NULL`)
+        .all();
+    // --- Group by folder ---
+    const folders = new Map();
+    for (const { path, summary } of files) {
+        if (!summary)
+            continue;
+        const parts = path.split("/");
+        parts.pop(); // remove filename
+        const folderPath = parts.join("/") || "/";
+        if (!folders.has(folderPath))
+            folders.set(folderPath, []);
+        folders.get(folderPath).push(summary);
+    }
+    // --- Generate folder-level summaries ---
+    for (const [folderPath, summaries] of folders.entries()) {
+        const content = summaries.join("\n\n");
+        const input = {
+            query: `Summarize folder ${folderPath}`,
+            content: `Summarize the following files to describe what this folder (${folderPath}) does:\n\n${content}`,
+        };
+        const response = await generate(input);
+        const summaryText = String(response.content ?? "").trim();
+        db.prepare(`
+      INSERT INTO summaries (path, type, summary, last_generated)
+      VALUES (?, 'folder', ?, datetime('now'))
+      ON CONFLICT(path) DO UPDATE SET
+        summary=excluded.summary,
+        last_generated=datetime('now')
+    `).run(folderPath, summaryText);
+        console.log(`🧠 Folder summary generated for ${folderPath}`);
+    }
+    // --- Project-level summary generation ---
+    const allFolderSummaries = db
+        .prepare(`SELECT summary FROM summaries WHERE type='folder'`)
+        .all()
+        .map((r) => r.summary)
+        .join("\n\n");
+    const projectInput = {
+        query: "Summarize project",
+        content: `Summarize the overall purpose and structure of the project based on these folder summaries:\n\n${allFolderSummaries}`,
+    };
+    const projectResponse = await generate(projectInput);
+    const projectSummary = String(projectResponse.content ?? "").trim();
+    db.prepare(`
+    INSERT INTO summaries (path, type, summary, last_generated)
+    VALUES ('/', 'project', ?, datetime('now'))
+    ON CONFLICT(path) DO UPDATE SET
+      summary=excluded.summary,
+      last_generated=datetime('now')
+  `).run(projectSummary);
+    console.log("🏗️ Project-level summary generated");
+}