@stan-chen/simple-cli 0.2.2 → 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,78 +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/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,15 +0,0 @@
-/**
- * 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

@@ -1,82 +0,0 @@
-/**
- * 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-5-mini'
-        };
-    }
-    // 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

@@ -1,11 +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';
-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

@@ -1,28 +0,0 @@
-/**
- * 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);
-        }
-    };
-};