prompt-language-shell 0.1.2 → 0.1.4

package/dist/config/PLAN.md

@@ -15,6 +15,38 @@ preserving the original intent. Apply minimal necessary changes to achieve
 optimal clarity. The refined output will be used to plan and execute real
 operations, so precision and unambiguous language are essential.
 
+## Skills Integration
+
+If skills are provided in the "Available Skills" section below, you MUST
+use them when the user's query matches a skill's domain.
+
+When a query matches a skill:
+1. Recognize the semantic match between the user's request and the skill
+   description
+2. Extract the individual steps from the skill's "Steps" section
+3. Refine each step into clear, professional task descriptions that start
+   with a capital letter like a sentence
+4. Return each step as a separate task in a JSON array
+5. If the user's query includes additional requirements beyond the skill,
+   append those as additional tasks
+6. NEVER replace the skill's detailed steps with a generic restatement of
+   the user's request
+
+Example 1:
+- Skill has steps: "- Navigate to the project directory. - Run the build
+  script - Execute the test suite"
+- User asks: "test the application"
+- Correct output: ["Navigate to the project directory", "Run the build
+  script", "Execute the test suite"]
+- WRONG output: ["test the application"]
+
+Example 2:
+- Skill has steps: "- Navigate to the project directory. - Run the build
+  script - Execute the test suite"
+- User asks: "test the application and generate a report"
+- Correct output: ["Navigate to the project directory", "Run the build
+  script", "Execute the test suite", "Generate a report"]
+
 ## Evaluation of Requests
 
 Before processing any request, evaluate its nature and respond appropriately:
@@ -35,18 +67,41 @@ If the request is too vague or unclear to understand what action should be
 taken, return the exact phrase "abort unclear request".
 
 Before marking a request as unclear, try to infer meaning from:
+- **Available skills**: If a skill is provided that narrows down a domain,
+  use that context to interpret the request. Skills define the scope of what
+  generic terms mean in a specific context. When a user says "all X" or
+  "the Y", check if an available skill defines what X or Y means. For example,
+  if a skill defines specific deployment environments for a project, then
+  "deploy to all environments" should be interpreted within that skill's
+  context, not as a generic unclear request.
 - Common abbreviations and acronyms in technical contexts
 - Well-known product names, tools, or technologies
 - Context clues within the request itself
 - Standard industry terminology
 
-For example:
-- "test GX" → "GX" possibly means Opera GX browser
+For example using skills context:
+- "build all applications" + build skill defining mobile, desktop, and web
+  applications → interpret as those three specific applications
+- "deploy to all environments" + deployment skill defining staging, production,
+  and canary → interpret as those three specific environments
+- "run all test suites" + testing skill listing unit and integration tests →
+  interpret as those two specific test types
+- "build the package" + monorepo skill defining a single backend package →
+  interpret as that one specific package
+- "check all services" + microservices skill listing auth, api, and database
+  services → interpret as those three specific services
+- "run both compilers" + build skill defining TypeScript and Sass compilers →
+  interpret as those two specific compilers
+- "start the server" + infrastructure skill defining a single Node.js server →
+  interpret as that one specific server
+
+For example using common context:
 - "run TS compiler" → "TS" stands for TypeScript
 - "open VSC" → "VSC" likely means Visual Studio Code
+- "run unit tests" → standard development terminology for testing
 
 Only mark as unclear if the request is truly unintelligible or lacks any
-discernible intent.
+discernible intent, even after considering available skills and context.
 
 Examples that are too vague:
 - "do stuff"
@@ -168,7 +223,9 @@ Split into multiple tasks when:
 - Single task: Return ONLY the corrected command text
 - Multiple tasks: Return ONLY a JSON array of strings
 
-Do not include explanations, commentary, or any other text.
+Do not include explanations, commentary, markdown formatting, code blocks, or
+any other text. For JSON arrays, return the raw JSON without ```json``` or
+any other wrapping.
 
 ## Final Validation Before Response
 

package/dist/index.js

@@ -6,8 +6,7 @@ import { dirname, join } from 'path';
 import { render, Text } from 'ink';
 import { loadConfig, ConfigError, configExists, saveConfig, } from './services/config.js';
 import { createAnthropicService } from './services/anthropic.js';
-import { Please } from './ui/Please.js';
-import { ConfigThenCommand } from './ui/ConfigThenCommand.js';
+import { PLS } from './ui/Please.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Get package info
@@ -28,33 +27,26 @@ const appInfo = {
 const args = process.argv.slice(2);
 const rawCommand = args.join(' ').trim();
 async function runApp() {
-    // Check if config exists, if not run setup
+    // First-time setup: config doesn't exist
     if (!configExists()) {
-        if (!rawCommand) {
-            // "pls" for the first time: show welcome box and ask about config below
-            const { waitUntilExit } = render(_jsx(Please, { app: appInfo, showConfigSetup: true, onConfigComplete: ({ apiKey, model }) => {
-                    saveConfig(apiKey, model);
-                } }));
-            await waitUntilExit();
-            return;
-        }
-        else {
-            // "pls do stuff" for the first time: ask about config, then continue
-            render(_jsx(ConfigThenCommand, { command: rawCommand, onConfigSave: saveConfig }));
-            return;
-        }
+        const { waitUntilExit } = render(_jsx(PLS, { app: appInfo, command: rawCommand || null, showConfigSetup: true, onConfigComplete: ({ apiKey, model }) => {
+                saveConfig(apiKey, model);
+                return rawCommand ? createAnthropicService(apiKey, model) : undefined;
+            } }));
+        await waitUntilExit();
+        return;
     }
     // Try to load and validate config
     try {
         const config = loadConfig();
         if (!rawCommand) {
             // "pls" when config present: show welcome box
-            render(_jsx(Please, { app: appInfo }));
+            render(_jsx(PLS, { app: appInfo, command: null }));
         }
         else {
             // "pls do stuff": fetch and show the plan
             const claudeService = createAnthropicService(config.anthropic.apiKey, config.anthropic.model);
-            render(_jsx(Please, { app: appInfo, command: rawCommand, claudeService: claudeService }));
+            render(_jsx(PLS, { app: appInfo, command: rawCommand, claudeService: claudeService }));
         }
     }
     catch (error) {

package/dist/services/anthropic.js

@@ -2,6 +2,7 @@ import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import Anthropic from '@anthropic-ai/sdk';
+import { loadSkills, formatSkillsForPrompt } from './skills.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const PLAN_PROMPT = readFileSync(join(__dirname, '../config/PLAN.md'), 'utf-8');
@@ -13,10 +14,14 @@ export class AnthropicService {
         this.model = model;
     }
     async processCommand(rawCommand) {
+        // Load skills and augment the planning prompt
+        const skills = loadSkills();
+        const skillsSection = formatSkillsForPrompt(skills);
+        const systemPrompt = PLAN_PROMPT + skillsSection;
         const response = await this.client.messages.create({
             model: this.model,
             max_tokens: 200,
-            system: PLAN_PROMPT,
+            system: systemPrompt,
             messages: [
                 {
                     role: 'user',
@@ -29,24 +34,39 @@ export class AnthropicService {
             throw new Error('Unexpected response type from Claude API');
         }
         const text = content.text.trim();
+        let tasks;
         // Try to parse as JSON array
         if (text.startsWith('[') && text.endsWith(']')) {
             try {
                 const parsed = JSON.parse(text);
-                if (Array.isArray(parsed) && parsed.length > 0) {
+                if (Array.isArray(parsed)) {
                     // Validate all items are strings
                     const allStrings = parsed.every((item) => typeof item === 'string');
                     if (allStrings) {
-                        return parsed.filter((item) => typeof item === 'string');
+                        tasks = parsed.filter((item) => typeof item === 'string');
                     }
+                    else {
+                        tasks = [text];
+                    }
+                }
+                else {
+                    tasks = [text];
                 }
             }
             catch {
                 // If JSON parsing fails, treat as single task
+                tasks = [text];
             }
         }
-        // Single task
-        return [text];
+        else {
+            // Single task
+            tasks = [text];
+        }
+        const isDebug = process.env.DEBUG === 'true';
+        return {
+            tasks,
+            systemPrompt: isDebug ? systemPrompt : undefined,
+        };
     }
 }
 export function createAnthropicService(apiKey, model) {

package/dist/services/config.js

@@ -1,10 +1,7 @@
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
+import { join } from 'path';
 import YAML from 'yaml';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
 export class ConfigError extends Error {
     constructor(message) {
         super(message);
@@ -52,17 +49,6 @@ function validateConfig(parsed) {
     if (anthropic.model && typeof anthropic.model === 'string') {
         validatedConfig.anthropic.model = anthropic.model;
     }
-    // Optional UI config
-    if (config.ui && typeof config.ui === 'object') {
-        const ui = config.ui;
-        validatedConfig.ui = {};
-        if (ui.theme && typeof ui.theme === 'string') {
-            validatedConfig.ui.theme = ui.theme;
-        }
-        if (typeof ui.verbose === 'boolean') {
-            validatedConfig.ui.verbose = ui.verbose;
-        }
-    }
     return validatedConfig;
 }
 export function loadConfig() {

package/dist/services/skills.js

@@ -0,0 +1,52 @@
+import { readFileSync, readdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+/**
+ * Get the path to the skills directory
+ */
+export function getSkillsDirectory() {
+    return join(homedir(), '.pls', 'skills');
+}
+/**
+ * Load all skill markdown files from the skills directory
+ * Returns an array of skill file contents
+ */
+export function loadSkills() {
+    const skillsDir = getSkillsDirectory();
+    // Return empty array if directory doesn't exist
+    if (!existsSync(skillsDir)) {
+        return [];
+    }
+    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) => {
+            const filePath = join(skillsDir, file);
+            return readFileSync(filePath, 'utf-8');
+        });
+    }
+    catch (error) {
+        // Return empty array if there's any error reading the directory
+        return [];
+    }
+}
+/**
+ * Format skills for inclusion in the planning prompt
+ */
+export function formatSkillsForPrompt(skills) {
+    if (skills.length === 0) {
+        return '';
+    }
+    const header = `
+
+## Available Skills
+
+The following skills define domain-specific workflows. When the user's
+query matches a skill, incorporate the skill's steps into your plan.
+
+`;
+    const skillsContent = skills.join('\n\n');
+    return header + skillsContent;
+}

package/dist/ui/Command.js

@@ -5,6 +5,7 @@ import { Spinner } from './Spinner.js';
 const MIN_PROCESSING_TIME = 2000; // purelly for visual effect
 export function Command({ rawCommand, claudeService }) {
     const [processedTasks, setProcessedTasks] = useState([]);
+    const [systemPrompt, setSystemPrompt] = useState();
     const [error, setError] = useState(null);
     const [isLoading, setIsLoading] = useState(true);
     useEffect(() => {
@@ -17,7 +18,8 @@ export function Command({ rawCommand, claudeService }) {
                 const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
-                    setProcessedTasks(result);
+                    setProcessedTasks(result.tasks);
+                    setSystemPrompt(result.systemPrompt);
                     setIsLoading(false);
                 }
             }

package/dist/ui/Please.js

@@ -5,12 +5,21 @@ import { Command } from './Command.js';
 import { Welcome } from './Welcome.js';
 import { ConfigSetup } from './ConfigSetup.js';
 import { History } from './History.js';
-export const Please = ({ app: info, command, claudeService, showConfigSetup, onConfigComplete, }) => {
+export const PLS = ({ app: info, command, claudeService, showConfigSetup, onConfigComplete, }) => {
     const [history, setHistory] = React.useState([]);
-    // Simple command execution
-    if (command && claudeService) {
-        return (_jsxs(Box, { marginTop: 1, flexDirection: "column", gap: 1, children: [_jsx(History, { items: history }), _jsx(Command, { rawCommand: command, claudeService: claudeService })] }));
+    const [service, setService] = React.useState(claudeService);
+    const handleConfigComplete = (config) => {
+        if (onConfigComplete) {
+            const result = onConfigComplete(config);
+            if (result) {
+                setService(result);
+            }
+        }
+    };
+    // Command execution (with service from props or after config)
+    if (command && service) {
+        return (_jsxs(Box, { marginTop: 1, flexDirection: "column", gap: 1, children: [_jsx(History, { items: history }), _jsx(Command, { rawCommand: command, claudeService: service })] }));
     }
     // Welcome screen with optional config setup
-    return (_jsxs(Box, { flexDirection: "column", marginY: 1, gap: 1, children: [_jsx(History, { items: history }), _jsx(Welcome, { info: info }), showConfigSetup && onConfigComplete && (_jsx(ConfigSetup, { onComplete: onConfigComplete }))] }));
+    return (_jsxs(Box, { flexDirection: "column", marginY: 1, gap: 1, children: [_jsx(History, { items: history }), !showConfigSetup && _jsx(Welcome, { info: info }), showConfigSetup && _jsx(ConfigSetup, { onComplete: handleConfigComplete })] }));
 };

package/package.json

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