thatgfsj-code 0.2.1 → 0.2.2

package/src/core/cli.ts

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

package/src/core/config.ts

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

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