aicodeman 0.5.2 → 0.5.4

package/dist/respawn-controller.js

@@ -53,12 +53,20 @@ import { RespawnAdaptiveTiming } from './respawn-adaptive-timing.js';
 import { RespawnCycleMetricsTracker } from './respawn-metrics.js';
 import { calculateHealthScore, shouldSkipClear } from './respawn-health.js';
 import { AI_CHECK_MODEL, AI_IDLE_CHECK_MAX_CONTEXT, AI_PLAN_CHECK_MAX_CONTEXT, AI_IDLE_CHECK_TIMEOUT_MS, AI_IDLE_CHECK_COOLDOWN_MS, AI_PLAN_CHECK_TIMEOUT_MS, AI_PLAN_CHECK_COOLDOWN_MS, } from './config/ai-defaults.js';
+import { getErrorMessage, } from './types.js';
 // ========== Constants ==========
 // COMPLETION_TIME_PATTERN moved to ./respawn-patterns.ts
 /** Pre-filter: numbered option pattern for plan mode detection */
 const PLAN_MODE_OPTION_PATTERN = /\d+\.\s+(Yes|No|Type|Cancel|Skip|Proceed|Approve|Reject)/i;
 /** Pre-filter: selection indicator arrow for plan mode detection */
 const PLAN_MODE_SELECTOR_PATTERN = /[❯>]\s*\d+\./;
+/**
+ * Convert milliseconds to a non-negative whole number of seconds for countdown display.
+ * Rounds up so that e.g. 1200 ms shows as 2 s (never under-reports remaining time).
+ */
+function formatRemainingSeconds(ms) {
+    return Math.max(0, Math.ceil(ms / 1000));
+}
 /** Default configuration values */
 const DEFAULT_CONFIG = {
     idleTimeoutMs: 10000, // 10 seconds of no activity after prompt (legacy, still used as fallback)
@@ -291,35 +299,39 @@ export class RespawnController extends EventEmitter {
      */
     validateConfig() {
         const c = this.config;
-        // Ensure timeouts are positive
-        if (c.idleTimeoutMs <= 0)
-            c.idleTimeoutMs = DEFAULT_CONFIG.idleTimeoutMs;
-        if (c.completionConfirmMs <= 0)
-            c.completionConfirmMs = DEFAULT_CONFIG.completionConfirmMs;
-        if (c.noOutputTimeoutMs <= 0)
-            c.noOutputTimeoutMs = DEFAULT_CONFIG.noOutputTimeoutMs;
-        if (c.autoAcceptDelayMs < 0)
-            c.autoAcceptDelayMs = DEFAULT_CONFIG.autoAcceptDelayMs;
-        if (c.interStepDelayMs <= 0)
-            c.interStepDelayMs = DEFAULT_CONFIG.interStepDelayMs;
+        /**
+         * Validate that a timeout value is positive (or non-negative when allowZero is true).
+         * Falls back to the DEFAULT_CONFIG value if invalid.
+         */
+        const validatePositiveTimeout = (field, allowZero = false) => {
+            const value = c[field];
+            const invalid = allowZero ? value < 0 : value <= 0;
+            if (invalid) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                c[field] = DEFAULT_CONFIG[field];
+            }
+        };
+        const REQUIRED_TIMEOUT_FIELDS = [
+            'idleTimeoutMs',
+            'completionConfirmMs',
+            'noOutputTimeoutMs',
+            'interStepDelayMs',
+            'aiIdleCheckTimeoutMs',
+            'aiIdleCheckMaxContext',
+            'aiPlanCheckTimeoutMs',
+            'aiPlanCheckMaxContext',
+        ];
+        for (const field of REQUIRED_TIMEOUT_FIELDS) {
+            validatePositiveTimeout(field);
+        }
+        const ALLOW_ZERO_FIELDS = ['autoAcceptDelayMs', 'aiIdleCheckCooldownMs', 'aiPlanCheckCooldownMs'];
+        for (const field of ALLOW_ZERO_FIELDS) {
+            validatePositiveTimeout(field, true);
+        }
         // Ensure completion confirm doesn't exceed no-output timeout
         if (c.completionConfirmMs > c.noOutputTimeoutMs) {
             c.completionConfirmMs = c.noOutputTimeoutMs;
         }
-        // Ensure AI check timeouts are positive
-        if (c.aiIdleCheckTimeoutMs <= 0)
-            c.aiIdleCheckTimeoutMs = DEFAULT_CONFIG.aiIdleCheckTimeoutMs;
-        if (c.aiIdleCheckCooldownMs < 0)
-            c.aiIdleCheckCooldownMs = DEFAULT_CONFIG.aiIdleCheckCooldownMs;
-        if (c.aiIdleCheckMaxContext <= 0)
-            c.aiIdleCheckMaxContext = DEFAULT_CONFIG.aiIdleCheckMaxContext;
-        // Ensure plan check timeouts are positive
-        if (c.aiPlanCheckTimeoutMs <= 0)
-            c.aiPlanCheckTimeoutMs = DEFAULT_CONFIG.aiPlanCheckTimeoutMs;
-        if (c.aiPlanCheckCooldownMs < 0)
-            c.aiPlanCheckCooldownMs = DEFAULT_CONFIG.aiPlanCheckCooldownMs;
-        if (c.aiPlanCheckMaxContext <= 0)
-            c.aiPlanCheckMaxContext = DEFAULT_CONFIG.aiPlanCheckMaxContext;
     }
     /** Wire up AI checker events to controller events (removes existing listeners first to prevent duplicates) */
     setupAiCheckerListeners() {
@@ -437,12 +449,12 @@ export class RespawnController extends EventEmitter {
         }
         else if (this._state === 'confirming_idle') {
             statusText = `Confirming idle (${confidence}% confidence)`;
-            waitingFor = `${Math.max(0, Math.ceil((this.config.completionConfirmMs - msSinceLastOutput) / 1000))}s more silence`;
+            waitingFor = `${formatRemainingSeconds(this.config.completionConfirmMs - msSinceLastOutput)}s more silence`;
         }
         else if (this._state === 'watching') {
             const aiState = this.aiChecker.getState();
             if (aiState.status === 'cooldown') {
-                const remaining = Math.ceil(this.aiChecker.getCooldownRemainingMs() / 1000);
+                const remaining = formatRemainingSeconds(this.aiChecker.getCooldownRemainingMs());
                 statusText = `AI Check: WORKING (cooldown ${remaining}s)`;
                 waitingFor = 'Cooldown to expire';
             }
@@ -788,88 +800,13 @@ export class RespawnController extends EventEmitter {
             this.lastTokenCount = tokenCount;
             this.lastTokenChangeTime = now;
         }
-        // Detect completion message FIRST (Layer 1) - PRIMARY DETECTION
-        // Check this before working patterns because completion message indicates
-        // the work is done, even if working patterns are still in the rolling window
-        if (isCompletionMessage(data)) {
-            // Clear the rolling window - completion marks a transition point
-            this.clearWorkingPatternWindow();
-            this.workingDetected = false;
-            this.completionMessageTime = now;
-            this.cancelAutoAcceptTimer(); // Normal idle flow handles this
-            this.log(`Completion message detected: "${data.trim().substring(0, 50)}..."`);
-            // In watching state, start completion confirmation timer
-            if (this._state === 'watching') {
-                this.startCompletionConfirmTimer();
-                return;
-            }
-            // In waiting states, also use confirmation timer (same detection logic)
-            // This ensures we wait for Claude to finish before proceeding
-            // Note: 'watching' is already handled above and returns early
-            switch (this._state) {
-                case 'waiting_update':
-                    this.startStepConfirmTimer('update');
-                    break;
-                case 'waiting_clear':
-                    this.checkClearComplete(); // /clear is quick, no need to wait
-                    break;
-                case 'waiting_init':
-                    this.startStepConfirmTimer('init');
-                    break;
-                case 'waiting_kickstart':
-                    this.startStepConfirmTimer('kickstart');
-                    break;
-                // Non-waiting states: completion message is ignored
-                case 'confirming_idle':
-                case 'ai_checking':
-                case 'sending_update':
-                case 'sending_clear':
-                case 'sending_init':
-                case 'monitoring_init':
-                case 'sending_kickstart':
-                case 'stopped':
-                    // Completion message during these states is ignored
-                    break;
-                default:
-                    assertNever(this._state, `Unhandled RespawnState in completion detection: ${this._state}`);
-            }
+        // Layer 1: Completion message (PRIMARY) — checked before working patterns
+        if (this._detectCompletionMessage(data, now))
             return;
-        }
-        // Detect working patterns (Layer 4)
-        const isWorking = this.checkWorkingPattern(data);
-        if (isWorking) {
-            this.workingDetected = true;
-            this.promptDetected = false;
-            this.elicitationDetected = false; // Clear on new work cycle
-            this.resetHookState(); // Clear hook signals on new work
-            this.lastWorkingPatternTime = now;
-            // Cancel hook confirmation timer if running
-            this.cancelTrackedTimer('hook-confirm', 'working patterns detected');
-            // Cancel any pending completion confirmation
-            this.cancelCompletionConfirm();
-            // Cancel any pending step confirmation (Claude is still working)
-            this.cancelStepConfirm();
-            // If AI check is running, cancel it (Claude is working)
-            if (this._state === 'ai_checking') {
-                this.log('Working patterns detected during AI check, cancelling');
-                this.aiChecker.cancel();
-                this.setState('watching');
-            }
-            // Cancel plan check if running (Claude started working)
-            if (this.planChecker.status === 'checking') {
-                this.log('Working patterns detected during plan check, cancelling');
-                this.planChecker.cancel();
-            }
-            // If we're monitoring init and work started, go to watching (no kickstart needed)
-            if (this._state === 'monitoring_init') {
-                this.log('/init triggered work, skipping kickstart');
-                this.emit('stepCompleted', 'init');
-                this.completeCycle();
-            }
+        // Layer 4: Working patterns
+        if (this._detectWorkingPattern(data, now))
             return;
-        }
-        // In confirming_idle or ai_checking state, substantial output cancels the flow.
-        // This prevents false triggers when Claude pauses briefly mid-work.
+        // Substantial output during confirming_idle/ai_checking cancels the flow
         if (this._state === 'confirming_idle' || this._state === 'ai_checking') {
             // Strip ANSI escape codes to check if there's real content
             ANSI_ESCAPE_PATTERN_SIMPLE.lastIndex = 0;
@@ -888,42 +825,125 @@ export class RespawnController extends EventEmitter {
                 return;
             }
         }
-        // Legacy fallback: detect prompt characters (still useful for waiting_* states)
+        // Legacy fallback: prompt detection
+        this._detectPrompt(data);
+    }
+    _detectCompletionMessage(data, now) {
+        if (!isCompletionMessage(data))
+            return false;
+        // Clear the rolling window - completion marks a transition point
+        this.clearWorkingPatternWindow();
+        this.workingDetected = false;
+        this.completionMessageTime = now;
+        this.cancelAutoAcceptTimer(); // Normal idle flow handles this
+        this.log(`Completion message detected: "${data.trim().substring(0, 50)}..."`);
+        // In watching state, start completion confirmation timer
+        if (this._state === 'watching') {
+            this.startCompletionConfirmTimer();
+            return true;
+        }
+        // In waiting states, also use confirmation timer (same detection logic)
+        // This ensures we wait for Claude to finish before proceeding
+        // Note: 'watching' is already handled above and returns early
+        switch (this._state) {
+            case 'waiting_update':
+                this.startStepConfirmTimer('update');
+                break;
+            case 'waiting_clear':
+                this.checkClearComplete(); // /clear is quick, no need to wait
+                break;
+            case 'waiting_init':
+                this.startStepConfirmTimer('init');
+                break;
+            case 'waiting_kickstart':
+                this.startStepConfirmTimer('kickstart');
+                break;
+            // Non-waiting states: completion message is ignored
+            case 'confirming_idle':
+            case 'ai_checking':
+            case 'sending_update':
+            case 'sending_clear':
+            case 'sending_init':
+            case 'monitoring_init':
+            case 'sending_kickstart':
+            case 'stopped':
+                // Completion message during these states is ignored
+                break;
+            default:
+                assertNever(this._state, `Unhandled RespawnState in completion detection: ${this._state}`);
+        }
+        return true;
+    }
+    _detectWorkingPattern(data, now) {
+        const isWorking = this.checkWorkingPattern(data);
+        if (!isWorking)
+            return false;
+        this.workingDetected = true;
+        this.promptDetected = false;
+        this.elicitationDetected = false; // Clear on new work cycle
+        this.resetHookState(); // Clear hook signals on new work
+        this.lastWorkingPatternTime = now;
+        // Cancel hook confirmation timer if running
+        this.cancelTrackedTimer('hook-confirm', 'working patterns detected');
+        // Cancel any pending completion confirmation
+        this.cancelCompletionConfirm();
+        // Cancel any pending step confirmation (Claude is still working)
+        this.cancelStepConfirm();
+        // If AI check is running, cancel it (Claude is working)
+        if (this._state === 'ai_checking') {
+            this.log('Working patterns detected during AI check, cancelling');
+            this.aiChecker.cancel();
+            this.setState('watching');
+        }
+        // Cancel plan check if running (Claude started working)
+        if (this.planChecker.status === 'checking') {
+            this.log('Working patterns detected during plan check, cancelling');
+            this.planChecker.cancel();
+        }
+        // If we're monitoring init and work started, go to watching (no kickstart needed)
+        if (this._state === 'monitoring_init') {
+            this.log('/init triggered work, skipping kickstart');
+            this.emit('stepCompleted', 'init');
+            this.completeCycle();
+        }
+        return true;
+    }
+    _detectPrompt(data) {
         const hasPrompt = PROMPT_PATTERNS.some((pattern) => data.includes(pattern));
-        if (hasPrompt) {
-            this.promptDetected = true;
-            this.workingDetected = false;
-            // Handle legacy detection in waiting states - also use confirmation timers
-            switch (this._state) {
-                case 'waiting_update':
-                    this.startStepConfirmTimer('update');
-                    break;
-                case 'waiting_clear':
-                    this.checkClearComplete(); // /clear is quick, no need to wait
-                    break;
-                case 'waiting_init':
-                    this.startStepConfirmTimer('init');
-                    break;
-                case 'monitoring_init':
-                    this.checkMonitoringInitIdle();
-                    break;
-                case 'waiting_kickstart':
-                    this.startStepConfirmTimer('kickstart');
-                    break;
-                // Non-waiting states: prompt detection is informational only
-                case 'watching':
-                case 'confirming_idle':
-                case 'ai_checking':
-                case 'sending_update':
-                case 'sending_clear':
-                case 'sending_init':
-                case 'sending_kickstart':
-                case 'stopped':
-                    // Prompt detection during these states doesn't trigger action
-                    break;
-                default:
-                    assertNever(this._state, `Unhandled RespawnState in prompt detection: ${this._state}`);
-            }
+        if (!hasPrompt)
+            return;
+        this.promptDetected = true;
+        this.workingDetected = false;
+        // Handle legacy detection in waiting states - also use confirmation timers
+        switch (this._state) {
+            case 'waiting_update':
+                this.startStepConfirmTimer('update');
+                break;
+            case 'waiting_clear':
+                this.checkClearComplete(); // /clear is quick, no need to wait
+                break;
+            case 'waiting_init':
+                this.startStepConfirmTimer('init');
+                break;
+            case 'monitoring_init':
+                this.checkMonitoringInitIdle();
+                break;
+            case 'waiting_kickstart':
+                this.startStepConfirmTimer('kickstart');
+                break;
+            // Non-waiting states: prompt detection is informational only
+            case 'watching':
+            case 'confirming_idle':
+            case 'ai_checking':
+            case 'sending_update':
+            case 'sending_clear':
+            case 'sending_init':
+            case 'sending_kickstart':
+            case 'stopped':
+                // Prompt detection during these states doesn't trigger action
+                break;
+            default:
+                assertNever(this._state, `Unhandled RespawnState in prompt detection: ${this._state}`);
         }
     }
     /**
@@ -1167,23 +1187,26 @@ export class RespawnController extends EventEmitter {
             case 'sending_init':
             case 'sending_kickstart':
                 // For sending states, retry the send
-                this.log('Recovery: returning to watching state');
-                this.setState('watching');
-                this.startNoOutputTimer();
-                this.startPreFilterTimer();
-                if (this.config.autoAcceptPrompts) {
-                    this.startAutoAcceptTimer();
-                }
+                this.recoveryResetToWatching('returning to watching state');
                 break;
             default:
                 // Fallback: reset to watching
-                this.log('Recovery: fallback to watching state');
-                this.setState('watching');
-                this.startNoOutputTimer();
-                this.startPreFilterTimer();
-                if (this.config.autoAcceptPrompts) {
-                    this.startAutoAcceptTimer();
-                }
+                this.recoveryResetToWatching('fallback to watching state');
+        }
+    }
+    /**
+     * Reset the controller to watching state during stuck-state recovery.
+     * Sets state to watching and restarts all detection timers.
+     *
+     * @param reason - Human-readable reason for the reset (logged)
+     */
+    recoveryResetToWatching(reason) {
+        this.log(`Recovery: ${reason}`);
+        this.setState('watching');
+        this.startNoOutputTimer();
+        this.startPreFilterTimer();
+        if (this.config.autoAcceptPrompts) {
+            this.startAutoAcceptTimer();
         }
     }
     /**
@@ -1372,7 +1395,7 @@ export class RespawnController extends EventEmitter {
         }
         // If on cooldown, don't start check - wait for cooldown to expire
         if (this.aiChecker.isOnCooldown()) {
-            this.log(`AI check on cooldown (${Math.ceil(this.aiChecker.getCooldownRemainingMs() / 1000)}s remaining), waiting...`);
+            this.log(`AI check on cooldown (${formatRemainingSeconds(this.aiChecker.getCooldownRemainingMs())}s remaining), waiting...`);
             return;
         }
         // If already checking, don't start another
@@ -1448,7 +1471,7 @@ export class RespawnController extends EventEmitter {
             if (this._state === 'stopped')
                 return; // Guard against stopped state
             if (this._state === 'ai_checking') {
-                const errorMsg = err instanceof Error ? err.message : String(err);
+                const errorMsg = getErrorMessage(err);
                 this.logAction('ai-check', `Failed: ${errorMsg.substring(0, 50)}`);
                 this.emit('aiCheckFailed', errorMsg);
                 this.setState('watching');
@@ -1500,33 +1523,13 @@ export class RespawnController extends EventEmitter {
      * @fires planCheckStarted
      */
     tryAutoAccept() {
-        // Only auto-accept in watching state (not during a respawn cycle)
-        if (this._state !== 'watching')
+        if (!this.canAutoAccept())
             return;
-        // Don't auto-accept if a completion message was detected (normal idle handles it)
-        if (this.completionMessageTime !== null)
-            return;
-        // Don't auto-accept if disabled
-        if (!this.config.autoAcceptPrompts)
-            return;
-        // Don't auto-accept if we haven't received any output yet (prevents spurious Enter on fresh start)
-        if (!this.hasReceivedOutput)
-            return;
-        // Don't auto-accept if an elicitation dialog (AskUserQuestion) was detected
-        if (this.elicitationDetected) {
-            this.log('Skipping auto-accept: elicitation dialog detected (AskUserQuestion)');
-            return;
-        }
-        // Stage 1: Pre-filter — check if buffer looks like plan mode
         const buffer = this.terminalBuffer.value;
-        if (!this.isPlanModePreFilterMatch(buffer)) {
-            this.log('Skipping auto-accept: pre-filter did not match plan mode patterns');
-            return;
-        }
         // Stage 2: AI confirmation (if enabled and available)
         if (this.config.aiPlanCheckEnabled && this.planChecker.status !== 'disabled') {
             if (this.planChecker.isOnCooldown()) {
-                this.log(`Skipping auto-accept: plan checker on cooldown (${Math.ceil(this.planChecker.getCooldownRemainingMs() / 1000)}s remaining)`);
+                this.log(`Skipping auto-accept: plan checker on cooldown (${formatRemainingSeconds(this.planChecker.getCooldownRemainingMs())}s remaining)`);
                 return;
             }
             if (this.planChecker.status === 'checking') {
@@ -1540,6 +1543,37 @@ export class RespawnController extends EventEmitter {
         // AI plan check disabled — pre-filter passed, send Enter directly
         this.sendAutoAcceptEnter();
     }
+    /**
+     * Check whether all preconditions for auto-accept are met.
+     * Validates state, config, and pre-filter conditions before attempting auto-accept.
+     *
+     * @returns True if auto-accept should proceed to the AI confirmation stage
+     */
+    canAutoAccept() {
+        // Only auto-accept in watching state (not during a respawn cycle)
+        if (this._state !== 'watching')
+            return false;
+        // Don't auto-accept if a completion message was detected (normal idle handles it)
+        if (this.completionMessageTime !== null)
+            return false;
+        // Don't auto-accept if disabled
+        if (!this.config.autoAcceptPrompts)
+            return false;
+        // Don't auto-accept if we haven't received any output yet (prevents spurious Enter on fresh start)
+        if (!this.hasReceivedOutput)
+            return false;
+        // Don't auto-accept if an elicitation dialog (AskUserQuestion) was detected
+        if (this.elicitationDetected) {
+            this.log('Skipping auto-accept: elicitation dialog detected (AskUserQuestion)');
+            return false;
+        }
+        // Stage 1: Pre-filter — check if buffer looks like plan mode
+        if (!this.isPlanModePreFilterMatch(this.terminalBuffer.value)) {
+            this.log('Skipping auto-accept: pre-filter did not match plan mode patterns');
+            return false;
+        }
+        return true;
+    }
     /**
      * Check if the terminal buffer matches plan mode pre-filter patterns.
      * Only checks the last 2000 chars (plan mode UI appears at the bottom).
@@ -1615,7 +1649,7 @@ export class RespawnController extends EventEmitter {
             }
         })
             .catch((err) => {
-            const errorMsg = err instanceof Error ? err.message : String(err);
+            const errorMsg = getErrorMessage(err);
             this.emit('planCheckFailed', errorMsg);
             this.logAction('plan-check', `Failed: ${errorMsg.substring(0, 50)}`);
         });