prompt-language-shell 0.4.4 → 0.4.8

package/dist/config/CONFIG.md

@@ -0,0 +1,66 @@
+## Overview
+
+You are the CONFIG tool for "pls" (please), a professional command-line concierge.
+Your role is to determine which configuration settings the user wants to configure
+based on their query.
+
+## Input
+
+You will receive:
+- `configStructure`: Object mapping config keys to descriptions (e.g., {"anthropic.key": "Anthropic API key"})
+- `query`: User's request (e.g., "app", "mode", "anthropic", or empty)
+
+## Task
+
+Determine which config keys the user wants to configure and return them as tasks.
+
+## Mapping Rules
+
+### Query: "app" or empty/unclear
+- Return all **required** config keys (those needed for the app to work)
+- Also include any **optional** config keys that are marked as "(discovered)" (they exist in user's config file)
+- Required keys: `anthropic.key`, `anthropic.model`
+
+### Query: "mode"
+- Return only: `settings.debug`
+
+### Query: "anthropic"
+- Return all keys starting with `anthropic.` (usually `anthropic.key` and `anthropic.model`)
+
+### Other queries
+- Match the query against config key names and descriptions
+- Return keys that seem relevant to the query
+- If unclear, return only required keys
+
+## Response Format
+
+```json
+{
+  "message": "Brief intro message ending with period.",
+  "tasks": [
+    {
+      "action": "Anthropic API key",
+      "type": "config",
+      "params": {
+        "key": "anthropic.key"
+      }
+    },
+    {
+      "action": "Model",
+      "type": "config",
+      "params": {
+        "key": "anthropic.model"
+      }
+    }
+  ]
+}
+```
+
+## Important
+
+- Use the exact config keys from `configStructure`
+- Use the descriptions from `configStructure` as the action text
+- Always use type "config"
+- Always include the key in params
+- Keep message concise (≤64 characters)
+- Return at least one task (required keys if unsure)

package/dist/config/INTROSPECT.md

@@ -53,21 +53,36 @@ Every response MUST include an introductory message before the capability list.
 
 ## Capabilities Structure
 
-Present capabilities in two categories:
+**⚠️ CRITICAL ORDERING REQUIREMENT ⚠️**
 
-### 1. Built-in Capabilities
+You MUST present capabilities in the EXACT order specified below. This is
+NON-NEGOTIABLE and applies to EVERY response.
 
-These are the core operations available to all users:
+**DO NOT:**
+- Reorder capabilities based on alphabetical sorting
+- Put Plan or Report first (this is WRONG)
+- Rearrange based on perceived importance
+- Deviate from this order for any reason
 
-- **Config**: Configuration changes, settings updates
-- **Plan**: Plan and structure tasks from natural language requests, breaking
-  them down into clear, actionable steps
-- **Introspect**: List and describe available capabilities and skills
-- **Answer**: Answer questions, explain concepts, provide information
-- **Execute**: Run shell commands, execute programs, process operations
-- **Report**: Generate summaries, create reports, display results
+**CORRECT ORDER - FOLLOW EXACTLY:**
 
-### 2. User-Defined Skills
+### Position 1-4: Built-in Capabilities (Direct User Operations)
+
+These MUST appear FIRST, in this EXACT sequence:
+
+1. **Introspect** ← ALWAYS FIRST
+2. **Config** ← ALWAYS SECOND
+3. **Answer** ← ALWAYS THIRD
+4. **Execute** ← ALWAYS FOURTH
+
+### Position 5-6: Indirect Workflow Capabilities
+
+These MUST appear AFTER Execute and BEFORE user skills:
+
+5. **Plan** ← NEVER FIRST, ALWAYS position 5 (after Execute)
+6. **Report** ← NEVER FIRST, ALWAYS position 6 (after Plan)
+
+### 3. User-Defined Skills
 
 If skills are provided in the "Available Skills" section below, include them
 in the response. For each skill:
@@ -116,9 +131,9 @@ Examples:
 ### Example 1: List All Capabilities
 
 When user asks "list your skills", create an introductory message like "here
-are my capabilities:" followed by a task for each built-in capability: Plan,
-Introspect, Answer, Execute, Report, and Config. Each task uses type
-"introspect" with an action describing the capability.
+are my capabilities:" followed by tasks for built-in capabilities (Introspect,
+Config, Answer, Execute), then indirect workflow capabilities (Plan, Report).
+Each task uses type "introspect" with an action describing the capability.
 
 ### Example 2: Filtered Skills
 

package/dist/config/PLAN.md

@@ -422,6 +422,27 @@ When creating task definitions, focus on:
 Prioritize clarity and precision over brevity. Each task should be unambiguous
 and executable.
 
+## Configuration Requests
+
+When the user wants to configure or change settings (e.g., "pls config", "pls configure", "pls change settings", "pls run settings", "pls config anthropic", "pls config mode"), create a SINGLE task with type "config".
+
+**Task format:**
+- **action**: "Configure settings" (or similar natural description)
+- **type**: "config"
+- **params**: Include `{ "query": "filter" }` where filter specifies which settings to configure:
+  - If command contains specific keywords like "anthropic", "mode", "debug" → use that keyword
+  - If command is just "config" or "configure" or "settings" with no specific area → use "app"
+  - Extract the relevant context, not the full command
+
+**Examples:**
+- User: "pls config anthropic" → `{ "action": "Configure settings", "type": "config", "params": { "query": "anthropic" } }`
+- User: "pls configure" → `{ "action": "Configure settings", "type": "config", "params": { "query": "app" } }`
+- User: "pls run settings" → `{ "action": "Configure settings", "type": "config", "params": { "query": "app" } }`
+- User: "pls config mode" → `{ "action": "Configure settings", "type": "config", "params": { "query": "mode" } }`
+- User: "pls change debug settings" → `{ "action": "Configure settings", "type": "config", "params": { "query": "mode" } }`
+
+The CONFIG tool will handle determining which specific config keys to show based on the query.
+
 ## Multiple Tasks
 
 When the user provides multiple tasks separated by commas, semicolons, or the

package/dist/handlers/config.js

@@ -1,7 +1,7 @@
 import { ComponentName, FeedbackType } from '../types/types.js';
 import { createAnthropicService, } from '../services/anthropic.js';
 import { createCommandDefinition, createFeedback, markAsDone, } from '../services/components.js';
-import { saveAnthropicConfig } from '../services/configuration.js';
+import { saveAnthropicConfig, saveConfig } from '../services/configuration.js';
 import { FeedbackMessages } from '../services/messages.js';
 import { exitApp } from '../services/process.js';
 import { withQueueHandler } from '../services/queue.js';
@@ -37,3 +37,44 @@ export function createConfigAbortedHandler(handleAborted) {
         handleAborted('Configuration');
     };
 }
+/**
+ * Creates config execution finished handler for CONFIG skill
+ * Saves arbitrary config keys and exits
+ */
+export function createConfigExecutionFinishedHandler(addToTimeline, keys) {
+    return (config) => {
+        // Map short keys back to full keys and save
+        // Group by section (e.g., "anthropic", "settings")
+        const sections = {};
+        for (const fullKey of keys) {
+            const parts = fullKey.split('.');
+            const shortKey = parts[parts.length - 1];
+            const section = parts.slice(0, -1).join('.');
+            sections[section] = sections[section] ?? {};
+            if (shortKey in config) {
+                sections[section][shortKey] = config[shortKey];
+            }
+        }
+        // Save each section
+        for (const [section, sectionConfig] of Object.entries(sections)) {
+            saveConfig(section, sectionConfig);
+        }
+        return withQueueHandler(ComponentName.Config, (first, rest) => {
+            addToTimeline(markAsDone(first), createFeedback(FeedbackType.Succeeded, FeedbackMessages.ConfigurationComplete));
+            exitApp(0);
+            return rest;
+        }, false, 0);
+    };
+}
+/**
+ * Creates config execution aborted handler for CONFIG skill
+ */
+export function createConfigExecutionAbortedHandler(addToTimeline) {
+    return () => {
+        return withQueueHandler(ComponentName.Config, (first, rest) => {
+            addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, 'Configuration cancelled.'));
+            exitApp(0);
+            return rest;
+        }, false, 0);
+    };
+}

package/dist/handlers/execution.js

@@ -1,12 +1,13 @@
 import { ComponentName, FeedbackType, TaskType } from '../types/types.js';
-import { createAnswerDefinition, createFeedback, createIntrospectDefinition, markAsDone, } from '../services/components.js';
+import { createAnswerDefinition, createConfigDefinitionWithKeys, createFeedback, createIntrospectDefinition, markAsDone, } from '../services/components.js';
+import { createConfigExecutionAbortedHandler, createConfigExecutionFinishedHandler, } from './config.js';
 import { getCancellationMessage } from '../services/messages.js';
 import { exitApp } from '../services/process.js';
 import { withQueueHandler } from '../services/queue.js';
 /**
  * Creates execution confirmed handler
  */
-export function createExecutionConfirmedHandler(timelineRef, addToTimeline, service, handleIntrospectError, handleIntrospectComplete, handleIntrospectAborted, handleAnswerError, handleAnswerComplete, handleAnswerAborted) {
+export function createExecutionConfirmedHandler(timelineRef, addToTimeline, service, handleIntrospectError, handleIntrospectComplete, handleIntrospectAborted, handleAnswerError, handleAnswerComplete, handleAnswerAborted, setQueue) {
     return () => withQueueHandler(ComponentName.Confirm, (first) => {
         // Find the most recent Plan in timeline to get tasks
         const currentTimeline = timelineRef.current;
@@ -22,6 +23,7 @@ export function createExecutionConfirmedHandler(timelineRef, addToTimeline, serv
             : [];
         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 (allIntrospect && tasks.length > 0) {
             // Execute introspection
             addToTimeline(markAsDone(first));
@@ -37,6 +39,24 @@ export function createExecutionConfirmedHandler(timelineRef, addToTimeline, serv
                 createAnswerDefinition(question, service, handleAnswerError, handleAnswerComplete, handleAnswerAborted),
             ];
         }
+        else if (allConfig && tasks.length > 0) {
+            // Execute config - extract keys from task params
+            const keys = tasks
+                .map((task) => task.params?.key)
+                .filter((key) => typeof key === 'string');
+            addToTimeline(markAsDone(first));
+            // Create handlers with keys for proper saving
+            // Wrap in setQueue to properly update queue when Config finishes
+            const handleConfigFinished = (config) => {
+                setQueue(createConfigExecutionFinishedHandler(addToTimeline, keys)(config));
+            };
+            const handleConfigAborted = () => {
+                setQueue(createConfigExecutionAbortedHandler(addToTimeline)());
+            };
+            return [
+                createConfigDefinitionWithKeys(keys, handleConfigFinished, handleConfigAborted),
+            ];
+        }
         else {
             // Regular execution - just exit for now
             addToTimeline(markAsDone(first));

package/dist/handlers/plan.js

@@ -1,6 +1,6 @@
 import { ComponentName, FeedbackType, TaskType } from '../types/types.js';
 import { createConfirmDefinition, createFeedback, createPlanDefinition, markAsDone, createRefinement, } from '../services/components.js';
-import { FeedbackMessages, getRefiningMessage } from '../services/messages.js';
+import { FeedbackMessages, formatErrorMessage, getRefiningMessage, } from '../services/messages.js';
 import { exitApp } from '../services/process.js';
 /**
  * Creates plan aborted handler
@@ -66,7 +66,7 @@ export function createPlanSelectionConfirmedHandler(addToTimeline, service, hand
             setQueue([confirmDefinition]);
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            const errorMessage = formatErrorMessage(error);
             // Mark refinement as done and move to timeline before showing error
             setQueue((currentQueue) => {
                 if (currentQueue.length > 0 &&

package/dist/services/anthropic.js

@@ -1,4 +1,5 @@
 import Anthropic from '@anthropic-ai/sdk';
+import { getAvailableConfigStructure, } from './configuration.js';
 import { formatSkillsForPrompt, loadSkills } from './skills.js';
 import { toolRegistry } from './tool-registry.js';
 export class AnthropicService {
@@ -12,16 +13,36 @@ export class AnthropicService {
         // Load tool from registry
         const tool = toolRegistry.getSchema(toolName);
         const instructions = toolRegistry.getInstructions(toolName);
-        // Load skills and augment the instructions
-        const skills = loadSkills();
-        const skillsSection = formatSkillsForPrompt(skills);
-        const systemPrompt = instructions + skillsSection;
+        // Build system prompt with additional context based on tool
+        let systemPrompt = instructions;
+        // Add skills section for applicable tools
+        if (toolName === 'plan' || toolName === 'introspect') {
+            const skills = loadSkills();
+            const skillsSection = formatSkillsForPrompt(skills);
+            systemPrompt += skillsSection;
+        }
+        // Add config structure for config tool only
+        if (toolName === 'config') {
+            const configStructure = getAvailableConfigStructure();
+            const configSection = '\n\n## Available Configuration\n\n' +
+                'Config structure (key: description):\n' +
+                JSON.stringify(configStructure, null, 2);
+            systemPrompt += configSection;
+        }
+        // Build tools array - add web search for answer tool
+        const tools = [tool];
+        if (toolName === 'answer') {
+            tools.push({
+                type: 'web_search_20250305',
+                name: 'web_search',
+            });
+        }
         // Call API with tool
         const response = await this.client.messages.create({
             model: this.model,
             max_tokens: 1024,
             system: systemPrompt,
-            tools: [tool],
+            tools,
             tool_choice: { type: 'any' },
             messages: [
                 {
@@ -34,15 +55,25 @@ export class AnthropicService {
         if (response.stop_reason === 'max_tokens') {
             throw new Error('Response was truncated due to length. Please simplify your request or break it into smaller parts.');
         }
-        // Validate response structure
-        if (response.content.length === 0 ||
-            response.content[0].type !== 'tool_use') {
+        // Find tool_use block in response (may not be first with web search)
+        const toolUseContent = response.content.find((block) => block.type === 'tool_use');
+        // For answer tool with web search, model might return text directly
+        if (toolName === 'answer' && !toolUseContent) {
+            const textContent = response.content.find((block) => block.type === 'text');
+            if (textContent) {
+                return {
+                    message: '',
+                    tasks: [],
+                    answer: textContent.text,
+                };
+            }
+        }
+        if (!toolUseContent) {
             throw new Error('Expected tool_use response from Claude API');
         }
-        const content = response.content[0];
+        const content = toolUseContent;
         // Extract and validate response based on tool type
         const input = content.input;
-        const isDebug = process.env.DEBUG === 'true';
         // Handle answer tool response
         if (toolName === 'answer') {
             if (!input.question || typeof input.question !== 'string') {
@@ -55,7 +86,6 @@ export class AnthropicService {
                 message: '',
                 tasks: [],
                 answer: input.answer,
-                systemPrompt: isDebug ? systemPrompt : undefined,
             };
         }
         // Handle plan and introspect tool responses
@@ -74,7 +104,6 @@ export class AnthropicService {
         return {
             message: input.message,
             tasks: input.tasks,
-            systemPrompt: isDebug ? systemPrompt : undefined,
         };
     }
 }

package/dist/services/colors.js

@@ -1,47 +1,81 @@
 import { FeedbackType, TaskType } from '../types/types.js';
+/**
+ * Base color palette - raw color values with descriptive names.
+ * All colors used in the interface are defined here.
+ */
+export const Palette = {
+    White: '#ffffff',
+    AshGray: '#d0d0d0',
+    PaleGreen: '#a8dcbc',
+    Gray: '#888888',
+    DarkGray: '#666666',
+    CharcoalGray: '#282828',
+    Green: '#5aaa8a',
+    LightGreen: '#65b595',
+    BrightGreen: '#22aa22',
+    Yellow: '#cccc5c',
+    LightYellow: '#d4d47a',
+    Orange: '#cc9c5c',
+    DarkOrange: '#a85c3f',
+    BurntOrange: '#cc7a5c',
+    Red: '#cc5c5c',
+    Cyan: '#5c9ccc',
+    LightCyan: '#5ccccc',
+    SteelBlue: '#5c8cbc',
+    Purple: '#9c5ccc',
+};
 /**
  * Semantic color palette - colors organized by their purpose/meaning.
- * Prefer adding semantic names here rather than to DescriptiveColors.
+ * References Palette colors to maintain consistency.
  */
 export const Colors = {
     Text: {
-        Active: '#ffffff', // white
-        Inactive: '#d0d0d0', // ash gray
+        Active: Palette.White,
+        Inactive: Palette.AshGray,
+        UserQuery: Palette.White,
+    },
+    Background: {
+        UserQuery: Palette.CharcoalGray,
     },
     Action: {
-        Execute: '#5aaa8a', // green
-        Discard: '#a85c3f', // dark orange
-        Select: '#5c8cbc', // steel blue
+        Execute: Palette.Green,
+        Discard: Palette.DarkOrange,
+        Select: Palette.SteelBlue,
     },
     Status: {
-        Success: '#22aa22', // green
-        Error: '#cc5c5c', // red
-        Warning: '#cc9c5c', // orange
-        Info: '#5c9ccc', // cyan
+        Success: Palette.BrightGreen,
+        Error: Palette.Red,
+        Warning: Palette.Orange,
+        Info: Palette.Cyan,
     },
     Label: {
-        Default: null, // replaced with active or inactive
-        Inactive: '#888888', // gray
-        Discarded: '#666666', // dark gray
-        Skipped: '#cccc5c', // yellow
+        Default: null, // calculated in runtime
+        Inactive: Palette.Gray,
+        Discarded: Palette.DarkGray,
+        Skipped: Palette.Yellow,
     },
     Type: {
-        Config: '#5c9ccc', // cyan
-        Plan: '#5ccccc', // magenta
-        Execute: '#5aaa8a', // green
-        Answer: '#9c5ccc', // purple
-        Introspect: '#9c5ccc', // purple
-        Report: '#cc9c5c', // orange
-        Define: '#cc9c5c', // amber
-        Ignore: '#cc7a5c', // dark orange
-        Select: '#5c8cbc', // steel blue
-        Discard: '#a85c3f', // dark orange
+        Config: Palette.Cyan,
+        Plan: Palette.LightCyan,
+        Execute: Palette.Green,
+        Answer: Palette.Purple,
+        Introspect: Palette.Purple,
+        Report: Palette.Orange,
+        Define: Palette.Orange,
+        Ignore: Palette.BurntOrange,
+        Select: Palette.SteelBlue,
+        Discard: Palette.DarkOrange,
+    },
+    Origin: {
+        BuiltIn: Palette.Cyan,
+        UserProvided: Palette.Green,
+        Indirect: Palette.Purple,
     },
 };
 /**
  * Task-specific color mappings (internal)
  */
-const TaskColors = {
+const taskColors = {
     [TaskType.Config]: {
         description: Colors.Label.Default,
         type: Colors.Type.Config,
@@ -86,7 +120,7 @@ const TaskColors = {
 /**
  * Feedback-specific color mappings (internal)
  */
-const FeedbackColors = {
+const feedbackColors = {
     [FeedbackType.Info]: Colors.Status.Info,
     [FeedbackType.Succeeded]: Colors.Status.Success,
     [FeedbackType.Aborted]: Colors.Status.Warning,
@@ -114,7 +148,7 @@ function processColor(color, isCurrent) {
  * - Colors.Text.Active for current items
  */
 export function getTaskColors(type, isCurrent) {
-    const colors = TaskColors[type];
+    const colors = taskColors[type];
     return {
         description: processColor(colors.description, isCurrent),
         type: processColor(colors.type, isCurrent),
@@ -128,7 +162,7 @@ export function getTaskColors(type, isCurrent) {
  * - Colors.Text.Active for current items
  */
 export function getFeedbackColor(type, isCurrent) {
-    return processColor(FeedbackColors[type], isCurrent);
+    return processColor(feedbackColors[type], isCurrent);
 }
 /**
  * Get text color based on current/historical state.