@jiggai/kitchen 0.3.1 → 0.3.3

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

@@ -1,136 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import * as path from "node:path";
-import fs from "node:fs/promises";
-import {
-  readOpenClawConfig,
-  getWorkspaceDir,
-  getWorkspaceRecipesDir,
-  getWorkspaceGoalsDir,
-  getTeamWorkspaceDir,
-  getBuiltinRecipesDir,
-  teamDirFromBaseWorkspace,
-  assertSafeRelativeFileName,
-} from "../paths";
-
-vi.mock("node:fs/promises", () => ({
-  default: {
-    readFile: vi.fn(),
-  },
-}));
-
-describe("paths", () => {
-  beforeEach(() => {
-    vi.mocked(fs.readFile).mockReset();
-  });
-
-  describe("readOpenClawConfig", () => {
-    it("parses config from ~/.openclaw/openclaw.json", async () => {
-      const config = {
-        agents: { defaults: { workspace: "/home/user/workspace" } },
-      };
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(config));
-
-      const result = await readOpenClawConfig();
-      expect(result).toEqual(config);
-      expect(fs.readFile).toHaveBeenCalledWith(
-        path.join(process.env.HOME || "", ".openclaw", "openclaw.json"),
-        "utf8"
-      );
-    });
-  });
-
-  describe("getWorkspaceDir", () => {
-    it("returns workspace from config", async () => {
-      vi.mocked(fs.readFile).mockResolvedValue(
-        JSON.stringify({ agents: { defaults: { workspace: "/my/ws" } } })
-      );
-      expect(await getWorkspaceDir()).toBe("/my/ws");
-    });
-
-    it("throws when workspace not set", async () => {
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({}));
-      await expect(getWorkspaceDir()).rejects.toThrow(
-        "agents.defaults.workspace is not set"
-      );
-    });
-  });
-
-  describe("getWorkspaceRecipesDir", () => {
-    it("joins workspace with recipes", async () => {
-      vi.mocked(fs.readFile).mockResolvedValue(
-        JSON.stringify({ agents: { defaults: { workspace: "/ws" } } })
-      );
-      expect(await getWorkspaceRecipesDir()).toBe("/ws/recipes");
-    });
-  });
-
-  describe("getWorkspaceGoalsDir", () => {
-    it("joins workspace with notes/goals", async () => {
-      vi.mocked(fs.readFile).mockResolvedValue(
-        JSON.stringify({ agents: { defaults: { workspace: "/ws" } } })
-      );
-      expect(await getWorkspaceGoalsDir()).toBe("/ws/notes/goals");
-    });
-  });
-
-  describe("getTeamWorkspaceDir", () => {
-    it("returns path for team workspace", async () => {
-      const home = process.env.HOME || "/home/user";
-      expect(await getTeamWorkspaceDir("my-team")).toBe(
-        path.join(home, ".openclaw", "workspace-my-team")
-      );
-    });
-  });
-
-  describe("teamDirFromBaseWorkspace", () => {
-    it("resolves team dir as sibling of base workspace", () => {
-      expect(teamDirFromBaseWorkspace("/home/x/.openclaw/agents", "my-team")).toBe(
-        path.join("/home/x/.openclaw", "workspace-my-team")
-      );
-    });
-  });
-
-  describe("assertSafeRelativeFileName", () => {
-    it("returns name when safe", () => {
-      expect(assertSafeRelativeFileName("TEAM.md")).toBe("TEAM.md");
-    });
-    it("throws on path traversal", () => {
-      expect(() => assertSafeRelativeFileName("../etc/passwd")).toThrow("Invalid file name");
-    });
-    it("throws on empty or leading slash", () => {
-      expect(() => assertSafeRelativeFileName("")).toThrow("Invalid file name");
-      expect(() => assertSafeRelativeFileName("/absolute")).toThrow("Invalid file name");
-    });
-  });
-
-  describe("getBuiltinRecipesDir", () => {
-    it("uses installPath when set", async () => {
-      vi.mocked(fs.readFile).mockResolvedValue(
-        JSON.stringify({
-          plugins: {
-            installs: { recipes: { installPath: "/plugins/claw" } },
-          },
-        })
-      );
-      expect(await getBuiltinRecipesDir()).toBe("/plugins/claw/recipes/default");
-    });
-
-    it("uses sourcePath when installPath not set", async () => {
-      vi.mocked(fs.readFile).mockResolvedValue(
-        JSON.stringify({
-          plugins: {
-            installs: { recipes: { sourcePath: "/src/claw" } },
-          },
-        })
-      );
-      expect(await getBuiltinRecipesDir()).toBe("/src/claw/recipes/default");
-    });
-
-    it("throws when no recipe path configured", async () => {
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({}));
-      await expect(getBuiltinRecipesDir()).rejects.toThrow(
-        "Could not determine recipes plugin install path"
-      );
-    });
-  });
-});

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

@@ -1,26 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { pollUntil } from "../poll";
-
-describe("poll", () => {
-  describe("pollUntil", () => {
-    it("returns result when check succeeds immediately", async () => {
-      const result = await pollUntil(async () => "done", { timeoutMs: 1000 });
-      expect(result).toBe("done");
-    });
-
-    it("returns result when check succeeds after retries", async () => {
-      let attempts = 0;
-      const result = await pollUntil(async () => {
-        attempts++;
-        return attempts >= 3 ? "ready" : null;
-      }, { timeoutMs: 5000, intervalMs: 10 });
-      expect(result).toBe("ready");
-      expect(attempts).toBe(3);
-    });
-
-    it("returns null when timeout", async () => {
-      const result = await pollUntil(async () => null, { timeoutMs: 50, intervalMs: 20 });
-      expect(result).toBeNull();
-    });
-  });
-});

package/src/lib/__tests__/recipe-clone.test.ts

@@ -1,85 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { suggestIds, scaffoldCmdForKind, patchFrontmatter } from "../recipe-clone";
-
-describe("recipe-clone", () => {
-  describe("suggestIds", () => {
-    it("returns suggested ids for base id", () => {
-      expect(suggestIds("my-agent")).toEqual([
-        "custom-my-agent",
-        "my-my-agent",
-        "my-agent-2",
-        "my-agent-alt",
-      ]);
-    });
-
-    it("uses recipe when base empty", () => {
-      expect(suggestIds("")).toEqual(["custom-recipe", "my-recipe", "recipe-2", "recipe-alt"]);
-    });
-  });
-
-  describe("scaffoldCmdForKind", () => {
-    it("returns team scaffold args", () => {
-      expect(scaffoldCmdForKind("team", "my-team")).toEqual([
-        "recipes",
-        "scaffold-team",
-        "my-team",
-        "--team-id",
-        "my-team",
-        "--overwrite",
-        "--overwrite-recipe",
-      ]);
-    });
-
-    it("returns agent scaffold args", () => {
-      expect(scaffoldCmdForKind("agent", "my-agent")).toEqual([
-        "recipes",
-        "scaffold",
-        "my-agent",
-        "--agent-id",
-        "my-agent",
-        "--overwrite",
-        "--overwrite-recipe",
-      ]);
-    });
-
-    it("returns null for unsupported kind", () => {
-      expect(scaffoldCmdForKind("other", "x")).toBeNull();
-    });
-  });
-
-  describe("patchFrontmatter", () => {
-    it("patches id and optionally name for agent", () => {
-      const md = `---
-id: source
-kind: agent
-name: Source Agent
----
-# Body`;
-      const { next, kind } = patchFrontmatter(md, "my-agent", "My Agent");
-      expect(kind).toBe("agent");
-      expect(next).toContain("id: my-agent");
-      expect(next).toContain("name: My Agent");
-      expect(next).toContain("# Body");
-    });
-
-    it("patches teamId for team kind", () => {
-      const md = `---
-id: source
-kind: team
----
-# Body`;
-      const { next, kind } = patchFrontmatter(md, "my-team", undefined);
-      expect(kind).toBe("team");
-      expect(next).toContain("id: my-team");
-      expect(next).toContain("teamId: my-team");
-    });
-
-    it("throws when frontmatter not terminated", () => {
-      const md = `---
-id: x`;
-      expect(() => patchFrontmatter(md, "y", undefined)).toThrow(
-        "Recipe frontmatter not terminated (---)"
-      );
-    });
-  });
-});

package/src/lib/__tests__/recipe-team-agents.test.ts

@@ -1,70 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { splitRecipeFrontmatter, normalizeRole, validateCreateId } from "../recipe-team-agents";
-
-describe("recipe-team-agents", () => {
-  describe("splitRecipeFrontmatter", () => {
-    it("returns yamlText and rest", () => {
-      const md = `---
-kind: team
-agents: []
----
-# Body`;
-      const { yamlText, rest } = splitRecipeFrontmatter(md);
-      expect(yamlText).toContain("kind: team");
-      expect(rest).toBe("# Body");
-    });
-
-    it("throws when not starting with ---", () => {
-      expect(() => splitRecipeFrontmatter("no frontmatter")).toThrow(
-        "Recipe markdown must start with YAML frontmatter (---)"
-      );
-    });
-
-    it("throws when frontmatter not terminated", () => {
-      expect(() => splitRecipeFrontmatter("---\nid: x")).toThrow(
-        "Recipe frontmatter not terminated (---)"
-      );
-    });
-  });
-
-  describe("normalizeRole", () => {
-    it("returns trimmed role", () => {
-      expect(normalizeRole("  lead  ")).toBe("lead");
-    });
-
-    it("throws when empty", () => {
-      expect(() => normalizeRole("")).toThrow("role is required");
-    });
-
-    it("throws when invalid format", () => {
-      expect(() => normalizeRole("bad!")).toThrow("role must be alphanumeric/dash");
-    });
-
-    it("accepts valid role", () => {
-      expect(normalizeRole("qa-lead")).toBe("qa-lead");
-    });
-  });
-
-  describe("validateCreateId", () => {
-    const recipe = { id: "my-recipe" };
-
-    it("returns null when recipe is null", () => {
-      expect(validateCreateId(null, "team-1", "team")).toBeNull();
-    });
-
-    it("returns error when id is empty", () => {
-      expect(validateCreateId(recipe, "", "team")).toBe("Team id is required.");
-      expect(validateCreateId(recipe, "  ", "agent")).toBe("Agent id is required.");
-    });
-
-    it("returns error when id matches recipe id", () => {
-      expect(validateCreateId(recipe, "my-recipe", "team")).toContain("cannot be the same");
-      expect(validateCreateId(recipe, "my-recipe", "agent")).toContain("cannot be the same");
-    });
-
-    it("returns null when valid", () => {
-      expect(validateCreateId(recipe, "team-1", "team")).toBeNull();
-      expect(validateCreateId(recipe, "agent-1", "agent")).toBeNull();
-    });
-  });
-});

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

@@ -1,199 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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",
-      ]);
-    });
-  });
-});