prompt-language-shell 0.8.2 → 0.8.6

package/dist/services/filesystem.js

@@ -0,0 +1,114 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from 'fs';
+import { dirname } from 'path';
+/**
+ * Real filesystem implementation using Node's fs module
+ */
+export class RealFileSystem {
+    exists(path) {
+        return existsSync(path);
+    }
+    readFile(path, encoding) {
+        return readFileSync(path, encoding);
+    }
+    writeFile(path, data) {
+        writeFileSync(path, data, 'utf-8');
+    }
+    readDirectory(path) {
+        return readdirSync(path);
+    }
+    createDirectory(path, options) {
+        mkdirSync(path, options);
+    }
+}
+/**
+ * In-memory filesystem implementation for testing
+ * Simulates filesystem behavior without touching disk
+ */
+export class MemoryFileSystem {
+    files = new Map();
+    directories = new Set();
+    exists(path) {
+        return this.files.has(path) || this.directories.has(path);
+    }
+    readFile(path, _encoding) {
+        const content = this.files.get(path);
+        if (content === undefined) {
+            throw new Error(`ENOENT: no such file or directory, open '${path}'`);
+        }
+        return content;
+    }
+    writeFile(path, data) {
+        // Auto-create parent directories
+        const dir = dirname(path);
+        if (dir !== '.' && dir !== path) {
+            this.createDirectory(dir, { recursive: true });
+        }
+        this.files.set(path, data);
+    }
+    readDirectory(path) {
+        if (!this.directories.has(path)) {
+            throw new Error(`ENOENT: no such file or directory, scandir '${path}'`);
+        }
+        const results = [];
+        const prefix = path.endsWith('/') ? path : `${path}/`;
+        // Find all direct children (files and directories)
+        for (const filePath of this.files.keys()) {
+            if (filePath.startsWith(prefix)) {
+                const relative = filePath.slice(prefix.length);
+                const firstSlash = relative.indexOf('/');
+                if (firstSlash === -1) {
+                    // Direct file child
+                    results.push(relative);
+                }
+            }
+        }
+        for (const dirPath of this.directories) {
+            if (dirPath.startsWith(prefix) && dirPath !== path) {
+                const relative = dirPath.slice(prefix.length);
+                const firstSlash = relative.indexOf('/');
+                if (firstSlash === -1) {
+                    // Direct directory child
+                    results.push(relative);
+                }
+            }
+        }
+        return results;
+    }
+    createDirectory(path, options) {
+        if (options?.recursive) {
+            // Create all parent directories
+            const parts = path.split('/').filter((p) => p);
+            let current = path.startsWith('/') ? '/' : '';
+            for (const part of parts) {
+                current = current === '/' ? `/${part}` : `${current}/${part}`;
+                this.directories.add(current);
+            }
+        }
+        else {
+            // Non-recursive: parent must exist
+            const parent = dirname(path);
+            if (parent !== '.' && parent !== path && !this.directories.has(parent)) {
+                throw new Error(`ENOENT: no such file or directory, mkdir '${path}'`);
+            }
+            this.directories.add(path);
+        }
+    }
+    /**
+     * Clear all files and directories (useful for test cleanup)
+     */
+    clear() {
+        this.files.clear();
+        this.directories.clear();
+    }
+    /**
+     * Get all files for debugging
+     */
+    getFiles() {
+        return new Map(this.files);
+    }
+}
+/**
+ * Default filesystem instance (uses real fs)
+ * Services can accept optional FileSystem parameter for testing
+ */
+export const defaultFileSystem = new RealFileSystem();

package/dist/services/loader.js

@@ -1,24 +1,27 @@
-import { existsSync, readFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 import YAML from 'yaml';
+import { defaultFileSystem } from './filesystem.js';
+import { displayWarning } from './logger.js';
 /**
  * Load user config from ~/.plsrc
  */
-export function loadUserConfig() {
+export function loadUserConfig(fs = defaultFileSystem) {
     const configPath = join(homedir(), '.plsrc');
-    if (!existsSync(configPath)) {
+    if (!fs.exists(configPath)) {
         return {};
     }
     try {
-        const content = readFileSync(configPath, 'utf-8');
+        const content = fs.readFile(configPath, 'utf-8');
         const parsed = YAML.parse(content);
         if (parsed && typeof parsed === 'object') {
             return parsed;
         }
+        displayWarning('User config file exists but is not a valid object');
         return {};
     }
-    catch {
+    catch (error) {
+        displayWarning('Failed to load user config', error);
         return {};
     }
 }

package/dist/services/logger.js

@@ -1,11 +1,16 @@
+import { DebugLevel } from '../configuration/types.js';
 import { createDebugDefinition } from './components.js';
-import { DebugLevel, loadDebugSetting } from './configuration.js';
+import { loadDebugSetting } from '../configuration/io.js';
 import { Palette } from './colors.js';
 /**
  * Debug logger for the application
  * Logs information based on the current debug level setting
  */
 let currentDebugLevel = DebugLevel.None;
+/**
+ * Accumulated warnings to be displayed in the timeline
+ */
+const warnings = [];
 /**
  * Initialize the logger with the current debug level from config
  */
@@ -24,6 +29,26 @@ export function setDebugLevel(debug) {
 export function getDebugLevel() {
     return currentDebugLevel;
 }
+/**
+ * Store a warning message to be displayed in the timeline
+ * Only stores warnings at Info or Verbose debug levels
+ */
+export function displayWarning(message, error) {
+    if (currentDebugLevel === DebugLevel.None) {
+        return;
+    }
+    const errorDetails = error instanceof Error ? `: ${error.message}` : '';
+    warnings.push(`${message}${errorDetails}`);
+}
+/**
+ * Get all accumulated warnings and clear the list
+ * Returns array of warning messages
+ */
+export function getWarnings() {
+    const result = [...warnings];
+    warnings.length = 0;
+    return result;
+}
 /**
  * Create debug component for system prompts sent to the LLM
  * Only creates at Verbose level

package/dist/services/messages.js

@@ -1,4 +1,5 @@
-import { DebugLevel, loadDebugSetting } from './configuration.js';
+import { DebugLevel } from '../configuration/types.js';
+import { loadDebugSetting } from '../configuration/io.js';
 export { formatDuration } from './utils.js';
 /**
  * Returns a natural language confirmation message for plan execution.
@@ -80,6 +81,36 @@ export function getMixedTaskTypesError(types) {
     const typeList = types.join(', ');
     return `Mixed task types are not supported. Found: ${typeList}. All tasks in a plan must have the same type.`;
 }
+/**
+ * Returns a message for unresolved placeholders/missing configuration.
+ * Each message has two sentences: what's missing + what will be done.
+ * Both sentences are randomly selected independently for variety.
+ * Supports singular and plural forms.
+ */
+export function getUnresolvedPlaceholdersMessage(count) {
+    const plural = count === 1 ? '' : 's';
+    const it = count === 1 ? 'it' : 'them';
+    const valueWord = count === 1 ? 'value' : 'values';
+    // First sentence: what's missing
+    const firstSentences = [
+        `Missing configuration ${valueWord} detected.`,
+        `Configuration ${valueWord} needed.`,
+        `Found unresolved placeholder${plural}.`,
+        `Additional configuration ${valueWord} required.`,
+        `Setup requires configuration ${valueWord}.`,
+    ];
+    // Second sentence: what will be done
+    const secondSentences = [
+        `Let me gather ${it} now.`,
+        `I'll set ${it} up for you.`,
+        `Let me configure ${it} first.`,
+        `I'll help you provide ${it}.`,
+        `Let me collect ${it} from you.`,
+    ];
+    const first = firstSentences[Math.floor(Math.random() * firstSentences.length)];
+    const second = secondSentences[Math.floor(Math.random() * secondSentences.length)];
+    return `${first} ${second}`;
+}
 /**
  * Feedback messages for various operations
  */

package/dist/services/parser.js

@@ -1,4 +1,5 @@
 import YAML from 'yaml';
+import { displayWarning } from './logger.js';
 /**
  * Validate a skill without parsing it fully
  * Returns validation error if skill is invalid, null if valid
@@ -188,7 +189,8 @@ function parseConfigSchema(content) {
         }
         return parsed;
     }
-    catch {
+    catch (error) {
+        displayWarning('Failed to parse config schema in skill', error);
         return undefined;
     }
 }

package/dist/services/refinement.js

@@ -5,12 +5,12 @@ import { routeTasksWithConfirm } from './router.js';
  * Handle refinement flow for DEFINE tasks
  * Called when user selects options from a plan with DEFINE tasks
  */
-export async function handleRefinement(selectedTasks, service, originalCommand, handlers) {
+export async function handleRefinement(selectedTasks, service, originalCommand, lifecycleHandlers, workflowHandlers, requestHandlers) {
     // Create and add refinement component to queue
     const refinementDef = createRefinement(getRefiningMessage(), (operation) => {
-        handlers.onAborted(operation);
+        requestHandlers.onAborted(operation);
     });
-    handlers.addToQueue(refinementDef);
+    workflowHandlers.addToQueue(refinementDef);
     try {
         // Build refined command from selected tasks
         const refinedCommand = selectedTasks
@@ -22,19 +22,19 @@ export async function handleRefinement(selectedTasks, service, originalCommand,
             .join(', ');
         // Call LLM to refine plan with selected tasks
         const refinedResult = await service.processWithTool(refinedCommand, 'schedule');
-        // Complete the Refinement component
-        handlers.completeActive();
+        // Complete the Refinement component with success state
+        lifecycleHandlers.completeActive();
         // Add debug components to timeline if present
-        if (refinedResult.debug && refinedResult.debug.length > 0) {
-            handlers.addToTimeline(...refinedResult.debug);
+        if (refinedResult.debug?.length) {
+            workflowHandlers.addToTimeline(...refinedResult.debug);
         }
         // Route refined tasks to appropriate components
-        routeTasksWithConfirm(refinedResult.tasks, refinedResult.message, service, originalCommand, handlers, false // No DEFINE tasks in refined result
+        routeTasksWithConfirm(refinedResult.tasks, refinedResult.message, service, originalCommand, lifecycleHandlers, workflowHandlers, requestHandlers, false // No DEFINE tasks in refined result
         );
     }
     catch (err) {
-        handlers.completeActive();
+        lifecycleHandlers.completeActive();
         const errorMessage = formatErrorMessage(err);
-        handlers.onError(errorMessage);
+        requestHandlers.onError(errorMessage);
     }
 }

package/dist/services/router.js

@@ -1,7 +1,10 @@
 import { asScheduledTasks } from '../types/guards.js';
 import { FeedbackType, TaskType } from '../types/types.js';
+import { saveConfig } from '../configuration/io.js';
+import { getConfigSchema } from '../configuration/schema.js';
+import { unflattenConfig } from '../configuration/transformation.js';
+import { saveConfigLabels } from './config-labels.js';
 import { createAnswerDefinition, createConfigDefinitionWithKeys, createConfirmDefinition, createExecuteDefinition, createFeedback, createIntrospectDefinition, createMessage, createScheduleDefinition, createValidateDefinition, } from './components.js';
-import { saveConfig, unflattenConfig } from './configuration.js';
 import { getCancellationMessage, getMixedTaskTypesError, getUnknownRequestMessage, } from './messages.js';
 import { validateExecuteTasks } from './validator.js';
 /**
@@ -20,7 +23,7 @@ export function getOperationName(tasks) {
  * Route tasks to appropriate components with Confirm flow
  * Handles the complete flow: Plan → Confirm → Execute/Answer/Introspect
  */
-export function routeTasksWithConfirm(tasks, message, service, userRequest, handlers, hasDefineTask = false) {
+export function routeTasksWithConfirm(tasks, message, service, userRequest, lifecycleHandlers, workflowHandlers, requestHandlers, hasDefineTask = false) {
     if (tasks.length === 0)
         return;
     // Filter out ignore and discard tasks early
@@ -28,7 +31,7 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, hand
     // Check if no valid tasks remain after filtering
     if (validTasks.length === 0) {
         const message = createMessage(getUnknownRequestMessage());
-        handlers.addToQueue(message);
+        workflowHandlers.addToQueue(message);
         return;
     }
     const operation = getOperationName(validTasks);
@@ -36,7 +39,7 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, hand
         // Has DEFINE tasks - add Schedule to queue for user selection
         // Refinement flow will call this function again with refined tasks
         const scheduleDefinition = createScheduleDefinition(message, validTasks);
-        handlers.addToQueue(scheduleDefinition);
+        workflowHandlers.addToQueue(scheduleDefinition);
     }
     else {
         // No DEFINE tasks - Schedule auto-completes and adds Confirm to queue
@@ -47,17 +50,17 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, hand
             // Schedule completed - add Confirm to queue
             const confirmDefinition = createConfirmDefinition(() => {
                 // User confirmed - complete both Confirm and Schedule, then route to appropriate component
-                handlers.completeActiveAndPending();
-                executeTasksAfterConfirm(validTasks, service, userRequest, handlers);
+                lifecycleHandlers.completeActiveAndPending();
+                executeTasksAfterConfirm(validTasks, service, userRequest, workflowHandlers, requestHandlers);
             }, () => {
                 // User cancelled - complete both Confirm and Schedule, then show cancellation
-                handlers.completeActiveAndPending();
+                lifecycleHandlers.completeActiveAndPending();
                 const message = getCancellationMessage(operation);
-                handlers.addToQueue(createFeedback(FeedbackType.Aborted, message));
+                workflowHandlers.addToQueue(createFeedback(FeedbackType.Aborted, message));
             });
-            handlers.addToQueue(confirmDefinition);
+            workflowHandlers.addToQueue(confirmDefinition);
         });
-        handlers.addToQueue(scheduleDefinition);
+        workflowHandlers.addToQueue(scheduleDefinition);
     }
 }
 /**
@@ -88,13 +91,13 @@ function validateTaskTypes(tasks) {
  * Validates task types and routes each type appropriately
  * Supports mixed types at top level with Groups
  */
-function executeTasksAfterConfirm(tasks, service, userRequest, handlers) {
+function executeTasksAfterConfirm(tasks, service, userRequest, workflowHandlers, requestHandlers) {
     // Validate task types (Groups must have uniform subtasks)
     try {
         validateTaskTypes(tasks);
     }
     catch (error) {
-        handlers.onError(error instanceof Error ? error.message : String(error));
+        requestHandlers.onError(error instanceof Error ? error.message : String(error));
         return;
     }
     const scheduledTasks = asScheduledTasks(tasks);
@@ -117,7 +120,7 @@ function executeTasksAfterConfirm(tasks, service, userRequest, handlers) {
             const taskType = type;
             if (typeTasks.length === 0)
                 continue;
-            routeTasksByType(taskType, typeTasks, service, userRequest, handlers);
+            routeTasksByType(taskType, typeTasks, service, userRequest, workflowHandlers, requestHandlers);
         }
         consecutiveStandaloneTasks = [];
     };
@@ -130,7 +133,7 @@ function executeTasksAfterConfirm(tasks, service, userRequest, handlers) {
             if (task.subtasks.length > 0) {
                 const subtasks = task.subtasks;
                 const taskType = subtasks[0].type;
-                routeTasksByType(taskType, subtasks, service, userRequest, handlers);
+                routeTasksByType(taskType, subtasks, service, userRequest, workflowHandlers, requestHandlers);
             }
         }
         else {
@@ -145,22 +148,35 @@ function executeTasksAfterConfirm(tasks, service, userRequest, handlers) {
  * Route tasks by type to appropriate components
  * Extracted to allow reuse for both Groups and standalone tasks
  */
-function routeTasksByType(taskType, typeTasks, service, userRequest, handlers) {
+function routeTasksByType(taskType, typeTasks, service, userRequest, workflowHandlers, requestHandlers) {
     if (taskType === TaskType.Answer) {
         // Create separate Answer component for each question
         for (const task of typeTasks) {
-            handlers.addToQueue(createAnswerDefinition(task.action, service));
+            workflowHandlers.addToQueue(createAnswerDefinition(task.action, service));
         }
     }
     else if (taskType === TaskType.Introspect) {
-        handlers.addToQueue(createIntrospectDefinition(typeTasks, service));
+        workflowHandlers.addToQueue(createIntrospectDefinition(typeTasks, service));
     }
     else if (taskType === TaskType.Config) {
-        // Route to Config flow - extract keys from task params
+        // Route to Config flow - extract keys and descriptions from task params
         const configKeys = typeTasks
             .map((task) => task.params?.key)
             .filter((key) => key !== undefined);
-        handlers.addToQueue(createConfigDefinitionWithKeys(configKeys, (config) => {
+        // Extract and cache labels from task descriptions
+        // Only cache labels for dynamically discovered keys (not in schema)
+        const schema = getConfigSchema();
+        const labels = {};
+        for (const task of typeTasks) {
+            const key = task.params?.key;
+            if (key && task.action && !(key in schema)) {
+                labels[key] = task.action;
+            }
+        }
+        if (Object.keys(labels).length > 0) {
+            saveConfigLabels(labels);
+        }
+        workflowHandlers.addToQueue(createConfigDefinitionWithKeys(configKeys, (config) => {
             // Save config - Config component will handle completion and feedback
             try {
                 // Convert flat dotted keys to nested structure grouped by section
@@ -177,7 +193,7 @@ function routeTasksByType(taskType, typeTasks, service, userRequest, handlers) {
                 throw new Error(errorMessage);
             }
         }, (operation) => {
-            handlers.onAborted(operation);
+            requestHandlers.onAborted(operation);
         }));
     }
     else if (taskType === TaskType.Execute) {
@@ -192,26 +208,26 @@ function routeTasksByType(taskType, typeTasks, service, userRequest, handlers) {
                         .join('\n');
                     return `Invalid skill definition "${error.skill}":\n\n${issuesList}`;
                 });
-                handlers.addToQueue(createFeedback(FeedbackType.Failed, errorMessages.join('\n\n')));
+                workflowHandlers.addToQueue(createFeedback(FeedbackType.Failed, errorMessages.join('\n\n')));
             }
             else if (validation.missingConfig.length > 0) {
-                handlers.addToQueue(createValidateDefinition(validation.missingConfig, userRequest, service, (error) => {
-                    handlers.onError(error);
+                workflowHandlers.addToQueue(createValidateDefinition(validation.missingConfig, userRequest, service, (error) => {
+                    requestHandlers.onError(error);
                 }, () => {
-                    handlers.addToQueue(createExecuteDefinition(typeTasks, service));
+                    workflowHandlers.addToQueue(createExecuteDefinition(typeTasks, service));
                 }, (operation) => {
-                    handlers.onAborted(operation);
+                    requestHandlers.onAborted(operation);
                 }));
             }
             else {
-                handlers.addToQueue(createExecuteDefinition(typeTasks, service));
+                workflowHandlers.addToQueue(createExecuteDefinition(typeTasks, service));
             }
         }
         catch (error) {
             // Handle skill reference errors (e.g., unknown skills)
             const errorMessage = error instanceof Error ? error.message : String(error);
             const message = createMessage(errorMessage);
-            handlers.addToQueue(message);
+            workflowHandlers.addToQueue(message);
         }
     }
 }

package/dist/services/skills.js

@@ -1,6 +1,7 @@
-import { existsSync, readdirSync, readFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
+import { defaultFileSystem } from './filesystem.js';
+import { displayWarning } from './logger.js';
 import { getUnknownSkillMessage } from './messages.js';
 import { parseSkillMarkdown, displayNameToKey } from './parser.js';
 /**
@@ -48,14 +49,14 @@ export function getSkillsDirectory() {
  * Returns an array of objects with filename (key) and content
  * Filters out invalid filenames and conflicts with system skills
  */
-export function loadSkills() {
+export function loadSkills(fs = defaultFileSystem) {
     const skillsDir = getSkillsDirectory();
     // Return empty array if directory doesn't exist
-    if (!existsSync(skillsDir)) {
+    if (!fs.exists(skillsDir)) {
         return [];
     }
     try {
-        const files = readdirSync(skillsDir);
+        const files = fs.readDirectory(skillsDir);
         // Filter and map valid skill files
         return files
             .filter((file) => {
@@ -75,12 +76,12 @@ export function loadSkills() {
             // Extract key (filename without extension, handles both .md and .MD)
             const key = file.slice(0, -3);
             const filePath = join(skillsDir, file);
-            const content = readFileSync(filePath, 'utf-8');
+            const content = fs.readFile(filePath, 'utf-8');
             return { key, content };
         });
     }
-    catch {
-        // Return empty array if there's any error reading the directory
+    catch (error) {
+        displayWarning('Failed to load skills directory', error);
         return [];
     }
 }
@@ -88,16 +89,16 @@ export function loadSkills() {
  * Load and parse all skill definitions
  * Returns structured skill definitions (including invalid skills)
  */
-export function loadSkillDefinitions() {
-    const skills = loadSkills();
+export function loadSkillDefinitions(fs = defaultFileSystem) {
+    const skills = loadSkills(fs);
     return skills.map(({ key, content }) => parseSkillMarkdown(key, content));
 }
 /**
  * Load skills and mark incomplete ones in their markdown
  * Returns array of skill markdown with status markers
  */
-export function loadSkillsWithValidation() {
-    const skills = loadSkills();
+export function loadSkillsWithValidation(fs = defaultFileSystem) {
+    const skills = loadSkills(fs);
     return skills.map(({ key, content }) => {
         const parsed = parseSkillMarkdown(key, content);
         // If skill is incomplete (either validation failed or needs more documentation), append (INCOMPLETE) to the name

package/dist/services/validator.js

@@ -1,17 +1,18 @@
+import { defaultFileSystem } from './filesystem.js';
 import { loadUserConfig, hasConfigPath } from './loader.js';
 import { loadSkillDefinitions, createSkillLookup } from './skills.js';
 /**
  * Validate config requirements for execute tasks
  * Returns validation result with missing config and validation errors
  */
-export function validateExecuteTasks(tasks) {
-    const userConfig = loadUserConfig();
+export function validateExecuteTasks(tasks, fs = defaultFileSystem) {
+    const userConfig = loadUserConfig(fs);
     const missing = [];
     const seenPaths = new Set();
     const validationErrors = [];
     const seenSkills = new Set();
     // Load all skills (including invalid ones for validation)
-    const parsedSkills = loadSkillDefinitions();
+    const parsedSkills = loadSkillDefinitions(fs);
     const skillLookup = createSkillLookup(parsedSkills);
     // Check for invalid skills being used in tasks
     for (const task of tasks) {

package/dist/types/guards.js

@@ -1,4 +1,5 @@
 import { TaskType } from './types.js';
+import { TaskSchema } from './schemas.js';
 /**
  * Type guard to check if a task is a ScheduledTask
  * ScheduledTask has optional subtasks property or is a Group type
@@ -14,12 +15,9 @@ export function asScheduledTasks(tasks) {
     return tasks;
 }
 /**
- * Type guard to check if a value is a valid Task
+ * Type guard to check if a value is a valid Task.
+ * Uses Zod schema for comprehensive runtime validation.
  */
 export function isTask(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        'action' in value &&
-        typeof value.action === 'string' &&
-        'type' in value);
+    return TaskSchema.safeParse(value).success;
 }

package/dist/types/handlers.js

@@ -0,0 +1 @@
+export {};