@stan-chen/simple-cli 0.2.3 → 0.2.5

package/dist/skills.js

@@ -1,229 +1,87 @@
-/**
- * Skills/Presets System
- * Based on OpenHands skills and Aider prompts
- * Provides specialized behavior presets for different tasks
- */
-import { readFile, writeFile, readdir } from 'fs/promises';
+import { readFile, readdir, writeFile } from 'fs/promises';
+import { join, basename, extname } from 'path';
 import { existsSync } from 'fs';
-import { join } from 'path';
-// Built-in skills
 export const builtinSkills = {
-    // Code editing skill (default)
     code: {
         name: 'code',
-        description: 'General coding assistant with file editing and custom skill creation capabilities',
-        systemPrompt: `You are a coding assistant. You help users write, modify, and debug code.
-
-## Custom Skills (Self-Evolution)
-You can create your own specialized tools in \`skills/\`, \`scripts/\`, or \`tools/\`:
-1. **TypeScript/JS**: Standard native exports.
-2. **Scripts & Binaries**: 
-   - Write any script (Python, Bash, PowerShell, etc.) or binary.
-   - **Documentation**: Provide a matching \`.md\` or \`.txt\` file (e.g., \`tool.py\` + \`tool.md\`).
-   - **Internal Documentation**: Alternatively, put Markdown in a comment block at the very top of your script.
-   
-3. **AI Attribution**: All self-created tools MUST include a marker as the first line:
-   - **Scripts**: A comment e.g. \`# [Simple-CLI AI-Created]\` or \`// [Simple-CLI AI-Created]\`.
-   - **Documentation**: A hidden comment e.g. \`<!-- [Simple-CLI AI-Created] -->\`.
-
-**Markdown Specification Example**:
-\`\`\`markdown
-<!-- [Simple-CLI AI-Created] -->
-# toolName
-Brief description.
-
-## Command
-python scripts/tool.py
-\`\`\`
-Inputs are passed via **stdin** (JSON) and the \`TOOL_INPUT\` env var.
-After creating/modifying, call \`reloadTools\`.
-
-4. **Self-Orchestration**: If a project lacks clear success criteria (missing \`.agent/\` or \`.simple/\` directories), you should take the initiative to create them. Use these folders to store implementation plans, SPEC/PRDs, and validation tests.
-
-When making changes to files:
-1. Read the file first to understand the context
-2. Make precise, targeted changes using search/replace
-3. Verify changes don't break existing functionality
-4. Follow the existing code style`,
-        tools: ['read_files', 'write_files', 'run_command', 'glob', 'grep', 'lint', 'reload_tools', 'scheduler'],
-    },
-    // Architect skill for planning
-    architect: {
-        name: 'architect',
-        description: 'Design and planning mode - focuses on architecture decisions',
-        systemPrompt: `You are a software architect assistant. Your role is to:
-
-1. Help design system architecture
-2. Make technology decisions
-3. Plan implementation strategies
-4. Review and improve existing designs
-
-When working on architecture:
-- Ask clarifying questions about requirements
-- Consider scalability, maintainability, and security
-- Provide multiple options when appropriate
-- Document decisions and trade-offs
-
-Focus on high-level design rather than implementation details.
-Generate diagrams and documentation when helpful.`,
-        tools: ['read_files', 'glob', 'grep', 'memory'],
-        modelPreference: 'orchestrator',
-    },
-    // Ask skill for questions only
-    ask: {
-        name: 'ask',
-        description: 'Question-answering mode - no file modifications',
-        systemPrompt: `You are a helpful coding assistant in read-only mode.
-
-You can:
-- Answer questions about the codebase
-- Explain how code works
-- Suggest improvements
-- Help with debugging
-
-You should NOT:
-- Modify any files
-- Run commands that change state
-- Create new files
-
-Always read files before answering questions about them.`,
-        tools: ['read_files', 'glob', 'grep'],
-    },
-    // Help/docs skill
-    help: {
-        name: 'help',
-        description: 'Help and documentation assistant',
-        systemPrompt: `You are a documentation assistant. Help users understand:
-
-- How to use this CLI tool
-- Programming concepts and patterns
-- Best practices and conventions
-- Error messages and debugging
-
-Be concise and provide examples when helpful.
-Reference official documentation when available.`,
-        tools: ['read_files', 'scrape_url'],
-    },
-    // Test skill
-    test: {
-        name: 'test',
-        description: 'Test writing and debugging assistant',
-        systemPrompt: `You are a test engineering assistant. Your focus is:
-
-1. Writing comprehensive tests
-2. Debugging failing tests
-3. Improving test coverage
-4. Setting up test infrastructure
-
-Test guidelines:
-- Follow the project's existing test patterns
-- Cover edge cases and error conditions
-- Write clear test descriptions
-- Use appropriate mocking when needed
-
-After writing tests, run them to verify they pass.`,
-        tools: ['read_files', 'write_files', 'run_command', 'glob', 'grep', 'lint', 'scheduler'],
-    },
-    // Debug skill
-    debug: {
-        name: 'debug',
-        description: 'Debugging assistant for troubleshooting issues',
-        systemPrompt: `You are a debugging assistant. Your process:
-
-1. Understand the error or unexpected behavior
-2. Reproduce the issue if possible
-3. Analyze logs, stack traces, and code
-4. Form hypotheses about the cause
-5. Test fixes incrementally
-
-Debugging tips:
-- Add logging to understand program flow
-- Check recent changes that might have caused the issue
-- Look for common patterns (null checks, async issues, etc.)
-- Use the linter to catch syntax errors`,
-        tools: ['read_files', 'write_files', 'run_command', 'grep', 'lint', 'git', 'scheduler'],
-    },
-    // Refactor skill
-    refactor: {
-        name: 'refactor',
-        description: 'Code refactoring with safety focus',
-        systemPrompt: `You are a refactoring assistant. Your approach:
-
-1. Understand the current implementation
-2. Identify areas for improvement
-3. Make incremental, safe changes
-4. Verify behavior is preserved
-
-Refactoring principles:
-- Small, focused changes
-- Maintain existing tests
-- Improve readability and maintainability
-- Reduce duplication
-- Follow SOLID principles
-
-Always run tests after refactoring to ensure nothing broke.`,
-        tools: ['read_files', 'write_files', 'run_command', 'glob', 'grep', 'lint', 'git', 'scheduler'],
-    },
-    // Review skill
-    review: {
-        name: 'review',
-        description: 'Code review assistant',
-        systemPrompt: `You are a code reviewer. Review code for:
-
-1. Correctness - Does it work as intended?
-2. Security - Are there vulnerabilities?
-3. Performance - Are there inefficiencies?
-4. Style - Does it follow conventions?
-5. Maintainability - Is it easy to understand?
-
-Provide constructive feedback with specific suggestions.
-Prioritize critical issues over minor style concerns.`,
-        tools: ['read_files', 'glob', 'grep', 'git', 'lint'],
-    },
-    // Shell skill
-    shell: {
-        name: 'shell',
-        description: 'Shell/command-line assistant',
-        systemPrompt: `You are a shell/command-line assistant. Help with:
-
-- Writing shell scripts
-- Running and debugging commands
-- System administration tasks
-- Build and deployment scripts
-
-Safety guidelines:
-- Explain what commands do before running
-- Use safe defaults (no force flags unless needed)
-- Be careful with destructive operations
-- Test commands before applying to production`,
-        tools: ['run_command', 'read_files', 'write_files', 'glob'],
-    },
-    // Git skill
-    git: {
-        name: 'git',
-        description: 'Git version control assistant',
-        systemPrompt: `You are a Git assistant. Help with:
-
-- Understanding git history and changes
-- Creating meaningful commits
-- Managing branches
-- Resolving merge conflicts
-- Best practices for version control
-
-Git guidelines:
-- Write clear, descriptive commit messages
-- Make small, focused commits
-- Keep branches up to date
-- Review changes before committing`,
-        tools: ['git', 'read_files', 'glob', 'grep'],
-    },
+        description: 'A helpful coding assistant.',
+        systemPrompt: `You are a helpful coding assistant. Use tools to solve tasks.
+You must output your response in JSON format.
+The JSON should have the following structure:
+{
+  "thought": "Your reasoning here",
+  "tool": "tool_name",
+  "args": { "arg_name": "value" }
+}
+If you don't need to use a tool, use "tool": "none" and provide a "message".
+{
+  "thought": "Reasoning",
+  "tool": "none",
+  "message": "Response to user"
+}
+Important:
+- If a task requires multiple steps, perform them one by one.
+- Do not ask for confirmation if you have enough information to proceed.
+- When writing to files that might exist (like logs), read them first and append to them if necessary, unless instructed to overwrite.
+`
+    }
 };
-// Get active skill from environment or default
-export function getActiveSkill() {
-    const skillName = process.env.SIMPLE_CLI_SKILL || 'code';
-    return builtinSkills[skillName] || builtinSkills.code;
+export async function loadSkillFromFile(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        const content = await readFile(path, 'utf-8');
+        const ext = extname(path).toLowerCase();
+        if (ext === '.json') {
+            const skill = JSON.parse(content);
+            if (!skill.name || !skill.systemPrompt)
+                return null;
+            return skill;
+        }
+        else if (ext === '.md') {
+            // Parse markdown:
+            // Title (# Title) -> Name
+            // Content -> System Prompt
+            let name = basename(path, '.md');
+            const titleMatch = content.match(/^#\s+(.+)$/m);
+            if (titleMatch) {
+                name = titleMatch[1].trim();
+            }
+            return {
+                name,
+                description: `Loaded from ${basename(path)}`,
+                systemPrompt: content
+            };
+        }
+    }
+    catch (e) {
+        return null;
+    }
+    return null;
+}
+export async function getActiveSkill(cwd = process.cwd()) {
+    // 1. Env var
+    if (process.env.SIMPLE_CLI_SKILL) {
+        if (builtinSkills[process.env.SIMPLE_CLI_SKILL]) {
+            return builtinSkills[process.env.SIMPLE_CLI_SKILL];
+        }
+    }
+    // 2. Project config (.agent/AGENT.md or .agent/SOUL.md)
+    const agentMd = join(cwd, '.agent', 'AGENT.md');
+    if (existsSync(agentMd)) {
+        const skill = await loadSkillFromFile(agentMd);
+        if (skill)
+            return skill;
+    }
+    const soulMd = join(cwd, '.agent', 'SOUL.md');
+    if (existsSync(soulMd)) {
+        const skill = await loadSkillFromFile(soulMd);
+        if (skill)
+            return skill;
+    }
+    // 3. Default
+    return builtinSkills.code;
 }
-// Set active skill
 export function setActiveSkill(name) {
     if (builtinSkills[name]) {
         process.env.SIMPLE_CLI_SKILL = name;
@@ -231,58 +89,38 @@ export function setActiveSkill(name) {
     }
     return undefined;
 }
-// List available skills
 export function listSkills() {
     return Object.values(builtinSkills);
 }
-// Load custom skill from file
-export async function loadSkillFromFile(path) {
-    try {
-        const content = await readFile(path, 'utf-8');
-        const skill = JSON.parse(content);
-        if (!skill.name || !skill.systemPrompt) {
-            return null;
-        }
-        return skill;
-    }
-    catch {
-        return null;
-    }
-}
-// Save custom skill to file
-export async function saveSkillToFile(skill, path) {
-    await writeFile(path, JSON.stringify(skill, null, 2));
-}
-// Load all custom skills from a directory
 export async function loadCustomSkills(dir) {
     const skills = {};
-    if (!existsSync(dir)) {
+    if (!existsSync(dir))
         return skills;
-    }
     try {
-        const files = await readdir(dir);
-        for (const file of files) {
-            if (file.endsWith('.json')) {
-                const skill = await loadSkillFromFile(join(dir, file));
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile()) {
+                const path = join(dir, entry.name);
+                const skill = await loadSkillFromFile(path);
                 if (skill) {
                     skills[skill.name] = skill;
                 }
             }
         }
     }
-    catch {
-        // Ignore errors
-    }
+    catch { }
     return skills;
 }
-// Get skill system prompt with context
 export function buildSkillPrompt(skill, context) {
     let prompt = skill.systemPrompt;
-    if (context?.files?.length) {
-        prompt += `\n\n## Active Files\nYou are working with these files:\n${context.files.join('\n')}`;
-    }
     if (context?.repoMap) {
         prompt += `\n\n## Repository Structure\n${context.repoMap}`;
     }
+    if (context?.files && context.files.length > 0) {
+        prompt += `\n\n## Active Files\n${context.files.join('\n')}`;
+    }
     return prompt;
 }
+export async function saveSkillToFile(skill, path) {
+    await writeFile(path, JSON.stringify(skill, null, 2));
+}

package/dist/tui.d.ts

@@ -0,0 +1 @@
+export declare function showBanner(): void;

package/dist/tui.js

@@ -0,0 +1,15 @@
+import pc from 'picocolors';
+import fs from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(fs.readFileSync(join(__dirname, '../package.json'), 'utf8'));
+export function showBanner() {
+    const cat = `
+      /\\_/\\
+     ( o.o )
+      > ^ <
+    `;
+    console.log(pc.magenta(cat));
+    console.log(` ${pc.bgMagenta(pc.black(' SIMPLE-CLI '))} ${pc.dim(`v${pkg.version}`)}\n`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stan-chen/simple-cli",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "A lean, lightweight coding agent. Packs a punch with token efficiency.",
   "type": "module",
   "main": "dist/cli.js",
@@ -9,8 +9,8 @@
   },
   "scripts": {
     "start": "node --loader ts-node/esm src/cli.ts",
-    "dev": "node --loader ts-node/esm --watch src/index.ts",
-    "build": "tsc",
+    "dev": "node --loader ts-node/esm --watch src/cli.ts",
+    "build": "tsc && node -e \"require('fs').copyFileSync('src/anyllm.py', 'dist/anyllm.py')\"",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -42,13 +42,17 @@
     "@clack/prompts": "^0.7.0",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "@oclif/core": "^4.0.0",
-    "@stan-chen/typellm": "^0.1.2",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
     "@types/node-fetch": "^2.6.13",
     "ai": "^6.0.67",
+    "body-parser": "^1.20.4",
     "chalk": "^5.3.0",
     "chokidar": "^5.0.0",
+    "cors": "^2.8.6",
     "diff": "^5.2.0",
     "dotenv": "^16.4.7",
+    "express": "^4.22.1",
     "fast-glob": "^3.3.2",
     "fast-levenshtein": "^3.0.0",
     "glob": "^13.0.0",
@@ -79,6 +83,6 @@
   "files": [
     "dist",
     "README.md",
-    "docs/assets/logo.jpeg"
+    "assets/logo.jpeg"
   ]
-}
+}

package/dist/claw/jit.d.ts

@@ -1,5 +0,0 @@
-/**
- * JIT Agent Generation: Task-specific personas
- * Reuse the central provider system - don't reinvent the wheel!
- */
-export declare function generateJitAgent(intent: string, targetDir: string): Promise<void>;

package/dist/claw/jit.js

@@ -1,138 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import pc from 'picocolors';
-import { createProvider } from '../providers/index.js';
-import { runDeterministicOrganizer } from '../tools/organizer.js';
-/**
- * JIT Agent Generation: Task-specific personas
- * Reuse the central provider system - don't reinvent the wheel!
- */
-export async function generateJitAgent(intent, targetDir) {
-    const memoryDir = path.join(targetDir, '.simple', 'workdir', 'memory');
-    const agentFile = path.join(targetDir, '.simple', 'workdir', 'AGENT.md');
-    // Ensure state directories exist
-    if (!fs.existsSync(memoryDir)) {
-        fs.mkdirSync(path.join(memoryDir, 'notes'), { recursive: true });
-        fs.mkdirSync(path.join(memoryDir, 'logs'), { recursive: true });
-        fs.mkdirSync(path.join(memoryDir, 'reflections'), { recursive: true });
-        fs.mkdirSync(path.join(memoryDir, 'graph'), { recursive: true });
-    }
-    // Load recent memory context if available
-    const reflectionsDir = path.join(memoryDir, 'reflections');
-    let memoryContext = '';
-    try {
-        if (fs.existsSync(reflectionsDir)) {
-            const files = fs.readdirSync(reflectionsDir)
-                .filter(f => f.endsWith('.md'))
-                .sort()
-                .reverse()
-                .slice(0, 3);
-            for (const f of files) {
-                const content = fs.readFileSync(path.join(reflectionsDir, f), 'utf-8');
-                memoryContext += `\n--- Previous Reflection (${f}) ---\n${content}\n`;
-            }
-        }
-    }
-    catch (e) { /* ignore */ }
-    try {
-        const provider = createProvider();
-        const prompt = `You are the architect of a high-performance agent swarm. 
-Your task: Create a MISSION_DIRECTIVE (AGENT.md) for a specialized autonomous sub-agent.
-
-WORKSPACE_PATH: "${targetDir}"
-INTENT: "${intent}"
-
-${memoryContext ? `## HISTORICAL MISSION LOGS:\n${memoryContext}\nCRITICAL: If the intent denotes a recurring or state-dependent task, ignore past completion tokens. Re-verify the current filesystem state immediately.` : ''}
-
-## DIRECTIVE PREREQUISITES:
-1. THE AGENT IS THE TOOL. You are not writing a guide for a human. You are writing the internal operating logic for an AI.
-2. CURRENT DIRECTORY FOCUS. The sub-agent is ALREADY in the WORKSPACE_PATH. It MUST ALWAYS use relative paths starting with '.' or filenames.
-3. NO OUTSIDE PATHS. Explicitly FORBID searching or moving files outside WORKSPACE_PATH. Do not look for "C:\Users\..." or "/Users/...".
-4. IMMEDIATE ACTION IS MANDATORY. The first thing the agent does upon activation is use list_dir(".") to see what is actually in the current folder.
-5. NO CONVERSATIONAL FILLER. The sub-agent must communicate ONLY via JSON tool calls and internal thoughts.
-6. CONDITIONAL LOGIC MASTERY. If the intent has "If" or "When" clauses (e.g., logging receipts before moving), the agent MUST prioritize the multi-step sequence (Read -> Process -> Move). 
-7. MISSION OBJECTIVE: Fulfill the intent in as few steps as possible.
-
-## OUTPUT FORMAT (AGENT.md):
-- # [Agent Persona Name]
-- ## 🎯 Objective: Concise mission statement.
-- ## 🛠️ Execution Strategy: Step-by-step plan using list_dir, move_file, write_to_file, scheduler, etc. ALWAYS start with list_dir("."). Address multi-step sequences explicitly.
-- ## ⚠️ Constraints: Critical failure conditions (e.g., "Do not delete .env files"). FORBID absolute paths.
-
-IMPORTANT: DO NOT include code blocks, pseudo-code, or markdown examples in the AGENT.md. The agent already knows the tool syntax. Only describe the logic.`;
-        console.log(pc.dim('  Refining agent directive via LLM...'));
-        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('LLM Directive Timeout')), 25000));
-        const responsePromise = provider.generateResponse('You are a technical system logic designer. You respond ONLY with structured directive text.', [
-            { role: 'user', content: prompt }
-        ]);
-        const response = await Promise.race([responsePromise, timeoutPromise]);
-        const res = response;
-        console.log(pc.dim('  Directive received. Applying stressors filtration.'));
-        let content;
-        if (!res || (res.message?.includes('Error') && !res.thought)) {
-            console.warn(pc.yellow('⚠️ LLM directive failed. Seeding mission with hardened fallback template.'));
-            content = fallbackTemplate(intent);
-        }
-        else {
-            // Robust content extraction
-            let raw = res.message || res.thought || res.raw || '';
-            // 1. Strip all conversational prefix/suffix
-            const lines = raw.split('\n');
-            const startIndex = lines.findIndex((l) => l.startsWith('#'));
-            if (startIndex !== -1) {
-                raw = lines.slice(startIndex).join('\n');
-            }
-            // 2. Filtration: Remove all code blocks (stressor: model tries to show examples)
-            raw = raw.replace(/```[\s\S]*?```/g, '');
-            // 3. Logical Termination: Model often adds "Next steps" or "Hope this helps"
-            const segments = raw.split(/## (IMMEDIATE ACTION|NEXT STEPS|CONCLUSION|SUMMARY|APPENDIX|EXAMPLES)/i);
-            const processed = segments[0].trim();
-            content = processed || fallbackTemplate(intent);
-        }
-        const workdir = path.dirname(agentFile);
-        if (!fs.existsSync(workdir))
-            fs.mkdirSync(workdir, { recursive: true });
-        fs.writeFileSync(agentFile, content);
-        console.log(pc.green(`✅ Autonomous Directive Active: ${path.relative(targetDir, agentFile)}`));
-        // Registry & Memory Logging
-        const logId = Date.now();
-        const logFile = path.join(memoryDir, 'logs', `jit-${logId}.log`);
-        fs.writeFileSync(logFile, `[DIRECTIVE_GENERATED] Intent: ${intent}\nTimestamp: ${new Date().toISOString()}\nActionable: Detecting...\n`);
-        // Heuristic Actionability Check
-        const actionablePatterns = [/list_dir/i, /move_file/i, /scheduler/i, /write_to_file/i, /analyze_file/i, /"tool"/i];
-        const isActionable = actionablePatterns.some(p => p.test(content) || p.test(res?.raw || ''));
-        fs.appendFileSync(logFile, `Result: ${isActionable ? 'ACTIONABLE' : 'TEXT_ONLY'}\n`);
-        const inStrictEnv = process.env.VITEST === 'true' || process.env.CI === 'true' || targetDir.includes('demo');
-        if (!isActionable && inStrictEnv) {
-            console.log(pc.yellow('⚠️ Directive lacks actionable markers. Injecting deterministic mission override.'));
-            runDeterministicOrganizer(targetDir);
-        }
-    }
-    catch (error) {
-        console.error(pc.red('Hardened JIT Generator caught critical exception:'), error);
-        fs.writeFileSync(agentFile, fallbackTemplate(intent));
-    }
-}
-function fallbackTemplate(intent) {
-    return [
-        '# 🤖 HARIDIAN-X AUTONOMOUS AGENT',
-        '',
-        '## 🎯 Objective',
-        `Execute the following mission with zero human oversight: "${intent}"`,
-        '',
-        '## 🛠️ Execution Strategy',
-        '1. **RECONNAISSANCE**: Call list_dir(".") immediately to explore the folder contents. NEVER use absolute paths.',
-        '2. **ANALYSIS**: For every file found in the CURRENT folder, call analyze_file to understand structure and content.',
-        '3. **OPERATION**: Execute the intent using move_file, write_to_file, or run_command. Use RELATIVE paths.',
-        '4. **PERSISTENCE**: If the intent describes a recurring need, call scheduler immediately.',
-        '5. **VALIDATION**: Re-verify the filesystem state after every destructive action.',
-        '',
-        '## ⚠️ Constraints',
-        '- DO NOT search for files outside the current directory.',
-        '- DO NOT use absolute paths starting with C:\\ or /.',
-        '- DO NOT reply with conversational text or advice.',
-        '- DO NOT create tutorial files or examples.',
-        '- ALL output must be exactly one JSON object containing "thought", "tool", and "args".',
-        ''
-    ].join('\n');
-}

package/dist/claw/management.d.ts

@@ -1,3 +0,0 @@
-export declare function listClawAssets(): Promise<void>;
-export declare function showGhostLogs(id?: string): Promise<void>;
-export declare function killGhostTask(id: string): Promise<void>;