wiggum-cli 0.12.1 → 0.13.1

package/dist/tui/screens/InterviewScreen.js

@@ -1,4 +1,4 @@
-import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 /**
  * InterviewScreen - Main screen for the /new command interview flow
  *
@@ -8,55 +8,54 @@ import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-run
  * 2. Goals - Understand what to build
  * 3. Interview - Clarifying questions
  * 4. Generation - Generate the specification
+ * 5. Complete - Show summary and return to shell
+ *
+ * Wrapped in AppShell for consistent layout. On completion,
+ * shows SpecCompletionSummary inline before returning to shell.
  */
 import { useEffect, useCallback, useRef, useState } from 'react';
 import { Box, Text, useInput } from 'ink';
-import { FooterStatusBar } from '../components/FooterStatusBar.js';
+import { logger } from '../../utils/logger.js';
 import { MessageList } from '../components/MessageList.js';
-import { WorkingIndicator } from '../components/WorkingIndicator.js';
 import { ChatInput } from '../components/ChatInput.js';
 import { MultiSelect } from '../components/MultiSelect.js';
+import { AppShell } from '../components/AppShell.js';
+import { SpecCompletionSummary } from '../components/SpecCompletionSummary.js';
 import { useSpecGenerator, PHASE_CONFIGS, TOTAL_DISPLAY_PHASES, } from '../hooks/useSpecGenerator.js';
 import { InterviewOrchestrator } from '../orchestration/interview-orchestrator.js';
-import { theme } from '../theme.js';
+import { theme, phase } from '../theme.js';
 import { loadContext, toScanResultFromPersisted, getContextAge, } from '../../context/index.js';
+import { join } from 'node:path';
 import { initTracing, flushTracing } from '../../utils/tracing.js';
 import { resolveOptionLabels } from '../types/interview.js';
 /**
  * InterviewScreen component
  *
  * The main screen for the /new command interview flow. Combines all TUI
- * components (MessageList, WorkingIndicator, ChatInput, MultiSelect,
- * FooterStatusBar) to create the complete interview experience.
- *
- * Uses the useSpecGenerator hook for state and InterviewOrchestrator
- * to bridge to the AI conversation.
+ * components within an AppShell layout.
  */
-export function InterviewScreen({ featureName, projectRoot, provider, model, scanResult, specsPath = '.ralph/specs', onComplete, onCancel, }) {
+export function InterviewScreen({ header, featureName, projectRoot, provider, model, scanResult, specsPath = '.ralph/specs', onComplete, onCancel, }) {
     const { state, initialize, addMessage, addStreamingMessage, updateStreamingMessage, completeStreamingMessage, startToolCall, completeToolCall, setPhase, setGeneratedSpec, setError, setWorking, setReady, } = useSpecGenerator();
-    // Track orchestrator instance
     const orchestratorRef = useRef(null);
-    // Track if we're in streaming mode for the current message
     const isStreamingRef = useRef(false);
     const streamContentRef = useRef('');
-    // Track if we're in generation phase (more reliable than checking orchestrator)
     const isGeneratingRef = useRef(false);
-    // Track if component is unmounted to prevent callbacks after cleanup
     const isCancelledRef = useRef(false);
-    // Use refs for callbacks and state to avoid stale closures
     const onCompleteRef = useRef(onComplete);
     onCompleteRef.current = onComplete;
-    // Track messages in ref for access in callbacks
     const messagesRef = useRef(state.messages);
     messagesRef.current = state.messages;
-    // State for tool call expansion (Ctrl+O toggle)
     const [toolCallsExpanded, setToolCallsExpanded] = useState(false);
-    // State for multi-select interview questions (null = free-text mode)
     const [currentQuestion, setCurrentQuestion] = useState(null);
-    // Initialize Braintrust tracing for this interview session.
-    // flushTracing is fire-and-forget (void) to avoid blocking TUI shutdown.
+    // Completion state: when spec is done, show summary inline
+    const [completionData, setCompletionData] = useState(null);
     useEffect(() => {
-        initTracing();
+        try {
+            initTracing();
+        }
+        catch (err) {
+            logger.error(`Failed to init tracing: ${err instanceof Error ? err.message : String(err)}`);
+        }
         return () => {
             void flushTracing();
         };
@@ -70,17 +69,13 @@ export function InterviewScreen({ featureName, projectRoot, provider, model, sca
             provider,
             model,
         });
-        // Async IIFE to allow loading persisted context
         (async () => {
-            // Determine session context: use scanResult prop if available,
-            // otherwise try loading persisted context from disk
             let resolvedScanResult = scanResult;
             let resolvedSessionContext;
             if (!scanResult) {
                 try {
                     const persisted = await loadContext(projectRoot);
                     if (persisted) {
-                        // Map persisted AI analysis to SessionContext
                         resolvedSessionContext = {
                             entryPoints: persisted.aiAnalysis.projectContext?.entryPoints,
                             keyDirectories: persisted.aiAnalysis.projectContext?.keyDirectories,
@@ -89,16 +84,15 @@ export function InterviewScreen({ featureName, projectRoot, provider, model, sca
                             implementationGuidelines: persisted.aiAnalysis.implementationGuidelines,
                             keyPatterns: persisted.aiAnalysis.technologyPractices?.practices,
                         };
-                        // Rehydrate a minimal scan result for Project Tech Stack context
                         resolvedScanResult = toScanResultFromPersisted(persisted.scanResult, projectRoot);
                         const { human } = getContextAge(persisted);
                         addMessage('system', `Using cached project context from .ralph/.context.json (updated ${human} ago). Run /sync to refresh.`);
                     }
                 }
                 catch (err) {
-                    // Show error but continue without context
                     if (!isCancelledRef.current) {
-                        addMessage('system', `Unable to load cached project context; continuing without it.`);
+                        const reason = err instanceof Error ? err.message : String(err);
+                        addMessage('system', `Unable to load cached project context (${reason}); continuing without it.`);
                     }
                 }
             }
@@ -160,7 +154,9 @@ export function InterviewScreen({ featureName, projectRoot, provider, model, sca
                     if (isCancelledRef.current)
                         return;
                     setGeneratedSpec(spec);
-                    onCompleteRef.current(spec, messagesRef.current);
+                    // Show completion summary inline instead of navigating away immediately
+                    const specFilePath = join(projectRoot, specsPath, `${featureName}.md`);
+                    setCompletionData({ spec, specPath: specFilePath });
                 },
                 onError: (error) => {
                     if (isCancelledRef.current)
@@ -184,114 +180,153 @@ export function InterviewScreen({ featureName, projectRoot, provider, model, sca
                 },
             });
             orchestratorRef.current = orchestrator;
-            orchestrator.start();
-        })();
+            try {
+                orchestrator.start();
+            }
+            catch (err) {
+                if (!isCancelledRef.current) {
+                    const reason = err instanceof Error ? err.message : String(err);
+                    logger.error(`Orchestrator start failed: ${reason}`);
+                    setError(reason);
+                }
+            }
+        })().catch((err) => {
+            if (!isCancelledRef.current) {
+                const reason = err instanceof Error ? err.message : String(err);
+                logger.error(`Interview initialization failed: ${reason}`);
+                setError(reason);
+            }
+        });
         return () => {
             isCancelledRef.current = true;
             orchestratorRef.current = null;
         };
-    }, [featureName, projectRoot, provider, model, scanResult]);
-    // Handle user input submission based on current phase
+    }, [featureName, projectRoot, provider, model, scanResult, specsPath]);
     const handleSubmit = useCallback(async (value) => {
-        const orchestrator = orchestratorRef.current;
-        if (!orchestrator)
-            return;
-        // Add user message to display
-        if (value) {
-            addMessage('user', value);
+        try {
+            const orchestrator = orchestratorRef.current;
+            if (!orchestrator) {
+                logger.debug('Interview submit ignored: orchestrator not ready yet');
+                return;
+            }
+            if (value) {
+                addMessage('user', value);
+            }
+            const currentPhase = orchestrator.getPhase();
+            switch (currentPhase) {
+                case 'context':
+                    if (value) {
+                        await orchestrator.addReference(value);
+                    }
+                    else {
+                        await orchestrator.advanceToGoals();
+                    }
+                    break;
+                case 'goals':
+                    await orchestrator.submitGoals(value);
+                    break;
+                case 'interview':
+                    if (value.toLowerCase() === 'done' || value.toLowerCase() === 'skip') {
+                        await orchestrator.skipToGeneration();
+                    }
+                    else {
+                        const answer = {
+                            mode: 'freeText',
+                            questionId: currentQuestion?.id || '',
+                            text: value,
+                        };
+                        await orchestrator.submitAnswer(answer);
+                    }
+                    break;
+                default:
+                    break;
+            }
         }
-        const currentPhase = orchestrator.getPhase();
-        switch (currentPhase) {
-            case 'context':
-                if (value) {
-                    // User entered a reference URL/path
-                    await orchestrator.addReference(value);
-                }
-                else {
-                    // Empty input = done with context, advance to goals
-                    await orchestrator.advanceToGoals();
-                }
-                break;
-            case 'goals':
-                // User entered their goals
-                await orchestrator.submitGoals(value);
-                break;
-            case 'interview':
-                if (value.toLowerCase() === 'done' || value.toLowerCase() === 'skip') {
-                    // Skip to generation
-                    await orchestrator.skipToGeneration();
-                }
-                else {
-                    // Submit free-text answer
-                    const answer = {
-                        mode: 'freeText',
-                        questionId: currentQuestion?.id || '',
-                        text: value,
-                    };
-                    await orchestrator.submitAnswer(answer);
-                }
-                break;
-            default:
-                // In generation or complete phase, ignore input
-                break;
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            logger.error(`Interview submit failed: ${reason}`);
+            setError(reason);
         }
-    }, [addMessage, currentQuestion]);
-    // Handle multi-select answer submission
+    }, [addMessage, currentQuestion, setError]);
     const handleMultiSelectSubmit = useCallback(async (selectedValues) => {
         try {
             const orchestrator = orchestratorRef.current;
             if (!orchestrator || !currentQuestion)
                 return;
-            // Add user message to display
+            // Capture question before clearing so MultiSelect disappears immediately
+            const question = currentQuestion;
+            setCurrentQuestion(null);
             if (selectedValues.length === 0) {
                 addMessage('user', '(No options selected)');
             }
             else {
-                const labels = resolveOptionLabels(currentQuestion.options, selectedValues);
+                const labels = resolveOptionLabels(question.options, selectedValues);
                 addMessage('user', labels.join(', '));
             }
-            // Submit multi-select answer
             const answer = {
                 mode: 'multiSelect',
-                questionId: currentQuestion.id,
+                questionId: question.id,
                 selectedOptionIds: selectedValues,
             };
             await orchestrator.submitAnswer(answer);
         }
         catch (error) {
-            setError(error instanceof Error ? error.message : String(error));
+            const reason = error instanceof Error ? error.message : String(error);
+            logger.error(`Interview multi-select submit failed: ${reason}`);
+            setError(reason);
         }
     }, [addMessage, currentQuestion, setError]);
-    // Handle "Chat about this" mode switch
     const handleChatMode = useCallback(() => {
         setCurrentQuestion(null);
     }, []);
-    // Handle keyboard input for Escape key and Ctrl+O
+    // Handle completion dismiss (user presses Enter or Esc on summary)
+    const handleCompletionDismiss = useCallback(() => {
+        if (completionData) {
+            onCompleteRef.current(completionData.spec, messagesRef.current, completionData.specPath);
+        }
+    }, [completionData]);
     useInput((input, key) => {
+        // If showing completion summary, Enter or Esc dismisses
+        if (completionData) {
+            if (key.return || key.escape) {
+                handleCompletionDismiss();
+            }
+            return;
+        }
         if (key.escape) {
-            // When in multiSelect mode, Escape switches back to free-text instead of cancelling
             if (currentQuestion) {
                 setCurrentQuestion(null);
                 return;
             }
             onCancel();
         }
-        // Ctrl+O to toggle tool call expansion
         if (key.ctrl && input === 'o') {
             setToolCallsExpanded((prev) => !prev);
         }
     });
-    // Get current phase configuration
     const phaseConfig = PHASE_CONFIGS[state.phase];
-    // Determine if input should be disabled
     const inputDisabled = !state.awaitingInput || state.isWorking || state.phase === 'complete';
-    // Build the working indicator state
-    const workingState = {
-        isWorking: state.isWorking,
-        status: state.workingStatus,
-        hint: 'esc to cancel',
+    // Get tips text based on phase
+    const getTips = () => {
+        if (completionData)
+            return null;
+        switch (state.phase) {
+            case 'context':
+                return 'Enter URLs or file paths. Empty input to continue.';
+            case 'goals':
+                return 'Describe what you want to build.';
+            case 'interview':
+                return currentQuestion
+                    ? 'Space select, Enter confirm, C to chat, Esc cancel'
+                    : "Type answer, 'done' to generate, Esc cancel";
+            case 'generation':
+                return 'Generating specification\u2026 Esc to cancel';
+            case 'complete':
+                return 'Enter to return to shell';
+            default:
+                return null;
+        }
     };
-    // Get placeholder text based on phase
     const getPlaceholder = () => {
         switch (state.phase) {
             case 'context':
@@ -308,13 +343,24 @@ export function InterviewScreen({ featureName, projectRoot, provider, model, sca
                 return 'Type your response...';
         }
     };
-    // Build phase string for status line
     const totalPhases = state.phase === 'complete' ? PHASE_CONFIGS.complete.number : TOTAL_DISPLAY_PHASES;
     const phaseString = `${phaseConfig.name} (${phaseConfig.number}/${totalPhases})`;
-    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [state.error && (_jsx(Box, { marginY: 1, children: _jsxs(Text, { color: theme.colors.error, children: ["Error: ", state.error] }) })), _jsx(Box, { marginY: 1, children: _jsx(MessageList, { messages: state.messages, toolCallsExpanded: toolCallsExpanded }) }), state.isWorking && (_jsx(Box, { marginY: 1, children: _jsx(WorkingIndicator, { state: workingState, variant: "active" }) })), state.phase === 'complete' && (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: theme.colors.success, children: [theme.chars.bullet, " "] }), _jsx(Text, { children: "Specification complete." })] })), state.phase !== 'complete' && (_jsx(Box, { marginTop: 1, children: state.phase === 'interview' && currentQuestion ? (_jsxs(_Fragment, { children: [_jsx(Box, { children: _jsx(Text, { dimColor: true, children: '─'.repeat(50) }) }), _jsx(Box, { marginTop: 1, children: _jsx(MultiSelect, { message: currentQuestion.text, options: currentQuestion.options.map(opt => ({
-                                    value: opt.id,
-                                    label: opt.label,
-                                })), onSubmit: handleMultiSelectSubmit, onChatMode: handleChatMode }) })] })) : (
-                // Free-text mode (default for all phases)
-                _jsx(ChatInput, { onSubmit: handleSubmit, disabled: inputDisabled, allowEmpty: state.phase === 'context', placeholder: getPlaceholder() })) })), _jsx(FooterStatusBar, { action: "New Spec", phase: phaseString, path: featureName })] }));
+    // Build input element based on phase
+    let inputElement = null;
+    if (!completionData && state.phase !== 'complete') {
+        if (state.phase === 'interview' && currentQuestion) {
+            inputElement = (_jsx(MultiSelect, { message: currentQuestion.text, options: currentQuestion.options.map(opt => ({
+                    value: opt.id,
+                    label: opt.label,
+                })), onSubmit: handleMultiSelectSubmit, onChatMode: handleChatMode }, currentQuestion.id));
+        }
+        else {
+            inputElement = (_jsx(ChatInput, { onSubmit: handleSubmit, disabled: inputDisabled, allowEmpty: state.phase === 'context', placeholder: getPlaceholder() }));
+        }
+    }
+    return (_jsx(AppShell, { header: header, tips: getTips(), isWorking: state.isWorking && !completionData, workingStatus: state.workingStatus, workingHint: "esc to cancel", error: state.error, input: inputElement, footerStatus: {
+            action: 'New Spec',
+            phase: phaseString,
+            path: featureName,
+        }, children: completionData ? (_jsx(SpecCompletionSummary, { featureName: featureName, spec: completionData.spec, specPath: completionData.specPath, messages: state.messages })) : (_jsxs(_Fragment, { children: [_jsx(MessageList, { messages: state.messages, toolCallsExpanded: toolCallsExpanded }), state.phase === 'complete' && !completionData && (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: theme.colors.success, children: [phase.complete, " "] }), _jsx(Text, { children: "Specification complete." })] }))] })) }));
 }

package/dist/tui/screens/MainShell.d.ts

@@ -3,43 +3,44 @@
  *
  * The main interactive shell for Wiggum CLI, replacing the readline REPL.
  * Handles slash commands and provides navigation to other screens.
+ * Wrapped in AppShell for consistent layout.
  */
 import React from 'react';
 import type { SessionState } from '../../repl/session-state.js';
+import type { BackgroundRun } from '../hooks/useBackgroundRuns.js';
 /**
  * Navigation targets for the shell
  */
-export type NavigationTarget = 'welcome' | 'shell' | 'interview' | 'init' | 'run';
+export type NavigationTarget = 'shell' | 'interview' | 'init' | 'run';
 /**
  * Navigation props passed to target screens
  */
 export interface NavigationProps {
     featureName?: string;
+    monitorOnly?: boolean;
     [key: string]: unknown;
 }
 /**
  * Props for MainShell component
  */
 export interface MainShellProps {
+    /** Pre-built header element from App */
+    header: React.ReactNode;
     /** Current session state */
     sessionState: SessionState;
     /** Called when navigating to another screen */
     onNavigate: (target: NavigationTarget, props?: NavigationProps) => void;
-    /** Called when session state changes */
-    onSessionStateChange?: (state: SessionState) => void;
+    /** Active background runs */
+    backgroundRuns?: BackgroundRun[];
+    /** Message to display when the shell first mounts (e.g. from init completion) */
+    initialMessage?: string;
+    /** File paths to display as dimmed lines below the initial message */
+    initialFiles?: string[];
 }
 /**
  * MainShell component
  *
  * The main interactive shell that handles slash commands and navigation.
  * Replaces the readline-based REPL with an Ink-powered TUI.
- *
- * @example
- * ```tsx
- * <MainShell
- *   sessionState={state}
- *   onNavigate={(target, props) => setScreen(target, props)}
- * />
- * ```
  */
-export declare function MainShell({ sessionState, onNavigate, }: MainShellProps): React.ReactElement;
+export declare function MainShell({ header, sessionState, onNavigate, backgroundRuns, initialMessage, initialFiles, }: MainShellProps): React.ReactElement;