scai 0.1.116 → 0.1.118

package/dist/pipeline/modules/generateTestsModule.js

@@ -1,59 +1,68 @@
-import path from 'path';
+"use strict";
+/* import path from 'path';
+import { PromptModule } from '../../types.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 }) {
-        if (!filepath)
-            throw new Error('Missing filepath in pipeline context');
-        const model = Config.getModel();
-        const lang = detectFileType(filepath);
-        const repoRoot = Config.getIndexDir();
-        // Compute relative import path (repo-relative, without extension)
-        const relativePath = path.relative(repoRoot, filepath);
-        const { dir, name, ext } = path.parse(relativePath);
-        const importPath = './' + path.join(dir, name).replace(/\\/g, '/');
-        // Where the test should be written (next to source file)
-        const absParsed = path.parse(filepath);
-        const testPath = path.join(absParsed.dir, `${absParsed.name}.test${ext}`);
-        const prompt = `
-You are a senior ${lang.toUpperCase()} engineer. Generate a Jest test file for the module below.
-
-Requirements:
-- Use the 'jest' test framework.
-- Always include imports at the top:
-  import { describe, it, expect } from '@jest/globals';
-  import * as moduleUnderTest from '${importPath}';
-- Cover only one public method: the most relevant or central function.
-- Include one edge case for that method.
-- Preserve and consider existing code comments in the module.
-- Only output valid ${lang} code; do not include markdown fences or explanations.
-- Use this scaffold at minimum:
-
-import { describe, it, expect } from '@jest/globals';
-import * as moduleUnderTest from '${importPath}';
-
-describe('moduleUnderTest', () => {
-  it('should ...', () => {
-    // test implementation
-  });
-});
-
---- MODULE CODE ---
-${content}
---- END MODULE CODE ---
+
+export const generateTestsModule: PromptModule = {
+  name: 'tests',
+  description: 'Generate a Jest test file for the class/module',
+
+  async run({ content, filepath }) {
+    if (!filepath) throw new Error('Missing filepath in pipeline context');
+
+    const model = Config.getModel();
+    const lang = detectFileType(filepath);
+    const repoRoot = Config.getIndexDir();
+
+    // Compute relative import path (repo-relative, without extension)
+    const relativePath = path.relative(repoRoot, filepath);
+    const { dir, name, ext } = path.parse(relativePath);
+    const importPath = './' + path.join(dir, name).replace(/\\/g, '/');
+
+    // Where the test should be written (next to source file)
+    const absParsed = path.parse(filepath);
+    const testPath = path.join(absParsed.dir, `${absParsed.name}.test${ext}`);
+
+    const prompt = `
+You are a senior ${lang.toUpperCase()} engineer. Generate a Jest test file for the module below.
+
+Requirements:
+- Use the 'jest' test framework.
+- Always include imports at the top:
+  import { describe, it, expect } from '@jest/globals';
+  import * as moduleUnderTest from '${importPath}';
+- Cover only one public method: the most relevant or central function.
+- Include one edge case for that method.
+- Preserve and consider existing code comments in the module.
+- Only output valid ${lang} code; do not include markdown fences or explanations.
+- Use this scaffold at minimum:
+
+import { describe, it, expect } from '@jest/globals';
+import * as moduleUnderTest from '${importPath}';
+
+describe('moduleUnderTest', () => {
+  it('should ...', () => {
+    // test implementation
+  });
+});
+
+--- MODULE CODE ---
+${content}
+--- END MODULE CODE ---
 `.trim();
-        const response = await generate({ content: prompt });
-        if (!response)
-            throw new Error('⚠️ No test code returned from model');
-        return {
-            originalContent: content,
-            content: response.content, // the test code
-            filepath, // original file path
-            newFilepath: testPath,
-            mode: "newFile" // ensure it gets written as a new file
-        };
-    }
+
+    const response = await generate({ content: prompt });
+    if (!response) throw new Error('⚠️ No test code returned from model');
+
+    return {
+      originalContent: content,
+      content: response.content,   // the test code
+      filepath,                    // original file path
+      newFilepath: testPath,
+      mode: "newFile"              // ensure it gets written as a new file
+    };
+  }
 };
+ */ 

package/dist/pipeline/modules/kgModule.js

@@ -1,7 +1,9 @@
 import { Config } from '../../config.js';
 import { generate } from '../../lib/generate.js';
 import path from 'path';
+import chalk from 'chalk';
 import { cleanupModule } from './cleanupModule.js';
+import { normalizeData } from '../../utils/normalizeData.js';
 export const kgModule = {
     name: 'knowledge-graph',
     description: 'Generates a knowledge graph of entities, tags, and relationships from file content.',
@@ -9,6 +11,7 @@ export const kgModule = {
         const model = Config.getModel();
         const ext = input.filepath ? path.extname(input.filepath).toLowerCase() : '';
         const filename = input.filepath ? path.basename(input.filepath) : '';
+        // Build prompt for LLM
         const prompt = `
 You are an assistant specialized in building knowledge graphs from code or text.
 
@@ -21,7 +24,7 @@ Extension: ${ext}
 - Identify all entities (functions, classes, modules, or main concepts)
 - For each entity, generate tags describing its characteristics, purpose, or category
 - Identify relationships between entities (e.g., "uses", "extends", "calls")
-- Return output in JSON format with the following structure:
+- Return output in **valid JSON** format with this structure:
 
 {
   "entities": [
@@ -32,24 +35,36 @@ Extension: ${ext}
   ]
 }
 
-Do NOT include raw content from the file. Only provide the structured JSON output.
+⚠️ Make sure all strings are safely JSON-encoded: escape quotes, backslashes, and newlines.
+
+Do NOT include raw content from the file. Only provide structured JSON output.
 
 --- FILE CONTENT START ---
 ${content}
 --- FILE CONTENT END ---
     `.trim();
-        const response = await generate({ content: prompt, filepath: input.filepath });
         try {
-            // Clean the model output first
-            const cleaned = await cleanupModule.run({ content: response.content });
-            console.log("Cleaned knowledge graph data: ", cleaned);
-            const jsonString = cleaned.content;
-            const parsed = JSON.parse(jsonString);
+            // === INTERACTION #1: generate.ts (via ModuleIO) ===
+            const genInput = {
+                query: 'Extract entities and relationships for knowledge graph',
+                content: prompt,
+            };
+            const genOutput = await generate(genInput);
+            // === INTERACTION #2: cleanupModule (via ModuleIO) ===
+            const cleaned = await cleanupModule.run({
+                query: 'Clean up JSON for knowledge graph',
+                content: genOutput.data,
+            });
+            // === Normalize and parse JSON result ===
+            const parsed = normalizeData(cleaned.data);
+            // Ensure structure validity
+            parsed.entities ?? (parsed.entities = []);
+            parsed.edges ?? (parsed.edges = []);
             return parsed;
         }
         catch (err) {
-            console.warn('⚠️ Failed to parse KG JSON:', err);
-            return { entities: [], edges: [] }; // fallback
+            console.log(chalk.yellow(`⚠️ [KG] Garbage or invalid JSON output for ${input.filepath}`));
+            return { entities: [], edges: [] };
         }
-    }
+    },
 };

package/dist/pipeline/modules/preserveCodeModule.js

@@ -9,63 +9,55 @@ export const preserveCodeModule = {
         if (!originalContent)
             throw new Error("Requires `originalContent`.");
         // 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 language = detectFileType(filepath ?? ext);
         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");
         const newLines = normalize(content).split("\n");
-        // --- Classify line ---
+        // --- Classify line for comment preservation ---
         let inBlockComment = false;
         let blockLines = [];
-        // --- Classify line ---
-        // returns: "code" | comment string | null
         const classifyLine = (line) => {
             const trimmed = line.trimStart();
-            // --- Single-line comment ---
+            // Single-line comments
             for (const s of syntax.singleLine) {
                 if (trimmed.startsWith(s))
                     return 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)) {
+                    if (trimmed.startsWith(start) || trimmed.startsWith("/**")) {
                         blockLines = [line];
                         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
+                            return null;
                         }
                     }
                 }
+                // ✅ New: Handle stray lines that look like part of a comment
+                if (trimmed.startsWith("*")) {
+                    return 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
-                    }
+                if (trimmed.includes("*/")) {
+                    inBlockComment = false;
+                    const fullBlock = blockLines.join("\n");
+                    blockLines = [];
+                    return fullBlock;
                 }
                 return null; // still inside block
             }
-            // --- default: code ---
             return "code";
         };
-        // --- Helper: collect comment blocks into map ---
+        // --- Collect comments into map ---
         function collectCommentsMap(lines) {
             const map = new Map();
             let commentBuffer = [];
@@ -82,13 +74,9 @@ export const preserveCodeModule = {
                     }
                     continue;
                 }
-                if (typeof result === "string") {
-                    // comment line or block
+                if (typeof result === "string")
                     commentBuffer.push(result);
-                }
-                // result === null => inside multi-line block, do nothing
             }
-            // flush at EOF
             if (commentBuffer.length > 0) {
                 const key = "";
                 const block = commentBuffer.join("\n").trim().toLowerCase();
@@ -96,12 +84,20 @@ export const preserveCodeModule = {
                     map.set(key, new Set());
                 map.get(key).add(block);
             }
+            if (blockLines.length > 0) {
+                const key = "";
+                const block = blockLines.join("\n").trim().toLowerCase();
+                if (!map.has(key))
+                    map.set(key, new Set());
+                map.get(key).add(block);
+                blockLines = [];
+            }
             return map;
         }
         // --- Step 1: Collect comments ---
-        const modelComments = collectCommentsMap(newLines); // model first
-        const origComments = collectCommentsMap(origLines); // original
-        // --- Step 2: Remove duplicates from model (since we insert model) ---
+        const modelComments = collectCommentsMap(newLines);
+        const origComments = collectCommentsMap(origLines);
+        // --- Step 2: Remove duplicates ---
         for (const [key, modelSet] of modelComments.entries()) {
             const origSet = origComments.get(key);
             if (!origSet)
@@ -114,40 +110,86 @@ export const preserveCodeModule = {
                 modelComments.delete(key);
         }
         // --- Step 3: Build fixed lines ---
-        const fixedLines = [];
+        let fixedLines = [];
         for (const origLine of origLines) {
             const key = origLine.trim().toLowerCase();
             if (modelComments.has(key)) {
                 for (const block of modelComments.get(key)) {
                     for (const line of block.split("\n")) {
                         const norm = line.trim().toLowerCase();
-                        const already = fixedLines.some(l => l.trim().toLowerCase() === norm);
-                        if (!already) {
+                        if (!fixedLines.some(l => l.trim().toLowerCase() === norm)) {
                             fixedLines.push(line);
-                            console.log(chalk.blue("Inserted comment:"), line.trim());
-                        }
-                        else {
-                            console.log(chalk.gray("Skipped duplicate:"), line.trim());
                         }
                     }
                 }
             }
-            fixedLines.push(origLine); // always keep original
+            fixedLines.push(origLine);
         }
-        // --- Logging ---
-        console.log(chalk.bold.blue("\n=== FIXED CONTENT ==="));
-        fixedLines.forEach((line, i) => {
-            const trimmed = line.trimStart();
-            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}]`)}`);
+        // --- Step 4: Remove opening/closing fences at top/bottom ---
+        while (fixedLines.length && /^```(?:\w+)?$/.test(fixedLines[0].trim())) {
+            fixedLines.shift();
+        }
+        while (fixedLines.length && /^```(?:\w+)?$/.test(fixedLines[fixedLines.length - 1].trim())) {
+            fixedLines.pop();
+        }
+        // --- Step 5: Remove opening/closing fences at top/bottom ---
+        while (fixedLines.length && /^```(?:\w+)?$/.test(fixedLines[0].trim())) {
+            console.log(chalk.red(`[preserveCodeModule] Removing top fence: "${fixedLines[0].trim()}"`));
+            fixedLines.shift();
+        }
+        while (fixedLines.length && /^```(?:\w+)?$/.test(fixedLines[fixedLines.length - 1].trim())) {
+            console.log(chalk.red(`[preserveCodeModule] Removing bottom fence: "${fixedLines[fixedLines.length - 1].trim()}"`));
+            fixedLines.pop();
+        }
+        // --- Step 6: Remove any lingering triple ticks inside content ---
+        fixedLines = fixedLines.filter(line => {
+            if (/^```(?:\w+)?$/.test(line.trim())) {
+                console.log(chalk.red(`[preserveCodeModule] Removing lingering fence: "${line.trim()}"`));
+                return false;
+            }
+            return true;
         });
+        // --- Step 7 (final): Clean stray '*' and '*/' lines ---
+        let insideBlock = false;
+        fixedLines = fixedLines.map(line => {
+            const trimmed = line.trim();
+            // Enter block comment
+            if (trimmed.startsWith("/*") || trimmed.startsWith("/**")) {
+                insideBlock = true;
+                return line;
+            }
+            // Exit block comment
+            if (trimmed.startsWith("*/")) {
+                if (insideBlock) {
+                    insideBlock = false;
+                    return line; // keep valid closer
+                }
+                else {
+                    return ""; // remove stray closer
+                }
+            }
+            // If inside a block, keep '*' lines as-is
+            if (insideBlock && trimmed.startsWith("*")) {
+                return line;
+            }
+            // If not inside a block but line starts with '*'
+            if (!insideBlock && trimmed.startsWith("*")) {
+                const afterStar = trimmed.slice(1).trim();
+                // ✅ If it's a JSDoc tag (starts with @), keep as-is
+                if (afterStar.startsWith("@")) {
+                    return line;
+                }
+                // Otherwise, treat as stray and convert to //
+                const indent = line.slice(0, line.indexOf("*"));
+                return indent + "//" + line.slice(line.indexOf("*") + 1);
+            }
+            return line;
+        }).filter(line => line !== ""); // remove empty stray lines
+        // --- Return PromptOutput ---
         return {
             content: fixedLines.join("\n"),
             filepath,
-            mode: "overwrite"
+            mode: "overwrite",
         };
     }
 };

package/dist/pipeline/modules/refactorModule.js

@@ -1,11 +1,15 @@
+// File: src/pipeline/modules/refactorModule.ts
 import { Config } from '../../config.js';
 import { generate } from '../../lib/generate.js';
 export const refactorModule = {
     name: 'refactor',
     description: 'Break code into small, clean functions',
-    async run(input) {
-        const model = Config.getModel();
+    run: async (input) => {
         const lang = Config.getLanguage();
+        const code = typeof input.content === 'string' ? input.content : '';
+        if (!code) {
+            throw new Error('⚠️ No code provided for refactoring.');
+        }
         const prompt = `
 You are a senior ${lang.toUpperCase()} engineer.
 
@@ -16,13 +20,21 @@ Refactor the following code:
 - Output the full, valid ${lang.toUpperCase()} code
 
 --- CODE START ---
-${input.content}
+${code}
 --- CODE END ---
     `.trim();
-        const response = await generate({ content: prompt });
-        if (!response) {
+        const response = await generate({
+            query: input.query ?? '',
+            content: prompt,
+        });
+        if (!response || !response.content) {
             throw new Error('❌ Model returned empty response for refactoring.');
         }
-        return { content: response.content };
-    }
+        const output = {
+            query: input.query ?? '',
+            content: response.content,
+            data: { refactoredCode: response.content },
+        };
+        return output;
+    },
 };

package/dist/pipeline/modules/repairTestsModule.js

@@ -1,40 +1,48 @@
+"use strict";
+/* import { PromptModule, PromptInput, PromptOutput } from "../../types.js";
 import { generate } from "../../lib/generate.js";
 import { Config } from "../../config.js";
-export const repairTestsModule = {
-    name: "repairTestsModule",
-    description: "Fix failing Jest tests using AI",
-    async run({ content, filepath, summary }) {
-        const model = Config.getModel();
-        const prompt = `
-You are a senior engineer tasked with repairing Jest tests.
-
-The following test file failed:
-
---- BEGIN TEST FILE ---
-${content}
---- END TEST FILE ---
-
-Failure summary:
-${summary || "No summary provided."}
-
-Instructions:
-- Keep the overall structure, imports, and test cases.
-- Only fix syntax errors, invalid Jest matchers, or broken references.
-- Do NOT remove or replace entire test suites unless strictly necessary.
-- Do NOT generate trivial placeholder tests (like add(2,3) examples).
-- Only return valid Jest code, no explanations, no markdown fences.
-
-Output the repaired test file:
+
+export const repairTestsModule: PromptModule = {
+  name: "repairTestsModule",
+  description: "Fix failing Jest tests using AI",
+
+  async run({ content, filepath, summary }: PromptInput): Promise<PromptOutput> {
+    const model = Config.getModel();
+
+    const prompt = `
+You are a senior engineer tasked with repairing Jest tests.
+
+The following test file failed:
+
+--- BEGIN TEST FILE ---
+${content}
+--- END TEST FILE ---
+
+Failure summary:
+${summary || "No summary provided."}
+
+Instructions:
+- Keep the overall structure, imports, and test cases.
+- Only fix syntax errors, invalid Jest matchers, or broken references.
+- Do NOT remove or replace entire test suites unless strictly necessary.
+- Do NOT generate trivial placeholder tests (like add(2,3) examples).
+- Only return valid Jest code, no explanations, no markdown fences.
+
+Output the repaired test file:
 `.trim();
-        const response = await generate({ content: prompt });
-        if (!response)
-            throw new Error("⚠️ No repaired test code returned from model");
-        return {
-            originalContent: content,
-            content: response.content, // repaired test code
-            filepath, // repair in-place
-            summary: `Repaired tests based on failure: ${summary || "unknown error"}`,
-            mode: "overwrite" // signal to overwrite existing test file
-        };
-    }
+
+
+    const response = await generate({ content: prompt });
+    if (!response) throw new Error("⚠️ No repaired test code returned from model");
+
+    return {
+      originalContent: content,
+      content: response.content, // repaired test code
+      filepath,                  // repair in-place
+      summary: `Repaired tests based on failure: ${summary || "unknown error"}`,
+      mode: "overwrite"          // signal to overwrite existing test file
+    };
+  }
 };
+ */ 

package/dist/pipeline/modules/reviewModule.js

@@ -1,10 +1,14 @@
+// File: src/pipeline/modules/reviewModule.ts
 import { generate } from '../../lib/generate.js';
-import { Config } from '../../config.js';
 export const reviewModule = {
     name: 'review',
-    description: 'Reviews code diff or PR content and provides feedback',
-    async run({ content, filepath }) {
-        const model = Config.getModel();
+    description: 'Reviews code diff or PR content and provides actionable suggestions',
+    run: async (input) => {
+        const query = input.query ?? '';
+        const codeDiff = typeof input.content === 'string' ? input.content : '';
+        if (!codeDiff) {
+            throw new Error('⚠️ No code diff provided for review.');
+        }
         const prompt = `
 Suggest ALWAYS 3 concise suggestions for improvements based on the input code diff.
 
@@ -18,20 +22,26 @@ Format your response exactly as:
 3. <type>: <message>
 
 Changes:
-${content}
-`.trim();
-        const response = await generate({ content: prompt, filepath });
+${codeDiff}
+    `.trim();
+        const response = await generate({
+            query,
+            content: prompt,
+        });
+        // Ensure content is string
+        const responseText = typeof response.content === 'string' ? response.content : JSON.stringify(response.content ?? '', null, 2);
         // Parse response: only keep numbered lines
-        const lines = response.content
+        const lines = responseText
             .split('\n')
             .map(line => line.trim())
             .filter(line => /^\d+\.\s+/.test(line));
         // Remove numbering and any surrounding quotes
         const suggestions = lines.map(line => line.replace(/^\d+\.\s+/, '').replace(/^"(.*)"$/, '$1').trim());
-        return {
-            content: response.content,
-            filepath,
-            suggestions
+        const output = {
+            query,
+            content: responseText, // raw model output
+            data: { suggestions }, // structured suggestions
         };
-    }
+        return output;
+    },
 };