scai 0.1.102 → 0.1.104

package/dist/CHANGELOG.md

@@ -146,4 +146,8 @@ Type handling with the module pipeline
 
 • 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
+• Update CLI config file to use codellama:13b model and 4096 context length
+
+## 2025-08-30
+
+* Add new workflow management functionality to handle file writes.

package/dist/commands/SwitchCmd.js

@@ -1,7 +1,7 @@
 // File: src/commands/switch.ts
 import readline from 'readline';
 import { Config, writeConfig } from '../config.js';
-import { getRepoKeyForPath } from '../utils/normalizePath.js';
+import { getRepoKeyForPath } from '../utils/contentUtils.js';
 import chalk from 'chalk';
 export function runSwitchCommand(inputPathOrKey) {
     const config = Config.getRaw();

package/dist/config.js

@@ -2,7 +2,7 @@ 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 { normalizePath } from './utils/normalizePath.js';
+import { normalizePath } from './utils/contentUtils.js';
 import chalk from 'chalk';
 import { getHashedRepoKey } from './utils/repoKey.js';
 const defaultConfig = {

package/dist/context.js

@@ -1,10 +1,12 @@
 // context.ts
-import { readConfig, writeConfig } from "./config.js";
-import { normalizePath } from "./utils/normalizePath.js";
+import { readConfig, writeConfig, Config } from "./config.js";
+import { normalizePath } from "./utils/contentUtils.js";
 import { getHashedRepoKey } from "./utils/repoKey.js";
 import { getDbForRepo, getDbPathForRepo } from "./db/client.js";
 import fs from "fs";
 import chalk from "chalk";
+import { generate } from "./lib/generate.js"; // 👈 use your existing generate wrapper
+import { startModelProcess } from "./utils/checkModel.js";
 export async function updateContext() {
     const cwd = normalizePath(process.cwd());
     const cfg = readConfig();
@@ -54,6 +56,17 @@ export async function updateContext() {
     else if (isNewRepo || activeRepoChanged) {
         console.log(chalk.green("✅ Database present"));
     }
+    // ✅ NEW: Ensure model is available
+    if (ok) {
+        const modelReady = await ensureModelReady();
+        if (modelReady) {
+            console.log(chalk.green("✅ Model ready"));
+        }
+        else {
+            console.log(chalk.red("❌ Model not available"));
+            ok = false;
+        }
+    }
     // Final context status
     if (ok) {
         console.log(chalk.bold.green("\n✅ Context OK\n"));
@@ -63,3 +76,15 @@ export async function updateContext() {
     }
     return ok;
 }
+async function ensureModelReady() {
+    try {
+        // simple "ping" prompt that costs almost nothing
+        const res = await generate({ content: "ping" }, Config.getModel());
+        return Boolean(res?.content);
+    }
+    catch {
+        console.log(chalk.yellow("⚡ Model not responding. Attempting to start..."));
+        await startModelProcess();
+        return false;
+    }
+}

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

@@ -26,13 +26,14 @@ import { runInteractiveSwitch } from "./commands/SwitchCmd.js";
 import { execSync } from "child_process";
 import { fileURLToPath } from "url";
 import { dirname, resolve } from "path";
-import { handleAgentRun } from './agentManager.js';
+import { handleAgentRun } from './workflowManager.js';
 import { addCommentsModule } from './pipeline/modules/commentModule.js';
 import { generateTestsModule } from './pipeline/modules/generateTestsModule.js';
 import { preserveCodeModule } from './pipeline/modules/preserveCodeModule.js';
 import { runInteractiveDelete } from './commands/DeleteIndex.js';
 import { resolveTargetsToFiles } from './utils/resolveTargetsToFiles.js';
 import { updateContext } from './context.js';
+import { cleanGeneratedTestsModule } from './pipeline/modules/cleanGeneratedTestsModule.js';
 // 🎛️ CLI Setup
 const cmd = new Command('scai')
     .version(version)
@@ -125,7 +126,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]);
         }
@@ -148,12 +150,14 @@ gen
     });
 });
 gen
-    .command('testgen <file>')
-    .description('Generate tests for the given file')
-    .option('-a, --apply', 'Apply the output to the original file')
-    .action(async (file) => {
+    .command("test <targets...>")
+    .description("Generate tests for the given file(s) or folder(s)")
+    .action(async (targets, options) => {
     await withContext(async () => {
-        handleAgentRun(file, [generateTestsModule]);
+        const files = await resolveTargetsToFiles(targets);
+        for (const file of files) {
+            await handleAgentRun(file, [generateTestsModule, cleanGeneratedTestsModule]);
+        }
     });
 });
 // ⚙️ Group: Configuration settings

package/dist/pipeline/modules/cleanGeneratedTestsModule.js

@@ -0,0 +1,21 @@
+import { normalizeText, stripMarkdownFences, isCodeLike } from "../../utils/contentUtils.js";
+export const cleanGeneratedTestsModule = {
+    name: "cleanGeneratedTestsModule",
+    description: "Removes markdown fences, prose, and explanations from generated test output, leaving only code",
+    async run(input) {
+        const { content, filepath } = input;
+        // normalize + strip markdown
+        const normalized = normalizeText(content);
+        const stripped = stripMarkdownFences(normalized);
+        // filter non-code lines
+        const lines = stripped.split("\n");
+        const codeLines = lines.filter(line => isCodeLike(line));
+        const cleanedCode = codeLines.join("\n");
+        return {
+            originalContent: content,
+            content: cleanedCode, // cleaned code for pipeline
+            filepath, // original file path
+            mode: "overwrite", // indicates overwrite existing file
+        };
+    }
+};

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,13 +54,14 @@ 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();
         const response = await generate({ content: prompt }, model);
         const contentToReturn = (response.content && response.content !== 'NO UPDATE') ? response.content : input.content;
-        return { content: contentToReturn };
+        return {
+            content: contentToReturn,
+            mode: 'overwrite', // <-- declares that the original file should be overwritten
+        };
     },
 };

package/dist/pipeline/modules/generateTestsModule.js

@@ -1,35 +1,41 @@
-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 ---
+      --- CODE START ---
+      ${content}
+      --- CODE END ---
     `.trim();
         const response = await generate({ content: prompt }, model);
         if (!response)
             throw new Error('⚠️ No test code returned from model');
         const { dir, name } = path.parse(filepath);
         const testPath = path.join(dir, `${name}.test.ts`);
-        await fs.writeFile(testPath, response.content, 'utf-8');
-        console.log(`✅ Test file saved to: ${testPath}`);
-        return { content, filepath }; // unchanged input
+        return {
+            originalContent: content,
+            content: response.content, // the test code
+            filepath, // original file path
+            newFilepath: testPath,
+            mode: "newFile" // where it *should* be written
+        };
     }
 };

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,6 +22,7 @@ export const preserveCodeModule = {
         // --- Classify line ---
         let inBlockComment = false;
         let blockLines = [];
+        // --- Classify line ---
         // returns: "code" | comment string | null
         const classifyLine = (line) => {
             const trimmed = line.trimStart();
@@ -25,29 +31,38 @@ export const preserveCodeModule = {
                 if (trimmed.startsWith(s))
                     return line;
             }
-            // --- Multi-line comment ---
-            for (const { start, end } of syntax.multiLine) {
-                if (!inBlockComment) {
-                    if (trimmed.startsWith(start) && trimmed.includes(end)) {
-                        return line; // 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 null; // 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;
                         const fullBlock = blockLines.join("\n");
                         blockLines = [];
                         return fullBlock; // emit entire block
                     }
-                    return null; // still inside block
                 }
+                return null; // still inside block
             }
+            // --- default: code ---
             return "code";
         };
         // --- Helper: collect comment blocks into map ---
@@ -123,13 +138,16 @@ export const preserveCodeModule = {
         console.log(chalk.bold.blue("\n=== FIXED CONTENT ==="));
         fixedLines.forEach((line, i) => {
             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}]`)}`);
         });
-        return { content: fixedLines.join("\n"), filepath };
+        return {
+            content: fixedLines.join("\n"),
+            filepath,
+            mode: "overwrite"
+        };
     }
 };

package/dist/pipeline/registry/moduleRegistry.js

@@ -4,6 +4,8 @@ import { summaryModule } from '../modules/summaryModule.js';
 import { generateTestsModule } from '../modules/generateTestsModule.js';
 import { commitSuggesterModule } from '../modules/commitSuggesterModule.js';
 import { changelogModule } from '../modules/changeLogModule.js';
+import { cleanGeneratedTestsModule } from '../modules/cleanGeneratedTestsModule.js';
+import { preserveCodeModule } from '../modules/preserveCodeModule.js';
 // Add more as needed...
 const builtInModules = {
     comments: addCommentsModule,
@@ -12,6 +14,8 @@ const builtInModules = {
     tests: generateTestsModule,
     suggest: commitSuggesterModule,
     changelog: changelogModule,
+    cleantTests: cleanGeneratedTestsModule,
+    cleanComments: preserveCodeModule
 };
 export function getModuleByName(name) {
     return builtInModules[name];

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/checkModel.js

@@ -0,0 +1,30 @@
+import { spawn } from "child_process";
+let modelProcess = null;
+async function isModelRunning() {
+    try {
+        const res = await fetch("http://localhost:11434/health"); // whatever endpoint your model exposes
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function startModelProcess() {
+    if (await isModelRunning()) {
+        console.log("✅ Model already running");
+        return;
+    }
+    console.log("🚀 Starting model process...");
+    modelProcess = spawn("ollama", ["serve"], {
+        stdio: "inherit",
+    });
+    // Poll until the model is ready
+    for (let i = 0; i < 30; i++) {
+        if (await isModelRunning()) {
+            console.log("✅ Model is now running");
+            return;
+        }
+        await new Promise((res) => setTimeout(res, 1000));
+    }
+    throw new Error("❌ Model failed to start in time");
+}

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/contentUtils.js

@@ -0,0 +1,49 @@
+import os from 'os';
+import path from "path";
+/**
+ * Normalizes a path string for loose, fuzzy matching:
+ * - Lowercases
+ * - Removes slashes and backslashes
+ * - Removes whitespace
+ */
+export function normalizePathForLooseMatch(p) {
+    return p.toLowerCase().replace(/[\\/]/g, '').replace(/\s+/g, '');
+}
+// Helper to normalize and resolve paths to a consistent format (forward slashes)
+export function normalizePath(p) {
+    if (p.startsWith('~')) {
+        p = path.join(os.homedir(), p.slice(1));
+    }
+    return path.resolve(p).replace(/\\/g, '/');
+}
+export function getRepoKeyForPath(pathToMatch, config) {
+    const norm = normalizePath(pathToMatch);
+    return Object.entries(config.repos).find(([, val]) => normalizePath(val.indexDir) === norm)?.[0] || null;
+}
+export function normalizeText(txt) {
+    return txt.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+export function stripMarkdownFences(txt) {
+    return txt
+        .replace(/```[\w-]*\s*/g, "") // ``` or ```java
+        .replace(/```/g, ""); // closing ```
+}
+// Very naive classifier: decide if a line is "code-like"
+export function isCodeLike(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return false;
+    // obvious markdown / prose markers
+    if (/^(This|Here is|Note)\b/.test(trimmed))
+        return false;
+    if (/^\d+\./.test(trimmed))
+        return false; // bullet list
+    if (/^[-*] /.test(trimmed))
+        return false; // list
+    // allow imports, class, functions, braces, annotations, etc.
+    if (/^(import|export|public|private|protected|class|function|@Test|@Before)/.test(trimmed))
+        return true;
+    if (/[;{}()=]/.test(trimmed))
+        return true;
+    return false;
+}

package/dist/utils/repoKey.js

@@ -1,6 +1,6 @@
 import crypto from 'crypto';
 import path from 'path';
-import { normalizePath } from './normalizePath.js';
+import { normalizePath } from './contentUtils.js';
 /**
  * Generate a stable unique key for a repo path.
  * Uses the basename plus a short hash of the full path.

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/dist/workflowManager.js

@@ -0,0 +1,89 @@
+// agentManager.ts
+import fs from 'fs/promises';
+import chalk from 'chalk';
+import { runModulePipeline } from './pipeline/runModulePipeline.js';
+import { countTokens, splitCodeIntoChunks } from './utils/splitCodeIntoChunk.js';
+import { normalizePath } from './utils/contentUtils.js';
+export async function handleAgentRun(filepath, modules) {
+    try {
+        filepath = normalizePath(filepath);
+        let fileContent = await fs.readFile(filepath, 'utf-8');
+        // Immutable baseline for this file (stays until file changes)
+        const maxTokens = 1500;
+        const baseChunks = splitCodeIntoChunks(fileContent, maxTokens);
+        // Working chunks that flow through modules; stays index-aligned with baseChunks
+        let workingChunks = [...baseChunks];
+        for (const mod of modules) {
+            console.log(chalk.cyan(`\n⚙️ Running module: ${mod.name}`));
+            console.log(chalk.blue(`🧮 Tokens:`), chalk.yellow(countTokens(fileContent).toString()));
+            console.log(chalk.magenta(`📦 Chunks: ${workingChunks.length}`));
+            const processed = [];
+            let mode;
+            let newFilepath;
+            for (let i = 0; i < workingChunks.length; i++) {
+                const input = {
+                    originalContent: baseChunks[i], // immutable baseline for this file
+                    content: workingChunks[i], // current state for this slice
+                    filepath,
+                    chunkIndex: i,
+                    chunkCount: workingChunks.length,
+                };
+                const out = await runModulePipeline([mod], input);
+                if (!out.content?.trim()) {
+                    throw new Error(`⚠️ Empty result on chunk ${i + 1}`);
+                }
+                processed.push(out.content);
+                // Capture mode/path (should be consistent across chunks)
+                if (out.mode)
+                    mode = out.mode;
+                if (out.newFilepath)
+                    newFilepath = out.newFilepath;
+            }
+            const finalOutput = processed.join('\n\n');
+            // Apply output mode
+            switch (mode ?? 'overwrite') {
+                case 'overwrite':
+                    await fs.writeFile(filepath, finalOutput, 'utf-8');
+                    console.log(chalk.green(`✅ Overwritten: ${filepath}`));
+                    // keep baseChunks (baseline stays the same), keep alignment: do NOT re-chunk
+                    workingChunks = processed;
+                    fileContent = finalOutput;
+                    break;
+                case 'append':
+                    await fs.appendFile(filepath, finalOutput, 'utf-8');
+                    console.log(chalk.green(`✅ Appended: ${filepath}`));
+                    // appended file content diverges; keep alignment by using processed as new working
+                    workingChunks = processed;
+                    fileContent += finalOutput;
+                    break;
+                case 'newFile':
+                    if (!newFilepath)
+                        throw new Error(`newFile mode requires newFilepath`);
+                    await fs.writeFile(newFilepath, finalOutput, 'utf-8');
+                    console.log(chalk.green(`✅ New file: ${newFilepath}`));
+                    // File context changes → reset baseline and working to the new file
+                    filepath = newFilepath;
+                    fileContent = finalOutput;
+                    const reset = splitCodeIntoChunks(fileContent, maxTokens);
+                    // new baseline for the new file (e.g., generated tests before cleaning)
+                    for (let i = 0; i < reset.length; i++)
+                        ; // (no-op; just clarity)
+                    // Replace both arrays to keep them in sync for subsequent modules
+                    workingChunks = reset;
+                    // Important: also reset baseChunks to this new file’s content so the next module
+                    // (e.g., cleaner) sees the *generated tests* as its originalContent baseline.
+                    baseChunks.length = 0;
+                    baseChunks.push(...reset);
+                    break;
+                default:
+                    console.log(chalk.yellow(`⚠️ Unknown mode; skipping write`));
+                    // still move pipeline forward with processed
+                    workingChunks = processed;
+                    fileContent = finalOutput;
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('❌ Error in agent run:'), err instanceof Error ? err.message : err);
+    }
+}

package/package.json

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

package/dist/agentManager.js

@@ -1,47 +0,0 @@
-import fs from 'fs/promises';
-import chalk from 'chalk';
-import { runModulePipeline } from './pipeline/runModulePipeline.js';
-import { normalizePath } from './utils/normalizePath.js';
-import { readConfig } from './config.js';
-import { countTokens, splitCodeIntoChunks } from './utils/splitCodeIntoChunk.js';
-export async function handleAgentRun(filepath, modules) {
-    try {
-        filepath = normalizePath(filepath);
-        const content = await fs.readFile(filepath, 'utf-8');
-        const totalTokens = countTokens(content);
-        console.log(chalk.blue(`🧮 Total tokens in file:`), chalk.yellow(totalTokens.toString()));
-        const config = readConfig();
-        const maxTokens = 1500;
-        const chunks = splitCodeIntoChunks(content, maxTokens);
-        console.log(chalk.magenta(`📦 Split into ${chunks.length} chunks`));
-        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()));
-            const chunkInput = {
-                originalContent: chunk,
-                content: chunk,
-                filepath,
-                chunkIndex: i,
-                chunkCount: chunks.length,
-            };
-            const response = await runModulePipeline(modules, chunkInput);
-            if (!response.content.trim()) {
-                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}`));
-        }
-        // Join all chunk outputs into one string
-        const finalOutput = processedChunks.join('\n\n');
-        // Overwrite original file here:
-        await fs.writeFile(filepath, finalOutput, 'utf-8');
-        console.log(chalk.green(`✅ Original file overwritten: ${filepath}`));
-    }
-    catch (err) {
-        console.error(chalk.red('❌ Error in agent run:'), err instanceof Error ? err.message : err);
-    }
-}

package/dist/utils/normalizePath.js

@@ -1,23 +0,0 @@
-// src/utils/normalizePath.ts
-import os from 'os';
-import path from "path";
-/**
- * Normalizes a path string for loose, fuzzy matching:
- * - Lowercases
- * - Removes slashes and backslashes
- * - Removes whitespace
- */
-export function normalizePathForLooseMatch(p) {
-    return p.toLowerCase().replace(/[\\/]/g, '').replace(/\s+/g, '');
-}
-// Helper to normalize and resolve paths to a consistent format (forward slashes)
-export function normalizePath(p) {
-    if (p.startsWith('~')) {
-        p = path.join(os.homedir(), p.slice(1));
-    }
-    return path.resolve(p).replace(/\\/g, '/');
-}
-export function getRepoKeyForPath(pathToMatch, config) {
-    const norm = normalizePath(pathToMatch);
-    return Object.entries(config.repos).find(([, val]) => normalizePath(val.indexDir) === norm)?.[0] || null;
-}