thatgfsj-code 0.2.1

package/src/core/config.ts

@@ -0,0 +1,147 @@
+/**
+ * Config Manager - Handles configuration loading and saving
+ * Supports multiple AI providers: MiniMax, SiliconFlow, OpenAI, Anthropic
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { Config, PROVIDERS, AIConfig } from './types.js';
+
+const DEFAULT_CONFIG: Config = {
+  model: 'Qwen/Qwen2.5-7B-Instruct',
+  apiKey: '',
+  temperature: 0.7,
+  maxTokens: 4096,
+  provider: 'siliconflow',
+  baseUrl: 'https://api.siliconflow.cn/v1'
+};
+
+export class ConfigManager {
+  private configPath: string;
+
+  constructor() {
+    const homeDir = homedir();
+    const configDir = join(homeDir, '.thatgfsj');
+    this.configPath = join(configDir, 'config.json');
+  }
+
+  /**
+   * Load configuration with environment variable support
+   */
+  static async load(): Promise<Config> {
+    const manager = new ConfigManager();
+    return manager.loadConfig();
+  }
+
+  /**
+   * Load config from file and merge with environment variables
+   */
+  private loadConfig(): Config {
+    let config = { ...DEFAULT_CONFIG };
+
+    try {
+      if (existsSync(this.configPath)) {
+        const data = readFileSync(this.configPath, 'utf-8');
+        const loaded = JSON.parse(data);
+        config = { ...config, ...loaded };
+      }
+    } catch (error) {
+      console.warn('Failed to load config, using defaults:', error);
+    }
+
+    // Resolve provider and get API key from environment
+    config = this.resolveProvider(config);
+
+    return config;
+  }
+
+  /**
+   * Resolve provider and API key from config or environment
+   */
+  private resolveProvider(config: Config): Config {
+    const provider = config.provider || 'siliconflow';
+    const providerConfig = (provider !== 'custom' && provider !== undefined) ? PROVIDERS[provider] : null;
+
+    if (!providerConfig) {
+      console.warn(`Unknown provider: ${provider}, falling back to siliconflow`);
+      return { ...config, provider: 'siliconflow', baseUrl: PROVIDERS.siliconflow.baseUrl };
+    }
+
+    // MODEL environment variable has highest priority
+    let model = process.env.MODEL || config.model || providerConfig.defaultModel;
+    
+    // Handle Ollama (local, no API key needed)
+    let apiKey = config.apiKey;
+    let baseUrl = config.baseUrl || providerConfig.baseUrl;
+    
+    if (provider === 'ollama') {
+      // Ollama doesn't need an API key
+      apiKey = '';
+      // Allow custom base URL via environment
+      baseUrl = process.env.OLLAMA_BASE_URL || baseUrl;
+    } else {
+      // Try to get API key from environment
+      for (const envKey of providerConfig.envKeys) {
+        if (process.env[envKey]) {
+          apiKey = process.env[envKey];
+          break;
+        }
+      }
+    }
+
+    return {
+      ...config,
+      provider,
+      baseUrl,
+      model,
+      apiKey: apiKey || ''
+    };
+  }
+
+  /**
+   * Get AIConfig for AIEngine
+   */
+  static async getAIConfig(): Promise<AIConfig> {
+    const config = await ConfigManager.load();
+    return {
+      model: config.model,
+      apiKey: config.apiKey,
+      temperature: config.temperature,
+      maxTokens: config.maxTokens,
+      baseUrl: config.baseUrl,
+      provider: config.provider
+    };
+  }
+
+  /**
+   * Save configuration
+   */
+  async save(config: Partial<Config>): Promise<void> {
+    const current = this.loadConfig();
+    const merged = { ...current, ...config };
+
+    const dir = dirname(this.configPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+
+    writeFileSync(this.configPath, JSON.stringify(merged, null, 2));
+  }
+
+  /**
+   * Get config path
+   */
+  getPath(): string {
+    return this.configPath;
+  }
+
+  /**
+   * List available providers
+   */
+  static listProviders(): string {
+    return Object.entries(PROVIDERS)
+      .map(([key, val]) => `  ${key}: ${val.name}`)
+      .join('\n');
+  }
+}

package/src/core/context-compactor.ts

@@ -0,0 +1,245 @@
+/**
+ * S05: Context Compactor - 3-tier progressive compression strategy
+ * 
+ * Tier 1: Truncation   - Remove oldest messages beyond hard limit
+ * Tier 2: Summarize    - Replace old message ranges with summary
+ * Tier 3: Selective    - Keep only recent N turns around tool executions
+ * 
+ * Core insight: Context window is finite. Three-tier strategy enables "infinite" work.
+ */
+
+import { ChatMessage } from './types.js';
+
+export interface CompactorConfig {
+  /** Hard limit: messages beyond this get removed first */
+  hardLimit?: number;
+  /** Soft limit: messages beyond this get summarized */
+  softLimit?: number;
+  /** How many recent turns to always preserve */
+  preserveRecent?: number;
+  /** Enable summarization (requires AI API) */
+  enableSummarize?: boolean;
+}
+
+export interface CompressionResult {
+  originalCount: number;
+  compactedCount: number;
+  removedCount: number;
+  method: 'none' | 'truncation' | 'summarize' | 'selective';
+}
+
+/**
+ * S05: Context Compactor
+ */
+export class ContextCompactor {
+  private config: CompactorConfig;
+  private totalTokensUsed = 0;
+
+  constructor(config: CompactorConfig = {}) {
+    this.config = {
+      hardLimit: 50,
+      softLimit: 30,
+      preserveRecent: 10,
+      enableSummarize: false,
+      ...config
+    };
+  }
+
+  /**
+   * S05: Compact messages using 3-tier strategy
+   * Called at the end of each agent turn
+   */
+  compact(messages: ChatMessage[]): { compacted: ChatMessage[]; result: CompressionResult } {
+    const count = messages.length;
+
+    // Tier 1: Within hard limit — no compression
+    if (count <= (this.config.hardLimit || 50)) {
+      return {
+        compacted: messages,
+        result: { originalCount: count, compactedCount: count, removedCount: 0, method: 'none' }
+      };
+    }
+
+    // Tier 2: Beyond soft limit — summarize middle messages
+    if (count > (this.config.softLimit || 30)) {
+      return this.summarizeStrategy(messages);
+    }
+
+    // Tier 3: Between soft and hard — selective preservation
+    return this.selectiveStrategy(messages);
+  }
+
+  // Tier 1: Simple truncation
+  private truncate(messages: ChatMessage[], maxMessages: number): ChatMessage[] {
+    const systemMsg = messages.find(m => m.role === 'system');
+    const others = messages.filter(m => m.role !== 'system');
+    const toRemove = others.length - maxMessages;
+
+    if (toRemove <= 0 || others.length === 0) {
+      return messages;
+    }
+
+    // Remove oldest non-system messages
+    const keptOthers = others.slice(toRemove);
+    return systemMsg ? [systemMsg, ...keptOthers] : keptOthers;
+  }
+
+  // Tier 2: Summarize middle messages (stub — needs AI for real summarization)
+  private summarizeStrategy(messages: ChatMessage[]): { compacted: ChatMessage[]; result: CompressionResult } {
+    const preserved = this.config.preserveRecent || 10;
+    const systemMsg = messages.find(m => m.role === 'system');
+    const others = messages.filter(m => m.role !== 'system');
+
+    if (others.length <= preserved) {
+      return {
+        compacted: messages,
+        result: { originalCount: messages.length, compactedCount: messages.length, removedCount: 0, method: 'none' }
+      };
+    }
+
+    // Keep recent N turns
+    const recent = others.slice(-preserved);
+
+    // Summarize the middle (this is a placeholder — real impl would call AI)
+    const summaryMsg: ChatMessage = {
+      role: 'system',
+      content: '[S05: ' + (others.length - preserved) + ' earlier messages summarized — ' +
+        'conversation had ' + (others.length - preserved) + ' exchanges covering ' +
+        this.summarizeTopic(others.slice(0, -preserved)) + ']'
+    };
+
+    const compacted = systemMsg
+      ? [systemMsg, summaryMsg, ...recent]
+      : [summaryMsg, ...recent];
+
+    return {
+      compacted,
+      result: {
+        originalCount: messages.length,
+        compactedCount: compacted.length,
+        removedCount: messages.length - compacted.length,
+        method: 'summarize'
+      }
+    };
+  }
+
+  // Extract simple topic from message content
+  private summarizeTopic(msgs: ChatMessage[]): string {
+    const texts = msgs
+      .filter(m => m.role === 'user')
+      .map(m => m.content)
+      .slice(0, 3)
+      .join(' ')
+      .substring(0, 50);
+    return texts || 'various topics';
+  }
+
+  // Tier 3: Selective — keep turns around tool executions
+  private selectiveStrategy(messages: ChatMessage[]): { compacted: ChatMessage[]; result: CompressionResult } {
+    const systemMsg = messages.find(m => m.role === 'system');
+    const others = messages.filter(m => m.role !== 'system');
+    const max = this.config.softLimit || 30;
+
+    if (others.length <= max) {
+      return {
+        compacted: messages,
+        result: { originalCount: messages.length, compactedCount: messages.length, removedCount: 0, method: 'none' }
+      };
+    }
+
+    // Find indices of tool-related messages
+    const toolIndices = new Set<number>();
+    others.forEach((m, i) => {
+      if (m.tool_calls || m.role === 'tool' || m.role === 'assistant') {
+        toolIndices.add(i);
+      }
+    });
+
+    // Also add indices around tool messages
+    for (const idx of toolIndices) {
+      for (let offset = -2; offset <= 2; offset++) {
+        toolIndices.add(idx + offset);
+      }
+    }
+
+    // Keep system message + messages near tool executions + recent messages
+    const recentCount = Math.floor(max * 0.3); // 30% recent
+    const toolCount = max - recentCount;
+
+    const recent = others.slice(-recentCount);
+    const toolMsgs: ChatMessage[] = [];
+    for (const idx of [...toolIndices].sort((a, b) => a - b)) {
+      if (toolMsgs.length >= toolCount) break;
+      if (idx >= 0 && idx < others.length - recentCount) {
+        toolMsgs.push(others[idx]);
+      }
+    }
+
+    const compacted = systemMsg
+      ? [systemMsg, ...toolMsgs, ...recent]
+      : [...toolMsgs, ...recent];
+
+    // Deduplicate while preserving order
+    const seen = new Set<string>();
+    const deduped = compacted.filter(m => {
+      const key = m.role + m.content.substring(0, 30);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+
+    return {
+      compacted: deduped,
+      result: {
+        originalCount: messages.length,
+        compactedCount: deduped.length,
+        removedCount: messages.length - deduped.length,
+        method: 'selective'
+      }
+    };
+  }
+
+  // S05: Check if context is approaching limit
+  isNearLimit(messages: ChatMessage[], limit: number = 150000): boolean {
+    // Rough estimate: 1 message ~= 200 tokens on average
+    const estimatedTokens = messages.length * 200;
+    return estimatedTokens > limit * 0.8; // 80% of limit
+  }
+
+  // S05: Get estimated token count
+  estimateTokens(messages: ChatMessage[]): number {
+    return messages.reduce((sum, m) => {
+      // Rough: content chars / 4 tokens
+      return sum + Math.ceil(m.content.length / 4) + 10; // +10 for role/overhead
+    }, 0);
+  }
+
+  // S05: Auto-compact if needed (called from AIEngine or SessionManager)
+  autoCompact(messages: ChatMessage[]): { compacted: ChatMessage[]; result: CompressionResult } {
+    if (this.isNearLimit(messages)) {
+      return this.compact(messages);
+    }
+    return {
+      compacted: messages,
+      result: { originalCount: messages.length, compactedCount: messages.length, removedCount: 0, method: 'none' }
+    };
+  }
+}
+
+// ==================== SessionManager Integration ====================
+
+export function integrateWithSessionManager(SessionManagerClass: any) {
+  const originalTruncate = SessionManagerClass.prototype.truncate;
+  
+  SessionManagerClass.prototype.truncate = function(maxMessages: number, forceCompact = false) {
+    if (forceCompact) {
+      const compactor = new ContextCompactor({ hardLimit: maxMessages });
+      const { compacted, result } = compactor.autoCompact(this.messages);
+      if (result.method !== 'none') {
+        this.messages = compacted;
+        return result;
+      }
+    }
+    return originalTruncate.call(this, maxMessages);
+  };
+}

package/src/core/hooks.ts

@@ -0,0 +1,196 @@
+/**
+ * S08: Hooks System
+ * Inject custom logic at key event points without modifying agent source code
+ * 
+ * Hook points: before/after tool calls, before/after agent loop, onError, etc.
+ * Users can register hooks for: audit logging, auto-formatting, security filtering, notifications
+ */
+
+import { ChatMessage, ToolCall } from './types.js';
+
+// ==================== Hook Types ====================
+
+export type HookName =
+  | 'beforeToolCall'
+  | 'afterToolCall'
+  | 'beforeAgentLoop'
+  | 'afterAgentLoop'
+  | 'onError'
+  | 'beforeMessage'
+  | 'afterMessage'
+  | 'onCompact';
+
+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>;
+
+export interface HookRegistration {
+  name: HookName;
+  fn: HookFn;
+  priority?: number; // Higher = runs first
+  once?: boolean;    // If true, auto-remove after first run
+}
+
+// ==================== Hook Manager ====================
+
+export class HookManager {
+  private hooks: Map<HookName, HookRegistration[]> = new Map();
+
+  constructor() {
+    // Initialize all hook types
+    const allHooks: HookName[] = [
+      'beforeToolCall', 'afterToolCall', 'beforeAgentLoop', 'afterAgentLoop',
+      'onError', 'beforeMessage', 'afterMessage', 'onCompact'
+    ];
+    for (const h of allHooks) {
+      this.hooks.set(h, []);
+    }
+  }
+
+  /**
+   * S08: Register a hook
+   * @param name Hook point name
+   * @param fn Function to run
+   * @param priority Higher priority runs first
+   * @param once If true, auto-removed after first run
+   */
+  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);
+  }
+
+  /**
+   * S08: Unregister a hook by function reference
+   */
+  unregister(name: HookName, fn: HookFn): void {
+    const regs = this.hooks.get(name) || [];
+    this.hooks.set(name, regs.filter(r => r.fn !== fn));
+  }
+
+  /**
+   * S08: Clear all hooks for a given name (or all)
+   */
+  clear(name?: HookName): void {
+    if (name) {
+      this.hooks.set(name, []);
+    } else {
+      for (const [, regs] of this.hooks) {
+        regs.length = 0;
+      }
+    }
+  }
+
+  /**
+   * S08: Emit a hook — call all registered functions at that point
+   * Returns after all sync hooks complete, awaits async ones
+   */
+  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);
+      }
+
+      // Remove if one-time hook
+      if (reg.once) {
+        this.unregister(name, reg.fn);
+      }
+    }
+  }
+
+  /**
+   * S08: Check if any hooks are registered for a given name
+   */
+  hasHooks(name: HookName): boolean {
+    return (this.hooks.get(name)?.length || 0) > 0;
+  }
+
+  /**
+   * S08: Get hook count
+   */
+  getHookCount(name?: HookName): number {
+    if (name) {
+      return this.hooks.get(name)?.length || 0;
+    }
+    let total = 0;
+    for (const regs of this.hooks.values()) {
+      total += regs.length;
+    }
+    return total;
+  }
+}
+
+// ==================== Built-in Hooks ====================
+
+/**
+ * S08: 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 || {})} | result=${ctx.toolResult?.success ? 'OK' : ctx.toolResult?.error}`);
+  }
+}
+
+/**
+ * S08: Prettier auto-format hook — run prettier after file writes
+ */
+export async function prettierFormatHook(ctx: HookContext): Promise<void> {
+  if (ctx.toolName === 'file' && ctx.toolParams?.action === 'write') {
+    const path = ctx.toolParams.path;
+    const ext = path.split('.').pop()?.toLowerCase();
+
+    const formattable = ['js', 'ts', 'jsx', 'tsx', 'json', 'md', 'css', 'html'];
+    if (formattable.includes(ext || '')) {
+      console.log(`[Hook] Auto-format skipped (prettier not installed) for ${path}`);
+      // In real impl: spawn prettier on the file
+    }
+  }
+}
+
+/**
+ * S08: Security filter hook — block suspicious patterns
+ */
+export function securityFilterHook(ctx: HookContext): { blocked: boolean; reason: string } {
+  if (ctx.toolName === 'shell' && ctx.toolParams?.command) {
+    const cmd = ctx.toolParams.command;
+    const suspicious = [
+      /curl\s+.*\|.*sh/i,
+      /wget\s+.*\|.*sh/i,
+      /base64\s+-d/i,
+      /\.\/[^/]+\s+&&.*rm/i
+    ];
+
+    for (const pattern of suspicious) {
+      if (pattern.test(cmd)) {
+        return { blocked: true, reason: `Suspicious pattern detected: ${pattern}` };
+      }
+    }
+  }
+  return { blocked: false, reason: '' };
+}
+
+// ==================== Singleton ====================
+
+let globalHookManager: HookManager | null = null;
+
+export function getHookManager(): HookManager {
+  if (!globalHookManager) {
+    globalHookManager = new HookManager();
+  }
+  return globalHookManager;
+}