@oflow-ai/core 0.1.0

package/dist/config/index.d.ts

@@ -0,0 +1,20 @@
+import { Config, AuthConfig } from '../types';
+export declare class ConfigManager {
+    private config;
+    constructor();
+    get<K extends keyof Config>(key: K): Config[K];
+    set<K extends keyof Config>(key: K, value: Config[K]): void;
+    getAll(): Config;
+    setAll(config: Partial<Config>): void;
+    clear(): void;
+    getAuth(): AuthConfig | undefined;
+    setAuth(auth: AuthConfig): void;
+    isAuthenticated(): boolean;
+    getDefaultModel(): string;
+    setDefaultModel(model: string): void;
+    getShowThinking(): boolean;
+    setShowThinking(show: boolean): void;
+    toggleShowThinking(): boolean;
+    getConfigPath(): string;
+}
+export declare function getConfigManager(): ConfigManager;

package/dist/config/index.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigManager = void 0;
+exports.getConfigManager = getConfigManager;
+const conf_1 = __importDefault(require("conf"));
+const DEFAULT_CONFIG = {
+    defaultModel: 'gpt-4o',
+    maxTokens: 4096,
+    temperature: 0.7,
+    sandbox: false,
+    showThinking: false, // 默认不显示思考过程
+    mcpServers: {}
+};
+class ConfigManager {
+    config;
+    constructor() {
+        this.config = new conf_1.default({
+            projectName: 'oflow',
+            defaults: DEFAULT_CONFIG
+        });
+    }
+    get(key) {
+        return this.config.get(key);
+    }
+    set(key, value) {
+        this.config.set(key, value);
+    }
+    getAll() {
+        return this.config.store;
+    }
+    setAll(config) {
+        for (const [key, value] of Object.entries(config)) {
+            this.config.set(key, value);
+        }
+    }
+    clear() {
+        this.config.clear();
+    }
+    getAuth() {
+        return this.config.get('auth');
+    }
+    setAuth(auth) {
+        this.config.set('auth', auth);
+    }
+    isAuthenticated() {
+        const auth = this.getAuth();
+        return !!(auth?.apiKey);
+    }
+    getDefaultModel() {
+        return this.config.get('defaultModel') || 'gpt-4o';
+    }
+    setDefaultModel(model) {
+        this.config.set('defaultModel', model);
+    }
+    // 思考过程显示控制
+    getShowThinking() {
+        return this.config.get('showThinking') ?? false;
+    }
+    setShowThinking(show) {
+        this.config.set('showThinking', show);
+    }
+    toggleShowThinking() {
+        const current = this.getShowThinking();
+        this.setShowThinking(!current);
+        return !current;
+    }
+    getConfigPath() {
+        return this.config.path;
+    }
+}
+exports.ConfigManager = ConfigManager;
+// Singleton instance
+let configManager = null;
+function getConfigManager() {
+    if (!configManager) {
+        configManager = new ConfigManager();
+    }
+    return configManager;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/conversation.d.ts

@@ -0,0 +1,26 @@
+import { Message, ToolCall } from './types';
+import { AIProvider } from './ai/openai-provider';
+export interface ConversationOptions {
+    provider: AIProvider;
+    workingDirectory?: string;
+    maxTokens?: number;
+    temperature?: number;
+    showThinking?: boolean;
+    onContent?: (content: string) => void;
+    onThinking?: (thinking: string) => void;
+    onToolCall?: (toolCall: ToolCall) => void;
+    onToolResult?: (result: string) => void;
+}
+export declare class Conversation {
+    private messages;
+    private provider;
+    private toolRegistry;
+    private options;
+    constructor(options: ConversationOptions);
+    addMessage(message: Message): void;
+    setSystemPrompt(prompt: string): void;
+    getMessages(): Message[];
+    clear(): void;
+    sendMessage(userMessage: string): Promise<string>;
+    private processConversation;
+}

package/dist/conversation.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Conversation = void 0;
+const tools_1 = require("./tools");
+class Conversation {
+    messages = [];
+    provider;
+    toolRegistry;
+    options;
+    constructor(options) {
+        this.provider = options.provider;
+        this.toolRegistry = (0, tools_1.getToolRegistry)();
+        this.options = options;
+    }
+    addMessage(message) {
+        this.messages.push(message);
+    }
+    setSystemPrompt(prompt) {
+        // Remove existing system prompt if any
+        this.messages = this.messages.filter(m => m.role !== 'system');
+        // Add new system prompt at the beginning
+        this.messages.unshift({ role: 'system', content: prompt });
+    }
+    getMessages() {
+        return this.messages;
+    }
+    clear() {
+        this.messages = [];
+    }
+    async sendMessage(userMessage) {
+        this.addMessage({ role: 'user', content: userMessage });
+        return this.processConversation();
+    }
+    async processConversation() {
+        let finalResponse = '';
+        let iterations = 0;
+        const maxIterations = 20; // Prevent infinite loops
+        while (iterations < maxIterations) {
+            iterations++;
+            const chatOptions = {
+                messages: this.messages,
+                tools: this.toolRegistry.getDefinitions(),
+                toolChoice: 'auto',
+                maxTokens: this.options.maxTokens || 4096,
+                temperature: this.options.temperature || 0.7,
+                stream: true
+            };
+            let currentContent = '';
+            let currentThinking = '';
+            let toolCalls = [];
+            let currentId = '';
+            try {
+                await this.provider.chatStream(chatOptions, (chunk) => {
+                    currentId = chunk.id;
+                    // 处理思考过程
+                    if (chunk.delta.reasoning && this.options.showThinking) {
+                        currentThinking += chunk.delta.reasoning;
+                        this.options.onThinking?.(chunk.delta.reasoning);
+                    }
+                    if (chunk.delta.content) {
+                        currentContent += chunk.delta.content;
+                        this.options.onContent?.(chunk.delta.content);
+                    }
+                    if (chunk.delta.toolCalls) {
+                        for (const tc of chunk.delta.toolCalls) {
+                            if (tc.id && tc.function?.name) {
+                                toolCalls.push({
+                                    id: tc.id,
+                                    type: 'function',
+                                    function: {
+                                        name: tc.function.name,
+                                        arguments: tc.function.arguments || ''
+                                    }
+                                });
+                            }
+                            else {
+                                // Update existing tool call
+                                const existing = toolCalls.find(t => t.id === tc.id);
+                                if (existing && tc.function?.arguments) {
+                                    existing.function.arguments += tc.function.arguments;
+                                }
+                            }
+                        }
+                    }
+                });
+                // Add assistant message
+                const assistantMessage = {
+                    role: 'assistant',
+                    content: currentContent || ''
+                };
+                if (toolCalls.length > 0) {
+                    assistantMessage.toolCalls = toolCalls;
+                }
+                this.messages.push(assistantMessage);
+                // Process tool calls
+                if (toolCalls.length > 0) {
+                    for (const toolCall of toolCalls) {
+                        this.options.onToolCall?.(toolCall);
+                        const toolOptions = {
+                            workingDirectory: this.options.workingDirectory
+                        };
+                        const result = await this.toolRegistry.execute(toolCall, toolOptions);
+                        this.options.onToolResult?.(result.content);
+                        // Add tool result message
+                        this.messages.push({
+                            role: 'tool',
+                            toolCallId: toolCall.id,
+                            content: result.content
+                        });
+                    }
+                    // Continue conversation to get final response
+                    continue;
+                }
+                // No tool calls, we have the final response
+                finalResponse = currentContent;
+                break;
+            }
+            catch (error) {
+                throw new Error(`Conversation error: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        return finalResponse;
+    }
+}
+exports.Conversation = Conversation;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"conversation.js","sourceRoot":"","sources":["../src/conversation.ts"],"names":[],"mappings":"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","sourcesContent":["import { Message, ChatCompletionOptions, ToolCall, StreamChunk } from './types';\nimport { AIProvider } from './ai/openai-provider';\nimport { ToolRegistry, getToolRegistry, ToolExecuteOptions } from './tools';\n\nexport interface ConversationOptions {\n  provider: AIProvider;\n  workingDirectory?: string;\n  maxTokens?: number;\n  temperature?: number;\n  showThinking?: boolean; // 是否显示思考过程\n  onContent?: (content: string) => void;\n  onThinking?: (thinking: string) => void; // 思考过程回调\n  onToolCall?: (toolCall: ToolCall) => void;\n  onToolResult?: (result: string) => void;\n}\n\nexport class Conversation {\n  private messages: Message[] = [];\n  private provider: AIProvider;\n  private toolRegistry: ToolRegistry;\n  private options: ConversationOptions;\n\n  constructor(options: ConversationOptions) {\n    this.provider = options.provider;\n    this.toolRegistry = getToolRegistry();\n    this.options = options;\n  }\n\n  addMessage(message: Message): void {\n    this.messages.push(message);\n  }\n\n  setSystemPrompt(prompt: string): void {\n    // Remove existing system prompt if any\n    this.messages = this.messages.filter(m => m.role !== 'system');\n    // Add new system prompt at the beginning\n    this.messages.unshift({ role: 'system', content: prompt });\n  }\n\n  getMessages(): Message[] {\n    return this.messages;\n  }\n\n  clear(): void {\n    this.messages = [];\n  }\n\n  async sendMessage(userMessage: string): Promise<string> {\n    this.addMessage({ role: 'user', content: userMessage });\n    return this.processConversation();\n  }\n\n  private async processConversation(): Promise<string> {\n    let finalResponse = '';\n    let iterations = 0;\n    const maxIterations = 20; // Prevent infinite loops\n\n    while (iterations < maxIterations) {\n      iterations++;\n\n      const chatOptions: ChatCompletionOptions = {\n        messages: this.messages,\n        tools: this.toolRegistry.getDefinitions(),\n        toolChoice: 'auto',\n        maxTokens: this.options.maxTokens || 4096,\n        temperature: this.options.temperature || 0.7,\n        stream: true\n      };\n\n      let currentContent = '';\n      let currentThinking = '';\n      let toolCalls: ToolCall[] = [];\n      let currentId = '';\n\n      try {\n        await this.provider.chatStream(chatOptions, (chunk: StreamChunk) => {\n          currentId = chunk.id;\n          \n          // 处理思考过程\n          if (chunk.delta.reasoning && this.options.showThinking) {\n            currentThinking += chunk.delta.reasoning;\n            this.options.onThinking?.(chunk.delta.reasoning);\n          }\n\n          if (chunk.delta.content) {\n            currentContent += chunk.delta.content;\n            this.options.onContent?.(chunk.delta.content);\n          }\n\n          if (chunk.delta.toolCalls) {\n            for (const tc of chunk.delta.toolCalls) {\n              if (tc.id && tc.function?.name) {\n                toolCalls.push({\n                  id: tc.id,\n                  type: 'function',\n                  function: {\n                    name: tc.function.name,\n                    arguments: tc.function.arguments || ''\n                  }\n                });\n              } else {\n                // Update existing tool call\n                const existing = toolCalls.find(t => t.id === tc.id);\n                if (existing && tc.function?.arguments) {\n                  existing.function.arguments += tc.function.arguments;\n                }\n              }\n            }\n          }\n        });\n\n        // Add assistant message\n        const assistantMessage: Message = {\n          role: 'assistant',\n          content: currentContent || ''\n        };\n\n        if (toolCalls.length > 0) {\n          assistantMessage.toolCalls = toolCalls;\n        }\n\n        this.messages.push(assistantMessage);\n\n        // Process tool calls\n        if (toolCalls.length > 0) {\n          for (const toolCall of toolCalls) {\n            this.options.onToolCall?.(toolCall);\n\n            const toolOptions: ToolExecuteOptions = {\n              workingDirectory: this.options.workingDirectory\n            };\n\n            const result = await this.toolRegistry.execute(toolCall, toolOptions);\n            \n            this.options.onToolResult?.(result.content);\n\n            // Add tool result message\n            this.messages.push({\n              role: 'tool',\n              toolCallId: toolCall.id,\n              content: result.content\n            });\n          }\n\n          // Continue conversation to get final response\n          continue;\n        }\n\n        // No tool calls, we have the final response\n        finalResponse = currentContent;\n        break;\n\n      } catch (error) {\n        throw new Error(`Conversation error: ${error instanceof Error ? error.message : String(error)}`);\n      }\n    }\n\n    return finalResponse;\n  }\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from './types';
+export { ConfigManager, getConfigManager } from './config';
+export { createAIProvider, OpenAIProvider, CustomProvider, ChineseProvider } from './ai';
+export { ToolRegistry, getToolRegistry, BaseTool, ReadFileTool, WriteFileTool, ListDirectoryTool, GlobTool, SearchFileContentTool, RunShellCommandTool, WebSearchTool, WebFetchTool, ReplaceTool, ImageReadTool, PDFExtractTool, AskUserQuestionTool, TaskTool, SaveMemoryTool } from './tools';
+export { Conversation } from './conversation';
+export { MCPClient, MCPManager } from './mcp';
+export { SkillManager } from './skills';
+export { Agent, AgentFactory, AgentDefinition, AgentResult, AgentType, AGENT_DEFINITIONS } from './agents';
+export { SandboxExecutor, SandboxBackend, SandboxConfig, SandboxResult, createSandboxExecutor } from './sandbox';
+export { CHINESE_MODELS, DEFAULT_CHINESE_MODELS } from './ai/chinese-provider';

package/dist/index.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CHINESE_MODELS = exports.CHINESE_MODELS = exports.createSandboxExecutor = exports.SandboxExecutor = exports.AGENT_DEFINITIONS = exports.AgentFactory = exports.Agent = exports.SkillManager = exports.MCPManager = exports.MCPClient = exports.Conversation = exports.SaveMemoryTool = exports.TaskTool = exports.AskUserQuestionTool = exports.PDFExtractTool = exports.ImageReadTool = exports.ReplaceTool = exports.WebFetchTool = exports.WebSearchTool = exports.RunShellCommandTool = exports.SearchFileContentTool = exports.GlobTool = exports.ListDirectoryTool = exports.WriteFileTool = exports.ReadFileTool = exports.BaseTool = exports.getToolRegistry = exports.ToolRegistry = exports.ChineseProvider = exports.CustomProvider = exports.OpenAIProvider = exports.createAIProvider = exports.getConfigManager = exports.ConfigManager = void 0;
+// Types
+__exportStar(require("./types"), exports);
+// Configuration
+var config_1 = require("./config");
+Object.defineProperty(exports, "ConfigManager", { enumerable: true, get: function () { return config_1.ConfigManager; } });
+Object.defineProperty(exports, "getConfigManager", { enumerable: true, get: function () { return config_1.getConfigManager; } });
+// AI Providers
+var ai_1 = require("./ai");
+Object.defineProperty(exports, "createAIProvider", { enumerable: true, get: function () { return ai_1.createAIProvider; } });
+Object.defineProperty(exports, "OpenAIProvider", { enumerable: true, get: function () { return ai_1.OpenAIProvider; } });
+Object.defineProperty(exports, "CustomProvider", { enumerable: true, get: function () { return ai_1.CustomProvider; } });
+Object.defineProperty(exports, "ChineseProvider", { enumerable: true, get: function () { return ai_1.ChineseProvider; } });
+// Tools
+var tools_1 = require("./tools");
+Object.defineProperty(exports, "ToolRegistry", { enumerable: true, get: function () { return tools_1.ToolRegistry; } });
+Object.defineProperty(exports, "getToolRegistry", { enumerable: true, get: function () { return tools_1.getToolRegistry; } });
+Object.defineProperty(exports, "BaseTool", { enumerable: true, get: function () { return tools_1.BaseTool; } });
+Object.defineProperty(exports, "ReadFileTool", { enumerable: true, get: function () { return tools_1.ReadFileTool; } });
+Object.defineProperty(exports, "WriteFileTool", { enumerable: true, get: function () { return tools_1.WriteFileTool; } });
+Object.defineProperty(exports, "ListDirectoryTool", { enumerable: true, get: function () { return tools_1.ListDirectoryTool; } });
+Object.defineProperty(exports, "GlobTool", { enumerable: true, get: function () { return tools_1.GlobTool; } });
+Object.defineProperty(exports, "SearchFileContentTool", { enumerable: true, get: function () { return tools_1.SearchFileContentTool; } });
+Object.defineProperty(exports, "RunShellCommandTool", { enumerable: true, get: function () { return tools_1.RunShellCommandTool; } });
+Object.defineProperty(exports, "WebSearchTool", { enumerable: true, get: function () { return tools_1.WebSearchTool; } });
+Object.defineProperty(exports, "WebFetchTool", { enumerable: true, get: function () { return tools_1.WebFetchTool; } });
+Object.defineProperty(exports, "ReplaceTool", { enumerable: true, get: function () { return tools_1.ReplaceTool; } });
+Object.defineProperty(exports, "ImageReadTool", { enumerable: true, get: function () { return tools_1.ImageReadTool; } });
+Object.defineProperty(exports, "PDFExtractTool", { enumerable: true, get: function () { return tools_1.PDFExtractTool; } });
+Object.defineProperty(exports, "AskUserQuestionTool", { enumerable: true, get: function () { return tools_1.AskUserQuestionTool; } });
+Object.defineProperty(exports, "TaskTool", { enumerable: true, get: function () { return tools_1.TaskTool; } });
+Object.defineProperty(exports, "SaveMemoryTool", { enumerable: true, get: function () { return tools_1.SaveMemoryTool; } });
+// Conversation
+var conversation_1 = require("./conversation");
+Object.defineProperty(exports, "Conversation", { enumerable: true, get: function () { return conversation_1.Conversation; } });
+// MCP
+var mcp_1 = require("./mcp");
+Object.defineProperty(exports, "MCPClient", { enumerable: true, get: function () { return mcp_1.MCPClient; } });
+Object.defineProperty(exports, "MCPManager", { enumerable: true, get: function () { return mcp_1.MCPManager; } });
+// Skills
+var skills_1 = require("./skills");
+Object.defineProperty(exports, "SkillManager", { enumerable: true, get: function () { return skills_1.SkillManager; } });
+// Agents
+var agents_1 = require("./agents");
+Object.defineProperty(exports, "Agent", { enumerable: true, get: function () { return agents_1.Agent; } });
+Object.defineProperty(exports, "AgentFactory", { enumerable: true, get: function () { return agents_1.AgentFactory; } });
+Object.defineProperty(exports, "AGENT_DEFINITIONS", { enumerable: true, get: function () { return agents_1.AGENT_DEFINITIONS; } });
+// Sandbox
+var sandbox_1 = require("./sandbox");
+Object.defineProperty(exports, "SandboxExecutor", { enumerable: true, get: function () { return sandbox_1.SandboxExecutor; } });
+Object.defineProperty(exports, "createSandboxExecutor", { enumerable: true, get: function () { return sandbox_1.createSandboxExecutor; } });
+// 国内模型常量
+var chinese_provider_1 = require("./ai/chinese-provider");
+Object.defineProperty(exports, "CHINESE_MODELS", { enumerable: true, get: function () { return chinese_provider_1.CHINESE_MODELS; } });
+Object.defineProperty(exports, "DEFAULT_CHINESE_MODELS", { enumerable: true, get: function () { return chinese_provider_1.DEFAULT_CHINESE_MODELS; } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mcp/index.d.ts

@@ -0,0 +1,48 @@
+import { EventEmitter } from 'events';
+import { ToolDefinition } from '../types';
+export interface MCPServerConfig {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export interface MCPTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface MCPClientEvents {
+    'tool-list': (tools: MCPTool[]) => void;
+    'tool-result': (result: unknown) => void;
+    'error': (error: Error) => void;
+    'close': () => void;
+}
+export declare class MCPClient extends EventEmitter {
+    private process;
+    private serverName;
+    private config;
+    private requestId;
+    private pendingRequests;
+    private buffer;
+    private tools;
+    constructor(serverName: string, config: MCPServerConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    private handleData;
+    private handleResponse;
+    private sendRequest;
+    private loadTools;
+    getTools(): MCPTool[];
+    getToolDefinitions(): ToolDefinition[];
+    callTool(name: string, args: Record<string, unknown>): Promise<unknown>;
+    isConnected(): boolean;
+}
+export declare class MCPManager {
+    private clients;
+    addServer(name: string, config: MCPServerConfig): Promise<MCPClient>;
+    removeServer(name: string): Promise<void>;
+    getClient(name: string): MCPClient | undefined;
+    getAllClients(): MCPClient[];
+    getAllTools(): MCPTool[];
+    getAllToolDefinitions(): ToolDefinition[];
+    disconnectAll(): Promise<void>;
+}

package/dist/mcp/index.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPManager = exports.MCPClient = void 0;
+const child_process_1 = require("child_process");
+const events_1 = require("events");
+class MCPClient extends events_1.EventEmitter {
+    process = null;
+    serverName;
+    config;
+    requestId = 0;
+    pendingRequests = new Map();
+    buffer = '';
+    tools = [];
+    constructor(serverName, config) {
+        super();
+        this.serverName = serverName;
+        this.config = config;
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            const env = { ...process.env, ...this.config.env };
+            this.process = (0, child_process_1.spawn)(this.config.command, this.config.args || [], {
+                env,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            this.process.stdout?.on('data', (data) => {
+                this.handleData(data.toString());
+            });
+            this.process.stderr?.on('data', (data) => {
+                console.error(`[MCP ${this.serverName}] ${data.toString()}`);
+            });
+            this.process.on('error', (error) => {
+                this.emit('error', error);
+                reject(error);
+            });
+            this.process.on('close', () => {
+                this.emit('close');
+            });
+            // Initialize connection
+            this.sendRequest('initialize', {
+                protocolVersion: '2024-11-05',
+                capabilities: {},
+                clientInfo: {
+                    name: 'oflow-cli',
+                    version: '0.1.0'
+                }
+            }).then(() => {
+                return this.loadTools();
+            }).then(() => {
+                resolve();
+            }).catch(reject);
+        });
+    }
+    async disconnect() {
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+        }
+    }
+    handleData(data) {
+        this.buffer += data;
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() || '';
+        for (const line of lines) {
+            if (line.trim()) {
+                try {
+                    const response = JSON.parse(line);
+                    this.handleResponse(response);
+                }
+                catch {
+                    // Ignore parse errors
+                }
+            }
+        }
+    }
+    handleResponse(response) {
+        if (response.id !== undefined && this.pendingRequests.has(response.id)) {
+            const pending = this.pendingRequests.get(response.id);
+            this.pendingRequests.delete(response.id);
+            if (response.error) {
+                pending.reject(new Error(response.error.message));
+            }
+            else {
+                pending.resolve(response.result);
+            }
+        }
+    }
+    sendRequest(method, params = {}) {
+        return new Promise((resolve, reject) => {
+            const id = this.requestId++;
+            this.pendingRequests.set(id, { resolve, reject });
+            const request = JSON.stringify({
+                jsonrpc: '2.0',
+                id,
+                method,
+                params
+            }) + '\n';
+            this.process?.stdin?.write(request);
+        });
+    }
+    async loadTools() {
+        try {
+            const result = await this.sendRequest('tools/list');
+            this.tools = result.tools || [];
+            this.emit('tool-list', this.tools);
+        }
+        catch {
+            // Server might not support tools
+            this.tools = [];
+        }
+    }
+    getTools() {
+        return this.tools;
+    }
+    getToolDefinitions() {
+        return this.tools.map(tool => ({
+            type: 'function',
+            function: {
+                name: `${this.serverName}__${tool.name}`,
+                description: tool.description,
+                parameters: tool.inputSchema
+            }
+        }));
+    }
+    async callTool(name, args) {
+        const result = await this.sendRequest('tools/call', {
+            name,
+            arguments: args
+        });
+        return result;
+    }
+    isConnected() {
+        return this.process !== null && !this.process.killed;
+    }
+}
+exports.MCPClient = MCPClient;
+class MCPManager {
+    clients = new Map();
+    async addServer(name, config) {
+        if (this.clients.has(name)) {
+            await this.removeServer(name);
+        }
+        const client = new MCPClient(name, config);
+        await client.connect();
+        this.clients.set(name, client);
+        return client;
+    }
+    async removeServer(name) {
+        const client = this.clients.get(name);
+        if (client) {
+            await client.disconnect();
+            this.clients.delete(name);
+        }
+    }
+    getClient(name) {
+        return this.clients.get(name);
+    }
+    getAllClients() {
+        return Array.from(this.clients.values());
+    }
+    getAllTools() {
+        return this.getAllClients().flatMap(client => client.getTools());
+    }
+    getAllToolDefinitions() {
+        return this.getAllClients().flatMap(client => client.getToolDefinitions());
+    }
+    async disconnectAll() {
+        for (const client of this.clients.values()) {
+            await client.disconnect();
+        }
+        this.clients.clear();
+    }
+}
+exports.MCPManager = MCPManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { spawn, ChildProcess } from 'child_process';\nimport { EventEmitter } from 'events';\nimport { ToolDefinition } from '../types';\n\nexport interface MCPServerConfig {\n  command: string;\n  args?: string[];\n  env?: Record<string, string>;\n}\n\nexport interface MCPTool {\n  name: string;\n  description: string;\n  inputSchema: Record<string, unknown>;\n}\n\nexport interface MCPClientEvents {\n  'tool-list': (tools: MCPTool[]) => void;\n  'tool-result': (result: unknown) => void;\n  'error': (error: Error) => void;\n  'close': () => void;\n}\n\nexport class MCPClient extends EventEmitter {\n  private process: ChildProcess | null = null;\n  private serverName: string;\n  private config: MCPServerConfig;\n  private requestId = 0;\n  private pendingRequests: Map<number, {\n    resolve: (value: unknown) => void;\n    reject: (error: Error) => void;\n  }> = new Map();\n  private buffer = '';\n  private tools: MCPTool[] = [];\n\n  constructor(serverName: string, config: MCPServerConfig) {\n    super();\n    this.serverName = serverName;\n    this.config = config;\n  }\n\n  async connect(): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const env = { ...process.env, ...this.config.env };\n      \n      this.process = spawn(this.config.command, this.config.args || [], {\n        env,\n        stdio: ['pipe', 'pipe', 'pipe']\n      });\n\n      this.process.stdout?.on('data', (data: Buffer) => {\n        this.handleData(data.toString());\n      });\n\n      this.process.stderr?.on('data', (data: Buffer) => {\n        console.error(`[MCP ${this.serverName}] ${data.toString()}`);\n      });\n\n      this.process.on('error', (error: Error) => {\n        this.emit('error', error);\n        reject(error);\n      });\n\n      this.process.on('close', () => {\n        this.emit('close');\n      });\n\n      // Initialize connection\n      this.sendRequest('initialize', {\n        protocolVersion: '2024-11-05',\n        capabilities: {},\n        clientInfo: {\n          name: 'oflow-cli',\n          version: '0.1.0'\n        }\n      }).then(() => {\n        return this.loadTools();\n      }).then(() => {\n        resolve();\n      }).catch(reject);\n    });\n  }\n\n  async disconnect(): Promise<void> {\n    if (this.process) {\n      this.process.kill();\n      this.process = null;\n    }\n  }\n\n  private handleData(data: string): void {\n    this.buffer += data;\n    \n    const lines = this.buffer.split('\\n');\n    this.buffer = lines.pop() || '';\n\n    for (const line of lines) {\n      if (line.trim()) {\n        try {\n          const response = JSON.parse(line);\n          this.handleResponse(response);\n        } catch {\n          // Ignore parse errors\n        }\n      }\n    }\n  }\n\n  private handleResponse(response: any): void {\n    if (response.id !== undefined && this.pendingRequests.has(response.id)) {\n      const pending = this.pendingRequests.get(response.id)!;\n      this.pendingRequests.delete(response.id);\n\n      if (response.error) {\n        pending.reject(new Error(response.error.message));\n      } else {\n        pending.resolve(response.result);\n      }\n    }\n  }\n\n  private sendRequest(method: string, params: unknown = {}): Promise<unknown> {\n    return new Promise((resolve, reject) => {\n      const id = this.requestId++;\n      \n      this.pendingRequests.set(id, { resolve, reject });\n\n      const request = JSON.stringify({\n        jsonrpc: '2.0',\n        id,\n        method,\n        params\n      }) + '\\n';\n\n      this.process?.stdin?.write(request);\n    });\n  }\n\n  private async loadTools(): Promise<void> {\n    try {\n      const result = await this.sendRequest('tools/list') as { tools: MCPTool[] };\n      this.tools = result.tools || [];\n      this.emit('tool-list', this.tools);\n    } catch {\n      // Server might not support tools\n      this.tools = [];\n    }\n  }\n\n  getTools(): MCPTool[] {\n    return this.tools;\n  }\n\n  getToolDefinitions(): ToolDefinition[] {\n    return this.tools.map(tool => ({\n      type: 'function' as const,\n      function: {\n        name: `${this.serverName}__${tool.name}`,\n        description: tool.description,\n        parameters: tool.inputSchema\n      }\n    }));\n  }\n\n  async callTool(name: string, args: Record<string, unknown>): Promise<unknown> {\n    const result = await this.sendRequest('tools/call', {\n      name,\n      arguments: args\n    });\n    return result;\n  }\n\n  isConnected(): boolean {\n    return this.process !== null && !this.process.killed;\n  }\n}\n\nexport class MCPManager {\n  private clients: Map<string, MCPClient> = new Map();\n\n  async addServer(name: string, config: MCPServerConfig): Promise<MCPClient> {\n    if (this.clients.has(name)) {\n      await this.removeServer(name);\n    }\n\n    const client = new MCPClient(name, config);\n    await client.connect();\n    this.clients.set(name, client);\n    \n    return client;\n  }\n\n  async removeServer(name: string): Promise<void> {\n    const client = this.clients.get(name);\n    if (client) {\n      await client.disconnect();\n      this.clients.delete(name);\n    }\n  }\n\n  getClient(name: string): MCPClient | undefined {\n    return this.clients.get(name);\n  }\n\n  getAllClients(): MCPClient[] {\n    return Array.from(this.clients.values());\n  }\n\n  getAllTools(): MCPTool[] {\n    return this.getAllClients().flatMap(client => client.getTools());\n  }\n\n  getAllToolDefinitions(): ToolDefinition[] {\n    return this.getAllClients().flatMap(client => client.getToolDefinitions());\n  }\n\n  async disconnectAll(): Promise<void> {\n    for (const client of this.clients.values()) {\n      await client.disconnect();\n    }\n    this.clients.clear();\n  }\n}\n"]}