scai 0.1.117 → 0.1.119

package/dist/agents/transformPlanGenStep.js

@@ -0,0 +1,107 @@
+// File: src/agents/transformPlanGenStep.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';
+const MAX_STEPS = 100;
+/**
+ * TRANSFORM PLAN GENERATOR
+ * Generates steps that perform concrete transformations or code changes.
+ */
+export const transformPlanGenStep = {
+    name: 'transformPlanGen',
+    description: 'Generates code transformation / modification steps.',
+    requires: ['analysis.intent', 'analysis.focus'],
+    produces: ['analysis.planSuggestion'],
+    async run(context) {
+        var _a, _b;
+        context.analysis || (context.analysis = {});
+        (_a = context.analysis).planSuggestion || (_a.planSuggestion = {});
+        (_b = context.analysis.planSuggestion).plan || (_b.plan = { steps: [] });
+        // Restrict actions to TRANSFORM group only
+        const effectiveActions = PLAN_ACTIONS.filter(a => a.groups?.includes('transform'));
+        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.
+Your task is to produce a structured plan describing how to implement actual code transformations
+or modifications in the system to achieve the intended task.
+
+Intent / task description:
+${intentText}
+
+If the intent indicates that this is NOT a coding, refactoring, or inline commenting task, 
+then return an empty plan object with an empty "steps" array: 
+{ "steps": [] }
+
+Allowed actions (transformation only):
+${actionsJson}
+
+Task category:
+${intentCategory}
+
+Folder structure:
+${context.analysis.folderCapsulesHuman ?? ''}
+
+Existing relevant files:
+${JSON.stringify(context.analysis.focus?.relevantFiles ?? {}, null, 2)}
+
+Only perform transformations that are safe based on the existing analysis.
+
+⚡ Phase guidance:
+- Actions are grouped into phases: info, transform, finalize.
+- Only include transform steps in this phase.
+- Include a 'writeFile' step for each 'codeTransform' to persist changes to disk.
+- Each step must include: "action", "targetFile" (optional), "description", "metadata"
+
+❌ IMPORTANT: Do NOT include "info" steps here. Only plan actual code transformations.
+
+Return a strictly valid JSON plan:
+
+{
+  "steps": [
+    { "action": "stepName", "targetFile": "optional/path.ts", "description": "explanation", "metadata": {} }
+  ]
+}
+        `.trim();
+        try {
+            console.log('TransformPlanGenStep prompt', prompt);
+            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 plan = JSON.parse(jsonString);
+            if (!plan || !Array.isArray(plan.steps))
+                throw new Error('Invalid transform plan structure');
+            if (plan.steps.length > MAX_STEPS)
+                plan.steps = plan.steps.slice(0, MAX_STEPS);
+            // Map groups & metadata
+            plan.steps = plan.steps.map(step => {
+                const actionDef = PLAN_ACTIONS.find(a => a.action === step.action);
+                return {
+                    ...step,
+                    metadata: {
+                        ...step.metadata,
+                        routingConfidence: context.analysis?.routingDecision?.confidence ?? 0
+                    },
+                    groups: actionDef?.groups ?? ['transform']
+                };
+            });
+            // Replace existing transform steps in planSuggestion
+            context.analysis.planSuggestion.plan.steps = [
+                ...context.analysis.planSuggestion.plan.steps.filter(s => !s.groups?.includes('transform')),
+                ...plan.steps
+            ];
+            logInputOutput('transformPlanGen', 'output', plan);
+        }
+        catch (err) {
+            console.warn('⚠️ Failed to generate transform plan:', err);
+        }
+    }
+};

package/dist/agents/understandIntentStep.js

@@ -0,0 +1,72 @@
+// File: src/agents/steps/understandIntentStep.ts
+import { generate } from "../lib/generate.js";
+import { logInputOutput } from "../utils/promptLogHelper.js";
+export const understandIntentStep = {
+    name: "understandIntent",
+    description: "Analyze the user query and determine its intent, type, and the appropriate task category.",
+    /**
+     * Run the step
+     */
+    run: async (input) => {
+        const { context } = input;
+        const prompt = `
+You are an AI assistant whose job is to determine the user's intent.
+
+User Query:
+${context.initContext?.userQuery}
+
+Return a STRICT JSON object with the following fields:
+{
+  "intent": "short sentence summarizing the user's intent",
+  "intentCategory": "one of: question, request, codingTask, refactorTask, explanation, debugging, planning, writing, other",
+  "normalizedQuery": "a cleaned and direct restatement of the user query",
+  "confidence": 0-1  // float
+}
+
+Do not include commentary. Emit ONLY valid JSON.
+        `.trim();
+        try {
+            const genInput = {
+                query: context.initContext?.userQuery ?? '',
+                content: prompt
+            };
+            const genOutput = await generate(genInput);
+            let raw = genOutput.data;
+            if (typeof raw !== "string")
+                raw = JSON.stringify(raw ?? "{}");
+            logInputOutput("understandIntent", "output", raw);
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch {
+                parsed = {
+                    intent: "unknown",
+                    intentCategory: "other",
+                    normalizedQuery: context.initContext?.userQuery,
+                    confidence: 0.3
+                };
+            }
+            // Ensure the analysis object exists
+            context.analysis ?? (context.analysis = {});
+            // Store intent inside a dedicated object
+            context.analysis.intent = {
+                intent: parsed.intent,
+                intentCategory: parsed.intentCategory,
+                normalizedQuery: parsed.normalizedQuery,
+                confidence: parsed.confidence
+            };
+        }
+        catch (err) {
+            console.error("understandIntent error:", err);
+            // Ensure the analysis object exists
+            context.analysis ?? (context.analysis = {});
+            context.analysis.intent = {
+                intent: "unknown",
+                intentCategory: "other",
+                normalizedQuery: context.initContext?.userQuery ?? '',
+                confidence: 0.0
+            };
+        }
+    }
+};

package/dist/agents/validationAnalysisStep.js

@@ -0,0 +1,87 @@
+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?.relevantFiles ?? [];
+        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/commands/AskCmd.js

@@ -1,145 +1,76 @@
 import fs from 'fs';
-import path from 'path';
 import readline from 'readline';
-import { searchFiles, queryFiles } from '../db/fileIndex.js';
-import { sanitizeQueryForFts } from '../utils/sanitizeQuery.js';
-import { generate } from '../lib/generate.js';
-import { buildContextualPrompt } from '../utils/buildContextualPrompt.js';
-import { log } from '../utils/log.js';
-import { PROMPT_LOG_PATH, SCAI_HOME, RELATED_FILES_LIMIT, getIndexDir } from '../constants.js';
 import chalk from 'chalk';
+import { searchFiles } from '../db/fileIndex.js';
+import { sanitizeQueryForFts } from '../utils/sanitizeQuery.js';
+import { NUM_TOPFILES, RELATED_FILES_LIMIT, getIndexDir } from '../constants.js';
+import { MainAgent } from '../agents/MainAgent.js';
+import { buildLightContext } from '../utils/buildContextualPrompt.js';
 export async function runAskCommand(query) {
-    if (!query) {
+    // STEP 0: Get user query
+    if (!query)
         query = await promptOnce('💬 Ask your question:\n');
-    }
     query = query.trim();
     if (!query) {
         console.error('❌ No question provided.\n👉 Usage: scai ask "your question"');
         return;
     }
     console.log(`📁 Using index root: ${getIndexDir()}`);
-    // Semantic Search
-    const start = Date.now();
-    const semanticResults = await searchFiles(query, RELATED_FILES_LIMIT);
-    const duration = Date.now() - start;
-    console.log(`⏱️ searchFiles took ${duration}ms and returned ${semanticResults.length} result(s)`);
-    semanticResults.forEach((file, i) => {
-        console.log(`  ${i + 1}. 📄 Path: ${file.path} | Score: ${file.score?.toFixed(3) ?? 'n/a'}`);
-    });
-    // Fallback FTS search
+    // STEP 1: FTS Search
     const safeQuery = sanitizeQueryForFts(query);
-    const fallbackResults = queryFiles(safeQuery, 10);
-    fallbackResults.forEach((file, i) => {
-        console.log(`  ${i + 1}. 🔎 Fallback Match: ${file.path}`);
-    });
-    // Merge results
-    const seen = new Set();
-    const combinedResults = [];
-    for (const file of semanticResults) {
-        const resolved = path.resolve(file.path);
-        seen.add(resolved);
-        combinedResults.push(file);
+    const start = Date.now();
+    const results = await searchFiles(safeQuery, RELATED_FILES_LIMIT);
+    console.log(`⏱️ searchFiles took ${Date.now() - start}ms and returned ${results.length} result(s)`);
+    if (results.length === 0) {
+        console.log(chalk.redBright('❌ No results found.'));
+        return;
     }
-    for (const file of fallbackResults) {
-        const resolved = path.resolve(file.path);
-        if (!seen.has(resolved)) {
-            seen.add(resolved);
-            combinedResults.push({
-                id: file.id,
-                path: file.path,
-                summary: file.summary || '',
-                score: 0.0,
-                sim: 0,
-                bm25: 0
-            });
+    // STEP 2: Build topFiles (with code)
+    const topResults = results.slice(0, NUM_TOPFILES);
+    const topFiles = topResults.map(r => {
+        let code = '';
+        try {
+            code = fs.readFileSync(r.path, 'utf-8');
         }
-    }
-    // Exact match prioritization
-    const queryFilenameRaw = path.basename(query).toLowerCase();
-    const queryFilenameNoExt = queryFilenameRaw.replace(/\.[^/.]+$/, '');
-    const exactMatchIndex = combinedResults.findIndex(f => {
-        const base = path.basename(f.path).toLowerCase();
-        const baseNoExt = base.replace(/\.[^/.]+$/, '');
-        return base === queryFilenameRaw || baseNoExt === queryFilenameNoExt;
-    });
-    if (exactMatchIndex !== -1) {
-        const [exactMatch] = combinedResults.splice(exactMatchIndex, 1);
-        combinedResults.unshift(exactMatch);
-        console.log(`🎯 Exact match prioritized: ${exactMatch.path}`);
-    }
-    // Log combined results
-    if (combinedResults.length) {
-        console.log('\n📊 Final Related Files:');
-        combinedResults.forEach((f, i) => {
-            console.log(`  ${i + 1}. ${f.path} (${f.score?.toFixed(3) ?? 'fallback'})`);
-        });
-    }
-    else {
-        console.log('⚠️ No similar files found. Using query only.');
-    }
-    // STEP 4+: Build contextual prompt using topFile + combinedResults
-    if (combinedResults.length === 0) {
-        throw new Error('❌ No search results found. Cannot build contextual prompt.');
-    }
-    const file = combinedResults[0];
-    let code = "";
-    // STEP 4++: Add code to params
-    try {
-        code = fs.readFileSync(file.path, 'utf-8');
-        if (!code) {
-            console.warn(`⚠️ No code loaded for top file: ${file.path}`);
+        catch (err) {
+            console.warn(`⚠️ Failed to read file: ${r.path}`);
         }
-    }
-    catch (e) {
-        console.log("Error reading code from selected file: ", e instanceof Error ? e.message : e);
-    }
-    const topFile = {
-        id: file.id,
-        path: file.path,
-        summary: file.summary ?? "",
-        code,
-    };
+        return {
+            path: r.path,
+            summary: r.summary ?? undefined,
+            code,
+        };
+    });
+    console.log(chalk.greenBright(`🎯 Selected top ${topFiles.length} file(s):`));
+    topFiles.forEach(f => console.log(`   → ${f.path}`));
+    // STEP 3: Related files (all results except topFiles)
+    const relatedFiles = results.slice(NUM_TOPFILES).map(f => ({
+        id: f.id,
+        path: f.path,
+        summary: f.summary ?? undefined,
+    }));
+    // STEP 4: Build context prompt
     const promptArgs = {
-        topFile,
-        relatedFiles: combinedResults,
+        topFiles,
+        relatedFiles,
         query,
     };
-    console.log(chalk.blueBright('\n📦 Building contextual prompt...'));
-    const promptContent = await buildContextualPrompt(promptArgs);
-    console.log(chalk.greenBright('✅ Prompt built successfully.'));
-    console.log(chalk.cyan(`[runAskCommand] Prompt token estimate: ~${Math.round(promptContent.length / 4)} tokens`));
-    // STEP 5: Save prompt
+    const context = await buildLightContext(promptArgs);
+    // STEP 5: Run agent
     try {
-        if (!fs.existsSync(SCAI_HOME))
-            fs.mkdirSync(SCAI_HOME, { recursive: true });
-        fs.writeFileSync(PROMPT_LOG_PATH, promptContent, 'utf-8');
-        log(`📝 Prompt saved to ${PROMPT_LOG_PATH}`);
+        console.log('\n🤖 Launching autonomous agent...');
+        const agent = new MainAgent(context);
+        await agent.run();
     }
     catch (err) {
-        log('❌ Failed to write prompt log:', err);
-    }
-    // STEP 6: Ask model
-    try {
-        console.log('\n🤖 Asking the model...');
-        const input = {
-            content: promptContent,
-            filepath: topFile.path,
-        };
-        const modelResponse = await generate(input);
-        console.log(`\n🧠 Model Response:\n${modelResponse.content}`);
-    }
-    catch (err) {
-        console.error('❌ Model request failed:', err);
+        console.error('❌ Autonomous agent run failed:', err);
     }
 }
-// Helper: Prompt once
+// helper
 function promptOnce(promptText) {
     return new Promise(resolve => {
         console.log(promptText);
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
         rl.question('> ', answer => {
             rl.close();
             resolve(answer.trim());

package/dist/commands/ChangeLogUpdateCmd.js

@@ -7,7 +7,6 @@ import { changelogModule } from '../pipeline/modules/changeLogModule.js';
 import { askChangelogApproval } from '../utils/changeLogPrompt.js';
 import { openTextEditor } from '../utils/editor.js';
 export async function handleStandaloneChangelogUpdate() {
-    // Don't bother with diffs at all here
     let entry = await generateChangelogEntry();
     if (!entry) {
         console.log('⚠️ No significant changes found.');
@@ -51,8 +50,16 @@ export async function generateChangelogEntry(currentCommitMsg) {
             console.log("⚠️ No commits found since last release.");
             return null;
         }
-        const result = await runModulePipeline([changelogModule], { content: commits });
-        const output = result?.summary?.trim();
+        // --- ModuleIO usage ---
+        const result = await runModulePipeline([changelogModule], {
+            query: 'generate changelog entry',
+            content: commits
+        });
+        const output = result?.data
+            ? typeof result.data === 'string'
+                ? result.data.trim()
+                : JSON.stringify(result.data, null, 2)
+            : null;
         if (!output || output === 'NO UPDATE') {
             console.log('⚠️ No significant changes detected for changelog.');
             return null;
@@ -69,11 +76,10 @@ function getLastGitTag() {
         return execSync('git describe --tags --abbrev=0', { encoding: 'utf-8' }).trim();
     }
     catch {
-        return null; // no tags found
+        return null;
     }
 }
 function getCommitsSinceTag(tag) {
-    // Get commit messages in a simple format, e.g. only commit messages
     return execSync(`git log ${tag}..HEAD --pretty=format:%s`, { encoding: 'utf-8' }).trim();
 }
 export async function updateChangelogFile(entry) {