joonecli 0.1.1 → 0.2.1

package/tests/core/compactor.test.ts

@@ -1,217 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import {
-  ConversationCompactor,
-  COMPACT_SYSTEM_PROMPT,
-  createHandoffPrompt,
-  FAST_MODEL_DEFAULTS,
-  resolveFastModel,
-} from "../../src/core/compactor.js";
-import { HumanMessage, AIMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";
-import { CacheOptimizedPromptBuilder } from "../../src/core/promptBuilder.js";
-
-// ─── Mock LLM ───────────────────────────────────────────────────────────────────
-
-function createMockLLM(response: string = "## Summary\nMocked summary.") {
-  return {
-    invoke: vi.fn().mockResolvedValue(new AIMessage(response)),
-  };
-}
-
-function createFailingLLM() {
-  return {
-    invoke: vi.fn().mockRejectedValue(new Error("LLM call failed")),
-  };
-}
-
-// ─── Test History ───────────────────────────────────────────────────────────────
-
-function makeHistory(count: number) {
-  const msgs = [];
-  for (let i = 0; i < count; i++) {
-    if (i % 2 === 0) {
-      msgs.push(new HumanMessage(`User message ${i}`));
-    } else {
-      msgs.push(new AIMessage(`Agent response ${i}`));
-    }
-  }
-  return msgs;
-}
-
-// ─── FAST_MODEL_DEFAULTS ────────────────────────────────────────────────────────
-
-describe("FAST_MODEL_DEFAULTS", () => {
-  it("maps all major providers to fast models", () => {
-    expect(FAST_MODEL_DEFAULTS["anthropic"]).toBe("claude-3-haiku-20240307");
-    expect(FAST_MODEL_DEFAULTS["openai"]).toBe("gpt-4o-mini");
-    expect(FAST_MODEL_DEFAULTS["google"]).toBe("gemini-2.5-flash");
-    expect(FAST_MODEL_DEFAULTS["mistral"]).toBe("mistral-small-latest");
-    expect(FAST_MODEL_DEFAULTS["groq"]).toBe("mixtral-8x7b-32768");
-    expect(FAST_MODEL_DEFAULTS["deepseek"]).toBe("deepseek-chat");
-  });
-});
-
-describe("resolveFastModel", () => {
-  it("returns override when provided", () => {
-    expect(resolveFastModel("anthropic", "claude-sonnet-4", "my-custom-model")).toBe("my-custom-model");
-  });
-
-  it("returns provider default when no override", () => {
-    expect(resolveFastModel("anthropic", "claude-sonnet-4")).toBe("claude-3-haiku-20240307");
-  });
-
-  it("falls back to main model for unknown provider", () => {
-    expect(resolveFastModel("unknown-provider", "main-model")).toBe("main-model");
-  });
-});
-
-// ─── Compact Prompt ─────────────────────────────────────────────────────────────
-
-describe("COMPACT_SYSTEM_PROMPT", () => {
-  it("instructs preservation of file paths", () => {
-    expect(COMPACT_SYSTEM_PROMPT).toContain("File paths");
-  });
-
-  it("instructs preservation of tool calls", () => {
-    expect(COMPACT_SYSTEM_PROMPT).toContain("Tool calls");
-  });
-
-  it("instructs structured markdown format", () => {
-    expect(COMPACT_SYSTEM_PROMPT).toContain("structured markdown");
-  });
-});
-
-// ─── Handoff Prompt ─────────────────────────────────────────────────────────────
-
-describe("createHandoffPrompt", () => {
-  it("includes the timestamp", () => {
-    const prompt = createHandoffPrompt("2026-03-06T15:00:00Z");
-    expect(prompt).toContain("2026-03-06T15:00:00Z");
-  });
-
-  it("includes CONTEXT HANDOFF marker", () => {
-    const prompt = createHandoffPrompt("now");
-    expect(prompt).toContain("[CONTEXT HANDOFF]");
-  });
-
-  it("instructs not to redo work", () => {
-    const prompt = createHandoffPrompt("now");
-    expect(prompt).toContain("do NOT redo work");
-  });
-});
-
-// ─── ConversationCompactor ──────────────────────────────────────────────────────
-
-describe("ConversationCompactor", () => {
-  let compactor: ConversationCompactor;
-
-  beforeEach(() => {
-    compactor = new ConversationCompactor();
-  });
-
-  it("skips compaction when history is shorter than keepLastN", async () => {
-    const history = makeHistory(4);
-    const llm = createMockLLM();
-
-    const result = await compactor.compact(history, llm as any, { keepLastN: 8 });
-
-    expect(result.evictedCount).toBe(0);
-    expect(result.compactedHistory).toEqual(history);
-    expect(result.llmUsed).toBe(false);
-    expect(llm.invoke).not.toHaveBeenCalled();
-  });
-
-  it("compacts with LLM and preserves recent messages", async () => {
-    const history = makeHistory(20);
-    const llm = createMockLLM("## Files Modified\n- test.ts\n## Current State\nIn progress.");
-
-    const result = await compactor.compact(history, llm as any, { keepLastN: 8 });
-
-    expect(result.evictedCount).toBe(12);
-    expect(result.llmUsed).toBe(true);
-    expect(llm.invoke).toHaveBeenCalledTimes(1);
-
-    // Should have: summary + handoff + 8 recent messages = 10 total
-    expect(result.compactedHistory.length).toBe(10);
-
-    // First message should be the compacted summary
-    const summaryMsg = result.compactedHistory[0];
-    expect(summaryMsg._getType()).toBe("human");
-    expect(typeof summaryMsg.content === "string" && summaryMsg.content).toContain("COMPACTED CONVERSATION SUMMARY");
-
-    // Second message should be the handoff
-    const handoffMsg = result.compactedHistory[1];
-    expect(handoffMsg._getType()).toBe("human");
-    expect(typeof handoffMsg.content === "string" && handoffMsg.content).toContain("CONTEXT HANDOFF");
-
-    // Remaining should be the last 8 messages from original history
-    const recent = result.compactedHistory.slice(2);
-    expect(recent).toEqual(history.slice(-8));
-  });
-
-  it("invokes LLM with compact prompt and evicted messages", async () => {
-    const history = makeHistory(12);
-    const llm = createMockLLM();
-
-    await compactor.compact(history, llm as any, { keepLastN: 4 });
-
-    const invokeCall = llm.invoke.mock.calls[0][0];
-    expect(invokeCall.length).toBe(2); // System + Human
-
-    const systemMsg = invokeCall[0];
-    const humanMsg = invokeCall[1];
-
-    // System msg should contain compact prompt
-    expect(typeof systemMsg.content === "string" && systemMsg.content).toContain("conversation summarizer");
-
-    // Human msg should contain evicted messages in readable format
-    expect(typeof humanMsg.content === "string" && humanMsg.content).toContain("User message 0");
-  });
-
-  it("falls back to string-based compaction when LLM fails", async () => {
-    const history = makeHistory(20);
-    const llm = createFailingLLM();
-
-    const result = await compactor.compact(history, llm as any, { keepLastN: 8 });
-
-    expect(result.evictedCount).toBe(12);
-    expect(result.llmUsed).toBe(false);
-
-    // Should still have summary + handoff + 8 recent = 10 messages
-    expect(result.compactedHistory.length).toBe(10);
-
-    // Summary should mention fallback
-    const summaryMsg = result.compactedHistory[0];
-    // We didn't change what the text content says, just that it's a HumanMessage now
-    expect(summaryMsg._getType()).toBe("human");
-    expect(typeof summaryMsg.content === "string" && summaryMsg.content).toContain("Fallback Compaction");
-  });
-
-  it("handles token reduction properly", async () => {
-    // Use a large history to ensure meaningful token reduction
-    const history = makeHistory(40);
-    const llm = createMockLLM("Short summary.");
-
-    const result = await compactor.compact(history, llm as any, { keepLastN: 8 });
-
-    // The compacted history (summary + handoff + 8 recent) should use fewer tokens
-    // than the original 40 messages
-    expect(result.tokensAfter).toBeLessThan(result.tokensBefore);
-    expect(result.evictedCount).toBe(32);
-  });
-});
-
-// ─── Integration with PromptBuilder ─────────────────────────────────────────────
-
-describe("CacheOptimizedPromptBuilder.compactHistoryWithLLM", () => {
-  it("delegates to ConversationCompactor", async () => {
-    const builder = new CacheOptimizedPromptBuilder();
-    const history = makeHistory(20);
-    const llm = createMockLLM();
-
-    const result = await builder.compactHistoryWithLLM(history, llm as any, 8);
-
-    expect(result.evictedCount).toBe(12);
-    expect(result.llmUsed).toBe(true);
-    expect(result.compactedHistory.length).toBe(10);
-  });
-});

package/tests/core/retryAndErrors.test.ts

@@ -1,164 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { retryWithBackoff } from "../../src/core/retry.js";
-import { JooneError, LLMApiError, ToolExecutionError, SandboxError, wrapLLMError } from "../../src/core/errors.js";
-
-// ─── retryWithBackoff ─────────────────────────────────────────────────────────
-
-describe("retryWithBackoff", () => {
-    it("should return immediately on success", async () => {
-        const result = await retryWithBackoff(async () => "ok");
-        expect(result).toBe("ok");
-    });
-
-    it("should retry retryable JooneErrors up to maxRetries", async () => {
-        let attempts = 0;
-        const fn = async () => {
-            attempts++;
-            if (attempts < 3) {
-                throw new JooneError("transient", { category: "network", retryable: true });
-            }
-            return "recovered";
-        };
-
-        const result = await retryWithBackoff(fn, { maxRetries: 3, initialDelayMs: 10, maxJitterMs: 5 });
-        expect(result).toBe("recovered");
-        expect(attempts).toBe(3);
-    });
-
-    it("should throw immediately on non-retryable JooneError", async () => {
-        const fn = async () => {
-            throw new JooneError("auth failure", { category: "config", retryable: false });
-        };
-
-        await expect(retryWithBackoff(fn, { maxRetries: 3, initialDelayMs: 10 }))
-            .rejects.toThrow("auth failure");
-    });
-
-    it("should throw immediately on raw non-JooneError", async () => {
-        const fn = async () => {
-            throw new Error("random crash");
-        };
-
-        await expect(retryWithBackoff(fn, { maxRetries: 3, initialDelayMs: 10 }))
-            .rejects.toThrow("random crash");
-    });
-
-    it("should call onRetry callback before each retry", async () => {
-        const retries: number[] = [];
-        let attempts = 0;
-
-        const fn = async () => {
-            attempts++;
-            if (attempts <= 2) {
-                throw new JooneError("transient", { category: "network", retryable: true });
-            }
-            return "ok";
-        };
-
-        await retryWithBackoff(fn, {
-            maxRetries: 3,
-            initialDelayMs: 10,
-            maxJitterMs: 0,
-            onRetry: (attempt) => retries.push(attempt),
-        });
-
-        expect(retries).toEqual([1, 2]);
-    });
-
-    it("should throw the last error after all retries exhausted", async () => {
-        const fn = async () => {
-            throw new JooneError("always fails", { category: "llm_api", retryable: true });
-        };
-
-        await expect(retryWithBackoff(fn, { maxRetries: 2, initialDelayMs: 10, maxJitterMs: 0 }))
-            .rejects.toThrow("always fails");
-    });
-});
-
-// ─── JooneError hierarchy ────────────────────────────────────────────────────
-
-describe("JooneError hierarchy", () => {
-    it("LLMApiError produces a rate-limit recovery hint for 429", () => {
-        const err = new LLMApiError("Too Many Requests", {
-            statusCode: 429,
-            provider: "anthropic",
-            retryable: true,
-            headers: { "retry-after": "30" },
-        });
-
-        expect(err.retryable).toBe(true);
-        expect(err.category).toBe("llm_api");
-        expect(err.toRecoveryHint()).toContain("RATE LIMITED");
-        expect(err.toRecoveryHint()).toContain("30 seconds");
-    });
-
-    it("LLMApiError produces a fatal hint for 401", () => {
-        const err = new LLMApiError("Unauthorized", {
-            statusCode: 401,
-            provider: "openai",
-            retryable: false,
-        });
-
-        expect(err.retryable).toBe(false);
-        expect(err.toRecoveryHint()).toContain("AUTH FAILURE");
-    });
-
-    it("ToolExecutionError wraps tool metadata", () => {
-        const err = new ToolExecutionError("file not found", {
-            toolName: "read_file",
-            args: { path: "/foo.txt" },
-            retryable: false,
-        });
-
-        expect(err.toolName).toBe("read_file");
-        expect(err.toRecoveryHint()).toContain('read_file');
-        expect(err.toRecoveryHint()).toContain("file not found");
-    });
-
-    it("SandboxError produces a sandbox-specific hint", () => {
-        const err = new SandboxError("container died", {
-            sandboxProvider: "e2b",
-            retryable: true,
-        });
-
-        expect(err.retryable).toBe(true);
-        expect(err.toRecoveryHint()).toContain("e2b sandbox");
-    });
-});
-
-// ─── wrapLLMError ─────────────────────────────────────────────────────────────
-
-describe("wrapLLMError", () => {
-    it("marks 429 as retryable", () => {
-        const raw = Object.assign(new Error("rate limited"), { status: 429 });
-        const wrapped = wrapLLMError(raw, "anthropic");
-
-        expect(wrapped).toBeInstanceOf(LLMApiError);
-        expect(wrapped.retryable).toBe(true);
-        expect(wrapped.statusCode).toBe(429);
-    });
-
-    it("marks 401 as non-retryable", () => {
-        const raw = Object.assign(new Error("bad key"), { status: 401 });
-        const wrapped = wrapLLMError(raw, "openai");
-
-        expect(wrapped.retryable).toBe(false);
-    });
-
-    it("marks ECONNRESET as retryable", () => {
-        const raw = Object.assign(new Error("connection reset"), { code: "ECONNRESET" });
-        const wrapped = wrapLLMError(raw, "google");
-
-        expect(wrapped.retryable).toBe(true);
-    });
-
-    it("passes through an existing LLMApiError unchanged", () => {
-        const original = new LLMApiError("already wrapped", {
-            statusCode: 500,
-            provider: "test",
-            retryable: true,
-        });
-        const result = wrapLLMError(original, "ignored");
-        expect(result).toBe(original);
-    });
-});

package/tests/core/sessionResumer.test.ts

@@ -1,95 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { SessionResumer } from "../../src/core/sessionResumer.js";
-import { AIMessage, HumanMessage, ToolMessage, SystemMessage } from "@langchain/core/messages";
-import { ContextState } from "../../src/core/promptBuilder.js";
-import { SessionStatePayload } from "../../src/core/sessionStore.js";
-import * as fs from "node:fs";
-
-// Mock the Node FS module so we can simulate mtime drifts
-vi.mock("node:fs", async (importOriginal) => {
-    const actual = await importOriginal<typeof import("node:fs")>();
-    return {
-        ...actual,
-        existsSync: vi.fn(),
-        statSync: vi.fn(),
-    };
-});
-
-describe("SessionResumer", () => {
-    const resumer = new SessionResumer("/mock/workspace");
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-
-    it("should detect drift on files where mtime > lastSavedAt", () => {
-        const state: ContextState = {
-            globalSystemInstructions: "",
-            projectMemory: "",
-            sessionContext: "",
-            conversationHistory: [
-                new AIMessage({
-                    content: "Let me modify file_a.ts and read file_b.ts",
-                    tool_calls: [
-                        { id: "1", name: "write_file", args: { path: "file_a.ts", content: "..." }, type: "tool_call" },
-                        { id: "2", name: "read_file", args: { path: "file_b.ts" }, type: "tool_call" },
-                        { id: "3", name: "bash", args: { command: "ls" }, type: "tool_call" } // Not a file target
-                    ]
-                })
-            ]
-        };
-
-        const lastSavedAt = 1000;
-        
-        vi.mocked(fs.existsSync).mockReturnValue(true);
-        vi.mocked(fs.statSync).mockImplementation((pathStr) => {
-            if (pathStr.toString().includes("file_a.ts")) {
-                return { mtimeMs: 2000 } as fs.Stats; // Drifted!
-            }
-            if (pathStr.toString().includes("file_b.ts")) {
-                return { mtimeMs: 500 } as fs.Stats; // Safe
-            }
-            return { mtimeMs: 0 } as fs.Stats;
-        });
-
-        const driftedFiles = resumer.detectFileDrift(state, lastSavedAt);
-        expect(driftedFiles).toContain("file_a.ts");
-        expect(driftedFiles).not.toContain("file_b.ts");
-        expect(driftedFiles.length).toBe(1);
-    });
-
-    it("should inject the wakeup prompt into the state", () => {
-        const payload: SessionStatePayload = {
-            header: {
-                sessionId: "123",
-                startedAt: 0,
-                lastSavedAt: 1000,
-                provider: "test",
-                model: "test",
-                description: ""
-            },
-            state: {
-                globalSystemInstructions: "sys",
-                projectMemory: "mem",
-                sessionContext: "ctx",
-                conversationHistory: [new HumanMessage("hello")]
-            }
-        };
-
-        vi.mocked(fs.existsSync).mockReturnValue(false); // Simulate no drifted files
-        
-        const resumedState = resumer.prepareForResume(payload);
-        
-        const lastMsg = resumedState.conversationHistory[resumedState.conversationHistory.length - 1];
-        expect(lastMsg).toBeInstanceOf(HumanMessage);
-        
-        const content = textContent(lastMsg.content);
-        expect(content).toContain("[SYSTEM NOTIFICATION: SESSION RESUMED]");
-        expect(content).toContain("No files in your active context appear to have been edited");
-    });
-
-    function textContent(c: string | any[]): string {
-        if (typeof c === "string") return c;
-        return c.map(part => part.text).join("");
-    }
-});

package/tests/core/sessionStore.test.ts

@@ -1,84 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { SessionStore } from "../../src/core/sessionStore.js";
-import { HumanMessage, AIMessage, ToolMessage, SystemMessage } from "@langchain/core/messages";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-
-const SESSIONS_DIR = path.join(os.homedir(), ".joone", "sessions");
-
-describe("SessionStore", () => {
-    let store: SessionStore;
-    const testSessionId = `test-session-${Date.now()}`;
-    const testFilePath = path.join(SESSIONS_DIR, `${testSessionId}.jsonl`);
-
-    beforeEach(() => {
-        store = new SessionStore();
-    });
-
-    afterEach(() => {
-        if (fs.existsSync(testFilePath)) {
-            fs.unlinkSync(testFilePath);
-        }
-    });
-
-    it("should serialize and deserialize a complex conversation history perfectly", async () => {
-        const initialState = {
-            globalSystemInstructions: "You are a test agent.",
-            projectMemory: "Project X",
-            sessionContext: "Windows 11",
-            conversationHistory: [
-                new SystemMessage("Injected dynamic system rules."),
-                new HumanMessage("Hello agent!"),
-                new AIMessage({
-                    content: "Let me use a tool.",
-                    tool_calls: [{ id: "call_abc123", name: "bash", args: { command: "ls" }, type: "tool_call" }]
-                }),
-                new ToolMessage({
-                    tool_call_id: "call_abc123",
-                    content: "file1.txt\nfile2.txt"
-                })
-            ]
-        };
-
-        // 1. Save it
-        await store.saveSession(testSessionId, initialState, "anthropic", "claude-3-opus");
-
-        // Verify file exists
-        expect(fs.existsSync(testFilePath)).toBe(true);
-
-        // 2. Load it back
-        const loaded = await store.loadSession(testSessionId);
-
-        // Verify Header & Metadata
-        expect(loaded.header.sessionId).toBe(testSessionId);
-        expect(loaded.header.provider).toBe("anthropic");
-        expect(loaded.header.model).toBe("claude-3-opus");
-        expect(loaded.header.description).toBe("Hello agent!...");
-        
-        // Verify State Primitives
-        expect(loaded.state.globalSystemInstructions).toBe("You are a test agent.");
-        expect(loaded.state.projectMemory).toBe("Project X");
-        expect(loaded.state.sessionContext).toBe("Windows 11");
-
-        // Verify LangChain Objects Extracted correctly
-        const history = loaded.state.conversationHistory;
-        expect(history.length).toBe(4);
-        
-        expect(history[0]).toBeInstanceOf(HumanMessage);
-        expect(history[0].content).toBe("<system-reminder>\nInjected dynamic system rules.\n</system-reminder>");
-        
-        expect(history[1]).toBeInstanceOf(HumanMessage);
-        expect(history[1].content).toBe("Hello agent!");
-        
-        expect(history[2]).toBeInstanceOf(AIMessage);
-        const aiMsg = history[2] as AIMessage;
-        expect(aiMsg.content).toBe("Let me use a tool.");
-        expect(aiMsg.tool_calls![0].id).toBe("call_abc123");
-        expect(aiMsg.tool_calls![0].name).toBe("bash");
-        
-        expect(history[3]).toBeInstanceOf(ToolMessage);
-        expect((history[3] as ToolMessage).tool_call_id).toBe("call_abc123");
-        expect(history[3].content).toBe("file1.txt\nfile2.txt");
-    });
-});