prompt-language-shell 0.6.6 → 0.7.0

package/dist/index.js

@@ -4,6 +4,7 @@ import { existsSync, readFileSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { render } from 'ink';
+import { DebugLevel } from './services/configuration.js';
 import { Main } from './ui/Main.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -20,7 +21,7 @@ const app = {
     version: packageJson.version,
     description: packageJson.description,
     isDev,
-    isDebug: false,
+    debug: DebugLevel.None,
 };
 // Get command from command-line arguments
 const args = process.argv.slice(2);

package/dist/services/anthropic.js

@@ -1,7 +1,8 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { getAvailableConfigStructure, getConfiguredKeys, } from './configuration.js';
+import { logPrompt, logResponse } from './logger.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.
@@ -70,7 +71,7 @@ export class AnthropicService {
         if (toolName === 'config') {
             const configStructure = getAvailableConfigStructure();
             const configuredKeys = getConfiguredKeys();
-            const configSection = '\n\n## Available Configuration\n\n' +
+            const configSection = '\n## Available Configuration\n\n' +
                 'Config structure (key: description):\n' +
                 JSON.stringify(configStructure, null, 2) +
                 '\n\nConfigured keys (keys that exist in config file):\n' +
@@ -85,7 +86,15 @@ export class AnthropicService {
                 name: 'web_search',
             });
         }
+        // Collect debug components
+        const debug = [];
+        // Log prompt at Verbose level
+        const promptDebug = logPrompt(toolName, command, systemPrompt);
+        if (promptDebug) {
+            debug.push(promptDebug);
+        }
         // Call API with tool
+        const startTime = Date.now();
         const response = await this.client.messages.create({
             model: this.model,
             max_tokens: 1024,
@@ -99,6 +108,12 @@ export class AnthropicService {
                 },
             ],
         });
+        const duration = Date.now() - startTime;
+        // Log response at Verbose level
+        const responseDebug = logResponse(toolName, response, duration);
+        if (responseDebug) {
+            debug.push(responseDebug);
+        }
         // Check for truncation
         if (response.stop_reason === 'max_tokens') {
             throw new Error('Response was truncated due to length. Please simplify your request or break it into smaller parts.');
@@ -113,6 +128,7 @@ export class AnthropicService {
                     message: '',
                     tasks: [],
                     answer: cleanAnswerText(textContent.text),
+                    debug,
                 };
             }
         }
@@ -143,6 +159,7 @@ export class AnthropicService {
                 message: input.message,
                 tasks: [],
                 commands: input.commands,
+                debug,
             };
         }
         // Handle answer tool response
@@ -157,6 +174,7 @@ export class AnthropicService {
                 message: '',
                 tasks: [],
                 answer: cleanAnswerText(input.answer),
+                debug,
             };
         }
         // Handle plan and introspect tool responses
@@ -175,6 +193,7 @@ export class AnthropicService {
         return {
             message: input.message,
             tasks: input.tasks,
+            debug,
         };
     }
 }

package/dist/services/components.js

@@ -252,6 +252,17 @@ export function createMessage(text) {
         },
     };
 }
+export function createDebugDefinition(title, content, color) {
+    return {
+        id: randomUUID(),
+        name: ComponentName.Debug,
+        props: {
+            title,
+            content,
+            color,
+        },
+    };
+}
 export function createRefinement(text, onAborted) {
     return {
         id: randomUUID(),

package/dist/services/configuration.js

@@ -9,6 +9,13 @@ export var AnthropicModel;
     AnthropicModel["Opus"] = "claude-opus-4-1";
 })(AnthropicModel || (AnthropicModel = {}));
 export const SUPPORTED_MODELS = Object.values(AnthropicModel);
+export var DebugLevel;
+(function (DebugLevel) {
+    DebugLevel["None"] = "none";
+    DebugLevel["Info"] = "info";
+    DebugLevel["Verbose"] = "verbose";
+})(DebugLevel || (DebugLevel = {}));
+export const SUPPORTED_DEBUG_LEVELS = Object.values(DebugLevel);
 export var ConfigDefinitionType;
 (function (ConfigDefinitionType) {
     ConfigDefinitionType["RegExp"] = "regexp";
@@ -62,8 +69,17 @@ function validateConfig(parsed) {
     if (config.settings && typeof config.settings === 'object') {
         const settings = config.settings;
         validatedConfig.settings = {};
-        if ('debug' in settings && typeof settings.debug === 'boolean') {
-            validatedConfig.settings.debug = settings.debug;
+        if ('debug' in settings) {
+            // Handle migration from boolean to enum
+            if (typeof settings.debug === 'boolean') {
+                validatedConfig.settings.debug = settings.debug
+                    ? DebugLevel.Info
+                    : DebugLevel.None;
+            }
+            else if (typeof settings.debug === 'string' &&
+                SUPPORTED_DEBUG_LEVELS.includes(settings.debug)) {
+                validatedConfig.settings.debug = settings.debug;
+            }
         }
     }
     return validatedConfig;
@@ -139,10 +155,10 @@ export function saveDebugSetting(debug) {
 export function loadDebugSetting() {
     try {
         const config = loadConfig();
-        return config.settings?.debug ?? false;
+        return config.settings?.debug ?? DebugLevel.None;
     }
     catch {
-        return false;
+        return DebugLevel.None;
     }
 }
 /**
@@ -193,8 +209,10 @@ const coreConfigSchema = {
         description: 'Anthropic model',
     },
     'settings.debug': {
-        type: ConfigDefinitionType.Boolean,
+        type: ConfigDefinitionType.Enum,
         required: false,
+        values: SUPPORTED_DEBUG_LEVELS,
+        default: DebugLevel.None,
         description: 'Debug mode',
     },
 };

package/dist/services/logger.js

@@ -0,0 +1,64 @@
+import { createDebugDefinition } from './components.js';
+import { DebugLevel, loadDebugSetting } from './configuration.js';
+import { Palette } from './colors.js';
+/**
+ * Debug logger for the application
+ * Logs information based on the current debug level setting
+ */
+let currentDebugLevel = DebugLevel.None;
+/**
+ * Initialize the logger with the current debug level from config
+ */
+export function initializeLogger() {
+    currentDebugLevel = loadDebugSetting();
+}
+/**
+ * Set the debug level (used for testing or runtime changes)
+ */
+export function setDebugLevel(debug) {
+    currentDebugLevel = debug;
+}
+/**
+ * Get the current debug level
+ */
+export function getDebugLevel() {
+    return currentDebugLevel;
+}
+/**
+ * Create debug component for system prompts sent to the LLM
+ * Only creates at Verbose level
+ */
+export function logPrompt(toolName, command, instructions) {
+    if (currentDebugLevel !== DebugLevel.Verbose) {
+        return null;
+    }
+    const content = [
+        '',
+        `Tool: ${toolName}`,
+        `Command: ${command}`,
+        '',
+        instructions,
+    ].join('\n');
+    // Calculate stats for the instructions
+    const lines = instructions.split('\n').length;
+    const bytes = Buffer.byteLength(instructions, 'utf-8');
+    const title = `SYSTEM PROMPT (${String(lines)} lines, ${String(bytes)} bytes)`;
+    return createDebugDefinition(title, content, Palette.Gray);
+}
+/**
+ * Create debug component for LLM responses received
+ * Only creates at Verbose level
+ */
+export function logResponse(toolName, response, durationMs) {
+    if (currentDebugLevel !== DebugLevel.Verbose) {
+        return null;
+    }
+    const content = [
+        '',
+        `Tool: ${toolName}`,
+        '',
+        JSON.stringify(response, null, 2),
+    ].join('\n');
+    const title = `LLM RESPONSE (${String(durationMs)} ms)`;
+    return createDebugDefinition(title, content, Palette.AshGray);
+}

package/dist/services/messages.js

@@ -1,4 +1,4 @@
-import { loadDebugSetting } from './configuration.js';
+import { DebugLevel, loadDebugSetting } from './configuration.js';
 export { formatDuration } from './utils.js';
 /**
  * Returns a natural language confirmation message for plan execution.
@@ -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.
  */
@@ -81,7 +96,7 @@ export const FeedbackMessages = {
  */
 export function formatErrorMessage(error) {
     const rawMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-    if (loadDebugSetting()) {
+    if (loadDebugSetting() !== DebugLevel.None) {
         return rawMessage;
     }
     // Try to extract message from Anthropic API error format

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
@@ -24,6 +24,10 @@ export async function handleRefinement(selectedTasks, service, originalCommand,
         const refinedResult = await service.processWithTool(refinedCommand, 'plan');
         // Complete the Refinement component
         handlers.completeActive();
+        // Add debug components to timeline if present
+        if (refinedResult.debug && refinedResult.debug.length > 0) {
+            handlers.addToTimeline(...refinedResult.debug);
+        }
         // Route refined tasks to appropriate components
         routeTasksWithConfirm(refinedResult.tasks, refinedResult.message, service, originalCommand, handlers, false // No DEFINE tasks in refined result
         );

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);
         }
     }
 }