prompt-language-shell 0.9.0 → 0.9.4

package/dist/services/components.js

@@ -1,407 +1,122 @@
 import { randomUUID } from 'node:crypto';
-import { parse as parseYaml } from 'yaml';
-import { ConfigDefinitionType, } from '../configuration/types.js';
 import { ComponentStatus, } from '../types/components.js';
 import { ComponentName } from '../types/types.js';
-import { getConfigPath, loadConfig } from '../configuration/io.js';
-import { getConfigSchema } from '../configuration/schema.js';
-import { getConfigLabel } from './config-labels.js';
-import { defaultFileSystem } from './filesystem.js';
-import { getConfirmationMessage } from './messages.js';
-import { StepType } from '../ui/Config.js';
-export function createWelcomeDefinition(app) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Welcome,
-        props: { app },
-        status: ComponentStatus.Awaiting,
-    };
-}
-export function createConfigSteps() {
-    // Use schema-based config step generation for required Anthropic settings
-    return createConfigStepsFromSchema(['anthropic.key', 'anthropic.model']);
-}
 /**
- * Get current config value for a dotted key path
+ * Shared component creation utility
  */
-function getConfigValue(config, key) {
-    if (!config)
-        return undefined;
-    const parts = key.split('.');
-    let value = config;
-    for (const part of parts) {
-        if (value && typeof value === 'object' && part in value) {
-            value = value[part];
-        }
-        else {
-            return undefined;
-        }
-    }
-    return value;
-}
+const createComponent = (name, props, state, status = ComponentStatus.Awaiting) => ({
+    id: randomUUID(),
+    name,
+    props,
+    ...(state !== undefined ? { state } : {}),
+    status,
+});
 /**
- * Get validation function for a config definition
+ * Create a simple component without state
  */
-function getValidator(definition) {
-    switch (definition.type) {
-        case ConfigDefinitionType.RegExp:
-            return (value) => definition.pattern.test(value);
-        case ConfigDefinitionType.String:
-            return () => true; // Strings are always valid
-        case ConfigDefinitionType.Enum:
-            return (value) => definition.values.includes(value);
-        case ConfigDefinitionType.Number:
-            return (value) => !isNaN(Number(value));
-        case ConfigDefinitionType.Boolean:
-            return (value) => value === 'true' || value === 'false';
-    }
-}
+const createSimpleComponent = (name, props, status) => createComponent(name, props, undefined, status);
 /**
- * Create config steps from schema for specified keys
+ * Create a managed component with state
  */
-export function createConfigStepsFromSchema(keys, fs = defaultFileSystem) {
-    const schema = getConfigSchema();
-    let currentConfig = null;
-    let rawConfig = null;
-    // Load validated config (may fail if config has validation errors)
-    try {
-        currentConfig = loadConfig(fs);
-    }
-    catch {
-        // Config doesn't exist or has validation errors, use defaults
-    }
-    // Load raw config separately (for discovered keys not in schema)
-    try {
-        const configFile = getConfigPath();
-        if (fs.exists(configFile)) {
-            const content = fs.readFile(configFile, 'utf-8');
-            rawConfig = parseYaml(content);
-        }
-    }
-    catch {
-        // Config file doesn't exist or can't be parsed
-    }
-    return keys.map((key) => {
-        // Check if key is in schema (system config)
-        if (!(key in schema)) {
-            // Key is not in schema - it's from a skill or discovered config
-            // Create a simple text step with cached label or full path as description
-            const keyParts = key.split('.');
-            const shortKey = keyParts[keyParts.length - 1];
-            // Load current value if it exists (use rawConfig since discovered keys aren't in validated config)
-            const currentValue = getConfigValue(rawConfig, key);
-            const value = currentValue !== undefined && typeof currentValue === 'string'
-                ? currentValue
-                : null;
-            // Use cached label if available, fallback to key path
-            const cachedLabel = getConfigLabel(key, fs);
-            return {
-                description: cachedLabel ?? key,
-                key: shortKey,
-                path: key,
-                type: StepType.Text,
-                value,
-                validate: () => true, // Accept any string for now
-            };
-        }
-        const definition = schema[key];
-        const currentValue = getConfigValue(currentConfig, key);
-        const keyParts = key.split('.');
-        const shortKey = keyParts[keyParts.length - 1];
-        // Map definition to ConfigStep based on type
-        switch (definition.type) {
-            case ConfigDefinitionType.RegExp:
-            case ConfigDefinitionType.String: {
-                const value = currentValue !== undefined && typeof currentValue === 'string'
-                    ? currentValue
-                    : definition.type === ConfigDefinitionType.String
-                        ? (definition.default ?? '')
-                        : null;
-                return {
-                    description: definition.description,
-                    key: shortKey,
-                    path: key,
-                    type: StepType.Text,
-                    value,
-                    validate: getValidator(definition),
-                };
-            }
-            case ConfigDefinitionType.Number: {
-                const value = currentValue !== undefined && typeof currentValue === 'number'
-                    ? String(currentValue)
-                    : definition.default !== undefined
-                        ? String(definition.default)
-                        : '0';
-                return {
-                    description: definition.description,
-                    key: shortKey,
-                    path: key,
-                    type: StepType.Text,
-                    value,
-                    validate: getValidator(definition),
-                };
-            }
-            case ConfigDefinitionType.Enum: {
-                const currentStr = currentValue !== undefined && typeof currentValue === 'string'
-                    ? currentValue
-                    : definition.default;
-                const defaultIndex = currentStr
-                    ? definition.values.indexOf(currentStr)
-                    : 0;
-                return {
-                    description: definition.description,
-                    key: shortKey,
-                    path: key,
-                    type: StepType.Selection,
-                    options: definition.values.map((value) => ({
-                        label: value,
-                        value,
-                    })),
-                    defaultIndex: Math.max(0, defaultIndex),
-                    validate: getValidator(definition),
-                };
-            }
-            case ConfigDefinitionType.Boolean: {
-                const currentBool = currentValue !== undefined && typeof currentValue === 'boolean'
-                    ? currentValue
-                    : undefined;
-                return {
-                    description: definition.description,
-                    key: shortKey,
-                    path: key,
-                    type: StepType.Selection,
-                    options: [
-                        { label: 'yes', value: 'true' },
-                        { label: 'no', value: 'false' },
-                    ],
-                    defaultIndex: currentBool !== undefined ? (currentBool ? 0 : 1) : 0,
-                    validate: getValidator(definition),
-                };
-            }
-        }
-    });
-}
-export function createConfigDefinition(onFinished, onAborted) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Config,
-        status: ComponentStatus.Awaiting,
-        state: {
-            values: {},
-            completedStep: 0,
-            selectedIndex: 0,
-        },
-        props: {
-            steps: createConfigSteps(),
-            onFinished,
-            onAborted,
-        },
-    };
-}
+const createManagedComponent = (name, props, state, status) => createComponent(name, props, state, status);
 /**
- * Create config definition with specific keys
+ * Initial state constants for managed components
  */
-export function createConfigDefinitionWithKeys(keys, onFinished, onAborted) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Config,
-        status: ComponentStatus.Awaiting,
-        state: {
-            values: {},
-            completedStep: 0,
-            selectedIndex: 0,
-        },
-        props: {
-            steps: createConfigStepsFromSchema(keys),
-            onFinished,
-            onAborted,
-        },
-    };
-}
-export function createCommandDefinition(command, service) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Command,
-        status: ComponentStatus.Awaiting,
-        state: {
-            error: null,
-            message: null,
-            tasks: [],
-        },
-        props: {
-            command,
-            service,
-        },
-    };
-}
-export function createScheduleDefinition(message, tasks, onSelectionConfirmed) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Schedule,
-        status: ComponentStatus.Awaiting,
-        state: {
-            highlightedIndex: null,
-            currentDefineGroupIndex: 0,
-            completedSelections: [],
-        },
-        props: {
-            message,
-            tasks,
-            onSelectionConfirmed,
-        },
-    };
-}
-export function createFeedback(type, ...messages) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Feedback,
-        props: {
-            type,
-            message: messages.join('\n\n'),
-        },
-        status: ComponentStatus.Awaiting,
-    };
-}
-export function createMessage(text) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Message,
-        props: {
-            text,
-        },
-        status: ComponentStatus.Awaiting,
-    };
-}
-export function createDebugDefinition(title, content, color) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Debug,
-        props: {
-            title,
-            content,
-            color,
-        },
-        status: ComponentStatus.Awaiting,
-    };
-}
-export function createRefinement(text, onAborted) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Refinement,
-        status: ComponentStatus.Awaiting,
-        state: {},
-        props: {
-            text,
-            onAborted,
-        },
-    };
-}
-export function createConfirmDefinition(onConfirmed, onCancelled) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Confirm,
-        status: ComponentStatus.Awaiting,
-        state: {
-            confirmed: false,
-            selectedIndex: 0,
-        },
-        props: {
-            message: getConfirmationMessage(),
-            onConfirmed,
-            onCancelled,
-        },
-    };
-}
-export function createIntrospectDefinition(tasks, service) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Introspect,
-        status: ComponentStatus.Awaiting,
-        state: {
-            error: null,
-            capabilities: [],
-            message: null,
-        },
-        props: {
-            tasks,
-            service,
-        },
-    };
-}
-export function createReportDefinition(message, capabilities) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Report,
-        props: {
-            message,
-            capabilities,
-        },
-        status: ComponentStatus.Awaiting,
-    };
-}
-export function createAnswerDefinition(question, service) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Answer,
-        status: ComponentStatus.Awaiting,
-        state: {
-            error: null,
-            answer: null,
-        },
-        props: {
-            question,
-            service,
-        },
-    };
-}
-export function isSimple(component) {
-    return !('state' in component);
-}
+const InitialConfigState = {
+    values: {},
+    completedStep: 0,
+    selectedIndex: 0,
+};
+const InitialCommandState = {
+    error: null,
+    message: null,
+    tasks: [],
+};
+const InitialScheduleState = {
+    highlightedIndex: null,
+    currentDefineGroupIndex: 0,
+    completedSelections: [],
+};
+const InitialRefinementState = {};
+const InitialConfirmState = {
+    confirmed: false,
+    selectedIndex: 0,
+};
+const InitialIntrospectState = {
+    error: null,
+    capabilities: [],
+    message: null,
+};
+const InitialAnswerState = {
+    error: null,
+    answer: null,
+};
+const InitialExecuteState = {
+    error: null,
+    message: '',
+    summary: '',
+    tasks: [],
+    completionMessage: null,
+};
+const InitialValidateState = {
+    error: null,
+    completionMessage: null,
+    configRequirements: [],
+    validated: false,
+};
 /**
- * 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 sets the status to Done and returns the updated component.
+ * Create a welcome component that displays application information
  */
-export function markAsDone(component) {
-    return { ...component, status: ComponentStatus.Done };
-}
-export function createExecuteDefinition(tasks, service) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Execute,
-        status: ComponentStatus.Awaiting,
-        state: {
-            error: null,
-            message: '',
-            summary: '',
-            tasks: [],
-            completed: 0,
-            completionMessage: null,
-        },
-        props: {
-            tasks,
-            service,
-        },
-    };
-}
-export function createValidateDefinition(missingConfig, userRequest, service, onError, onValidationComplete, onAborted) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Validate,
-        status: ComponentStatus.Awaiting,
-        state: {
-            error: null,
-            completionMessage: null,
-            configRequirements: [],
-            validated: false,
-        },
-        props: {
-            missingConfig,
-            userRequest,
-            service,
-            onError,
-            onValidationComplete,
-            onAborted,
-        },
-    };
-}
+export const createWelcome = (props, status) => createSimpleComponent(ComponentName.Welcome, props, status);
+/**
+ * Create a feedback component that displays status messages
+ */
+export const createFeedback = (props, status) => createSimpleComponent(ComponentName.Feedback, props, status);
+/**
+ * Create a message component that displays informational text
+ */
+export const createMessage = (props, status) => createSimpleComponent(ComponentName.Message, props, status);
+/**
+ * Create a debug component that displays diagnostic information
+ */
+export const createDebug = (props, status) => createSimpleComponent(ComponentName.Debug, props, status);
+/**
+ * Create a report component that displays capability listings
+ */
+export const createReport = (props, status) => createSimpleComponent(ComponentName.Report, props, status);
+/**
+ * Create a configuration component for multi-step user input
+ */
+export const createConfig = (props, status) => createManagedComponent(ComponentName.Config, props, InitialConfigState, status);
+/**
+ * Create a command component that processes user requests via LLM
+ */
+export const createCommand = (props, status) => createManagedComponent(ComponentName.Command, props, InitialCommandState, status);
+/**
+ * Create a schedule component that displays and manages task execution plans
+ */
+export const createSchedule = (props, status) => createManagedComponent(ComponentName.Schedule, props, InitialScheduleState, status);
+/**
+ * Create a refinement component for interactive task selection
+ */
+export const createRefinement = (props, status) => createManagedComponent(ComponentName.Refinement, props, InitialRefinementState, status);
+/**
+ * Create a confirmation component that prompts user for yes/no decisions
+ */
+export const createConfirm = (props, status) => createManagedComponent(ComponentName.Confirm, props, InitialConfirmState, status);
+/**
+ * Create an introspect component that lists available capabilities
+ */
+export const createIntrospect = (props, status) => createManagedComponent(ComponentName.Introspect, props, InitialIntrospectState, status);
+/**
+ * Create an answer component that responds to information requests via LLM
+ */
+export const createAnswer = (props, status) => createManagedComponent(ComponentName.Answer, props, InitialAnswerState, status);
+/**
+ * Create an execute component that runs shell commands and processes operations
+ */
+export const createExecute = (props, status) => createManagedComponent(ComponentName.Execute, props, InitialExecuteState, status);
+/**
+ * Create a validate component that checks and collects missing configuration
+ */
+export const createValidate = (props, status) => createManagedComponent(ComponentName.Validate, props, InitialValidateState, status);

package/dist/services/logger.js

@@ -1,5 +1,5 @@
 import { DebugLevel } from '../configuration/types.js';
-import { createDebugDefinition } from './components.js';
+import { createDebug } from './components.js';
 import { loadDebugSetting } from '../configuration/io.js';
 import { Palette } from './colors.js';
 /**
@@ -68,7 +68,7 @@ export function logPrompt(toolName, command, instructions) {
     const lines = instructions.split('\n').length;
     const bytes = Buffer.byteLength(instructions, 'utf-8');
     const title = `SYSTEM PROMPT (${String(lines)} lines, ${String(bytes)} bytes)`;
-    return createDebugDefinition(title, content, Palette.Gray);
+    return createDebug({ title, content, color: Palette.Gray });
 }
 /**
  * Create debug component for LLM responses received
@@ -85,5 +85,5 @@ export function logResponse(toolName, response, durationMs) {
         JSON.stringify(response, null, 2),
     ].join('\n');
     const title = `LLM RESPONSE (${String(durationMs)} ms)`;
-    return createDebugDefinition(title, content, Palette.AshGray);
+    return createDebug({ title, content, color: Palette.AshGray });
 }

package/dist/services/messages.js

@@ -162,3 +162,22 @@ export function getExecutionErrorMessage(_error) {
     ];
     return messages[Math.floor(Math.random() * messages.length)];
 }
+/**
+ * Returns a loading message while fetching an answer.
+ * Randomly selects from variations to sound natural.
+ */
+export function getAnswerLoadingMessage() {
+    const messages = [
+        'Finding that out for you.',
+        'Looking into this.',
+        'Let me find out.',
+        'One moment please.',
+        'Checking on that.',
+        'Let me look that up.',
+        'Give me a moment.',
+        'Looking that up now.',
+        'Let me check.',
+        'Just a moment.',
+    ];
+    return messages[Math.floor(Math.random() * messages.length)];
+}

package/dist/services/refinement.js

@@ -8,8 +8,11 @@ import { routeTasksWithConfirm } from './router.js';
  */
 export async function handleRefinement(selectedTasks, service, originalCommand, lifecycleHandlers, workflowHandlers, requestHandlers) {
     // Create and add refinement component to queue
-    const refinementDef = createRefinement(getRefiningMessage(), (operation) => {
-        requestHandlers.onAborted(operation);
+    const refinementDef = createRefinement({
+        text: getRefiningMessage(),
+        onAborted: (operation) => {
+            requestHandlers.onAborted(operation);
+        },
     });
     workflowHandlers.addToQueue(refinementDef);
     try {