prompt-language-shell 1.0.0 → 1.0.4

package/README.md

@@ -125,6 +125,46 @@ Skills let you teach `pls` about your project-specific workflows. Create
 markdown files in `~/.pls/skills/` to define custom operations that
 `pls` can understand and execute.
 
+### Creating Skills
+
+The easiest way to create a new skill is with the guided walkthrough:
+
+```
+$ pls learn
+
+Creating a new skill...
+
+Skill name (e.g., "Deploy Project"):
+> Build Frontend
+
+Description (min 20 characters):
+> Build the frontend application using npm
+
+Step 1 - What does this step do?
+> Install dependencies
+
+How should this step be executed?
+> shell command
+
+Enter the shell command:
+> npm install
+
+Add another step?
+> yes
+
+...
+```
+
+The walkthrough guides you through defining:
+- **Name**: A unique name for the skill
+- **Description**: What the skill does (min 20 characters)
+- **Aliases**: Example commands that invoke the skill (optional)
+- **Config**: Configuration properties needed (optional)
+- **Steps**: Each step with either a shell command or reference to another skill
+
+Skills are saved to `~/.pls/skills/` as markdown files. File names use
+kebab-case (e.g., "Build Frontend" becomes `build-frontend.md`).
+
 For complete documentation, see [docs/SKILLS.md](./docs/SKILLS.md).
 
 ### Structure

package/dist/Main.js

@@ -8,10 +8,19 @@ import { getMissingConfigKeys } from './configuration/schema.js';
 import { createConfigStepsFromSchema } from './configuration/steps.js';
 import { unflattenConfig } from './configuration/transformation.js';
 import { createAnthropicService } from './services/anthropic.js';
-import { createCommand, createConfig, createFeedback, createMessage, createWelcome, } from './services/components.js';
+import { createCommand, createConfig, createFeedback, createHelp, createMessage, createWelcome, } from './services/components.js';
 import { registerGlobalShortcut } from './services/keyboard.js';
 import { initializeLogger, setDebugLevel } from './services/logger.js';
 import { Workflow } from './components/Workflow.js';
+/**
+ * Check if command matches help variations (help, --help, -h)
+ */
+function isHelpCommand(cmd) {
+    if (!cmd)
+        return false;
+    const normalized = cmd.toLowerCase().trim();
+    return (normalized === 'help' || normalized === '--help' || normalized === '-h');
+}
 export const Main = ({ app, command, serviceFactory = createAnthropicService, }) => {
     const [service, setService] = useState(null);
     const [initialQueue, setInitialQueue] = useState(null);
@@ -106,6 +115,10 @@ export const Main = ({ app, command, serviceFactory = createAnthropicService, })
                 }),
             ]);
         }
+        else if (service && isHelpCommand(command)) {
+            // Help command - show help screen directly (no LLM)
+            setInitialQueue([createHelp({ app })]);
+        }
         else if (service && command) {
             // Valid service exists and command provided - execute command
             setInitialQueue([createCommand({ command, service })]);

package/dist/components/Component.js

@@ -10,11 +10,13 @@ import { Debug } from './views/Debug.js';
 import { Execute, ExecuteView, mapStateToViewProps, } from './controllers/Execute.js';
 import { Feedback } from './views/Feedback.js';
 import { Introspect, IntrospectView } from './controllers/Introspect.js';
+import { Learn, LearnView } from './controllers/Learn.js';
 import { Message } from './views/Message.js';
 import { Refinement, RefinementView } from './controllers/Refinement.js';
 import { Report } from './views/Report.js';
 import { Schedule, ScheduleView } from './controllers/Schedule.js';
 import { Validate, ValidateView } from './controllers/Validate.js';
+import { Help } from './views/Help.js';
 import { Welcome } from './views/Welcome.js';
 /**
  * Render a simple component (no lifecycle management)
@@ -25,6 +27,10 @@ export const SimpleComponent = memo(function SimpleComponent({ def, }) {
             const { props, status } = def;
             return _jsx(Welcome, { ...props, status: status });
         }
+        case ComponentName.Help: {
+            const { props, status } = def;
+            return _jsx(Help, { ...props, status: status });
+        }
         case ComponentName.Feedback: {
             const { props, status } = def;
             return _jsx(Feedback, { ...props, status: status });
@@ -86,6 +92,10 @@ export const ControllerComponent = memo(function ControllerComponent({ def, debu
             const { props: { tasks, service, upcoming, label }, status, } = def;
             return (_jsx(Execute, { tasks: tasks, service: service, upcoming: upcoming, label: label, requestHandlers: requestHandlers, lifecycleHandlers: lifecycleHandlers, workflowHandlers: workflowHandlers, status: status }));
         }
+        case ComponentName.Learn: {
+            const { props: { suggestedName, onFinished, onAborted }, status, } = def;
+            return (_jsx(Learn, { suggestedName: suggestedName, onFinished: onFinished, onAborted: onAborted, requestHandlers: requestHandlers, lifecycleHandlers: lifecycleHandlers, workflowHandlers: workflowHandlers, status: status }));
+        }
         default:
             throw new Error(`Unknown managed component: ${def.name}`);
     }
@@ -137,6 +147,10 @@ export const ViewComponent = memo(function ViewComponent({ def, }) {
             const { props: { text }, status, } = def;
             return _jsx(RefinementView, { text: text, status: status });
         }
+        case ComponentName.Learn: {
+            const { state, status } = def;
+            return (_jsx(LearnView, { state: state, status: status, onInputChange: () => { }, onInputSubmit: () => { } }));
+        }
         default:
             throw new Error(`Unknown managed component: ${def.name}`);
     }
@@ -148,6 +162,7 @@ export const TimelineComponent = ({ def, }) => {
     switch (def.name) {
         // Simple components render as-is
         case ComponentName.Welcome:
+        case ComponentName.Help:
         case ComponentName.Feedback:
         case ComponentName.Message:
         case ComponentName.Debug:
@@ -163,6 +178,7 @@ export const TimelineComponent = ({ def, }) => {
         case ComponentName.Execute:
         case ComponentName.Answer:
         case ComponentName.Introspect:
+        case ComponentName.Learn:
             return _jsx(ViewComponent, { def: def });
         default:
             throw new Error('Unknown component type');

package/dist/components/controllers/Config.js

@@ -8,9 +8,31 @@ import { createConfigStepsFromSchema } from '../../configuration/steps.js';
 import { saveConfigLabels } from '../../configuration/labels.js';
 import { DebugLevel } from '../../configuration/types.js';
 import { useInput } from '../../services/keyboard.js';
-import { ConfigView, StepType } from '../views/Config.js';
+import { StepType } from '../views/Config.js';
+import { Setting } from './Setting.js';
 import { Spinner } from '../views/Spinner.js';
 export { ConfigView, StepType, } from '../views/Config.js';
+function isTextStep(step) {
+    return step.type === StepType.Text;
+}
+function isSelectionStep(step) {
+    return step.type === StepType.Selection;
+}
+function initializeStepValues(steps) {
+    const values = {};
+    for (const step of steps) {
+        const configKey = step.path || step.key;
+        if (isTextStep(step)) {
+            if (step.value !== null) {
+                values[configKey] = step.value;
+            }
+        }
+        else if (isSelectionStep(step)) {
+            values[configKey] = step.options[step.defaultIndex].value;
+        }
+    }
+    return values;
+}
 /**
  * Resolve query to config steps via CONFIGURE tool
  */
@@ -48,56 +70,19 @@ export function Config(props) {
     const isActive = status === ComponentStatus.Active;
     const [steps, setSteps] = useState(initialSteps || []);
     const [resolving, setResolving] = useState(!initialSteps?.length && !!query);
-    const [step, setStep] = useState(0);
-    const [values, setValues] = useState(() => {
-        const initial = {};
-        (initialSteps || []).forEach((stepConfig) => {
-            const configKey = stepConfig.path || stepConfig.key;
-            switch (stepConfig.type) {
-                case StepType.Text:
-                    if (stepConfig.value !== null) {
-                        initial[configKey] = stepConfig.value;
-                    }
-                    break;
-                case StepType.Selection:
-                    initial[configKey] =
-                        stepConfig.options[stepConfig.defaultIndex].value;
-                    break;
-            }
-        });
-        return initial;
-    });
-    const [inputValue, setInputValue] = useState('');
-    const [selectedIndex, setSelectedIndex] = useState(0);
-    // Resolve query to steps
+    const [currentStep, setCurrentStep] = useState(0);
+    const [values, setValues] = useState(() => initializeStepValues(initialSteps || []));
     useEffect(() => {
         if (!isActive || !query || !service || initialSteps?.length)
             return;
         resolveQueryToSteps(query, service)
             .then((result) => {
-            // Add debug components to timeline if present
             if (result.debug.length) {
                 workflowHandlers.addToTimeline(...result.debug);
             }
             setSteps(result.steps);
             setResolving(false);
-            // Initialize values for resolved steps
-            const initial = {};
-            result.steps.forEach((stepConfig) => {
-                const configKey = stepConfig.path || stepConfig.key;
-                switch (stepConfig.type) {
-                    case StepType.Text:
-                        if (stepConfig.value !== null) {
-                            initial[configKey] = stepConfig.value;
-                        }
-                        break;
-                    case StepType.Selection:
-                        initial[configKey] =
-                            stepConfig.options[stepConfig.defaultIndex].value;
-                        break;
-                }
-            });
-            setValues(initial);
+            setValues(initializeStepValues(result.steps));
         })
             .catch((err) => {
             setResolving(false);
@@ -114,93 +99,39 @@ export function Config(props) {
         lifecycleHandlers,
         workflowHandlers,
     ]);
-    // Update inputValue when step changes
-    useEffect(() => {
-        if (isActive && step < steps.length) {
-            const stepConfig = steps[step];
-            const configKey = stepConfig.path || stepConfig.key;
-            setInputValue(values[configKey] || '');
+    const handleEscape = () => {
+        requestHandlers.onCompleted({
+            values,
+            completedStep: currentStep,
+            selectedIndex: 0,
+            steps,
+        });
+        if (onAborted) {
+            onAborted('configuration');
+        }
+        else {
+            lifecycleHandlers.completeActive(createFeedback({
+                type: FeedbackType.Aborted,
+                message: 'Configuration cancelled.',
+            }));
         }
-    }, [step, isActive, steps, values]);
-    const normalizeValue = (value) => {
-        if (value === null || value === undefined)
-            return '';
-        return value.replace(/\n/g, '').trim();
     };
     useInput((_, key) => {
-        if (!isActive || step >= steps.length)
+        if (!isActive || currentStep >= steps.length)
             return;
-        const currentStepConfig = steps[step];
         if (key.escape) {
-            const configKey = currentStepConfig.path || currentStepConfig.key;
-            let currentValue = '';
-            switch (currentStepConfig.type) {
-                case StepType.Text:
-                    currentValue = inputValue || values[configKey] || '';
-                    break;
-                case StepType.Selection:
-                    currentValue = values[configKey] || '';
-                    break;
-            }
-            const finalValues = currentValue
-                ? { ...values, [configKey]: currentValue }
-                : values;
-            requestHandlers.onCompleted({
-                values: finalValues,
-                completedStep: step,
-                selectedIndex,
-                steps,
-            });
-            if (onAborted) {
-                onAborted('configuration');
-            }
-            else {
-                lifecycleHandlers.completeActive(createFeedback({
-                    type: FeedbackType.Aborted,
-                    message: 'Configuration cancelled.',
-                }));
-            }
-            return;
-        }
-        if (currentStepConfig.type === StepType.Selection) {
-            if (key.tab) {
-                setSelectedIndex((prev) => (prev + 1) % currentStepConfig.options.length);
-            }
-            else if (key.return) {
-                handleSubmit(currentStepConfig.options[selectedIndex].value);
-            }
+            handleEscape();
         }
     }, { isActive });
-    const handleSubmit = (value) => {
-        const currentStepConfig = steps[step];
-        let finalValue = '';
-        switch (currentStepConfig.type) {
-            case StepType.Selection:
-                finalValue = value;
-                break;
-            case StepType.Text: {
-                const normalizedInput = normalizeValue(value);
-                if (normalizedInput && currentStepConfig.validate(normalizedInput)) {
-                    finalValue = normalizedInput;
-                }
-                else if (currentStepConfig.value &&
-                    currentStepConfig.validate(currentStepConfig.value)) {
-                    finalValue = currentStepConfig.value;
-                }
-                break;
-            }
-        }
-        if (!finalValue)
-            return;
-        const configKey = currentStepConfig.path || currentStepConfig.key;
-        const newValues = { ...values, [configKey]: finalValue };
+    const handleEntrySubmit = (stepConfig, value) => {
+        const configKey = stepConfig.path || stepConfig.key;
+        const newValues = { ...values, [configKey]: value };
         setValues(newValues);
-        setInputValue('');
-        if (step === steps.length - 1) {
+        if (currentStep === steps.length - 1) {
             requestHandlers.onCompleted({
                 values: newValues,
                 completedStep: steps.length,
-                selectedIndex,
+                selectedIndex: 0,
                 steps,
             });
             try {
@@ -216,19 +147,25 @@ export function Config(props) {
                     message: error instanceof Error ? error.message : 'Configuration failed',
                 }));
             }
-            setStep(steps.length);
+            setCurrentStep(steps.length);
         }
         else {
-            const nextStep = step + 1;
-            setStep(nextStep);
-            if (nextStep < steps.length &&
-                steps[nextStep].type === StepType.Selection) {
-                setSelectedIndex(steps[nextStep].defaultIndex);
-            }
+            setCurrentStep(currentStep + 1);
         }
     };
     if (resolving) {
         return (_jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { children: "Resolving configuration... " }), _jsx(Spinner, {})] }));
     }
-    return (_jsx(ConfigView, { steps: steps, state: { values, completedStep: step, selectedIndex }, status: status, debug: debug, onInputChange: setInputValue, onInputSubmit: handleSubmit }));
+    return (_jsx(Box, { flexDirection: "column", marginLeft: 1, children: steps.map((stepConfig, index) => {
+            const isStepActive = index === currentStep && isActive;
+            const isCompleted = index < currentStep;
+            const wasAborted = index === currentStep && !isActive;
+            const shouldShow = isCompleted || isStepActive || wasAborted;
+            if (!shouldShow)
+                return null;
+            const configKey = stepConfig.path || stepConfig.key;
+            return (_jsx(Box, { marginTop: index === 0 ? 0 : 1, children: _jsx(Setting, { step: stepConfig, initialValue: values[configKey] || '', isActive: isStepActive, debug: debug, onSubmit: (value) => {
+                        handleEntrySubmit(stepConfig, value);
+                    } }) }, configKey));
+        }) }));
 }

package/dist/components/controllers/Confirm.js

@@ -19,7 +19,7 @@ export function Confirm({ message, status, requestHandlers, onConfirmed, onCance
             requestHandlers.onCompleted(finalState);
             onCancelled();
         }
-        else if (key.tab) {
+        else if (key.tab || key.leftArrow || key.rightArrow) {
             // Toggle between Yes (0) and No (1)
             setSelectedIndex((prev) => (prev === 0 ? 1 : 0));
         }

package/dist/components/controllers/Execute.js

@@ -1,9 +1,9 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useCallback, useEffect, useReducer, useRef } from 'react';
-import { ComponentStatus, } from '../../types/components.js';
+import { useCallback, useEffect, useReducer, useRef, useState } from 'react';
+import { ComponentStatus, OutputSource, } from '../../types/components.js';
 import { useInput } from '../../services/keyboard.js';
 import { formatErrorMessage, getExecutionErrorMessage, } from '../../services/messages.js';
-import { ExecutionStatus } from '../../services/shell.js';
+import { ExecutionStatus, killCurrentProcess, writeStdin, } from '../../services/shell.js';
 import { ELAPSED_UPDATE_INTERVAL, ensureMinimumTime, } from '../../services/timing.js';
 import { handleTaskCompletion, handleTaskFailure, } from '../../execution/handlers.js';
 import { processTasks } from '../../execution/processing.js';
@@ -43,6 +43,9 @@ export function Execute({ tasks: inputTasks, status, service, upcoming, label, r
     });
     // Ref to track if current task execution is cancelled
     const cancelledRef = useRef(false);
+    // Toggle stdin input visibility with / key
+    const [showStdinInput, setShowStdinInput] = useState(false);
+    const showStdinInputRef = useRef(false);
     const { error, tasks, message, hasProcessed, completionMessage, summary } = localState;
     // Derive current task index from tasks
     const currentTaskIndex = getCurrentTaskIndex(tasks);
@@ -75,9 +78,17 @@ export function Execute({ tasks: inputTasks, status, service, upcoming, label, r
             clearInterval(interval);
         };
     }, [runningTask?.startTime, isExecuting, currentTaskIndex]);
-    // Handle cancel - state already in reducer, just need to update final output
+    // Hide stdin input when not executing
+    useEffect(() => {
+        if (!isExecuting) {
+            showStdinInputRef.current = false;
+            setShowStdinInput(false);
+        }
+    }, [isExecuting]);
+    // Handle cancel - kill the running process and update final output
     const handleCancel = useCallback(() => {
         cancelledRef.current = true;
+        killCurrentProcess();
         dispatch({ type: ExecuteActionType.CancelExecution });
         // Build final state with current output for the running task
         const updatedTasks = tasks.map((task) => {
@@ -103,9 +114,30 @@ export function Execute({ tasks: inputTasks, status, service, upcoming, label, r
         requestHandlers.onCompleted(finalState);
         requestHandlers.onAborted('execution');
     }, [message, summary, tasks, requestHandlers]);
-    useInput((_, key) => {
+    // Handle stdin submission: write the line to the running process
+    const handleStdinSubmit = useCallback((value) => {
+        writeStdin(value + '\n');
+        outputRef.current.chunks.push({
+            text: `\n> ${value}\n`,
+            timestamp: Date.now(),
+            source: OutputSource.Stdin,
+        });
+        showStdinInputRef.current = false;
+        setShowStdinInput(false);
+    }, []);
+    useInput((input, key) => {
         if (key.escape && (isLoading || isExecuting)) {
-            handleCancel();
+            if (showStdinInputRef.current) {
+                showStdinInputRef.current = false;
+                setShowStdinInput(false);
+            }
+            else {
+                handleCancel();
+            }
+        }
+        if (input === '/' && isExecuting && !showStdinInputRef.current) {
+            showStdinInputRef.current = true;
+            setShowStdinInput(true);
         }
     }, { isActive: (isLoading || isExecuting) && isActive });
     // Process tasks to get commands from AI
@@ -210,6 +242,8 @@ export function Execute({ tasks: inputTasks, status, service, upcoming, label, r
         });
         // Reset output ref for new task
         outputRef.current = { chunks: [], currentMemory: undefined };
+        showStdinInputRef.current = false;
+        setShowStdinInput(false);
         // Merge workdir into command
         const command = workdirRef.current
             ? { ...currentTask.command, workdir: workdirRef.current }
@@ -217,8 +251,10 @@ export function Execute({ tasks: inputTasks, status, service, upcoming, label, r
         void executeTask(command, currentTaskIndex, {
             onUpdate: (output) => {
                 if (!cancelledRef.current) {
+                    // Preserve stdin chunks that were added locally
+                    const stdinChunks = outputRef.current.chunks.filter((c) => c.source === OutputSource.Stdin);
                     outputRef.current = {
-                        chunks: output.chunks,
+                        chunks: [...output.chunks, ...stdinChunks],
                         currentMemory: output.currentMemory,
                     };
                 }
@@ -230,11 +266,13 @@ export function Execute({ tasks: inputTasks, status, service, upcoming, label, r
                 if (execOutput.workdir) {
                     workdirRef.current = execOutput.workdir;
                 }
+                // Preserve stdin chunks in final output
+                const stdinChunks = outputRef.current.chunks.filter((c) => c.source === OutputSource.Stdin);
                 const tasksWithOutput = tasks.map((task, i) => i === currentTaskIndex
                     ? {
                         ...task,
                         output: {
-                            chunks: execOutput.chunks,
+                            chunks: [...execOutput.chunks, ...stdinChunks],
                         },
                     }
                     : task);
@@ -256,11 +294,13 @@ export function Execute({ tasks: inputTasks, status, service, upcoming, label, r
                 if (execOutput.workdir) {
                     workdirRef.current = execOutput.workdir;
                 }
+                // Preserve stdin chunks in final output
+                const stdinChunks = outputRef.current.chunks.filter((c) => c.source === OutputSource.Stdin);
                 const tasksWithOutput = tasks.map((task, i) => i === currentTaskIndex
                     ? {
                         ...task,
                         output: {
-                            chunks: execOutput.chunks,
+                            chunks: [...execOutput.chunks, ...stdinChunks],
                         },
                         error: execOutput.error || undefined,
                     }
@@ -287,5 +327,5 @@ export function Execute({ tasks: inputTasks, status, service, upcoming, label, r
         lifecycleHandlers,
         workflowHandlers,
     ]);
-    return (_jsx(ExecuteView, { isLoading: isLoading, isExecuting: isExecuting, isActive: isActive, error: error, message: message, tasks: tasks, completionMessage: completionMessage, showTasks: showTasks, upcoming: upcoming, label: label }));
+    return (_jsx(ExecuteView, { isLoading: isLoading, isExecuting: isExecuting, isActive: isActive, error: error, message: message, tasks: tasks, completionMessage: completionMessage, showTasks: showTasks, upcoming: upcoming, label: label, onStdinSubmit: showStdinInput ? handleStdinSubmit : undefined }));
 }