scai 0.1.117 → 0.1.118

package/dist/lib/spinner.js

@@ -3,14 +3,19 @@ export class Spinner {
         this.frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
         this.interval = null;
         this.i = 0;
-        this.text = message;
+        if (message) {
+            this.text = message;
+        }
     }
     start() {
         process.stdout.write('\x1b[?25l'); // hide cursor
-        process.stdout.write(` ${this.text}`); // print text once
+        if (this.text) {
+            process.stdout.write(` ${this.text}`);
+        }
         this.interval = setInterval(() => {
-            process.stdout.write('\r'); // return to start of line
-            process.stdout.write(`${this.frames[this.i]} ${this.text}`);
+            const text = this.text ?? '';
+            process.stdout.write('\r');
+            process.stdout.write(`${this.frames[this.i]} ${text}`);
             this.i = (this.i + 1) % this.frames.length;
         }, 80);
     }
@@ -20,7 +25,9 @@ export class Spinner {
     succeed(msg) {
         this.stop();
         process.stdout.write('\r'); // go to start
-        console.log(`✅ ${msg}`);
+        if (msg) {
+            console.log(`✅ ${msg}`);
+        }
     }
     fail(msg) {
         this.stop();

package/dist/modelSetup.js

@@ -194,13 +194,3 @@ export async function bootstrap() {
     await ensureModelsDownloaded();
     await ensureVSCodeInstalled();
 }
-// 🔗 Helper: open file or diff in VSCode
-export function openInVSCode(filePath, options) {
-    const args = options?.diffWith ? ['--diff', options.diffWith, filePath] : [filePath];
-    try {
-        spawn('code', args, { stdio: 'inherit' });
-    }
-    catch {
-        console.log(chalk.red('❌ Failed to launch VSCode CLI. Make sure it is installed and in PATH.'));
-    }
-}

package/dist/pipeline/modules/changeLogModule.js

@@ -1,10 +1,12 @@
+// src/pipeline/modules/changeLogModule.ts
 import { Config } from '../../config.js';
 import { generate } from '../../lib/generate.js';
 export const changelogModule = {
     name: 'changelogModule',
-    description: 'Generates changelog entry based on Git diff',
+    description: 'Generates a changelog entry based on Git diff',
     async run(input) {
         const model = Config.getModel();
+        const diffContent = typeof input.content === 'string' ? input.content : '';
         const prompt = `
 Using the Git diff below, return **only meaningful user-facing changes** as clean markdown bullet points.
 
@@ -15,33 +17,28 @@ ONLY return the bullet points!
 If no meaningful changes are present, return the text: "NO UPDATE".
 
 --- DIFF START ---
-${input.content}
+${diffContent}
 --- DIFF END ---
 `.trim();
-        const response = await generate({ content: prompt });
-        // Check if we received a meaningful result or "NO UPDATE"
-        const content = response?.content?.trim();
-        if (content === 'NO UPDATE') {
+        const response = await generate({
+            query: input.query,
+            content: prompt,
+        });
+        const rawContent = typeof response?.data === 'string' ? response.data.trim() : '';
+        if (!rawContent || rawContent === 'NO UPDATE') {
             console.log("⚠️ No meaningful updates found. Returning 'NO UPDATE'.");
             return {
-                content: response.content,
-                summary: 'NO UPDATE',
-                suggestions: response?.suggestions ?? [],
-                filepath: input.filepath,
+                query: input.query,
+                data: 'NO UPDATE',
             };
         }
-        // Split the content into lines
-        const lines = content?.split('\n').map(line => line.trim()) ?? [];
-        // Filter out non-bullet lines (now including the '•' symbol)
+        // Split into lines and keep only bullet points
+        const lines = rawContent.split('\n').map(line => line.trim());
         const bulletLines = lines.filter(line => /^([*-+•]|\d+\.)\s/.test(line));
-        // Join the filtered lines into the final changelog entry
         const filtered = bulletLines.join('\n');
-        // Return the processed content and filtered changelog
         return {
-            content: response.content,
-            summary: filtered,
-            suggestions: response?.suggestions ?? [],
-            filepath: input.filepath,
+            query: input.query,
+            data: filtered || 'NO UPDATE',
         };
     }
 };

package/dist/pipeline/modules/chunkManagerModule.js

@@ -0,0 +1,24 @@
+// src/pipeline/modules/chunkManagerModule.ts
+import fs from 'fs';
+import { normalizePath } from '../../utils/contentUtils.js';
+import { splitCodeIntoChunks } from '../../utils/splitCodeIntoChunk.js';
+export const chunkManagerModule = {
+    name: "chunkManager",
+    description: "Splits large files into manageable chunks for processing.",
+    async run(input) {
+        const filepath = normalizePath(input.filepath ?? "");
+        const fileContent = fs.readFileSync(filepath, "utf-8");
+        const maxTokens = 1500;
+        const baseChunks = splitCodeIntoChunks(fileContent, maxTokens);
+        return {
+            content: fileContent,
+            data: {
+                baseChunks,
+                workingChunks: [...baseChunks],
+                chunkCount: baseChunks.length,
+                filepath,
+            },
+            filepath,
+        };
+    },
+};

package/dist/pipeline/modules/cleanupModule.js

@@ -1,4 +1,6 @@
-import chalk from 'chalk';
+// File: src/modules/cleanupModule.ts
+import chalk from "chalk";
+/** --- Helper: detect noise at top/bottom of content --- */
 function isTopOrBottomNoise(line) {
     const trimmed = line.trim();
     if (/^```(?:\w+)?$/.test(trimmed))
@@ -6,7 +8,7 @@ function isTopOrBottomNoise(line) {
     if (/^<!--.*-->$/.test(trimmed))
         return true;
     const lower = trimmed.toLowerCase();
-    if (!trimmed.startsWith('//') && !trimmed.startsWith('/*')) {
+    if (!trimmed.startsWith("//") && !trimmed.startsWith("/*")) {
         return [
             /^i\s/i,
             /^here/,
@@ -23,107 +25,110 @@ function isTopOrBottomNoise(line) {
             /example/,
             /summary/,
             /added comments/,
-        ].some(pattern => pattern.test(lower));
+        ].some((pattern) => pattern.test(lower));
     }
     return false;
 }
-export const cleanupModule = {
-    name: 'cleanup',
-    description: 'Remove markdown fences, fluff, and non-JSON lines with colored logging',
-    async run(input) {
-        // Normalize line endings to \n
-        let content = input.content.replace(/\r\n/g, '\n');
-        let lines = content.split('\n');
-        // --- CLEAN TOP ---
-        while (lines.length && (lines[0].trim() === '' || isTopOrBottomNoise(lines[0]))) {
-            if (/^```(?:\w+)?$/.test(lines[0].trim()))
-                break;
-            console.log(chalk.red(`[cleanupModule] Removing noise from top:`), chalk.yellow(`"${lines[0].trim()}"`));
-            lines.shift();
+/** Extract first object slice { ... } */
+function extractObject(text) {
+    const start = text.indexOf("{");
+    const end = text.lastIndexOf("}");
+    return start !== -1 && end !== -1 && end > start ? text.slice(start, end + 1) : null;
+}
+/** Extract first array slice [ ... ] */
+function extractArray(text) {
+    const start = text.indexOf("[");
+    const end = text.lastIndexOf("]");
+    return start !== -1 && end !== -1 && end > start ? text.slice(start, end + 1) : null;
+}
+/** Try parsing with fallback slice logic */
+function parseJsonWithFallback(content) {
+    const trimmed = content.trim();
+    // --- 1) JSON Array strategy ---
+    if (trimmed.startsWith("[")) {
+        try {
+            return JSON.parse(trimmed);
         }
-        if (lines.length && /^```(?:\w+)?$/.test(lines[0].trim())) {
-            console.log(chalk.red(`[cleanupModule] Found opening fenced block at top.`));
-            lines.shift();
-            let closingIndex = -1;
-            for (let i = 0; i < lines.length; i++) {
-                if (/^```(?:\w+)?$/.test(lines[i].trim())) {
-                    closingIndex = i;
-                    break;
+        catch {
+            const slice = extractArray(trimmed);
+            if (slice) {
+                try {
+                    return JSON.parse(slice);
                 }
+                catch { }
             }
-            if (closingIndex !== -1) {
-                console.log(chalk.red(`[cleanupModule] Found closing fenced block at line ${closingIndex + 1}, removing fence lines.`));
-                lines.splice(closingIndex, 1);
-            }
-            else {
-                console.log(chalk.yellow(`[cleanupModule] No closing fenced block found, only removed opening fence.`));
-            }
-        }
-        // --- CLEAN BOTTOM ---
-        if (lines.length && /^```(?:\w+)?$/.test(lines[lines.length - 1].trim())) {
-            console.log(chalk.red(`[cleanupModule] Removing closing fenced block line at bottom.`));
-            lines.pop();
         }
-        while (lines.length && (lines[lines.length - 1].trim() === '' || isTopOrBottomNoise(lines[lines.length - 1]))) {
-            console.log(chalk.red(`[cleanupModule] Removing noise from bottom after fenced block:`), chalk.yellow(`"${lines[lines.length - 1].trim()}"`));
-            lines.pop();
+    }
+    // --- 2) JSON Object strategy ---
+    if (trimmed.startsWith("{")) {
+        try {
+            return JSON.parse(trimmed);
         }
-        // --- REMOVE ANY LINGERING TRIPLE TICK LINES ANYWHERE ---
-        lines = lines.filter(line => {
-            const trimmed = line.trim();
-            if (/^```(?:\w+)?$/.test(trimmed)) {
-                console.log(chalk.red(`[cleanupModule] Removing lingering triple tick line:`), chalk.yellow(`"${line}"`));
-                return false;
-            }
-            return true;
-        });
-        // --- FINAL CLEANUP: KEEP ONLY JSON LINES INSIDE BRACES ---
-        let jsonLines = [];
-        let braceDepth = 0;
-        let insideBraces = false;
-        for (let line of lines) {
-            const trimmed = line.trim();
-            // Detect start of JSON object/array
-            if (!insideBraces && (trimmed.startsWith('{') || trimmed.startsWith('['))) {
-                insideBraces = true;
-            }
-            if (insideBraces) {
-                // Track nested braces/brackets
-                for (const char of trimmed) {
-                    if (char === '{' || char === '[')
-                        braceDepth++;
-                    if (char === '}' || char === ']')
-                        braceDepth--;
-                }
-                // Skip lines that are clearly non-JSON inside braces
-                if (!trimmed.startsWith('//') && !/^\/\*/.test(trimmed) && trimmed !== '') {
-                    jsonLines.push(line);
+        catch {
+            const slice = extractObject(trimmed);
+            if (slice) {
+                try {
+                    return JSON.parse(slice);
                 }
-                // Stop collecting after outermost brace closed
-                if (braceDepth === 0)
-                    break;
+                catch { }
             }
         }
-        let finalContent = jsonLines.join('\n').trim();
-        // --- VALIDATE JSON ---
+    }
+    // --- 3) Fallback: if mixed text, extract first object ---
+    const fallbackObj = extractObject(content);
+    if (fallbackObj) {
         try {
-            JSON.parse(finalContent);
-            return { content: finalContent };
-        }
-        catch (err) {
-            console.warn(chalk.yellow(`[cleanupModule] Initial JSON.parse failed:`), chalk.red(err instanceof Error ? err.message : err));
-            // Attempt simple cleanup: remove trailing commas before } or ]
-            finalContent = finalContent.replace(/,\s*([}\]])/g, '$1');
-            try {
-                JSON.parse(finalContent);
-                console.log(chalk.green(`[cleanupModule] Fixed JSON by removing trailing commas.`));
-                return { content: finalContent };
-            }
-            catch (err2) {
-                console.error(chalk.red(`[cleanupModule] JSON still invalid after cleanup:`), chalk.yellow(err2 instanceof Error ? err2.message : err2));
-                // Return best-effort content even if invalid, so downstream can log/debug
-                return { content: finalContent };
-            }
+            return JSON.parse(fallbackObj);
         }
+        catch { }
     }
+    return null;
+}
+/** --- Module --- */
+export const cleanupModule = {
+    name: "cleanup",
+    description: "Removes markdown fences, fluff, and reasoning text; extracts valid JSON if possible.",
+    groups: ["transform"],
+    async run(input) {
+        // --- Normalize input ---
+        let content = typeof input.content === "string"
+            ? input.content
+            : JSON.stringify(input.content ?? "");
+        content = content.replace(/\r\n/g, "\n");
+        // --- Trim top/bottom noise ---
+        let lines = content.split("\n");
+        while (lines.length && (lines[0].trim() === "" || isTopOrBottomNoise(lines[0])))
+            lines.shift();
+        while (lines.length && (lines[lines.length - 1].trim() === "" || isTopOrBottomNoise(lines[lines.length - 1]))) {
+            lines.pop();
+        }
+        content = lines.join("\n");
+        // --- Strip markdown fences, comments, thinking tags ---
+        content = content
+            .replace(/```(?:json)?/gi, "")
+            .replace(/```/g, "")
+            .replace(/<!--.*?-->/gs, "")
+            .replace(/<think>[\s\S]*?<\/think>/gi, "")
+            .trim();
+        // If no JSON markers at all → treat as plain cleaned text
+        if (!content.includes("{") && !content.includes("[")) {
+            return { query: input.query, data: content };
+        }
+        // --- Parse JSON using simplified strategy ---
+        const parsed = parseJsonWithFallback(content);
+        if (parsed !== null) {
+            console.log(chalk.green("[cleanupModule] JSON parsed successfully."));
+            return {
+                query: input.query,
+                content,
+                data: parsed,
+            };
+        }
+        console.warn(chalk.red("[cleanupModule] Failed to parse JSON — returning raw content."));
+        return {
+            query: input.query,
+            content,
+            data: content,
+        };
+    },
 };

package/dist/pipeline/modules/codeTransformModule.js

@@ -0,0 +1,208 @@
+import { generate } from "../../lib/generate.js";
+import { cleanupModule } from "./cleanupModule.js";
+import { logInputOutput } from "../../utils/promptLogHelper.js";
+import { splitCodeIntoChunks, countTokens } from "../../utils/splitCodeIntoChunk.js";
+const SINGLE_SHOT_TOKEN_LIMIT = 1800;
+const CHUNK_TOKEN_LIMIT = 1500;
+/**
+ * Remove leading/trailing markdown code fences.
+ */
+function stripCodeFences(text) {
+    const lines = text.split("\n");
+    while (lines.length && /^```/.test(lines[0].trim())) {
+        lines.shift();
+    }
+    while (lines.length && /^```/.test(lines[lines.length - 1].trim())) {
+        lines.pop();
+    }
+    return lines.join("\n");
+}
+/**
+ * Heuristic: decide whether chunk output looks unsafe / non-code.
+ */
+function isSuspiciousChunkOutput(text, originalChunk) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return true;
+    // Explanations or meta text
+    if (/here is|transformed|updated code|explanation/i.test(trimmed)) {
+        return true;
+    }
+    // JSON-ish output (we do NOT want JSON in chunk mode)
+    if (trimmed.startsWith("{") &&
+        trimmed.endsWith("}")) {
+        return true;
+    }
+    // Extremely short compared to original
+    if (trimmed.length < originalChunk.trim().length * 0.3) {
+        return true;
+    }
+    return false;
+}
+export const codeTransformModule = {
+    name: "codeTransform",
+    description: "Transforms a single file specified in the current plan step based on user instruction. " +
+        "Outputs full rewritten file content (materialized state).",
+    groups: ["transform"],
+    run: async (input) => {
+        var _a, _b;
+        const query = typeof input.query === "string"
+            ? input.query
+            : String(input.query ?? "");
+        const context = input.context;
+        if (!context) {
+            return { query, data: { files: [], errors: ["No context provided"] } };
+        }
+        const workingFiles = context.workingFiles ?? [];
+        const step = context.currentStep;
+        const targetFile = step?.targetFile;
+        if (!targetFile) {
+            return {
+                query,
+                data: { files: [], errors: ["No targetFile specified in current plan step"] },
+            };
+        }
+        const file = workingFiles.find(f => f.path === targetFile);
+        if (!file || typeof file.code !== "string") {
+            return {
+                query,
+                data: { files: [], errors: [`Target file not found or missing code: ${targetFile}`] },
+            };
+        }
+        const normalizedQuery = context.analysis?.intent?.normalizedQuery ?? query;
+        const outputs = [];
+        const perFileErrors = [];
+        const tokenCount = countTokens(file.code);
+        // =========================================================================
+        // 🔹 PATH 1 — SMALL FILE (JSON, strict)
+        // =========================================================================
+        if (tokenCount <= SINGLE_SHOT_TOKEN_LIMIT) {
+            const prompt = `
+You are a precise code transformation assistant.
+
+User instruction (normalized):
+${normalizedQuery}
+
+File to transform:
+---\nFILE: ${file.path}\n${file.code}
+
+Rules:
+- You MUST apply the user instruction.
+- You MUST return the FULL rewritten file content.
+- Do NOT return diffs or partial snippets.
+
+JSON schema:
+{
+  "files": [
+    {
+      "filePath": "<path>",
+      "content": "<FULL rewritten file content>",
+      "notes": "<optional>"
+    }
+  ],
+  "errors": []
+}
+`.trim();
+            try {
+                const llmResponse = await generate({ content: prompt, query });
+                const cleaned = await cleanupModule.run({
+                    query,
+                    content: llmResponse.data,
+                });
+                const structured = typeof cleaned.data === "object"
+                    ? cleaned.data
+                    : JSON.parse(cleaned.data ?? "{}");
+                const out = Array.isArray(structured.files)
+                    ? structured.files.find((f) => f.filePath === file.path)
+                    : null;
+                if (!out || typeof out.content !== "string" || !out.content.trim()) {
+                    perFileErrors.push(`Model did not return full content for ${file.path}`);
+                }
+                else {
+                    outputs.push({
+                        filePath: file.path,
+                        content: out.content,
+                        notes: out.notes,
+                    });
+                }
+                perFileErrors.push(...(structured.errors ?? []));
+            }
+            catch (err) {
+                return {
+                    query,
+                    data: { files: [], errors: [`LLM call or parsing failed: ${err.message}`] },
+                };
+            }
+        }
+        // =========================================================================
+        // 🔹 PATH 2 — LARGE FILE (chunked, raw text)
+        // =========================================================================
+        else {
+            const chunks = splitCodeIntoChunks(file.code, CHUNK_TOKEN_LIMIT);
+            const transformedChunks = [];
+            for (let i = 0; i < chunks.length; i++) {
+                const chunk = chunks[i];
+                const prompt = `
+You are a precise code transformation assistant.
+
+User instruction (normalized):
+${normalizedQuery}
+
+You are given ONE CHUNK of a larger file.
+
+Rules:
+- Apply the instruction ONLY if relevant to this chunk.
+- If no change is needed, return the chunk UNCHANGED.
+- Do NOT add or remove unrelated code.
+- Do NOT reference other chunks.
+- Return ONLY code. No JSON. No explanations. No markdown fences.
+
+FILE: ${file.path}
+CHUNK ${i + 1} / ${chunks.length}
+---
+${chunk}
+`.trim();
+                try {
+                    logInputOutput("chunks", "output", chunk);
+                    const llmResponse = await generate({ content: prompt, query });
+                    const raw = typeof llmResponse.data === "string"
+                        ? llmResponse.data
+                        : String(llmResponse.data ?? "");
+                    const stripped = stripCodeFences(raw);
+                    if (isSuspiciousChunkOutput(stripped, chunk)) {
+                        transformedChunks.push(chunk);
+                        perFileErrors.push(`Chunk ${i + 1} suspicious output; original preserved.`);
+                    }
+                    else {
+                        transformedChunks.push(stripped);
+                    }
+                }
+                catch (err) {
+                    transformedChunks.push(chunk);
+                    perFileErrors.push(`Chunk ${i + 1} failed; original preserved. Error: ${err.message}`);
+                }
+            }
+            outputs.push({
+                filePath: file.path,
+                content: transformedChunks.join("\n"),
+            });
+        }
+        // =========================================================================
+        // 🔹 Persist execution artifacts
+        // =========================================================================
+        context.execution || (context.execution = {});
+        (_a = context.execution).codeTransformArtifacts || (_a.codeTransformArtifacts = { files: [] });
+        context.execution.codeTransformArtifacts.files.push(...outputs);
+        context.plan || (context.plan = {});
+        (_b = context.plan).touchedFiles || (_b.touchedFiles = []);
+        if (!context.plan.touchedFiles.includes(file.path)) {
+            context.plan.touchedFiles.push(file.path);
+        }
+        const output = {
+            query,
+            data: { files: outputs, errors: perFileErrors },
+        };
+        logInputOutput("codeTransform", "output", output.data);
+        return output;
+    },
+};

package/dist/pipeline/modules/commentModule.js

@@ -4,10 +4,12 @@ import { detectFileType } from '../../fileRules/detectFileType.js';
 export const addCommentsModule = {
     name: 'comments',
     description: 'Adds meaningful comments to any file type (code, config, or data)',
-    async run(input) {
+    groups: ["transform"],
+    run: async (input) => {
         const model = Config.getModel();
-        const fileType = detectFileType(input.filepath || '');
-        // Map file types to valid comment syntax
+        const filepath = typeof input.query === 'string' ? input.query : '';
+        const content = typeof input.content === 'string' ? input.content : '';
+        const fileType = detectFileType(filepath);
         const commentMap = {
             javascript: '//',
             typescript: '//',
@@ -42,7 +44,7 @@ You are a senior engineer reviewing a ${fileType} file.
 
 Please:
 
-- Add summary comments (2-3 lines) at relevant points for greater class insights
+- 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}.
 
@@ -50,14 +52,21 @@ Rules:
 - Return the full original chunk of code with added comments.
 - Inline comments should clarify complex or tricky parts.
 
-${input.content}
-
-`.trim();
-        const response = await generate({ content: prompt });
-        const contentToReturn = (response.content && response.content !== 'NO UPDATE') ? response.content : input.content;
+${content}
+    `.trim();
+        // ✅ Generate now uses ModuleIO (query + content)
+        const response = await generate({
+            query: filepath,
+            content: prompt,
+        });
+        // ✅ The result is now in `data`
+        const commentedContent = typeof response.data === 'string' && response.data !== 'NO UPDATE'
+            ? response.data
+            : content;
+        // ✅ Return proper ModuleIO shape (output → data)
         return {
-            content: contentToReturn,
-            mode: 'overwrite', // <-- declares that the original file should be overwritten
+            query: filepath,
+            data: commentedContent,
         };
     },
 };