thatgfsj-code 0.3.0 → 0.3.1

package/src/llm/anthropic.ts

@@ -1,146 +0,0 @@
-/**
- * Anthropic Provider
- * Works with: Anthropic Claude, MiniMax (Anthropic mode)
- */
-
-import type { ChatMessage, ChatResponse, ChatOptions } from '../types.js';
-import type { Tool } from '../tools/types.js';
-import type { LLMProvider, ProviderConfig } from './provider.js';
-
-export class AnthropicProvider implements LLMProvider {
-  readonly name = 'anthropic';
-  private config: ProviderConfig;
-
-  constructor(config: ProviderConfig) {
-    this.config = config;
-  }
-
-  buildTools(tools: Tool[]): any[] {
-    return tools.map(tool => ({
-      name: tool.name,
-      description: tool.description,
-      input_schema: 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}/messages`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-api-key': this.config.apiKey,
-        'anthropic-version': '2023-06-01',
-      },
-      body: JSON.stringify(body),
-    });
-
-    if (!response.ok) {
-      const text = await response.text().catch(() => '');
-      throw new Error(`Anthropic API error ${response.status}: ${text}`);
-    }
-
-    const data = await response.json();
-    const contentBlock = data.content?.find((b: any) => b.type === 'text');
-    const toolUseBlocks = data.content?.filter((b: any) => b.type === 'tool_use') || [];
-
-    return {
-      content: contentBlock?.text || '',
-      role: 'assistant',
-      usage: data.usage ? {
-        prompt_tokens: data.usage.input_tokens || 0,
-        completion_tokens: data.usage.output_tokens || 0,
-        total_tokens: (data.usage.input_tokens || 0) + (data.usage.output_tokens || 0),
-      } : undefined,
-      tool_calls: toolUseBlocks.length > 0 ? toolUseBlocks.map((b: any) => ({
-        id: b.id,
-        type: 'function' as const,
-        function: {
-          name: b.name,
-          arguments: JSON.stringify(b.input),
-        },
-      })) : undefined,
-    };
-  }
-
-  async *chatStream(messages: ChatMessage[], options?: ChatOptions): AsyncGenerator<string, ChatResponse> {
-    const body = this.buildRequest(messages, true, options);
-
-    const response = await fetch(`${this.config.baseUrl}/messages`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-api-key': this.config.apiKey,
-        'anthropic-version': '2023-06-01',
-        'anthropic-dangerous-direct-browser-access': 'true',
-      },
-      body: JSON.stringify(body),
-    });
-
-    if (!response.ok || !response.body) {
-      const text = await response.text().catch(() => '');
-      throw new Error(`Anthropic 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: ')) continue;
-
-          try {
-            const data = JSON.parse(trimmed.slice(6));
-            if (data.type === 'content_block_delta' && data.delta?.type === 'text_delta') {
-              const text = data.delta.text;
-              fullContent += text;
-              yield text;
-            }
-          } catch {
-            // Skip invalid JSON
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-
-    return { content: fullContent, role: 'assistant' };
-  }
-
-  private buildRequest(messages: ChatMessage[], stream: boolean, options?: ChatOptions) {
-    // Anthropic uses separate system message
-    const systemMsg = messages.find(m => m.role === 'system');
-    const nonSystemMsgs = messages.filter(m => m.role !== 'system');
-
-    return {
-      model: this.config.model,
-      max_tokens: options?.maxTokens ?? this.config.maxTokens,
-      temperature: options?.temperature ?? this.config.temperature,
-      ...(systemMsg && { system: systemMsg.content }),
-      messages: nonSystemMsgs.map(m => ({
-        role: m.role === 'assistant' ? 'assistant' : 'user',
-        content: m.content,
-      })),
-      stream,
-    };
-  }
-}

package/src/llm/gemini.ts

@@ -1,127 +0,0 @@
-/**
- * Google Gemini Provider
- */
-
-import type { ChatMessage, ChatResponse, ChatOptions } from '../types.js';
-import type { Tool } from '../tools/types.js';
-import type { LLMProvider, ProviderConfig } from './provider.js';
-
-export class GeminiProvider implements LLMProvider {
-  readonly name = 'gemini';
-  private config: ProviderConfig;
-
-  constructor(config: ProviderConfig) {
-    this.config = config;
-  }
-
-  buildTools(tools: Tool[]): any[] {
-    return tools.map(tool => ({
-      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, options);
-
-    const url = `${this.config.baseUrl}/models/${this.config.model}:generateContent?key=${this.config.apiKey}`;
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(body),
-    });
-
-    if (!response.ok) {
-      const text = await response.text().catch(() => '');
-      throw new Error(`Gemini API error ${response.status}: ${text}`);
-    }
-
-    const data = await response.json();
-    const candidate = data.candidates?.[0];
-    const text = candidate?.content?.parts?.map((p: any) => p.text).join('') || '';
-
-    return {
-      content: text,
-      role: 'assistant',
-      usage: data.usageMetadata ? {
-        prompt_tokens: data.usageMetadata.promptTokenCount || 0,
-        completion_tokens: data.usageMetadata.candidatesTokenCount || 0,
-        total_tokens: data.usageMetadata.totalTokenCount || 0,
-      } : undefined,
-    };
-  }
-
-  async *chatStream(messages: ChatMessage[], options?: ChatOptions): AsyncGenerator<string, ChatResponse> {
-    const body = this.buildRequest(messages, options);
-
-    const url = `${this.config.baseUrl}/models/${this.config.model}:streamGenerateContent?key=${this.config.apiKey}`;
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(body),
-    });
-
-    if (!response.ok || !response.body) {
-      const text = await response.text().catch(() => '');
-      throw new Error(`Gemini 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 });
-
-        // Gemini streams JSON array chunks
-        const jsonMatch = buffer.match(/\{"candidates":\[.*?\]\}/);
-        if (jsonMatch) {
-          try {
-            const data = JSON.parse(jsonMatch[0]);
-            const text = data.candidates?.[0]?.content?.parts?.map((p: any) => p.text).join('') || '';
-            if (text) {
-              fullContent += text;
-              yield text;
-            }
-          } catch {
-            // Skip invalid JSON
-          }
-          buffer = buffer.slice(jsonMatch.index! + jsonMatch[0].length);
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-
-    return { content: fullContent, role: 'assistant' };
-  }
-
-  private buildRequest(messages: ChatMessage[], options?: ChatOptions) {
-    const contents = messages
-      .filter(m => m.role !== 'system')
-      .map(m => ({
-        role: m.role === 'assistant' ? 'model' : 'user',
-        parts: [{ text: m.content }],
-      }));
-
-    return {
-      contents,
-      generationConfig: {
-        temperature: options?.temperature ?? this.config.temperature,
-        maxOutputTokens: options?.maxTokens ?? this.config.maxTokens,
-      },
-    };
-  }
-}

package/src/llm/index.ts

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

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

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