scai 0.1.98 → 0.1.100

package/README.md

@@ -6,7 +6,7 @@
  
 - 💬 **Suggests intelligent Git commit messages** based on your staged diff  
 - 🤖 **Reviews open pull requests** and provides AI‑driven feedback (BETA) 
-- 📝 Summarizes files in plain English  
+- 📝 **Generates comments for multiple files** while you keep coding
 - 📜 Auto‑updates your changelog  
 - 🔍 (ALPHA) Search & ask questions across your codebase  
 - 🔐 100% local — no API keys, no cloud, no telemetry  
@@ -225,22 +225,12 @@ This will:
 ### 🛠️ Code Generation Commands (`gen` group)
 
 ```bash
-scai gen summ <file>
 scai gen comm <file|folder...>
+scai gen summ <file>
 scai gen changelog
 scai gen tests <file>
 ```
 
-* `summ`: Summarize a file
-
-   You can also pipe file content directly:
-
-   ```bash
-   cat src/utils/math.ts | scai gen summ
-   ```
-
-   </br>
-
 * `comm`: Add comments to one or more files, or to all matching files in a folder (recursive).
 
    </br>
@@ -255,6 +245,17 @@ scai gen tests <file>
 
   </br>
 
+* `summ`: Summarize a file
+
+   You can also pipe file content directly:
+
+   ```bash
+   cat src/utils/math.ts | scai gen summ
+   ```
+
+   </br>
+
+
 * `changelog`: Update or create `CHANGELOG.md` from Git diff
 
 * `tests`: Create Jest test stubs (ALPHA)
@@ -268,17 +269,24 @@ scai stores settings in `~/.scai/config.json`. You can override or view them:
 * **Set model:**
 
   ```bash
-  scai set model codellama:7b
+  scai config set-model codellama:7b
   ```
 * **Set language:**
 
   ```bash
-  scai set lang ts
+  scai config set-lang ts
   ```
 * **Show config:**
 
+  To see the config for the active repo
   ```bash
-  scai config
+  scai config show
+  ```
+
+  To see the config for all repos
+
+    ```bash
+  scai config show --raw 
   ```
 
 ---

package/dist/CHANGELOG.md

@@ -140,4 +140,10 @@ Type handling with the module pipeline
 
 ## 2025-08-24
 
-• Improved CLI review command with AI-generated suggestions and enhanced user interface.
+• Improved CLI review command with AI-generated suggestions and enhanced user interface.
+
+## 2025-08-26
+
+• Fixed bug where entire block was returned as a single line for multi-line comments
+• Add multi-line comment handling with ~90% accuracy
+• Update CLI config file to use codellama:13b model and 4096 context length

package/dist/config.js

@@ -6,8 +6,8 @@ import { normalizePath } from './utils/normalizePath.js';
 import chalk from 'chalk';
 import { getHashedRepoKey } from './utils/repoKey.js';
 const defaultConfig = {
-    model: 'llama3',
-    contextLength: 8192,
+    model: 'codellama:13b',
+    contextLength: 4096,
     language: 'ts',
     indexDir: '',
     githubToken: '',

package/dist/lib/generate.js

@@ -5,9 +5,7 @@ export async function generate(input, model) {
     const contextLength = readConfig().contextLength ?? 8192;
     let prompt = input.content;
     if (prompt.length > contextLength) {
-        console.warn(`⚠️ Warning: Input prompt length (${prompt.length}) exceeds model context length (${contextLength}). ` +
-            `The model may truncate or not handle the entire prompt. Truncating input.`);
-        prompt = prompt.slice(0, contextLength);
+        console.warn(`⚠️ Warning: Input prompt length (${prompt.length}) exceeds model context length (${contextLength}). `);
     }
     const spinner = new Spinner(`🧠 Thinking with ${model}...`);
     spinner.start();

package/dist/pipeline/modules/preserveCodeModule.js

@@ -8,126 +8,131 @@ export const preserveCodeModule = {
             throw new Error("Requires `originalContent`.");
         const syntax = {
             singleLine: ["//"],
-            multiLine: [{ start: "/*", end: "*/" }]
+            multiLine: [{ start: "/*", end: "*/" }, { start: "/**", end: "*/" }]
         };
         // --- 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
+        // --- Classify line ---
         let inBlockComment = false;
+        let blockLines = [];
         const classifyLine = (line) => {
             const trimmed = line.trimStart();
-            // Single-line
+            // --- Single-line comment ---
             for (const s of syntax.singleLine) {
                 if (trimmed.startsWith(s))
-                    return "single-comment";
+                    return line; // return actual line
             }
-            // Multi-line start/end
+            // --- Multi-line comment ---
             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.startsWith(start) && trimmed.includes(end)) {
+                        return line; // entire block on a single line
+                    }
+                    if (trimmed.startsWith(start)) {
+                        inBlockComment = true;
+                        blockLines = [line];
+                        return line; // start of multi-line block
+                    }
                 }
-                if (inBlockComment) {
+                else {
+                    blockLines.push(line);
                     if (trimmed.includes(end)) {
                         inBlockComment = false;
-                        return "multi-comment (end)";
+                        const fullBlock = blockLines.join("\n");
+                        blockLines = [];
+                        return fullBlock; // return entire multi-line block
                     }
-                    return "multi-comment (mid)";
+                    return ""; // middle lines, wait until block ends
                 }
             }
             return "code";
         };
-        // 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;
-        // Track all inserted comment blocks globally
-        const insertedBlocks = new Set();
-        while (origIndex < origLines.length) {
-            const origLine = origLines[origIndex];
-            // 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);
-                // 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);
-                    }
+        // --- Helper: collect comment blocks into map ---
+        function collectCommentsMap(lines) {
+            const map = new Map();
+            let commentBuffer = [];
+            for (const line of lines) {
+                const type = classifyLine(line);
+                if (type && type !== "code") {
+                    // Collect comment lines
+                    commentBuffer.push(type.trim());
                 }
-                // 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)");
+                else if (type === "code") {
+                    // Flush buffer when hitting code
+                    if (commentBuffer.length > 0) {
+                        const key = line.trim().toLowerCase();
+                        if (!map.has(key))
+                            map.set(key, new Set());
+                        // Join consecutive comments into one block
+                        const commentBlock = commentBuffer.join("\n").toLowerCase();
+                        map.get(key).add(commentBlock);
+                        commentBuffer = [];
+                    }
                 }
-                // Advance indices past the entire blocks
-                origIndex += origBlock.length;
-                newIndex += modelBlock.length;
-                continue;
             }
-            // Non-comment line
-            const newLine = newLines[newIndex] ?? "";
-            fixedLines.push(origLine.trim() === newLine.trim() ? newLine : origLine);
-            origIndex++;
-            newIndex++;
+            // Flush remaining comments at EOF
+            if (commentBuffer.length > 0) {
+                const key = "";
+                if (!map.has(key))
+                    map.set(key, new Set());
+                const commentBlock = commentBuffer.join("\n").toLowerCase();
+                map.get(key).add(commentBlock);
+            }
+            return map;
         }
-        // Add any remaining original lines if model ran out
-        while (origIndex < origLines.length) {
-            fixedLines.push(origLines[origIndex++]);
+        // --- Step 1: Collect comments ---
+        const modelComments = collectCommentsMap(newLines); // model first
+        const origComments = collectCommentsMap(origLines); // original
+        // --- Step 2: Remove duplicates ---
+        for (const [key, commentSet] of modelComments.entries()) {
+            if (origComments.has(key)) {
+                commentSet.forEach(c => {
+                    origComments.get(key).delete(c.trim().toLowerCase());
+                });
+                if (origComments.get(key).size === 0)
+                    origComments.delete(key);
+            }
         }
-        // Add trailing comments from model if any
-        while (newIndex < newLines.length) {
-            if (classifyLine(newLines[newIndex]) !== "code") {
-                fixedLines.push(newLines[newIndex]);
+        // --- Step 3: Build fixed lines with model comments inserted above original ---
+        const fixedLines = [];
+        for (const origLine of origLines) {
+            const key = origLine.trim().toLowerCase();
+            // Insert model comment blocks if any
+            if (modelComments.has(key)) {
+                modelComments.get(key).forEach(block => {
+                    const lines = block.split("\n");
+                    for (const line of lines) {
+                        if (!fixedLines.includes(line)) {
+                            fixedLines.push(line);
+                            console.log(chalk.blue("Inserted comment:"), line.trim());
+                        }
+                        else {
+                            console.log(chalk.gray("Skipped duplicate comment:"), line.trim());
+                        }
+                    }
+                });
             }
-            newIndex++;
+            fixedLines.push(origLine);
         }
         // --- 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);
+            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);
+            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 ==="));
         fixedLines.forEach((line, i) => {
             const type = classifyLine(line);
-            const colored = type === "code"
-                ? chalk.green(line)
-                : chalk.yellow(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/dist/utils/splitCodeIntoChunk.js

@@ -4,24 +4,41 @@ export function splitCodeIntoChunks(text, maxTokens) {
     const chunks = [];
     let currentChunkLines = [];
     let currentTokens = 0;
+    let inMultiComment = false;
+    const start = '/*';
+    const end = '*/';
     for (const line of lines) {
+        const trimmed = line.trim();
+        // --- Track multi-line comments ---
+        if (trimmed.includes(start) && !trimmed.includes(end)) {
+            // Starts a block comment but does not end on the same line
+            inMultiComment = true;
+        }
+        else if (trimmed.includes(start) && trimmed.includes(end)) {
+            // Inline comment: "/* ... */" on same line → ignore, don't toggle state
+            // do nothing with inMultiComment
+        }
+        else if (trimmed.includes(end)) {
+            // End of a block comment
+            inMultiComment = false;
+        }
         const lineTokens = encode(line + '\n').length;
         if (currentTokens + lineTokens > maxTokens) {
-            // Try to split at a more natural point
+            // Split at natural points but never inside a multi-line comment
             let splitIndex = currentChunkLines.length;
             for (let i = currentChunkLines.length - 1; i >= 0; i--) {
-                const trimmed = currentChunkLines[i].trim();
-                if (trimmed === '' ||
-                    trimmed.startsWith('function ') ||
-                    trimmed.startsWith('class ') ||
-                    trimmed.endsWith('}') ||
-                    trimmed.endsWith(';')) {
+                const t = currentChunkLines[i].trim();
+                if (!inMultiComment &&
+                    (t === '' ||
+                        t.startsWith('function ') ||
+                        t.startsWith('class ') ||
+                        t.endsWith('}') ||
+                        t.endsWith(';'))) {
                     splitIndex = i + 1;
                     break;
                 }
             }
             chunks.push(currentChunkLines.slice(0, splitIndex).join('\n'));
-            // Move leftover lines into the next chunk
             currentChunkLines = currentChunkLines.slice(splitIndex);
             currentTokens = encode(currentChunkLines.join('\n')).length;
         }

package/package.json

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