scai 0.1.88 → 0.1.89

package/dist/CHANGELOG.md

@@ -107,4 +107,9 @@ 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

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