thatgfsj-code 0.2.1

package/src/core/ai-engine.ts

@@ -0,0 +1,437 @@
+/**
+ * AI Engine - Core AI interaction module
+ * Supports multiple providers: MiniMax, SiliconFlow, OpenAI, Anthropic
+ * 
+ * Implements S01: Agent Loop pattern with async generator for streaming
+ * Core pattern: while(true) { response → execute tools → append results → repeat }
+ */
+
+import chalk from 'chalk';
+import { ChatMessage, AIResponse, AIConfig, Tool, ToolCall } from './types.js';
+
+export { AIResponse, ChatMessage };
+
+export class AIEngine {
+  private config: AIConfig;
+  private tools: Map<string, Tool> = new Map();
+
+  constructor(config: AIConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Register tools for function calling
+   */
+  registerTool(tool: Tool) {
+    this.tools.set(tool.name, tool);
+  }
+
+  /**
+   * Unregister a tool
+   */
+  unregisterTool(name: string) {
+    this.tools.delete(name);
+  }
+
+  /**
+   * Get registered tools for API (S02: uses ToolRegistry if available)
+   */
+  private getToolsForAPI() {
+    // If registry is injected, use its getToolsForAPI
+    if (this.registry) {
+      return this.registry.getToolsForAPI();
+    }
+    // Fallback: build from tools map
+    return Array.from(this.tools.values()).map(tool => ({
+      type: 'function' as const,
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: {
+          type: 'object',
+          properties: tool.parameters.reduce((acc, p) => {
+            acc[p.name] = { type: p.type, description: p.description };
+            return acc;
+          }, {} as any),
+          required: tool.parameters.filter(p => p.required).map(p => p.name)
+        }
+      }
+    }));
+  }
+
+  // S02: Inject registry for enhanced tool management
+  setRegistry(registry: any) {
+    this.registry = registry;
+  }
+  private registry?: any;
+
+  // S08: Hook manager
+  setHooks(hooks: import('./hooks.js').HookManager) {
+    this.hooks = hooks;
+  }
+  private hooks?: import('./hooks.js').HookManager | null = null;
+
+  // ==================== S01: Async Generator Agent Loop ====================
+
+  async *chatStream(
+    messages: ChatMessage[],
+    maxIterations: number = 10
+  ): AsyncGenerator<string, AIResponse, unknown> {
+    let currentMessages = [...messages];
+    let iterations = 0;
+
+    while (iterations < maxIterations) {
+      iterations++;
+
+      // S08 Hook: beforeAgentLoop
+      if (this.hooks) {
+        await this.hooks.emit('beforeAgentLoop', { messages: currentMessages, iteration: iterations });
+      }
+
+      let fullResponse = '';
+
+      for await (const chunk of this.streamRequest(currentMessages)) {
+        fullResponse += chunk;
+        yield chunk;
+      }
+
+      const response = this.parseResponse(fullResponse);
+
+      if (response.tool_calls && response.tool_calls.length > 0) {
+        currentMessages.push({
+          role: 'assistant',
+          content: response.content,
+          tool_calls: response.tool_calls
+        });
+
+        // Execute each tool
+        for (const toolCall of response.tool_calls) {
+          // S08 Hook: beforeToolCall
+          if (this.hooks) {
+            await this.hooks.emit('beforeToolCall', {
+              toolName: toolCall.function.name,
+              toolParams: JSON.parse(toolCall.function.arguments || '{}'),
+              toolCallId: toolCall.id
+            });
+          }
+
+          const result = await this.executeToolCall(toolCall);
+
+          // S08 Hook: afterToolCall
+          if (this.hooks) {
+            await this.hooks.emit('afterToolCall', {
+              toolName: toolCall.function.name,
+              toolParams: JSON.parse(toolCall.function.arguments || '{}'),
+              toolResult: result,
+              toolCallId: toolCall.id
+            });
+          }
+
+          const toolResultMsg: ChatMessage = {
+            role: 'tool',
+            content: result.output || result.error || '',
+            tool_call_id: toolCall.id,
+            name: toolCall.function.name
+          };
+          currentMessages.push(toolResultMsg);
+
+          yield `\n${chalk.gray(`[tool: ${toolCall.function.name}]`)}`;
+        }
+
+        continue;
+      }
+
+      // No tool calls — exit loop
+      if (response.content) {
+        currentMessages.push({
+          role: 'assistant',
+          content: response.content
+        });
+      }
+
+      // S08 Hook: afterAgentLoop
+      if (this.hooks) {
+        await this.hooks.emit('afterAgentLoop', { messages: currentMessages, iteration: iterations });
+      }
+
+      return response;
+    }
+
+    // Max iterations reached
+    return {
+      content: '[Agent loop exceeded maximum iterations]',
+      role: 'assistant'
+    };
+  }
+
+  /**
+   * S01 Core: Stream request — yields chunks as they arrive
+   * Uses async generator for backpressure control and lazy evaluation
+   */
+  private async *streamRequest(
+    messages: ChatMessage[]
+  ): AsyncGenerator<string, void, unknown> {
+    const apiKey = this.config.apiKey || this.getApiKey();
+
+    if (!apiKey) {
+      // Mock streaming for demo
+      const mock = this.getMockResponse(messages);
+      for (const char of mock) {
+        await new Promise(r => setTimeout(r, 10));
+        yield char;
+      }
+      return;
+    }
+
+    const isAnthropicFormat = this.config.provider === 'anthropic' || this.config.provider === 'minimax';
+    const isGeminiFormat = this.config.provider === 'gemini';
+
+    let url: string;
+    let headers: Record<string, string> = {};
+    let body: any;
+
+    if (isGeminiFormat) {
+      url = `${this.config.baseUrl}/models/${this.config.model}:generateContent`;
+      headers = { 'Content-Type': 'application/json' };
+      body = this.buildGeminiRequest(messages);
+    } else if (isAnthropicFormat) {
+      url = `${this.config.baseUrl}/messages-stream`;
+      headers = {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+        'anthropic-dangerous-direct-browser-access': 'true'
+      };
+      body = this.buildAnthropicRequest(messages, true);
+    } else {
+      url = `${this.config.baseUrl}/chat/completions`;
+      headers = {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`
+      };
+      body = this.buildOpenAIRequest(messages, true);
+    }
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body)
+    });
+
+    if (!response.ok || !response.body) {
+      yield `\n${chalk.red(`[API Error: ${response.status}]`)}`;
+      return;
+    }
+
+    const decoder = new TextDecoder();
+    const reader = response.body.getReader();
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        const chunk = decoder.decode(value, { stream: true });
+        const text = this.extractChunkText(chunk, isAnthropicFormat, isGeminiFormat);
+        if (text) {
+          yield text;
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+
+  /**
+   * Extract text from streaming chunk based on provider format
+   */
+  private extractChunkText(
+    chunk: string,
+    isAnthropic: boolean,
+    isGemini: boolean
+  ): string {
+    if (isAnthropic) {
+      // Anthropic streaming format: data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"..."}}
+      const match = chunk.match(/"type"\s*:\s*"text_delta"\s*,\s*"text"\s*:\s*"([^"]*)"/);
+      return match ? match[1] : '';
+    } else if (isGemini) {
+      // Gemini format
+      const match = chunk.match(/"text"\s*:\s*"([^"]*)"/);
+      return match ? match[1] : '';
+    } else {
+      // OpenAI SSE format: data: {"choices":[{"delta":{"content":"..."}}]}
+      const lines = chunk.split('\n');
+      for (const line of lines) {
+        if (line.startsWith('data: ') && line !== 'data: [DONE]') {
+          try {
+            const data = JSON.parse(line.slice(6));
+            const content = data.choices?.[0]?.delta?.content;
+            if (content) return content;
+          } catch {
+            // Skip invalid JSON
+          }
+        }
+      }
+      return '';
+    }
+  }
+
+  /**
+   * Parse full response text into structured AIResponse
+   */
+  private parseResponse(fullText: string): AIResponse {
+    // For now return content as-is; tool call parsing happens via content patterns
+    return {
+      content: fullText,
+      role: 'assistant',
+      tool_calls: this.extractToolCalls(fullText)
+    };
+  }
+
+  /**
+   * Extract tool calls from response content
+   */
+  private extractToolCalls(content: string): ToolCall[] | undefined {
+    // Simple pattern: look for tool_call blocks in response
+    // In real implementation this would be parsed from structured response
+    // For streaming, we check if content indicates a tool call
+    if (!content.includes('tool_use')) return undefined;
+    return undefined; // Placeholder — actual implementation depends on provider
+  }
+
+  // ==================== Legacy chat() — delegates to chatStream ====================
+
+  /**
+   * Original non-streaming chat — now implemented via chatStream
+   */
+  async chat(messages: ChatMessage[], maxIterations: number = 5): Promise<AIResponse> {
+    let fullContent = '';
+
+    for await (const chunk of this.chatStream(messages, maxIterations)) {
+      fullContent += chunk;
+    }
+
+    return {
+      content: fullContent,
+      role: 'assistant'
+    };
+  }
+
+  // ==================== Tool Execution ====================
+
+  private async executeToolCall(toolCall: ToolCall): Promise<{ output?: string; error?: string }> {
+    const { name, arguments: args } = toolCall.function;
+    const tool = this.tools.get(name);
+
+    if (!tool) {
+      return { error: `Tool "${name}" not found` };
+    }
+
+    try {
+      const params = JSON.parse(args);
+      const result = await tool.execute(params, {
+        confirmAction: async (msg: string): Promise<boolean> => {
+          console.log(chalk.yellow(`\n⚠️  Tool wants to execute: ${msg}`));
+          return false; // Default deny in CLI mode
+        }
+      });
+
+      return {
+        output: result.success ? (result.output || JSON.stringify(result.data)) : undefined,
+        error: result.error
+      };
+    } catch (error: any) {
+      return { error: `Tool execution failed: ${error.message}` };
+    }
+  }
+
+  // ==================== Request Builders ====================
+
+  private buildOpenAIRequest(messages: ChatMessage[], stream: boolean) {
+    const tools = this.getToolsForAPI();
+    return {
+      model: this.config.model || 'Qwen/Qwen2.5-7B-Instruct',
+      messages: messages.map(m => ({
+        role: m.role,
+        content: m.content,
+        name: m.name,
+        tool_call_id: m.tool_call_id,
+        tool_calls: m.tool_calls
+      })),
+      temperature: this.config.temperature || 0.7,
+      max_tokens: this.config.maxTokens || 4096,
+      stream,
+      ...(tools.length > 0 && { tools })
+    };
+  }
+
+  private buildAnthropicRequest(messages: ChatMessage[], stream: boolean) {
+    const anthropicMessages = messages
+      .filter(m => m.role !== 'system')
+      .map(m => ({
+        role: m.role === 'assistant' ? 'assistant' : 'user',
+        content: m.content
+      }));
+
+    return {
+      model: this.config.model || 'claude-3-haiku-20240307',
+      messages: anthropicMessages,
+      max_tokens: this.config.maxTokens || 4096,
+      temperature: this.config.temperature || 0.7,
+      stream
+    };
+  }
+
+  private buildGeminiRequest(messages: ChatMessage[]) {
+    const contents = messages
+      .filter(m => m.role !== 'system')
+      .map(m => ({
+        role: m.role === 'assistant' ? 'model' : 'user',
+        parts: [{ text: m.content }]
+      }));
+
+    return {
+      contents,
+      generationConfig: {
+        temperature: this.config.temperature || 0.7,
+        maxOutputTokens: this.config.maxTokens || 4096
+      }
+    };
+  }
+
+  private getApiKey(): string {
+    const provider = this.config.provider || 'siliconflow';
+
+    const envKeys: Record<string, string[]> = {
+      siliconflow: ['SILICONFLOW_API_KEY', 'OPENAI_API_KEY'],
+      minimax: ['MINIMAX_API_KEY', 'OPENAI_API_KEY'],
+      openai: ['OPENAI_API_KEY'],
+      anthropic: ['ANTHROPIC_API_KEY'],
+      ollama: [],
+      gemini: ['GEMINI_API_KEY'],
+      kimi: ['KIMI_API_KEY', 'MOONSHOT_API_KEY'],
+      deepseek: ['DEEPSEEK_API_KEY']
+    };
+
+    for (const key of envKeys[provider] || []) {
+      if (process.env[key]) return process.env[key];
+    }
+
+    return '';
+  }
+
+  private getMockResponse(messages: ChatMessage[]): string {
+    const lastMessage = messages[messages.length - 1]?.content || '';
+    let response = 'Hello! I am Thatgfsj Code.\n\n';
+
+    if (lastMessage.toLowerCase().includes('hello') || lastMessage.toLowerCase().includes('hi')) {
+      response = 'Hi there! How can I help you today?';
+    } else if (lastMessage.toLowerCase().includes('who are you')) {
+      response = 'I am Thatgfsj Code, an AI assistant built with Node.js.';
+    } else {
+      response = `I understand you said: "${lastMessage.slice(0, 50)}..."\n\nThis is a streaming demo. Enable an API key for full AI capabilities.`;
+    }
+
+    return response;
+  }
+}

package/src/core/cli.ts

@@ -0,0 +1,171 @@
+/**
+ * S12: CLI & Architecture
+ * 
+ * Main entry point, CLI argument parsing, and module architecture overview.
+ */
+
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { AIEngine } from './ai-engine.js';
+import { ConfigManager } from './config.js';
+import { REPLLoop } from '../repl/loop.js';
+import { ToolRegistry } from './tool-registry.js';
+import { ShellTool, FileTool, GitTool } from '../tools/index.js';
+import { HookManager, auditLogHook, getHookManager } from './hooks.js';
+import { getStateManager } from './state.js';
+import { SystemPromptBuilder } from './system-prompt.js';
+import { BUILT_IN_SKILLS } from './skills.js';
+
+// ==================== CLI Argument Parsing ====================
+
+export interface CLIOptions {
+  model?: string;
+  provider?: string;
+  prompt?: string;
+  noStream?: boolean;
+  verbose?: boolean;
+  hooks?: boolean;
+  permissionMode?: 'accept' | 'deny' | 'ask';
+}
+
+export function parseArgs(args: string[]): CLIOptions {
+  const options: CLIOptions = {};
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    switch (arg) {
+      case '--model':
+      case '-m':
+        options.model = args[++i];
+        break;
+      case '--provider':
+      case '-p':
+        options.provider = args[++i];
+        break;
+      case '--prompt':
+      case '-c':
+        options.prompt = args[++i];
+        break;
+      case '--no-stream':
+        options.noStream = true;
+        break;
+      case '--verbose':
+      case '-v':
+        options.verbose = true;
+        break;
+      case '--hooks':
+        options.hooks = true;
+        break;
+      case '--permission':
+        options.permissionMode = (args[++i] as 'accept' | 'deny' | 'ask') || 'ask';
+        break;
+      case '--help':
+      case '-h':
+        printHelp();
+        process.exit(0);
+    }
+  }
+
+  return options;
+}
+
+function printHelp(): void {
+  console.log(`
+Thatgfsj Code - AI Coding Assistant
+
+Usage: thatgfsj [options]
+
+Options:
+  -m, --model <model>       Set AI model
+  -p, --provider <provider> Set provider (siliconflow, minimax, openai, etc.)
+  -c, --prompt <text>       Run single prompt and exit
+  --no-stream               Disable streaming output
+  --hooks                   Enable built-in hooks (audit log, etc.)
+  --permission <mode>       Set permission mode (accept, deny, ask)
+  -v, --verbose             Verbose output
+  -h, --help                Show this help
+
+Examples:
+  thatgfsj                           Start REPL
+  thatgfsj -c "Hello"                Run single prompt
+  thatgfsj --provider minimax --model MiniMax-M2.5  Use specific provider
+  thatgfsj --permission accept        Accept all tool calls
+`);
+}
+
+// ==================== Architecture ====================
+
+/**
+ * S12: Print architecture overview
+ */
+export function printArchitecture(): void {
+  console.log(`
+Thatgfsj Code Architecture
+============================
+
+Core:
+  AIEngine         - Async generator agent loop (S01), multi-provider
+  ToolRegistry     - Tool registration and execution (S02)
+  PermissionChecker - 6-stage permission pipeline (S03)
+  SystemPromptBuilder - Dynamic prompt construction (S04)
+  ContextCompactor - 3-tier context compression (S05)
+  SubagentManager  - Parallel subagent execution (S06)
+  HookManager      - Event-driven hooks (S08)
+  SkillsLoader     - Skills discovery and catalog (S10)
+  StateManager     - Ephemeral/Persistent/Session state (S11)
+
+Tools:
+  ShellTool        - Shell command execution
+  FileTool         - File read/write/list/delete
+  GitTool          - Git operations
+
+Entry:
+  REPLLoop         - Interactive REPL
+  CLI              - Command-line mode
+`);
+}
+
+// ==================== Main ====================
+
+export async function main(argv: string[]): Promise<void> {
+  const options = parseArgs(argv.slice(2));
+
+  // Single prompt mode
+  if (options.prompt) {
+    const config = await ConfigManager.load();
+    if (options.provider) config.provider = options.provider as any;
+    if (options.model) config.model = options.model;
+
+    const ai = new AIEngine(config);
+    const tools = [new ShellTool(), new FileTool(), new GitTool()];
+    for (const tool of tools) ai.registerTool(tool);
+
+    if (options.hooks) {
+      const hooks = getHookManager();
+      hooks.register('afterToolCall', auditLogHook);
+      ai.setHooks(hooks);
+    }
+
+    const promptBuilder = new SystemPromptBuilder({ tools, permissionMode: options.permissionMode });
+    const messages = [
+      { role: 'system' as const, content: promptBuilder.build() },
+      { role: 'user' as const, content: options.prompt }
+    ];
+
+    if (options.noStream) {
+      const response = await ai.chat(messages);
+      console.log(response.content);
+    } else {
+      for await (const chunk of ai.chatStream(messages)) {
+        process.stdout.write(chunk);
+      }
+      console.log();
+    }
+    return;
+  }
+
+  // REPL mode
+  const repl = new REPLLoop();
+  await repl.start();
+}