thatgfsj-code 1.0.3 → 2.2.9

package/src/session/index.ts

@@ -5,12 +5,65 @@
 import type { ChatMessage } from '../types.js';
 import { ContextCompactor } from './compactor.js';
 
+/**
+ * v2.2.4 (port from v2.1.0): patterns that, if found in an assistant
+ * message, indicate the message is a truncated/aborted response that
+ * should NOT be persisted into history. Without this filter, the next
+ * turn's LLM sees the marker and starts echoing it back, creating a
+ * self-reinforcing "[已中断]" hallucination loop.
+ *
+ * v2.2.6.1 tightening (smoke-test driven): the design here is a
+ * two-tier check:
+ *   1. STRONG markers — unambiguous pollution, always drop:
+ *      - `[已中断]` bracketed (the model emits this exact form)
+ *      - `[interrupted]` bracketed English equivalent
+ *   2. WEAK markers — only drop if the message is also short (<200
+ *      chars). Long messages mentioning "response truncated" are
+ *      legitimate conversation (e.g. user complaints about past
+ *      behavior), not pollution.
+ *
+ * Earlier drafts matched bare `已中断` substrings and "response
+ * truncated" anywhere in the message — both were too greedy and
+ * dropped legitimate Chinese/English conversation.
+ */
+const POLLUTION_STRONG: RegExp[] = [
+  /\[已中断\]/,
+  /\[interrupted\]/i,
+];
+
+const POLLUTION_WEAK: RegExp[] = [
+  /^\s*[\*#>\-`]*\s*\[已中断\]/m,
+  /^\s*[\*#>\-`]*\s*\[interrupted\]/im,
+  /\bresponse (was )?(truncated|cut off|interrupted)\b/i,
+  /\boutput (was )?(truncated|cut off|interrupted)\b/i,
+];
+
+function looksPolluted(content: string): boolean {
+  if (!content) return false;
+  // Common gates (apply to both tiers):
+  //   - Length: model got cut off mid-stream → pollution is short.
+  //     A long message with [已中断] in the middle is the model
+  //     legitimately referencing the marker, not pollution.
+  //   - Question: ends with '?' → user complaining about past behavior.
+  //   - Temporal: contains "last time" / "earlier" / etc. → past tense.
+  if (content.length >= 200) return false;
+  if (/\?\s*$/.test(content.trim())) return false;
+  if (/\b(last time|earlier|before|previously|yesterday)\b/i.test(content)) return false;
+  // STRONG markers — bracketed truncation markers, unambiguous.
+  if (POLLUTION_STRONG.some(p => p.test(content))) return true;
+  // WEAK markers — bare "response truncated" phrases.
+  if (POLLUTION_WEAK.some(p => p.test(content))) return true;
+  return false;
+}
+
 export class SessionManager {
   private messages: ChatMessage[] = [];
   private sessionId: string;
   private createdAt: Date;
   private compactor: ContextCompactor;
   private maxMessages: number;
+  /** v2.2.4: counter for messages dropped by the pollution filter. */
+  private droppedCount: number = 0;
 
   constructor(maxMessages = 50) {
     this.maxMessages = maxMessages;
@@ -24,6 +77,26 @@ export class SessionManager {
     this.autoCompact();
   }
 
+  /**
+   * v2.2.4 (port from v2.1.0): same as addMessage but returns false
+   * (and skips the push) if the message content matches a known
+   * truncation/abort pollution pattern. Use this for assistant
+   * messages whose stream might have been aborted.
+   */
+  addMessageSafe(role: ChatMessage['role'], content: string, extras?: Partial<ChatMessage>): boolean {
+    if (role === 'assistant' && looksPolluted(content)) {
+      this.droppedCount++;
+      return false;
+    }
+    this.addMessage(role, content, extras);
+    return true;
+  }
+
+  /** v2.2.4: total messages dropped by addMessageSafe since session start. */
+  getDroppedCount(): number {
+    return this.droppedCount;
+  }
+
   getMessages(): ChatMessage[] {
     return [...this.messages];
   }
@@ -62,8 +135,16 @@ export class SessionManager {
 
   truncate(maxMessages?: number): void {
     if (maxMessages) {
+      // v2.2.7 edge fix: preserveRecent must be <= maxMessages - 1,
+      // otherwise the compactor's "always keep recent N" branch
+      // overrides the trim and no messages actually get dropped.
+      // Set preserveRecent to maxMessages-1 so anything beyond the
+      // last maxMessages-1 user/assistant msgs gets summarized.
       this.maxMessages = maxMessages;
-      this.compactor = new ContextCompactor({ maxMessages });
+      this.compactor = new ContextCompactor({
+        maxMessages,
+        preserveRecent: Math.max(1, maxMessages - 1),
+      });
     }
     const { compacted } = this.compactor.compact(this.messages);
     this.messages = compacted;

package/src/tui/components/ChatList.tsx

@@ -1,6 +1,6 @@
 /** @jsxImportSource react */
 import React, { memo } from 'react';
-import { Box } from 'ink';
+import { Box, Static } from 'ink';
 import { ChatMessage, type MessageData } from './ChatMessage.js';
 import type { ToolCallData } from './ToolCall.js';
 
@@ -12,17 +12,26 @@ interface Props {
 }
 
 export const ChatList = memo(function ChatList({ messages, streaming, streamingToolCalls, width }: Props) {
+  const hasStreaming = !!(streaming || (streamingToolCalls && streamingToolCalls.length > 0));
+
   return (
     <Box flexDirection="column">
-      {messages.map((msg, i) => (
-        <ChatMessage key={i} message={msg} width={width} />
-      ))}
-      {(streaming || streamingToolCalls) && (
+      {/* Completed messages - Static prevents re-rendering */}
+      {messages.length > 0 && (
+        <Static items={messages}>
+          {(msg: MessageData, index: number) => (
+            <ChatMessage key={`msg-${index}`} message={msg} width={width} />
+          )}
+        </Static>
+      )}
+
+      {/* Streaming content - only this part re-renders */}
+      {hasStreaming && (
         <ChatMessage
           message={{
             role: 'assistant',
             content: streaming || '',
-            toolCalls: streamingToolCalls,
+            toolCalls: streamingToolCalls && streamingToolCalls.length > 0 ? streamingToolCalls : undefined,
           }}
           width={width}
         />

package/src/tui/components/Header.tsx

@@ -1,6 +1,7 @@
 /** @jsxImportSource react */
 import React from 'react';
 import { Box, Text } from 'ink';
+import { PRODUCT_VERSION_DISPLAY } from '../../version.js';
 
 interface Props {
   provider: string;
@@ -14,7 +15,7 @@ export const Header = React.memo(function Header({ provider, model }: Props) {
         <Box>
           <Text color="#06B6D4" bold> ⚡ </Text>
           <Text color="#22D3EE" bold>THATGFSJ CODE</Text>
-          <Text dimColor> v1.0.3</Text>
+          <Text dimColor> {PRODUCT_VERSION_DISPLAY}</Text>
         </Box>
         <Box>
           <Text color="#06B6D4" bold> {provider} </Text>

package/src/tui/components/ToolCall.tsx

@@ -40,9 +40,14 @@ function truncateOutput(output: string, maxLines = 8): { text: string; truncated
   return { text: lines.slice(0, maxLines).join('\n'), truncated: true };
 }
 
-export function ToolCall({ tool }: Props) {
+export function ToolCall({ tool, width }: Props) {
   const label = formatToolName(tool.name, tool.args);
-  const result = tool.result ? truncateOutput(tool.result) : null;
+  // v2.2.7 edge: treat null same as undefined (both mean "still
+  // running"). Previous check `result !== undefined` would render
+  // null as an empty string output, causing confusion.
+  const result = (tool.result !== undefined && tool.result !== null)
+    ? truncateOutput(tool.result)
+    : null;
 
   return (
     <Box flexDirection="column" marginBottom={0} paddingLeft={1}>
@@ -53,15 +58,46 @@ export function ToolCall({ tool }: Props) {
         {label && <Text color="#64748B"> {label}</Text>}
       </Box>
 
-      {/* Result */}
-      {result && (
+      {/* Result — v2.2.6 fix:
+          - Use `!== undefined` (not truthy) so empty string results
+            still render (truthy check dropped them, making it look
+            like the tool result was missing).
+          - Switch wrap from "truncate" to "wrap" so long lines don't
+            silently disappear off-screen.
+          - Always render the Box even when result is empty (just
+            with a "(no output)" marker), so the visual frame stays
+            consistent.
+          - If truncated, show explicit "(+N more lines)" indicator
+            so users know the result was clipped. */}
+      {result !== null && (
         <Box paddingLeft={2} flexDirection="column">
-          {result.text.split('\n').map((line, i) => (
-            <Text key={i} color={tool.isError ? '#EF4444' : '#64748B'} wrap="truncate">
-              {line}
-            </Text>
-          ))}
-          {result.truncated && <Text dimColor>  ...</Text>}
+          {result.text.length === 0 ? (
+            <Text color="#94A3B8" dimColor>(no output)</Text>
+          ) : (
+            <>
+              {result.text.split('\n').map((line, i) => (
+                <Text
+                  key={i}
+                  color={tool.isError ? '#EF4444' : '#64748B'}
+                  wrap="wrap"
+                >
+                  {line || ' '}
+                </Text>
+              ))}
+              {result.truncated && (
+                <Text color="#94A3B8" dimColor>
+                  {'  '}(+{tool.result!.split('\n').length - 8} more lines)
+                </Text>
+              )}
+            </>
+          )}
+        </Box>
+      )}
+      {/* v2.2.6: if result is undefined (still running), show a
+          pending indicator so the user knows the tool is in flight. */}
+      {result === null && tool.result === undefined && (
+        <Box paddingLeft={2}>
+          <Text color="#94A3B8" dimColor>  ⏳ running...</Text>
         </Box>
       )}
     </Box>

package/src/tui/hooks/useChat.ts

@@ -2,6 +2,7 @@ import { useState, useCallback, useRef } from 'react';
 import type { MessageData } from '../components/ChatMessage.js';
 import type { ToolCallData } from '../components/ToolCall.js';
 import type { App } from '../../app/index.js';
+import { compressThinking, splitThinking, summarizeThinking } from '../../utils/thinking.js';
 
 interface ChatState {
   messages: MessageData[];
@@ -95,20 +96,63 @@ export function useChat(app: App) {
         }
       }
 
-      // Save response (even if aborted, save what we have)
-      if (fullContent.trim() || currentToolCalls.length > 0) {
-        const suffix = abortRef.current ? '\n\n[已中断]' : '';
-        app.session.addMessage('assistant', fullContent + suffix);
+      // v2.2.4 (port from v2.1.0): DO NOT persist truncated assistant
+      // messages. The previous code literally wrote `'\n\n[已中断]'`
+      // as a suffix and persisted it — which is what created the
+      // hallucination loop where the next turn's LLM echoed the
+      // marker back. The fix is two-pronged:
+      //   1. Never persist when the stream was aborted (here).
+      //   2. SessionManager.addMessageSafe drops messages that match
+      //      the pollution filter as a belt-and-suspenders check
+      //      for cases where we somehow persist a polluted message.
+      const wasAborted = abortRef.current;
+      const shouldPersist = !wasAborted &&
+        (fullContent.trim() || currentToolCalls.length > 0);
+
+      if (shouldPersist) {
+        // v2.2.5: strip <think> blocks from the persisted message
+        // when compression is enabled. Same rationale as in
+        // cmd/index.tsx — keeps history compact, avoids re-feeding
+        // reasoning into the next turn's context window.
+        const toPersist = compressThinking(fullContent, app.showThinking);
+        app.session.addMessageSafe('assistant', toPersist);
       }
 
+      // v2.2.5: build a displayable version. When thinking is hidden
+      // we still want the user to see a one-line indicator of how
+      // much reasoning the model did, plus the conclusion.
+      const split = splitThinking(fullContent);
+      const displayContent = app.showThinking
+        ? fullContent
+        : (split.thinking
+            ? `${summarizeThinking(split)}\n${split.conclusion}`
+            : fullContent);
+
+      // v2.2.6 (tool-result belt-and-suspenders): if any tool call
+      // returned text, also append a compact "[tool: name → result]"
+      // summary to the persisted/displayed content. This guarantees
+      // the user sees the tool output regardless of whether the Ink
+      // <ToolCall/> component renders it correctly. Past sessions
+      // have had cases where the streaming ToolCall rendering failed
+      // silently (e.g. result was empty string, wrap=truncate cut
+      // long output off-screen) and the user had no idea what the
+      // tool actually returned.
+      const toolSummary = currentToolCalls.length > 0
+        ? '\n\n' + currentToolCalls.map((tc) => {
+            const r = tc.result !== undefined ? tc.result : '(no result)';
+            const short = r.length > 200 ? r.slice(0, 197) + '...' : r;
+            return `[tool: ${tc.name} → ${short}]`;
+          }).join('\n')
+        : '';
+
       setState(prev => ({
         ...prev,
         messages: [
           ...prev.messages,
-          ...(fullContent.trim() || currentToolCalls.length > 0
+          ...(shouldPersist
             ? [{
                 role: 'assistant' as const,
-                content: fullContent + (abortRef.current ? '\n\n[已中断]' : ''),
+                content: displayContent + toolSummary,
                 toolCalls: currentToolCalls.length > 0 ? currentToolCalls : undefined,
               }]
             : []),

package/src/tui/hooks/useCommands.ts

@@ -18,6 +18,7 @@ const CMD_ALIASES: Record<string, string> = {
   '/mcp': '/mcp',
   '/帮助': '/help',
   '/服务商': '/provider',
+  '/思考': '/thinking',
 };
 
 export const COMMAND_LIST = [
@@ -125,6 +126,26 @@ export function useCommands(app: App) {
       };
     }
 
+    // ── /thinking on|off ─────────────────────────────────
+    if (name === '/thinking' || name === '/思考') {
+      if (!arg) {
+        return {
+          handled: true,
+          output: `思考块显示: ${app.showThinking ? '开启 (显示完整 <think>...</think>)' : '关闭 (压缩为单行提示)'}`,
+        };
+      }
+      const want = arg.toLowerCase();
+      if (want === 'on' || want === '开启' || want === 'true' || want === '1') {
+        app.showThinking = true;
+        return { handled: true, output: '✓ 已开启完整思考块显示' };
+      }
+      if (want === 'off' || want === '关闭' || want === 'false' || want === '0') {
+        app.showThinking = false;
+        return { handled: true, output: '✓ 已关闭思考块显示 (压缩为单行提示)' };
+      }
+      return { handled: true, output: `用法: /thinking on|off (当前: ${app.showThinking ? 'on' : 'off'})` };
+    }
+
     // ── /help ───────────────────────────────────────────
     if (name === '/help') {
       return {
@@ -135,6 +156,7 @@ export function useCommands(app: App) {
           '  /服务商          更换服务商',
           '  /新建            新建会话',
           '  /压缩            压缩上下文',
+          '  /思考 [on|off]   切换思考块显示',
           '  /技能 [id]       管理技能',
           '  /mcp             MCP 设置',
           '  /帮助            查看帮助',

package/src/tui/welcome.ts

@@ -8,6 +8,7 @@ import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { PROVIDERS, getModelsForProvider, listProviders, isCustomProvider } from '../config/providers.js';
+import { PRODUCT_VERSION_DISPLAY } from '../version.js';
 import type { ProviderName } from '../config/types.js';
 
 const line = chalk.gray('─'.repeat(52));
@@ -18,7 +19,7 @@ export class WelcomeScreen {
     if (hasApiKey) return;
 
     console.log();
-    console.log(chalk.cyan.bold('  ⚡ Thatgfsj Code') + chalk.gray(' v0.5.0'));
+    console.log(chalk.cyan.bold('  ⚡ Thatgfsj Code') + chalk.gray(' ' + PRODUCT_VERSION_DISPLAY));
     console.log(chalk.gray('  AI Coding Assistant'));
     console.log(line);
     console.log();
@@ -35,7 +36,7 @@ export class WelcomeScreen {
   static async interactiveSetup(): Promise<void> {
     console.clear();
     console.log();
-    console.log(chalk.cyan.bold('  ⚡ Thatgfsj Code') + chalk.gray(' - Setup'));
+    console.log(chalk.cyan.bold('  ⚡ Thatgfsj Code') + chalk.gray(' ' + PRODUCT_VERSION_DISPLAY + ' - Setup'));
     console.log(line);
     console.log();
 

package/src/utils/thinking.ts

@@ -0,0 +1,122 @@
+/**
+ * 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 '';
+}
+
+export { THINKING_PATTERNS };

package/src/version.ts

@@ -0,0 +1,16 @@
+/**
+ * Product version (what users see in --version, the TUI header, and
+ * the welcome screen). This is SEPARATE from the npm package version
+ * (`package.json` `version` field) — see the dual-version scheme docs
+ * in CHANGELOG.md (v2.2.2 entry).
+ *
+ * Bump this when shipping a user-visible change. Bump package.json
+ * version (npm version) at the same time. They are both +0.0.1 per
+ * release.
+ */
+export const PRODUCT_VERSION = '0.4.6';
+
+/**
+ * Convenience: format with leading "v" for display contexts.
+ */
+export const PRODUCT_VERSION_DISPLAY = `v${PRODUCT_VERSION}`;