prompt-language-shell 0.4.8 → 0.5.0

package/dist/services/config-loader.js

@@ -0,0 +1,67 @@
+import { existsSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import YAML from 'yaml';
+/**
+ * Load user config from ~/.plsrc
+ */
+export function loadUserConfig() {
+    const configPath = join(homedir(), '.plsrc');
+    if (!existsSync(configPath)) {
+        return {};
+    }
+    try {
+        const content = readFileSync(configPath, 'utf-8');
+        const parsed = YAML.parse(content);
+        if (parsed && typeof parsed === 'object') {
+            return parsed;
+        }
+        return {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Check if config has a specific path
+ */
+export function hasConfigPath(config, path) {
+    const parts = path.split('.');
+    let current = config;
+    for (const part of parts) {
+        if (current === null || current === undefined) {
+            return false;
+        }
+        if (typeof current !== 'object') {
+            return false;
+        }
+        current = current[part];
+    }
+    return (current !== null &&
+        current !== undefined &&
+        (typeof current === 'string' ||
+            typeof current === 'boolean' ||
+            typeof current === 'number'));
+}
+/**
+ * Get config value at path
+ */
+export function getConfigValue(config, path) {
+    const parts = path.split('.');
+    let current = config;
+    for (const part of parts) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        if (typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[part];
+    }
+    if (typeof current === 'string' ||
+        typeof current === 'boolean' ||
+        typeof current === 'number') {
+        return current;
+    }
+    return undefined;
+}

package/dist/services/execution-validator.js

@@ -0,0 +1,110 @@
+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';
+/**
+ * Validate config requirements for execute tasks
+ * Returns missing config requirements
+ */
+export function validateExecuteTasks(tasks) {
+    const userConfig = loadUserConfig();
+    const missing = [];
+    const seenPaths = new Set();
+    // Load and parse all skills for validation
+    const skillContents = loadSkills();
+    const parsedSkills = skillContents
+        .map((content) => parseSkillMarkdown(content))
+        .filter((s) => s !== null);
+    const skillLookup = (name) => parsedSkills.find((s) => s.name === name) || null;
+    for (const task of tasks) {
+        // Check if task originates from a skill
+        const skillName = typeof task.params?.skill === 'string' ? task.params.skill : null;
+        if (skillName) {
+            // Task comes from a skill - check skill's Execution section
+            const skill = skillLookup(skillName);
+            if (!skill || !skill.execution) {
+                continue;
+            }
+            // Get variant from task params (if any)
+            // Try params.variant first, then look for other param keys that might be the variant
+            let variant = null;
+            if (typeof task.params?.variant === 'string') {
+                variant = task.params.variant.toLowerCase();
+            }
+            else if (task.params && typeof task.params === 'object') {
+                // Look for other params that could be the variant (e.g., product, target, option, etc.)
+                // Exclude known non-variant params
+                const excludeKeys = new Set(['skill', 'type']);
+                for (const [key, value] of Object.entries(task.params)) {
+                    if (!excludeKeys.has(key) && typeof value === 'string') {
+                        variant = value.toLowerCase();
+                        break;
+                    }
+                }
+            }
+            // Expand skill references to get actual commands
+            const expanded = expandSkillReferences(skill.execution, skillLookup);
+            // Extract placeholders from actual commands
+            for (const line of expanded) {
+                const placeholders = extractPlaceholders(line);
+                for (const placeholder of placeholders) {
+                    let resolvedPath;
+                    if (placeholder.hasVariant) {
+                        // Variant placeholder - resolve with variant from params
+                        if (!variant) {
+                            // No variant provided - skip this placeholder
+                            continue;
+                        }
+                        const resolvedPathArray = resolveVariant(placeholder.path, variant);
+                        resolvedPath = pathToString(resolvedPathArray);
+                    }
+                    else {
+                        // Strict placeholder - use as-is
+                        resolvedPath = pathToString(placeholder.path);
+                    }
+                    // Skip if already processed
+                    if (seenPaths.has(resolvedPath)) {
+                        continue;
+                    }
+                    seenPaths.add(resolvedPath);
+                    // Check if config exists
+                    if (!hasConfigPath(userConfig, resolvedPath)) {
+                        // Get type from skill config
+                        const type = skill.config
+                            ? getConfigType(skill.config, resolvedPath)
+                            : undefined;
+                        missing.push({
+                            path: resolvedPath,
+                            type: type || 'string',
+                        });
+                    }
+                }
+            }
+        }
+        else {
+            // Task doesn't come from a skill - check task action for placeholders
+            const placeholders = extractPlaceholders(task.action);
+            for (const placeholder of placeholders) {
+                // Skip variant placeholders - they should have been resolved during planning
+                if (placeholder.hasVariant) {
+                    continue;
+                }
+                const path = placeholder.path.join('.');
+                // Skip if already processed
+                if (seenPaths.has(path)) {
+                    continue;
+                }
+                seenPaths.add(path);
+                // Check if config exists
+                if (!hasConfigPath(userConfig, path)) {
+                    missing.push({
+                        path,
+                        type: 'string', // Default to string for now
+                    });
+                }
+            }
+        }
+    }
+    return missing;
+}

package/dist/services/messages.js

@@ -1,4 +1,5 @@
 import { loadDebugSetting } from './configuration.js';
+export { formatDuration } from './utils.js';
 /**
  * Returns a natural language confirmation message for plan execution.
  * Randomly selects from variations to sound less robotic.

package/dist/services/placeholder-resolver.js

@@ -0,0 +1,120 @@
+/**
+ * Check if a string is all uppercase (variant placeholder indicator)
+ */
+function isUpperCase(str) {
+    return str === str.toUpperCase() && str !== str.toLowerCase();
+}
+/**
+ * Parse placeholder from string
+ * Returns placeholder info or null if no valid placeholder found
+ */
+export function parsePlaceholder(text) {
+    // Match {path.to.property} format
+    const match = text.match(/\{([^}]+)\}/);
+    if (!match) {
+        return null;
+    }
+    const original = match[0];
+    const pathString = match[1];
+    const path = pathString.split('.');
+    // Check if any path component is uppercase (variant placeholder)
+    const variantIndex = path.findIndex((part) => isUpperCase(part));
+    const hasVariant = variantIndex !== -1;
+    return {
+        original,
+        path,
+        hasVariant,
+        variantIndex: hasVariant ? variantIndex : undefined,
+    };
+}
+/**
+ * Extract all placeholders from text
+ */
+export function extractPlaceholders(text) {
+    const placeholders = [];
+    const regex = /\{([^}]+)\}/g;
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+        const pathString = match[1];
+        const path = pathString.split('.');
+        const variantIndex = path.findIndex((part) => isUpperCase(part));
+        const hasVariant = variantIndex !== -1;
+        placeholders.push({
+            original: match[0],
+            path,
+            hasVariant,
+            variantIndex: hasVariant ? variantIndex : undefined,
+        });
+    }
+    return placeholders;
+}
+/**
+ * Replace uppercase component in path with actual variant name
+ * Returns new path with variant replaced
+ */
+export function resolveVariant(path, variantName) {
+    return path.map((part) => (isUpperCase(part) ? variantName : part));
+}
+/**
+ * Convert path array to dot notation string
+ */
+export function pathToString(path) {
+    return path.join('.');
+}
+/**
+ * Resolve placeholder value from config
+ * Returns the value at the specified path or undefined if not found
+ */
+export function resolveFromConfig(config, path) {
+    let current = config;
+    for (const part of path) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        if (typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[part];
+    }
+    if (typeof current === 'string' ||
+        typeof current === 'boolean' ||
+        typeof current === 'number') {
+        return current;
+    }
+    return undefined;
+}
+/**
+ * Replace all placeholders in text with values from config
+ * Note: Variant placeholders (with uppercase components) must be resolved first
+ */
+export function replacePlaceholders(text, config) {
+    return text.replace(/\{([^}]+)\}/g, (_match, pathString) => {
+        const path = pathString.split('.');
+        const value = resolveFromConfig(config, path);
+        if (value === undefined) {
+            // Keep placeholder if not found in config
+            return `{${pathString}}`;
+        }
+        return String(value);
+    });
+}
+/**
+ * Check if text contains any placeholders
+ */
+export function hasPlaceholders(text) {
+    return /\{[^}]+\}/.test(text);
+}
+/**
+ * Get all unique config paths required by placeholders in text
+ * Note: Variant placeholders (with uppercase components) must be resolved first
+ */
+export function getRequiredConfigPaths(text) {
+    const placeholders = extractPlaceholders(text);
+    const paths = new Set();
+    for (const placeholder of placeholders) {
+        if (!placeholder.hasVariant) {
+            paths.add(pathToString(placeholder.path));
+        }
+    }
+    return Array.from(paths);
+}

package/dist/services/shell.js

@@ -0,0 +1,118 @@
+export var ExecutionStatus;
+(function (ExecutionStatus) {
+    ExecutionStatus["Pending"] = "pending";
+    ExecutionStatus["Running"] = "running";
+    ExecutionStatus["Success"] = "success";
+    ExecutionStatus["Failed"] = "failed";
+    ExecutionStatus["Aborted"] = "aborted";
+})(ExecutionStatus || (ExecutionStatus = {}));
+export var ExecutionResult;
+(function (ExecutionResult) {
+    ExecutionResult["Success"] = "success";
+    ExecutionResult["Error"] = "error";
+    ExecutionResult["Aborted"] = "aborted";
+})(ExecutionResult || (ExecutionResult = {}));
+const DEFAULT_DELAY_GENERATOR = (index) => (Math.pow(3, index + 1) * Math.max(Math.random(), Math.random()) + 1) * 1000;
+/**
+ * Dummy executor that simulates command execution with configurable delays.
+ * Supports mocked responses for testing different scenarios.
+ */
+export class DummyExecutor {
+    mockedResponses = new Map();
+    delayGenerator;
+    constructor(delayGenerator = DEFAULT_DELAY_GENERATOR) {
+        this.delayGenerator = delayGenerator;
+    }
+    /**
+     * Set a mocked response for a specific command
+     */
+    mock(command, response) {
+        this.mockedResponses.set(command, response);
+    }
+    /**
+     * Clear all mocked responses
+     */
+    clearMocks() {
+        this.mockedResponses.clear();
+    }
+    execute(cmd, onProgress, index = 0) {
+        return new Promise((resolve) => {
+            onProgress?.(ExecutionStatus.Running);
+            const delay = this.delayGenerator(index);
+            setTimeout(() => {
+                const mocked = this.mockedResponses.get(cmd.command);
+                const commandResult = {
+                    description: cmd.description,
+                    command: cmd.command,
+                    output: mocked?.output ?? '',
+                    errors: mocked?.errors ?? '',
+                    result: mocked?.result ?? ExecutionResult.Success,
+                    error: mocked?.error,
+                };
+                onProgress?.(commandResult.result === ExecutionResult.Success
+                    ? ExecutionStatus.Success
+                    : ExecutionStatus.Failed);
+                resolve(commandResult);
+            }, delay);
+        });
+    }
+}
+/**
+ * Default executor uses DummyExecutor for development and testing.
+ * To implement real shell execution, create a RealExecutor class that:
+ * - Spawns process with cmd.command in shell mode using child_process.spawn()
+ * - Sets working directory from cmd.workdir
+ * - Handles cmd.timeout for command timeout
+ * - Captures stdout and stderr streams
+ * - Calls onProgress with Running/Success/Failed status
+ * - Returns CommandOutput with actual stdout, stderr, exitCode
+ * - Handles errors (spawn failures, timeouts, non-zero exit codes)
+ */
+const executor = new DummyExecutor();
+/**
+ * Execute a single shell command
+ */
+export function executeCommand(cmd, onProgress, index = 0) {
+    return executor.execute(cmd, onProgress, index);
+}
+/**
+ * Execute multiple commands sequentially
+ */
+export async function executeCommands(commands, onProgress) {
+    const results = [];
+    for (let i = 0; i < commands.length; i++) {
+        const cmd = commands[i];
+        onProgress?.({
+            currentIndex: i,
+            total: commands.length,
+            command: cmd,
+            status: ExecutionStatus.Running,
+        });
+        const output = await executeCommand(cmd, (status) => {
+            onProgress?.({
+                currentIndex: i,
+                total: commands.length,
+                command: cmd,
+                status,
+                output: status !== ExecutionStatus.Running ? results[i] : undefined,
+            });
+        }, i);
+        results.push(output);
+        // Update with final status
+        onProgress?.({
+            currentIndex: i,
+            total: commands.length,
+            command: cmd,
+            status: output.result === ExecutionResult.Success
+                ? ExecutionStatus.Success
+                : ExecutionStatus.Failed,
+            output,
+        });
+        // Stop if critical command failed
+        const isCritical = cmd.critical !== false;
+        if (output.result !== ExecutionResult.Success && isCritical) {
+            break;
+        }
+    }
+    return results;
+}

package/dist/services/skill-expander.js

@@ -0,0 +1,91 @@
+/**
+ * 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;
+        }
+        if (!skill.execution || skill.execution.length === 0) {
+            // Referenced skill has no execution, skip
+            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 && skill.execution) {
+            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/skill-parser.js

@@ -0,0 +1,169 @@
+import YAML from 'yaml';
+/**
+ * Parse a skill markdown file into structured definition
+ */
+export function parseSkillMarkdown(content) {
+    const sections = extractSections(content);
+    // Name is required
+    if (!sections.name) {
+        return null;
+    }
+    // Description is required
+    if (!sections.description) {
+        return null;
+    }
+    // Steps are required
+    if (!sections.steps || sections.steps.length === 0) {
+        return null;
+    }
+    // Validate execution and steps have same count (if execution exists)
+    if (sections.execution &&
+        sections.execution.length !== sections.steps.length) {
+        return null;
+    }
+    const skill = {
+        name: sections.name,
+        description: sections.description,
+        steps: sections.steps,
+    };
+    if (sections.aliases && sections.aliases.length > 0) {
+        skill.aliases = sections.aliases;
+    }
+    if (sections.config) {
+        skill.config = sections.config;
+    }
+    if (sections.execution && sections.execution.length > 0) {
+        skill.execution = sections.execution;
+    }
+    return skill;
+}
+/**
+ * Extract sections from markdown content
+ */
+function extractSections(content) {
+    const lines = content.split('\n');
+    const sections = {};
+    let currentSection = null;
+    let sectionLines = [];
+    for (const line of lines) {
+        // Check for section headers (### SectionName)
+        const headerMatch = line.match(/^###\s+(.+)$/);
+        if (headerMatch) {
+            // Process previous section
+            if (currentSection) {
+                processSectionContent(currentSection, sectionLines, sections);
+            }
+            // Start new section
+            currentSection = headerMatch[1].trim().toLowerCase();
+            sectionLines = [];
+        }
+        else if (currentSection) {
+            // Accumulate lines for current section
+            sectionLines.push(line);
+        }
+    }
+    // Process final section
+    if (currentSection) {
+        processSectionContent(currentSection, sectionLines, sections);
+    }
+    return sections;
+}
+/**
+ * Process accumulated section content
+ */
+function processSectionContent(sectionName, lines, sections) {
+    const content = lines.join('\n').trim();
+    if (!content) {
+        return;
+    }
+    switch (sectionName) {
+        case 'name':
+            sections.name = content;
+            break;
+        case 'description':
+            sections.description = content;
+            break;
+        case 'aliases':
+            sections.aliases = extractBulletList(content);
+            break;
+        case 'config':
+            sections.config = parseConfigSchema(content);
+            break;
+        case 'steps':
+            sections.steps = extractBulletList(content);
+            break;
+        case 'execution':
+            sections.execution = extractBulletList(content);
+            break;
+    }
+}
+/**
+ * Extract bullet list items from content
+ */
+function extractBulletList(content) {
+    const lines = content.split('\n');
+    const items = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Match bullet points: "- text" or "* text"
+        const bulletMatch = trimmed.match(/^[-*]\s+(.+)$/);
+        if (bulletMatch) {
+            items.push(bulletMatch[1].trim());
+        }
+    }
+    return items;
+}
+/**
+ * Parse YAML config schema
+ */
+function parseConfigSchema(content) {
+    try {
+        const parsed = YAML.parse(content);
+        if (!parsed || typeof parsed !== 'object') {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Generate all config paths from schema
+ */
+export function generateConfigPaths(schema, prefix = '') {
+    const paths = [];
+    for (const [key, value] of Object.entries(schema)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        if (typeof value === 'string') {
+            // Leaf node with type annotation
+            paths.push(fullKey);
+        }
+        else if (typeof value === 'object') {
+            // Nested object - recurse
+            paths.push(...generateConfigPaths(value, fullKey));
+        }
+    }
+    return paths;
+}
+/**
+ * Get config type for a specific path
+ */
+export function getConfigType(schema, path) {
+    const parts = path.split('.');
+    let current = schema;
+    for (const part of parts) {
+        if (typeof current === 'string') {
+            return undefined;
+        }
+        if (typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[part];
+    }
+    if (typeof current === 'string' &&
+        (current === 'string' || current === 'boolean' || current === 'number')) {
+        return current;
+    }
+    return undefined;
+}