@jiggai/kitchen 0.3.1 → 0.3.3

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

@@ -1,275 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import * as path from "node:path";
-import fs from "node:fs/promises";
-import {
-  assertSafeGoalId,
-  splitFrontmatter,
-  normalizeFrontmatter,
-  listGoals,
-  readGoal,
-  writeGoal,
-  deleteGoal,
-  goalErrorStatus,
-  parseCommaList,
-} from "../goals";
-import { getWorkspaceGoalsDir } from "@/lib/paths";
-
-vi.mock("node:fs/promises", () => ({
-  default: {
-    mkdir: vi.fn(),
-    readdir: vi.fn(),
-    readFile: vi.fn(),
-    writeFile: vi.fn(),
-    unlink: vi.fn(),
-  },
-}));
-
-vi.mock("@/lib/paths", () => ({
-  getWorkspaceGoalsDir: vi.fn(),
-}));
-
-describe("goals", () => {
-  describe("assertSafeGoalId", () => {
-    it("accepts valid ids", () => {
-      expect(() => assertSafeGoalId("ab")).not.toThrow();
-      expect(() => assertSafeGoalId("my-goal-123")).not.toThrow();
-      expect(() => assertSafeGoalId("increase-trial-activation")).not.toThrow();
-    });
-
-    it("rejects invalid ids", () => {
-      expect(() => assertSafeGoalId("")).toThrow("Invalid goal id");
-      expect(() => assertSafeGoalId("A")).toThrow("Invalid goal id");
-      expect(() => assertSafeGoalId("invalid_id")).toThrow("Invalid goal id");
-      expect(() => assertSafeGoalId("no spaces")).toThrow("Invalid goal id");
-      expect(() => assertSafeGoalId("-leading")).toThrow("Invalid goal id");
-      expect(() => assertSafeGoalId("a".repeat(65))).toThrow("Invalid goal id");
-    });
-  });
-
-  describe("parseCommaList", () => {
-    it("parses comma-separated values", () => {
-      expect(parseCommaList("a, b, c")).toEqual(["a", "b", "c"]);
-      expect(parseCommaList("development-team, marketing-team")).toEqual(["development-team", "marketing-team"]);
-    });
-    it("trims and filters empty", () => {
-      expect(parseCommaList("  a , , b  ")).toEqual(["a", "b"]);
-      expect(parseCommaList("")).toEqual([]);
-    });
-  });
-
-  describe("goalErrorStatus", () => {
-    it("returns 400 for validation errors", () => {
-      expect(goalErrorStatus("Invalid goal id")).toBe(400);
-      expect(goalErrorStatus("Path traversal rejected")).toBe(400);
-    });
-    it("returns 500 for other errors", () => {
-      expect(goalErrorStatus("fs error")).toBe(500);
-    });
-  });
-
-  describe("splitFrontmatter", () => {
-    it("parses valid frontmatter", () => {
-      const md = `---
-id: foo
-title: My Goal
-status: active
----
-Body here`;
-      const { fm, body } = splitFrontmatter(md);
-      expect(fm).toEqual({ id: "foo", title: "My Goal", status: "active" });
-      expect(body.trim()).toBe("Body here");
-    });
-
-    it("returns empty fm and full body when no frontmatter", () => {
-      const md = "# Just markdown\n\nNo frontmatter";
-      const { fm, body } = splitFrontmatter(md);
-      expect(fm).toEqual({});
-      expect(body).toBe("# Just markdown\n\nNo frontmatter");
-    });
-
-    it("handles empty frontmatter", () => {
-      const md = `---
----
-Body`;
-      const { fm, body } = splitFrontmatter(md);
-      expect(fm).toEqual({});
-      // Implementation returns full md when closing --- not found from position 4
-      expect(body).toContain("Body");
-    });
-  });
-
-  describe("normalizeFrontmatter", () => {
-    it("normalizes full input", () => {
-      const input = {
-        id: "my-goal",
-        title: "My Goal",
-        status: "active",
-        tags: ["a", "b"],
-        teams: ["team1"],
-        updatedAt: "2026-01-01T00:00:00Z",
-      };
-      const result = normalizeFrontmatter(input, "fallback-id", "Fallback Title");
-      expect(result).toEqual({
-        id: "my-goal",
-        title: "My Goal",
-        status: "active",
-        tags: ["a", "b"],
-        teams: ["team1"],
-        updatedAt: "2026-01-01T00:00:00Z",
-      });
-    });
-
-    it("uses fallbacks for missing fields", () => {
-      const result = normalizeFrontmatter({}, "fb-id", "Fallback");
-      expect(result.id).toBe("fb-id");
-      expect(result.title).toBe("Fallback");
-      expect(result.status).toBe("planned");
-      expect(result.tags).toEqual([]);
-      expect(result.teams).toEqual([]);
-      expect(result.updatedAt).toBeDefined();
-    });
-
-    it("normalizes status to planned when invalid", () => {
-      const result = normalizeFrontmatter({ status: "invalid" }, "id", "Title");
-      expect(result.status).toBe("planned");
-    });
-
-    it("accepts active and done status", () => {
-      expect(normalizeFrontmatter({ status: "active" }, "id", "").status).toBe("active");
-      expect(normalizeFrontmatter({ status: "done" }, "id", "").status).toBe("done");
-    });
-
-    it("handles non-object input", () => {
-      const result = normalizeFrontmatter(null, "id", "t");
-      expect(result.id).toBe("id");
-      expect(result.title).toBe("t");
-    });
-  });
-
-  describe("listGoals", () => {
-    beforeEach(() => {
-      vi.mocked(getWorkspaceGoalsDir).mockResolvedValue("/mock-workspace/goals");
-      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
-    });
-
-    it("returns sorted goals", async () => {
-      vi.mocked(fs.readdir).mockResolvedValue(["goal-b.md", "goal-a.md"]);
-      vi.mocked(fs.readFile)
-        .mockResolvedValueOnce(`---
-id: goal-b
-title: B
-status: done
-tags: []
-teams: []
-updatedAt: 2026-01-02T00:00:00Z
----
-Body B`)
-        .mockResolvedValueOnce(`---
-id: goal-a
-title: A
-status: active
-tags: []
-teams: []
-updatedAt: 2026-01-01T00:00:00Z
----
-Body A`);
-
-      const result = await listGoals();
-      expect(result).toHaveLength(2);
-      expect(result[0].id).toBe("goal-a");
-      expect(result[0].status).toBe("active");
-      expect(result[1].id).toBe("goal-b");
-      expect(result[1].status).toBe("done");
-    });
-
-    it("returns empty array when no files", async () => {
-      vi.mocked(fs.readdir).mockResolvedValue([]);
-      const result = await listGoals();
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe("readGoal", () => {
-    beforeEach(() => {
-      vi.mocked(getWorkspaceGoalsDir).mockResolvedValue("/mock-workspace/goals");
-      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
-    });
-
-    it("returns goal when exists", async () => {
-      vi.mocked(fs.readFile).mockResolvedValue(`---
-id: my-goal
-title: My Goal
-status: active
----
-Body text`);
-
-      const result = await readGoal("my-goal");
-      expect(result).not.toBeNull();
-      expect(result!.frontmatter.id).toBe("my-goal");
-      expect(result!.frontmatter.title).toBe("My Goal");
-      expect(result!.body.trim()).toBe("Body text");
-    });
-
-    it("returns null when file not found", async () => {
-      vi.mocked(fs.readFile).mockRejectedValue({ code: "ENOENT" });
-      const result = await readGoal("missing-goal");
-      expect(result).toBeNull();
-    });
-
-    it("throws on invalid id", async () => {
-      await expect(readGoal("")).rejects.toThrow("Invalid goal id");
-    });
-  });
-
-  describe("writeGoal", () => {
-    beforeEach(() => {
-      vi.mocked(getWorkspaceGoalsDir).mockResolvedValue("/mock-workspace/goals");
-      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
-      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-    });
-
-    it("writes goal and returns frontmatter", async () => {
-      const result = await writeGoal({
-        id: "new-goal",
-        title: "New Goal",
-        body: "Content",
-      });
-      expect(result.frontmatter.id).toBe("new-goal");
-      expect(result.frontmatter.title).toBe("New Goal");
-      expect(fs.writeFile).toHaveBeenCalledWith(
-        path.join("/mock-workspace/goals", "new-goal.md"),
-        expect.stringContaining("New Goal"),
-        "utf8"
-      );
-    });
-
-    it("throws on invalid id", async () => {
-      await expect(writeGoal({ id: "bad id", title: "X", body: "" })).rejects.toThrow("Invalid goal id");
-    });
-  });
-
-  describe("deleteGoal", () => {
-    beforeEach(() => {
-      vi.mocked(getWorkspaceGoalsDir).mockResolvedValue("/mock-workspace/goals");
-      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
-      vi.mocked(fs.unlink).mockResolvedValue(undefined);
-    });
-
-    it("returns ok when deleted", async () => {
-      const result = await deleteGoal("my-goal");
-      expect(result).toEqual({ ok: true });
-      expect(fs.unlink).toHaveBeenCalledWith(path.join("/mock-workspace/goals", "my-goal.md"));
-    });
-
-    it("returns not_found when file missing", async () => {
-      vi.mocked(fs.unlink).mockRejectedValue({ code: "ENOENT" });
-      const result = await deleteGoal("missing");
-      expect(result).toEqual({ ok: false, reason: "not_found" });
-    });
-
-    it("throws on other errors", async () => {
-      vi.mocked(fs.unlink).mockRejectedValue(new Error("Permission denied"));
-      await expect(deleteGoal("my-goal")).rejects.toThrow("Permission denied");
-    });
-  });
-});

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

@@ -1,15 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { safeJsonParse } from "../json";
-
-describe("safeJsonParse", () => {
-  it("parses valid JSON", () => {
-    expect(safeJsonParse('{"a":1}')).toEqual({ a: 1 });
-    expect(safeJsonParse("[1,2]")).toEqual([1, 2]);
-    expect(safeJsonParse('"hi"')).toBe("hi");
-  });
-
-  it("returns null for invalid JSON", () => {
-    expect(safeJsonParse("not json")).toBeNull();
-    expect(safeJsonParse("{")).toBeNull();
-  });
-});

package/src/lib/__tests__/kitchen-api.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it, beforeEach, afterEach } from "vitest";
-import { getKitchenApi } from "../kitchen-api";
-
-describe("kitchen-api", () => {
-  beforeEach(() => {
-    delete (globalThis as unknown as { __clawkitchen_api?: unknown }).__clawkitchen_api;
-  });
-
-  afterEach(() => {
-    delete (globalThis as unknown as { __clawkitchen_api?: unknown }).__clawkitchen_api;
-  });
-
-  it("throws when __clawkitchen_api is missing", () => {
-    expect(() => getKitchenApi()).toThrow(
-      "ClawKitchen: OpenClaw plugin API not available"
-    );
-  });
-
-  it("returns api when __clawkitchen_api is set", () => {
-    const mockApi = {
-      config: {},
-      runtime: {
-        system: {
-          runCommandWithTimeout: async () => ({ stdout: "", stderr: "" }),
-        },
-      },
-    };
-    (globalThis as unknown as { __clawkitchen_api?: unknown }).__clawkitchen_api = mockApi;
-
-    expect(getKitchenApi()).toBe(mockApi);
-  });
-});

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

@@ -1,116 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { loadRegistry, search, getBySlug, type MarketplaceRecipe } from "../marketplace";
-
-vi.mock("node:fs/promises", () => ({
-  default: { readFile: vi.fn() },
-}));
-
-import fs from "node:fs/promises";
-
-describe("marketplace", () => {
-  const sampleRecipes: MarketplaceRecipe[] = [
-    {
-      slug: "my-agent",
-      kind: "agent",
-      name: "My Agent",
-      description: "Does stuff with AI",
-      version: "1.0.0",
-      tags: ["agent", "ai"],
-      sourceUrl: "https://example.com/repo",
-    },
-    {
-      slug: "team-template",
-      kind: "team",
-      name: "Team Template",
-      description: "Multi-agent collaboration",
-      version: "0.1.0",
-      tags: ["team", "collab"],
-      sourceUrl: "https://example.com/team",
-    },
-  ];
-
-  beforeEach(() => {
-    vi.mocked(fs.readFile).mockReset();
-  });
-
-  describe("loadRegistry", () => {
-    it("returns parsed registry when valid", async () => {
-      const reg = {
-        version: 1,
-        generatedAt: "2025-01-01T00:00:00Z",
-        recipes: sampleRecipes,
-      };
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(reg));
-
-      const result = await loadRegistry();
-      expect(result.version).toBe(1);
-      expect(result.recipes).toHaveLength(2);
-      expect(result.recipes[0].slug).toBe("my-agent");
-    });
-
-    it("throws when registry is invalid (no recipes array)", async () => {
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({ version: 1 }));
-
-      await expect(loadRegistry()).rejects.toThrow("Invalid marketplace registry.json");
-    });
-
-    it("throws when recipes is not array", async () => {
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({ version: 1, recipes: "bad" }));
-
-      await expect(loadRegistry()).rejects.toThrow("Invalid marketplace registry.json");
-    });
-  });
-
-  describe("search", () => {
-    it("returns all when query is null or empty", () => {
-      expect(search(sampleRecipes, null)).toEqual(sampleRecipes);
-      expect(search(sampleRecipes, "")).toEqual(sampleRecipes);
-      expect(search(sampleRecipes, "   ")).toEqual(sampleRecipes);
-    });
-
-    it("filters by name match", () => {
-      const r = search(sampleRecipes, "template");
-      expect(r).toHaveLength(1);
-      expect(r[0].name).toBe("Team Template");
-    });
-
-    it("filters by slug match", () => {
-      const r = search(sampleRecipes, "team-template");
-      expect(r).toHaveLength(1);
-      expect(r[0].slug).toBe("team-template");
-    });
-
-    it("filters by description", () => {
-      const r = search(sampleRecipes, "collaboration");
-      expect(r).toHaveLength(1);
-      expect(r[0].name).toBe("Team Template");
-    });
-
-    it("is case insensitive", () => {
-      const r = search(sampleRecipes, "COLLAB");
-      expect(r).toHaveLength(1);
-    });
-  });
-
-  describe("getBySlug", () => {
-    it("returns recipe when slug matches", () => {
-      const r = getBySlug(sampleRecipes, "my-agent");
-      expect(r).not.toBeNull();
-      expect(r!.slug).toBe("my-agent");
-    });
-
-    it("returns null when slug not found", () => {
-      expect(getBySlug(sampleRecipes, "nonexistent")).toBeNull();
-    });
-
-    it("is case insensitive", () => {
-      const r = getBySlug(sampleRecipes, "MY-AGENT");
-      expect(r?.slug).toBe("my-agent");
-    });
-
-    it("trims query", () => {
-      const r = getBySlug(sampleRecipes, "  my-agent  ");
-      expect(r?.slug).toBe("my-agent");
-    });
-  });
-});

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

@@ -1,129 +0,0 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
-import { runOpenClaw } from "../openclaw";
-
-const mockRunCommand = vi.hoisted(() => vi.fn());
-
-describe("openclaw", () => {
-  beforeEach(() => {
-    mockRunCommand.mockReset();
-    (globalThis as unknown as { __clawkitchen_api?: unknown }).__clawkitchen_api = {
-      runtime: {
-        system: {
-          runCommandWithTimeout: mockRunCommand,
-        },
-      },
-    };
-  });
-
-  afterEach(() => {
-    delete (globalThis as unknown as { __clawkitchen_api?: unknown }).__clawkitchen_api;
-  });
-
-  describe("runOpenClaw", () => {
-    it("returns ok true when exit is 0", async () => {
-      mockRunCommand.mockResolvedValue({
-        stdout: "stdout\n",
-        stderr: "stderr",
-        exitCode: 0,
-      });
-
-      const result = await runOpenClaw(["recipes", "list"]);
-      expect(result.ok).toBe(true);
-      expect(result.exitCode).toBe(0);
-      expect(result.stdout).toBe("stdout\n");
-      expect(result.stderr).toBe("stderr");
-    });
-
-    it("returns ok false with stdout/stderr on non-zero exit", async () => {
-      const err = new Error("Command failed") as Error & { code?: number; stdout?: string; stderr?: string };
-      err.code = 1;
-      err.stdout = "out";
-      err.stderr = "err";
-
-      mockRunCommand.mockRejectedValue(err);
-
-      const result = await runOpenClaw(["bad", "cmd"]);
-      expect(result.ok).toBe(false);
-      expect(result.exitCode).toBe(1);
-      expect(result.stdout).toBe("out");
-      expect(result.stderr).toBe("err");
-    });
-
-    it("uses err.message as stderr fallback when stderr missing", async () => {
-      const err = new Error("Something went wrong") as Error & { code?: number };
-      err.code = 2;
-
-      mockRunCommand.mockRejectedValue(err);
-
-      const result = await runOpenClaw(["fail"]);
-      expect(result.ok).toBe(false);
-      expect(result.exitCode).toBe(2);
-      expect(result.stderr).toBe("Something went wrong");
-    });
-
-    it("uses numeric code from error", async () => {
-      const err = new Error("fail") as Error & { code?: number };
-      err.code = 42;
-
-      mockRunCommand.mockRejectedValue(err);
-
-      const result = await runOpenClaw(["x"]);
-      expect(result.exitCode).toBe(42);
-    });
-
-    it("defaults exitCode to 1 when code not numeric", async () => {
-      const err = new Error("fail");
-
-      mockRunCommand.mockRejectedValue(err);
-
-      const result = await runOpenClaw(["x"]);
-      expect(result.exitCode).toBe(1);
-    });
-
-    it("extracts stdout from object with toString when rejected", async () => {
-      const err = new Error("fail") as Error & { code?: number; stdout?: unknown };
-      err.code = 1;
-      err.stdout = { toString: () => "custom-out" };
-
-      mockRunCommand.mockRejectedValue(err);
-
-      const result = await runOpenClaw(["x"]);
-      expect(result.stdout).toBe("custom-out");
-    });
-
-    it("extracts stderr from object with toString when rejected", async () => {
-      const err = new Error("fail") as Error & { code?: number; stderr?: unknown };
-      err.code = 1;
-      err.stderr = { toString: () => "custom-err" };
-
-      mockRunCommand.mockRejectedValue(err);
-
-      const result = await runOpenClaw(["x"]);
-      expect(result.stderr).toBe("custom-err");
-    });
-
-    it("uses code from result when exitCode missing", async () => {
-      mockRunCommand.mockResolvedValue({
-        stdout: "",
-        stderr: "",
-        code: 2,
-      });
-
-      const result = await runOpenClaw(["x"]);
-      expect(result.ok).toBe(false);
-      expect(result.exitCode).toBe(2);
-    });
-
-    it("uses status from result when exitCode and code missing", async () => {
-      mockRunCommand.mockResolvedValue({
-        stdout: "",
-        stderr: "",
-        status: 3,
-      });
-
-      const result = await runOpenClaw(["x"]);
-      expect(result.ok).toBe(false);
-      expect(result.exitCode).toBe(3);
-    });
-  });
-});