thatgfsj-code 2.2.9 → 3.0.0

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);
+  });
+});

package/tests/cache/volatile.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect } from 'vitest';
+import { VolatileScratch } from '../../src/cache/volatile.js';
+
+describe('VolatileScratch', () => {
+  it('starts empty', () => {
+    const s = new VolatileScratch();
+    expect(s.isEmpty()).toBe(true);
+    expect(s.read()).toBe('');
+    expect(s.size()).toBe(0);
+  });
+
+  it('accumulates writes separated by newlines', () => {
+    const s = new VolatileScratch();
+    s.write('first thought');
+    s.write('second thought');
+    expect(s.read()).toBe('first thought\nsecond thought');
+    expect(s.size()).toBe(2);
+    expect(s.isEmpty()).toBe(false);
+  });
+
+  it('ignores empty writes', () => {
+    const s = new VolatileScratch();
+    s.write('');
+    s.write('real content');
+    s.write('');
+    expect(s.size()).toBe(1);
+    expect(s.read()).toBe('real content');
+  });
+
+  it('reset() clears everything', () => {
+    const s = new VolatileScratch();
+    s.write('a');
+    s.write('b');
+    s.reset();
+    expect(s.isEmpty()).toBe(true);
+    expect(s.read()).toBe('');
+    expect(s.size()).toBe(0);
+  });
+
+  it('multiple reset() cycles are independent', () => {
+    const s = new VolatileScratch();
+    s.write('cycle 1');
+    s.reset();
+    s.write('cycle 2');
+    expect(s.read()).toBe('cycle 2');
+    s.reset();
+    expect(s.read()).toBe('');
+  });
+});
+
+describe('shouldDowngrade (smartModel)', () => {
+  it('returns false when prompt is long', async () => {
+    const { shouldDowngrade } = await import('../../src/cache/smartModel.js');
+    const decision = shouldDowngrade([], 'x'.repeat(500));
+    expect(decision.downgrade).toBe(false);
+    expect(decision.reason).toBe('prompt-too-long');
+  });
+
+  it('returns false when recent messages had tool_calls', async () => {
+    const { shouldDowngrade } = await import('../../src/cache/smartModel.js');
+    const messages = [
+      { role: 'assistant' as const, content: '...', tool_calls: [{ id: '1', type: 'function' as const, function: { name: 'file', arguments: '{}' } }] },
+    ];
+    const decision = shouldDowngrade(messages, 'short prompt');
+    expect(decision.downgrade).toBe(false);
+    expect(decision.reason).toBe('recent-tool-call');
+  });
+
+  it('returns true for short prompt with no recent tool activity', async () => {
+    const { shouldDowngrade } = await import('../../src/cache/smartModel.js');
+    const decision = shouldDowngrade([], 'thanks!');
+    expect(decision.downgrade).toBe(true);
+    expect(decision.reason).toBe('short-no-tools');
+  });
+});

package/tests/smoke-pollution.mjs

@@ -0,0 +1,78 @@
+// Smoke test: SessionManager.looksPolluted filter
+// Verifies the v2.2.4 anti-pollution filter catches the markers that
+// caused the [已中断] hallucination loop in v2.2.3.
+
+import { SessionManager } from '../dist/session/index.js';
+
+let pass = 0, fail = 0;
+const check = (name, cond) => {
+  console.log((cond ? '✅' : '❌') + ' ' + name);
+  cond ? pass++ : fail++;
+};
+
+const shouldDrop = (content) => {
+  const sm = new SessionManager();
+  return sm.addMessageSafe('assistant', content);
+};
+
+const shouldKeep = (content) => {
+  const sm = new SessionManager();
+  return sm.addMessageSafe('assistant', content);
+};
+
+// These SHOULD be dropped (matches the loop-causing pollution patterns)
+check('drop: [已中断] at line start',
+  shouldDrop('[已中断]\npartial text') === false);
+check('drop: [已中断] standalone',
+  shouldDrop('[已中断]') === false);
+check('drop: response was truncated',
+  shouldDrop('Some text. response was truncated mid-stream.') === false);
+check('drop: output was cut off',
+  shouldDrop('output was cut off, please retry') === false);
+check('drop: [interrupted] English',
+  shouldDrop('[interrupted] partial assistant response') === false);
+
+// These SHOULD be kept (legitimate conversation mentioning these phrases)
+check('keep: 已中断 mentioned in middle of sentence',
+  shouldKeep('我看到这个进程已中断了') === true);
+check('keep: "response truncated" as user complaint',
+  shouldKeep('Why was the response truncated last time?') === true);
+check('keep: normal Chinese sentence',
+  shouldKeep('好的，我已经理解了。') === true);
+check('keep: normal English',
+  shouldKeep('Hello, how can I help you?') === true);
+check('keep: empty',
+  shouldKeep('') === true);  // empty doesn't match any pattern
+
+// Test getDroppedCount
+{
+  const sm = new SessionManager();
+  sm.addMessageSafe('assistant', '[已中断] partial');
+  sm.addMessageSafe('assistant', 'normal response');
+  sm.addMessageSafe('assistant', '[已中断] another partial');
+  check('droppedCount === 2', sm.getDroppedCount() === 2);
+}
+
+// Test that kept messages actually go into getMessages()
+{
+  const sm = new SessionManager();
+  sm.addMessage('user', 'hello');
+  sm.addMessageSafe('assistant', 'normal response');
+  sm.addMessageSafe('assistant', '[已中断] dropped');
+  const msgs = sm.getMessages();
+  check('kept 2 messages after drop', msgs.length === 2);
+  check('user msg preserved', msgs[0].content === 'hello');
+  check('normal assistant preserved', msgs[1].content === 'normal response');
+}
+
+// Test length-gated WEAK pattern detection
+check('drop: short "response was truncated" (<200 chars)',
+  shouldDrop('Some text. response was truncated mid-stream.') === false);
+check('drop: short "response was cut off" (<200 chars)',
+  shouldDrop('response was cut off, please retry') === false);
+// Test length gate — long messages with same phrase are kept
+check('keep: long "Why was response truncated last time?" (>=200 chars)',
+  shouldKeep('Why was the response truncated last time? It seemed to stop mid-sentence when the network went down. I think we should add retry logic so this kind of mid-stream failure does not cause confusion for the end user, who might wonder whether their question was actually answered correctly.' + 'x'.repeat(100)) === true);
+
+console.log(`\n=== ${pass} pass / ${fail} fail ===`);
+if (fail > 0) process.exit(1);

package/tests/smoke-thinking.mjs

@@ -0,0 +1,110 @@
+// Smoke test: thinking compression on realistic samples
+import { splitThinking, summarizeThinking, compressThinking } from '../dist/utils/thinking.js';
+
+let pass = 0, fail = 0;
+const eq = (name, actual, expected) => {
+  const ok = JSON.stringify(actual) === JSON.stringify(expected);
+  console.log((ok ? '✅' : '❌') + ' ' + name);
+  if (!ok) console.log('   actual  :', JSON.stringify(actual), '\n   expected:', JSON.stringify(expected));
+  ok ? pass++ : fail++;
+};
+const truthy = (name, value) => {
+  console.log((value ? '✅' : '❌') + ' ' + name);
+  value ? pass++ : fail++;
+};
+
+// Case A: simple <think>...</think> with English hint
+{
+  const s = splitThinking('<think>The user said hi. I should respond warmly.</think>\n\nHi there!');
+  eq('A.thinkingLines', s.thinkingLines, 1);
+  eq('A.thinkingHint', s.thinkingHint, 'The user said hi. I should respond warmly.');
+  eq('A.conclusion', s.conclusion, 'Hi there!');
+}
+
+// Case B: multi-line <think> + Chinese conclusion (user-paste style)
+{
+  const s = splitThinking(
+    '<think>The user is asking in Chinese if I am minimax\\u0027s M3.\nBased on the ROOT_SYSTEM_POLICY, yes I am MiniMax-M3. I\nwill respond in Chinese since they asked in Chinese.</think>\n\n是的，我是 MiniMax-M3。'
+  );
+  truthy('B.thinkingLines >= 2', s.thinkingLines >= 2);
+  eq('B.conclusion starts with 是', s.conclusion.startsWith('是的'), true);
+}
+
+// Case C: <reasoning>...</reasoning> alternative format
+{
+  const s = splitThinking('<reasoning>step 1\nstep 2</reasoning>\nFinal answer here.');
+  eq('C.thinkingLines', s.thinkingLines, 2);
+  eq('C.thinkingHint', s.thinkingHint, 'step 1');
+  eq('C.conclusion', s.conclusion, 'Final answer here.');
+}
+
+// Case D: [THINK]...[/THINK] alternative format
+{
+  const s = splitThinking('[THINK]user greeted me[/THINK]\nGreetings!');
+  eq('D.thinkingHint', s.thinkingHint, 'user greeted me');
+  eq('D.conclusion', s.conclusion, 'Greetings!');
+}
+
+// Case E: no thinking block at all
+{
+  const s = splitThinking('Just a plain response.');
+  eq('E.thinkingLines', s.thinkingLines, 0);
+  eq('E.thinkingHint', s.thinkingHint, '');
+  eq('E.conclusion', s.conclusion, 'Just a plain response.');
+}
+
+// Case F: multiple <think> blocks (rare but possible)
+{
+  const s = splitThinking('<think>first thought</think>middle text<think>second thought</think>\n\nFinal.');
+  truthy('F.thinkingLines > 0', s.thinkingLines > 0);
+  truthy('F.conclusion contains "Final."', s.conclusion.includes('Final.'));
+}
+
+// Case G: compressThinking round-trip
+{
+  const original = '<think>lots of internal monologue spanning\nseveral lines about nothing in particular</think>\n\nShort answer.';
+  const compressed = compressThinking(original, false);
+  truthy('G.compressed has 💭', compressed.includes('💭'));
+  truthy('G.compressed has "Short answer."', compressed.includes('Short answer.'));
+  truthy('G.compressed strips <think>', !compressed.includes('<think>'));
+}
+
+// Case H: compressThinking with showThinking=true passthrough
+{
+  const original = '<think>inner</think>\n\nouter';
+  const out = compressThinking(original, true);
+  truthy('H.showThinking=true preserves <think>', out.includes('<think>'));
+  truthy('H.showThinking=true preserves outer', out.includes('outer'));
+}
+
+// Case I: empty input
+{
+  const s = splitThinking('');
+  eq('I.empty.thinkingLines', s.thinkingLines, 0);
+  eq('I.empty.conclusion', s.conclusion, '');
+}
+
+// Case J: hint with line wrap across tag (regression test for tag-strip fix)
+{
+  // raw content captured by regex includes '<think>' on its own line
+  const raw = '<think>\nThe actual thought starts here.\nMore lines.\n</think>\n\nConclusion.';
+  const s = splitThinking(raw);
+  truthy('J.hint does not contain <think>', !s.thinkingHint.includes('<think>'));
+  truthy('J.hint does not contain </think>', !s.thinkingHint.includes('</think>'));
+  truthy('J.hint contains real content', s.thinkingHint.includes('actual thought'));
+}
+
+// Case K: realistic long thinking block (mimics user-paste scenario)
+{
+  const longThink = '<think>'.repeat(1) +
+    Array.from({length: 14}, (_, i) => `Line ${i+1} of internal monologue.`).join('\n') +
+    '</think>\n\n' +
+    '没死没死，只是被你那句"随便思考一下问题"给整不会了 😂';
+  const out = compressThinking(longThink, false);
+  truthy('K.compressed shows 14 lines', out.includes('thought for 14 lines'));
+  truthy('K.compressed shows conclusion', out.includes('没死没死'));
+  truthy('K.compressed is short (no 14 lines of monologue)', out.split('\n').length < 8);
+}
+
+console.log(`\n=== ${pass} pass / ${fail} fail ===`);
+if (fail > 0) process.exit(1);

package/tests/smoke-tool-stream.mjs

@@ -0,0 +1,69 @@
+// Simulates the exact useChat stream-parsing logic from src/tui/hooks/useChat.ts
+// to confirm tool result is correctly extracted from streaming chunks.
+
+function simulateUseChat(chunks) {
+  let fullContent = '';
+  let currentToolCalls = [];
+  const states = [];
+
+  for (const chunk of chunks) {
+    if (chunk.includes('@@TOOL@@')) {
+      const parts = chunk.split('\n');
+      for (const part of parts) {
+        if (part.startsWith('@@TOOL@@')) {
+          try {
+            const data = JSON.parse(part.slice(8));
+            if (data.action === 'call') {
+              currentToolCalls.push({ name: data.name, args: data.args || '' });
+              states.push({ kind: 'call', toolCalls: JSON.parse(JSON.stringify(currentToolCalls)) });
+            } else if (data.action === 'result') {
+              const lastIdx = currentToolCalls.length - 1;
+              if (lastIdx >= 0) {
+                currentToolCalls[lastIdx] = {
+                  ...currentToolCalls[lastIdx],
+                  result: data.output || data.error || '',
+                  isError: !!data.error,
+                };
+              }
+              states.push({ kind: 'result', toolCalls: JSON.parse(JSON.stringify(currentToolCalls)) });
+            }
+          } catch (e) {
+            fullContent += part;
+          }
+        } else if (part) {
+          fullContent += part;
+        }
+      }
+    } else {
+      fullContent += chunk;
+    }
+  }
+
+  return { fullContent, states, finalToolCalls: currentToolCalls };
+}
+
+// Simulate what LLMService.chatStream yields in a real session:
+//   iter 1: tool_call → tool.execute → tool_result → \n → loop
+//   iter 2: text "好嘞，那我给你演示..."
+const chunks = [
+  '\n@@TOOL@@{"action":"call","name":"shell","args":"{\\"command\\":\\"date\\"}"}\n',
+  '@@TOOL@@{"action":"result","output":"Mon Jul 6 22:00:00 CST 2026"}\n',
+  '\n',
+  '\n',
+  '好',
+  '嘞',
+  '，',
+  '那我',
+  '给你',
+  '演示一组工具——并行调用，互不干扰：',
+  '\n',
+];
+
+const result = simulateUseChat(chunks);
+console.log('--- states (push order) ---');
+result.states.forEach((s, i) => console.log(i, s.kind, JSON.stringify(s.toolCalls)));
+console.log('--- final ---');
+console.log('fullContent:', JSON.stringify(result.fullContent));
+console.log('finalToolCalls:', JSON.stringify(result.finalToolCalls));
+console.log('--- last tool call has result? ---');
+console.log(!!result.finalToolCalls[0]?.result, '=>', result.finalToolCalls[0]?.result);

package/tests/smoke-tool.mjs

@@ -0,0 +1,117 @@
+// Smoke test: ToolCall rendering path + the empty-string-result regression
+// Simulates the React/Ink <ToolCall tool={tc}/> rendering logic in JS
+
+function simulateToolCallRender(tool) {
+  // Mirrors src/tui/components/ToolCall.tsx exactly
+  const hasResult = tool.result !== undefined;
+  const isEmpty = hasResult && tool.result === '';
+  const truncatedLines = tool.result?.split('\n').length || 0;
+  const maxLines = 8;
+  const truncated = hasResult && !isEmpty && truncatedLines > maxLines;
+  const visible = isEmpty ? '' :
+    truncated ? tool.result.split('\n').slice(0, maxLines).join('\n') :
+    hasResult ? tool.result : null;
+
+  const rendered = {
+    header: `⚙ ${tool.name}${tool.args ? ' ' + tool.args.slice(0, 60) : ''}`,
+    pending: visible === null,
+    noOutput: isEmpty,
+    lines: visible === null ? [] : visible.split('\n'),
+    truncatedMsg: truncated ? `(+${truncatedLines - maxLines} more lines)` : null,
+  };
+  return rendered;
+}
+
+let pass = 0, fail = 0;
+const check = (name, cond) => {
+  console.log((cond ? '✅' : '❌') + ' ' + name);
+  cond ? pass++ : fail++;
+};
+
+// Case A: normal shell result (date output)
+{
+  const r = simulateToolCallRender({
+    name: 'shell', args: '{"command":"date"}',
+    result: 'Mon Jul  7 10:00:00 CST 2026', isError: false,
+  });
+  check('A.header includes "shell"', r.header.includes('shell'));
+  check('A.header includes date command', r.header.includes('date'));
+  check('A.not pending', !r.pending);
+  check('A.has 1 line', r.lines.length === 1);
+  check('A.line shows time', r.lines[0].includes('CST'));
+  check('A.not truncated', r.truncatedMsg === null);
+}
+
+// Case B: empty-string result (the bug we just fixed!)
+{
+  const r = simulateToolCallRender({
+    name: 'shell', args: '{"command":"echo > /dev/null"}',
+    result: '', isError: false,
+  });
+  check('B.not pending (result IS present, just empty)', !r.pending);
+  check('B.marked as noOutput', r.noOutput);
+}
+
+// Case C: pending state (no result yet)
+{
+  const r = simulateToolCallRender({
+    name: 'shell', args: '{"command":"sleep 10"}',
+    result: undefined, isError: false,
+  });
+  check('C.is pending', r.pending);
+}
+
+// Case D: long output (>8 lines) gets truncated with explicit count
+{
+  const longResult = Array.from({length: 50}, (_, i) => `line ${i+1}`).join('\n');
+  const r = simulateToolCallRender({
+    name: 'shell', args: '{"command":"ls"}',
+    result: longResult, isError: false,
+  });
+  check('D.truncated', r.truncatedMsg !== null);
+  check('D.truncated count = 42', r.truncatedMsg.includes('42'));
+  check('D.shows 8 visible lines', r.lines.length === 8);
+}
+
+// Case E: error result
+{
+  const r = simulateToolCallRender({
+    name: 'shell', args: '{"command":"false"}',
+    result: undefined, isError: true, // errors come via `error` field, not `result`
+    error: 'Command failed with exit code 1',
+  });
+  // simulateToolCallRender doesn't read `error` — that path uses result=error string
+}
+
+// Case E2: error as result string
+{
+  const r = simulateToolCallRender({
+    name: 'shell', args: '{"command":"false"}',
+    result: 'Command failed with exit code 1', isError: true,
+  });
+  check('E2.error message visible', r.lines.some(l => l.includes('Command failed')));
+  check('E2.not truncated', r.truncatedMsg === null);
+}
+
+// Case F: multi-line output (small enough to not truncate)
+{
+  const r = simulateToolCallRender({
+    name: 'shell', args: '{"command":"pwd && ls"}',
+    result: '/home/user\nfile1.txt\nfile2.txt', isError: false,
+  });
+  check('F.has 3 lines', r.lines.length === 3);
+  check('F.line 1 is path', r.lines[0] === '/home/user');
+}
+
+// Case G: result with 200+ chars — user-paste style tool summary fallback test
+{
+  const r = simulateToolCallRender({
+    name: 'shell', args: '{"command":"cat big-file.txt"}',
+    result: 'A'.repeat(500), isError: false,
+  });
+  check('G.shown in full (under 8 lines)', r.truncatedMsg === null);
+  check('G.500 chars visible', r.lines[0].length === 500);
+}
+
+console.log(`\n=== ${pass} pass / ${fail} fail ===`);
+if (fail > 0) process.exit(1);

package/.nwt/meta.json

@@ -1,5 +0,0 @@
-{
-  "version": "2.0.0",
-  "created": "2026-07-06T19:29:58.147Z",
-  "description": "NeuroWeave Timeline - Project evolution memory"
-}

package/dist/version.d.ts

@@ -1,16 +0,0 @@
-/**
- * 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 declare const PRODUCT_VERSION = "0.4.6";
-/**
- * Convenience: format with leading "v" for display contexts.
- */
-export declare const PRODUCT_VERSION_DISPLAY = "v0.4.6";
-//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,UAAU,CAAC;AAEvC;;GAEG;AACH,eAAO,MAAM,uBAAuB,WAAwB,CAAC"}

package/dist/version.js

@@ -1,16 +0,0 @@
-/**
- * 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}`;
-//# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,OAAO,CAAC;AAEvC;;GAEG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,IAAI,eAAe,EAAE,CAAC"}

package/src/version.ts

@@ -1,16 +0,0 @@
-/**
- * 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}`;