prompt-language-shell 1.0.0 → 1.0.2

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/components/Component.js

@@ -10,6 +10,7 @@ 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';
@@ -86,6 +87,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 +142,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}`);
     }
@@ -163,6 +172,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

@@ -68,7 +68,12 @@ export function Config(props) {
         return initial;
     });
     const [inputValue, setInputValue] = useState('');
-    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [selectedIndex, setSelectedIndex] = useState(() => {
+        if (!initialSteps?.length)
+            return 0;
+        const first = initialSteps[0];
+        return first.type === StepType.Selection ? first.defaultIndex : 0;
+    });
     // Resolve query to steps
     useEffect(() => {
         if (!isActive || !query || !service || initialSteps?.length)
@@ -114,12 +119,15 @@ export function Config(props) {
         lifecycleHandlers,
         workflowHandlers,
     ]);
-    // Update inputValue when step changes
+    // Update inputValue and selectedIndex when step changes
     useEffect(() => {
         if (isActive && step < steps.length) {
             const stepConfig = steps[step];
             const configKey = stepConfig.path || stepConfig.key;
             setInputValue(values[configKey] || '');
+            if (stepConfig.type === StepType.Selection) {
+                setSelectedIndex(stepConfig.defaultIndex);
+            }
         }
     }, [step, isActive, steps, values]);
     const normalizeValue = (value) => {
@@ -219,12 +227,7 @@ export function Config(props) {
             setStep(steps.length);
         }
         else {
-            const nextStep = step + 1;
-            setStep(nextStep);
-            if (nextStep < steps.length &&
-                steps[nextStep].type === StepType.Selection) {
-                setSelectedIndex(steps[nextStep].defaultIndex);
-            }
+            setStep(step + 1);
         }
     };
     if (resolving) {

package/dist/components/controllers/Learn.js

@@ -0,0 +1,416 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { ComponentStatus, LearnPhase, } from '../../types/components.js';
+import { FeedbackType } from '../../types/types.js';
+import { createFeedback } from '../../services/components.js';
+import { useInput } from '../../services/keyboard.js';
+import { generateSkillMarkdown, getAvailableSkillNames, isSkillNameAvailable, saveSkill, } from '../../services/skills.js';
+import { displayNameToKey } from '../../services/parser.js';
+import { LearnView } from '../views/Learn.js';
+export { LearnView } from '../views/Learn.js';
+/**
+ * Learn controller: Guided walkthrough for skill creation
+ */
+export function Learn(props) {
+    const { status, requestHandlers, lifecycleHandlers, onFinished, onAborted, suggestedName, } = props;
+    const isActive = status === ComponentStatus.Active;
+    const [state, setState] = useState(() => ({
+        name: null,
+        description: null,
+        aliases: [],
+        configEntries: [],
+        stepPairs: [],
+        currentPhase: LearnPhase.Name,
+        inputValue: suggestedName || '',
+        selectedIndex: 0,
+        error: null,
+        availableSkills: [],
+        pendingStepDescription: null,
+        pendingExecutionType: null,
+    }));
+    // Load available skills on mount
+    useEffect(() => {
+        if (isActive) {
+            const skills = getAvailableSkillNames();
+            setState((prev) => ({ ...prev, availableSkills: skills }));
+        }
+    }, [isActive]);
+    const handleInputChange = (value) => {
+        setState((prev) => ({ ...prev, inputValue: value, error: null }));
+    };
+    const handleNameSubmit = (value) => {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            setState((prev) => ({ ...prev, error: 'Skill name is required' }));
+            return;
+        }
+        const availability = isSkillNameAvailable(trimmed);
+        if (!availability.available) {
+            setState((prev) => ({
+                ...prev,
+                error: availability.reason || 'Invalid name',
+            }));
+            return;
+        }
+        setState((prev) => ({
+            ...prev,
+            name: trimmed,
+            inputValue: '',
+            error: null,
+            currentPhase: LearnPhase.Description,
+        }));
+    };
+    const handleDescriptionSubmit = (value) => {
+        const trimmed = value.trim();
+        if (trimmed.length < 20) {
+            setState((prev) => ({
+                ...prev,
+                error: 'Description must be at least 20 characters',
+            }));
+            return;
+        }
+        setState((prev) => ({
+            ...prev,
+            description: trimmed,
+            inputValue: '',
+            error: null,
+            currentPhase: LearnPhase.Aliases,
+        }));
+    };
+    const handleAliasSubmit = (value) => {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            // Skip to config phase
+            setState((prev) => ({
+                ...prev,
+                inputValue: '',
+                currentPhase: LearnPhase.Config,
+            }));
+            return;
+        }
+        // Add alias and ask for more
+        setState((prev) => ({
+            ...prev,
+            aliases: [...prev.aliases, trimmed],
+            inputValue: '',
+            selectedIndex: 0,
+            currentPhase: LearnPhase.AliasMore,
+        }));
+    };
+    const handleAliasMoreSelection = (addMore) => {
+        if (addMore) {
+            setState((prev) => ({
+                ...prev,
+                inputValue: '',
+                currentPhase: LearnPhase.Aliases,
+            }));
+        }
+        else {
+            setState((prev) => ({
+                ...prev,
+                inputValue: '',
+                currentPhase: LearnPhase.Config,
+            }));
+        }
+    };
+    const validateConfigEntry = (entry) => {
+        const configPattern = /^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)*:\s*(string|number|boolean)$/;
+        return configPattern.test(entry.trim());
+    };
+    const handleConfigSubmit = (value) => {
+        const trimmed = value.trim();
+        // Empty is allowed (skip config)
+        if (!trimmed) {
+            setState((prev) => ({
+                ...prev,
+                inputValue: '',
+                currentPhase: LearnPhase.StepDescription,
+            }));
+            return;
+        }
+        // Validate entry
+        if (!validateConfigEntry(trimmed)) {
+            setState((prev) => ({
+                ...prev,
+                error: 'Format: property.path: string | number | boolean',
+            }));
+            return;
+        }
+        // Add config entry and ask for more
+        setState((prev) => ({
+            ...prev,
+            configEntries: [...prev.configEntries, trimmed],
+            inputValue: '',
+            selectedIndex: 0,
+            error: null,
+            currentPhase: LearnPhase.ConfigMore,
+        }));
+    };
+    const handleConfigMoreSelection = (addMore) => {
+        if (addMore) {
+            setState((prev) => ({
+                ...prev,
+                inputValue: '',
+                currentPhase: LearnPhase.Config,
+            }));
+        }
+        else {
+            setState((prev) => ({
+                ...prev,
+                inputValue: '',
+                currentPhase: LearnPhase.StepDescription,
+            }));
+        }
+    };
+    const handleStepDescriptionSubmit = (value) => {
+        const trimmed = value.trim();
+        // For first step, use skill name as default if empty
+        const description = trimmed || (state.stepPairs.length === 0 ? state.name : null);
+        if (!description) {
+            setState((prev) => ({
+                ...prev,
+                error: 'Step description is required',
+            }));
+            return;
+        }
+        setState((prev) => ({
+            ...prev,
+            pendingStepDescription: description,
+            inputValue: description, // Keep for display in next phase
+            selectedIndex: 0,
+            error: null,
+            currentPhase: LearnPhase.StepExecutionType,
+        }));
+    };
+    const handleExecutionTypeSelection = (type) => {
+        setState((prev) => ({
+            ...prev,
+            pendingExecutionType: type,
+            inputValue: '',
+            selectedIndex: 0,
+            currentPhase: LearnPhase.StepExecutionValue,
+        }));
+    };
+    const handleExecutionValueSubmit = (value) => {
+        if (!state.pendingStepDescription || !state.pendingExecutionType)
+            return;
+        const trimmed = value.trim();
+        if (!trimmed) {
+            setState((prev) => ({
+                ...prev,
+                error: state.pendingExecutionType === 'command'
+                    ? 'Command is required'
+                    : 'Skill selection is required',
+            }));
+            return;
+        }
+        const newPair = {
+            description: state.pendingStepDescription,
+            executionType: state.pendingExecutionType,
+            execution: trimmed,
+        };
+        setState((prev) => ({
+            ...prev,
+            stepPairs: [...prev.stepPairs, newPair],
+            pendingStepDescription: null,
+            pendingExecutionType: null,
+            inputValue: '',
+            selectedIndex: 0,
+            error: null,
+            currentPhase: LearnPhase.StepMore,
+        }));
+    };
+    const handleSkillReferenceSelection = (skillName) => {
+        if (!state.pendingStepDescription)
+            return;
+        const newPair = {
+            description: state.pendingStepDescription,
+            executionType: 'reference',
+            execution: skillName,
+        };
+        setState((prev) => ({
+            ...prev,
+            stepPairs: [...prev.stepPairs, newPair],
+            pendingStepDescription: null,
+            pendingExecutionType: null,
+            inputValue: '',
+            selectedIndex: 0,
+            error: null,
+            currentPhase: LearnPhase.StepMore,
+        }));
+    };
+    const handleStepMoreSelection = (addMore) => {
+        if (addMore) {
+            setState((prev) => ({
+                ...prev,
+                inputValue: '',
+                currentPhase: LearnPhase.StepDescription,
+            }));
+        }
+        else {
+            setState((prev) => ({
+                ...prev,
+                inputValue: '',
+                selectedIndex: 0,
+                currentPhase: LearnPhase.Review,
+            }));
+        }
+    };
+    const handleReviewSelection = (save) => {
+        if (save && state.name && state.description) {
+            try {
+                const markdown = generateSkillMarkdown(state.name, state.description, state.aliases, state.configEntries, state.stepPairs);
+                const key = displayNameToKey(state.name);
+                saveSkill(key, markdown);
+                requestHandlers.onCompleted(state);
+                onFinished?.(key);
+                lifecycleHandlers.completeActive(createFeedback({
+                    type: FeedbackType.Info,
+                    message: `Skill "${state.name}" saved to ~/.pls/skills/${key}.md`,
+                }));
+            }
+            catch (error) {
+                lifecycleHandlers.completeActive(createFeedback({
+                    type: FeedbackType.Failed,
+                    message: error instanceof Error ? error.message : 'Failed to save skill',
+                }));
+            }
+        }
+        else {
+            handleAbort();
+        }
+    };
+    const handleAbort = () => {
+        requestHandlers.onCompleted(state);
+        if (onAborted) {
+            onAborted('skill creation');
+        }
+        else {
+            lifecycleHandlers.completeActive(createFeedback({
+                type: FeedbackType.Aborted,
+                message: 'Skill creation cancelled.',
+            }));
+        }
+    };
+    const handleInputSubmit = (value) => {
+        switch (state.currentPhase) {
+            case LearnPhase.Name:
+                handleNameSubmit(value);
+                break;
+            case LearnPhase.Description:
+                handleDescriptionSubmit(value);
+                break;
+            case LearnPhase.Aliases:
+                handleAliasSubmit(value);
+                break;
+            case LearnPhase.Config:
+                handleConfigSubmit(value);
+                break;
+            case LearnPhase.StepDescription:
+                handleStepDescriptionSubmit(value);
+                break;
+            case LearnPhase.StepExecutionValue:
+                if (state.pendingExecutionType === 'command') {
+                    handleExecutionValueSubmit(value);
+                }
+                break;
+        }
+    };
+    // Keyboard input handling
+    useInput((_, key) => {
+        if (!isActive)
+            return;
+        if (key.escape) {
+            handleAbort();
+            return;
+        }
+        // Handle selection phases
+        switch (state.currentPhase) {
+            case LearnPhase.AliasMore:
+                if (key.tab) {
+                    setState((prev) => ({
+                        ...prev,
+                        selectedIndex: (prev.selectedIndex + 1) % 2,
+                    }));
+                }
+                else if (key.return) {
+                    handleAliasMoreSelection(state.selectedIndex === 0);
+                }
+                break;
+            case LearnPhase.ConfigMore:
+                if (key.tab) {
+                    setState((prev) => ({
+                        ...prev,
+                        selectedIndex: (prev.selectedIndex + 1) % 2,
+                    }));
+                }
+                else if (key.return) {
+                    handleConfigMoreSelection(state.selectedIndex === 0);
+                }
+                break;
+            case LearnPhase.StepMore:
+                if (key.tab) {
+                    setState((prev) => ({
+                        ...prev,
+                        selectedIndex: (prev.selectedIndex + 1) % 2,
+                    }));
+                }
+                else if (key.return) {
+                    handleStepMoreSelection(state.selectedIndex === 0);
+                }
+                break;
+            case LearnPhase.Review:
+                if (key.tab) {
+                    setState((prev) => ({
+                        ...prev,
+                        selectedIndex: (prev.selectedIndex + 1) % 2,
+                    }));
+                }
+                else if (key.return) {
+                    handleReviewSelection(state.selectedIndex === 0);
+                }
+                break;
+            case LearnPhase.StepExecutionType:
+                if (key.tab) {
+                    setState((prev) => ({
+                        ...prev,
+                        selectedIndex: (prev.selectedIndex + 1) % 2,
+                    }));
+                }
+                else if (key.return) {
+                    const type = state.selectedIndex === 0 ? 'command' : 'reference';
+                    handleExecutionTypeSelection(type);
+                }
+                break;
+            case LearnPhase.StepExecutionValue:
+                if (state.pendingExecutionType === 'reference') {
+                    const skillCount = state.availableSkills.length;
+                    if (skillCount === 0) {
+                        // No skills available, go back to type selection
+                        if (key.return) {
+                            setState((prev) => ({
+                                ...prev,
+                                error: 'No skills available to reference',
+                                selectedIndex: 0,
+                                currentPhase: LearnPhase.StepExecutionType,
+                            }));
+                        }
+                    }
+                    else {
+                        if (key.tab) {
+                            setState((prev) => ({
+                                ...prev,
+                                selectedIndex: (prev.selectedIndex + 1) % skillCount,
+                            }));
+                        }
+                        else if (key.return) {
+                            const selectedSkill = state.availableSkills[state.selectedIndex];
+                            handleSkillReferenceSelection(selectedSkill);
+                        }
+                    }
+                }
+                break;
+        }
+    }, { isActive });
+    return (_jsx(LearnView, { state: state, status: status, onInputChange: handleInputChange, onInputSubmit: handleInputSubmit }));
+}

package/dist/components/views/Learn.js

@@ -0,0 +1,147 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { Box, Text, useFocus } from 'ink';
+import TextInput from 'ink-text-input';
+import { ComponentStatus, LearnPhase, } from '../../types/components.js';
+import { Colors, Palette } from '../../services/colors.js';
+import { useInput } from '../../services/keyboard.js';
+import { configEntriesToYaml } from '../../services/skills.js';
+const YES_NO_OPTIONS = [
+    { label: 'yes', value: true },
+    { label: 'no', value: false },
+];
+function ValidationMessage({ message }) {
+    return (_jsx(Box, { marginTop: 1, minWidth: 40, children: _jsxs(Text, { color: Colors.Status.Warning, children: [message, "."] }) }));
+}
+// Phase ordering for visibility logic
+const PHASE_ORDER = [
+    LearnPhase.Name,
+    LearnPhase.Description,
+    LearnPhase.Aliases,
+    LearnPhase.AliasMore,
+    LearnPhase.Config,
+    LearnPhase.ConfigMore,
+    LearnPhase.StepDescription,
+    LearnPhase.StepExecutionType,
+    LearnPhase.StepExecutionValue,
+    LearnPhase.StepMore,
+    LearnPhase.Review,
+];
+function createPhaseHelpers(current) {
+    const currentIndex = PHASE_ORDER.indexOf(current);
+    return {
+        isPast: (target) => currentIndex > PHASE_ORDER.indexOf(target),
+        isInRange: (start, end) => currentIndex >= PHASE_ORDER.indexOf(start) &&
+            currentIndex < PHASE_ORDER.indexOf(end),
+    };
+}
+const EXECUTION_TYPE_OPTIONS = [
+    { label: 'shell command', value: 'command' },
+    { label: 'reference existing skill', value: 'reference' },
+];
+function TextInputStep({ value, placeholder, onChange, onSubmit, }) {
+    const [inputValue, setInputValue] = useState(value);
+    const { isFocused } = useFocus({ autoFocus: true });
+    useEffect(() => {
+        setInputValue(value);
+    }, [value]);
+    const handleChange = (newValue) => {
+        setInputValue(newValue);
+        onChange(newValue);
+    };
+    return (_jsxs(Box, { children: [_jsx(Text, { color: Colors.Action.Select, children: ">" }), _jsx(Text, { children: " " }), isFocused ? (_jsx(TextInput, { value: inputValue, onChange: handleChange, onSubmit: onSubmit, placeholder: placeholder })) : (_jsx(Text, { dimColor: true, children: inputValue || placeholder }))] }));
+}
+function SelectionStep({ options, selectedIndex, isActive, }) {
+    return (_jsxs(Box, { children: [_jsx(Text, { color: Colors.Action.Select, children: ">" }), _jsx(Text, { children: " " }), options.map((option, index) => {
+                const isSelected = index === selectedIndex;
+                return (_jsx(Box, { marginRight: 2, children: _jsx(Text, { color: isSelected && isActive ? Palette.BrightGreen : undefined, dimColor: !isSelected, bold: isSelected, children: option.label }) }, option.label));
+            })] }));
+}
+function SkillSelectionStep({ skills, selectedIndex, }) {
+    if (skills.length === 0) {
+        return (_jsxs(Box, { children: [_jsx(Text, { color: Colors.Action.Select, children: ">" }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: "no skills available" })] }));
+    }
+    return (_jsx(Box, { flexDirection: "column", children: skills.map((skill, index) => {
+            const isSelected = index === selectedIndex;
+            return (_jsxs(Box, { children: [_jsx(Text, { color: Colors.Action.Select, children: isSelected ? '>' : ' ' }), _jsx(Text, { children: " " }), _jsx(Text, { color: isSelected ? undefined : Palette.LightGray, bold: isSelected, children: skill })] }, skill));
+        }) }));
+}
+function CompletedValue({ value }) {
+    return (_jsxs(Box, { children: [_jsx(Text, { color: Colors.Action.Select, dimColor: true, children: ">" }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: value })] }));
+}
+function CompletedStep({ index, description, executionType, execution, }) {
+    const executionValue = executionType === 'reference' ? `[ ${execution} ]` : execution;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Step ", index, ": ", description] }), _jsx(CompletedValue, { value: executionValue })] }));
+}
+function WizardHeader({ name, description, aliases = [], configEntries = [], stepPairs = [], showDescription = false, showAliases = false, showConfig = false, showSteps = false, }) {
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { color: Colors.Action.Execute, children: "Creating a new skill..." }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Name:" }), _jsx(CompletedValue, { value: name || '' })] }), showDescription && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Description:" }), _jsx(CompletedValue, { value: description || '' })] })), showAliases && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Aliases:" }), aliases.length > 0 ? (aliases.map((alias, i) => _jsx(CompletedValue, { value: alias }, i))) : (_jsx(Text, { dimColor: true, children: " (none)" }))] })), showConfig && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Config:" }), configEntries.length > 0 ? (configEntries.map((entry, i) => (_jsx(CompletedValue, { value: entry }, i)))) : (_jsx(Text, { dimColor: true, children: " (none)" }))] })), showSteps &&
+                stepPairs.map((pair, i) => (_jsx(CompletedStep, { index: i + 1, description: pair.description, executionType: pair.executionType, execution: pair.execution }, i)))] }));
+}
+function Preview({ name, description, aliases, configEntries, stepPairs, }) {
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: Palette.Gray, paddingY: 1, paddingX: 2, gap: 1, minWidth: 60, children: [_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: Palette.Cyan, children: "### Name" }), _jsx(Text, { children: name })] }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: Palette.Cyan, children: "### Description" }), _jsx(Text, { children: description })] }), aliases.length > 0 && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: Palette.Cyan, children: "### Aliases" }), aliases.map((alias, i) => (_jsxs(Text, { children: ["- ", alias] }, i)))] })), configEntries.length > 0 && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: Palette.Cyan, children: "### Config" }), _jsx(Text, { children: configEntriesToYaml(configEntries).trimEnd() })] })), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: Palette.Cyan, children: "### Steps" }), stepPairs.map((pair, i) => (_jsxs(Text, { children: ["- ", pair.description] }, i)))] }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, color: Palette.Cyan, children: "### Execution" }), stepPairs.map((pair, i) => (_jsxs(Text, { children: ["-", ' ', pair.executionType === 'reference'
+                                ? `[ ${pair.execution} ]`
+                                : pair.execution] }, i)))] })] }));
+}
+export const LearnView = ({ state, status, onInputChange, onInputSubmit, }) => {
+    const isActive = status === ComponentStatus.Active;
+    const { name, description, aliases, configEntries, stepPairs, currentPhase, inputValue, selectedIndex, error, availableSkills, pendingStepDescription, } = state;
+    // Prevent keyboard input when not active
+    useInput(() => { }, { isActive: false });
+    const headerProps = {
+        name,
+        description,
+        aliases,
+        configEntries,
+        stepPairs,
+    };
+    // Show section if we've moved past where it was entered
+    const { isPast, isInRange } = createPhaseHelpers(currentPhase);
+    const showDescription = isPast(LearnPhase.Description);
+    const showAliases = isPast(LearnPhase.AliasMore);
+    const showConfig = isPast(LearnPhase.ConfigMore);
+    const showSteps = isInRange(LearnPhase.StepDescription, LearnPhase.Review);
+    const isReference = state.pendingExecutionType === 'reference';
+    const renderPhaseContent = () => {
+        switch (currentPhase) {
+            case LearnPhase.Name:
+                return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Name:" }), _jsx(TextInputStep, { value: inputValue, onChange: onInputChange, onSubmit: onInputSubmit }, "name"), error && _jsx(ValidationMessage, { message: error })] }));
+            case LearnPhase.Description:
+                return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Description (min 20 characters):" }), _jsx(TextInputStep, { value: inputValue, onChange: onInputChange, onSubmit: onInputSubmit }, "description"), error && _jsx(ValidationMessage, { message: error })] }));
+            case LearnPhase.Aliases:
+                return (_jsxs(_Fragment, { children: [aliases.length > 0 && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Aliases:" }), aliases.map((alias, i) => (_jsx(CompletedValue, { value: alias }, i)))] })), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: aliases.length === 0
+                                        ? 'Alias (Enter to skip):'
+                                        : 'Another alias (Enter to skip):' }), _jsx(TextInputStep, { value: inputValue, placeholder: "e.g. deploy to prod", onChange: onInputChange, onSubmit: onInputSubmit }, `alias-${aliases.length}`)] })] }));
+            case LearnPhase.AliasMore:
+                return (_jsxs(_Fragment, { children: [_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Aliases:" }), aliases.map((alias, i) => (_jsx(CompletedValue, { value: alias }, i)))] }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Add another alias?" }), _jsx(SelectionStep, { options: YES_NO_OPTIONS, selectedIndex: selectedIndex, isActive: isActive }, "alias-more")] })] }));
+            case LearnPhase.Config:
+                return (_jsxs(_Fragment, { children: [configEntries.length > 0 && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Config:" }), configEntries.map((entry, i) => (_jsx(CompletedValue, { value: entry }, i)))] })), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: configEntries.length === 0
+                                        ? 'Config (Enter to skip):'
+                                        : 'Another config (Enter to skip):' }), _jsx(TextInputStep, { value: inputValue, placeholder: "e.g. server.production.url: string", onChange: onInputChange, onSubmit: onInputSubmit }, `config-${configEntries.length}`), error && _jsx(ValidationMessage, { message: error })] })] }));
+            case LearnPhase.ConfigMore:
+                return (_jsxs(_Fragment, { children: [_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Config:" }), configEntries.map((entry, i) => (_jsx(CompletedValue, { value: entry }, i)))] }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Add another configuration entry?" }), _jsx(SelectionStep, { options: YES_NO_OPTIONS, selectedIndex: selectedIndex, isActive: isActive }, "config-more")] })] }));
+            case LearnPhase.StepDescription:
+                return (_jsxs(Box, { flexDirection: "column", children: [stepPairs.length === 0 && (_jsx(Text, { children: "Step 1 - What does this step do?" })), _jsx(TextInputStep, { value: inputValue, placeholder: stepPairs.length === 0
+                                ? name || undefined
+                                : `Describe step ${stepPairs.length + 1}`, onChange: onInputChange, onSubmit: onInputSubmit }, `step-desc-${stepPairs.length}`), error && _jsx(ValidationMessage, { message: error })] }));
+            case LearnPhase.StepExecutionType:
+                return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Text, { dimColor: true, children: ["Step ", stepPairs.length + 1, ": ", inputValue] }), _jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsx(Text, { children: "How should this step be executed?" }), _jsx(SelectionStep, { options: EXECUTION_TYPE_OPTIONS, selectedIndex: selectedIndex, isActive: isActive }, `step-type-${stepPairs.length}`)] })] }));
+            case LearnPhase.StepExecutionValue:
+                return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Text, { dimColor: true, children: ["Step ", stepPairs.length + 1, ": ", pendingStepDescription] }), _jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [isReference ? (_jsxs(_Fragment, { children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Select skill to reference:" }) }), _jsx(SkillSelectionStep, { skills: availableSkills, selectedIndex: selectedIndex, isActive: isActive }, `step-ref-${stepPairs.length}`)] })) : (_jsxs(_Fragment, { children: [_jsx(Text, { children: "Enter the shell command:" }), _jsx(TextInputStep, { value: inputValue, placeholder: "e.g. npm install", onChange: onInputChange, onSubmit: onInputSubmit }, `step-exec-${stepPairs.length}`)] })), error && _jsx(ValidationMessage, { message: error })] })] }));
+            case LearnPhase.StepMore:
+                return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Add another step?" }), _jsx(SelectionStep, { options: YES_NO_OPTIONS, selectedIndex: selectedIndex, isActive: isActive }, `step-more-${stepPairs.length}`)] }));
+            case LearnPhase.Review:
+                return null; // Review has its own layout
+            default:
+                return null;
+        }
+    };
+    // Name phase has its own layout (no header yet)
+    if (currentPhase === LearnPhase.Name) {
+        return (_jsxs(Box, { flexDirection: "column", marginLeft: 1, gap: 1, children: [_jsx(Text, { color: Colors.Action.Execute, children: "Creating a new skill..." }), renderPhaseContent()] }));
+    }
+    // Review phase has a different layout
+    if (currentPhase === LearnPhase.Review) {
+        return (_jsxs(Box, { flexDirection: "column", marginLeft: 1, gap: 1, children: [_jsx(Text, { children: "Review your new skill:" }), _jsx(Preview, { name: name || '', description: description || '', aliases: aliases, configEntries: configEntries, stepPairs: stepPairs }), _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Save this skill?" }), _jsx(SelectionStep, { options: YES_NO_OPTIONS, selectedIndex: selectedIndex, isActive: isActive }, "review-save")] })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", marginLeft: 1, gap: 1, children: [_jsx(WizardHeader, { ...headerProps, showDescription: showDescription, showAliases: showAliases, showConfig: showConfig, showSteps: showSteps }), renderPhaseContent()] }));
+};

package/dist/services/colors.js

@@ -127,6 +127,10 @@ const taskColors = {
         description: Colors.Label.Default,
         type: Colors.Type.Group,
     },
+    [TaskType.Learn]: {
+        description: Colors.Label.Default,
+        type: Palette.LightGreen,
+    },
 };
 /**
  * Feedback-specific color mappings (internal)
@@ -221,6 +225,7 @@ const verboseTaskTypeLabels = {
     [TaskType.Execute]: 'execute command',
     [TaskType.Answer]: 'answer question',
     [TaskType.Introspect]: 'introspect capabilities',
+    [TaskType.Learn]: 'learn skill',
     [TaskType.Report]: 'report results',
     [TaskType.Define]: 'define options',
     [TaskType.Ignore]: 'ignore request',

package/dist/services/components.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-import { ComponentStatus, } from '../types/components.js';
+import { ComponentStatus, LearnPhase, } from '../types/components.js';
 import { ComponentName } from '../types/types.js';
 /**
  * Shared component creation utility
@@ -64,6 +64,20 @@ const InitialValidateState = {
     configRequirements: [],
     validated: false,
 };
+const InitialLearnState = {
+    name: null,
+    description: null,
+    aliases: [],
+    configEntries: [],
+    stepPairs: [],
+    currentPhase: LearnPhase.Name,
+    inputValue: '',
+    selectedIndex: 0,
+    error: null,
+    availableSkills: [],
+    pendingStepDescription: null,
+    pendingExecutionType: null,
+};
 /**
  * Create a welcome component that displays application information
  */
@@ -120,3 +134,7 @@ export const createExecute = (props, status) => createManagedComponent(Component
  * Create a validate component that checks and collects missing configuration
  */
 export const createValidate = (props, status) => createManagedComponent(ComponentName.Validate, props, InitialValidateState, status);
+/**
+ * Create a learn component that guides users through skill creation
+ */
+export const createLearn = (props, status) => createManagedComponent(ComponentName.Learn, props, InitialLearnState, status);

package/dist/services/router.js

@@ -5,7 +5,7 @@ import { getConfigSchema } from '../configuration/schema.js';
 import { createConfigStepsFromSchema } from '../configuration/steps.js';
 import { unflattenConfig } from '../configuration/transformation.js';
 import { saveConfigLabels } from '../configuration/labels.js';
-import { createAnswer, createConfig, createConfirm, createExecute, createFeedback, createIntrospect, createSchedule, createValidate, } from './components.js';
+import { createAnswer, createConfig, createConfirm, createExecute, createFeedback, createIntrospect, createLearn, createSchedule, createValidate, } from './components.js';
 import { getCancellationMessage, getConfirmationMessage, getUnknownRequestMessage, } from './messages.js';
 import { validateExecuteTasks } from './validator.js';
 /**
@@ -297,6 +297,8 @@ export function getRoutingCategory(task) {
             return 'execute';
         case TaskType.Answer:
             return 'answer';
+        case TaskType.Learn:
+            return 'learn';
         default:
             return task.type;
     }
@@ -512,6 +514,14 @@ function routeConfigTasks(tasks, context, _upcoming) {
 function routeExecuteTasks(tasks, context, upcoming, label) {
     context.workflowHandlers.addToQueue(createExecute({ tasks, service: context.service, upcoming, label }));
 }
+/**
+ * Route Learn tasks - creates Learn component for skill creation walkthrough
+ */
+function routeLearnTasks(tasks, context, _upcoming) {
+    // Extract suggested name from first task's params if provided
+    const suggestedName = tasks[0]?.params?.suggestedName;
+    context.workflowHandlers.addToQueue(createLearn({ suggestedName }));
+}
 /**
  * Registry mapping task types to their route handlers
  */
@@ -520,6 +530,7 @@ const taskRouteHandlers = {
     [TaskType.Introspect]: routeIntrospectTasks,
     [TaskType.Config]: routeConfigTasks,
     [TaskType.Execute]: routeExecuteTasks,
+    [TaskType.Learn]: routeLearnTasks,
 };
 /**
  * Route tasks by type to appropriate components

package/dist/services/skills.js

@@ -1,5 +1,6 @@
 import { homedir } from 'os';
 import { join } from 'path';
+import YAML from 'yaml';
 import { AppError, ErrorCode } from '../types/errors.js';
 import { defaultFileSystem } from './filesystem.js';
 import { displayWarning } from './logger.js';
@@ -274,3 +275,104 @@ export function validateNoCycles(execution, skillLookup, visited = new Set()) {
         throw error;
     }
 }
+/**
+ * Check if a skill name is available (not conflicting with existing files
+ * or built-in skills)
+ */
+export function isSkillNameAvailable(name, fs = defaultFileSystem) {
+    const key = displayNameToKey(name);
+    if (!key) {
+        return { available: false, reason: 'Skill name is required' };
+    }
+    if (conflictsWithBuiltIn(key)) {
+        return { available: false, reason: 'Name conflicts with a built-in skill' };
+    }
+    const skillsDir = getSkillsDirectory();
+    const filePath = join(skillsDir, `${key}.md`);
+    if (fs.exists(filePath)) {
+        return {
+            available: false,
+            reason: 'A skill with this name already exists',
+        };
+    }
+    return { available: true };
+}
+/**
+ * Convert dot-notation config entries to nested YAML format.
+ * Input: ["pdf.base.dir: string", "pdf.base.format: string"]
+ * Output: "pdf:\n  base:\n    dir: string\n    format: string\n"
+ */
+export function configEntriesToYaml(entries) {
+    const root = {};
+    for (const entry of entries) {
+        const colonIndex = entry.lastIndexOf(':');
+        if (colonIndex === -1)
+            continue;
+        const path = entry.slice(0, colonIndex).trim();
+        const type = entry.slice(colonIndex + 1).trim();
+        const parts = path.split('.');
+        let current = root;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            if (!(part in current) || typeof current[part] !== 'object') {
+                current[part] = {};
+            }
+            current = current[part];
+        }
+        current[parts[parts.length - 1]] = type;
+    }
+    return YAML.stringify(root, { indent: 2 });
+}
+/**
+ * Generate skill markdown from collected data
+ */
+export function generateSkillMarkdown(name, description, aliases, configEntries, stepPairs) {
+    let markdown = `### Name\n${name}\n\n`;
+    markdown += `### Description\n${description}\n\n`;
+    if (aliases.length > 0) {
+        markdown += `### Aliases\n`;
+        for (const alias of aliases) {
+            markdown += `- ${alias}\n`;
+        }
+        markdown += '\n';
+    }
+    if (configEntries.length > 0) {
+        markdown += `### Config\n`;
+        markdown += configEntriesToYaml(configEntries);
+        markdown += '\n';
+    }
+    markdown += `### Steps\n`;
+    for (const pair of stepPairs) {
+        markdown += `- ${pair.description}\n`;
+    }
+    markdown += '\n';
+    markdown += `### Execution\n`;
+    for (const pair of stepPairs) {
+        if (pair.executionType === 'reference') {
+            markdown += `- [ ${pair.execution} ]\n`;
+        }
+        else {
+            markdown += `- ${pair.execution}\n`;
+        }
+    }
+    return markdown;
+}
+/**
+ * Save skill to file (creates directory if needed)
+ */
+export function saveSkill(key, content, fs = defaultFileSystem) {
+    const skillsDir = getSkillsDirectory();
+    // Create directory if it doesn't exist
+    if (!fs.exists(skillsDir)) {
+        fs.createDirectory(skillsDir, { recursive: true });
+    }
+    const filePath = join(skillsDir, `${key}.md`);
+    fs.writeFile(filePath, content);
+}
+/**
+ * Get list of available skill names for reference selection
+ */
+export function getAvailableSkillNames(fs = defaultFileSystem) {
+    const definitions = loadSkillDefinitions(fs);
+    return definitions.filter((def) => def.isValid).map((def) => def.name);
+}

package/dist/skills/introspect.md

@@ -71,28 +71,28 @@ NON-NEGOTIABLE and applies to EVERY response.
 
 **DO NOT:**
 - Reorder capabilities based on alphabetical sorting
-- Put Schedule or Report first (this is WRONG)
+- Put Schedule first (this is WRONG)
 - Rearrange based on perceived importance
 - Deviate from this order for any reason
 
 **CORRECT ORDER - FOLLOW EXACTLY:**
 
-### Position 1-4: system capabilities (origin: "system")
+### Position 1-5: system capabilities (origin: "system")
 
 These MUST appear FIRST, in this EXACT sequence:
 
 1. **Introspect**
 2. **Configure**
 3. **Answer**
-4. **Execute**
+4. **Learn**
+5. **Execute**
 
-### Position 5-7: meta workflow capabilities (origin: "meta")
+### Position 6-7: meta workflow capabilities (origin: "meta")
 
 These MUST appear AFTER Execute and BEFORE user-provided skills:
 
-5. **Schedule**
-6. **Validate**
-7. **Report**
+6. **Schedule**
+7. **Validate**
 
 ### Position 8+: user-provided skills (origin: "user")
 
@@ -122,6 +122,7 @@ Create capability objects for each capability. Each object should have:
   - Start with lowercase letter, no ending punctuation
   - Focus on clarity and brevity
   - Describe the core purpose in one short phrase
+  - For Learn: "learn new skills or capabilities"
   - Examples:
     - "break down requests into actionable steps"
     - "run shell commands and process operations"
@@ -129,8 +130,8 @@ Create capability objects for each capability. Each object should have:
 
 - **origin**: The origin type of the capability
   - Use "system" for system capabilities: Introspect, Configure, Answer,
-    Execute
-  - Use "meta" for meta workflow capabilities: Schedule, Validate, Report
+    Learn, Execute
+  - Use "meta" for meta workflow capabilities: Schedule, Validate
   - Use "user" for all user-provided skills
 
 - **isIncomplete**: Optional boolean flag
@@ -158,9 +159,9 @@ Examples:
 
 When user asks "list your skills", create an introductory message like
 "here are my capabilities:" followed by capability objects for system
-capabilities (Introspect, Configure, Answer, Execute with origin
-"system"), then meta workflow capabilities (Schedule, Validate, Report
-with origin "meta").
+capabilities (Introspect, Configure, Answer, Learn, Execute with origin
+"system"), then meta workflow capabilities (Schedule, Validate with
+origin "meta").
 
 ### Example 2: Filtered Skills
 
@@ -174,9 +175,9 @@ app skill with origin "user".
 When user asks "what can you do" and user-provided skills like "process
 data" and "backup files" exist, create an introductory message like "i can
 help with these operations:" followed by all system capabilities
-(Introspect, Configure, Answer, Execute with origin "system"), meta
-capabilities (Schedule, Validate, Report with origin "meta"), plus the
-user-provided skills with origin "user".
+(Introspect, Configure, Answer, Learn, Execute with origin "system"),
+meta capabilities (Schedule, Validate with origin "meta"), plus
+the user-provided skills with origin "user".
 
 ## Final Validation
 

package/dist/skills/schedule.md

@@ -76,6 +76,7 @@ Every task MUST have a type field. Use the appropriate type:
 - `execute` - Shell commands, running programs (ONLY if skill exists)
 - `answer` - Answering questions, explaining concepts
 - `introspect` - Listing capabilities when user asks what you can do
+- `learn` - Creating a new skill (guided walkthrough for skill creation)
 - `report` - Generating summaries, displaying results
 - `define` - Presenting options when a matching skill needs variant
   selection
@@ -136,12 +137,43 @@ Before creating tasks, evaluate the request type:
    - NEVER break down capabilities into separate introspect tasks
    - The single introspect task will list ALL capabilities
 
-2. **Information requests** (questions) - Use question keywords:
+2. **Skill creation requests** - User wants to create/teach a new skill:
+   - "learn", "teach", "create skill", "new skill", "add skill",
+     "define skill", "make skill"
+   - Example: "learn" → learn type
+   - Example: "teach me to build" → learn type
+   - Example: "create a new skill" → learn type
+
+   **CRITICAL - Learn is ALWAYS a single task:**
+   - Learn requests MUST result in exactly ONE learn leaf task
+   - NEVER create multiple learn tasks for a single request
+   - NEVER nest learn tasks within groups
+   - The learn task launches a guided walkthrough for skill creation
+
+   **Learn task action format**: The action MUST explicitly mention
+   learning a new skill/capability. Use the user's original phrasing:
+   - "learn to build docker images" → action: "Learn to build docker images"
+   - "teach me to deploy" → action: "Learn to deploy"
+   - "create a new skill" → action: "Learn a new skill"
+   - "learn" → action: "Learn a new skill"
+
+   **Skill name extraction**: If the user's request includes a skill
+   topic (after "learn", "teach", "create skill", etc.), extract it and
+   include as `params.suggestedName`. Convert to imperative mood (command
+   form) with title case. Convert gerunds (-ing) to base verb form:
+   - "learn refining prompts" → params: { suggestedName: "Refine Prompts" }
+   - "learn building apps" → params: { suggestedName: "Build Apps" }
+   - "teach me to deploy" → params: { suggestedName: "Deploy" }
+   - "learn how to do stuff" → params: { suggestedName: "Do Stuff" }
+   - "create a deploy script skill" → params: { suggestedName: "Deploy Script" }
+   - "learn" (no topic) → no params needed
+
+3. **Information requests** (questions) - Use question keywords:
    - "explain", "describe", "tell me", "what is", "how does", "find",
      "search"
    - Example: "explain docker" → answer type
 
-3. **Action requests** (commands) - Must match skills in "Available
+4. **Action requests** (commands) - Must match skills in "Available
    Skills" section:
    - Check if action verb matches ANY skill in "Available Skills"
      section
@@ -158,7 +190,7 @@ Before creating tasks, evaluate the request type:
    - Example: "build" with no matching skill in "Available Skills" →
      action "Ignore unknown 'build' request"
 
-4. **Vague/ambiguous requests** without clear verb:
+5. **Vague/ambiguous requests** without clear verb:
    - Phrases like "do something", "handle it" → ignore type
    - Action format: "Ignore unknown 'X' request" where X is the phrase
 

package/dist/tools/introspect.tool.js

@@ -10,7 +10,7 @@ export const introspectTool = {
             },
             capabilities: {
                 type: 'array',
-                description: 'Array of capabilities and skills. Include system capabilities (Introspect, Configure, Answer, Execute) with origin "system", meta workflow capabilities (Schedule, Validate, Report) with origin "meta", and user-provided skills from the Available Skills section with origin "user".',
+                description: 'Array of capabilities and skills. Include system capabilities (Introspect, Configure, Answer, Learn, Execute) with origin "system", meta workflow capabilities (Schedule, Validate) with origin "meta", and user-provided skills from the Available Skills section with origin "user".',
                 items: {
                     type: 'object',
                     properties: {
@@ -25,7 +25,7 @@ export const introspectTool = {
                         origin: {
                             type: 'string',
                             enum: ['system', 'user', 'meta'],
-                            description: 'Origin of the capability. Use "system" for system capabilities (Introspect, Configure, Answer, Execute), "meta" for meta workflow capabilities (Schedule, Validate, Report), and "user" for user-provided skills.',
+                            description: 'Origin of the capability. Use "system" for system capabilities (Introspect, Configure, Answer, Learn, Execute), "meta" for meta workflow capabilities (Schedule, Validate), and "user" for user-provided skills.',
                         },
                         isIncomplete: {
                             type: 'boolean',

package/dist/tools/schedule.tool.js

@@ -27,7 +27,7 @@ export const scheduleTool = {
                     },
                     type: {
                         type: 'string',
-                        description: 'Type: "group" for parent tasks with subtasks. For leaf tasks: "configure", "execute", "answer", "introspect", "report", "define", "ignore"',
+                        description: 'Type: "group" for parent tasks with subtasks. For leaf tasks: "configure", "execute", "answer", "introspect", "learn", "report", "define", "ignore"',
                     },
                     params: {
                         type: 'object',

package/dist/types/components.js

@@ -6,3 +6,17 @@ export var ComponentStatus;
     ComponentStatus["Pending"] = "pending";
     ComponentStatus["Done"] = "done";
 })(ComponentStatus || (ComponentStatus = {}));
+export var LearnPhase;
+(function (LearnPhase) {
+    LearnPhase["Name"] = "name";
+    LearnPhase["Description"] = "description";
+    LearnPhase["Aliases"] = "aliases";
+    LearnPhase["AliasMore"] = "alias_more";
+    LearnPhase["Config"] = "config";
+    LearnPhase["ConfigMore"] = "config_more";
+    LearnPhase["StepDescription"] = "step_description";
+    LearnPhase["StepExecutionType"] = "step_execution_type";
+    LearnPhase["StepExecutionValue"] = "step_execution_value";
+    LearnPhase["StepMore"] = "step_more";
+    LearnPhase["Review"] = "review";
+})(LearnPhase || (LearnPhase = {}));

package/dist/types/schemas.js

@@ -10,6 +10,7 @@ export const TaskTypeSchema = z.enum([
     TaskType.Execute,
     TaskType.Answer,
     TaskType.Introspect,
+    TaskType.Learn,
     TaskType.Report,
     TaskType.Define,
     TaskType.Ignore,

package/dist/types/types.js

@@ -14,6 +14,7 @@ export var ComponentName;
     ComponentName["Answer"] = "answer";
     ComponentName["Execute"] = "execute";
     ComponentName["Validate"] = "validate";
+    ComponentName["Learn"] = "learn";
 })(ComponentName || (ComponentName = {}));
 export var TaskType;
 (function (TaskType) {
@@ -28,6 +29,7 @@ export var TaskType;
     TaskType["Select"] = "select";
     TaskType["Discard"] = "discard";
     TaskType["Group"] = "group";
+    TaskType["Learn"] = "learn";
 })(TaskType || (TaskType = {}));
 export var Origin;
 (function (Origin) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",