@stan-chen/simple-cli 0.2.2 → 0.2.4

package/dist/lib/ui.js

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

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

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

@@ -1,186 +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 { 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;