prompt-language-shell 0.7.4 → 0.7.8

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.
 

package/dist/services/anthropic.js

@@ -74,8 +74,8 @@ export class AnthropicService {
                 const skillsSection = formatSkillsForPrompt(skills);
                 systemPrompt += skillsSection;
             }
-            // Add config structure for config tool only
-            if (toolName === 'config') {
+            // Add config structure for configure tool only
+            if (toolName === 'configure') {
                 const configStructure = getAvailableConfigStructure();
                 const configuredKeys = getConfiguredKeys();
                 const configSection = '\n## Available Configuration\n\n' +
@@ -165,6 +165,7 @@ export class AnthropicService {
             });
             return {
                 message: input.message,
+                summary: input.summary,
                 tasks: [],
                 commands: input.commands,
                 debug,

package/dist/services/colors.js

@@ -1,5 +1,6 @@
 import { FeedbackType, TaskType } from '../types/types.js';
 import { DebugLevel } from './configuration.js';
+import { ExecutionStatus } from './shell.js';
 /**
  * Base color palette - raw color values with descriptive names.
  * All colors used in the interface are defined here.
@@ -210,3 +211,61 @@ export function getTaskTypeLabel(type, debug) {
     }
     return type;
 }
+/**
+ * Status icons for execution states
+ */
+export const STATUS_ICONS = {
+    [ExecutionStatus.Pending]: '- ',
+    [ExecutionStatus.Running]: '• ',
+    [ExecutionStatus.Success]: '✓ ',
+    [ExecutionStatus.Failed]: '✗ ',
+    [ExecutionStatus.Aborted]: '⊘ ',
+};
+/**
+ * Get colors for different execution status states.
+ *
+ * Returns color scheme for:
+ * - Icon: Status indicator symbol
+ * - Description: Task description text
+ * - Command: Command text
+ * - Symbol: Command prefix symbol
+ */
+export function getStatusColors(status) {
+    switch (status) {
+        case ExecutionStatus.Pending:
+            return {
+                icon: Palette.Gray,
+                description: Palette.Gray,
+                command: Palette.DarkGray,
+                symbol: Palette.DarkGray,
+            };
+        case ExecutionStatus.Running:
+            return {
+                icon: Palette.Gray,
+                description: getTextColor(true),
+                command: Palette.LightGreen,
+                symbol: Palette.AshGray,
+            };
+        case ExecutionStatus.Success:
+            return {
+                icon: Colors.Status.Success,
+                description: getTextColor(true),
+                command: Palette.Gray,
+                symbol: Palette.Gray,
+            };
+        case ExecutionStatus.Failed:
+            return {
+                icon: Colors.Status.Error,
+                description: Colors.Status.Error,
+                command: Colors.Status.Error,
+                symbol: Palette.Gray,
+            };
+        case ExecutionStatus.Aborted:
+            return {
+                icon: Palette.DarkOrange,
+                description: getTextColor(true),
+                command: Palette.DarkOrange,
+                symbol: Palette.Gray,
+            };
+    }
+}

package/dist/services/components.js

@@ -361,3 +361,11 @@ export function createValidateDefinition(missingConfig, userRequest, service, on
         },
     };
 }
+/**
+ * Add debug components to timeline if present in result
+ */
+export function addDebugToTimeline(debugComponents, handlers) {
+    if (debugComponents && debugComponents.length > 0 && handlers) {
+        handlers.addToTimeline(...debugComponents);
+    }
+}

package/dist/services/router.js

@@ -97,99 +97,121 @@ function executeTasksAfterConfirm(tasks, service, userRequest, handlers) {
         handlers.onError(error instanceof Error ? error.message : String(error));
         return;
     }
-    // Flatten Group tasks to get actual executable subtasks
-    const flattenedTasks = [];
     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) {
-            // Add all subtasks from the group
-            flattenedTasks.push(...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 {
-            // Add non-group tasks as-is
-            flattenedTasks.push(task);
+            // Accumulate standalone task
+            consecutiveStandaloneTasks.push(task);
         }
     }
-    // Group flattened tasks by type - initialize all TaskType keys with empty arrays
-    const tasksByType = {};
-    for (const type of Object.values(TaskType)) {
-        tasksByType[type] = [];
+    // 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));
+        }
     }
-    for (const task of flattenedTasks) {
-        tasksByType[task.type].push(task);
+    else if (taskType === TaskType.Introspect) {
+        handlers.addToQueue(createIntrospectDefinition(typeTasks, service));
     }
-    // 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
+    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 {
-                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));
+                // 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) {
-                // Handle skill reference errors (e.g., unknown skills)
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                const message = createMessage(errorMessage);
-                handlers.addToQueue(message);
+                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 {
+            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));
+            }
+        }
+        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

@@ -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',
 ]);

package/dist/services/utils.js

@@ -1,3 +1,9 @@
+/**
+ * Calculates elapsed time from a start timestamp, rounded to seconds.
+ */
+export function calculateElapsed(start) {
+    return Math.floor((Date.now() - start) / 1000) * 1000;
+}
 /**
  * Formats a duration in milliseconds to a human-readable string.
  * Uses correct singular/plural forms.

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
@@ -88,7 +88,12 @@ these commands specifically for their environment and workflow.
 Return a structured response with commands to execute:
 
 **Response structure:**
-- **message**: Brief status message (max 64 characters, end with period)
+- **message**: Brief status message in imperative mood (max 64 characters,
+  end with colon)
+- **summary**: Natural language summary as if execution has finished,
+  like a concierge would report (max 48 characters, no period, time will
+  be appended). Use varied expressions and synonyms, not necessarily the
+  same verb as the message. MUST NOT be empty.
 - **commands**: Array of command objects to execute sequentially
 
 **Command object structure:**
@@ -133,7 +138,8 @@ Task: {
 
 Response:
 ```
-message: "Creating the file."
+message: "Create the file:"
+summary: "File created"
 commands:
   - description: "Create test.txt"
     command: "touch test.txt"
@@ -148,7 +154,8 @@ Task: {
 
 Response:
 ```
-message: "Listing directory contents."
+message: "List directory contents:"
+summary: "I've listed the directory contents"
 commands:
   - description: "List files with details"
     command: "ls -la"
@@ -167,7 +174,8 @@ Tasks:
 
 Response:
 ```
-message: "Setting up the project."
+message: "Set up the project:"
+summary: "Project ready to go"
 commands:
   - description: "Create project directory"
     command: "mkdir -p my-project"
@@ -188,7 +196,8 @@ Task: {
 
 Response:
 ```
-message: "Installing dependencies."
+message: "Install dependencies:"
+summary: "Dependencies installed successfully"
 commands:
   - description: "Install npm packages"
     command: "npm install"
@@ -224,7 +233,8 @@ The "Process Data" skill's Execution section specifies:
 
 Response (using skill's Execution commands):
 ```
-message: "Processing sales data."
+message: "Process sales data:"
+summary: "Sales data transformed and exported"
 commands:
   - description: "Load the sales dataset"
     command: "curl -O https://data.example.com/sales.csv"
@@ -250,7 +260,8 @@ Task: {
 
 Response:
 ```
-message: "Creating backup."
+message: "Create backup:"
+summary: "Backup complete"
 commands:
   - description: "Copy config directory"
     command: "cp -r ~/.config/app ~/.config/app.backup"
@@ -265,7 +276,8 @@ Task: {
 
 Response:
 ```
-message: "Checking disk space."
+message: "Check disk space:"
+summary: "Disk space verified"
 commands:
   - description: "Show disk usage"
     command: "df -h"

package/dist/skills/introspect.md

@@ -82,7 +82,7 @@ NON-NEGOTIABLE and applies to EVERY response.
 These MUST appear FIRST, in this EXACT sequence:
 
 1. **Introspect** ← ALWAYS FIRST
-2. **Config** ← ALWAYS SECOND
+2. **Configure** ← ALWAYS SECOND
 3. **Answer** ← ALWAYS THIRD
 4. **Execute** ← ALWAYS FOURTH
 
@@ -149,7 +149,7 @@ Examples:
 
 When user asks "list your skills", create an introductory message like
 "here are my capabilities:" followed by tasks for built-in capabilities
-(Introspect, Config, Answer, Execute), then indirect workflow capabilities
+(Introspect, Configure, Answer, Execute), then indirect workflow capabilities
 (Schedule, Validate, Report).
 
 Each task uses type "introspect" with an action describing the
@@ -167,7 +167,7 @@ deploy app skill with its description.
 When user asks "what can you do" and user-defined skills like "process
 data" and "backup files" exist, create an introductory message like "i can
 help with these operations:" followed by all built-in capabilities
-(Introspect, Config, Answer, Execute, Validate, Schedule, Report) plus the
+(Introspect, Configure, Answer, Execute, Validate, Schedule, Report) plus the
 user-defined skills. Each capability and skill becomes a task with type
 "introspect".
 

package/dist/skills/schedule.md

@@ -7,13 +7,17 @@ task structures with high-level tasks and their subtasks.
 ## Response Format
 
 Every response MUST include a brief message (single sentence, max 64
-characters, ending with period) that introduces the schedule.
+characters, ending with period) that introduces the schedule. Use
+either imperative mood or present tense statements, but NEVER use
+present continuous ("-ing" form).
 
-**Examples**: "Here's the schedule." / "I've organized the work." /
-"This is how I'll structure it."
+**Examples**: "Build the application." / "Here's the schedule." /
+"Deploy to production." / "I've organized the work."
 
 **Critical rules**:
 - Message is MANDATORY
+- Use imperative mood OR present tense statements
+- NEVER use present continuous ("-ing" form)
 - NEVER repeat the same message
 - ALWAYS end with period (.)
 - Vary phrasing naturally
@@ -56,6 +60,14 @@ Every task MUST have a type field. Use the appropriate type:
 a matching skill in the "Available Skills" section. DO NOT create
 `execute` tasks without a corresponding skill.
 
+**Define task params**: When creating a `define` type task, include:
+- `skill`: the skill name that needs variant selection (REQUIRED)
+- `options`: array of option strings describing each variant (REQUIRED)
+
+Example: User "build" without variant → Task with type "define",
+params { skill: "Build Project", options: ["Build project Alpha, the
+main variant", "Build project Beta, the experimental variant"] }
+
 ## Configuration Requests
 
 When user wants to configure or change settings (e.g., "config",
@@ -130,12 +142,15 @@ components (e.g., {project.VARIANT.path}, {env.TYPE.config},
 
 5. **Extract config expressions**: All leaf tasks must include a
    `config` array listing resolved configuration paths:
-   - After resolving variant placeholders, extract all config
-     expressions from the task's execution commands
+   - After resolving variant placeholders, extract **ALL** config
+     expressions from the task's execution commands (every single
+     placeholder in curly braces)
    - List them in dot notation (e.g., "project.beta.repo",
      "env.production.url")
    - The app will check if these exist in ~/.plsrc and prompt for
      missing values
+   - **CRITICAL**: If a task has multiple config placeholders, ALL
+     must be included in the config array
    - Example: Task with `cd {project.beta.repo}` and `cat
      {project.beta.config}` should include config:
      ["project.beta.repo", "project.beta.config"]
@@ -193,27 +208,51 @@ structure.
 
 ## Sequential and Multiple Requests
 
-When the user provides multiple requests separated by commas,
-semicolons, or the word "and":
+**CRITICAL**: When the user provides multiple requests separated by
+commas, semicolons, or the word "and", EVERY request must be
+represented as a separate task. DO NOT skip or merge any requests,
+even if they use the same action verb.
+
+**Sequential Processing Rules:**
+
+1. **Preserve ALL requests**: Each operation in the sequence creates a
+   separate task, in the exact order specified. Count the requests
+   carefully and verify each one is represented.
+
+2. **Same action, different subjects = separate tasks**: Multiple
+   requests using the same verb with different subjects are NOT
+   duplicates:
+   - "explain X, explain Y" → TWO separate answer tasks
+   - "process A, process B" → TWO separate task groups
+   - "show X, show Y" → TWO separate report/answer tasks
 
-1. **Preserve the sequence**: Each operation should be represented as a
-   separate task in the order specified
-2. **Independent skill matching**: For each operation, independently
+3. **Independent skill matching**: For each operation, independently
    check if it matches a skill:
    - If operation matches a skill → extract skill steps as subtasks
    - If operation does NOT match a skill → create "ignore" type task
    - **CRITICAL: Do NOT infer context or create generic execute tasks
      for unmatched operations**
-3. **No merging**: Keep operations separate even if they seem related.
-   The user's sequence is intentional.
+
+4. **No merging**: Keep operations separate even if they seem related.
+   The user's sequence is intentional and must be preserved exactly.
+
+5. **Verify completeness**: Before finalizing, count your tasks and
+   verify the count matches the number of distinct requests in the
+   user's input.
 
 **Examples:**
 
-- "explain docker, build production, then list the changes" → Three
-  separate task groups:
+- "explain docker, process data, explain kubernetes" → THREE
+  separate task groups (not two):
   - Task 1: "Explain Docker" (type: answer)
-  - Task 2: "Build production" (skill-based with subtasks)
-  - Task 3: "List the changes" (type: answer or report)
+  - 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)
@@ -270,14 +309,20 @@ Before finalizing, verify there are no duplicates.
      simple terms")
    - "list X completely" = ONE task (not "list X" + "be complete")
 
-2. **Synonymous verbs are duplicates**: Different verbs meaning the
-   same thing are duplicates
+2. **Synonymous verbs with SAME subject are duplicates**: Different
+   verbs meaning the same thing on the SAME subject are duplicates
    - "explain X" + "describe X" = DUPLICATE (choose one)
    - "show X" + "display X" = DUPLICATE (choose one)
    - "check X" + "verify X" = DUPLICATE (choose one)
 
-3. **Redundant operations are duplicates**: If two tasks would perform
-   the same operation
+3. **Same verb with DIFFERENT subjects are NOT duplicates**: This is
+   a sequential request and each must be preserved
+   - "explain X" + "explain Y" = TWO SEPARATE TASKS
+   - "process A" + "process B" = TWO SEPARATE TASKS
+   - "show X" + "show Y" = TWO SEPARATE TASKS
+
+4. **Redundant operations are duplicates**: If two tasks would perform
+   the same operation on the same target
    - "install and set up dependencies" = ONE task (setup is part of
      install)
    - "check and verify disk space" = ONE task (verify means check)
@@ -286,17 +331,22 @@ Before finalizing, verify there are no duplicates.
 
 Before finalizing the schedule, perform strict validation:
 
-1. Each task represents a distinct step in the user's request
-2. Tasks are ordered in the logical sequence they should execute
-3. Each task is clearly defined with specific action and parameters
-4. Tasks are NOT merged - preserve the user's intended sequence
-5. All operations from the user's request are represented
-6. No semantic duplicates exist (same operation with different words)
-7. For skill-based tasks, verify all required params are included
+1. **Count verification**: Count the distinct requests in the user's
+   input and verify your task list has the same number of top-level
+   tasks. If counts don't match, you've skipped or merged requests.
+2. Each task represents a distinct step in the user's request
+3. Tasks are ordered in the logical sequence they should execute
+4. Each task is clearly defined with specific action and parameters
+5. Tasks are NOT merged - preserve the user's intended sequence
+6. All operations from the user's request are represented (check each
+   one individually)
+7. No semantic duplicates exist (same verb on same subject), but same
+   verb on different subjects creates separate tasks
+8. For skill-based tasks, verify all required params are included
    (skill name, variant if applicable)
-8. For leaf tasks, verify type field is present
-9. For leaf tasks with config placeholders, verify config array is
-   populated
+9. For leaf tasks, verify type field is present
+10. For leaf tasks with config placeholders, verify config array is
+    populated
 
 ## Critical Guidelines