prompt-language-shell 0.7.8 → 0.8.2

package/dist/ui/Execute.js

@@ -1,13 +1,14 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useState } from 'react';
 import { Box, Text } from 'ink';
-import { ComponentStatus } from '../types/components.js';
+import { ComponentStatus, } from '../types/components.js';
 import { Colors, getTextColor } from '../services/colors.js';
 import { addDebugToTimeline } from '../services/components.js';
 import { useInput } from '../services/keyboard.js';
+import { loadUserConfig } from '../services/loader.js';
 import { formatErrorMessage } from '../services/messages.js';
 import { replacePlaceholders } from '../services/resolver.js';
-import { loadUserConfig } from '../services/loader.js';
+import { ExecutionStatus } from '../services/shell.js';
 import { ensureMinimumTime } from '../services/timing.js';
 import { formatDuration } from '../services/utils.js';
 import { Spinner } from './Spinner.js';
@@ -18,19 +19,49 @@ export function Execute({ tasks, state, status, service, handlers, }) {
     const [error, setError] = useState(state?.error ?? null);
     const [taskInfos, setTaskInfos] = useState(state?.taskInfos ?? []);
     const [message, setMessage] = useState(state?.message ?? '');
-    const [activeTaskIndex, setActiveTaskIndex] = useState(state?.activeTaskIndex ?? -1);
+    const [completed, setCompleted] = useState(state?.completed ?? 0);
     const [hasProcessed, setHasProcessed] = useState(false);
     const [taskExecutionTimes, setTaskExecutionTimes] = useState(state?.taskExecutionTimes ?? []);
     const [completionMessage, setCompletionMessage] = useState(state?.completionMessage ?? null);
     const [summary, setSummary] = useState(state?.summary ?? '');
     // Derive loading state from current conditions
     const isLoading = isActive && taskInfos.length === 0 && !error && !hasProcessed;
-    const isExecuting = activeTaskIndex >= 0 && activeTaskIndex < taskInfos.length;
+    const isExecuting = completed < taskInfos.length;
+    // Handle cancel with useCallback to ensure we capture latest state
+    const handleCancel = useCallback(() => {
+        // Mark tasks based on their status relative to completed:
+        // - Before completed: finished (Success)
+        // - At completed: interrupted (Aborted)
+        // - After completed: never started (Cancelled)
+        const updatedTaskInfos = taskInfos.map((task, taskIndex) => {
+            if (taskIndex < completed) {
+                // Tasks that completed before interruption
+                return { ...task, status: ExecutionStatus.Success };
+            }
+            else if (taskIndex === completed) {
+                // Task that was running when interrupted
+                return { ...task, status: ExecutionStatus.Aborted };
+            }
+            else {
+                // Tasks that haven't started yet
+                return { ...task, status: ExecutionStatus.Cancelled };
+            }
+        });
+        setTaskInfos(updatedTaskInfos);
+        handlers?.updateState({
+            message,
+            summary,
+            taskInfos: updatedTaskInfos,
+            completed,
+            taskExecutionTimes,
+            completionMessage: null,
+            error: null,
+        });
+        handlers?.onAborted('execution');
+    }, [message, summary, taskInfos, completed, taskExecutionTimes, handlers]);
     useInput((_, key) => {
         if (key.escape && (isLoading || isExecuting) && isActive) {
-            // Cancel execution
-            setActiveTaskIndex(-1);
-            handlers?.onAborted('execution');
+            handleCancel();
         }
     }, { isActive: (isLoading || isExecuting) && isActive });
     // Process tasks to get commands from AI
@@ -38,10 +69,6 @@ export function Execute({ tasks, state, status, service, handlers, }) {
         if (!isActive || taskInfos.length > 0 || hasProcessed) {
             return;
         }
-        if (!service) {
-            setError('No service available');
-            return;
-        }
         let mounted = true;
         async function process(svc) {
             const startTime = Date.now();
@@ -69,7 +96,12 @@ export function Execute({ tasks, state, status, service, handlers, }) {
                     setHasProcessed(true);
                     handlers?.updateState({
                         message: result.message,
+                        summary: '',
                         taskInfos: [],
+                        completed: 0,
+                        taskExecutionTimes: [],
+                        completionMessage: null,
+                        error: null,
                     });
                     handlers?.completeActive();
                     return;
@@ -80,14 +112,26 @@ export function Execute({ tasks, state, status, service, handlers, }) {
                     command: replacePlaceholders(cmd.command, userConfig),
                 }));
                 // Set message, summary, and create task infos
-                setMessage(result.message);
-                setSummary(result.summary || '');
+                const newMessage = result.message;
+                const newSummary = result.summary || '';
                 const infos = resolvedCommands.map((cmd, index) => ({
                     label: tasks[index]?.action,
                     command: cmd,
                 }));
+                setMessage(newMessage);
+                setSummary(newSummary);
                 setTaskInfos(infos);
-                setActiveTaskIndex(0); // Start with first task
+                setCompleted(0); // Start with first task
+                // Update state after AI processing
+                handlers?.updateState({
+                    message: newMessage,
+                    summary: newSummary,
+                    taskInfos: infos,
+                    completed: 0,
+                    taskExecutionTimes: [],
+                    completionMessage: null,
+                    error: null,
+                });
             }
             catch (err) {
                 await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
@@ -95,12 +139,20 @@ export function Execute({ tasks, state, status, service, handlers, }) {
                     const errorMessage = formatErrorMessage(err);
                     setError(errorMessage);
                     setHasProcessed(true);
-                    handlers?.updateState({ error: errorMessage });
+                    handlers?.updateState({
+                        message: '',
+                        summary: '',
+                        taskInfos: [],
+                        completed: 0,
+                        taskExecutionTimes: [],
+                        completionMessage: null,
+                        error: errorMessage,
+                    });
                     handlers?.onError(errorMessage);
                 }
             }
         }
-        process(service);
+        void process(service);
         return () => {
             mounted = false;
         };
@@ -109,62 +161,94 @@ export function Execute({ tasks, state, status, service, handlers, }) {
     const handleTaskComplete = useCallback((index, _output, elapsed) => {
         const updatedTimes = [...taskExecutionTimes, elapsed];
         setTaskExecutionTimes(updatedTimes);
+        // Update task with elapsed time and success status
+        const updatedTaskInfos = taskInfos.map((task, i) => i === index
+            ? { ...task, status: ExecutionStatus.Success, elapsed }
+            : task);
+        setTaskInfos(updatedTaskInfos);
         if (index < taskInfos.length - 1) {
             // More tasks to execute
-            setActiveTaskIndex(index + 1);
+            setCompleted(index + 1);
+            handlers?.updateState({
+                message,
+                summary,
+                taskInfos: updatedTaskInfos,
+                completed: index + 1,
+                taskExecutionTimes: updatedTimes,
+                completionMessage: null,
+                error: null,
+            });
         }
         else {
             // All tasks complete
-            setActiveTaskIndex(-1);
             const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
-            const summaryText = summary?.trim() || 'Execution completed';
+            const summaryText = summary.trim() || 'Execution completed';
             const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
             setCompletionMessage(completion);
             handlers?.updateState({
                 message,
                 summary,
-                taskInfos,
-                activeTaskIndex: -1,
+                taskInfos: updatedTaskInfos,
+                completed: index + 1,
                 taskExecutionTimes: updatedTimes,
                 completionMessage: completion,
+                error: null,
             });
             handlers?.completeActive();
         }
     }, [taskInfos, message, handlers, taskExecutionTimes, summary]);
-    const handleTaskError = useCallback((index, error) => {
+    const handleTaskError = useCallback((index, error, elapsed) => {
         const task = taskInfos[index];
-        const isCritical = task?.command.critical !== false; // Default to true
+        const isCritical = task.command.critical !== false; // Default to true
+        // Update task with elapsed time and failed status
+        const updatedTaskInfos = taskInfos.map((task, i) => i === index
+            ? { ...task, status: ExecutionStatus.Failed, elapsed }
+            : task);
+        setTaskInfos(updatedTaskInfos);
         if (isCritical) {
             // Critical failure - stop execution
-            setActiveTaskIndex(-1);
             setError(error);
             handlers?.updateState({
                 message,
-                taskInfos,
-                activeTaskIndex: -1,
+                summary,
+                taskInfos: updatedTaskInfos,
+                completed: index + 1,
+                taskExecutionTimes,
+                completionMessage: null,
                 error,
             });
             handlers?.onError(error);
         }
         else {
             // Non-critical failure - continue to next task
+            const updatedTimes = [...taskExecutionTimes, elapsed];
+            setTaskExecutionTimes(updatedTimes);
             if (index < taskInfos.length - 1) {
-                setActiveTaskIndex(index + 1);
+                setCompleted(index + 1);
+                handlers?.updateState({
+                    message,
+                    summary,
+                    taskInfos: updatedTaskInfos,
+                    completed: index + 1,
+                    taskExecutionTimes: updatedTimes,
+                    completionMessage: null,
+                    error: null,
+                });
             }
             else {
                 // Last task, complete execution
-                setActiveTaskIndex(-1);
-                const totalElapsed = taskExecutionTimes.reduce((sum, time) => sum + time, 0);
-                const summaryText = summary?.trim() || 'Execution completed';
+                const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
+                const summaryText = summary.trim() || 'Execution completed';
                 const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
                 setCompletionMessage(completion);
                 handlers?.updateState({
                     message,
                     summary,
-                    taskInfos,
-                    activeTaskIndex: -1,
-                    taskExecutionTimes,
+                    taskInfos: updatedTaskInfos,
+                    completed: index + 1,
+                    taskExecutionTimes: updatedTimes,
                     completionMessage: completion,
+                    error: null,
                 });
                 handlers?.completeActive();
             }
@@ -175,15 +259,19 @@ export function Execute({ tasks, state, status, service, handlers, }) {
         // Just update state, don't call onAborted (already called at Execute level)
         handlers?.updateState({
             message,
+            summary,
             taskInfos,
-            activeTaskIndex: -1,
+            completed,
+            taskExecutionTimes,
+            completionMessage: null,
+            error: null,
         });
-    }, [taskInfos, message, handlers]);
+    }, [taskInfos, message, summary, completed, taskExecutionTimes, handlers]);
     // Return null only when loading completes with no commands
     if (!isActive && taskInfos.length === 0 && !error) {
         return null;
     }
     // Show completed steps when not active
     const showTasks = !isActive && taskInfos.length > 0;
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: "Preparing commands. " }), _jsx(Spinner, {})] })), (isExecuting || showTasks) && (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [message && (_jsxs(Box, { marginBottom: 1, gap: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: message }), isExecuting && _jsx(Spinner, {})] })), taskInfos.map((taskInfo, index) => (_jsx(Box, { marginBottom: index < taskInfos.length - 1 ? 1 : 0, children: _jsx(Task, { label: taskInfo.label, command: taskInfo.command, isActive: isActive && index === activeTaskIndex, index: index, onComplete: handleTaskComplete, onAbort: handleTaskAbort, onError: handleTaskError }) }, index)))] })), completionMessage && !isActive && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(false), children: completionMessage }) })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) }))] }));
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: "Preparing commands. " }), _jsx(Spinner, {})] })), (isExecuting || showTasks) && (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [message && (_jsxs(Box, { marginBottom: 1, gap: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: message }), isExecuting && _jsx(Spinner, {})] })), taskInfos.map((taskInfo, index) => (_jsx(Box, { marginBottom: index < taskInfos.length - 1 ? 1 : 0, children: _jsx(Task, { label: taskInfo.label, command: taskInfo.command, isActive: isActive && index === completed, index: index, initialStatus: taskInfo.status, initialElapsed: taskInfo.elapsed, onComplete: handleTaskComplete, onAbort: handleTaskAbort, onError: handleTaskError }) }, index)))] })), completionMessage && !isActive && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(false), children: completionMessage }) })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) }))] }));
 }

package/dist/ui/Feedback.js

@@ -1,7 +1,7 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-import { getFeedbackColor } from '../services/colors.js';
 import { FeedbackType } from '../types/types.js';
+import { getFeedbackColor } from '../services/colors.js';
 function getSymbol(type) {
     return {
         [FeedbackType.Info]: 'ℹ',

package/dist/ui/Introspect.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { Box, Text } from 'ink';
-import { ComponentStatus, } from '../types/components.js';
+import { ComponentStatus } from '../types/components.js';
 import { Colors, getTextColor } from '../services/colors.js';
 import { addDebugToTimeline, createReportDefinition, } from '../services/components.js';
 import { DebugLevel } from '../services/configuration.js';
@@ -10,49 +10,7 @@ import { formatErrorMessage } from '../services/messages.js';
 import { ensureMinimumTime } from '../services/timing.js';
 import { Spinner } from './Spinner.js';
 const MIN_PROCESSING_TIME = 1000;
-const BUILT_IN_CAPABILITIES = new Set([
-    'CONFIGURE',
-    'SCHEDULE',
-    'INTROSPECT',
-    'ANSWER',
-    'EXECUTE',
-    'VALIDATE',
-    'REPORT',
-]);
-const INDIRECT_CAPABILITIES = new Set(['SCHEDULE', 'VALIDATE', 'REPORT']);
-function parseCapabilityFromTask(task) {
-    // Parse "NAME: Description" format from task.action
-    const colonIndex = task.action.indexOf(':');
-    if (colonIndex === -1) {
-        const upperName = task.action.toUpperCase();
-        // Check for status markers
-        const isIncomplete = task.action.includes('(INCOMPLETE)');
-        const cleanName = task.action.replace(/\s*\(INCOMPLETE\)\s*/gi, '').trim();
-        return {
-            name: cleanName,
-            description: '',
-            isBuiltIn: BUILT_IN_CAPABILITIES.has(upperName),
-            isIndirect: INDIRECT_CAPABILITIES.has(upperName),
-            isIncomplete,
-        };
-    }
-    const name = task.action.substring(0, colonIndex).trim();
-    const description = task.action.substring(colonIndex + 1).trim();
-    // Check for status markers
-    const isIncomplete = name.includes('(INCOMPLETE)');
-    const cleanName = name.replace(/\s*\(INCOMPLETE\)\s*/gi, '').trim();
-    const upperName = cleanName.toUpperCase();
-    const isBuiltIn = BUILT_IN_CAPABILITIES.has(upperName);
-    const isIndirect = INDIRECT_CAPABILITIES.has(upperName);
-    return {
-        name: cleanName,
-        description,
-        isBuiltIn,
-        isIndirect,
-        isIncomplete,
-    };
-}
-export function Introspect({ tasks, state, status, service, children, debug = DebugLevel.None, handlers, }) {
+export function Introspect({ tasks, state: _state, status, service, children, debug = DebugLevel.None, handlers, }) {
     const isActive = status === ComponentStatus.Active;
     // isActive passed as prop
     const [error, setError] = useState(null);
@@ -66,11 +24,6 @@ export function Introspect({ tasks, state, status, service, children, debug = De
         if (!isActive) {
             return;
         }
-        // Skip processing if no service available
-        if (!service) {
-            setError('No service available');
-            return;
-        }
         let mounted = true;
         async function process(svc) {
             const startTime = Date.now();
@@ -83,8 +36,8 @@ export function Introspect({ tasks, state, status, service, children, debug = De
                 if (mounted) {
                     // Add debug components to timeline if present
                     addDebugToTimeline(result.debug, handlers);
-                    // Parse capabilities from returned tasks
-                    let capabilities = result.tasks.map(parseCapabilityFromTask);
+                    // Capabilities come directly from result - no parsing needed
+                    let capabilities = result.capabilities;
                     // Filter out internal capabilities when not in debug mode
                     if (debug === DebugLevel.None) {
                         capabilities = capabilities.filter((cap) => cap.name.toUpperCase() !== 'SCHEDULE' &&
@@ -115,7 +68,7 @@ export function Introspect({ tasks, state, status, service, children, debug = De
                 }
             }
         }
-        process(service);
+        void process(service);
         return () => {
             mounted = false;
         };

package/dist/ui/Label.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-import { DebugLevel } from '../services/configuration.js';
 import { getTaskColors, getTaskTypeLabel } from '../services/colors.js';
+import { DebugLevel } from '../services/configuration.js';
 import { Separator } from './Separator.js';
 export function Label({ description, taskType, showType = false, isCurrent = false, debug = DebugLevel.None, }) {
     const colors = getTaskColors(taskType, isCurrent);

package/dist/ui/List.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
+import { Palette } from '../services/colors.js';
 import { Separator } from './Separator.js';
 export const List = ({ items, level = 0, highlightedIndex = null, highlightedParentIndex = null, showType = false, }) => {
     const marginLeft = level > 0 ? 2 : 0;
@@ -21,7 +22,7 @@ export const List = ({ items, level = 0, highlightedIndex = null, highlightedPar
             const markerColor = item.markerColor ||
                 (isHighlighted && item.type.highlightedColor
                     ? item.type.highlightedColor
-                    : 'whiteBright');
+                    : Palette.White);
             return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: markerColor, children: marker }), _jsx(Text, { color: descriptionColor, children: item.description.text }), showType && (_jsxs(_Fragment, { children: [_jsx(Separator, {}), _jsx(Text, { color: typeColor, children: item.type.text })] }))] }), item.children && item.children.length > 0 && (_jsx(List, { items: item.children, level: level + 1, highlightedIndex: shouldHighlightChildren ? highlightedIndex : null, showType: showType }))] }, index));
         }) }));
 };

package/dist/ui/Main.js

@@ -86,7 +86,7 @@ export const Main = ({ app, command }) => {
                     throw new Error(errorMessage);
                 }
             };
-            const handleConfigAborted = (operation) => {
+            const handleConfigAborted = (_operation) => {
                 // Config was cancelled
             };
             setInitialQueue([

package/dist/ui/Report.js

@@ -1,14 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-import { Colors } from '../services/colors.js';
-function CapabilityItem({ name, description, isBuiltIn, isIndirect, isIncomplete, }) {
-    const color = isIndirect
-        ? Colors.Origin.Indirect
-        : isBuiltIn
-            ? Colors.Origin.BuiltIn
-            : Colors.Origin.UserProvided;
+import { Colors, getOriginColor } from '../services/colors.js';
+function CapabilityItem({ name, description, origin, isIncomplete, }) {
+    const color = getOriginColor(origin);
     return (_jsxs(Box, { children: [_jsx(Text, { children: "- " }), _jsx(Text, { color: color, children: name }), _jsxs(Text, { children: [" - ", description] }), isIncomplete && _jsx(Text, { color: Colors.Status.Warning, children: " (incomplete)" })] }));
 }
 export function Report({ message, capabilities }) {
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginLeft: 1, children: _jsx(Text, { children: message }) }), _jsx(Box, { flexDirection: "column", marginLeft: 3, marginTop: 1, children: capabilities.map((capability, index) => (_jsx(CapabilityItem, { name: capability.name, description: capability.description, isBuiltIn: capability.isBuiltIn, isIndirect: capability.isIndirect, isIncomplete: capability.isIncomplete }, index))) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginLeft: 1, children: _jsx(Text, { children: message }) }), _jsx(Box, { flexDirection: "column", marginLeft: 3, marginTop: 1, children: capabilities.map((capability, index) => (_jsx(CapabilityItem, { name: capability.name, description: capability.description, origin: capability.origin, isIncomplete: capability.isIncomplete }, index))) })] }));
 }

package/dist/ui/Schedule.js

@@ -3,8 +3,8 @@ import { useEffect, useState } from 'react';
 import { Box } from 'ink';
 import { ComponentStatus } from '../types/components.js';
 import { TaskType } from '../types/types.js';
-import { DebugLevel } from '../services/configuration.js';
 import { getTaskColors, getTaskTypeLabel } from '../services/colors.js';
+import { DebugLevel } from '../services/configuration.js';
 import { useInput } from '../services/keyboard.js';
 import { Label } from './Label.js';
 import { List } from './List.js';
@@ -37,7 +37,7 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
             const planColors = getTaskColors(TaskType.Schedule, isCurrent);
             return {
                 description: {
-                    text: String(option),
+                    text: option,
                     color: colors.description,
                     highlightedColor: planColors.description,
                 },
@@ -96,7 +96,7 @@ export function Schedule({ message, tasks, state, status, debug = DebugLevel.Non
             // Complete the selection phase - it goes to timeline
             // Callback will create a new Plan showing refined tasks (pending) + Confirm (active)
             handlers?.completeActive();
-            onSelectionConfirmed(concreteTasks);
+            void onSelectionConfirmed(concreteTasks);
         }
     }, [
         isActive,
@@ -153,7 +153,7 @@ export function Schedule({ message, tasks, state, status, debug = DebugLevel.Non
                         // This is a Define task - only include the selected option
                         const options = task.params.options;
                         const selectedIndex = newCompletedSelections[defineGroupIndex];
-                        const selectedOption = String(options[selectedIndex]);
+                        const selectedOption = options[selectedIndex];
                         // Use Execute as default - LLM will properly classify during refinement
                         refinedTasks.push({
                             action: selectedOption,
@@ -171,7 +171,7 @@ export function Schedule({ message, tasks, state, status, debug = DebugLevel.Non
                     // Complete the selection phase - it goes to timeline
                     // Callback will create a new Plan showing refined tasks (pending) + Confirm (active)
                     handlers?.completeActive();
-                    onSelectionConfirmed(refinedTasks);
+                    void onSelectionConfirmed(refinedTasks);
                 }
                 else {
                     // No selection callback, just complete normally

package/dist/ui/Spinner.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { Text } from 'ink';
+import { Palette } from '../services/colors.js';
 const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 const INTERVAL = 80;
 const CYCLE = FRAMES.length * INTERVAL;
@@ -16,7 +17,9 @@ export function Spinner() {
                 return next !== prev ? next : prev;
             });
         }, INTERVAL);
-        return () => clearInterval(timer);
+        return () => {
+            clearInterval(timer);
+        };
     }, []);
-    return _jsx(Text, { color: "blueBright", children: FRAMES[frame] });
+    return _jsx(Text, { color: Palette.Cyan, children: FRAMES[frame] });
 }

package/dist/ui/Subtask.js

@@ -1,11 +1,22 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { getStatusColors, Palette, STATUS_ICONS } from '../services/colors.js';
-import { formatDuration } from '../services/utils.js';
 import { ExecutionStatus } from '../services/shell.js';
+import { formatDuration } from '../services/utils.js';
 import { Spinner } from './Spinner.js';
-export function Subtask({ label, command, status, startTime, endTime, elapsed, }) {
+export function Subtask({ label, command, status, isActive: _isActive, startTime, endTime, elapsed, }) {
     const colors = getStatusColors(status);
+    const isCancelled = status === ExecutionStatus.Cancelled;
+    const isAborted = status === ExecutionStatus.Aborted;
+    const shouldStrikethrough = isCancelled || isAborted;
+    const isFinished = status === ExecutionStatus.Success ||
+        status === ExecutionStatus.Failed ||
+        status === ExecutionStatus.Aborted;
     const elapsedTime = elapsed ?? (startTime && endTime ? endTime - startTime : undefined);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { paddingLeft: 2, gap: 1, children: [_jsx(Text, { color: colors.icon, children: STATUS_ICONS[status] }), _jsx(Text, { color: colors.description, children: label || command.description }), elapsedTime !== undefined && (_jsxs(Text, { color: Palette.DarkGray, children: ["(", formatDuration(elapsedTime), ")"] }))] }), _jsxs(Box, { paddingLeft: 5, gap: 1, children: [_jsx(Text, { color: colors.symbol, children: "\u221F" }), _jsx(Text, { color: colors.command, children: command.command }), status === ExecutionStatus.Running && _jsx(Spinner, {})] })] }));
+    // Apply strikethrough for cancelled and aborted tasks
+    const formatText = (text) => shouldStrikethrough ? text.split('').join('\u0336') + '\u0336' : text;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { paddingLeft: 2, gap: 1, children: [_jsx(Text, { color: colors.icon, children: STATUS_ICONS[status] }), _jsx(Text, { color: colors.description, children: shouldStrikethrough
+                            ? formatText(label || command.description)
+                            : label || command.description }), (isFinished || status === ExecutionStatus.Running) &&
+                        elapsedTime !== undefined && (_jsxs(Text, { color: Palette.DarkGray, children: ["(", formatDuration(elapsedTime), ")"] }))] }), _jsxs(Box, { paddingLeft: 5, flexDirection: "row", children: [_jsx(Box, { children: _jsx(Text, { color: colors.symbol, children: "\u221F " }) }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { color: colors.command, children: command.command }), status === ExecutionStatus.Running && _jsx(Spinner, {})] })] })] }));
 }

package/dist/ui/Task.js

@@ -1,13 +1,13 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { ExecutionStatus, executeCommand, } from '../services/shell.js';
+import { ExecutionResult, ExecutionStatus, executeCommand, } from '../services/shell.js';
 import { calculateElapsed } from '../services/utils.js';
 import { Subtask } from './Subtask.js';
-export function Task({ label, command, isActive, index, onComplete, onAbort, onError, }) {
-    const [status, setStatus] = useState(ExecutionStatus.Pending);
+export function Task({ label, command, isActive, index, initialStatus, initialElapsed, onComplete, onAbort, onError, }) {
+    const [status, setStatus] = useState(initialStatus ?? ExecutionStatus.Pending);
     const [startTime, setStartTime] = useState();
     const [endTime, setEndTime] = useState();
-    const [elapsed, setElapsed] = useState();
+    const [elapsed, setElapsed] = useState(initialElapsed);
     const [currentElapsed, setCurrentElapsed] = useState(0);
     // Update elapsed time while running
     useEffect(() => {
@@ -19,11 +19,16 @@ export function Task({ label, command, isActive, index, onComplete, onAbort, onE
                 return next !== prev ? next : prev;
             });
         }, 1000);
-        return () => clearInterval(interval);
+        return () => {
+            clearInterval(interval);
+        };
     }, [status, startTime]);
     // Execute command when becoming active
     useEffect(() => {
-        if (!isActive || status !== ExecutionStatus.Pending) {
+        // Don't execute if task is cancelled or if not active
+        if (!isActive ||
+            status === ExecutionStatus.Cancelled ||
+            status !== ExecutionStatus.Pending) {
             return;
         }
         let mounted = true;
@@ -40,14 +45,14 @@ export function Task({ label, command, isActive, index, onComplete, onAbort, onE
                 setEndTime(end);
                 const taskDuration = calculateElapsed(start);
                 setElapsed(taskDuration);
-                setStatus(output.result === 'success'
+                setStatus(output.result === ExecutionResult.Success
                     ? ExecutionStatus.Success
                     : ExecutionStatus.Failed);
-                if (output.result === 'success') {
+                if (output.result === ExecutionResult.Success) {
                     onComplete?.(index, output, taskDuration);
                 }
                 else {
-                    onError?.(index, output.errors || 'Command failed');
+                    onError?.(index, output.errors || 'Command failed', taskDuration);
                 }
             }
             catch (err) {
@@ -55,16 +60,16 @@ export function Task({ label, command, isActive, index, onComplete, onAbort, onE
                     return;
                 const end = Date.now();
                 setEndTime(end);
-                setElapsed(calculateElapsed(start));
+                const errorDuration = calculateElapsed(start);
+                setElapsed(errorDuration);
                 setStatus(ExecutionStatus.Failed);
-                onError?.(index, err instanceof Error ? err.message : 'Unknown error');
+                onError?.(index, err instanceof Error ? err.message : 'Unknown error', errorDuration);
             }
         }
-        execute();
+        void execute();
         return () => {
             mounted = false;
         };
-        // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [isActive]);
     // Handle abort when task becomes inactive while running
     useEffect(() => {
@@ -77,5 +82,5 @@ export function Task({ label, command, isActive, index, onComplete, onAbort, onE
             onAbort?.(index);
         }
     }, [isActive, status, startTime, index, onAbort]);
-    return (_jsx(Subtask, { label: label, command: command, status: status, startTime: startTime, endTime: endTime, elapsed: status === ExecutionStatus.Running ? currentElapsed : elapsed }));
+    return (_jsx(Subtask, { label: label, command: command, status: status, isActive: isActive, startTime: startTime, endTime: endTime, elapsed: status === ExecutionStatus.Running ? currentElapsed : elapsed }));
 }