prompt-language-shell 0.6.0 → 0.6.2

package/dist/config/CONFIG.md

@@ -7,7 +7,8 @@ based on their query.
 ## Input
 
 You will receive:
-- `configStructure`: Object mapping config keys to descriptions (e.g., {"anthropic.key": "Anthropic API key"})
+- `configStructure`: Object mapping config keys to descriptions (e.g., {"anthropic.key": "Anthropic API key", "settings.debug": "Debug mode (optional)"})
+- `configuredKeys`: Array of keys that exist in the user's config file (e.g., ["anthropic.key", "anthropic.model", "settings.debug"])
 - `query`: User's request (e.g., "app", "mode", "anthropic", or empty)
 
 ## Task
@@ -18,7 +19,8 @@ Determine which config keys the user wants to configure and return them as tasks
 
 ### 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)
+- Also include any keys marked as "(optional)" that appear in `configuredKeys` (optional settings that exist in user's config file)
+- Also include any keys marked as "(discovered)" (they exist in user's config file but aren't in schema)
 - Required keys: `anthropic.key`, `anthropic.model`
 
 ### Query: "mode"

package/dist/services/anthropic.js

@@ -1,7 +1,49 @@
 import Anthropic from '@anthropic-ai/sdk';
-import { getAvailableConfigStructure, } from './configuration.js';
+import { getAvailableConfigStructure, getConfiguredKeys, } from './configuration.js';
 import { formatSkillsForPrompt, loadSkills } from './skills.js';
 import { toolRegistry } from './tool-registry.js';
+/**
+ * Wraps text to ensure no line exceeds the specified width.
+ * Breaks at word boundaries to maintain readability.
+ */
+function wrapText(text, maxWidth) {
+    const words = text.split(/\s+/);
+    const lines = [];
+    let currentLine = '';
+    for (const word of words) {
+        // If adding this word would exceed max width, start a new line
+        if (currentLine.length > 0 &&
+            currentLine.length + 1 + word.length > maxWidth) {
+            lines.push(currentLine);
+            currentLine = word;
+        }
+        else {
+            currentLine = currentLine.length > 0 ? `${currentLine} ${word}` : word;
+        }
+    }
+    // Add the last line if not empty
+    if (currentLine.length > 0) {
+        lines.push(currentLine);
+    }
+    return lines.join('\n');
+}
+/**
+ * Removes citation tags and other markup from answer text.
+ * Web search responses may include <cite> tags that should be stripped.
+ * Also wraps text to ensure lines don't exceed 80 characters.
+ */
+export function cleanAnswerText(text) {
+    // Remove citation tags like <cite index="1-1">content</cite>
+    // Replace with just the content
+    let cleaned = text.replace(/<cite[^>]*>(.*?)<\/cite>/g, '$1');
+    // Remove any other XML/HTML tags that might appear
+    cleaned = cleaned.replace(/<[^>]+>/g, '');
+    // Normalize whitespace, converting all whitespace to single spaces
+    cleaned = cleaned.replace(/\s+/g, ' ').trim();
+    // Wrap text to 80 characters per line
+    cleaned = wrapText(cleaned, 80);
+    return cleaned;
+}
 export class AnthropicService {
     client;
     model;
@@ -27,9 +69,12 @@ export class AnthropicService {
         // Add config structure for config tool only
         if (toolName === 'config') {
             const configStructure = getAvailableConfigStructure();
+            const configuredKeys = getConfiguredKeys();
             const configSection = '\n\n## Available Configuration\n\n' +
                 'Config structure (key: description):\n' +
-                JSON.stringify(configStructure, null, 2);
+                JSON.stringify(configStructure, null, 2) +
+                '\n\nConfigured keys (keys that exist in config file):\n' +
+                JSON.stringify(configuredKeys, null, 2);
             systemPrompt += configSection;
         }
         // Build tools array - add web search for answer tool
@@ -67,7 +112,7 @@ export class AnthropicService {
                 return {
                     message: '',
                     tasks: [],
-                    answer: textContent.text,
+                    answer: cleanAnswerText(textContent.text),
                 };
             }
         }
@@ -111,7 +156,7 @@ export class AnthropicService {
             return {
                 message: '',
                 tasks: [],
-                answer: input.answer,
+                answer: cleanAnswerText(input.answer),
             };
         }
         // Handle plan and introspect tool responses

package/dist/services/components.js

@@ -164,8 +164,8 @@ export function createConfigStepsFromSchema(keys) {
                     path: key,
                     type: StepType.Selection,
                     options: [
-                        { label: 'Yes', value: 'true' },
-                        { label: 'No', value: 'false' },
+                        { label: 'yes', value: 'true' },
+                        { label: 'no', value: 'false' },
                     ],
                     defaultIndex: currentBool !== undefined ? (currentBool ? 0 : 1) : 0,
                     validate: getValidator(definition),

package/dist/services/configuration.js

@@ -263,21 +263,14 @@ export function getMissingConfigKeys() {
     return missing;
 }
 /**
- * Get available config structure for CONFIG tool
- * Returns keys with descriptions only (no values for privacy)
+ * Get list of configured keys from config file
+ * Returns array of dot-notation keys that exist in the config file
  */
-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)
+export function getConfiguredKeys() {
     try {
         const configFile = getConfigFile();
         if (!existsSync(configFile)) {
-            return structure;
+            return [];
         }
         const content = readFileSync(configFile, 'utf-8');
         const parsed = YAML.parse(content);
@@ -296,25 +289,103 @@ export function getAvailableConfigStructure() {
             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)`;
+        return Object.keys(flatConfig);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get available config structure for CONFIG tool
+ * Returns keys with descriptions only (no values for privacy)
+ * Marks optional keys as "(optional)"
+ */
+export function getAvailableConfigStructure() {
+    const schema = getConfigSchema();
+    const structure = {};
+    // Try to load existing config to see which keys are already set
+    let flatConfig = {};
+    try {
+        const configFile = getConfigFile();
+        if (existsSync(configFile)) {
+            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;
             }
+            flatConfig = flattenConfig(parsed);
         }
     }
     catch {
-        // Config file doesn't exist or can't be read, only use schema
+        // Config file doesn't exist or can't be read
+    }
+    // Add schema keys with descriptions
+    // Mark optional keys as (optional)
+    for (const [key, definition] of Object.entries(schema)) {
+        const isOptional = !definition.required;
+        if (isOptional) {
+            structure[key] = `${definition.description} (optional)`;
+        }
+        else {
+            structure[key] = definition.description;
+        }
+    }
+    // Add discovered keys that aren't in schema
+    for (const key of Object.keys(flatConfig)) {
+        if (!(key in structure)) {
+            structure[key] = `${key} (discovered)`;
+        }
     }
     return structure;
 }
+/**
+ * Convert string value to appropriate type based on schema definition
+ */
+function parseConfigValue(key, stringValue, schema) {
+    // If we have a schema definition, use its type
+    if (key in schema) {
+        const definition = schema[key];
+        switch (definition.type) {
+            case 'boolean':
+                return stringValue === 'true';
+            case 'number':
+                return Number(stringValue);
+            case 'string':
+            case 'regexp':
+            case 'enum':
+                return stringValue;
+        }
+    }
+    // No schema definition - try to infer type from string value
+    // This handles skill-defined configs that may not be in schema yet
+    if (stringValue === 'true' || stringValue === 'false') {
+        return stringValue === 'true';
+    }
+    if (!isNaN(Number(stringValue)) && stringValue.trim() !== '') {
+        return Number(stringValue);
+    }
+    return stringValue;
+}
 /**
  * Unflatten dotted keys into nested structure
  * Example: { "product.alpha.path": "value" } -> { product: { alpha: { path: "value" } } }
+ * Converts string values to appropriate types based on config schema
  */
 export function unflattenConfig(dotted) {
     const result = {};
-    for (const [dottedKey, value] of Object.entries(dotted)) {
+    const schema = getConfigSchema();
+    for (const [dottedKey, stringValue] of Object.entries(dotted)) {
         const parts = dottedKey.split('.');
         const section = parts[0];
         // Initialize section if needed
@@ -325,8 +396,9 @@ export function unflattenConfig(dotted) {
             current[parts[i]] = current[parts[i]] ?? {};
             current = current[parts[i]];
         }
-        // Set final value
-        current[parts[parts.length - 1]] = value;
+        // Convert string value to appropriate type and set
+        const typedValue = parseConfigValue(dottedKey, stringValue, schema);
+        current[parts[parts.length - 1]] = typedValue;
     }
     return result;
 }

package/dist/services/refinement.js

@@ -25,7 +25,8 @@ export async function handleRefinement(selectedTasks, service, originalCommand,
         // Complete the Refinement component
         handlers.completeActive();
         // Route refined tasks to appropriate components
-        routeTasksWithConfirm(refinedResult.tasks, refinedResult.message, service, originalCommand, handlers, false // No DEFINE tasks in refined result
+        routeTasksWithConfirm(refinedResult.tasks, refinedResult.message, service, originalCommand, handlers, false, // No DEFINE tasks in refined result
+        undefined // No commandComponent - use normal flow
         );
     }
     catch (err) {

package/dist/services/task-router.js

@@ -20,7 +20,7 @@ export function getOperationName(tasks) {
  * Route tasks to appropriate components with Confirm flow
  * Handles the complete flow: Plan → Confirm → Execute/Answer/Introspect
  */
-export function routeTasksWithConfirm(tasks, message, service, userRequest, handlers, hasDefineTask = false) {
+export function routeTasksWithConfirm(tasks, message, service, userRequest, handlers, hasDefineTask = false, commandComponent) {
     if (tasks.length === 0)
         return;
     // Filter out ignore and discard tasks early
@@ -49,7 +49,13 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, hand
             // User cancelled
             handlers.onAborted(operation);
         });
-        handlers.addToTimeline(planDefinition);
+        // Use atomic update if commandComponent provided, else normal flow
+        if (commandComponent) {
+            handlers.completeActive(planDefinition);
+        }
+        else {
+            handlers.addToTimeline(planDefinition);
+        }
         handlers.addToQueue(confirmDefinition);
     }
 }

package/dist/ui/Answer.js

@@ -37,7 +37,7 @@ export function Answer({ question, state, isActive = true, service, handlers, })
                     // Update component state so answer persists in timeline
                     handlers?.updateState({ answer: answerText });
                     // Signal completion
-                    handlers?.onComplete();
+                    handlers?.completeActive();
                 }
             }
             catch (err) {

package/dist/ui/Command.js

@@ -61,16 +61,15 @@ export function Command({ command, state, isActive = true, service, handlers, on
                         }
                         : undefined);
                     if (hasDefineTask) {
-                        // Has DEFINE tasks: Add Plan to queue for selection
-                        // The refinement callback will handle routing after user selects
+                        // DEFINE tasks: Move Command to timeline, add Plan to queue
+                        handlers?.completeActive();
                         handlers?.addToQueue(planDefinition);
                     }
                     else {
-                        // No DEFINE tasks: Use routing service for Confirm flow
-                        routeTasksWithConfirm(result.tasks, result.message, svc, command, handlers, false);
+                        // No DEFINE tasks: Pass Plan to be added atomically with Command
+                        routeTasksWithConfirm(result.tasks, result.message, svc, command, handlers, false, planDefinition // Pass Plan for atomic update
+                        );
                     }
-                    // Move Command to timeline
-                    handlers?.onComplete();
                 }
             }
             catch (err) {

package/dist/ui/Config.js

@@ -90,8 +90,13 @@ export function Config({ steps, state, isActive = true, debug, handlers, onFinis
     });
     const [inputValue, setInputValue] = useState('');
     const [selectedIndex, setSelectedIndex] = useState(() => {
-        const firstStep = steps[0];
-        return firstStep?.type === StepType.Selection ? firstStep.defaultIndex : 0;
+        // Initialize selectedIndex based on current step's defaultIndex
+        if (isActive &&
+            step < steps.length &&
+            steps[step].type === StepType.Selection) {
+            return steps[step].defaultIndex;
+        }
+        return 0;
     });
     const normalizeValue = (value) => {
         if (value === null || value === undefined) {
@@ -99,10 +104,12 @@ export function Config({ steps, state, isActive = true, debug, handlers, onFinis
         }
         return value.replace(/\n/g, '').trim();
     };
-    useInput((input, key) => {
-        if (key.escape && isActive && step < steps.length) {
+    useInput((_, key) => {
+        if (!isActive || step >= steps.length)
+            return;
+        const currentStepConfig = steps[step];
+        if (key.escape) {
             // Save current value before aborting
-            const currentStepConfig = steps[step];
             if (currentStepConfig) {
                 const configKey = currentStepConfig.path || currentStepConfig.key;
                 let currentValue = '';
@@ -111,10 +118,7 @@ export function Config({ steps, state, isActive = true, debug, handlers, onFinis
                         currentValue = inputValue || values[configKey] || '';
                         break;
                     case StepType.Selection:
-                        currentValue =
-                            currentStepConfig.options[selectedIndex]?.value ||
-                                values[configKey] ||
-                                '';
+                        currentValue = values[configKey] || '';
                         break;
                     default: {
                         const exhaustiveCheck = currentStepConfig;
@@ -130,24 +134,13 @@ export function Config({ steps, state, isActive = true, debug, handlers, onFinis
             }
             return;
         }
-        const currentStep = steps[step];
-        if (isActive && step < steps.length && currentStep) {
-            switch (currentStep.type) {
-                case StepType.Selection:
-                    if (key.tab) {
-                        setSelectedIndex((prev) => (prev + 1) % currentStep.options.length);
-                    }
-                    else if (key.return) {
-                        handleSubmit(currentStep.options[selectedIndex].value);
-                    }
-                    break;
-                case StepType.Text:
-                    // Text input handled by TextInput component
-                    break;
-                default: {
-                    const exhaustiveCheck = currentStep;
-                    throw new Error(`Unsupported step type: ${exhaustiveCheck}`);
-                }
+        // Handle selection step navigation
+        if (currentStepConfig.type === StepType.Selection) {
+            if (key.tab) {
+                setSelectedIndex((prev) => (prev + 1) % currentStepConfig.options.length);
+            }
+            else if (key.return) {
+                handleSubmit(currentStepConfig.options[selectedIndex].value);
             }
         }
     });
@@ -188,35 +181,38 @@ export function Config({ steps, state, isActive = true, debug, handlers, onFinis
         setInputValue('');
         if (step === steps.length - 1) {
             // Last step completed
+            // IMPORTANT: Update state BEFORE calling onFinished
+            // onFinished may call handlers.completeActive(), so state must be saved first
+            const stateUpdate = {
+                values: newValues,
+                completedStep: steps.length,
+            };
+            handlers?.updateState(stateUpdate);
+            // Now call onFinished - this may trigger completeActive()
             if (onFinished) {
                 onFinished(newValues);
             }
-            // Save state before completing
-            handlers?.updateState({
-                values: newValues,
-                completedStep: steps.length,
-            });
-            // Signal Workflow that config is complete
-            handlers?.onComplete();
             setStep(steps.length);
         }
         else {
             // Save state after each step
-            handlers?.updateState({
+            const stateUpdate = {
                 values: newValues,
                 completedStep: step + 1,
-            });
-            setStep(step + 1);
-            // Reset selection index for next step
-            const nextStep = steps[step + 1];
-            if (nextStep?.type === StepType.Selection) {
-                setSelectedIndex(nextStep.defaultIndex);
+            };
+            handlers?.updateState(stateUpdate);
+            const nextStep = step + 1;
+            setStep(nextStep);
+            // Reset selectedIndex for next step
+            if (nextStep < steps.length &&
+                steps[nextStep].type === StepType.Selection) {
+                setSelectedIndex(steps[nextStep].defaultIndex);
             }
         }
     };
     const renderStepInput = (stepConfig, isCurrentStep) => {
         const configKey = stepConfig.path || stepConfig.key;
-        // Use state values if not active (in timeline), otherwise use local values
+        // Use state values when inactive, local values when active
         const displayValue = !isActive && state?.values ? state.values[configKey] : values[configKey];
         switch (stepConfig.type) {
             case StepType.Text:
@@ -226,10 +222,11 @@ export function Config({ steps, state, isActive = true, debug, handlers, onFinis
                 return (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: displayValue || '' }));
             case StepType.Selection: {
                 if (!isCurrentStep) {
-                    const selectedOption = stepConfig.options.find((opt) => opt.value === displayValue);
-                    return _jsx(Text, { dimColor: true, children: selectedOption?.label || '' });
+                    // Find the option that matches the saved/current value
+                    const option = stepConfig.options.find((opt) => opt.value === displayValue);
+                    return _jsx(Text, { dimColor: true, children: option?.label || '' });
                 }
-                return (_jsx(SelectionStep, { options: stepConfig.options, selectedIndex: selectedIndex, isCurrentStep: isCurrentStep }));
+                return (_jsx(SelectionStep, { options: stepConfig.options, selectedIndex: selectedIndex, isCurrentStep: true }));
             }
             default: {
                 const exhaustiveCheck = stepConfig;

package/dist/ui/Execute.js

@@ -157,7 +157,7 @@ export function Execute({ tasks, state, isActive = true, service, handlers, }) {
             commandStatuses,
             error,
         });
-        handlers?.onComplete();
+        handlers?.completeActive();
     }, [isExecuting, commandStatuses, outputs, handlers, message, error]);
     useEffect(() => {
         if (!isActive) {
@@ -197,7 +197,7 @@ export function Execute({ tasks, state, isActive = true, service, handlers, }) {
                         message: result.message,
                         commandStatuses: [],
                     });
-                    handlers?.onComplete();
+                    handlers?.completeActive();
                     return;
                 }
                 // Resolve placeholders in command strings before execution

package/dist/ui/Introspect.js

@@ -86,7 +86,7 @@ export function Introspect({ tasks, state, isActive = true, service, children, d
                     // Add Report component to queue
                     handlers?.addToQueue(createReportDefinition(result.message, capabilities));
                     // Signal completion
-                    handlers?.onComplete();
+                    handlers?.completeActive();
                 }
             }
             catch (err) {

package/dist/ui/Plan.js

@@ -72,7 +72,7 @@ export function Plan({ message, tasks, state, isActive = true, debug = false, ha
             const concreteTasks = tasks.filter((task) => task.type !== TaskType.Ignore && task.type !== TaskType.Discard);
             onSelectionConfirmed(concreteTasks);
             // Signal Plan completion after adding Confirm to queue
-            handlers?.onComplete();
+            handlers?.completeActive();
         }
     }, [
         isActive,
@@ -145,12 +145,12 @@ export function Plan({ message, tasks, state, isActive = true, debug = false, ha
                 if (onSelectionConfirmed) {
                     // Callback will handle the entire flow (Refinement, refined Plan, Confirm)
                     // So we need to complete the Plan first
-                    handlers?.onComplete();
+                    handlers?.completeActive();
                     onSelectionConfirmed(refinedTasks);
                 }
                 else {
                     // No selection callback, just complete normally
-                    handlers?.onComplete();
+                    handlers?.completeActive();
                 }
             }
         }

package/dist/ui/Workflow.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { Box, Static } from 'ink';
 import { ComponentName, FeedbackType } from '../types/types.js';
 import { createFeedback, isStateless, markAsDone, } from '../services/components.js';
@@ -10,21 +10,31 @@ export const Workflow = ({ initialQueue, debug }) => {
     const [timeline, setTimeline] = useState([]);
     const [active, setActive] = useState(null);
     const [queue, setQueue] = useState(initialQueue);
-    // Function to move active component to timeline
-    const moveActiveToTimeline = useCallback(() => {
-        setActive((curr) => {
-            if (!curr)
-                return null;
-            const doneComponent = markAsDone(curr);
-            setTimeline((prev) => [...prev, doneComponent]);
-            return null;
-        });
+    // Ref to track active component for synchronous access
+    const activeRef = useRef(null);
+    // Keep ref in sync with active state
+    useEffect(() => {
+        activeRef.current = active;
+    }, [active]);
+    // Function to move active component to timeline with optional additional items
+    const moveActiveToTimeline = useCallback((...items) => {
+        const curr = activeRef.current;
+        if (!curr) {
+            // No active component, just add items if provided
+            if (items.length > 0) {
+                setTimeline((prev) => [...prev, ...items]);
+            }
+            return;
+        }
+        const doneComponent = markAsDone(curr);
+        // Atomic update: add active component and any additional items
+        setTimeline((prev) => items.length > 0
+            ? [...prev, doneComponent, ...items]
+            : [...prev, doneComponent]);
+        setActive(null);
     }, []);
     // Global handlers for all stateful components
     const handlers = useMemo(() => ({
-        onComplete: () => {
-            moveActiveToTimeline();
-        },
         onAborted: (operation) => {
             moveActiveToTimeline();
             // Add feedback to queue and exit
@@ -48,21 +58,24 @@ export const Workflow = ({ initialQueue, debug }) => {
         addToTimeline: (...items) => {
             setTimeline((prev) => [...prev, ...items]);
         },
-        completeActive: () => {
-            moveActiveToTimeline();
+        completeActive: (...items) => {
+            moveActiveToTimeline(...items);
         },
         updateState: (newState) => {
             setActive((curr) => {
                 if (!curr || !('state' in curr))
                     return curr;
                 const stateful = curr;
-                return {
+                const updated = {
                     ...stateful,
                     state: {
                         ...stateful.state,
                         ...newState,
                     },
                 };
+                // Update ref synchronously so moveActiveToTimeline sees the latest state
+                activeRef.current = updated;
+                return updated;
             });
         },
     }), [moveActiveToTimeline]);

package/package.json

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