thatgfsj-code 0.3.0

package/src/config/providers.ts

@@ -0,0 +1,160 @@
+/**
+ * Provider definitions and model catalogs
+ * Consolidated from old types.ts PROVIDERS + welcome.ts model lists
+ */
+
+import type { ProviderConfig, ProviderName, ModelInfo } from './types.js';
+
+// ==================== Provider Definitions ====================
+
+export const PROVIDERS: Record<ProviderName, ProviderConfig> = {
+  siliconflow: {
+    name: 'SiliconFlow (硅基流动)',
+    baseUrl: 'https://api.siliconflow.cn/v1',
+    defaultModel: 'Qwen/Qwen2.5-7B-Instruct',
+    envKeys: ['SILICONFLOW_API_KEY', 'OPENAI_API_KEY'],
+    format: 'openai',
+  },
+  minimax: {
+    name: 'MiniMax',
+    baseUrl: 'https://api.minimax.io/anthropic/v1',
+    defaultModel: 'MiniMax-M2.5',
+    envKeys: ['MINIMAX_API_KEY', 'OPENAI_API_KEY'],
+    format: 'anthropic',
+  },
+  openai: {
+    name: 'OpenAI',
+    baseUrl: 'https://api.openai.com/v1',
+    defaultModel: 'gpt-4o-mini',
+    envKeys: ['OPENAI_API_KEY'],
+    format: 'openai',
+  },
+  anthropic: {
+    name: 'Anthropic',
+    baseUrl: 'https://api.anthropic.com/v1',
+    defaultModel: 'claude-3-haiku-20240307',
+    envKeys: ['ANTHROPIC_API_KEY'],
+    format: 'anthropic',
+  },
+  ollama: {
+    name: 'Ollama (Local)',
+    baseUrl: process.env.OLLAMA_BASE_URL || 'http://localhost:11434',
+    defaultModel: 'llama2',
+    envKeys: [],
+    format: 'openai',
+  },
+  gemini: {
+    name: 'Google Gemini',
+    baseUrl: 'https://generativelanguage.googleapis.com/v1beta',
+    defaultModel: 'gemini-1.5-flash',
+    envKeys: ['GEMINI_API_KEY'],
+    format: 'gemini',
+  },
+  kimi: {
+    name: 'Kimi (Moonshot AI)',
+    baseUrl: 'https://api.moonshot.cn/v1',
+    defaultModel: 'moonshot-v1-8k',
+    envKeys: ['KIMI_API_KEY', 'MOONSHOT_API_KEY'],
+    format: 'openai',
+  },
+  deepseek: {
+    name: 'DeepSeek',
+    baseUrl: 'https://api.deepseek.com/v1',
+    defaultModel: 'deepseek-chat',
+    envKeys: ['DEEPSEEK_API_KEY'],
+    format: 'openai',
+  },
+  ernie: {
+    name: 'Baidu ERNIE (文心一言)',
+    baseUrl: 'https://aip.baidubce.com/rpc/2.0/ai_custom/v1',
+    defaultModel: 'ernie-4.0-8k',
+    envKeys: ['ERNIE_API_KEY', 'BAIDU_API_KEY'],
+    format: 'openai',
+  },
+};
+
+// ==================== Model Catalogs ====================
+
+export const MODEL_CATALOGS: Record<ProviderName, ModelInfo[]> = {
+  siliconflow: [
+    { id: 'Qwen/Qwen2.5-7B-Instruct', name: 'Qwen2.5-7B (推荐)', desc: '性价比高，适合日常编程' },
+    { id: 'Qwen/Qwen2.5-32B-Instruct', name: 'Qwen2.5-32B', desc: '更强性能，适合复杂任务' },
+    { id: 'Qwen/Qwen2.5-72B-Instruct', name: 'Qwen2.5-72B', desc: '旗舰模型' },
+    { id: 'Pro/moonshotai/Kimi-K2.5', name: 'Kimi-K2.5 (私有)', desc: 'Moonshot 强力模型' },
+    { id: 'Pro/deepseek-ai/DeepSeek-V3', name: 'DeepSeek-V3', desc: '深度求索最新模型' },
+    { id: 'Pro/deepseek-ai/DeepSeek-R1', name: 'DeepSeek-R1', desc: '推理能力强' },
+    { id: 'THUDM/glm-4-9b-chat', name: 'GLM-4-9B', desc: '智谱模型' },
+    { id: 'THUDM/glm-4-32b-chat', name: 'GLM-4-32B', desc: '智谱大模型' },
+    { id: '01-ai/Yi-1.5-34B-Chat', name: 'Yi-1.5-34B', desc: '零一万物' },
+    { id: 'microsoft/WizardLM-2-8x22B', name: 'WizardLM-2', desc: '微软开源' },
+  ],
+  minimax: [
+    { id: 'MiniMax-M2.5', name: 'MiniMax-M2.5 (推荐)', desc: 'Agent 能力最强' },
+    { id: 'MiniMax-M2.1', name: 'MiniMax-M2.1', desc: '稳定版本' },
+  ],
+  openai: [
+    { id: 'gpt-4o-mini', name: 'GPT-4o-mini (推荐)', desc: '性价比高' },
+    { id: 'gpt-4o', name: 'GPT-4o', desc: '最新旗舰' },
+    { id: 'gpt-4-turbo', name: 'GPT-4-Turbo', desc: '强性能' },
+  ],
+  anthropic: [
+    { id: 'claude-3-haiku-20240307', name: 'Claude-3-Haiku (推荐)', desc: '快速响应' },
+    { id: 'claude-3.5-sonnet-20241022', name: 'Claude-3.5-Sonnet', desc: '最新旗舰' },
+    { id: 'claude-3-opus-20240229', name: 'Claude-3-Opus', desc: '最强性能' },
+  ],
+  ollama: [
+    { id: 'llama2', name: 'Llama 2', desc: 'Meta 开源模型' },
+    { id: 'codellama', name: 'Code Llama', desc: '编程专用' },
+    { id: 'mistral', name: 'Mistral', desc: '高性能开源' },
+  ],
+  gemini: [
+    { id: 'gemini-1.5-flash-8b', name: 'Gemini-1.5-Flash-8B (推荐)', desc: '免费快速' },
+    { id: 'gemini-1.5-flash', name: 'Gemini-1.5-Flash', desc: '性价比高' },
+    { id: 'gemini-1.5-pro', name: 'Gemini-1.5-Pro', desc: '最新旗舰' },
+  ],
+  kimi: [
+    { id: 'moonshot-v1-8k', name: 'Moonshot-V1-8K (推荐)', desc: '日常编程' },
+    { id: 'moonshot-v1-32k', name: 'Moonshot-V1-32K', desc: '更长上下文' },
+    { id: 'moonshot-v1-128k', name: 'Moonshot-V1-128K', desc: '超长上下文' },
+  ],
+  deepseek: [
+    { id: 'deepseek-chat', name: 'DeepSeek-Chat (推荐)', desc: '性价比高' },
+    { id: 'deepseek-coder', name: 'DeepSeek-Coder', desc: '编程专用' },
+  ],
+  ernie: [
+    { id: 'ernie-4.0-8k', name: 'ERNIE-4.0-8K (推荐)', desc: '百度旗舰' },
+    { id: 'ernie-3.5-8k', name: 'ERNIE-3.5-8K', desc: '性价比高' },
+  ],
+};
+
+// ==================== Helpers ====================
+
+/**
+ * Get models for a specific provider
+ */
+export function getModelsForProvider(provider: ProviderName): ModelInfo[] {
+  return MODEL_CATALOGS[provider] || MODEL_CATALOGS.siliconflow;
+}
+
+/**
+ * Get API key for a provider from environment variables
+ */
+export function getApiKeyFromEnv(provider: ProviderName): string {
+  const providerConfig = PROVIDERS[provider];
+  if (!providerConfig) return '';
+
+  for (const envKey of providerConfig.envKeys) {
+    if (process.env[envKey]) return process.env[envKey];
+  }
+  return '';
+}
+
+/**
+ * List all provider names
+ */
+export function listProviders(): Array<{ key: ProviderName; name: string }> {
+  return Object.entries(PROVIDERS).map(([key, val]) => ({
+    key: key as ProviderName,
+    name: val.name,
+  }));
+}

package/src/config/types.ts

@@ -0,0 +1,46 @@
+/**
+ * Configuration types for Thatgfsj Code
+ */
+
+export type ProviderName =
+  | 'siliconflow'
+  | 'minimax'
+  | 'openai'
+  | 'anthropic'
+  | 'ollama'
+  | 'gemini'
+  | 'kimi'
+  | 'deepseek'
+  | 'ernie';
+
+export interface ProviderConfig {
+  name: string;
+  baseUrl: string;
+  defaultModel: string;
+  envKeys: string[];
+  format: 'openai' | 'anthropic' | 'gemini';
+}
+
+export interface Config {
+  model: string;
+  apiKey: string;
+  temperature: number;
+  maxTokens: number;
+  provider: ProviderName;
+  baseUrl?: string;
+}
+
+export interface AIConfig {
+  model: string;
+  apiKey?: string;
+  temperature?: number;
+  maxTokens?: number;
+  baseUrl?: string;
+  provider?: ProviderName;
+}
+
+export interface ModelInfo {
+  id: string;
+  name: string;
+  desc: string;
+}

package/src/hooks/index.ts

@@ -0,0 +1,111 @@
+/**
+ * Hooks System - Event-driven lifecycle hooks
+ * Migrated from old src/core/hooks.ts
+ */
+
+import type { ChatMessage, ToolCall } from '../types.js';
+
+// ==================== Hook Types ====================
+
+export type HookName =
+  | 'beforeToolCall'
+  | 'afterToolCall'
+  | 'beforeAgentLoop'
+  | 'afterAgentLoop'
+  | 'onError';
+
+export interface HookContext {
+  toolName?: string;
+  toolParams?: Record<string, any>;
+  toolResult?: any;
+  messages?: ChatMessage[];
+  error?: Error;
+  iteration?: number;
+  [key: string]: any;
+}
+
+export type HookFn = (ctx: HookContext) => void | Promise<void>;
+
+interface HookRegistration {
+  name: HookName;
+  fn: HookFn;
+  priority?: number;
+  once?: boolean;
+}
+
+// ==================== Hook Manager ====================
+
+export class HookManager {
+  private hooks: Map<HookName, HookRegistration[]> = new Map();
+
+  constructor() {
+    const allHooks: HookName[] = ['beforeToolCall', 'afterToolCall', 'beforeAgentLoop', 'afterAgentLoop', 'onError'];
+    for (const h of allHooks) {
+      this.hooks.set(h, []);
+    }
+  }
+
+  register(name: HookName, fn: HookFn, priority = 0, once = false): void {
+    const regs = this.hooks.get(name) || [];
+    regs.push({ name, fn, priority, once });
+    regs.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+    this.hooks.set(name, regs);
+  }
+
+  unregister(name: HookName, fn: HookFn): void {
+    const regs = this.hooks.get(name) || [];
+    this.hooks.set(name, regs.filter(r => r.fn !== fn));
+  }
+
+  clear(name?: HookName): void {
+    if (name) {
+      this.hooks.set(name, []);
+    } else {
+      for (const regs of this.hooks.values()) {
+        regs.length = 0;
+      }
+    }
+  }
+
+  async emit(name: HookName, ctx: HookContext): Promise<void> {
+    const regs = this.hooks.get(name) || [];
+    for (const reg of regs) {
+      try {
+        await Promise.resolve(reg.fn(ctx));
+      } catch (error: any) {
+        console.error(`[Hook ${name}] error:`, error.message);
+      }
+      if (reg.once) {
+        this.unregister(name, reg.fn);
+      }
+    }
+  }
+
+  hasHooks(name: HookName): boolean {
+    return (this.hooks.get(name)?.length || 0) > 0;
+  }
+}
+
+// ==================== Built-in Hooks ====================
+
+/**
+ * Audit logging hook - logs all tool calls
+ */
+export function auditLogHook(ctx: HookContext): void {
+  if (ctx.toolName) {
+    const ts = new Date().toISOString().split('T')[1].split('.')[0];
+    const status = ctx.toolResult?.success ? 'OK' : 'FAIL';
+    console.log(`[AUDIT ${ts}] ${status} | tool=${ctx.toolName} | params=${JSON.stringify(ctx.toolParams || {})}`);
+  }
+}
+
+// ==================== Singleton ====================
+
+let globalHookManager: HookManager | null = null;
+
+export function getHookManager(): HookManager {
+  if (!globalHookManager) {
+    globalHookManager = new HookManager();
+  }
+  return globalHookManager;
+}

package/src/llm/anthropic.ts

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

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