@jiggai/kitchen 0.3.1 → 0.3.3

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

@@ -1,15 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { errorMessage } from "../errors";
-
-describe("errorMessage", () => {
-  it("returns message for Error instances", () => {
-    expect(errorMessage(new Error("foo"))).toBe("foo");
-  });
-
-  it("returns string for non-Error values", () => {
-    expect(errorMessage("bar")).toBe("bar");
-    expect(errorMessage(42)).toBe("42");
-    expect(errorMessage(null)).toBe("null");
-    expect(errorMessage(undefined)).toBe("undefined");
-  });
-});

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

@@ -1,13 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { execFileAsync } from "../exec";
-
-describe("exec", () => {
-  it("exports execFileAsync as a function", () => {
-    expect(typeof execFileAsync).toBe("function");
-  });
-
-  it("invokes and returns stdout", async () => {
-    const result = await execFileAsync("echo", ["hello"], { encoding: "utf8" });
-    expect(result.stdout).toBe("hello\n");
-  });
-});

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

@@ -1,118 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { fetchAll, fetchJson, fetchJsonWithStatus } from "../fetch-json";
-
-describe("fetchAll", () => {
-  beforeEach(() => {
-    vi.stubGlobal(
-      "fetch",
-      vi.fn((url: string) =>
-        Promise.resolve({
-          ok: true,
-          text: () => Promise.resolve(`{"url":"${url}"}`),
-          json: () => Promise.resolve({ url }),
-        } as Response)
-      )
-    );
-  });
-
-  it("fetches multiple URLs in parallel with cache no-store", async () => {
-    const responses = await fetchAll(["https://a.com", "https://b.com"]);
-    expect(responses).toHaveLength(2);
-    expect(fetch).toHaveBeenCalledTimes(2);
-    expect(fetch).toHaveBeenCalledWith("https://a.com", { cache: "no-store" });
-    expect(fetch).toHaveBeenCalledWith("https://b.com", { cache: "no-store" });
-  });
-});
-
-describe("fetchJson", () => {
-  beforeEach(() => {
-    vi.stubGlobal(
-      "fetch",
-      vi.fn((url: string) => {
-        if (url.includes("/ok")) {
-          return Promise.resolve({
-            ok: true,
-            json: () => Promise.resolve({ data: "success" }),
-          } as Response);
-        }
-        if (url.includes("/error")) {
-          return Promise.resolve({
-            ok: false,
-            status: 400,
-            json: () => Promise.resolve({ error: "Bad request" }),
-          } as Response);
-        }
-        return Promise.resolve({
-          ok: false,
-          status: 500,
-          json: () => Promise.resolve({}),
-        } as Response);
-      })
-    );
-  });
-
-  it("returns parsed JSON on success", async () => {
-    const result = await fetchJson<{ data: string }>("https://example.com/ok");
-    expect(result).toEqual({ data: "success" });
-  });
-
-  it("throws with error message on !res.ok", async () => {
-    await expect(fetchJson("https://example.com/error")).rejects.toThrow("Bad request");
-  });
-
-  it("throws generic message when error field missing", async () => {
-    await expect(fetchJson("https://example.com/other")).rejects.toThrow("Request failed");
-  });
-});
-
-describe("fetchJsonWithStatus", () => {
-  beforeEach(() => {
-    vi.stubGlobal(
-      "fetch",
-      vi.fn((url: string) => {
-        if (url.includes("/ok")) {
-          return Promise.resolve({
-            ok: true,
-            json: () => Promise.resolve({ data: "success" }),
-          } as Response);
-        }
-        if (url.includes("/409")) {
-          return Promise.resolve({
-            ok: false,
-            status: 409,
-            json: () => Promise.resolve({ error: "Conflict" }),
-          } as Response);
-        }
-        return Promise.resolve({
-          ok: false,
-          status: 500,
-          json: () => Promise.resolve({}),
-        } as Response);
-      })
-    );
-  });
-
-  it("returns { ok: true, data } on success", async () => {
-    const result = await fetchJsonWithStatus<{ data: string }>("https://example.com/ok");
-    expect(result.ok).toBe(true);
-    if (result.ok) expect(result.data).toEqual({ data: "success" });
-  });
-
-  it("returns { ok: false, status, error } on HTTP error", async () => {
-    const result = await fetchJsonWithStatus("https://example.com/409");
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.status).toBe(409);
-      expect(result.error).toBe("Conflict");
-    }
-  });
-
-  it("returns generic error when error field missing", async () => {
-    const result = await fetchJsonWithStatus("https://example.com/other");
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.status).toBe(500);
-      expect(result.error).toBe("Request failed");
-    }
-  });
-});

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

@@ -1,234 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { toolsInvoke, gatewayConfigGet, gatewayConfigPatch, getContentText } from "../gateway";
-
-vi.mock("@/lib/paths", () => ({
-  readOpenClawConfig: vi.fn(),
-}));
-
-import { readOpenClawConfig } from "@/lib/paths";
-
-const mockFetch = vi.hoisted(() => vi.fn());
-
-describe("gateway", () => {
-  beforeEach(() => {
-    vi.stubGlobal("fetch", mockFetch);
-    vi.mocked(readOpenClawConfig).mockReset();
-    mockFetch.mockReset();
-    vi.stubEnv("OPENCLAW_GATEWAY_HTTP_URL", "");
-    vi.stubEnv("OPENCLAW_GATEWAY_URL", "");
-    vi.stubEnv("OPENCLAW_GATEWAY_TOKEN", "");
-  });
-
-  describe("toolsInvoke", () => {
-    it("returns result when ok", async () => {
-      vi.mocked(readOpenClawConfig).mockResolvedValue({
-        gateway: { port: 18789, auth: { token: "test-token" } },
-      });
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => ({ ok: true, result: { foo: "bar" } }),
-      });
-
-      const r = await toolsInvoke({ tool: "test", action: "run" });
-      expect(r).toEqual({ foo: "bar" });
-      expect(mockFetch).toHaveBeenCalledWith(
-        "http://127.0.0.1:18789/tools/invoke",
-        expect.objectContaining({
-          method: "POST",
-          headers: expect.objectContaining({ authorization: "Bearer test-token" }),
-          body: JSON.stringify({ tool: "test", action: "run" }),
-        })
-      );
-    });
-
-    it("throws when res.ok false", async () => {
-      vi.mocked(readOpenClawConfig).mockResolvedValue({
-        gateway: { auth: { token: "t" } },
-      });
-      mockFetch.mockResolvedValue({
-        ok: false,
-        status: 500,
-        json: async () => ({ ok: false, error: "Server error" }),
-      });
-
-      await expect(toolsInvoke({ tool: "x" })).rejects.toThrow("Server error");
-    });
-
-    it("throws when json.ok false", async () => {
-      vi.mocked(readOpenClawConfig).mockResolvedValue({
-        gateway: { auth: { token: "t" } },
-      });
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => ({ ok: false, error: { message: "Tool failed" } }),
-      });
-
-      await expect(toolsInvoke({ tool: "x" })).rejects.toThrow("Tool failed");
-    });
-
-    it("throws when token missing", async () => {
-      vi.mocked(readOpenClawConfig).mockResolvedValue({});
-
-      await expect(toolsInvoke({ tool: "x" })).rejects.toThrow("Missing gateway token");
-    });
-
-    it("uses config token when env and config both set", async () => {
-      vi.stubEnv("OPENCLAW_GATEWAY_TOKEN", "env-token");
-      vi.mocked(readOpenClawConfig).mockResolvedValue({
-        gateway: { auth: { token: "config-token" } },
-      });
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => ({ ok: true, result: {} }),
-      });
-
-      await toolsInvoke({ tool: "x" });
-      expect(mockFetch).toHaveBeenCalledWith(
-        expect.any(String),
-        expect.objectContaining({
-          headers: expect.objectContaining({ authorization: "Bearer config-token" }),
-        })
-      );
-    });
-  });
-
-  describe("getContentText", () => {
-    it("returns text from content item with type text", () => {
-      expect(getContentText([{ type: "text", text: "hello" }])).toBe("hello");
-    });
-    it("returns undefined when no text item", () => {
-      expect(getContentText([{ type: "other" }])).toBeUndefined();
-      expect(getContentText([])).toBeUndefined();
-      expect(getContentText(undefined)).toBeUndefined();
-    });
-  });
-
-  describe("gatewayConfigGet", () => {
-    it("returns raw and hash from tool result", async () => {
-      vi.mocked(readOpenClawConfig).mockResolvedValue({
-        gateway: { auth: { token: "t" } },
-      });
-      const payload = {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              ok: true,
-              result: { raw: '{"key":"val"}', hash: "abc123" },
-            }),
-          },
-        ],
-      };
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => ({ ok: true, result: payload }),
-      });
-
-      const r = await gatewayConfigGet();
-      expect(r).toEqual({ raw: '{"key":"val"}', hash: "abc123" });
-    });
-
-    it("throws when text payload missing", async () => {
-      vi.mocked(readOpenClawConfig).mockResolvedValue({
-        gateway: { auth: { token: "t" } },
-      });
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => ({
-          ok: true,
-          result: { content: [{ type: "other" }] },
-        }),
-      });
-
-      await expect(gatewayConfigGet()).rejects.toThrow("gateway config.get: missing text payload");
-    });
-
-    it("throws when result.raw missing", async () => {
-      vi.mocked(readOpenClawConfig).mockResolvedValue({
-        gateway: { auth: { token: "t" } },
-      });
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => ({
-          ok: true,
-          result: {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({ ok: true, result: { hash: "x" } }),
-              },
-            ],
-          },
-        }),
-      });
-
-      await expect(gatewayConfigGet()).rejects.toThrow("gateway config.get: missing result.raw");
-    });
-
-    it("throws when result.hash missing", async () => {
-      vi.mocked(readOpenClawConfig).mockResolvedValue({
-        gateway: { auth: { token: "t" } },
-      });
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: async () => ({
-          ok: true,
-          result: {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({ ok: true, result: { raw: "{}" } }),
-              },
-            ],
-          },
-        }),
-      });
-
-      await expect(gatewayConfigGet()).rejects.toThrow("gateway config.get: missing result.hash");
-    });
-  });
-
-  describe("gatewayConfigPatch", () => {
-    it("calls toolsInvoke with patch and baseHash", async () => {
-      vi.mocked(readOpenClawConfig).mockResolvedValue({
-        gateway: { auth: { token: "t" } },
-      });
-      let callCount = 0;
-      mockFetch.mockImplementation(async () => {
-        callCount++;
-        if (callCount === 1) {
-          return {
-            ok: true,
-            json: async () => ({
-              ok: true,
-              result: {
-                content: [
-                  {
-                    type: "text",
-                    text: JSON.stringify({
-                      ok: true,
-                      result: { raw: "{}", hash: "h1" },
-                    }),
-                  },
-                ],
-              },
-            }),
-          };
-        }
-        return {
-          ok: true,
-          json: async () => ({ ok: true, result: {} }),
-        };
-      });
-
-      await gatewayConfigPatch({ newKey: "val" }, "Custom note");
-
-      expect(mockFetch).toHaveBeenCalledTimes(2);
-      const patchCall = mockFetch.mock.calls[1];
-      const body = JSON.parse(patchCall[1].body as string);
-      expect(body.args?.action).toBe("config.patch");
-      expect(body.args?.baseHash).toBe("h1");
-      expect(body.args?.note).toBe("Custom note");
-    });
-  });
-});

package/src/lib/__tests__/goal-promote.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { slugifyFilePart, ensureWorkflowInstructions } from "../goal-promote";
-
-describe("goal-promote", () => {
-  describe("slugifyFilePart", () => {
-    it("lowercases and hyphenates", () => {
-      expect(slugifyFilePart("My Goal Title")).toBe("my-goal-title");
-    });
-
-    it("strips leading and trailing hyphens", () => {
-      expect(slugifyFilePart("  --foo--  ")).toBe("foo");
-    });
-
-    it("truncates to 80 chars", () => {
-      const long = "a".repeat(100);
-      expect(slugifyFilePart(long).length).toBe(80);
-    });
-
-    it("handles empty input", () => {
-      expect(slugifyFilePart("")).toBe("");
-    });
-  });
-
-  describe("ensureWorkflowInstructions", () => {
-    it("returns body unchanged when marker present", () => {
-      const body = "Content\n<!-- goal-workflow -->\nMore";
-      expect(ensureWorkflowInstructions(body)).toBe(body);
-    });
-
-    it("appends workflow snippet when marker missing", () => {
-      const body = "## Existing";
-      const result = ensureWorkflowInstructions(body);
-      expect(result).toContain("## Existing");
-      expect(result).toContain("## Workflow");
-      expect(result).toContain("<!-- goal-workflow -->");
-      expect(result).toContain("Promote to inbox");
-    });
-  });
-});

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

@@ -1,26 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseCommaList } from "../goals-client";
-
-describe("goals-client", () => {
-  describe("parseCommaList", () => {
-    it("parses comma-separated string into trimmed array", () => {
-      expect(parseCommaList("a, b, c")).toEqual(["a", "b", "c"]);
-    });
-
-    it("filters empty strings", () => {
-      expect(parseCommaList("a,,b,  ,c")).toEqual(["a", "b", "c"]);
-    });
-
-    it("returns empty array for empty string", () => {
-      expect(parseCommaList("")).toEqual([]);
-    });
-
-    it("trims whitespace", () => {
-      expect(parseCommaList("  x  ,  y  ")).toEqual(["x", "y"]);
-    });
-
-    it("handles single item", () => {
-      expect(parseCommaList("only")).toEqual(["only"]);
-    });
-  });
-});