prompt-language-shell 0.8.8 → 0.9.2

package/dist/skills/execute.md

@@ -24,6 +24,12 @@ You will receive:
 - Tasks from user-defined skills include params.skill (skill name) and
   parameter values that were substituted into the action
 
+**CRITICAL - Command Count Rule**: You MUST generate EXACTLY one command
+per input task, no more, no less. The number of commands in your response
+MUST match the number of tasks you received. Do NOT split a single task
+into multiple commands or generate extra commands beyond what was
+scheduled.
+
 ## Skill-Based Command Generation
 
 **CRITICAL**: The "Available Skills" section in the prompt defines the ONLY
@@ -133,9 +139,26 @@ Given tasks from this skill:
 Do NOT invent different commands - use exactly what the skill specifies,
 with parameter placeholders replaced by actual values.
 
-**CRITICAL**: Take the exact command from the ### Execution section. Do
-not modify, improve, or rewrite the command in any way. The user wrote
-these commands specifically for their environment and workflow.
+**CRITICAL - VERBATIM EXECUTION**: Run shell commands EXACTLY as written in
+the ### Execution section. Do NOT:
+- Modify the command string in any way
+- Optimize or improve the command
+- Add flags or options
+- Change paths or filenames
+- Rewrite using different syntax
+- "Fix" perceived issues in the command
+- Expand aliases or shortcuts
+- Strip or modify escape characters (backslashes, quotes)
+- Convert `\"` to `"` or `\'` to `'`
+- Remove or change any escaping sequences
+
+The ONLY allowed change is replacing `{placeholder}` tokens with their
+resolved values. Everything else must remain character-for-character
+identical to what the user wrote in their skill definition.
+
+**PRESERVE ALL CHARACTERS**: If the skill has `x=\"y\"`, output `x=\"y\"`.
+If it has `path/to/file\ with\ spaces`, keep it exactly as written.
+Escape sequences are intentional - do not "clean" or "simplify" them.
 
 ## Response Format
 
@@ -350,50 +373,86 @@ For complex multi-step operations:
 4. **Error handling**: For non-critical cleanup steps, set critical:
    false
 
+## Handling Config Placeholders
+
+When substituting parameter placeholders in skill commands:
+
+1. **Known values**: Replace `{PARAM}` with the actual value from task params
+2. **Unknown values**: If a placeholder value is not available in task params,
+   **keep the original `{placeholder}` syntax** in the command. Do NOT replace
+   it with `<UNKNOWN>` or any other marker.
+
+**CRITICAL**: Never use `<UNKNOWN>`, `<MISSING>`, `<undefined>`, or similar
+markers in commands. The `<` and `>` characters break shell syntax. Always
+preserve the original `{placeholder}` format for unresolved values - this
+allows the system to detect and prompt for missing configuration.
+
+Example:
+- Command template: `process.py --output {settings.output}`
+- If `settings.output` is NOT in task params:
+  - WRONG: `process.py --output <UNKNOWN>`
+  - CORRECT: `process.py --output {settings.output}`
+
 ## Common Mistakes to Avoid
 
-❌ Generating commands that don't match the task description
-❌ Using platform-specific commands without consideration
-❌ Forgetting to quote paths with spaces
-❌ Setting unrealistic timeouts for long operations
-❌ Running destructive commands without safeguards
-❌ Ignoring task parameters when generating commands
-❌ **CRITICAL: Inventing commands instead of using skill's Execution
-   section**
-❌ **CRITICAL: Ignoring params.skill and making up your own commands**
-❌ **CRITICAL: Generating commands when the skill doesn't exist in
-   Available Skills**
-❌ Not substituting parameter placeholders in skill commands
-❌ **CRITICAL: Assuming what commands to run when skill is missing**
-
-✅ Match commands precisely to task descriptions
-✅ Use task params to fill in specific values
-✅ Quote all file paths properly
-✅ Set appropriate timeouts for each operation type
-✅ Include safety checks for destructive operations
-✅ Generate portable commands when possible
-✅ **CRITICAL: Verify skill exists in Available Skills before generating
-   commands**
-✅ **CRITICAL: Return error response if skill not found, never invent
-   commands**
-✅ Always use skill's Execution section when params.skill is present
-✅ Replace all {PARAM} placeholders with values from task params
+**DO NOT:**
+- Generate commands that don't match the task description
+- Use platform-specific commands without consideration
+- Forget to quote paths with spaces
+- Set unrealistic timeouts for long operations
+- Run destructive commands without safeguards
+- Ignore task parameters when generating commands
+- **CRITICAL: Invent commands instead of using skill's Execution
+  section**
+- **CRITICAL: Ignore params.skill and make up your own commands**
+- **CRITICAL: Generate commands when the skill doesn't exist in
+  Available Skills**
+- Fail to substitute parameter placeholders in skill commands
+- **CRITICAL: Assume what commands to run when skill is missing**
+- **CRITICAL: Replace unknown placeholders with `<UNKNOWN>` - this breaks
+  shell syntax**
+
+**DO:**
+- Match commands precisely to task descriptions
+- Use task params to fill in specific values
+- Quote all file paths properly
+- Set appropriate timeouts for each operation type
+- Include safety checks for destructive operations
+- Generate portable commands when possible
+- **CRITICAL: Verify skill exists in Available Skills before generating
+  commands**
+- **CRITICAL: Return error response if skill not found, never invent
+  commands**
+- Always use skill's Execution section when params.skill is present
+- Replace all {PARAM} placeholders with values from task params
 
 ## Final Validation
 
 Before returning commands:
 
-1. **CRITICAL: If tasks have params.skill, verify Available Skills
+1. **CRITICAL: Verify command count matches input task count** - you must
+   have exactly one command per input task
+2. **CRITICAL: If tasks have params.skill, verify Available Skills
    section exists**
-2. **CRITICAL: If tasks have params.skill, verify the skill exists in
+3. **CRITICAL: If tasks have params.skill, verify the skill exists in
    Available Skills section**
-3. **CRITICAL: If tasks have params.skill, verify the skill has both
+4. **CRITICAL: If tasks have params.skill, verify the skill has both
    Steps and Execution sections**
-4. **CRITICAL: If any validation fails, return error response with empty
+5. **CRITICAL: If any validation fails, return error response with empty
    commands array**
-5. Verify each command matches its task description
-6. Check that all task params are incorporated
-7. Ensure paths are properly quoted
-8. Confirm timeouts are reasonable for each operation
-9. Validate that critical flags are set appropriately
-10. Review for any safety concerns
+6. Verify each command matches its task description
+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
+
+## Confirmed Schedule
+
+CRITICAL: The user message contains the confirmed schedule that the user
+has reviewed and approved. You MUST generate exactly one command per task
+listed in the confirmed schedule. The number of commands in your response
+MUST equal the number of tasks below. DO NOT add extra commands, DO NOT
+skip tasks, and DO NOT split tasks into multiple commands.
+
+Your response MUST contain exactly N commands corresponding to these N tasks.

package/dist/skills/introspect.md

@@ -64,7 +64,7 @@ capability list.
 
 ## Capabilities Structure
 
-**⚠️ CRITICAL ORDERING REQUIREMENT ⚠️**
+**CRITICAL ORDERING REQUIREMENT**
 
 You MUST present capabilities in the EXACT order specified below. This is
 NON-NEGOTIABLE and applies to EVERY response.
@@ -81,20 +81,20 @@ NON-NEGOTIABLE and applies to EVERY response.
 
 These MUST appear FIRST, in this EXACT sequence:
 
-1. **Introspect** ← ALWAYS FIRST
-2. **Configure** ← ALWAYS SECOND
-3. **Answer** ← ALWAYS THIRD
-4. **Execute** ← ALWAYS FOURTH
+1. **Introspect**
+2. **Configure**
+3. **Answer**
+4. **Execute**
 
 ### Position 5-7: meta workflow capabilities (origin: "meta")
 
 These MUST appear AFTER Execute and BEFORE user-provided skills:
 
-5. **Schedule** ← NEVER FIRST, ALWAYS position 5 (after Execute)
-6. **Validate** ← ALWAYS position 6 (after Schedule)
-7. **Report** ← NEVER FIRST, ALWAYS position 7 (after Validate)
+5. **Schedule**
+6. **Validate**
+7. **Report**
 
-### 3. user-provided skills (origin: "user")
+### Position 8+: user-provided skills (origin: "user")
 
 If skills are provided in the "Available Skills" section below, include
 them in the response. For each skill:

package/dist/skills/schedule.md

@@ -325,12 +325,6 @@ even if they use the same action verb.
   - Task 2: "Process data" (skill-based with subtasks)
   - Task 3: "Explain Kubernetes" (type: answer)
 
-- "explain tdd, process files, explain tbd" → THREE separate task
-  groups:
-  - Task 1: "Explain Test-Driven Development" (type: answer)
-  - Task 2: "Process files" (skill-based with subtasks)
-  - Task 3: "Explain TBD" (type: answer)
-
 - "process files and validate" where only "process" has a skill →
   - Task 1: "Process files" (skill-based with subtasks)
   - Task 2: type "ignore" for unmatched "validate"

package/dist/types/errors.js

@@ -0,0 +1,47 @@
+/**
+ * Error codes for categorization and programmatic handling
+ */
+export var ErrorCode;
+(function (ErrorCode) {
+    // User errors - display to user, usually recoverable
+    ErrorCode["InvalidInput"] = "INVALID_INPUT";
+    ErrorCode["MissingConfig"] = "MISSING_CONFIG";
+    ErrorCode["SkillNotFound"] = "SKILL_NOT_FOUND";
+    // System errors - log + display, may be recoverable
+    ErrorCode["FileReadError"] = "FILE_READ_ERROR";
+    ErrorCode["FileWriteError"] = "FILE_WRITE_ERROR";
+    ErrorCode["NetworkError"] = "NETWORK_ERROR";
+    ErrorCode["ApiError"] = "API_ERROR";
+    ErrorCode["ParseError"] = "PARSE_ERROR";
+    // Fatal errors - must abort
+    ErrorCode["CircularReference"] = "CIRCULAR_REFERENCE";
+    ErrorCode["InvalidState"] = "INVALID_STATE";
+    ErrorCode["ConfigCorruption"] = "CONFIG_CORRUPTION";
+})(ErrorCode || (ErrorCode = {}));
+/**
+ * Base error class with cause chain support
+ * Provides consistent error structure throughout the application
+ */
+export class AppError extends Error {
+    code;
+    cause;
+    constructor(message, code, cause) {
+        super(message);
+        this.code = code;
+        this.cause = cause;
+        this.name = 'AppError';
+    }
+}
+/**
+ * Type guard for AppError
+ */
+export function isAppError(error) {
+    return error instanceof AppError;
+}
+/**
+ * Helper to wrap unknown errors with context
+ */
+export function wrapError(error, code, message) {
+    const cause = error instanceof Error ? error : undefined;
+    return new AppError(message, code, cause);
+}

package/dist/types/result.js

@@ -0,0 +1,40 @@
+/**
+ * Create a successful result
+ */
+export function ok(value) {
+    return { ok: true, value };
+}
+/**
+ * Create a failed result
+ */
+export function err(error) {
+    return { ok: false, error };
+}
+/**
+ * Unwrap a result, throwing if it's an error
+ */
+export function unwrap(result) {
+    if (result.ok)
+        return result.value;
+    throw result.error;
+}
+/**
+ * Map the value of a successful result
+ */
+export function mapResult(result, fn) {
+    if (result.ok)
+        return ok(fn(result.value));
+    return result;
+}
+/**
+ * Check if a result is successful
+ */
+export function isOk(result) {
+    return result.ok;
+}
+/**
+ * Check if a result is an error
+ */
+export function isErr(result) {
+    return !result.ok;
+}

package/dist/ui/Command.js

@@ -4,7 +4,7 @@ import { Box, Text } from 'ink';
 import { ComponentStatus, } from '../types/components.js';
 import { TaskType } from '../types/types.js';
 import { Colors } from '../services/colors.js';
-import { createScheduleDefinition } from '../services/components.js';
+import { createSchedule } from '../services/components.js';
 import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
 import { handleRefinement } from '../services/refinement.js';
@@ -77,12 +77,16 @@ export function Command({ command, status, service, requestHandlers, lifecycleHa
                     // Check if tasks contain DEFINE type (variant selection needed)
                     const hasDefineTask = result.tasks.some((task) => task.type === TaskType.Define);
                     // Create Schedule definition
-                    const scheduleDefinition = createScheduleDefinition(result.message, result.tasks, hasDefineTask
-                        ? async (selectedTasks) => {
-                            // Refinement flow for DEFINE tasks
-                            await handleRefinement(selectedTasks, svc, command, lifecycleHandlers, workflowHandlers, requestHandlers);
-                        }
-                        : undefined);
+                    const scheduleDefinition = createSchedule({
+                        message: result.message,
+                        tasks: result.tasks,
+                        onSelectionConfirmed: hasDefineTask
+                            ? async (selectedTasks) => {
+                                // Refinement flow for DEFINE tasks
+                                await handleRefinement(selectedTasks, svc, command, lifecycleHandlers, workflowHandlers, requestHandlers);
+                            }
+                            : undefined,
+                    });
                     if (hasDefineTask) {
                         // DEFINE tasks: Move Command to timeline, add Schedule to queue
                         lifecycleHandlers.completeActive();

package/dist/ui/Component.js

@@ -1,12 +1,13 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { memo } from 'react';
+import { ComponentStatus, } from '../types/components.js';
 import { ComponentName } from '../types/types.js';
 import { Answer, AnswerView } from './Answer.js';
 import { Command, CommandView } from './Command.js';
 import { Config, ConfigView } from './Config.js';
 import { Confirm, ConfirmView } from './Confirm.js';
 import { Debug } from './Debug.js';
-import { Execute, ExecuteView } from './Execute.js';
+import { Execute, ExecuteView, mapStateToViewProps } from './Execute.js';
 import { Feedback } from './Feedback.js';
 import { Introspect, IntrospectView } from './Introspect.js';
 import { Message } from './Message.js';
@@ -107,8 +108,10 @@ export const ViewComponent = memo(function ViewComponent({ def, }) {
             return (_jsx(ScheduleView, { message: message, tasks: tasks, state: state, status: status }));
         }
         case ComponentName.Execute: {
-            const { props: { tasks }, state, status, } = def;
-            return _jsx(ExecuteView, { tasks: tasks, state: state, status: status });
+            const { state, status } = def;
+            const isActive = status === ComponentStatus.Active;
+            const viewProps = mapStateToViewProps(state, isActive);
+            return _jsx(ExecuteView, { ...viewProps });
         }
         case ComponentName.Answer: {
             const { props: { question }, state, status, } = def;

package/dist/ui/Config.js

@@ -208,7 +208,10 @@ export function Config(props) {
             }
             else {
                 // Fallback: complete with abort feedback directly
-                lifecycleHandlers.completeActive(createFeedback(FeedbackType.Aborted, 'Configuration cancelled.'));
+                lifecycleHandlers.completeActive(createFeedback({
+                    type: FeedbackType.Aborted,
+                    message: 'Configuration cancelled.',
+                }));
             }
             return;
         }
@@ -272,12 +275,15 @@ export function Config(props) {
                     onFinished(newValues);
                 }
                 // Success - complete with success feedback
-                lifecycleHandlers.completeActive(createFeedback(FeedbackType.Succeeded, 'Configuration saved successfully.'));
+                lifecycleHandlers.completeActive(createFeedback({
+                    type: FeedbackType.Succeeded,
+                    message: 'Configuration saved successfully.',
+                }));
             }
             catch (error) {
                 // Failure - complete with error feedback
                 const errorMessage = error instanceof Error ? error.message : 'Configuration failed';
-                lifecycleHandlers.completeActive(createFeedback(FeedbackType.Failed, errorMessage));
+                lifecycleHandlers.completeActive(createFeedback({ type: FeedbackType.Failed, message: errorMessage }));
             }
             setStep(steps.length);
         }