thatgfsj-code 0.3.0 → 0.3.1

package/src/mcp/client.ts

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

package/src/prompts/index.ts

@@ -1,123 +0,0 @@
-/**
- * System Prompt Builder - Dynamic prompt construction
- * Migrated from old src/core/system-prompt.ts
- */
-
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-import type { Tool } from '../tools/types.js';
-
-export interface SystemPromptConfig {
-  cwd?: string;
-  tools?: Tool[];
-  includeProjectMd?: boolean;
-  permissionMode?: 'accept' | 'deny' | 'ask';
-  date?: Date;
-}
-
-export class SystemPromptBuilder {
-  private config: Required<SystemPromptConfig>;
-
-  constructor(config: SystemPromptConfig = {}) {
-    this.config = {
-      cwd: config.cwd ?? process.cwd(),
-      tools: config.tools ?? [],
-      includeProjectMd: config.includeProjectMd ?? true,
-      permissionMode: config.permissionMode ?? 'ask',
-      date: config.date ?? new Date(),
-    };
-  }
-
-  build(): string {
-    const fragments: string[] = [
-      this.buildIdentity(),
-      this.buildToolInstructions(),
-      this.buildEnvironment(),
-      this.buildPermissionMode(),
-      this.buildProjectInstructions(),
-      this.buildDateInfo(),
-    ];
-    return fragments.filter(Boolean).join('\n\n');
-  }
-
-  private buildIdentity(): string {
-    return [
-      'You are Thatgfsj Code, an interactive coding agent running in the user\'s terminal.',
-      '',
-      'You have access to tools (file operations, shell commands, git, search) that let you',
-      'read, write, and modify files and run commands to help with coding tasks.',
-      '',
-      'When working on a task:',
-      '1. First understand what files are involved',
-      '2. Read necessary files to understand the codebase',
-      '3. Make changes using appropriate tools',
-      '4. Verify the changes work',
-      '',
-      'Be concise but thorough. Show your reasoning.',
-      '',
-      'When using tools:',
-      '- Prefer small, targeted operations over large batch changes',
-      '- Confirm destructive operations (rm, git push --force, etc.)',
-      '- Explain what you are going to do before doing it',
-    ].join('\n');
-  }
-
-  private buildToolInstructions(): string {
-    const tools = this.config.tools;
-    if (tools.length === 0) {
-      return '## Tools\n\nNo tools are currently registered.';
-    }
-
-    const toolDescs = tools.map(t => {
-      const params = t.parameters
-        .map(p => `  - ${p.name} (${p.type}${p.required ? ', required' : ''}): ${p.description}`)
-        .join('\n');
-      return `### ${t.name}\n${t.description}\n\nParameters:\n${params}`;
-    }).join('\n\n');
-
-    return `## Tools\n\nYou have access to the following tools:\n\n${toolDescs}\n\nTo use a tool, respond with a tool call. Each tool call must include the tool name and parameters as a JSON object.`;
-  }
-
-  private buildEnvironment(): string {
-    return `## Environment\n\nWorking directory: ${this.config.cwd}`;
-  }
-
-  private buildPermissionMode(): string {
-    const mode = this.config.permissionMode;
-    const explanations: Record<string, string> = {
-      accept: 'All tool calls are automatically allowed without confirmation.',
-      deny: 'All tool calls are blocked. You may only read and discuss.',
-      ask: 'Dangerous or destructive commands require user confirmation before execution.',
-    };
-    return `## Permission Mode\n\nCurrent mode: ${mode}\n\n${explanations[mode] || ''}`;
-  }
-
-  private buildProjectInstructions(): string {
-    if (!this.config.includeProjectMd) return '';
-
-    const cwd = this.config.cwd;
-    const paths = [join(cwd, 'CLAUDE.md'), join(cwd, '.claude.md'), join(cwd, 'AGENTS.md')];
-
-    for (const path of paths) {
-      if (existsSync(path)) {
-        try {
-          const content = readFileSync(path, 'utf-8');
-          return `## Project Instructions (from ${path.split(/[/\\]/).pop()})\n\n${content}`;
-        } catch {
-          // Ignore
-        }
-      }
-    }
-    return '';
-  }
-
-  private buildDateInfo(): string {
-    const now = this.config.date;
-    const iso = now.toISOString().replace('T', ' ').split('.')[0];
-    return `## Current Time\n\n${iso}`;
-  }
-
-  setTools(tools: Tool[]): this { this.config.tools = tools; return this; }
-  setCwd(cwd: string): this { this.config.cwd = cwd; return this; }
-  setPermissionMode(mode: 'accept' | 'deny' | 'ask'): this { this.config.permissionMode = mode; return this; }
-}

package/src/session/compactor.ts

@@ -1,103 +0,0 @@
-/**
- * Context Compactor - Progressive compression for conversation history
- * Migrated from old src/core/context-compactor.ts
- *
- * Strategy:
- * 1. Within limit: no compression
- * 2. Beyond limit: keep system + recent N turns + summarize middle
- */
-
-import type { ChatMessage } from '../types.js';
-
-export interface CompactorConfig {
-  /** Max messages before compression kicks in */
-  maxMessages?: number;
-  /** How many recent turns to always preserve */
-  preserveRecent?: number;
-}
-
-export interface CompressionResult {
-  originalCount: number;
-  compactedCount: number;
-  removedCount: number;
-}
-
-export class ContextCompactor {
-  private maxMessages: number;
-  private preserveRecent: number;
-
-  constructor(config: CompactorConfig = {}) {
-    this.maxMessages = config.maxMessages ?? 50;
-    this.preserveRecent = config.preserveRecent ?? 10;
-  }
-
-  /**
-   * Compact messages if needed
-   */
-  compact(messages: ChatMessage[]): { compacted: ChatMessage[]; result: CompressionResult } {
-    if (messages.length <= this.maxMessages) {
-      return {
-        compacted: messages,
-        result: { originalCount: messages.length, compactedCount: messages.length, removedCount: 0 },
-      };
-    }
-
-    const systemMsg = messages.find(m => m.role === 'system');
-    const others = messages.filter(m => m.role !== 'system');
-
-    if (others.length <= this.preserveRecent) {
-      return {
-        compacted: messages,
-        result: { originalCount: messages.length, compactedCount: messages.length, removedCount: 0 },
-      };
-    }
-
-    // Keep recent N turns
-    const recent = others.slice(-this.preserveRecent);
-
-    // Summarize the middle portion
-    const middle = others.slice(0, -this.preserveRecent);
-    const summary: ChatMessage = {
-      role: 'system',
-      content: `[Earlier conversation summary: ${middle.length} messages covering ${this.extractTopics(middle)}]`,
-    };
-
-    const compacted = systemMsg
-      ? [systemMsg, summary, ...recent]
-      : [summary, ...recent];
-
-    return {
-      compacted,
-      result: {
-        originalCount: messages.length,
-        compactedCount: compacted.length,
-        removedCount: messages.length - compacted.length,
-      },
-    };
-  }
-
-  /**
-   * Auto-compact if messages exceed limit
-   */
-  autoCompact(messages: ChatMessage[]): { compacted: ChatMessage[]; result: CompressionResult } {
-    return this.compact(messages);
-  }
-
-  /**
-   * Estimate token count (rough: ~4 chars per token)
-   */
-  estimateTokens(messages: ChatMessage[]): number {
-    return messages.reduce((sum, m) => sum + Math.ceil(m.content.length / 4) + 10, 0);
-  }
-
-  /**
-   * Extract topic summary from messages
-   */
-  private extractTopics(msgs: ChatMessage[]): string {
-    const topics = msgs
-      .filter(m => m.role === 'user')
-      .map(m => m.content.slice(0, 30))
-      .slice(0, 3);
-    return topics.join(', ') || 'various topics';
-  }
-}

package/src/session/index.ts

@@ -1,81 +0,0 @@
-/**
- * Session Manager - Manages conversation history
- * Migrated from old src/core/session.ts
- */
-
-import type { ChatMessage } from '../types.js';
-import { ContextCompactor } from './compactor.js';
-
-export class SessionManager {
-  private messages: ChatMessage[] = [];
-  private sessionId: string;
-  private createdAt: Date;
-  private compactor: ContextCompactor;
-
-  constructor(maxMessages = 50) {
-    this.sessionId = `session_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-    this.createdAt = new Date();
-    this.compactor = new ContextCompactor({ maxMessages });
-  }
-
-  /**
-   * Add a message to the session
-   */
-  addMessage(role: ChatMessage['role'], content: string, extras?: Partial<ChatMessage>): void {
-    this.messages.push({ role, content, ...extras });
-  }
-
-  /**
-   * Get all messages (copy)
-   */
-  getMessages(): ChatMessage[] {
-    return [...this.messages];
-  }
-
-  /**
-   * Get message count
-   */
-  getMessageCount(): number {
-    return this.messages.length;
-  }
-
-  /**
-   * Clear session history
-   */
-  clear(): void {
-    this.messages = [];
-  }
-
-  /**
-   * Truncate messages to fit context window
-   */
-  truncate(maxMessages?: number): void {
-    if (maxMessages) {
-      this.compactor = new ContextCompactor({ maxMessages });
-    }
-    const { compacted } = this.compactor.autoCompact(this.messages);
-    this.messages = compacted;
-  }
-
-  /**
-   * Get session ID
-   */
-  getId(): string {
-    return this.sessionId;
-  }
-
-  /**
-   * Get session info
-   */
-  getInfo(): { id: string; messageCount: number; createdAt: Date } {
-    return {
-      id: this.sessionId,
-      messageCount: this.messages.length,
-      createdAt: this.createdAt,
-    };
-  }
-}
-
-export { ContextCompactor } from './compactor.js';
-export type { CompactorConfig, CompressionResult } from './compactor.js';
-export * from './message.js';

package/src/session/message.ts

@@ -1,42 +0,0 @@
-/**
- * Message types and utilities
- */
-
-import type { ChatMessage, Role } from '../types.js';
-
-export { ChatMessage, Role };
-
-/**
- * Create a message
- */
-export function createMessage(role: Role, content: string, extras?: Partial<ChatMessage>): ChatMessage {
-  return { role, content, ...extras };
-}
-
-/**
- * Create a system message
- */
-export function systemMessage(content: string): ChatMessage {
-  return { role: 'system', content };
-}
-
-/**
- * Create a user message
- */
-export function userMessage(content: string): ChatMessage {
-  return { role: 'user', content };
-}
-
-/**
- * Create an assistant message
- */
-export function assistantMessage(content: string): ChatMessage {
-  return { role: 'assistant', content };
-}
-
-/**
- * Create a tool result message
- */
-export function toolMessage(content: string, toolCallId: string, name: string): ChatMessage {
-  return { role: 'tool', content, tool_call_id: toolCallId, name };
-}