thatgfsj-code 2.2.9 → 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

@@ -1,122 +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,
-  /<thinking>[\s\S]*?<\/thinking>/gi,
-  /<reasoning>[\s\S]*?<\/reasoning>/gi,
-  /<THINK>[\s\S]*?<\/THINK>/gi,        // v2.2.7 edge: case variant
-  /\[THINK\][\s\S]*?\[\/THINK\]/gi,
-  /\[\/?think\]/gi,                    // bare [think] / [/think] (rare)
-];
-
-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 '';
-}
-
+/**
+ * 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('[]');
+  });
+});