prompt-language-shell 0.8.8 → 0.9.2

package/README.md

@@ -159,7 +159,6 @@ $ pls build test
 
 ## Roadmap
 
-- **0.8** - Sequential and interlaced skill execution
 - **0.9** - Learn skill, codebase refinement, complex dependency handling
 - **1.0** - Production release
 

package/dist/configuration/io.js

@@ -61,11 +61,32 @@ export function mergeConfig(existingContent, sectionName, newValues) {
 }
 export function saveConfig(section, config, fs = defaultFileSystem) {
     const configFile = getConfigFile();
+    const tempFile = `${configFile}.tmp`;
     const existingContent = fs.exists(configFile)
         ? fs.readFile(configFile, 'utf-8')
         : '';
     const newContent = mergeConfig(existingContent, section, config);
-    fs.writeFile(configFile, newContent);
+    try {
+        // Write to temp file first
+        fs.writeFile(tempFile, newContent);
+        // Validate the temp file can be parsed
+        const tempContent = fs.readFile(tempFile, 'utf-8');
+        parseYamlConfig(tempContent);
+        // Atomic rename (on POSIX systems)
+        fs.rename(tempFile, configFile);
+    }
+    catch (error) {
+        // Clean up temp file if it exists
+        if (fs.exists(tempFile)) {
+            try {
+                fs.remove(tempFile);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+        throw error;
+    }
 }
 export function saveAnthropicConfig(config, fs = defaultFileSystem) {
     saveConfig('anthropic', config, fs);

package/dist/{services/config-labels.js → configuration/labels.js}

@@ -1,6 +1,6 @@
 import { homedir } from 'os';
 import { join } from 'path';
-import { defaultFileSystem } from './filesystem.js';
+import { defaultFileSystem } from '../services/filesystem.js';
 /**
  * Get the path to the config labels cache file
  */

package/dist/configuration/schema.js

@@ -1,7 +1,7 @@
 import YAML from 'yaml';
 import { AnthropicModel, ConfigDefinitionType, DebugLevel, SUPPORTED_DEBUG_LEVELS, SUPPORTED_MODELS, } from './types.js';
-import { flattenConfig } from '../services/config-utils.js';
-import { getConfigLabel } from '../services/config-labels.js';
+import { flattenConfig } from './transformation.js';
+import { getConfigLabel } from './labels.js';
 import { defaultFileSystem } from '../services/filesystem.js';
 import { getConfigPath, loadConfig } from './io.js';
 /**

package/dist/configuration/steps.js

@@ -0,0 +1,171 @@
+import { parse as parseYaml } from 'yaml';
+import { ConfigDefinitionType } from './types.js';
+import { getConfigPath, loadConfig } from './io.js';
+import { getConfigSchema } from './schema.js';
+import { getConfigLabel } from './labels.js';
+import { defaultFileSystem } from '../services/filesystem.js';
+import { StepType } from '../ui/Config.js';
+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
+ */
+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;
+}
+/**
+ * Get validation function for a config definition
+ */
+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';
+    }
+}
+/**
+ * Create config steps from schema for specified keys
+ */
+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),
+                };
+            }
+        }
+    });
+}

package/dist/configuration/transformation.js

@@ -1,5 +1,22 @@
 import { ConfigDefinitionType } from './types.js';
 import { getConfigSchema } from './schema.js';
+/**
+ * Flatten nested config object to dot notation
+ * Example: { a: { b: 1 } } => { 'a.b': 1 }
+ */
+export 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;
+}
 /**
  * Convert string value to appropriate type based on schema definition
  */

package/dist/configuration/types.js

@@ -1,3 +1,4 @@
+import { AppError, ErrorCode } from '../types/errors.js';
 export var AnthropicModel;
 (function (AnthropicModel) {
     AnthropicModel["Sonnet"] = "claude-sonnet-4-5";
@@ -20,11 +21,9 @@ export var ConfigDefinitionType;
     ConfigDefinitionType["Number"] = "number";
     ConfigDefinitionType["Boolean"] = "boolean";
 })(ConfigDefinitionType || (ConfigDefinitionType = {}));
-export class ConfigError extends Error {
-    origin;
+export class ConfigError extends AppError {
     constructor(message, origin) {
-        super(message);
+        super(message, ErrorCode.MissingConfig, origin);
         this.name = 'ConfigError';
-        this.origin = origin;
     }
 }

package/dist/execution/handlers.js

@@ -1,14 +1,14 @@
 import { ExecutionStatus } from '../services/shell.js';
 import { formatDuration } from '../services/utils.js';
 import { ExecuteActionType, } from './types.js';
+import { getTotalElapsed } from './utils.js';
 /**
  * Handles task completion logic and returns the appropriate action and state.
  */
 export function handleTaskCompletion(index, elapsed, context) {
-    const { taskInfos, message, summary, taskExecutionTimes } = context;
-    const updatedTimes = [...taskExecutionTimes, elapsed];
-    const updatedTaskInfos = taskInfos.map((task, i) => i === index ? { ...task, status: ExecutionStatus.Success, elapsed } : task);
-    if (index < taskInfos.length - 1) {
+    const { tasks, message, summary } = context;
+    const updatedTaskInfos = tasks.map((task, i) => i === index ? { ...task, status: ExecutionStatus.Success, elapsed } : task);
+    if (index < tasks.length - 1) {
         // More tasks to execute
         return {
             action: {
@@ -18,9 +18,7 @@ export function handleTaskCompletion(index, elapsed, context) {
             finalState: {
                 message,
                 summary,
-                taskInfos: updatedTaskInfos,
-                completed: index + 1,
-                taskExecutionTimes: updatedTimes,
+                tasks: updatedTaskInfos,
                 completionMessage: null,
                 error: null,
             },
@@ -29,7 +27,7 @@ export function handleTaskCompletion(index, elapsed, context) {
     }
     // All tasks complete
     const summaryText = summary.trim() || 'Execution completed';
-    const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
+    const totalElapsed = getTotalElapsed(updatedTaskInfos);
     const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
     return {
         action: {
@@ -39,9 +37,7 @@ export function handleTaskCompletion(index, elapsed, context) {
         finalState: {
             message,
             summary,
-            taskInfos: updatedTaskInfos,
-            completed: index + 1,
-            taskExecutionTimes: updatedTimes,
+            tasks: updatedTaskInfos,
             completionMessage: completion,
             error: null,
         },
@@ -52,10 +48,10 @@ export function handleTaskCompletion(index, elapsed, context) {
  * Handles task error logic and returns the appropriate action and state.
  */
 export function handleTaskFailure(index, error, elapsed, context) {
-    const { taskInfos, message, summary, taskExecutionTimes } = context;
-    const task = taskInfos[index];
+    const { tasks, message, summary } = context;
+    const task = tasks[index];
     const isCritical = task.command.critical !== false; // Default to true
-    const updatedTaskInfos = taskInfos.map((task, i) => i === index ? { ...task, status: ExecutionStatus.Failed, elapsed } : task);
+    const updatedTaskInfos = tasks.map((task, i) => i === index ? { ...task, status: ExecutionStatus.Failed, elapsed } : task);
     if (isCritical) {
         // Critical failure - stop execution
         return {
@@ -66,19 +62,15 @@ export function handleTaskFailure(index, error, elapsed, context) {
             finalState: {
                 message,
                 summary,
-                taskInfos: updatedTaskInfos,
-                completed: index + 1,
-                taskExecutionTimes,
+                tasks: updatedTaskInfos,
                 completionMessage: null,
-                error,
+                error: null,
             },
             shouldComplete: true,
-            shouldReportError: true,
         };
     }
     // Non-critical failure - continue to next task
-    const updatedTimes = [...taskExecutionTimes, elapsed];
-    if (index < taskInfos.length - 1) {
+    if (index < tasks.length - 1) {
         return {
             action: {
                 type: ExecuteActionType.TaskErrorContinue,
@@ -87,19 +79,17 @@ export function handleTaskFailure(index, error, elapsed, context) {
             finalState: {
                 message,
                 summary,
-                taskInfos: updatedTaskInfos,
-                completed: index + 1,
-                taskExecutionTimes: updatedTimes,
+                tasks: updatedTaskInfos,
                 completionMessage: null,
                 error: null,
             },
             shouldComplete: false,
-            shouldReportError: false,
         };
     }
-    // Last task, complete execution
+    // Last task failed (non-critical), complete execution
+    // Non-critical failures still show completion message with summary
     const summaryText = summary.trim() || 'Execution completed';
-    const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
+    const totalElapsed = getTotalElapsed(updatedTaskInfos);
     const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
     return {
         action: {
@@ -109,26 +99,21 @@ export function handleTaskFailure(index, error, elapsed, context) {
         finalState: {
             message,
             summary,
-            taskInfos: updatedTaskInfos,
-            completed: index + 1,
-            taskExecutionTimes: updatedTimes,
+            tasks: updatedTaskInfos,
             completionMessage: completion,
             error: null,
         },
         shouldComplete: true,
-        shouldReportError: false,
     };
 }
 /**
  * Builds final state for task abortion.
  */
-export function buildAbortedState(taskInfos, message, summary, completed, taskExecutionTimes) {
+export function buildAbortedState(tasks, message, summary) {
     return {
         message,
         summary,
-        taskInfos,
-        completed,
-        taskExecutionTimes,
+        tasks,
         completionMessage: null,
         error: null,
     };