prompt-language-shell 0.4.8 → 0.5.0

package/dist/handlers/config.js

@@ -1,66 +1,74 @@
 import { ComponentName, FeedbackType } from '../types/types.js';
 import { createAnthropicService, } from '../services/anthropic.js';
-import { createCommandDefinition, createFeedback, markAsDone, } from '../services/components.js';
+import { createCommandDefinition, createExecuteDefinition, createFeedback, markAsDone, } from '../services/components.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);
+        }, false, 0));
     };
-}
-/**
- * Creates config aborted handler
- */
-export function createConfigAbortedHandler(handleAborted) {
-    return () => {
+    const onAborted = () => {
         handleAborted('Configuration');
     };
+    return { onFinished, onAborted };
 }
 /**
  * Creates config execution finished handler for CONFIG skill
- * Saves arbitrary config keys and exits
+ * Saves arbitrary config keys and optionally continues with execution
  */
-export function createConfigExecutionFinishedHandler(addToTimeline, keys) {
+export function createConfigExecutionFinishedHandler(addToTimeline, keys, tasks, service, executeHandlers) {
     return (config) => {
-        // Map short keys back to full keys and save
-        // Group by section (e.g., "anthropic", "settings")
+        // Group by top-level section
         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] ?? {};
+            const topSection = parts[0];
+            // Initialize section if needed
+            sections[topSection] = sections[topSection] ?? {};
             if (shortKey in config) {
-                sections[section][shortKey] = config[shortKey];
+                const value = config[shortKey];
+                // Build nested structure recursively
+                let current = sections[topSection];
+                for (let i = 1; i < parts.length - 1; i++) {
+                    current[parts[i]] = current[parts[i]] ?? {};
+                    current = current[parts[i]];
+                }
+                current[parts[parts.length - 1]] = value;
             }
         }
-        // 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));
+            // If tasks are provided, continue with execution
+            if (tasks && service && executeHandlers) {
+                return [
+                    ...rest,
+                    createExecuteDefinition(tasks, service, executeHandlers.onError, executeHandlers.onComplete, executeHandlers.onAborted),
+                ];
+            }
+            // Otherwise, exit (legacy behavior for initial setup)
             exitApp(0);
             return rest;
         }, false, 0);

package/dist/handlers/execute.js

@@ -0,0 +1,46 @@
+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) {
+    void 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 = (elapsedTime) => {
+        ops.setQueue(withQueueHandler(ComponentName.Execute, (first) => {
+            const message = elapsedTime > 0
+                ? `The execution was cancelled after ${formatDuration(elapsedTime)}.`
+                : 'The execution was cancelled.';
+            ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, message));
+            exitApp(0);
+            return [];
+        }));
+    };
+    return { onError, onComplete, onAborted };
+}

package/dist/handlers/execution.js

@@ -1,88 +1,140 @@
 import { ComponentName, FeedbackType, TaskType } from '../types/types.js';
-import { createAnswerDefinition, createConfigDefinitionWithKeys, createFeedback, createIntrospectDefinition, markAsDone, } from '../services/components.js';
-import { createConfigExecutionAbortedHandler, createConfigExecutionFinishedHandler, } from './config.js';
+import { createAnswerDefinition, createConfigDefinitionWithKeys, createExecuteDefinition, createFeedback, createIntrospectDefinition, createValidateDefinition, markAsDone, } from '../services/components.js';
+import { StepType } from '../ui/Config.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';
+import { validateExecuteTasks } from '../services/execution-validator.js';
 /**
- * Creates execution confirmed handler
- */
-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;
-        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);
-        const allConfig = tasks.every((task) => task.type === TaskType.Config);
-        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 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));
-            exitApp(0);
-            return [];
-        }
-    });
-}
-/**
- * Creates execution cancelled handler
+ * Creates all execution handlers
  */
-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) {
+                // Validate config requirements before execution
+                const missingConfig = validateExecuteTasks(tasks);
+                if (missingConfig.length > 0) {
+                    // Config is missing - call VALIDATE tool to get contextual descriptions
+                    const keys = missingConfig.map((req) => req.path);
+                    const userRequest = tasks.map((t) => t.action).join(', ');
+                    ops.addToTimeline(markAsDone(first));
+                    // Create handlers for Validate completion
+                    const handleValidateComplete = (configWithDescriptions) => {
+                        ops.setQueue(withQueueHandler(ComponentName.Validate, (first) => {
+                            // Create CONFIG component with descriptions from VALIDATE
+                            const handleConfigFinished = (config) => {
+                                ops.setQueue(createConfigExecutionFinishedHandler(ops.addToTimeline, keys, tasks, service, taskHandlers.execute)(config));
+                            };
+                            const handleConfigAborted = () => {
+                                ops.setQueue(createConfigExecutionAbortedHandler(ops.addToTimeline)());
+                            };
+                            // Create config steps from validated descriptions
+                            const steps = configWithDescriptions.map((req) => {
+                                const keyParts = req.path.split('.');
+                                const shortKey = keyParts[keyParts.length - 1];
+                                // Extract description without the {path} suffix
+                                // Format from VALIDATE: "Description {path}"
+                                let description = req.description || req.path;
+                                const pathPattern = /\s*\{[^}]+\}\s*$/;
+                                description = description.replace(pathPattern, '').trim();
+                                const step = {
+                                    description,
+                                    key: shortKey,
+                                    path: req.path,
+                                    type: StepType.Text,
+                                    value: null,
+                                    validate: () => true,
+                                };
+                                return step;
+                            });
+                            // Mark Validate as done and move to timeline
+                            ops.addToTimeline(markAsDone(first));
+                            return [
+                                {
+                                    id: crypto.randomUUID(),
+                                    name: ComponentName.Config,
+                                    state: { done: false },
+                                    props: {
+                                        steps,
+                                        onFinished: handleConfigFinished,
+                                        onAborted: handleConfigAborted,
+                                    },
+                                },
+                            ];
+                        }));
+                    };
+                    const handleValidateError = (error) => {
+                        ops.addToTimeline(createFeedback(FeedbackType.Failed, error));
+                        exitApp(1);
+                    };
+                    const handleValidateAborted = () => {
+                        ops.addToTimeline(createFeedback(FeedbackType.Aborted, 'Configuration validation cancelled'));
+                        exitApp(0);
+                    };
+                    return [
+                        createValidateDefinition(missingConfig, userRequest, service, handleValidateError, handleValidateComplete, handleValidateAborted),
+                    ];
+                }
+                // No missing config - execute directly
+                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

@@ -3,46 +3,41 @@ import { createConfirmDefinition, createFeedback, createPlanDefinition, markAsDo
 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 = formatErrorMessage(error);
-            // Mark refinement as done and move to timeline before showing error
-            setQueue((currentQueue) => {
+            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

@@ -16,7 +16,10 @@ export class AnthropicService {
         // Build system prompt with additional context based on tool
         let systemPrompt = instructions;
         // Add skills section for applicable tools
-        if (toolName === 'plan' || toolName === 'introspect') {
+        if (toolName === 'plan' ||
+            toolName === 'introspect' ||
+            toolName === 'execute' ||
+            toolName === 'validate') {
             const skills = loadSkills();
             const skillsSection = formatSkillsForPrompt(skills);
             systemPrompt += skillsSection;
@@ -74,6 +77,29 @@ export class AnthropicService {
         const content = toolUseContent;
         // Extract and validate response based on tool type
         const input = content.input;
+        // 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') {
@@ -89,7 +115,7 @@ export class AnthropicService {
             };
         }
         // Handle plan and introspect tool responses
-        if (!input.message || typeof input.message !== 'string') {
+        if (input.message === undefined || typeof input.message !== 'string') {
             throw new Error('Invalid tool response: missing or invalid message field');
         }
         if (!input.tasks || !Array.isArray(input.tasks)) {

package/dist/services/colors.js

@@ -12,11 +12,11 @@ export const Palette = {
     CharcoalGray: '#282828',
     Green: '#5aaa8a',
     LightGreen: '#65b595',
-    BrightGreen: '#22aa22',
+    BrightGreen: '#3e9a3e',
     Yellow: '#cccc5c',
     LightYellow: '#d4d47a',
-    Orange: '#cc9c5c',
-    DarkOrange: '#a85c3f',
+    Orange: '#f48c80',
+    DarkOrange: '#ab5e40',
     BurntOrange: '#cc7a5c',
     Red: '#cc5c5c',
     Cyan: '#5c9ccc',

package/dist/services/components.js

@@ -65,8 +65,22 @@ export function createConfigStepsFromSchema(keys) {
         // Config doesn't exist yet, use defaults
     }
     return keys.map((key) => {
+        // Check if key is in schema (built-in config)
         if (!(key in schema)) {
-            throw new Error(`Unknown config key: ${key}`);
+            // Key is not in schema - it's from a skill
+            // Create a simple text step with placeholder description
+            const keyParts = key.split('.');
+            const shortKey = keyParts[keyParts.length - 1];
+            const description = keyParts
+                .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+                .join(' ');
+            return {
+                description: `${description} {${key}}`,
+                key: shortKey,
+                type: StepType.Text,
+                value: null,
+                validate: () => true, // Accept any string for now
+            };
         }
         const definition = schema[key];
         const currentValue = getConfigValue(currentConfig, key);
@@ -301,3 +315,38 @@ export function createAnswerDisplayDefinition(answer) {
 export function isStateless(component) {
     return !('state' in component);
 }
+export function createExecuteDefinition(tasks, service, onError, onComplete, onAborted) {
+    return {
+        id: randomUUID(),
+        name: ComponentName.Execute,
+        state: {
+            done: false,
+            isLoading: true,
+        },
+        props: {
+            tasks,
+            service,
+            onError,
+            onComplete,
+            onAborted,
+        },
+    };
+}
+export function createValidateDefinition(missingConfig, userRequest, service, onError, onComplete, onAborted) {
+    return {
+        id: randomUUID(),
+        name: ComponentName.Validate,
+        state: {
+            done: false,
+            isLoading: true,
+        },
+        props: {
+            missingConfig,
+            userRequest,
+            service,
+            onError,
+            onComplete,
+            onAborted,
+        },
+    };
+}