scai 0.1.166 → 0.1.168

package/dist/agents/MainAgent.js

@@ -19,18 +19,9 @@ import { selectRelevantSourcesStep } from "./selectRelevantSourcesStep.js";
 import { iterationFileSelector } from "./iterationFileSelector.js";
 import { finalAnswerModule } from "../pipeline/modules/finalAnswerModule.js";
 import { reasonNextStep } from "./reasonNextStep.js";
+import chalk from "chalk";
 /* ───────────────────────── registry ───────────────────────── */
-/**
- * Registry mapping action names to their corresponding Module implementations.
- * This registry is populated with built-in modules from the module registry.
- */
 const MODULE_REGISTRY = Object.fromEntries(Object.entries(builtInModules).map(([name, mod]) => [name, mod]));
-/**
- * Resolves a module by its action name.
- *
- * @param action - The action name to resolve.
- * @returns The Module implementation if found, otherwise undefined.
- */
 function resolveModuleForAction(action) {
     return MODULE_REGISTRY[action];
 }
@@ -64,13 +55,17 @@ export class MainAgent {
     }
     /* ───────────── main run ───────────── */
     async run() {
-        this.runCount = 0;
-        await this.runBoot();
-        await this.runPrecheck();
-        await this.runScope();
-        await this.runGrounding();
-        await this.runWorkLoop();
-        await this.runFinalize();
+        try {
+            this.runCount = 0;
+            await this.runBoot();
+            await this.runScope();
+            await this.runGrounding();
+            await this.runWorkLoop();
+            await this.runFinalize();
+        }
+        finally {
+            this.ui.stop(); // ← guaranteed cleanup
+        }
     }
     /* ───────────── boot ───────────── */
     async runBoot() {
@@ -78,128 +73,141 @@ export class MainAgent {
         await understandIntentStep.run({ context: this.context });
         await resolveExecutionModeStep.run(this.context);
         // Boot the task and get the real DB taskId
-        this.taskId = bootTaskForRepo(this.context, getDbForRepo(), this.logLine.bind(this));
-        // Ensure context.task exists and has all required fields
+        this.taskId = bootTaskForRepo(this.context, getDbForRepo(), (phase, step, ms, desc) => this.logLine(phase, step, ms, desc, { highlight: true }));
         (_a = this.context).task || (_a.task = {
             id: this.taskId,
-            projectId: 0, // optionally set to a real projectId if available
+            projectId: 0,
             status: "active",
             initialQuery: this.context.initContext?.userQuery ?? "",
             createdAt: new Date().toISOString(),
             updatedAt: new Date().toISOString(),
             taskSteps: [],
         });
-        // If task existed but id wasn’t set, set it now
         this.context.task.id = this.taskId;
-    }
-    /* ───────────── precheck ───────────── */
-    async runPrecheck() {
-        await fileCheckStep(this.context);
+        this.logLine("TASK", "Boot complete", undefined, `taskId=${this.taskId}`, { highlight: true });
     }
     /* ───────────── scope ───────────── */
     async runScope() {
         await scopeClassificationStep.run(this.context);
+        this.logLine("TASK", "Scope classification complete");
     }
-    /* ───────────── grounding / info acquisition loop ───────────── */
     async runGrounding() {
         let ready = false;
-        while (!ready && this.runCount < this.maxRuns) {
+        while (this.runCount < this.maxRuns) {
+            // ---------------- EVIDENCE PIPELINE ----------------
+            const t1 = this.startTimer();
+            await evidenceVerifierStep.run({ query: this.query, context: this.context });
+            this.logLine("ANALYSIS", "collectAnalysisEvidence", t1());
+            const t2 = this.startTimer();
+            await fileCheckStep(this.context);
+            this.logLine("ANALYSIS", "fileCheckStep", t2());
+            const t3 = this.startTimer();
+            await selectRelevantSourcesStep.run({ query: this.query, context: this.context });
+            this.logLine("ANALYSIS", "selectRelevantSources", t3());
+            // ---------------- READINESS GATE ----------------
+            const t4 = this.startTimer();
+            await readinessGateStep.run(this.context);
+            this.logLine("HASINFO", "readinessGate", t4());
+            ready = this.context.analysis?.readiness?.decision === "ready";
+            if (ready) {
+                break;
+            }
             // ---------------- INFORMATION ACQUISITION ----------------
             if (this.canExecutePhase("planning") &&
                 this.canExecuteScope("planning")) {
                 const t = this.startTimer();
-                // Generate info plan step(s) in context
                 await infoPlanGenStep.run(this.context);
                 const infoPlan = this.context.analysis?.planSuggestion?.plan ?? { steps: [] };
+                // If we are about to execute a new info acquisition wave,
+                // wipe previous search results.
+                if (infoPlan.steps.length > 0 && this.context.initContext && this.context.analysis?.focus) {
+                    this.context.initContext.relatedFiles = [];
+                    this.context.analysis.focus.candidateFiles = [];
+                }
                 for (const step of infoPlan.steps) {
                     const stepIO = { query: this.query };
                     await this.executeStep(step, stepIO);
-                    // Re-check any new files discovered
-                    const t2 = this.startTimer();
-                    await fileCheckStep(this.context);
-                    this.logLine("PRECHECK", "postFileSearch", t2());
-                }
-                this.logLine("PLAN", "infoPlanGen", t());
-            }
-            // ---------------- DETERMINISTIC EVIDENCE VERIFICATION ----------------
-            const t1 = this.startTimer();
-            await evidenceVerifierStep.run({ query: this.query, context: this.context });
-            this.logLine("ANALYSIS", "collectAnalysisEvidence", t1(), undefined);
-            // Select grounded candidate files
-            const t2 = this.startTimer();
-            await selectRelevantSourcesStep.run({ query: this.query, context: this.context });
-            this.logLine("ANALYSIS", "selectRelevantSources", t2(), undefined);
-            // ---------------- READINESS GATE ----------------
-            const t3 = this.startTimer();
-            await readinessGateStep.run(this.context);
-            this.logLine("HASINFO", "readinessGate", t3(), undefined);
-            ready = this.context.analysis?.readiness?.decision === "ready";
-            if (!ready) {
-                this.runCount++;
-                // Previously resetInitContextForLoop removed; optionally clear temporary data
-                if (this.context.analysis) {
-                    this.context.analysis.planSuggestion = undefined;
                 }
-                this.logLine("HASINFO", "readinessGate", undefined, "Not ready, looping back to information acquisition");
+                this.logLine("PLAN", "infoPlanGen", t(), undefined, { highlight: false });
             }
+            this.runCount++;
+            this.logLine("HASINFO", "Not ready — looping back to evidence collection", undefined, undefined, { highlight: false });
         }
     }
     /* ───────────── finalize ───────────── */
     async runFinalize() {
-        // generate final answer
         await finalAnswerModule.run({ query: this.query, context: this.context });
-        // persist task and steps
         persistTaskData(this.context, this.taskId, getDbForRepo(), this.logLine.bind(this));
+        this.logLine("TASK", "Finalize complete", undefined, undefined, { highlight: false });
     }
     /* ───────────── work loop ───────────── */
     async runWorkLoop() {
+        const readinessDecision = this.context.analysis?.readiness?.decision;
+        const readinessConfidence = this.context.analysis?.readiness?.confidence ?? 0;
+        if (readinessDecision !== "ready") {
+            // ❌ Graceful fallback instead of throwing
+            this.context.task.status = "deferred";
+            this.context.task.reason = `Readiness not achieved (decision=${readinessDecision}, confidence=${readinessConfidence})`;
+            persistTaskData(this.context, this.taskId, getDbForRepo(), this.logLine.bind(this));
+            this.logLine("TASK", `Cannot start work loop — agent needs more evidence to safely proceed`, undefined, `Readiness: ${readinessDecision}, Confidence: ${readinessConfidence}`, { highlight: true });
+            return;
+        }
+        if (!this.context.task) {
+            throw new Error("runWorkLoop: missing task");
+        }
         const MAX_TASK_STEPS = 5;
         let stepCount = 0;
-        while (stepCount < MAX_TASK_STEPS) {
+        while (stepCount < MAX_TASK_STEPS &&
+            this.context.task.status === "active") {
             await reasonNextTaskStep.run(this.context);
             const nextAction = this.context.analysis?.iterationReasoning?.nextAction;
+            // 🟡 Pause for user clarification
+            if (nextAction === "request-feedback") {
+                this.context.task.status = "paused";
+                persistTaskData(this.context, this.taskId, getDbForRepo(), this.logLine.bind(this));
+                this.logLine("TASK", "Execution paused — awaiting user clarification", undefined, undefined, { highlight: false });
+                return;
+            }
+            // 🟢 Completed task
             if (nextAction === "complete") {
-                this.logLine("TASK", "All selected files processed — task complete");
+                this.context.task.status = "completed";
+                persistTaskData(this.context, this.taskId, getDbForRepo(), this.logLine.bind(this));
+                this.logLine("TASK", "All selected files processed — task complete", undefined, undefined, { highlight: false });
                 return;
             }
             const taskStep = await iterationFileSelector.run(this.context);
             if (!taskStep) {
-                this.logLine("TASK", "No eligible taskStep found — task complete");
+                this.context.task.status = "completed";
+                persistTaskData(this.context, this.taskId, getDbForRepo(), this.logLine.bind(this));
+                this.logLine("TASK", "No eligible taskStep found — task complete", undefined, undefined, { highlight: false });
                 return;
             }
-            // Set current step in context
-            if (this.context.task) {
-                this.context.task.currentStep = taskStep;
-            }
+            this.context.task.currentStep = taskStep;
             stepCount++;
             taskStep.taskId = this.taskId;
             taskStep.stepIndex = stepCount;
             taskStep.status = "pending";
-            // ⬇️ Persist newly created step
             persistTaskStepInsert(taskStep, getDbForRepo());
-            logInputOutput("Step to process", "input", taskStep);
-            this.logLine("TASK", `Processing taskStep ${stepCount}/${MAX_TASK_STEPS}`, undefined, taskStep.filePath);
-            // ---------------------------
-            //  Start the step
-            // ---------------------------
+            this.logLine("NEW STEP", `Processing taskStep ${stepCount}`, undefined, taskStep.filePath, { highlight: true });
             taskStep.startTime = Date.now();
             persistTaskStepStart(taskStep, getDbForRepo());
             // ---------------------------
-            // Step-level iterations: reason only about this file
+            // Step-level iterations
             // ---------------------------
             const stepAction = await this.runStepIterations(taskStep);
             if (stepAction === "complete") {
                 taskStep.status = "completed";
                 taskStep.endTime = Date.now();
                 persistTaskStepCompletion(taskStep, getDbForRepo());
+                this.logLine("STEP-DONE", `Completed taskStep ${stepCount}`, undefined, taskStep.filePath, { highlight: false });
             }
             else {
-                // optionally mark as pending or redo-step
                 taskStep.status = "pending";
                 persistTaskStepCompletion(taskStep, getDbForRepo());
+                this.logLine("STEP", `Pending taskStep ${stepCount}`, undefined, taskStep.filePath);
             }
         }
-        this.logLine("TASK", "Max task step limit reached — stopping work loop");
+        this.logLine("TASK", "Max task step limit reached — stopping work loop", undefined, undefined, { highlight: false });
     }
     /* ───────────── step iterations ───────────── */
     async runStepIterations(taskStep) {
@@ -207,31 +215,22 @@ export class MainAgent {
         let loopCount = 0;
         const getNextIterationAction = () => {
             const nextAction = this.context.analysis?.iterationReasoning?.nextAction;
-            if (nextAction !== "continue" &&
-                nextAction !== "redo-step" &&
-                nextAction !== "expand-scope" &&
-                nextAction !== "request-feedback" &&
-                nextAction !== "complete") {
-                return "complete"; // fallback
-            }
+            if (!["continue", "redo-step", "expand-scope", "request-feedback", "complete"].includes(nextAction ?? ""))
+                return "complete";
             return nextAction;
         };
-        // Loop through iterations for a single task step (file)
         while (loopCount < MAX_ITERATIONS) {
             this.runCount++;
             loopCount++;
-            // 🔴 HARD RESET — no carryover allowed
-            if (this.context.analysis?.iterationReasoning) {
+            if (this.context.analysis?.iterationReasoning)
                 this.context.analysis.iterationReasoning.nextAction = undefined;
-            }
             await this.runWorkIteration(taskStep);
             const nextAction = getNextIterationAction();
-            this.logLine("STEP-LOOP", "nextAction", undefined, nextAction);
+            this.logLine("STEP-LOOP", `nextAction = ${nextAction}`);
             if (nextAction === "complete")
                 return "complete";
             if (nextAction === "request-feedback")
                 return "request-feedback";
-            // else: continue
         }
         return "continue";
     }
@@ -239,56 +238,47 @@ export class MainAgent {
     async runWorkIteration(taskStep) {
         if (!this.context.analysis)
             this.context.analysis = {};
-        // ---------------- ANALYSIS ----------------
         if (this.canExecutePhase("analysis") && this.canExecuteScope("analysis")) {
             const tAnalysis = this.startTimer();
             await analysisPlanGenStep.run(this.context);
-            this.logLine("PLAN", "analysisPlanGen", tAnalysis());
+            this.logLine("PLAN", "analysisPlanGen", tAnalysis(), undefined, { highlight: false });
             const analysisPlan = this.context.analysis?.planSuggestion?.plan ?? { steps: [] };
             for (const step of analysisPlan.steps) {
                 const tStep = this.startTimer();
                 await this.executeStep(step, { query: this.query });
-                this.logLine("STEP", step.action || "unnamedStep", tStep());
+                this.logLine("PLANNING-STEP", step.action || "unnamedStep", tStep());
             }
-            if (this.context.analysis) {
+            if (this.context.analysis)
                 this.context.analysis.planSuggestion = undefined;
-            }
         }
-        // ---------------- TRANSFORM ----------------
         if (this.canExecutePhase("transform") && this.canExecuteScope("transform")) {
             const tTransform = this.startTimer();
             await transformPlanGenStep.run(this.context);
-            this.logLine("PLAN", "transformPlanGen", tTransform());
+            this.logLine("PLAN", "transformPlanGen", tTransform(), undefined, { highlight: false });
             const transformPlan = this.context.analysis?.planSuggestion?.plan ?? { steps: [] };
             const firstStep = transformPlan.steps[0];
             if (firstStep) {
                 const tStep = this.startTimer();
                 await this.executeStep(firstStep, { query: this.query });
-                this.logLine("STEP", `#1 (only) - ${firstStep.action || "unnamedStep"}`, tStep());
+                this.logLine("PLANNING-STEP", `#1 (only) - ${firstStep.action || "unnamedStep"}`, tStep());
             }
-            if (this.context.analysis) {
+            if (this.context.analysis)
                 this.context.analysis.planSuggestion = undefined;
-            }
-            // ---------------- WRITE ----------------
             if (this.canExecutePhase("write") && this.canExecuteScope("write")) {
                 const tWrite = this.startTimer();
                 await writeFileStep.run({ query: this.query, context: this.context });
                 this.logLine("WRITE", "writeFileStep", tWrite());
             }
-            // ---------------- VALIDATION ----------------
             const tValidate = this.startTimer();
             await validateChangesStep.run(this.context);
             this.logLine("VALIDATION", "validateChangesStep", tValidate());
         }
-        // ---------------- REASONING ----------------
         const tReason = this.startTimer();
         await reasonNextStep.run(this.context, taskStep);
         this.logLine("REASONING", "reasonNextStep", tReason());
-        // ---------------- COLLABORATOR FEEDBACK ----------------
         const tCollab = this.startTimer();
         await collaboratorStep.run(this.context);
         this.logLine("FEEDBACK", "collaboratorStep", tCollab());
-        // ---------------- INTEGRATE FEEDBACK ----------------
         const tIntegrate = this.startTimer();
         await integrateFeedbackStep.run(this.context);
         this.logLine("FEEDBACK", "integrateFeedbackStep", tIntegrate());
@@ -304,9 +294,7 @@ export class MainAgent {
      */
     async executeStep(step, input) {
         const stop = this.startTimer();
-        // Set current step in context
         this.context.currentStep = step;
-        // Resolve module for this action
         const mod = resolveModuleForAction(step.action);
         if (!mod) {
             this.logLine("EXECUTE", step.action, stop(), "skipped (missing module)");
@@ -314,13 +302,7 @@ export class MainAgent {
         }
         try {
             this.ui.update(`Running step: ${step.action}`);
-            // Execute the module
-            await mod.run({
-                query: step.description ?? input.query,
-                content: input.data ?? input.content,
-                context: this.context
-            });
-            // Return ModuleIO (can remain minimal since output is untyped)
+            await mod.run({ query: step.description ?? input.query, content: input.data ?? input.content, context: this.context });
             return { query: step.description ?? input.query, data: {} };
         }
         catch (err) {
@@ -342,12 +324,10 @@ export class MainAgent {
         switch (phase) {
             case "analysis":
             case "planning":
-                // Read-only phases are always allowed
                 allowed = !docsOnly;
                 break;
             case "transform":
             case "write":
-                // Side-effect phases require explicit permission
                 allowed = constraints?.allowFileWrites ?? false;
                 break;
         }
@@ -365,14 +345,10 @@ export class MainAgent {
         let allowed = false;
         switch (scope) {
             case "none":
-                // Non-repo questions: analysis/planning only
                 allowed = phase === "analysis" || phase === "planning";
                 break;
-            case "single-file":
-            case "multi-file":
-            case "repo-wide":
+            default:
                 allowed = true;
-                break;
         }
         return allowed;
     }
@@ -396,38 +372,33 @@ export class MainAgent {
      * @param fn - The function to execute while spinner is paused.
      */
     withSpinnerPaused(fn) {
-        this.ui.pause(() => {
-            // Ensure spinner line is fully gone
-            process.stdout.write('\r\x1b[K');
-            fn();
-        });
+        this.ui.pause(() => { process.stdout.write('\r\x1b[K'); fn(); });
     }
-    /**
-     * Logs a line with timing information.
-     *
-     * @param phase - The phase of execution.
-     * @param step - The step being executed.
-     * @param ms - The execution time in milliseconds.
-     * @param desc - Optional description of the step.
-     */
-    logLine(phase, step, ms, desc) {
+    logLine(phase, step, ms, desc, options) {
         this.withSpinnerPaused(() => {
             const suffix = desc ? ` — ${desc}` : "";
             const timing = typeof ms === "number" ? ` (${ms}ms)` : "";
-            console.log(`[AGENT] ${phase} :: ${step}${suffix}${timing}`);
+            let line = `[AGENT] ${phase} :: ${step}${suffix}${timing}`;
+            // Coloring rules
+            if (phase === "NEW STEP" || phase === "STEP") {
+                line = chalk.green(line);
+            }
+            else if (options?.highlight) {
+                line = chalk.green(line);
+            }
+            // Print a blank line **before** NEW STEP only
+            if (phase === "NEW STEP")
+                console.log();
+            console.log(line);
         });
     }
-    /**
-     * Logs a message to the user output.
-     *
-     * @param message - The message to log.
-     */
     userOutput(message) {
         this.withSpinnerPaused(() => {
             console.log(`[USER OUTPUT] ${message}`);
         });
     }
 }
+// All helper functions (persistTaskData, bootTaskForRepo, persistTaskStep*) remain unchanged
 /* ───────────── FOLDER CAPSULES SUMMARY HELPER ───────────── */
 /**
  * Generates a human-readable summary of folder capsules and logs it.