@jiggai/kitchen 0.3.1 → 0.3.3

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

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

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

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

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

package/src/lib/agent-workspace.ts

@@ -1,14 +0,0 @@
-import path from "node:path";
-
-export function parseTeamRoleWorkspace(ws: string):
-  | { kind: "teamRole"; teamDir: string; teamId: string; roleDir: string; role: string }
-  | { kind: "other" } {
-  const normalized = ws.replace(/\\/g, "/");
-  const m = normalized.match(/^(.*\/workspace-([^\/]+))\/roles\/([^\/]+)\/?$/);
-  if (!m) return { kind: "other" };
-  const teamDir = m[1];
-  const teamId = m[2];
-  const role = m[3];
-  const roleDir = path.join(teamDir, "roles", role);
-  return { kind: "teamRole", teamDir, teamId, roleDir, role };
-}

package/src/lib/agents.ts

@@ -1,17 +0,0 @@
-import { runOpenClaw } from "./openclaw";
-
-export type AgentListItem = {
-  id: string;
-  identityName?: string;
-  workspace?: string;
-  model?: string;
-  isDefault?: boolean;
-};
-
-export async function resolveAgentWorkspace(agentId: string): Promise<string> {
-  const { stdout } = await runOpenClaw(["agents", "list", "--json"]);
-  const list = JSON.parse(stdout) as AgentListItem[];
-  const agent = list.find((a) => a.id === agentId);
-  if (!agent?.workspace) throw new Error(`Agent workspace not found for ${agentId}`);
-  return agent.workspace;
-}

package/src/lib/api-route-helpers.ts

@@ -1,157 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { NextResponse } from "next/server";
-
-/** Parses JSON body; returns 400 on parse error. */
-export async function parseJsonBody(req: Request): Promise<{ body: Record<string, unknown> } | NextResponse> {
-  let body: unknown;
-  try {
-    body = await req.json();
-  } catch {
-    return NextResponse.json({ ok: false, error: "Invalid JSON" }, { status: 400 });
-  }
-  const o = body && typeof body === "object" ? (body as Record<string, unknown>) : {};
-  return { body: o };
-}
-
-/** Returns NextResponse.json({ ok: true, ...rest }) from a storage result with ok field. */
-export function jsonOkRest<T extends { ok: boolean }>(r: T): NextResponse {
-  const rest = Object.fromEntries(Object.entries(r as Record<string, unknown>).filter(([k]) => k !== "ok"));
-  return NextResponse.json({ ok: true, ...rest });
-}
-
-import { resolveAgentWorkspace } from "@/lib/agents";
-import { errorMessage } from "@/lib/errors";
-
-/** Runs async storage fn and returns jsonOkRest on success, or 500 on error. */
-export async function withStorageError<T extends { ok: boolean }>(
-  fn: () => Promise<T>
-): Promise<NextResponse> {
-  try {
-    return jsonOkRest(await fn());
-  } catch (err: unknown) {
-    return NextResponse.json({ ok: false, error: errorMessage(err) }, { status: 500 });
-  }
-}
-import { readOpenClawConfig, teamDirFromBaseWorkspace } from "@/lib/paths";
-
-export type TeamContext = { teamId: string; teamDir: string };
-
-/** Error response for install-skill openclaw failures. Use when runOpenClaw returns !ok. */
-export function installSkillErrorResponse(
-  args: string[],
-  res: { stdout?: string; stderr?: string; exitCode?: number },
-  extra?: Record<string, unknown>
-): NextResponse {
-  const stdout = res.stdout?.trim();
-  const stderr = res.stderr?.trim();
-  return NextResponse.json(
-    {
-      ok: false,
-      error: stderr || stdout || `openclaw ${args.join(" ")} failed (exit=${res.exitCode})`,
-      stdout: res.stdout,
-      stderr: res.stderr,
-      ...extra,
-    },
-    { status: 500 }
-  );
-}
-
-async function resolveTeamContext(teamId: string): Promise<TeamContext | NextResponse> {
-  if (!teamId) return NextResponse.json({ ok: false, error: "teamId is required" }, { status: 400 });
-
-  const cfg = await readOpenClawConfig();
-  const baseWorkspace = String(cfg.agents?.defaults?.workspace ?? "").trim();
-  if (!baseWorkspace) {
-    return NextResponse.json({ ok: false, error: "agents.defaults.workspace not set" }, { status: 500 });
-  }
-
-  const teamDir = teamDirFromBaseWorkspace(baseWorkspace, teamId);
-  return { teamId, teamDir };
-}
-
-/** Resolves teamId and teamDir from URL search params. Returns error response if invalid. */
-export async function getTeamContextFromQuery(req: Request): Promise<TeamContext | NextResponse> {
-  const { searchParams } = new URL(req.url);
-  const teamId = String(searchParams.get("teamId") ?? "").trim();
-  return resolveTeamContext(teamId);
-}
-
-/** Runs handler with team context from query; returns error response if context invalid. */
-export async function withTeamContextFromQuery(
-  req: Request,
-  handler: (ctx: TeamContext) => Promise<NextResponse>
-): Promise<NextResponse> {
-  const ctx = await getTeamContextFromQuery(req);
-  if (ctx instanceof NextResponse) return ctx;
-  return handler(ctx);
-}
-
-/** Resolves teamId and teamDir from parsed body. Caller must parse req.json() first. */
-export async function getTeamContextFromBody(body: { teamId?: string }): Promise<TeamContext | NextResponse> {
-  const teamId = String(body.teamId ?? "").trim();
-  return resolveTeamContext(teamId);
-}
-
-export type AgentContext = { agentId: string; ws: string };
-
-/** Resolves agentId and workspace from URL search params. Returns error response if invalid. */
-export async function getAgentContextFromQuery(req: Request): Promise<AgentContext | NextResponse> {
-  const { searchParams } = new URL(req.url);
-  const agentId = String(searchParams.get("agentId") ?? "").trim();
-  return resolveAgentContext(agentId);
-}
-
-/** Resolves agentId and workspace from parsed body. Caller must parse req.json() first. */
-export async function getAgentContextFromBody(body: { agentId?: string }): Promise<AgentContext | NextResponse> {
-  const agentId = String(body.agentId ?? "").trim();
-  return resolveAgentContext(agentId);
-}
-
-async function resolveAgentContext(agentId: string): Promise<AgentContext | NextResponse> {
-  if (!agentId) return NextResponse.json({ ok: false, error: "agentId is required" }, { status: 400 });
-  try {
-    const ws = await resolveAgentWorkspace(agentId);
-    return { agentId, ws };
-  } catch (e: unknown) {
-    return NextResponse.json({ ok: false, error: errorMessage(e) }, { status: 404 });
-  }
-}
-
-export type FileCandidate = { name: string; required: boolean; rationale: string };
-
-/** Lists workspace files with presence/size info. */
-export async function listWorkspaceFiles(
-  baseDir: string,
-  candidates: FileCandidate[]
-): Promise<
-  Array<{
-    name: string;
-    required: boolean;
-    rationale: string;
-    path: string;
-    missing: boolean;
-    size?: number;
-    updatedAtMs?: number;
-  }>
-> {
-  return Promise.all(
-    candidates.map(async (c) => {
-      const p = path.join(baseDir, c.name);
-      try {
-        const st = await fs.stat(p);
-        return {
-          name: c.name,
-          required: c.required,
-          rationale: c.rationale,
-          path: p,
-          missing: false,
-          size: st.size,
-          updatedAtMs: st.mtimeMs,
-        };
-      } catch {
-        return { name: c.name, required: c.required, rationale: c.rationale, path: p, missing: true };
-      }
-    })
-  );
-}

package/src/lib/cron.ts

@@ -1,40 +0,0 @@
-/**
- * Shared shape for cron job objects returned by the gateway cron tool.
- * Different callers may receive slightly different structures; these helpers normalize access.
- */
-export type CronJobShape = {
-  id?: unknown;
-  jobId?: unknown;
-  name?: unknown;
-  enabled?: unknown;
-  state?: { enabled?: unknown };
-};
-
-/** Typed cron job for UI display. API returns jobs that match this structure. */
-export type CronJob = {
-  id: string;
-  name?: string;
-  enabled?: boolean;
-  schedule?: { kind?: string; expr?: string; everyMs?: number };
-  state?: { nextRunAtMs?: number };
-  agentId?: string;
-  sessionTarget?: string;
-};
-
-export function cronJobId(j: CronJobShape): string {
-  return String(j.id ?? j.jobId ?? "").trim();
-}
-
-export function cronJobLabel(j: CronJobShape): string {
-  return String(j.name ?? j.id ?? j.jobId ?? "(unnamed)");
-}
-
-export function fmtCronSchedule(s?: CronJob["schedule"]): string {
-  if (!s) return "";
-  if (s.kind === "cron" && s.expr) return s.expr;
-  if (s.kind === "every" && s.everyMs) {
-    const mins = Math.round(s.everyMs / 60000);
-    return mins >= 60 ? `every ${Math.round(mins / 60)}h` : `every ${mins}m`;
-  }
-  return s.kind ?? "";
-}

package/src/lib/editor-utils.ts

@@ -1,18 +0,0 @@
-export type FileListEntry = {
-  name: string;
-  missing: boolean;
-  required: boolean;
-  rationale?: string;
-};
-
-export function normalizeFileListEntries(files: unknown[]): FileListEntry[] {
-  return files.map((f) => {
-    const entry = f as { name?: unknown; missing?: unknown; required?: unknown; rationale?: unknown };
-    return {
-      name: String(entry.name ?? ""),
-      missing: Boolean(entry.missing),
-      required: Boolean(entry.required),
-      rationale: typeof entry.rationale === "string" ? entry.rationale : undefined,
-    };
-  });
-}

package/src/lib/errors.ts

@@ -1,7 +0,0 @@
-/**
- * Extracts a string message from an unknown error value.
- * Used consistently across API routes and client components.
- */
-export function errorMessage(e: unknown): string {
-  return e instanceof Error ? e.message : String(e);
-}

package/src/lib/exec.ts

@@ -1,4 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-
-export const execFileAsync = promisify(execFile);

package/src/lib/fetch-json.ts

@@ -1,29 +0,0 @@
-/** Fetches multiple URLs in parallel with cache: "no-store". */
-export async function fetchAll(urls: string[]): Promise<Response[]> {
-  return Promise.all(urls.map((url) => fetch(url, { cache: "no-store" })));
-}
-
-/**
- * Fetches JSON and throws on !res.ok.
- * Use errorMessage(e) in catch blocks.
- */
-export async function fetchJson<T = unknown>(url: string, opts?: RequestInit): Promise<T> {
-  const res = await fetch(url, opts);
-  const json = (await res.json()) as { error?: string };
-  if (!res.ok) throw new Error(json.error ?? "Request failed");
-  return json as T;
-}
-
-/**
- * Fetches JSON and returns result with status. Use when you need to handle specific
- * HTTP status codes (e.g. 409) differently from generic errors.
- */
-export async function fetchJsonWithStatus<T = unknown>(
-  url: string,
-  opts?: RequestInit
-): Promise<{ ok: true; data: T } | { ok: false; status: number; error: string }> {
-  const res = await fetch(url, opts);
-  const json = (await res.json()) as { error?: string };
-  if (res.ok) return { ok: true, data: json as T };
-  return { ok: false, status: res.status, error: json.error ?? "Request failed" };
-}