prompt-language-shell 0.9.2 → 0.9.4

package/dist/skills/execute.md

@@ -139,6 +139,18 @@ Given tasks from this skill:
 Do NOT invent different commands - use exactly what the skill specifies,
 with parameter placeholders replaced by actual values.
 
+### Handling Skipped Steps
+
+**CRITICAL - STEP ORDER PRESERVATION**: When some steps from a skill are
+omitted during scheduling, you MUST maintain alignment with the
+original step positions in both the Steps and Execution sections. Each
+task corresponds to a specific line number in the skill definition, NOT
+to its sequential position in the task list. If you receive tasks for
+steps 1 and 3 (with step 2 skipped), use Execution lines 1 and 3
+(NOT lines 1 and 2). The step numbers in the task actions indicate
+which Execution line to use - always match by original position, never
+by sequential task index.
+
 **CRITICAL - VERBATIM EXECUTION**: Run shell commands EXACTLY as written in
 the ### Execution section. Do NOT:
 - Modify the command string in any way
@@ -180,7 +192,6 @@ Return a structured response with commands to execute:
 - **workdir**: Optional working directory for the command (defaults to
   current)
 - **timeout**: Optional timeout in milliseconds (defaults to 30000)
-- **critical**: Whether failure should stop execution (defaults to true)
 
 ## Command Generation Guidelines
 
@@ -364,14 +375,12 @@ commands:
 
 For complex multi-step operations:
 
-1. **Sequential dependencies**: Mark early commands as critical so failure
-   stops the chain
+1. **Sequential dependencies**: Commands execute in order; any failure stops
+   the chain
 2. **Long-running processes**: Set appropriate timeouts (build processes
    may need 10+ minutes)
 3. **Working directories**: Use workdir to ensure commands run in the
    right location
-4. **Error handling**: For non-critical cleanup steps, set critical:
-   false
 
 ## Handling Config Placeholders
 
@@ -444,8 +453,7 @@ Before returning commands:
 7. Check that all task params are incorporated
 8. Ensure paths are properly quoted
 9. Confirm timeouts are reasonable for each operation
-10. Validate that critical flags are set appropriately
-11. Review for any safety concerns
+10. Review for any safety concerns
 
 ## Confirmed Schedule
 

package/dist/tools/execute.tool.js

@@ -34,10 +34,6 @@ export const executeTool = {
                             type: 'number',
                             description: 'Optional timeout in milliseconds. Defaults to 30000 (30 seconds).',
                         },
-                        critical: {
-                            type: 'boolean',
-                            description: 'Whether failure should stop execution of subsequent commands. Defaults to true.',
-                        },
                     },
                     required: ['description', 'command'],
                 },

package/dist/types/schemas.js

@@ -56,7 +56,6 @@ export const ExecuteCommandSchema = z.object({
     command: z.string().min(1),
     workdir: z.string().optional(),
     timeout: z.number().int().positive().optional(),
-    critical: z.boolean().optional(),
 });
 /**
  * Zod schema for Capability type.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",

package/dist/execution/hooks.js

@@ -1,291 +0,0 @@
-import { useCallback, useEffect, useRef, useState, } from 'react';
-import { ComponentStatus, } from '../types/components.js';
-import { FeedbackType } from '../types/types.js';
-import { createFeedback, createMessage } from '../services/components.js';
-import { formatErrorMessage, getExecutionErrorMessage, } from '../services/messages.js';
-import { ExecutionStatus } from '../services/shell.js';
-import { ensureMinimumTime } from '../services/timing.js';
-import { handleTaskCompletion, handleTaskFailure } from './handlers.js';
-import { processTasks } from './processing.js';
-import { executeTask } from './runner.js';
-import { ExecuteActionType } from './types.js';
-import { getCurrentTaskIndex } from './utils.js';
-const ELAPSED_UPDATE_INTERVAL = 1000;
-/**
- * Track elapsed time from a start timestamp.
- * Returns 0 when not active or no start time.
- */
-export function useElapsedTimer(startTime, isActive) {
-    const [elapsed, setElapsed] = useState(0);
-    useEffect(() => {
-        if (!startTime || !isActive)
-            return;
-        const interval = setInterval(() => {
-            setElapsed(Date.now() - startTime);
-        }, ELAPSED_UPDATE_INTERVAL);
-        return () => {
-            clearInterval(interval);
-        };
-    }, [startTime, isActive]);
-    return elapsed;
-}
-/**
- * Manage live output and timing for the currently executing task.
- * Groups related state for tracking a running task's output.
- */
-export function useLiveTaskOutput() {
-    const [output, setOutput] = useState({
-        stdout: '',
-        stderr: '',
-        error: '',
-    });
-    const [startTime, setStartTime] = useState(null);
-    const start = useCallback(() => {
-        setOutput({ stdout: '', stderr: '', error: '' });
-        setStartTime(Date.now());
-    }, []);
-    const stop = useCallback(() => {
-        setStartTime(null);
-    }, []);
-    return {
-        output,
-        startTime,
-        setOutput,
-        start,
-        stop,
-    };
-}
-/**
- * Handle execution cancellation with a ref-based flag.
- * The ref is needed because callbacks check the current cancellation state.
- */
-export function useCancellation() {
-    const cancelledRef = useRef(false);
-    const cancel = useCallback(() => {
-        cancelledRef.current = true;
-    }, []);
-    const reset = useCallback(() => {
-        cancelledRef.current = false;
-    }, []);
-    return {
-        cancelledRef,
-        cancel,
-        reset,
-    };
-}
-const MINIMUM_PROCESSING_TIME = 400;
-/**
- * Helper to create ExecuteState with defaults
- */
-function createExecuteState(overrides = {}) {
-    return {
-        message: '',
-        summary: '',
-        tasks: [],
-        completionMessage: null,
-        error: null,
-        ...overrides,
-    };
-}
-/**
- * Process input tasks through AI to generate executable commands.
- * Handles the initial phase of task execution.
- */
-export function useTaskProcessor(config) {
-    const { inputTasks, service, isActive, hasProcessed, tasksCount, dispatch, requestHandlers, lifecycleHandlers, workflowHandlers, } = config;
-    useEffect(() => {
-        if (!isActive || tasksCount > 0 || hasProcessed) {
-            return;
-        }
-        let mounted = true;
-        async function process(svc) {
-            const startTime = Date.now();
-            try {
-                const result = await processTasks(inputTasks, svc);
-                await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
-                if (!mounted)
-                    return;
-                // Add debug components to timeline if present
-                if (result.debug?.length) {
-                    workflowHandlers.addToTimeline(...result.debug);
-                }
-                if (result.commands.length === 0) {
-                    if (result.error) {
-                        const errorMessage = getExecutionErrorMessage(result.error);
-                        workflowHandlers.addToTimeline(createMessage({ text: errorMessage }, ComponentStatus.Done));
-                        requestHandlers.onCompleted(createExecuteState({ message: result.message }));
-                        lifecycleHandlers.completeActive();
-                        return;
-                    }
-                    dispatch({
-                        type: ExecuteActionType.ProcessingComplete,
-                        payload: { message: result.message },
-                    });
-                    requestHandlers.onCompleted(createExecuteState({ message: result.message }));
-                    lifecycleHandlers.completeActive();
-                    return;
-                }
-                // Create task infos from commands
-                const taskInfos = result.commands.map((cmd, index) => ({
-                    label: inputTasks[index]?.action ?? cmd.description,
-                    command: cmd,
-                    status: ExecutionStatus.Pending,
-                    elapsed: 0,
-                }));
-                dispatch({
-                    type: ExecuteActionType.CommandsReady,
-                    payload: {
-                        message: result.message,
-                        summary: result.summary,
-                        tasks: taskInfos,
-                    },
-                });
-                requestHandlers.onCompleted(createExecuteState({
-                    message: result.message,
-                    summary: result.summary,
-                    tasks: taskInfos,
-                }));
-            }
-            catch (err) {
-                await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
-                if (mounted) {
-                    const errorMessage = formatErrorMessage(err);
-                    dispatch({
-                        type: ExecuteActionType.ProcessingError,
-                        payload: { error: errorMessage },
-                    });
-                    requestHandlers.onCompleted(createExecuteState({ error: errorMessage }));
-                    requestHandlers.onError(errorMessage);
-                }
-            }
-        }
-        void process(service);
-        return () => {
-            mounted = false;
-        };
-    }, [
-        inputTasks,
-        isActive,
-        service,
-        requestHandlers,
-        lifecycleHandlers,
-        workflowHandlers,
-        tasksCount,
-        hasProcessed,
-        dispatch,
-    ]);
-}
-/**
- * Execute tasks sequentially, managing state and handling completion/errors.
- */
-export function useTaskExecutor(config) {
-    const { isActive, tasks, message, summary, error, workdir, setWorkdir, cancelledRef, liveOutput, dispatch, requestHandlers, lifecycleHandlers, workflowHandlers, } = config;
-    const currentTaskIndex = getCurrentTaskIndex(tasks);
-    useEffect(() => {
-        if (!isActive ||
-            tasks.length === 0 ||
-            currentTaskIndex >= tasks.length ||
-            error) {
-            return;
-        }
-        const currentTask = tasks[currentTaskIndex];
-        if (currentTask.status !== ExecutionStatus.Pending) {
-            return;
-        }
-        cancelledRef.current = false;
-        // Mark task as started (running)
-        dispatch({
-            type: ExecuteActionType.TaskStarted,
-            payload: { index: currentTaskIndex },
-        });
-        // Reset live state for new task
-        liveOutput.start();
-        // Merge workdir into command
-        const command = workdir
-            ? { ...currentTask.command, workdir }
-            : currentTask.command;
-        void executeTask(command, currentTaskIndex, {
-            onOutputChange: (output) => {
-                if (!cancelledRef.current) {
-                    liveOutput.setOutput(output);
-                }
-            },
-            onComplete: (elapsed, output) => {
-                if (cancelledRef.current)
-                    return;
-                liveOutput.stop();
-                // Track working directory
-                if (output.workdir) {
-                    setWorkdir(output.workdir);
-                }
-                const tasksWithOutput = tasks.map((task, i) => i === currentTaskIndex
-                    ? {
-                        ...task,
-                        stdout: output.stdout,
-                        stderr: output.stderr,
-                        error: output.error,
-                    }
-                    : task);
-                const result = handleTaskCompletion(currentTaskIndex, elapsed, {
-                    tasks: tasksWithOutput,
-                    message,
-                    summary,
-                });
-                dispatch(result.action);
-                requestHandlers.onCompleted(result.finalState);
-                if (result.shouldComplete) {
-                    lifecycleHandlers.completeActive();
-                }
-            },
-            onError: (errorMsg, elapsed, output) => {
-                if (cancelledRef.current)
-                    return;
-                liveOutput.stop();
-                // Track working directory
-                if (output.workdir) {
-                    setWorkdir(output.workdir);
-                }
-                const tasksWithOutput = tasks.map((task, i) => i === currentTaskIndex
-                    ? {
-                        ...task,
-                        stdout: output.stdout,
-                        stderr: output.stderr,
-                        error: output.error,
-                    }
-                    : task);
-                const result = handleTaskFailure(currentTaskIndex, errorMsg, elapsed, {
-                    tasks: tasksWithOutput,
-                    message,
-                    summary,
-                });
-                dispatch(result.action);
-                requestHandlers.onCompleted(result.finalState);
-                if (result.action.type === ExecuteActionType.TaskErrorCritical) {
-                    const criticalErrorMessage = getExecutionErrorMessage(errorMsg);
-                    workflowHandlers.addToQueue(createFeedback({
-                        type: FeedbackType.Failed,
-                        message: criticalErrorMessage,
-                    }));
-                }
-                if (result.shouldComplete) {
-                    lifecycleHandlers.completeActive();
-                }
-            },
-        });
-    }, [
-        isActive,
-        tasks,
-        currentTaskIndex,
-        message,
-        summary,
-        error,
-        workdir,
-        setWorkdir,
-        cancelledRef,
-        liveOutput,
-        dispatch,
-        requestHandlers,
-        lifecycleHandlers,
-        workflowHandlers,
-    ]);
-}

package/dist/ui/Confirm.js

@@ -1,62 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState } from 'react';
-import { Box, Text } from 'ink';
-import { ComponentStatus, } from '../types/components.js';
-import { Colors, getTextColor, Palette } from '../services/colors.js';
-import { useInput } from '../services/keyboard.js';
-import { UserQuery } from './UserQuery.js';
-export const ConfirmView = ({ message, state, status }) => {
-    const isActive = status === ComponentStatus.Active;
-    const { selectedIndex } = state;
-    const options = [
-        { label: 'yes', value: 'yes', color: Palette.BrightGreen },
-        { label: 'no', value: 'no', color: Colors.Status.Error },
-    ];
-    // Timeline rendering (Done status)
-    if (status === ComponentStatus.Done) {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Text, { color: undefined, children: message }) }), _jsxs(UserQuery, { children: ["> ", options[selectedIndex].label] })] }));
-    }
-    // Active/Pending rendering
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(isActive), children: message }) }), _jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: Colors.Action.Select, children: ">" }), _jsx(Text, { children: " " }), _jsx(Box, { children: options.map((option, index) => {
-                            const isSelected = index === selectedIndex;
-                            return (_jsx(Box, { marginRight: 2, children: _jsx(Text, { color: isSelected ? option.color : undefined, dimColor: !isSelected, children: option.label }) }, option.value));
-                        }) })] })] }));
-};
-/**
- * Confirm controller: Manages yes/no selection
- */
-export function Confirm({ message, status, requestHandlers, onConfirmed, onCancelled, }) {
-    const isActive = status === ComponentStatus.Active;
-    const [selectedIndex, setSelectedIndex] = useState(0); // 0 = Yes, 1 = No
-    useInput((input, key) => {
-        if (!isActive)
-            return;
-        if (key.escape) {
-            // Escape: highlight "No" and cancel
-            const finalState = { selectedIndex: 1, confirmed: false };
-            requestHandlers.onCompleted(finalState);
-            onCancelled();
-        }
-        else if (key.tab) {
-            // Toggle between Yes (0) and No (1)
-            setSelectedIndex((prev) => (prev === 0 ? 1 : 0));
-        }
-        else if (key.return) {
-            // Confirm selection
-            const finalState = {
-                selectedIndex,
-                confirmed: true,
-            };
-            requestHandlers.onCompleted(finalState);
-            if (selectedIndex === 0) {
-                onConfirmed();
-            }
-            else {
-                onCancelled();
-            }
-        }
-    }, { isActive });
-    // Controller always renders View, passing current state
-    const state = { selectedIndex, confirmed: false };
-    return _jsx(ConfirmView, { message: message, state: state, status: status });
-}

package/dist/ui/Refinement.js

@@ -1,23 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box } from 'ink';
-import { ComponentStatus } from '../types/components.js';
-import { useInput } from '../services/keyboard.js';
-import { Message } from './Message.js';
-import { Spinner } from './Spinner.js';
-export const RefinementView = ({ text, status }) => {
-    const isActive = status === ComponentStatus.Active;
-    return (_jsxs(Box, { gap: 1, children: [_jsx(Message, { text: text, status: status }), isActive && _jsx(Spinner, {})] }));
-};
-/**
- * Refinement controller: Handles abort input
- */
-export const Refinement = ({ text, status, onAborted }) => {
-    const isActive = status === ComponentStatus.Active;
-    useInput((_, key) => {
-        if (key.escape && isActive) {
-            onAborted('plan refinement');
-            return;
-        }
-    }, { isActive });
-    return _jsx(RefinementView, { text: text, status: status });
-};