rafcode 2.2.0 → 2.4.0

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

@@ -8,10 +8,12 @@ import {
   formatCost,
   formatTaskTokenSummary,
   formatTokenTotalSummary,
+  formatRateLimitPercentage,
+  TokenSummaryOptions,
   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 +298,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');
+      });
     });
   });
 
@@ -387,5 +477,145 @@ describe('Terminal Symbols', () => {
       expect(lines[0]).toContain('──');
       expect(lines[lines.length - 1]).toContain('──');
     });
+
+    it('should include rate limit percentage when option enabled', () => {
+      const options: TokenSummaryOptions = {
+        showRateLimitEstimate: true,
+        rateLimitPercentage: 42.5,
+      };
+      const result = formatTokenTotalSummary(makeUsage(), makeCost(3.75), options);
+      expect(result).toContain('~43% of 5h window');
+    });
+
+    it('should not include rate limit when option disabled', () => {
+      const options: TokenSummaryOptions = {
+        showRateLimitEstimate: false,
+        rateLimitPercentage: 42.5,
+      };
+      const result = formatTokenTotalSummary(makeUsage(), makeCost(3.75), options);
+      expect(result).not.toContain('5h window');
+    });
+
+    it('should hide cache tokens when option disabled', () => {
+      const options: TokenSummaryOptions = {
+        showCacheTokens: false,
+      };
+      const result = formatTokenTotalSummary(
+        makeUsage({ cacheReadInputTokens: 125000 }),
+        makeCost(3.75),
+        options
+      );
+      expect(result).not.toContain('Cache:');
+    });
+  });
+
+  describe('formatRateLimitPercentage', () => {
+    it('should format zero percentage', () => {
+      expect(formatRateLimitPercentage(0)).toBe('~0% of 5h window');
+    });
+
+    it('should format very small percentages with 2 decimals', () => {
+      expect(formatRateLimitPercentage(0.05)).toBe('~0.05% of 5h window');
+    });
+
+    it('should format small percentages with 1 decimal', () => {
+      expect(formatRateLimitPercentage(0.5)).toBe('~0.5% of 5h window');
+    });
+
+    it('should round percentages >= 1', () => {
+      expect(formatRateLimitPercentage(1.5)).toBe('~2% of 5h window');
+      expect(formatRateLimitPercentage(42.3)).toBe('~42% of 5h window');
+      expect(formatRateLimitPercentage(100)).toBe('~100% of 5h window');
+    });
+
+    it('should handle percentages over 100%', () => {
+      expect(formatRateLimitPercentage(150.7)).toBe('~151% of 5h window');
+    });
+  });
+
+  describe('formatTaskTokenSummary with options', () => {
+    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],
+    });
+
+    it('should include rate limit percentage in single-attempt summary', () => {
+      const usage = makeUsage({ cacheReadInputTokens: 18500 });
+      const entry = makeEntry(usage, makeCost(0.42));
+      const options: TokenSummaryOptions = {
+        showRateLimitEstimate: true,
+        rateLimitPercentage: 2.5,
+      };
+
+      const result = formatTaskTokenSummary(entry, undefined, options);
+      expect(result).toContain('~3% of 5h window');
+    });
+
+    it('should hide cache tokens in single-attempt summary when disabled', () => {
+      const usage = makeUsage({ cacheReadInputTokens: 18500 });
+      const entry = makeEntry(usage, makeCost(0.42));
+      const options: TokenSummaryOptions = {
+        showCacheTokens: false,
+      };
+
+      const result = formatTaskTokenSummary(entry, undefined, options);
+      expect(result).not.toContain('Cache:');
+    });
+
+    it('should only show rate limit on total line in multi-attempt summary', () => {
+      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 options: TokenSummaryOptions = {
+        showRateLimitEstimate: true,
+        rateLimitPercentage: 1.5,
+      };
+
+      const result = formatTaskTokenSummary(entry, undefined, options);
+      const lines = result.split('\n');
+
+      // Rate limit should only appear on the Total line
+      expect(lines[0]).not.toContain('5h window'); // Attempt 1
+      expect(lines[1]).not.toContain('5h window'); // Attempt 2
+      expect(lines[2]).toContain('~2% of 5h window'); // Total
+    });
+
+    it('should respect showCacheTokens in multi-attempt summary', () => {
+      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 options: TokenSummaryOptions = {
+        showCacheTokens: false,
+      };
+
+      const result = formatTaskTokenSummary(entry, undefined, options);
+      expect(result).not.toContain('Cache:');
+    });
   });
 });

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