prompt-language-shell 0.4.6 → 0.4.9

package/dist/handlers/config.js

@@ -1,39 +1,71 @@
 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';
 /**
- * Creates config finished handler
+ * Creates all config handlers
  */
-export function createConfigFinishedHandler(addToTimeline, command, handleCommandError, handleCommandComplete, handleCommandAborted, setService) {
-    return (config) => {
+export function createConfigHandlers(ops, handleAborted, command, commandHandlers, setService) {
+    const onFinished = (config) => {
         const anthropicConfig = config;
         saveAnthropicConfig(anthropicConfig);
         const newService = createAnthropicService(anthropicConfig);
         setService(newService);
-        return withQueueHandler(ComponentName.Config, (first, rest) => {
-            addToTimeline(markAsDone(first), createFeedback(FeedbackType.Succeeded, FeedbackMessages.ConfigurationComplete));
-            // Add command to queue if we have one
+        ops.setQueue(withQueueHandler(ComponentName.Config, (first, rest) => {
+            ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Succeeded, FeedbackMessages.ConfigurationComplete));
             if (command) {
                 return [
                     ...rest,
-                    createCommandDefinition(command, newService, handleCommandError, handleCommandComplete, handleCommandAborted),
+                    createCommandDefinition(command, newService, commandHandlers.onError, commandHandlers.onComplete, commandHandlers.onAborted),
                 ];
             }
-            // No command - exit after showing completion message
+            exitApp(0);
+            return rest;
+        }, false, 0));
+    };
+    const onAborted = () => {
+        handleAborted('Configuration');
+    };
+    return { onFinished, onAborted };
+}
+/**
+ * Creates config execution finished handler for CONFIG skill
+ * Saves arbitrary config keys and exits
+ */
+export function createConfigExecutionFinishedHandler(addToTimeline, keys) {
+    return (config) => {
+        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];
+            }
+        }
+        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 aborted handler
+ * Creates config execution aborted handler for CONFIG skill
  */
-export function createConfigAbortedHandler(handleAborted) {
+export function createConfigExecutionAbortedHandler(addToTimeline) {
     return () => {
-        handleAborted('Configuration');
+        return withQueueHandler(ComponentName.Config, (first, rest) => {
+            addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, 'Configuration cancelled.'));
+            exitApp(0);
+            return rest;
+        }, false, 0);
     };
 }

package/dist/handlers/execute.js

@@ -0,0 +1,38 @@
+import { ComponentName, FeedbackType } from '../types/types.js';
+import { createFeedback, createMessage, markAsDone, } from '../services/components.js';
+import { formatDuration } from '../services/messages.js';
+import { exitApp } from '../services/process.js';
+import { ExecutionResult } from '../services/shell.js';
+import { withQueueHandler } from '../services/queue.js';
+/**
+ * Creates all execute handlers
+ */
+export function createExecuteHandlers(ops, handleAborted) {
+    const onError = (error) => {
+        ops.setQueue(withQueueHandler(ComponentName.Execute, (first) => {
+            ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Failed, error));
+            exitApp(1);
+            return [];
+        }));
+    };
+    const onComplete = (outputs, totalElapsed) => {
+        ops.setQueue(withQueueHandler(ComponentName.Execute, (first) => {
+            const failed = outputs.find((out) => out.result !== ExecutionResult.Success);
+            if (failed) {
+                const errorMessage = failed.error
+                    ? `${failed.description}: ${failed.error}`
+                    : `${failed.description} failed`;
+                ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Failed, errorMessage));
+                exitApp(1);
+                return [];
+            }
+            ops.addToTimeline(markAsDone(first), createMessage(`Execution completed in ${formatDuration(totalElapsed)}.`));
+            exitApp(0);
+            return [];
+        }));
+    };
+    const onAborted = () => {
+        handleAborted('Execution');
+    };
+    return { onError, onComplete, onAborted };
+}

package/dist/handlers/execution.js

@@ -1,68 +1,73 @@
 import { ComponentName, FeedbackType, TaskType } from '../types/types.js';
-import { createAnswerDefinition, createFeedback, createIntrospectDefinition, markAsDone, } from '../services/components.js';
+import { createAnswerDefinition, createConfigDefinitionWithKeys, createExecuteDefinition, createFeedback, createIntrospectDefinition, markAsDone, } from '../services/components.js';
 import { getCancellationMessage } from '../services/messages.js';
 import { exitApp } from '../services/process.js';
 import { withQueueHandler } from '../services/queue.js';
+import { createConfigExecutionAbortedHandler, createConfigExecutionFinishedHandler, } from './config.js';
 /**
- * Creates execution confirmed handler
+ * Creates all execution handlers
  */
-export function createExecutionConfirmedHandler(timelineRef, addToTimeline, service, handleIntrospectError, handleIntrospectComplete, handleIntrospectAborted, handleAnswerError, handleAnswerComplete, handleAnswerAborted) {
-    return () => withQueueHandler(ComponentName.Confirm, (first) => {
-        // Find the most recent Plan in timeline to get tasks
-        const currentTimeline = timelineRef.current;
-        const lastPlanIndex = [...currentTimeline]
-            .reverse()
-            .findIndex((item) => item.name === ComponentName.Plan);
-        const lastPlan = lastPlanIndex >= 0
-            ? currentTimeline[currentTimeline.length - 1 - lastPlanIndex]
-            : null;
-        const tasks = lastPlan?.name === ComponentName.Plan &&
-            Array.isArray(lastPlan.props.tasks)
-            ? lastPlan.props.tasks
-            : [];
-        const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
-        const allAnswer = tasks.every((task) => task.type === TaskType.Answer);
-        if (allIntrospect && tasks.length > 0) {
-            // Execute introspection
-            addToTimeline(markAsDone(first));
-            return [
-                createIntrospectDefinition(tasks, service, handleIntrospectError, handleIntrospectComplete, handleIntrospectAborted),
-            ];
-        }
-        else if (allAnswer && tasks.length > 0) {
-            // Execute answer - extract question from first task
-            const question = tasks[0].action;
-            addToTimeline(markAsDone(first));
-            return [
-                createAnswerDefinition(question, service, handleAnswerError, handleAnswerComplete, handleAnswerAborted),
-            ];
-        }
-        else {
-            // Regular execution - just exit for now
-            addToTimeline(markAsDone(first));
-            exitApp(0);
-            return [];
-        }
-    });
-}
-/**
- * Creates execution cancelled handler
- */
-export function createExecutionCancelledHandler(timelineRef, addToTimeline) {
-    return () => withQueueHandler(ComponentName.Confirm, (first) => {
-        // Find the most recent Plan in timeline to check task types
-        const currentTimeline = timelineRef.current;
-        const lastPlanIndex = [...currentTimeline]
-            .reverse()
-            .findIndex((item) => item.name === ComponentName.Plan);
-        const lastPlan = lastPlanIndex >= 0
-            ? currentTimeline[currentTimeline.length - 1 - lastPlanIndex]
-            : null;
-        const allIntrospect = lastPlan?.name === ComponentName.Plan &&
-            Array.isArray(lastPlan.props.tasks) &&
-            lastPlan.props.tasks.every((task) => task.type === TaskType.Introspect);
-        const operation = allIntrospect ? 'introspection' : 'execution';
-        addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, getCancellationMessage(operation)));
-        return undefined;
-    }, true, 0);
+export function createExecutionHandlers(ops, taskHandlers) {
+    const onConfirmed = (tasks) => {
+        ops.setQueue(withQueueHandler(ComponentName.Confirm, (first) => {
+            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);
+            const allExecute = tasks.every((task) => task.type === TaskType.Execute);
+            const service = ops.service;
+            if (!service) {
+                ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Failed, 'Service not available'));
+                exitApp(1);
+                return [];
+            }
+            if (allIntrospect && tasks.length > 0) {
+                ops.addToTimeline(markAsDone(first));
+                return [
+                    createIntrospectDefinition(tasks, service, taskHandlers.introspect.onError, taskHandlers.introspect.onComplete, taskHandlers.introspect.onAborted),
+                ];
+            }
+            else if (allAnswer && tasks.length > 0) {
+                const question = tasks[0].action;
+                ops.addToTimeline(markAsDone(first));
+                return [
+                    createAnswerDefinition(question, service, taskHandlers.answer.onError, taskHandlers.answer.onComplete, taskHandlers.answer.onAborted),
+                ];
+            }
+            else if (allConfig && tasks.length > 0) {
+                const keys = tasks
+                    .map((task) => task.params?.key)
+                    .filter((key) => typeof key === 'string');
+                ops.addToTimeline(markAsDone(first));
+                const handleConfigFinished = (config) => {
+                    ops.setQueue(createConfigExecutionFinishedHandler(ops.addToTimeline, keys)(config));
+                };
+                const handleConfigAborted = () => {
+                    ops.setQueue(createConfigExecutionAbortedHandler(ops.addToTimeline)());
+                };
+                return [
+                    createConfigDefinitionWithKeys(keys, handleConfigFinished, handleConfigAborted),
+                ];
+            }
+            else if (allExecute && tasks.length > 0) {
+                ops.addToTimeline(markAsDone(first));
+                return [
+                    createExecuteDefinition(tasks, service, taskHandlers.execute.onError, taskHandlers.execute.onComplete, taskHandlers.execute.onAborted),
+                ];
+            }
+            else {
+                ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Failed, 'I can only process one type of task at a time for now.'));
+                exitApp(0);
+                return [];
+            }
+        }));
+    };
+    const onCancelled = (tasks) => {
+        ops.setQueue(withQueueHandler(ComponentName.Confirm, (first) => {
+            const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
+            const operation = allIntrospect ? 'introspection' : 'execution';
+            ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, getCancellationMessage(operation)));
+            return undefined;
+        }, true, 0));
+    };
+    return { onConfirmed, onCancelled };
 }

package/dist/handlers/introspect.js

@@ -2,27 +2,20 @@ import { ComponentName } from '../types/types.js';
 import { createReportDefinition } from '../services/components.js';
 import { createErrorHandler, withQueueHandler } from '../services/queue.js';
 /**
- * Creates introspect error handler
+ * Creates all introspect handlers
  */
-export function createIntrospectErrorHandler(addToTimeline) {
-    return (error) => createErrorHandler(ComponentName.Introspect, addToTimeline)(error);
-}
-/**
- * Creates introspect completion handler
- */
-export function createIntrospectCompleteHandler(addToTimeline) {
-    return (message, capabilities) => withQueueHandler(ComponentName.Introspect, () => {
-        // Don't add the Introspect component to timeline (it renders null)
-        // Only add the Report component
-        addToTimeline(createReportDefinition(message, capabilities));
-        return undefined;
-    }, true, 0);
-}
-/**
- * Creates introspect aborted handler
- */
-export function createIntrospectAbortedHandler(handleAborted) {
-    return () => {
+export function createIntrospectHandlers(ops, handleAborted) {
+    const onError = (error) => {
+        ops.setQueue(createErrorHandler(ComponentName.Introspect, ops.addToTimeline)(error));
+    };
+    const onComplete = (message, capabilities) => {
+        ops.setQueue(withQueueHandler(ComponentName.Introspect, () => {
+            ops.addToTimeline(createReportDefinition(message, capabilities));
+            return undefined;
+        }, true, 0));
+    };
+    const onAborted = () => {
         handleAborted('Introspection');
     };
+    return { onError, onComplete, onAborted };
 }

package/dist/handlers/plan.js

@@ -1,48 +1,43 @@
 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
+ * Creates all plan handlers
  */
-export function createPlanAbortedHandler(handleAborted) {
-    return () => {
+export function createPlanHandlers(ops, handleAborted, executionHandlers) {
+    const onAborted = () => {
         handleAborted('Task selection');
     };
-}
-/**
- * Creates plan abort handler factory
- */
-export function createPlanAbortHandlerFactory(handleAborted, handlePlanAborted) {
-    return (tasks) => {
+    const createAbortHandler = (tasks) => {
         const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
         if (allIntrospect) {
             return () => {
                 handleAborted('Introspection');
             };
         }
-        return handlePlanAborted;
+        return onAborted;
     };
-}
-/**
- * Creates plan selection confirmed handler
- */
-export function createPlanSelectionConfirmedHandler(addToTimeline, service, handleRefinementAborted, createPlanAbortHandler, handleExecutionConfirmed, handleExecutionCancelled, setQueue) {
-    return async (selectedTasks) => {
-        // Mark current plan as done and add refinement to queue
-        const refinementDef = createRefinement(getRefiningMessage(), handleRefinementAborted);
-        setQueue((currentQueue) => {
+    const onSelectionConfirmed = async (selectedTasks) => {
+        const refinementDef = createRefinement(getRefiningMessage(), () => {
+            handleAborted('Plan refinement');
+        });
+        ops.setQueue((currentQueue) => {
             if (currentQueue.length === 0)
                 return currentQueue;
             const [first] = currentQueue;
             if (first.name === ComponentName.Plan) {
-                addToTimeline(markAsDone(first));
+                ops.addToTimeline(markAsDone(first));
             }
-            // Add refinement to queue so it becomes the active component
             return [refinementDef];
         });
-        // Process refined command in background
         try {
+            const service = ops.service;
+            if (!service) {
+                ops.addToTimeline(createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, 'Service not available'));
+                exitApp(1);
+                return;
+            }
             const refinedCommand = selectedTasks
                 .map((task) => {
                 const action = task.action.toLowerCase().replace(/,/g, ' -');
@@ -51,32 +46,34 @@ export function createPlanSelectionConfirmedHandler(addToTimeline, service, hand
             })
                 .join(', ');
             const result = await service.processWithTool(refinedCommand, 'plan');
-            // Mark refinement as done and move to timeline
-            setQueue((currentQueue) => {
+            ops.setQueue((currentQueue) => {
                 if (currentQueue.length > 0 &&
                     currentQueue[0].id === refinementDef.id) {
-                    addToTimeline(markAsDone(currentQueue[0]));
+                    ops.addToTimeline(markAsDone(currentQueue[0]));
                 }
                 return [];
             });
-            // Show final execution plan with confirmation
-            const planDefinition = createPlanDefinition(result.message, result.tasks, createPlanAbortHandler(result.tasks), undefined);
-            const confirmDefinition = createConfirmDefinition(handleExecutionConfirmed, handleExecutionCancelled);
-            addToTimeline(planDefinition);
-            setQueue([confirmDefinition]);
+            const planDefinition = createPlanDefinition(result.message, result.tasks, createAbortHandler(result.tasks), undefined);
+            const confirmDefinition = createConfirmDefinition(() => {
+                executionHandlers.onConfirmed(result.tasks);
+            }, () => {
+                executionHandlers.onCancelled(result.tasks);
+            });
+            ops.addToTimeline(planDefinition);
+            ops.setQueue([confirmDefinition]);
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            // Mark refinement as done and move to timeline before showing error
-            setQueue((currentQueue) => {
+            const errorMessage = formatErrorMessage(error);
+            ops.setQueue((currentQueue) => {
                 if (currentQueue.length > 0 &&
                     currentQueue[0].id === refinementDef.id) {
-                    addToTimeline(markAsDone(currentQueue[0]));
+                    ops.addToTimeline(markAsDone(currentQueue[0]));
                 }
                 return [];
             });
-            addToTimeline(createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, errorMessage));
+            ops.addToTimeline(createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, errorMessage));
             exitApp(1);
         }
     };
+    return { onAborted, createAbortHandler, onSelectionConfirmed };
 }

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,38 @@ 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' ||
+            toolName === 'execute') {
+            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 +57,48 @@ 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 execute tool response
+        if (toolName === 'execute') {
+            if (!input.message || typeof input.message !== 'string') {
+                throw new Error('Invalid tool response: missing or invalid message field');
+            }
+            if (!input.commands || !Array.isArray(input.commands)) {
+                throw new Error('Invalid tool response: missing or invalid commands array');
+            }
+            // Validate each command has required fields
+            input.commands.forEach((cmd, i) => {
+                if (!cmd.description || typeof cmd.description !== 'string') {
+                    throw new Error(`Invalid command at index ${String(i)}: missing or invalid 'description' field`);
+                }
+                if (!cmd.command || typeof cmd.command !== 'string') {
+                    throw new Error(`Invalid command at index ${String(i)}: missing or invalid 'command' field`);
+                }
+            });
+            return {
+                message: input.message,
+                tasks: [],
+                commands: input.commands,
+            };
+        }
         // Handle answer tool response
         if (toolName === 'answer') {
             if (!input.question || typeof input.question !== 'string') {
@@ -55,7 +111,6 @@ export class AnthropicService {
                 message: '',
                 tasks: [],
                 answer: input.answer,
-                systemPrompt: isDebug ? systemPrompt : undefined,
             };
         }
         // Handle plan and introspect tool responses
@@ -74,7 +129,6 @@ export class AnthropicService {
         return {
             message: input.message,
             tasks: input.tasks,
-            systemPrompt: isDebug ? systemPrompt : undefined,
         };
     }
 }

package/dist/services/colors.js

@@ -12,7 +12,7 @@ export const Palette = {
     CharcoalGray: '#282828',
     Green: '#5aaa8a',
     LightGreen: '#65b595',
-    BrightGreen: '#22aa22',
+    BrightGreen: '#3e9a3e',
     Yellow: '#cccc5c',
     LightYellow: '#d4d47a',
     Orange: '#cc9c5c',
@@ -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.