@polderlabs/bizar 6.2.5 → 6.3.0

package/plugins/bizar/tests/fingerprint.test.ts

@@ -1,190 +0,0 @@
-/**
- * fingerprint.test.ts
- *
- * Tests for stable fingerprint computation per §5.1, §5.3.
- */
-
-import { describe, test, expect } from "bun:test";
-import { fingerprint } from "../src/fingerprint";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import os from "node:os";
-
-/** Use a real temp directory as the worktree for path normalization tests */
-const WORKTREE = path.join(os.tmpdir(), "bizar-fingerprint-test-worktree");
-const OUTSIDE_TREE = path.join(os.tmpdir(), "bizar-outside-worktree");
-
-function setupWorktree() {
-  try {
-    mkdirSync(WORKTREE, { recursive: true });
-    mkdirSync(OUTSIDE_TREE, { recursive: true });
-    // Create a file inside the worktree for path tests
-    writeFileSync(path.join(WORKTREE, "file.txt"), "x");
-  } catch {
-    // dir may already exist
-  }
-}
-
-function teardownWorktree() {
-  try { rmSync(WORKTREE, { recursive: true, force: true }); } catch { /* ok */ }
-  try { rmSync(OUTSIDE_TREE, { recursive: true, force: true }); } catch { /* ok */ }
-}
-
-setupWorktree();
-
-describe("fingerprint — stable hash", () => {
-  test("same args produce the same fingerprint", () => {
-      const args = { path: path.join(os.tmpdir(), "foo.ts"), recursive: false };
-    const a = fingerprint("read", args, WORKTREE);
-    const b = fingerprint("read", args, WORKTREE);
-    expect(a).toBe(b);
-  });
-
-  test("different tool name produces different fingerprint", () => {
-      const args = { path: path.join(os.tmpdir(), "foo.ts") };
-    const a = fingerprint("read", args, WORKTREE);
-    const b = fingerprint("edit", args, WORKTREE);
-    expect(a).not.toBe(b);
-  });
-
-  test("different args produce different fingerprint", () => {
-    const a = fingerprint("read", { path: path.join(os.tmpdir(), "foo.ts") }, WORKTREE);
-    const b = fingerprint("read", { path: path.join(os.tmpdir(), "bar.ts") }, WORKTREE);
-    expect(a).not.toBe(b);
-  });
-
-  test("empty args object produces stable hash", () => {
-    const a = fingerprint("read", {}, WORKTREE);
-    const b = fingerprint("read", {}, WORKTREE);
-    expect(a).toBe(b);
-    expect(a).toHaveLength(64); // sha256 hex
-  });
-});
-
-describe("fingerprint — path normalization", () => {
-  test("in-worktree absolute path becomes worktree-relative", () => {
-    const inWorktree = path.join(WORKTREE, "src", "index.ts");
-    const fp1 = fingerprint("read", { path: inWorktree }, WORKTREE);
-    const fp2 = fingerprint("read", { path: "src/index.ts" }, WORKTREE);
-    expect(fp1).toBe(fp2);
-  });
-
-  test("out-of-worktree absolute path becomes per-path stable hash (not global sentinel)", () => {
-    const outside = path.join(OUTSIDE_TREE, "secret.txt");
-    const fp1 = fingerprint("read", { path: outside }, WORKTREE);
-    const fp2 = fingerprint("read", { path: outside }, WORKTREE);
-    expect(fp1).toBe(fp2);
-    // Must NOT collide with a different outside path
-    const different = path.join(os.tmpdir(), "different/path/file.txt");
-    const fp3 = fingerprint("read", { path: different }, WORKTREE);
-    expect(fp1).not.toBe(fp3);
-  });
-
-  test("two distinct absolute paths outside worktree produce two distinct hashes", () => {
-    const pathA = path.join(OUTSIDE_TREE, "a.txt");
-    const pathB = path.join(OUTSIDE_TREE, "b.txt");
-    const fpA = fingerprint("read", { path: pathA }, WORKTREE);
-    const fpB = fingerprint("read", { path: pathB }, WORKTREE);
-    expect(fpA).not.toBe(fpB);
-  });
-});
-
-describe("fingerprint — noise field stripping", () => {
-  test("strips timestamp fields", () => {
-    const a = fingerprint("read", { path: path.join(os.tmpdir(), "foo.ts"), createdAt: 1234567890 }, WORKTREE);
-    const b = fingerprint("read", { path: path.join(os.tmpdir(), "foo.ts"), createdAt: 9999999999 }, WORKTREE);
-    expect(a).toBe(b);
-  });
-
-  test("strips updatedAt timestamp fields", () => {
-    const a = fingerprint("read", { path: path.join(os.tmpdir(), "foo.ts"), updatedAt: "2024-01-01T00:00:00Z" }, WORKTREE);
-    const b = fingerprint("read", { path: path.join(os.tmpdir(), "foo.ts"), updatedAt: "2025-12-31T23:59:59Z" }, WORKTREE);
-    expect(a).toBe(b);
-  });
-
-  test("strips id field", () => {
-    const a = fingerprint("read", { path: path.join(os.tmpdir(), "foo.ts"), id: "abc123" }, WORKTREE);
-    const b = fingerprint("read", { path: path.join(os.tmpdir(), "foo.ts"), id: "xyz789" }, WORKTREE);
-    expect(a).toBe(b);
-  });
-
-  test("strips uuid field", () => {
-    const a = fingerprint("read", { path: path.join(os.tmpdir(), "foo.ts"), uuid: "550e8400-e29b-41d4-a716-446655440000" }, WORKTREE);
-    const b = fingerprint("read", { path: path.join(os.tmpdir(), "foo.ts"), uuid: "6ba7b810-9dad-11d1-80b4-00c04fd430c8" }, WORKTREE);
-    expect(a).toBe(b);
-  });
-
-  test("strips nonce field", () => {
-    const a = fingerprint("read", { path: path.join(os.tmpdir(), "foo.ts"), nonce: "random1" }, WORKTREE);
-    const b = fingerprint("read", { path: path.join(os.tmpdir(), "foo.ts"), nonce: "random2" }, WORKTREE);
-    expect(a).toBe(b);
-  });
-
-  test("strips cwd field entirely", () => {
-    const a = fingerprint("read", { path: path.join(os.tmpdir(), "foo.ts"), cwd: "/home/user" }, WORKTREE);
-    const b = fingerprint("read", { path: path.join(os.tmpdir(), "foo.ts"), cwd: "/completely/different" }, WORKTREE);
-    expect(a).toBe(b);
-  });
-
-  // v6.2.4 — noise fields at ANY depth must be stripped. Previously
-  // the `cwd` field was only stripped at the top level, so a nested
-  // `cwd` like `{ options: { cwd: "/x" } }` would still differentiate
-  // the fingerprint and trigger the loop-guard false-positives.
-  test("v6.2.4 — strips cwd at nested depth", () => {
-    const a = fingerprint("bash", {
-      command: "ls -la",
-      options: { cwd: "/home/user", env: { PATH: "/usr/bin" } },
-    }, WORKTREE);
-    const b = fingerprint("bash", {
-      command: "ls -la",
-      options: { cwd: "/completely/different", env: { PATH: "/usr/bin" } },
-    }, WORKTREE);
-    expect(a).toBe(b, "nested cwd must be stripped to keep the fingerprint stable");
-  });
-
-  test("v6.2.4 — strips id at nested depth", () => {
-    const a = fingerprint("edit", { meta: { id: "uuid-1", author: "alice" } }, WORKTREE);
-    const b = fingerprint("edit", { meta: { id: "uuid-2", author: "alice" } }, WORKTREE);
-    expect(a).toBe(b);
-  });
-
-  test("v6.2.4 — strips timestamp at nested depth", () => {
-    const a = fingerprint("edit", { config: { created_at: 1000, author: "alice" } }, WORKTREE);
-    const b = fingerprint("edit", { config: { created_at: 9999, author: "alice" } }, WORKTREE);
-    expect(a).toBe(b);
-  });
-});
-
-describe("fingerprint — nested objects", () => {
-  test("nested objects are normalized recursively", () => {
-    const a = fingerprint("edit", {
-      meta: { author: "Alice", timestamp: 1000 },
-      path: path.join(os.tmpdir(), "foo.ts"),
-    }, WORKTREE);
-    const b = fingerprint("edit", {
-      path: path.join(os.tmpdir(), "foo.ts"),
-      meta: { timestamp: 9999, author: "Alice" },
-    }, WORKTREE);
-    expect(a).toBe(b);
-  });
-
-  test("deeply nested paths normalized correctly", () => {
-    const inWorktree = path.join(WORKTREE, "deeply", "nested", "file.ts");
-    const fp = fingerprint("read", {
-      config: {
-        files: [inWorktree],
-      },
-    }, WORKTREE);
-    const fpRelative = fingerprint("read", {
-      config: {
-        files: ["deeply/nested/file.ts"],
-      },
-    }, WORKTREE);
-    expect(fp).toBe(fpRelative);
-  });
-});
-
-// Run canonical key order tests in a separate file (canonical-key-order.test.ts)
-// to satisfy §12.1 which references the test by name.
-
-teardownWorktree();

package/plugins/bizar/tests/http-client.test.ts

@@ -1,404 +0,0 @@
-/**
- * HttpClient tests.
- *
- * Tests: createSession, sendPrompt, abortSession, listMessages,
- * fetchEventStream. All network calls are mocked.
- */
-
-import { describe, it, expect } from "bun:test";
-import os from "node:os";
-import path from "node:path";
-
-// ---------------------------------------------------------------------------
-// Types that mirror the expected HttpClient API from §1 / §2
-// ---------------------------------------------------------------------------
-
-interface SessionResponse {
-  id: string;
-  projectID: string;
-  directory: string;
-  parentID: string;
-  title: string;
-}
-
-interface MessagePart {
-  type: "text";
-  text: string;
-}
-
-interface MessageInfo {
-  role: "user" | "assistant";
-}
-
-interface Message {
-  info: MessageInfo;
-  parts: MessagePart[];
-}
-
-type CollectedMessage = Message;
-
-// ---------------------------------------------------------------------------
-// Fake HttpClient matching the expected interface
-// ---------------------------------------------------------------------------
-
-class FakeHttpClient {
-  private baseUrl: string;
-  private password: string;
-  private sessions = new Map<string, SessionResponse>();
-  private messages = new Map<string, Message[]>();
-  private aborted = new Set<string>();
-
-  constructor(baseUrl = "http://127.0.0.1:4096", password = "test-secret") {
-    this.baseUrl = baseUrl;
-    this.password = password;
-  }
-
-  get authHeader(): string {
-    return `Basic ${Buffer.from(`cline:${this.password}`).toString("base64")}`;
-  }
-
-  /** POST /session */
-  async createSession(params: {
-    parentID: string;
-    title: string;
-    agent: string;
-    directory: string;
-  }): Promise<SessionResponse> {
-    const id = `sess_${Date.now()}`;
-    const session: SessionResponse = {
-      id,
-      projectID: "proj_test",
-      directory: params.directory,
-      parentID: params.parentID,
-      title: params.title,
-    };
-    this.sessions.set(id, session);
-    this.messages.set(id, []);
-    return session;
-  }
-
-  /** POST /session/{id}/prompt_async */
-  async sendPrompt(params: {
-    sessionId: string;
-    messageID: string;
-    prompt: string;
-    agent: string;
-    model?: { providerID: string; modelID: string };
-    directory: string;
-  }): Promise<void> {
-    if (!this.sessions.has(params.sessionId)) {
-      throw new Error(`Session ${params.sessionId} not found`);
-    }
-    if (this.aborted.has(params.sessionId)) {
-      throw new Error("Session aborted");
-    }
-    // Store the prompt as a user message
-    const msgs = this.messages.get(params.sessionId)!;
-    msgs.push({
-      info: { role: "user" },
-      parts: [{ type: "text", text: params.prompt }],
-    });
-  }
-
-  /** POST /session/{id}/abort */
-  async abortSession(sessionId: string, directory: string): Promise<boolean> {
-    this.aborted.add(sessionId);
-    return true;
-  }
-
-  /** GET /session/{id}/message */
-  async listMessages(sessionId: string, directory: string): Promise<CollectedMessage[]> {
-    return this.messages.get(sessionId) ?? [];
-  }
-
-  /** Fetch SSE stream (not actually tested here — see event-stream.test.ts) */
-  async fetchEventStream(directory: string): Promise<ReadableStream> {
-    return new ReadableStream();
-  }
-}
-
-// ---------------------------------------------------------------------------
-// createSession
-// ---------------------------------------------------------------------------
-
-describe("HttpClient.createSession", () => {
-  it("returns a session with id, projectID, directory, parentID, title", async () => {
-    const client = new FakeHttpClient();
-    const session = await client.createSession({
-      parentID: "parent_sess",
-      title: "bgr:mimir:bgr_01",
-      agent: "mimir",
-      directory: path.join(os.tmpdir(), "worktree"),
-    });
-
-    expect(session.id).toBeTruthy();
-    expect(session.projectID).toBe("proj_test");
-    expect(session.directory).toBe(path.join(os.tmpdir(), "worktree"));
-    expect(session.parentID).toBe("parent_sess");
-    expect(session.title).toBe("bgr:mimir:bgr_01");
-  });
-
-  it("sends Authorization header with every request", () => {
-    const client = new FakeHttpClient("http://127.0.0.1:4096", "my-secret");
-    expect(client.authHeader).toContain("Basic");
-    expect(client.authHeader).toContain(Buffer.from("cline:my-secret").toString("base64"));
-  });
-
-  it("POST body includes agent field (HIGH-1 / NEW-H6)", async () => {
-    const client = new FakeHttpClient();
-    // The real impl verifies the body has agent field
-    const session = await client.createSession({
-      parentID: "p",
-      title: "t",
-      agent: "thor",
-      directory: "/tmp",
-    });
-    // Without the agent field, cline would spawn the default agent
-    // With the agent field, it spawns the requested one
-    expect(session).toBeDefined();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// sendPrompt
-// ---------------------------------------------------------------------------
-
-describe("HttpClient.sendPrompt", () => {
-  it("sends the prompt as parts=[{type:'text', text}] (HIGH-2)", async () => {
-    const client = new FakeHttpClient();
-    const session = await client.createSession({
-      parentID: "p",
-      title: "t",
-      agent: "mimir",
-      directory: "/tmp",
-    });
-
-    await client.sendPrompt({
-      sessionId: session.id,
-      messageID: "msg_test123",
-      prompt: "Do the research on X",
-      agent: "mimir",
-      directory: "/tmp",
-    });
-
-    const msgs = await client.listMessages(session.id, "/tmp");
-    const userMsg = msgs.find((m) => m.info.role === "user");
-    expect(userMsg).toBeDefined();
-    const firstPart = userMsg?.parts[0];
-    expect(firstPart).toBeDefined();
-    expect(firstPart?.type).toBe("text");
-    expect(firstPart?.text).toBe("Do the research on X");
-  });
-
-  it("generates a unique messageID per call (HIGH-2)", async () => {
-    const client = new FakeHttpClient();
-    const session = await client.createSession({
-      parentID: "p",
-      title: "t",
-      agent: "mimir",
-      directory: "/tmp",
-    });
-
-    const id1 = "msg_" + Date.now() + "_1";
-    const id2 = "msg_" + Date.now() + "_2";
-
-    await client.sendPrompt({
-      sessionId: session.id,
-      messageID: id1,
-      prompt: "First prompt",
-      agent: "mimir",
-      directory: "/tmp",
-    });
-
-    await client.sendPrompt({
-      sessionId: session.id,
-      messageID: id2,
-      prompt: "Second prompt",
-      agent: "mimir",
-      directory: "/tmp",
-    });
-
-    const msgs = await client.listMessages(session.id, "/tmp");
-    expect(msgs.length).toBe(2);
-  });
-
-  it("rejects with 403 on permission denial (MEDIUM-41)", async () => {
-    const client = new FakeHttpClient();
-    const session = await client.createSession({
-      parentID: "p",
-      title: "t",
-      agent: "mimir",
-      directory: "/tmp",
-    });
-
-    // Simulate 403 by aborting first
-    await client.abortSession(session.id, "/tmp");
-    try {
-      await client.sendPrompt({
-        sessionId: session.id,
-        messageID: "msg_test",
-        prompt: "Do something",
-        agent: "mimir",
-        directory: "/tmp",
-      });
-      expect("no error").toBe("threw");
-    } catch (e: unknown) {
-      expect((e as Error).message).toContain("aborted");
-    }
-  });
-
-  it("includes model in body when provided", async () => {
-    const client = new FakeHttpClient();
-    const session = await client.createSession({
-      parentID: "p",
-      title: "t",
-      agent: "mimir",
-      directory: "/tmp",
-    });
-
-    // Model parsing is done in bg-spawn.ts; HttpClient receives the parsed object
-    await client.sendPrompt({
-      sessionId: session.id,
-      messageID: "msg_model_test",
-      prompt: "Use a specific model",
-      agent: "mimir",
-      model: { providerID: "openrouter", modelID: "minimax-m3" },
-      directory: "/tmp",
-    });
-
-    const msgs = await client.listMessages(session.id, "/tmp");
-    expect(msgs.length).toBe(1);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// abortSession
-// ---------------------------------------------------------------------------
-
-describe("HttpClient.abortSession", () => {
-  it("calls POST /session/{id}/abort (HIGH-4)", async () => {
-    const client = new FakeHttpClient();
-    const session = await client.createSession({
-      parentID: "p",
-      title: "t",
-      agent: "mimir",
-      directory: "/tmp",
-    });
-
-    const result = await client.abortSession(session.id, "/tmp");
-    expect(result).toBe(true);
-  });
-
-  it("returns true for unknown session (no throw)", async () => {
-    const client = new FakeHttpClient();
-    const result = await client.abortSession("sess_unknown", "/tmp");
-    // Real impl would return false or throw; our fake just tracks it
-    expect(result).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// listMessages
-// ---------------------------------------------------------------------------
-
-describe("HttpClient.listMessages", () => {
-  it("returns all messages for a session", async () => {
-    const client = new FakeHttpClient();
-    const session = await client.createSession({
-      parentID: "p",
-      title: "t",
-      agent: "mimir",
-      directory: "/tmp",
-    });
-
-    await client.sendPrompt({
-      sessionId: session.id,
-      messageID: "msg_1",
-      prompt: "Hello",
-      agent: "mimir",
-      directory: "/tmp",
-    });
-
-    const msgs = await client.listMessages(session.id, "/tmp");
-    expect(msgs.length).toBe(1);
-  });
-
-  it("returns empty array for unknown session", async () => {
-    const client = new FakeHttpClient();
-    const msgs = await client.listMessages("sess_unknown", "/tmp");
-    expect(msgs).toEqual([]);
-  });
-
-  it("result is used by bizar_collect to reconstruct text (MEDIUM-19)", async () => {
-    const client = new FakeHttpClient();
-    const session = await client.createSession({
-      parentID: "p",
-      title: "t",
-      agent: "mimir",
-      directory: "/tmp",
-    });
-
-    // Simulate: session.messages returns array of {info, parts}
-    // Agent's response text is in TextPart.text fields of assistant messages
-    const msgs = await client.listMessages(session.id, "/tmp");
-    // Filter to assistant messages, extract TextPart.text, concatenate
-    const text = msgs
-      .filter((m) => m.info.role === "assistant")
-      .flatMap((m) => m.parts.filter((p: MessagePart) => p.type === "text"))
-      .map((p: MessagePart & { type: "text" }) => p.text)
-      .join("\n");
-
-    expect(text).toBe("");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// HttpClient interface contract
-// ---------------------------------------------------------------------------
-
-describe("HttpClient interface contract", () => {
-  it("has createSession, sendPrompt, abortSession, listMessages, fetchEventStream", () => {
-    const client = new FakeHttpClient();
-    expect(typeof client.createSession).toBe("function");
-    expect(typeof client.sendPrompt).toBe("function");
-    expect(typeof client.abortSession).toBe("function");
-    expect(typeof client.listMessages).toBe("function");
-    expect(typeof client.fetchEventStream).toBe("function");
-  });
-
-  it("all HTTP calls include Authorization: Basic header", () => {
-    const client = new FakeHttpClient("http://127.0.0.1:4096", "test123");
-    // Auth header is generated per call in real impl; verified here
-    expect(client.authHeader.startsWith("Basic ")).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Timeout tests (HIGH-36)
-// ---------------------------------------------------------------------------
-
-describe("HTTP timeout handling (HIGH-36)", () => {
-  it("AbortError on collect returns clear error to caller", async () => {
-    // Simulate network failure
-    class FailingHttpClient extends FakeHttpClient {
-      override async listMessages(_sessionId: string, _directory: string): Promise<never> {
-        throw new TypeError("fetch failed");
-      }
-    }
-
-    const client = new FailingHttpClient();
-    try {
-      await client.listMessages("sess_test", "/tmp");
-      expect("no throw").toBe("threw");
-    } catch (e: unknown) {
-      expect(e).toBeInstanceOf(TypeError);
-      expect((e as TypeError).message).toContain("fetch failed");
-    }
-  });
-
-  it("instance state on disk is unchanged on network failure", async () => {
-    // Network failure during collect does not modify BackgroundState on disk
-    // This is ensured by the implementation not writing on AbortError
-    expect(true).toBe(true);
-  });
-});