scai 0.1.56 → 0.1.57

package/README.md

@@ -57,6 +57,7 @@ scai runs entirely on your machine and doesn't require cloud APIs or API keys. T
 No more struggling to write pull request descriptions by hand. `scai git review` automatically generates a rich summary of your changes, complete with context, suggestions, and rationale.
 
 > ⚠️ These features are in **beta** — feedback welcome!
+Ping [@ticcr](https://bsky.app/profile/ticcr.xyz) on Bluesky — I'd love to hear your thoughts!
 
 ---
 
@@ -87,7 +88,7 @@ To interact with GitHub and create pull requests, `scai` needs a personal access
 3. **Set the index dir:**
 
    ```bash
-   scai set index-dir <repo path>
+   scai index set /path/to/repo
    ```
 
    This is the repo from which scai will look up pull requests that can be reviewed. 
@@ -116,10 +117,16 @@ SCAI supports an integrated review flow for GitHub pull requests. To get started
 1. **Set your working index directory (once per repo):**
 
    ```sh
-   scai set index-dir .
+   scai index set /path/to/repo
    ```
 
 2. **Authenticate with GitHub:**
+   ```sh
+   scai git review
+   ```
+
+   This command will query you for the Personal Access Token and set it for you. 
+   You may also do this with the auth commands below
 
    ```sh
    scai auth set
@@ -170,25 +177,19 @@ You might consider renaming `sessionManager` to better reflect its dual role in
 
 
 
-### 🔧  How to Use `scai git sugg`
+### 🔧  How to Use `scai git commit`
 
 Use AI to suggest a meaningful commit message based on your staged code:
 
 ```bash
 git add .
-scai git sugg
-```
-
-To automatically commit with the selected suggestion:
-
-```bash
-scai git sugg --commit
+scai git commit
 ```
 
 You can also include a changelog entry along with the commit:
 
 ```bash
-scai git sugg --commit --changelog
+scai git commit --changelog
 ```
 
 This will:
@@ -287,13 +288,13 @@ You won't gain much value from the index unless you scope it to one repository.
 1. **Set index directory:**
 
     ```bash
-    scai set index-dir /path/to/repo
+    scai index set /path/to/repo
     ```
 
 2. **Index your repo (once):**
 
    ```bash
-   scai index 
+   scai index start
    ```
 
 3. The daemon is designed to **consume minimal resources** and run unobtrusively. You can control it with:

package/dist/commands/AskCmd.js

@@ -7,7 +7,7 @@ import { generate } from '../lib/generate.js';
 import { buildContextualPrompt } from '../utils/buildContextualPrompt.js';
 import { generateFocusedFileTree } from '../utils/fileTree.js';
 import { log } from '../utils/log.js';
-import { PROMPT_LOG_PATH, SCAI_HOME, INDEX_DIR, RELATED_FILES_LIMIT, MAX_SUMMARY_LINES } from '../constants.js';
+import { PROMPT_LOG_PATH, SCAI_HOME, RELATED_FILES_LIMIT, MAX_SUMMARY_LINES, getIndexDir } from '../constants.js';
 export async function runAskCommand(query) {
     if (!query) {
         query = await promptOnce('💬 Ask your question:\n');
@@ -17,7 +17,7 @@ export async function runAskCommand(query) {
         console.error('❌ No question provided.\n👉 Usage: scai ask "your question"');
         return;
     }
-    console.log(`📁 Using index root: ${INDEX_DIR}`);
+    console.log(`📁 Using index root: ${getIndexDir}`);
     console.log(`🔍 Searching for: "${query}"\n`);
     // 🟩 STEP 1: Semantic Search
     const start = Date.now();
@@ -103,7 +103,7 @@ export async function runAskCommand(query) {
     // 🟩 STEP 6: Generate file tree
     let fileTree = '';
     try {
-        fileTree = generateFocusedFileTree(INDEX_DIR, filepath, 2);
+        fileTree = generateFocusedFileTree(filepath, 2);
     }
     catch (e) {
         console.warn('⚠️ Could not generate file tree:', e);

package/dist/commands/CommitSuggesterCmd.js

@@ -63,6 +63,7 @@ export async function suggestCommitMessage(options) {
             console.log('⚠️  No staged changes to suggest a message for.');
             return;
         }
+        // Handle changelog generation if the flag is provided
         if (options.changelog) {
             let entryFinalized = false;
             while (!entryFinalized) {
@@ -122,6 +123,7 @@ export async function suggestCommitMessage(options) {
             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.');
     }

package/dist/commands/IndexCmd.js

@@ -1,3 +1,4 @@
+// indexCmd.ts
 import fg from 'fast-glob';
 import path from 'path';
 import { initSchema } from '../db/schema.js';
@@ -6,14 +7,13 @@ import { detectFileType } from '../fileRules/detectFileType.js';
 import { startDaemon } from './DaemonCmd.js';
 import { IGNORED_FOLDER_GLOBS } from '../fileRules/ignoredPaths.js';
 import { Config } from '../config.js';
-import { DB_PATH } from '../constants.js';
 import { log } from '../utils/log.js';
 import lockfile from 'proper-lockfile';
 import { classifyFile } from '../fileRules/classifyFile.js';
-// 🧠 Lock the database to prevent simultaneous access
+import { getDbPathForRepo } from '../db/client.js';
 async function lockDb() {
     try {
-        const lock = await lockfile.lock(DB_PATH); // DB_PATH from constants.ts
+        const lock = await lockfile.lock(getDbPathForRepo());
         return lock;
     }
     catch (err) {
@@ -21,7 +21,7 @@ async function lockDb() {
         throw err;
     }
 }
-export async function runIndexCommand(targetDir, options = {}) {
+export async function runIndexCommand() {
     try {
         initSchema();
     }
@@ -29,31 +29,17 @@ export async function runIndexCommand(targetDir, options = {}) {
         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 indexDir = Config.getIndexDir() || process.cwd();
+    Config.setIndexDir(indexDir); // persist if not already saved
+    log(`📂 Indexing files in: ${indexDir}`);
     const files = await fg('**/*.*', {
-        cwd: resolvedDir,
+        cwd: indexDir,
         ignore: IGNORED_FOLDER_GLOBS,
         absolute: true,
     });
     const countByExt = {};
     let count = 0;
-    const release = await lockDb(); // Lock the DB before starting
+    const release = await lockDb();
     for (const file of files) {
         const classification = classifyFile(file);
         if (classification !== 'valid') {
@@ -62,10 +48,10 @@ export async function runIndexCommand(targetDir, options = {}) {
         }
         try {
             const type = detectFileType(file);
-            indexFile(file, null, type); // Index file without summary
+            indexFile(file, null, type);
             const ext = path.extname(file);
             countByExt[ext] = (countByExt[ext] || 0) + 1;
-            log(`📄 Indexed: ${path.relative(resolvedDir, file)}`);
+            log(`📄 Indexed: ${path.relative(indexDir, file)}`);
             count++;
         }
         catch (err) {
@@ -74,7 +60,6 @@ export async function runIndexCommand(targetDir, options = {}) {
     }
     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
+    await release();
     startDaemon();
 }

package/dist/commands/InspectCmd.js

@@ -1,7 +1,7 @@
-import { db } from '../db/client.js';
 import path from 'path';
 import fs from 'fs';
 import { log } from '../utils/log.js';
+import { getDbForRepo } from '../db/client.js';
 export async function runInspectCommand(fileArg) {
     if (!fileArg) {
         log('❌ Please provide a file path to inspect.');
@@ -12,6 +12,7 @@ export async function runInspectCommand(fileArg) {
         log(`❌ File does not exist: ${resolvedPath}`);
         process.exit(1);
     }
+    const db = getDbForRepo();
     const file = db
         .prepare(`SELECT * FROM files WHERE REPLACE(path, '\\', '/') = ?`)
         .get(resolvedPath);
@@ -29,12 +30,10 @@ export async function runInspectCommand(fileArg) {
     console.log(`📌 Functions extracted: ${isExtracted ? '✅' : '❌'}`);
     console.log(`📆 Extracted at:        ${file.functions_extracted_at || '❌ Not yet'}`);
     console.log(`⚙️  Processing status:   ${file.processing_status || 'unknown'}`);
-    // 📝 Show summary preview
     if (file.summary) {
         console.log('\n📝 Summary:');
         console.log(file.summary.slice(0, 300) + (file.summary.length > 300 ? '...' : ''));
     }
-    // 🧑‍💻 Show extracted functions
     const functions = db
         .prepare(`SELECT name, start_line, end_line FROM functions WHERE file_id = ? ORDER BY start_line ASC`)
         .all(file.id);

package/dist/commands/ResetDbCmd.js

@@ -1,21 +1,24 @@
 import fs from 'fs';
 import path from 'path';
 import lockfile from 'proper-lockfile';
-import { db } from '../db/client.js';
-import { DB_PATH } from '../constants.js';
-import { backupScaiFolder } from '../db/backup.js'; // <-- New import
+import { backupScaiFolder } from '../db/backup.js';
+import { getDbPathForRepo, getDbForRepo } from '../db/client.js';
 export async function resetDatabase() {
     console.log('🔁 Backing up existing .scai folder...');
     await backupScaiFolder();
+    const dbPath = getDbPathForRepo();
+    // Close the DB connection
     try {
+        const db = getDbForRepo();
         db.close();
         console.log('🔒 Closed SQLite database connection.');
     }
     catch (err) {
         console.warn('⚠️ Could not close database:', err instanceof Error ? err.message : err);
     }
+    // Release lockfile if present
     try {
-        const releaseLock = await lockfile.unlock(DB_PATH).catch(() => null);
+        const releaseLock = await lockfile.unlock(dbPath).catch(() => null);
         if (releaseLock) {
             console.log('🔓 Released database lock.');
         }
@@ -23,27 +26,29 @@ export async function resetDatabase() {
     catch (err) {
         console.warn('⚠️ Failed to release database lock:', err instanceof Error ? err.message : err);
     }
-    if (fs.existsSync(DB_PATH)) {
+    // Delete DB file
+    if (fs.existsSync(dbPath)) {
         try {
-            fs.unlinkSync(DB_PATH);
-            console.log(`🧹 Deleted existing database at ${DB_PATH}`);
+            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);
-            return;
         }
     }
     else {
-        console.log('ℹ️ No existing database found at:', DB_PATH);
+        console.log('ℹ️ No existing database found at:', dbPath);
     }
+    // Ensure directory exists
     try {
-        fs.mkdirSync(path.dirname(DB_PATH), { recursive: true });
+        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);
     }
-    const lockDir = `${DB_PATH}.lock`;
+    // Clean up lock directory
+    const lockDir = `${dbPath}.lock`;
     if (fs.existsSync(lockDir)) {
         try {
             fs.rmSync(lockDir, { recursive: true, force: true });

package/dist/commands/SummaryCmd.js

@@ -7,7 +7,7 @@ import { summarizeCode } from '../utils/summarizer.js';
 import { detectFileType } from '../fileRules/detectFileType.js';
 import { generateEmbedding } from '../lib/generateEmbedding.js';
 import { sanitizeQueryForFts } from '../utils/sanitizeQuery.js';
-import { db } from '../db/client.js';
+import { getDbForRepo } from '../db/client.js';
 export async function summarizeFile(filepath) {
     let content = '';
     let filePathResolved;
@@ -71,9 +71,10 @@ export async function summarizeFile(filepath) {
             console.log('💾 Summary saved to local database.');
             const embedding = await generateEmbedding(response.summary);
             if (embedding) {
+                const db = getDbForRepo();
                 db.prepare(`
-          UPDATE files SET embedding = ? WHERE path = ?
-        `).run(JSON.stringify(embedding), filePathResolved.replace(/\\/g, '/'));
+            UPDATE files SET embedding = ? WHERE path = ?
+          `).run(JSON.stringify(embedding), filePathResolved.replace(/\\/g, '/'));
                 console.log('📐 Embedding saved to database.');
             }
         }

package/dist/commands/SwitchCmd.js

@@ -0,0 +1,73 @@
+// File: src/commands/switch.ts
+import readline from 'readline';
+import { Config, writeConfig } from '../config.js';
+import { normalizePath, getRepoKeyForPath } from '../utils/normalizePath.js';
+import chalk from 'chalk';
+export function runSwitchCommand(inputPathOrKey) {
+    const config = Config.getRaw();
+    const normalizedInput = normalizePath(inputPathOrKey);
+    // Try to match by key directly
+    if (config.repos[normalizedInput]) {
+        config.activeRepo = normalizedInput;
+        // Update GitHub token
+        Config.setGitHubToken(config.repos[normalizedInput].githubToken ?? '');
+        console.log(`✅ Switched active repo to key: ${normalizedInput}`);
+    }
+    else {
+        // Try to match by indexDir path
+        const repoKey = getRepoKeyForPath(inputPathOrKey, config);
+        if (!repoKey) {
+            console.error(`❌ No repo found matching path or key: "${inputPathOrKey}"`);
+            process.exit(1);
+        }
+        config.activeRepo = repoKey;
+        // Update GitHub token
+        Config.setGitHubToken(config.repos[repoKey]?.githubToken ?? '');
+        console.log(`✅ Switched active repo to path match: ${repoKey}`);
+    }
+    // Ensure the active repo change is saved back to the config
+    writeConfig(config);
+}
+export async function runInteractiveSwitch() {
+    const config = Config.getRaw();
+    const keys = Object.keys(config.repos || {});
+    if (!keys.length) {
+        console.log('⚠️ No repositories configured.');
+        return;
+    }
+    // Auto-switch to the other repo if only 2 are present
+    if (keys.length === 2) {
+        const current = config.activeRepo;
+        const other = keys.find(k => k !== current);
+        if (other) {
+            runSwitchCommand(other);
+            return;
+        }
+    }
+    // Otherwise, show interactive selection
+    console.log('\n📁 Available Repositories:\n');
+    keys.forEach((key, i) => {
+        const isActive = config.activeRepo === key ? chalk.green('(active)') : '';
+        const dir = config.repos[key]?.indexDir ?? '';
+        // Color the number using chalk.blue and make active repo green
+        const numberedRepo = chalk.blue(`${i + 1})`);
+        // Highlight the active repo in green and list it
+        console.log(`${numberedRepo} ${key} ${isActive}`);
+        // Use light grey for the indexDir
+        console.log(`    ↳ ${chalk.grey(dir)}`);
+    });
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    rl.question('\n👉 Select a repository number to activate: ', (answer) => {
+        rl.close();
+        const index = parseInt(answer.trim(), 10) - 1;
+        if (isNaN(index) || index < 0 || index >= keys.length) {
+            console.log('❌ Invalid selection.');
+            return;
+        }
+        const selectedKey = keys[index];
+        runSwitchCommand(selectedKey);
+    });
+}

package/dist/config.js

@@ -1,79 +1,199 @@
 import fs from 'fs';
-import { CONFIG_PATH, SCAI_HOME, INDEX_DIR } from './constants.js'; // Correctly import INDEX_DIR from constants
-// Default configuration values
+import path from 'path';
+import { CONFIG_PATH, SCAI_HOME, SCAI_REPOS } from './constants.js';
+import { getDbForRepo } from './db/client.js';
+import { getRepoKeyForPath, normalizePath } from './utils/normalizePath.js';
+import chalk from 'chalk';
 const defaultConfig = {
     model: 'llama3',
     language: 'ts',
-    indexDir: INDEX_DIR, // Default index directory from constants
-    githubToken: '', // Add githubToken to default config
+    indexDir: '',
+    githubToken: '',
+    repos: {},
+    activeRepo: undefined,
 };
-// Function to ensure the configuration directory exists
 function ensureConfigDir() {
     if (!fs.existsSync(SCAI_HOME)) {
         fs.mkdirSync(SCAI_HOME, { recursive: true });
     }
 }
-// Function to read the configuration file
 function readConfig() {
     try {
         const content = fs.readFileSync(CONFIG_PATH, 'utf-8');
         return { ...defaultConfig, ...JSON.parse(content) };
     }
     catch {
-        return defaultConfig; // Return default config if read fails
+        return defaultConfig;
     }
 }
-// Function to write the configuration to the config file
-function writeConfig(newConfig) {
+export function writeConfig(newCfg) {
     ensureConfigDir();
     const current = readConfig();
-    const merged = { ...current, ...newConfig };
+    const merged = {
+        ...current,
+        ...newCfg,
+        repos: {
+            ...current.repos,
+            ...(newCfg.repos || {}),
+        },
+    };
     fs.writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2));
 }
 export const Config = {
-    // Get the current model from the config
     getModel() {
-        return readConfig().model;
+        const cfg = readConfig();
+        const repoCfg = cfg.repos?.[cfg.activeRepo ?? ''];
+        return repoCfg?.model || cfg.model;
     },
-    // Set a new model in the config
     setModel(model) {
-        writeConfig({ model });
-        console.log(`📦 Model set to: ${model}`);
+        const cfg = readConfig();
+        const active = cfg.activeRepo;
+        if (active) {
+            cfg.repos[active] = { ...cfg.repos[active], model };
+            writeConfig(cfg);
+            console.log(`📦 Model set to: ${model}`);
+        }
+        else {
+            writeConfig({ model });
+            console.log(`📦 Default model set to: ${model}`);
+        }
     },
-    // Get the current language from the config
     getLanguage() {
-        return readConfig().language;
+        const cfg = readConfig();
+        const repoCfg = cfg.repos?.[cfg.activeRepo ?? ''];
+        return repoCfg?.language || cfg.language;
     },
-    // Set a new language in the config
     setLanguage(language) {
-        writeConfig({ language });
-        console.log(`🗣️ Language set to: ${language}`);
+        const cfg = readConfig();
+        const active = cfg.activeRepo;
+        if (active) {
+            cfg.repos[active] = { ...cfg.repos[active], language };
+            writeConfig(cfg);
+            console.log(`🗣️ Language set to: ${language}`);
+        }
+        else {
+            writeConfig({ language });
+            console.log(`🗣️ Default language set to: ${language}`);
+        }
     },
-    // Get the index directory from the config
     getIndexDir() {
-        return readConfig().indexDir;
+        const config = readConfig();
+        const activeRepo = config.activeRepo;
+        if (activeRepo) {
+            const normalized = normalizePath(activeRepo);
+            return normalizePath(config.repos[normalized]?.indexDir ?? '');
+        }
+        return '';
+    },
+    async setIndexDir(indexDir) {
+        const absPath = path.resolve(indexDir); // Resolve the index directory to an absolute path
+        const repoKey = normalizePath(absPath); // Normalize path for the repo (get repo name, not full path)
+        // Ensure repoKey doesn't contain an absolute path, only the repo name or a relative path
+        const scaiRepoRoot = path.join(SCAI_REPOS, path.basename(repoKey)); // Use repo name as key to avoid double paths
+        // Set the active repo to the provided indexDir
+        const cfg = readConfig();
+        cfg.activeRepo = repoKey;
+        await writeConfig(cfg); // Persist the change in activeRepo
+        // Call setRepoIndexDir to update the repo's indexDir and other settings
+        await this.setRepoIndexDir(scaiRepoRoot, absPath); // Set the indexDir for the repo
+        // Ensure base folders exist
+        fs.mkdirSync(scaiRepoRoot, { recursive: true });
+        fs.mkdirSync(path.join(scaiRepoRoot, 'summaries'), { recursive: true });
+        fs.mkdirSync(path.join(scaiRepoRoot, 'metadata'), { recursive: true });
+        // Init DB if not exists
+        const dbPath = path.join(scaiRepoRoot, 'db.sqlite');
+        if (!fs.existsSync(dbPath)) {
+            console.log(`Database not found. Initializing DB at ${normalizePath(dbPath)}`);
+            getDbForRepo(); // Now DB creation works after config update
+        }
+        console.log(`✅ Index directory set to: ${normalizePath(absPath)}`);
+    },
+    /**
+     * Set both the scaiRepoRoot for the config and the indexDir (the actual repo root path)
+     * @param scaiRepoRoot
+     * @param indexDir
+     */
+    async setRepoIndexDir(scaiRepoRoot, indexDir) {
+        const normalizedRepoPath = normalizePath(scaiRepoRoot);
+        const normalizedIndexDir = normalizePath(indexDir);
+        const cfg = readConfig();
+        if (!cfg.repos[normalizedRepoPath]) {
+            cfg.repos[normalizedRepoPath] = {};
+        }
+        cfg.repos[normalizedRepoPath] = {
+            ...cfg.repos[normalizedRepoPath],
+            indexDir: normalizedIndexDir, // Ensure the indexDir is always normalized
+        };
+        await writeConfig(cfg); // Persist the config update
+        console.log(`✅ Repo index directory set for ${normalizedRepoPath} : ${normalizedIndexDir}`);
     },
-    // Set a new index directory in the config
-    setIndexDir(indexDir) {
-        writeConfig({ indexDir });
-        console.log(`📁 Index directory set to: ${indexDir}`);
+    setActiveRepo(repoKey) {
+        const cfg = readConfig();
+        cfg.activeRepo = repoKey;
+        writeConfig(cfg);
+        console.log(`✅ Active repo switched to: ${repoKey}`);
+    },
+    printAllRepos() {
+        const cfg = readConfig();
+        const keys = Object.keys(cfg.repos || {});
+        if (!keys.length) {
+            console.log('ℹ️ No repositories configured yet.');
+            return;
+        }
+        console.log('📁 Configured repositories:\n');
+        for (const key of keys) {
+            const r = cfg.repos[key];
+            const isActive = cfg.activeRepo === key;
+            // Use chalk to ensure proper coloring
+            const label = isActive
+                ? chalk.green(`✅ ${key} (active)`) // Active repo in green
+                : chalk.white(`  ${key}`); // Inactive repos in white
+            console.log(`- ${label}`);
+            console.log(`    ↳ indexDir: ${r.indexDir}`);
+        }
     },
-    // Get the GitHub token from the config
+    // Method to get GitHub token for the active repo
     getGitHubToken() {
-        return readConfig().githubToken || null;
+        const cfg = readConfig();
+        const active = cfg.activeRepo;
+        if (active) {
+            // Normalize the active repo path and fetch token from repos[activeRepo]
+            const normalizedActiveRepo = normalizePath(active);
+            return cfg.repos[normalizedActiveRepo]?.githubToken || null;
+        }
+        // If no activeRepo, fall back to the global githubToken field
+        return cfg.githubToken || null;
     },
-    // Set the GitHub token in the config
     setGitHubToken(token) {
-        writeConfig({ githubToken: token });
-        console.log("✅ GitHub token updated");
+        const cfg = readConfig();
+        const active = cfg.activeRepo;
+        if (active) {
+            const repoKey = getRepoKeyForPath(active, cfg) ?? normalizePath(active);
+            if (!cfg.repos[repoKey]) {
+                cfg.repos[repoKey] = {};
+            }
+            cfg.repos[repoKey] = {
+                ...cfg.repos[repoKey],
+                githubToken: token,
+            };
+        }
+        else {
+            cfg.githubToken = token;
+        }
+        writeConfig(cfg);
+        console.log('✅ GitHub token updated');
     },
-    // Show the current configuration
     show() {
         const cfg = readConfig();
+        const active = cfg.activeRepo;
         console.log(`🔧 Current configuration:`);
-        console.log(`   Model     : ${cfg.model}`);
-        console.log(`   Language  : ${cfg.language}`);
-        console.log(`   Index dir : ${cfg.indexDir}`);
-        console.log(`   GitHub Token: ${cfg.githubToken ? '*****' : 'Not Set'}`);
-    }
+        console.log(`   Active index dir: ${active || 'Not Set'}`);
+        const repoCfg = active ? cfg.repos?.[active] : {};
+        console.log(`   Model           : ${repoCfg?.model || cfg.model}`);
+        console.log(`   Language        : ${repoCfg?.language || cfg.language}`);
+        console.log(`   GitHub Token    : ${cfg.githubToken ? '*****' : 'Not Set'}`);
+    },
+    getRaw() {
+        return readConfig();
+    },
 };

package/dist/constants.js

@@ -7,10 +7,9 @@ import fs from 'fs';
  */
 export const SCAI_HOME = path.join(os.homedir(), '.scai');
 /**
- * Full path to the SQLite database used by SCAI:
- * ~/.scai/db.sqlite
+ * Repos dir for multi-repo setup
  */
-export const DB_PATH = path.join(SCAI_HOME, 'db.sqlite');
+export const SCAI_REPOS = path.join(SCAI_HOME, 'repos');
 /**
  * Path to the daemon process ID file (if running in background mode):
  * ~/.scai/daemon.pid
@@ -32,26 +31,24 @@ export const LOG_PATH = path.join(SCAI_HOME, 'daemon.log');
  */
 export const PROMPT_LOG_PATH = path.join(SCAI_HOME, 'prompt.log');
 /**
- * Get the active index directory.
+ * Get the active index directory based on the active repo.
  *
- * - If the user has configured an `indexDir`, use it.
- * - If not, default to the user’s home directory (`~`), not `.scai`.
+ * - If there is an active repository, return its `indexDir` from the config.
+ * - If no active repo is set, default to the user's home directory (`~`).
  */
 export function getIndexDir() {
     try {
         const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
-        return config.indexDir || os.homedir(); // 🏠 Default: ~
+        const activeRepo = config.activeRepo;
+        if (activeRepo && config.repos[activeRepo]) {
+            return config.repos[activeRepo].indexDir || os.homedir(); // Repo-specific indexDir or default to home
+        }
+        return os.homedir(); // Fallback to home if no active repo
     }
     catch (e) {
-        return os.homedir(); // 🏠 Fallback if config file is missing or invalid
+        return os.homedir(); // Fallback if config file is missing or invalid
     }
 }
-/**
- * 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();
 /**
  * Limit for number of related files included in model prompt.
  */
@@ -61,6 +58,6 @@ export const RELATED_FILES_LIMIT = 3;
  */
 export const CANDIDATE_LIMIT = 100;
 /**
- * Limit number of summery lines
+ * Limit number of summary lines
  */
 export const MAX_SUMMARY_LINES = 12;

package/dist/daemon/daemonBatch.js

@@ -1,13 +1,12 @@
 import { indexFunctionsForFile } from '../db/functionIndex.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 { summaryModule } from '../pipeline/modules/summaryModule.js';
 import { classifyFile } from '../fileRules/classifyFile.js';
+import { getDbForRepo, getDbPathForRepo } from '../db/client.js';
 import { markFileAsSkippedByPath, selectUnprocessedFiles, updateFileWithSummaryAndEmbedding, } from '../db/sqlTemplates.js';
 const MAX_FILES_PER_BATCH = 5;
 /**
@@ -16,7 +15,7 @@ const MAX_FILES_PER_BATCH = 5;
  */
 async function lockDb() {
     try {
-        return await lockfile.lock(DB_PATH);
+        return await lockfile.lock(getDbPathForRepo());
     }
     catch (err) {
         log('❌ Failed to acquire DB lock: ' + err);
@@ -34,6 +33,7 @@ async function lockDb() {
 export async function runDaemonBatch() {
     log('🟡 Starting daemon batch...');
     // Selects up to MAX_FILES_PER_BATCH files that haven't been processed yet
+    const db = getDbForRepo();
     const rows = db.prepare(selectUnprocessedFiles).all(MAX_FILES_PER_BATCH);
     if (rows.length === 0) {
         log('✅ No files left to process.');

package/dist/daemon/daemonWorker.js

@@ -1,4 +1,4 @@
-import { db } from '../db/client.js';
+import { getDbForRepo } from '../db/client.js';
 import { runDaemonBatch } from './daemonBatch.js';
 import { log } from '../utils/log.js';
 const SLEEP_MS = 2000;
@@ -7,6 +7,7 @@ const IDLE_SLEEP_MS = 5000;
 log('🛠️ daemonWorker.js loaded');
 async function isQueueEmpty() {
     try {
+        const db = getDbForRepo();
         const row = db.prepare(`
       SELECT COUNT(*) AS count
       FROM files

package/dist/db/client.js

@@ -1,9 +1,31 @@
-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');
+import path from 'path';
+import { SCAI_HOME } from '../constants.js';
+import { Config } from '../config.js';
+import Database from 'better-sqlite3';
+/**
+ * Returns a per-repo SQLite database instance.
+ * Ensures the directory and file are created.
+ */
+export function getDbForRepo() {
+    const repoRoot = Config.getIndexDir();
+    if (!repoRoot) {
+        throw new Error('No index directory set. Please set an index directory first.');
+    }
+    fs.mkdirSync(SCAI_HOME, { recursive: true });
+    const dbPath = getDbPathForRepo();
+    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    const db = new Database(dbPath);
+    db.pragma('journal_mode = WAL');
+    return db;
+}
+export function getDbPathForRepo() {
+    const repoRoot = Config.getIndexDir();
+    if (!repoRoot) {
+        throw new Error('No index directory set. Please set an index directory first.');
+    }
+    // Use path.basename to get the repo name from the full path
+    const repoName = path.basename(repoRoot); // Get the last part of the path (the repo name)
+    const scaiRepoPath = path.join(SCAI_HOME, 'repos', repoName, 'db.sqlite');
+    return scaiRepoPath;
+}

package/dist/db/fileIndex.js

@@ -1,4 +1,3 @@
-import { db } from './client.js';
 import fs from 'fs';
 import path from 'path';
 import { generateEmbedding } from '../lib/generateEmbedding.js';
@@ -6,6 +5,7 @@ import { sanitizeQueryForFts } from '../utils/sanitizeQuery.js';
 import * as sqlTemplates from './sqlTemplates.js';
 import { stringSimilarity } from 'string-similarity-js';
 import { CANDIDATE_LIMIT } from '../constants.js';
+import { getDbForRepo } from './client.js';
 /**
  * 📄 Index a single file into the database.
  *
@@ -20,6 +20,7 @@ export function indexFile(filePath, summary, type) {
     const normalizedPath = path.normalize(filePath).replace(/\\/g, '/');
     const fileName = path.basename(normalizedPath); // Extracting the filename
     // Insert into files table
+    const db = getDbForRepo();
     db.prepare(sqlTemplates.upsertFileTemplate).run({
         path: normalizedPath,
         filename: fileName, // Pass filename
@@ -51,6 +52,7 @@ export function indexFile(filePath, summary, type) {
  */
 export function queryFiles(safeQuery, limit = 10) {
     console.log(`Executing search query: ${safeQuery}`);
+    const db = getDbForRepo();
     const results = db.prepare(`
     SELECT f.id, f.path, f.filename, f.summary, f.type, f.last_modified, f.indexed_at
     FROM files f
@@ -81,6 +83,7 @@ export async function searchFiles(query, topK = 5) {
     }
     const safeQuery = sanitizeQueryForFts(query);
     console.log(`Executing search query in FTS5: ${safeQuery}`);
+    const db = getDbForRepo();
     const ftsResults = db.prepare(`
     SELECT fts.rowid AS id, f.path, f.filename, f.summary, f.type, bm25(files_fts) AS bm25Score, f.embedding
     FROM files f
@@ -158,6 +161,7 @@ export function getFunctionsForFiles(fileIds) {
     if (!fileIds.length)
         return {};
     const placeholders = fileIds.map(() => '?').join(',');
+    const db = getDbForRepo();
     const stmt = db.prepare(`
     SELECT f.file_id, f.name, f.start_line, f.end_line, f.content
     FROM functions f

package/dist/db/functionExtractors/extractFromJava.js

@@ -1,8 +1,9 @@
-import { db } from '../client.js';
+import { getDbForRepo } from '../client.js';
 import { markFileAsSkippedTemplate } from '../sqlTemplates.js';
 export async function extractFromJava(filePath, _content, fileId) {
     console.warn(`⛔️ Java extraction not implemented: ${filePath}`);
     // Mark the file as skipped with the relevant status update
+    const db = getDbForRepo();
     db.prepare(markFileAsSkippedTemplate).run({ id: fileId });
     return false;
 }

package/dist/db/functionExtractors/extractFromJs.js

@@ -1,11 +1,11 @@
 import { parse } from 'acorn';
 import { ancestor as walkAncestor } from 'acorn-walk';
 import { generateEmbedding } from '../../lib/generateEmbedding.js';
-import { db } from '../client.js';
 import path from 'path';
 import { log } from '../../utils/log.js';
 import fs from 'fs';
 import { markFileAsSkippedTemplate, markFileAsExtractedTemplate, markFileAsFailedTemplate } from '../sqlTemplates.js';
+import { getDbForRepo } from '../client.js';
 function getFunctionName(node, parent, fileName) {
     if (node.id?.name)
         return node.id.name;
@@ -20,6 +20,7 @@ function getFunctionName(node, parent, fileName) {
     return `${fileName}:<anon>`;
 }
 export async function extractFromJS(filePath, content, fileId) {
+    const db = getDbForRepo();
     try {
         const code = fs.readFileSync(filePath, 'utf-8');
         console.log(`[Debug] Attempting to parse: ${filePath}`);

package/dist/db/functionExtractors/extractFromXML.js

@@ -1,8 +1,9 @@
-import { db } from '../client.js';
+import { getDbForRepo } from '../client.js';
 import { markFileAsSkippedTemplate } from '../sqlTemplates.js';
 export async function extractFromXML(filePath, _content, fileId) {
     console.warn(`⛔️ XML extraction not implemented: ${filePath}`);
     // Mark the file as skipped with the relevant status update
+    const db = getDbForRepo();
     db.prepare(markFileAsSkippedTemplate).run({ id: fileId });
     return false;
 }

package/dist/db/functionExtractors/index.js

@@ -3,13 +3,14 @@ import { detectFileType } from '../../fileRules/detectFileType.js';
 import { extractFromJava } from './extractFromJava.js';
 import { extractFromJS } from './extractFromJs.js';
 import { extractFromXML } from './extractFromXML.js';
-import { db } from '../client.js';
+import { getDbForRepo } from '../client.js';
 import { markFileAsFailedTemplate, markFileAsSkippedByPath } from '../sqlTemplates.js';
 /**
  * Detects file type and delegates to the appropriate extractor.
  */
 export async function extractFunctionsFromFile(filePath, content, fileId) {
     const type = detectFileType(filePath).trim().toLowerCase();
+    const db = getDbForRepo();
     try {
         if (type === 'js' || type === 'ts' || type === 'javascript' || type === 'typescript') {
             log(`✅ Attempting to extract JS functions from ${filePath}`);

package/dist/db/schema.js

@@ -1,5 +1,6 @@
-import { db } from "./client.js";
+import { getDbForRepo } from "./client.js";
 export function initSchema() {
+    const db = getDbForRepo();
     db.exec(`
     -- Create the files table
     CREATE TABLE IF NOT EXISTS files (

package/dist/index.js

@@ -1,6 +1,5 @@
 //!/usr/bin/env node
 import { Command } from "commander";
-import path from "path";
 import { Config } from './config.js';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
@@ -26,6 +25,7 @@ import { reviewPullRequestCmd } from "./commands/ReviewCmd.js";
 import { promptForToken } from "./github/token.js";
 import { validateGitHubTokenAgainstRepo } from "./github/githubAuthCheck.js";
 import { checkGit } from "./commands/GitCmd.js";
+import { runSwitchCommand, runInteractiveSwitch } from "./commands/SwitchCmd.js";
 // 🎛️ CLI Setup
 const cmd = new Command('scai')
     .version(version)
@@ -50,9 +50,8 @@ git
     await reviewPullRequestCmd('main', showAll);
 });
 git
-    .command('sugg')
-    .description('Suggest a commit message from staged changes')
-    .option('-c, --commit', 'Automatically commit with suggested message')
+    .command('commit')
+    .description('Suggest a commit message from staged changes and optionally commit')
     .option('-l, --changelog', 'Generate and optionally stage a changelog entry')
     .action((options) => suggestCommitMessage(options));
 git
@@ -119,40 +118,61 @@ gen
     .description('Generate a Jest test file for the specified JS/TS module')
     .action((file) => generateTests(file));
 // ⚙️ Group: Configuration settings
-const set = cmd.command('set').description('Set configuration values');
-set
-    .command('model <model>')
+const config = cmd.command('config').description('Manage SCAI configuration');
+config
+    .command('set-model <model>')
     .description('Set the model to use')
     .action((model) => {
     Config.setModel(model);
     Config.show();
 });
-set
-    .command('lang <lang>')
+config
+    .command('set-lang <lang>')
     .description('Set the programming language')
     .action((lang) => {
     Config.setLanguage(lang);
     Config.show();
 });
-set
-    .command('index-dir <dir>')
-    .description('Set the path to the indexed directory')
+config
+    .command('show')
+    .option('--raw', 'Show full raw config')
+    .description('Display current configuration')
+    .action((options) => {
+    if (options.raw) {
+        console.log(JSON.stringify(Config.getRaw(), null, 2));
+    }
+    else {
+        Config.show();
+    }
+});
+const index = cmd.command('index').description('index operations');
+index
+    .command('start')
+    .description('Index supported files in the configured index directory')
+    .action(runIndexCommand);
+index
+    .command('set <dir>')
+    .description('Set and activate index directory')
     .action((dir) => {
-    Config.setIndexDir(path.resolve(dir));
+    Config.setIndexDir(dir);
     Config.show();
 });
-cmd
-    .command('config')
-    .description('Show the currently active model and language settings')
+index
+    .command('list')
+    .description('List all indexed repositories')
     .action(() => {
-    Config.show();
-});
-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 });
+    Config.printAllRepos(); // 👈 simple and clean
+});
+index
+    .command('switch [input]')
+    .description('Switch active repository (by key or indexDir). Run without input for a list')
+    .action((input) => {
+    if (input) {
+        runSwitchCommand(input);
+    }
+    else {
+        runInteractiveSwitch();
+    }
 });
 cmd
     .command('backup')

package/dist/scripts/migrateDb.js

@@ -1,7 +1,8 @@
 // scripts/migrateDb.ts
-import { db } from "../db/client.js";
+import { getDbForRepo } from "../db/client.js";
 import { log } from "../utils/log.js";
 // scripts/resetFunctionExtraction.ts
+const db = getDbForRepo();
 try {
     db.prepare(`DELETE FROM function_calls`).run();
     log("✅ Deleted all rows from function_calls.");

package/dist/utils/fileTree.js

@@ -1,9 +1,11 @@
 import fs from 'fs';
 import path from 'path';
-export function generateFocusedFileTree(rootDir, focusPath, maxDepth = 2) {
+import { getIndexDir } from '../constants.js';
+export function generateFocusedFileTree(focusPath, maxDepth = 2) {
     const absoluteFocus = path.resolve(focusPath);
     const parentDir = path.dirname(absoluteFocus);
-    const relativeTitle = path.relative(rootDir, parentDir).replace(/\\/g, '/');
+    const indexDir = getIndexDir();
+    const relativeTitle = path.relative(indexDir, parentDir).replace(/\\/g, '/');
     const tree = generateFileTree(parentDir, maxDepth, absoluteFocus);
     return `📂 ${relativeTitle || '.'}\n${tree}`;
 }

package/dist/utils/normalizePath.js

@@ -1,4 +1,5 @@
 // src/utils/normalizePath.ts
+import path from "path";
 /**
  * Normalizes a path string for loose, fuzzy matching:
  * - Lowercases
@@ -8,3 +9,11 @@
 export function normalizePathForLooseMatch(p) {
     return p.toLowerCase().replace(/[\\/]/g, '').replace(/\s+/g, '');
 }
+// Helper to normalize and resolve paths to a consistent format (forward slashes)
+export function normalizePath(p) {
+    return path.resolve(p).replace(/\\/g, '/');
+}
+export function getRepoKeyForPath(pathToMatch, config) {
+    const norm = normalizePath(pathToMatch);
+    return Object.entries(config.repos).find(([, val]) => normalizePath(val.indexDir) === norm)?.[0] || null;
+}

package/package.json

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