@jiggai/kitchen 0.1.12 → 0.2.0

package/src/app/api/recipes/delete/route.ts

@@ -1,37 +1,24 @@
 import { NextResponse } from "next/server";
+import path from "node:path";
 import { runOpenClaw } from "@/lib/openclaw";
-import { resolveRecipePath, type RecipeListItem } from "@/lib/recipes";
+import { findRecipeById, resolveRecipePath } from "@/lib/recipes";
 import fs from "node:fs/promises";
-import path from "node:path";
+import { getAttachedTeams, getAttachedAgents } from "./helpers";
 
 export async function POST(req: Request) {
   const body = (await req.json()) as { id?: string };
   const id = String(body.id ?? "").trim();
   if (!id) return NextResponse.json({ ok: false, error: "id is required" }, { status: 400 });
 
-  // Look up recipe source/path.
-  const list = await runOpenClaw(["recipes", "list"]);
-  if (!list.ok) {
-    return NextResponse.json({ ok: false, error: list.stderr.trim() || "Failed to list recipes" }, { status: 500 });
-  }
-
-  let recipes: RecipeListItem[] = [];
-  try {
-    recipes = JSON.parse(list.stdout) as RecipeListItem[];
-  } catch {
-    return NextResponse.json({ ok: false, error: "Failed to parse recipes list" }, { status: 500 });
-  }
-
-  const item = recipes.find((r) => r.id === id);
+  const item = await findRecipeById(id);
   if (!item) return NextResponse.json({ ok: false, error: `Recipe not found: ${id}` }, { status: 404 });
   if (item.source === "builtin") {
     return NextResponse.json({ ok: false, error: `Recipe ${id} is builtin and cannot be deleted` }, { status: 403 });
   }
 
-  // Safety: only allow deleting files inside the workspace recipes directory.
   const workspaceRoot = (await runOpenClaw(["config", "get", "agents.defaults.workspace"]))?.stdout?.trim();
   if (!workspaceRoot) {
-    return NextResponse.json({ ok: false, error: "agents.defaults.workspace is not set" }, { status: 500 });
+    return NextResponse.json({ ok: false, error: "agents.defaults.workspace not set" }, { status: 500 });
   }
   const allowedDir = path.resolve(workspaceRoot, "recipes") + path.sep;
 
@@ -43,75 +30,22 @@ export async function POST(req: Request) {
 
   const kind = (item.kind ?? "team") as "team" | "agent";
 
-  // Block deletion if this recipe appears in use.
   if (kind === "team") {
-    // A team recipe can scaffold many teams with different teamIds.
-    // We treat any workspace-*/team.json referencing this recipe as "in use".
-    const teamsRoot = path.resolve(workspaceRoot, "..");
-    const attachedTeams: string[] = [];
-
-    try {
-      const entries = await fs.readdir(teamsRoot, { withFileTypes: true });
-      const workspaceDirs = entries.filter((e) => e.isDirectory() && e.name.startsWith("workspace-"));
-      for (const dirent of workspaceDirs) {
-        const metaPath = path.join(teamsRoot, dirent.name, "team.json");
-        try {
-          const raw = await fs.readFile(metaPath, "utf8");
-          const meta = JSON.parse(raw) as { recipeId?: unknown; teamId?: unknown };
-          if (String(meta.recipeId ?? "").trim() === id) {
-            attachedTeams.push(String(meta.teamId ?? dirent.name.replace(/^workspace-/, "")).trim() || dirent.name);
-          }
-        } catch {
-          // ignore missing/unparseable
-        }
-      }
-    } catch {
-      // ignore
-    }
-
+    const attachedTeams = await getAttachedTeams(workspaceRoot, id);
     if (attachedTeams.length) {
       return NextResponse.json(
         {
           ok: false,
-          error: `Team ${id} is in use by installed team(s): ${attachedTeams.join(", ")}. Remove the team(s) first, then delete the recipe. If no team is shown, you still have a .openclaw/workspace-${id} folder. Please remove the folder to delete this recipe.`, 
+          error: `Team ${id} is in use by installed team(s): ${attachedTeams.join(", ")}. Remove the team(s) first, then delete the recipe. If no team is shown, you still have a .openclaw/workspace-${id} folder. Please remove the folder to delete this recipe.`,
           details: { attachedTeams },
         },
-        { status: 409 },
+        { status: 409 }
       );
     }
   }
 
   if (kind === "agent") {
-    // Agent recipes can scaffold many agents with different agentIds.
-    // We treat any agents/<agentId>/agent.json referencing this recipe as "in use".
-    // Additionally, if an active agent exists with the SAME id as the recipe, we must block deletion
-    // (older installs may not have agent.json provenance yet).
-    const agentsRes = await runOpenClaw(["agents", "list", "--json"]);
-    const attachedAgents: string[] = [];
-    let hasSameIdAgent = false;
-
-    if (agentsRes.ok) {
-      try {
-        const agents = JSON.parse(agentsRes.stdout) as Array<{ id?: unknown }>;
-        hasSameIdAgent = agents.some((a) => String(a.id ?? "").trim() === id);
-
-        for (const a of agents) {
-          const agentId = String(a.id ?? "").trim();
-          if (!agentId) continue;
-          const metaPath = path.join(workspaceRoot, "agents", agentId, "agent.json");
-          try {
-            const raw = await fs.readFile(metaPath, "utf8");
-            const meta = JSON.parse(raw) as { recipeId?: unknown };
-            if (String(meta.recipeId ?? "").trim() === id) attachedAgents.push(agentId);
-          } catch {
-            // ignore missing/unparseable
-          }
-        }
-      } catch {
-        // ignore
-      }
-    }
-
+    const { attachedAgents, hasSameIdAgent } = await getAttachedAgents(workspaceRoot, id);
     if (hasSameIdAgent) {
       return NextResponse.json(
         {
@@ -119,10 +53,9 @@ export async function POST(req: Request) {
           error: `Agent recipe ${id} cannot be deleted because an active agent exists with the same id: ${id}. Delete the agent first, then delete the recipe.`,
           details: { agentId: id },
         },
-        { status: 409 },
+        { status: 409 }
       );
     }
-
     if (attachedAgents.length) {
       return NextResponse.json(
         {
@@ -130,7 +63,7 @@ export async function POST(req: Request) {
           error: `Agent recipe ${id} is in use by active agent(s): ${attachedAgents.join(", ")}. Delete the agent(s) first, then delete the recipe.`,
           details: { attachedAgents },
         },
-        { status: 409 },
+        { status: 409 }
       );
     }
   }

package/src/app/api/recipes/team-agents/__tests__/helpers.test.ts

@@ -0,0 +1,156 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import {
+  parseRecipeFrontmatter,
+  buildNextMarkdown,
+  handleRemove,
+  handleAdd,
+  handleAddLike,
+} from "../helpers";
+
+vi.mock("@/lib/openclaw", () => ({
+  runOpenClaw: vi.fn(),
+}));
+
+import { runOpenClaw } from "@/lib/openclaw";
+
+describe("recipes team-agents helpers", () => {
+  describe("parseRecipeFrontmatter", () => {
+    it("parses valid YAML with agents and templates", () => {
+      const yaml = `
+kind: team
+agents:
+  - role: lead
+    name: Lead
+templates:
+  lead.prompt: "# Prompt"
+`;
+      const { fm, agents, templates } = parseRecipeFrontmatter(yaml);
+      expect(fm.kind).toBe("team");
+      expect(agents).toHaveLength(1);
+      expect(agents[0]).toEqual({ role: "lead", name: "Lead" });
+      expect(templates).toEqual({ "lead.prompt": "# Prompt" });
+    });
+
+    it("handles empty YAML", () => {
+      const { fm, agents, templates } = parseRecipeFrontmatter("");
+      expect(fm).toEqual({});
+      expect(agents).toEqual([]);
+      expect(templates).toEqual({});
+    });
+
+    it("handles non-array agents", () => {
+      const { agents } = parseRecipeFrontmatter("agents: not-an-array");
+      expect(agents).toEqual([]);
+    });
+
+    it("handles non-object templates", () => {
+      const { templates } = parseRecipeFrontmatter("templates: []");
+      expect(templates).toEqual({});
+    });
+  });
+
+  describe("buildNextMarkdown", () => {
+    it("builds markdown with updated agents and templates", () => {
+      const fm = { kind: "team" };
+      const nextAgents = [{ role: "lead", name: "Lead" }];
+      const nextTemplates = { "lead.prompt": "content" };
+      const rest = "# Body";
+      const result = buildNextMarkdown(fm, nextAgents, nextTemplates, rest);
+      expect(result).toContain("---");
+      expect(result).toContain("kind: team");
+      expect(result).toContain("role: lead");
+      expect(result).toContain("# Body");
+    });
+
+    it("omits templates when empty", () => {
+      const fm = { kind: "team" };
+      const nextAgents: Array<Record<string, unknown>> = [];
+      const nextTemplates: Record<string, unknown> = {};
+      const result = buildNextMarkdown(fm, nextAgents, nextTemplates, "body");
+      expect(result).not.toContain("templates:");
+    });
+  });
+
+  describe("handleRemove", () => {
+    it("removes agent and role-prefixed templates", () => {
+      const agents = [
+        { role: "lead", name: "Lead" },
+        { role: "qa", name: "QA" },
+      ];
+      const templates = {
+        "lead.prompt": "x",
+        "qa.prompt": "y",
+        "other.stuff": "z",
+      };
+      const result = handleRemove(agents, templates, "lead");
+      expect(result.nextAgents).toHaveLength(1);
+      expect(result.nextAgents[0].role).toBe("qa");
+      expect(result.nextTemplates).toEqual({ "qa.prompt": "y", "other.stuff": "z" });
+      expect(result.addedRole).toBeNull();
+    });
+
+    it("returns addedRole null", () => {
+      const result = handleRemove([{ role: "x" }], {}, "x");
+      expect(result.addedRole).toBeNull();
+    });
+  });
+
+  describe("handleAdd", () => {
+    it("adds new agent when role not present", () => {
+      const agents: Array<Record<string, unknown>> = [];
+      const templates = {};
+      const result = handleAdd(agents, templates, "qa", "QA Lead");
+      expect(result.nextAgents).toHaveLength(1);
+      expect(result.nextAgents[0]).toEqual({ role: "qa", name: "QA Lead" });
+      expect(result.addedRole).toBe("qa");
+    });
+
+    it("updates existing agent when role present", () => {
+      const agents = [{ role: "qa", name: "Old" }];
+      const templates = {};
+      const result = handleAdd(agents, templates, "qa", "New Name");
+      expect(result.nextAgents).toHaveLength(1);
+      expect(result.nextAgents[0]).toEqual({ role: "qa", name: "New Name" });
+      expect(result.addedRole).toBe("qa");
+    });
+
+    it("copies templates without mutating", () => {
+      const agents: Array<Record<string, unknown>> = [];
+      const templates = { x: "y" };
+      const result = handleAdd(agents, templates, "qa", "");
+      expect(result.nextTemplates).toEqual({ x: "y" });
+    });
+  });
+
+  describe("handleAddLike", () => {
+    beforeEach(() => {
+      vi.mocked(runOpenClaw).mockResolvedValue({
+        ok: true,
+        stdout: JSON.stringify([{ id: "team1-lead" }]),
+        stderr: "",
+        exitCode: 0,
+      });
+    });
+
+    it("returns 400 when baseRole not found", async () => {
+      const agents: Array<Record<string, unknown>> = [];
+      const result = await handleAddLike(agents, {}, "lead", "New", "team1");
+      expect(result).toBeInstanceOf(Response);
+      const res = result as Response;
+      expect(res.status).toBe(400);
+      const json = await res.json();
+      expect(json.error).toContain("baseRole not found");
+    });
+
+    it("adds clone with suffixed role when base exists", async () => {
+      const agents = [{ role: "lead", name: "Lead" }];
+      const templates = { "lead.prompt": "content" };
+      const result = await handleAddLike(agents, templates, "lead", "Lead 2", "team1");
+      expect(result).not.toBeInstanceOf(Response);
+      const op = result as { nextAgents: Array<Record<string, unknown>>; nextTemplates: Record<string, unknown>; addedRole: string | null };
+      expect(op.nextAgents).toHaveLength(2);
+      expect(op.nextAgents[1].role).toMatch(/^lead(-\d+)?$/);
+      expect(op.addedRole).toBeTruthy();
+    });
+  });
+});

package/src/app/api/recipes/team-agents/helpers.ts

@@ -0,0 +1,151 @@
+import YAML from "yaml";
+import { NextResponse } from "next/server";
+import { runOpenClaw } from "@/lib/openclaw";
+import { splitRecipeFrontmatter, normalizeRole } from "@/lib/recipe-team-agents";
+
+export { splitRecipeFrontmatter as splitFrontmatter, normalizeRole };
+
+export function parseRecipeFrontmatter(yamlText: string) {
+  const fm = (YAML.parse(yamlText) ?? {}) as Record<string, unknown>;
+  const agentsRaw = fm.agents;
+  const agents: Array<Record<string, unknown>> = Array.isArray(agentsRaw)
+    ? (agentsRaw as Array<Record<string, unknown>>)
+    : [];
+  const templatesRaw = fm.templates;
+  const templates: Record<string, unknown> =
+    templatesRaw && typeof templatesRaw === "object" && !Array.isArray(templatesRaw)
+      ? (templatesRaw as Record<string, unknown>)
+      : {};
+  return { fm, agents, templates };
+}
+
+export function buildNextMarkdown(
+  fm: Record<string, unknown>,
+  nextAgents: Array<Record<string, unknown>>,
+  nextTemplates: Record<string, unknown>,
+  rest: string
+) {
+  const nextFm = {
+    ...fm,
+    agents: nextAgents,
+    ...(Object.keys(nextTemplates).length ? { templates: nextTemplates } : {}),
+  };
+  const nextYaml = YAML.stringify(nextFm).trimEnd();
+  return `---\n${nextYaml}\n---\n${rest}`;
+}
+
+export type OpResult = {
+  nextAgents: Array<Record<string, unknown>>;
+  nextTemplates: Record<string, unknown>;
+  addedRole: string | null;
+};
+
+export function handleRemove(
+  agents: Array<Record<string, unknown>>,
+  templates: Record<string, unknown>,
+  role: string
+): OpResult {
+  const nextAgents = agents.filter((a) => String(a.role ?? "") !== role);
+  const nextTemplates = { ...templates };
+  for (const k of Object.keys(nextTemplates)) {
+    if (k.startsWith(`${role}.`)) delete nextTemplates[k];
+  }
+  return { nextAgents, nextTemplates, addedRole: null };
+}
+
+export function handleAdd(
+  agents: Array<Record<string, unknown>>,
+  templates: Record<string, unknown>,
+  role: string,
+  name: string
+): OpResult {
+  const next = {
+    ...agents.find((a) => String(a.role ?? "") === role),
+    role,
+    ...(name ? { name } : {}),
+  };
+  const nextAgents = agents.slice();
+  const idx = nextAgents.findIndex((a) => String(a.role ?? "") === role);
+  if (idx === -1) nextAgents.push(next);
+  else nextAgents[idx] = next;
+  return { nextAgents, nextTemplates: { ...templates }, addedRole: role };
+}
+
+function maxSuffixFromUsedRoles(usedRoles: Set<string>, baseRole: string): number {
+  const escaped = baseRole.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+  let n = 1;
+  for (const r of usedRoles) {
+    if (r === baseRole) n = Math.max(n, 1);
+    const m = r.match(new RegExp(`^${escaped}-([0-9]+)$`));
+    if (m) {
+      const k = Number(m[1]);
+      if (Number.isFinite(k)) n = Math.max(n, k);
+    }
+  }
+  return n;
+}
+
+async function fetchExistingAgentIds(teamId: string): Promise<Set<string>> {
+  if (!teamId) return new Set<string>();
+  try {
+    const res = await runOpenClaw(["agents", "list", "--json"]);
+    if (!res.ok) return new Set<string>();
+    const items = JSON.parse(res.stdout) as Array<{ id?: unknown }>;
+    return new Set(items.map((a) => String(a.id ?? "").trim()).filter(Boolean));
+  } catch {
+    return new Set<string>();
+  }
+}
+
+function pickNextRole(
+  baseRole: string,
+  usedRoles: Set<string>,
+  existingAgentIds: Set<string>,
+  teamId: string,
+  n: number
+): string {
+  const isTaken = (role: string) =>
+    usedRoles.has(role) || (teamId ? existingAgentIds.has(`${teamId}-${role}`) : false);
+  if (!isTaken(baseRole)) return baseRole;
+  let i = Math.max(2, n + 1);
+  while (isTaken(`${baseRole}-${i}`)) i++;
+  return `${baseRole}-${i}`;
+}
+
+export async function handleAddLike(
+  agents: Array<Record<string, unknown>>,
+  templates: Record<string, unknown>,
+  baseRole: string,
+  name: string,
+  teamId: string
+): Promise<OpResult | NextResponse> {
+  const base = agents.find((a) => String(a.role ?? "") === baseRole);
+  if (!base) {
+    return NextResponse.json({ ok: false, error: `baseRole not found in recipe: ${baseRole}` }, { status: 400 });
+  }
+
+  const nextAgents = agents.slice();
+  const nextTemplates = { ...templates };
+  const usedRoles = new Set(nextAgents.map((a) => String(a.role ?? "").trim()).filter(Boolean));
+  const n = maxSuffixFromUsedRoles(usedRoles, baseRole);
+  const existingAgentIds = await fetchExistingAgentIds(teamId);
+  const nextRole = pickNextRole(baseRole, usedRoles, existingAgentIds, teamId, n);
+
+  const baseName = typeof (base as { name?: unknown }).name === "string" ? String((base as { name?: unknown }).name) : "";
+  const autoSuffix = nextRole === baseRole ? "" : String(nextRole.slice(baseRole.length + 1));
+  const suffixPart = autoSuffix ? ` ${autoSuffix}` : "";
+  const nextName = name || (baseName ? baseName + suffixPart : "");
+
+  const clone = { ...base, role: nextRole, ...(nextName ? { name: nextName } : {}) };
+  nextAgents.push(clone);
+
+  for (const [k, v] of Object.entries(templates)) {
+    if (!k.startsWith(`${baseRole}.`)) continue;
+    const suffix = k.slice(baseRole.length);
+    const nextKey = `${nextRole}${suffix}`;
+    if (nextTemplates[nextKey] === undefined) nextTemplates[nextKey] = v;
+  }
+
+  const addedRole = String((nextAgents[nextAgents.length - 1] as { role?: unknown } | undefined)?.role ?? "").trim() || null;
+  return { nextAgents, nextTemplates, addedRole };
+}

package/src/app/api/recipes/team-agents/route.ts

@@ -1,25 +1,16 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import YAML from "yaml";
 import { NextResponse } from "next/server";
 import { getWorkspaceRecipesDir } from "@/lib/paths";
-import { runOpenClaw } from "@/lib/openclaw";
-
-function splitFrontmatter(md: string) {
-  if (!md.startsWith("---\n")) throw new Error("Recipe markdown must start with YAML frontmatter (---)");
-  const end = md.indexOf("\n---\n", 4);
-  if (end === -1) throw new Error("Recipe frontmatter not terminated (---)");
-  const yamlText = md.slice(4, end + 1);
-  const rest = md.slice(end + 5);
-  return { yamlText, rest };
-}
-
-function normalizeRole(role: string) {
-  const r = role.trim();
-  if (!r) throw new Error("role is required");
-  if (!/^[a-z][a-z0-9-]{0,62}$/i.test(r)) throw new Error("role must be alphanumeric/dash");
-  return r;
-}
+import {
+  splitFrontmatter,
+  normalizeRole,
+  parseRecipeFrontmatter,
+  buildNextMarkdown,
+  handleRemove,
+  handleAdd,
+  handleAddLike,
+} from "./helpers";
 
 export async function POST(req: Request) {
   const body = (await req.json()) as {
@@ -45,134 +36,45 @@ export async function POST(req: Request) {
 
   const md = await fs.readFile(filePath, "utf8");
   const { yamlText, rest } = splitFrontmatter(md);
-  const fm = (YAML.parse(yamlText) ?? {}) as Record<string, unknown>;
+  const { fm, agents, templates } = parseRecipeFrontmatter(yamlText);
 
   const kind = String(fm.kind ?? "");
   if (kind && kind !== "team") {
     return NextResponse.json({ ok: false, error: `recipe kind must be team (got ${kind})` }, { status: 400 });
   }
 
-  const agentsRaw = fm.agents;
-  const agents: Array<Record<string, unknown>> = Array.isArray(agentsRaw)
-    ? (agentsRaw as Array<Record<string, unknown>>)
-    : [];
-
-  let nextAgents = agents.slice();
-
-  // Templates are optional, but if present we must keep them consistent with role duplication.
-  const templatesRaw = fm.templates;
-  const templates: Record<string, unknown> =
-    templatesRaw && typeof templatesRaw === "object" && !Array.isArray(templatesRaw)
-      ? (templatesRaw as Record<string, unknown>)
-      : {};
-  const nextTemplates: Record<string, unknown> = { ...templates };
+  let result: { nextAgents: Array<Record<string, unknown>>; nextTemplates: Record<string, unknown>; addedRole: string | null } | NextResponse;
 
   if (op === "remove") {
     const role = normalizeRole(String(body.role ?? ""));
-    nextAgents = nextAgents.filter((a) => String(a.role ?? "") !== role);
-
-    // Best-effort: remove templates for this role as well.
-    for (const k of Object.keys(nextTemplates)) {
-      if (k.startsWith(`${role}.`)) delete nextTemplates[k];
-    }
+    result = handleRemove(agents, templates, role);
   } else if (op === "add") {
     const role = normalizeRole(String(body.role ?? ""));
-    // add or update by role
-    const next = {
-      ...agents.find((a) => String(a.role ?? "") === role),
-      role,
-      ...(name ? { name } : {}),
-    };
-    const idx = nextAgents.findIndex((a) => String(a.role ?? "") === role);
-    if (idx === -1) nextAgents.push(next);
-    else nextAgents[idx] = next;
+    result = handleAdd(agents, templates, role, name);
   } else {
-    // addLike: create a *new* role entry based on an existing role's capabilities AND templates.
     const baseRole = normalizeRole(String(body.baseRole ?? ""));
-    const base = agents.find((a) => String(a.role ?? "") === baseRole);
-    if (!base) {
-      return NextResponse.json({ ok: false, error: `baseRole not found in recipe: ${baseRole}` }, { status: 400 });
-    }
-
-    const usedRoles = new Set(nextAgents.map((a) => String(a.role ?? "").trim()).filter(Boolean));
-
-    // Find next suffix: baseRole, baseRole-2, baseRole-3, ...
-    let n = 1;
-    for (const r of usedRoles) {
-      if (r === baseRole) n = Math.max(n, 1);
-      const m = r.match(new RegExp(`^${baseRole.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&")}-([0-9]+)$`));
-      if (m) {
-        const k = Number(m[1]);
-        if (Number.isFinite(k)) n = Math.max(n, k);
-      }
-    }
-
     const teamId = String(body.teamId ?? "").trim();
-    let existingAgentIds = new Set<string>();
-    if (teamId) {
-      try {
-        const res = await runOpenClaw(["agents", "list", "--json"]);
-        if (res.ok) {
-          const items = JSON.parse(res.stdout) as Array<{ id?: unknown }>;
-          existingAgentIds = new Set(items.map((a) => String(a.id ?? "").trim()).filter(Boolean));
-        }
-      } catch {
-        // ignore
-      }
-    }
-
-    function isTaken(role: string) {
-      if (usedRoles.has(role)) return true;
-      if (teamId) {
-        const agentId = `${teamId}-${role}`;
-        if (existingAgentIds.has(agentId)) return true;
-      }
-      return false;
-    }
-
-    let nextRole = baseRole;
-    if (isTaken(nextRole)) {
-      let i = Math.max(2, n + 1);
-      while (isTaken(`${baseRole}-${i}`)) i++;
-      nextRole = `${baseRole}-${i}`;
-    }
-
-    const baseName = typeof (base as { name?: unknown }).name === "string" ? String((base as { name?: unknown }).name) : "";
-    const autoSuffix = nextRole === baseRole ? "" : String(nextRole.slice(baseRole.length + 1));
-    const nextName = name || (baseName ? `${baseName}${autoSuffix ? ` ${autoSuffix}` : ""}` : "");
-
-    const clone = { ...base, role: nextRole, ...(nextName ? { name: nextName } : {}) };
-    nextAgents.push(clone);
-
-    // Duplicate templates: templates.<baseRole>.* => templates.<nextRole>.*
-    // This is required so scaffold-team can generate role files for the duplicated role.
-    for (const [k, v] of Object.entries(templates)) {
-      if (!k.startsWith(`${baseRole}.`)) continue;
-      const suffix = k.slice(baseRole.length); // includes leading '.'
-      const nextKey = `${nextRole}${suffix}`;
-      if (nextTemplates[nextKey] === undefined) nextTemplates[nextKey] = v;
-    }
+    result = await handleAddLike(agents, templates, baseRole, name, teamId);
   }
 
-  // Keep stable order by role.
-  nextAgents.sort((a, b) => String(a.role ?? "").localeCompare(String(b.role ?? "")));
+  if (result instanceof NextResponse) return result;
 
-  const nextFm = { ...fm, agents: nextAgents, ...(Object.keys(nextTemplates).length ? { templates: nextTemplates } : {}) };
-  const nextYaml = YAML.stringify(nextFm).trimEnd();
-  const nextMd = `---\n${nextYaml}\n---\n${rest}`;
+  const { nextAgents, nextTemplates, addedRole } = result;
+  nextAgents.sort((a, b) => String(a.role ?? "").localeCompare(String(b.role ?? "")));
 
+  const nextMd = buildNextMarkdown(fm, nextAgents, nextTemplates, rest);
   await fs.writeFile(filePath, nextMd, "utf8");
 
-  // Best-effort: return the last-added role so the client can install immediately.
-  let addedRole: string | null = null;
-  if (op === "add") addedRole = normalizeRole(String(body.role ?? ""));
-  if (op === "addLike") {
-    // In addLike we pushed a clone as the last entry.
-    addedRole = String((nextAgents[nextAgents.length - 1] as { role?: unknown } | undefined)?.role ?? "").trim() || null;
-  }
-
   const teamId = typeof body.teamId === "string" ? body.teamId.trim() : "";
   const addedAgentId = teamId && addedRole ? `${teamId}-${addedRole}` : null;
 
-  return NextResponse.json({ ok: true, recipeId, filePath, agents: nextAgents, content: nextMd, addedRole, addedAgentId });
+  return NextResponse.json({
+    ok: true,
+    recipeId,
+    filePath,
+    agents: nextAgents,
+    content: nextMd,
+    addedRole,
+    addedAgentId,
+  });
 }