joonecli 0.1.1 → 0.2.1

package/src/__tests__/middleware.test.ts

@@ -1,219 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { MiddlewarePipeline } from "../middleware/pipeline.js";
-import { ToolCallContext, ToolMiddleware } from "../middleware/types.js";
-import { LoopDetectionMiddleware } from "../middleware/loopDetection.js";
-import { CommandSanitizerMiddleware } from "../middleware/commandSanitizer.js";
-import { PreCompletionMiddleware } from "../middleware/preCompletion.js";
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// Pipeline Core
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("MiddlewarePipeline", () => {
-  const makeCtx = (overrides?: Partial<ToolCallContext>): ToolCallContext => ({
-    toolName: "bash",
-    args: { command: "echo hello" },
-    callId: "call-1",
-    ...overrides,
-  });
-
-  // ─── Test #44: Runs before/after hooks in order ───
-
-  it("runs before hooks in registration order and after hooks in reverse", async () => {
-    const order: string[] = [];
-
-    const pipeline = new MiddlewarePipeline();
-    pipeline.use({
-      name: "A",
-      before: (ctx) => { order.push("A:before"); return ctx; },
-      after: (_ctx, r) => { order.push("A:after"); return r; },
-    });
-    pipeline.use({
-      name: "B",
-      before: (ctx) => { order.push("B:before"); return ctx; },
-      after: (_ctx, r) => { order.push("B:after"); return r; },
-    });
-
-    const executeFn = vi.fn(async () => ({ content: "result" }));
-    await pipeline.run(makeCtx(), executeFn);
-
-    expect(order).toEqual(["A:before", "B:before", "B:after", "A:after"]);
-    expect(executeFn).toHaveBeenCalledOnce();
-  });
-
-  // ─── Test #45: Short-circuits when before returns string ───
-
-  it("short-circuits and does NOT execute the tool when before returns a string", async () => {
-    const pipeline = new MiddlewarePipeline();
-    pipeline.use({
-      name: "Blocker",
-      before: () => "⚠ Blocked!",
-    });
-
-    const executeFn = vi.fn(async () => ({ content: "should not reach this" }));
-    const result = await pipeline.run(makeCtx(), executeFn);
-
-    expect(result).toBe("⚠ Blocked!");
-    expect(executeFn).not.toHaveBeenCalled();
-  });
-
-  // ─── Test #46: After hooks can transform the result ───
-
-  it("after hooks can transform the tool result", async () => {
-    const pipeline = new MiddlewarePipeline();
-    pipeline.use({
-      name: "Uppercaser",
-      after: (_ctx, result) => { result.content = result.content.toUpperCase(); return result; },
-    });
-
-    const result = await pipeline.run(makeCtx(), async () => ({ content: "hello" }));
-
-    expect(result).toBe("HELLO");
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// LoopDetectionMiddleware
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("LoopDetectionMiddleware", () => {
-  const makeCtx = (cmd = "echo hello"): ToolCallContext => ({
-    toolName: "bash",
-    args: { command: cmd },
-    callId: "call-x",
-  });
-
-  // ─── Test #47: Allows first 2 identical calls ───
-
-  it("allows calls below the threshold", () => {
-    const mw = new LoopDetectionMiddleware(3);
-
-    expect(mw.before(makeCtx())).toEqual(makeCtx());
-    expect(mw.before(makeCtx())).toEqual(makeCtx());
-  });
-
-  // ─── Test #48: Blocks on 3rd identical call ───
-
-  it("blocks on the Nth identical consecutive call", () => {
-    const mw = new LoopDetectionMiddleware(3);
-
-    mw.before(makeCtx());
-    mw.before(makeCtx());
-    const result = mw.before(makeCtx());
-
-    expect(typeof result).toBe("string");
-    expect(result as string).toMatch(/loop detected/i);
-  });
-
-  // ─── Test #49: Resets when args change ───
-
-  it("resets the count when a different call is made", () => {
-    const mw = new LoopDetectionMiddleware(3);
-
-    mw.before(makeCtx("echo a"));
-    mw.before(makeCtx("echo a"));
-    // Different call breaks the streak
-    mw.before(makeCtx("echo b"));
-    // Back to "echo a" — only 1 in a row now
-    const result = mw.before(makeCtx("echo a"));
-
-    expect(typeof result).not.toBe("string");
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// CommandSanitizerMiddleware
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("CommandSanitizerMiddleware", () => {
-  const mw = new CommandSanitizerMiddleware();
-
-  const makeCtx = (cmd: string): ToolCallContext => ({
-    toolName: "bash",
-    args: { command: cmd },
-    callId: "call-x",
-  });
-
-  // ─── Test #50: Blocks rm -rf / ───
-
-  it("blocks rm -rf /", () => {
-    const result = mw.before(makeCtx("rm -rf /"));
-    expect(typeof result).toBe("string");
-    expect(result as string).toMatch(/blocked/i);
-  });
-
-  // ─── Test #51: Blocks interactive commands ───
-
-  it("blocks interactive commands like vim", () => {
-    const result = mw.before(makeCtx("vim src/index.ts"));
-    expect(typeof result).toBe("string");
-    expect(result as string).toMatch(/interactive/i);
-  });
-
-  // ─── Test #52: Allows safe commands ───
-
-  it("allows safe commands through", () => {
-    const result = mw.before(makeCtx("npm test"));
-    expect(result).toEqual(makeCtx("npm test"));
-  });
-
-  // ─── Test #53: Ignores non-bash tools ───
-
-  it("ignores non-bash tool calls entirely", () => {
-    const ctx: ToolCallContext = {
-      toolName: "read_file",
-      args: { path: "/etc/passwd" },
-      callId: "call-x",
-    };
-    expect(mw.before(ctx)).toEqual(ctx);
-  });
-});
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// PreCompletionMiddleware
-// ═══════════════════════════════════════════════════════════════════════════════
-
-describe("PreCompletionMiddleware", () => {
-  // ─── Test #54: Blocks completion without tests ───
-
-  it("blocks task_complete when no tests have been run", () => {
-    const mw = new PreCompletionMiddleware();
-
-    const ctx: ToolCallContext = {
-      toolName: "task_complete",
-      args: {},
-      callId: "call-x",
-    };
-    const result = mw.before(ctx);
-
-    expect(typeof result).toBe("string");
-    expect(result as string).toMatch(/must run tests/i);
-  });
-
-  // ─── Test #55: Allows completion after tests ───
-
-  it("allows task_complete after a test command has been run", () => {
-    const mw = new PreCompletionMiddleware();
-
-    // Simulate running tests
-    const testCtx: ToolCallContext = {
-      toolName: "bash",
-      args: { command: "npm test" },
-      callId: "call-1",
-    };
-    mw.before(testCtx);
-    mw.after(testCtx, { content: "tests passed", metadata: { exitCode: 0 }, isError: false });
-
-    expect(mw.hasPassedTests()).toBe(true);
-
-    // Now try completion
-    const completeCtx: ToolCallContext = {
-      toolName: "task_complete",
-      args: {},
-      callId: "call-2",
-    };
-    const result = mw.before(completeCtx);
-
-    expect(result).toEqual(completeCtx);
-  });
-});

package/src/__tests__/modelFactory.test.ts

@@ -1,63 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { JooneConfig, DEFAULT_CONFIG } from "../cli/config.js";
-import { createModel } from "../cli/modelFactory.js";
-
-describe("Model Factory", () => {
-  // ─── RED Test #4: createModel returns a ChatAnthropic for "anthropic" ───
-
-  it("creates an Anthropic model when provider is 'anthropic'", async () => {
-    const config: JooneConfig = {
-      ...DEFAULT_CONFIG,
-      provider: "anthropic",
-      model: "claude-sonnet-4-20250514",
-      apiKey: "sk-ant-test-key",
-    };
-
-    const model = await createModel(config);
-
-    // The model should have the correct type identifier
-    expect(model).toBeDefined();
-    expect(model.constructor.name).toContain("ChatAnthropic");
-  }, 15000);
-
-  // ─── RED Test #5: createModel returns a ChatOpenAI for "openai" ───
-
-  it("creates an OpenAI model when provider is 'openai'", async () => {
-    const config: JooneConfig = {
-      ...DEFAULT_CONFIG,
-      provider: "openai",
-      model: "gpt-4o",
-      apiKey: "sk-openai-test-key",
-    };
-
-    const model = await createModel(config);
-
-    expect(model).toBeDefined();
-    expect(model.constructor.name).toContain("ChatOpenAI");
-  }, 15000);
-
-  // ─── RED Test #6: createModel throws if API key is missing ───
-
-  it("throws a descriptive error when API key is missing for a cloud provider", async () => {
-    const config: JooneConfig = {
-      ...DEFAULT_CONFIG,
-      provider: "anthropic",
-      model: "claude-sonnet-4-20250514",
-      apiKey: undefined,
-    };
-
-    await expect(createModel(config)).rejects.toThrow(/API key/i);
-  });
-
-  // ─── RED Test #7: createModel throws with install command for missing package ───
-
-  it("throws an error with install instructions for unsupported/missing provider", async () => {
-    const config: JooneConfig = {
-      ...DEFAULT_CONFIG,
-      provider: "unknown-provider",
-      apiKey: "some-key",
-    };
-
-    await expect(createModel(config)).rejects.toThrow(/unsupported provider/i);
-  });
-});

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");
-  });
-});