thatgfsj-code 1.0.2 → 2.2.9

package/src/tools/nwt.ts

@@ -9,7 +9,7 @@
 import type { Tool, ToolResult } from './types.js';
 import {
   readFileSync, writeFileSync, existsSync, mkdirSync,
-  readdirSync, renameSync
+  readdirSync, renameSync, unlinkSync
 } from 'fs';
 import { join } from 'path';
 
@@ -22,6 +22,7 @@ interface TimelineEvent {
   files: string[];
   tags: string[];
   parent?: string;
+  importance: 'low' | 'normal' | 'high' | 'milestone';
 }
 
 const NWT_DIR = '.nwt';
@@ -32,22 +33,41 @@ const ARCHIVE_AFTER_DAYS = 30;
 
 export class NwtTool implements Tool {
   name = 'nwt';
-  description = 'NeuroWeave Timeline - Project evolution memory. Log decisions, track changes, search history. Actions: init, log, history, search, story, explain, archive';
+  description = `NeuroWeave Timeline - Project evolution memory.
+Actions: init, log, history, search, story, explain, archive, diff, compact
+
+AUTO-LOG TRIGGERS (call nwt log silently when):
+- Created, modified, or deleted 2+ files
+- Made an architectural decision (chose a library, pattern, or approach)
+- Fixed a bug
+- Added a new feature or capability
+- Refactored existing code
+- Set up a new project or module
+- Resolved a security issue
+- Completed a multi-step task
+
+DO NOT log:
+- Simple file reads or searches
+- Trivial single-line changes
+- Conversational questions with no code changes`;
 
   inputSchema = {
     type: 'object' as const,
     properties: {
       action: {
         type: 'string',
-        description: 'Action: init, log, history, search, story, explain, archive',
+        description: 'Action: init, log, history, search, story, explain, archive, diff, compact',
       },
       task: { type: 'string', description: 'Short imperative title (for log)' },
       summary: { type: 'string', description: 'What was done (for log)' },
       reason: { type: 'string', description: 'Why it was done (for log)' },
       files: { type: 'string', description: 'Comma-separated file paths (for log)' },
       tags: { type: 'string', description: 'Comma-separated tags (for log)' },
+      importance: { type: 'string', description: 'Importance: low, normal, high, milestone (for log)' },
       query: { type: 'string', description: 'Search query (for search/explain)' },
       limit: { type: 'number', description: 'Max results (for history/search)' },
+      from_id: { type: 'string', description: 'Start event ID (for diff)' },
+      to_id: { type: 'string', description: 'End event ID (for diff)' },
     },
     required: ['action'],
   };
@@ -64,8 +84,11 @@ export class NwtTool implements Tool {
     { name: 'reason', type: 'string', description: 'Why it was done', required: false },
     { name: 'files', type: 'string', description: 'Comma-separated file paths', required: false },
     { name: 'tags', type: 'string', description: 'Comma-separated tags', required: false },
+    { name: 'importance', type: 'string', description: 'low/normal/high/milestone', required: false },
     { name: 'query', type: 'string', description: 'Search query', required: false },
     { name: 'limit', type: 'number', description: 'Max results', required: false },
+    { name: 'from_id', type: 'string', description: 'Start event ID for diff', required: false },
+    { name: 'to_id', type: 'string', description: 'End event ID for diff', required: false },
   ];
 
   async execute(params: Record<string, any>, ctx?: any): Promise<ToolResult> {
@@ -88,6 +111,10 @@ export class NwtTool implements Tool {
           return this.explain(cwd, params.query || '');
         case 'archive':
           return this.archive(cwd);
+        case 'diff':
+          return this.diff(cwd, params.from_id || '', params.to_id || '');
+        case 'compact':
+          return this.compact(cwd);
         default:
           return { success: false, error: `Unknown action: ${action}` };
       }
@@ -112,7 +139,7 @@ export class NwtTool implements Tool {
 
     // Write metadata
     const meta = {
-      version: '1.0.0',
+      version: '2.0.0',
       created: new Date().toISOString(),
       description: 'NeuroWeave Timeline - Project evolution memory',
     };
@@ -129,7 +156,7 @@ export class NwtTool implements Tool {
       this.init(cwd);
     }
 
-    const { task, summary, reason, files, tags } = params;
+    const { task, summary, reason, files, tags, importance } = params;
     if (!task || !summary) {
       return { success: false, error: 'task and summary are required' };
     }
@@ -146,6 +173,10 @@ export class NwtTool implements Tool {
       ? existing.sort().pop()?.replace('.json', '')
       : undefined;
 
+    // Validate importance
+    const validImportance = ['low', 'normal', 'high', 'milestone'];
+    const eventImportance = validImportance.includes(importance) ? importance : 'normal';
+
     const event: TimelineEvent = {
       id: nextId,
       timestamp: new Date().toISOString(),
@@ -155,6 +186,7 @@ export class NwtTool implements Tool {
       files: files ? files.split(',').map((f: string) => f.trim()).filter(Boolean) : [],
       tags: tags ? tags.split(',').map((t: string) => t.trim().toLowerCase()).filter(Boolean) : [],
       parent: parent || undefined,
+      importance: eventImportance as TimelineEvent['importance'],
     };
 
     writeFileSync(
@@ -186,7 +218,8 @@ export class NwtTool implements Tool {
       const time = e.timestamp.split('T')[0];
       const files = e.files.length > 0 ? ` [${e.files.join(', ')}]` : '';
       const tags = e.tags.length > 0 ? ` {${e.tags.join(', ')}}` : '';
-      return `[${e.id}] ${time} ${e.task}${files}${tags}`;
+      const imp = e.importance && e.importance !== 'normal' ? ` (${e.importance})` : '';
+      return `[${e.id}] ${time} ${e.task}${imp}${files}${tags}`;
     });
 
     return { success: true, output: lines.join('\n') };
@@ -227,8 +260,9 @@ export class NwtTool implements Tool {
       return { success: true, output: 'No events yet.' };
     }
 
-    // Group by tags and find milestones
-    const milestones = events.filter(e => e.tags.includes('milestone'));
+    // Group by importance
+    const milestones = events.filter(e => e.importance === 'milestone' || e.tags.includes('milestone'));
+    const highImportance = events.filter(e => e.importance === 'high');
     const decisions = events.filter(e => e.tags.includes('decision'));
     const totalFiles = new Set(events.flatMap(e => e.files)).size;
 
@@ -245,6 +279,14 @@ export class NwtTool implements Tool {
       lines.push('');
     }
 
+    if (highImportance.length > 0) {
+      lines.push('High Importance:');
+      for (const h of highImportance.slice(-5)) {
+        lines.push(`  [${h.id}] ${h.task} - ${h.summary}`);
+      }
+      lines.push('');
+    }
+
     if (decisions.length > 0) {
       lines.push('Key Decisions:');
       for (const d of decisions.slice(-5)) {
@@ -256,7 +298,8 @@ export class NwtTool implements Tool {
     lines.push('Recent Activity:');
     for (const e of events.slice(-5)) {
       const time = e.timestamp.split('T')[0];
-      lines.push(`  ${time} ${e.task}`);
+      const imp = e.importance && e.importance !== 'normal' ? ` (${e.importance})` : '';
+      lines.push(`  ${time} ${e.task}${imp}`);
     }
 
     return { success: true, output: lines.join('\n') };
@@ -284,6 +327,135 @@ export class NwtTool implements Tool {
     return { success: true, output: `History of ${filePath}:\n\n${lines.join('\n\n')}` };
   }
 
+  // ── Diff ──────────────────────────────────────────────
+
+  private diff(cwd: string, fromId: string, toId: string): ToolResult {
+    if (!fromId || !toId) {
+      return { success: false, error: 'from_id and to_id are required' };
+    }
+
+    const events = this.loadEvents(cwd);
+    const fromEvent = events.find(e => e.id === fromId.padStart(6, '0'));
+    const toEvent = events.find(e => e.id === toId.padStart(6, '0'));
+
+    if (!fromEvent) return { success: false, error: `Event ${fromId} not found` };
+    if (!toEvent) return { success: false, error: `Event ${toId} not found` };
+
+    // Get events between from and to
+    const fromIdx = events.indexOf(fromEvent);
+    const toIdx = events.indexOf(toEvent);
+    const between = events.slice(fromIdx, toIdx + 1);
+
+    // Collect all files touched
+    const allFiles = new Set(between.flatMap(e => e.files));
+    const fromFiles = new Set(fromEvent.files);
+    const toFiles = new Set(toEvent.files);
+
+    // Files added/removed/modified
+    const added = [...toFiles].filter(f => !fromFiles.has(f));
+    const removed = [...fromFiles].filter(f => !toFiles.has(f));
+    const modified = [...allFiles].filter(f => fromFiles.has(f) && toFiles.has(f));
+
+    const lines = [
+      `Diff: [${fromEvent.id}] → [${toEvent.id}]`,
+      `Events: ${between.length} between these points`,
+      '',
+    ];
+
+    if (added.length > 0) lines.push(`Added: ${added.join(', ')}`);
+    if (removed.length > 0) lines.push(`Removed: ${removed.join(', ')}`);
+    if (modified.length > 0) lines.push(`Modified: ${modified.join(', ')}`);
+
+    lines.push('', 'Events in range:');
+    for (const e of between) {
+      const time = e.timestamp.split('T')[0];
+      lines.push(`  [${e.id}] ${time} ${e.task}`);
+    }
+
+    return { success: true, output: lines.join('\n') };
+  }
+
+  // ── Compact ───────────────────────────────────────────
+
+  private compact(cwd: string): ToolResult {
+    const events = this.loadEvents(cwd);
+    if (events.length < 10) {
+      return { success: true, output: 'Not enough events to compact (need 10+).' };
+    }
+
+    const nwtDir = join(cwd, NWT_DIR);
+    const eventsDir = join(nwtDir, EVENTS_DIR);
+
+    // Group consecutive events with same tags
+    const groups: TimelineEvent[][] = [];
+    let currentGroup: TimelineEvent[] = [events[0]];
+
+    for (let i = 1; i < events.length; i++) {
+      const prev = events[i - 1];
+      const curr = events[i];
+
+      // Same tags and close in time (within 1 hour)
+      const sameTags = curr.tags.join(',') === prev.tags.join(',');
+      const timeDiff = new Date(curr.timestamp).getTime() - new Date(prev.timestamp).getTime();
+      const closeInTime = timeDiff < 3600000; // 1 hour
+
+      if (sameTags && closeInTime) {
+        currentGroup.push(curr);
+      } else {
+        groups.push(currentGroup);
+        currentGroup = [curr];
+      }
+    }
+    groups.push(currentGroup);
+
+    // Merge groups with 3+ events
+    let merged = 0;
+    const newEvents: TimelineEvent[] = [];
+
+    for (const group of groups) {
+      if (group.length >= 3) {
+        // Merge into one summary event
+        const first = group[0];
+        const last = group[group.length - 1];
+        const allFiles = [...new Set(group.flatMap(e => e.files))];
+        const allTags = [...new Set(group.flatMap(e => e.tags))];
+
+        newEvents.push({
+          id: first.id,
+          timestamp: first.timestamp,
+          task: `${first.task} ... ${last.task}`,
+          summary: `Compacted ${group.length} events: ${group.map(e => e.task).join(', ')}`,
+          files: allFiles,
+          tags: allTags,
+          importance: first.importance,
+        });
+        merged += group.length - 1;
+      } else {
+        newEvents.push(...group);
+      }
+    }
+
+    if (merged === 0) {
+      return { success: true, output: 'No events to compact.' };
+    }
+
+    // Re-write events
+    for (const file of readdirSync(eventsDir).filter(f => f.endsWith('.json'))) {
+      unlinkSync(join(eventsDir, file));
+    }
+
+    for (let i = 0; i < newEvents.length; i++) {
+      const event = newEvents[i];
+      event.id = (i + 1).toString().padStart(6, '0');
+      writeFileSync(join(eventsDir, `${event.id}.json`), JSON.stringify(event, null, 2));
+    }
+
+    return {
+      success: true,
+      output: `Compacted: ${events.length} → ${newEvents.length} events (merged ${merged})`,
+    };
+  }
+
   // ── Archive ───────────────────────────────────────────
 
   private archive(cwd: string): ToolResult {
@@ -345,10 +517,6 @@ export class NwtTool implements Tool {
 
   // ── Auto Archive ──────────────────────────────────────
 
-  /**
-   * Auto-archive events older than 30 days.
-   * Runs silently on init - no output unless something was archived.
-   */
   private autoArchiveIfNeeded(cwd: string): void {
     try {
       const nwtDir = join(cwd, NWT_DIR);

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.2</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();