prompt-language-shell 0.7.0 → 0.7.4

package/README.md

@@ -159,7 +159,6 @@ $ pls build test
 
 ## Roadmap
 
-- **0.7** - Comprehend skill, simplified prompts, better debugging
 - **0.8** - Sequential and interlaced skill execution
 - **0.9** - Learn skill, codebase refinement, complex dependency handling
 - **1.0** - Production release

package/dist/services/anthropic.js

@@ -52,31 +52,39 @@ export class AnthropicService {
         this.client = new Anthropic({ apiKey: key });
         this.model = model;
     }
-    async processWithTool(command, toolName) {
+    async processWithTool(command, toolName, customInstructions) {
         // Load tool from registry
         const tool = toolRegistry.getSchema(toolName);
-        const instructions = toolRegistry.getInstructions(toolName);
-        // Build system prompt with additional context based on tool
-        let systemPrompt = instructions;
-        // Add skills section for applicable tools
-        if (toolName === 'plan' ||
-            toolName === 'introspect' ||
-            toolName === 'execute' ||
-            toolName === 'validate') {
-            const skills = loadSkillsWithValidation();
-            const skillsSection = formatSkillsForPrompt(skills);
-            systemPrompt += skillsSection;
+        // Use custom instructions if provided, otherwise load from registry
+        let systemPrompt;
+        if (customInstructions) {
+            // Custom instructions provided (typically for testing)
+            systemPrompt = customInstructions;
         }
-        // Add config structure for config tool only
-        if (toolName === 'config') {
-            const configStructure = getAvailableConfigStructure();
-            const configuredKeys = getConfiguredKeys();
-            const configSection = '\n## Available Configuration\n\n' +
-                'Config structure (key: description):\n' +
-                JSON.stringify(configStructure, null, 2) +
-                '\n\nConfigured keys (keys that exist in config file):\n' +
-                JSON.stringify(configuredKeys, null, 2);
-            systemPrompt += configSection;
+        else {
+            // Load and build system prompt automatically (production)
+            const instructions = toolRegistry.getInstructions(toolName);
+            systemPrompt = instructions;
+            // Add skills section for applicable tools
+            if (toolName === 'schedule' ||
+                toolName === 'introspect' ||
+                toolName === 'execute' ||
+                toolName === 'validate') {
+                const skills = loadSkillsWithValidation();
+                const skillsSection = formatSkillsForPrompt(skills);
+                systemPrompt += skillsSection;
+            }
+            // Add config structure for config tool only
+            if (toolName === 'config') {
+                const configStructure = getAvailableConfigStructure();
+                const configuredKeys = getConfiguredKeys();
+                const configSection = '\n## Available Configuration\n\n' +
+                    'Config structure (key: description):\n' +
+                    JSON.stringify(configStructure, null, 2) +
+                    '\n\nConfigured keys (keys that exist in config file):\n' +
+                    JSON.stringify(configuredKeys, null, 2);
+                systemPrompt += configSection;
+            }
         }
         // Build tools array - add web search for answer tool
         const tools = [tool];
@@ -177,7 +185,7 @@ export class AnthropicService {
                 debug,
             };
         }
-        // Handle plan and introspect tool responses
+        // Handle schedule and introspect tool responses
         if (input.message === undefined || typeof input.message !== 'string') {
             throw new Error('Invalid tool response: missing or invalid message field');
         }

package/dist/services/colors.js

@@ -1,4 +1,5 @@
 import { FeedbackType, TaskType } from '../types/types.js';
+import { DebugLevel } from './configuration.js';
 /**
  * Base color palette - raw color values with descriptive names.
  * All colors used in the interface are defined here.
@@ -56,7 +57,7 @@ export const Colors = {
     },
     Type: {
         Config: Palette.Cyan,
-        Plan: Palette.LightCyan,
+        Schedule: Palette.LightCyan,
         Execute: Palette.Green,
         Answer: Palette.Purple,
         Introspect: Palette.Purple,
@@ -65,6 +66,7 @@ export const Colors = {
         Ignore: Palette.BurntOrange,
         Select: Palette.SteelBlue,
         Discard: Palette.DarkOrange,
+        Group: Palette.Yellow,
     },
     Origin: {
         BuiltIn: Palette.Cyan,
@@ -80,9 +82,9 @@ const taskColors = {
         description: Colors.Label.Default,
         type: Colors.Type.Config,
     },
-    [TaskType.Plan]: {
+    [TaskType.Schedule]: {
         description: Colors.Label.Default,
-        type: Colors.Type.Plan,
+        type: Colors.Type.Schedule,
     },
     [TaskType.Execute]: {
         description: Colors.Label.Default,
@@ -116,6 +118,10 @@ const taskColors = {
         description: Colors.Label.Discarded,
         type: Colors.Type.Discard,
     },
+    [TaskType.Group]: {
+        description: Colors.Label.Default,
+        type: Colors.Type.Group,
+    },
 };
 /**
  * Feedback-specific color mappings (internal)
@@ -174,3 +180,33 @@ export function getFeedbackColor(type, isCurrent) {
 export function getTextColor(isCurrent) {
     return isCurrent ? Colors.Text.Active : Colors.Text.Inactive;
 }
+/**
+ * Verbose task type labels - two-word descriptions that start with the same
+ * keyword as the short version
+ */
+const verboseTaskTypeLabels = {
+    [TaskType.Config]: 'configure option',
+    [TaskType.Schedule]: 'schedule tasks',
+    [TaskType.Execute]: 'execute command',
+    [TaskType.Answer]: 'answer question',
+    [TaskType.Introspect]: 'introspect capabilities',
+    [TaskType.Report]: 'report results',
+    [TaskType.Define]: 'define options',
+    [TaskType.Ignore]: 'ignore request',
+    [TaskType.Select]: 'select option',
+    [TaskType.Discard]: 'discard option',
+    [TaskType.Group]: 'group tasks',
+};
+/**
+ * Get task type label based on debug level.
+ *
+ * Returns:
+ * - Verbose label (2 words) in verbose mode
+ * - Short label (1 word) in info mode or when debug is off
+ */
+export function getTaskTypeLabel(type, debug) {
+    if (debug === DebugLevel.Verbose) {
+        return verboseTaskTypeLabels[type];
+    }
+    return type;
+}

package/dist/services/components.js

@@ -216,10 +216,10 @@ export function createCommandDefinition(command, service) {
         },
     };
 }
-export function createPlanDefinition(message, tasks, onSelectionConfirmed) {
+export function createScheduleDefinition(message, tasks, onSelectionConfirmed) {
     return {
         id: randomUUID(),
-        name: ComponentName.Plan,
+        name: ComponentName.Schedule,
         status: ComponentStatus.Awaiting,
         state: {
             highlightedIndex: null,

package/dist/services/refinement.js

@@ -21,7 +21,7 @@ export async function handleRefinement(selectedTasks, service, originalCommand,
         })
             .join(', ');
         // Call LLM to refine plan with selected tasks
-        const refinedResult = await service.processWithTool(refinedCommand, 'plan');
+        const refinedResult = await service.processWithTool(refinedCommand, 'schedule');
         // Complete the Refinement component
         handlers.completeActive();
         // Add debug components to timeline if present

package/dist/services/registry.js

@@ -34,17 +34,17 @@ class ToolRegistry {
 export const toolRegistry = new ToolRegistry();
 // Register built-in tools
 import { answerTool } from '../tools/answer.tool.js';
-import { configTool } from '../tools/config.tool.js';
+import { configureTool } from '../tools/configure.tool.js';
 import { executeTool } from '../tools/execute.tool.js';
 import { introspectTool } from '../tools/introspect.tool.js';
-import { planTool } from '../tools/plan.tool.js';
+import { scheduleTool } from '../tools/schedule.tool.js';
 import { validateTool } from '../tools/validate.tool.js';
 const tools = {
     answer: answerTool,
-    config: configTool,
+    configure: configureTool,
     execute: executeTool,
     introspect: introspectTool,
-    plan: planTool,
+    schedule: scheduleTool,
     validate: validateTool,
 };
 for (const [name, schema] of Object.entries(tools)) {

package/dist/services/router.js

@@ -1,5 +1,5 @@
 import { TaskType } from '../types/types.js';
-import { createAnswerDefinition, createConfigDefinitionWithKeys, createConfirmDefinition, createExecuteDefinition, createFeedback, createIntrospectDefinition, createMessage, createPlanDefinition, createValidateDefinition, } from './components.js';
+import { createAnswerDefinition, createConfigDefinitionWithKeys, createConfirmDefinition, createExecuteDefinition, createFeedback, createIntrospectDefinition, createMessage, createScheduleDefinition, createValidateDefinition, } from './components.js';
 import { saveConfig, unflattenConfig } from './configuration.js';
 import { FeedbackType } from '../types/types.js';
 import { validateExecuteTasks } from './validator.js';
@@ -33,52 +33,63 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, hand
     }
     const operation = getOperationName(validTasks);
     if (hasDefineTask) {
-        // Has DEFINE tasks - add Plan to queue for user selection
+        // Has DEFINE tasks - add Schedule to queue for user selection
         // Refinement flow will call this function again with refined tasks
-        const planDefinition = createPlanDefinition(message, validTasks);
-        handlers.addToQueue(planDefinition);
+        const scheduleDefinition = createScheduleDefinition(message, validTasks);
+        handlers.addToQueue(scheduleDefinition);
     }
     else {
-        // No DEFINE tasks - Plan auto-completes and adds Confirm to queue
-        // When Plan activates, Command moves to timeline
-        // When Plan completes, it moves to pending
-        // When Confirm activates, Plan stays pending (visible for context)
-        const planDefinition = createPlanDefinition(message, validTasks, () => {
-            // Plan completed - add Confirm to queue
+        // No DEFINE tasks - Schedule auto-completes and adds Confirm to queue
+        // 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 Plan, then route to appropriate component
+                // User confirmed - complete both Confirm and Schedule, then route to appropriate component
                 handlers.completeActiveAndPending();
                 executeTasksAfterConfirm(validTasks, service, userRequest, handlers);
             }, () => {
-                // User cancelled - complete both Confirm and Plan, then show cancellation
+                // User cancelled - complete both Confirm and Schedule, then show cancellation
                 handlers.completeActiveAndPending();
                 const message = getCancellationMessage(operation);
                 handlers.addToQueue(createFeedback(FeedbackType.Aborted, message));
             });
             handlers.addToQueue(confirmDefinition);
         });
-        handlers.addToQueue(planDefinition);
+        handlers.addToQueue(scheduleDefinition);
     }
 }
 /**
- * Validate that all tasks have the same type
- * Per FLOWS.md: "Mixed types → Error (not supported)"
+ * Validate task types - allows mixed types at top level with Groups,
+ * but each Group must have uniform subtask types
  */
 function validateTaskTypes(tasks) {
     if (tasks.length === 0)
         return;
-    const types = new Set(tasks.map((task) => task.type));
-    if (types.size > 1) {
-        throw new Error(getMixedTaskTypesError(Array.from(types)));
+    // Cast to ScheduledTask to access subtasks property
+    const scheduledTasks = tasks;
+    // Check each Group task's subtasks for uniform types
+    for (const task of scheduledTasks) {
+        if (task.type === TaskType.Group &&
+            task.subtasks &&
+            task.subtasks.length > 0) {
+            const subtaskTypes = new Set(task.subtasks.map((t) => t.type));
+            if (subtaskTypes.size > 1) {
+                throw new Error(getMixedTaskTypesError(Array.from(subtaskTypes)));
+            }
+            // Recursively validate nested groups
+            validateTaskTypes(task.subtasks);
+        }
     }
 }
 /**
  * Execute tasks after confirmation (internal helper)
- * Validates task types after user has seen and confirmed the plan
+ * Validates task types and routes each type appropriately
+ * Supports mixed types at top level with Groups
  */
 function executeTasksAfterConfirm(tasks, service, userRequest, handlers) {
-    // Validate all tasks have the same type after user confirmation
-    // Per FLOWS.md: "Confirm component completes → Execution handler analyzes task types"
+    // Validate task types (Groups must have uniform subtasks)
     try {
         validateTaskTypes(tasks);
     }
@@ -86,75 +97,99 @@ function executeTasksAfterConfirm(tasks, service, userRequest, handlers) {
         handlers.onError(error instanceof Error ? error.message : String(error));
         return;
     }
-    const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
-    const allAnswer = tasks.every((task) => task.type === TaskType.Answer);
-    const allConfig = tasks.every((task) => task.type === TaskType.Config);
-    if (allAnswer) {
-        const question = tasks[0].action;
-        handlers.addToQueue(createAnswerDefinition(question, service));
+    // Flatten Group tasks to get actual executable subtasks
+    const flattenedTasks = [];
+    const scheduledTasks = tasks;
+    for (const task of scheduledTasks) {
+        if (task.type === TaskType.Group && task.subtasks) {
+            // Add all subtasks from the group
+            flattenedTasks.push(...task.subtasks);
+        }
+        else {
+            // Add non-group tasks as-is
+            flattenedTasks.push(task);
+        }
     }
-    else if (allIntrospect) {
-        handlers.addToQueue(createIntrospectDefinition(tasks, service));
+    // Group flattened tasks by type - initialize all TaskType keys with empty arrays
+    const tasksByType = {};
+    for (const type of Object.values(TaskType)) {
+        tasksByType[type] = [];
     }
-    else if (allConfig) {
-        // Route to Config flow - extract keys from task params
-        const configKeys = tasks
-            .map((task) => task.params?.key)
-            .filter((key) => key !== undefined);
-        handlers.addToQueue(createConfigDefinitionWithKeys(configKeys, (config) => {
-            // Save config using the same pattern as Validate component
+    for (const task of flattenedTasks) {
+        tasksByType[task.type].push(task);
+    }
+    // Route each type group appropriately
+    for (const [type, typeTasks] of Object.entries(tasksByType)) {
+        const taskType = type;
+        // Skip empty task groups (pre-initialized but unused)
+        if (typeTasks.length === 0) {
+            continue;
+        }
+        if (taskType === TaskType.Answer) {
+            const question = typeTasks[0].action;
+            handlers.addToQueue(createAnswerDefinition(question, service));
+        }
+        else if (taskType === TaskType.Introspect) {
+            handlers.addToQueue(createIntrospectDefinition(typeTasks, service));
+        }
+        else if (taskType === TaskType.Config) {
+            // Route to Config flow - extract keys from task params
+            const configKeys = typeTasks
+                .map((task) => task.params?.key)
+                .filter((key) => key !== undefined);
+            handlers.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);
+                    }
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error
+                        ? error.message
+                        : 'Failed to save configuration';
+                    throw new Error(errorMessage);
+                }
+            }, (operation) => {
+                handlers.onAborted(operation);
+            }));
+        }
+        else if (taskType === TaskType.Execute) {
+            // Execute tasks with validation
             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);
+                const validation = validateExecuteTasks(typeTasks);
+                if (validation.validationErrors.length > 0) {
+                    // Show error feedback for invalid skills
+                    const errorMessages = validation.validationErrors.map((error) => {
+                        const issuesList = error.issues
+                            .map((issue) => `  - ${issue}`)
+                            .join('\n');
+                        return `Invalid skill definition "${error.skill}":\n\n${issuesList}`;
+                    });
+                    handlers.addToQueue(createFeedback(FeedbackType.Failed, errorMessages.join('\n\n')));
+                }
+                else if (validation.missingConfig.length > 0) {
+                    handlers.addToQueue(createValidateDefinition(validation.missingConfig, userRequest, service, (error) => {
+                        handlers.onError(error);
+                    }, () => {
+                        handlers.addToQueue(createExecuteDefinition(typeTasks, service));
+                    }, (operation) => {
+                        handlers.onAborted(operation);
+                    }));
+                }
+                else {
+                    handlers.addToQueue(createExecuteDefinition(typeTasks, service));
                 }
-                handlers.completeActive();
-                handlers.addToQueue(createFeedback(FeedbackType.Succeeded, 'Configuration updated successfully.'));
             }
             catch (error) {
-                const errorMessage = error instanceof Error
-                    ? error.message
-                    : 'Failed to save configuration';
-                handlers.onError(errorMessage);
-            }
-        }, (operation) => {
-            handlers.onAborted(operation);
-        }));
-    }
-    else {
-        // Execute tasks with validation
-        try {
-            const validation = validateExecuteTasks(tasks);
-            if (validation.validationErrors.length > 0) {
-                // Show error feedback for invalid skills
-                const errorMessages = validation.validationErrors.map((error) => {
-                    const issuesList = error.issues
-                        .map((issue) => `  - ${issue}`)
-                        .join('\n');
-                    return `Invalid skill definition "${error.skill}":\n\n${issuesList}`;
-                });
-                handlers.addToQueue(createFeedback(FeedbackType.Failed, errorMessages.join('\n\n')));
-            }
-            else if (validation.missingConfig.length > 0) {
-                handlers.addToQueue(createValidateDefinition(validation.missingConfig, userRequest, service, (error) => {
-                    handlers.onError(error);
-                }, () => {
-                    handlers.addToQueue(createExecuteDefinition(tasks, service));
-                }, (operation) => {
-                    handlers.onAborted(operation);
-                }));
+                // Handle skill reference errors (e.g., unknown skills)
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                const message = createMessage(errorMessage);
+                handlers.addToQueue(message);
             }
-            else {
-                handlers.addToQueue(createExecuteDefinition(tasks, service));
-            }
-        }
-        catch (error) {
-            // Handle skill reference errors (e.g., unknown skills)
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            const message = createMessage(errorMessage);
-            handlers.addToQueue(message);
         }
     }
 }

package/dist/services/skills.js

@@ -146,8 +146,11 @@ brackets for additional information. Use commas instead. For example:
 - WRONG: "Build project Alpha (the legacy version)"
 
 `;
-    const skillsContent = skills.map((s) => s.trim()).join('\n\n');
-    return header + skillsContent;
+    const separator = '-'.repeat(64);
+    const skillsContent = skills
+        .map((s) => s.trim())
+        .join('\n\n' + separator + '\n\n');
+    return header + separator + '\n\n' + skillsContent;
 }
 /**
  * Parse skill reference from execution line

package/dist/services/utils.js

@@ -19,3 +19,19 @@ export function formatDuration(ms) {
     }
     return parts.join(' ');
 }
+/**
+ * Recursively extracts all leaf tasks from a hierarchical task structure.
+ * Leaf tasks are tasks without subtasks.
+ */
+export function getAllLeafTasks(tasks) {
+    const leafTasks = [];
+    for (const task of tasks) {
+        if (!task.subtasks || task.subtasks.length === 0) {
+            leafTasks.push(task);
+        }
+        else {
+            leafTasks.push(...getAllLeafTasks(task.subtasks));
+        }
+    }
+    return leafTasks;
+}

package/dist/services/validator.js

@@ -1,7 +1,5 @@
-import { extractPlaceholders, pathToString, resolveVariant, } from './resolver.js';
 import { loadUserConfig, hasConfigPath } from './loader.js';
-import { loadSkillDefinitions, createSkillLookup, expandSkillReferences, } from './skills.js';
-import { getConfigType } from './parser.js';
+import { loadSkillDefinitions, createSkillLookup } from './skills.js';
 /**
  * Validate config requirements for execute tasks
  * Returns validation result with missing config and validation errors
@@ -38,88 +36,22 @@ export function validateExecuteTasks(tasks) {
         };
     }
     for (const task of tasks) {
-        // Check if task originates from a skill
-        const skillName = typeof task.params?.skill === 'string' ? task.params.skill : null;
-        if (skillName) {
-            // Task comes from a skill - check skill's Execution section
-            const skill = skillLookup(skillName);
-            if (!skill) {
-                continue;
-            }
-            // Get variant from task params (if any)
-            // Try params.variant first, then look for other param keys that might be the variant
-            let variant = null;
-            if (typeof task.params?.variant === 'string') {
-                variant = task.params.variant.toLowerCase();
-            }
-            else if (task.params && typeof task.params === 'object') {
-                // Look for other params that could be the variant (e.g., product, target, option, etc.)
-                // Exclude known non-variant params
-                const excludeKeys = new Set(['skill', 'type']);
-                for (const [key, value] of Object.entries(task.params)) {
-                    if (!excludeKeys.has(key) && typeof value === 'string') {
-                        variant = value.toLowerCase();
-                        break;
-                    }
-                }
-            }
-            // Expand skill references to get actual commands
-            const expanded = expandSkillReferences(skill.execution, skillLookup);
-            // Extract placeholders from actual commands
-            for (const line of expanded) {
-                const placeholders = extractPlaceholders(line);
-                for (const placeholder of placeholders) {
-                    let resolvedPath;
-                    if (placeholder.hasVariant) {
-                        // Variant placeholder - resolve with variant from params
-                        if (!variant) {
-                            // No variant provided - skip this placeholder
-                            continue;
-                        }
-                        const resolvedPathArray = resolveVariant(placeholder.path, variant);
-                        resolvedPath = pathToString(resolvedPathArray);
-                    }
-                    else {
-                        // Strict placeholder - use as-is
-                        resolvedPath = pathToString(placeholder.path);
-                    }
-                    // Skip if already processed
-                    if (seenPaths.has(resolvedPath)) {
-                        continue;
-                    }
-                    seenPaths.add(resolvedPath);
-                    // Check if config exists
-                    if (!hasConfigPath(userConfig, resolvedPath)) {
-                        // Get type from skill config
-                        const type = skill.config
-                            ? getConfigType(skill.config, resolvedPath)
-                            : undefined;
-                        missing.push({
-                            path: resolvedPath,
-                            type: type || 'string',
-                        });
-                    }
-                }
-            }
-        }
-        else {
-            // Task doesn't come from a skill - check task action for placeholders
-            const placeholders = extractPlaceholders(task.action);
-            for (const placeholder of placeholders) {
-                // Skip variant placeholders - they should have been resolved during planning
-                if (placeholder.hasVariant) {
+        // Check task's config array from SCHEDULE tool
+        // This is the authoritative source for required configuration
+        if (task.config && task.config.length > 0) {
+            for (const configPath of task.config) {
+                if (typeof configPath !== 'string') {
                     continue;
                 }
-                const path = placeholder.path.join('.');
                 // Skip if already processed
-                if (seenPaths.has(path)) {
+                if (seenPaths.has(configPath)) {
                     continue;
                 }
-                seenPaths.add(path);
+                seenPaths.add(configPath);
                 // Check if config exists
-                if (!hasConfigPath(userConfig, path)) {
+                if (!hasConfigPath(userConfig, configPath)) {
                     missing.push({
-                        path,
+                        path: configPath,
                         type: 'string', // Default to string for now
                     });
                 }

package/dist/skills/{config.md → configure.md}

@@ -49,14 +49,14 @@ as tasks.
   "tasks": [
     {
       "action": "Anthropic API key",
-      "type": "config",
+      "type": "configure",
       "params": {
         "key": "anthropic.key"
       }
     },
     {
       "action": "Model",
-      "type": "config",
+      "type": "configure",
       "params": {
         "key": "anthropic.model"
       }
@@ -69,7 +69,7 @@ as tasks.
 
 - Use the exact config keys from `configStructure`
 - Use the descriptions from `configStructure` as the action text
-- Always use type "config"
+- Always use type "configure"
 - Always include the key in params
 - Keep message concise (≤64 characters)
 - Return at least one task (required keys if unsure)