@jiggai/kitchen 0.1.11 → 0.2.0

package/src/lib/__tests__/recipes.test.ts

@@ -0,0 +1,199 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import {
+  findRecipeById,
+  forceFrontmatterId,
+  listRecipes,
+  parseFrontmatterId,
+  resolveRecipePath,
+  readRecipe,
+  writeRecipeFile,
+  type RecipeListItem,
+} from "../recipes";
+
+vi.mock("../openclaw", () => ({ runOpenClaw: vi.fn() }));
+
+vi.mock("../paths", () => ({
+  getBuiltinRecipesDir: vi.fn(),
+  getWorkspaceRecipesDir: vi.fn(),
+}));
+
+vi.mock("node:fs/promises", () => ({
+  default: {
+    mkdir: vi.fn(),
+    writeFile: vi.fn(),
+  },
+}));
+
+import path from "node:path";
+import fs from "node:fs/promises";
+import { runOpenClaw } from "../openclaw";
+import { getBuiltinRecipesDir, getWorkspaceRecipesDir } from "../paths";
+
+describe("recipes", () => {
+  beforeEach(() => {
+    vi.mocked(runOpenClaw).mockReset();
+    vi.mocked(getBuiltinRecipesDir).mockReset();
+    vi.mocked(getWorkspaceRecipesDir).mockReset();
+    vi.mocked(fs.mkdir).mockReset();
+    vi.mocked(fs.writeFile).mockReset();
+  });
+
+  describe("listRecipes", () => {
+    it("returns parsed list when openclaw succeeds", async () => {
+      const items: RecipeListItem[] = [
+        { id: "r1", name: "R1", kind: "agent", source: "workspace" },
+      ];
+      vi.mocked(runOpenClaw).mockResolvedValue({
+        ok: true,
+        exitCode: 0,
+        stdout: JSON.stringify(items),
+        stderr: "",
+      });
+      expect(await listRecipes()).toEqual(items);
+    });
+
+    it("returns empty array when openclaw fails", async () => {
+      vi.mocked(runOpenClaw).mockResolvedValue({ ok: false, exitCode: 1, stdout: "", stderr: "err" });
+      expect(await listRecipes()).toEqual([]);
+    });
+
+    it("returns empty array when stdout is invalid JSON", async () => {
+      vi.mocked(runOpenClaw).mockResolvedValue({ ok: true, exitCode: 0, stdout: "not json", stderr: "" });
+      expect(await listRecipes()).toEqual([]);
+    });
+  });
+
+  describe("findRecipeById", () => {
+    it("returns item when found", async () => {
+      const item: RecipeListItem = { id: "x", name: "X", kind: "agent", source: "workspace" };
+      vi.mocked(runOpenClaw).mockResolvedValue({
+        ok: true,
+        exitCode: 0,
+        stdout: JSON.stringify([item]),
+        stderr: "",
+      });
+      expect(await findRecipeById("x")).toEqual(item);
+    });
+
+    it("returns null when not found", async () => {
+      vi.mocked(runOpenClaw).mockResolvedValue({
+        ok: true,
+        exitCode: 0,
+        stdout: JSON.stringify([]),
+        stderr: "",
+      });
+      expect(await findRecipeById("missing")).toBeNull();
+    });
+  });
+
+  describe("forceFrontmatterId", () => {
+    it("replaces existing id in frontmatter", () => {
+      const md = "---\nid: old\nname: Foo\n---\nBody";
+      expect(forceFrontmatterId(md, "new-id")).toContain("id: new-id");
+      expect(forceFrontmatterId(md, "new-id")).toContain("Body");
+    });
+
+    it("adds id when missing", () => {
+      const md = "---\nname: Foo\n---\nBody";
+      const out = forceFrontmatterId(md, "added");
+      expect(out).toMatch(/id:\s*added/);
+    });
+
+    it("returns md unchanged when no frontmatter", () => {
+      const md = "No frontmatter";
+      expect(forceFrontmatterId(md, "x")).toBe(md);
+    });
+  });
+
+  describe("parseFrontmatterId", () => {
+    it("returns id from valid frontmatter", () => {
+      const md = `---
+id: my-recipe
+name: My Recipe
+---
+# Content`;
+      expect(parseFrontmatterId(md)).toBe("my-recipe");
+    });
+
+    it("throws when markdown does not start with ---", () => {
+      expect(() => parseFrontmatterId("no frontmatter")).toThrow(
+        "Recipe markdown must start with YAML frontmatter (---)"
+      );
+    });
+
+    it("throws when frontmatter not terminated", () => {
+      const md = `---
+id: x`;
+      expect(() => parseFrontmatterId(md)).toThrow("Recipe frontmatter not terminated (---)");
+    });
+
+    it("throws when id is missing", () => {
+      const md = `---
+name: Foo
+---
+# Content`;
+      expect(() => parseFrontmatterId(md)).toThrow("Recipe frontmatter must include id");
+    });
+
+    it("handles id with extra fields", () => {
+      const md = `---
+id: agent-recipe
+kind: agent
+---
+# Body`;
+      expect(parseFrontmatterId(md)).toBe("agent-recipe");
+    });
+  });
+
+  describe("resolveRecipePath", () => {
+    it("returns builtin path for builtin source", async () => {
+      vi.mocked(getBuiltinRecipesDir).mockResolvedValue("/builtin/recipes");
+      const item: RecipeListItem = { id: "foo", name: "Foo", kind: "agent", source: "builtin" };
+      const p = await resolveRecipePath(item);
+      expect(p).toBe(path.join("/builtin/recipes", "foo.md"));
+      expect(getBuiltinRecipesDir).toHaveBeenCalledOnce();
+    });
+
+    it("returns workspace path for workspace source", async () => {
+      vi.mocked(getWorkspaceRecipesDir).mockResolvedValue("/ws/recipes");
+      const item: RecipeListItem = { id: "bar", name: "Bar", kind: "team", source: "workspace" };
+      const p = await resolveRecipePath(item);
+      expect(p).toBe(path.join("/ws/recipes", "bar.md"));
+      expect(getWorkspaceRecipesDir).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe("readRecipe", () => {
+    it("returns detail with filePath when resolve succeeds", async () => {
+      vi.mocked(getWorkspaceRecipesDir).mockResolvedValue("/ws/recipes");
+      const item: RecipeListItem = { id: "r1", name: "R1", kind: "agent", source: "workspace" };
+      const content = "# Recipe content";
+      const result = await readRecipe(item, content);
+      expect(result).toEqual({
+        ...item,
+        content,
+        filePath: path.join("/ws/recipes", "r1.md"),
+      });
+    });
+
+    it("returns filePath null when resolve throws", async () => {
+      vi.mocked(getWorkspaceRecipesDir).mockRejectedValue(new Error("no config"));
+      const item: RecipeListItem = { id: "r2", name: "R2", kind: "team", source: "workspace" };
+      const result = await readRecipe(item, "body");
+      expect(result.content).toBe("body");
+      expect(result.filePath).toBeNull();
+    });
+  });
+
+  describe("writeRecipeFile", () => {
+    it("creates dir and writes file", async () => {
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+
+      await writeRecipeFile("/some/dir/recipe.md", "# Markdown");
+
+      expect(fs.mkdir).toHaveBeenCalledWith("/some/dir", { recursive: true });
+      expect(fs.writeFile).toHaveBeenCalledWith("/some/dir/recipe.md", "# Markdown", "utf8");
+    });
+  });
+});

package/src/lib/__tests__/scaffold-client.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { fetchScaffold } from "../scaffold-client";
+
+const mockFetch = vi.hoisted(() => vi.fn());
+
+describe("scaffold-client", () => {
+  beforeEach(() => {
+    vi.stubGlobal("fetch", mockFetch);
+    mockFetch.mockReset();
+  });
+
+  describe("fetchScaffold", () => {
+    it("sends team scaffold request with correct body", async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({ ok: true }),
+      });
+
+      const { res, json } = await fetchScaffold({
+        kind: "team",
+        recipeId: "my-recipe",
+        teamId: "my-team",
+        cronInstallChoice: "yes",
+      });
+
+      expect(res.ok).toBe(true);
+      expect(json).toEqual({ ok: true });
+      expect(mockFetch).toHaveBeenCalledWith("/api/scaffold", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          kind: "team",
+          recipeId: "my-recipe",
+          teamId: "my-team",
+          cronInstallChoice: "yes",
+          applyConfig: true,
+          overwrite: false,
+        }),
+      });
+    });
+
+    it("sends agent scaffold request with correct body", async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({ ok: true, stderr: "" }),
+      });
+
+      const { res, json } = await fetchScaffold({
+        kind: "agent",
+        recipeId: "template",
+        agentId: "my-agent",
+        name: "My Agent",
+      });
+
+      expect(res.ok).toBe(true);
+      expect(json).toEqual({ ok: true, stderr: "" });
+      expect(mockFetch).toHaveBeenCalledWith("/api/scaffold", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          kind: "agent",
+          recipeId: "template",
+          agentId: "my-agent",
+          name: "My Agent",
+          applyConfig: true,
+          overwrite: false,
+        }),
+      });
+    });
+
+    it("always adds applyConfig and overwrite to body", async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: async () => ({}),
+      });
+
+      await fetchScaffold({
+        kind: "agent",
+        recipeId: "r",
+        agentId: "a",
+      });
+
+      const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+      expect(body.applyConfig).toBe(true);
+      expect(body.overwrite).toBe(false);
+    });
+
+    it("returns res and parsed json on non-ok response", async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 500,
+        json: async () => ({ ok: false, error: "Scaffold failed" }),
+      });
+
+      const { res, json } = await fetchScaffold({
+        kind: "team",
+        recipeId: "r",
+        teamId: "t",
+      });
+
+      expect(res.ok).toBe(false);
+      expect(res.status).toBe(500);
+      expect(json).toEqual({ ok: false, error: "Scaffold failed" });
+    });
+  });
+});

package/src/lib/__tests__/scaffold.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+import { buildScaffoldArgs } from "../scaffold";
+
+describe("scaffold", () => {
+  describe("buildScaffoldArgs", () => {
+    it("builds minimal agent args", () => {
+      expect(
+        buildScaffoldArgs({ kind: "agent", recipeId: "my-agent" })
+      ).toEqual(["recipes", "scaffold", "my-agent"]);
+    });
+
+    it("builds agent args with agentId and name", () => {
+      expect(
+        buildScaffoldArgs({
+          kind: "agent",
+          recipeId: "template",
+          agentId: "my-agent",
+          name: "My Agent",
+        })
+      ).toEqual([
+        "recipes",
+        "scaffold",
+        "template",
+        "--agent-id",
+        "my-agent",
+        "--name",
+        "My Agent",
+      ]);
+    });
+
+    it("adds overwrite and applyConfig for agent", () => {
+      expect(
+        buildScaffoldArgs({
+          kind: "agent",
+          recipeId: "r",
+          overwrite: true,
+          applyConfig: true,
+        })
+      ).toEqual(["recipes", "scaffold", "r", "--overwrite", "--apply-config", "--overwrite-recipe"]);
+    });
+
+    it("builds minimal team args", () => {
+      expect(
+        buildScaffoldArgs({ kind: "team", recipeId: "my-team" })
+      ).toEqual(["recipes", "scaffold-team", "my-team"]);
+    });
+
+    it("adds teamId for team", () => {
+      expect(
+        buildScaffoldArgs({
+          kind: "team",
+          recipeId: "template",
+          teamId: "my-team",
+        })
+      ).toEqual([
+        "recipes",
+        "scaffold-team",
+        "template",
+        "--team-id",
+        "my-team",
+      ]);
+    });
+  });
+});

package/src/lib/__tests__/slugify.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { slugifyId } from "../slugify";
+
+describe("slugifyId", () => {
+  it("lowercases and replaces spaces with hyphens", () => {
+    expect(slugifyId("My Goal Title")).toBe("my-goal-title");
+  });
+
+  it("trims leading and trailing hyphens", () => {
+    expect(slugifyId("  --foo--  ")).toBe("foo");
+  });
+
+  it("respects maxLength parameter", () => {
+    const long = "a".repeat(100);
+    expect(slugifyId(long, 64).length).toBe(64);
+    expect(slugifyId(long, 80).length).toBe(80);
+  });
+
+  it("returns empty for empty input", () => {
+    expect(slugifyId("")).toBe("");
+    expect(slugifyId("   ")).toBe("");
+  });
+});

package/src/lib/__tests__/tickets.test.ts

@@ -0,0 +1,158 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import {
+  parseTitle,
+  stageDir,
+  parseNumberFromFilename,
+  listTickets,
+  getTicketMarkdown,
+} from "../tickets";
+import fs from "node:fs/promises";
+
+vi.mock("node:fs/promises", () => ({
+  default: {
+    readdir: vi.fn(),
+    readFile: vi.fn(),
+    stat: vi.fn(),
+  },
+}));
+
+describe("tickets", () => {
+  describe("stageDir", () => {
+    it("maps each stage to correct path", () => {
+      expect(stageDir("backlog")).toContain("work/backlog");
+      expect(stageDir("in-progress")).toContain("work/in-progress");
+      expect(stageDir("testing")).toContain("work/testing");
+      expect(stageDir("done")).toContain("work/done");
+    });
+  });
+
+  describe("parseTitle", () => {
+    it("derives title from slug when no explicit title", () => {
+      expect(parseTitle("# 0033-fix-login-bug")).toBe("Fix Login Bug");
+      expect(parseTitle("# 0042-api-rate-limits")).toBe("API Rate Limits");
+    });
+
+    it("keeps explicit title when present", () => {
+      expect(parseTitle("# 0033-fix-login Fix the login bug")).toBe("Fix the login bug");
+    });
+
+    it("handles acronyms in slug", () => {
+      expect(parseTitle("# 0100-api-cli-integration")).toContain("API");
+      expect(parseTitle("# 0100-api-cli-integration")).toContain("CLI");
+    });
+
+    it("returns untitled for empty or missing header", () => {
+      expect(parseTitle("")).toBe("(untitled)");
+      expect(parseTitle("no header here")).toBe("(untitled)");
+    });
+  });
+
+  describe("parseNumberFromFilename", () => {
+    it("extracts 4-digit prefix", () => {
+      expect(parseNumberFromFilename("0033-fix-login.md")).toBe(33);
+      expect(parseNumberFromFilename("0042-something.md")).toBe(42);
+      expect(parseNumberFromFilename("0001-first.md")).toBe(1);
+    });
+
+    it("returns null for invalid filenames", () => {
+      expect(parseNumberFromFilename("abc-def.md")).toBeNull();
+      expect(parseNumberFromFilename("33-something.md")).toBeNull();
+      expect(parseNumberFromFilename("00333-too-long.md")).toBeNull();
+    });
+  });
+
+  describe("listTickets", () => {
+    beforeEach(() => {
+      vi.mocked(fs.readdir).mockReset();
+      vi.mocked(fs.readFile).mockReset();
+      vi.mocked(fs.stat).mockReset();
+    });
+
+    it("returns tickets from all stages", async () => {
+      vi.mocked(fs.readdir)
+        .mockResolvedValueOnce(["0033-fix-login.md"])
+        .mockResolvedValueOnce([])
+        .mockResolvedValueOnce([])
+        .mockResolvedValueOnce([]);
+
+      vi.mocked(fs.readFile).mockResolvedValue("# 0033-fix-login Fix Login\n\nOwner: alice");
+      vi.mocked(fs.stat).mockResolvedValue({
+        mtime: new Date("2026-01-15T10:00:00Z"),
+        mtimeMs: new Date("2026-01-15T10:00:00Z").getTime(),
+      } as ReturnType<typeof fs.stat> extends Promise<infer T> ? T : never);
+
+      const result = await listTickets();
+      expect(result).toHaveLength(1);
+      expect(result[0].number).toBe(33);
+      expect(result[0].id).toBe("0033-fix-login");
+      expect(result[0].title).toBe("Fix Login");
+      expect(result[0].owner).toBe("alice");
+      expect(result[0].stage).toBe("backlog");
+    });
+
+    it("skips stages that throw", async () => {
+      vi.mocked(fs.readdir)
+        .mockRejectedValueOnce(new Error("no dir"))
+        .mockResolvedValueOnce([])
+        .mockResolvedValueOnce([])
+        .mockResolvedValueOnce([]);
+
+      const result = await listTickets();
+      expect(result).toEqual([]);
+    });
+
+    it("skips non-md files", async () => {
+      vi.mocked(fs.readdir)
+        .mockResolvedValueOnce(["0033-a.md", "readme.txt"])
+        .mockResolvedValueOnce([])
+        .mockResolvedValueOnce([])
+        .mockResolvedValueOnce([]);
+
+      vi.mocked(fs.readFile).mockResolvedValue("# 0033-a\n");
+      vi.mocked(fs.stat).mockResolvedValue({
+        mtime: new Date(),
+        mtimeMs: Date.now(),
+      } as ReturnType<typeof fs.stat> extends Promise<infer T> ? T : never);
+
+      const result = await listTickets();
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe("0033-a");
+    });
+  });
+
+  describe("getTicketMarkdown", () => {
+    beforeEach(() => {
+      vi.mocked(fs.readdir)
+        .mockResolvedValueOnce(["0033-fix.md"])
+        .mockResolvedValueOnce([])
+        .mockResolvedValueOnce([])
+        .mockResolvedValueOnce([]);
+      vi.mocked(fs.readFile)
+        .mockResolvedValueOnce("# 0033-fix Fix it\n")
+        .mockResolvedValueOnce("# 0033-fix Fix it\n");
+      vi.mocked(fs.stat).mockResolvedValue({
+        mtime: new Date(),
+        mtimeMs: Date.now(),
+      } as ReturnType<typeof fs.stat> extends Promise<infer T> ? T : never);
+    });
+
+    it("finds by id and returns markdown", async () => {
+      const result = await getTicketMarkdown("development-team", "0033-fix");
+      expect(result).not.toBeNull();
+      expect(result!.id).toBe("0033-fix");
+      expect(result!.markdown).toContain("Fix it");
+    });
+
+    it("finds by number", async () => {
+      const result = await getTicketMarkdown("development-team", "33");
+      expect(result).not.toBeNull();
+      expect(result!.id).toBe("0033-fix");
+    });
+
+    it("returns null when not found", async () => {
+      vi.mocked(fs.readdir).mockReset().mockResolvedValue([]);
+      const result = await getTicketMarkdown("development-team", "9999");
+      expect(result).toBeNull();
+    });
+  });
+});

package/src/lib/__tests__/type-guards.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { isRecord } from "../type-guards";
+
+describe("type-guards", () => {
+  describe("isRecord", () => {
+    it("returns true for plain objects", () => {
+      expect(isRecord({})).toBe(true);
+      expect(isRecord({ a: 1 })).toBe(true);
+    });
+    it("returns false for arrays and primitives", () => {
+      expect(isRecord([])).toBe(false);
+      expect(isRecord(null)).toBe(false);
+      expect(isRecord(undefined)).toBe(false);
+      expect(isRecord("x")).toBe(false);
+      expect(isRecord(1)).toBe(false);
+    });
+  });
+});

package/src/lib/__tests__/use-slugified-id.test.tsx

@@ -0,0 +1,120 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import { useSlugifiedId } from "../use-slugified-id";
+
+describe("useSlugifiedId", () => {
+  const mockSetName = vi.fn();
+  const mockSetId = vi.fn();
+  const mockSetIdTouched = vi.fn();
+
+  beforeEach(() => {
+    mockSetName.mockClear();
+    mockSetId.mockClear();
+    mockSetIdTouched.mockClear();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("returns derivedId from slugified name", () => {
+    const { result } = renderHook(() =>
+      useSlugifiedId({
+        open: true,
+        name: "My Agent",
+        setName: mockSetName,
+        id: "",
+        setId: mockSetId,
+        idTouched: false,
+        setIdTouched: mockSetIdTouched,
+      })
+    );
+    expect(result.current.derivedId).toBe("my-agent");
+  });
+
+  it("returns effectiveId as derivedId when idTouched is false", () => {
+    const { result } = renderHook(() =>
+      useSlugifiedId({
+        open: true,
+        name: "Test Name",
+        setName: mockSetName,
+        id: "custom-id",
+        setId: mockSetId,
+        idTouched: false,
+        setIdTouched: mockSetIdTouched,
+      })
+    );
+    expect(result.current.effectiveId).toBe("test-name");
+  });
+
+  it("returns effectiveId as id when idTouched is true", () => {
+    const { result } = renderHook(() =>
+      useSlugifiedId({
+        open: true,
+        name: "Test Name",
+        setName: mockSetName,
+        id: "custom-id",
+        setId: mockSetId,
+        idTouched: true,
+        setIdTouched: mockSetIdTouched,
+      })
+    );
+    expect(result.current.effectiveId).toBe("custom-id");
+  });
+
+  it("syncs derivedId to id when open and !idTouched", () => {
+    renderHook(() =>
+      useSlugifiedId({
+        open: true,
+        name: "Hello World",
+        setName: mockSetName,
+        id: "",
+        setId: mockSetId,
+        idTouched: false,
+        setIdTouched: mockSetIdTouched,
+      })
+    );
+    expect(mockSetId).toHaveBeenCalledWith("hello-world");
+  });
+
+  it("resets form when modal closes (open becomes false)", () => {
+    const { rerender } = renderHook(
+      ({ open }) =>
+        useSlugifiedId({
+          open,
+          name: "Test",
+          setName: mockSetName,
+          id: "test-id",
+          setId: mockSetId,
+          idTouched: true,
+          setIdTouched: mockSetIdTouched,
+        }),
+      { initialProps: { open: true } }
+    );
+
+    act(() => {
+      rerender({ open: false });
+    });
+
+    expect(mockSetIdTouched).toHaveBeenCalledWith(false);
+    expect(mockSetName).toHaveBeenCalledWith("");
+    expect(mockSetId).toHaveBeenCalledWith("");
+  });
+
+  it("uses custom slugify when provided", () => {
+    const customSlugify = (s: string) => s.toUpperCase().replace(/\s/g, "_");
+    const { result } = renderHook(() =>
+      useSlugifiedId({
+        open: true,
+        name: "foo bar",
+        setName: mockSetName,
+        id: "",
+        setId: mockSetId,
+        idTouched: false,
+        setIdTouched: mockSetIdTouched,
+        slugify: customSlugify,
+      })
+    );
+    expect(result.current.derivedId).toBe("FOO_BAR");
+  });
+});