@stan-chen/simple-cli 0.2.3 → 0.2.4

package/dist/mcp/manager.js

@@ -1,446 +0,0 @@
-/**
- * MCP Client Manager - Manages multiple MCP server connections
- * Supports Composio, custom MCP servers, and dynamic tool discovery
- * Based on GeminiCLI's mcp-client.ts patterns
- */
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { z } from 'zod';
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-// MCP Server Configuration Schema
-export const MCPServerConfigSchema = z.object({
-    name: z.string(),
-    command: z.string().optional(),
-    args: z.array(z.string()).optional(),
-    env: z.record(z.string()).optional(),
-    url: z.string().optional(),
-    type: z.enum(['stdio', 'sse', 'http']).optional(),
-    timeout: z.number().optional(),
-    trust: z.enum(['full', 'partial', 'none']).optional(),
-    enabled: z.boolean().optional().default(true),
-});
-// Server Status
-export var MCPServerStatus;
-(function (MCPServerStatus) {
-    MCPServerStatus["DISCONNECTED"] = "disconnected";
-    MCPServerStatus["CONNECTING"] = "connecting";
-    MCPServerStatus["CONNECTED"] = "connected";
-    MCPServerStatus["ERROR"] = "error";
-})(MCPServerStatus || (MCPServerStatus = {}));
-/**
- * MCP Client Manager
- * Manages connections to multiple MCP servers and aggregates their tools
- */
-export class MCPManager {
-    servers = new Map();
-    onStatusChange;
-    constructor(options) {
-        this.onStatusChange = options?.onStatusChange;
-    }
-    /**
-     * Load MCP configuration from all available sources
-     */
-    async loadConfig(configPath) {
-        const allConfigs = [];
-        const sources = [
-            { path: configPath, type: 'file' },
-            { path: join(process.cwd(), 'mcp.json'), type: 'file' },
-            { path: join(process.cwd(), '.mcp.json'), type: 'file' },
-            { path: join(process.cwd(), 'mcp'), type: 'dir' },
-            { path: join(process.env.HOME || '', '.config', 'simplecli', 'mcp.json'), type: 'file' },
-            { path: join(process.env.APPDATA || '', 'simplecli', 'mcp.json'), type: 'file' },
-        ].filter(s => s.path && existsSync(s.path));
-        for (const source of sources) {
-            try {
-                if (source.type === 'file') {
-                    const content = readFileSync(source.path, 'utf-8');
-                    allConfigs.push(...this.parseConfigContent(content));
-                }
-                else if (source.type === 'dir') {
-                    // Scan directory for .json files
-                    const { readdir } = await import('fs/promises');
-                    const files = await readdir(source.path);
-                    for (const file of files) {
-                        if (file.endsWith('.json')) {
-                            const content = readFileSync(join(source.path, file), 'utf-8');
-                            allConfigs.push(...this.parseConfigContent(content));
-                        }
-                    }
-                }
-            }
-            catch (e) {
-                if (process.env.DEBUG)
-                    console.error(`Failed to load MCP source ${source.path}:`, e);
-            }
-        }
-        // De-duplicate by name, preferring earlier (local) configs
-        const unique = new Map();
-        for (const config of allConfigs) {
-            if (!unique.has(config.name)) {
-                unique.set(config.name, config);
-            }
-        }
-        return Array.from(unique.values()).filter(s => s.enabled !== false);
-    }
-    /**
-     * Parse MCP config content which can be in multiple formats
-     */
-    parseConfigContent(content) {
-        try {
-            const config = JSON.parse(content);
-            // Handle { servers: [...] } format
-            if (Array.isArray(config.servers)) {
-                return config.servers;
-            }
-            // Handle { mcpServers: { name: config } } format (Claude-style)
-            if (config.mcpServers) {
-                return Object.entries(config.mcpServers).map(([name, cfg]) => ({
-                    name,
-                    ...cfg
-                }));
-            }
-            // Handle single server config
-            if (config.name && (config.command || config.url)) {
-                return [config];
-            }
-        }
-        catch (e) {
-            if (process.env.DEBUG)
-                console.error('Failed to parse MCP content:', e);
-        }
-        return [];
-    }
-    /**
-     * Connect to an MCP server
-     */
-    async connect(config) {
-        const serverName = config.name;
-        if (this.servers.has(serverName)) {
-            await this.disconnect(serverName);
-        }
-        const state = {
-            client: null,
-            transport: null,
-            status: MCPServerStatus.CONNECTING,
-            config,
-            tools: [],
-            resources: [],
-            prompts: [],
-        };
-        this.servers.set(serverName, state);
-        this.updateStatus(serverName, MCPServerStatus.CONNECTING);
-        try {
-            const client = new Client({ name: 'simplecli', version: '0.2.1' }, { capabilities: {} });
-            let transport;
-            if (config.command) {
-                // Stdio transport
-                transport = new StdioClientTransport({
-                    command: config.command,
-                    args: config.args || [],
-                    env: { ...process.env, ...(config.env || {}) },
-                });
-            }
-            else if (config.url) {
-                // For URL-based transports, we'd need additional SDK imports
-                // For now, throw an error suggesting stdio
-                throw new Error('URL-based MCP transports require additional configuration. Use stdio transport with command.');
-            }
-            else {
-                throw new Error(`Invalid MCP server config for ${serverName}: missing command or url`);
-            }
-            // Connect with a 5-second timeout
-            await Promise.race([
-                client.connect(transport),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('Connection timeout')), 5000))
-            ]);
-            state.client = client;
-            state.transport = transport;
-            state.status = MCPServerStatus.CONNECTED;
-            // Discover tools, resources, and prompts
-            await this.discover(serverName);
-            this.updateStatus(serverName, MCPServerStatus.CONNECTED);
-            console.log(`✓ Connected to MCP server: ${serverName}`);
-        }
-        catch (error) {
-            state.status = MCPServerStatus.ERROR;
-            state.error = error instanceof Error ? error.message : String(error);
-            this.updateStatus(serverName, MCPServerStatus.ERROR);
-            console.error(`✗ Failed to connect to MCP server ${serverName}:`, state.error);
-        }
-    }
-    /**
-     * Connect to all configured servers
-     */
-    async connectAll(configs) {
-        const serverConfigs = configs || await this.loadConfig();
-        await Promise.all(serverConfigs.map(config => this.connect(config).catch(e => {
-            console.error(`Failed to connect to ${config.name}:`, e);
-        })));
-    }
-    /**
-     * Disconnect from an MCP server
-     */
-    async disconnect(serverName) {
-        const state = this.servers.get(serverName);
-        if (!state)
-            return;
-        try {
-            if (state.transport) {
-                await state.transport.close();
-            }
-            if (state.client) {
-                await state.client.close();
-            }
-        }
-        catch (e) {
-            // Ignore close errors
-        }
-        this.servers.delete(serverName);
-        this.updateStatus(serverName, MCPServerStatus.DISCONNECTED);
-    }
-    /**
-     * Disconnect from all servers
-     */
-    async disconnectAll() {
-        await Promise.all(Array.from(this.servers.keys()).map(name => this.disconnect(name)));
-    }
-    /**
-     * Discover tools, resources, and prompts from a server
-     */
-    async discover(serverName) {
-        const state = this.servers.get(serverName);
-        if (!state?.client)
-            return;
-        const client = state.client;
-        // Discover tools
-        try {
-            const toolsResult = await client.listTools();
-            state.tools = toolsResult.tools.map(tool => ({
-                name: tool.name,
-                description: tool.description || '',
-                serverName,
-                inputSchema: tool.inputSchema || {},
-                execute: async (args) => {
-                    const result = await client.callTool({ name: tool.name, arguments: args });
-                    return result;
-                },
-            }));
-        }
-        catch {
-            // Server may not support tools
-        }
-        // Discover resources
-        try {
-            const resourcesResult = await client.listResources();
-            state.resources = resourcesResult.resources.map(resource => ({
-                uri: resource.uri,
-                name: resource.name,
-                description: resource.description,
-                mimeType: resource.mimeType,
-                serverName,
-            }));
-        }
-        catch {
-            // Server may not support resources
-        }
-        // Discover prompts
-        try {
-            const promptsResult = await client.listPrompts();
-            state.prompts = promptsResult.prompts.map(prompt => ({
-                name: prompt.name,
-                description: prompt.description,
-                serverName,
-                arguments: prompt.arguments,
-                invoke: async (params) => {
-                    const stringParams = {};
-                    for (const [k, v] of Object.entries(params)) {
-                        stringParams[k] = String(v);
-                    }
-                    const result = await client.getPrompt({ name: prompt.name, arguments: stringParams });
-                    return {
-                        messages: result.messages.map(m => ({
-                            role: m.role,
-                            content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
-                        })),
-                    };
-                },
-            }));
-        }
-        catch {
-            // Server may not support prompts
-        }
-    }
-    /**
-     * Get all discovered tools from all connected servers
-     */
-    getAllTools() {
-        const tools = [];
-        for (const state of this.servers.values()) {
-            if (state.status === MCPServerStatus.CONNECTED) {
-                tools.push(...state.tools);
-            }
-        }
-        return tools;
-    }
-    /**
-     * Get all discovered resources from all connected servers
-     */
-    getAllResources() {
-        const resources = [];
-        for (const state of this.servers.values()) {
-            if (state.status === MCPServerStatus.CONNECTED) {
-                resources.push(...state.resources);
-            }
-        }
-        return resources;
-    }
-    /**
-     * Get all discovered prompts from all connected servers
-     */
-    getAllPrompts() {
-        const prompts = [];
-        for (const state of this.servers.values()) {
-            if (state.status === MCPServerStatus.CONNECTED) {
-                prompts.push(...state.prompts);
-            }
-        }
-        return prompts;
-    }
-    /**
-     * Get a specific tool by name
-     */
-    getTool(name) {
-        return this.getAllTools().find(t => t.name === name);
-    }
-    /**
-     * Execute an MCP tool
-     */
-    async executeTool(name, args) {
-        const tool = this.getTool(name);
-        if (!tool) {
-            throw new Error(`MCP tool not found: ${name}`);
-        }
-        return tool.execute(args);
-    }
-    /**
-     * Read an MCP resource
-     */
-    async readResource(uri) {
-        // Find which server has this resource
-        for (const state of this.servers.values()) {
-            if (state.status !== MCPServerStatus.CONNECTED || !state.client)
-                continue;
-            const resource = state.resources.find(r => r.uri === uri);
-            if (resource) {
-                const result = await state.client.readResource({ uri });
-                return result;
-            }
-        }
-        throw new Error(`Resource not found: ${uri}`);
-    }
-    /**
-     * Invoke an MCP prompt
-     */
-    async invokePrompt(name, params) {
-        const prompt = this.getAllPrompts().find(p => p.name === name);
-        if (!prompt) {
-            throw new Error(`MCP prompt not found: ${name}`);
-        }
-        return prompt.invoke(params);
-    }
-    /**
-     * Get server status
-     */
-    getServerStatus(serverName) {
-        return this.servers.get(serverName)?.status || MCPServerStatus.DISCONNECTED;
-    }
-    /**
-     * Get all server statuses
-     */
-    getAllServerStatuses() {
-        const statuses = new Map();
-        for (const [name, state] of this.servers) {
-            statuses.set(name, state.status);
-        }
-        return statuses;
-    }
-    updateStatus(serverName, status) {
-        this.onStatusChange?.(serverName, status);
-    }
-}
-/**
- * Create Composio MCP configuration
- * Composio provides pre-built integrations for 250+ tools
- */
-export function createComposioConfig(apiKey) {
-    return {
-        name: 'composio',
-        command: 'npx',
-        args: ['-y', 'composio-core', 'mcp'],
-        env: apiKey ? { COMPOSIO_API_KEY: apiKey } : {},
-        trust: 'full',
-        enabled: true,
-    };
-}
-/**
- * Create filesystem MCP configuration
- */
-export function createFilesystemConfig(allowedPaths) {
-    return {
-        name: 'filesystem',
-        command: 'npx',
-        args: ['-y', '@modelcontextprotocol/server-filesystem', ...allowedPaths],
-        trust: 'full',
-        enabled: true,
-    };
-}
-/**
- * Create GitHub MCP configuration
- */
-export function createGitHubConfig(token) {
-    return {
-        name: 'github',
-        command: 'npx',
-        args: ['-y', '@modelcontextprotocol/server-github'],
-        env: token ? { GITHUB_PERSONAL_ACCESS_TOKEN: token } : {},
-        trust: 'full',
-        enabled: true,
-    };
-}
-/**
- * Create memory/context MCP configuration
- */
-export function createMemoryConfig() {
-    return {
-        name: 'memory',
-        command: 'npx',
-        args: ['-y', '@modelcontextprotocol/server-memory'],
-        trust: 'full',
-        enabled: true,
-    };
-}
-/**
- * Create Brave Search MCP configuration
- */
-export function createBraveSearchConfig(apiKey) {
-    return {
-        name: 'brave-search',
-        command: 'npx',
-        args: ['-y', '@modelcontextprotocol/server-brave-search'],
-        env: apiKey ? { BRAVE_API_KEY: apiKey } : {},
-        trust: 'full',
-        enabled: true,
-    };
-}
-// Singleton instance
-let mcpManager = null;
-/**
- * Get or create the global MCP manager instance
- */
-export function getMCPManager() {
-    if (!mcpManager) {
-        mcpManager = new MCPManager();
-    }
-    return mcpManager;
-}

package/dist/prompts/provider.d.ts

@@ -1,22 +0,0 @@
-/**
- * Prompt Provider - Manages composition of system prompts
- * Supports built-in defaults, project-specific overrides, and modular personas.
- */
-export interface PromptOptions {
-    cwd: string;
-    skillPrompt?: string;
-}
-export declare class PromptProvider {
-    /**
-     * Builds the full system prompt by composing multiple layers:
-     * 1. Built-in system instructions (src/prompts/defaults)
-     * 2. Global user overrides (~/.simple/prompts)
-     * 3. Project-specific prompts (.simple/prompts)
-     * 4. Current skill instructions
-     * 5. Local project rules (AGENT.md)
-     */
-    getSystemPrompt(options: PromptOptions): Promise<string>;
-    private loadFromDirectory;
-    private loadProjectRules;
-}
-export declare function getPromptProvider(): PromptProvider;

package/dist/prompts/provider.js

@@ -1,79 +0,0 @@
-/**
- * Prompt Provider - Manages composition of system prompts
- * Supports built-in defaults, project-specific overrides, and modular personas.
- */
-import { readFileSync, existsSync, readdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { homedir } from 'os';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-export class PromptProvider {
-    /**
-     * Builds the full system prompt by composing multiple layers:
-     * 1. Built-in system instructions (src/prompts/defaults)
-     * 2. Global user overrides (~/.simple/prompts)
-     * 3. Project-specific prompts (.simple/prompts)
-     * 4. Current skill instructions
-     * 5. Local project rules (AGENT.md)
-     */
-    async getSystemPrompt(options) {
-        const parts = [];
-        // 1. Built-in defaults (Hardcoded in the package)
-        const builtInDir = join(__dirname, 'defaults');
-        if (existsSync(builtInDir)) {
-            parts.push(...this.loadFromDirectory(builtInDir));
-        }
-        // 2. Global user rules (~/.simple/AGENT.md)
-        const globalRulesPath = join(homedir(), '.simple', 'AGENT.md');
-        if (existsSync(globalRulesPath)) {
-            parts.push('\n## Global Rules\n' + readFileSync(globalRulesPath, 'utf-8'));
-        }
-        // 3. Project rules (AGENT.md)
-        const rules = this.loadProjectRules(options.cwd);
-        if (rules) {
-            parts.push('\n## Project Rules\n' + rules);
-        }
-        // 4. Skill-specific prompt (Dynamic based on @skill)
-        if (options.skillPrompt) {
-            parts.push('\n## Skill Context: ' + options.skillPrompt);
-        }
-        return parts.join('\n\n').trim();
-    }
-    loadFromDirectory(dir) {
-        try {
-            return readdirSync(dir)
-                .filter(f => f.endsWith('.md') || f.endsWith('.mdc'))
-                .sort() // Ensure deterministic order
-                .map(f => readFileSync(join(dir, f), 'utf-8'));
-        }
-        catch {
-            return [];
-        }
-    }
-    loadProjectRules(cwd) {
-        const commonPaths = [
-            '.simple/workdir/AGENT.md',
-            '.simple/AGENT.md',
-            '.agent/AGENT.md',
-            'AGENT.md',
-            '.agent.md',
-            '.cursorrules',
-            '.aider/agent.md'
-        ];
-        for (const p of commonPaths) {
-            const fullPath = join(cwd, p);
-            if (existsSync(fullPath)) {
-                return readFileSync(fullPath, 'utf-8');
-            }
-        }
-        return null;
-    }
-}
-let provider = null;
-export function getPromptProvider() {
-    if (!provider) {
-        provider = new PromptProvider();
-    }
-    return provider;
-}

package/dist/providers/index.d.ts

@@ -1,31 +0,0 @@
-/**
- * Provider Bridge: Unified LLM interface via Vercel AI SDK
- * Support for OpenAI, Anthropic, Google (Gemini), and custom endpoints.
- */
-import { type TypeLLMResponse } from '@stan-chen/typellm';
-export interface Message {
-    role: 'user' | 'assistant' | 'system';
-    content: string;
-}
-export interface Provider {
-    name: string;
-    model: string;
-    generateResponse: (systemPrompt: string, messages: Message[]) => Promise<TypeLLMResponse>;
-}
-/**
- * Structured output strategy:
- * - Uses strong system prompts with explicit JSON format examples
- * - Response parsing with jsonrepair (in cli.ts)
- * - Format reminders in user messages (in context.ts)
- *
- * This approach works across ALL providers without hitting
- * provider-specific schema limitations (e.g., OpenAI's additionalProperties requirement)
- */
-/**
- * Creates a provider instance using TypeLLM
- */
-export declare const createProviderForModel: (modelId: string) => Provider;
-/**
- * Creates the default provider
- */
-export declare const createProvider: () => Provider;

package/dist/providers/index.js

@@ -1,93 +0,0 @@
-/**
- * Provider Bridge: Unified LLM interface via Vercel AI SDK
- * Support for OpenAI, Anthropic, Google (Gemini), and custom endpoints.
- */
-import { createTypeLLM } from '@stan-chen/typellm';
-/**
- * Structured output strategy:
- * - Uses strong system prompts with explicit JSON format examples
- * - Response parsing with jsonrepair (in cli.ts)
- * - Format reminders in user messages (in context.ts)
- *
- * This approach works across ALL providers without hitting
- * provider-specific schema limitations (e.g., OpenAI's additionalProperties requirement)
- */
-/**
- * Creates a provider instance using TypeLLM
- */
-export const createProviderForModel = (modelId) => {
-    let providerType = 'openai';
-    let actualModel = modelId;
-    let baseURL;
-    // Handle provider selection
-    if (modelId.startsWith('anthropic:')) {
-        actualModel = modelId.split(':')[1] || modelId;
-        providerType = 'anthropic';
-    }
-    else if (modelId.startsWith('google:') || modelId.startsWith('gemini:')) {
-        actualModel = modelId.split(':')[1] || modelId;
-        providerType = 'google';
-    }
-    else if (modelId.startsWith('openai:')) {
-        actualModel = modelId.split(':')[1] || modelId;
-        providerType = 'openai';
-    }
-    else if (modelId.startsWith('claude') || (process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY)) {
-        providerType = 'anthropic';
-    }
-    else if (modelId.startsWith('gemini') || (process.env.GEMINI_API_KEY && !process.env.OPENAI_API_KEY)) {
-        providerType = 'google';
-    }
-    else if (process.env.LITELLM_BASE_URL) {
-        providerType = 'litellm';
-        baseURL = process.env.LITELLM_BASE_URL;
-    }
-    else {
-        providerType = 'openai';
-    }
-    // Final check for the Google key mapping
-    if (providerType === 'google' && process.env.GEMINI_API_KEY && !process.env.GOOGLE_GENERATIVE_AI_API_KEY) {
-        process.env.GOOGLE_GENERATIVE_AI_API_KEY = process.env.GEMINI_API_KEY;
-    }
-    const llm = createTypeLLM({
-        provider: providerType,
-        model: actualModel,
-        baseURL: baseURL,
-        apiKey: providerType === 'openai' ? process.env.OPENAI_API_KEY :
-            providerType === 'google' ? process.env.GEMINI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY :
-                providerType === 'anthropic' ? process.env.ANTHROPIC_API_KEY :
-                    undefined,
-        temperature: 0
-    });
-    return {
-        name: providerType,
-        model: actualModel,
-        generateResponse: async (systemPrompt, messages) => {
-            try {
-                const response = await llm.generate(systemPrompt, messages);
-                if ((process.env.DEBUG === 'true') && response)
-                    console.log(`[DEBUG] TypeLLM Response: ${JSON.stringify(response).substring(0, 300)}...`);
-                return response;
-            }
-            catch (e) {
-                const msg = `Error calling TypeLLM: ${e instanceof Error ? e.message : e}`;
-                return {
-                    thought: 'Error occurred during generation',
-                    tool: 'none',
-                    args: {},
-                    message: msg,
-                    raw: msg
-                };
-            }
-        }
-    };
-};
-/**
- * Creates the default provider
- */
-export const createProvider = () => {
-    const isClaw = process.argv.includes('--claw') || process.argv.includes('-claw');
-    const model = (isClaw ? process.env.CLAW_MODEL : null) || process.env.OPENAI_MODEL || process.env.GEMINI_MODEL || 'gpt-4o-mini';
-    console.log(`🤖 Using TypeLLM with model: ${model}`);
-    return createProviderForModel(model);
-};

package/dist/providers/multi.d.ts

@@ -1,12 +0,0 @@
-/**
- * Multi-Provider: Manages multiple LLM models for MoE routing via LiteLLM
- * Each tier can use a different model from any provider
- */
-import { type Provider, type Message } from './index.js';
-import type { Tier, TierConfig } from '../router.js';
-import type { TypeLLMResponse } from '@stan-chen/typellm';
-export interface MultiProvider {
-    getProvider: (tier: Tier) => Provider;
-    generateWithTier: (tier: Tier, systemPrompt: string, messages: Message[]) => Promise<TypeLLMResponse>;
-}
-export declare const createMultiProvider: (tierConfigs: Map<Tier, TierConfig>) => MultiProvider;