@ebowwa/coder 0.7.63 → 0.7.64

package/dist/core/agent-loop/__tests__/compaction.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Compaction Tests - Context compaction strategies
+ */
+export {};
+//# sourceMappingURL=compaction.test.d.ts.map

package/dist/core/agent-loop/__tests__/compaction.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compaction.test.d.ts","sourceRoot":"","sources":["../../../../packages/src/core/agent-loop/__tests__/compaction.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/core/agent-loop/__tests__/compaction.test.js

@@ -0,0 +1,209 @@
+/**
+ * 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";
+// Helper to create messages with specific token counts
+function createMessages(count, tokensPerMessage = 100) {
+    const messages = [];
+    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;
+    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;
+    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 = [
+            { 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 = [
+            { 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 = [
+            { 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/dist/core/agent-loop/__tests__/formatters.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Formatters Tests - Cost and metrics display utilities
+ */
+export {};
+//# sourceMappingURL=formatters.test.d.ts.map

package/dist/core/agent-loop/__tests__/formatters.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatters.test.d.ts","sourceRoot":"","sources":["../../../../packages/src/core/agent-loop/__tests__/formatters.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/core/agent-loop/__tests__/formatters.test.js

@@ -0,0 +1,195 @@
+/**
+ * Formatters Tests - Cost and metrics display utilities
+ */
+import { describe, it, expect } from "bun:test";
+import { formatCost, formatMetrics, formatCostBrief, formatCacheMetrics, } from "../formatters.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 = {
+            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 = {
+            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 = {
+            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 = {
+            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 = {
+            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 = {
+            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 = {
+            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 = {
+            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 = {
+            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 = {
+            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/dist/core/agent-loop/__tests__/index.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Agent Loop Index Tests - Main entry point and exports
+ */
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/core/agent-loop/__tests__/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../../packages/src/core/agent-loop/__tests__/index.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/core/agent-loop/__tests__/index.test.js

@@ -0,0 +1,121 @@
+/**
+ * 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";
+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 = {
+            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 = {
+            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 = 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 () => {
+            const options = {
+                apiKey: "test",
+                systemPrompt: "test",
+                tools: [],
+                permissionMode: "bypassPermissions",
+                workingDirectory: "/test",
+            };
+            // This would actually call the API, so we just verify the type
+            const _typeCheck = () => 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", content: [{ type: "text", text: "Hello" }] },
+        ];
+        const result = buildAPIMessages(messages, "System", "Reminder");
+        expect(result).toHaveLength(1);
+        expect((result[0]?.content[0]).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);
+    });
+});

package/dist/core/agent-loop/__tests__/loop-state.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * LoopState Tests - State management for the agent loop
+ */
+export {};
+//# sourceMappingURL=loop-state.test.d.ts.map

package/dist/core/agent-loop/__tests__/loop-state.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop-state.test.d.ts","sourceRoot":"","sources":["../../../../packages/src/core/agent-loop/__tests__/loop-state.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}