rafcode 2.2.0 → 2.3.0

package/tests/unit/config.test.ts

@@ -16,6 +16,7 @@ import {
   getAutoCommit,
   getWorktreeDefault,
   getClaudeCommand,
+  getModelShortName,
   resetConfigCache,
   saveConfig,
   renderCommitMessage,
@@ -616,6 +617,29 @@ describe('Config', () => {
     });
   });
 
+  describe('getModelShortName', () => {
+    it('should return short aliases as-is', () => {
+      expect(getModelShortName('opus')).toBe('opus');
+      expect(getModelShortName('sonnet')).toBe('sonnet');
+      expect(getModelShortName('haiku')).toBe('haiku');
+    });
+
+    it('should extract family from full model IDs', () => {
+      expect(getModelShortName('claude-opus-4-6')).toBe('opus');
+      expect(getModelShortName('claude-opus-4-5-20251101')).toBe('opus');
+      expect(getModelShortName('claude-sonnet-4-5-20250929')).toBe('sonnet');
+      expect(getModelShortName('claude-sonnet-4-5')).toBe('sonnet');
+      expect(getModelShortName('claude-haiku-4-5-20251001')).toBe('haiku');
+    });
+
+    it('should return unknown model IDs as-is', () => {
+      expect(getModelShortName('gpt-4')).toBe('gpt-4');
+      expect(getModelShortName('claude-unknown-3-0')).toBe('claude-unknown-3-0');
+      expect(getModelShortName('')).toBe('');
+      expect(getModelShortName('some-random-model')).toBe('some-random-model');
+    });
+  });
+
   describe('config integration - overrides work', () => {
     it('should use custom model when configured', () => {
       const configPath = path.join(tempDir, 'custom-models.json');

package/tests/unit/terminal-symbols.test.ts

@@ -11,7 +11,7 @@ import {
   TaskStatus,
 } from '../../src/utils/terminal-symbols.js';
 import type { UsageData } from '../../src/types/config.js';
-import type { CostBreakdown } from '../../src/utils/token-tracker.js';
+import type { CostBreakdown, TaskUsageEntry } from '../../src/utils/token-tracker.js';
 
 describe('Terminal Symbols', () => {
   describe('SYMBOLS', () => {
@@ -296,38 +296,126 @@ describe('Terminal Symbols', () => {
       totalCost: total,
     });
 
-    it('should format basic token summary without cache', () => {
-      const result = formatTaskTokenSummary(makeUsage(), makeCost(0.42));
-      expect(result).toBe('  Tokens: 5,234 in / 1,023 out | Est. cost: $0.42');
-    });
-
-    it('should include cache read tokens', () => {
-      const result = formatTaskTokenSummary(
-        makeUsage({ cacheReadInputTokens: 18500 }),
-        makeCost(0.42)
-      );
-      expect(result).toBe('  Tokens: 5,234 in / 1,023 out | Cache: 18,500 read | Est. cost: $0.42');
-    });
-
-    it('should include cache creation tokens', () => {
-      const result = formatTaskTokenSummary(
-        makeUsage({ cacheCreationInputTokens: 5000 }),
-        makeCost(0.55)
-      );
-      expect(result).toBe('  Tokens: 5,234 in / 1,023 out | Cache: 5,000 created | Est. cost: $0.55');
-    });
-
-    it('should include both cache read and creation tokens', () => {
-      const result = formatTaskTokenSummary(
-        makeUsage({ cacheReadInputTokens: 18500, cacheCreationInputTokens: 5000 }),
-        makeCost(0.75)
-      );
-      expect(result).toBe('  Tokens: 5,234 in / 1,023 out | Cache: 18,500 read / 5,000 created | Est. cost: $0.75');
-    });
-
-    it('should format small costs with 4 decimal places', () => {
-      const result = formatTaskTokenSummary(makeUsage(), makeCost(0.0042));
-      expect(result).toBe('  Tokens: 5,234 in / 1,023 out | Est. cost: $0.0042');
+    const makeEntry = (usage: UsageData, cost: CostBreakdown, attempts?: UsageData[]): TaskUsageEntry => ({
+      taskId: '01',
+      usage,
+      cost,
+      attempts: attempts ?? [usage],
+    });
+
+    describe('single-attempt tasks', () => {
+      it('should format basic token summary without cache', () => {
+        const usage = makeUsage();
+        const result = formatTaskTokenSummary(makeEntry(usage, makeCost(0.42)));
+        expect(result).toBe('  Tokens: 5,234 in / 1,023 out | Est. cost: $0.42');
+      });
+
+      it('should include cache read tokens', () => {
+        const usage = makeUsage({ cacheReadInputTokens: 18500 });
+        const result = formatTaskTokenSummary(makeEntry(usage, makeCost(0.42)));
+        expect(result).toBe('  Tokens: 5,234 in / 1,023 out | Cache: 18,500 read | Est. cost: $0.42');
+      });
+
+      it('should include cache creation tokens', () => {
+        const usage = makeUsage({ cacheCreationInputTokens: 5000 });
+        const result = formatTaskTokenSummary(makeEntry(usage, makeCost(0.55)));
+        expect(result).toBe('  Tokens: 5,234 in / 1,023 out | Cache: 5,000 created | Est. cost: $0.55');
+      });
+
+      it('should include both cache read and creation tokens', () => {
+        const usage = makeUsage({ cacheReadInputTokens: 18500, cacheCreationInputTokens: 5000 });
+        const result = formatTaskTokenSummary(makeEntry(usage, makeCost(0.75)));
+        expect(result).toBe('  Tokens: 5,234 in / 1,023 out | Cache: 18,500 read / 5,000 created | Est. cost: $0.75');
+      });
+
+      it('should format small costs with 4 decimal places', () => {
+        const usage = makeUsage();
+        const result = formatTaskTokenSummary(makeEntry(usage, makeCost(0.0042)));
+        expect(result).toBe('  Tokens: 5,234 in / 1,023 out | Est. cost: $0.0042');
+      });
+
+      it('should format single-attempt task with empty attempts array as single-line', () => {
+        const usage = makeUsage();
+        const result = formatTaskTokenSummary(makeEntry(usage, makeCost(0.42), []));
+        expect(result).toBe('  Tokens: 5,234 in / 1,023 out | Est. cost: $0.42');
+      });
+    });
+
+    describe('multi-attempt tasks', () => {
+      it('should show per-attempt breakdown with costs when calculateAttemptCost provided', () => {
+        const attempt1 = makeUsage({ inputTokens: 1234, outputTokens: 567 });
+        const attempt2 = makeUsage({ inputTokens: 2345, outputTokens: 890 });
+        const totalUsage = makeUsage({ inputTokens: 3579, outputTokens: 1457 });
+        const entry = makeEntry(totalUsage, makeCost(0.06), [attempt1, attempt2]);
+
+        const calculateCost = (usage: UsageData): CostBreakdown => ({
+          inputCost: 0,
+          outputCost: 0,
+          cacheReadCost: 0,
+          cacheCreateCost: 0,
+          totalCost: usage.inputTokens === 1234 ? 0.02 : 0.04,
+        });
+
+        const result = formatTaskTokenSummary(entry, calculateCost);
+        const lines = result.split('\n');
+
+        expect(lines).toHaveLength(3);
+        expect(lines[0]).toBe('    Attempt 1: 1,234 in / 567 out | Est. cost: $0.02');
+        expect(lines[1]).toBe('    Attempt 2: 2,345 in / 890 out | Est. cost: $0.04');
+        expect(lines[2]).toBe('    Total: 3,579 in / 1,457 out | Est. cost: $0.06');
+      });
+
+      it('should show per-attempt breakdown without costs when no calculateAttemptCost', () => {
+        const attempt1 = makeUsage({ inputTokens: 1000, outputTokens: 200 });
+        const attempt2 = makeUsage({ inputTokens: 2000, outputTokens: 400 });
+        const totalUsage = makeUsage({ inputTokens: 3000, outputTokens: 600 });
+        const entry = makeEntry(totalUsage, makeCost(0.05), [attempt1, attempt2]);
+
+        const result = formatTaskTokenSummary(entry);
+        const lines = result.split('\n');
+
+        expect(lines).toHaveLength(3);
+        expect(lines[0]).toBe('    Attempt 1: 1,000 in / 200 out | Est. cost: $0.00');
+        expect(lines[1]).toBe('    Attempt 2: 2,000 in / 400 out | Est. cost: $0.00');
+        expect(lines[2]).toBe('    Total: 3,000 in / 600 out | Est. cost: $0.05');
+      });
+
+      it('should include cache tokens in per-attempt breakdown', () => {
+        const attempt1 = makeUsage({ inputTokens: 1000, outputTokens: 200, cacheReadInputTokens: 5000 });
+        const attempt2 = makeUsage({ inputTokens: 1500, outputTokens: 300, cacheCreationInputTokens: 2000 });
+        const totalUsage = makeUsage({
+          inputTokens: 2500,
+          outputTokens: 500,
+          cacheReadInputTokens: 5000,
+          cacheCreationInputTokens: 2000,
+        });
+        const entry = makeEntry(totalUsage, makeCost(0.08), [attempt1, attempt2]);
+
+        const result = formatTaskTokenSummary(entry);
+        const lines = result.split('\n');
+
+        expect(lines).toHaveLength(3);
+        expect(lines[0]).toContain('Cache: 5,000 read');
+        expect(lines[1]).toContain('Cache: 2,000 created');
+        expect(lines[2]).toContain('Cache: 5,000 read / 2,000 created');
+      });
+
+      it('should handle three or more attempts', () => {
+        const attempt1 = makeUsage({ inputTokens: 500, outputTokens: 100 });
+        const attempt2 = makeUsage({ inputTokens: 600, outputTokens: 120 });
+        const attempt3 = makeUsage({ inputTokens: 700, outputTokens: 140 });
+        const totalUsage = makeUsage({ inputTokens: 1800, outputTokens: 360 });
+        const entry = makeEntry(totalUsage, makeCost(0.10), [attempt1, attempt2, attempt3]);
+
+        const result = formatTaskTokenSummary(entry);
+        const lines = result.split('\n');
+
+        expect(lines).toHaveLength(4);
+        expect(lines[0]).toContain('Attempt 1');
+        expect(lines[1]).toContain('Attempt 2');
+        expect(lines[2]).toContain('Attempt 3');
+        expect(lines[3]).toContain('Total');
+      });
     });
   });
 

package/tests/unit/timer-verbose-integration.test.ts

@@ -0,0 +1,170 @@
+import { jest } from '@jest/globals';
+import { createStatusLine } from '../../src/utils/status-line.js';
+import { createTaskTimer } from '../../src/utils/timer.js';
+
+/**
+ * Tests the interaction between the timer callback, status line, and verbose toggle.
+ * This mirrors the logic in do.ts where the onTick callback checks verboseToggle.isVerbose
+ * and clears/skips the status line when verbose is on.
+ */
+describe('Timer-Verbose Integration', () => {
+  let originalIsTTY: boolean | undefined;
+  let originalWrite: typeof process.stdout.write;
+  let writeOutput: string[];
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    originalIsTTY = process.stdout.isTTY;
+    originalWrite = process.stdout.write;
+    writeOutput = [];
+
+    // Mock stdout.write to capture output
+    process.stdout.isTTY = true;
+    process.stdout.write = jest.fn((data: string | Uint8Array) => {
+      writeOutput.push(data.toString());
+      return true;
+    }) as typeof process.stdout.write;
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+    process.stdout.isTTY = originalIsTTY;
+    process.stdout.write = originalWrite;
+  });
+
+  describe('onTick callback with verbose check', () => {
+    it('should update status line when verbose is off', () => {
+      const statusLine = createStatusLine();
+      let isVerbose = false;
+
+      const timer = createTaskTimer((elapsed) => {
+        if (isVerbose) {
+          statusLine.clear();
+          return;
+        }
+        statusLine.update(`Task running: ${elapsed}ms`);
+      });
+
+      timer.start();
+      expect(writeOutput.length).toBeGreaterThan(0);
+      expect(writeOutput.some(output => output.includes('Task running'))).toBe(true);
+
+      timer.stop();
+    });
+
+    it('should clear status line and skip update when verbose is toggled on', () => {
+      const statusLine = createStatusLine();
+      let isVerbose = false;
+
+      const timer = createTaskTimer((elapsed) => {
+        if (isVerbose) {
+          statusLine.clear();
+          return;
+        }
+        statusLine.update(`Task running: ${elapsed}ms`);
+      });
+
+      timer.start();
+      // Initial tick should update
+      expect(writeOutput.some(output => output.includes('Task running: 0ms'))).toBe(true);
+
+      // Toggle verbose on
+      isVerbose = true;
+      writeOutput = [];
+
+      // Next tick should clear the line instead of updating
+      jest.advanceTimersByTime(1000);
+
+      // Should have cleared (written empty/reset) but not updated with task info
+      expect(writeOutput.length).toBeGreaterThan(0);
+      // The clear writes spaces to overwrite, not "Task running"
+      expect(writeOutput.some(output => output.includes('Task running'))).toBe(false);
+
+      timer.stop();
+    });
+
+    it('should resume updating status line when verbose is toggled back off', () => {
+      const statusLine = createStatusLine();
+      let isVerbose = false;
+
+      const timer = createTaskTimer((elapsed) => {
+        if (isVerbose) {
+          statusLine.clear();
+          return;
+        }
+        statusLine.update(`Task running: ${elapsed}ms`);
+      });
+
+      timer.start();
+      // Toggle verbose on
+      isVerbose = true;
+      jest.advanceTimersByTime(1000);
+
+      // Toggle verbose back off
+      isVerbose = false;
+      writeOutput = [];
+
+      // Next tick should update normally
+      jest.advanceTimersByTime(1000);
+
+      expect(writeOutput.some(output => output.includes('Task running'))).toBe(true);
+
+      timer.stop();
+    });
+
+    it('should track elapsed time correctly regardless of verbose state', () => {
+      const statusLine = createStatusLine();
+      let isVerbose = false;
+
+      const timer = createTaskTimer((elapsed) => {
+        if (isVerbose) {
+          statusLine.clear();
+          return;
+        }
+        statusLine.update(`Task running: ${elapsed}ms`);
+      });
+
+      timer.start();
+
+      // Run some time with verbose off
+      jest.advanceTimersByTime(2000);
+      expect(timer.getElapsed()).toBeGreaterThanOrEqual(2000);
+
+      // Toggle verbose on - timer keeps running
+      isVerbose = true;
+      jest.advanceTimersByTime(3000);
+      expect(timer.getElapsed()).toBeGreaterThanOrEqual(5000);
+
+      // Toggle verbose off - elapsed time is accurate
+      isVerbose = false;
+      writeOutput = [];
+      jest.advanceTimersByTime(1000);
+
+      // The elapsed time should be around 6000ms now, visible in the output
+      expect(writeOutput.some(output => output.includes('Task running'))).toBe(true);
+      expect(timer.getElapsed()).toBeGreaterThanOrEqual(6000);
+
+      timer.stop();
+    });
+
+    it('should not create timer callback when started with verbose flag', () => {
+      // This mirrors the do.ts logic: verbose ? undefined : (elapsed) => {...}
+      const initialVerbose = true;
+      const onTick = initialVerbose ? undefined : jest.fn();
+
+      const timer = createTaskTimer(onTick);
+      timer.start();
+
+      jest.advanceTimersByTime(5000);
+
+      // No callback should have been called
+      if (onTick) {
+        expect(onTick).not.toHaveBeenCalled();
+      }
+      // Timer still tracks time
+      expect(timer.getElapsed()).toBeGreaterThanOrEqual(5000);
+
+      timer.stop();
+    });
+  });
+});