thatgfsj-code 0.3.0

package/src/llm/index.ts

@@ -0,0 +1,209 @@
+/**
+ * LLM Service - Factory for creating providers
+ * Replaces the monolithic AIEngine with a clean provider abstraction
+ */
+
+import chalk from 'chalk';
+import type { ChatMessage, ChatResponse, ChatOptions, ToolCall } from '../types.js';
+import type { Tool } from '../tools/types.js';
+import type { LLMProvider } from './provider.js';
+import type { AIConfig, ProviderName } from '../config/types.js';
+import { PROVIDERS } from '../config/providers.js';
+import { OpenAIProvider } from './openai.js';
+import { AnthropicProvider } from './anthropic.js';
+import { GeminiProvider } from './gemini.js';
+
+export class LLMService {
+  private provider: LLMProvider;
+  private tools: Map<string, Tool> = new Map();
+
+  constructor(provider: LLMProvider) {
+    this.provider = provider;
+  }
+
+  /**
+   * Create LLMService from AIConfig
+   */
+  static fromConfig(config: AIConfig): LLMService {
+    const providerName = config.provider || 'siliconflow';
+    const providerConfig = PROVIDERS[providerName];
+
+    const providerCfg = {
+      apiKey: config.apiKey || '',
+      model: config.model || providerConfig.defaultModel,
+      baseUrl: config.baseUrl || providerConfig.baseUrl,
+      temperature: config.temperature ?? 0.7,
+      maxTokens: config.maxTokens ?? 4096,
+    };
+
+    const format = providerConfig.format;
+    let provider: LLMProvider;
+
+    switch (format) {
+      case 'anthropic':
+        provider = new AnthropicProvider(providerCfg);
+        break;
+      case 'gemini':
+        provider = new GeminiProvider(providerCfg);
+        break;
+      default:
+        provider = new OpenAIProvider(providerCfg);
+    }
+
+    return new LLMService(provider);
+  }
+
+  /**
+   * Register tools for function calling
+   */
+  registerTools(tools: Tool[]): void {
+    for (const tool of tools) {
+      this.tools.set(tool.name, tool);
+    }
+  }
+
+  /**
+   * Get provider name
+   */
+  getProviderName(): string {
+    return this.provider.name;
+  }
+
+  /**
+   * Non-streaming chat
+   */
+  async chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse> {
+    if (!this.hasApiKey()) {
+      return this.getMockResponse(messages);
+    }
+    return this.provider.chat(messages, options);
+  }
+
+  /**
+   * Streaming chat with agent loop (tool call support)
+   */
+  async *chatStream(
+    messages: ChatMessage[],
+    options?: ChatOptions & { maxIterations?: number }
+  ): AsyncGenerator<string, ChatResponse> {
+    if (!this.hasApiKey()) {
+      const mock = this.getMockResponse(messages);
+      for (const char of mock.content) {
+        await new Promise(r => setTimeout(r, 10));
+        yield char;
+      }
+      return mock;
+    }
+
+    const maxIterations = options?.maxIterations ?? 10;
+    let currentMessages = [...messages];
+    let iterations = 0;
+
+    while (iterations < maxIterations) {
+      iterations++;
+
+      // Get tools in provider format
+      const toolsArray = [...this.tools.values()];
+      const providerTools = toolsArray.length > 0 ? this.provider.buildTools(toolsArray) : [];
+
+      // Stream the response
+      let fullContent = '';
+      const streamOptions = { ...options };
+
+      // Add tools to the request if available
+      if (providerTools.length > 0) {
+        // We need to pass tools differently depending on provider
+        // For now, inject into messages context
+      }
+
+      for await (const chunk of this.provider.chatStream(currentMessages, streamOptions)) {
+        fullContent += chunk;
+        yield chunk;
+      }
+
+      // Check for tool calls in the response
+      const response = await this.provider.chat(currentMessages, { ...streamOptions, stream: false });
+      const toolCalls = response.tool_calls;
+
+      if (toolCalls && toolCalls.length > 0) {
+        // Append assistant message with tool calls
+        currentMessages.push({
+          role: 'assistant',
+          content: fullContent,
+          tool_calls: toolCalls,
+        });
+
+        // Execute each tool
+        for (const toolCall of toolCalls) {
+          const tool = this.tools.get(toolCall.function.name);
+          if (!tool) {
+            currentMessages.push({
+              role: 'tool',
+              content: `Tool "${toolCall.function.name}" not found`,
+              tool_call_id: toolCall.id,
+              name: toolCall.function.name,
+            });
+            continue;
+          }
+
+          try {
+            const params = JSON.parse(toolCall.function.arguments || '{}');
+            const result = await tool.execute(params);
+            currentMessages.push({
+              role: 'tool',
+              content: result.success ? (result.output || JSON.stringify(result.data)) : (result.error || 'Tool failed'),
+              tool_call_id: toolCall.id,
+              name: toolCall.function.name,
+            });
+            yield `\n${chalk.gray(`[tool: ${toolCall.function.name}]`)}`;
+          } catch (error: any) {
+            currentMessages.push({
+              role: 'tool',
+              content: `Tool execution error: ${error.message}`,
+              tool_call_id: toolCall.id,
+              name: toolCall.function.name,
+            });
+          }
+        }
+
+        continue; // Loop back for next iteration
+      }
+
+      // No tool calls - we're done
+      return response;
+    }
+
+    return { content: '[Agent loop exceeded maximum iterations]', role: 'assistant' };
+  }
+
+  /**
+   * Check if API key is available
+   */
+  private hasApiKey(): boolean {
+    return !!(this.provider as any).config?.apiKey;
+  }
+
+  /**
+   * Mock response when no API key is set
+   */
+  private getMockResponse(messages: ChatMessage[]): ChatResponse {
+    const last = messages[messages.length - 1]?.content || '';
+    let content: string;
+
+    if (/^(hi|hello|hey)/i.test(last)) {
+      content = 'Hi there! How can I help you today?';
+    } else if (last.toLowerCase().includes('who are you')) {
+      content = 'I am Thatgfsj Code, an AI coding assistant.';
+    } else {
+      content = `I understand you said: "${last.slice(0, 50)}..."\n\nThis is a demo response. Configure an API key for full AI capabilities.\nRun: gfcode init`;
+    }
+
+    return { content, role: 'assistant' };
+  }
+}
+
+// Re-export provider types
+export type { LLMProvider, ProviderConfig } from './provider.js';
+export { OpenAIProvider } from './openai.js';
+export { AnthropicProvider } from './anthropic.js';
+export { GeminiProvider } from './gemini.js';

package/src/llm/openai.ts

@@ -0,0 +1,132 @@
+/**
+ * OpenAI-compatible Provider
+ * Works with: OpenAI, SiliconFlow, MiniMax (OpenAI mode), DeepSeek, Kimi, ERNIE, Ollama
+ */
+
+import type { ChatMessage, ChatResponse, ChatOptions } from '../types.js';
+import type { Tool } from '../tools/types.js';
+import type { LLMProvider, ProviderConfig } from './provider.js';
+
+export class OpenAIProvider implements LLMProvider {
+  readonly name = 'openai';
+  private config: ProviderConfig;
+
+  constructor(config: ProviderConfig) {
+    this.config = config;
+  }
+
+  buildTools(tools: Tool[]): any[] {
+    return tools.map(tool => ({
+      type: 'function' as const,
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.inputSchema || {
+          type: 'object',
+          properties: Object.fromEntries(
+            tool.parameters.map(p => [p.name, { type: p.type, description: p.description }])
+          ),
+          required: tool.parameters.filter(p => p.required).map(p => p.name),
+        },
+      },
+    }));
+  }
+
+  async chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse> {
+    const body = this.buildRequest(messages, false, options);
+
+    const response = await fetch(`${this.config.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.config.apiKey}`,
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const text = await response.text().catch(() => '');
+      throw new Error(`OpenAI API error ${response.status}: ${text}`);
+    }
+
+    const data = await response.json();
+    const choice = data.choices?.[0];
+
+    return {
+      content: choice?.message?.content || '',
+      role: 'assistant',
+      usage: data.usage,
+      tool_calls: choice?.message?.tool_calls,
+    };
+  }
+
+  async *chatStream(messages: ChatMessage[], options?: ChatOptions): AsyncGenerator<string, ChatResponse> {
+    const body = this.buildRequest(messages, true, options);
+
+    const response = await fetch(`${this.config.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.config.apiKey}`,
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok || !response.body) {
+      const text = await response.text().catch(() => '');
+      throw new Error(`OpenAI API error ${response.status}: ${text}`);
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let fullContent = '';
+    let buffer = '';
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith('data: ') || trimmed === 'data: [DONE]') continue;
+
+          try {
+            const data = JSON.parse(trimmed.slice(6));
+            const content = data.choices?.[0]?.delta?.content;
+            if (content) {
+              fullContent += content;
+              yield content;
+            }
+          } catch {
+            // Skip invalid JSON lines
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+
+    return { content: fullContent, role: 'assistant' };
+  }
+
+  private buildRequest(messages: ChatMessage[], stream: boolean, options?: ChatOptions) {
+    return {
+      model: this.config.model,
+      messages: messages.map(m => ({
+        role: m.role,
+        content: m.content,
+        ...(m.name && { name: m.name }),
+        ...(m.tool_call_id && { tool_call_id: m.tool_call_id }),
+        ...(m.tool_calls && { tool_calls: m.tool_calls }),
+      })),
+      temperature: options?.temperature ?? this.config.temperature,
+      max_tokens: options?.maxTokens ?? this.config.maxTokens,
+      stream,
+    };
+  }
+}

package/src/llm/provider.ts

@@ -0,0 +1,38 @@
+/**
+ * Abstract LLM Provider interface
+ * All providers implement this interface
+ */
+
+import type { ChatMessage, ChatResponse, ChatOptions } from '../types.js';
+import type { Tool } from '../tools/types.js';
+
+export interface LLMProvider {
+  /** Provider name for logging */
+  readonly name: string;
+
+  /**
+   * Non-streaming chat completion
+   */
+  chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse>;
+
+  /**
+   * Streaming chat completion - yields text chunks
+   */
+  chatStream(messages: ChatMessage[], options?: ChatOptions): AsyncGenerator<string, ChatResponse>;
+
+  /**
+   * Convert Tool[] to provider-specific format
+   */
+  buildTools(tools: Tool[]): any[];
+}
+
+/**
+ * Provider configuration passed to each provider
+ */
+export interface ProviderConfig {
+  apiKey: string;
+  model: string;
+  baseUrl: string;
+  temperature: number;
+  maxTokens: number;
+}

package/src/mcp/client.ts

@@ -0,0 +1,330 @@
+/**
+ * S07: MCP Client (Model Context Protocol)
+ * Connect to MCP servers and expose their tools as agent tools
+ * 
+ * MCP turns the agent from a closed system into an open platform.
+ * Any server can expose tools via the MCP JSON-RPC 2.0 protocol.
+ */
+
+import { spawn, ChildProcess } from 'child_process';
+import type { Tool, ToolResult } from '../tools/types.js';
+
+// ==================== MCP Types ====================
+
+interface MCPJsonRPCRequest {
+  jsonrpc: '2.0';
+  id: number | string;
+  method: string;
+  params?: any;
+}
+
+interface MCPJsonRPCResponse {
+  jsonrpc: '2.0';
+  id: number | string;
+  result?: any;
+  error?: { code: number; message: string; data?: any };
+}
+
+interface MCPTool {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: 'object';
+    properties: Record<string, any>;
+    required?: string[];
+  };
+}
+
+// ==================== MCP Client ====================
+
+export class MCPClient {
+  private process: ChildProcess | null = null;
+  private tools: Map<string, MCPTool> = new Map();
+  private requestId = 0;
+  private pendingRequests: Map<number | string, {
+    resolve: (value: any) => void;
+    reject: (reason: any) => void;
+  }> = new Map();
+  private name: string;
+  private connected = false;
+
+  constructor(name: string) {
+    this.name = name;
+  }
+
+  /**
+   * S07: Connect to an MCP server
+   * @param command Command to run (e.g., 'npx', 'node')
+   * @param args Arguments (e.g., ['-y', '@modelcontextprotocol/server-filesystem', '/path/to/dir'])
+   */
+  async connect(command: string, args: string[]): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.process = spawn(command, args, {
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+
+      let buffer = '';
+
+      this.process.stdout?.on('data', (data: Buffer) => {
+        buffer += data.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (line.trim()) {
+            this.handleMessage(line);
+          }
+        }
+      });
+
+      this.process.stderr?.on('data', (data: Buffer) => {
+        console.error(`[MCP ${this.name}] stderr:`, data.toString().trim());
+      });
+
+      this.process.on('error', (err) => {
+        reject(err);
+      });
+
+      this.process.on('close', (code) => {
+        this.connected = false;
+        console.log(`[MCP ${this.name}] exited with code ${code}`);
+      });
+
+      // Initialize MCP connection
+      this.sendRequest('initialize', {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: {} },
+        clientInfo: { name: 'thatgfsj-code', version: '1.0.0' }
+      }).then(() => {
+        this.connected = true;
+        // Send initialized notification
+        this.sendNotification('initialized', {});
+        // List available tools
+        return this.listTools();
+      }).then(() => {
+        resolve();
+      }).catch(reject);
+
+      // Timeout
+      setTimeout(() => reject(new Error('MCP connection timeout')), 30000);
+    });
+  }
+
+  /**
+   * S07: Handle incoming JSON-RPC message
+   */
+  private handleMessage(raw: string): void {
+    try {
+      const msg: MCPJsonRPCResponse = JSON.parse(raw);
+
+      // Handle response
+      const pending = this.pendingRequests.get(msg.id);
+      if (pending) {
+        this.pendingRequests.delete(msg.id);
+        if (msg.error) {
+          pending.reject(new Error(msg.error.message));
+        } else {
+          pending.resolve(msg.result);
+        }
+        return;
+      }
+    } catch {
+      // Not JSON, ignore
+    }
+  }
+
+  /**
+   * S07: Send a JSON-RPC request
+   */
+  private sendRequest(method: string, params: any): Promise<any> {
+    return new Promise((resolve, reject) => {
+      if (!this.process?.connected) {
+        reject(new Error('MCP process not connected'));
+        return;
+      }
+
+      const id = ++this.requestId;
+      this.pendingRequests.set(id, { resolve, reject });
+
+      const request: MCPJsonRPCRequest = {
+        jsonrpc: '2.0',
+        id,
+        method,
+        params
+      };
+
+      this.process.stdin?.write(JSON.stringify(request) + '\n');
+
+      // Timeout
+      setTimeout(() => {
+        if (this.pendingRequests.has(id)) {
+          this.pendingRequests.delete(id);
+          reject(new Error('MCP request timeout: ' + method));
+        }
+      }, 30000);
+    });
+  }
+
+  /**
+   * S07: Send a notification (no response expected)
+   */
+  private sendNotification(method: string, params: any): void {
+    if (!this.process?.connected) return;
+
+    const notification = {
+      jsonrpc: '2.0',
+      method,
+      params
+    };
+
+    this.process.stdin?.write(JSON.stringify(notification) + '\n');
+  }
+
+  /**
+   * S07: Call an MCP tool
+   */
+  async callTool(name: string, arguments_: Record<string, any>): Promise<ToolResult> {
+    try {
+      const result = await this.sendRequest('tools/call', {
+        name,
+        arguments: arguments_
+      });
+
+      return {
+        success: true,
+        output: typeof result === 'string' ? result : JSON.stringify(result)
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * S07: List tools from MCP server
+   */
+  private async listTools(): Promise<void> {
+    try {
+      const result = await this.sendRequest('tools/list', {});
+      const tools: MCPTool[] = result.tools || [];
+
+      this.tools.clear();
+      for (const tool of tools) {
+        this.tools.set(tool.name, tool);
+      }
+
+      console.log(`[MCP ${this.name}] Loaded ${tools.length} tools:`, [...this.tools.keys()].join(', '));
+    } catch (error: any) {
+      console.error(`[MCP ${this.name}] Failed to list tools:`, error.message);
+    }
+  }
+
+  /**
+   * S07: Get registered tools as agent Tool[]
+   */
+  getTools(): Tool[] {
+    return [...this.tools.values()].map(mcpTool => ({
+      name: this.name + ':' + mcpTool.name,
+      description: mcpTool.description,
+      parameters: Object.entries(mcpTool.inputSchema.properties || {}).map(([name, schema]: [string, any]) => ({
+        name,
+        type: schema.type || 'string',
+        description: schema.description || '',
+        required: (mcpTool.inputSchema.required || []).includes(name)
+      })),
+      execute: async (params: Record<string, any>): Promise<ToolResult> => {
+        return this.callTool(mcpTool.name, params);
+      }
+    }));
+  }
+
+  /**
+   * S07: Get tool names
+   */
+  getToolNames(): string[] {
+    return [...this.tools.keys()];
+  }
+
+  /**
+   * S07: Check if connected
+   */
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  /**
+   * S07: Disconnect from MCP server
+   */
+  disconnect(): void {
+    if (this.process) {
+      this.process.kill();
+      this.process = null;
+    }
+    this.connected = false;
+    this.tools.clear();
+    this.pendingRequests.clear();
+  }
+}
+
+// ==================== MCP Server Manager ====================
+
+export class MCPServerManager {
+  private clients: Map<string, MCPClient> = new Map();
+
+  /**
+   * S07: Add and connect an MCP server
+   */
+  async addServer(name: string, command: string, args: string[]): Promise<void> {
+    const client = new MCPClient(name);
+    await client.connect(command, args);
+    this.clients.set(name, client);
+  }
+
+  /**
+   * S07: Get all tools from all servers
+   */
+  getAllTools(): Tool[] {
+    const allTools: Tool[] = [];
+    for (const client of this.clients.values()) {
+      allTools.push(...client.getTools());
+    }
+    return allTools;
+  }
+
+  /**
+   * S07: Get tool names from all servers
+   */
+  getAllToolNames(): string[] {
+    const names: string[] = [];
+    for (const [serverName, client] of this.clients) {
+      for (const toolName of client.getToolNames()) {
+        names.push(serverName + ':' + toolName);
+      }
+    }
+    return names;
+  }
+
+  /**
+   * S07: Disconnect a server
+   */
+  removeServer(name: string): void {
+    const client = this.clients.get(name);
+    if (client) {
+      client.disconnect();
+      this.clients.delete(name);
+    }
+  }
+
+  /**
+   * S07: Get server status
+   */
+  getStatus(): Record<string, boolean> {
+    const status: Record<string, boolean> = {};
+    for (const [name, client] of this.clients) {
+      status[name] = client.isConnected();
+    }
+    return status;
+  }
+}