thatgfsj-code 3.0.3 → 3.0.6

package/src/cache/stats.ts

@@ -1,199 +0,0 @@
-/**
- * Cache statistics store.
- *
- * Tracks per-round cache hit/miss token counts across the user's local
- * sessions and persists them to `~/.thatgfsj/cache-stats.json`. The store
- * is consumed by:
- *   - the TUI Header (`⚡ 命中率 87%`)
- *   - the /cache CLI command (detailed breakdown)
- *   - the /cache reset command (clears the file)
- *
- * Provider-agnostic. Anthropic reports cache_creation_input_tokens /
- * cache_read_input_tokens; DeepSeek reports prompt_cache_hit_tokens /
- * prompt_cache_miss_tokens; OpenAI does not surface any cache stats at
- * all (their automatic cache is invisible to the client). We normalize
- * both shapes into a single internal model.
- *
- * Cost estimation is intentionally simplified:
- *   - cache_read = 10% of normal input price
- *   - cache_creation = 125% of normal input price (Anthropic charges extra
- *     on first write)
- *   - We compare against the baseline "what would this have cost without
- *     caching" and report the delta as estimated savings.
- *
- * Prices are in CNY per million tokens. Defaults reflect Anthropic Claude
- * Sonnet on the official API; users on cheaper providers may see savings
- * proportional to their actual price floor. The numbers are *estimates*
- * — the goal is to give the user a sense of order of magnitude, not a
- * billable invoice.
- */
-
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { dirname, join } from 'path';
-import { homedir } from 'os';
-import type { Usage } from '../types.js';
-
-/** Per-million-token price in CNY. Adjust if your provider differs significantly. */
-const PRICE = {
-  normalInput: 3,
-  cacheRead: 0.3,
-  cacheCreation: 3.75,
-  output: 15,
-};
-
-/** Maximum number of recent rounds kept in the history array (rolling window). */
-const HISTORY_LIMIT = 50;
-
-export interface CacheStats {
-  /** Total tokens served from cache (Anthropic cache_read / DeepSeek hit). */
-  totalReadTokens: number;
-  /** Total tokens written into cache (Anthropic cache_creation / DeepSeek miss prefix written). */
-  totalCreationTokens: number;
-  /** Total input tokens (prompt_tokens). */
-  totalInputTokens: number;
-  /** Total output tokens. */
-  totalOutputTokens: number;
-  /** Number of completed rounds. */
-  totalRequests: number;
-  /** Last N round snapshots (oldest first). */
-  history: Array<{
-    ts: number;
-    read: number;
-    creation: number;
-    input: number;
-    output: number;
-    hitRate: number;
-  }>;
-}
-
-export interface CacheSnapshot extends CacheStats {
-  /** 0..1 ratio of cached tokens to total input tokens. */
-  hitRate: number;
-  /** Estimated CNY saved vs uncached baseline. */
-  estimatedSavingsCNY: number;
-}
-
-const EMPTY_STATS: CacheStats = {
-  totalReadTokens: 0,
-  totalCreationTokens: 0,
-  totalInputTokens: 0,
-  totalOutputTokens: 0,
-  totalRequests: 0,
-  history: [],
-};
-
-/**
- * Estimate the CNY saved by cache_read vs a hypothetical uncached baseline.
- * Negative values are clamped to zero (e.g. a relay station that returned
- * bogus cache stats).
- */
-export function estimateSavingsCNY(stats: CacheStats): number {
-  const baselineCost = (stats.totalReadTokens / 1e6) * PRICE.normalInput;
-  const cachedCost = (stats.totalReadTokens / 1e6) * PRICE.cacheRead;
-  return Math.max(0, baselineCost - cachedCost);
-}
-
-/**
- * Persists cache stats to disk. Safe to call from a hot path — uses atomic
- * write (write to .tmp, rename) to avoid corruption on crash.
- */
-export class CacheStatsStore {
-  private stats: CacheStats;
-  private path: string;
-
-  constructor(path?: string) {
-    this.path = path ?? join(homedir(), '.thatgfsj', 'cache-stats.json');
-    this.stats = this.load();
-  }
-
-  /**
-   * Record a single round's usage. Provider-agnostic: accepts both Anthropic
-   * (cache_creation_input_tokens / cache_read_input_tokens) and DeepSeek
-   * (prompt_cache_hit_tokens / prompt_cache_miss_tokens) shapes. If a
-   * provider returned neither (e.g. OpenAI), the call is a no-op apart
-   * from updating totalRequest count.
-   */
-  record(usage: Usage): void {
-    const read = usage.cache_read_input_tokens ?? usage.prompt_cache_hit_tokens ?? 0;
-    const creation = usage.cache_creation_input_tokens
-      ?? (usage.prompt_cache_miss_tokens ?? 0);
-    const input = usage.prompt_tokens ?? 0;
-    const output = usage.completion_tokens ?? 0;
-
-    // Avoid double-counting: if the provider reported both cache_creation
-    // and prompt_cache_miss_tokens we'd otherwise sum them. The ?? in the
-    // chain above only uses prompt_cache_miss_tokens when
-    // cache_creation_input_tokens is undefined, which is what we want.
-
-    this.stats.totalReadTokens += read;
-    this.stats.totalCreationTokens += creation;
-    this.stats.totalInputTokens += input;
-    this.stats.totalOutputTokens += output;
-    this.stats.totalRequests += 1;
-
-    // Per-round snapshot (for /cache command history view).
-    const total = read + (input - read);
-    const hitRate = total > 0 ? read / total : 0;
-    this.stats.history.push({ ts: Date.now(), read, creation, input, output, hitRate });
-    if (this.stats.history.length > HISTORY_LIMIT) {
-      this.stats.history.splice(0, this.stats.history.length - HISTORY_LIMIT);
-    }
-
-    this.save();
-  }
-
-  /**
-   * Reset the stats. Used by `/cache reset`.
-   */
-  reset(): void {
-    this.stats = { ...EMPTY_STATS, history: [] };
-    this.save();
-  }
-
-  /**
-   * Read-only snapshot for rendering (TUI Header, /cache command).
-   */
-  snapshot(): CacheSnapshot {
-    const input = this.stats.totalInputTokens;
-    const read = this.stats.totalReadTokens;
-    const hitRate = input > 0 ? read / input : 0;
-    return {
-      ...this.stats,
-      hitRate,
-      estimatedSavingsCNY: estimateSavingsCNY(this.stats),
-    };
-  }
-
-  /** Direct accessor for tests. */
-  get raw(): CacheStats { return this.stats; }
-
-  // -- I/O --
-
-  private load(): CacheStats {
-    try {
-      if (!existsSync(this.path)) return { ...EMPTY_STATS, history: [] };
-      const txt = readFileSync(this.path, 'utf-8');
-      const parsed = JSON.parse(txt);
-      // Tolerate partial / older shapes.
-      return {
-        totalReadTokens: parsed.totalReadTokens ?? 0,
-        totalCreationTokens: parsed.totalCreationTokens ?? 0,
-        totalInputTokens: parsed.totalInputTokens ?? 0,
-        totalOutputTokens: parsed.totalOutputTokens ?? 0,
-        totalRequests: parsed.totalRequests ?? 0,
-        history: Array.isArray(parsed.history) ? parsed.history : [],
-      };
-    } catch {
-      return { ...EMPTY_STATS, history: [] };
-    }
-  }
-
-  private save(): void {
-    try {
-      mkdirSync(dirname(this.path), { recursive: true });
-      writeFileSync(this.path, JSON.stringify(this.stats, null, 2), 'utf-8');
-    } catch {
-      // best-effort persistence; do not crash the chat loop on disk errors
-    }
-  }
-}

package/src/cache/volatile.ts

@@ -1,47 +0,0 @@
-/**
- * VolatileScratch — per-round reasoning / planning state that MUST NOT be
- * uploaded to the API.
- *
- * Reasonix Principle #3 (Volatile Scratch):
- *   The model's thinking content, intermediate plans, and other
- *   intra-round state should never be appended to the conversation
- *   history. They are useful for the UI (so users can debug / audit
- *   reasoning) and for cross-iteration handoff within the same round
- *   (e.g. retry-after-tool-failure), but they are NOT part of the cache
- *   prefix and re-uploading them in the next round would:
- *     1. waste tokens (potentially a lot — reasoning can dwarf the answer)
- *     2. cause context-window pressure
- *     3. risk leaking partial / contradictory reasoning back to the model
- *
- * Usage (in LLMService / useChat when receiving 'thinking' chunks):
- *   scratch.write(chunk.content);
- *   // ... later in the same round ...
- *   scratch.read(); // → joined reasoning so far
- *   scratch.reset(); // → call at end of round OR on /new
- */
-export class VolatileScratch {
-  private current: string[] = [];
-
-  reset(): void {
-    this.current = [];
-  }
-
-  write(data: string): void {
-    if (!data) return;
-    this.current.push(data);
-  }
-
-  read(): string {
-    return this.current.join('\n');
-  }
-
-  /** True when no scratch has been written since the last reset. */
-  isEmpty(): boolean {
-    return this.current.length === 0;
-  }
-
-  /** Number of segments written. Useful for UI display ("thought for N lines"). */
-  size(): number {
-    return this.current.length;
-  }
-}

package/src/cmd/index.tsx

@@ -1,288 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Thatgfsj Code - CLI Entry Point
- *
- * v2.2.4 (product 0.4.1): three concrete fixes for the bugs visible
- * in the 2.2.3 (product 0.4.0) session log:
- *
- *   1. Encoding: chcp 65001 used to be wrapped in a silent try/catch,
- *      and stdout never had its default encoding set. On Windows this
- *      caused Chinese characters from tool output to render as
- *      mojibake (ļ ʹ ϵͳ Ƿ ...).
- *
- *   2. [已中断] hallucination loop: 1.0.4's SessionManager had no
- *      anti-pollution filter. When the user pressed Ctrl+C mid-
- *      stream, the truncated assistant message (containing the
- *      model's literal "[已中断]" marker) got persisted to history.
- *      On the next turn, the model saw that and kept echoing it.
- *      v2.1.0 had the right fix (_wasAborted flag + filter) — we
- *      port it back here.
- *
- *   3. Tool output visual: 1.0.4 printed `@@TOOL@@{...}` markers
- *      inline with text, no separator, no truncation. Long tool
- *      output (registry dumps, dir listings) bled into the next
- *      AI message. Add separator + truncation + color separation.
- */
-
-if (process.platform === 'win32') {
-  // Switch Windows console to UTF-8 BEFORE any other code runs.
-  // v2.2.3 wrapped this in `try { } catch {}` which silently swallowed
-  // failures (e.g. when running under a non-interactive shell where
-  // chcp is meaningless). Now we still try, but we also fall back to
-  // setting the codepage via the parent process's stdio handles.
-  try {
-    require('child_process').execSync('chcp 65001 >NUL', { stdio: 'ignore', windowsHide: true });
-  } catch {
-    // Non-Windows shell, or chcp unavailable (e.g. git-bash on CI) —
-    // that's fine, Node defaults to UTF-8 in that environment.
-  }
-}
-
-// Force stdout/stderr to UTF-8 regardless of platform. Without this,
-// Node will emit GBK-encoded bytes for non-ASCII characters on
-// Windows even after `chcp 65001`, because the underlying file
-// descriptors still report a non-UTF-8 code page.
-if (process.stdout.setDefaultEncoding) {
-  process.stdout.setDefaultEncoding('utf8');
-}
-if (process.stderr.setDefaultEncoding) {
-  process.stderr.setDefaultEncoding('utf8');
-}
-
-import { program } from 'commander';
-import chalk from 'chalk';
-import { App } from '../app/index.js';
-import { WelcomeScreen } from '../tui/welcome.js';
-import { compressThinking, summarizeThinking, splitThinking } from '../utils/thinking.js';
-
-process.on('uncaughtException', (error) => {
-  console.error(chalk.red('\n  Error:'), error.message);
-  process.exit(1);
-});
-
-process.on('unhandledRejection', (reason) => {
-  console.error(chalk.red('\n  Error:'), reason);
-  process.exit(1);
-});
-
-program
-  .name('gfcode')
-  .description('Thatgfsj Code - AI Coding Assistant')
-  .version('0.5.0')
-  .argument('[prompt]', 'Task to execute (omit to start interactive mode)')
-  .option('-m, --model <model>', 'Specify model')
-  .option('-i, --interactive', 'Force interactive mode')
-  .option('--show-thinking', 'Show full <think>...</think> reasoning blocks (default: compress to one-line summary)')
-  .action(async (prompt: string | undefined, options: { model?: string; interactive?: boolean; showThinking?: boolean }) => {
-    try {
-      const app = await App.create();
-
-      // Check if API key is configured
-      if (!app.config.hasApiKey()) {
-        console.log(chalk.yellow('\n  ⚠  No API key configured\n'));
-        console.log(chalk.gray('  Run ') + chalk.cyan('gfcode init') + chalk.gray(' to set up your provider.\n'));
-        const readline = await import('readline');
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        const answer = await new Promise<string>(resolve => {
-          rl.question(chalk.cyan('  Run init now? (Y/n): '), resolve);
-        });
-        rl.close();
-        if (answer.toLowerCase() !== 'n') {
-          await WelcomeScreen.interactiveSetup();
-          // Reload config after setup
-          const newApp = await App.create();
-          Object.assign(app, newApp);
-        } else {
-          process.exit(0);
-        }
-      }
-
-      if (options.model) {
-        await app.config.save({ model: options.model });
-      }
-
-      if (!prompt || options.interactive) {
-        // Interactive mode - Ink TUI
-        const { render } = await import('ink');
-        const { TuiApp } = await import('../tui/app.js');
-        const { unmount } = render(<TuiApp app={app} />);
-        await new Promise<void>((resolve) => {
-          process.on('exit', () => { unmount(); resolve(); });
-        });
-      } else {
-        // Single prompt mode
-        console.log(chalk.cyan.bold('\n  ⚡ THATGFSJ CODE\n'));
-        console.log(chalk.gray('  You'));
-        console.log(chalk.gray('  ' + '─'.repeat(40)));
-        console.log('  ' + prompt);
-        console.log();
-
-        app.session.addMessage('user', prompt);
-        let fullResponse = '';
-        // v2.2.4: track whether the stream was aborted so we don't
-        // persist a truncated assistant message (which is what caused
-        // the [已中断] hallucination loop in v2.2.3).
-        const abortCtrl = new AbortController();
-        const onSigInt = () => { abortCtrl.abort(); };
-        process.once('SIGINT', onSigInt);
-        // v2.2.5 (product 0.4.2): compress <think> blocks at render time
-        // AND before persisting to history. Without this, every assistant
-        // message balloons history with reasoning the user has already
-        // seen compressed, and context windows blow up fast.
-        const showThinking = !!options.showThinking;
-
-        try {
-          process.stdout.write(chalk.gray('  Thinking...'));
-          const stream = app.streamResponse();
-
-          // v3.0.0: stream is now AsyncGenerator<StreamChunk> instead of
-          // string. Tool calls come as { type: 'tool_calls', toolCalls }
-          // with structured args; usage comes as { type: 'usage', usage }
-          // at end. We render text live, render tool dispatches inline, and
-          // capture the final response text into fullResponse for the
-          // post-process step below.
-          for await (const chunk of stream) {
-            if (abortCtrl.signal.aborted) break;
-            // Clear the entire "Thinking..." line — must use enough
-            // spaces to overwrite any longer thinking indicator.
-            process.stdout.write('\r' + ' '.repeat(80) + '\r');
-
-            switch (chunk.type) {
-              case 'text': {
-                if (chunk.content) {
-                  fullResponse += chunk.content;
-                  // Show the chunk as it streams, but we'll re-render the
-                  // final compressed version below. To avoid double-
-                  // printing, only echo when we're NOT going to post-
-                  // process (i.e., when showThinking is true and we want
-                  // to see everything live).
-                  if (showThinking) {
-                    process.stdout.write(chalk.cyan('  │ ') + chunk.content);
-                  }
-                }
-                break;
-              }
-              case 'thinking': {
-                // Reasoning content. Strip from persisted content via
-                // compressThinking; show live if user asked for it.
-                if (showThinking && chunk.content) {
-                  fullResponse += chunk.content;
-                  process.stdout.write(chalk.cyan('  │ ') + chunk.content);
-                }
-                break;
-              }
-              case 'tool_calls': {
-                if (chunk.toolCalls && chunk.toolCalls.length > 0) {
-                  for (const tc of chunk.toolCalls) {
-                    console.log();
-                    console.log(chalk.cyan(`  ⚙ ${tc.function.name}: ${formatArgs(tc.function.arguments)}`));
-                    console.log(chalk.gray('  ' + '─'.repeat(40)));
-                  }
-                }
-                break;
-              }
-              case 'usage': {
-                // v3.0.0: surface cache stats at the end of single-prompt
-                // mode so CLI users can see hit-rate without /cache command.
-                const u = chunk.usage;
-                const hit = u.prompt_cache_hit_tokens || u.cache_read_input_tokens || 0;
-                const miss = u.prompt_cache_miss_tokens || u.cache_creation_input_tokens || (u.prompt_tokens - hit);
-                if (hit > 0 || miss > 0) {
-                  const total = hit + miss;
-                  const rate = total > 0 ? ((hit / total) * 100).toFixed(1) : '0.0';
-                  console.log(chalk.gray(`  ⚡ cache: ${rate}% hit (${hit} / ${total} tokens)`));
-                }
-                break;
-              }
-            }
-          }
-
-          // v2.2.5: post-process. Strip <think> blocks, summarize,
-          // and print the cleaned conclusion if we suppressed it
-          // during streaming.
-          if (!showThinking && !abortCtrl.signal.aborted && fullResponse) {
-            const split = splitThinking(fullResponse);
-            if (split.thinking) {
-              // Clear what we already streamed (we suppressed text
-              // chunks during streaming, so there's nothing to clear
-              // unless showThinking was on; in that case the text
-              // already contains the <think> block live and there's
-              // no point double-printing).
-              const summary = summarizeThinking(split);
-              if (summary) {
-                console.log(chalk.gray(`  ${summary}`));
-              }
-              if (split.conclusion) {
-                console.log(chalk.cyan('  │ ') + split.conclusion);
-              }
-            } else if (fullResponse.trim()) {
-              // No thinking block found — print the conclusion if we
-              // hadn't already (showThinking=false suppresses
-              // streaming text).
-              console.log(chalk.cyan('  │ ') + fullResponse);
-            }
-          }
-
-          console.log();
-          // v2.2.4: skip persistence on abort.
-          if (!abortCtrl.signal.aborted) {
-            // v2.2.5: persist only the conclusion (no <think> blocks)
-            // when compression is enabled. This keeps the conversation
-            // log readable AND keeps context-window usage low.
-            const toPersist = showThinking
-              ? fullResponse
-              : compressThinking(fullResponse, false);
-            const accepted = app.session.addMessageSafe('assistant', toPersist);
-            if (!accepted) {
-              console.error(chalk.yellow(
-                '  ⚠️  Dropped assistant message containing [已中断] marker.\n' +
-                '      (prevents hallucination loop — try your question again)'
-              ));
-            }
-          } else {
-            console.log(chalk.yellow('  ⏹  Cancelled (response not saved)'));
-          }
-        } catch (error: any) {
-          const msg = error.message || String(error);
-          if (msg.includes('401') || msg.includes('403') || msg.includes('Unauthorized')) {
-            console.error(chalk.red('\n  ❌ API key invalid or expired.'));
-            console.log(chalk.gray('  Run ') + chalk.cyan('gfcode init') + chalk.gray(' to reconfigure.\n'));
-          } else if (msg.includes('429') || msg.includes('rate limit') || msg.includes('quota')) {
-            console.error(chalk.red('\n  ❌ Rate limit or quota exceeded.'));
-            console.log(chalk.gray('  Wait or run ') + chalk.cyan('gfcode init') + chalk.gray(' to switch provider.\n'));
-          } else if (msg.includes('ECONNREFUSED') || msg.includes('ENOTFOUND')) {
-            console.error(chalk.red('\n  ❌ Cannot connect to API server.'));
-            console.log(chalk.gray('  Check network or run ') + chalk.cyan('gfcode init') + chalk.gray('.\n'));
-          } else {
-            console.error(chalk.red(`\n  Error: ${msg}`));
-          }
-        } finally {
-          process.removeListener('SIGINT', onSigInt);
-        }
-      }
-    } catch (error: any) {
-      console.error(chalk.red(`\n  ${error.message}`));
-      process.exit(1);
-    }
-  });
-
-program
-  .command('init')
-  .description('Configure API key and model')
-  .action(async () => {
-    await WelcomeScreen.interactiveSetup();
-  });
-
-program.parse(process.argv);
-
-function formatArgs(args: string): string {
-  try {
-    const obj = JSON.parse(args);
-    return Object.entries(obj)
-      .map(([k, v]) => `${k}=${typeof v === 'string' && v.length > 40 ? v.slice(0, 40) + '...' : JSON.stringify(v)}`)
-      .join(' ');
-  } catch {
-    return args.length > 60 ? args.slice(0, 60) + '...' : args;
-  }
-}

package/src/config/index.ts

@@ -1,158 +0,0 @@
-/**
- * Config Manager - Handles configuration loading and saving
- * Supports custom providers (relay stations / 中转站)
- */
-
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { homedir } from 'os';
-import type { Config, AIConfig, ProviderName } from './types.js';
-import { PROVIDERS, getApiKeyFromEnv, isCustomProvider } from './providers.js';
-
-const DEFAULT_CONFIG: Config = {
-  model: 'Qwen/Qwen2.5-7B-Instruct',
-  apiKey: '',
-  temperature: 0.7,
-  maxTokens: 4096,
-  contextLength: 50,
-  provider: 'siliconflow',
-  // v3.0.0: prompt cache policy. Default = enabled, 'auto' TTL.
-  // v3.0.3: 'auto' TTL lets the runtime's decideTTL() pick 5m for short
-  // sessions and 1h for long ones (>= 15 turns or >= 50k chars). The
-  // chosen TTL is sticky across rounds within a session so the cache
-  // prefix stays stable.
-  cache: {
-    enabled: true,
-    ttl: 'auto',
-    strategy: 'auto',
-  },
-};
-
-export class ConfigManager {
-  private configPath: string;
-  private config: Config;
-
-  private constructor(configPath: string, config: Config) {
-    this.configPath = configPath;
-    this.config = config;
-  }
-
-  /**
-   * Load configuration from file + environment variables
-   */
-  static async load(): Promise<ConfigManager> {
-    const configDir = join(homedir(), '.thatgfsj');
-    const configPath = join(configDir, 'config.json');
-
-    let config = { ...DEFAULT_CONFIG };
-
-    // Load from file
-    try {
-      if (existsSync(configPath)) {
-        const data = readFileSync(configPath, 'utf-8');
-        config = { ...config, ...JSON.parse(data) };
-      }
-    } catch {
-      // Use defaults if file is corrupted
-    }
-
-    // Resolve provider
-    config = ConfigManager.resolveProvider(config);
-
-    return new ConfigManager(configPath, config);
-  }
-
-  /**
-   * Resolve provider settings: API key from env, base URL, model
-   */
-  private static resolveProvider(config: Config): Config {
-    const provider = config.provider || 'siliconflow';
-    const providerConfig = PROVIDERS[provider];
-
-    if (!providerConfig) {
-      return { ...config, provider: 'siliconflow', baseUrl: PROVIDERS.siliconflow.baseUrl };
-    }
-
-    // Model: env MODEL > config > provider default
-    const model = process.env.MODEL || config.model || providerConfig.defaultModel;
-
-    // API key: env > config
-    let apiKey = config.apiKey;
-    if (provider === 'ollama') {
-      apiKey = '';
-    } else if (!apiKey) {
-      apiKey = getApiKeyFromEnv(provider);
-    }
-
-    // Base URL: config > env > provider default
-    let baseUrl = config.baseUrl;
-    if (!baseUrl) {
-      // Check env for custom base URL
-      if (provider === 'custom_openai') {
-        baseUrl = process.env.CUSTOM_BASE_URL || '';
-      } else if (provider === 'custom_anthropic') {
-        baseUrl = process.env.CUSTOM_BASE_URL || '';
-      } else {
-        baseUrl = providerConfig.baseUrl;
-      }
-    }
-
-    return { ...config, provider, baseUrl, model, apiKey: apiKey || '' };
-  }
-
-  /**
-   * Get the current config
-   */
-  get(): Config {
-    return { ...this.config };
-  }
-
-  /**
-   * Get AIConfig for LLM providers
-   */
-  getAIConfig(): AIConfig {
-    return {
-      model: this.config.model,
-      apiKey: this.config.apiKey,
-      temperature: this.config.temperature,
-      maxTokens: this.config.maxTokens,
-      baseUrl: this.config.baseUrl,
-      provider: this.config.provider,
-    };
-  }
-
-  /**
-   * Get provider format (openai | anthropic | gemini)
-   */
-  getProviderFormat(): 'openai' | 'anthropic' | 'gemini' {
-    return PROVIDERS[this.config.provider]?.format || 'openai';
-  }
-
-  /**
-   * Update config and save to file
-   */
-  async save(updates: Partial<Config>): Promise<void> {
-    this.config = { ...this.config, ...updates };
-
-    const dir = dirname(this.configPath);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-
-    writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
-  }
-
-  /**
-   * Check if an API key is configured
-   */
-  hasApiKey(): boolean {
-    return !!this.config.apiKey;
-  }
-
-  /**
-   * Check if using a custom provider
-   */
-  isCustomProvider(): boolean {
-    return isCustomProvider(this.config.provider);
-  }
-}