@stan-chen/simple-cli 0.2.1

package/dist/mcp/manager.js

@@ -0,0 +1,442 @@
+/**
+ * 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`);
+            }
+            await client.connect(transport);
+            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

@@ -0,0 +1,22 @@
+/**
+ * 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

@@ -0,0 +1,78 @@
+/**
+ * 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/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

@@ -0,0 +1,15 @@
+/**
+ * Provider Bridge: Unified LLM interface via OpenAI SDK
+ * Supports OpenAI, DeepSeek, Groq, and other OpenAI-compatible endpoints.
+ */
+export interface Message {
+    role: string;
+    content: string;
+}
+export interface Provider {
+    name: string;
+    model: string;
+    generateResponse: (systemPrompt: string, messages: Message[]) => Promise<string>;
+}
+export declare const createProviderForModel: (model: string) => Provider;
+export declare const createProvider: () => Provider;

package/dist/providers/index.js

@@ -0,0 +1,82 @@
+/**
+ * Provider Bridge: Unified LLM interface via OpenAI SDK
+ * Supports OpenAI, DeepSeek, Groq, and other OpenAI-compatible endpoints.
+ */
+import OpenAI from 'openai';
+const getProviderConfig = () => {
+    // 1. OpenAI (Default)
+    if (process.env.OPENAI_API_KEY) {
+        return {
+            apiKey: process.env.OPENAI_API_KEY,
+            model: process.env.OPENAI_MODEL || 'gpt-4o'
+        };
+    }
+    // 2. DeepSeek
+    if (process.env.DEEPSEEK_API_KEY) {
+        return {
+            apiKey: process.env.DEEPSEEK_API_KEY,
+            baseURL: 'https://api.deepseek.com/v1',
+            model: process.env.DEEPSEEK_MODEL || 'deepseek-chat'
+        };
+    }
+    // 3. Groq
+    if (process.env.GROQ_API_KEY) {
+        return {
+            apiKey: process.env.GROQ_API_KEY,
+            baseURL: 'https://api.groq.com/openai/v1',
+            model: process.env.GROQ_MODEL || 'llama3-70b-8192'
+        };
+    }
+    // 4. Mistral
+    if (process.env.MISTRAL_API_KEY) {
+        return {
+            apiKey: process.env.MISTRAL_API_KEY,
+            baseURL: 'https://api.mistral.ai/v1',
+            model: process.env.MISTRAL_MODEL || 'mistral-large-latest'
+        };
+    }
+    throw new Error('No supported API key found (OPENAI_API_KEY, DEEPSEEK_API_KEY, GROQ_API_KEY, MISTRAL_API_KEY)');
+};
+export const createProviderForModel = (model) => {
+    // Quick heuristic to determine provider for specific model overrides
+    // logic can be improved, but this assumes the environment variables set the *default* linkage
+    // If a specific model is requested (e.g. for MoE), we try to route it.
+    let config = getProviderConfig();
+    // Override config if model implies a different provider? 
+    // For the sake of "Simple-CLI", we assume the default connected provider serves the requested model
+    // or we just use OpenAI SDK's flexibility.
+    if (model.includes('gpt'))
+        config = { ...config, apiKey: process.env.OPENAI_API_KEY, baseURL: undefined };
+    else if (model.includes('deepseek'))
+        config = { ...config, apiKey: process.env.DEEPSEEK_API_KEY, baseURL: 'https://api.deepseek.com/v1' };
+    if (!config.apiKey)
+        throw new Error(`Cannot route for model ${model} - missing API key`);
+    const client = new OpenAI({
+        apiKey: config.apiKey,
+        baseURL: config.baseURL
+    });
+    return {
+        name: 'openai-compatible',
+        model,
+        generateResponse: async (systemPrompt, messages) => {
+            try {
+                const response = await client.chat.completions.create({
+                    model: model,
+                    messages: [
+                        { role: 'system', content: systemPrompt },
+                        ...messages.map(m => ({ role: m.role, content: m.content }))
+                    ]
+                });
+                return response.choices[0]?.message?.content || '';
+            }
+            catch (e) {
+                return `Error calling LLM: ${e instanceof Error ? e.message : e}`; // Fail gracefully
+            }
+        }
+    };
+};
+export const createProvider = () => {
+    const config = getProviderConfig();
+    console.log(`🤖 Using model: ${config.model}`);
+    return createProviderForModel(config.model);
+};

package/dist/providers/multi.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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';
+export interface MultiProvider {
+    getProvider: (tier: Tier) => Provider;
+    generateWithTier: (tier: Tier, systemPrompt: string, messages: Message[]) => Promise<string>;
+}
+export declare const createMultiProvider: (tierConfigs: Map<Tier, TierConfig>) => MultiProvider;

package/dist/providers/multi.js

@@ -0,0 +1,28 @@
+/**
+ * Multi-Provider: Manages multiple LLM models for MoE routing via LiteLLM
+ * Each tier can use a different model from any provider
+ */
+import { createProviderForModel } from './index.js';
+// Create multi-provider system using LiteLLM
+export const createMultiProvider = (tierConfigs) => {
+    const providerCache = new Map();
+    const getProvider = (tier) => {
+        const cached = providerCache.get(tier);
+        if (cached)
+            return cached;
+        const config = tierConfigs.get(tier);
+        if (!config) {
+            throw new Error(`No configuration for tier ${tier}`);
+        }
+        const provider = createProviderForModel(config.model);
+        providerCache.set(tier, provider);
+        return provider;
+    };
+    return {
+        getProvider,
+        generateWithTier: async (tier, systemPrompt, messages) => {
+            const provider = getProvider(tier);
+            return provider.generateResponse(systemPrompt, messages);
+        }
+    };
+};