joonecli 0.1.0 → 0.2.0

package/src/__tests__/optimizations.test.ts

@@ -1,201 +0,0 @@
-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

@@ -1,141 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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" });
-  });
-});