prompt-language-shell 0.4.0 → 0.4.2

package/dist/config/INTROSPECT.md

@@ -59,13 +59,13 @@ Present capabilities in two categories:
 
 These are the core operations available to all users:
 
-- **CONFIG**: Configuration changes, settings updates
-- **PLAN**: Plan and structure tasks from natural language requests, breaking
+- **Config**: Configuration changes, settings updates
+- **Plan**: Plan and structure tasks from natural language requests, breaking
   them down into clear, actionable steps
-- **INTROSPECT**: List and describe available capabilities and skills
-- **ANSWER**: Answer questions, explain concepts, provide information
-- **EXECUTE**: Run shell commands, execute programs, process operations
-- **REPORT**: Generate summaries, create reports, display results
+- **Introspect**: List and describe available capabilities and skills
+- **Answer**: Answer questions, explain concepts, provide information
+- **Execute**: Run shell commands, execute programs, process operations
+- **Report**: Generate summaries, create reports, display results
 
 ### 2. User-Defined Skills
 
@@ -82,15 +82,20 @@ in the response. For each skill:
 Create tasks with type "introspect" for each capability. Each task should:
 
 - **Action**: The capability name and a concise description
-  - Format: "CAPABILITY: Description"
+  - Format: "Capability Name: description" (note: display format will use " - " separator)
+  - **IMPORTANT**: Use title case for capability names (e.g., "Plan", "Execute"), NOT all uppercase (NOT "PLAN", "EXECUTE")
   - Examples:
-    - "PLAN: Break down requests into actionable steps"
-    - "EXECUTE: Run shell commands and process operations"
-    - "Deploy Application: Build and deploy to staging or production"
+    - "Plan: break down requests into actionable steps"
+    - "Execute: run shell commands and process operations"
+    - "Deploy Application: build and deploy to staging or production"
 - **Type**: Always use "introspect"
 - **Params**: Omit params field
 
-**Keep action descriptions concise, at most 64 characters.**
+**Keep action descriptions concise:**
+- Maximum 60 characters for the description portion (after the colon)
+- Focus on clarity and brevity
+- Describe the core purpose in one short phrase
+- Start descriptions with a lowercase letter (they follow a colon)
 
 ## Filtering
 
@@ -111,8 +116,8 @@ Examples:
 ### Example 1: List All Capabilities
 
 When user asks "list your skills", create an introductory message like "here
-are my capabilities:" followed by a task for each built-in capability: PLAN,
-INTROSPECT, ANSWER, EXECUTE, REPORT, and CONFIG. Each task uses type
+are my capabilities:" followed by a task for each built-in capability: Plan,
+Introspect, Answer, Execute, Report, and Config. Each task uses type
 "introspect" with an action describing the capability.
 
 ### Example 2: Filtered Skills

package/dist/config/PLAN.md

@@ -237,7 +237,7 @@ Examples that should be aborted as offensive:
    capabilities or skills:
    - Verbs: "list skills", "show skills", "what can you do", "list
      capabilities", "show capabilities", "what skills", "describe skills",
-     "flex", "show off"
+     "introspect", "flex", "show off"
    - **Filtering**: If the request specifies a category, domain, or context
      (e.g., "for deployment", "related to files", "about testing"), add a
      params object with a filter field containing the specified context

package/dist/services/components.js

@@ -125,6 +125,33 @@ export function createConfirmDefinition(onConfirmed, onCancelled) {
         },
     };
 }
+export function createIntrospectDefinition(tasks, service, onError, onComplete, onAborted) {
+    return {
+        id: randomUUID(),
+        name: ComponentName.Introspect,
+        state: {
+            done: false,
+            isLoading: true,
+        },
+        props: {
+            tasks,
+            service,
+            onError,
+            onComplete,
+            onAborted,
+        },
+    };
+}
+export function createReportDefinition(message, capabilities) {
+    return {
+        id: randomUUID(),
+        name: ComponentName.Report,
+        props: {
+            message,
+            capabilities,
+        },
+    };
+}
 export function isStateless(component) {
     return !('state' in component);
 }

package/dist/types/types.js

@@ -8,6 +8,8 @@ export var ComponentName;
     ComponentName["Refinement"] = "refinement";
     ComponentName["Feedback"] = "feedback";
     ComponentName["Confirm"] = "confirm";
+    ComponentName["Introspect"] = "introspect";
+    ComponentName["Report"] = "report";
 })(ComponentName || (ComponentName = {}));
 export var TaskType;
 (function (TaskType) {

package/dist/ui/Component.js

@@ -5,9 +5,11 @@ import { Command } from './Command.js';
 import { Confirm } from './Confirm.js';
 import { Config } from './Config.js';
 import { Feedback } from './Feedback.js';
+import { Introspect } from './Introspect.js';
 import { Message } from './Message.js';
 import { Plan } from './Plan.js';
 import { Refinement } from './Refinement.js';
+import { Report } from './Report.js';
 import { Welcome } from './Welcome.js';
 export const Component = React.memo(function Component({ def, debug, }) {
     switch (def.name) {
@@ -39,5 +41,12 @@ export const Component = React.memo(function Component({ def, debug, }) {
             const state = def.state;
             return _jsx(Confirm, { ...props, state: state });
         }
+        case ComponentName.Introspect: {
+            const props = def.props;
+            const state = def.state;
+            return _jsx(Introspect, { ...props, state: state });
+        }
+        case ComponentName.Report:
+            return _jsx(Report, { ...def.props });
     }
 });

package/dist/ui/Introspect.js

@@ -0,0 +1,98 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { Spinner } from './Spinner.js';
+const MIN_PROCESSING_TIME = 1000;
+const BUILT_IN_CAPABILITIES = new Set([
+    'CONFIG',
+    'PLAN',
+    'INTROSPECT',
+    'ANSWER',
+    'EXECUTE',
+    'REPORT',
+]);
+function parseCapabilityFromTask(task) {
+    // Parse "NAME: Description" format from task.action
+    const colonIndex = task.action.indexOf(':');
+    if (colonIndex === -1) {
+        return {
+            name: task.action,
+            description: '',
+            isBuiltIn: BUILT_IN_CAPABILITIES.has(task.action.toUpperCase()),
+        };
+    }
+    const name = task.action.substring(0, colonIndex).trim();
+    const description = task.action.substring(colonIndex + 1).trim();
+    const isBuiltIn = BUILT_IN_CAPABILITIES.has(name.toUpperCase());
+    return {
+        name,
+        description,
+        isBuiltIn,
+    };
+}
+export function Introspect({ tasks, state, service, children, onError, onComplete, onAborted, }) {
+    const done = state?.done ?? false;
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(state?.isLoading ?? !done);
+    useInput((input, key) => {
+        if (key.escape && isLoading && !done) {
+            setIsLoading(false);
+            onAborted();
+        }
+    }, { isActive: isLoading && !done });
+    useEffect(() => {
+        // Skip processing if done
+        if (done) {
+            return;
+        }
+        // Skip processing if no service available
+        if (!service) {
+            setError('No service available');
+            setIsLoading(false);
+            return;
+        }
+        let mounted = true;
+        async function process(svc) {
+            const startTime = Date.now();
+            try {
+                // Get the introspect task action (first task should have the intro message)
+                const introspectAction = tasks[0]?.action || 'list capabilities';
+                // Call introspect tool
+                const result = await svc.processWithTool(introspectAction, 'introspect');
+                const elapsed = Date.now() - startTime;
+                const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
+                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                if (mounted) {
+                    // Parse capabilities from returned tasks
+                    const capabilities = result.tasks.map(parseCapabilityFromTask);
+                    setIsLoading(false);
+                    onComplete?.(result.message, capabilities);
+                }
+            }
+            catch (err) {
+                const elapsed = Date.now() - startTime;
+                const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
+                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                if (mounted) {
+                    const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+                    setIsLoading(false);
+                    if (onError) {
+                        onError(errorMessage);
+                    }
+                    else {
+                        setError(errorMessage);
+                    }
+                }
+            }
+        }
+        process(service);
+        return () => {
+            mounted = false;
+        };
+    }, [tasks, done, service]);
+    // Don't render wrapper when done and nothing to show
+    if (!isLoading && !error && !children) {
+        return null;
+    }
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { children: [_jsx(Text, { children: "Listing capabilities. " }), _jsx(Spinner, {})] })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) })), children] }));
+}

package/dist/ui/Main.js

@@ -5,7 +5,7 @@ import { ComponentName, FeedbackType, TaskType, } from '../types/types.js';
 import { createAnthropicService, } from '../services/anthropic.js';
 import { getConfigurationRequiredMessage, hasValidAnthropicKey, loadConfig, loadDebugSetting, saveAnthropicConfig, saveDebugSetting, } from '../services/config.js';
 import { FeedbackMessages, getCancellationMessage, getRefiningMessage, } from '../services/messages.js';
-import { createCommandDefinition, createConfirmDefinition, createConfigDefinition, createFeedback, createMessage, createRefinement, createPlanDefinition, createWelcomeDefinition, isStateless, markAsDone, } from '../services/components.js';
+import { createCommandDefinition, createConfirmDefinition, createConfigDefinition, createFeedback, createIntrospectDefinition, createMessage, createPlanDefinition, createRefinement, createReportDefinition, createWelcomeDefinition, isStateless, markAsDone, } from '../services/components.js';
 import { exitApp } from '../services/process.js';
 import { Column } from './Column.js';
 export const Main = ({ app, command }) => {
@@ -95,18 +95,82 @@ export const Main = ({ app, command }) => {
     const handleRefinementAborted = React.useCallback(() => {
         handleAborted('Plan refinement');
     }, [handleAborted]);
+    const handleIntrospectAborted = React.useCallback(() => {
+        handleAborted('Introspection');
+    }, [handleAborted]);
+    const handleIntrospectError = React.useCallback((error) => {
+        setQueue((currentQueue) => {
+            if (currentQueue.length === 0)
+                return currentQueue;
+            const [first] = currentQueue;
+            if (first.name === ComponentName.Introspect) {
+                addToTimeline(markAsDone(first), createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, error));
+            }
+            exitApp(1);
+            return [];
+        });
+    }, [addToTimeline]);
+    const handleIntrospectComplete = React.useCallback((message, capabilities) => {
+        setQueue((currentQueue) => {
+            if (currentQueue.length === 0)
+                return currentQueue;
+            const [first] = currentQueue;
+            if (first.name === ComponentName.Introspect) {
+                // Don't add the Introspect component to timeline (it renders null)
+                // Only add the Report component
+                addToTimeline(createReportDefinition(message, capabilities));
+            }
+            exitApp(0);
+            return [];
+        });
+    }, [addToTimeline]);
     const handleExecutionConfirmed = React.useCallback(() => {
         setQueue((currentQueue) => {
             if (currentQueue.length === 0)
                 return currentQueue;
             const [first] = currentQueue;
             if (first.name === ComponentName.Confirm) {
-                addToTimeline(markAsDone(first));
+                // Find the most recent Plan in timeline to get tasks
+                const currentTimeline = timelineRef.current;
+                const lastPlanIndex = [...currentTimeline]
+                    .reverse()
+                    .findIndex((item) => item.name === ComponentName.Plan);
+                const lastPlan = lastPlanIndex >= 0
+                    ? currentTimeline[currentTimeline.length - 1 - lastPlanIndex]
+                    : null;
+                const tasks = lastPlan &&
+                    lastPlan.name === ComponentName.Plan &&
+                    'props' in lastPlan &&
+                    lastPlan.props &&
+                    'tasks' in lastPlan.props &&
+                    Array.isArray(lastPlan.props.tasks)
+                    ? lastPlan.props.tasks
+                    : [];
+                const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
+                if (allIntrospect && tasks.length > 0) {
+                    // Execute introspection
+                    addToTimeline(markAsDone(first));
+                    return [
+                        createIntrospectDefinition(tasks, service, handleIntrospectError, handleIntrospectComplete, handleIntrospectAborted),
+                    ];
+                }
+                else {
+                    // Regular execution - just exit for now
+                    addToTimeline(markAsDone(first));
+                    exitApp(0);
+                    return [];
+                }
             }
             exitApp(0);
             return [];
         });
-    }, [addToTimeline]);
+    }, [
+        addToTimeline,
+        service,
+        handleIntrospectError,
+        handleIntrospectComplete,
+        handleIntrospectAborted,
+    ]);
     const handleExecutionCancelled = React.useCallback(() => {
         setQueue((currentQueue) => {
             if (currentQueue.length === 0)

package/dist/ui/Report.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+const COLORS = {
+    BuiltIn: '#5c9ccc', // blue - for built-in capabilities
+    UserDefined: '#5aaa8a', // green - for user-defined skills
+};
+function CapabilityItem({ name, description, isBuiltIn }) {
+    const color = isBuiltIn ? COLORS.BuiltIn : COLORS.UserDefined;
+    return (_jsxs(Box, { children: [_jsx(Text, { children: "- " }), _jsx(Text, { color: color, children: name }), _jsxs(Text, { children: [" - ", description] })] }));
+}
+export function Report({ message, capabilities }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: message }), _jsx(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: capabilities.map((capability, index) => (_jsx(CapabilityItem, { name: capability.name, description: capability.description, isBuiltIn: capability.isBuiltIn }, index))) })] }));
+}

package/package.json

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