thatgfsj-code 3.0.4 → 3.0.7

package/src/utils/project.ts

@@ -1,99 +0,0 @@
-/**
- * Project Context - Detect project type and gather info
- * Migrated from old src/utils/project-context.ts + getProjectContext() from index.ts
- */
-
-import { existsSync, readdirSync, statSync, readFileSync } from 'fs';
-import { join } from 'path';
-
-export interface ProjectInfo {
-  type: string;
-  name: string;
-  path: string;
-  fileCount: number;
-  dependencies: number;
-}
-
-export interface PackageJson {
-  name?: string;
-  version?: string;
-  dependencies?: Record<string, string>;
-  devDependencies?: Record<string, string>;
-}
-
-export class ProjectContext {
-  /**
-   * Get project context string for display
-   */
-  static getSummary(cwd: string = process.cwd()): string {
-    const info: string[] = [];
-
-    try {
-      const pkgPath = join(cwd, 'package.json');
-      if (existsSync(pkgPath)) {
-        const pkg: PackageJson = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-        info.push(`📦 Project: ${cwd}`);
-        info.push(`   Name: ${pkg.name || 'unknown'}`);
-        const depCount = Object.keys(pkg.dependencies || {}).length;
-        if (depCount > 0) info.push(`   Deps: ${depCount} packages`);
-      } else {
-        info.push(`📁 Working dir: ${cwd}`);
-      }
-
-      const fileCount = ProjectContext.countCodeFiles(cwd);
-      if (fileCount > 0) {
-        info.push(`   Files: ${fileCount} code files`);
-      }
-    } catch {
-      info.push(`📁 Working dir: ${cwd}`);
-    }
-
-    return info.join('\n');
-  }
-
-  /**
-   * Count code files in directory (skipping node_modules, .git, etc.)
-   */
-  static countCodeFiles(dir: string, maxDepth = 3): number {
-    let count = 0;
-    const codeExts = /\.(ts|js|py|go|rs|java|cpp|c|h|tsx|jsx|vue|svelte)$/;
-
-    const walk = (d: string, depth: number) => {
-      if (depth > maxDepth) return;
-      try {
-        const items = readdirSync(d);
-        for (const item of items) {
-          if (['node_modules', '.git', 'dist', 'build', '__pycache__'].includes(item)) continue;
-          const fullPath = join(d, item);
-          try {
-            const stat = statSync(fullPath);
-            if (stat.isDirectory()) {
-              walk(fullPath, depth + 1);
-            } else if (codeExts.test(item)) {
-              count++;
-            }
-          } catch {
-            // Skip inaccessible files
-          }
-        }
-      } catch {
-        // Skip inaccessible directories
-      }
-    };
-
-    walk(dir, 0);
-    return count;
-  }
-
-  /**
-   * Detect project type from files
-   */
-  static detectType(cwd: string = process.cwd()): string {
-    if (existsSync(join(cwd, 'package.json'))) return 'node';
-    if (existsSync(join(cwd, 'Cargo.toml'))) return 'rust';
-    if (existsSync(join(cwd, 'go.mod'))) return 'go';
-    if (existsSync(join(cwd, 'pyproject.toml')) || existsSync(join(cwd, 'requirements.txt'))) return 'python';
-    if (existsSync(join(cwd, 'build.gradle'))) return 'java';
-    return 'unknown';
-  }
-}

package/src/utils/stableStringify.ts

@@ -1,47 +0,0 @@
-/**
- * Deterministic JSON serializer.
- *
- * JSON.stringify in V8 iterates keys in insertion order, which means objects
- * built with literal `{a, b, c}` are stable, but anything built via spread,
- * Object.fromEntries, or merged maps can produce different byte sequences
- * between requests. That byte-sequence instability is fatal for prompt-cache
- * hit-rate: a single reordered key invalidates the cache fingerprint.
- *
- * stableStringify sorts object keys lexicographically before recursing, so
- * any pair of structurally equal objects produces identical JSON text.
- *
- * Performance note: O(n log n) on key counts per object. For typical request
- * bodies (<200 KB) the overhead is negligible (<5 ms). The main hot path is
- * the tool/parameters tree which is small and stable in practice.
- *
- * Reference: Reasonix-style "stableStringify" requirement for prefix-cache
- * byte-level stability (see DeepSeek Reasonix, Section 3).
- */
-export function stableStringify(value: unknown): string {
-  return stringify(value);
-}
-
-function stringify(value: unknown): string {
-  if (value === null) return 'null';
-  if (value === undefined) return 'null'; // OpenAI wire format does not carry undefined
-  const t = typeof value;
-  if (t === 'string') return JSON.stringify(value);
-  if (t === 'number') return Number.isFinite(value as number) ? String(value) : 'null';
-  if (t === 'boolean') return value ? 'true' : 'false';
-  if (Array.isArray(value)) {
-    return '[' + value.map((v) => stringify(v)).join(',') + ']';
-  }
-  if (t === 'object') {
-    const obj = value as Record<string, unknown>;
-    const keys = Object.keys(obj).sort();
-    const parts: string[] = [];
-    for (const k of keys) {
-      const v = obj[k];
-      if (v === undefined) continue; // omit undefined to match OpenAI/Anthropic convention
-      parts.push(JSON.stringify(k) + ':' + stringify(v));
-    }
-    return '{' + parts.join(',') + '}';
-  }
-  // functions / symbols / bigints: drop
-  return 'null';
-}

package/src/utils/thinking.ts

@@ -1,119 +0,0 @@
-/**
- * Thinking block extraction + compression
- *
- * Models that aren't truly reasoning-capable (Qwen, DeepSeek-V3 chat,
- * Kimi, etc.) still emit `<think>...</think>` blocks as plain text
- * inside their response. These blocks can be hundreds of lines of
- * internal monologue that the user doesn't want to see scroll by.
- *
- * opencode handles this by separating reasoning into its own stream
- * part at the protocol level. We don't have that luxury — the model
- * is emitting everything as a single `content` field. So we use the
- * same regex-strip approach opencode uses internally (see
- * packages/opencode/src/session/prompt.ts line 244).
- *
- * Three block delimiters are supported:
- *   1. <think>...</think>          — DeepSeek / Qwen / Kimi
- *   2. <reasoning>...</reasoning>  — OpenRouter-style
- *   3. [THINK]...[/THINK]          — some custom fine-tunes
- *
- * Usage:
- *   const { thinking, conclusion } = splitThinking(fullContent);
- *   if (thinking && compress) {
- *     render(`💭 ${summarize(thinking)}\n${conclusion}`);
- *   } else {
- *     render(fullContent);
- *   }
- */
-
-export interface ThinkingSplit {
-  /** Raw `<think>...` content, or empty if none. */
-  thinking: string;
-  /** Content with thinking blocks stripped + trimmed. */
-  conclusion: string;
-  /** How many lines the thinking block spanned. */
-  thinkingLines: number;
-  /** First non-empty line of the thinking block (heuristic summary). */
-  thinkingHint: string;
-}
-
-/**
- * All known thinking-block delimiters, in priority order. The regex
- * flags `gi` (global, case-insensitive) so `[THINK]` and `<think>`
- * are both caught, and so multiple blocks collapse cleanly.
- */
-const THINKING_PATTERNS: RegExp[] = [
-  /<think>[\s\S]*?<\/think>/gi,
-  /<reasoning>[\s\S]*?<\/reasoning>/gi,
-  /\[THINK\][\s\S]*?\[\/THINK\]/gi,
-];
-
-export function splitThinking(content: string): ThinkingSplit {
-  if (!content) {
-    return { thinking: '', conclusion: '', thinkingLines: 0, thinkingHint: '' };
-  }
-
-  let thinking = '';
-  let remaining = content;
-
-  for (const pat of THINKING_PATTERNS) {
-    const matches = remaining.match(pat);
-    if (matches) {
-      thinking += matches.join('\n');
-      remaining = remaining.replace(pat, '');
-    }
-  }
-
-  const conclusion = remaining.trim();
-  const thinkingLines = thinking ? thinking.split('\n').length : 0;
-  const thinkingHint = firstNonEmptyLine(thinking);
-
-  return { thinking, conclusion, thinkingLines, thinkingHint };
-}
-
-/**
- * Build a short, single-line summary of a thinking block, suitable
- * for collapsed display. Returns something like:
- *   "💭 thought for 24 lines: The user is asking about Win+E..."
- * Falls back to "(no hint)" if the block is empty.
- */
-export function summarizeThinking(split: ThinkingSplit): string {
-  if (!split.thinking) return '';
-  const hint = split.thinkingHint.length > 60
-    ? split.thinkingHint.slice(0, 57) + '...'
-    : split.thinkingHint;
-  return `💭 thought for ${split.thinkingLines} line${split.thinkingLines === 1 ? '' : 's'}${hint ? `: ${hint}` : ''}`;
-}
-
-/**
- * Render full content with thinking blocks compressed (collapsed to
- * a single-line indicator). If `showThinking` is true, returns the
- * content unchanged (debug mode).
- */
-export function compressThinking(content: string, showThinking: boolean = false): string {
-  if (showThinking || !content) return content;
-  const split = splitThinking(content);
-  if (!split.thinking) return content;
-  const summary = summarizeThinking(split);
-  return summary ? `${summary}\n${split.conclusion}` : split.conclusion;
-}
-
-function firstNonEmptyLine(s: string): string {
-  if (!s) return '';
-  for (const line of s.split('\n')) {
-    // Strip any leading/trailing thinking-tag fragments that may have
-    // been captured by the regex (e.g. "<think>The user said..."
-    // or "...</think>"). We strip ALL occurrences to handle the
-    // case where the first line wraps across a tag.
-    const t = line
-      .trim()
-      .replace(/<\/?think>/gi, '')
-      .replace(/<\/?reasoning>/gi, '')
-      .replace(/\[\/?THINK\]/gi, '')
-      .trim();
-    if (t) return t;
-  }
-  return '';
-}
-
-export { THINKING_PATTERNS };

package/tests/cache/fingerprint.test.ts

@@ -1,75 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { fingerprint, fingerprintTools, fingerprintSystemPrefix } from '../../src/cache/fingerprint.js';
-import type { Tool } from '../../src/tools/types.js';
-import type { SystemSegment } from '../../src/prompts/index.js';
-
-describe('fingerprint', () => {
-  it('returns same hash for structurally equal objects', () => {
-    const a = { name: 'file', description: 'Read files', inputSchema: { type: 'object' } };
-    const b = { inputSchema: { type: 'object' }, description: 'Read files', name: 'file' };
-    expect(fingerprint(a)).toBe(fingerprint(b));
-  });
-
-  it('returns different hash for different content', () => {
-    expect(fingerprint({ name: 'a' })).not.toBe(fingerprint({ name: 'b' }));
-  });
-
-  it('returns 16-char hex string', () => {
-    const fp = fingerprint({ x: 1 });
-    expect(fp).toMatch(/^[0-9a-f]{16}$/);
-  });
-
-  it('fingerprintTools ignores non-wire Tool metadata', () => {
-    // Two Tool objects with same name/description/inputSchema but different
-    // internal metadata (e.g. version, internal flags) must produce the
-    // same fingerprint, because only the three wire fields matter for
-    // upstream prompt cache lookup.
-    const t1: Tool = {
-      name: 'file',
-      description: 'Read/write files',
-      parameters: [],
-      inputSchema: { type: 'object', properties: { path: { type: 'string' } } },
-      execute: async () => ({ success: true }),
-      // @ts-expect-error: simulate extra internal metadata
-      version: '1.0.0',
-    };
-    const t2: Tool = {
-      name: 'file',
-      description: 'Read/write files',
-      parameters: [],
-      inputSchema: { type: 'object', properties: { path: { type: 'string' } } },
-      execute: async () => ({ success: true }),
-      // @ts-expect-error
-      version: '2.0.0',
-    };
-    expect(fingerprintTools([t1])).toBe(fingerprintTools([t2]));
-  });
-
-  it('fingerprintSystemPrefix excludes volatile segments', () => {
-    const segments: SystemSegment[] = [
-      { name: 'identity', content: 'You are Thatgfsj', volatile: false },
-      { name: 'tools', content: '## Tools\nfile, shell', volatile: false },
-      { name: 'nwt', content: 'Recent: did X, did Y, did Z', volatile: true },
-      { name: 'date', content: '2026-08-08 12:34:56', volatile: true },
-    ];
-    // Hash should be stable when only the volatile segments change.
-    const baseFp = fingerprintSystemPrefix(segments);
-
-    const segmentsMutated: SystemSegment[] = [
-      { name: 'identity', content: 'You are Thatgfsj', volatile: false },
-      { name: 'tools', content: '## Tools\nfile, shell', volatile: false },
-      { name: 'nwt', content: 'Recent: did X, did Y, did ZZZZZZ', volatile: true }, // mutated
-      { name: 'date', content: '2099-12-31 00:00:00', volatile: true }, // mutated
-    ];
-    expect(fingerprintSystemPrefix(segmentsMutated)).toBe(baseFp);
-
-    // But change to an immutable segment should break the hash.
-    const segmentsIdentityChanged: SystemSegment[] = [
-      { name: 'identity', content: 'You are a different agent', volatile: false },
-      { name: 'tools', content: '## Tools\nfile, shell', volatile: false },
-      { name: 'nwt', content: 'Recent: did X, did Y, did Z', volatile: true },
-      { name: 'date', content: '2026-08-08 12:34:56', volatile: true },
-    ];
-    expect(fingerprintSystemPrefix(segmentsIdentityChanged)).not.toBe(baseFp);
-  });
-});

package/tests/cache/providerCatalog.test.ts

@@ -1,31 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getModelsForProvider, PROVIDERS } from '../../src/config/providers.js';
-
-describe('ModelSelector catalog integration', () => {
-  it('deepseek provider has deepseek-chat and deepseek-reasoner', () => {
-    const models = getModelsForProvider('deepseek');
-    const ids = models.map(m => m.id);
-    expect(ids).toContain('deepseek-chat');
-    expect(ids).toContain('deepseek-reasoner');
-  });
-
-  it('siliconflow provider has Qwen models', () => {
-    const models = getModelsForProvider('siliconflow');
-    const ids = models.map(m => m.id);
-    expect(ids).toContain('Qwen/Qwen2.5-7B-Instruct');
-  });
-
-  it('custom_openai provider has gpt-4o fallback', () => {
-    const models = getModelsForProvider('custom_openai');
-    const ids = models.map(m => m.id);
-    expect(ids).toContain('gpt-4o');
-  });
-
-  it('all known providers have a non-empty catalog', () => {
-    const knownProviders = Object.keys(PROVIDERS);
-    for (const p of knownProviders) {
-      const models = getModelsForProvider(p as any);
-      expect(models.length, `provider ${p} should have at least one model`).toBeGreaterThan(0);
-    }
-  });
-});

package/tests/cache/smartModel.test.ts

@@ -1,100 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { decideTTL, totalConversationChars, shouldDowngrade } from '../../src/cache/smartModel.js';
-import type { ChatMessage } from '../../src/types.js';
-
-function userMsg(s: string): ChatMessage {
-  return { role: 'user', content: s };
-}
-function assistantMsg(s: string): ChatMessage {
-  return { role: 'assistant', content: s };
-}
-
-describe('decideTTL', () => {
-  it('defaults to 1h (long-task) on round 0 — task length unknown', () => {
-    const d = decideTTL([], null);
-    expect(d.ttl).toBe('1h');
-    expect(d.isFirstDecision).toBe(true);
-    expect(d.reason).toBe('default-long-task');
-  });
-
-  it('defaults to 1h even for a small conversation — cannot predict future length', () => {
-    const messages = [
-      userMsg('hello'),
-      assistantMsg('hi'),
-      userMsg('how are you?'),
-      assistantMsg('good'),
-    ];
-    const d = decideTTL(messages, null);
-    expect(d.ttl).toBe('1h');
-  });
-
-  it('defaults to 1h for a large conversation too', () => {
-    const messages: ChatMessage[] = [];
-    for (let i = 0; i < 16; i++) {
-      messages.push(userMsg(`question ${i}`));
-      messages.push(assistantMsg(`answer ${i} long enough to be content`));
-    }
-    const d = decideTTL(messages, null);
-    expect(d.ttl).toBe('1h');
-  });
-
-  it('reuses previous TTL (stability rule)', () => {
-    const messages = [userMsg('hello'), assistantMsg('hi')];
-    const d1 = decideTTL(messages, null);
-    expect(d1.ttl).toBe('1h');
-    expect(d1.isFirstDecision).toBe(true);
-
-    // Once pinned to 5m by the user, later rounds keep 5m.
-    const d2 = decideTTL(messages, '5m');
-    expect(d2.ttl).toBe('5m');
-    expect(d2.isFirstDecision).toBe(false);
-    expect(d2.reason).toBe('reused-from-previous-round');
-
-    // And once pinned to 1h, later rounds keep 1h.
-    const d3 = decideTTL(messages, '1h');
-    expect(d3.ttl).toBe('1h');
-    expect(d3.isFirstDecision).toBe(false);
-  });
-});
-
-describe('totalConversationChars', () => {
-  it('sums string content', () => {
-    const total = totalConversationChars([
-      userMsg('abc'),
-      assistantMsg('defgh'),
-    ]);
-    expect(total).toBe(8);
-  });
-
-  it('handles array content blocks', () => {
-    const total = totalConversationChars([
-      { role: 'user', content: [
-        { type: 'text', text: 'hello' },
-        { type: 'image', source: { type: 'base64', media_type: 'image/png', data: 'XXXX' } },
-      ] as any },
-    ]);
-    expect(total).toBe(5);
-  });
-});
-
-describe('shouldDowngrade', () => {
-  it('downgrades short prompts without tool calls', () => {
-    const d = shouldDowngrade([], 'hi');
-    expect(d.downgrade).toBe(true);
-  });
-
-  it('does not downgrade long prompts', () => {
-    const d = shouldDowngrade([], 'x'.repeat(300));
-    expect(d.downgrade).toBe(false);
-    expect(d.reason).toBe('prompt-too-long');
-  });
-
-  it('does not downgrade when recent tool calls exist', () => {
-    const messages: ChatMessage[] = [
-      { role: 'assistant', content: '...', tool_calls: [{ id: '1', type: 'function', function: { name: 'f', arguments: '{}' } }] },
-    ];
-    const d = shouldDowngrade(messages, 'hi');
-    expect(d.downgrade).toBe(false);
-    expect(d.reason).toBe('recent-tool-call');
-  });
-});

package/tests/cache/stableStringify.test.ts

@@ -1,43 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { stableStringify } from '../../src/utils/stableStringify.js';
-
-describe('stableStringify', () => {
-  it('produces identical output for keys inserted in different orders', () => {
-    const a = { name: 'file', description: 'Read files', inputSchema: { type: 'object' } };
-    const b = { inputSchema: { type: 'object' }, description: 'Read files', name: 'file' };
-    expect(stableStringify(a)).toBe(stableStringify(b));
-  });
-
-  it('omits undefined values (matches OpenAI/Anthropic wire convention)', () => {
-    expect(stableStringify({ a: 1, b: undefined, c: 2 })).toBe(stableStringify({ a: 1, c: 2 }));
-  });
-
-  it('handles nested objects recursively', () => {
-    const a = { tools: [{ name: 'a', args: { x: 1 } }, { name: 'b', args: { y: 2 } }] };
-    const b = { tools: [{ args: { x: 1 }, name: 'a' }, { args: { y: 2 }, name: 'b' }] };
-    expect(stableStringify(a)).toBe(stableStringify(b));
-  });
-
-  it('handles primitives correctly', () => {
-    expect(stableStringify(null)).toBe('null');
-    expect(stableStringify('hello')).toBe('"hello"');
-    expect(stableStringify(42)).toBe('42');
-    expect(stableStringify(true)).toBe('true');
-    expect(stableStringify(false)).toBe('false');
-  });
-
-  it('escapes special characters in strings', () => {
-    expect(stableStringify('hello\nworld')).toBe('"hello\\nworld"');
-    expect(stableStringify('"quoted"')).toBe('"\\"quoted\\""');
-  });
-
-  it('drops NaN and Infinity to null (JSON-incompatible)', () => {
-    expect(stableStringify(NaN)).toBe('null');
-    expect(stableStringify(Infinity)).toBe('null');
-  });
-
-  it('produces empty {} for empty objects and [] for empty arrays', () => {
-    expect(stableStringify({})).toBe('{}');
-    expect(stableStringify([])).toBe('[]');
-  });
-});

package/tests/cache/stats.test.ts

@@ -1,146 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync, existsSync, readFileSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { CacheStatsStore, estimateSavingsCNY } from '../../src/cache/stats.js';
-import type { Usage } from '../../src/types.js';
-
-let tmpDir: string;
-let statsPath: string;
-
-beforeEach(() => {
-  tmpDir = mkdtempSync(join(tmpdir(), 'cache-stats-'));
-  statsPath = join(tmpDir, 'cache-stats.json');
-});
-
-afterEach(() => {
-  rmSync(tmpDir, { recursive: true, force: true });
-});
-
-describe('CacheStatsStore', () => {
-  it('starts empty when no file exists', () => {
-    const store = new CacheStatsStore(statsPath);
-    const s = store.snapshot();
-    expect(s.totalRequests).toBe(0);
-    expect(s.totalReadTokens).toBe(0);
-    expect(s.totalCreationTokens).toBe(0);
-    expect(s.totalInputTokens).toBe(0);
-    expect(s.hitRate).toBe(0);
-    expect(s.estimatedSavingsCNY).toBe(0);
-    expect(s.history).toEqual([]);
-  });
-
-  it('records Anthropic usage (cache_read / cache_creation)', () => {
-    const store = new CacheStatsStore(statsPath);
-    const usage: Usage = {
-      prompt_tokens: 1000,
-      completion_tokens: 200,
-      total_tokens: 1200,
-      cache_creation_input_tokens: 800,
-      cache_read_input_tokens: 100,
-    };
-    store.record(usage);
-
-    const s = store.snapshot();
-    expect(s.totalRequests).toBe(1);
-    expect(s.totalReadTokens).toBe(100);
-    expect(s.totalCreationTokens).toBe(800);
-    expect(s.totalInputTokens).toBe(1000);
-    expect(s.totalOutputTokens).toBe(200);
-    expect(s.hitRate).toBeCloseTo(0.1, 5); // 100 / 1000
-    expect(s.history.length).toBe(1);
-    expect(s.history[0].read).toBe(100);
-  });
-
-  it('records DeepSeek usage (prompt_cache_hit / miss)', () => {
-    const store = new CacheStatsStore(statsPath);
-    const usage: Usage = {
-      prompt_tokens: 5000,
-      completion_tokens: 800,
-      total_tokens: 5800,
-      prompt_cache_hit_tokens: 4000,
-      prompt_cache_miss_tokens: 1000,
-    };
-    store.record(usage);
-
-    const s = store.snapshot();
-    expect(s.totalReadTokens).toBe(4000); // hit → read
-    expect(s.totalCreationTokens).toBe(1000); // miss → creation
-    expect(s.hitRate).toBeCloseTo(0.8, 5); // 4000 / 5000
-  });
-
-  it('persists across instances', () => {
-    const a = new CacheStatsStore(statsPath);
-    a.record({
-      prompt_tokens: 100,
-      completion_tokens: 50,
-      total_tokens: 150,
-      cache_read_input_tokens: 80,
-    });
-    expect(existsSync(statsPath)).toBe(true);
-
-    const b = new CacheStatsStore(statsPath);
-    const s = b.snapshot();
-    expect(s.totalRequests).toBe(1);
-    expect(s.totalReadTokens).toBe(80);
-  });
-
-  it('reset() clears all stats', () => {
-    const store = new CacheStatsStore(statsPath);
-    store.record({
-      prompt_tokens: 100,
-      completion_tokens: 50,
-      total_tokens: 150,
-      cache_read_input_tokens: 80,
-    });
-    expect(store.snapshot().totalRequests).toBe(1);
-
-    store.reset();
-    const s = store.snapshot();
-    expect(s.totalRequests).toBe(0);
-    expect(s.totalReadTokens).toBe(0);
-    expect(s.history).toEqual([]);
-  });
-
-  it('history rolls over after HISTORY_LIMIT rounds', () => {
-    const store = new CacheStatsStore(statsPath);
-    for (let i = 0; i < 60; i++) {
-      store.record({
-        prompt_tokens: 100,
-        completion_tokens: 50,
-        total_tokens: 150,
-        cache_read_input_tokens: 10,
-      });
-    }
-    // Internal HISTORY_LIMIT is 50; the array should be capped.
-    expect(store.snapshot().history.length).toBeLessThanOrEqual(50);
-    expect(store.snapshot().totalRequests).toBe(60); // totals not capped
-  });
-});
-
-describe('estimateSavingsCNY', () => {
-  it('returns 0 when nothing cached', () => {
-    expect(estimateSavingsCNY({
-      totalReadTokens: 0,
-      totalCreationTokens: 0,
-      totalInputTokens: 0,
-      totalOutputTokens: 0,
-      totalRequests: 0,
-      history: [],
-    })).toBe(0);
-  });
-
-  it('returns positive for cached tokens', () => {
-    // 1M tokens cached at 10x saving ≈ ¥2.7
-    const v = estimateSavingsCNY({
-      totalReadTokens: 1_000_000,
-      totalCreationTokens: 0,
-      totalInputTokens: 1_000_000,
-      totalOutputTokens: 0,
-      totalRequests: 1,
-      history: [],
-    });
-    expect(v).toBeGreaterThan(2);
-    expect(v).toBeLessThan(3.5);
-  });
-});