prompt-language-shell 0.7.2 → 0.7.6

package/README.md

@@ -28,7 +28,7 @@ $ pls list skills
 Here's what I can help with:
 
   - Introspect - list available capabilities and skills
-  - Config - manage and configure system settings
+  - Configure - manage and configure system settings
   - Answer - respond to questions and provide information
   - Execute - run shell commands and process operations
   ```
@@ -74,10 +74,10 @@ Run `pls` without arguments to see the welcome screen.
 ## How It Works
 
 When you make a request, `pls` interprets your intent and creates a structured
-plan breaking down the work into individual tasks. You'll see this plan
+plan breaking down the work into individual tasks. You'll see this schedule
 displayed in your terminal before anything executes.
 
-After reviewing the plan, you can confirm to proceed or cancel if something
+After reviewing the schedule, you can confirm to proceed or cancel if something
 doesn't look right. Once confirmed, `pls` executes each task sequentially and
 shows real-time progress and results.
 
@@ -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 === 'configure') {
-            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 configure tool only
+            if (toolName === 'configure') {
+                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

@@ -57,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,
@@ -66,6 +66,7 @@ export const Colors = {
         Ignore: Palette.BurntOrange,
         Select: Palette.SteelBlue,
         Discard: Palette.DarkOrange,
+        Group: Palette.Yellow,
     },
     Origin: {
         BuiltIn: Palette.Cyan,
@@ -81,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,
@@ -117,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)
@@ -181,7 +186,7 @@ export function getTextColor(isCurrent) {
  */
 const verboseTaskTypeLabels = {
     [TaskType.Config]: 'configure option',
-    [TaskType.Plan]: 'plan tasks',
+    [TaskType.Schedule]: 'schedule tasks',
     [TaskType.Execute]: 'execute command',
     [TaskType.Answer]: 'answer question',
     [TaskType.Introspect]: 'introspect capabilities',
@@ -190,6 +195,7 @@ const verboseTaskTypeLabels = {
     [TaskType.Ignore]: 'ignore request',
     [TaskType.Select]: 'select option',
     [TaskType.Discard]: 'discard option',
+    [TaskType.Group]: 'group tasks',
 };
 /**
  * Get task type label based on debug level.

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

@@ -37,14 +37,14 @@ import { answerTool } from '../tools/answer.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,
     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,19 +97,67 @@ 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));
+    const scheduledTasks = tasks;
+    // Process tasks in order, preserving Group boundaries
+    // Track consecutive standalone tasks to group them by type
+    let consecutiveStandaloneTasks = [];
+    const processStandaloneTasks = () => {
+        if (consecutiveStandaloneTasks.length === 0)
+            return;
+        // Group consecutive standalone tasks by type
+        const tasksByType = {};
+        for (const type of Object.values(TaskType)) {
+            tasksByType[type] = [];
+        }
+        for (const task of consecutiveStandaloneTasks) {
+            tasksByType[task.type].push(task);
+        }
+        // Route each type group
+        for (const [type, typeTasks] of Object.entries(tasksByType)) {
+            const taskType = type;
+            if (typeTasks.length === 0)
+                continue;
+            routeTasksByType(taskType, typeTasks, service, userRequest, handlers);
+        }
+        consecutiveStandaloneTasks = [];
+    };
+    // Process tasks in original order
+    for (const task of scheduledTasks) {
+        if (task.type === TaskType.Group && task.subtasks) {
+            // Process any accumulated standalone tasks first
+            processStandaloneTasks();
+            // Process Group as separate component
+            if (task.subtasks.length > 0) {
+                const subtasks = task.subtasks;
+                const taskType = subtasks[0].type;
+                routeTasksByType(taskType, subtasks, service, userRequest, handlers);
+            }
+        }
+        else {
+            // Accumulate standalone task
+            consecutiveStandaloneTasks.push(task);
+        }
+    }
+    // Process any remaining standalone tasks
+    processStandaloneTasks();
+}
+/**
+ * Route tasks by type to appropriate components
+ * Extracted to allow reuse for both Groups and standalone tasks
+ */
+function routeTasksByType(taskType, typeTasks, service, userRequest, handlers) {
+    if (taskType === TaskType.Answer) {
+        // Create separate Answer component for each question
+        for (const task of typeTasks) {
+            handlers.addToQueue(createAnswerDefinition(task.action, service));
+        }
     }
-    else if (allIntrospect) {
-        handlers.addToQueue(createIntrospectDefinition(tasks, service));
+    else if (taskType === TaskType.Introspect) {
+        handlers.addToQueue(createIntrospectDefinition(typeTasks, service));
     }
-    else if (allConfig) {
+    else if (taskType === TaskType.Config) {
         // Route to Config flow - extract keys from task params
-        const configKeys = tasks
+        const configKeys = typeTasks
             .map((task) => task.params?.key)
             .filter((key) => key !== undefined);
         handlers.addToQueue(createConfigDefinitionWithKeys(configKeys, (config) => {
@@ -121,10 +180,10 @@ function executeTasksAfterConfirm(tasks, service, userRequest, handlers) {
             handlers.onAborted(operation);
         }));
     }
-    else {
+    else if (taskType === TaskType.Execute) {
         // Execute tasks with validation
         try {
-            const validation = validateExecuteTasks(tasks);
+            const validation = validateExecuteTasks(typeTasks);
             if (validation.validationErrors.length > 0) {
                 // Show error feedback for invalid skills
                 const errorMessages = validation.validationErrors.map((error) => {
@@ -139,13 +198,13 @@ function executeTasksAfterConfirm(tasks, service, userRequest, handlers) {
                 handlers.addToQueue(createValidateDefinition(validation.missingConfig, userRequest, service, (error) => {
                     handlers.onError(error);
                 }, () => {
-                    handlers.addToQueue(createExecuteDefinition(tasks, service));
+                    handlers.addToQueue(createExecuteDefinition(typeTasks, service));
                 }, (operation) => {
                     handlers.onAborted(operation);
                 }));
             }
             else {
-                handlers.addToQueue(createExecuteDefinition(tasks, service));
+                handlers.addToQueue(createExecuteDefinition(typeTasks, service));
             }
         }
         catch (error) {

package/dist/services/skills.js

@@ -7,10 +7,10 @@ import { parseSkillMarkdown, displayNameToKey } from './parser.js';
  * Built-in skill names that user skills cannot override
  */
 const BUILT_IN_SKILLS = new Set([
-    'plan',
+    'schedule',
     'execute',
     'answer',
-    'config',
+    'configure',
     'validate',
     'introspect',
 ]);
@@ -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/answer.md

@@ -13,8 +13,8 @@ training data.
 ## Execution Flow
 
 This tool is invoked AFTER:
-1. PLAN detected an information request and created a task with type "answer"
-2. User reviewed and confirmed the plan
+1. SCHEDULE detected an information request and created a task with type "answer"
+2. User reviewed and confirmed the schedule
 3. The answer task is now being executed
 
 Your task is to provide a clear, concise answer to the user's question.

package/dist/skills/execute.md

@@ -7,11 +7,11 @@ operations when tasks with type "execute" have been planned and confirmed.
 ## Execution Flow
 
 This tool is invoked AFTER:
-1. PLAN created tasks with type "execute" describing operations to perform
-2. User reviewed and confirmed the plan
+1. SCHEDULE created tasks with type "execute" describing operations to perform
+2. User reviewed and confirmed the schedule
 3. The execute tasks are now being executed
 
-Your task is to translate the planned actions into specific shell commands
+Your task is to translate the scheduled actions into specific shell commands
 that can be run in the terminal.
 
 ## Input