@stan-chen/simple-cli 0.2.1

package/dist/lib/ui.js

@@ -0,0 +1,252 @@
+/**
+ * Terminal UI using Clack
+ * Modern, clean terminal prompts and spinners
+ */
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+export { p as prompts };
+/**
+ * UI Theme colors
+ */
+export const theme = {
+    primary: pc.cyan,
+    success: pc.green,
+    warning: pc.yellow,
+    error: pc.red,
+    muted: pc.dim,
+    highlight: pc.bold,
+    code: pc.bgBlack,
+};
+/**
+ * Display intro banner
+ */
+export function intro(message) {
+    p.intro(theme.primary(message));
+}
+/**
+ * Display outro message
+ */
+export function outro(message) {
+    p.outro(theme.success(message));
+}
+/**
+ * Display a note
+ */
+export function note(message, title) {
+    p.note(message, title);
+}
+/**
+ * Display a log message
+ */
+export function log(message) {
+    p.log.message(message);
+}
+/**
+ * Display an info message
+ */
+export function info(message) {
+    p.log.info(theme.primary(message));
+}
+/**
+ * Display a success message
+ */
+export function success(message) {
+    p.log.success(theme.success(message));
+}
+/**
+ * Display a warning message
+ */
+export function warning(message) {
+    p.log.warn(theme.warning(message));
+}
+/**
+ * Display an error message
+ */
+export function error(message) {
+    p.log.error(theme.error(message));
+}
+/**
+ * Display a step message
+ */
+export function step(message) {
+    p.log.step(message);
+}
+/**
+ * Show a spinner while executing an async operation
+ */
+export async function spin(message, fn) {
+    const s = p.spinner();
+    s.start(message);
+    try {
+        const result = await fn();
+        s.stop(theme.success('✓ ' + message));
+        return result;
+    }
+    catch (err) {
+        s.stop(theme.error('✗ ' + message));
+        throw err;
+    }
+}
+/**
+ * Prompt for text input
+ */
+export async function text(options) {
+    return p.text(options);
+}
+/**
+ * Prompt for password input
+ */
+export async function password(options) {
+    return p.password(options);
+}
+/**
+ * Prompt for confirmation
+ */
+export async function confirm(options) {
+    return p.confirm(options);
+}
+/**
+ * Prompt for single selection
+ */
+export async function select(options) {
+    return p.select(options);
+}
+/**
+ * Prompt for multi-selection
+ */
+export async function multiselect(options) {
+    return p.multiselect(options);
+}
+/**
+ * Group related prompts together
+ */
+export async function group(prompts, options) {
+    return p.group(prompts, options);
+}
+/**
+ * Check if user cancelled
+ */
+export function isCancel(value) {
+    return p.isCancel(value);
+}
+/**
+ * Cancel and exit
+ */
+export function cancel(message) {
+    p.cancel(message || 'Operation cancelled.');
+    process.exit(0);
+}
+/**
+ * Display a diff with syntax highlighting
+ */
+export function showDiff(diffText) {
+    const lines = diffText.split('\n');
+    for (const line of lines) {
+        if (line.startsWith('+') && !line.startsWith('+++')) {
+            console.log(theme.success(line));
+        }
+        else if (line.startsWith('-') && !line.startsWith('---')) {
+            console.log(theme.error(line));
+        }
+        else if (line.startsWith('@@')) {
+            console.log(theme.primary(line));
+        }
+        else if (line.startsWith('diff') || line.startsWith('index')) {
+            console.log(theme.muted(line));
+        }
+        else {
+            console.log(line);
+        }
+    }
+}
+/**
+ * Display a code block
+ */
+export function showCode(code, language) {
+    const header = language ? theme.muted(`\`\`\`${language}`) : theme.muted('```');
+    const footer = theme.muted('```');
+    console.log(header);
+    console.log(code);
+    console.log(footer);
+}
+/**
+ * Display a thinking/reasoning block
+ */
+export function showThought(thought) {
+    const lines = thought.split('\n');
+    const boxed = lines.map(line => theme.muted('│ ') + line).join('\n');
+    console.log(theme.muted('┌─ Thinking'));
+    console.log(boxed);
+    console.log(theme.muted('└─'));
+}
+/**
+ * Display a tool invocation
+ */
+export function showToolCall(name, args) {
+    const argsStr = Object.entries(args)
+        .map(([k, v]) => `${theme.muted(k)}=${theme.highlight(JSON.stringify(v))}`)
+        .join(' ');
+    console.log(`${theme.primary('▶')} ${theme.highlight(name)} ${argsStr}`);
+}
+/**
+ * Display a tool result
+ */
+export function showToolResult(result, truncate = 500) {
+    const display = result.length > truncate
+        ? result.slice(0, truncate) + theme.muted(`\n... (${result.length - truncate} more chars)`)
+        : result;
+    console.log(theme.muted('◀ ') + display);
+}
+/**
+ * Display file status indicators
+ */
+export function showFileStatus(files) {
+    const icons = {
+        added: theme.success('+'),
+        modified: theme.warning('~'),
+        deleted: theme.error('-'),
+        readonly: theme.muted('○'),
+    };
+    for (const file of files) {
+        console.log(`  ${icons[file.status]} ${file.path}`);
+    }
+}
+/**
+ * Display token count
+ */
+export function showTokens(count, max) {
+    const formatted = count.toLocaleString();
+    if (max) {
+        const percent = ((count / max) * 100).toFixed(1);
+        const color = count / max > 0.8 ? theme.warning : theme.muted;
+        console.log(color(`Tokens: ${formatted} / ${max.toLocaleString()} (${percent}%)`));
+    }
+    else {
+        console.log(theme.muted(`Tokens: ~${formatted}`));
+    }
+}
+/**
+ * Create a task list for progress tracking
+ */
+export function tasks() {
+    const taskList = new Map();
+    const icons = {
+        pending: theme.muted('○'),
+        running: theme.primary('●'),
+        done: theme.success('✓'),
+        error: theme.error('✗'),
+    };
+    return {
+        add(name, status = 'pending') {
+            taskList.set(name, status);
+        },
+        update(name, status) {
+            taskList.set(name, status);
+        },
+        render() {
+            for (const [name, status] of taskList) {
+                console.log(`  ${icons[status]} ${name}`);
+            }
+        },
+    };
+}

package/dist/mcp/client.d.ts

@@ -0,0 +1,22 @@
+/**
+ * MCP Client: External tool integration via Model Context Protocol
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { z } from 'zod';
+export interface MCPServer {
+    name: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export interface MCPTool {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<z.ZodRawShape>;
+}
+export declare const connectMCPServer: (server: MCPServer) => Promise<Client>;
+export declare const listMCPTools: (serverName: string) => Promise<MCPTool[]>;
+export declare const callMCPTool: (serverName: string, toolName: string, args: Record<string, unknown>) => Promise<unknown>;
+export declare const disconnectMCPServer: (serverName: string) => Promise<void>;
+export declare const disconnectAllMCPServers: () => Promise<void>;
+export declare const loadMCPConfig: (configPath?: string) => Promise<MCPServer[]>;

package/dist/mcp/client.js

@@ -0,0 +1,81 @@
+/**
+ * MCP Client: External tool integration via Model Context Protocol
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { z } from 'zod';
+// Active MCP connections
+const connections = new Map();
+// Connect to an MCP server
+export const connectMCPServer = async (server) => {
+    if (connections.has(server.name)) {
+        return connections.get(server.name).client;
+    }
+    const transport = new StdioClientTransport({
+        command: server.command,
+        args: server.args || [],
+        env: { ...process.env, ...server.env }
+    });
+    const client = new Client({
+        name: 'simplecli',
+        version: '0.1.0'
+    }, {
+        capabilities: {}
+    });
+    await client.connect(transport);
+    connections.set(server.name, { client, transport });
+    console.log(`  ✓ Connected to MCP server: ${server.name}`);
+    return client;
+};
+// List tools from an MCP server
+export const listMCPTools = async (serverName) => {
+    const connection = connections.get(serverName);
+    if (!connection) {
+        throw new Error(`MCP server "${serverName}" not connected`);
+    }
+    const result = await connection.client.listTools();
+    return result.tools.map(tool => ({
+        name: tool.name,
+        description: tool.description || '',
+        inputSchema: z.object({}) // Simplified - would parse JSON schema in production
+    }));
+};
+// Call an MCP tool
+export const callMCPTool = async (serverName, toolName, args) => {
+    const connection = connections.get(serverName);
+    if (!connection) {
+        throw new Error(`MCP server "${serverName}" not connected`);
+    }
+    const result = await connection.client.callTool({
+        name: toolName,
+        arguments: args
+    });
+    return result.content;
+};
+// Disconnect from an MCP server
+export const disconnectMCPServer = async (serverName) => {
+    const connection = connections.get(serverName);
+    if (connection) {
+        await connection.client.close();
+        connections.delete(serverName);
+        console.log(`  ✓ Disconnected from MCP server: ${serverName}`);
+    }
+};
+// Disconnect from all MCP servers
+export const disconnectAllMCPServers = async () => {
+    for (const [name] of connections) {
+        await disconnectMCPServer(name);
+    }
+};
+// Load MCP servers from configuration
+export const loadMCPConfig = async (configPath = './mcp.json') => {
+    try {
+        const { readFile } = await import('fs/promises');
+        const content = await readFile(configPath, 'utf-8');
+        const config = JSON.parse(content);
+        return config.servers || [];
+    }
+    catch {
+        return [];
+    }
+};

package/dist/mcp/manager.d.ts

@@ -0,0 +1,186 @@
+/**
+ * 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 { z } from 'zod';
+export declare const MCPServerConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    url: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["stdio", "sse", "http"]>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    trust: z.ZodOptional<z.ZodEnum<["full", "partial", "none"]>>;
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    enabled: boolean;
+    command?: string | undefined;
+    type?: "stdio" | "sse" | "http" | undefined;
+    args?: string[] | undefined;
+    env?: Record<string, string> | undefined;
+    url?: string | undefined;
+    timeout?: number | undefined;
+    trust?: "full" | "partial" | "none" | undefined;
+}, {
+    name: string;
+    command?: string | undefined;
+    type?: "stdio" | "sse" | "http" | undefined;
+    args?: string[] | undefined;
+    env?: Record<string, string> | undefined;
+    url?: string | undefined;
+    timeout?: number | undefined;
+    trust?: "full" | "partial" | "none" | undefined;
+    enabled?: boolean | undefined;
+}>;
+export type MCPServerConfig = z.infer<typeof MCPServerConfigSchema>;
+export interface MCPTool {
+    name: string;
+    description: string;
+    serverName: string;
+    inputSchema: Record<string, unknown>;
+    execute: (args: Record<string, unknown>) => Promise<unknown>;
+}
+export interface MCPResource {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+    serverName: string;
+}
+export interface MCPPrompt {
+    name: string;
+    description?: string;
+    serverName: string;
+    arguments?: Array<{
+        name: string;
+        description?: string;
+        required?: boolean;
+    }>;
+    invoke: (params: Record<string, unknown>) => Promise<{
+        messages: Array<{
+            role: string;
+            content: string;
+        }>;
+    }>;
+}
+export declare enum MCPServerStatus {
+    DISCONNECTED = "disconnected",
+    CONNECTING = "connecting",
+    CONNECTED = "connected",
+    ERROR = "error"
+}
+/**
+ * MCP Client Manager
+ * Manages connections to multiple MCP servers and aggregates their tools
+ */
+export declare class MCPManager {
+    private servers;
+    private onStatusChange?;
+    constructor(options?: {
+        onStatusChange?: (serverName: string, status: MCPServerStatus) => void;
+    });
+    /**
+     * Load MCP configuration from all available sources
+     */
+    loadConfig(configPath?: string): Promise<MCPServerConfig[]>;
+    /**
+     * Parse MCP config content which can be in multiple formats
+     */
+    private parseConfigContent;
+    /**
+     * Connect to an MCP server
+     */
+    connect(config: MCPServerConfig): Promise<void>;
+    /**
+     * Connect to all configured servers
+     */
+    connectAll(configs?: MCPServerConfig[]): Promise<void>;
+    /**
+     * Disconnect from an MCP server
+     */
+    disconnect(serverName: string): Promise<void>;
+    /**
+     * Disconnect from all servers
+     */
+    disconnectAll(): Promise<void>;
+    /**
+     * Discover tools, resources, and prompts from a server
+     */
+    private discover;
+    /**
+     * Get all discovered tools from all connected servers
+     */
+    getAllTools(): MCPTool[];
+    /**
+     * Get all discovered resources from all connected servers
+     */
+    getAllResources(): MCPResource[];
+    /**
+     * Get all discovered prompts from all connected servers
+     */
+    getAllPrompts(): MCPPrompt[];
+    /**
+     * Get a specific tool by name
+     */
+    getTool(name: string): MCPTool | undefined;
+    /**
+     * Execute an MCP tool
+     */
+    executeTool(name: string, args: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Read an MCP resource
+     */
+    readResource(uri: string): Promise<{
+        contents: Array<{
+            uri: string;
+            text?: string;
+            blob?: string;
+        }>;
+    }>;
+    /**
+     * Invoke an MCP prompt
+     */
+    invokePrompt(name: string, params: Record<string, unknown>): Promise<{
+        messages: Array<{
+            role: string;
+            content: string;
+        }>;
+    }>;
+    /**
+     * Get server status
+     */
+    getServerStatus(serverName: string): MCPServerStatus;
+    /**
+     * Get all server statuses
+     */
+    getAllServerStatuses(): Map<string, MCPServerStatus>;
+    private updateStatus;
+}
+/**
+ * Create Composio MCP configuration
+ * Composio provides pre-built integrations for 250+ tools
+ */
+export declare function createComposioConfig(apiKey?: string): MCPServerConfig;
+/**
+ * Create filesystem MCP configuration
+ */
+export declare function createFilesystemConfig(allowedPaths: string[]): MCPServerConfig;
+/**
+ * Create GitHub MCP configuration
+ */
+export declare function createGitHubConfig(token?: string): MCPServerConfig;
+/**
+ * Create memory/context MCP configuration
+ */
+export declare function createMemoryConfig(): MCPServerConfig;
+/**
+ * Create Brave Search MCP configuration
+ */
+export declare function createBraveSearchConfig(apiKey?: string): MCPServerConfig;
+/**
+ * Get or create the global MCP manager instance
+ */
+export declare function getMCPManager(): MCPManager;