rafcode 2.1.1 → 2.3.0

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

@@ -4,8 +4,14 @@ import {
   formatProjectHeader,
   formatSummary,
   formatProgressBar,
+  formatNumber,
+  formatCost,
+  formatTaskTokenSummary,
+  formatTokenTotalSummary,
   TaskStatus,
 } from '../../src/utils/terminal-symbols.js';
+import type { UsageData } from '../../src/types/config.js';
+import type { CostBreakdown, TaskUsageEntry } from '../../src/utils/token-tracker.js';
 
 describe('Terminal Symbols', () => {
   describe('SYMBOLS', () => {
@@ -231,4 +237,243 @@ describe('Terminal Symbols', () => {
       expect(result).toBe('✓✗⊘○');
     });
   });
+
+  describe('formatNumber', () => {
+    it('should format small numbers without separators', () => {
+      expect(formatNumber(42)).toBe('42');
+    });
+
+    it('should format numbers with thousands separators', () => {
+      expect(formatNumber(12345)).toBe('12,345');
+    });
+
+    it('should format large numbers', () => {
+      expect(formatNumber(1234567)).toBe('1,234,567');
+    });
+
+    it('should format zero', () => {
+      expect(formatNumber(0)).toBe('0');
+    });
+  });
+
+  describe('formatCost', () => {
+    it('should format zero cost', () => {
+      expect(formatCost(0)).toBe('$0.00');
+    });
+
+    it('should format normal costs with 2 decimals', () => {
+      expect(formatCost(1.23)).toBe('$1.23');
+    });
+
+    it('should format small costs with 4 decimals', () => {
+      expect(formatCost(0.0042)).toBe('$0.0042');
+    });
+
+    it('should format costs just at the threshold', () => {
+      expect(formatCost(0.01)).toBe('$0.01');
+    });
+
+    it('should format costs below threshold', () => {
+      expect(formatCost(0.009)).toBe('$0.0090');
+    });
+  });
+
+  describe('formatTaskTokenSummary', () => {
+    const makeUsage = (overrides: Partial<UsageData> = {}): UsageData => ({
+      inputTokens: 5234,
+      outputTokens: 1023,
+      cacheReadInputTokens: 0,
+      cacheCreationInputTokens: 0,
+      modelUsage: {},
+      ...overrides,
+    });
+
+    const makeCost = (total: number): CostBreakdown => ({
+      inputCost: 0,
+      outputCost: 0,
+      cacheReadCost: 0,
+      cacheCreateCost: 0,
+      totalCost: total,
+    });
+
+    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');
+      });
+    });
+  });
+
+  describe('formatTokenTotalSummary', () => {
+    const makeUsage = (overrides: Partial<UsageData> = {}): UsageData => ({
+      inputTokens: 45678,
+      outputTokens: 12345,
+      cacheReadInputTokens: 0,
+      cacheCreationInputTokens: 0,
+      modelUsage: {},
+      ...overrides,
+    });
+
+    const makeCost = (total: number): CostBreakdown => ({
+      inputCost: 0,
+      outputCost: 0,
+      cacheReadCost: 0,
+      cacheCreateCost: 0,
+      totalCost: total,
+    });
+
+    it('should format total summary without cache', () => {
+      const result = formatTokenTotalSummary(makeUsage(), makeCost(3.75));
+      expect(result).toContain('Token Usage Summary');
+      expect(result).toContain('Total tokens: 45,678 in / 12,345 out');
+      expect(result).toContain('Estimated cost: $3.75');
+      expect(result).not.toContain('Cache:');
+    });
+
+    it('should include cache read in total summary', () => {
+      const result = formatTokenTotalSummary(
+        makeUsage({ cacheReadInputTokens: 125000 }),
+        makeCost(3.75)
+      );
+      expect(result).toContain('Cache: 125,000 read');
+    });
+
+    it('should include cache creation in total summary', () => {
+      const result = formatTokenTotalSummary(
+        makeUsage({ cacheCreationInputTokens: 8000 }),
+        makeCost(3.75)
+      );
+      expect(result).toContain('Cache: 8,000 created');
+    });
+
+    it('should include both cache types in total summary', () => {
+      const result = formatTokenTotalSummary(
+        makeUsage({ cacheReadInputTokens: 125000, cacheCreationInputTokens: 8000 }),
+        makeCost(3.75)
+      );
+      expect(result).toContain('Cache: 125,000 read / 8,000 created');
+    });
+
+    it('should have divider lines', () => {
+      const result = formatTokenTotalSummary(makeUsage(), makeCost(3.75));
+      const lines = result.split('\n');
+      expect(lines[0]).toContain('──');
+      expect(lines[lines.length - 1]).toContain('──');
+    });
+  });
 });

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