thatgfsj-code 1.0.3 → 3.0.0

package/src/utils/project.ts

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

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

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

@@ -0,0 +1,75 @@
+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/stableStringify.test.ts

@@ -0,0 +1,43 @@
+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

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