prompt-language-shell 0.6.0 → 0.6.4

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

@@ -1,8 +1,9 @@
 import { randomUUID } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { ComponentName } from '../types/types.js';
+import { ComponentStatus, } from '../types/components.js';
 import { parse as parseYaml } from 'yaml';
-import { getConfigPath, getConfigSchema, loadConfig, } from './configuration.js';
+import { ConfigDefinitionType, getConfigPath, getConfigSchema, loadConfig, } from './configuration.js';
 import { getConfirmationMessage } from './messages.js';
 import { StepType } from '../ui/Config.js';
 export function createWelcomeDefinition(app) {
@@ -39,15 +40,15 @@ function getConfigValue(config, key) {
  */
 function getValidator(definition) {
     switch (definition.type) {
-        case 'regexp':
+        case ConfigDefinitionType.RegExp:
             return (value) => definition.pattern.test(value);
-        case 'string':
+        case ConfigDefinitionType.String:
             return () => true; // Strings are always valid
-        case 'enum':
+        case ConfigDefinitionType.Enum:
             return (value) => definition.values.includes(value);
-        case 'number':
+        case ConfigDefinitionType.Number:
             return (value) => !isNaN(Number(value));
-        case 'boolean':
+        case ConfigDefinitionType.Boolean:
             return (value) => value === 'true' || value === 'false';
     }
 }
@@ -103,11 +104,11 @@ export function createConfigStepsFromSchema(keys) {
         const shortKey = keyParts[keyParts.length - 1];
         // Map definition to ConfigStep based on type
         switch (definition.type) {
-            case 'regexp':
-            case 'string': {
+            case ConfigDefinitionType.RegExp:
+            case ConfigDefinitionType.String: {
                 const value = currentValue !== undefined && typeof currentValue === 'string'
                     ? currentValue
-                    : definition.type === 'string'
+                    : definition.type === ConfigDefinitionType.String
                         ? (definition.default ?? '')
                         : null;
                 return {
@@ -119,7 +120,7 @@ export function createConfigStepsFromSchema(keys) {
                     validate: getValidator(definition),
                 };
             }
-            case 'number': {
+            case ConfigDefinitionType.Number: {
                 const value = currentValue !== undefined && typeof currentValue === 'number'
                     ? String(currentValue)
                     : definition.default !== undefined
@@ -134,7 +135,7 @@ export function createConfigStepsFromSchema(keys) {
                     validate: getValidator(definition),
                 };
             }
-            case 'enum': {
+            case ConfigDefinitionType.Enum: {
                 const currentStr = currentValue !== undefined && typeof currentValue === 'string'
                     ? currentValue
                     : definition.default;
@@ -154,7 +155,7 @@ export function createConfigStepsFromSchema(keys) {
                     validate: getValidator(definition),
                 };
             }
-            case 'boolean': {
+            case ConfigDefinitionType.Boolean: {
                 const currentBool = currentValue !== undefined && typeof currentValue === 'boolean'
                     ? currentValue
                     : undefined;
@@ -164,8 +165,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),
@@ -178,6 +179,7 @@ export function createConfigDefinition(onFinished, onAborted) {
     return {
         id: randomUUID(),
         name: ComponentName.Config,
+        status: ComponentStatus.Awaiting,
         state: {},
         props: {
             steps: createConfigSteps(),
@@ -193,6 +195,7 @@ export function createConfigDefinitionWithKeys(keys, onFinished, onAborted) {
     return {
         id: randomUUID(),
         name: ComponentName.Config,
+        status: ComponentStatus.Awaiting,
         state: {},
         props: {
             steps: createConfigStepsFromSchema(keys),
@@ -205,6 +208,7 @@ export function createCommandDefinition(command, service) {
     return {
         id: randomUUID(),
         name: ComponentName.Command,
+        status: ComponentStatus.Awaiting,
         state: {},
         props: {
             command,
@@ -216,6 +220,7 @@ export function createPlanDefinition(message, tasks, onSelectionConfirmed) {
     return {
         id: randomUUID(),
         name: ComponentName.Plan,
+        status: ComponentStatus.Awaiting,
         state: {
             highlightedIndex: null,
             currentDefineGroupIndex: 0,
@@ -251,6 +256,7 @@ export function createRefinement(text, onAborted) {
     return {
         id: randomUUID(),
         name: ComponentName.Refinement,
+        status: ComponentStatus.Awaiting,
         state: {},
         props: {
             text,
@@ -262,6 +268,7 @@ export function createConfirmDefinition(onConfirmed, onCancelled) {
     return {
         id: randomUUID(),
         name: ComponentName.Confirm,
+        status: ComponentStatus.Awaiting,
         state: {},
         props: {
             message: getConfirmationMessage(),
@@ -274,6 +281,7 @@ export function createIntrospectDefinition(tasks, service) {
     return {
         id: randomUUID(),
         name: ComponentName.Introspect,
+        status: ComponentStatus.Awaiting,
         state: {},
         props: {
             tasks,
@@ -295,6 +303,7 @@ export function createAnswerDefinition(question, service) {
     return {
         id: randomUUID(),
         name: ComponentName.Answer,
+        status: ComponentStatus.Awaiting,
         state: {},
         props: {
             question,
@@ -308,16 +317,16 @@ export function isStateless(component) {
 /**
  * Mark a component as done. Returns the component to be added to timeline.
  * Components use handlers.updateState to save their state before completion,
- * so this function simply returns the component as-is.
+ * so this function sets the status to Done and returns the updated component.
  */
 export function markAsDone(component) {
-    // State already updated via handlers.updateState
-    return component;
+    return { ...component, status: ComponentStatus.Done };
 }
 export function createExecuteDefinition(tasks, service) {
     return {
         id: randomUUID(),
         name: ComponentName.Execute,
+        status: ComponentStatus.Awaiting,
         state: {},
         props: {
             tasks,
@@ -329,6 +338,7 @@ export function createValidateDefinition(missingConfig, userRequest, service, on
     return {
         id: randomUUID(),
         name: ComponentName.Validate,
+        status: ComponentStatus.Awaiting,
         state: {},
         props: {
             missingConfig,

package/dist/services/configuration.js

@@ -9,6 +9,14 @@ export var AnthropicModel;
     AnthropicModel["Opus"] = "claude-opus-4-1";
 })(AnthropicModel || (AnthropicModel = {}));
 export const SUPPORTED_MODELS = Object.values(AnthropicModel);
+export var ConfigDefinitionType;
+(function (ConfigDefinitionType) {
+    ConfigDefinitionType["RegExp"] = "regexp";
+    ConfigDefinitionType["String"] = "string";
+    ConfigDefinitionType["Enum"] = "enum";
+    ConfigDefinitionType["Number"] = "number";
+    ConfigDefinitionType["Boolean"] = "boolean";
+})(ConfigDefinitionType || (ConfigDefinitionType = {}));
 export class ConfigError extends Error {
     origin;
     constructor(message, origin) {
@@ -172,20 +180,20 @@ export function getConfigurationRequiredMessage(forFutureUse = false) {
  */
 const coreConfigSchema = {
     'anthropic.key': {
-        type: 'regexp',
+        type: ConfigDefinitionType.RegExp,
         required: true,
         pattern: /^sk-ant-api03-[A-Za-z0-9_-]{95}$/,
         description: 'Anthropic API key',
     },
     'anthropic.model': {
-        type: 'enum',
+        type: ConfigDefinitionType.Enum,
         required: true,
         values: SUPPORTED_MODELS,
         default: AnthropicModel.Haiku,
         description: 'Anthropic model',
     },
     'settings.debug': {
-        type: 'boolean',
+        type: ConfigDefinitionType.Boolean,
         required: false,
         description: 'Debug mode',
     },
@@ -239,20 +247,20 @@ export function getMissingConfigKeys() {
         // Validate based on type
         let isValid = false;
         switch (definition.type) {
-            case 'regexp':
+            case ConfigDefinitionType.RegExp:
                 isValid = typeof value === 'string' && definition.pattern.test(value);
                 break;
-            case 'string':
+            case ConfigDefinitionType.String:
                 isValid = typeof value === 'string';
                 break;
-            case 'enum':
+            case ConfigDefinitionType.Enum:
                 isValid =
                     typeof value === 'string' && definition.values.includes(value);
                 break;
-            case 'number':
+            case ConfigDefinitionType.Number:
                 isValid = typeof value === 'number';
                 break;
-            case 'boolean':
+            case ConfigDefinitionType.Boolean:
                 isValid = typeof value === 'boolean';
                 break;
         }
@@ -263,21 +271,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 +297,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 ConfigDefinitionType.Boolean:
+                return stringValue === 'true';
+            case ConfigDefinitionType.Number:
+                return Number(stringValue);
+            case ConfigDefinitionType.String:
+            case ConfigDefinitionType.RegExp:
+            case ConfigDefinitionType.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 +404,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/task-router.js

@@ -3,7 +3,7 @@ import { createAnswerDefinition, createConfigDefinitionWithKeys, createConfirmDe
 import { saveConfig, unflattenConfig } from './configuration.js';
 import { FeedbackType } from '../types/types.js';
 import { validateExecuteTasks } from './execution-validator.js';
-import { getMixedTaskTypesError, getUnknownRequestMessage, } from './messages.js';
+import { getCancellationMessage, getMixedTaskTypesError, getUnknownRequestMessage, } from './messages.js';
 /**
  * Determine the operation name based on task types
  */
@@ -32,25 +32,32 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, hand
         return;
     }
     const operation = getOperationName(validTasks);
-    // Create plan definition with valid tasks only
-    const planDefinition = createPlanDefinition(message, validTasks);
     if (hasDefineTask) {
         // Has DEFINE tasks - add Plan to queue for user selection
         // Refinement flow will call this function again with refined tasks
+        const planDefinition = createPlanDefinition(message, validTasks);
         handlers.addToQueue(planDefinition);
     }
     else {
-        // No DEFINE tasks - add Plan to timeline, create Confirm
-        const confirmDefinition = createConfirmDefinition(() => {
-            // User confirmed - route to appropriate component
-            handlers.completeActive();
-            executeTasksAfterConfirm(validTasks, service, userRequest, handlers);
-        }, () => {
-            // User cancelled
-            handlers.onAborted(operation);
+        // No DEFINE tasks - Plan auto-completes and adds Confirm to queue
+        // When Plan activates, Command moves to timeline
+        // When Plan completes, it moves to pending
+        // When Confirm activates, Plan stays pending (visible for context)
+        const planDefinition = createPlanDefinition(message, validTasks, () => {
+            // Plan completed - add Confirm to queue
+            const confirmDefinition = createConfirmDefinition(() => {
+                // User confirmed - complete both Confirm and Plan, then route to appropriate component
+                handlers.completeActiveAndPending();
+                executeTasksAfterConfirm(validTasks, service, userRequest, handlers);
+            }, () => {
+                // User cancelled - complete both Confirm and Plan, then show cancellation
+                handlers.completeActiveAndPending();
+                const message = getCancellationMessage(operation);
+                handlers.addToQueue(createFeedback(FeedbackType.Aborted, message));
+            });
+            handlers.addToQueue(confirmDefinition);
         });
-        handlers.addToTimeline(planDefinition);
-        handlers.addToQueue(confirmDefinition);
+        handlers.addToQueue(planDefinition);
     }
 }
 /**

package/dist/types/components.js

@@ -1 +1,8 @@
-export {};
+// Component lifecycle status
+export var ComponentStatus;
+(function (ComponentStatus) {
+    ComponentStatus["Awaiting"] = "awaiting";
+    ComponentStatus["Active"] = "active";
+    ComponentStatus["Pending"] = "pending";
+    ComponentStatus["Done"] = "done";
+})(ComponentStatus || (ComponentStatus = {}));

package/dist/ui/Answer.js

@@ -1,13 +1,15 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { Box, Text } from 'ink';
+import { ComponentStatus } from '../types/components.js';
 import { Colors, getTextColor } from '../services/colors.js';
 import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
 import { withMinimumTime } from '../services/timing.js';
 import { Spinner } from './Spinner.js';
 const MINIMUM_PROCESSING_TIME = 400;
-export function Answer({ question, state, isActive = true, service, handlers, }) {
+export function Answer({ question, state, status, service, handlers, }) {
+    const isActive = status === ComponentStatus.Active;
     const [error, setError] = useState(null);
     const [answer, setAnswer] = useState(state?.answer ?? null);
     useInput((input, key) => {
@@ -37,7 +39,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

@@ -1,6 +1,7 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { Box, Text } from 'ink';
+import { ComponentStatus, } from '../types/components.js';
 import { TaskType } from '../types/types.js';
 import { Colors } from '../services/colors.js';
 import { createPlanDefinition } from '../services/components.js';
@@ -12,7 +13,8 @@ import { ensureMinimumTime } from '../services/timing.js';
 import { Spinner } from './Spinner.js';
 import { UserQuery } from './UserQuery.js';
 const MIN_PROCESSING_TIME = 400; // purely for visual effect
-export function Command({ command, state, isActive = true, service, handlers, onAborted, }) {
+export function Command({ command, state, status, service, handlers, onAborted, }) {
+    const isActive = status === ComponentStatus.Active;
     const [error, setError] = useState(state?.error ?? null);
     useInput((_, key) => {
         if (key.escape && isActive) {
@@ -61,16 +63,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
+                        // No DEFINE tasks: Complete Command, then route to Confirm flow
+                        handlers?.completeActive();
                         routeTasksWithConfirm(result.tasks, result.message, svc, command, handlers, false);
                     }
-                    // Move Command to timeline
-                    handlers?.onComplete();
                 }
             }
             catch (err) {