prompt-language-shell 0.5.2 → 0.6.0

package/dist/config/ANSWER.md

@@ -42,6 +42,8 @@ Provide a direct, helpful answer following these strict formatting rules:
 - Break long sentences naturally at phrase boundaries
 - If the answer requires more than 4 lines, prioritize the most essential
   information
+- **Do NOT use citation tags** like `<cite>` or any HTML/XML markup
+- Provide direct answers in plain text only
 
 ## Examples
 
@@ -112,8 +114,10 @@ They enable cleaner, more reusable component logic.
 ❌ Including unnecessary details
 ❌ Using overly technical jargon without explanation
 ❌ Repeating the question in the answer
+❌ Using citation tags like `<cite>` or any HTML/XML markup
 
 ✅ Direct, concise answers
 ✅ Proper line breaks at natural phrase boundaries
 ✅ Essential information only
 ✅ Clear, accessible language
+✅ Plain text only - no markup tags

package/dist/config/PLAN.md

@@ -280,6 +280,29 @@ Examples that should be aborted as offensive:
 - Requests to create malware or exploit vulnerabilities
 - Requests with offensive, discriminatory, or abusive language
 
+**CRITICAL: Distinguishing Questions from Actions**
+
+User requests fall into two categories:
+
+1. **Information requests (questions)** - Must use question keywords:
+   - "explain", "answer", "describe", "tell me", "say", "what is", "what are",
+     "how does", "how do", "find", "search", "lookup"
+   - Example: "pls explain TypeScript" → answer type
+   - Example: "pls what is the weather" → answer type
+
+2. **Action requests (commands)** - Must match available skills:
+   - Verbs like "test", "deploy", "process", "backup", "sync"
+   - If verb matches a skill → use that skill
+   - If verb does NOT match any skill → use "ignore" type
+   - Example: "pls test" with no test skill → ignore type
+   - Example: "pls reverberate" with no reverberate skill → ignore type
+   - Example: "pls shut down" with no shutdown skill → ignore type
+
+**Critical rule:** Requests using action verbs that don't match question
+keywords AND don't match any available skills should ALWAYS be classified
+as "ignore" type. Do NOT try to infer or create generic execute tasks for
+unrecognized verbs.
+
 **For requests with clear intent:**
 
 1. **Introspection requests** - Use "introspect" type when request asks about

package/dist/config/VALIDATE.md

@@ -29,12 +29,12 @@ For each CONFIG task, create a natural language description that:
 
 ## Description Format
 
-**Format:** "Brief description" (NO {config.path} at the end!)
+**Format:** "Brief description" (DO NOT include {config.path}!)
 
 The description should:
 - Start with what the config value represents (e.g., "Path to...", "URL for...", "Name of...")
 - Be SHORT and direct - no extra details or variant explanations
-- NOT include the config path in curly brackets - that's added automatically
+- NEVER include the config path in curly brackets like {config.path}
 
 ## Examples
 
@@ -50,7 +50,7 @@ The description should:
 message: ""
 tasks: [
   {
-    action: "Path to Alpha repository {project.alpha.repo}",
+    action: "Path to Alpha repository",
     type: "config",
     params: { key: "project.alpha.repo" }
   }
@@ -69,7 +69,7 @@ tasks: [
 message: ""
 tasks: [
   {
-    action: "Staging environment URL {env.staging.url}",
+    action: "Staging environment URL",
     type: "config",
     params: { key: "env.staging.url" }
   }
@@ -88,7 +88,7 @@ tasks: [
 message: ""
 tasks: [
   {
-    action: "Path to Beta workspace {workspace.beta.path}",
+    action: "Path to Beta workspace",
     type: "config",
     params: { key: "workspace.beta.path" }
   }
@@ -98,10 +98,10 @@ tasks: [
 ## Guidelines
 
 1. **Use skill context**: Read the skill's Description section to understand what the variant represents
-2. **Be specific**: Don't just say "Repository path" - say "Alpha project repository path"
-3. **Add helpful details**: Include information from the description (e.g., "legacy implementation")
-4. **Keep it concise**: One sentence that clearly explains what's needed
-5. **Always include the path**: End with `{config.path}` for technical reference
+2. **Be specific**: Don't just say "Repository path" - say "Path to Alpha repository"
+3. **Add helpful details**: Include information from the description when relevant
+4. **Keep it concise**: One brief phrase that clearly explains what's needed
+5. **Never include the path**: Do not append `{config.path}` - it's shown separately in debug mode
 
 ## Common Config Types
 
@@ -122,7 +122,7 @@ Return a message field (can be empty string) and an array of CONFIG tasks:
 message: ""
 tasks: [
   {
-    action: "Natural description {config.path}",
+    action: "Natural description without config path",
     type: "config",
     params: { key: "config.path" }
   },
@@ -136,4 +136,5 @@ tasks: [
 - All tasks must include params.key with the config path
 - Descriptions should be helpful and contextual, not just technical
 - Use information from Available Skills section to provide context
-- Keep descriptions to one concise sentence
+- Keep descriptions to one brief phrase (3-6 words)
+- NEVER include the config path in the action/description - it's shown separately

package/dist/services/components.js

@@ -1,11 +1,10 @@
 import { randomUUID } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
 import { ComponentName } from '../types/types.js';
-import { getConfigSchema, loadConfig, } from './configuration.js';
+import { parse as parseYaml } from 'yaml';
+import { getConfigPath, getConfigSchema, loadConfig, } from './configuration.js';
 import { getConfirmationMessage } from './messages.js';
 import { StepType } from '../ui/Config.js';
-export function markAsDone(component) {
-    return { ...component, state: { ...component.state, done: true } };
-}
 export function createWelcomeDefinition(app) {
     return {
         id: randomUUID(),
@@ -58,27 +57,43 @@ function getValidator(definition) {
 export function createConfigStepsFromSchema(keys) {
     const schema = getConfigSchema();
     let currentConfig = null;
+    let rawConfig = null;
+    // Load validated config (may fail if config has validation errors)
     try {
         currentConfig = loadConfig();
     }
     catch {
-        // Config doesn't exist yet, use defaults
+        // 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 (existsSync(configFile)) {
+            const content = readFileSync(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 (built-in config)
         if (!(key in schema)) {
-            // Key is not in schema - it's from a skill
-            // Create a simple text step with placeholder description
+            // Key is not in schema - it's from a skill or discovered config
+            // Create a simple text step with the full path as description
             const keyParts = key.split('.');
             const shortKey = keyParts[keyParts.length - 1];
-            const description = keyParts
-                .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-                .join(' ');
+            // 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;
             return {
-                description: `${description} {${key}}`,
+                description: key,
                 key: shortKey,
+                path: key,
                 type: StepType.Text,
-                value: null,
+                value,
                 validate: () => true, // Accept any string for now
             };
         }
@@ -98,6 +113,7 @@ export function createConfigStepsFromSchema(keys) {
                 return {
                     description: definition.description,
                     key: shortKey,
+                    path: key,
                     type: StepType.Text,
                     value,
                     validate: getValidator(definition),
@@ -112,6 +128,7 @@ export function createConfigStepsFromSchema(keys) {
                 return {
                     description: definition.description,
                     key: shortKey,
+                    path: key,
                     type: StepType.Text,
                     value,
                     validate: getValidator(definition),
@@ -127,6 +144,7 @@ export function createConfigStepsFromSchema(keys) {
                 return {
                     description: definition.description,
                     key: shortKey,
+                    path: key,
                     type: StepType.Selection,
                     options: definition.values.map((value) => ({
                         label: value,
@@ -143,6 +161,7 @@ export function createConfigStepsFromSchema(keys) {
                 return {
                     description: definition.description,
                     key: shortKey,
+                    path: key,
                     type: StepType.Selection,
                     options: [
                         { label: 'Yes', value: 'true' },
@@ -159,7 +178,7 @@ export function createConfigDefinition(onFinished, onAborted) {
     return {
         id: randomUUID(),
         name: ComponentName.Config,
-        state: { done: false },
+        state: {},
         props: {
             steps: createConfigSteps(),
             onFinished,
@@ -174,7 +193,7 @@ export function createConfigDefinitionWithKeys(keys, onFinished, onAborted) {
     return {
         id: randomUUID(),
         name: ComponentName.Config,
-        state: { done: false },
+        state: {},
         props: {
             steps: createConfigStepsFromSchema(keys),
             onFinished,
@@ -182,29 +201,22 @@ export function createConfigDefinitionWithKeys(keys, onFinished, onAborted) {
         },
     };
 }
-export function createCommandDefinition(command, service, onError, onComplete, onAborted) {
+export function createCommandDefinition(command, service) {
     return {
         id: randomUUID(),
         name: ComponentName.Command,
-        state: {
-            done: false,
-            isLoading: true,
-        },
+        state: {},
         props: {
             command,
             service,
-            onError,
-            onComplete,
-            onAborted,
         },
     };
 }
-export function createPlanDefinition(message, tasks, onAborted, onSelectionConfirmed) {
+export function createPlanDefinition(message, tasks, onSelectionConfirmed) {
     return {
         id: randomUUID(),
         name: ComponentName.Plan,
         state: {
-            done: false,
             highlightedIndex: null,
             currentDefineGroupIndex: 0,
             completedSelections: [],
@@ -213,7 +225,6 @@ export function createPlanDefinition(message, tasks, onAborted, onSelectionConfi
             message,
             tasks,
             onSelectionConfirmed,
-            onAborted,
         },
     };
 }
@@ -240,7 +251,7 @@ export function createRefinement(text, onAborted) {
     return {
         id: randomUUID(),
         name: ComponentName.Refinement,
-        state: { done: false },
+        state: {},
         props: {
             text,
             onAborted,
@@ -251,7 +262,7 @@ export function createConfirmDefinition(onConfirmed, onCancelled) {
     return {
         id: randomUUID(),
         name: ComponentName.Confirm,
-        state: { done: false },
+        state: {},
         props: {
             message: getConfirmationMessage(),
             onConfirmed,
@@ -259,20 +270,14 @@ export function createConfirmDefinition(onConfirmed, onCancelled) {
         },
     };
 }
-export function createIntrospectDefinition(tasks, service, onError, onComplete, onAborted) {
+export function createIntrospectDefinition(tasks, service) {
     return {
         id: randomUUID(),
         name: ComponentName.Introspect,
-        state: {
-            done: false,
-            isLoading: true,
-        },
+        state: {},
         props: {
             tasks,
             service,
-            onError,
-            onComplete,
-            onAborted,
         },
     };
 }
@@ -286,49 +291,37 @@ export function createReportDefinition(message, capabilities) {
         },
     };
 }
-export function createAnswerDefinition(question, service, onError, onComplete, onAborted) {
+export function createAnswerDefinition(question, service) {
     return {
         id: randomUUID(),
         name: ComponentName.Answer,
-        state: {
-            done: false,
-            isLoading: true,
-        },
+        state: {},
         props: {
             question,
             service,
-            onError,
-            onComplete,
-            onAborted,
-        },
-    };
-}
-export function createAnswerDisplayDefinition(answer) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.AnswerDisplay,
-        props: {
-            answer,
         },
     };
 }
 export function isStateless(component) {
     return !('state' in component);
 }
-export function createExecuteDefinition(tasks, service, onError, onComplete, onAborted) {
+/**
+ * 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 simply returns the component as-is.
+ */
+export function markAsDone(component) {
+    // State already updated via handlers.updateState
+    return component;
+}
+export function createExecuteDefinition(tasks, service) {
     return {
         id: randomUUID(),
         name: ComponentName.Execute,
-        state: {
-            done: false,
-            isLoading: true,
-        },
+        state: {},
         props: {
             tasks,
             service,
-            onError,
-            onComplete,
-            onAborted,
         },
     };
 }
@@ -336,10 +329,7 @@ export function createValidateDefinition(missingConfig, userRequest, service, on
     return {
         id: randomUUID(),
         name: ComponentName.Validate,
-        state: {
-            done: false,
-            isLoading: true,
-        },
+        state: {},
         props: {
             missingConfig,
             userRequest,

package/dist/services/configuration.js

@@ -123,6 +123,7 @@ export function saveConfig(section, config) {
 }
 export function saveAnthropicConfig(config) {
     saveConfig('anthropic', config);
+    return loadConfig();
 }
 export function saveDebugSetting(debug) {
     saveConfig('settings', { debug });
@@ -200,6 +201,67 @@ export function getConfigSchema() {
         // 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 'regexp':
+                isValid = typeof value === 'string' && definition.pattern.test(value);
+                break;
+            case 'string':
+                isValid = typeof value === 'string';
+                break;
+            case 'enum':
+                isValid =
+                    typeof value === 'string' && definition.values.includes(value);
+                break;
+            case 'number':
+                isValid = typeof value === 'number';
+                break;
+            case 'boolean':
+                isValid = typeof value === 'boolean';
+                break;
+        }
+        if (!isValid) {
+            missing.push(key);
+        }
+    }
+    return missing;
+}
 /**
  * Get available config structure for CONFIG tool
  * Returns keys with descriptions only (no values for privacy)
@@ -246,3 +308,25 @@ export function getAvailableConfigStructure() {
     }
     return structure;
 }
+/**
+ * Unflatten dotted keys into nested structure
+ * Example: { "product.alpha.path": "value" } -> { product: { alpha: { path: "value" } } }
+ */
+export function unflattenConfig(dotted) {
+    const result = {};
+    for (const [dottedKey, value] 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]];
+        }
+        // Set final value
+        current[parts[parts.length - 1]] = value;
+    }
+    return result;
+}

package/dist/services/messages.js

@@ -43,6 +43,28 @@ export function getCancellationMessage(operation) {
     ];
     return templates[Math.floor(Math.random() * templates.length)];
 }
+/**
+ * Returns an error message when the request cannot be understood.
+ * Randomly selects from variations to sound natural.
+ */
+export function getUnknownRequestMessage() {
+    const messages = [
+        'I do not understand the request.',
+        'I cannot understand what you want me to do.',
+        "I'm not sure what you're asking for.",
+        'I cannot determine what action to take.',
+        'This request is unclear to me.',
+        'I do not recognize this command.',
+    ];
+    return messages[Math.floor(Math.random() * messages.length)];
+}
+/**
+ * Returns an error message for mixed task types.
+ */
+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.`;
+}
 /**
  * Feedback messages for various operations
  */

package/dist/services/queue.js

@@ -1,5 +1,5 @@
 import { FeedbackType } from '../types/types.js';
-import { createFeedback, markAsDone } from './components.js';
+import { createFeedback } from './components.js';
 import { FeedbackMessages } from './messages.js';
 import { exitApp } from './process.js';
 /**
@@ -37,7 +37,7 @@ export function withQueueHandler(componentName, callback, shouldExit = false, ex
  */
 export function createErrorHandler(componentName, addToTimeline) {
     return (error) => withQueueHandler(componentName, (first) => {
-        addToTimeline(markAsDone(first), createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, error));
+        addToTimeline(first, createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, error));
         return undefined;
     }, true, 1);
 }

package/dist/services/refinement.js

@@ -0,0 +1,36 @@
+import { createRefinement } from './components.js';
+import { formatErrorMessage, getRefiningMessage } from './messages.js';
+import { routeTasksWithConfirm } from './task-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) {
+    // Create and add refinement component to queue
+    const refinementDef = createRefinement(getRefiningMessage(), (operation) => {
+        handlers.onAborted(operation);
+    });
+    handlers.addToQueue(refinementDef);
+    try {
+        // Build refined command from selected tasks
+        const refinedCommand = selectedTasks
+            .map((task) => {
+            const action = task.action.toLowerCase().replace(/,/g, ' -');
+            const type = task.type;
+            return `${action} (type: ${type})`;
+        })
+            .join(', ');
+        // Call LLM to refine plan with selected tasks
+        const refinedResult = await service.processWithTool(refinedCommand, 'plan');
+        // Complete the Refinement component
+        handlers.completeActive();
+        // Route refined tasks to appropriate components
+        routeTasksWithConfirm(refinedResult.tasks, refinedResult.message, service, originalCommand, handlers, false // No DEFINE tasks in refined result
+        );
+    }
+    catch (err) {
+        handlers.completeActive();
+        const errorMessage = formatErrorMessage(err);
+        handlers.onError(errorMessage);
+    }
+}