@ebowwa/coder 0.2.1 → 0.7.64

package/packages/src/core/agent-loop/__tests__/compaction.test.ts

@@ -0,0 +1,280 @@
+/**
+ * Compaction Tests - Context compaction strategies
+ */
+
+import { describe, it, expect, beforeEach } from "bun:test";
+import {
+  handleProactiveCompaction,
+  handleReactiveCompaction,
+  needsCompaction,
+  DEFAULT_PROACTIVE_OPTIONS,
+  DEFAULT_REACTIVE_OPTIONS,
+} from "../compaction.js";
+import { LoopState } from "../loop-state.js";
+import type { Message } from "../../../types/index.js";
+
+// Helper to create messages with specific token counts
+function createMessages(count: number, tokensPerMessage: number = 100): Message[] {
+  const messages: Message[] = [];
+  const charsPerMessage = tokensPerMessage * 4; // ~4 chars per token
+
+  for (let i = 0; i < count; i++) {
+    messages.push({
+      role: i % 2 === 0 ? "user" : "assistant",
+      content: [{
+        type: "text",
+        text: "x".repeat(charsPerMessage) + ` Message ${i}`,
+      }],
+    });
+  }
+
+  return messages;
+}
+
+describe("DEFAULT_PROACTIVE_OPTIONS", () => {
+  it("should have correct default values", () => {
+    expect(DEFAULT_PROACTIVE_OPTIONS.keepFirst).toBe(0);
+    expect(DEFAULT_PROACTIVE_OPTIONS.keepLast).toBe(3);
+    expect(DEFAULT_PROACTIVE_OPTIONS.preserveToolPairs).toBe(true);
+  });
+});
+
+describe("DEFAULT_REACTIVE_OPTIONS", () => {
+  it("should have correct default values", () => {
+    expect(DEFAULT_REACTIVE_OPTIONS.keepFirst).toBe(0);
+    expect(DEFAULT_REACTIVE_OPTIONS.keepLast).toBe(3);
+    expect(DEFAULT_REACTIVE_OPTIONS.preserveToolPairs).toBe(true);
+  });
+});
+
+describe("needsCompaction", () => {
+  it("should return false for small message sets", () => {
+    const messages = createMessages(5, 1000); // 5 messages, high tokens
+
+    // Should not need compaction because not enough messages
+    expect(needsCompaction(messages, 4096)).toBe(false);
+  });
+
+  it("should return false when under threshold", () => {
+    const messages = createMessages(10, 50); // 10 messages, low tokens each
+
+    // Under 90% threshold
+    expect(needsCompaction(messages, 4096)).toBe(false);
+  });
+
+  it("should return true when over threshold", () => {
+    const messages = createMessages(10, 500); // 10 messages, high tokens
+
+    // Over 90% threshold
+    expect(needsCompaction(messages, 4096)).toBe(true);
+  });
+
+  it("should respect custom threshold", () => {
+    // Create messages that are exactly at a specific token count
+    // 10 messages * 200 tokens = 2000 tokens total
+    const messages = createMessages(10, 200);
+    // Total ~2000 tokens, at 90% of 2000 = 1800 threshold
+    // 2000 >= 1800, so needs compaction at 0.9 threshold
+    expect(needsCompaction(messages, 2000, 0.9)).toBe(true);
+
+    // At 99% threshold (1980), 2000 >= 1980, so still needs compaction
+    expect(needsCompaction(messages, 2000, 0.99)).toBe(true);
+
+    // At 101% threshold (2020), 2000 < 2020, so no compaction needed
+    expect(needsCompaction(messages, 2000, 1.01)).toBe(false);
+  });
+});
+
+describe("handleProactiveCompaction", () => {
+  let state: LoopState;
+
+  beforeEach(() => {
+    // Create state with enough messages for compaction
+    const messages = createMessages(12, 500);
+    state = new LoopState(messages);
+  });
+
+  it("should return false when compaction not needed", async () => {
+    const smallState = new LoopState(createMessages(5, 50));
+
+    const result = await handleProactiveCompaction(smallState, 4096);
+
+    expect(result).toBe(false);
+    expect(smallState.compactionCount).toBe(0);
+  });
+
+  it("should apply compaction when needed", async () => {
+    const result = await handleProactiveCompaction(state, 4096);
+
+    // May or may not compact depending on actual token counts
+    // Just verify it doesn't throw
+    expect(typeof result).toBe("boolean");
+  });
+
+  it("should respect custom options", async () => {
+    const customOptions = {
+      keepFirst: 2,
+      keepLast: 5,
+      preserveToolPairs: false,
+    };
+
+    const result = await handleProactiveCompaction(state, 4096, customOptions);
+
+    expect(typeof result).toBe("boolean");
+  });
+});
+
+describe("handleReactiveCompaction", () => {
+  let state: LoopState;
+
+  beforeEach(() => {
+    const messages = createMessages(12, 500);
+    state = new LoopState(messages);
+  });
+
+  it("should attempt compaction on any message set", async () => {
+    const result = await handleReactiveCompaction(state, 4096);
+
+    expect(typeof result).toBe("boolean");
+  });
+
+  it("should return false if compaction does not reduce tokens", async () => {
+    // Very small state that can't be compacted meaningfully
+    const smallState = new LoopState(createMessages(2, 100));
+
+    const result = await handleReactiveCompaction(smallState, 4096);
+
+    expect(result).toBe(false);
+  });
+
+  it("should increment compaction count on success", async () => {
+    const initialCount = state.compactionCount;
+
+    await handleReactiveCompaction(state, 1000); // Force compaction with low limit
+
+    // If compaction succeeded, count should increase
+    // (depends on actual token counts)
+  });
+});
+
+describe("compaction with tool pairs", () => {
+  it("should preserve tool use/result pairs when enabled", async () => {
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "x".repeat(4000) }] },
+      { role: "assistant", content: [
+        { type: "tool_use", id: "tool1", name: "Read", input: { file_path: "/test" } },
+      ]},
+      { role: "user", content: [
+        { type: "tool_result", tool_use_id: "tool1", content: "result" },
+      ]},
+      { role: "assistant", content: [{ type: "text", text: "Done" }] },
+    ];
+
+    const state = new LoopState(messages);
+
+    // With preserveToolPairs: true
+    const result = await handleProactiveCompaction(state, 1000, {
+      keepFirst: 0,
+      keepLast: 1,
+      preserveToolPairs: true,
+    });
+
+    // Tool pairs should be considered for preservation
+    expect(typeof result).toBe("boolean");
+  });
+});
+
+describe("compaction state updates", () => {
+  it("should update state messages on successful compaction", async () => {
+    const messages = createMessages(15, 500);
+    const state = new LoopState(messages);
+    const originalLength = state.messages.length;
+
+    await handleProactiveCompaction(state, 2000); // Force compaction
+
+    // If compaction occurred, message count should decrease
+    // (depends on actual implementation)
+  });
+
+  it("should track total tokens compacted", async () => {
+    const messages = createMessages(15, 500);
+    const state = new LoopState(messages);
+
+    const initialCompacted = state.totalTokensCompacted;
+
+    await handleProactiveCompaction(state, 2000);
+
+    // If compaction succeeded, this should increase
+    // (depends on actual implementation)
+  });
+});
+
+describe("edge cases", () => {
+  it("should handle empty messages", async () => {
+    const state = new LoopState([]);
+
+    const result = await handleProactiveCompaction(state, 4096);
+
+    expect(result).toBe(false);
+  });
+
+  it("should handle single message", async () => {
+    const state = new LoopState(createMessages(1, 1000));
+
+    const result = await handleProactiveCompaction(state, 4096);
+
+    expect(result).toBe(false);
+  });
+
+  it("should handle messages exactly at threshold", async () => {
+    // Create messages that are exactly at the threshold
+    const messages = createMessages(8, 460); // ~3680 tokens, at 90% of 4096
+    const state = new LoopState(messages);
+
+    const result = await handleProactiveCompaction(state, 4096);
+
+    // Should need compaction at exactly 90%
+    expect(typeof result).toBe("boolean");
+  });
+
+  it("should handle very large individual messages", async () => {
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "x".repeat(100000) }] },
+      { role: "assistant", content: [{ type: "text", text: "Response" }] },
+      { role: "user", content: [{ type: "text", text: "Follow up" }] },
+    ];
+
+    const state = new LoopState(messages);
+
+    const result = await handleReactiveCompaction(state, 4096);
+
+    expect(typeof result).toBe("boolean");
+  });
+
+  it("should handle messages with mixed content types", async () => {
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "x".repeat(2000) }] },
+      { role: "assistant", content: [
+        { type: "tool_use", id: "t1", name: "Read", input: {} },
+        { type: "text", text: "Text after tool" },
+      ]},
+      { role: "user", content: [
+        { type: "tool_result", tool_use_id: "t1", content: "result" },
+        { type: "image", source: { type: "base64", data: "imagedata", media_type: "image/png" } },
+      ]},
+    ];
+
+    for (let i = 0; i < 6; i++) {
+      messages.push({
+        role: i % 2 === 0 ? "user" : "assistant",
+        content: [{ type: "text", text: "x".repeat(500) }],
+      });
+    }
+
+    const state = new LoopState(messages);
+
+    const result = await handleProactiveCompaction(state, 4096);
+
+    expect(typeof result).toBe("boolean");
+  });
+});

package/packages/src/core/agent-loop/__tests__/formatters.test.ts

@@ -0,0 +1,234 @@
+/**
+ * Formatters Tests - Cost and metrics display utilities
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+  formatCost,
+  formatMetrics,
+  formatCostBrief,
+  formatCacheMetrics,
+} from "../formatters.js";
+import type { QueryMetrics, CacheMetrics } from "../../../types/index.js";
+
+describe("formatCost", () => {
+  it("should format small costs with 4 decimal places", () => {
+    expect(formatCost(0.001)).toBe("$0.0010");
+    expect(formatCost(0.0099)).toBe("$0.0099");
+    expect(formatCost(0.005)).toBe("$0.0050");
+  });
+
+  it("should format larger costs with 2 decimal places", () => {
+    expect(formatCost(0.01)).toBe("$0.01");
+    expect(formatCost(0.5)).toBe("$0.50");
+    expect(formatCost(1.0)).toBe("$1.00");
+    expect(formatCost(10.99)).toBe("$10.99");
+    expect(formatCost(100.0)).toBe("$100.00");
+  });
+
+  it("should handle zero cost", () => {
+    expect(formatCost(0)).toBe("$0.0000");
+  });
+
+  it("should handle very large costs", () => {
+    expect(formatCost(1000.0)).toBe("$1000.00");
+    expect(formatCost(9999.99)).toBe("$9999.99");
+  });
+});
+
+describe("formatMetrics", () => {
+  it("should format basic metrics without cache", () => {
+    const metrics: QueryMetrics = {
+      model: "claude-sonnet-4-6",
+      messageCount: 5,
+      messageTokens: 1500,
+      usage: { input_tokens: 1000, output_tokens: 500 },
+      durationMs: 2000,
+      ttftMs: 150,
+      costUSD: 0.05,
+      stopReason: "end_turn",
+      requestId: "req-123",
+    };
+
+    const result = formatMetrics(metrics);
+
+    expect(result).toContain("Cost: $0.05");
+    expect(result).toContain("1,000 input");
+    expect(result).toContain("500 output");
+    expect(result).not.toContain("Cache:");
+  });
+
+  it("should format metrics with cache information", () => {
+    const metrics: QueryMetrics = {
+      model: "claude-sonnet-4-6",
+      messageCount: 5,
+      messageTokens: 1500,
+      usage: {
+        input_tokens: 1000,
+        output_tokens: 500,
+        cache_read_input_tokens: 800,
+        cache_creation_input_tokens: 200,
+      },
+      durationMs: 2000,
+      ttftMs: 150,
+      costUSD: 0.03,
+      stopReason: "end_turn",
+      requestId: "req-123",
+    };
+
+    const result = formatMetrics(metrics);
+
+    expect(result).toContain("Cost: $0.03");
+    expect(result).toContain("800 read");
+    expect(result).toContain("200 write");
+    expect(result).toContain("Cache:");
+  });
+
+  it("should handle small costs with 4 decimals", () => {
+    const metrics: QueryMetrics = {
+      model: "claude-sonnet-4-6",
+      messageCount: 1,
+      messageTokens: 100,
+      usage: { input_tokens: 50, output_tokens: 50 },
+      durationMs: 500,
+      ttftMs: 100,
+      costUSD: 0.005,
+      stopReason: "end_turn",
+      requestId: "req-1",
+    };
+
+    const result = formatMetrics(metrics);
+    expect(result).toContain("$0.0050");
+  });
+
+  it("should format large token counts with locale separators", () => {
+    const metrics: QueryMetrics = {
+      model: "claude-sonnet-4-6",
+      messageCount: 100,
+      messageTokens: 500000,
+      usage: { input_tokens: 400000, output_tokens: 100000 },
+      durationMs: 10000,
+      ttftMs: 500,
+      costUSD: 5.0,
+      stopReason: "end_turn",
+      requestId: "req-123",
+    };
+
+    const result = formatMetrics(metrics);
+
+    expect(result).toContain("400,000 input");
+    expect(result).toContain("100,000 output");
+  });
+});
+
+describe("formatCostBrief", () => {
+  it("should format brief cost with total tokens", () => {
+    const metrics: QueryMetrics = {
+      model: "claude-sonnet-4-6",
+      messageCount: 5,
+      messageTokens: 1500,
+      usage: { input_tokens: 1000, output_tokens: 500 },
+      durationMs: 2000,
+      ttftMs: 150,
+      costUSD: 0.05,
+      stopReason: "end_turn",
+      requestId: "req-123",
+    };
+
+    const result = formatCostBrief(metrics);
+
+    expect(result).toContain("Cost: $0.05");
+    expect(result).toContain("1,500"); // Total tokens
+    expect(result).not.toContain("input");
+    expect(result).not.toContain("output");
+  });
+
+  it("should handle small costs", () => {
+    const metrics: QueryMetrics = {
+      model: "claude-sonnet-4-6",
+      messageCount: 1,
+      messageTokens: 100,
+      usage: { input_tokens: 50, output_tokens: 50 },
+      durationMs: 500,
+      ttftMs: 100,
+      costUSD: 0.001,
+      stopReason: "end_turn",
+      requestId: "req-1",
+    };
+
+    const result = formatCostBrief(metrics);
+    expect(result).toContain("$0.0010");
+  });
+});
+
+describe("formatCacheMetrics", () => {
+  it("should format cache metrics with all fields", () => {
+    const cacheMetrics: CacheMetrics = {
+      cacheHits: 50,
+      cacheMisses: 10,
+      totalCacheReadTokens: 50000,
+      totalCacheWriteTokens: 5000,
+      cacheHitRate: 0.833,
+      estimatedSavingsUSD: 0.25,
+    };
+
+    const result = formatCacheMetrics(cacheMetrics);
+
+    expect(result).toContain("83.3% hit rate");
+    expect(result).toContain("50,000 read");
+    expect(result).toContain("5,000 written");
+    expect(result).toContain("Saved: $0.25");
+  });
+
+  it("should handle zero cache activity", () => {
+    const cacheMetrics: CacheMetrics = {
+      cacheHits: 0,
+      cacheMisses: 0,
+      totalCacheReadTokens: 0,
+      totalCacheWriteTokens: 0,
+      cacheHitRate: 0,
+      estimatedSavingsUSD: 0,
+    };
+
+    const result = formatCacheMetrics(cacheMetrics);
+
+    expect(result).toContain("0.0% hit rate");
+    expect(result).toContain("0 read");
+    expect(result).toContain("0 written");
+    expect(result).toContain("Saved: $0.0000");
+  });
+
+  it("should handle 100% hit rate", () => {
+    const cacheMetrics: CacheMetrics = {
+      cacheHits: 100,
+      cacheMisses: 0,
+      totalCacheReadTokens: 100000,
+      totalCacheWriteTokens: 0,
+      cacheHitRate: 1.0,
+      estimatedSavingsUSD: 1.50,
+    };
+
+    const result = formatCacheMetrics(cacheMetrics);
+
+    expect(result).toContain("100.0% hit rate");
+    expect(result).toContain("100,000 read");
+    expect(result).toContain("Saved: $1.50");
+  });
+
+  it("should format large numbers with separators", () => {
+    const cacheMetrics: CacheMetrics = {
+      cacheHits: 1000,
+      cacheMisses: 100,
+      totalCacheReadTokens: 1000000,
+      totalCacheWriteTokens: 100000,
+      cacheHitRate: 0.909,
+      estimatedSavingsUSD: 10.0,
+    };
+
+    const result = formatCacheMetrics(cacheMetrics);
+
+    expect(result).toContain("1,000,000 read");
+    expect(result).toContain("100,000 written");
+    expect(result).toContain("90.9% hit rate");
+  });
+});

package/packages/src/core/agent-loop/__tests__/index.test.ts

@@ -0,0 +1,162 @@
+/**
+ * Agent Loop Index Tests - Main entry point and exports
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+  agentLoop,
+  formatCost,
+  formatMetrics,
+  formatCostBrief,
+  formatCacheMetrics,
+  LoopState,
+  executeTools,
+  buildAPIMessages,
+  injectReminderIntoContent,
+  handleProactiveCompaction,
+  handleReactiveCompaction,
+  needsCompaction,
+  estimateMessagesTokens,
+  DEFAULT_PROACTIVE_OPTIONS,
+  DEFAULT_REACTIVE_OPTIONS,
+} from "../index.js";
+import type { AgentLoopOptions, AgentLoopResult } from "../index.js";
+
+describe("exports", () => {
+  it("should export agentLoop function", () => {
+    expect(typeof agentLoop).toBe("function");
+  });
+
+  it("should export formatter functions", () => {
+    expect(typeof formatCost).toBe("function");
+    expect(typeof formatMetrics).toBe("function");
+    expect(typeof formatCostBrief).toBe("function");
+    expect(typeof formatCacheMetrics).toBe("function");
+  });
+
+  it("should export LoopState class", () => {
+    expect(LoopState).toBeDefined();
+    expect(typeof LoopState).toBe("function");
+  });
+
+  it("should export executeTools function", () => {
+    expect(typeof executeTools).toBe("function");
+  });
+
+  it("should export message builder functions", () => {
+    expect(typeof buildAPIMessages).toBe("function");
+    expect(typeof injectReminderIntoContent).toBe("function");
+  });
+
+  it("should export compaction functions and constants", () => {
+    expect(typeof handleProactiveCompaction).toBe("function");
+    expect(typeof handleReactiveCompaction).toBe("function");
+    expect(typeof needsCompaction).toBe("function");
+    expect(typeof estimateMessagesTokens).toBe("function");
+    expect(DEFAULT_PROACTIVE_OPTIONS).toBeDefined();
+    expect(DEFAULT_REACTIVE_OPTIONS).toBeDefined();
+  });
+});
+
+describe("AgentLoopOptions type", () => {
+  it("should have required apiKey field", () => {
+    const options: AgentLoopOptions = {
+      apiKey: "test-key",
+      systemPrompt: "Test prompt",
+      tools: [],
+      permissionMode: "bypassPermissions",
+      workingDirectory: "/test",
+    };
+
+    expect(options.apiKey).toBe("test-key");
+  });
+
+  it("should have optional fields with defaults", () => {
+    const options: AgentLoopOptions = {
+      apiKey: "test-key",
+      systemPrompt: "Test prompt",
+      tools: [],
+      permissionMode: "default",
+      workingDirectory: "/test",
+    };
+
+    // Optional fields should be accessible
+    expect(options.model).toBeUndefined();
+    expect(options.maxTokens).toBeUndefined();
+    expect(options.hookManager).toBeUndefined();
+  });
+});
+
+describe("AgentLoopResult type", () => {
+  it("should contain all expected fields", () => {
+    // Create a result via LoopState to verify type compatibility
+    const state = new LoopState([]);
+    const result: AgentLoopResult = state.toResult();
+
+    expect(result.messages).toBeDefined();
+    expect(result.metrics).toBeDefined();
+    expect(typeof result.totalCost).toBe("number");
+    expect(typeof result.totalDuration).toBe("number");
+    expect(result.totalCacheMetrics).toBeDefined();
+    expect(typeof result.compactionCount).toBe("number");
+    expect(typeof result.totalTokensCompacted).toBe("number");
+  });
+});
+
+describe("agentLoop function signature", () => {
+  it("should accept AgentLoopOptions and return Promise<AgentLoopResult>", () => {
+    // Type check only - don't actually run it
+    const checkSignature = async (): Promise<void> => {
+      const options: AgentLoopOptions = {
+        apiKey: "test",
+        systemPrompt: "test",
+        tools: [],
+        permissionMode: "bypassPermissions",
+        workingDirectory: "/test",
+      };
+
+      // This would actually call the API, so we just verify the type
+      const _typeCheck: () => Promise<AgentLoopResult> = () => agentLoop([], options);
+
+      // Verify the function exists and has correct signature
+      expect(typeof agentLoop).toBe("function");
+    };
+
+    // Just verify no type errors
+    expect(checkSignature).toBeDefined();
+  });
+});
+
+describe("re-exports from submodules", () => {
+  it("should re-export LoopState correctly", () => {
+    const state = new LoopState([
+      { role: "user", content: [{ type: "text", text: "test" }] },
+    ]);
+
+    expect(state.messages).toHaveLength(1);
+    expect(state.turnNumber).toBe(0);
+  });
+
+  it("should re-export formatters with correct behavior", () => {
+    expect(formatCost(0.005)).toBe("$0.0050");
+    expect(formatCost(1.5)).toBe("$1.50");
+  });
+
+  it("should re-export message builder functions", () => {
+    const messages = [
+      { role: "user" as const, content: [{ type: "text" as const, text: "Hello" }] },
+    ];
+
+    const result = buildAPIMessages(messages, "System", "Reminder");
+
+    expect(result).toHaveLength(1);
+    expect((result[0]?.content[0] as any).text).toContain("Reminder");
+  });
+
+  it("should re-export compaction constants", () => {
+    expect(DEFAULT_PROACTIVE_OPTIONS.keepFirst).toBe(0);
+    expect(DEFAULT_PROACTIVE_OPTIONS.keepLast).toBe(3);
+    expect(DEFAULT_REACTIVE_OPTIONS.keepFirst).toBe(0);
+    expect(DEFAULT_REACTIVE_OPTIONS.keepLast).toBe(3);
+  });
+});