prompt-language-shell 0.8.4 → 0.8.6

package/dist/ui/Workflow.js

@@ -3,12 +3,11 @@ import { useCallback, useEffect, useMemo, useState } from 'react';
 import { Box, Static } from 'ink';
 import { ComponentStatus, } from '../types/components.js';
 import { ComponentName, FeedbackType } from '../types/types.js';
-import { createFeedback, isStateless, markAsDone, } from '../services/components.js';
-import { DebugLevel } from '../services/configuration.js';
+import { createFeedback, isSimple, markAsDone, } from '../services/components.js';
 import { getWarnings } from '../services/logger.js';
 import { getCancellationMessage } from '../services/messages.js';
 import { exitApp } from '../services/process.js';
-import { Component } from './Component.js';
+import { SimpleComponent, ControllerComponent, TimelineComponent, } from './Component.js';
 export const Workflow = ({ initialQueue, debug }) => {
     const [timeline, setTimeline] = useState([]);
     const [current, setCurrent] = useState({ active: null, pending: null });
@@ -36,25 +35,42 @@ export const Workflow = ({ initialQueue, debug }) => {
             return { active: null, pending };
         });
     }, []);
-    // Focused handler instances - segregated by responsibility
-    const stateHandlers = useMemo(() => ({
-        updateState: (newState) => {
+    // Request handlers - manages errors, aborts, and completions
+    const requestHandlers = useMemo(() => ({
+        onError: (error) => {
+            moveActiveToTimeline();
+            // Add feedback to queue
+            setQueue((queue) => [
+                ...queue,
+                createFeedback(FeedbackType.Failed, error),
+            ]);
+        },
+        onAborted: (operation) => {
+            moveActiveToTimeline();
+            // Add feedback to queue
+            const message = getCancellationMessage(operation);
+            setQueue((queue) => [
+                ...queue,
+                createFeedback(FeedbackType.Aborted, message),
+            ]);
+        },
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+        onCompleted: (finalState) => {
             setCurrent((curr) => {
                 const { active, pending } = curr;
                 if (!active || !('state' in active))
                     return curr;
-                const stateful = active;
+                // Save final state to definition
+                const managed = active;
                 const updated = {
-                    ...stateful,
-                    state: {
-                        ...stateful.state,
-                        ...newState,
-                    },
+                    ...managed,
+                    state: finalState,
                 };
                 return { active: updated, pending };
             });
         },
-    }), []);
+    }), [moveActiveToTimeline]);
+    // Lifecycle handlers - for components with active/pending states
     const lifecycleHandlers = useMemo(() => ({
         completeActive: (...items) => {
             moveActiveToPending();
@@ -62,33 +78,6 @@ export const Workflow = ({ initialQueue, debug }) => {
                 setQueue((queue) => [...items, ...queue]);
             }
         },
-    }), [moveActiveToPending]);
-    const queueHandlers = useMemo(() => ({
-        addToQueue: (...items) => {
-            setQueue((queue) => [...queue, ...items]);
-        },
-    }), []);
-    const errorHandlers = useMemo(() => ({
-        onAborted: (operation) => {
-            moveActiveToTimeline();
-            // Add feedback to queue
-            const message = getCancellationMessage(operation);
-            setQueue((queue) => [
-                ...queue,
-                createFeedback(FeedbackType.Aborted, message),
-            ]);
-        },
-        onError: (error) => {
-            moveActiveToTimeline();
-            // Add feedback to queue
-            setQueue((queue) => [
-                ...queue,
-                createFeedback(FeedbackType.Failed, error),
-            ]);
-        },
-    }), [moveActiveToTimeline]);
-    // Workflow handlers - used for timeline/queue management
-    const workflowHandlers = useMemo(() => ({
         completeActiveAndPending: (...items) => {
             setCurrent((curr) => {
                 const { active, pending } = curr;
@@ -107,6 +96,12 @@ export const Workflow = ({ initialQueue, debug }) => {
                 setQueue((queue) => [...items, ...queue]);
             }
         },
+    }), [moveActiveToPending]);
+    // Workflow handlers - manages queue and timeline
+    const workflowHandlers = useMemo(() => ({
+        addToQueue: (...items) => {
+            setQueue((queue) => [...queue, ...items]);
+        },
         addToTimeline: (...items) => {
             setTimeline((prev) => [...prev, ...items]);
         },
@@ -140,13 +135,13 @@ export const Workflow = ({ initialQueue, debug }) => {
         const { active, pending } = current;
         if (!active)
             return;
-        if (isStateless(active)) {
-            // Stateless components move directly to timeline
+        if (isSimple(active)) {
+            // Simple components move directly to timeline
             const doneComponent = markAsDone(active);
             setTimeline((prev) => [...prev, doneComponent]);
             setCurrent({ active: null, pending });
         }
-        // Stateful components stay in active until handlers move them to pending
+        // Managed components stay in active until handlers move them to pending
     }, [current]);
     // Check for accumulated warnings and add them to timeline
     useEffect(() => {
@@ -180,86 +175,18 @@ export const Workflow = ({ initialQueue, debug }) => {
             lastItem.props.type === FeedbackType.Failed;
         exitApp(isFailed ? 1 : 0);
     }, [current, queue, timeline]);
-    // Render active and pending components
-    const activeComponent = useMemo(() => {
-        const { active } = current;
-        if (!active)
-            return null;
-        // For stateless components, render as-is
-        if (isStateless(active)) {
-            return _jsx(Component, { def: active, debug: debug }, active.id);
-        }
-        // For stateful components, inject focused handlers
-        const statefulActive = active;
-        const wrappedDef = {
-            ...statefulActive,
-            props: {
-                ...statefulActive.props,
-                stateHandlers,
-                lifecycleHandlers,
-                queueHandlers,
-                errorHandlers,
-                workflowHandlers,
-            },
-        };
-        return _jsx(Component, { def: wrappedDef, debug: debug }, active.id);
-    }, [
-        current,
-        debug,
-        stateHandlers,
-        lifecycleHandlers,
-        queueHandlers,
-        errorHandlers,
-        workflowHandlers,
-    ]);
-    const pendingComponent = useMemo(() => {
-        const { pending } = current;
-        if (!pending)
+    // Render component with handlers (used for both active and pending)
+    const renderComponent = useCallback((def, status) => {
+        if (!def)
             return null;
-        // For stateless components, render as-is
-        if (isStateless(pending)) {
-            return _jsx(Component, { def: pending, debug: debug }, pending.id);
+        // For simple components, render as-is
+        if (isSimple(def)) {
+            return _jsx(SimpleComponent, { def: def }, def.id);
         }
-        // For stateful components, inject focused handlers (they may have useEffect hooks)
-        const statefulPending = pending;
-        const wrappedDef = {
-            ...statefulPending,
-            props: {
-                ...statefulPending.props,
-                stateHandlers,
-                lifecycleHandlers,
-                queueHandlers,
-                errorHandlers,
-                workflowHandlers,
-            },
-        };
-        return _jsx(Component, { def: wrappedDef, debug: debug }, pending.id);
-    }, [
-        current,
-        debug,
-        stateHandlers,
-        lifecycleHandlers,
-        queueHandlers,
-        errorHandlers,
-        workflowHandlers,
-    ]);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: timeline, children: (item) => {
-                    // For stateful timeline components, inject handlers (useEffect hooks may still run)
-                    let def = item;
-                    if (!isStateless(item)) {
-                        const statefulItem = item;
-                        def = {
-                            ...statefulItem,
-                            props: {
-                                ...statefulItem.props,
-                                stateHandlers,
-                                lifecycleHandlers,
-                                queueHandlers,
-                                errorHandlers,
-                                workflowHandlers,
-                            },
-                        };
-                    }
-                    return (_jsx(Box, { marginTop: 1, children: _jsx(Component, { def: def, debug: DebugLevel.None }) }, item.id));
-                } }, "timeline"), pendingComponent && _jsx(Box, { marginTop: 1, children: pendingComponent }), activeComponent && _jsx(Box, { marginTop: 1, children: activeComponent })] }));
+        // For managed components, inject handlers via ControllerComponent
+        return (_jsx(ControllerComponent, { def: { ...def, status }, debug: debug, requestHandlers: requestHandlers, lifecycleHandlers: lifecycleHandlers, workflowHandlers: workflowHandlers }, def.id));
+    }, [debug, requestHandlers, lifecycleHandlers, workflowHandlers]);
+    const activeComponent = useMemo(() => renderComponent(current.active, ComponentStatus.Active), [current.active, renderComponent]);
+    const pendingComponent = useMemo(() => renderComponent(current.pending, ComponentStatus.Pending), [current.pending, renderComponent]);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: timeline, children: (item) => (_jsx(Box, { marginTop: 1, children: _jsx(TimelineComponent, { def: item }) }, item.id)) }, "timeline"), pendingComponent && _jsx(Box, { marginTop: 1, children: pendingComponent }), activeComponent && _jsx(Box, { marginTop: 1, children: activeComponent })] }));
 };

package/package.json

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

package/dist/services/configuration.js

@@ -1,409 +0,0 @@
-import { homedir } from 'os';
-import { join } from 'path';
-import YAML from 'yaml';
-import { getConfigLabel } from './config-labels.js';
-import { flattenConfig } from './config-utils.js';
-import { defaultFileSystem } from './filesystem.js';
-/**
- * Convert a dotted config key to a readable label
- * Example: "project.alpha.repo" -> "Project Alpha Repo"
- */
-function keyToLabel(key) {
-    return key
-        .split('.')
-        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-        .join(' ');
-}
-export var AnthropicModel;
-(function (AnthropicModel) {
-    AnthropicModel["Sonnet"] = "claude-sonnet-4-5";
-    AnthropicModel["Haiku"] = "claude-haiku-4-5";
-    AnthropicModel["Opus"] = "claude-opus-4-1";
-})(AnthropicModel || (AnthropicModel = {}));
-export const SUPPORTED_MODELS = Object.values(AnthropicModel);
-export var DebugLevel;
-(function (DebugLevel) {
-    DebugLevel["None"] = "none";
-    DebugLevel["Info"] = "info";
-    DebugLevel["Verbose"] = "verbose";
-})(DebugLevel || (DebugLevel = {}));
-export const SUPPORTED_DEBUG_LEVELS = Object.values(DebugLevel);
-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) {
-        super(message);
-        this.name = 'ConfigError';
-        this.origin = origin;
-    }
-}
-function getConfigFile() {
-    return join(homedir(), '.plsrc');
-}
-function parseYamlConfig(content) {
-    try {
-        return YAML.parse(content);
-    }
-    catch (error) {
-        throw new ConfigError('Failed to parse configuration file', error instanceof Error ? error : undefined);
-    }
-}
-function validateConfig(parsed) {
-    if (!parsed || typeof parsed !== 'object') {
-        throw new ConfigError('Invalid configuration format');
-    }
-    const config = parsed;
-    // Validate anthropic section
-    if (!config.anthropic || typeof config.anthropic !== 'object') {
-        throw new ConfigError('Missing or invalid anthropic configuration');
-    }
-    const { key, model } = config.anthropic;
-    if (!key || typeof key !== 'string') {
-        throw new ConfigError('Missing or invalid API key');
-    }
-    const validatedConfig = {
-        anthropic: {
-            key,
-        },
-    };
-    // Optional model - only set if valid
-    if (model && typeof model === 'string' && isValidAnthropicModel(model)) {
-        validatedConfig.anthropic.model = model;
-    }
-    // Optional settings section
-    if (config.settings && typeof config.settings === 'object') {
-        const settings = config.settings;
-        validatedConfig.settings = {};
-        if ('debug' in settings) {
-            // Handle migration from boolean to enum
-            if (typeof settings.debug === 'boolean') {
-                validatedConfig.settings.debug = settings.debug
-                    ? DebugLevel.Info
-                    : DebugLevel.None;
-            }
-            else if (typeof settings.debug === 'string' &&
-                SUPPORTED_DEBUG_LEVELS.includes(settings.debug)) {
-                validatedConfig.settings.debug = settings.debug;
-            }
-        }
-    }
-    return validatedConfig;
-}
-export function loadConfig(fs = defaultFileSystem) {
-    const configFile = getConfigFile();
-    if (!fs.exists(configFile)) {
-        throw new ConfigError('Configuration not found');
-    }
-    const content = fs.readFile(configFile, 'utf-8');
-    const parsed = parseYamlConfig(content);
-    return validateConfig(parsed);
-}
-export function getConfigPath() {
-    return getConfigFile();
-}
-export function configExists(fs = defaultFileSystem) {
-    return fs.exists(getConfigFile());
-}
-export function isValidAnthropicApiKey(key) {
-    // Anthropic API keys format: sk-ant-api03-XXXXX (108 chars total)
-    // - Prefix: sk-ant-api03- (13 chars)
-    // - Key body: 95 characters (uppercase, lowercase, digits, hyphens, underscores)
-    const apiKeyPattern = /^sk-ant-api03-[A-Za-z0-9_-]{95}$/;
-    return apiKeyPattern.test(key);
-}
-export function isValidAnthropicModel(model) {
-    return SUPPORTED_MODELS.includes(model);
-}
-export function hasValidAnthropicKey() {
-    try {
-        const config = loadConfig();
-        return (!!config.anthropic.key && isValidAnthropicApiKey(config.anthropic.key));
-    }
-    catch {
-        return false;
-    }
-}
-export function mergeConfig(existingContent, sectionName, newValues) {
-    const parsed = existingContent.trim()
-        ? YAML.parse(existingContent)
-        : {};
-    // Update or add section
-    const section = parsed[sectionName] ?? {};
-    for (const [key, value] of Object.entries(newValues)) {
-        section[key] = value;
-    }
-    parsed[sectionName] = section;
-    // Sort sections alphabetically
-    const sortedKeys = Object.keys(parsed).sort();
-    const sortedConfig = {};
-    for (const key of sortedKeys) {
-        sortedConfig[key] = parsed[key];
-    }
-    // Convert back to YAML
-    return YAML.stringify(sortedConfig);
-}
-export function saveConfig(section, config, fs = defaultFileSystem) {
-    const configFile = getConfigFile();
-    const existingContent = fs.exists(configFile)
-        ? fs.readFile(configFile, 'utf-8')
-        : '';
-    const newContent = mergeConfig(existingContent, section, config);
-    fs.writeFile(configFile, newContent);
-}
-export function saveAnthropicConfig(config, fs = defaultFileSystem) {
-    saveConfig('anthropic', config, fs);
-    return loadConfig(fs);
-}
-export function saveDebugSetting(debug, fs = defaultFileSystem) {
-    saveConfig('settings', { debug }, fs);
-}
-export function loadDebugSetting(fs = defaultFileSystem) {
-    try {
-        const config = loadConfig(fs);
-        return config.settings?.debug ?? DebugLevel.None;
-    }
-    catch {
-        return DebugLevel.None;
-    }
-}
-/**
- * Returns a message requesting initial setup.
- * Provides natural language variations that sound like a professional concierge
- * preparing to serve, avoiding technical jargon.
- *
- * @param forFutureUse - If true, indicates setup is for future requests rather than
- *                       an immediate task
- */
-export function getConfigurationRequiredMessage(forFutureUse = false) {
-    if (forFutureUse) {
-        const messages = [
-            "Before I can assist with your requests, let's get a few things ready.",
-            'Let me set up a few things so I can help you in the future.',
-            "I'll need to prepare a few things before I can assist you.",
-            "Let's get everything ready so I can help with your tasks.",
-            "I need to set up a few things first, then I'll be ready to assist.",
-            'Let me prepare everything so I can help you going forward.',
-        ];
-        return messages[Math.floor(Math.random() * messages.length)];
-    }
-    const messages = [
-        'Before I can help, let me get a few things ready.',
-        'I need to set up a few things first.',
-        'Let me prepare everything before we begin.',
-        'Just a moment while I get ready to assist you.',
-        "I'll need to get set up before I can help with that.",
-        'Let me get everything ready for you.',
-    ];
-    return messages[Math.floor(Math.random() * messages.length)];
-}
-/**
- * Core configuration schema - defines structure and types for system settings
- */
-const coreConfigSchema = {
-    'anthropic.key': {
-        type: ConfigDefinitionType.RegExp,
-        required: true,
-        pattern: /^sk-ant-api03-[A-Za-z0-9_-]{95}$/,
-        description: 'Anthropic API key',
-    },
-    'anthropic.model': {
-        type: ConfigDefinitionType.Enum,
-        required: true,
-        values: SUPPORTED_MODELS,
-        default: AnthropicModel.Haiku,
-        description: 'Anthropic model',
-    },
-    'settings.debug': {
-        type: ConfigDefinitionType.Enum,
-        required: false,
-        values: SUPPORTED_DEBUG_LEVELS,
-        default: DebugLevel.None,
-        description: 'Debug mode',
-    },
-};
-/**
- * Get complete configuration schema
- * Currently returns core schema only
- * Future: will merge with skill-declared schemas
- */
-export function getConfigSchema() {
-    return {
-        ...coreConfigSchema,
-        // Future: ...loadSkillSchemas()
-    };
-}
-/**
- * Get missing required configuration keys
- * Returns array of keys that are required but not present or invalid in config
- */
-export function getMissingConfigKeys() {
-    const schema = getConfigSchema();
-    const missing = [];
-    let currentConfig = null;
-    try {
-        currentConfig = loadConfig();
-    }
-    catch {
-        // Config doesn't exist
-    }
-    for (const [key, definition] of Object.entries(schema)) {
-        if (!definition.required) {
-            continue;
-        }
-        // Get current value for this key
-        const parts = key.split('.');
-        let value = currentConfig;
-        for (const part of parts) {
-            if (value && typeof value === 'object' && part in value) {
-                value = value[part];
-            }
-            else {
-                value = undefined;
-                break;
-            }
-        }
-        // Check if value is missing or invalid
-        if (value === undefined || value === null) {
-            missing.push(key);
-            continue;
-        }
-        // Validate based on type
-        let isValid = false;
-        switch (definition.type) {
-            case ConfigDefinitionType.RegExp:
-                isValid = typeof value === 'string' && definition.pattern.test(value);
-                break;
-            case ConfigDefinitionType.String:
-                isValid = typeof value === 'string';
-                break;
-            case ConfigDefinitionType.Enum:
-                isValid =
-                    typeof value === 'string' && definition.values.includes(value);
-                break;
-            case ConfigDefinitionType.Number:
-                isValid = typeof value === 'number';
-                break;
-            case ConfigDefinitionType.Boolean:
-                isValid = typeof value === 'boolean';
-                break;
-        }
-        if (!isValid) {
-            missing.push(key);
-        }
-    }
-    return missing;
-}
-/**
- * Get list of configured keys from config file
- * Returns array of dot-notation keys that exist in the config file
- */
-export function getConfiguredKeys(fs = defaultFileSystem) {
-    try {
-        const configFile = getConfigFile();
-        if (!fs.exists(configFile)) {
-            return [];
-        }
-        const content = fs.readFile(configFile, 'utf-8');
-        const parsed = YAML.parse(content);
-        // Flatten nested config to dot notation
-        const flatConfig = flattenConfig(parsed);
-        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(fs = defaultFileSystem) {
-    const schema = getConfigSchema();
-    const structure = {};
-    // Try to load existing config to see which keys are already set
-    let flatConfig = {};
-    try {
-        const configFile = getConfigFile();
-        if (fs.exists(configFile)) {
-            const content = fs.readFile(configFile, 'utf-8');
-            const parsed = YAML.parse(content);
-            // Flatten nested config to dot notation
-            flatConfig = flattenConfig(parsed);
-        }
-    }
-    catch {
-        // Config file doesn't exist or can't be read
-    }
-    // Add schema keys with descriptions
-    for (const [key, definition] of Object.entries(schema)) {
-        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] = getConfigLabel(key) || keyToLabel(key);
-        }
-    }
-    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 = {};
-    const schema = getConfigSchema();
-    for (const [dottedKey, stringValue] of Object.entries(dotted)) {
-        const parts = dottedKey.split('.');
-        const section = parts[0];
-        // Initialize section if needed
-        result[section] = result[section] ?? {};
-        // Build nested structure for this section
-        let current = result[section];
-        for (let i = 1; i < parts.length - 1; i++) {
-            current[parts[i]] = current[parts[i]] ?? {};
-            current = current[parts[i]];
-        }
-        // Convert string value to appropriate type and set
-        const typedValue = parseConfigValue(dottedKey, stringValue, schema);
-        current[parts[parts.length - 1]] = typedValue;
-    }
-    return result;
-}