scai 0.1.117 → 0.1.119

package/dist/pipeline/modules/summaryModule.js

@@ -1,41 +1,33 @@
-import { Config } from '../../config.js';
-import { generate } from '../../lib/generate.js';
-import path from 'path';
+import { generate } from "../../lib/generate.js";
+import { logInputOutput } from "../../utils/promptLogHelper.js";
 export const summaryModule = {
-    name: 'summary',
-    description: 'Generates a general summary of any file content.',
-    run: async ({ content, filepath }) => {
-        const model = Config.getModel();
-        const ext = filepath ? path.extname(filepath).toLowerCase() : '';
-        const filename = filepath ? path.basename(filepath) : '';
+    name: "summary",
+    description: "Generates a general summary of any file content.",
+    groups: ["analysis"],
+    run: async (input) => {
+        // ✅ Only care about content now
+        const contentStr = typeof input.content === "string"
+            ? input.content
+            : JSON.stringify(input.content ?? "", null, 2);
+        // ❌ Removed filepath/ext/filename extraction
         const prompt = `
 You are an assistant specialized in summarizing files.
 
-Your task is to summarize the contents of the following file as clearly and concisely as possible.
+Your task is to summarize the following content as clearly and concisely as possible:
 
-File: ${filename}
-Extension: ${ext}
-
-📋 Instructions:
-- Identify the main topic and purpose of the file
-- Summarize key content and sections
-- Mention any technical, legal, or structural info if relevant
-- Do NOT include the raw content or repeat lines from it
-- Return a human-readable bullet-point summary
-
---- FILE CONTENT START ---
-${content}
---- FILE CONTENT END ---
-    `.trim();
-        const response = await generate({ content: prompt, filepath });
-        if (response.content) {
-            response.summary = response.content;
-            console.log('\n📝 Summary:\n');
-            console.log(response.summary);
-        }
-        else {
-            console.warn('⚠️ No summary generated.');
-        }
-        return response;
-    }
+${contentStr}
+`.trim();
+        const response = await generate({
+            content: prompt,
+            query: ""
+        });
+        const summary = response.data ?? "⚠️ No summary generated.";
+        const output = {
+            query: input.query, // keep query for context
+            content: '',
+            data: { summary }, // ❌ no filepath
+        };
+        logInputOutput("summary", "output", output.data);
+        return output;
+    },
 };

package/dist/pipeline/modules/writeFileModule.js

@@ -0,0 +1,86 @@
+// File: src/modules/writeFileModule.ts
+import fs from "fs/promises";
+import chalk from "chalk";
+import { normalizePath } from "../../utils/contentUtils.js";
+import { logInputOutput } from "../../utils/promptLogHelper.js";
+export const writeFileModule = {
+    name: "writeFile",
+    description: "Writes materialized file outputs from codeTransformModule to disk. " +
+        "Only writes files specified in the current plan step.",
+    groups: ["finalize"],
+    run: async (input) => {
+        var _a;
+        const context = input.context;
+        const mode = input.data?.mode ?? "overwrite";
+        if (!context) {
+            return {
+                query: input.query,
+                data: { writeMode: mode, writtenFiles: [], errors: ["Missing execution context"] },
+            };
+        }
+        const step = context.currentStep;
+        if (!step) {
+            return {
+                query: input.query,
+                data: { writeMode: mode, writtenFiles: [], errors: ["No current step in context"] },
+            };
+        }
+        // Determine target file(s) from the current step
+        const targetFiles = [];
+        if (step.targetFile)
+            targetFiles.push(step.targetFile);
+        if (Array.isArray(step.targetFiles))
+            targetFiles.push(...step.targetFiles);
+        if (!targetFiles.length) {
+            return {
+                query: input.query,
+                data: { writeMode: mode, writtenFiles: [], errors: ["No targetFile(s) specified in current step"] },
+            };
+        }
+        // Filter codeTransformArtifacts to only the target file(s)
+        const allFiles = context.execution?.codeTransformArtifacts?.files ?? [];
+        const filesToWrite = allFiles.filter(f => targetFiles.includes(f.filePath));
+        if (!filesToWrite.length) {
+            return {
+                query: input.query,
+                data: { writeMode: mode, writtenFiles: [], errors: ["No transformed files found for targetFile(s)"] },
+            };
+        }
+        const writtenFiles = [];
+        const errors = [];
+        for (const f of filesToWrite) {
+            const filePath = normalizePath(f.filePath);
+            if (!filePath) {
+                errors.push(`Invalid filePath: ${f.filePath}`);
+                continue;
+            }
+            if (typeof f.content !== "string" || !f.content.trim()) {
+                errors.push(`No content to write for ${filePath}`);
+                continue;
+            }
+            try {
+                await fs.writeFile(filePath, f.content, "utf-8");
+                console.log(chalk.green(`✅ Written: ${filePath}`));
+                writtenFiles.push(filePath);
+            }
+            catch (err) {
+                console.error(chalk.red(`❌ Failed writing ${filePath}:`), err);
+                errors.push(`${filePath}: ${err.message}`);
+            }
+        }
+        // Mark only the files we just wrote as touched
+        context.plan ?? (context.plan = {});
+        (_a = context.plan).touchedFiles ?? (_a.touchedFiles = []);
+        for (const file of writtenFiles) {
+            if (!context.plan.touchedFiles.includes(file)) {
+                context.plan.touchedFiles.push(file);
+            }
+        }
+        const output = {
+            query: input.query,
+            data: { writeMode: mode, writtenFiles, errors },
+        };
+        logInputOutput("writeFile", "output", output.data);
+        return output;
+    },
+};

package/dist/pipeline/registry/moduleRegistry.js

@@ -1,110 +1,55 @@
-import { addCommentsModule } from '../modules/commentModule.js';
-import { cleanupModule } from '../modules/cleanupModule.js';
-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';
-import { runTestsModule } from '../modules/runTestsModule.js';
-import { repairTestsModule } from '../modules/repairTestsModule.js';
-// Built-in modules with metadata
+import { contextReviewModule } from "../modules/contextReviewModule.js";
+import { finalAnswerModule } from "../modules/finalAnswerModule.js";
+import { writeFileModule } from "../modules/writeFileModule.js";
+import { fileSearchModule } from "../modules/fileSearchModule.js";
+import { cleanupModule } from "../modules/cleanupModule.js";
+import { summaryModule } from "../modules/summaryModule.js";
+import { addCommentsModule } from "../modules/commentModule.js";
+import { codeTransformModule } from "../modules/codeTransformModule.js";
+/**
+ * Active built-in modules — all use ModuleIO for input/output.
+ */
 export const builtInModules = {
-    comments: {
-        ...addCommentsModule,
-        group: 'documentation',
-        dependencies: {
-            after: ['cleanComments'], // run cleanComments after comments
-        },
-    },
-    cleanComments: {
-        ...preserveCodeModule,
-        group: 'documentation',
-    },
-    cleanup: {
-        ...cleanupModule,
-        group: 'maintenance',
-    },
-    summary: {
-        ...summaryModule,
-        group: 'documentation',
-    },
-    tests: {
-        ...generateTestsModule,
-        group: 'testing',
-        dependencies: {
-            after: ['cleanTests'], // run cleanTests after tests
-        },
-    },
-    cleanTests: {
-        ...cleanGeneratedTestsModule,
-        group: 'testing',
-    },
-    runTests: {
-        ...runTestsModule,
-        group: 'testing',
-        dependencies: {
-            before: ['tests'], // must exist after tests are generated
-            after: ['cleanTests'], // run after cleaning
-        },
-    },
-    repairTests: {
-        ...repairTestsModule,
-        group: 'testing',
-        dependencies: {
-            after: ['runTests'], // repair runs after tests have been executed
-        },
-    },
-    suggest: {
-        ...commitSuggesterModule,
-        group: 'git',
-    },
-    changelog: {
-        ...changelogModule,
-        group: 'git',
-    },
+    fileSearch: fileSearchModule,
+    summary: summaryModule,
+    contextReview: contextReviewModule,
+    // analysis (as agent options?)
+    codeTransform: codeTransformModule,
+    cleanup: cleanupModule,
+    comments: addCommentsModule,
+    writeFile: writeFileModule,
+    finalAnswer: finalAnswerModule,
 };
-// Get module by name
+/**
+ * Get module by name.
+ */
 export function getModuleByName(name) {
     return builtInModules[name];
 }
-// Return module metadata for CLI or UI
+/**
+ * List available modules for CLI or UI display.
+ */
 export function listAvailableModules() {
-    return Object.values(builtInModules).map(({ name, description, group, dependencies }) => ({
+    return Object.entries(builtInModules).map(([name, mod]) => ({
         name,
-        description: description || 'No description available',
-        group,
-        dependencies,
+        description: mod.description ?? "No description available",
     }));
 }
 /**
- * Resolve module execution order including before/after dependencies.
- * Returns a unique ordered array of PromptModuleMeta.
+ * Resolve modules from a list of names.
+ * Returns a unique ordered array of modules.
  */
-export function resolveModuleOrder(moduleNames) {
+export function resolveModulesByNames(names) {
+    const seen = new Set();
     const resolved = [];
-    const visited = new Set();
-    function visit(name) {
-        if (visited.has(name))
-            return;
+    for (const name of names) {
+        if (seen.has(name))
+            continue;
         const mod = getModuleByName(name);
-        if (!mod)
-            return;
-        // Handle before dependencies first
-        if (mod.dependencies?.before) {
-            for (const dep of mod.dependencies.before)
-                visit(dep);
-        }
-        // Add the module itself
-        resolved.push(mod);
-        visited.add(name);
-        // Handle after dependencies
-        if (mod.dependencies?.after) {
-            for (const dep of mod.dependencies.after)
-                visit(dep);
+        if (mod) {
+            resolved.push(mod);
+            seen.add(name);
         }
     }
-    for (const name of moduleNames)
-        visit(name);
     return resolved;
 }

package/dist/pipeline/runModulePipeline.js

@@ -1,27 +1,30 @@
-import chalk from 'chalk';
-export async function runModulePipeline(modules, input) {
-    let current = input;
-    const isDebug = false;
+export async function runModulePipeline(modules, initialInput) {
+    const logPrefix = `[runModulePipeline]`;
+    console.log(`${logPrefix} 🚀 Starting pipeline with ${modules.length} module(s)`);
+    // Copy initial input
+    let currentIO = { ...initialInput };
     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));
+            const output = await mod.run(currentIO);
+            // Validate shape
+            if (!output) {
+                throw new Error(`Module '${mod.name}' returned empty output`);
             }
-            // Safeguard to preserve filepath + originalContent
-            current = {
-                ...response,
-                originalContent: current.originalContent,
-                filepath: current.filepath,
+            // --- FIX: Pipeline semantics ---
+            // Next module receives:
+            // - same query
+            // - content = previous module's data
+            // - (data is the last produced data only, never merged)
+            currentIO = {
+                query: currentIO.query,
+                content: output.data, // data -> content handoff
+                data: '',
             };
+            console.log(`${logPrefix} 🔁 '${mod.name}' → content replaced with data`);
         }
-        catch (error) {
-            console.error(`❌ Error in ${mod.name}:`, error instanceof Error ? error.message : error);
-            throw new Error(`Pipeline failed at module ${mod.name}`);
+        catch (err) {
+            console.error(`${logPrefix} ❌ Module '${mod.name}' failed:`, err instanceof Error ? err.message : err);
         }
     }
-    return current;
+    return currentIO;
 }