thatgfsj-code 3.0.4 → 3.0.6

package/install.sh

@@ -1,113 +0,0 @@
-#!/bin/bash
-# Thatgfsj Code Installer for macOS/Linux
-# Usage: curl -sL https://raw.githubusercontent.com/Thatgfsj/thatgfsj-code/main/install.sh | bash
-
-set -e
-
-# Colors
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-CYAN='\033[0;36m'
-NC='\033[0m' # No Color
-
-echo ""
-echo -e "${CYAN}  Thatgfsj Code 安装向导${NC}"
-echo -e "${CYAN}  =======================${NC}"
-echo ""
-
-# ============== Step 1: Check Node.js ==============
-echo -e "${YELLOW}[*] 检查 Node.js...${NC}"
-
-if command -v node &> /dev/null; then
-    NODE_VERSION=$(node --version)
-    MAJOR_VERSION=$(echo $NODE_VERSION | cut -d'v' -f2 | cut -d'.' -f1)
-    if [ "$MAJOR_VERSION" -ge 18 ]; then
-        echo -e "${GREEN}[✓] Node.js $NODE_VERSION 已安装${NC}"
-    else
-        echo -e "${RED}[✗] Node.js 版本过低，需要 v18+${NC}"
-        echo "    请访问 https://nodejs.org 升级"
-        exit 1
-    fi
-else
-    echo -e "${YELLOW}[*] 未检测到 Node.js，开始安装...${NC}"
-    
-    # Try Homebrew (macOS)
-    if command -v brew &> /dev/null; then
-        echo -e "${YELLOW}[*] 使用 Homebrew 安装...${NC}"
-        brew install node
-    # Try apt (Ubuntu/Debian)
-    elif command -v apt-get &> /dev/null; then
-        echo -e "${YELLOW}[*] 使用 apt 安装...${NC}"
-        curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
-        sudo apt-get install -y nodejs
-    # Try yum (CentOS/RHEL)
-    elif command -v yum &> /dev/null; then
-        echo -e "${YELLOW}[*] 使用 yum 安装...${NC}"
-        curl -fsSL https://rpm.nodesource.com/setup_20.x | sudo bash -
-        sudo yum install -y nodejs
-    else
-        echo -e "${RED}[✗] 未找到包管理器${NC}"
-        echo "    请手动安装: https://nodejs.org"
-        exit 1
-    fi
-fi
-
-# ============== Step 2: Clone/Update ==============
-echo -e "${YELLOW}[*] 准备安装 Thatgfsj Code...${NC}"
-
-INSTALL_DIR="$HOME/thatgfsj-code"
-
-if [ -d "$INSTALL_DIR" ]; then
-    echo -e "${YELLOW}[*] 检测到已有安装，正在更新...${NC}"
-    cd "$INSTALL_DIR"
-    git pull origin main 2>/dev/null || {
-        echo -e "${YELLOW}[*] 更新失败，重新克隆...${NC}"
-        rm -rf "$INSTALL_DIR"
-    }
-fi
-
-if [ ! -d "$INSTALL_DIR" ]; then
-    echo -e "${YELLOW}[*] 克隆仓库...${NC}"
-    git clone https://github.com/Thatgfsj/thatgfsj-code.git "$INSTALL_DIR"
-fi
-
-cd "$INSTALL_DIR"
-
-if [ ! -f "package.json" ]; then
-    echo -e "${RED}[✗] 安装目录无效${NC}"
-    exit 1
-fi
-
-echo -e "${GREEN}[✓] 代码准备完成: $INSTALL_DIR${NC}"
-
-# ============== Step 3: Install Dependencies ==============
-echo -e "${YELLOW}[*] 安装依赖...${NC}"
-
-npm install
-npm run build
-
-echo -e "${GREEN}[✓] 依赖安装完成${NC}"
-
-# ============== Step 4: Link Command ==============
-echo -e "${YELLOW}[*] 设置命令...${NC}"
-
-npm link
-
-echo -e "${GREEN}[✓] 命令 'gfcode' 已可用${NC}"
-
-# ============== Done ==============
-echo ""
-echo -e "${CYAN}  ======================================${NC}"
-echo -e "${GREEN}  安装完成!${NC}"
-echo -e "${CYAN}  ======================================${NC}"
-echo ""
-echo -e "  ${WHITE}使用方法:${NC}"
-echo -e "    gfcode init          - 重新配置"
-echo -e "    gfcode               - 启动交互模式"
-echo -e "    gfcode '你的问题'    - 直接提问"
-echo -e "    gfcode explain '代码' - 解释代码"
-echo -e "    gfcode debug '代码'   - 调试代码"
-echo ""
-echo -e "  文档: ${CYAN}https://github.com/Thatgfsj/thatgfsj-code${NC}"
-echo ""

package/src/app/index.ts

@@ -1,197 +0,0 @@
-/**
- * App - Core application singleton
- * Simplified: directly uses LLMService (which has built-in agent loop)
- *
- * v3.0.0+: streamResponse yields structured StreamChunk
- *   - runPrompt streams { type: 'text' } chunks to stdout and captures the
- *     final usage for cache stats recording.
- */
-
-import { ConfigManager } from '../config/index.js';
-import { LLMService } from '../llm/index.js';
-import { SessionManager } from '../session/index.js';
-import { ToolRegistry } from '../tools/index.js';
-import { HookManager } from '../hooks/index.js';
-import { SystemPromptBuilder } from '../prompts/index.js';
-import { SkillRegistry } from '../skills/index.js';
-import { CacheStatsStore } from '../cache/stats.js';
-import { compressThinking } from '../utils/thinking.js';
-import type { ChatMessage, ChatResponse, StreamChunk, Usage } from '../types.js';
-
-export class App {
-  config: ConfigManager;
-  llm: LLMService;
-  session: SessionManager;
-  tools: ToolRegistry;
-  hooks: HookManager;
-  prompts: SystemPromptBuilder;
-  skills: SkillRegistry;
-  /**
-   * v3.0.0: persistent cache stats store. The single source of truth for
-   * cache hit-rate and estimated savings, surfaced through the TUI Header
-   * and the /cache command.
-   */
-  cacheStats: CacheStatsStore;
-  /**
-   * v2.2.5 (product 0.4.2): toggle  block compression. Default
-   * true. Toggled by `--show-thinking` on the CLI or `/thinking on|off`
-   * in the REPL.
-   */
-  showThinking: boolean = false;
-  /**
-   * v3.0.3: TTL resolved per session. null = not yet decided (auto mode
-   * waiting for first round). After the first chatStream completes, this
-   * is '5m' or '1h' and stays sticky.
-   */
-  resolvedTtl: '5m' | '1h' | null = null;
-
-  private constructor(
-    config: ConfigManager,
-    llm: LLMService,
-    session: SessionManager,
-    tools: ToolRegistry,
-    hooks: HookManager,
-    prompts: SystemPromptBuilder,
-    skills: SkillRegistry,
-    cacheStats: CacheStatsStore,
-  ) {
-    this.config = config;
-    this.llm = llm;
-    this.session = session;
-    this.tools = tools;
-    this.hooks = hooks;
-    this.prompts = prompts;
-    this.skills = skills;
-    this.cacheStats = cacheStats;
-  }
-
-  static async create(): Promise<App> {
-    const config = await ConfigManager.load();
-    const aiConfig = config.getAIConfig();
-
-    const llm = LLMService.fromConfig(aiConfig);
-    const cacheStats = new CacheStatsStore();
-    const session = new SessionManager(config.get().contextLength || 50);
-    // v3.0.0: do not mutate messages when context grows — instead, surface
-    // a "consider /new" toast via onSuggestNewSession. The TUI wires this
-    // up in app.tsx; in CLI single-prompt mode it's a no-op (one-shot).
-    session.onSuggestNewSession = (info) => {
-      console.warn(
-        `\n  ⚠️  上下文较长（${info.currentLength}/${info.max}）。` +
-        `建议调 /new 开新会话（NWT 已自动归档历史）\n`,
-      );
-    };
-    const tools = new ToolRegistry();
-    const hooks = new HookManager();
-    const skills = new SkillRegistry();
-
-    // Register tools with LLM service
-    llm.registerTools(tools.list());
-
-    // Auto-init NWT timeline
-    const nwtTool = tools.get('nwt');
-    if (nwtTool) {
-      await nwtTool.execute({ action: 'init' });
-    }
-
-    // Build system prompt with active skills
-    const prompts = new SystemPromptBuilder({
-      cwd: process.cwd(),
-      tools: tools.list(),
-      permissionMode: 'ask',
-      skillsPrompt: skills.getActivePrompts(),
-    });
-    session.addMessage('system', prompts.build());
-
-    return new App(config, llm, session, tools, hooks, prompts, skills, cacheStats);
-  }
-
-  /**
-   * Stream a response for the current session messages.
-   * The LLMService handles the full agent loop internally.
-   *
-   * Yields structured StreamChunks. Returns the final ChatResponse (with usage
-   * if the provider reported it) so the caller can record cache stats.
-   *
-   * Implementation note: we drain the inner stream manually so the final
-   * ChatResponse returned by LLMService.chatStream is propagated as this
-   * generator's return value. Using yield* doesn't carry the return value
-   * through TS's AsyncGenerator<T, R> type inference in this version of
-   * TypeScript, so we wrap with an inner for-await and explicit return.
-   */
-  async *streamResponse(messages?: ChatMessage[]): AsyncGenerator<StreamChunk, ChatResponse> {
-    const msgs = messages || this.session.getMessages();
-    const inner = this.llm.chatStream(msgs);
-    const debugUsage = !!process.env.GFCODE_DEBUG_USAGE;
-    // v3.0.3: read TTL the LLMService resolved this round (sticky per session).
-    this.resolvedTtl = this.llm.getResolvedTTL();
-    let next = await inner.next();
-    while (!next.done) {
-      // Forward chunks unchanged, but capture usage into the persistent
-      // cache stats store so the TUI Header / /cache command can read it.
-      if (next.value && next.value.type === 'usage') {
-        try { this.cacheStats.record(next.value.usage); } catch { /* best-effort */ }
-        if (debugUsage) {
-          // v3.0.0 DEBUG: dump raw usage fields to stderr so the user can
-          // confirm whether the upstream provider/relay forwards cache stats.
-          // Enable with: GFCODE_DEBUG_USAGE=1 gfcode ...
-          process.stderr.write(
-            '[debug_usage] ' + JSON.stringify(next.value.usage) + '\n'
-          );
-        }
-      }
-      yield next.value;
-      next = await inner.next();
-    }
-    // The generator's return value (ChatResponse with usage) is propagated
-    // to callers via `for await ... await streamResponse.next()` semantics.
-    return next.value;
-  }
-
-  /**
-   * Run a single prompt (non-interactive mode)
-   *
-   * v2.2.4 (port from v2.1.0): persistence of the assistant message
-   * uses addMessageSafe, which drops the message if it contains
-   * pollution markers like "[已中断]".
-   *
-   * v2.2.5 (product 0.4.2): persistence also strips  blocks
-   * (and similar reasoning delimiters) when showThinking is false,
-   * so the conversation log stays compact.
-   *
-   * v3.0.0: yields structured StreamChunks; final usage is captured
-   * into onUsage callback for cache stats persistence.
-   */
-  async runPrompt(prompt: string, onUsage?: (usage: Usage) => void): Promise<string> {
-    this.session.addMessage('user', prompt);
-
-    let fullResponse = '';
-    let finalUsage: ChatResponse['usage'] | undefined;
-    try {
-      for await (const chunk of this.streamResponse()) {
-        if (chunk.type === 'text' && chunk.content) {
-          process.stdout.write(chunk.content);
-          fullResponse += chunk.content;
-        } else if (chunk.type === 'usage') {
-          finalUsage = chunk.usage;
-        }
-      }
-    } catch (err) {
-      // Re-throw without persisting partial response. Persisting
-      // truncated output here was the source of the [已中断] loop in
-      // v2.2.3.
-      throw err;
-    }
-
-    console.log();
-    // v2.2.5: compress  blocks before persisting.
-    const toPersist = compressThinking(fullResponse, this.showThinking);
-    this.session.addMessageSafe('assistant', toPersist);
-
-    // v3.0.0: forward usage to caller (CLI single-shot mode records stats too)
-    if (finalUsage && onUsage) {
-      try { onUsage(finalUsage); } catch { /* best-effort */ }
-    }
-    return fullResponse;
-  }
-}

package/src/cache/fingerprint.ts

@@ -1,101 +0,0 @@
-/**
- * Cache fingerprints — small, stable hashes used to detect when the
- * "cacheable prefix" of an LLM request changes between rounds.
- *
- * Why this exists:
- *   Anthropic prompt cache and DeepSeek automatic prefix cache both break
- *   when the request body changes upstream of the cache breakpoint. To
- *   debug "why is my hit-rate 0%", we want a quick fingerprint of the
- *   things that *should* be cacheable (tools + system prefix) so we can
- *   log it on every request and compare across rounds.
- *
- *   The fingerprint itself is NOT used to decide anything (the upstream
- *   provider does the actual cache lookup). It's purely a debug /
- *   observability tool — same role as `reasoning_content` in the message
- *   schema: captured for transparency, not for control flow.
- *
- * Implementation:
- *   - Uses stableStringify (sibling module) so logically equal objects
- *     always produce the same JSON.
- *   - Hashes with sha256 (Node built-in `crypto`), truncated to 16 chars.
- *     16 hex chars = 64 bits, which is plenty for collision-resistance
- *     across a single user's session.
- */
-
-import { createHash } from 'crypto';
-import type { Tool } from '../tools/types.js';
-import type { SystemSegment } from '../prompts/index.js';
-
-/**
- * Hash a stable JSON representation of `value` and return a 16-char hex prefix.
- * Recursively normalizes object keys (sorted) so insertion order does not
- * affect the output.
- */
-export function fingerprint(value: unknown): string {
-  // stableStringify is imported lazily to avoid a circular dep — fingerprint
-  // is consumed by both providers (which sit above utils/) and the cache
-  // stats store (which sits next to fingerprint). Top-level import works
-  // because utils has no other consumers besides fingerprint, so we just
-  // import statically.
-  return createHash('sha256')
-    .update(stableStringifyLocal(value))
-    .digest('hex')
-    .slice(0, 16);
-}
-
-/**
- * Compute a fingerprint of the registered tool schemas.
- *
- * We deliberately pick only `name`, `description`, and `inputSchema` — the
- * three fields that matter for the upstream prompt cache. Other Tool
- * metadata (version strings, descriptions of internal handlers, etc) is
- * ignored because it never reaches the wire.
- */
-export function fingerprintTools(tools: Tool[]): string {
-  const minimal = tools.map(t => ({
-    name: t.name,
-    description: t.description,
-    inputSchema: t.inputSchema,
-  }));
-  return fingerprint({ tools: minimal });
-}
-
-/**
- * Compute a fingerprint of the system prompt's *immutable* portion.
- *
- * Volatile segments (NWT history, current time) are deliberately excluded
- * because they change between rounds and would defeat the fingerprint's
- * purpose as a "did the cacheable prefix change?" signal.
- */
-export function fingerprintSystemPrefix(segments: SystemSegment[]): string {
-  const immutable = segments.filter(s => !s.volatile);
-  return fingerprint({ system: immutable.map(s => ({ name: s.name, content: s.content })) });
-}
-
-// -- Local copy of stableStringify to avoid a circular dep. This must stay
-//    byte-for-byte identical to src/utils/stableStringify.ts. If you change
-//    one, change both.
-
-function stableStringifyLocal(value: unknown): string {
-  if (value === null) return 'null';
-  if (value === undefined) return 'null';
-  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) => stableStringifyLocal(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;
-      parts.push(JSON.stringify(k) + ':' + stableStringifyLocal(v));
-    }
-    return '{' + parts.join(',') + '}';
-  }
-  return 'null';
-}

package/src/cache/index.ts

@@ -1,21 +0,0 @@
-/**
- * Cache subsystem barrel. Re-exports the public surface used by the TUI,
- * the App singleton, and the LLM service.
- *
- * Modules:
- *   - fingerprint.ts: stable hashes for tools + immutable system prefix
- *   - stats.ts:       CacheStatsStore — per-round hit/miss + cost savings
- *   - volatile.ts:    VolatileScratch — per-round scratch that never reaches the API
- *   - smartModel.ts:  smart-model routing hook (simple → mini, complex → main)
- */
-
-export { fingerprint, fingerprintTools, fingerprintSystemPrefix } from './fingerprint.js';
-export { CacheStatsStore, estimateSavingsCNY, type CacheStats, type CacheSnapshot } from './stats.js';
-export { VolatileScratch } from './volatile.js';
-export {
-  shouldDowngrade,
-  decideTTL,
-  totalConversationChars,
-  type SmartModelDecision,
-  type SmartTTLDecision,
-} from './smartModel.js';

package/src/cache/smartModel.ts

@@ -1,133 +0,0 @@
-/**
- * Smart-model routing + auto TTL selection (P3 of the Reasonix plan,
- * v3.0.3 onwards).
- *
- * Idea: classify the conversation as "short" / "medium" / "long" and
- * route accordingly. Two levers:
- *
- *   1. Model downgrade
- *      Short follow-ups ("yes", "thanks") → mini model
- *      Tool-heavy turns → main model
- *
- *   2. Cache TTL
- *      v3.0.4: default to 1h (long-task TTL). We cannot predict task
- *      length at round 0, so we choose the TTL that cannot expire
- *      mid-task. 5m is opt-in only (user pins it via /ttl 5m or the
- *      init wizard).
- *
- * Why TTL is decided per-ROUND but CHANGES per-CONVERSATION:
- *   The Anthropic cache_control marker is part of the request body.
- *   Changing the TTL between rounds would push the wire bytes to a
- *   different Anthropic cache bucket, blowing the cache on every round
- *   and *costing* more in cache_creation_input_tokens than what we save.
- *
- *   So we compute the TTL once per conversation (lazily, on the first
- *   round) and never change it. Subsequent rounds get the same TTL,
- *   which keeps the cache prefix stable and lets Anthropic match it.
- *
- * Trade-off: 1h write costs 2x input price (vs 1.25x for 5m), but
- * reads are the same 0.1x. A long task hitting cache 2-3 times pays
- * back the extra write cost; a short task pays it once and moves on.
- * That is strictly better than guessing 5m and having the cache expire
- * mid-task.
- */
-
-import type { ChatMessage } from '../types.js';
-
-export interface SmartModelDecision {
-  /** Should we route this turn to a cheaper model? */
-  downgrade: boolean;
-  /** Why we made this call — useful for `/cache` debug output. */
-  reason: string;
-}
-
-export interface SmartTTLDecision {
-  ttl: '5m' | '1h';
-  reason: string;
-  /** Computed per-conversation. Once we pick a TTL, we keep it. */
-  isFirstDecision: boolean;
-}
-
-/**
- * Heuristic: downgrade when
- *   1. The latest user message is short (< 200 chars), AND
- *   2. The last 3 messages contain no assistant tool_calls.
- *
- * This covers greetings, one-line questions, and simple follow-ups
- * ("thanks", "ok", "explain this one line") while routing anything
- * that triggered a tool to the main model.
- */
-export function shouldDowngrade(messages: ChatMessage[], lastUserInput: string): SmartModelDecision {
-  if (lastUserInput.length > 200) {
-    return { downgrade: false, reason: 'prompt-too-long' };
-  }
-  const recent = messages.slice(-3);
-  const hasRecentToolCalls = recent.some(m => m.tool_calls && m.tool_calls.length > 0);
-  if (hasRecentToolCalls) {
-    return { downgrade: false, reason: 'recent-tool-call' };
-  }
-  return { downgrade: true, reason: 'short-no-tools' };
-}
-
-/**
- * Total character count of all message content. Used as a cheap
- * proxy for "is this conversation long enough to justify 1h TTL?"
- * (Anthropic charges cache_creation at 1.25x normal input, so we
- * need to be sure the conversation will hit cache ~10+ times to
- * break even on 1h vs 5m.)
- */
-export function totalConversationChars(messages: ChatMessage[]): number {
-  let total = 0;
-  for (const m of messages) {
-    if (typeof m.content === 'string') {
-      total += m.content.length;
-    } else if (Array.isArray(m.content)) {
-      for (const blk of m.content) {
-        if (blk.type === 'text') total += (blk as any).text.length;
-      }
-    }
-  }
-  return total;
-}
-
-/**
- * Decide the cache TTL for the current round.
- *
- * v3.0.4: The previous implementation tried to *predict* the task length
- * from the conversation so far (short sessions → 5m, long → 1h). That
- * was wrong: at the moment the decision is made (first round), the task
- * hasn't started yet — there is no way to know whether it will be a
- * 30-second question or a 3-hour refactor. Predicting 5m for a task
- * that turns out to be long means the cache expires mid-task (5-minute
- * TTL counts from the last HIT, and agent work often has >5m gaps while
- * tools run / user reads output), so every round after the gap re-writes
- * the whole prefix at full price.
- *
- * Correct rule: DEFAULT TO THE LONG TTL (1h) and don't guess.
- *   - 1h costs 2x input price to WRITE (vs 1.25x for 5m), but reads are
- *     the same 0.1x for both.
- *   - A long task that hits cache even 2-3 times pays back the extra
- *     write cost. A short task only pays the extra write once.
- *   - Users who are SURE the session is short can pin 5m via
- *     /ttl 5m or the init wizard — the default stays 1h.
- *
- * Stability rule (unchanged): once a TTL is chosen, it is reused for
- * every subsequent round in the same session. Changing TTL between
- * rounds would invalidate the Anthropic cache prefix and cost more
- * than it saves.
- *
- * The `isFirstDecision` flag tells the caller whether to apply the
- * decision (first round) or reuse the previous one (later rounds).
- */
-export function decideTTL(
-  messages: ChatMessage[],
-  previousTTL: '5m' | '1h' | null,
-): SmartTTLDecision {
-  if (previousTTL) {
-    return { ttl: previousTTL, reason: 'reused-from-previous-round', isFirstDecision: false };
-  }
-  // Default: long-task TTL. We cannot know the task length upfront, so
-  // we pick the TTL that cannot expire mid-task. 5m is only used when
-  // the user explicitly pins it.
-  return { ttl: '1h', reason: 'default-long-task', isFirstDecision: true };
-}