scai 0.1.90 → 0.1.92

package/dist/CHANGELOG.md

@@ -117,4 +117,8 @@ Type handling with the module pipeline
 ## 2025-08-18
 
 • Add interactive delete repository command
-• Refactor DeleteIndex command to handle repository deletion correctly
+• Refactor DeleteIndex command to handle repository deletion correctly
+
+## 2025-08-19
+
+* Improved line classification and merging logic

package/dist/commands/DeleteIndex.js

@@ -29,17 +29,19 @@ export async function runInteractiveDelete() {
         }
         const selectedKey = keys[index];
         console.log(`\n⚠️  Deleting repository: ${chalk.red(selectedKey)}\n`);
-        // Build update: remove repo by setting it to null
+        // Build an update that uses the null-sentinel for deletion.
         const update = { repos: { [selectedKey]: null } };
-        // Reset activeRepo if it pointed to the deleted one
+        // If deleting the active repo, pick another one (first remaining) or unset.
         if (config.activeRepo === selectedKey) {
-            const remainingKeys = keys.filter((k) => k !== 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
+            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,
@@ -30,7 +31,7 @@ export function readConfig() {
 export function writeConfig(newCfg) {
     ensureConfigDir();
     const current = readConfig();
-    let merged = {
+    const merged = {
         ...current,
         ...newCfg,
         repos: {
@@ -38,7 +39,7 @@ export function writeConfig(newCfg) {
             ...(newCfg.repos || {}),
         },
     };
-    // Special handling: remove repos explicitly set to null
+    // Remove repos explicitly set to null
     if (newCfg.repos) {
         for (const [key, value] of Object.entries(newCfg.repos)) {
             if (value === null) {
@@ -86,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}`);
     },
@@ -148,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;
@@ -192,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/pipeline/modules/preserveCodeModule.js

@@ -57,53 +57,48 @@ export const preserveCodeModule = {
         const fixedLines = [];
         let origIndex = 0;
         let newIndex = 0;
-        while (origIndex < origLines.length && newIndex < newLines.length) {
+        // Track all inserted comment blocks globally
+        const insertedBlocks = new Set();
+        while (origIndex < origLines.length) {
             const origLine = origLines[origIndex];
-            const newLine = newLines[newIndex];
-            // If either current line is a comment → treat whole comment block
-            let lastInsertedModelBlock = [];
-            if (classifyLine(origLine) !== "code" || classifyLine(newLine) !== "code") {
+            // If this is a comment line in original or model
+            if (classifyLine(origLine) !== "code" || classifyLine(newLines[newIndex] ?? "") !== "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);
-                            }
-                        }
+                // Merge: model block first, then any orig lines not in model
+                const seen = new Set(trimBlock(modelBlock));
+                const mergedBlock = [...modelBlock];
+                for (const line of origBlock) {
+                    if (!seen.has(line.trim())) {
+                        mergedBlock.push(line);
                     }
-                    // Update lastInsertedModelBlock
-                    lastInsertedModelBlock = [...modelBlock];
+                }
+                // Create a key for duplicate detection
+                const mergedKey = JSON.stringify(trimBlock(mergedBlock));
+                // Insert only if this block was never inserted before
+                if (!insertedBlocks.has(mergedKey)) {
+                    fixedLines.push(...mergedBlock);
+                    insertedBlocks.add(mergedKey);
                 }
                 else {
                     console.log("Skipping duplicate block (already inserted)");
                 }
+                // Advance indices past the entire blocks
                 origIndex += origBlock.length;
                 newIndex += modelBlock.length;
                 continue;
             }
-            // Non-comment lines
-            if (origLine.trim() === newLine.trim()) {
-                fixedLines.push(newLine);
-            }
-            else {
-                fixedLines.push(origLine);
-            }
+            // Non-comment line
+            const newLine = newLines[newIndex] ?? "";
+            fixedLines.push(origLine.trim() === newLine.trim() ? newLine : origLine);
             origIndex++;
             newIndex++;
         }
-        // Add trailing lines from original (if model ran out first)
+        // Add any remaining original lines if model ran out
         while (origIndex < origLines.length) {
             fixedLines.push(origLines[origIndex++]);
         }
-        // Add trailing comments from model
+        // Add trailing comments from model if any
         while (newIndex < newLines.length) {
             if (classifyLine(newLines[newIndex]) !== "code") {
                 fixedLines.push(newLines[newIndex]);

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.90",
+  "version": "0.1.92",
   "type": "module",
   "bin": {
     "scai": "./dist/index.js"