scai 0.1.178 → 1.0.0

package/dist/agents/contextReviewStep.js

@@ -1,101 +0,0 @@
-// File: src/modules/contextReviewStep.ts
-import { generate } from "../lib/generate.js";
-import { logInputOutput } from "../utils/promptLogHelper.js";
-export async function contextReviewStep(context) {
-    const analysis = context.analysis;
-    if (!analysis) {
-        throw new Error("[contextReviewStep] No analysis state available.");
-    }
-    const intent = analysis.intent ?? {
-        intent: "",
-        intentCategory: "",
-        normalizedQuery: "",
-        confidence: 0,
-    };
-    const focus = analysis.focus ?? {
-        selectedFiles: [],
-        candidateFiles: [],
-        rationale: "",
-    };
-    const fileAnalysis = analysis.fileAnalysis ?? {};
-    const planDecision = analysis.planSuggestion?.plan
-        ? "planExists"
-        : "needsPlan";
-    // ------------------------------
-    // Compress file-level analysis to high-signal summaries
-    // ------------------------------
-    const summarizedFiles = Object.entries(fileAnalysis)
-        .filter(([, fa]) => fa.intent === "relevant")
-        .map(([filePath, fa]) => ({
-        file: filePath,
-        role: fa.role ?? "unspecified",
-        relevance: fa.relevanceExplanation,
-        proposedChangeScope: fa.proposedChanges?.scope ?? "none",
-        excerptCount: fa.excerpts?.length ?? 0,
-        excerptTopics: fa.excerpts?.map(e => e.description).slice(0, 3),
-    }));
-    // ------------------------------
-    // Build prompt using distilled conclusions only
-    // ------------------------------
-    const prompt = `
-You are a meta-reasoning agent.
-
-Your job is to determine whether enough relevant information
-has been collected to directly answer the user's intent,
-or whether more data must be gathered first.
-
-Decision meanings:
-- "executeOnQuery": The collected analysis and files are sufficient to answer the user's question.
-- "gatherData": The current analysis is insufficient; more files or analysis are required.
-
-User Intent:
-${JSON.stringify(intent, null, 2)}
-
-Plan Suggestion Status: ${planDecision}
-
-Relevant Files (paths only):
-${JSON.stringify(focus.selectedFiles, null, 2)}
-
-Missing Files:
-${JSON.stringify(focus.candidateFiles, null, 2)}
-
-Why these files were selected:
-${focus.rationale ?? "No rationale provided."}
-
-Relevant File Summaries (high-signal only):
-${JSON.stringify(summarizedFiles, null, 2)}
-
-
-Question:
-Based on the above, is there enough information to answer the user's question directly?
-
-Output STRICT JSON with shape:
-
-{
-  "decision": "gatherData" | "executeOnQuery",
-  "reason": "concise explanation",
-  "missing": string[]
-}
-`.trim();
-    const ai = await generate({
-        query: context.initContext?.userQuery ?? "",
-        content: prompt,
-    });
-    const text = typeof ai.data === "string" ? ai.data : JSON.stringify(ai.data);
-    logInputOutput("contextReviewStep", "output", text);
-    // ------------------------------
-    // Parse JSON or fallback
-    // ------------------------------
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return {
-            decision: text.toLowerCase().includes("gather")
-                ? "gatherData"
-                : "executeOnQuery",
-            reason: text,
-            missing: [],
-        };
-    }
-}

package/dist/agents/finalPlanGenStep.js

@@ -1,107 +0,0 @@
-// File: src/agents/finalPlanGenStep.ts
-import { generate } from '../lib/generate.js';
-import { PLAN_ACTIONS } from '../utils/planActions.js';
-import { logInputOutput } from '../utils/promptLogHelper.js';
-import { cleanupModule } from '../pipeline/modules/cleanupModule.js';
-/**
- * FINAL PLAN GENERATOR
- * Generates a single finalization step to wrap up and produce user-facing results.
- */
-export const finalPlanGenStep = {
-    name: 'finalPlanGen',
-    description: 'Generates a single finalization step for the workflow.',
-    requires: ['analysis.intent', 'analysis.focus'],
-    produces: ['analysis.planSuggestion'],
-    async run(context) {
-        context.analysis || (context.analysis = {});
-        // Clear previous final plan
-        delete context.analysis.planSuggestion;
-        // Restrict actions to FINALIZE only
-        const effectiveActions = PLAN_ACTIONS.filter(a => a.groups?.includes('finalize'));
-        if (!effectiveActions.length) {
-            context.analysis.planSuggestion = { plan: { steps: [] } };
-            logInputOutput('finalPlanGen', 'output', { steps: [] });
-            return;
-        }
-        const actionsJson = JSON.stringify(effectiveActions, null, 2);
-        const intentText = context.analysis.intent?.normalizedQuery ?? '';
-        const intentCategory = context.analysis.intent?.intentCategory ?? '';
-        const prompt = `
-You are an autonomous coding agent.
-
-Produce exactly one structured step to finalize the workflow and generate the user-facing output.
-
-Intent / task description:
-${intentText}
-
-Task category:
-${intentCategory}
-
-Allowed actions (finalize only):
-${actionsJson}
-
-Rules:
-- Only produce a single finalize step.
-- Step must include: "action", "targetFile" (optional), "description", "metadata".
-- Do NOT invent new actions.
-- Always ensure a user-facing result is produced.
-
-Return strictly valid JSON representing one step:
-
-{
-  "action": "stepName",
-  "targetFile": "optional/path.ts",
-  "description": "Generate final user-facing output summarizing results.",
-  "metadata": {}
-}
-        `.trim();
-        try {
-            const genInput = { query: intentText, content: prompt };
-            const genOutput = await generate(genInput);
-            const raw = typeof genOutput.data === 'string' ? genOutput.data : JSON.stringify(genOutput.data ?? '{}');
-            const cleaned = await cleanupModule.run({ query: intentText, content: raw });
-            const jsonString = typeof cleaned.content === 'string' ? cleaned.content : JSON.stringify(cleaned.content ?? '{}');
-            let step = JSON.parse(jsonString);
-            // Validate structure
-            if (!step || typeof step.action !== 'string') {
-                step = {
-                    id: 'finalize',
-                    action: 'finalAnswer',
-                    description: 'Generate final user-facing response summarizing results.',
-                    metadata: {}
-                };
-            }
-            // Map groups & metadata
-            const actionDef = PLAN_ACTIONS.find(a => a.action === step.action);
-            step.groups = actionDef?.groups ?? ['finalize'];
-            const confidence = context.analysis?.routingDecision?.confidence;
-            step.metadata = {
-                ...step.metadata,
-                ...(typeof confidence === 'number' && confidence > 0
-                    ? { routingConfidence: confidence }
-                    : {})
-            };
-            // Save single step to context
-            context.analysis.planSuggestion = { plan: { steps: [step] } };
-            logInputOutput('finalPlanGen', 'output', step);
-        }
-        catch (err) {
-            console.warn('⚠️ Failed to generate final step:', err);
-            // Fallback: always include finalAnswer
-            const confidence = context.analysis?.routingDecision?.confidence;
-            const step = {
-                id: 'finalize',
-                action: 'finalAnswer',
-                description: 'Generate final user-facing response summarizing results.',
-                metadata: {
-                    ...(typeof confidence === 'number' && confidence > 0
-                        ? { routingConfidence: confidence }
-                        : {})
-                },
-                groups: ['finalize']
-            };
-            context.analysis.planSuggestion = { plan: { steps: [step] } };
-            logInputOutput('finalPlanGen', 'output', step);
-        }
-    }
-};

package/dist/agents/structuralAnalysisStep.js

@@ -1,46 +0,0 @@
-import { logInputOutput } from "../utils/promptLogHelper.js";
-export const structuralAnalysisStep = {
-    name: "structuralAnalysis",
-    description: "Derive structural characteristics from workingFiles using existing metadata only. " +
-        "Produces a durable, machine-usable summary of file shape and relationships.",
-    groups: ["analysis"],
-    run: async (input) => {
-        const ctx = input.context;
-        if (!ctx) {
-            throw new Error("[structuralAnalysis] StructuredContext is required but was not provided.");
-        }
-        const workingFiles = ctx.workingFiles;
-        if (!Array.isArray(workingFiles) || workingFiles.length === 0) {
-            const output = {
-                query: input.query,
-                data: {
-                    notes: "No workingFiles present; structural analysis skipped."
-                }
-            };
-            logInputOutput("structuralAnalysis", "output", output.data);
-            return output;
-        }
-        const files = workingFiles.map((file) => ({
-            path: file.path,
-            imports: file.imports ?? [],
-            exports: file.exports ?? [],
-            functions: file.functions?.length ?? 0,
-            classes: file.classes?.length ?? 0,
-        }));
-        // 🧠 Persist durable structural understanding
-        ctx.analysis ?? (ctx.analysis = {});
-        ctx.analysis.structure = {
-            files,
-        };
-        const output = {
-            query: input.query,
-            data: {
-                fileCount: files.length,
-                files,
-                notes: "Structural characteristics derived from loaded workingFiles.",
-            }
-        };
-        logInputOutput("structuralAnalysis", "output", output.data);
-        return output;
-    }
-};

package/dist/agents/validationAnalysisStep.js

@@ -1,87 +0,0 @@
-import { logInputOutput } from "../utils/promptLogHelper.js";
-export const validationAnalysisStep = {
-    name: "validationAnalysis",
-    description: "Validate semantic analysis results and verify that focused working files were correctly synced into plan.targetFiles.",
-    groups: ["analysis"],
-    run: async (input) => {
-        const ctx = input.context;
-        if (!ctx) {
-            throw new Error("[validationAnalysisStep] StructuredContext is required but was not provided.");
-        }
-        const notes = [];
-        const warnings = [];
-        // -----------------------------
-        // Focus validation
-        // -----------------------------
-        const focusFiles = ctx.analysis?.focus?.selectedFiles ?? [];
-        if (!focusFiles.length) {
-            warnings.push("No relevant files found in analysis.focus.");
-        }
-        // -----------------------------
-        // Semantic understanding validation
-        // -----------------------------
-        const understanding = ctx.analysis?.understanding;
-        if (!understanding) {
-            notes.push("No semantic understanding produced by analysis.");
-        }
-        else {
-            if (!understanding.risks?.length) {
-                notes.push("No risks recorded in analysis.understanding.");
-            }
-            if (!understanding.assumptions?.length) {
-                notes.push("No assumptions recorded in analysis.understanding.");
-            }
-        }
-        // -----------------------------
-        // Intent presence & shape validation
-        // (Produced by understandIntent step)
-        // -----------------------------
-        const intent = ctx.analysis?.intent;
-        if (!intent) {
-            warnings.push("No intent found in context (expected from understandIntent step).");
-        }
-        else {
-            if (!intent.intent || !intent.intentCategory) {
-                warnings.push("Intent is missing required fields (intent/intentCategory).");
-            }
-            if (typeof intent.confidence !== "number") {
-                warnings.push("Intent confidence not set or invalid.");
-            }
-        }
-        // -----------------------------
-        // Plan.targetFiles consistency validation
-        // -----------------------------
-        const plan = ctx.plan;
-        const workingFiles = new Set(ctx.workingFiles?.map(f => f.path) ?? []);
-        const targetFiles = new Set(plan?.targetFiles ?? []);
-        if (!plan) {
-            warnings.push("No plan found in context; target files were not validated.");
-        }
-        else {
-            // Only focused files that are also working files are expected to be in the plan
-            const expectedTargetFiles = focusFiles.filter(f => workingFiles.has(f));
-            const missing = expectedTargetFiles.filter(f => !targetFiles.has(f));
-            if (missing.length > 0) {
-                warnings.push(`Some focused working files were not added to plan.targetFiles: ${missing.join(", ")}`);
-            }
-        }
-        const output = {
-            query: input.query,
-            data: {
-                notes,
-                warnings,
-                summary: {
-                    focusValid: focusFiles.length > 0,
-                    semanticValid: !!understanding,
-                    intentValid: !!intent,
-                    planFilesValid: !!plan &&
-                        focusFiles
-                            .filter(f => workingFiles.has(f))
-                            .every(f => targetFiles.has(f)),
-                },
-            },
-        };
-        logInputOutput("validationAnalysis", "output", output.data);
-        return output;
-    },
-};

package/dist/pipeline/modules/chunkManagerModule.js

@@ -1,24 +0,0 @@
-// 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/cleanGeneratedTestsModule.js

@@ -1,33 +0,0 @@
-import { normalizeText, stripMarkdownFences, isCodeLike } from "../../utils/contentUtils.js";
-export const cleanGeneratedTestsModule = {
-    name: "cleanGeneratedTestsModule",
-    description: "Removes markdown fences, prose, and explanations from generated test output, leaving only code",
-    async run(input) {
-        const { content, filepath } = input;
-        // normalize + strip markdown
-        const normalized = normalizeText(content);
-        const stripped = stripMarkdownFences(normalized);
-        // filter non-code lines, but keep blank ones
-        const lines = stripped.split("\n");
-        const codeLines = lines.filter(line => line.trim() === "" || isCodeLike(line));
-        // remove duplicate imports (normalize spacing/semicolon)
-        const seenImports = new Set();
-        const dedupedLines = codeLines.filter(line => {
-            if (line.trim().startsWith("import")) {
-                const key = line.trim().replace(/;$/, "");
-                if (seenImports.has(key)) {
-                    return false;
-                }
-                seenImports.add(key);
-            }
-            return true;
-        });
-        const cleanedCode = dedupedLines.join("\n").trimEnd();
-        return {
-            originalContent: content,
-            content: cleanedCode,
-            filepath,
-            mode: "overwrite",
-        };
-    }
-};

package/dist/pipeline/modules/fileReaderModule.js

@@ -1,72 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { logInputOutput } from "../../utils/promptLogHelper.js";
-import { getDbForRepo } from "../../db/client.js";
-import { updateFileWithSummary, upsertFileFtsTemplate, } from "../../db/sqlTemplates.js";
-export const fileReaderModule = {
-    name: "fileReader",
-    description: "Reads files from disk only if they are not available in the DB, updates DB and FTS.",
-    groups: ["analysis"],
-    run: async (input) => {
-        let filePaths = [];
-        logInputOutput('filereader', 'input', input.content);
-        if (Array.isArray(input.content)) {
-            filePaths = input.content;
-        }
-        else if (typeof input.content === "object" && input.content !== null) {
-            const obj = input.content;
-            if (Array.isArray(obj.filePaths))
-                filePaths = obj.filePaths;
-        }
-        if (filePaths.length === 0) {
-            const emptyOutput = {
-                query: input.query,
-                data: { files: [] },
-            };
-            logInputOutput("fileReader", "output", emptyOutput.data);
-            return emptyOutput;
-        }
-        const db = getDbForRepo();
-        const files = [];
-        for (const filePath of filePaths) {
-            const fullPath = path.resolve(filePath);
-            // 1️⃣ Check DB for existing summary/content
-            const row = db
-                .prepare("SELECT path, content_text, summary FROM files WHERE path = ?")
-                .get(fullPath);
-            if (row?.content_text) {
-                files.push({ filePath: fullPath, content: row.content_text });
-                continue; // already in DB, no need to read disk
-            }
-            // 2️⃣ Read file from disk
-            let content = "";
-            try {
-                content = await fs.readFile(fullPath, "utf-8");
-            }
-            catch (err) {
-                content = `ERROR: ${err.message}`;
-            }
-            files.push({ filePath: fullPath, content });
-            // 3️⃣ Update DB and FTS if content successfully read
-            if (!content.startsWith("ERROR")) {
-                db.prepare(updateFileWithSummary).run({
-                    path: fullPath,
-                    summary: null, // optionally leave null; summary can be generated later
-                    contentText: content,
-                });
-                db.prepare(upsertFileFtsTemplate).run({
-                    path: fullPath,
-                    filename: path.basename(fullPath),
-                    summary: null,
-                    contentText: content,
-                });
-            }
-        }
-        const output = {
-            query: input.query,
-            data: { files },
-        };
-        logInputOutput("fileReader", "output", output.data);
-        return output;
-    },
-};

package/dist/pipeline/modules/gatherInfoModule.js

@@ -1,181 +0,0 @@
-// src/pipeline/modules/gatherInfoModule.ts
-import { getDbForRepo } from "../../db/client.js";
-import chalk from "chalk";
-import { compileSearchQuery } from "../../utils/compileSearchQuery.js";
-import { logInputOutput } from "../../utils/promptLogHelper.js"; // ✅ import logger
-/** Escape % and _ for LIKE queries */
-function sanitizeForLike(input) {
-    return input.replace(/[%_]/g, "\\$&");
-}
-/** ✅ Strip embeddings before logging */
-function stripEmbeddings(output) {
-    if (output?.data?.files) {
-        output.data.files = output.data.files.map((f) => {
-            const { embedding, ...rest } = f;
-            return rest;
-        });
-    }
-    return output;
-}
-export const gatherInfoModule = {
-    name: "gatherInfo",
-    description: "Collects relevant code summaries, functions, classes, and related graph info for the current query.",
-    run: async function (input) {
-        const db = getDbForRepo();
-        const query = input.metadata?.query?.trim() ?? "";
-        const maxFiles = input.metadata?.maxFiles ?? 10;
-        if (!query) {
-            const emptyOutput = {
-                content: "⚠️ No query provided to gatherInfoModule.",
-                data: { files: [], functions: [], classes: [], summaries: [], tags: [] },
-            };
-            logInputOutput("gatherInfo", "output", stripEmbeddings(emptyOutput)); // ✅
-            return emptyOutput;
-        }
-        const compiled = compileSearchQuery({ query, mode: "fts" });
-        const sanitizedFts = compiled.fts.expression;
-        const likeQuery = `%${sanitizeForLike(query)}%`;
-        // 🩹 Handle legacy DBs that might not have `functions_extracted`
-        let files = [];
-        try {
-            if (sanitizedFts) {
-                files = db
-                    .prepare(`
-          SELECT f.id, f.path, f.type, f.summary, f.embedding,
-                 f.last_modified, f.indexed_at,
-                 COALESCE(f.functions_extracted, 0) AS functions_extracted,
-                 f.functions_extracted_at, f.processing_status
-          FROM files f
-          JOIN files_fts fts ON fts.rowid = f.id
-          WHERE files_fts MATCH '${sanitizedFts}'
-          ORDER BY f.path ASC
-          LIMIT ?;
-        `)
-                    .all(maxFiles);
-            }
-        }
-        catch (err) {
-            console.warn(chalk.yellow("⚠️ 'functions_extracted' column missing in files table, running fallback query..."));
-            if (sanitizedFts) {
-                files = db
-                    .prepare(`
-          SELECT f.id, f.path, f.type, f.summary, f.embedding,
-                 f.last_modified, f.indexed_at, f.processing_status
-          FROM files f
-          JOIN files_fts fts ON fts.rowid = f.id
-          WHERE files_fts MATCH '${sanitizedFts}'
-          ORDER BY f.path ASC
-          LIMIT ?;
-        `)
-                    .all(maxFiles);
-            }
-        }
-        const functions = db
-            .prepare(`
-        SELECT fn.id, fn.name, fn.start_line, fn.end_line,
-               substr(fn.content, 1, 400) AS content,
-               f.path AS file_path
-        FROM functions fn
-        JOIN files f ON f.id = fn.file_id
-        WHERE fn.name LIKE ? ESCAPE '\\'
-           OR fn.content LIKE ? ESCAPE '\\'
-        ORDER BY f.path ASC
-        LIMIT ?;
-      `)
-            .all(likeQuery, likeQuery, maxFiles);
-        const classes = db
-            .prepare(`
-        SELECT c.name, f.path AS file_path, substr(c.content, 1, 400) AS snippet
-        FROM graph_classes c
-        JOIN files f ON f.id = c.file_id
-        WHERE c.name LIKE ? ESCAPE '\\'
-           OR c.content LIKE ? ESCAPE '\\'
-        ORDER BY f.path ASC
-        LIMIT ?;
-      `)
-            .all(likeQuery, likeQuery, maxFiles);
-        const tagRows = db
-            .prepare(`
-        SELECT DISTINCT gtm.name
-        FROM graph_tags_master gtm
-        WHERE gtm.name LIKE ? ESCAPE '\\'
-        ORDER BY gtm.name ASC;
-      `)
-            .all(likeQuery);
-        const tags = tagRows.map((t) => t.name);
-        const summaries = db
-            .prepare(`
-        SELECT path, type, summary
-        FROM summaries
-        WHERE summary LIKE ? ESCAPE '\\'
-        ORDER BY CASE WHEN type='project' THEN 0 ELSE 1 END, path ASC
-        LIMIT 5;
-      `)
-            .all(likeQuery);
-        // --- Gather common project config files
-        let configFiles = [];
-        try {
-            configFiles = db
-                .prepare(`
-          SELECT f.id, f.path, f.type, f.summary, f.embedding,
-                 f.last_modified, f.indexed_at,
-                 COALESCE(f.functions_extracted, 0) AS functions_extracted,
-                 f.functions_extracted_at, f.processing_status
-          FROM files f
-          WHERE path LIKE '%package.json%'
-             OR path LIKE '%tsconfig.json%'
-             OR path LIKE '%.eslintrc%'
-             OR path LIKE '%.env%'
-             OR path LIKE '%README.md%'
-          ORDER BY path ASC;
-        `)
-                .all();
-        }
-        catch (err) {
-            configFiles = db
-                .prepare(`
-          SELECT f.id, f.path, f.type, f.summary, f.embedding,
-                 f.last_modified, f.indexed_at, f.processing_status
-          FROM files f
-          WHERE path LIKE '%package.json%'
-             OR path LIKE '%tsconfig.json%'
-             OR path LIKE '%.eslintrc%'
-             OR path LIKE '%.env%'
-             OR path LIKE '%README.md%'
-          ORDER BY path ASC;
-        `)
-                .all();
-        }
-        // Merge & deduplicate
-        const uniqueFiles = [
-            ...files,
-            ...configFiles.filter((c) => !files.find((f) => f.path === c.path)),
-        ];
-        if (!uniqueFiles.length &&
-            !functions.length &&
-            !classes.length &&
-            !summaries.length &&
-            !tags.length) {
-            const emptyOutput = {
-                content: `⚠️ No relevant information found for query: "${query}"`,
-                data: { files: [], functions: [], classes: [], summaries: [], tags: [] },
-            };
-            logInputOutput("gatherInfo", "output", stripEmbeddings(emptyOutput)); // ✅
-            return emptyOutput;
-        }
-        const output = {
-            content: `Gathered ${uniqueFiles.length} files, ${functions.length} functions, ${classes.length} classes, and ${summaries.length} summaries.`,
-            data: {
-                query, // ✅ ensure query passes forward
-                files: uniqueFiles,
-                functions,
-                classes,
-                summaries,
-                tags,
-            },
-        };
-        // ✅ Log sanitized module output (no embeddings)
-        logInputOutput("gatherInfo", "output", stripEmbeddings(output));
-        return output;
-    },
-};