@openeryc/pi-coding-agent 0.75.45 → 0.75.46

package/dist/modes/interactive/interactive-mode.js

@@ -30,6 +30,7 @@ import { parseGitUrl } from "../../utils/git.js";
 import { getCwdRelativePath } from "../../utils/paths.js";
 import { getPiUserAgent } from "../../utils/pi-user-agent.js";
 import { killTrackedDetachedChildren } from "../../utils/shell.js";
+import { sleep } from "../../utils/sleep.js";
 import { ensureTool } from "../../utils/tools-manager.js";
 import { checkForNewPiVersion } from "../../utils/version-check.js";
 import { ArminComponent } from "./components/armin.js";
@@ -172,6 +173,15 @@ export class InteractiveMode {
     compactionQueuedMessages = [];
     // Shutdown state
     shutdownRequested = false;
+    // Goal runner state: auto-continues working on a session goal across turns,
+    // retries on errors, and survives process restarts via session persistence.
+    goalRunnerEnabled = true;
+    goalRunnerAbortController = undefined;
+    goalRunnerRetryAttempt = 0;
+    goalRunnerStatusDisplayed = false;
+    GOAL_RUNNER_MAX_RETRIES = 10;
+    GOAL_RUNNER_BASE_DELAY_MS = 3000;
+    GOAL_RUNNER_TURN_DELAY_MS = 800;
     // Extension UI state
     extensionSelector = undefined;
     extensionInput = undefined;
@@ -507,6 +517,16 @@ export class InteractiveMode {
      */
     async run() {
         await this.init();
+        // If resuming a session that has a goal, auto-continue from where it left off.
+        // This handles crash recovery and manual resume scenarios.
+        const resumedGoal = this.session.sessionGoal;
+        if (resumedGoal && this.session.state.messages.length > 0) {
+            this.goalRunnerEnabled = true;
+            this.chatContainer.addChild(new Spacer(1));
+            this.chatContainer.addChild(new Text(theme.fg("dim", `Resuming goal: "${resumedGoal}" (${keyText("app.interrupt")} to pause)`), 1, 0));
+            this.ui.requestRender();
+            await this.goalRunnerContinuationLoop(resumedGoal);
+        }
         // Start version check asynchronously
         checkForNewPiVersion(this.version).then((newRelease) => {
             if (newRelease) {
@@ -562,6 +582,7 @@ export class InteractiveMode {
         // Main interactive loop
         while (true) {
             const userInput = await this.getUserInput();
+            this.goalRunnerEnabled = true; // Re-enable on any user input
             try {
                 await this.session.prompt(userInput);
             }
@@ -569,6 +590,13 @@ export class InteractiveMode {
                 const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
                 this.showError(errorMessage);
             }
+            // After the prompt completes (or errors), check if goal runner should auto-continue.
+            if (this.goalRunnerEnabled) {
+                const goal = this.session.sessionGoal;
+                if (goal) {
+                    await this.goalRunnerContinuationLoop(goal);
+                }
+            }
         }
     }
     async checkForPackageUpdates() {
@@ -1884,6 +1912,14 @@ export class InteractiveMode {
             if (this.session.isStreaming) {
                 this.restoreQueuedMessagesToEditor({ abort: true });
             }
+            else if (this.goalRunnerAbortController) {
+                // Pause goal runner without clearing the goal
+                this.goalRunnerEnabled = false;
+                this.goalRunnerAbortController.abort();
+                this.chatContainer.addChild(new Spacer(1));
+                this.chatContainer.addChild(new Text(theme.fg("dim", "Goal runner paused. Use /goal on to resume."), 1, 0));
+                this.ui.requestRender();
+            }
             else if (this.session.isBashRunning) {
                 this.session.abortBash();
             }
@@ -4365,9 +4401,12 @@ export class InteractiveMode {
         const goal = text.replace(/^\/goal\s*/, "").trim();
         if (!goal) {
             const currentGoal = this.session.sessionGoal;
+            const runnerStatus = this.goalRunnerEnabled ? "enabled" : "paused";
             if (currentGoal) {
                 this.chatContainer.addChild(new Spacer(1));
-                this.chatContainer.addChild(new Text(theme.fg("dim", `Session goal: ${currentGoal}`), 1, 0));
+                this.chatContainer.addChild(new Text(theme.fg("dim", `Session goal: ${currentGoal} (goal runner: ${runnerStatus})`), 1, 0));
+                this.chatContainer.addChild(new Text(theme.fg("dim", `  /goal on  - enable goal runner`), 1, 0));
+                this.chatContainer.addChild(new Text(theme.fg("dim", `  /goal off - pause goal runner`), 1, 0));
             }
             else {
                 this.showWarning("Usage: /goal <goal description>");
@@ -4375,11 +4414,92 @@ export class InteractiveMode {
             this.ui.requestRender();
             return;
         }
+        const lower = goal.toLowerCase();
+        if (lower === "on" || lower === "off") {
+            this.goalRunnerEnabled = lower === "on";
+            const currentGoal = this.session.sessionGoal;
+            if (currentGoal) {
+                const label = lower === "on" ? theme.fg("success", "enabled") : theme.fg("warning", "paused");
+                this.chatContainer.addChild(new Spacer(1));
+                this.chatContainer.addChild(new Text(theme.fg("dim", `Goal runner ${label} for goal: "${currentGoal}"`), 1, 0));
+            }
+            else {
+                this.showWarning("No goal is set. Use /goal <description> to set one first.");
+            }
+            this.ui.requestRender();
+            return;
+        }
         this.session.setSessionGoal(goal);
+        this.goalRunnerEnabled = true;
         this.chatContainer.addChild(new Spacer(1));
         this.chatContainer.addChild(new Text(theme.fg("dim", `Session goal set: ${goal}`), 1, 0));
         this.ui.requestRender();
     }
+    /**
+     * Goal runner continuation loop.
+     * After each turn completes, auto-prompts the agent to continue pursuing the goal.
+     * Handles errors with exponential backoff and respects user interruption.
+     * Survives crashes: on next startup, the persisted session goal triggers auto-resume.
+     */
+    async goalRunnerContinuationLoop(goal) {
+        // Abort any previous goal runner controller
+        this.goalRunnerAbortController?.abort();
+        this.goalRunnerAbortController = new AbortController();
+        const signal = this.goalRunnerAbortController.signal;
+        try {
+            while (this.goalRunnerEnabled && this.session.sessionGoal) {
+                if (signal.aborted)
+                    break;
+                // Small delay between turns so the user can see what happened
+                try {
+                    await sleep(this.GOAL_RUNNER_TURN_DELAY_MS, signal);
+                }
+                catch {
+                    break;
+                }
+                if (signal.aborted)
+                    break;
+                // Skip if the agent is already streaming or compacting
+                if (this.session.isStreaming || this.session.isCompacting) {
+                    continue;
+                }
+                // Show status on first iteration
+                if (!this.goalRunnerStatusDisplayed) {
+                    this.goalRunnerStatusDisplayed = true;
+                    this.showStatus(`Pursuing goal: "${goal}" (${keyText("app.interrupt")} to pause)`);
+                }
+                try {
+                    await this.session.prompt(`Continue pursuing the goal: "${goal}". If you have fully completed this goal, report what was accomplished. If you cannot make further progress, explain what blocked you.`);
+                    // Successful turn completed, reset retry counter
+                    this.goalRunnerRetryAttempt = 0;
+                }
+                catch (error) {
+                    this.goalRunnerRetryAttempt++;
+                    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+                    if (this.goalRunnerRetryAttempt >= this.GOAL_RUNNER_MAX_RETRIES) {
+                        this.goalRunnerEnabled = false;
+                        this.showError(`Goal runner paused after ${this.GOAL_RUNNER_MAX_RETRIES} consecutive errors. ` +
+                            `Last error: ${errorMessage}. Use /goal on to resume.`);
+                        break;
+                    }
+                    // Exponential backoff
+                    const delay = this.GOAL_RUNNER_BASE_DELAY_MS * 2 ** (this.goalRunnerRetryAttempt - 1);
+                    this.showStatus(`Goal runner error, retrying in ${Math.ceil(delay / 1000)}s ` +
+                        `(${this.goalRunnerRetryAttempt}/${this.GOAL_RUNNER_MAX_RETRIES})... (${keyText("app.interrupt")} to pause)`);
+                    try {
+                        await sleep(delay, signal);
+                    }
+                    catch {
+                        break;
+                    }
+                }
+            }
+        }
+        finally {
+            this.goalRunnerAbortController = undefined;
+            this.goalRunnerStatusDisplayed = false;
+        }
+    }
     handleSessionCommand() {
         const stats = this.session.getSessionStats();
         const sessionName = this.sessionManager.getSessionName();