pm-orchestrator-runner 1.0.5 → 1.0.7

package/dist/repl/repl-interface.js

@@ -117,6 +117,9 @@ class REPLInterface extends events_1.EventEmitter {
     hasIncompleteTasks = false;
     // Session completion tracking (prevents double completion)
     sessionCompleted = false;
+    // Non-blocking task queue (allows input while tasks are running)
+    taskQueue = [];
+    isTaskWorkerRunning = false;
     // Project mode support (per spec 10_REPL_UX.md, Property 32, 33)
     projectMode;
     verificationRoot;
@@ -193,6 +196,8 @@ class REPLInterface extends events_1.EventEmitter {
             runner: null,
             supervisor: null,
             status: 'idle',
+            current_task_id: null,
+            last_task_id: null,
         };
         // Initialize command handlers
         this.initCommand = new init_1.InitCommand();
@@ -229,8 +234,12 @@ class REPLInterface extends events_1.EventEmitter {
             await this.initializeTempProjectRoot();
         }
         // Output PROJECT_PATH if requested (per spec 10_REPL_UX.md)
+        // Emit 'output' event for programmatic access (tests, wrappers)
+        // Also print to stdout for shell script parsing
         if (this.config.printProjectPath) {
-            console.log('PROJECT_PATH=' + this.verificationRoot);
+            const projectPathLine = 'PROJECT_PATH=' + this.verificationRoot;
+            this.emit('output', projectPathLine);
+            console.log(projectPathLine);
         }
     }
     /**
@@ -611,27 +620,50 @@ class REPLInterface extends events_1.EventEmitter {
         }
     }
     /**
-     * Process natural language input
+     * Check if input is a bare "exit" typo (should use /exit)
+     * Per spec 10_REPL_UX.md: Exit Typo Safety
+     * Pattern: ^exit\s*$ (case-insensitive, trimmed)
+     */
+    isExitTypo(input) {
+        const trimmed = input.trim().toLowerCase();
+        return trimmed === 'exit';
+    }
+    /**
+     * Process natural language input - NON-BLOCKING
      * Per spec 10_REPL_UX.md L117-118: Model selection is REPL-local
      * Model is read from .claude/repl.json and passed to executor via runner
      *
+     * Non-blocking design:
+     * - Creates task and adds to queue immediately
+     * - Returns control to input prompt right away
+     * - Background worker processes tasks asynchronously
+     *
      * Auto-start: In non-interactive mode, automatically start a session if none exists
      * This improves CLI usability for piped input and scripting
+     *
+     * Exit Typo Safety (per spec 10_REPL_UX.md):
+     * - Detects bare "exit" input (without slash)
+     * - Shows error and suggests /exit
+     * - Never passes "exit" to Claude Code
      */
     async processNaturalLanguage(input) {
         console.log(`[DEBUG processNaturalLanguage] start, input="${input}"`);
+        // Exit Typo Safety: Block bare "exit" input
+        // Per spec 10_REPL_UX.md: fail-closed - 2 lines max, return to input
+        if (this.isExitTypo(input)) {
+            this.print('ERROR: Did you mean /exit?');
+            this.print('HINT: /exit');
+            return;
+        }
+        // Auto-start session for any natural language input (no /start required)
+        // Per redesign: natural language input = automatic task creation
         if (this.session.status !== 'running') {
-            // In non-interactive mode, auto-start a session for better UX
-            if (this.executionMode === 'non_interactive') {
-                console.log('[DEBUG processNaturalLanguage] auto-starting session for non-interactive mode');
-                const startResult = await this.handleStart([]);
-                if (!startResult.success) {
-                    this.print('Failed to auto-start session: ' + (startResult.error?.message || 'Unknown error'));
-                    return;
-                }
-            }
-            else {
-                this.print('No active session. Use /start to begin, or /init to set up a new project.');
+            console.log('[DEBUG processNaturalLanguage] auto-starting session');
+            this.print('');
+            this.print('[Auto-starting session...]');
+            const startResult = await this.handleStart([]);
+            if (!startResult.success) {
+                this.print('Failed to auto-start session: ' + (startResult.error?.message || 'Unknown error'));
                 return;
             }
         }
@@ -639,46 +671,150 @@ class REPLInterface extends events_1.EventEmitter {
             this.print('Runner not initialized. Use /start first.');
             return;
         }
-        this.print('Processing task: ' + input);
+        // Generate task ID
+        // Per spec 05_DATA_MODELS.md Property 38
+        const taskId = 'task-' + Date.now();
+        // Create queued task
+        const queuedTask = {
+            id: taskId,
+            description: input,
+            state: 'QUEUED',
+            queuedAt: Date.now(),
+            startedAt: null,
+            completedAt: null,
+        };
+        // Add to task queue
+        this.taskQueue.push(queuedTask);
+        // Display task queued info (per redesign: visibility)
+        // Per user requirement: Provider/Mode/Auth must be shown at task start
+        this.print('');
+        this.print('--- Task Queued ---');
+        this.print('Task ID: ' + taskId);
+        this.print('State: QUEUED');
+        // Show LLM layer info (Provider/Mode/Auth) - per redesign requirement
+        if (this.config.authMode === 'claude-code') {
+            this.print('Provider: Claude Code CLI (uses your Claude subscription, no API key required)');
+        }
+        else if (this.config.authMode === 'api-key') {
+            this.print('Provider: Anthropic API (API key configured)');
+        }
+        else {
+            this.print('Provider: ' + this.config.authMode);
+        }
+        // Show prompt summary (first 100 chars)
+        const promptSummary = input.length > 100 ? input.substring(0, 100) + '...' : input;
+        this.print('Prompt: ' + promptSummary);
+        this.print('-------------------');
         this.print('');
+        this.print('(Input is not blocked - you can submit more tasks with /tasks to view status)');
+        this.print('');
+        // Start background worker if not running
+        // The worker runs asynchronously - we don't await it
+        if (!this.isTaskWorkerRunning) {
+            this.startTaskWorker();
+        }
+        console.log(`[DEBUG processNaturalLanguage] task queued, returning immediately`);
+    }
+    /**
+     * Background task worker - processes queued tasks asynchronously
+     * Runs in background, allowing input to continue while tasks execute
+     */
+    async startTaskWorker() {
+        if (this.isTaskWorkerRunning) {
+            return;
+        }
+        this.isTaskWorkerRunning = true;
+        console.log('[DEBUG startTaskWorker] worker started');
+        try {
+            while (this.running) {
+                // Find next QUEUED task
+                const nextTask = this.taskQueue.find(t => t.state === 'QUEUED');
+                if (!nextTask) {
+                    // No more queued tasks - worker exits
+                    break;
+                }
+                // Execute the task
+                await this.executeQueuedTask(nextTask);
+            }
+        }
+        finally {
+            this.isTaskWorkerRunning = false;
+            console.log('[DEBUG startTaskWorker] worker stopped');
+        }
+    }
+    /**
+     * Execute a single queued task
+     * Updates task state and prints results
+     */
+    async executeQueuedTask(task) {
+        console.log(`[DEBUG executeQueuedTask] starting task ${task.id}`);
+        // Update state to RUNNING
+        task.state = 'RUNNING';
+        task.startedAt = Date.now();
+        this.session.current_task_id = task.id;
+        // Print status update
+        this.print('');
+        this.print('--- Task Started ---');
+        this.print('Task ID: ' + task.id);
+        this.print('State: RUNNING');
+        this.print('--------------------');
         try {
             // Per spec 10_REPL_UX.md L117-118: Get selected model from REPL config
-            // Model is REPL-local, stored in .claude/repl.json
             let selectedModel;
             const modelResult = await this.modelCommand.getModel(this.session.projectPath);
             if (modelResult.success && modelResult.model && modelResult.model !== 'UNSET') {
                 selectedModel = modelResult.model;
             }
-            console.log(`[DEBUG processNaturalLanguage] calling runner.execute...`);
-            // Create task from natural language input
-            // CRITICAL: naturalLanguageTask must be set to trigger Claude Code execution
-            // Without this, the task would only use fallback file creation patterns
+            console.log(`[DEBUG executeQueuedTask] calling runner.execute...`);
             const result = await this.session.runner.execute({
                 tasks: [{
-                        id: 'task-' + Date.now(),
-                        description: input,
-                        naturalLanguageTask: input,
+                        id: task.id,
+                        description: task.description,
+                        naturalLanguageTask: task.description,
                     }],
                 selectedModel,
             });
-            console.log(`[DEBUG processNaturalLanguage] runner.execute returned, status=${result.overall_status}`);
-            // Handle INCOMPLETE with clarification interactively
+            console.log(`[DEBUG executeQueuedTask] runner.execute returned, status=${result.overall_status}`);
+            // Update task state based on result
+            task.completedAt = Date.now();
+            task.resultStatus = result.overall_status;
+            task.filesModified = result.files_modified;
+            task.responseSummary = result.executor_output_summary;
+            switch (result.overall_status) {
+                case enums_1.OverallStatus.COMPLETE:
+                    task.state = 'COMPLETE';
+                    break;
+                case enums_1.OverallStatus.INCOMPLETE:
+                    task.state = 'INCOMPLETE';
+                    break;
+                case enums_1.OverallStatus.ERROR:
+                    task.state = 'ERROR';
+                    task.errorMessage = result.error?.message;
+                    break;
+                default:
+                    task.state = 'COMPLETE';
+            }
+            // Handle INCOMPLETE with clarification (but don't block)
             if (result.overall_status === enums_1.OverallStatus.INCOMPLETE &&
                 result.incomplete_task_reasons &&
                 result.incomplete_task_reasons.length > 0) {
-                const clarificationNeeded = await this.handleClarificationNeeded(input, result.incomplete_task_reasons);
-                if (clarificationNeeded) {
-                    // User provided clarification, will be processed in next input
-                    return;
-                }
+                await this.handleClarificationNeeded(task.description, result.incomplete_task_reasons);
             }
             this.printExecutionResult(result);
         }
         catch (err) {
-            console.log(`[DEBUG processNaturalLanguage] error: ${err.message}`);
+            console.log(`[DEBUG executeQueuedTask] error: ${err.message}`);
+            task.state = 'ERROR';
+            task.completedAt = Date.now();
+            task.errorMessage = err.message;
             this.printError(err);
         }
-        console.log(`[DEBUG processNaturalLanguage] done`);
+        finally {
+            // Clear current_task_id
+            this.session.last_task_id = this.session.current_task_id;
+            this.session.current_task_id = null;
+        }
+        console.log(`[DEBUG executeQueuedTask] task ${task.id} done, state=${task.state}`);
     }
     /**
      * Handle clarification needed - prompt user interactively
@@ -1028,7 +1164,8 @@ class REPLInterface extends events_1.EventEmitter {
             // /logs <task-id> [--full]
             const taskId = args[0];
             const full = args.includes('--full');
-            const result = await this.logsCommand.getTaskDetail(this.session.projectPath, taskId, full);
+            // Per redesign: Pass sessionId for visibility fields
+            const result = await this.logsCommand.getTaskDetail(this.session.projectPath, taskId, full, this.session.sessionId ?? undefined);
             if (result.success) {
                 this.print(result.output || 'No log detail found.');
                 return { success: true };
@@ -1041,10 +1178,78 @@ class REPLInterface extends events_1.EventEmitter {
     }
     /**
      * Handle /tasks command
+     * Shows task queue with RUNNING/QUEUED/COMPLETE/ERROR/INCOMPLETE states
+     * Per redesign: proves non-blocking by showing multiple tasks simultaneously
      */
     async handleTasks() {
-        const result = await this.statusCommands.getTasks();
-        this.print(result);
+        this.print('');
+        this.print('=== Task Queue ===');
+        this.print('');
+        if (this.taskQueue.length === 0) {
+            this.print('No tasks in queue.');
+            this.print('');
+            // Also show legacy tasks from statusCommands if available
+            const legacyResult = await this.statusCommands.getTasks();
+            if (legacyResult && legacyResult.trim()) {
+                this.print('--- Session Tasks ---');
+                this.print(legacyResult);
+            }
+            return;
+        }
+        // Count by state
+        const running = this.taskQueue.filter(t => t.state === 'RUNNING').length;
+        const queued = this.taskQueue.filter(t => t.state === 'QUEUED').length;
+        const complete = this.taskQueue.filter(t => t.state === 'COMPLETE').length;
+        const incomplete = this.taskQueue.filter(t => t.state === 'INCOMPLETE').length;
+        const error = this.taskQueue.filter(t => t.state === 'ERROR').length;
+        this.print('Summary: ' + running + ' RUNNING, ' + queued + ' QUEUED, ' + complete + ' COMPLETE, ' + incomplete + ' INCOMPLETE, ' + error + ' ERROR');
+        this.print('');
+        // List all tasks with state
+        for (const task of this.taskQueue) {
+            const promptSummary = task.description.length > 50
+                ? task.description.substring(0, 50) + '...'
+                : task.description;
+            let durationStr = '';
+            if (task.startedAt) {
+                const endTime = task.completedAt || Date.now();
+                const durationMs = endTime - task.startedAt;
+                durationStr = ' (' + (durationMs / 1000).toFixed(1) + 's)';
+            }
+            // State indicator with visual marker
+            let stateMarker = '';
+            switch (task.state) {
+                case 'RUNNING':
+                    stateMarker = '[*]';
+                    break;
+                case 'QUEUED':
+                    stateMarker = '[ ]';
+                    break;
+                case 'COMPLETE':
+                    stateMarker = '[v]';
+                    break;
+                case 'INCOMPLETE':
+                    stateMarker = '[!]';
+                    break;
+                case 'ERROR':
+                    stateMarker = '[X]';
+                    break;
+            }
+            this.print(stateMarker + ' ' + task.id + ' | ' + task.state + durationStr);
+            this.print('    ' + promptSummary);
+            // Show error message if error
+            if (task.state === 'ERROR' && task.errorMessage) {
+                this.print('    Error: ' + task.errorMessage);
+            }
+            // Show files modified if complete
+            if (task.state === 'COMPLETE' && task.filesModified && task.filesModified.length > 0) {
+                this.print('    Files: ' + task.filesModified.slice(0, 3).join(', ') +
+                    (task.filesModified.length > 3 ? ' (+' + (task.filesModified.length - 3) + ' more)' : ''));
+            }
+        }
+        this.print('');
+        this.print('Use /logs <task-id> for details.');
+        this.print('==================');
+        this.print('');
     }
     /**
      * Handle /status command
@@ -1175,6 +1380,7 @@ class REPLInterface extends events_1.EventEmitter {
      * Per spec 10_REPL_UX.md: Ensure clean exit with flushed output
      *
      * Guarantees:
+     * - Waits for running tasks to complete (task worker)
      * - Session state is persisted before exit
      * - All output is flushed before readline closes
      * - Double-completion is prevented via sessionCompleted flag
@@ -1188,6 +1394,18 @@ class REPLInterface extends events_1.EventEmitter {
             return;
         }
         this.sessionCompleted = true;
+        // Wait for task worker to complete any running tasks
+        if (this.isTaskWorkerRunning) {
+            const runningTasks = this.taskQueue.filter(t => t.state === 'RUNNING');
+            const queuedTasks = this.taskQueue.filter(t => t.state === 'QUEUED');
+            if (runningTasks.length > 0 || queuedTasks.length > 0) {
+                this.print('Waiting for ' + runningTasks.length + ' running and ' + queuedTasks.length + ' queued tasks to complete...');
+            }
+            while (this.isTaskWorkerRunning) {
+                await new Promise(r => setTimeout(r, 100));
+            }
+            this.print('All tasks completed.');
+        }
         this.print('Saving session state...');
         if (this.session.runner && this.session.sessionId) {
             try {
@@ -1215,14 +1433,102 @@ class REPLInterface extends events_1.EventEmitter {
         this.running = false;
         this.rl?.close();
     }
+    /**
+     * Map OverallStatus to TaskLogStatus
+     * Per spec 05_DATA_MODELS.md: Terminal states are complete/incomplete/error
+     */
+    mapToTaskLogStatus(status) {
+        switch (status) {
+            case enums_1.OverallStatus.COMPLETE:
+                return 'complete';
+            case enums_1.OverallStatus.INCOMPLETE:
+                return 'incomplete';
+            case enums_1.OverallStatus.ERROR:
+                return 'error';
+            default:
+                return 'running';
+        }
+    }
+    /**
+     * Check if status is terminal
+     * Per spec 05_DATA_MODELS.md: Terminal states are complete/incomplete/error
+     */
+    isTerminalStatus(status) {
+        return status === 'complete' || status === 'incomplete' || status === 'error';
+    }
+    /**
+     * Print immediate summary block
+     * Per spec 10_REPL_UX.md: Immediate Summary Output
+     *
+     * COMPLETE (4 lines fixed):
+     *   RESULT: COMPLETE / TASK / NEXT: (none) / HINT
+     *
+     * INCOMPLETE/ERROR (5 lines fixed, WHY required):
+     *   RESULT / TASK / NEXT: /logs <id> / WHY / HINT
+     */
+    printImmediateSummary(taskId, status, reason) {
+        if (!this.isTerminalStatus(status)) {
+            return;
+        }
+        this.print('RESULT: ' + status.toUpperCase());
+        this.print('TASK: ' + taskId);
+        if (status === 'complete') {
+            // COMPLETE: 4 lines fixed, no WHY
+            this.print('NEXT: (none)');
+        }
+        else {
+            // INCOMPLETE/ERROR: 5 lines fixed, WHY required
+            this.print('NEXT: /logs ' + taskId);
+            this.print('WHY: ' + (reason && reason.trim() ? reason : '(unknown)'));
+        }
+        this.print('HINT: /logs ' + taskId);
+    }
     /**
      * Print execution result
      * Per spec 10_REPL_UX.md: Error details must be visible for fail-closed debugging
+     * Also prints Immediate Summary for terminal states (per Property 39)
      */
     printExecutionResult(result) {
+        // Get task ID from session tracking
+        const taskId = this.session.current_task_id || this.session.last_task_id || 'unknown';
+        // Map to TaskLogStatus
+        const taskLogStatus = this.mapToTaskLogStatus(result.overall_status);
+        // Update current_task_id / last_task_id on terminal state
+        // Per spec 05_DATA_MODELS.md Property 38
+        if (this.isTerminalStatus(taskLogStatus)) {
+            this.session.last_task_id = this.session.current_task_id;
+            this.session.current_task_id = null;
+        }
+        // Generate reason from result
+        let reason;
+        if (result.error) {
+            reason = result.error.message;
+        }
+        else if (result.incomplete_task_reasons && result.incomplete_task_reasons.length > 0) {
+            reason = result.incomplete_task_reasons[0].reason;
+        }
+        else if (result.overall_status === enums_1.OverallStatus.COMPLETE) {
+            reason = 'タスクが正常に完了しました';
+        }
+        else {
+            reason = '状態: ' + result.overall_status;
+        }
+        // Print Immediate Summary for terminal states (per Property 39)
+        if (this.isTerminalStatus(taskLogStatus)) {
+            this.printImmediateSummary(taskId, taskLogStatus, reason);
+        }
         this.print('');
         this.print('--- Execution Result ---');
         this.print('Status: ' + result.overall_status);
+        // Display executor mode (per redesign: visibility)
+        if (result.executor_mode) {
+            this.print('Executor: ' + result.executor_mode);
+        }
+        // Display duration (per redesign: visibility)
+        if (result.duration_ms !== undefined && result.duration_ms > 0) {
+            const seconds = (result.duration_ms / 1000).toFixed(1);
+            this.print('Duration: ' + seconds + 's');
+        }
         if (result.tasks_completed !== undefined) {
             this.print('Tasks: ' + result.tasks_completed + '/' + result.tasks_total + ' completed');
             // Track incomplete tasks for exit code (non-interactive mode)
@@ -1231,8 +1537,23 @@ class REPLInterface extends events_1.EventEmitter {
                 this.updateExitCode();
             }
         }
+        // Display files modified (per redesign: visibility)
+        if (result.files_modified && result.files_modified.length > 0) {
+            this.print('');
+            this.print('Files Modified:');
+            for (const file of result.files_modified) {
+                this.print('  - ' + file);
+            }
+        }
+        // Display executor output summary (per redesign: visibility)
+        if (result.executor_output_summary) {
+            this.print('');
+            this.print('Response Summary:');
+            this.print('  ' + result.executor_output_summary);
+        }
         // Display error details when status is ERROR (critical for debugging fail-closed behavior)
         if (result.error) {
+            this.print('');
             this.print('Error: ' + result.error.message);
             if (result.error.code) {
                 this.print('Error Code: ' + result.error.code);
@@ -1243,6 +1564,7 @@ class REPLInterface extends events_1.EventEmitter {
         }
         // Display incomplete task reasons (helps identify why tasks failed)
         if (result.incomplete_task_reasons && result.incomplete_task_reasons.length > 0) {
+            this.print('');
             this.print('Incomplete Tasks:');
             for (const reason of result.incomplete_task_reasons) {
                 this.print('  - ' + reason.task_id + ': ' + reason.reason);
@@ -1260,6 +1582,16 @@ class REPLInterface extends events_1.EventEmitter {
             this.hasIncompleteTasks = true;
             this.updateExitCode();
         }
+        // NO_EVIDENCE handling: show next action hint (per redesign requirement)
+        // Per user requirement: NO_EVIDENCE should not complete silently
+        if (result.overall_status === enums_1.OverallStatus.NO_EVIDENCE) {
+            this.print('');
+            this.print('HINT: No file changes were verified for this task.');
+            this.print('  Possible next actions:');
+            this.print('    - Check /logs for execution details');
+            this.print('    - Retry with more specific instructions');
+            this.print('    - Use /status to see current session state');
+        }
         if (result.next_action !== undefined) {
             this.print('Next Action: ' + (result.next_action ? 'Yes' : 'No'));
             if (result.next_action_reason) {