joonecli 0.1.0

package/src/__tests__/optimizations.test.ts

@@ -0,0 +1,201 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { HumanMessage, AIMessage, SystemMessage } from "@langchain/core/messages";
+import {
+  SearchToolsTool,
+  ActivateToolTool,
+  activateTool,
+  getActivatedTools,
+  resetActivatedTools,
+} from "../tools/registry.js";
+import {
+  estimateTokens,
+  countMessageTokens,
+  isNearCapacity,
+} from "../core/tokenCounter.js";
+import { CacheOptimizedPromptBuilder } from "../core/promptBuilder.js";
+import {
+  ReasoningRouter,
+  ReasoningLevel,
+} from "../core/reasoningRouter.js";
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 5a: Enhanced Tool Registry
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("Enhanced Tool Registry", () => {
+  beforeEach(() => {
+    resetActivatedTools();
+  });
+
+  // ─── Test #56: Fuzzy search matches by description keyword ───
+
+  it("fuzzy search matches tools by description keyword", async () => {
+    const result = await SearchToolsTool.execute({ query: "commit" });
+
+    expect(result.content).toContain("git_commit");
+  });
+
+  // ─── Test #57: Fuzzy search matches by name ───
+
+  it("fuzzy search matches tools by name", async () => {
+    const result = await SearchToolsTool.execute({ query: "grep" });
+
+    expect(result.content).toContain("grep_search");
+  });
+
+  // ─── Test #58: activateTool adds tool to the active set ───
+
+  it("activateTool adds a tool to the active set", () => {
+    expect(getActivatedTools()).toHaveLength(0);
+
+    const tool = activateTool("git_commit");
+
+    expect(tool).toBeDefined();
+    expect(tool!.name).toBe("git_commit");
+    expect(getActivatedTools()).toHaveLength(1);
+  });
+
+  // ─── Test #59: ActivateToolTool returns schema on activation ───
+
+  it("ActivateToolTool returns the schema on successful activation", async () => {
+    const result = await ActivateToolTool.execute({ name: "git_diff" });
+
+    expect(result.content).toContain("activated");
+    expect(result.content).toContain("Schema");
+    expect(getActivatedTools()).toHaveLength(1);
+  });
+
+  // ─── Test #60: ActivateToolTool returns error for unknown tool ───
+
+  it("ActivateToolTool returns error for unknown tool", async () => {
+    const result = await ActivateToolTool.execute({ name: "nonexistent" });
+
+    expect(result.content).toMatch(/not found/i);
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 5b: Token Counter & Context Compaction
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("Token Counter", () => {
+  // ─── Test #61: Estimates tokens for short string ───
+
+  it("estimates tokens using ~4 chars per token", () => {
+    const tokens = estimateTokens("Hello world!"); // 12 chars → 3 tokens
+    expect(tokens).toBe(3);
+  });
+
+  // ─── Test #62: Counts tokens across messages ───
+
+  it("counts tokens across multiple messages", () => {
+    const messages = [
+      new HumanMessage("Hello"),     // 5 chars → 2 tokens + 4 overhead = 6
+      new AIMessage("Hi there"),     // 8 chars → 2 tokens + 4 overhead = 6
+    ];
+    const total = countMessageTokens(messages);
+
+    expect(total).toBeGreaterThan(0);
+    expect(total).toBe(12); // (2+4) + (2+4)
+  });
+
+  // ─── Test #63: isNearCapacity detects threshold ───
+
+  it("returns true when messages exceed 80% of capacity", () => {
+    // Create a big message ~320 chars → ~80 tokens
+    const bigMsg = new HumanMessage("x".repeat(320));
+    const messages = [bigMsg];
+
+    // maxTokens=100, threshold=0.8 → trigger at 80 tokens
+    // 320/4=80 + 4 overhead = 84 > 80
+    expect(isNearCapacity(messages, 100, 0.8)).toBe(true);
+  });
+
+  // ─── Test #64: isNearCapacity returns false below threshold ───
+
+  it("returns false when well below capacity", () => {
+    const messages = [new HumanMessage("short")];
+
+    expect(isNearCapacity(messages, 100000, 0.8)).toBe(false);
+  });
+});
+
+describe("Context Compaction", () => {
+  // ─── Test #65: compactHistory preserves last N messages ───
+
+  it("preserves the last N messages and prepends summary", () => {
+    const builder = new CacheOptimizedPromptBuilder();
+    const history = [
+      new HumanMessage("msg 1"),
+      new AIMessage("response 1"),
+      new HumanMessage("msg 2"),
+      new AIMessage("response 2"),
+      new HumanMessage("msg 3"),
+      new AIMessage("response 3"),
+    ];
+
+    const compacted = builder.compactHistory(history, "Summary of turns 1-2.", 4);
+
+    // Should have: 1 summary + 4 preserved
+    expect(compacted).toHaveLength(5);
+    expect((compacted[0] as HumanMessage).content).toContain("compacted");
+    expect((compacted[0] as HumanMessage).content).toContain("Summary of turns 1-2.");
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 5c: Reasoning Sandwich
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("ReasoningRouter", () => {
+  // ─── Test #66: First turns are HIGH (planning) ───
+
+  it("returns HIGH for the first turn (planning phase)", () => {
+    const router = new ReasoningRouter();
+
+    router.advanceTurn(false, false);
+    const level = router.getLevel();
+
+    expect(level).toBe(ReasoningLevel.HIGH);
+  });
+
+  // ─── Test #67: Tool-heavy turns are MEDIUM ───
+
+  it("returns MEDIUM for tool-heavy turns after planning", () => {
+    const router = new ReasoningRouter({ planningTurns: 1 });
+
+    router.advanceTurn(false, false); // turn 1
+    router.getLevel(); // HIGH (planning)
+    
+    router.advanceTurn(true, false); // turn 2
+    const level = router.getLevel(); // tool call shouldn't be high
+
+    expect(level).toBe(ReasoningLevel.MEDIUM);
+  });
+
+  // ─── Test #68: Post-error turns are HIGH (recovery) ───
+
+  it("returns HIGH for recovery after an error", () => {
+    const router = new ReasoningRouter({ planningTurns: 1 });
+
+    router.advanceTurn(false, false); // turn 1
+    router.getLevel(); // planning
+    
+    router.advanceTurn(true, false);  // turn 2
+    router.getLevel(); // tool call (MEDIUM)
+    
+    router.advanceTurn(false, true); // turn 3
+    const level = router.getLevel(); // error!
+
+    expect(level).toBe(ReasoningLevel.HIGH);
+  });
+
+  // ─── Test #69: Temperature mapping ───
+
+  it("maps reasoning levels to correct temperatures", () => {
+    const router = new ReasoningRouter({ highTemp: 0, mediumTemp: 0.3 });
+
+    expect(router.getTemperature(ReasoningLevel.HIGH)).toBe(0);
+    expect(router.getTemperature(ReasoningLevel.MEDIUM)).toBe(0.3);
+  });
+});

package/src/__tests__/promptBuilder.test.ts

@@ -0,0 +1,141 @@
+import { describe, it, expect } from "vitest";
+import {
+  CacheOptimizedPromptBuilder,
+  ContextState,
+} from "../core/promptBuilder.js";
+import {
+  SystemMessage,
+  HumanMessage,
+  AIMessage,
+} from "@langchain/core/messages";
+
+describe("CacheOptimizedPromptBuilder", () => {
+  // ─── Behavior 1: Static prefix ordering ───
+  // The most critical behavior: the first 3 messages must ALWAYS be
+  // SystemMessages in the order: global → project → session.
+  // This is the foundation of prompt cache validity.
+
+  it("builds prompt with static prefix in strict order: global, project, session", () => {
+    const builder = new CacheOptimizedPromptBuilder();
+    const state: ContextState = {
+      globalSystemInstructions: "You are a coding assistant.",
+      projectMemory: "Use TypeScript.",
+      sessionContext: "OS: Windows",
+      conversationHistory: [],
+    };
+
+    const messages = builder.buildPrompt(state);
+
+    // exactly 1 static message when history is empty
+    expect(messages).toHaveLength(1);
+
+    // must be system-type message
+    expect(messages[0]._getType()).toBe("system");
+
+    // Order must be: global → project → session
+    expect(messages[0].content).toContain("You are a coding assistant.");
+    expect(messages[0].content).toContain("Use TypeScript.");
+    expect(messages[0].content).toContain("OS: Windows");
+  });
+
+  // ─── Behavior 2: Conversation history appended AFTER the static prefix ───
+  // Dynamic messages must never appear before the static prefix.
+
+  it("appends conversation history after the static prefix", () => {
+    const builder = new CacheOptimizedPromptBuilder();
+    const state: ContextState = {
+      globalSystemInstructions: "System prompt.",
+      projectMemory: "Project rules.",
+      sessionContext: "Session info.",
+      conversationHistory: [
+        new HumanMessage("Hello"),
+        new AIMessage("Hi there!"),
+      ],
+    };
+
+    const messages = builder.buildPrompt(state);
+
+    // 1 static + 2 conversation = 3
+    expect(messages).toHaveLength(3);
+
+    // First is system messages (static prefix)
+    expect(messages[0]._getType()).toBe("system");
+
+    // Last 2 are conversation messages
+    expect(messages[1]._getType()).toBe("human");
+    expect(messages[2]._getType()).toBe("ai");
+    expect(messages[1].content).toBe("Hello");
+    expect(messages[2].content).toBe("Hi there!");
+  });
+
+  // ─── Behavior 3: Static prefix is identical across calls ───
+  // If we call buildPrompt twice with the same state (but more history),
+  // the first 3 messages must be byte-identical to preserve the cache.
+
+  it("produces identical static prefix across multiple calls with growing history", () => {
+    const builder = new CacheOptimizedPromptBuilder();
+    const state: ContextState = {
+      globalSystemInstructions: "Be helpful.",
+      projectMemory: "Use strict types.",
+      sessionContext: "Env: Node",
+      conversationHistory: [],
+    };
+
+    const firstCall = builder.buildPrompt(state);
+
+    // Simulate a conversation turn
+    state.conversationHistory.push(new HumanMessage("What is 2+2?"));
+    state.conversationHistory.push(new AIMessage("4"));
+
+    const secondCall = builder.buildPrompt(state);
+
+    // Static prefix (first message) must be identical
+    expect(secondCall[0].content).toBe(firstCall[0].content);
+  });
+
+  // ─── Behavior 4: System reminder is injected as a HumanMessage ───
+
+  it("injects a system reminder as a HumanMessage with <system-reminder> tags", () => {
+    const builder = new CacheOptimizedPromptBuilder();
+    const history = [new HumanMessage("Start task")];
+
+    const updated = builder.injectSystemReminder(
+      history,
+      "File auth.ts was deleted."
+    );
+
+    // Original history is not mutated
+    expect(history).toHaveLength(1);
+
+    // Updated history has the reminder appended
+    expect(updated).toHaveLength(2);
+    expect(updated[1]._getType()).toBe("human");
+    expect(updated[1].content).toContain("<system-reminder>");
+    expect(updated[1].content).toContain("File auth.ts was deleted.");
+    expect(updated[1].content).toContain("</system-reminder>");
+  });
+
+  // ─── Behavior 5: Compaction preserves recent messages with summary ───
+
+  it("compacts history into summary + preserved recent messages", () => {
+    const builder = new CacheOptimizedPromptBuilder();
+    const longHistory = [
+      new HumanMessage("Step 1"),
+      new AIMessage("Done 1"),
+      new HumanMessage("Step 2"),
+      new AIMessage("Done 2"),
+    ];
+
+    const compacted = builder.compactHistory(
+      longHistory,
+      "Completed steps 1 and 2."
+    );
+
+    // Default keepLastN=6, history has 4 → summary + all 4 preserved
+    expect(compacted).toHaveLength(5);
+    expect(compacted[0]._getType()).toBe("human");
+    expect(compacted[0].content).toContain("Completed steps 1 and 2.");
+    // Recent messages are preserved after the summary
+    expect(compacted[1].content).toBe("Step 1");
+  });
+});

package/src/__tests__/sandbox.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { SandboxManager } from "../sandbox/manager.js";
+
+// Mock the e2b SDK since we don't want real sandbox creation in tests
+vi.mock("e2b", () => {
+  const mockSandbox = {
+    sandboxId: "test-sandbox-123",
+    commands: {
+      run: vi.fn().mockResolvedValue({
+        stdout: "mock output",
+        stderr: "",
+        exitCode: 0,
+      }),
+    },
+    files: {
+      write: vi.fn().mockResolvedValue(undefined),
+      read: vi.fn().mockResolvedValue("file content"),
+      list: vi.fn().mockResolvedValue([]),
+    },
+    kill: vi.fn().mockResolvedValue(undefined),
+    isRunning: vi.fn().mockResolvedValue(true),
+    setTimeout: vi.fn().mockResolvedValue(undefined),
+  };
+
+  return {
+    Sandbox: {
+      create: vi.fn().mockResolvedValue(mockSandbox),
+    },
+  };
+});
+
+describe("SandboxManager", () => {
+  let manager: SandboxManager;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    manager = new SandboxManager({ apiKey: "test-e2b-key" });
+  });
+
+  afterEach(async () => {
+    // Ensure sandbox is cleaned up after each test
+    try {
+      await manager.destroy();
+    } catch {
+      // Already destroyed or never created
+    }
+  });
+
+  // ─── Test #15: SandboxManager.create() initializes a sandbox ───
+
+  it("creates a sandbox and returns the sandbox ID", async () => {
+    const sandboxId = await manager.create();
+
+    expect(sandboxId).toBe("test-sandbox-123");
+    expect(manager.isActive()).toBe(true);
+  });
+
+  // ─── Test #16: SandboxManager.destroy() cleans up the sandbox ───
+
+  it("destroys the sandbox and marks it as inactive", async () => {
+    await manager.create();
+    expect(manager.isActive()).toBe(true);
+
+    await manager.destroy();
+    expect(manager.isActive()).toBe(false);
+  });
+
+  // ─── Test #17: SandboxManager.exec() runs a command in the sandbox ───
+
+  it("executes a command in the sandbox and returns output", async () => {
+    await manager.create();
+
+    const result = await manager.exec("echo hello");
+
+    expect(result.stdout).toBe("mock output");
+    expect(result.exitCode).toBe(0);
+  });
+
+  // ─── Test #18: SandboxManager.exec() throws if sandbox not active ───
+
+  it("throws an error if exec is called before create", async () => {
+    await expect(manager.exec("echo hello")).rejects.toThrow(
+      /sandbox is not active/i
+    );
+  });
+
+  // ─── Test #19: SandboxManager.uploadFile() writes a file to the sandbox ───
+
+  it("uploads a file to the sandbox filesystem", async () => {
+    await manager.create();
+
+    await manager.uploadFile("/workspace/src/foo.ts", "const x = 1;");
+
+    // Verify the E2B files.write was called
+    const { Sandbox } = await import("e2b");
+    const mockSandbox = await Sandbox.create();
+    expect(mockSandbox.files.write).toHaveBeenCalledWith(
+      "/workspace/src/foo.ts",
+      "const x = 1;"
+    );
+  });
+});

package/src/__tests__/security.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  SecurityScanTool,
+  DepScanTool,
+  bindSecuritySandbox,
+} from "../tools/security.js";
+import { SandboxManager } from "../sandbox/manager.js";
+import { LazyInstaller } from "../sandbox/bootstrap.js";
+
+// Helpers
+const createMockSandbox = (active = true) => ({
+  exec: vi.fn(),
+  isActive: vi.fn().mockReturnValue(active),
+  create: vi.fn(),
+  destroy: vi.fn(),
+  uploadFile: vi.fn(),
+  getSandbox: vi.fn(),
+});
+
+describe("SecurityScanTool", () => {
+  let mockSandbox: ReturnType<typeof createMockSandbox>;
+  let installer: LazyInstaller;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockSandbox = createMockSandbox();
+    // Use custom template mode so ensureGeminiCli is instant
+    installer = new LazyInstaller(true);
+    bindSecuritySandbox(
+      mockSandbox as unknown as SandboxManager,
+      installer
+    );
+  });
+
+  // ─── Test #39: Runs security:analyze and returns report ───
+
+  it("runs gemini security:analyze and returns the report", async () => {
+    mockSandbox.exec.mockResolvedValueOnce({
+      exitCode: 0,
+      stdout: "## Security Report\n\nNo critical vulnerabilities found.",
+      stderr: "",
+    });
+
+    const result = await SecurityScanTool.execute({ target: "changes" });
+
+    expect(result.content).toContain("Security Report");
+    expect(mockSandbox.exec).toHaveBeenCalledWith(
+      expect.stringContaining("security:analyze")
+    );
+  });
+
+  // ─── Test #40: Returns error for file scan without path ───
+
+  it("returns error when target is 'file' but no path provided", async () => {
+    const result = await SecurityScanTool.execute({ target: "file" });
+
+    expect(result.content).toMatch(/path.*required/i);
+  });
+
+  // ─── Test #41: Handles failed scans gracefully ───
+
+  it("returns failure info when scan exits with non-zero code", async () => {
+    mockSandbox.exec.mockResolvedValueOnce({
+      exitCode: 1,
+      stdout: "",
+      stderr: "Some error occurred",
+    });
+
+    const result = await SecurityScanTool.execute({ target: "changes" });
+
+    expect(result.content).toContain("failed");
+    expect(result.content).toContain("Some error occurred");
+  });
+});
+
+describe("DepScanTool", () => {
+  let mockSandbox: ReturnType<typeof createMockSandbox>;
+  let installer: LazyInstaller;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockSandbox = createMockSandbox();
+    installer = new LazyInstaller(true); // pre-baked template
+    bindSecuritySandbox(
+      mockSandbox as unknown as SandboxManager,
+      installer
+    );
+  });
+
+  // ─── Test #42: OSV-Scanner returns vulnerability report ───
+
+  it("runs osv-scanner and returns the report", async () => {
+    mockSandbox.exec.mockResolvedValueOnce({
+      exitCode: 0,
+      stdout: "Found 2 vulnerabilities:\n- CVE-2024-1234\n- CVE-2024-5678",
+      stderr: "",
+    });
+
+    const result = await DepScanTool.execute({ format: "summary" });
+
+    expect(result.content).toContain("CVE-2024-1234");
+    expect(result.content).toContain("CVE-2024-5678");
+  });
+
+  // ─── Test #43: Falls back to npm audit when OSV-Scanner fails ───
+
+  it("falls back to npm audit if osv-scanner returns empty output", async () => {
+    // OSV-Scanner: empty output
+    mockSandbox.exec
+      .mockResolvedValueOnce({ exitCode: 1, stdout: "", stderr: "error" })
+      // npm audit fallback
+      .mockResolvedValueOnce({
+        exitCode: 0,
+        stdout: "found 0 vulnerabilities",
+        stderr: "",
+      });
+
+    const result = await DepScanTool.execute({ format: "summary" });
+
+    expect(result.content).toContain("0 vulnerabilities");
+  });
+});

package/src/__tests__/streaming.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect, vi } from "vitest";
+import { AIMessageChunk } from "@langchain/core/messages";
+import { ExecutionHarness } from "../core/agentLoop.js";
+import { ContextState } from "../core/promptBuilder.js";
+
+/**
+ * Creates a mock LLM that yields predefined chunks when .stream() is called.
+ * This avoids real API calls while testing streaming behavior.
+ */
+function createMockStreamingLlm(chunks: AIMessageChunk[]) {
+  return {
+    invoke: vi.fn(),
+    stream: vi.fn().mockResolvedValue({
+      async *[Symbol.asyncIterator]() {
+        for (const chunk of chunks) {
+          yield chunk;
+        }
+      },
+    }),
+  };
+}
+
+describe("ExecutionHarness Streaming", () => {
+  const baseState: ContextState = {
+    globalSystemInstructions: "You are a helpful assistant.",
+    projectMemory: "",
+    sessionContext: "",
+    conversationHistory: [],
+  };
+
+  // ─── RED Test #8: streamStep emits text chunks to a callback ───
+
+  it("emits text content chunks to an onToken callback", async () => {
+    const chunks = [
+      new AIMessageChunk({ content: "Hello" }),
+      new AIMessageChunk({ content: " world" }),
+      new AIMessageChunk({ content: "!" }),
+    ];
+    const mockLlm = createMockStreamingLlm(chunks);
+    const harness = new ExecutionHarness(mockLlm as any);
+
+    const receivedTokens: string[] = [];
+    const result = await harness.streamStep(baseState, {
+      onToken: (token: string) => receivedTokens.push(token),
+    });
+
+    // Callback should have received each text chunk
+    expect(receivedTokens).toEqual(["Hello", " world", "!"]);
+
+    // The returned message should contain the full concatenated content
+    expect(result.content).toBe("Hello world!");
+  });
+
+  // ─── RED Test #9: streamStep buffers tool calls and returns complete AIMessage ───
+
+  it("buffers tool call chunks and returns a complete AIMessage with tool_calls", async () => {
+    const chunks = [
+      new AIMessageChunk({
+        content: "",
+        tool_call_chunks: [
+          { name: "read_file", args: '{"path": "', index: 0, id: "tc_1", type: "tool_call_chunk" },
+        ],
+      }),
+      new AIMessageChunk({
+        content: "",
+        tool_call_chunks: [
+          { name: undefined, args: 'src/index.ts"}', index: 0, id: undefined, type: "tool_call_chunk" },
+        ],
+      }),
+    ];
+    const mockLlm = createMockStreamingLlm(chunks);
+    const harness = new ExecutionHarness(mockLlm as any);
+
+    const result = await harness.streamStep(baseState, {});
+
+    // The result should have tool_calls populated
+    expect(result.tool_calls).toBeDefined();
+    expect(result.tool_calls!.length).toBe(1);
+    expect(result.tool_calls![0].name).toBe("read_file");
+    expect(result.tool_calls![0].args).toEqual({ path: "src/index.ts" });
+  });
+});