scai 0.1.178 → 1.0.0

package/dist/pipeline/modules/generateTestsModule.js

@@ -1,68 +0,0 @@
-"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: 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
-    };
-  }
-};
- */ 

package/dist/pipeline/modules/preserveCodeModule.js

@@ -1,195 +0,0 @@
-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",
-    async run(input) {
-        const { originalContent, content, filepath } = input;
-        if (!originalContent)
-            throw new Error("Requires `originalContent`.");
-        // Determine language from filepath extension
-        const ext = "." + (filepath?.split(".").pop() || "ts");
-        const language = detectFileType(filepath ?? ext);
-        const syntax = getCommentSyntax(language);
-        // --- 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 for comment preservation ---
-        let inBlockComment = false;
-        let blockLines = [];
-        const classifyLine = (line) => {
-            const trimmed = line.trimStart();
-            // Single-line comments
-            for (const s of syntax.singleLine) {
-                if (trimmed.startsWith(s))
-                    return line;
-            }
-            const multiLineComments = syntax.multiLine ?? [];
-            if (!inBlockComment) {
-                for (const { start, end } of multiLineComments) {
-                    if (trimmed.startsWith(start) || trimmed.startsWith("/**")) {
-                        blockLines = [line];
-                        if (trimmed.includes(end) && trimmed.indexOf(end) > trimmed.indexOf(start)) {
-                            return blockLines.join("\n");
-                        }
-                        else {
-                            inBlockComment = true;
-                            return null;
-                        }
-                    }
-                }
-                // ✅ New: Handle stray lines that look like part of a comment
-                if (trimmed.startsWith("*")) {
-                    return line;
-                }
-            }
-            else {
-                blockLines.push(line);
-                if (trimmed.includes("*/")) {
-                    inBlockComment = false;
-                    const fullBlock = blockLines.join("\n");
-                    blockLines = [];
-                    return fullBlock;
-                }
-                return null; // still inside block
-            }
-            return "code";
-        };
-        // --- Collect comments into map ---
-        function collectCommentsMap(lines) {
-            const map = new Map();
-            let commentBuffer = [];
-            for (const line of lines) {
-                const result = classifyLine(line);
-                if (result === "code") {
-                    if (commentBuffer.length > 0) {
-                        const key = line.trim().toLowerCase();
-                        const block = commentBuffer.join("\n").trim().toLowerCase();
-                        if (!map.has(key))
-                            map.set(key, new Set());
-                        map.get(key).add(block);
-                        commentBuffer = [];
-                    }
-                    continue;
-                }
-                if (typeof result === "string")
-                    commentBuffer.push(result);
-            }
-            if (commentBuffer.length > 0) {
-                const key = "";
-                const block = commentBuffer.join("\n").trim().toLowerCase();
-                if (!map.has(key))
-                    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);
-        const origComments = collectCommentsMap(origLines);
-        // --- Step 2: Remove duplicates ---
-        for (const [key, modelSet] of modelComments.entries()) {
-            const origSet = origComments.get(key);
-            if (!origSet)
-                continue;
-            for (const c of Array.from(modelSet)) {
-                if (origSet.has(c))
-                    modelSet.delete(c);
-            }
-            if (modelSet.size === 0)
-                modelComments.delete(key);
-        }
-        // --- Step 3: Build fixed lines ---
-        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();
-                        if (!fixedLines.some(l => l.trim().toLowerCase() === norm)) {
-                            fixedLines.push(line);
-                        }
-                    }
-                }
-            }
-            fixedLines.push(origLine);
-        }
-        // --- 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",
-        };
-    }
-};

package/dist/pipeline/modules/refactorModule.js

@@ -1,40 +0,0 @@
-// 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',
-    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.
-
-Refactor the following code:
-- Only split up long and complex functions
-- Preserve original names and semantics
-- Do NOT insert comments
-- Output the full, valid ${lang.toUpperCase()} code
-
---- CODE START ---
-${code}
---- CODE END ---
-    `.trim();
-        const response = await generate({
-            query: input.query ?? '',
-            content: prompt,
-        });
-        if (!response || !response.content) {
-            throw new Error('❌ Model returned empty response for refactoring.');
-        }
-        const output = {
-            query: input.query ?? '',
-            content: response.content,
-            data: { refactoredCode: response.content },
-        };
-        return output;
-    },
-};

package/dist/pipeline/modules/repairTestsModule.js

@@ -1,48 +0,0 @@
-"use strict";
-/* import { PromptModule, PromptInput, PromptOutput } from "../../types.js";
-import { generate } from "../../lib/generate.js";
-import { Config } from "../../config.js";
-
-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
-    };
-  }
-};
- */ 

package/dist/pipeline/modules/runTestsModule.js

@@ -1,37 +0,0 @@
-import { execSync } from "child_process";
-import path from "path";
-export const runTestsModule = {
-    name: "runTestsModule",
-    description: "Runs generated Jest tests with safety checks for a single file",
-    async run(input) {
-        const { filepath } = input;
-        if (!filepath) {
-            throw new Error("No filepath provided to runTestsModule.");
-        }
-        const absoluteFilePath = path.resolve(filepath);
-        try {
-            // Step 1: TypeScript syntax check for this file only using tsconfig.test.json
-            // Step 1: TypeScript syntax check for this file only
-            execSync(`npx tsc --noEmit --project tsconfig.test.json`, { stdio: "inherit" });
-            // Step 2: Dry-run Jest for this file only
-            execSync(`npx jest --config ${path.resolve("jest.config.ts")} --dryRun ${absoluteFilePath}`, { stdio: "inherit" });
-            // Step 3: Full Jest run for this file only
-            execSync(`npx jest --config ${path.resolve("jest.config.ts")} ${absoluteFilePath}`, { stdio: "inherit" });
-            return {
-                content: "✅ Tests ran successfully",
-                filepath,
-                mode: "skip",
-                summary: "All tests passed successfully."
-            };
-        }
-        catch (error) {
-            const errorMessage = error?.message || String(error);
-            return {
-                content: `❌ Test run failed:\n${errorMessage}`,
-                filepath,
-                mode: "skip",
-                summary: errorMessage // provides failure context for repair
-            };
-        }
-    }
-};