thatgfsj-code 0.2.1 → 0.2.2

package/src/core/tool-registry.ts

@@ -1,157 +0,0 @@
-/**
- * Tool Registry - Manages available tools with context support
- * S02: Enhanced with inputSchema generation and permission metadata
- */
-
-import { Tool, ToolResult, ToolContext, ToolInputSchema } from './types.js';
-
-export class ToolRegistry {
-  private tools: Map<string, Tool> = new Map();
-  private context: ToolContext = {};
-
-  constructor() {
-    this.registerDefaultTools();
-  }
-
-  setContext(ctx: Partial<ToolContext>) {
-    this.context = { ...this.context, ...ctx };
-  }
-
-  getContext(): ToolContext {
-    return this.context;
-  }
-
-  register(tool: Tool): void {
-    if (this.tools.has(tool.name)) {
-      console.warn(`Tool ${tool.name} already exists, overwriting...`);
-    }
-    this.tools.set(tool.name, tool);
-  }
-
-  unregister(name: string): boolean {
-    return this.tools.delete(name);
-  }
-
-  get(name: string): Tool | undefined {
-    return this.tools.get(name);
-  }
-
-  list(): string[] {
-    return Array.from(this.tools.keys());
-  }
-
-  /**
-   * S02: Get tools formatted for AI API
-   * Uses inputSchema if available, otherwise builds from parameters
-   */
-  getToolsForAPI() {
-    return Array.from(this.tools.values()).map(tool => ({
-      type: 'function' as const,
-      function: {
-        name: tool.name,
-        description: tool.description,
-        parameters: tool.inputSchema || this.buildInputSchema(tool)
-      }
-    }));
-  }
-
-  /**
-   * S02: Build JSON Schema from legacy parameters array
-   */
-  private buildInputSchema(tool: Tool): ToolInputSchema {
-    return {
-      type: 'object',
-      properties: tool.parameters.reduce((acc, p) => {
-        acc[p.name] = {
-          type: p.type === 'string' ? 'string'
-              : p.type === 'number' ? 'number'
-              : p.type === 'boolean' ? 'boolean'
-              : 'string',
-          description: p.description
-        };
-        return acc;
-      }, {} as Record<string, { type: string; description: string }>),
-      required: tool.parameters.filter(p => p.required).map(p => p.name)
-    };
-  }
-
-  /**
-   * S02: List all tools with their metadata
-   */
-  listAll() {
-    return Array.from(this.tools.values()).map(t => ({
-      name: t.name,
-      description: t.description,
-      permissions: t.metadata?.permissions,
-      tags: t.metadata?.tags,
-      deprecated: t.metadata?.deprecated
-    }));
-  }
-
-  async execute(name: string, params: Record<string, any>): Promise<ToolResult> {
-    const tool = this.tools.get(name);
-
-    if (!tool) {
-      return { success: false, error: `Tool "${name}" not found` };
-    }
-
-    // S02: Validate params against inputSchema
-    const validationError = this.validateParams(tool, params);
-    if (validationError) {
-      return { success: false, error: validationError };
-    }
-
-    try {
-      return await tool.execute(params, this.context);
-    } catch (error: any) {
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
-   * S02: Validate params against tool's inputSchema
-   */
-  private validateParams(tool: Tool, params: Record<string, any>): string | null {
-    const schema = tool.inputSchema || this.buildInputSchema(tool);
-
-    // Check required
-    if (schema.required) {
-      for (const req of schema.required) {
-        if (params[req] === undefined || params[req] === null) {
-          return `Missing required parameter: ${req}`;
-        }
-      }
-    }
-
-    // Check types
-    for (const [key, value] of Object.entries(params)) {
-      const prop = schema.properties[key];
-      if (prop && value !== undefined) {
-        const expectedType = prop.type;
-        const actualType = typeof value;
-        // Type coercion for string/number
-        if (expectedType === 'number' && actualType === 'string' && !isNaN(Number(value))) {
-          // Auto-coerce strings to numbers — ok
-        } else if (actualType !== expectedType) {
-          return `Invalid type for ${key}: expected ${expectedType}, got ${actualType}`;
-        }
-      }
-    }
-
-    return null;
-  }
-
-  async executeAll(tools: Array<{ name: string; params: Record<string, any> }>): Promise<ToolResult[]> {
-    const results: ToolResult[] = [];
-    for (const { name, params } of tools) {
-      const result = await this.execute(name, params);
-      results.push(result);
-      if (!result.success) break;
-    }
-    return results;
-  }
-
-  private registerDefaultTools(): void {
-    // Tools registered externally via AIEngine
-  }
-}

package/src/core/types.ts

@@ -1,280 +0,0 @@
-/**
- * Type definitions for Thatgfsj Code
- * S02: Enhanced Tool interface with Builder pattern, inputSchema, and metadata
- */
-
-export type Role = 'system' | 'user' | 'assistant' | 'tool';
-
-export interface ChatMessage {
-  role: Role;
-  content: string;
-  name?: string;
-  tool_calls?: ToolCall[];
-  tool_call_id?: string;
-  reasoning_content?: string;
-}
-
-export interface ToolCall {
-  id: string;
-  type: 'function';
-  function: {
-    name: string;
-    arguments: string;
-  };
-}
-
-export interface AIResponse {
-  content: string;
-  role: 'assistant';
-  usage?: {
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens: number;
-  };
-  tool_calls?: ToolCall[];
-  reasoning_content?: string;
-}
-
-export interface AIConfig {
-  model: string;
-  apiKey?: string;
-  temperature?: number;
-  maxTokens?: number;
-  baseUrl?: string;
-  provider?: 'minimax' | 'openai' | 'siliconflow' | 'anthropic' | 'ollama' | 'custom' | 'gemini' | 'kimi' | 'deepseek' | 'ernie';
-}
-
-// ==================== S02: Enhanced Tool Interface ====================
-
-/**
- * Tool parameter with type support
- */
-export interface ToolParameter {
-  name: string;
-  type: string;
-  description: string;
-  required: boolean;
-  default?: any;
-  enum?: string[];
-}
-
-/**
- * S02: Input Schema — JSON Schema style tool input definition
- * Claude Code uses this for structured tool parameter validation
- */
-export interface ToolInputSchema {
-  type: 'object';
-  properties: Record<string, {
-    type: string;
-    description: string;
-    default?: any;
-    enum?: string[];
-  }>;
-  required?: string[];
-}
-
-/**
- * S02: Tool metadata — extra info beyond name/description
- */
-export interface ToolMetadata {
-  /** Permission category: read, write, execute, network */
-  permissions?: ('read' | 'write' | 'execute' | 'network')[];
-  /** Max execution time in ms */
-  maxDuration?: number;
-  /** Tags for categorization */
-  tags?: string[];
-  /** Version */
-  version?: string;
-  /** Deprecation notice */
-  deprecated?: string;
-}
-
-/**
- * S02: Tool interface with inputSchema + metadata
- * Both 'parameters' (legacy) and 'inputSchema' (new) are supported
- */
-export interface Tool {
-  name: string;
-  description: string;
-  /** Legacy parameter list (still used by existing tools) */
-  parameters: ToolParameter[];
-  /** S02: JSON Schema for tool input (computed from parameters) */
-  inputSchema?: ToolInputSchema;
-  /** S02: Metadata for permissions, tags, etc. */
-  metadata?: ToolMetadata;
-  execute(params: Record<string, any>, ctx?: ToolContext): Promise<ToolResult>;
-}
-
-/**
- * S02: Enriched execution context
- */
-export interface ToolContext {
-  sessionId?: string;
-  workingDirectory?: string;
-  confirmAction?: (msg: string) => Promise<boolean>;
-  signal?: AbortSignal;
-  toolCallId?: string;
-}
-
-// Legacy alias
-export { ToolParameter as ToolParam };
-
-/**
- * S02: Tool Builder — fluent API to construct tools
- */
-export class ToolBuilder {
-  private _name = '';
-  private _description = '';
-  private _parameters: ToolParameter[] = [];
-  private _inputSchema: ToolInputSchema = { type: 'object', properties: {} };
-  private _metadata: ToolMetadata = {};
-  private _fn?: (params: Record<string, any>, ctx: ToolContext) => Promise<ToolResult>;
-
-  name(n: string): this { this._name = n; return this; }
-  description(d: string): this { this._description = d; return this; }
-
-  param(p: ToolParameter): this {
-    this._parameters.push(p);
-    this._inputSchema.properties[p.name] = {
-      type: p.type,
-      description: p.description,
-      default: p.default,
-      enum: p.enum
-    };
-    return this;
-  }
-
-  stringParam(name: string, description: string, required = true, defaultVal?: string): this {
-    return this.param({ name, type: 'string', description, required, default: defaultVal });
-  }
-
-  numberParam(name: string, description: string, required = true, defaultVal?: number): this {
-    return this.param({ name, type: 'number', description, required, default: defaultVal });
-  }
-
-  booleanParam(name: string, description: string, required: boolean = false, defaultVal?: boolean): this {
-    return this.param({ name, type: 'boolean', description, required, default: defaultVal });
-  }
-
-  required(...names: string[]): this {
-    this._inputSchema.required = names;
-    return this;
-  }
-
-  meta(m: ToolMetadata): this {
-    this._metadata = { ...this._metadata, ...m };
-    return this;
-  }
-
-  permissions(...perms: ('read' | 'write' | 'execute' | 'network')[]): this {
-    this._metadata.permissions = perms;
-    return this;
-  }
-
-  tags(...t: string[]): this {
-    this._metadata.tags = t;
-    return this;
-  }
-
-  handle(fn: (params: Record<string, any>, ctx: ToolContext) => Promise<ToolResult>): this {
-    this._fn = fn;
-    return this;
-  }
-
-  build(): Tool {
-    if (!this._name || !this._fn) {
-      throw new Error('Tool name and handler are required');
-    }
-    return {
-      name: this._name,
-      description: this._description,
-      parameters: this._parameters,
-      inputSchema: this._inputSchema,
-      metadata: this._metadata,
-      execute: this._fn
-    };
-  }
-}
-
-// ==================== Tool Registry Enhancement ====================
-
-export interface ToolResult {
-  success: boolean;
-  output?: string;
-  error?: string;
-  data?: any;
-}
-
-export interface Session {
-  id: string;
-  messages: ChatMessage[];
-  createdAt: Date;
-  lastActiveAt: Date;
-}
-
-export interface Config {
-  model: string;
-  apiKey: string;
-  temperature: number;
-  maxTokens: number;
-  provider?: 'minimax' | 'openai' | 'siliconflow' | 'anthropic' | 'ollama' | 'custom' | 'gemini' | 'kimi' | 'deepseek' | 'ernie';
-  baseUrl?: string;
-}
-
-// Provider configurations
-export const PROVIDERS = {
-  minimax: {
-    name: 'MiniMax',
-    baseUrl: 'https://api.minimax.io/anthropic/v1',
-    defaultModel: 'MiniMax-M2.5',
-    envKeys: ['MINIMAX_API_KEY', 'OPENAI_API_KEY']
-  },
-  siliconflow: {
-    name: 'SiliconFlow (硅基流动)',
-    baseUrl: 'https://api.siliconflow.cn/v1',
-    defaultModel: 'Qwen/Qwen2.5-7B-Instruct',
-    envKeys: ['SILICONFLOW_API_KEY', 'OPENAI_API_KEY']
-  },
-  openai: {
-    name: 'OpenAI',
-    baseUrl: 'https://api.openai.com/v1',
-    defaultModel: 'gpt-4o-mini',
-    envKeys: ['OPENAI_API_KEY']
-  },
-  anthropic: {
-    name: 'Anthropic',
-    baseUrl: 'https://api.anthropic.com/v1',
-    defaultModel: 'claude-3-haiku-20240307',
-    envKeys: ['ANTHROPIC_API_KEY']
-  },
-  ollama: {
-    name: 'Ollama (Local)',
-    baseUrl: process.env.OLLAMA_BASE_URL || 'http://localhost:11434',
-    defaultModel: 'llama2',
-    envKeys: []
-  },
-  gemini: {
-    name: 'Google Gemini',
-    baseUrl: 'https://generativelanguage.googleapis.com/v1beta',
-    defaultModel: 'gemini-1.5-flash',
-    envKeys: ['GEMINI_API_KEY']
-  },
-  kimi: {
-    name: 'Kimi (Moonshot AI)',
-    baseUrl: 'https://api.moonshot.cn/v1',
-    defaultModel: 'moonshot-v1-8k',
-    envKeys: ['KIMI_API_KEY', 'MOONSHOT_API_KEY']
-  },
-  deepseek: {
-    name: 'DeepSeek',
-    baseUrl: 'https://api.deepseek.com/v1',
-    defaultModel: 'deepseek-chat',
-    envKeys: ['DEEPSEEK_API_KEY']
-  },
-  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']
-  }
-} as const;