scai 0.1.86 → 0.1.87

package/dist/agentManager.js

@@ -17,11 +17,12 @@ export async function handleAgentRun(filepath, modules) {
         const processedChunks = [];
         for (const [i, chunk] of chunks.entries()) {
             const chunkTokens = countTokens(chunk);
-            if (i === 0) {
-                console.log(chalk.cyan(`🔍 Processing ${chunks.length} chunks of file:`), chalk.white(filepath));
-            }
-            console.log(chalk.gray(`   - Chunk ${i + 1} tokens:`), chalk.yellow(chunkTokens.toString()));
+            // if (i === 0) {
+            //   console.log(chalk.cyan(`🔍 Processing ${chunks.length} chunks of file:`), chalk.white(filepath));
+            // }
+            // console.log(chalk.gray(`   - Chunk ${i + 1} tokens:`), chalk.yellow(chunkTokens.toString()));
             const chunkInput = {
+                originalContent: chunk,
                 content: chunk,
                 filepath,
                 chunkIndex: i,
@@ -32,7 +33,7 @@ export async function handleAgentRun(filepath, modules) {
                 throw new Error(`⚠️ Model returned empty result on chunk ${i + 1}`);
             }
             processedChunks.push(response.content);
-            console.log(chalk.green(`✅ Finished chunk ${i + 1}/${chunks.length}`));
+            //console.log(chalk.green(`✅ Finished chunk ${i + 1}/${chunks.length}`));
         }
         // Join all chunk outputs into one string
         const finalOutput = processedChunks.join('\n\n');

package/dist/index.js

@@ -29,7 +29,7 @@ import { dirname, resolve } from "path";
 import { handleAgentRun } from './agentManager.js';
 import { addCommentsModule } from './pipeline/modules/commentModule.js';
 import { generateTestsModule } from './pipeline/modules/generateTestsModule.js';
-import { cleanupModule } from './pipeline/modules/cleanupModule.js';
+import { preserveCodeModule } from './pipeline/modules/preserveCodeModule.js';
 // 🎛️ CLI Setup
 const cmd = new Command('scai')
     .version(version)
@@ -106,7 +106,7 @@ gen
     .command('comm <file>')
     .description('Write comments for the given file')
     .action((file) => {
-    handleAgentRun(file, [addCommentsModule, cleanupModule]);
+    handleAgentRun(file, [addCommentsModule, preserveCodeModule]);
 });
 gen
     .command('changelog')

package/dist/pipeline/modules/commentModule.js

@@ -37,9 +37,6 @@ export const addCommentsModule = {
             text: '#',
         };
         const commentSyntax = commentMap[fileType] || '//';
-        const chunkLabel = (input.chunkIndex && input.chunkCount && input.chunkCount > 1)
-            ? `CHUNK ${input.chunkIndex + 1}/${input.chunkCount} of ${input.filepath}`
-            : `FULL FILE: ${input.filepath}`;
         const prompt = `
 You are a senior engineer reviewing a ${fileType} file.
 
@@ -56,15 +53,19 @@ Please:
 
 4. Preserve all original formatting, whitespace, and code exactly.
 
+5. You may only be shown parts of a file. Add comments as instructed.
+
 Rules:
 - Return the full original chunk of code with added comments only.
 - Do NOT remove, change, or overwrite any existing code or comments.
 - Summaries should be brief but meaningful.
 - Inline comments should clarify complex or tricky parts only.
+- Do NOT add any “chunk” start/end markers, numbering, or metadata to the output.
+
+Code to comments is below this line: 
 
---- ${chunkLabel} START ---
 ${input.content}
---- ${chunkLabel} END ---
+
 `.trim();
         const response = await generate({ content: prompt }, model);
         const contentToReturn = (response.content && response.content !== 'NO UPDATE') ? response.content : input.content;

package/dist/pipeline/modules/preserveCodeModule.js

@@ -0,0 +1,93 @@
+import chalk from "chalk";
+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;
+        if (!originalContent)
+            throw new Error("Requires `originalContent`.");
+        const syntax = {
+            singleLine: ["//"],
+            multiLine: [{ start: "/*", end: "*/" }]
+        };
+        // Detect comments
+        const isComment = (line) => {
+            const ltrim = line.trimStart();
+            for (const s of syntax.singleLine) {
+                if (ltrim.startsWith(s))
+                    return true;
+            }
+            if (syntax.multiLine) {
+                for (const { start } of syntax.multiLine) {
+                    if (ltrim.startsWith(start))
+                        return true;
+                }
+            }
+            return false;
+        };
+        const origLines = originalContent.split("\n");
+        const newLines = content.split("\n");
+        const fixedLines = [];
+        let origIndex = 0;
+        let newIndex = 0;
+        while (origIndex < origLines.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++;
+                }
+                else {
+                    // New comment from model
+                    fixedLines.push(newLine);
+                    newIndex++;
+                }
+                newLine = newLines[newIndex] ?? "";
+            }
+            if (newLine.trim() === origLine.trim()) {
+                fixedLines.push(newLine);
+                origIndex++;
+                newIndex++;
+            }
+            else {
+                fixedLines.push(origLine);
+                origIndex++;
+                if (!isComment(newLine)) {
+                    newIndex++;
+                }
+            }
+        }
+        // Add trailing comments from model
+        while (newIndex < newLines.length) {
+            if (isComment(newLines[newIndex])) {
+                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));
+        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"));
+        return { content: fixedLines.join("\n"), filepath };
+    }
+};

package/dist/pipeline/runModulePipeline.js

@@ -1,19 +1,19 @@
 import chalk from 'chalk';
 export async function runModulePipeline(modules, input) {
     let current = input;
-    const isDebug = true;
+    const isDebug = false;
     for (const mod of modules) {
         try {
-            if (isDebug) {
-                console.log(chalk.green('➡️ Input:', current.content));
-            }
             const response = await mod.run(current);
             console.log(`⚙️ Running: ${mod.name}`);
             if (isDebug) {
-                console.log(chalk.red('➡️ Output:', response.content));
+                console.log(chalk.yellow('➡️ Output:', response.content));
             }
-            // Feed this output into the next module
-            current = response;
+            // Safeguard if originalContent is overwritten by module
+            current = {
+                ...response,
+                originalContent: current.originalContent
+            };
         }
         catch (error) {
             console.error(`❌ Error in ${mod.name}:`, error instanceof Error ? error.message : error);

package/dist/utils/commentMap.js

@@ -0,0 +1,79 @@
+// utils/commentMap.ts
+export const commentMap = {
+    javascript: {
+        singleLine: ["//"],
+        multiLine: [{ start: "/*", end: "*/" }]
+    },
+    typescript: {
+        singleLine: ["//"],
+        multiLine: [{ start: "/*", end: "*/" }]
+    },
+    java: {
+        singleLine: ["//"],
+        multiLine: [{ start: "/*", end: "*/" }]
+    },
+    c: {
+        singleLine: ["//"],
+        multiLine: [{ start: "/*", end: "*/" }]
+    },
+    cpp: {
+        singleLine: ["//"],
+        multiLine: [{ start: "/*", end: "*/" }]
+    },
+    csharp: {
+        singleLine: ["//"],
+        multiLine: [{ start: "/*", end: "*/" }]
+    },
+    python: {
+        singleLine: ["#"],
+        multiLine: [
+            { start: `"""`, end: `"""` },
+            { start: `'''`, end: `'''` }
+        ]
+    },
+    ruby: {
+        singleLine: ["#"],
+        multiLine: [{ start: `=begin`, end: `=end` }]
+    },
+    shell: {
+        singleLine: ["#"]
+    },
+    bash: {
+        singleLine: ["#"]
+    },
+    html: {
+        singleLine: [],
+        multiLine: [{ start: "<!--", end: "-->" }]
+    },
+    css: {
+        singleLine: [],
+        multiLine: [{ start: "/*", end: "*/" }]
+    },
+    sql: {
+        singleLine: ["--"],
+        multiLine: []
+    },
+    xml: {
+        singleLine: [],
+        multiLine: [{ start: "<!--", end: "-->" }]
+    },
+    json: {
+        singleLine: [],
+        multiLine: [{ start: "/*", end: "*/" }]
+    },
+    markdown: {
+        singleLine: [],
+        multiLine: [{ start: "<!--", end: "-->" }]
+    },
+    text: {
+        singleLine: ["#"]
+    }
+};
+/**
+ * Returns the CommentSyntax for a given language.
+ * Falls back to single-line `#` if language is unknown.
+ */
+export function getCommentSyntax(language) {
+    const normalized = language.toLowerCase();
+    return commentMap[normalized] || { singleLine: ["#"], multiLine: [] };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scai",
-  "version": "0.1.86",
+  "version": "0.1.87",
   "type": "module",
   "bin": {
     "scai": "./dist/index.js"
@@ -29,7 +29,9 @@
     "productivity",
     "scai",
     "review",
-    "commit"
+    "commit",
+    "agent",
+    "workflow"
   ],
   "scripts": {
     "build": "rm -rfd dist && tsc && git add .",