scai 0.1.117 → 0.1.118

package/dist/utils/promptBuilderHelper.js

@@ -0,0 +1,67 @@
+import chalk from "chalk";
+import { buildLightContext } from "./buildContextualPrompt.js";
+/**
+ * Responsible only for building the contextual prompt text (no file writes).
+ */
+export async function buildContext(args) {
+    console.log(chalk.blueBright("\n📦 Building contextual prompt..."));
+    // ↳ Now returns a StructuredContext object
+    const ctx = await buildLightContext(args);
+    // Serialize to prompt string
+    const promptContent = serializeContext(ctx);
+    console.log(chalk.greenBright("✅ Prompt built successfully."));
+    console.log(chalk.cyan(`[PromptBuilder] Token estimate: ~${Math.round(promptContent.length / 4)} tokens`));
+    return promptContent;
+}
+function serializeContext(ctx) {
+    const out = [];
+    out.push(`# User Query\n${ctx.initContext?.userQuery}\n`);
+    if (ctx.initContext?.projectSummary) {
+        out.push(`# Project Summary\n${ctx.initContext?.projectSummary}\n`);
+    }
+    if (ctx.initContext?.moduleSummaries?.length) {
+        out.push(`# Module Summaries`);
+        for (const m of ctx.initContext?.moduleSummaries) {
+            out.push(`- **${m.path}**: ${m.summary}`);
+        }
+        out.push("");
+    }
+    if (ctx.workingFiles?.length) {
+        out.push(`# Working Files`);
+        for (const f of ctx.workingFiles) {
+            out.push(`\n## ${f.path}`);
+            if (f.summary)
+                out.push(`Summary: ${f.summary}`);
+            if (f.code)
+                out.push(`\nCode (truncated):\n${f.code.slice(0, 1000)}`);
+        }
+    }
+    if (ctx.analysis?.focus?.relevantFiles?.length) {
+        out.push(`# Focused Files (semantic analysis)`);
+        for (const path of ctx.analysis.focus.relevantFiles) {
+            out.push(`- ${path}`);
+        }
+        if (ctx.analysis.focus.rationale) {
+            out.push(`Rationale: ${ctx.analysis.focus.rationale}`);
+        }
+    }
+    if (ctx.analysis?.understanding) {
+        out.push(`# Semantic Understanding`);
+        if (ctx.analysis.understanding.problemStatement)
+            out.push(`Problem: ${ctx.analysis.understanding.problemStatement}`);
+        if (ctx.analysis.understanding.assumptions?.length)
+            out.push(`Assumptions: ${ctx.analysis.understanding.assumptions.join(", ")}`);
+        if (ctx.analysis.understanding.risks?.length)
+            out.push(`Risks: ${ctx.analysis.understanding.risks.join(", ")}`);
+    }
+    if (ctx.initContext?.repoTree) {
+        out.push(`# Repo Tree\n${ctx.initContext?.repoTree}\n`);
+    }
+    if (ctx.initContext?.kgSample?.length) {
+        out.push(`# Knowledge Graph Sample`);
+        for (const e of ctx.initContext?.kgSample) {
+            out.push(`- ${e.source} -> (${e.relation}) -> ${e.target}`);
+        }
+    }
+    return out.join("\n");
+}

package/dist/utils/promptLogHelper.js

@@ -0,0 +1,52 @@
+import fs from "fs";
+import path from "path";
+import { log } from "../utils/log.js";
+import { SCAI_HOME, PROMPT_LOG_PATH } from "../constants.js";
+/**
+ * Ensures SCAI_HOME exists before writing logs.
+ */
+function ensureHomeDir() {
+    if (!fs.existsSync(SCAI_HOME))
+        fs.mkdirSync(SCAI_HOME, { recursive: true });
+}
+/**
+ * Creates a formatted header for visual clarity in logs.
+ */
+function formatHeader(title) {
+    const divider = "=".repeat(68);
+    return `\n\n${divider}\n📂 ${title}\n${divider}\n`;
+}
+/**
+ * Overwrites the prompt log with a new prompt.
+ */
+export function logPrompt(prompt) {
+    try {
+        ensureHomeDir();
+        const entry = formatHeader("Prompt Updated") + prompt + "\n";
+        fs.writeFileSync(PROMPT_LOG_PATH, entry, "utf-8");
+        log(`📝 Prompt written to ${PROMPT_LOG_PATH}`);
+    }
+    catch (err) {
+        log("❌ Failed to write prompt log:", err);
+    }
+}
+/**
+ * Appends module input/output data to a separate log file.
+ * Automatically stringifies objects.
+ */
+export function logInputOutput(stepName, type, content) {
+    const ioLogPath = path.join(SCAI_HOME, "input_output.log");
+    try {
+        ensureHomeDir();
+        const contentStr = typeof content === "string" ? content.trim() : JSON.stringify(content, null, 2);
+        const entry = formatHeader(`${type.toUpperCase()} | ${stepName}`) +
+            contentStr +
+            "\n" +
+            "=".repeat(68) +
+            "\n";
+        fs.appendFileSync(ioLogPath, entry, "utf-8");
+    }
+    catch (err) {
+        log(`❌ Failed to append ${type} for ${stepName}:`, err);
+    }
+}

package/dist/utils/sanitizeQuery.js

@@ -1,27 +1,39 @@
 // src/utils/sanitizeQuery.ts
 import { STOP_WORDS } from '../fileRules/stopWords.js';
+// Stage 1: normalize junk out of query
+export function basicCleanup(raw) {
+    return raw
+        .replace(/["']/g, '') // remove quotes
+        .replace(/[()]/g, ' ') // replace parens with space
+        .replace(/\bOR\b|\bAND\b/gi, ' ') // strip boolean operators
+        .replace(/\w+:/g, '') // remove field prefixes like path:, ext:
+        .replace(/[<>=*]/g, ' ') // remove invalid operators
+        .replace(/\\/g, '') // remove stray backslashes
+        .replace(/<[^>]+>/g, '') // strip placeholders like <endpoint>
+        .replace(/\s+/g, ' ') // collapse whitespace
+        .trim();
+}
+// Stage 2: tokenize & prepare for FTS5
 export function sanitizeQueryForFts(input) {
-    input = input.trim().toLowerCase();
-    // If the whole input looks like a filename/path, quote it
+    input = basicCleanup(input)
+        .toLowerCase()
+        .replace(/\(([^)]+)\)/g, (_, inner) => inner.replace(/[|]/g, ' ')) // expand grouped ORs
+        .replace(/[|]/g, ' '); // handle standalone ORs
     if (/^[\w\-./]+$/.test(input) && !/\s/.test(input)) {
         return `"${input.replace(/"/g, '""')}"*`;
     }
     const tokens = input
         .split(/\s+/)
-        .map(token => token.toLowerCase())
         .map(token => {
-        // If the token looks like a filename/path, keep it quoted
         if (/[\w]+\.[a-z0-9]+$/.test(token)) {
             return `"${token.replace(/"/g, '""')}"`;
         }
-        // Otherwise, clean it like normal
         return token
-            .replace(/[^a-z0-9_*"]/gi, '') // remove all invalid FTS5 chars
+            .replace(/[^a-z0-9_*"]/gi, '')
             .replace(/'/g, "''");
     })
         .filter(token => token.length > 2 &&
-        !STOP_WORDS.has(token.replace(/[*"]/g, '')) // check unquoted
-    )
+        !STOP_WORDS.has(token.replace(/[*"]/g, '')))
         .map(token => (token.startsWith('"') ? token : token + '*'));
     return tokens.length > 0 ? tokens.join(' OR ') : '*';
 }

package/dist/utils/sleep.js

@@ -0,0 +1,3 @@
+export function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/dist/utils/splitCodeIntoChunk.js

@@ -1,49 +1,82 @@
 import { encode } from 'gpt-3-encoder';
-export function splitCodeIntoChunks(text, maxTokens) {
+export function splitCodeIntoChunks(text, maxTokens = 1500, hardLimitMultiplier = 1.8) {
     const lines = text.split('\n');
     const chunks = [];
     let currentChunkLines = [];
     let currentTokens = 0;
     let inMultiComment = false;
-    const start = '/*';
-    const end = '*/';
+    let inFunction = false;
+    let inTryBlock = false;
+    let globalBraceDepth = 0;
+    let functionBraceDepth = 0;
+    let parenDepth = 0;
+    let bracketDepth = 0;
     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
+        // ---------- comments ----------
+        if (trimmed.includes('/*') && !trimmed.includes('*/'))
             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
+        if (trimmed.includes('*/'))
             inMultiComment = false;
+        // ---------- function start ----------
+        const isFunctionStart = trimmed.startsWith('function ') ||
+            trimmed.startsWith('async function ') ||
+            trimmed.startsWith('class ') ||
+            trimmed.match(/^\w+\s*=\s*\(.*\)\s*=>\s*{/);
+        if (!inFunction && isFunctionStart) {
+            inFunction = true;
+            functionBraceDepth = 0;
         }
-        const lineTokens = encode(line + '\n').length;
-        if (currentTokens + lineTokens > maxTokens) {
-            // 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 t = currentChunkLines[i].trim();
-                if (!inMultiComment &&
-                    (t === '' ||
-                        t.startsWith('function ') ||
-                        t.startsWith('class ') ||
-                        t.endsWith('}') ||
-                        t.endsWith(';'))) {
-                    splitIndex = i + 1;
-                    break;
-                }
+        // ---------- try/catch ----------
+        if (trimmed.startsWith('try {'))
+            inTryBlock = true;
+        if (trimmed.startsWith('catch') || trimmed.startsWith('finally'))
+            inTryBlock = false;
+        // ---------- depth tracking ----------
+        for (const char of line) {
+            if (char === '{') {
+                globalBraceDepth++;
+                if (inFunction)
+                    functionBraceDepth++;
+            }
+            else if (char === '}') {
+                globalBraceDepth = Math.max(0, globalBraceDepth - 1);
+                if (inFunction)
+                    functionBraceDepth = Math.max(0, functionBraceDepth - 1);
+            }
+            else if (char === '(') {
+                parenDepth++;
+            }
+            else if (char === ')') {
+                parenDepth = Math.max(0, parenDepth - 1);
+            }
+            else if (char === '[') {
+                bracketDepth++;
+            }
+            else if (char === ']') {
+                bracketDepth = Math.max(0, bracketDepth - 1);
             }
-            chunks.push(currentChunkLines.slice(0, splitIndex).join('\n'));
-            currentChunkLines = currentChunkLines.slice(splitIndex);
-            currentTokens = encode(currentChunkLines.join('\n')).length;
         }
+        // ---------- add line ----------
         currentChunkLines.push(line);
-        currentTokens += lineTokens;
+        currentTokens += encode(line + '\n').length;
+        // ---------- split decision ----------
+        const softLimitReached = currentTokens >= maxTokens;
+        const hardLimitReached = currentTokens >= maxTokens * hardLimitMultiplier;
+        const safeToSplit = !inMultiComment &&
+            !inTryBlock &&
+            functionBraceDepth === 0 &&
+            parenDepth === 0 &&
+            bracketDepth === 0;
+        if ((softLimitReached && safeToSplit) || hardLimitReached) {
+            chunks.push(currentChunkLines.join('\n'));
+            currentChunkLines = [];
+            currentTokens = 0;
+        }
+        // ---------- function end ----------
+        if (inFunction && functionBraceDepth === 0) {
+            inFunction = false;
+        }
     }
     if (currentChunkLines.length > 0) {
         chunks.push(currentChunkLines.join('\n'));

package/dist/utils/vscode.js

@@ -0,0 +1,49 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { spawn } from "child_process";
+/**
+ * Opens a visual diff in VS Code between the original and modified versions.
+ *
+ * @param filePath - The path or name of the file being diffed.
+ * @param diffContent - The unified diff text for that file.
+ */
+export async function openDiffInVSCode(filePath, diffContent) {
+    try {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "scai-diff-"));
+        // Temporary file paths
+        const baseName = path.basename(filePath);
+        const originalPath = path.join(tmpDir, `${baseName}_OLD.tmp`);
+        const modifiedPath = path.join(tmpDir, `${baseName}_NEW.tmp`);
+        // Extract file versions from unified diff
+        const oldLines = [];
+        const newLines = [];
+        for (const line of diffContent.split("\n")) {
+            if (line.startsWith("+") && !line.startsWith("+++")) {
+                newLines.push(line.slice(1));
+            }
+            else if (line.startsWith("-") && !line.startsWith("---")) {
+                oldLines.push(line.slice(1));
+            }
+            else if (!line.startsWith("@@")) {
+                // context lines appear in both versions
+                oldLines.push(line);
+                newLines.push(line);
+            }
+        }
+        fs.writeFileSync(originalPath, oldLines.join("\n"), "utf-8");
+        fs.writeFileSync(modifiedPath, newLines.join("\n"), "utf-8");
+        console.log(`\n🔍 Opening VS Code diff:`);
+        console.log(`   ${originalPath}`);
+        console.log(`⇄  ${modifiedPath}\n`);
+        const child = spawn("code", ["--diff", originalPath, modifiedPath], {
+            stdio: "inherit",
+        });
+        child.on("error", () => {
+            console.error("❌ Failed to open diff in VS Code. Ensure the 'code' CLI is installed and in your PATH.");
+        });
+    }
+    catch (err) {
+        console.error("❌ Error while preparing diff for VS Code:", err);
+    }
+}

package/dist/workflow/workflowResolver.js

@@ -0,0 +1,14 @@
+// src/agents/WorkflowResolver.ts
+import { resolveModulesByNames } from "../pipeline/registry/moduleRegistry.js";
+/**
+ * Simple resolver function to compute module order (honours before/after relationships).
+ * This replaces the previous Workflow class used only to resolve modules.
+ *
+ * Returns an array of PromptModuleMeta (the existing shape your registry returns).
+ */
+export function resolveModules(goals) {
+    // Trim and validate names here (defensive)
+    const trimmed = goals.map((g) => (typeof g === "string" ? g.trim() : g));
+    const modules = resolveModulesByNames(trimmed);
+    return modules;
+}

package/dist/workflow/workflowRunner.js

@@ -0,0 +1,103 @@
+// File: src/workflow/workflowRunner.ts
+import fs from "fs/promises";
+import chalk from "chalk";
+import { normalizePath } from "../utils/contentUtils.js";
+/**
+ * runWorkflow - orchestrates running a modular I/O pipeline.
+ *
+ * Each module conforms to the `ModuleIO` interface:
+ *   input:  { query, content? }
+ *   output: { data?, mode?, newFilepath? }
+ *
+ * Options:
+ *  - modules: ordered modules to run (Module[])
+ *  - filepath: optional file path to read/write
+ *  - inputContent: optional string for stdin content
+ *
+ * Behaviours:
+ *  - Sequentially runs each module on the full file content
+ *  - Supports output modes: overwrite, append, newFile, skip
+ *  - Stream mode (no filepath): prints final output to stdout
+ */
+export async function runWorkflow(opts) {
+    const { modules } = opts;
+    let filepath = opts.filepath;
+    let fileContent = "";
+    try {
+        if (filepath) {
+            filepath = normalizePath(filepath);
+            await fs.access(filepath);
+            fileContent = await fs.readFile(filepath, "utf-8");
+        }
+        else {
+            fileContent = opts.inputContent ?? "";
+        }
+        for (const mod of modules) {
+            console.log(chalk.cyan(`\n⚙️ Running module: ${mod.name}`));
+            const io = {
+                query: `Process ${filepath ?? "<stdin>"} with ${mod.name}`,
+                content: fileContent,
+            };
+            const result = await mod.run(io);
+            if (!result || !result.data || !String(result.data).trim()) {
+                throw new Error(`⚠️ Empty result from module ${mod.name}`);
+            }
+            const output = typeof result.data === "string"
+                ? result.data
+                : JSON.stringify(result.data, null, 2);
+            const mode = result.mode ??
+                "overwrite"; // default mode if not specified by module
+            const newFilepath = result.newFilepath;
+            //
+            // === Handle stdout vs file modes ===
+            //
+            if (!filepath) {
+                // stdin mode: print directly to stdout
+                process.stdout.write(output);
+                fileContent = output;
+                continue;
+            }
+            //
+            // === File-backed mode handling (honor mode semantics) ===
+            //
+            switch (mode) {
+                case "overwrite":
+                    await fs.writeFile(filepath, output, "utf-8");
+                    console.log(chalk.green(`✅ Overwritten: ${filepath}`));
+                    fileContent = output;
+                    break;
+                case "append":
+                    await fs.appendFile(filepath, output, "utf-8");
+                    console.log(chalk.green(`✅ Appended: ${filepath}`));
+                    fileContent += output;
+                    break;
+                case "newFile":
+                    if (!newFilepath)
+                        throw new Error(`newFile mode requires a newFilepath`);
+                    const resolvedNew = normalizePath(newFilepath);
+                    await fs.writeFile(resolvedNew, output, "utf-8");
+                    console.log(chalk.green(`✅ New file created: ${resolvedNew}`));
+                    filepath = resolvedNew;
+                    fileContent = output;
+                    break;
+                case "skip":
+                    console.log(chalk.gray(`⏭️ Skipped writing for module ${mod.name}`));
+                    fileContent = output;
+                    break;
+                default:
+                    console.log(chalk.yellow(`⚠️ Unknown mode (${String(mode)}). Treating as overwrite.`));
+                    await fs.writeFile(filepath, output, "utf-8");
+                    fileContent = output;
+                    break;
+            }
+        }
+        // Final stdout flush if running without filepath
+        if (!opts.filepath) {
+            process.stdout.write("\n");
+        }
+    }
+    catch (err) {
+        console.error(chalk.red("❌ Error in workflow run:"), err?.message ?? err);
+        throw err;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scai",
-  "version": "0.1.117",
+  "version": "0.1.118",
   "type": "module",
   "bin": {
     "scai": "./dist/index.js"
@@ -35,7 +35,9 @@
   ],
   "scripts": {
     "build": "rm -rfd dist && tsc && chmod +x dist/index.js && git add .",
-    "start": "node dist/index.js"
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest watch"
   },
   "dependencies": {
     "@octokit/rest": "^22.0.0",
@@ -47,18 +49,17 @@
     "commander": "^11.0.0",
     "fast-glob": "^3.3.3",
     "gpt-3-encoder": "^1.1.4",
+    "java-parser": "^3.0.1",
     "proper-lockfile": "^4.1.2",
+    "shell-quote": "^1.8.3",
     "string-similarity-js": "^2.1.4",
     "ts-morph": "^26.0.0"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/columnify": "^1.5.4",
-    "@types/jest": "^30.0.0",
     "@types/node": "^24.2.1",
     "@types/proper-lockfile": "^4.1.4",
-    "jest": "^30.0.2",
-    "ts-jest": "^29.4.0",
     "ts-node": "^10.9.2",
     "typescript": "^5.8.3"
   },

package/dist/agent/agentManager.js

@@ -1,39 +0,0 @@
-// src/agent/agentManager.ts
-import chalk from "chalk";
-import fs from "fs/promises";
-import { resolveModuleOrder } from "../pipeline/registry/moduleRegistry.js";
-import { handleAgentRun } from "./workflowManager.js";
-// Minimal agent: resolves modules (with before/after dependencies) and delegates to handleAgentRun
-export class Agent {
-    constructor(goals) {
-        // Trim goal names to avoid whitespace issues
-        this.goals = goals.map((g) => g.trim());
-    }
-    resolveModules(goals) {
-        // Use the registry helper to get the correct order
-        return resolveModuleOrder(goals);
-    }
-    async execute(filepath) {
-        console.log(chalk.cyan(`🤖 Agent starting on: ${filepath}`));
-        // Resolve modules (with before/after dependencies)
-        const modules = this.resolveModules(this.goals);
-        console.log(chalk.green("📋 Modules to run:"), modules.map((m) => m.name).join(" → "));
-        try {
-            // Check that the file exists before trying to read it
-            await fs.access(filepath);
-            // Read file content (optional, could be used by modules in workflow)
-            await fs.readFile(filepath, "utf-8");
-        }
-        catch (err) {
-            if (err.code === "ENOENT") {
-                console.error(chalk.redBright("❌ Error:"), `File not found: ${chalk.yellow(filepath)}`);
-                console.error(`Make sure the path is correct. (cwd: ${chalk.gray(process.cwd())})`);
-                process.exit(1);
-            }
-            throw err; // rethrow for unexpected errors
-        }
-        // Delegate everything to handleAgentRun (like CLI commands do)
-        await handleAgentRun(filepath, modules);
-        console.log(chalk.green("✅ Agent finished!"));
-    }
-}

package/dist/agent/workflowManager.js

@@ -1,95 +0,0 @@
-// 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';
-// basically handles all input (chunk if large), and writing of output (overwrite, append, new file)
-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;
-                case 'skip':
-                    console.log(chalk.gray(`⏭️ Skipped writing for module ${mod.name}`));
-                    // don’t touch files, but keep chunks flowing
-                    workingChunks = processed;
-                    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/dist/commands/ModulePipelineCmd.js

@@ -1,31 +0,0 @@
-import { readFileSync } from 'fs';
-import { getModuleByName } from '../pipeline/registry/moduleRegistry.js';
-import { runModulePipeline } from '../pipeline/runModulePipeline.js';
-export async function runModulePipelineFromCLI(file, options) {
-    if (!options.modules) {
-        console.error('❌ No modules specified. Use --modules or -m.');
-        process.exit(1);
-    }
-    const moduleNames = options.modules.split(',').map((m) => m.trim());
-    // Read file content
-    let fileContent = '';
-    try {
-        fileContent = readFileSync(file, 'utf-8');
-    }
-    catch (err) {
-        console.error(`❌ Could not read file: ${file}`);
-        process.exit(1);
-    }
-    const input = { content: fileContent, filepath: file };
-    // Retrieve modules from the registry
-    const resolvedModules = moduleNames.map((name) => {
-        const module = getModuleByName(name);
-        if (!module) {
-            console.error(`❌ Failed to load module: ${name}`);
-            process.exit(1);
-        }
-        return module;
-    });
-    // Run the module pipeline
-    await runModulePipeline(resolvedModules, input);
-}