@folpe/loom 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
+import { createRequire } from "module";
 import { Command } from "commander";
 
 // src/commands/list.ts
@@ -31,14 +32,16 @@ async function listAgents() {
     try {
       const raw = fs.readFileSync(filePath, "utf-8");
       const { data } = matter(raw);
+      const fm = data;
       agents.push({
         slug,
-        name: data.name || slug,
-        description: data.description || "",
-        role: data.role || ""
+        name: fm.name || slug,
+        description: fm.description || "",
+        role: fm.role || "",
+        skills: Array.isArray(fm.skills) ? fm.skills : []
       });
     } catch {
-      agents.push({ slug, name: slug, description: "", role: "" });
+      agents.push({ slug, name: slug, description: "", role: "", skills: [] });
     }
   }
   return agents;
@@ -146,10 +149,10 @@ async function listCommand(type) {
       if (presets.length === 0) {
         console.log(pc.dim("  No presets found."));
       }
-      for (const p of presets) {
-        const meta = pc.dim(`(${p.agentCount} agents, ${p.skillCount} skills)`);
+      for (const p2 of presets) {
+        const meta = pc.dim(`(${p2.agentCount} agents, ${p2.skillCount} skills)`);
         console.log(
-          `  ${padEnd(pc.green(p.slug), 30)} ${padEnd(p.name, 25)} ${meta}`
+          `  ${padEnd(pc.green(p2.slug), 30)} ${padEnd(p2.name, 25)} ${meta}`
         );
       }
     }
@@ -193,6 +196,12 @@ function writeSkill(slug, content, cwd = process.cwd()) {
   fs2.writeFileSync(filePath, content, "utf-8");
   return filePath;
 }
+function writeOrchestrator(content, cwd = process.cwd()) {
+  const filePath = path2.join(cwd, CLAUDE_DIR, "orchestrator.md");
+  ensureDir(path2.dirname(filePath));
+  fs2.writeFileSync(filePath, content, "utf-8");
+  return filePath;
+}
 function writeClaudeMd(content, cwd = process.cwd()) {
   const filePath = path2.join(cwd, "CLAUDE.md");
   fs2.writeFileSync(filePath, content, "utf-8");
@@ -235,9 +244,11 @@ async function addCommand(type, slug) {
 
 // src/commands/init.ts
 import pc3 from "picocolors";
-import matter2 from "gray-matter";
+import * as p from "@clack/prompts";
+import matter3 from "gray-matter";
 
 // src/lib/generator.ts
+import matter2 from "gray-matter";
 function generateClaudeMd(preset, agents) {
   const lines = [];
   lines.push(`# ${preset.name}`);
@@ -246,8 +257,8 @@ function generateClaudeMd(preset, agents) {
   lines.push("");
   if (preset.constitution.principles.length > 0) {
     lines.push("## Principles");
-    for (const p of preset.constitution.principles) {
-      lines.push(`- ${p}`);
+    for (const p2 of preset.constitution.principles) {
+      lines.push(`- ${p2}`);
     }
     lines.push("");
   }
@@ -279,100 +290,44 @@ function generateClaudeMd(preset, agents) {
     }
     lines.push("");
   }
-  if (preset.claudemd.orchestratorRef) {
-    lines.push("## Orchestrator");
-    lines.push(preset.claudemd.orchestratorRef);
-    lines.push("");
-  }
+  lines.push("## Orchestrator");
+  lines.push("");
+  lines.push("Use the orchestrator agent (`.claude/orchestrator.md`) as the main coordinator. It will analyze tasks, break them into subtasks, and delegate to the appropriate specialized agents listed above.");
+  lines.push("");
   return lines.join("\n");
 }
+function generateOrchestrator(templateContent, agents, presetSkills) {
+  const { data: frontmatter, content } = matter2(templateContent);
+  const rules = [];
+  const delegatesTo = [];
+  for (const agent of agents) {
+    if (agent.slug === "orchestrator") continue;
+    delegatesTo.push(agent.slug);
+    const relevantSkills = agent.skills.filter((s) => presetSkills.includes(s));
+    let line = `- **${agent.slug}**: ${agent.description}`;
+    if (relevantSkills.length > 0) {
+      line += `. Skills: ${relevantSkills.join(", ")}`;
+    }
+    rules.push(line);
+  }
+  const newFrontmatter = { ...frontmatter, "delegates-to": delegatesTo };
+  const newContent = content.replace("{{DELEGATION_RULES}}", rules.join("\n"));
+  return matter2.stringify(newContent, newFrontmatter);
+}
 
 // src/commands/init.ts
-async function initCommand(presetSlug) {
+async function initCommand(presetSlug, opts = {}) {
   try {
-    let preset;
-    if (!presetSlug) {
-      const presets = await listPresets();
-      if (presets.length === 0) {
-        console.error(pc3.red("\n  No presets available.\n"));
-        process.exit(1);
-      }
-      console.log(pc3.bold(pc3.cyan("\n  Available presets:\n")));
-      presets.forEach((p, i) => {
-        console.log(`  ${pc3.bold(String(i + 1))}. ${pc3.green(p.slug)} \u2014 ${p.description}`);
-      });
-      const { createInterface } = await import("readline");
-      const rl = createInterface({
-        input: process.stdin,
-        output: process.stdout
-      });
-      const answer = await new Promise((resolve) => {
-        rl.question(pc3.cyan("\n  Choose a preset (number): "), (ans) => {
-          rl.close();
-          resolve(ans.trim());
-        });
-      });
-      const index = parseInt(answer, 10) - 1;
-      if (isNaN(index) || index < 0 || index >= presets.length) {
-        console.error(pc3.red("\n  Invalid selection.\n"));
-        process.exit(1);
-      }
-      presetSlug = presets[index].slug;
-      preset = await getPreset(presetSlug);
-    } else {
-      preset = await getPreset(presetSlug);
-    }
-    console.log(pc3.bold(pc3.cyan(`
-  Initializing preset "${preset.name}"...
-`)));
-    const agentResults = await Promise.allSettled(
-      preset.agents.map((slug) => getAgent(slug))
-    );
-    const skillResults = await Promise.allSettled(
-      preset.skills.map((slug) => getSkill(slug))
-    );
-    const agentInfos = [];
-    for (let i = 0; i < preset.agents.length; i++) {
-      const slug = preset.agents[i];
-      const result = agentResults[i];
-      if (result.status === "fulfilled") {
-        writeAgent(slug, result.value.rawContent);
-        const { data } = matter2(result.value.rawContent);
-        const fm = data;
-        agentInfos.push({
-          slug,
-          name: fm.name || slug,
-          role: fm.role || ""
-        });
-        console.log(pc3.green(`  \u2713 Agent: ${slug}`));
-      } else {
-        console.log(pc3.yellow(`  \u26A0 Agent "${slug}" skipped: ${result.reason}`));
-      }
+    const hasFlags = !!(opts.addAgent || opts.removeAgent || opts.addSkill || opts.removeSkill);
+    if (!presetSlug && hasFlags) {
+      console.error(pc3.red("\n  Error: flags require a preset argument. Usage: loom init <preset> [flags]\n"));
+      process.exit(1);
     }
-    for (let i = 0; i < preset.skills.length; i++) {
-      const slug = preset.skills[i];
-      const result = skillResults[i];
-      if (result.status === "fulfilled") {
-        writeSkill(slug, result.value.rawContent);
-        console.log(pc3.green(`  \u2713 Skill: ${slug}`));
-      } else {
-        console.log(pc3.yellow(`  \u26A0 Skill "${slug}" skipped: ${result.reason}`));
-      }
+    if (!presetSlug && !hasFlags) {
+      await interactiveInit();
+    } else {
+      await nonInteractiveInit(presetSlug, opts);
     }
-    const claudeContent = generateClaudeMd(preset, agentInfos);
-    writeClaudeMd(claudeContent);
-    console.log(pc3.green(`  \u2713 CLAUDE.md generated`));
-    const agentOk = agentResults.filter((r) => r.status === "fulfilled").length;
-    const skillOk = skillResults.filter((r) => r.status === "fulfilled").length;
-    console.log(
-      pc3.bold(
-        pc3.cyan(
-          `
-  Done! ${agentOk} agent(s), ${skillOk} skill(s), CLAUDE.md ready.
-`
-        )
-      )
-    );
   } catch (error) {
     if (error instanceof Error) {
       console.error(pc3.red(`
@@ -384,17 +339,216 @@ async function initCommand(presetSlug) {
     process.exit(1);
   }
 }
+async function interactiveInit() {
+  p.intro(pc3.bgCyan(pc3.black(" loom init ")));
+  const presets = await listPresets();
+  if (presets.length === 0) {
+    p.cancel("No presets available.");
+    process.exit(1);
+  }
+  const presetSlug = await p.select({
+    message: "Choose a preset",
+    options: presets.map((pr) => ({
+      value: pr.slug,
+      label: pr.name,
+      hint: `${pr.agentCount} agents, ${pr.skillCount} skills`
+    }))
+  });
+  if (p.isCancel(presetSlug)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const preset = await getPreset(presetSlug);
+  const allAgents = await listAgents();
+  const allSkillSlugs = (await listSkills()).map((s2) => s2.slug);
+  const nonOrchestratorAgents = allAgents.filter((a) => a.slug !== "orchestrator");
+  const presetAgentSet = new Set(preset.agents);
+  const selectedAgents = await p.multiselect({
+    message: "Select agents",
+    options: nonOrchestratorAgents.map((a) => ({
+      value: a.slug,
+      label: a.name,
+      hint: a.description
+    })),
+    initialValues: nonOrchestratorAgents.filter((a) => presetAgentSet.has(a.slug)).map((a) => a.slug),
+    required: true
+  });
+  if (p.isCancel(selectedAgents)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const agentSlugs = ["orchestrator", ...selectedAgents];
+  const skillOptions = computeAvailableSkills(preset, selectedAgents, allAgents, allSkillSlugs);
+  const selectedSkills = await p.multiselect({
+    message: "Select skills",
+    options: skillOptions.map((s2) => ({
+      value: s2.slug,
+      label: s2.slug,
+      hint: s2.preSelected ? "recommended" : void 0
+    })),
+    initialValues: skillOptions.filter((s2) => s2.preSelected).map((s2) => s2.slug),
+    required: false
+  });
+  if (p.isCancel(selectedSkills)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const skillSlugs = selectedSkills;
+  const confirmed = await p.confirm({
+    message: `Scaffold with ${agentSlugs.length} agents and ${skillSlugs.length} skills?`
+  });
+  if (p.isCancel(confirmed) || !confirmed) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const s = p.spinner();
+  s.start("Generating project files...");
+  await generateAndWrite(preset, agentSlugs, skillSlugs);
+  s.stop("Project files generated.");
+  p.outro(pc3.green(`Done! ${agentSlugs.length} agent(s), ${skillSlugs.length} skill(s), CLAUDE.md ready.`));
+}
+async function nonInteractiveInit(presetSlug, opts) {
+  const preset = await getPreset(presetSlug);
+  const allAgents = await listAgents();
+  let agentSlugs = [...preset.agents];
+  if (opts.addAgent) {
+    for (const slug of opts.addAgent) {
+      if (!agentSlugs.includes(slug)) agentSlugs.push(slug);
+    }
+  }
+  if (opts.removeAgent) {
+    agentSlugs = agentSlugs.filter(
+      (s) => s === "orchestrator" || !opts.removeAgent.includes(s)
+    );
+  }
+  const selectedNonOrch = agentSlugs.filter((s) => s !== "orchestrator");
+  const linkedToSelected = /* @__PURE__ */ new Set();
+  const linkedToRemoved = /* @__PURE__ */ new Set();
+  for (const agent of allAgents) {
+    if (selectedNonOrch.includes(agent.slug)) {
+      for (const sk of agent.skills) linkedToSelected.add(sk);
+    }
+    if (opts.removeAgent?.includes(agent.slug)) {
+      for (const sk of agent.skills) linkedToRemoved.add(sk);
+    }
+  }
+  const orphanSkills = /* @__PURE__ */ new Set();
+  for (const sk of linkedToRemoved) {
+    if (!linkedToSelected.has(sk)) orphanSkills.add(sk);
+  }
+  let skillSlugs = preset.skills.filter((s) => !orphanSkills.has(s));
+  if (opts.addSkill) {
+    for (const slug of opts.addSkill) {
+      if (!skillSlugs.includes(slug)) skillSlugs.push(slug);
+    }
+  }
+  if (opts.removeSkill) {
+    skillSlugs = skillSlugs.filter((s) => !opts.removeSkill.includes(s));
+  }
+  console.log(pc3.bold(pc3.cyan(`
+  Initializing preset "${preset.name}"...
+`)));
+  await generateAndWrite(preset, agentSlugs, skillSlugs);
+  console.log(
+    pc3.bold(
+      pc3.cyan(
+        `
+  Done! ${agentSlugs.length} agent(s), ${skillSlugs.length} skill(s), CLAUDE.md ready.
+`
+      )
+    )
+  );
+}
+async function generateAndWrite(preset, agentSlugs, skillSlugs) {
+  const agentResults = await Promise.allSettled(
+    agentSlugs.map((slug) => getAgent(slug))
+  );
+  const skillResults = await Promise.allSettled(
+    skillSlugs.map((slug) => getSkill(slug))
+  );
+  const agentInfos = [];
+  const agentsWithSkills = [];
+  let orchestratorTemplate = null;
+  for (let i = 0; i < agentSlugs.length; i++) {
+    const slug = agentSlugs[i];
+    const result = agentResults[i];
+    if (result.status === "fulfilled") {
+      const { data } = matter3(result.value.rawContent);
+      const fm = data;
+      if (slug === "orchestrator") {
+        orchestratorTemplate = result.value.rawContent;
+      } else {
+        writeAgent(slug, result.value.rawContent);
+        console.log(pc3.green(`  \u2713 Agent: ${slug}`));
+      }
+      agentInfos.push({
+        slug,
+        name: fm.name || slug,
+        role: fm.role || ""
+      });
+      agentsWithSkills.push({
+        slug,
+        name: fm.name || slug,
+        description: fm.description || "",
+        skills: Array.isArray(fm.skills) ? fm.skills : []
+      });
+    } else {
+      console.log(pc3.yellow(`  \u26A0 Agent "${slug}" skipped: ${result.reason}`));
+    }
+  }
+  if (orchestratorTemplate) {
+    const orchestratorContent = generateOrchestrator(
+      orchestratorTemplate,
+      agentsWithSkills,
+      skillSlugs
+    );
+    writeOrchestrator(orchestratorContent);
+    console.log(pc3.green(`  \u2713 orchestrator.md generated`));
+  }
+  for (let i = 0; i < skillSlugs.length; i++) {
+    const slug = skillSlugs[i];
+    const result = skillResults[i];
+    if (result.status === "fulfilled") {
+      writeSkill(slug, result.value.rawContent);
+      console.log(pc3.green(`  \u2713 Skill: ${slug}`));
+    } else {
+      console.log(pc3.yellow(`  \u26A0 Skill "${slug}" skipped: ${result.reason}`));
+    }
+  }
+  const claudeContent = generateClaudeMd(preset, agentInfos);
+  writeClaudeMd(claudeContent);
+  console.log(pc3.green(`  \u2713 CLAUDE.md generated`));
+}
+function computeAvailableSkills(preset, selectedAgentSlugs, allAgents, allSkillSlugs) {
+  const linkedToSelected = /* @__PURE__ */ new Set();
+  for (const agent of allAgents) {
+    if (selectedAgentSlugs.includes(agent.slug)) {
+      for (const sk of agent.skills) linkedToSelected.add(sk);
+    }
+  }
+  const linkedToAny = /* @__PURE__ */ new Set();
+  for (const agent of allAgents) {
+    for (const sk of agent.skills) linkedToAny.add(sk);
+  }
+  const presetSkillSet = new Set(preset.skills);
+  return allSkillSlugs.map((slug) => {
+    const preSelected = linkedToSelected.has(slug) || presetSkillSet.has(slug) && !linkedToAny.has(slug);
+    return { slug, preSelected };
+  });
+}
 
 // src/index.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
 var program = new Command();
-program.name("loom").description("Integrate Loom library (agents, skills, presets) into your project").version("0.1.0");
+program.name("loom").description("Integrate Loom library (agents, skills, presets) into your project").version(version);
 program.command("list").description("List available agents, skills, and presets").argument("[type]", "Filter by type: agents, skills, or presets").action(async (type) => {
   await listCommand(type);
 });
 program.command("add").description("Download an agent or skill from the library").argument("<type>", "Type: agent or skill").argument("<slug>", "Slug of the agent or skill").action(async (type, slug) => {
   await addCommand(type, slug);
 });
-program.command("init").description("Initialize a project with a preset (agents + skills + CLAUDE.md)").argument("[preset]", "Preset slug (interactive if omitted)").action(async (preset) => {
-  await initCommand(preset);
+program.command("init").description("Initialize a project with a preset (agents + skills + CLAUDE.md)").argument("[preset]", "Preset slug (interactive if omitted)").option("--add-agent <slugs...>", "Add extra agents").option("--remove-agent <slugs...>", "Remove agents from preset").option("--add-skill <slugs...>", "Add extra skills").option("--remove-skill <slugs...>", "Remove skills from preset").action(async (preset, opts) => {
+  await initCommand(preset, opts);
 });
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@folpe/loom",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "CLI to scaffold Claude Code projects with curated agents, skills, and presets",
   "type": "module",
   "license": "MIT",
@@ -30,6 +30,7 @@
     "data"
   ],
   "dependencies": {
+    "@clack/prompts": "^1.0.1",
     "commander": "^13.1.0",
     "gray-matter": "^4.0.3",
     "picocolors": "^1.1.1",