@polderlabs/bizar 6.2.4 → 6.3.0

package/plugins/bizar/tests/tools/read-glyph-feedback.test.ts

@@ -1,253 +0,0 @@
-/**
- * read-glyph-feedback.test.ts
- *
- * Tests for `readGlyphFeedback` — the pure read function extracted
- * from `read-glyph-feedback.ts`. Mirrors the style of
- * `bg-get-comments.test.ts` so future readers can compare them
- * side-by-side.
- *
- * Groups (8 tests):
- *   1. invalid slug              — returns ok:false
- *   2. missing feedback.md       — returns ok:true, found:false
- *   3. valid feedback file       — parses frontmatter + body
- *   4. commentCount / questionCount parsed as integers
- *   5. malformed frontmatter     — falls back to raw body
- *   6. multi-line body preserved verbatim
- *   7. empty file                — found:false-equivalent? Actually returns ok:true, found:true, empty meta
- *   8. feedback file with comments + Q&A sections round-trips correctly
- */
-
-import { describe, it, expect, beforeAll, afterAll } from "bun:test";
-import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { readGlyphFeedback } from "../../src/tools/read-glyph-feedback.js";
-
-// ---------------------------------------------------------------------------
-// Fixtures / helpers
-// ---------------------------------------------------------------------------
-
-let worktree: string;
-
-beforeAll(() => {
-  worktree = mkdtempSync(join(tmpdir(), "bizar-feedback-test-"));
-});
-
-afterAll(() => {
-  if (worktree) {
-    rmSync(worktree, { recursive: true, force: true });
-  }
-});
-
-function writeFeedback(slug: string, body: string): void {
-  const dir = join(worktree, "artifacts", slug);
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, "feedback.md"), body, "utf-8");
-}
-
-const SAMPLE_FEEDBACK = `---
-glyph: sample-plan
-submittedAt: 2026-06-26T18:00:00.000Z
-submittedBy: drb0rk
-commentCount: 2
-questionCount: 1
----
-
-# Feedback for Sample Plan
-
-## Free-placed comments
-- (240, 120) — drb0rk: Make this button say Send link instead of Continue
-- (165, 2121) — drb0rk: test
-
-## Open-question answers
-### Q: Rate-limit per IP or per email?
-A: Per email
-
-(kind: choice)
-
-## Full MDX source
-\`\`\`mdx
----
-title: "Sample Plan"
-status: review
----
-
-# Hello
-\`\`\`
-`;
-
-// ---------------------------------------------------------------------------
-// Group 1 — invalid slug
-// ---------------------------------------------------------------------------
-
-describe("readGlyphFeedback — invalid slug", () => {
-  it("rejects uppercase slugs", () => {
-    const result = readGlyphFeedback(worktree, "INVALID");
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error).toContain("Invalid slug");
-      expect(result.slug).toBe("INVALID");
-    }
-  });
-
-  it("rejects path-traversal slugs", () => {
-    const result = readGlyphFeedback(worktree, "../etc");
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error).toContain("Invalid slug");
-    }
-  });
-
-  it("rejects empty slugs", () => {
-    const result = readGlyphFeedback(worktree, "");
-    expect(result.ok).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Group 2 — missing feedback.md
-// ---------------------------------------------------------------------------
-
-describe("readGlyphFeedback — missing feedback.md", () => {
-  it("returns ok:true, found:false when the file does not exist", () => {
-    const result = readGlyphFeedback(worktree, "no-feedback-yet");
-    expect(result.ok).toBe(true);
-    if (result.ok && !result.found) {
-      expect(result.found).toBe(false);
-      expect(result.slug).toBe("no-feedback-yet");
-      expect(result.message).toContain("No feedback.md");
-    } else {
-      throw new Error("expected found:false");
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Group 3 — valid feedback file
-// ---------------------------------------------------------------------------
-
-describe("readGlyphFeedback — valid feedback file", () => {
-  it("parses frontmatter and body", () => {
-    const slug = "valid-feedback";
-    writeFeedback(slug, SAMPLE_FEEDBACK);
-    const result = readGlyphFeedback(worktree, slug);
-    expect(result.ok).toBe(true);
-    if (result.ok && result.found) {
-      expect(result.meta.glyph).toBe("sample-plan");
-      expect(result.meta.submittedBy).toBe("drb0rk");
-      expect(result.body).toContain("# Feedback for Sample Plan");
-      expect(result.body).toContain("(240, 120)");
-      expect(result.body).toContain("A: Per email");
-    } else {
-      throw new Error("expected found:true");
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Group 4 — counts parsed
-// ---------------------------------------------------------------------------
-
-describe("readGlyphFeedback — counts parsed as integers", () => {
-  it("returns commentCount and questionCount as numbers", () => {
-    const slug = "counts-feedback";
-    writeFeedback(slug, SAMPLE_FEEDBACK);
-    const result = readGlyphFeedback(worktree, slug);
-    expect(result.ok).toBe(true);
-    if (result.ok && result.found) {
-      expect(result.commentCount).toBe(2);
-      expect(result.questionCount).toBe(1);
-      expect(typeof result.commentCount).toBe("number");
-      expect(typeof result.questionCount).toBe("number");
-    } else {
-      throw new Error("expected found:true");
-    }
-  });
-
-  it("treats missing counts as 0", () => {
-    const slug = "no-counts-feedback";
-    writeFeedback(slug, "---\nglyph: x\n---\n\nbody\n");
-    const result = readGlyphFeedback(worktree, slug);
-    expect(result.ok).toBe(true);
-    if (result.ok && result.found) {
-      expect(result.commentCount).toBe(0);
-      expect(result.questionCount).toBe(0);
-    } else {
-      throw new Error("expected found:true");
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Group 5 — malformed frontmatter
-// ---------------------------------------------------------------------------
-
-describe("readGlyphFeedback — malformed frontmatter", () => {
-  it("returns the raw text as body when frontmatter delimiters are missing", () => {
-    const slug = "no-frontmatter";
-    writeFeedback(slug, "Just a plain markdown body\nwith two lines\n");
-    const result = readGlyphFeedback(worktree, slug);
-    expect(result.ok).toBe(true);
-    if (result.ok && result.found) {
-      expect(result.meta).toEqual({});
-      expect(result.body).toContain("Just a plain markdown body");
-      expect(result.commentCount).toBe(0);
-      expect(result.questionCount).toBe(0);
-    } else {
-      throw new Error("expected found:true");
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Group 6 — body preserved verbatim
-// ---------------------------------------------------------------------------
-
-describe("readGlyphFeedback — body preserved verbatim", () => {
-  it("preserves multi-line bodies including fenced code blocks", () => {
-    const slug = "verbatim-feedback";
-    const longBody = "Line 1\nLine 2\n```ts\nconst x = 1;\n```\nLine 4\n";
-    writeFeedback(slug, `---\nglyph: x\ncommentCount: 0\nquestionCount: 0\n---\n\n${longBody}`);
-    const result = readGlyphFeedback(worktree, slug);
-    expect(result.ok).toBe(true);
-    if (result.ok && result.found) {
-      expect(result.body).toContain("const x = 1;");
-      expect(result.body).toContain("Line 4");
-    } else {
-      throw new Error("expected found:true");
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Group 7 — round-trip
-// ---------------------------------------------------------------------------
-
-describe("readGlyphFeedback — round-trip", () => {
-  it("a feedback.md containing comments + Q&A + MDX source round-trips", () => {
-    const slug = "roundtrip";
-    writeFeedback(slug, SAMPLE_FEEDBACK);
-    const result = readGlyphFeedback(worktree, slug);
-    expect(result.ok).toBe(true);
-    if (result.ok && result.found) {
-      // Free-placed comments section
-      expect(result.body).toMatch(/## Free-placed comments/);
-      expect(result.body).toContain("(240, 120)");
-      expect(result.body).toContain("Send link");
-      // Open-question answers section
-      expect(result.body).toMatch(/## Open-question answers/);
-      expect(result.body).toContain("A: Per email");
-      // Full MDX source section
-      expect(result.body).toMatch(/## Full MDX source/);
-      expect(result.body).toContain("```mdx");
-      // Counts
-      expect(result.commentCount).toBe(2);
-      expect(result.questionCount).toBe(1);
-      // feedbackFile path is the worktree path
-      expect(result.feedbackFile).toBe(join(worktree, "artifacts", slug, "feedback.md"));
-    } else {
-      throw new Error("expected found:true");
-    }
-  });
-});

package/plugins/bizar/tests/tools/wait-for-feedback.test.ts

@@ -1,390 +0,0 @@
-/**
- * wait-for-feedback.test.ts
- *
- * Tests for `waitForFeedback` in src/tools/wait-for-feedback.ts.
- *
- * We test the core function (extracted from the tool factory) directly
- * with an injectable `sleep` and `now` so tests run instantly. The
- * tool factory's wrapper is thin and adds no behavior.
- *
- * Groups:
- *   1. timeout (no feedback → status: "timed_out")
- *   2. immediate feedback (comments already present)
- *   3. delayed feedback (comments added while polling)
- *   4. approved status (meta.json)
- *   5. rejected status (meta.json)
- *   6. sinceTimestamp filter (only newer comments count)
- *   7. invalid slug → error
- *   8. missing plan → error
- */
-
-import { describe, test, expect, beforeAll, afterAll } from "bun:test";
-import {
-  mkdtempSync,
-  rmSync,
-  mkdirSync,
-  writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { waitForFeedback } from "../../src/tools/wait-for-feedback.js";
-
-// ---------------------------------------------------------------------------
-// Fixtures
-// ---------------------------------------------------------------------------
-
-class MockLogger {
-  messages: Array<{ level: string; message: string }> = [];
-  log(opts: { level: string; message: string }) { this.messages.push(opts); }
-  debug(m: string) { this.messages.push({ level: "debug", message: m }); }
-  info(m: string) { this.messages.push({ level: "info", message: m }); }
-  warn(m: string) { this.messages.push({ level: "warn", message: m }); }
-  error(m: string) { this.messages.push({ level: "error", message: m }); }
-}
-
-let worktree: string;
-
-beforeAll(() => {
-  worktree = mkdtempSync(join(tmpdir(), "bizar-wait-feedback-test-"));
-});
-
-afterAll(() => {
-  if (worktree) rmSync(worktree, { recursive: true, force: true });
-});
-
-function planDir(slug: string) {
-  return join(worktree, "plans", slug);
-}
-function planJsonPath(slug: string) {
-  return join(planDir(slug), "plan.json");
-}
-function metaJsonPath(slug: string) {
-  return join(planDir(slug), "meta.json");
-}
-function seedCanvas(slug: string, canvas: unknown) {
-  mkdirSync(planDir(slug), { recursive: true });
-  writeFileSync(planJsonPath(slug), JSON.stringify(canvas), "utf-8");
-}
-function seedMeta(slug: string, meta: unknown) {
-  mkdirSync(planDir(slug), { recursive: true });
-  writeFileSync(metaJsonPath(slug), JSON.stringify(meta), "utf-8");
-}
-
-/** Make a sleep function that just bumps a fake clock by `ms` instead of
- *  actually waiting. Tests stay fast even with big timeout values. */
-function fakeSleep(now: { t: number }) {
-  return (ms: number) => {
-    now.t += ms;
-    return Promise.resolve();
-  };
-}
-
-// ===========================================================================
-// Group 1 — timeout
-// ===========================================================================
-
-describe("waitForFeedback — timeout", () => {
-  test("returns timed_out when no feedback arrives", async () => {
-    const slug = "timeout-no-feedback";
-    seedCanvas(slug, { schemaVersion: 2, comments: [] });
-    const now = { t: 1000 };
-    const r = await waitForFeedback(
-      {
-        worktree,
-        logger: new MockLogger(),
-        pollIntervalMs: 5,
-        sleep: fakeSleep(now),
-        now: () => now.t,
-      },
-      { planSlug: slug, timeoutMs: 50 },
-    );
-    expect(r.ok).toBe(true);
-    if (r.ok) {
-      expect(r.status).toBe("timed_out");
-      expect(r.newComments).toEqual([]);
-      expect(r.planStatus).toBe("draft");
-    }
-  });
-
-  test("clamps timeout to minimum 5000ms", async () => {
-    const slug = "timeout-clamp";
-    seedCanvas(slug, { schemaVersion: 2, comments: [] });
-    const now = { t: 0 };
-    const r = await waitForFeedback(
-      {
-        worktree,
-        logger: new MockLogger(),
-        pollIntervalMs: 5,
-        sleep: fakeSleep(now),
-        now: () => now.t,
-      },
-      { planSlug: slug, timeoutMs: 100 }, // way below min
-    );
-    expect(r.ok).toBe(true);
-    if (r.ok) {
-      // Waited exactly the clamped minimum (5000ms), no feedback → timed out
-      expect(r.status).toBe("timed_out");
-      expect(r.waitedMs).toBeGreaterThanOrEqual(5000);
-    }
-  });
-});
-
-// ===========================================================================
-// Group 2 — immediate feedback (comments already present)
-// ===========================================================================
-
-describe("waitForFeedback — immediate feedback", () => {
-  test("returns feedback_received on first tick when comments exist", async () => {
-    const slug = "immediate-comments";
-    seedCanvas(slug, {
-      schemaVersion: 2,
-      comments: [
-        { id: "c_1", text: "Hello", created: "2026-06-18T10:00:00Z", author: "DrB0rk" },
-      ],
-    });
-    const now = { t: 0 };
-    const r = await waitForFeedback(
-      {
-        worktree,
-        logger: new MockLogger(),
-        pollIntervalMs: 5,
-        sleep: fakeSleep(now),
-        now: () => now.t,
-      },
-      { planSlug: slug, timeoutMs: 60_000 },
-    );
-    expect(r.ok).toBe(true);
-    if (r.ok) {
-      expect(r.status).toBe("feedback_received");
-      expect(r.newComments).toHaveLength(1);
-      expect(r.newComments[0]!.id).toBe("c_1");
-    }
-  });
-});
-
-// ===========================================================================
-// Group 3 — delayed feedback (comments added while polling)
-// ===========================================================================
-
-describe("waitForFeedback — delayed feedback", () => {
-  test("returns feedback_received when comments appear during polling", async () => {
-    const slug = "delayed-comments";
-    seedCanvas(slug, { schemaVersion: 2, comments: [] });
-    const now = { t: 0 };
-
-    // Sleep that injects a comment after 2 ticks
-    let sleepCount = 0;
-    const sleep = (ms: number) => {
-      sleepCount++;
-      now.t += ms;
-      // After 2 sleeps (i.e. during the 3rd tick), add a comment.
-      if (sleepCount === 2) {
-        const canvas = {
-          schemaVersion: 2,
-          comments: [
-            { id: "c_late", text: "Late", created: "2026-06-18T12:00:00Z" },
-          ],
-        };
-        writeFileSync(planJsonPath(slug), JSON.stringify(canvas), "utf-8");
-      }
-      return Promise.resolve();
-    };
-
-    const r = await waitForFeedback(
-      {
-        worktree,
-        logger: new MockLogger(),
-        pollIntervalMs: 5,
-        sleep,
-        now: () => now.t,
-      },
-      { planSlug: slug, timeoutMs: 60_000 },
-    );
-    expect(r.ok).toBe(true);
-    if (r.ok) {
-      expect(r.status).toBe("feedback_received");
-      expect(r.newComments).toHaveLength(1);
-      expect(r.newComments[0]!.id).toBe("c_late");
-    }
-  });
-});
-
-// ===========================================================================
-// Group 4 — approved status
-// ===========================================================================
-
-describe("waitForFeedback — approved", () => {
-  test("returns approved when meta.json status is approved (on first tick)", async () => {
-    const slug = "approved-first-tick";
-    seedCanvas(slug, { schemaVersion: 2, comments: [] });
-    seedMeta(slug, { status: "approved" });
-    const now = { t: 0 };
-    const r = await waitForFeedback(
-      {
-        worktree,
-        logger: new MockLogger(),
-        pollIntervalMs: 5,
-        sleep: fakeSleep(now),
-        now: () => now.t,
-      },
-      { planSlug: slug, timeoutMs: 60_000 },
-    );
-    expect(r.ok).toBe(true);
-    if (r.ok) {
-      expect(r.status).toBe("approved");
-      expect(r.planStatus).toBe("approved");
-    }
-  });
-
-  test("returns approved when meta.json becomes approved during polling", async () => {
-    const slug = "approved-during";
-    seedCanvas(slug, { schemaVersion: 2, comments: [] });
-    const now = { t: 0 };
-    let sleepCount = 0;
-    const sleep = (ms: number) => {
-      sleepCount++;
-      now.t += ms;
-      if (sleepCount === 2) {
-        writeFileSync(metaJsonPath(slug), JSON.stringify({ status: "approved" }));
-      }
-      return Promise.resolve();
-    };
-    const r = await waitForFeedback(
-      { worktree, logger: new MockLogger(), pollIntervalMs: 5, sleep, now: () => now.t },
-      { planSlug: slug, timeoutMs: 60_000 },
-    );
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.status).toBe("approved");
-  });
-});
-
-// ===========================================================================
-// Group 5 — rejected status
-// ===========================================================================
-
-describe("waitForFeedback — rejected", () => {
-  test("returns rejected when meta.json status is rejected", async () => {
-    const slug = "rejected-ok";
-    seedCanvas(slug, { schemaVersion: 2, comments: [] });
-    seedMeta(slug, { status: "rejected" });
-    const now = { t: 0 };
-    const r = await waitForFeedback(
-      {
-        worktree,
-        logger: new MockLogger(),
-        pollIntervalMs: 5,
-        sleep: fakeSleep(now),
-        now: () => now.t,
-      },
-      { planSlug: slug, timeoutMs: 60_000 },
-    );
-    expect(r.ok).toBe(true);
-    if (r.ok) {
-      expect(r.status).toBe("rejected");
-      expect(r.planStatus).toBe("rejected");
-    }
-  });
-});
-
-// ===========================================================================
-// Group 6 — sinceTimestamp filter
-// ===========================================================================
-
-describe("waitForFeedback — sinceTimestamp filter", () => {
-  test("only counts comments strictly after sinceTimestamp", async () => {
-    const slug = "since-ts";
-    seedCanvas(slug, {
-      schemaVersion: 2,
-      comments: [
-        { id: "c_old", text: "Old", created: "2026-06-18T09:00:00Z" },
-        { id: "c_new", text: "New", created: "2026-06-18T11:00:00Z" },
-      ],
-    });
-    const now = { t: 0 };
-    const r = await waitForFeedback(
-      {
-        worktree,
-        logger: new MockLogger(),
-        pollIntervalMs: 5,
-        sleep: fakeSleep(now),
-        now: () => now.t,
-      },
-      {
-        planSlug: slug,
-        timeoutMs: 60_000,
-        sinceTimestamp: "2026-06-18T10:00:00Z",
-      },
-    );
-    expect(r.ok).toBe(true);
-    if (r.ok) {
-      expect(r.status).toBe("feedback_received");
-      expect(r.newComments).toHaveLength(1);
-      expect(r.newComments[0]!.id).toBe("c_new");
-    }
-  });
-
-  test("returns timed_out when all comments are older than sinceTimestamp", async () => {
-    const slug = "since-ts-no-new";
-    seedCanvas(slug, {
-      schemaVersion: 2,
-      comments: [
-        { id: "c_old", text: "Old", created: "2026-06-18T09:00:00Z" },
-      ],
-    });
-    const now = { t: 0 };
-    const r = await waitForFeedback(
-      {
-        worktree,
-        logger: new MockLogger(),
-        pollIntervalMs: 5,
-        sleep: fakeSleep(now),
-        now: () => now.t,
-      },
-      {
-        planSlug: slug,
-        timeoutMs: 60_000,
-        sinceTimestamp: "2026-06-18T12:00:00Z",
-      },
-    );
-    expect(r.ok).toBe(true);
-    if (r.ok) {
-      expect(r.status).toBe("timed_out");
-      expect(r.newComments).toEqual([]);
-    }
-  });
-});
-
-// ===========================================================================
-// Group 7 — invalid slug
-// ===========================================================================
-
-describe("waitForFeedback — invalid slug", () => {
-  test("returns error result for invalid slug", async () => {
-    const r = await waitForFeedback(
-      { worktree, logger: new MockLogger(), pollIntervalMs: 5, sleep: fakeSleep({ t: 0 }), now: () => 0 },
-      { planSlug: "UPPERCASE", timeoutMs: 60_000 },
-    );
-    expect(r.ok).toBe(false);
-    if (!r.ok) {
-      expect(r.error).toMatch(/Invalid planSlug/);
-    }
-  });
-});
-
-// ===========================================================================
-// Group 8 — missing plan
-// ===========================================================================
-
-describe("waitForFeedback — missing plan", () => {
-  test("returns error result when plan directory does not exist", async () => {
-    const r = await waitForFeedback(
-      { worktree, logger: new MockLogger(), pollIntervalMs: 5, sleep: fakeSleep({ t: 0 }), now: () => 0 },
-      { planSlug: "does-not-exist", timeoutMs: 60_000 },
-    );
-    expect(r.ok).toBe(false);
-    if (!r.ok) {
-      expect(r.error).toMatch(/Plan not found/);
-    }
-  });
-});