@stan-chen/simple-cli 0.2.2 → 0.2.4

package/dist/mcp.d.ts

@@ -0,0 +1,132 @@
+export declare class MCP {
+    private clients;
+    init(): Promise<void>;
+    getTools(): Promise<{
+        execute: (args: any) => Promise<{
+            [x: string]: unknown;
+            content: ({
+                type: "text";
+                text: string;
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                type: "image";
+                data: string;
+                mimeType: string;
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                type: "audio";
+                data: string;
+                mimeType: string;
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                type: "resource";
+                resource: {
+                    uri: string;
+                    text: string;
+                    mimeType?: string | undefined;
+                    _meta?: Record<string, unknown> | undefined;
+                } | {
+                    uri: string;
+                    blob: string;
+                    mimeType?: string | undefined;
+                    _meta?: Record<string, unknown> | undefined;
+                };
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                uri: string;
+                name: string;
+                type: "resource_link";
+                description?: string | undefined;
+                mimeType?: string | undefined;
+                annotations?: {
+                    audience?: ("user" | "assistant")[] | undefined;
+                    priority?: number | undefined;
+                    lastModified?: string | undefined;
+                } | undefined;
+                _meta?: {
+                    [x: string]: unknown;
+                } | undefined;
+                icons?: {
+                    src: string;
+                    mimeType?: string | undefined;
+                    sizes?: string[] | undefined;
+                    theme?: "light" | "dark" | undefined;
+                }[] | undefined;
+                title?: string | undefined;
+            })[];
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+                "io.modelcontextprotocol/related-task"?: {
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+            structuredContent?: Record<string, unknown> | undefined;
+            isError?: boolean | undefined;
+        } | {
+            [x: string]: unknown;
+            toolResult: unknown;
+            _meta?: {
+                [x: string]: unknown;
+                progressToken?: string | number | undefined;
+                "io.modelcontextprotocol/related-task"?: {
+                    taskId: string;
+                } | undefined;
+            } | undefined;
+        }>;
+        source: "mcp";
+        server: string;
+        inputSchema: {
+            [x: string]: unknown;
+            type: "object";
+            properties?: Record<string, object> | undefined;
+            required?: string[] | undefined;
+        };
+        name: string;
+        description?: string | undefined;
+        outputSchema?: {
+            [x: string]: unknown;
+            type: "object";
+            properties?: Record<string, object> | undefined;
+            required?: string[] | undefined;
+        } | undefined;
+        annotations?: {
+            title?: string | undefined;
+            readOnlyHint?: boolean | undefined;
+            destructiveHint?: boolean | undefined;
+            idempotentHint?: boolean | undefined;
+            openWorldHint?: boolean | undefined;
+        } | undefined;
+        execution?: {
+            taskSupport?: "optional" | "required" | "forbidden" | undefined;
+        } | undefined;
+        _meta?: Record<string, unknown> | undefined;
+        icons?: {
+            src: string;
+            mimeType?: string | undefined;
+            sizes?: string[] | undefined;
+            theme?: "light" | "dark" | undefined;
+        }[] | undefined;
+        title?: string | undefined;
+    }[]>;
+}

package/dist/mcp.js

@@ -0,0 +1,43 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+export class MCP {
+    clients = new Map();
+    async init() {
+        const configPath = join(process.cwd(), 'mcp.json');
+        if (!existsSync(configPath))
+            return;
+        const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+        const servers = config.mcpServers || config.servers || {};
+        for (const [name, cfg] of Object.entries(servers)) {
+            try {
+                const client = new Client({ name: 'simple-cli', version: '1.0.0' }, { capabilities: {} });
+                const transport = new StdioClientTransport({
+                    command: cfg.command,
+                    args: cfg.args || [],
+                    env: { ...process.env, ...(cfg.env || {}) }
+                });
+                await client.connect(transport);
+                this.clients.set(name, client);
+                console.log(`✓ Connected to MCP: ${name}`);
+            }
+            catch (e) {
+                console.error(`✗ Failed to connect to MCP ${name}:`, e);
+            }
+        }
+    }
+    async getTools() {
+        const all = [];
+        for (const [name, client] of this.clients) {
+            const { tools } = await client.listTools();
+            all.push(...tools.map(t => ({
+                ...t,
+                execute: (args) => client.callTool({ name: t.name, arguments: args }),
+                source: 'mcp',
+                server: name
+            })));
+        }
+        return all;
+    }
+}

package/dist/skills.d.ts

@@ -1,25 +1,14 @@
-/**
- * Skills/Presets System
- * Based on OpenHands skills and Aider prompts
- * Provides specialized behavior presets for different tasks
- */
 export interface Skill {
     name: string;
-    description: string;
+    description?: string;
     systemPrompt: string;
     tools?: string[];
-    modelPreference?: string;
-    autoActions?: string[];
 }
 export declare const builtinSkills: Record<string, Skill>;
-export declare function getActiveSkill(): Skill;
+export declare function loadSkillFromFile(path: string): Promise<Skill | null>;
+export declare function getActiveSkill(cwd?: string): Promise<Skill>;
 export declare function setActiveSkill(name: string): Skill | undefined;
 export declare function listSkills(): Skill[];
-export declare function loadSkillFromFile(path: string): Promise<Skill | null>;
-export declare function saveSkillToFile(skill: Skill, path: string): Promise<void>;
 export declare function loadCustomSkills(dir: string): Promise<Record<string, Skill>>;
-export declare function buildSkillPrompt(skill: Skill, context?: {
-    files?: string[];
-    repoMap?: string;
-    history?: string;
-}): string;
+export declare function buildSkillPrompt(skill: Skill, context?: any): string;
+export declare function saveSkillToFile(skill: Skill, path: string): Promise<void>;

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: ['readFiles', 'writeFiles', 'runCommand', 'glob', 'grep', 'lint', 'reloadTools'],
-    },
-    // 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: ['readFiles', '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: ['readFiles', '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: ['readFiles', 'scrapeUrl'],
-    },
-    // 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: ['readFiles', 'writeFiles', 'runCommand', 'glob', 'grep', 'lint'],
-    },
-    // 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: ['readFiles', 'writeFiles', 'runCommand', 'grep', 'lint', 'git'],
-    },
-    // 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: ['readFiles', 'writeFiles', 'runCommand', 'glob', 'grep', 'lint', 'git'],
-    },
-    // 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: ['readFiles', '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: ['runCommand', 'readFiles', 'writeFiles', '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', 'readFiles', '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,10 @@
+import pc from 'picocolors';
+export function showBanner() {
+    const cat = `
+      /\\_/\\
+     ( o.o )
+      > ^ <
+    `;
+    console.log(pc.magenta(cat));
+    console.log(` ${pc.bgMagenta(pc.black(' SIMPLE-CLI '))} ${pc.dim('v0.4.0')}\n`);
+}