scai 0.1.89 → 0.1.91

package/README.md

@@ -301,6 +301,14 @@ scai index switch
 
 Switch active repository (by key or indexDir). Run without input for an interactive list of repositories.
 
+#### `scai index delete`
+
+Delete a repository from the index (interactive).  
+This removes the repository entry from the `config.json` file, but does **not** delete the repository folder on disk.
+
+```bash
+scai index delete
+```
 
 --- 
 

package/dist/CHANGELOG.md

@@ -112,4 +112,9 @@ Type handling with the module pipeline
 ## 2025-08-16
 
 • Update preserveCodeModule to compare blocks correctly and handle duplicate blocks
-• Normalize line endings and detect comments in preserveCodeModule
+• Normalize line endings and detect comments in preserveCodeModule
+
+## 2025-08-18
+
+• Add interactive delete repository command
+• Refactor DeleteIndex command to handle repository deletion correctly

package/dist/commands/DeleteIndex.js

@@ -0,0 +1,50 @@
+// File: src/commands/delete.ts
+import readline from 'readline';
+import { Config, writeConfig } from '../config.js';
+import chalk from 'chalk';
+export async function runInteractiveDelete() {
+    const config = Config.getRaw();
+    const keys = Object.keys(config.repos || {});
+    if (!keys.length) {
+        console.log('⚠️ No repositories configured.');
+        return;
+    }
+    console.log('\n🗑️  Repositories Available for Deletion:\n');
+    keys.forEach((key, i) => {
+        const isActive = config.activeRepo === key ? chalk.green('(active)') : '';
+        const dir = config.repos[key]?.indexDir ?? '';
+        console.log(`${chalk.blue(`${i + 1})`)} ${key} ${isActive}`);
+        console.log(`    ↳ ${chalk.grey(dir)}`);
+    });
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    rl.question('\n👉 Select a repository number to delete: ', (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];
+        console.log(`\n⚠️  Deleting repository: ${chalk.red(selectedKey)}\n`);
+        // Build an update that uses the null-sentinel for deletion.
+        const update = { repos: { [selectedKey]: null } };
+        // If deleting the active repo, pick another one (first remaining) or unset.
+        if (config.activeRepo === selectedKey) {
+            const remainingKeys = keys.filter(k => k !== selectedKey);
+            update.activeRepo = remainingKeys[0] || undefined;
+            console.log(`ℹ️ Active repo reset to: ${chalk.green(update.activeRepo ?? 'none')}`);
+        }
+        try {
+            writeConfig(update); // this will actually remove the repo key
+            console.log(`✅ Repository "${selectedKey}" removed from config.json.`);
+            // NOTE: We intentionally do NOT delete the on-disk repo folder here.
+            // Only remove data when a --purge flag is explicitly used.
+        }
+        catch (err) {
+            console.error('❌ Failed to update config.json:', err instanceof Error ? err.message : err);
+        }
+    });
+}

package/dist/commands/SwitchCmd.js

@@ -1,31 +1,28 @@
 // File: src/commands/switch.ts
 import readline from 'readline';
 import { Config, writeConfig } from '../config.js';
-import { normalizePath, getRepoKeyForPath } from '../utils/normalizePath.js';
+import { 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}`);
+    // Direct key match
+    if (config.repos[inputPathOrKey]) {
+        config.activeRepo = inputPathOrKey;
+        Config.setGitHubToken(config.repos[inputPathOrKey].githubToken ?? '');
+        console.log(`✅ Switched active repo to key: ${inputPathOrKey}`);
     }
     else {
-        // Try to match by indexDir path
+        // Path match only if key match failed
         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
+    // Persist change
     writeConfig(config);
 }
 export async function runInteractiveSwitch() {

package/dist/config.js

@@ -2,8 +2,9 @@ import fs from 'fs';
 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 { normalizePath } from './utils/normalizePath.js';
 import chalk from 'chalk';
+import { getHashedRepoKey } from './utils/repoKey.js';
 const defaultConfig = {
     model: 'llama3',
     contextLength: 8192,
@@ -38,6 +39,14 @@ export function writeConfig(newCfg) {
             ...(newCfg.repos || {}),
         },
     };
+    // Remove repos explicitly set to null
+    if (newCfg.repos) {
+        for (const [key, value] of Object.entries(newCfg.repos)) {
+            if (value === null) {
+                delete merged.repos[key];
+            }
+        }
+    }
     fs.writeFileSync(CONFIG_PATH, JSON.stringify(merged, null, 2));
 }
 export const Config = {
@@ -78,54 +87,47 @@ export const Config = {
         }
     },
     getIndexDir() {
-        const config = readConfig();
-        const activeRepo = config.activeRepo;
-        if (activeRepo) {
-            const normalized = normalizePath(activeRepo);
-            return normalizePath(config.repos[normalized]?.indexDir ?? '');
-        }
-        return '';
+        const cfg = readConfig();
+        const activeRepo = cfg.activeRepo;
+        if (!activeRepo)
+            return '';
+        return cfg.repos[activeRepo]?.indexDir ?? '';
     },
     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
-        this.setActiveRepo(scaiRepoRoot);
-        // Call setRepoIndexDir to update the repo's indexDir and other settings
-        await this.setRepoIndexDir(scaiRepoRoot, absPath); // Set the indexDir for the repo
+        // 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 });
-        // Init DB if not exists
+        // 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)}`);
-            getDbForRepo(); // Now DB creation works after config update
+            getDbForRepo();
         }
     },
-    /**
-     * 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);
+    async setRepoIndexDir(repoKey, 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
+        if (!cfg.repos[repoKey])
+            cfg.repos[repoKey] = {};
+        cfg.repos[repoKey] = {
+            ...cfg.repos[repoKey],
+            indexDir, // Already normalized
         };
-        await writeConfig(cfg); // Persist the config update
-        console.log(`✅ Repo index directory set for ${normalizedRepoPath} : ${normalizedIndexDir}`);
+        await writeConfig(cfg);
+        console.log(`✅ Repo index directory set for ${repoKey} : ${indexDir}`);
     },
     setActiveRepo(repoKey) {
         const cfg = readConfig();
-        cfg.activeRepo = normalizePath(repoKey);
+        cfg.activeRepo = repoKey;
+        if (!cfg.repos[repoKey])
+            cfg.repos[repoKey] = {};
         writeConfig(cfg);
         console.log(`✅ Active repo switched to: ${repoKey}`);
     },
@@ -140,38 +142,27 @@ export const Config = {
         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
+                ? chalk.green(`✅ ${key} (active)`)
+                : chalk.white(`  ${key}`);
             console.log(`- ${label}`);
             console.log(`    ↳ indexDir: ${r.indexDir}`);
         }
     },
-    // Method to get GitHub token for the active repo
     getGitHubToken() {
         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
+        if (active)
+            return cfg.repos[active]?.githubToken || null;
         return cfg.githubToken || null;
     },
     setGitHubToken(token) {
         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,
-            };
+            if (!cfg.repos[active])
+                cfg.repos[active] = {};
+            cfg.repos[active] = { ...cfg.repos[active], githubToken: token };
         }
         else {
             cfg.githubToken = token;
@@ -184,7 +175,7 @@ export const Config = {
         const active = cfg.activeRepo;
         console.log(`🔧 Current configuration:`);
         console.log(`   Active index dir: ${active || 'Not Set'}`);
-        const repoCfg = active ? cfg.repos?.[active] : {};
+        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'}`);

package/dist/db/client.js

@@ -1,31 +1,24 @@
 import fs from 'fs';
 import path from 'path';
 import { SCAI_HOME } from '../constants.js';
-import { Config } from '../config.js';
+import { readConfig } 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.');
+export function getDbPathForRepo() {
+    const cfg = readConfig();
+    const repoKey = cfg.activeRepo;
+    if (!repoKey) {
+        throw new Error('No active repo set. Please set an index directory first.');
     }
-    fs.mkdirSync(SCAI_HOME, { recursive: true });
+    return path.join(SCAI_HOME, 'repos', repoKey, 'db.sqlite');
+}
+export function getDbForRepo() {
     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/index.js

@@ -30,6 +30,7 @@ import { handleAgentRun } from './agentManager.js';
 import { addCommentsModule } from './pipeline/modules/commentModule.js';
 import { generateTestsModule } from './pipeline/modules/generateTestsModule.js';
 import { preserveCodeModule } from './pipeline/modules/preserveCodeModule.js';
+import { runInteractiveDelete } from './commands/DeleteIndex.js';
 // 🎛️ CLI Setup
 const cmd = new Command('scai')
     .version(version)
@@ -177,6 +178,12 @@ index
     .action(() => {
     runInteractiveSwitch();
 });
+index
+    .command('delete')
+    .description('Delete a repository from the index (interactive)')
+    .action(() => {
+    runInteractiveDelete();
+});
 // This will help resolve the current directory in an ES Module
 cmd
     .command('check-db')

package/dist/utils/repoKey.js

@@ -0,0 +1,14 @@
+import crypto from 'crypto';
+import path from 'path';
+import { normalizePath } from './normalizePath.js';
+/**
+ * Generate a stable unique key for a repo path.
+ * Uses the basename plus a short hash of the full path.
+ * Example: "sps-1a2b3c"
+ */
+export function getHashedRepoKey(repoPath) {
+    const absPath = normalizePath(repoPath); // now cross-platform consistent
+    const base = path.basename(absPath);
+    const hash = crypto.createHash('md5').update(absPath).digest('hex').slice(0, 6);
+    return `${base}-${hash}`;
+}

package/package.json

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