@usezombie/zombiectl 0.3.0

package/test/spec-init.unit.test.js

@@ -0,0 +1,160 @@
+import { describe, test, expect } from "bun:test";
+import { parseMakeTargets, detectTestPatterns, detectProjectStructure, generateTemplate } from "../src/commands/spec_init.js";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import os from "node:os";
+
+// ── parseMakeTargets ──────────────────────────────────────────────────────────
+
+describe("parseMakeTargets", () => {
+  let tmpDir;
+
+  function setup(makefileContent) {
+    tmpDir = mkdirSync(join(os.tmpdir(), `spec-init-test-${Date.now()}`), { recursive: true }) || join(os.tmpdir(), `spec-init-test-${Date.now()}`);
+    // mkdirSync returns undefined on success for existing dirs; use a unique path
+    tmpDir = join(os.tmpdir(), `spec-init-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tmpDir, { recursive: true });
+    if (makefileContent !== null) writeFileSync(join(tmpDir, "Makefile"), makefileContent);
+    return tmpDir;
+  }
+
+  function cleanup() {
+    try { rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  }
+
+  test("returns empty array when no Makefile", () => {
+    setup(null);
+    try {
+      expect(parseMakeTargets(tmpDir)).toEqual([]);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("parses standard make targets", () => {
+    setup("lint:\n\techo lint\n\ntest:\n\techo test\n\nbuild:\n\techo build\n");
+    try {
+      const targets = parseMakeTargets(tmpDir);
+      expect(targets).toContain("lint");
+      expect(targets).toContain("test");
+      expect(targets).toContain("build");
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("ignores hidden/special targets starting with dot", () => {
+    setup(".PHONY: lint\nlint:\n\techo lint\n");
+    try {
+      const targets = parseMakeTargets(tmpDir);
+      expect(targets).not.toContain(".PHONY");
+      expect(targets).toContain("lint");
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("parses targets with hyphens and underscores", () => {
+    setup("lint-zig:\n\tzig fmt\ntest_unit:\n\tbun test\n");
+    try {
+      const targets = parseMakeTargets(tmpDir);
+      expect(targets).toContain("lint-zig");
+      expect(targets).toContain("test_unit");
+    } finally {
+      cleanup();
+    }
+  });
+});
+
+// ── detectTestPatterns ────────────────────────────────────────────────────────
+
+describe("detectTestPatterns", () => {
+  test("returns empty for no test files", () => {
+    expect(detectTestPatterns(["src/main.go", "src/server.go"])).toEqual([]);
+  });
+
+  test("detects tests/ directory", () => {
+    const patterns = detectTestPatterns(["tests/foo_test.go"]);
+    expect(patterns).toContain("tests/ directory");
+  });
+
+  test("detects *.test.* pattern", () => {
+    const patterns = detectTestPatterns(["src/foo.test.js"]);
+    expect(patterns.some((p) => p.includes("test"))).toBe(true);
+  });
+
+  test("detects *_test.* pattern (Go)", () => {
+    const patterns = detectTestPatterns(["src/server_test.go"]);
+    expect(patterns).toContain("*_test.*");
+  });
+
+  test("deduplicates patterns", () => {
+    const files = ["a.test.js", "b.test.js", "c.test.ts"];
+    const patterns = detectTestPatterns(files);
+    const counts = patterns.filter((p) => p.includes("test")).length;
+    expect(counts).toBeLessThanOrEqual(2);
+  });
+});
+
+// ── detectProjectStructure ────────────────────────────────────────────────────
+
+describe("detectProjectStructure", () => {
+  let tmpDir;
+
+  function setup(dirs) {
+    tmpDir = join(os.tmpdir(), `spec-proj-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tmpDir, { recursive: true });
+    for (const d of dirs) mkdirSync(join(tmpDir, d), { recursive: true });
+    return tmpDir;
+  }
+
+  function cleanup() {
+    try { rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  }
+
+  test("returns empty for bare repo", () => {
+    setup([]);
+    try {
+      expect(detectProjectStructure(tmpDir)).toEqual([]);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("detects src/ and docs/", () => {
+    setup(["src", "docs"]);
+    try {
+      const structure = detectProjectStructure(tmpDir);
+      expect(structure).toContain("src/");
+      expect(structure).toContain("docs/");
+    } finally {
+      cleanup();
+    }
+  });
+});
+
+// ── generateTemplate ──────────────────────────────────────────────────────────
+
+describe("generateTemplate", () => {
+  test("includes detected make targets in gates section", () => {
+    const scan = { makeTargets: ["lint", "test", "build"], testPatterns: [], projectStructure: ["src/"] };
+    const tpl = generateTemplate(scan);
+    expect(tpl).toContain("make lint");
+    expect(tpl).toContain("make test");
+  });
+
+  test("produces valid template with empty gates section when no Makefile", () => {
+    const scan = { makeTargets: [], testPatterns: [], projectStructure: [] };
+    const tpl = generateTemplate(scan);
+    expect(tpl).toContain("no Makefile gates detected");
+    expect(tpl).toContain("Acceptance Criteria");
+    expect(tpl).toContain("PENDING");
+  });
+
+  test("includes detected project structure", () => {
+    const scan = { makeTargets: [], testPatterns: [], projectStructure: ["src/", "docs/"] };
+    const tpl = generateTemplate(scan);
+    expect(tpl).toContain("`src/`");
+    expect(tpl).toContain("`docs/`");
+  });
+});

package/test/specs-sync.unit.test.js

@@ -0,0 +1,164 @@
+import { describe, test, expect } from "bun:test";
+import { makeNoop, makeBufferStream, ui, WS_ID } from "./helpers.js";
+import { createCoreHandlers } from "../src/commands/core.js";
+import { ApiError } from "../src/lib/http.js";
+import { ERR_BILLING_CREDIT_EXHAUSTED } from "../src/constants/error-codes.js";
+
+function makeDeps(overrides = {}) {
+  return {
+    clearCredentials: async () => {},
+    createSpinner: () => ({ start() {}, succeed() {}, fail() {} }),
+    newIdempotencyKey: () => "idem_test",
+    openUrl: async () => false,
+    parseFlags: (tokens) => {
+      const options = {};
+      const positionals = [];
+      for (let i = 0; i < tokens.length; i++) {
+        if (tokens[i].startsWith("--")) {
+          const key = tokens[i].slice(2);
+          const next = tokens[i + 1];
+          if (next && !next.startsWith("--")) { options[key] = next; i++; }
+          else options[key] = true;
+        } else { positionals.push(tokens[i]); }
+      }
+      return { options, positionals };
+    },
+    printJson: (_s, v) => {},
+    printKeyValue: (stream, rows) => {
+      for (const [key, value] of Object.entries(rows)) stream.write(`${key}: ${value}\n`);
+    },
+    printSection: (stream, title) => stream.write(`${title}\n`),
+    printTable: () => {},
+    request: async () => ({}),
+    saveCredentials: async () => {},
+    saveWorkspaces: async () => {},
+    ui,
+    writeLine: (stream, line = "") => stream.write(`${line}\n`),
+    apiHeaders: () => ({}),
+    ...overrides,
+  };
+}
+
+describe("commandSpecsSync", () => {
+  test("successful sync with workspace", async () => {
+    const out = makeBufferStream();
+    let calledPath = null;
+    const deps = makeDeps({
+      request: async (_ctx, reqPath) => {
+        calledPath = reqPath;
+        return { synced_count: 3, total_pending: 0, plan_tier: "free", credit_remaining_cents: 1000, credit_currency: "USD" };
+      },
+    });
+    const ctx = { stdout: out.stream, stderr: makeNoop(), jsonMode: false, env: {} };
+    const workspaces = { current_workspace_id: WS_ID, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandSpecsSync([]);
+    expect(code).toBe(0);
+    expect(calledPath).toContain(WS_ID);
+    expect(out.read()).toContain("Specs synced");
+    expect(out.read()).toContain(WS_ID);
+    expect(out.read()).toContain("credit_remaining_cents: 1000");
+  });
+
+  test("missing workspace_id error", async () => {
+    const err = makeBufferStream();
+    const deps = makeDeps();
+    const ctx = { stdout: makeNoop(), stderr: err.stream, jsonMode: false, env: {} };
+    const workspaces = { current_workspace_id: null, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandSpecsSync([]);
+    expect(code).toBe(2);
+    expect(err.read()).toContain("workspace_id required");
+  });
+
+  test("JSON mode output", async () => {
+    let printed = null;
+    const deps = makeDeps({
+      request: async () => ({ synced_count: 5, total_pending: 2 }),
+      printJson: (_s, v) => { printed = v; },
+    });
+    const ctx = { stdout: makeNoop(), stderr: makeNoop(), jsonMode: true, env: {} };
+    const workspaces = { current_workspace_id: WS_ID, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandSpecsSync([]);
+    expect(code).toBe(0);
+    expect(printed.synced_count).toBe(5);
+  });
+
+  test("prints upgrade path when free credit is exhausted", async () => {
+    const out = makeBufferStream();
+    const deps = makeDeps({
+      request: async () => ({ synced_count: 0, total_pending: 2, plan_tier: "free", credit_remaining_cents: 0, credit_currency: "USD" }),
+    });
+    const ctx = { stdout: out.stream, stderr: makeNoop(), jsonMode: false, env: {} };
+    const workspaces = { current_workspace_id: WS_ID, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandSpecsSync([]);
+    expect(code).toBe(0);
+    expect(out.read()).toContain("Upgrade path:");
+    expect(out.read()).toContain("workspace upgrade-scale");
+  });
+
+  test("prints upgrade path when sync is rejected with credit exhausted", async () => {
+    const err = makeBufferStream();
+    const deps = makeDeps({
+      request: async () => {
+        throw new ApiError("Free plan credit exhausted. Upgrade to Scale to continue.", {
+          status: 403,
+          code: ERR_BILLING_CREDIT_EXHAUSTED,
+        });
+      },
+    });
+    const ctx = { stdout: makeNoop(), stderr: err.stream, jsonMode: false, env: {} };
+    const workspaces = { current_workspace_id: WS_ID, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+
+    await expect(core.commandSpecsSync([])).rejects.toMatchObject({ code: ERR_BILLING_CREDIT_EXHAUSTED });
+    expect(err.read()).toContain("Upgrade path:");
+    expect(err.read()).toContain(`--workspace-id ${WS_ID}`);
+  });
+
+  test("JSON mode error path does NOT print upgrade hint on credit exhausted", async () => {
+    const err = makeBufferStream();
+    const deps = makeDeps({
+      request: async () => {
+        throw new ApiError("Free plan credit exhausted.", {
+          status: 403,
+          code: ERR_BILLING_CREDIT_EXHAUSTED,
+        });
+      },
+    });
+    const ctx = { stdout: makeNoop(), stderr: err.stream, jsonMode: true, env: {} };
+    const workspaces = { current_workspace_id: WS_ID, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+
+    await expect(core.commandSpecsSync([])).rejects.toMatchObject({ code: ERR_BILLING_CREDIT_EXHAUSTED });
+    expect(err.read()).not.toContain("Upgrade path:");
+  });
+
+  test("negative credit_remaining_cents triggers upgrade hint", async () => {
+    const out = makeBufferStream();
+    const deps = makeDeps({
+      request: async () => ({ synced_count: 1, total_pending: 0, plan_tier: "free", credit_remaining_cents: -50, credit_currency: "USD" }),
+    });
+    const ctx = { stdout: out.stream, stderr: makeNoop(), jsonMode: false, env: {} };
+    const workspaces = { current_workspace_id: WS_ID, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandSpecsSync([]);
+    expect(code).toBe(0);
+    expect(out.read()).toContain("Upgrade path:");
+  });
+
+  test("missing credit_remaining_cents does NOT trigger upgrade hint", async () => {
+    const out = makeBufferStream();
+    const deps = makeDeps({
+      request: async () => ({ synced_count: 1, total_pending: 0, plan_tier: "free" }),
+    });
+    const ctx = { stdout: out.stream, stderr: makeNoop(), jsonMode: false, env: {} };
+    const workspaces = { current_workspace_id: WS_ID, items: [] };
+    const core = createCoreHandlers(ctx, workspaces, deps);
+    const code = await core.commandSpecsSync([]);
+    expect(code).toBe(0);
+    expect(out.read()).not.toContain("Upgrade path:");
+  });
+});

package/test/sse-parser.unit.test.js

@@ -0,0 +1,54 @@
+import { describe, test, expect } from "bun:test";
+import { parseSseBuffer } from "../src/lib/sse-parser.js";
+
+describe("parseSseBuffer", () => {
+  test("parses single tool_use event", () => {
+    const buf = 'event: tool_use\ndata: {"id":"tu_01","name":"read_file","input":{"path":"go.mod"}}\n\n';
+    const { events, remainder } = parseSseBuffer(buf);
+    expect(events).toHaveLength(1);
+    expect(events[0].type).toBe("tool_use");
+    expect(events[0].data.name).toBe("read_file");
+    expect(events[0].data.input.path).toBe("go.mod");
+    expect(remainder).toBe("");
+  });
+
+  test("parses multiple events", () => {
+    const buf = 'event: text_delta\ndata: {"text":"hello"}\n\nevent: done\ndata: {"usage":{"total_tokens":100}}\n\n';
+    const result = parseSseBuffer(buf);
+    expect(result.events).toHaveLength(2);
+    expect(result.events[0].type).toBe("text_delta");
+    expect(result.events[0].data.text).toBe("hello");
+    expect(result.events[1].type).toBe("done");
+    expect(result.events[1].data.usage.total_tokens).toBe(100);
+    expect(result.remainder).toBe("");
+  });
+
+  test("returns remainder for incomplete frame", () => {
+    const buf = 'event: text_delta\ndata: {"text":"partial';
+    const { events, remainder } = parseSseBuffer(buf);
+    expect(events).toHaveLength(0);
+    expect(remainder).toBe(buf);
+  });
+
+  test("skips heartbeat comments", () => {
+    const buf = ': heartbeat\n\nevent: done\ndata: {"ok":true}\n\n';
+    const { events } = parseSseBuffer(buf);
+    // heartbeat-only frame produces null (no data line), only done event returned
+    expect(events).toHaveLength(1);
+    expect(events[0].type).toBe("done");
+  });
+
+  test("handles empty buffer", () => {
+    const { events, remainder } = parseSseBuffer("");
+    expect(events).toHaveLength(0);
+    expect(remainder).toBe("");
+  });
+
+  test("parses error event", () => {
+    const buf = 'event: error\ndata: {"message":"provider timeout"}\n\n';
+    const { events } = parseSseBuffer(buf);
+    expect(events).toHaveLength(1);
+    expect(events[0].type).toBe("error");
+    expect(events[0].data.message).toBe("provider timeout");
+  });
+});

package/test/state.unit.test.js

@@ -0,0 +1,34 @@
+import { test } from "bun:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+
+import { stateInternals } from "../src/lib/state.js";
+
+test("resolveStatePaths defaults to XDG-style zombiectl config directory", () => {
+  const previous = process.env.ZOMBIE_STATE_DIR;
+  delete process.env.ZOMBIE_STATE_DIR;
+  try {
+    const paths = stateInternals.resolveStatePaths();
+    const expectedBase = path.join(os.homedir(), ".config", "zombiectl");
+    assert.equal(paths.baseDir, expectedBase);
+    assert.equal(paths.credentialsPath, path.join(expectedBase, "credentials.json"));
+    assert.equal(paths.workspacesPath, path.join(expectedBase, "workspaces.json"));
+  } finally {
+    if (previous !== undefined) process.env.ZOMBIE_STATE_DIR = previous;
+  }
+});
+
+test("resolveStatePaths honors ZOMBIE_STATE_DIR override", () => {
+  const previous = process.env.ZOMBIE_STATE_DIR;
+  process.env.ZOMBIE_STATE_DIR = "/tmp/zombiectl-state-test";
+  try {
+    const paths = stateInternals.resolveStatePaths();
+    assert.equal(paths.baseDir, "/tmp/zombiectl-state-test");
+    assert.equal(paths.credentialsPath, "/tmp/zombiectl-state-test/credentials.json");
+    assert.equal(paths.workspacesPath, "/tmp/zombiectl-state-test/workspaces.json");
+  } finally {
+    if (previous === undefined) delete process.env.ZOMBIE_STATE_DIR;
+    else process.env.ZOMBIE_STATE_DIR = previous;
+  }
+});

package/test/streamfetch.unit.test.js

@@ -0,0 +1,211 @@
+import { describe, test, expect } from "bun:test";
+import { streamFetch, ApiError } from "../src/lib/http.js";
+
+// ── Test helpers ─────────────────────────────────────────────────────────────
+
+function sseResponseFrom(sseBody, status = 200) {
+  const encoder = new TextEncoder();
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    statusText: status === 200 ? "OK" : "Error",
+    headers: new Headers(),
+    text: async () => sseBody,
+    body: {
+      getReader() {
+        let sent = false;
+        return {
+          read() {
+            if (!sent) { sent = true; return Promise.resolve({ done: false, value: encoder.encode(sseBody) }); }
+            return Promise.resolve({ done: true });
+          },
+        };
+      },
+    },
+  };
+}
+
+// ── T1: Happy path ──────────────────────────────────────────────────────────
+
+describe("streamFetch — happy path", () => {
+  test("parses SSE events and calls onEvent for each", async () => {
+    const events = [];
+    const fetchImpl = async () => sseResponseFrom(
+      'event: tool_use\ndata: {"id":"tu_01","name":"read_file"}\n\nevent: done\ndata: {"ok":true}\n\n'
+    );
+    await streamFetch("https://api.test.com/v1/x", {}, {}, (e) => events.push(e), { fetchImpl });
+    expect(events).toHaveLength(2);
+    expect(events[0].type).toBe("tool_use");
+    expect(events[0].data.name).toBe("read_file");
+    expect(events[1].type).toBe("done");
+  });
+
+  test("merges custom headers with content-type and accept", async () => {
+    let capturedHeaders = null;
+    const fetchImpl = async (url, opts) => {
+      capturedHeaders = opts.headers;
+      return sseResponseFrom('event: done\ndata: {}\n\n');
+    };
+    await streamFetch("https://api.test.com/v1/x", { msg: 1 },
+      { Authorization: "Bearer tok" }, () => {}, { fetchImpl });
+    expect(capturedHeaders.Authorization).toBe("Bearer tok");
+    expect(capturedHeaders["Content-Type"]).toBe("application/json");
+    expect(capturedHeaders.Accept).toBe("text/event-stream");
+  });
+
+  test("sends JSON-stringified payload as body", async () => {
+    let capturedBody = null;
+    const fetchImpl = async (url, opts) => {
+      capturedBody = opts.body;
+      return sseResponseFrom('event: done\ndata: {}\n\n');
+    };
+    await streamFetch("https://api.test.com/v1/x", { messages: ["hello"], tools: [] },
+      {}, () => {}, { fetchImpl });
+    const parsed = JSON.parse(capturedBody);
+    expect(parsed.messages).toEqual(["hello"]);
+  });
+});
+
+// ── T2: Edge cases ──────────────────────────────────────────────────────────
+
+describe("streamFetch — edge cases", () => {
+  test("handles empty SSE body (no events)", async () => {
+    const events = [];
+    const fetchImpl = async () => sseResponseFrom("");
+    await streamFetch("https://api.test.com/v1/x", {}, {}, (e) => events.push(e), { fetchImpl });
+    expect(events).toHaveLength(0);
+  });
+
+  test("skips heartbeat comments", async () => {
+    const events = [];
+    const fetchImpl = async () => sseResponseFrom(': heartbeat\n\nevent: done\ndata: {"ok":true}\n\n');
+    await streamFetch("https://api.test.com/v1/x", {}, {}, (e) => events.push(e), { fetchImpl });
+    expect(events).toHaveLength(1);
+    expect(events[0].type).toBe("done");
+  });
+
+  test("handles multi-chunk delivery (split across reads)", async () => {
+    const encoder = new TextEncoder();
+    const chunk1 = 'event: text_delta\ndata: {"te';
+    const chunk2 = 'xt":"hello"}\n\nevent: done\ndata: {}\n\n';
+    let readCount = 0;
+    const fetchImpl = async () => ({
+      ok: true, status: 200, body: {
+        getReader() {
+          return {
+            read() {
+              readCount++;
+              if (readCount === 1) return Promise.resolve({ done: false, value: encoder.encode(chunk1) });
+              if (readCount === 2) return Promise.resolve({ done: false, value: encoder.encode(chunk2) });
+              return Promise.resolve({ done: true });
+            },
+          };
+        },
+      },
+    });
+    const events = [];
+    await streamFetch("https://api.test.com/v1/x", {}, {}, (e) => events.push(e), { fetchImpl });
+    expect(events).toHaveLength(2);
+    expect(events[0].data.text).toBe("hello");
+  });
+});
+
+// ── T3: Error paths ─────────────────────────────────────────────────────────
+
+describe("streamFetch — error paths", () => {
+  test("non-200 response throws ApiError with parsed error code", async () => {
+    const fetchImpl = async () => ({
+      ok: false,
+      status: 403,
+      statusText: "Forbidden",
+      text: async () => JSON.stringify({ error: { code: "UZ-AUTH-001", message: "access denied" } }),
+    });
+    try {
+      await streamFetch("https://api.test.com/v1/x", {}, {}, () => {}, { fetchImpl });
+      expect(true).toBe(false);
+    } catch (err) {
+      expect(err).toBeInstanceOf(ApiError);
+      expect(err.status).toBe(403);
+      expect(err.code).toBe("UZ-AUTH-001");
+    }
+  });
+
+  test("non-200 with non-JSON body still throws ApiError", async () => {
+    const fetchImpl = async () => ({
+      ok: false,
+      status: 502,
+      statusText: "Bad Gateway",
+      text: async () => "upstream error",
+    });
+    try {
+      await streamFetch("https://api.test.com/v1/x", {}, {}, () => {}, { fetchImpl });
+      expect(true).toBe(false);
+    } catch (err) {
+      expect(err).toBeInstanceOf(ApiError);
+      expect(err.code).toBe("HTTP_502");
+    }
+  });
+
+  test("timeout throws ApiError with TIMEOUT code", async () => {
+    const fetchImpl = async (url, opts) => {
+      // Simulate slow response — wait longer than timeoutMs
+      await new Promise((resolve, reject) => {
+        opts.signal.addEventListener("abort", () => {
+          reject(Object.assign(new Error("aborted"), { name: "AbortError" }));
+        });
+      });
+    };
+    try {
+      await streamFetch("https://api.test.com/v1/x", {}, {}, () => {}, {
+        fetchImpl,
+        timeoutMs: 50,
+      });
+      expect(true).toBe(false);
+    } catch (err) {
+      expect(err).toBeInstanceOf(ApiError);
+      expect(err.code).toBe("TIMEOUT");
+    }
+  });
+
+  test("read error mid-stream propagates", async () => {
+    const fetchImpl = async () => ({
+      ok: true,
+      status: 200,
+      body: {
+        getReader() {
+          return {
+            read() { return Promise.reject(new Error("socket hang up")); },
+          };
+        },
+      },
+    });
+    try {
+      await streamFetch("https://api.test.com/v1/x", {}, {}, () => {}, { fetchImpl });
+      expect(true).toBe(false);
+    } catch (err) {
+      expect(err.message).toContain("socket hang up");
+    }
+  });
+});
+
+// ── T4: Output fidelity — SSE parsing correctness ───────────────────────────
+
+describe("streamFetch — SSE parsing fidelity", () => {
+  test("parses event with JSON data containing nested objects", async () => {
+    const events = [];
+    const fetchImpl = async () => sseResponseFrom(
+      'event: tool_use\ndata: {"id":"tu_01","name":"read_file","input":{"path":"src/main.go"}}\n\n'
+    );
+    await streamFetch("https://api.test.com/v1/x", {}, {}, (e) => events.push(e), { fetchImpl });
+    expect(events[0].data.input.path).toBe("src/main.go");
+  });
+
+  test("handles data with unicode content", async () => {
+    const events = [];
+    const fetchImpl = async () => sseResponseFrom(
+      'event: text_delta\ndata: {"text":"中文テスト 👨‍💻"}\n\n'
+    );
+    await streamFetch("https://api.test.com/v1/x", {}, {}, (e) => events.push(e), { fetchImpl });
+    expect(events[0].data.text).toBe("中文テスト 👨‍💻");
+  });
+});