prompt-language-shell 0.6.6 → 0.6.8

package/dist/services/anthropic.js

@@ -1,7 +1,7 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { getAvailableConfigStructure, getConfiguredKeys, } from './configuration.js';
 import { formatSkillsForPrompt, loadSkillsWithValidation } from './skills.js';
-import { toolRegistry } from './tool-registry.js';
+import { toolRegistry } from './registry.js';
 /**
  * Wraps text to ensure no line exceeds the specified width.
  * Breaks at word boundaries to maintain readability.

package/dist/services/messages.js

@@ -58,6 +58,21 @@ export function getUnknownRequestMessage() {
     ];
     return messages[Math.floor(Math.random() * messages.length)];
 }
+/**
+ * Returns an error message for unknown skill references.
+ * Randomly selects from variations to sound natural.
+ * Skill name should be a verb with details (e.g., "Deploy Application")
+ */
+export function getUnknownSkillMessage(skillName) {
+    const templates = [
+        `I don't know how to "${skillName}".`,
+        `I'm not familiar with the "${skillName}" command.`,
+        `I haven't learned how to "${skillName}" yet.`,
+        `I can't "${skillName}".`,
+        `I'm unable to "${skillName}".`,
+    ];
+    return templates[Math.floor(Math.random() * templates.length)];
+}
 /**
  * Returns an error message for mixed task types.
  */

package/dist/services/{skill-parser.js → parser.js}

@@ -2,18 +2,13 @@ import YAML from 'yaml';
 /**
  * Validate a skill without parsing it fully
  * Returns validation error if skill is invalid, null if valid
+ * Note: Name section is optional - key from filename is used as fallback
  */
-export function validateSkill(content) {
+export function validateSkillStructure(content, key) {
     const sections = extractSections(content);
-    // Name is required for error reporting
-    const skillName = sections.name || 'Unknown skill';
-    // Check required sections
-    if (!sections.name) {
-        return {
-            skillName,
-            error: 'The skill file is missing a Name section',
-        };
-    }
+    // Use key for error reporting if name not present
+    const skillName = sections.name || key;
+    // Check required sections (Name is now optional)
     if (!sections.description) {
         return {
             skillName,
@@ -41,17 +36,40 @@ export function validateSkill(content) {
     }
     return null;
 }
+/**
+ * Convert kebab-case key to Title Case display name
+ * Examples: "deploy-app" -> "Deploy App", "build-project-2" -> "Build Project 2"
+ */
+function keyToDisplayName(key) {
+    return key
+        .split('-')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
+/**
+ * Convert display name to kebab-case key
+ * Examples: "Deploy App" -> "deploy-app", "Navigate To Product" -> "navigate-to-product"
+ */
+export function displayNameToKey(name) {
+    return name
+        .toLowerCase()
+        .replace(/\s+/g, '-')
+        .replace(/[^a-z0-9-]/g, '');
+}
 /**
  * Parse a skill markdown file into structured definition
  */
-export function parseSkillMarkdown(content) {
+export function parseSkillMarkdown(key, content) {
     const sections = extractSections(content);
-    // Validate the skill
-    const validationError = validateSkill(content);
+    // Determine display name: prefer Name section, otherwise derive from key
+    const displayName = sections.name || keyToDisplayName(key);
+    // Validate the skill (Name is no longer required since we have key)
+    const validationError = validateSkillStructure(content, key);
     // For invalid skills, return minimal definition with error
     if (validationError) {
         return {
-            name: sections.name || 'Unknown skill',
+            key,
+            name: displayName,
             description: sections.description || '',
             steps: sections.steps || [],
             execution: sections.execution || [],
@@ -63,7 +81,8 @@ export function parseSkillMarkdown(content) {
     // Valid skill - all required fields are present (validation passed)
     const description = sections.description;
     const skill = {
-        name: sections.name,
+        key,
+        name: displayName,
         description,
         steps: sections.steps,
         execution: sections.execution,

package/dist/services/refinement.js

@@ -1,6 +1,6 @@
 import { createRefinement } from './components.js';
 import { formatErrorMessage, getRefiningMessage } from './messages.js';
-import { routeTasksWithConfirm } from './task-router.js';
+import { routeTasksWithConfirm } from './router.js';
 /**
  * Handle refinement flow for DEFINE tasks
  * Called when user selects options from a plan with DEFINE tasks

package/dist/services/{tool-registry.js → registry.js}

@@ -39,27 +39,17 @@ import { executeTool } from '../tools/execute.tool.js';
 import { introspectTool } from '../tools/introspect.tool.js';
 import { planTool } from '../tools/plan.tool.js';
 import { validateTool } from '../tools/validate.tool.js';
-toolRegistry.register('plan', {
-    schema: planTool,
-    instructionsPath: 'config/PLAN.md',
-});
-toolRegistry.register('introspect', {
-    schema: introspectTool,
-    instructionsPath: 'config/INTROSPECT.md',
-});
-toolRegistry.register('answer', {
-    schema: answerTool,
-    instructionsPath: 'config/ANSWER.md',
-});
-toolRegistry.register('config', {
-    schema: configTool,
-    instructionsPath: 'config/CONFIG.md',
-});
-toolRegistry.register('execute', {
-    schema: executeTool,
-    instructionsPath: 'config/EXECUTE.md',
-});
-toolRegistry.register('validate', {
-    schema: validateTool,
-    instructionsPath: 'config/VALIDATE.md',
-});
+const tools = {
+    answer: answerTool,
+    config: configTool,
+    execute: executeTool,
+    introspect: introspectTool,
+    plan: planTool,
+    validate: validateTool,
+};
+for (const [name, schema] of Object.entries(tools)) {
+    toolRegistry.register(name, {
+        schema,
+        instructionsPath: `skills/${name}.md`,
+    });
+}

package/dist/services/{task-router.js → router.js}

@@ -2,7 +2,7 @@ import { TaskType } from '../types/types.js';
 import { createAnswerDefinition, createConfigDefinitionWithKeys, createConfirmDefinition, createExecuteDefinition, createFeedback, createIntrospectDefinition, createMessage, createPlanDefinition, createValidateDefinition, } from './components.js';
 import { saveConfig, unflattenConfig } from './configuration.js';
 import { FeedbackType } from '../types/types.js';
-import { validateExecuteTasks } from './execution-validator.js';
+import { validateExecuteTasks } from './validator.js';
 import { getCancellationMessage, getMixedTaskTypesError, getUnknownRequestMessage, } from './messages.js';
 /**
  * Determine the operation name based on task types
@@ -125,28 +125,36 @@ function executeTasksAfterConfirm(tasks, service, userRequest, handlers) {
     }
     else {
         // Execute tasks with validation
-        const validation = validateExecuteTasks(tasks);
-        if (validation.validationErrors.length > 0) {
-            // Show error feedback for invalid skills
-            const errorMessages = validation.validationErrors.map((error) => {
-                const issuesList = error.issues
-                    .map((issue) => `  - ${issue}`)
-                    .join('\n');
-                return `Invalid skill definition "${error.skill}":\n\n${issuesList}`;
-            });
-            handlers.addToQueue(createFeedback(FeedbackType.Failed, errorMessages.join('\n\n')));
-        }
-        else if (validation.missingConfig.length > 0) {
-            handlers.addToQueue(createValidateDefinition(validation.missingConfig, userRequest, service, (error) => {
-                handlers.onError(error);
-            }, () => {
+        try {
+            const validation = validateExecuteTasks(tasks);
+            if (validation.validationErrors.length > 0) {
+                // Show error feedback for invalid skills
+                const errorMessages = validation.validationErrors.map((error) => {
+                    const issuesList = error.issues
+                        .map((issue) => `  - ${issue}`)
+                        .join('\n');
+                    return `Invalid skill definition "${error.skill}":\n\n${issuesList}`;
+                });
+                handlers.addToQueue(createFeedback(FeedbackType.Failed, errorMessages.join('\n\n')));
+            }
+            else if (validation.missingConfig.length > 0) {
+                handlers.addToQueue(createValidateDefinition(validation.missingConfig, userRequest, service, (error) => {
+                    handlers.onError(error);
+                }, () => {
+                    handlers.addToQueue(createExecuteDefinition(tasks, service));
+                }, (operation) => {
+                    handlers.onAborted(operation);
+                }));
+            }
+            else {
                 handlers.addToQueue(createExecuteDefinition(tasks, service));
-            }, (operation) => {
-                handlers.onAborted(operation);
-            }));
+            }
         }
-        else {
-            handlers.addToQueue(createExecuteDefinition(tasks, service));
+        catch (error) {
+            // Handle skill reference errors (e.g., unknown skills)
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const message = createMessage(errorMessage);
+            handlers.addToQueue(message);
         }
     }
 }

package/dist/services/skills.js

@@ -1,7 +1,42 @@
 import { existsSync, readdirSync, readFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
-import { parseSkillMarkdown } from './skill-parser.js';
+import { getUnknownSkillMessage } from './messages.js';
+import { parseSkillMarkdown, displayNameToKey } from './parser.js';
+/**
+ * Built-in skill names that user skills cannot override
+ */
+const BUILT_IN_SKILLS = new Set([
+    'plan',
+    'execute',
+    'answer',
+    'config',
+    'validate',
+    'introspect',
+]);
+/**
+ * Validate filename follows kebab-case pattern
+ * Valid: deploy-app.md, build-project-2.md, copy-files.md
+ * Invalid: Deploy_App.md, buildProject.md, DEPLOY.md, file name.md
+ */
+export function isValidSkillFilename(filename) {
+    // Must end with .md or .MD extension
+    if (!filename.endsWith('.md') && !filename.endsWith('.MD')) {
+        return false;
+    }
+    // Extract name without extension
+    const name = filename.slice(0, -3);
+    // Must match kebab-case pattern: lowercase letters, numbers, and hyphens only
+    // Must start with a letter, and not start or end with a hyphen
+    const kebabCasePattern = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+    return kebabCasePattern.test(name);
+}
+/**
+ * Check if skill key conflicts with built-in skills
+ */
+export function conflictsWithBuiltIn(key) {
+    return BUILT_IN_SKILLS.has(key);
+}
 /**
  * Get the path to the skills directory
  */
@@ -10,7 +45,8 @@ export function getSkillsDirectory() {
 }
 /**
  * Load all skill markdown files from the skills directory
- * Returns an array of skill file contents
+ * Returns an array of objects with filename (key) and content
+ * Filters out invalid filenames and conflicts with built-in skills
  */
 export function loadSkills() {
     const skillsDir = getSkillsDirectory();
@@ -20,12 +56,27 @@ export function loadSkills() {
     }
     try {
         const files = readdirSync(skillsDir);
-        // Filter for markdown files
-        const skillFiles = files.filter((file) => file.endsWith('.md') || file.endsWith('.MD'));
-        // Read and return contents of each skill file
-        return skillFiles.map((file) => {
+        // Filter and map valid skill files
+        return files
+            .filter((file) => {
+            // Must follow kebab-case naming convention
+            if (!isValidSkillFilename(file)) {
+                return false;
+            }
+            // Extract key (filename without extension, handles both .md and .MD)
+            const key = file.slice(0, -3);
+            // Must not conflict with built-in skills
+            if (conflictsWithBuiltIn(key)) {
+                return false;
+            }
+            return true;
+        })
+            .map((file) => {
+            // Extract key (filename without extension, handles both .md and .MD)
+            const key = file.slice(0, -3);
             const filePath = join(skillsDir, file);
-            return readFileSync(filePath, 'utf-8');
+            const content = readFileSync(filePath, 'utf-8');
+            return { key, content };
         });
     }
     catch {
@@ -38,17 +89,17 @@ export function loadSkills() {
  * Returns structured skill definitions (including invalid skills)
  */
 export function loadSkillDefinitions() {
-    const skillContents = loadSkills();
-    return skillContents.map((content) => parseSkillMarkdown(content));
+    const skills = loadSkills();
+    return skills.map(({ key, content }) => parseSkillMarkdown(key, content));
 }
 /**
  * Load skills and mark incomplete ones in their markdown
  * Returns array of skill markdown with status markers
  */
 export function loadSkillsWithValidation() {
-    const skillContents = loadSkills();
-    return skillContents.map((content) => {
-        const parsed = parseSkillMarkdown(content);
+    const skills = loadSkills();
+    return skills.map(({ key, content }) => {
+        const parsed = parseSkillMarkdown(key, content);
         // If skill is incomplete (either validation failed or needs more documentation), append (INCOMPLETE) to the name
         if (parsed.isIncomplete) {
             return content.replace(/^(#{1,6}\s+Name\s*\n+)(.+?)(\n|$)/im, `$1$2 (INCOMPLETE)$3`);
@@ -58,13 +109,19 @@ export function loadSkillsWithValidation() {
 }
 /**
  * Create skill lookup function from definitions
+ * Lookup by key (display name is converted to kebab-case for matching)
+ * Example: "Deploy App" -> "deploy-app" -> matches skill with key "deploy-app"
  */
 export function createSkillLookup(definitions) {
-    const map = new Map();
+    const keyMap = new Map();
     for (const definition of definitions) {
-        map.set(definition.name, definition);
+        keyMap.set(definition.key, definition);
     }
-    return (name) => map.get(name) || null;
+    return (name) => {
+        // Convert display name to kebab-case key for lookup
+        const key = displayNameToKey(name);
+        return keyMap.get(key) || null;
+    };
 }
 /**
  * Format skills for inclusion in the planning prompt
@@ -93,3 +150,95 @@ brackets for additional information. Use commas instead. For example:
     const skillsContent = skills.join('\n\n');
     return header + skillsContent;
 }
+/**
+ * Parse skill reference from execution line
+ * Format: [ Display Name ] with mandatory spaces
+ * Returns display name if line matches format, otherwise null
+ * Example: "[ My Skill ]" -> "My Skill"
+ */
+export function parseSkillReference(line) {
+    // Must match format: [ content ] with at least one space before and after
+    const match = line.trim().match(/^\[\s+(.+?)\s+\]$/);
+    return match ? match[1] : null;
+}
+/**
+ * Check if execution line is a skill reference
+ * Must have format: [ content ] with spaces
+ */
+export function isSkillReference(line) {
+    return /^\[\s+.+?\s+\]$/.test(line.trim());
+}
+/**
+ * Expand skill references in execution commands
+ * Returns expanded execution lines with references replaced
+ * Throws error if circular reference detected or skill not found
+ * Reference format: [ Skill Name ]
+ */
+export function expandSkillReferences(execution, skillLookup, visited = new Set()) {
+    const expanded = [];
+    for (const line of execution) {
+        // First: Detect if line matches [ XXX ] format
+        const skillName = parseSkillReference(line);
+        if (!skillName) {
+            // Not a reference, keep command as-is
+            expanded.push(line);
+            continue;
+        }
+        // Check for circular reference
+        if (visited.has(skillName)) {
+            throw new Error(`Circular skill reference detected: ${Array.from(visited).join(' → ')} → ${skillName}`);
+        }
+        // Second: Match against skill name
+        const skill = skillLookup(skillName);
+        if (!skill) {
+            // Referenced skill not found - throw error to break execution
+            throw new Error(getUnknownSkillMessage(skillName));
+        }
+        // Recursively expand referenced skill's execution
+        const newVisited = new Set(visited);
+        newVisited.add(skillName);
+        const referencedExecution = expandSkillReferences(skill.execution, skillLookup, newVisited);
+        expanded.push(...referencedExecution);
+    }
+    return expanded;
+}
+/**
+ * Get all skill names referenced in execution (including nested)
+ * Returns unique set of skill names
+ */
+export function getReferencedSkills(execution, skillLookup, visited = new Set()) {
+    const referenced = new Set();
+    for (const line of execution) {
+        const skillName = parseSkillReference(line);
+        if (!skillName || visited.has(skillName)) {
+            continue;
+        }
+        referenced.add(skillName);
+        const skill = skillLookup(skillName);
+        if (skill) {
+            const newVisited = new Set(visited);
+            newVisited.add(skillName);
+            const nested = getReferencedSkills(skill.execution, skillLookup, newVisited);
+            for (const name of nested) {
+                referenced.add(name);
+            }
+        }
+    }
+    return referenced;
+}
+/**
+ * Validate skill references don't form cycles
+ * Returns true if valid, false if circular reference detected
+ */
+export function validateNoCycles(execution, skillLookup, visited = new Set()) {
+    try {
+        expandSkillReferences(execution, skillLookup, visited);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('Circular')) {
+            return false;
+        }
+        throw error;
+    }
+}

package/dist/services/{execution-validator.js → validator.js}

@@ -1,8 +1,7 @@
-import { extractPlaceholders, pathToString, resolveVariant, } from './placeholder-resolver.js';
-import { loadUserConfig, hasConfigPath } from './config-loader.js';
-import { loadSkills } from './skills.js';
-import { expandSkillReferences } from './skill-expander.js';
-import { getConfigType, parseSkillMarkdown } from './skill-parser.js';
+import { extractPlaceholders, pathToString, resolveVariant, } from './resolver.js';
+import { loadUserConfig, hasConfigPath } from './loader.js';
+import { loadSkillDefinitions, createSkillLookup, expandSkillReferences, } from './skills.js';
+import { getConfigType } from './parser.js';
 /**
  * Validate config requirements for execute tasks
  * Returns validation result with missing config and validation errors
@@ -14,9 +13,8 @@ export function validateExecuteTasks(tasks) {
     const validationErrors = [];
     const seenSkills = new Set();
     // Load all skills (including invalid ones for validation)
-    const skillContents = loadSkills();
-    const parsedSkills = skillContents.map((content) => parseSkillMarkdown(content));
-    const skillLookup = (name) => parsedSkills.find((s) => s.name === name) || null;
+    const parsedSkills = loadSkillDefinitions();
+    const skillLookup = createSkillLookup(parsedSkills);
     // Check for invalid skills being used in tasks
     for (const task of tasks) {
         const skillName = typeof task.params?.skill === 'string' ? task.params.skill : null;

package/dist/ui/Command.js

@@ -8,7 +8,7 @@ import { createPlanDefinition } from '../services/components.js';
 import { formatErrorMessage } from '../services/messages.js';
 import { useInput } from '../services/keyboard.js';
 import { handleRefinement } from '../services/refinement.js';
-import { routeTasksWithConfirm } from '../services/task-router.js';
+import { routeTasksWithConfirm } from '../services/router.js';
 import { ensureMinimumTime } from '../services/timing.js';
 import { Spinner } from './Spinner.js';
 import { UserQuery } from './UserQuery.js';

package/dist/ui/Execute.js

@@ -7,8 +7,8 @@ import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
 import { formatDuration } from '../services/utils.js';
 import { ExecutionStatus, executeCommands, } from '../services/shell.js';
-import { replacePlaceholders } from '../services/placeholder-resolver.js';
-import { loadUserConfig } from '../services/config-loader.js';
+import { replacePlaceholders } from '../services/resolver.js';
+import { loadUserConfig } from '../services/loader.js';
 import { ensureMinimumTime } from '../services/timing.js';
 import { Spinner } from './Spinner.js';
 const MINIMUM_PROCESSING_TIME = 400;

package/dist/ui/Validate.js

@@ -128,9 +128,15 @@ export function Validate({ missingConfig, userRequest, state, status, service, c
         for (const [section, sectionConfig] of Object.entries(configBySection)) {
             saveConfig(section, sectionConfig);
         }
+        // Mark validation component as complete before invoking callback
+        // This allows the workflow to proceed to execution
+        handlers?.completeActive();
+        // Invoke callback which will queue the Execute component
         onComplete?.(configRequirements);
     };
     const handleConfigAborted = (operation) => {
+        // Mark validation component as complete when aborted
+        handlers?.completeActive();
         onAborted(operation);
     };
     return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isActive && !completionMessage && !error && (_jsxs(Box, { marginLeft: 1, children: [_jsxs(Text, { color: getTextColor(isActive), children: ["Validating configuration requirements.", ' '] }), _jsx(Spinner, {})] })), completionMessage && (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { color: getTextColor(isActive), children: completionMessage }) })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) })), configSteps && !error && (_jsx(Box, { marginTop: 1, children: _jsx(Config, { steps: configSteps, status: status, debug: debug, onFinished: handleConfigFinished, onAborted: handleConfigAborted, handlers: handlers }) })), children] }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.6.6",
+  "version": "0.6.8",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",
@@ -13,7 +13,7 @@
   "scripts": {
     "clean": "rm -rf dist",
     "typecheck": "tsc --project tsconfig.eslint.json",
-    "build": "npm run typecheck && npm run clean && tsc && chmod +x dist/index.js && mkdir -p dist/config && cp src/config/*.md dist/config/",
+    "build": "npm run typecheck && npm run clean && tsc && chmod +x dist/index.js && mkdir -p dist/skills && cp src/skills/*.md dist/skills/",
     "dev": "npm run build && tsc --watch",
     "prepare": "husky",
     "prepublishOnly": "npm run check",

package/dist/services/skill-expander.js

@@ -1,87 +0,0 @@
-/**
- * Parse skill reference from execution line
- * Returns skill name if line is a reference, otherwise null
- */
-export function parseSkillReference(line) {
-    const match = line.match(/^\[(.+)\]$/);
-    return match ? match[1].trim() : null;
-}
-/**
- * Check if execution line is a skill reference
- */
-export function isSkillReference(line) {
-    return /^\[.+\]$/.test(line.trim());
-}
-/**
- * Expand skill references in execution commands
- * Returns expanded execution lines with references replaced
- * Throws error if circular reference detected
- */
-export function expandSkillReferences(execution, skillLookup, visited = new Set()) {
-    const expanded = [];
-    for (const line of execution) {
-        const skillName = parseSkillReference(line);
-        if (!skillName) {
-            // Not a reference, keep as-is
-            expanded.push(line);
-            continue;
-        }
-        // Check for circular reference
-        if (visited.has(skillName)) {
-            throw new Error(`Circular skill reference detected: ${Array.from(visited).join(' → ')} → ${skillName}`);
-        }
-        // Look up referenced skill
-        const skill = skillLookup(skillName);
-        if (!skill) {
-            // Referenced skill not found, keep as-is
-            expanded.push(line);
-            continue;
-        }
-        // Recursively expand referenced skill's execution
-        const newVisited = new Set(visited);
-        newVisited.add(skillName);
-        const referencedExecution = expandSkillReferences(skill.execution, skillLookup, newVisited);
-        expanded.push(...referencedExecution);
-    }
-    return expanded;
-}
-/**
- * Get all skill names referenced in execution (including nested)
- * Returns unique set of skill names
- */
-export function getReferencedSkills(execution, skillLookup, visited = new Set()) {
-    const referenced = new Set();
-    for (const line of execution) {
-        const skillName = parseSkillReference(line);
-        if (!skillName || visited.has(skillName)) {
-            continue;
-        }
-        referenced.add(skillName);
-        const skill = skillLookup(skillName);
-        if (skill) {
-            const newVisited = new Set(visited);
-            newVisited.add(skillName);
-            const nested = getReferencedSkills(skill.execution, skillLookup, newVisited);
-            for (const name of nested) {
-                referenced.add(name);
-            }
-        }
-    }
-    return referenced;
-}
-/**
- * Validate skill references don't form cycles
- * Returns true if valid, false if circular reference detected
- */
-export function validateNoCycles(execution, skillLookup, visited = new Set()) {
-    try {
-        expandSkillReferences(execution, skillLookup, visited);
-        return true;
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.includes('Circular')) {
-            return false;
-        }
-        throw error;
-    }
-}