scai 0.1.101 → 0.1.103

package/dist/fileRules/detectFileType.js

@@ -1,52 +1,49 @@
 import path from 'path';
-export function detectFileType(filepath) {
-    const ext = path.extname(filepath).toLowerCase();
+export function detectFileType(filepathOrExt) {
+    // If it's already an extension (starts with '.'), use it directly
+    const ext = filepathOrExt.startsWith(".")
+        ? filepathOrExt.toLowerCase()
+        : path.extname(filepathOrExt).toLowerCase();
     const map = {
-        // Programming languages
-        '.ts': 'typescript',
-        '.tsx': 'typescript',
-        '.js': 'javascript',
-        '.jsx': 'javascript',
-        '.java': 'java',
-        '.py': 'python',
-        '.rb': 'ruby',
-        '.php': 'php',
-        '.go': 'go',
-        '.rs': 'rust',
-        '.c': 'c',
-        '.cpp': 'cpp',
-        '.cs': 'csharp',
-        '.swift': 'swift',
-        '.kt': 'kotlin',
-        '.scala': 'scala',
-        // Markup & docs
-        '.md': 'markdown',
-        '.html': 'html',
-        '.htm': 'html',
-        '.xml': 'xml',
-        '.json': 'json',
-        '.yaml': 'yaml',
-        '.yml': 'yaml',
-        // Configs
-        '.ini': 'config',
-        '.toml': 'config',
-        '.env': 'config',
-        // Data
-        '.sql': 'sql',
-        '.csv': 'csv',
-        '.tsv': 'tsv',
-        // Text & writing
-        '.txt': 'text',
-        '.log': 'log',
-        '.rst': 'text',
-        // Office
-        '.doc': 'word',
-        '.docx': 'word',
-        '.pdf': 'pdf',
-        '.ppt': 'powerpoint',
-        '.pptx': 'powerpoint',
-        '.xls': 'excel',
-        '.xlsx': 'excel',
+        ".ts": "typescript",
+        ".tsx": "typescript",
+        ".js": "javascript",
+        ".jsx": "javascript",
+        ".java": "java",
+        ".py": "python",
+        ".rb": "ruby",
+        ".php": "php",
+        ".go": "go",
+        ".rs": "rust",
+        ".c": "c",
+        ".cpp": "cpp",
+        ".cs": "csharp",
+        ".swift": "swift",
+        ".kt": "kotlin",
+        ".scala": "scala",
+        ".md": "markdown",
+        ".html": "html",
+        ".htm": "html",
+        ".xml": "xml",
+        ".json": "json",
+        ".yaml": "yaml",
+        ".yml": "yaml",
+        ".ini": "config",
+        ".toml": "config",
+        ".env": "config",
+        ".sql": "sql",
+        ".csv": "csv",
+        ".tsv": "tsv",
+        ".txt": "text",
+        ".log": "log",
+        ".rst": "text",
+        ".doc": "word",
+        ".docx": "word",
+        ".pdf": "pdf",
+        ".ppt": "powerpoint",
+        ".pptx": "powerpoint",
+        ".xls": "excel",
+        ".xlsx": "excel",
     };
-    return map[ext] || ext.replace('.', '') || 'unknown';
+    return map[ext] || ext.replace(".", "") || "unknown";
 }

package/dist/index.js

@@ -125,7 +125,8 @@ gen
     .description("Write comments for the given file(s) or folder(s)")
     .action(async (targets) => {
     await withContext(async () => {
-        const files = await resolveTargetsToFiles(targets, [".ts", ".js"]);
+        // Remove the file type filter to allow any file
+        const files = await resolveTargetsToFiles(targets);
         for (const file of files) {
             await handleAgentRun(file, [addCommentsModule, preserveCodeModule]);
         }

package/dist/pipeline/modules/commentModule.js

@@ -42,18 +42,10 @@ You are a senior engineer reviewing a ${fileType} file.
 
 Please:
 
-1. Add a concise summary comment above each function describing its purpose.  
-   - Do NOT write trivial summaries like "..." or empty comments.  
-   - Do NOT overwrite or remove any existing comments.
-
-2. Add clear, helpful inline comments to explain non-obvious logic inside functions.  
-   - Preserve all existing comments as-is.
-
-3. Use "${commentSyntax}" as the comment syntax appropriate for ${fileType}.
-
-4. Preserve all original formatting, whitespace, and code exactly.
-
-5. You may only be shown parts of a file. Add comments as instructed.
+- Add summary comments (2-3 lines) at relevant points for greater class insights
+- Add clear, helpful inline comments to explain non-obvious logic inside functions.  
+- Use "${commentSyntax}" as the comment syntax appropriate for ${fileType}.
+- Preserve all original formatting, whitespace, and code exactly.
 
 Rules:
 - Return the full original chunk of code with added comments only.
@@ -62,8 +54,6 @@ Rules:
 - 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: 
-
 ${input.content}
 
 `.trim();

package/dist/pipeline/modules/generateTestsModule.js

@@ -1,28 +1,31 @@
 import fs from 'fs/promises';
 import path from 'path';
-import { Config } from '../../config.js';
 import { generate } from '../../lib/generate.js';
+import { detectFileType } from '../../fileRules/detectFileType.js';
+import { Config } from '../../config.js';
 export const generateTestsModule = {
     name: 'tests',
     description: 'Generate a Jest test file for the class/module',
     async run({ content, filepath }) {
-        const model = Config.getModel();
-        const lang = Config.getLanguage();
         if (!filepath)
             throw new Error('Missing filepath in pipeline context');
+        const model = Config.getModel();
+        const lang = detectFileType(filepath);
         const prompt = `
-You are a senior ${lang.toUpperCase()} engineer. Given the following class or module, generate a Jest test file.
+      You are a senior ${lang.toUpperCase()} engineer. Given the following class or module, generate a Jest test file.
 
-Guidelines:
-- Use the 'jest' test framework
-- Cover public methods and one edge case
-- Name the file <original>.test.ts
-- Only return valid TypeScript code
+      Guidelines:
+      - Use the 'jest' test framework
+      - Cover only one public method: the most relevant or central function
+      - Include one edge case for that method
+      - Preserve and consider existing code comments
+      - Name the file <original>.test.${path.extname(filepath).slice(1)}
+      - Only return valid ${lang} code
 
---- CODE START ---
-${content}
---- CODE END ---
-    `.trim();
+      --- CODE START ---
+      ${content}
+      --- CODE END ---
+      `.trim();
         const response = await generate({ content: prompt }, model);
         if (!response)
             throw new Error('⚠️ No test code returned from model');

package/dist/pipeline/modules/preserveCodeModule.js

@@ -1,4 +1,6 @@
 import chalk from "chalk";
+import { getCommentSyntax } from "../../utils/commentMap.js";
+import { detectFileType } from "../../fileRules/detectFileType.js";
 export const preserveCodeModule = {
     name: "preserveCodeModule",
     description: "Ensure code matches original exactly, preserving comments with clear before/after output",
@@ -6,10 +8,13 @@ export const preserveCodeModule = {
         const { originalContent, content, filepath } = input;
         if (!originalContent)
             throw new Error("Requires `originalContent`.");
-        const syntax = {
-            singleLine: ["//"],
-            multiLine: [{ start: "/*", end: "*/" }, { start: "/**", end: "*/" }]
-        };
+        // Determine language from filepath extension
+        console.log("Filepath: ", filepath);
+        const ext = "." + (filepath?.split(".").pop() || "ts");
+        console.log("Extension: ", ext);
+        const language = detectFileType(filepath ?? ext); // returns "javascript", "python", etc.
+        const syntax = getCommentSyntax(language);
+        console.log(`Using comment syntax for extension '${language}':`, syntax);
         // --- Normalize line endings ---
         const normalize = (txt) => txt.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
         const origLines = normalize(originalContent).split("\n");
@@ -17,34 +22,47 @@ export const preserveCodeModule = {
         // --- Classify line ---
         let inBlockComment = false;
         let blockLines = [];
+        // --- Classify line ---
+        // returns: "code" | comment string | null
         const classifyLine = (line) => {
             const trimmed = line.trimStart();
             // --- Single-line comment ---
             for (const s of syntax.singleLine) {
                 if (trimmed.startsWith(s))
-                    return "comment";
+                    return line;
             }
-            // --- Multi-line comment ---
-            for (const { start, end } of syntax.multiLine) {
-                if (!inBlockComment) {
-                    if (trimmed.startsWith(start) && trimmed.includes(end)) {
-                        return "comment"; // entire block on one line
-                    }
+            // --- Multi-line comment (optional) ---
+            const multiLineComments = syntax.multiLine ?? [];
+            if (!inBlockComment) {
+                // check if line starts a multi-line comment
+                for (const { start, end } of multiLineComments) {
                     if (trimmed.startsWith(start)) {
-                        inBlockComment = true;
                         blockLines = [line];
-                        return ""; // wait until block ends
+                        if (trimmed.includes(end) && trimmed.indexOf(end) > trimmed.indexOf(start)) {
+                            // entire block on one line
+                            return blockLines.join("\n");
+                        }
+                        else {
+                            inBlockComment = true;
+                            return null; // wait for block to finish
+                        }
                     }
                 }
-                else {
-                    blockLines.push(line);
+            }
+            else {
+                // currently inside a multi-line block
+                blockLines.push(line);
+                for (const { end } of multiLineComments) {
                     if (trimmed.includes(end)) {
                         inBlockComment = false;
-                        return "comment"; // end of block
+                        const fullBlock = blockLines.join("\n");
+                        blockLines = [];
+                        return fullBlock; // emit entire block
                     }
-                    return ""; // inside block
                 }
+                return null; // still inside block
             }
+            // --- default: code ---
             return "code";
         };
         // --- Helper: collect comment blocks into map ---
@@ -52,97 +70,77 @@ export const preserveCodeModule = {
             const map = new Map();
             let commentBuffer = [];
             for (const line of lines) {
-                const type = classifyLine(line);
-                if (type === "comment") {
-                    // Collect full comment line
-                    commentBuffer.push(line);
-                }
-                else if (type === "code") {
-                    // Flush buffer when hitting code
+                const result = classifyLine(line);
+                if (result === "code") {
                     if (commentBuffer.length > 0) {
                         const key = line.trim().toLowerCase();
+                        const block = commentBuffer.join("\n").trim().toLowerCase();
                         if (!map.has(key))
                             map.set(key, new Set());
-                        const commentBlock = commentBuffer.map(l => l.trimEnd()).join("\n").toLowerCase();
-                        map.get(key).add(commentBlock);
+                        map.get(key).add(block);
                         commentBuffer = [];
                     }
+                    continue;
+                }
+                if (typeof result === "string") {
+                    // comment line or block
+                    commentBuffer.push(result);
                 }
+                // result === null => inside multi-line block, do nothing
             }
-            // Flush remaining comments at EOF
+            // flush at EOF
             if (commentBuffer.length > 0) {
                 const key = "";
+                const block = commentBuffer.join("\n").trim().toLowerCase();
                 if (!map.has(key))
                     map.set(key, new Set());
-                const commentBlock = commentBuffer.map(l => l.trimEnd()).join("\n").toLowerCase();
-                map.get(key).add(commentBlock);
+                map.get(key).add(block);
             }
             return map;
         }
         // --- 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);
+        // --- Step 2: Remove duplicates from model (since we insert model) ---
+        for (const [key, modelSet] of modelComments.entries()) {
+            const origSet = origComments.get(key);
+            if (!origSet)
+                continue;
+            for (const c of Array.from(modelSet)) {
+                if (origSet.has(c))
+                    modelSet.delete(c);
             }
+            if (modelSet.size === 0)
+                modelComments.delete(key);
         }
-        // --- Step 3: Build fixed lines with model comments inserted above original ---
+        // --- Step 3: Build fixed lines ---
         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)) {
+                for (const block of modelComments.get(key)) {
+                    for (const line of block.split("\n")) {
+                        const norm = line.trim().toLowerCase();
+                        const already = fixedLines.some(l => l.trim().toLowerCase() === norm);
+                        if (!already) {
                             fixedLines.push(line);
                             console.log(chalk.blue("Inserted comment:"), line.trim());
                         }
                         else {
-                            console.log(chalk.gray("Skipped duplicate comment:"), line.trim());
+                            console.log(chalk.gray("Skipped duplicate:"), line.trim());
                         }
                     }
-                });
+                }
             }
-            fixedLines.push(origLine);
+            fixedLines.push(origLine); // always keep original
         }
-        // --- 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)
-                : type === "comment"
-                    ? chalk.yellow(line)
-                    : chalk.gray(line); // "" means middle of block
-            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)
-                : type === "comment"
-                    ? chalk.yellow(line)
-                    : chalk.gray(line);
-            console.log(`${i + 1}: ${colored} ${chalk.gray(`[${type}]`)}`);
-        });
+        // --- Logging ---
         console.log(chalk.bold.blue("\n=== FIXED CONTENT ==="));
         fixedLines.forEach((line, i) => {
-            // classifyLine might not be ideal here since fixedLines are final
-            // so we treat anything starting with a comment marker as "comment"
             const trimmed = line.trimStart();
-            const type = syntax.singleLine.some(s => trimmed.startsWith(s)) ||
-                syntax.multiLine.some(({ start }) => trimmed.startsWith(start))
-                ? "comment"
-                : "code";
+            const isComment = syntax.singleLine.some(s => trimmed.startsWith(s)) ||
+                (syntax.multiLine ?? []).some(({ start }) => trimmed.startsWith(start));
+            const type = isComment ? "comment" : "code";
             const colored = type === "code" ? chalk.green(line) : chalk.yellow(line);
             console.log(`${i + 1}: ${colored} ${chalk.gray(`[${type}]`)}`);
         });

package/dist/pipeline/runModulePipeline.js

@@ -4,15 +4,18 @@ export async function runModulePipeline(modules, input) {
     const isDebug = false;
     for (const mod of modules) {
         try {
+            if (isDebug)
+                console.log(current.filepath);
             const response = await mod.run(current);
             console.log(`⚙️ Running: ${mod.name}`);
             if (isDebug) {
                 console.log(chalk.yellow('➡️ Output:', response.content));
             }
-            // Safeguard if originalContent is overwritten by module
+            // Safeguard to preserve filepath + originalContent
             current = {
                 ...response,
-                originalContent: current.originalContent
+                originalContent: current.originalContent,
+                filepath: current.filepath,
             };
         }
         catch (error) {

package/dist/utils/commentMap.js

@@ -75,5 +75,6 @@ export const commentMap = {
  */
 export function getCommentSyntax(language) {
     const normalized = language.toLowerCase();
-    return commentMap[normalized] || { singleLine: ["#"], multiLine: [] };
+    return (commentMap[normalized] ||
+        { singleLine: ["//"], multiLine: ["/*", "*/"] });
 }

package/dist/utils/resolveTargetsToFiles.js

@@ -21,7 +21,7 @@ async function collectFilesRecursive(dir, exts) {
         if (entry.isDirectory()) {
             files.push(...await collectFilesRecursive(fullPath, exts));
         }
-        else if (exts.includes(path.extname(entry.name))) {
+        else if (!exts || exts.includes(path.extname(entry.name))) {
             files.push(fullPath);
         }
     }

package/package.json

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