scai 0.1.88 → 0.1.90

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

@@ -107,4 +107,14 @@ Type handling with the module pipeline
 * Split file processing into logical chunks with logging.
 * Improved commit suggestion generation logic.
 * Removed unnecessary files and updated index.ts to use handleAgentRun instead.
-* Fetch download statistics from NPM API.
+* Fetch download statistics from NPM API.
+
+## 2025-08-16
+
+• Update preserveCodeModule to compare blocks correctly and handle duplicate blocks
+• 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,48 @@
+// 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 update: remove repo by setting it to null
+        const update = { repos: { [selectedKey]: null } };
+        // Reset activeRepo if it pointed to the deleted one
+        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); // only pass the diff
+            console.log(`✅ Repository "${selectedKey}" removed from config.json.`);
+        }
+        catch (err) {
+            console.error('❌ Failed to update config.json:', err instanceof Error ? err.message : err);
+        }
+    });
+}

package/dist/config.js

@@ -30,7 +30,7 @@ export function readConfig() {
 export function writeConfig(newCfg) {
     ensureConfigDir();
     const current = readConfig();
-    const merged = {
+    let merged = {
         ...current,
         ...newCfg,
         repos: {
@@ -38,6 +38,14 @@ export function writeConfig(newCfg) {
             ...(newCfg.repos || {}),
         },
     };
+    // Special handling: 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 = {

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/pipeline/modules/preserveCodeModule.js

@@ -3,91 +3,138 @@ export const preserveCodeModule = {
     name: "preserveCodeModule",
     description: "Ensure code matches original exactly, preserving comments with clear before/after output",
     async run(input) {
-        const { originalContent, content, filepath, language: forcedLang } = input;
+        const { originalContent, content, filepath } = input;
         if (!originalContent)
             throw new Error("Requires `originalContent`.");
         const syntax = {
             singleLine: ["//"],
             multiLine: [{ start: "/*", end: "*/" }]
         };
-        // Detect comments
-        const isComment = (line) => {
-            const ltrim = line.trimStart();
+        // --- Normalize line endings ---
+        const normalize = (txt) => txt.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        const origLines = normalize(originalContent).split("\n");
+        const newLines = normalize(content).split("\n");
+        // Detect if a line is a comment line, and classify
+        let inBlockComment = false;
+        const classifyLine = (line) => {
+            const trimmed = line.trimStart();
+            // Single-line
             for (const s of syntax.singleLine) {
-                if (ltrim.startsWith(s))
-                    return true;
+                if (trimmed.startsWith(s))
+                    return "single-comment";
             }
-            if (syntax.multiLine) {
-                for (const { start } of syntax.multiLine) {
-                    if (ltrim.startsWith(start))
-                        return true;
+            // Multi-line start/end
+            for (const { start, end } of syntax.multiLine) {
+                if (trimmed.startsWith(start) && trimmed.includes(end)) {
+                    return "multi-comment (start+end)";
+                }
+                if (trimmed.startsWith(start)) {
+                    inBlockComment = true;
+                    return "multi-comment (start)";
+                }
+                if (inBlockComment) {
+                    if (trimmed.includes(end)) {
+                        inBlockComment = false;
+                        return "multi-comment (end)";
+                    }
+                    return "multi-comment (mid)";
                 }
             }
-            return false;
+            return "code";
         };
-        const origLines = originalContent.split("\n");
-        const newLines = content.split("\n");
+        // Collect consecutive comment lines as one block
+        function collectBlock(lines, startIndex) {
+            const block = [];
+            let i = startIndex;
+            while (i < lines.length && classifyLine(lines[i]) !== "code") {
+                block.push(lines[i]);
+                i++;
+            }
+            return block;
+        }
+        const trimBlock = (block) => block.map(line => line.trim());
+        const blocksEqual = (a, b) => JSON.stringify(trimBlock(a)) === JSON.stringify(trimBlock(b));
         const fixedLines = [];
         let origIndex = 0;
         let newIndex = 0;
-        while (origIndex < origLines.length) {
+        while (origIndex < origLines.length && newIndex < newLines.length) {
             const origLine = origLines[origIndex];
-            let newLine = newLines[newIndex] ?? "";
-            // Preserve comments from model output if not already in original
-            while (newIndex < newLines.length && isComment(newLine)) {
-                if (origLine && newLine.trim() === origLine.trim()) {
-                    // Comment already exists in original, advance both
-                    fixedLines.push(origLine);
-                    origIndex++;
-                    newIndex++;
+            const newLine = newLines[newIndex];
+            // If either current line is a comment → treat whole comment block
+            let lastInsertedModelBlock = [];
+            if (classifyLine(origLine) !== "code" || classifyLine(newLine) !== "code") {
+                const origBlock = collectBlock(origLines, origIndex);
+                const modelBlock = collectBlock(newLines, newIndex);
+                // Compare with last inserted block
+                if (!blocksEqual(modelBlock, lastInsertedModelBlock)) {
+                    if (blocksEqual(origBlock, modelBlock)) {
+                        fixedLines.push(...origBlock);
+                    }
+                    else {
+                        const seen = new Set(trimBlock(modelBlock));
+                        fixedLines.push(...modelBlock);
+                        for (const line of origBlock) {
+                            if (!seen.has(line.trim())) {
+                                fixedLines.push(line);
+                            }
+                        }
+                    }
+                    // Update lastInsertedModelBlock
+                    lastInsertedModelBlock = [...modelBlock];
                 }
                 else {
-                    // New comment from model
-                    fixedLines.push(newLine);
-                    newIndex++;
+                    console.log("Skipping duplicate block (already inserted)");
                 }
-                newLine = newLines[newIndex] ?? "";
+                origIndex += origBlock.length;
+                newIndex += modelBlock.length;
+                continue;
             }
-            if (newLine.trim() === origLine.trim()) {
+            // Non-comment lines
+            if (origLine.trim() === newLine.trim()) {
                 fixedLines.push(newLine);
-                origIndex++;
-                newIndex++;
             }
             else {
                 fixedLines.push(origLine);
-                origIndex++;
-                if (!isComment(newLine)) {
-                    newIndex++;
-                }
             }
+            origIndex++;
+            newIndex++;
+        }
+        // Add trailing lines from original (if model ran out first)
+        while (origIndex < origLines.length) {
+            fixedLines.push(origLines[origIndex++]);
         }
         // Add trailing comments from model
         while (newIndex < newLines.length) {
-            if (isComment(newLines[newIndex])) {
+            if (classifyLine(newLines[newIndex]) !== "code") {
                 fixedLines.push(newLines[newIndex]);
             }
             newIndex++;
         }
-        // Diff display
-        console.log(chalk.bold.blue("\n=== ORIGINAL CONTENT ==="));
-        console.log(chalk.green(originalContent));
-        console.log(chalk.bold.blue("\n=== MODEL CONTENT ==="));
-        console.log(chalk.gray(content));
+        // --- Logging for debugging ---
+        console.log(chalk.bold.blue("\n=== LINE CLASSIFICATION (original) ==="));
+        origLines.forEach((line, i) => {
+            const type = classifyLine(line);
+            const colored = type === "code"
+                ? chalk.green(line)
+                : chalk.yellow(line);
+            console.log(`${i + 1}: ${colored} ${chalk.gray(`[${type}]`)}`);
+        });
+        console.log(chalk.bold.blue("\n=== LINE CLASSIFICATION (model) ==="));
+        newLines.forEach((line, i) => {
+            const type = classifyLine(line);
+            const colored = type === "code"
+                ? chalk.green(line)
+                : chalk.yellow(line);
+            console.log(`${i + 1}: ${colored} ${chalk.gray(`[${type}]`)}`);
+        });
         console.log(chalk.bold.blue("\n=== FIXED CONTENT ==="));
-        console.log(fixedLines
-            .map(line => {
-            const comment = isComment(line);
-            if (origLines.includes(line.trim()) && !comment) {
-                return chalk.green(line);
-            }
-            else if (comment) {
-                return chalk.yellow(line);
-            }
-            else {
-                return chalk.red(line);
-            }
-        })
-            .join("\n"));
+        fixedLines.forEach((line, i) => {
+            const type = classifyLine(line);
+            const colored = type === "code"
+                ? chalk.green(line)
+                : chalk.yellow(line);
+            console.log(`${i + 1}: ${colored} ${chalk.gray(`[${type}]`)}`);
+        });
         return { content: fixedLines.join("\n"), filepath };
     }
 };

package/package.json

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