prompt-language-shell 0.8.6 → 0.9.0

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/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,8 @@ export function handleTaskCompletion(index, elapsed, context) {
             finalState: {
                 message,
                 summary,
-                taskInfos: updatedTaskInfos,
+                tasks: updatedTaskInfos,
                 completed: index + 1,
-                taskExecutionTimes: updatedTimes,
                 completionMessage: null,
                 error: null,
             },
@@ -29,7 +28,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 +38,8 @@ export function handleTaskCompletion(index, elapsed, context) {
         finalState: {
             message,
             summary,
-            taskInfos: updatedTaskInfos,
+            tasks: updatedTaskInfos,
             completed: index + 1,
-            taskExecutionTimes: updatedTimes,
             completionMessage: completion,
             error: null,
         },
@@ -52,10 +50,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 +64,16 @@ export function handleTaskFailure(index, error, elapsed, context) {
             finalState: {
                 message,
                 summary,
-                taskInfos: updatedTaskInfos,
+                tasks: updatedTaskInfos,
                 completed: index + 1,
-                taskExecutionTimes,
                 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 +82,18 @@ export function handleTaskFailure(index, error, elapsed, context) {
             finalState: {
                 message,
                 summary,
-                taskInfos: updatedTaskInfos,
+                tasks: updatedTaskInfos,
                 completed: index + 1,
-                taskExecutionTimes: updatedTimes,
                 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 +103,23 @@ export function handleTaskFailure(index, error, elapsed, context) {
         finalState: {
             message,
             summary,
-            taskInfos: updatedTaskInfos,
+            tasks: updatedTaskInfos,
             completed: index + 1,
-            taskExecutionTimes: updatedTimes,
             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, completed) {
     return {
         message,
         summary,
-        taskInfos,
+        tasks,
         completed,
-        taskExecutionTimes,
         completionMessage: null,
         error: null,
     };

package/dist/execution/processing.js

@@ -1,6 +1,15 @@
 import { loadUserConfig } from '../services/loader.js';
 import { replacePlaceholders } from '../services/resolver.js';
 import { validatePlaceholderResolution } from './validation.js';
+/**
+ * Fix escaped quotes in commands
+ * JSON parsing removes backslashes before quotes in patterns like key="value"
+ * This restores them: key="value" -> key=\"value\"
+ */
+export function fixEscapedQuotes(command) {
+    // Replace ="value" with =\"value\"
+    return command.replace(/="([^"]*)"/g, '=\\"$1\\"');
+}
 /**
  * Processes tasks through the AI service to generate executable commands.
  * Resolves placeholders in task descriptions and validates the results.
@@ -22,7 +31,9 @@ export async function processTasks(tasks, service) {
     const result = await service.processWithTool(taskDescriptions, 'execute');
     // Resolve placeholders in command strings
     const resolvedCommands = (result.commands || []).map((cmd) => {
-        const resolved = replacePlaceholders(cmd.command, userConfig);
+        // Fix escaped quotes lost in JSON parsing
+        const fixed = fixEscapedQuotes(cmd.command);
+        const resolved = replacePlaceholders(fixed, userConfig);
         validatePlaceholderResolution(resolved);
         return { ...cmd, command: resolved };
     });
@@ -30,6 +41,7 @@ export async function processTasks(tasks, service) {
         message: result.message,
         summary: result.summary || '',
         commands: resolvedCommands,
+        error: result.error,
         debug: result.debug,
     };
 }

package/dist/execution/reducer.js

@@ -1,13 +1,13 @@
 import { ExecutionStatus } from '../services/shell.js';
 import { formatDuration } from '../services/utils.js';
 import { ExecuteActionType, } from './types.js';
+import { getTotalElapsed } from './utils.js';
 export const initialState = {
     error: null,
-    taskInfos: [],
+    tasks: [],
     message: '',
     completed: 0,
     hasProcessed: false,
-    taskExecutionTimes: [],
     completionMessage: null,
     summary: '',
 };
@@ -24,7 +24,7 @@ export function executeReducer(state, action) {
                 ...state,
                 message: action.payload.message,
                 summary: action.payload.summary,
-                taskInfos: action.payload.taskInfos,
+                tasks: action.payload.tasks,
                 completed: 0,
             };
         case ExecuteActionType.ProcessingError:
@@ -34,11 +34,7 @@ export function executeReducer(state, action) {
                 hasProcessed: true,
             };
         case ExecuteActionType.TaskComplete: {
-            const updatedTimes = [
-                ...state.taskExecutionTimes,
-                action.payload.elapsed,
-            ];
-            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
+            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
                 ? {
                     ...task,
                     status: ExecutionStatus.Success,
@@ -47,49 +43,39 @@ export function executeReducer(state, action) {
                 : task);
             return {
                 ...state,
-                taskInfos: updatedTaskInfos,
-                taskExecutionTimes: updatedTimes,
+                tasks: updatedTaskInfos,
                 completed: action.payload.index + 1,
             };
         }
         case ExecuteActionType.AllTasksComplete: {
-            const updatedTimes = [
-                ...state.taskExecutionTimes,
-                action.payload.elapsed,
-            ];
-            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
+            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
                 ? {
                     ...task,
                     status: ExecutionStatus.Success,
                     elapsed: action.payload.elapsed,
                 }
                 : task);
-            const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
+            const totalElapsed = getTotalElapsed(updatedTaskInfos);
             const completion = `${action.payload.summaryText} in ${formatDuration(totalElapsed)}.`;
             return {
                 ...state,
-                taskInfos: updatedTaskInfos,
-                taskExecutionTimes: updatedTimes,
+                tasks: updatedTaskInfos,
                 completed: action.payload.index + 1,
                 completionMessage: completion,
             };
         }
         case ExecuteActionType.TaskErrorCritical: {
-            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
+            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
                 ? { ...task, status: ExecutionStatus.Failed, elapsed: 0 }
                 : task);
             return {
                 ...state,
-                taskInfos: updatedTaskInfos,
+                tasks: updatedTaskInfos,
                 error: action.payload.error,
             };
         }
         case ExecuteActionType.TaskErrorContinue: {
-            const updatedTimes = [
-                ...state.taskExecutionTimes,
-                action.payload.elapsed,
-            ];
-            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
+            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
                 ? {
                     ...task,
                     status: ExecutionStatus.Failed,
@@ -98,35 +84,29 @@ export function executeReducer(state, action) {
                 : task);
             return {
                 ...state,
-                taskInfos: updatedTaskInfos,
-                taskExecutionTimes: updatedTimes,
+                tasks: updatedTaskInfos,
                 completed: action.payload.index + 1,
             };
         }
         case ExecuteActionType.LastTaskError: {
-            const updatedTimes = [
-                ...state.taskExecutionTimes,
-                action.payload.elapsed,
-            ];
-            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
+            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
                 ? {
                     ...task,
                     status: ExecutionStatus.Failed,
                     elapsed: action.payload.elapsed,
                 }
                 : task);
-            const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
+            const totalElapsed = getTotalElapsed(updatedTaskInfos);
             const completion = `${action.payload.summaryText} in ${formatDuration(totalElapsed)}.`;
             return {
                 ...state,
-                taskInfos: updatedTaskInfos,
-                taskExecutionTimes: updatedTimes,
+                tasks: updatedTaskInfos,
                 completed: action.payload.index + 1,
                 completionMessage: completion,
             };
         }
         case ExecuteActionType.CancelExecution: {
-            const updatedTaskInfos = state.taskInfos.map((task, taskIndex) => {
+            const updatedTaskInfos = state.tasks.map((task, taskIndex) => {
                 if (taskIndex < action.payload.completed) {
                     return { ...task, status: ExecutionStatus.Success };
                 }
@@ -139,7 +119,7 @@ export function executeReducer(state, action) {
             });
             return {
                 ...state,
-                taskInfos: updatedTaskInfos,
+                tasks: updatedTaskInfos,
             };
         }
         default:

package/dist/execution/utils.js

@@ -0,0 +1,6 @@
+/**
+ * Calculate total elapsed time from task infos
+ */
+export function getTotalElapsed(tasks) {
+    return tasks.reduce((sum, task) => sum + task.elapsed, 0);
+}

package/dist/services/anthropic.js

@@ -167,6 +167,7 @@ export class AnthropicService {
                 summary: input.summary,
                 tasks: [],
                 commands: input.commands,
+                error: input.error,
                 debug,
             });
             if (!validation.success) {

package/dist/services/colors.js

@@ -1,13 +1,16 @@
 import { DebugLevel } from '../configuration/types.js';
 import { FeedbackType, Origin, TaskType } from '../types/types.js';
 import { ExecutionStatus } from './shell.js';
+import { ComponentStatus } from '../types/components.js';
 /**
  * Base color palette - raw color values with descriptive names.
  * All colors used in the interface are defined here.
  */
 export const Palette = {
     White: '#ffffff',
+    SoftWhite: '#fafafa',
     AshGray: '#d0d0d0',
+    LightGray: '#aaaaaa',
     Gray: '#888888',
     DarkGray: '#666666',
     CharcoalGray: '#282828',
@@ -32,6 +35,7 @@ export const Palette = {
 export const Colors = {
     Text: {
         Active: Palette.White,
+        Pending: Palette.SoftWhite,
         Inactive: Palette.AshGray,
         UserQuery: Palette.White,
     },
@@ -148,12 +152,18 @@ const originColors = {
  * - Colors.Text.Active for current items
  * - Colors.Text.Inactive (undefined) for historical items
  */
-function processColor(color, isCurrent) {
-    return color === null
-        ? isCurrent
-            ? Colors.Text.Active
-            : Colors.Text.Inactive
-        : color;
+function processColor(color, status) {
+    const getColor = () => {
+        switch (status) {
+            case ComponentStatus.Active:
+                return Colors.Text.Active;
+            case ComponentStatus.Pending:
+                return Colors.Text.Pending;
+            default:
+                return Colors.Text.Inactive;
+        }
+    };
+    return color || getColor();
 }
 /**
  * Get task colors with current/historical state handling.
@@ -162,11 +172,11 @@ function processColor(color, isCurrent) {
  * - Colors.Text.Inactive (undefined) for historical items
  * - Colors.Text.Active for current items
  */
-export function getTaskColors(type, isCurrent) {
+export function getTaskColors(type, status) {
     const colors = taskColors[type];
     return {
-        description: processColor(colors.description, isCurrent),
-        type: processColor(colors.type, isCurrent),
+        description: processColor(colors.description, status),
+        type: processColor(colors.type, status),
     };
 }
 /**
@@ -176,8 +186,8 @@ export function getTaskColors(type, isCurrent) {
  * - Colors.Text.Inactive (undefined) for historical items
  * - Colors.Text.Active for current items
  */
-export function getFeedbackColor(type, isCurrent) {
-    return processColor(feedbackColors[type], isCurrent);
+export function getFeedbackColor(type, status = ComponentStatus.Done) {
+    return processColor(feedbackColors[type], status);
 }
 /**
  * Get color for capability origin.

package/dist/services/components.js

@@ -374,9 +374,8 @@ export function createExecuteDefinition(tasks, service) {
             error: null,
             message: '',
             summary: '',
-            taskInfos: [],
+            tasks: [],
             completed: 0,
-            taskExecutionTimes: [],
             completionMessage: null,
         },
         props: {

package/dist/services/filesystem.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from 'fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from 'fs';
 import { dirname } from 'path';
 /**
  * Real filesystem implementation using Node's fs module
@@ -19,6 +19,12 @@ export class RealFileSystem {
     createDirectory(path, options) {
         mkdirSync(path, options);
     }
+    rename(oldPath, newPath) {
+        renameSync(oldPath, newPath);
+    }
+    remove(path) {
+        unlinkSync(path);
+    }
 }
 /**
  * In-memory filesystem implementation for testing
@@ -93,6 +99,20 @@ export class MemoryFileSystem {
             this.directories.add(path);
         }
     }
+    rename(oldPath, newPath) {
+        const content = this.files.get(oldPath);
+        if (content === undefined) {
+            throw new Error(`ENOENT: no such file or directory, rename '${oldPath}'`);
+        }
+        this.files.delete(oldPath);
+        this.files.set(newPath, content);
+    }
+    remove(path) {
+        if (!this.files.has(path)) {
+            throw new Error(`ENOENT: no such file or directory, unlink '${path}'`);
+        }
+        this.files.delete(path);
+    }
     /**
      * Clear all files and directories (useful for test cleanup)
      */

package/dist/services/messages.js

@@ -147,3 +147,18 @@ export function formatErrorMessage(error) {
     }
     return rawMessage;
 }
+/**
+ * Returns an execution error message with varied phrasing.
+ * Error details are shown in the task output, so this is just a summary.
+ * Randomly selects from variations to sound natural.
+ */
+export function getExecutionErrorMessage(_error) {
+    const messages = [
+        'The execution failed.',
+        'Execution has failed.',
+        'The execution was not successful.',
+        'Execution did not succeed.',
+        'The execution encountered an error.',
+    ];
+    return messages[Math.floor(Math.random() * messages.length)];
+}

package/dist/services/process.js

@@ -1,6 +1,11 @@
+export const defaultProcessControl = {
+    exit: (code) => process.exit(code),
+};
 /**
  * Exit application after brief delay to allow UI to render
  */
-export function exitApp(code) {
-    setTimeout(() => process.exit(code), 100);
+export function exitApp(code, processControl = defaultProcessControl) {
+    setTimeout(() => {
+        processControl.exit(code);
+    }, 100);
 }

package/dist/services/refinement.js

@@ -1,3 +1,4 @@
+import { TaskType } from '../types/types.js';
 import { createRefinement } from './components.js';
 import { formatErrorMessage, getRefiningMessage } from './messages.js';
 import { routeTasksWithConfirm } from './router.js';
@@ -17,6 +18,10 @@ export async function handleRefinement(selectedTasks, service, originalCommand,
             .map((task) => {
             const action = task.action.toLowerCase().replace(/,/g, ' -');
             const type = task.type;
+            // For execute/group tasks, use generic hint - let LLM decide based on skill
+            if (type === TaskType.Execute || type === TaskType.Group) {
+                return `${action} (shell execution)`;
+            }
             return `${action} (type: ${type})`;
         })
             .join(', ');