prompt-language-shell 0.9.0 → 0.9.2

package/dist/services/router.js

@@ -2,10 +2,11 @@ import { asScheduledTasks } from '../types/guards.js';
 import { FeedbackType, TaskType } from '../types/types.js';
 import { saveConfig } from '../configuration/io.js';
 import { getConfigSchema } from '../configuration/schema.js';
+import { createConfigStepsFromSchema } from '../configuration/steps.js';
 import { unflattenConfig } from '../configuration/transformation.js';
-import { saveConfigLabels } from './config-labels.js';
-import { createAnswerDefinition, createConfigDefinitionWithKeys, createConfirmDefinition, createExecuteDefinition, createFeedback, createIntrospectDefinition, createMessage, createScheduleDefinition, createValidateDefinition, } from './components.js';
-import { getCancellationMessage, getMixedTaskTypesError, getUnknownRequestMessage, } from './messages.js';
+import { saveConfigLabels } from '../configuration/labels.js';
+import { createAnswer, createConfig, createConfirm, createExecute, createFeedback, createIntrospect, createMessage, createSchedule, createValidate, } from './components.js';
+import { getCancellationMessage, getConfirmationMessage, getMixedTaskTypesError, getUnknownRequestMessage, } from './messages.js';
 import { validateExecuteTasks } from './validator.js';
 /**
  * Determine the operation name based on task types
@@ -30,7 +31,7 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, life
     const validTasks = tasks.filter((task) => task.type !== TaskType.Ignore && task.type !== TaskType.Discard);
     // Check if no valid tasks remain after filtering
     if (validTasks.length === 0) {
-        const msg = createMessage(getUnknownRequestMessage());
+        const msg = createMessage({ text: getUnknownRequestMessage() });
         workflowHandlers.addToQueue(msg);
         return;
     }
@@ -45,7 +46,7 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, life
     if (hasDefineTask) {
         // Has DEFINE tasks - add Schedule to queue for user selection
         // Refinement flow will call this function again with refined tasks
-        const scheduleDefinition = createScheduleDefinition(message, validTasks);
+        const scheduleDefinition = createSchedule({ message, tasks: validTasks });
         workflowHandlers.addToQueue(scheduleDefinition);
     }
     else {
@@ -53,19 +54,27 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, life
         // When Schedule activates, Command moves to timeline
         // When Schedule completes, it moves to pending
         // When Confirm activates, Schedule stays pending (visible for context)
-        const scheduleDefinition = createScheduleDefinition(message, validTasks, () => {
-            // Schedule completed - add Confirm to queue
-            const confirmDefinition = createConfirmDefinition(() => {
-                // User confirmed - complete both Confirm and Schedule, then route
-                lifecycleHandlers.completeActiveAndPending();
-                executeTasksAfterConfirm(validTasks, context);
-            }, () => {
-                // User cancelled - complete both Confirm and Schedule, then show cancellation
-                lifecycleHandlers.completeActiveAndPending();
-                const message = getCancellationMessage(operation);
-                workflowHandlers.addToQueue(createFeedback(FeedbackType.Aborted, message));
-            });
-            workflowHandlers.addToQueue(confirmDefinition);
+        const scheduleDefinition = createSchedule({
+            message,
+            tasks: validTasks,
+            onSelectionConfirmed: () => {
+                // Schedule completed - add Confirm to queue
+                const confirmDefinition = createConfirm({
+                    message: getConfirmationMessage(),
+                    onConfirmed: () => {
+                        // User confirmed - complete both Confirm and Schedule, then route
+                        lifecycleHandlers.completeActiveAndPending();
+                        executeTasksAfterConfirm(validTasks, context);
+                    },
+                    onCancelled: () => {
+                        // User cancelled - complete both Confirm and Schedule, then show cancellation
+                        lifecycleHandlers.completeActiveAndPending();
+                        const message = getCancellationMessage(operation);
+                        workflowHandlers.addToQueue(createFeedback({ type: FeedbackType.Aborted, message }));
+                    },
+                });
+                workflowHandlers.addToQueue(confirmDefinition);
+            },
         });
         workflowHandlers.addToQueue(scheduleDefinition);
     }
@@ -134,18 +143,28 @@ function executeTasksAfterConfirm(tasks, context) {
                         .join('\n');
                     return `Invalid skill definition "${error.skill}":\n\n${issuesList}`;
                 });
-                workflowHandlers.addToQueue(createFeedback(FeedbackType.Failed, errorMessages.join('\n\n')));
+                workflowHandlers.addToQueue(createFeedback({
+                    type: FeedbackType.Failed,
+                    message: errorMessages.join('\n\n'),
+                }));
                 return;
             }
             else if (validation.missingConfig.length > 0) {
                 // Missing config detected - create ONE Validate component for ALL missing config
-                workflowHandlers.addToQueue(createValidateDefinition(validation.missingConfig, userRequest, service, (error) => {
-                    requestHandlers.onError(error);
-                }, () => {
-                    // After config is complete, resume task routing
-                    routeTasksAfterConfig(scheduledTasks, context);
-                }, (operation) => {
-                    requestHandlers.onAborted(operation);
+                workflowHandlers.addToQueue(createValidate({
+                    missingConfig: validation.missingConfig,
+                    userRequest,
+                    service,
+                    onError: (error) => {
+                        requestHandlers.onError(error);
+                    },
+                    onValidationComplete: () => {
+                        // After config is complete, resume task routing
+                        routeTasksAfterConfig(scheduledTasks, context);
+                    },
+                    onAborted: (operation) => {
+                        requestHandlers.onAborted(operation);
+                    },
                 }));
                 return;
             }
@@ -211,14 +230,14 @@ function routeTasksAfterConfig(scheduledTasks, context) {
  */
 function routeAnswerTasks(tasks, context) {
     for (const task of tasks) {
-        context.workflowHandlers.addToQueue(createAnswerDefinition(task.action, context.service));
+        context.workflowHandlers.addToQueue(createAnswer({ question: task.action, service: context.service }));
     }
 }
 /**
  * Route Introspect tasks - creates single Introspect component for all tasks
  */
 function routeIntrospectTasks(tasks, context) {
-    context.workflowHandlers.addToQueue(createIntrospectDefinition(tasks, context.service));
+    context.workflowHandlers.addToQueue(createIntrospect({ tasks, service: context.service }));
 }
 /**
  * Route Config tasks - extracts keys, caches labels, creates Config component
@@ -240,31 +259,35 @@ function routeConfigTasks(tasks, context) {
     if (Object.keys(labels).length > 0) {
         saveConfigLabels(labels);
     }
-    context.workflowHandlers.addToQueue(createConfigDefinitionWithKeys(configKeys, (config) => {
-        // Save config - Config component will handle completion and feedback
-        try {
-            // Convert flat dotted keys to nested structure grouped by section
-            const configBySection = unflattenConfig(config);
-            // Save each section
-            for (const [section, sectionConfig] of Object.entries(configBySection)) {
-                saveConfig(section, sectionConfig);
+    context.workflowHandlers.addToQueue(createConfig({
+        steps: createConfigStepsFromSchema(configKeys),
+        onFinished: (config) => {
+            // Save config - Config component will handle completion and feedback
+            try {
+                // Convert flat dotted keys to nested structure grouped by section
+                const configBySection = unflattenConfig(config);
+                // Save each section
+                for (const [section, sectionConfig] of Object.entries(configBySection)) {
+                    saveConfig(section, sectionConfig);
+                }
             }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error
-                ? error.message
-                : 'Failed to save configuration';
-            throw new Error(errorMessage);
-        }
-    }, (operation) => {
-        context.requestHandlers.onAborted(operation);
+            catch (error) {
+                const errorMessage = error instanceof Error
+                    ? error.message
+                    : 'Failed to save configuration';
+                throw new Error(errorMessage);
+            }
+        },
+        onAborted: (operation) => {
+            context.requestHandlers.onAborted(operation);
+        },
     }));
 }
 /**
  * Route Execute tasks - creates Execute component (validation already done)
  */
 function routeExecuteTasks(tasks, context) {
-    context.workflowHandlers.addToQueue(createExecuteDefinition(tasks, context.service));
+    context.workflowHandlers.addToQueue(createExecute({ tasks, service: context.service }));
 }
 /**
  * Registry mapping task types to their route handlers

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
@@ -424,17 +430,29 @@ Example:
 
 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/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';
@@ -108,7 +109,9 @@ export const ViewComponent = memo(function ViewComponent({ def, }) {
         }
         case ComponentName.Execute: {
             const { state, status } = def;
-            return _jsx(ExecuteView, { state: state, status: status });
+            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);
         }