prompt-language-shell 0.4.6 → 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

@@ -69,12 +69,13 @@ export const Colors = {
     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,
@@ -119,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,
@@ -147,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),
@@ -161,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.

package/dist/services/components.js

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { ComponentName } from '../types/types.js';
-import { AnthropicModel, isValidAnthropicApiKey, isValidAnthropicModel, } from './configuration.js';
+import { getConfigSchema, loadConfig, } from './configuration.js';
 import { getConfirmationMessage } from './messages.js';
 import { StepType } from '../ui/Config.js';
 export function markAsDone(component) {
@@ -14,27 +14,132 @@ export function createWelcomeDefinition(app) {
     };
 }
 export function createConfigSteps() {
-    return [
-        {
-            description: 'Anthropic API key',
-            key: 'key',
-            type: StepType.Text,
-            value: null,
-            validate: isValidAnthropicApiKey,
-        },
-        {
-            description: 'Model',
-            key: 'model',
-            type: StepType.Selection,
-            options: [
-                { label: 'Haiku 4.5', value: AnthropicModel.Haiku },
-                { label: 'Sonnet 4.5', value: AnthropicModel.Sonnet },
-                { label: 'Opus 4.1', value: AnthropicModel.Opus },
-            ],
-            defaultIndex: 0,
-            validate: isValidAnthropicModel,
-        },
-    ];
+    // Use schema-based config step generation for required Anthropic settings
+    return createConfigStepsFromSchema(['anthropic.key', 'anthropic.model']);
+}
+/**
+ * Get current config value for a dotted key path
+ */
+function getConfigValue(config, key) {
+    if (!config)
+        return undefined;
+    const parts = key.split('.');
+    let value = config;
+    for (const part of parts) {
+        if (value && typeof value === 'object' && part in value) {
+            value = value[part];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return value;
+}
+/**
+ * Get validation function for a config definition
+ */
+function getValidator(definition) {
+    switch (definition.type) {
+        case 'regexp':
+            return (value) => definition.pattern.test(value);
+        case 'string':
+            return () => true; // Strings are always valid
+        case 'enum':
+            return (value) => definition.values.includes(value);
+        case 'number':
+            return (value) => !isNaN(Number(value));
+        case 'boolean':
+            return (value) => value === 'true' || value === 'false';
+    }
+}
+/**
+ * Create config steps from schema for specified keys
+ */
+export function createConfigStepsFromSchema(keys) {
+    const schema = getConfigSchema();
+    let currentConfig = null;
+    try {
+        currentConfig = loadConfig();
+    }
+    catch {
+        // Config doesn't exist yet, use defaults
+    }
+    return keys.map((key) => {
+        if (!(key in schema)) {
+            throw new Error(`Unknown config key: ${key}`);
+        }
+        const definition = schema[key];
+        const currentValue = getConfigValue(currentConfig, key);
+        const keyParts = key.split('.');
+        const shortKey = keyParts[keyParts.length - 1];
+        // Map definition to ConfigStep based on type
+        switch (definition.type) {
+            case 'regexp':
+            case 'string': {
+                const value = currentValue !== undefined && typeof currentValue === 'string'
+                    ? currentValue
+                    : definition.type === 'string'
+                        ? (definition.default ?? '')
+                        : null;
+                return {
+                    description: definition.description,
+                    key: shortKey,
+                    type: StepType.Text,
+                    value,
+                    validate: getValidator(definition),
+                };
+            }
+            case 'number': {
+                const value = currentValue !== undefined && typeof currentValue === 'number'
+                    ? String(currentValue)
+                    : definition.default !== undefined
+                        ? String(definition.default)
+                        : '0';
+                return {
+                    description: definition.description,
+                    key: shortKey,
+                    type: StepType.Text,
+                    value,
+                    validate: getValidator(definition),
+                };
+            }
+            case 'enum': {
+                const currentStr = currentValue !== undefined && typeof currentValue === 'string'
+                    ? currentValue
+                    : definition.default;
+                const defaultIndex = currentStr
+                    ? definition.values.indexOf(currentStr)
+                    : 0;
+                return {
+                    description: definition.description,
+                    key: shortKey,
+                    type: StepType.Selection,
+                    options: definition.values.map((value) => ({
+                        label: value,
+                        value,
+                    })),
+                    defaultIndex: Math.max(0, defaultIndex),
+                    validate: getValidator(definition),
+                };
+            }
+            case 'boolean': {
+                const currentBool = currentValue !== undefined && typeof currentValue === 'boolean'
+                    ? currentValue
+                    : undefined;
+                return {
+                    description: definition.description,
+                    key: shortKey,
+                    type: StepType.Selection,
+                    options: [
+                        { label: 'Yes', value: 'true' },
+                        { label: 'No', value: 'false' },
+                    ],
+                    defaultIndex: currentBool !== undefined ? (currentBool ? 0 : 1) : 0,
+                    validate: getValidator(definition),
+                };
+            }
+        }
+    });
 }
 export function createConfigDefinition(onFinished, onAborted) {
     return {
@@ -48,6 +153,21 @@ export function createConfigDefinition(onFinished, onAborted) {
         },
     };
 }
+/**
+ * Create config definition with specific keys
+ */
+export function createConfigDefinitionWithKeys(keys, onFinished, onAborted) {
+    return {
+        id: randomUUID(),
+        name: ComponentName.Config,
+        state: { done: false },
+        props: {
+            steps: createConfigStepsFromSchema(keys),
+            onFinished,
+            onAborted,
+        },
+    };
+}
 export function createCommandDefinition(command, service, onError, onComplete, onAborted) {
     return {
         id: randomUUID(),

package/dist/services/configuration.js

@@ -166,3 +166,83 @@ export function getConfigurationRequiredMessage(forFutureUse = false) {
     ];
     return messages[Math.floor(Math.random() * messages.length)];
 }
+/**
+ * Core configuration schema - defines structure and types for built-in settings
+ */
+const coreConfigSchema = {
+    'anthropic.key': {
+        type: 'regexp',
+        required: true,
+        pattern: /^sk-ant-api03-[A-Za-z0-9_-]{95}$/,
+        description: 'Anthropic API key',
+    },
+    'anthropic.model': {
+        type: 'enum',
+        required: true,
+        values: SUPPORTED_MODELS,
+        default: AnthropicModel.Haiku,
+        description: 'Anthropic model',
+    },
+    'settings.debug': {
+        type: 'boolean',
+        required: false,
+        description: 'Debug mode',
+    },
+};
+/**
+ * Get complete configuration schema
+ * Currently returns core schema only
+ * Future: will merge with skill-declared schemas
+ */
+export function getConfigSchema() {
+    return {
+        ...coreConfigSchema,
+        // Future: ...loadSkillSchemas()
+    };
+}
+/**
+ * Get available config structure for CONFIG tool
+ * Returns keys with descriptions only (no values for privacy)
+ */
+export function getAvailableConfigStructure() {
+    const schema = getConfigSchema();
+    const structure = {};
+    // Add core schema keys with descriptions
+    for (const [key, definition] of Object.entries(schema)) {
+        structure[key] = definition.description;
+    }
+    // Add discovered keys from config file (if it exists)
+    try {
+        const configFile = getConfigFile();
+        if (!existsSync(configFile)) {
+            return structure;
+        }
+        const content = readFileSync(configFile, 'utf-8');
+        const parsed = YAML.parse(content);
+        // Flatten nested config to dot notation
+        function flattenConfig(obj, prefix = '') {
+            const result = {};
+            for (const [key, value] of Object.entries(obj)) {
+                const fullKey = prefix ? `${prefix}.${key}` : key;
+                if (value && typeof value === 'object' && !Array.isArray(value)) {
+                    Object.assign(result, flattenConfig(value, fullKey));
+                }
+                else {
+                    result[fullKey] = value;
+                }
+            }
+            return result;
+        }
+        const flatConfig = flattenConfig(parsed);
+        // Add discovered keys that aren't in schema
+        for (const key of Object.keys(flatConfig)) {
+            if (!structure[key]) {
+                structure[key] = `${key} (discovered)`;
+            }
+        }
+    }
+    catch {
+        // Config file doesn't exist or can't be read, only use schema
+    }
+    return structure;
+}

package/dist/services/keyboard.js

@@ -0,0 +1,86 @@
+import { useInput as useInkInput } from 'ink';
+const globalShortcuts = new Map();
+/**
+ * Converts a Key object to a normalized pattern string
+ * Example: { shift: true, tab: true } → "shift+tab"
+ */
+function keyToPattern(key) {
+    const modifiers = [];
+    if (key.ctrl)
+        modifiers.push('ctrl');
+    if (key.meta)
+        modifiers.push('meta');
+    if (key.shift)
+        modifiers.push('shift');
+    // Get the key name
+    let keyName = '';
+    if (key.escape)
+        keyName = 'escape';
+    else if (key.tab)
+        keyName = 'tab';
+    else if (key.return)
+        keyName = 'return';
+    else if (key.upArrow)
+        keyName = 'up';
+    else if (key.downArrow)
+        keyName = 'down';
+    else if (key.leftArrow)
+        keyName = 'left';
+    else if (key.rightArrow)
+        keyName = 'right';
+    else if (key.backspace)
+        keyName = 'backspace';
+    else if (key.delete)
+        keyName = 'delete';
+    if (!keyName)
+        return null;
+    return [...modifiers, keyName].join('+');
+}
+/**
+ * Register a global keyboard shortcut
+ * @param pattern Pattern string like "shift+tab" or "ctrl+c"
+ * @param handler Function to call when shortcut is triggered
+ */
+export function registerGlobalShortcut(pattern, handler) {
+    globalShortcuts.set(pattern.toLowerCase(), handler);
+}
+/**
+ * Check if a key event matches a global shortcut
+ * If matched, calls the handler and returns true
+ * If not matched, returns false
+ * @param key The key object from ink's useInput
+ * @returns true if global shortcut was handled, false otherwise
+ */
+export function isGlobalShortcut(key) {
+    const pattern = keyToPattern(key);
+    if (!pattern)
+        return false;
+    const handler = globalShortcuts.get(pattern.toLowerCase());
+    if (handler) {
+        handler();
+        return true;
+    }
+    return false;
+}
+/**
+ * Clear all registered global shortcuts (useful for testing)
+ */
+export function clearGlobalShortcuts() {
+    globalShortcuts.clear();
+}
+/**
+ * Custom useInput hook that automatically handles global shortcuts
+ * before passing events to the component handler
+ * @param handler Component's keyboard event handler
+ * @param options Options for useInput (isActive, etc.)
+ */
+export function useInput(handler, options) {
+    useInkInput((input, key) => {
+        // Check for global shortcuts first
+        if (isGlobalShortcut(key)) {
+            return; // Global shortcut handled, don't propagate to component
+        }
+        // No global shortcut matched, call component handler
+        handler(input, key);
+    }, options);
+}

package/dist/services/messages.js

@@ -1,3 +1,4 @@
+import { loadDebugSetting } from './configuration.js';
 /**
  * Returns a natural language confirmation message for plan execution.
  * Randomly selects from variations to sound less robotic.
@@ -48,3 +49,32 @@ export const FeedbackMessages = {
     ConfigurationComplete: 'Configuration complete.',
     UnexpectedError: 'Unexpected error occurred:',
 };
+/**
+ * Extracts a user-friendly error message from API errors.
+ * In debug mode, returns the full error; otherwise, returns just the message.
+ *
+ * Handles Anthropic API error format:
+ * 400 {"type":"error","error":{"type":"...","message":"..."},"request_id":"..."}
+ */
+export function formatErrorMessage(error) {
+    const rawMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+    if (loadDebugSetting()) {
+        return rawMessage;
+    }
+    // Try to extract message from Anthropic API error format
+    // Format: "400 {json...}" or just "{json...}"
+    const jsonMatch = rawMessage.match(/\{.*\}/s);
+    if (jsonMatch) {
+        try {
+            const parsed = JSON.parse(jsonMatch[0]);
+            const message = parsed.error?.message ?? parsed.message;
+            if (message) {
+                return message;
+            }
+        }
+        catch {
+            // JSON parsing failed, return original message
+        }
+    }
+    return rawMessage;
+}

package/dist/services/tool-registry.js

@@ -34,6 +34,7 @@ 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 { introspectTool } from '../tools/introspect.tool.js';
 import { planTool } from '../tools/plan.tool.js';
 toolRegistry.register('plan', {
@@ -48,3 +49,7 @@ toolRegistry.register('answer', {
     schema: answerTool,
     instructionsPath: 'config/ANSWER.md',
 });
+toolRegistry.register('config', {
+    schema: configTool,
+    instructionsPath: 'config/CONFIG.md',
+});

package/dist/tools/config.tool.js

@@ -0,0 +1,43 @@
+export const configTool = {
+    name: 'config',
+    description: 'Determine which configuration settings to show based on user query. Receives available config keys with descriptions and returns which keys the user wants to configure.',
+    input_schema: {
+        type: 'object',
+        properties: {
+            message: {
+                type: 'string',
+                description: 'Brief message to display before config plan. Single sentence, maximum 64 characters. End with period.',
+            },
+            tasks: {
+                type: 'array',
+                description: 'Array of config settings to configure. Each task has type "config" and params with the config key.',
+                items: {
+                    type: 'object',
+                    properties: {
+                        action: {
+                            type: 'string',
+                            description: 'Description of the config setting (from the provided descriptions). Maximum 64 characters.',
+                        },
+                        type: {
+                            type: 'string',
+                            description: 'Always "config" for configuration tasks.',
+                        },
+                        params: {
+                            type: 'object',
+                            description: 'Parameters for the config task.',
+                            properties: {
+                                key: {
+                                    type: 'string',
+                                    description: 'The config key to configure (e.g., "anthropic.key", "settings.debug").',
+                                },
+                            },
+                            required: ['key'],
+                        },
+                    },
+                    required: ['action', 'type', 'params'],
+                },
+            },
+        },
+        required: ['message', 'tasks'],
+    },
+};

package/dist/ui/Answer.js

@@ -1,9 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { Box, Text, useInput } from 'ink';
+import { Box, Text } from 'ink';
 import { Colors, getTextColor } from '../services/colors.js';
+import { useInput } from '../services/keyboard.js';
+import { formatErrorMessage } from '../services/messages.js';
 import { Spinner } from './Spinner.js';
-const MinimumProcessingTime = 400;
+const MINIMUM_PROCESSING_TIME = 400;
 export function Answer({ question, state, service, onError, onComplete, onAborted, }) {
     const done = state?.done ?? false;
     const isCurrent = done === false;
@@ -33,7 +35,7 @@ export function Answer({ question, state, service, onError, onComplete, onAborte
                 // Call answer tool
                 const result = await svc.processWithTool(question, 'answer');
                 const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MinimumProcessingTime - elapsed);
+                const remainingTime = Math.max(0, MINIMUM_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
                     // Extract answer from result
@@ -44,10 +46,10 @@ export function Answer({ question, state, service, onError, onComplete, onAborte
             }
             catch (err) {
                 const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MinimumProcessingTime - elapsed);
+                const remainingTime = Math.max(0, MINIMUM_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
-                    const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+                    const errorMessage = formatErrorMessage(err);
                     setIsLoading(false);
                     if (onError) {
                         onError(errorMessage);

package/dist/ui/Command.js

@@ -1,7 +1,10 @@
 import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { Box, Text, useInput } from 'ink';
+import { Box, Text } from 'ink';
+import { TaskType } from '../types/types.js';
 import { Colors } from '../services/colors.js';
+import { useInput } from '../services/keyboard.js';
+import { formatErrorMessage } from '../services/messages.js';
 import { Spinner } from './Spinner.js';
 const MIN_PROCESSING_TIME = 1000; // purely for visual effect
 export function Command({ command, state, service, children, onError, onComplete, onAborted, }) {
@@ -29,7 +32,16 @@ export function Command({ command, state, service, children, onError, onComplete
         async function process(svc) {
             const startTime = Date.now();
             try {
-                const result = await svc.processWithTool(command, 'plan');
+                let result = await svc.processWithTool(command, 'plan');
+                // If all tasks are config type, delegate to CONFIG tool
+                const allConfig = result.tasks.length > 0 &&
+                    result.tasks.every((task) => task.type === TaskType.Config);
+                if (allConfig) {
+                    // Extract query from first config task params, default to 'app'
+                    const query = result.tasks[0].params?.query || 'app';
+                    // Call CONFIG tool to get specific config keys
+                    result = await svc.processWithTool(query, 'config');
+                }
                 const elapsed = Date.now() - startTime;
                 const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
@@ -43,7 +55,7 @@ export function Command({ command, state, service, children, onError, onComplete
                 const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
-                    const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+                    const errorMessage = formatErrorMessage(err);
                     setIsLoading(false);
                     if (onError) {
                         onError(errorMessage);

package/dist/ui/Component.js

@@ -49,7 +49,7 @@ export const Component = React.memo(function Component({ def, debug, }) {
         case ComponentName.Introspect: {
             const props = def.props;
             const state = def.state;
-            return _jsx(Introspect, { ...props, state: state });
+            return _jsx(Introspect, { ...props, state: state, debug: debug });
         }
         case ComponentName.Report:
             return _jsx(Report, { ...def.props });

package/dist/ui/Config.js

@@ -1,8 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
-import { Box, Text, useFocus, useInput } from 'ink';
+import { Box, Text, useFocus } from 'ink';
 import TextInput from 'ink-text-input';
 import { Colors } from '../services/colors.js';
+import { useInput } from '../services/keyboard.js';
 export var StepType;
 (function (StepType) {
     StepType["Text"] = "text";
@@ -20,11 +21,13 @@ function TextStep({ value, placeholder, validate, onChange, onSubmit, }) {
         }
     };
     const handleSubmit = (value) => {
-        if (!validate(value)) {
+        // Use placeholder if input is empty
+        const finalValue = value || placeholder || '';
+        if (!validate(finalValue)) {
             setValidationFailed(true);
             return;
         }
-        onSubmit(value);
+        onSubmit(finalValue);
     };
     // Handle input manually when validation fails
     useInput((input, key) => {

package/dist/ui/Confirm.js

@@ -1,7 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
-import { Box, Text, useInput } from 'ink';
+import { Box, Text } from 'ink';
 import { Colors } from '../services/colors.js';
+import { useInput } from '../services/keyboard.js';
 export function Confirm({ message, state, onConfirmed, onCancelled, }) {
     const done = state?.done ?? false;
     const isCurrent = done === false;

package/dist/ui/Introspect.js

@@ -1,7 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { Box, Text, useInput } from 'ink';
+import { Box, Text } from 'ink';
 import { Colors, getTextColor } from '../services/colors.js';
+import { useInput } from '../services/keyboard.js';
+import { formatErrorMessage } from '../services/messages.js';
 import { Spinner } from './Spinner.js';
 const MIN_PROCESSING_TIME = 1000;
 const BUILT_IN_CAPABILITIES = new Set([
@@ -12,26 +14,32 @@ const BUILT_IN_CAPABILITIES = new Set([
     'EXECUTE',
     'REPORT',
 ]);
+const INDIRECT_CAPABILITIES = new Set(['PLAN', 'REPORT']);
 function parseCapabilityFromTask(task) {
     // Parse "NAME: Description" format from task.action
     const colonIndex = task.action.indexOf(':');
     if (colonIndex === -1) {
+        const upperName = task.action.toUpperCase();
         return {
             name: task.action,
             description: '',
-            isBuiltIn: BUILT_IN_CAPABILITIES.has(task.action.toUpperCase()),
+            isBuiltIn: BUILT_IN_CAPABILITIES.has(upperName),
+            isIndirect: INDIRECT_CAPABILITIES.has(upperName),
         };
     }
     const name = task.action.substring(0, colonIndex).trim();
     const description = task.action.substring(colonIndex + 1).trim();
-    const isBuiltIn = BUILT_IN_CAPABILITIES.has(name.toUpperCase());
+    const upperName = name.toUpperCase();
+    const isBuiltIn = BUILT_IN_CAPABILITIES.has(upperName);
+    const isIndirect = INDIRECT_CAPABILITIES.has(upperName);
     return {
         name,
         description,
         isBuiltIn,
+        isIndirect,
     };
 }
-export function Introspect({ tasks, state, service, children, onError, onComplete, onAborted, }) {
+export function Introspect({ tasks, state, service, children, debug = false, onError, onComplete, onAborted, }) {
     const done = state?.done ?? false;
     const isCurrent = done === false;
     const [error, setError] = useState(null);
@@ -66,7 +74,12 @@ export function Introspect({ tasks, state, service, children, onError, onComplet
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
                     // Parse capabilities from returned tasks
-                    const capabilities = result.tasks.map(parseCapabilityFromTask);
+                    let capabilities = result.tasks.map(parseCapabilityFromTask);
+                    // Filter out internal capabilities when not in debug mode
+                    if (!debug) {
+                        capabilities = capabilities.filter((cap) => cap.name.toUpperCase() !== 'PLAN' &&
+                            cap.name.toUpperCase() !== 'REPORT');
+                    }
                     setIsLoading(false);
                     onComplete?.(result.message, capabilities);
                 }
@@ -76,7 +89,7 @@ export function Introspect({ tasks, state, service, children, onError, onComplet
                 const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
-                    const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+                    const errorMessage = formatErrorMessage(err);
                     setIsLoading(false);
                     if (onError) {
                         onError(errorMessage);
@@ -91,7 +104,7 @@ export function Introspect({ tasks, state, service, children, onError, onComplet
         return () => {
             mounted = false;
         };
-    }, [tasks, done, service]);
+    }, [tasks, done, service, debug, onComplete, onError]);
     // Don't render wrapper when done and nothing to show
     if (!isLoading && !error && !children) {
         return null;

package/dist/ui/Main.js

@@ -1,9 +1,9 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
-import { useInput } from 'ink';
 import { FeedbackType } from '../types/types.js';
 import { createAnthropicService, } from '../services/anthropic.js';
 import { getConfigurationRequiredMessage, hasValidAnthropicKey, loadConfig, loadDebugSetting, saveDebugSetting, } from '../services/configuration.js';
+import { registerGlobalShortcut } from '../services/keyboard.js';
 import { getCancellationMessage } from '../services/messages.js';
 import { createCommandDefinition, createConfigDefinition, createFeedback, createMessage, createWelcomeDefinition, isStateless, markAsDone, } from '../services/components.js';
 import { exitApp } from '../services/process.js';
@@ -31,17 +31,17 @@ export const Main = ({ app, command }) => {
     React.useEffect(() => {
         timelineRef.current = timeline;
     }, [timeline]);
-    // Top-level Shift+Tab handler for debug mode toggle
-    // Child components must ignore Shift+Tab to prevent conflicts
-    useInput((input, key) => {
-        if (key.shift && key.tab) {
+    // Register global keyboard shortcuts
+    React.useEffect(() => {
+        // Shift+Tab: Toggle debug mode
+        registerGlobalShortcut('shift+tab', () => {
             setIsDebug((prev) => {
                 const newValue = !prev;
                 saveDebugSetting(newValue);
                 return newValue;
             });
-        }
-    }, { isActive: true });
+        });
+    }, []);
     const addToTimeline = React.useCallback((...items) => {
         setTimeline((timeline) => [...timeline, ...items]);
     }, []);
@@ -84,7 +84,7 @@ export const Main = ({ app, command }) => {
     const handleAnswerAborted = React.useCallback(createAnswerAbortedHandler(handleAborted), [handleAborted]);
     const handleAnswerError = React.useCallback((error) => setQueue(createAnswerErrorHandler(addToTimeline)(error)), [addToTimeline]);
     const handleAnswerComplete = React.useCallback((answer) => setQueue(createAnswerCompleteHandler(addToTimeline)(answer)), [addToTimeline]);
-    const handleExecutionConfirmed = React.useCallback(() => setQueue(createExecutionConfirmedHandler(timelineRef, addToTimeline, service, handleIntrospectError, handleIntrospectComplete, handleIntrospectAborted, handleAnswerError, handleAnswerComplete, handleAnswerAborted)()), [
+    const handleExecutionConfirmed = React.useCallback(() => setQueue(createExecutionConfirmedHandler(timelineRef, addToTimeline, service, handleIntrospectError, handleIntrospectComplete, handleIntrospectAborted, handleAnswerError, handleAnswerComplete, handleAnswerAborted, setQueue)()), [
         addToTimeline,
         service,
         handleIntrospectError,

package/dist/ui/Plan.js

@@ -1,8 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { Box, useInput } from 'ink';
+import { Box } from 'ink';
 import { TaskType } from '../types/types.js';
 import { getTaskColors } from '../services/colors.js';
+import { useInput } from '../services/keyboard.js';
 import { Label } from './Label.js';
 import { List } from './List.js';
 function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutSelection = false, isCurrent = false) {

package/dist/ui/Refinement.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, useInput } from 'ink';
+import { Box } from 'ink';
+import { useInput } from '../services/keyboard.js';
 import { Message } from './Message.js';
 import { Spinner } from './Spinner.js';
 export const Refinement = ({ text, state, onAborted }) => {

package/dist/ui/Report.js

@@ -1,10 +1,14 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { Colors } from '../services/colors.js';
-function CapabilityItem({ name, description, isBuiltIn }) {
-    const color = isBuiltIn ? Colors.Origin.BuiltIn : Colors.Origin.UserProvided;
+function CapabilityItem({ name, description, isBuiltIn, isIndirect, }) {
+    const color = isIndirect
+        ? Colors.Origin.Indirect
+        : isBuiltIn
+            ? Colors.Origin.BuiltIn
+            : Colors.Origin.UserProvided;
     return (_jsxs(Box, { children: [_jsx(Text, { children: "- " }), _jsx(Text, { color: color, children: name }), _jsxs(Text, { children: [" - ", description] })] }));
 }
 export function Report({ message, capabilities }) {
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: message }), _jsx(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: capabilities.map((capability, index) => (_jsx(CapabilityItem, { name: capability.name, description: capability.description, isBuiltIn: capability.isBuiltIn }, index))) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: message }), _jsx(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: capabilities.map((capability, index) => (_jsx(CapabilityItem, { name: capability.name, description: capability.description, isBuiltIn: capability.isBuiltIn, isIndirect: capability.isIndirect }, index))) })] }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",