@folpe/loom 0.2.0 → 0.4.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}`
         );
       }
     }
@@ -175,32 +178,37 @@ import pc2 from "picocolors";
 // src/lib/writer.ts
 import fs2 from "fs";
 import path2 from "path";
-var CLAUDE_DIR = ".claude";
 function ensureDir(dirPath) {
   fs2.mkdirSync(dirPath, { recursive: true });
 }
-function writeAgent(slug, content, cwd = process.cwd()) {
-  const dir = path2.join(cwd, CLAUDE_DIR, "agents");
+function writeAgent(target, slug, content, cwd = process.cwd()) {
+  const dir = path2.join(cwd, target.dir, target.agentsSubdir, slug);
   ensureDir(dir);
-  const filePath = path2.join(dir, `${slug}.md`);
+  const filePath = path2.join(dir, "AGENT.md");
   fs2.writeFileSync(filePath, content, "utf-8");
   return filePath;
 }
-function writeSkill(slug, content, cwd = process.cwd()) {
-  const dir = path2.join(cwd, CLAUDE_DIR, "skills");
+function writeSkill(target, slug, content, cwd = process.cwd()) {
+  const dir = path2.join(cwd, target.dir, target.skillsSubdir, slug);
   ensureDir(dir);
-  const filePath = path2.join(dir, `${slug}.md`);
+  const filePath = path2.join(dir, "SKILL.md");
   fs2.writeFileSync(filePath, content, "utf-8");
   return filePath;
 }
-function writeClaudeMd(content, cwd = process.cwd()) {
-  const filePath = path2.join(cwd, "CLAUDE.md");
+function writeOrchestrator(target, content, cwd = process.cwd()) {
+  const filePath = path2.join(cwd, target.dir, target.orchestratorFile);
+  ensureDir(path2.dirname(filePath));
+  fs2.writeFileSync(filePath, content, "utf-8");
+  return filePath;
+}
+function writeContextFile(target, content, cwd = process.cwd()) {
+  const filePath = path2.join(cwd, target.contextFile);
   fs2.writeFileSync(filePath, content, "utf-8");
   return filePath;
 }
 
 // src/commands/add.ts
-async function addCommand(type, slug) {
+async function addCommand(type, slug, target) {
   if (type !== "agent" && type !== "skill") {
     console.error(pc2.red(`
   Error: Invalid type "${type}". Use "agent" or "skill".
@@ -210,13 +218,13 @@ async function addCommand(type, slug) {
   try {
     if (type === "agent") {
       const agent = await getAgent(slug);
-      const filePath = writeAgent(slug, agent.rawContent);
+      const filePath = writeAgent(target, slug, agent.rawContent);
       console.log(pc2.green(`
   \u2713 Agent "${slug}" written to ${filePath}
 `));
     } else {
       const skill = await getSkill(slug);
-      const filePath = writeSkill(slug, skill.rawContent);
+      const filePath = writeSkill(target, slug, skill.rawContent);
       console.log(pc2.green(`
   \u2713 Skill "${slug}" written to ${filePath}
 `));
@@ -235,31 +243,28 @@ 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
-function generateClaudeMd(preset, agents) {
+import matter2 from "gray-matter";
+function generateContextFile(preset, agents, target, skillSlugs = []) {
   const lines = [];
   lines.push(`# ${preset.name}`);
   lines.push("");
-  lines.push(preset.claudemd.projectDescription);
+  lines.push(preset.context.projectDescription.trim());
   lines.push("");
   if (preset.constitution.principles.length > 0) {
     lines.push("## Principles");
-    for (const p of preset.constitution.principles) {
-      lines.push(`- ${p}`);
-    }
     lines.push("");
-  }
-  if (preset.constitution.stack.length > 0) {
-    lines.push("## Stack");
-    for (const s of preset.constitution.stack) {
-      lines.push(`- ${s}`);
+    for (const p2 of preset.constitution.principles) {
+      lines.push(`- ${p2}`);
     }
     lines.push("");
   }
   if (preset.constitution.conventions.length > 0) {
     lines.push("## Conventions");
+    lines.push("");
     for (const c of preset.constitution.conventions) {
       lines.push(`- ${c}`);
     }
@@ -268,133 +273,457 @@ function generateClaudeMd(preset, agents) {
   if (preset.constitution.customSections) {
     for (const [title, content] of Object.entries(preset.constitution.customSections)) {
       lines.push(`## ${title}`);
+      lines.push("");
       lines.push(content);
       lines.push("");
     }
   }
-  if (agents.length > 0) {
-    lines.push("## Agents");
-    for (const agent of agents) {
-      lines.push(`- **${agent.slug}**: ${agent.name} \u2014 ${agent.role}`);
+  lines.push("## Commands");
+  lines.push("");
+  lines.push("```bash");
+  lines.push("npm run dev          # Start development server");
+  lines.push("npm run build        # Build for production");
+  lines.push("npm run lint         # Run linter");
+  lines.push("npm test             # Run tests");
+  lines.push("```");
+  lines.push("");
+  lines.push("<!-- loom:agents:start -->");
+  lines.push("## Agents");
+  lines.push("");
+  const nonOrchestrator = agents.filter((a) => a.slug !== "orchestrator");
+  if (nonOrchestrator.length > 0) {
+    lines.push(`This project uses ${nonOrchestrator.length} specialized agents coordinated by an orchestrator (\`${target.dir}/${target.orchestratorFile}\`).`);
+    lines.push("");
+    lines.push("| Agent | Role | Description |");
+    lines.push("|-------|------|-------------|");
+    for (const agent of nonOrchestrator) {
+      lines.push(`| \`${agent.slug}\` | ${agent.name} | ${agent.description} |`);
     }
     lines.push("");
   }
-  if (preset.claudemd.orchestratorRef) {
-    lines.push("## Orchestrator");
-    lines.push(preset.claudemd.orchestratorRef);
+  lines.push("<!-- loom:agents:end -->");
+  lines.push("");
+  if (skillSlugs.length > 0) {
+    lines.push("<!-- loom:skills:start -->");
+    lines.push("## Skills");
+    lines.push("");
+    lines.push("Installed skills providing domain-specific conventions and patterns:");
+    lines.push("");
+    for (const slug of skillSlugs) {
+      lines.push(`- \`${slug}\``);
+    }
+    lines.push("");
+    lines.push("<!-- loom:skills:end -->");
     lines.push("");
   }
+  lines.push("## How to use");
+  lines.push("");
+  lines.push(`The orchestrator agent (\`${target.dir}/${target.orchestratorFile}\`) is the main entry point. It analyzes tasks, breaks them into subtasks, and delegates to the appropriate specialized agents. Each agent has access to its assigned skills for domain-specific guidance.`);
+  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/lib/target.ts
+var BUILTIN_TARGETS = {
+  "claude-code": {
+    name: "claude-code",
+    description: "Claude Code \u2014 .claude/ + CLAUDE.md",
+    dir: ".claude",
+    agentsSubdir: "agents",
+    skillsSubdir: "skills",
+    orchestratorFile: "orchestrator.md",
+    contextFile: "CLAUDE.md"
+  },
+  cursor: {
+    name: "cursor",
+    description: "Cursor \u2014 .cursor/ + .cursorrules",
+    dir: ".cursor",
+    agentsSubdir: "agents",
+    skillsSubdir: "skills",
+    orchestratorFile: "orchestrator.md",
+    contextFile: ".cursorrules"
+  }
+};
+var DEFAULT_TARGET = "claude-code";
+function listTargetNames() {
+  return Object.keys(BUILTIN_TARGETS);
+}
+function resolveTarget(targetName, customDir, customContextFile) {
+  const builtin = BUILTIN_TARGETS[targetName];
+  if (builtin) return builtin;
+  if (targetName === "custom") {
+    if (!customDir || !customContextFile) {
+      throw new Error(
+        'Target "custom" requires --target-dir and --context-file.'
+      );
+    }
+    return {
+      name: "custom",
+      description: `Custom \u2014 ${customDir}/ + ${customContextFile}`,
+      dir: customDir,
+      agentsSubdir: "agents",
+      skillsSubdir: "skills",
+      orchestratorFile: "orchestrator.md",
+      contextFile: customContextFile
+    };
+  }
+  const available = [...listTargetNames(), "custom"].join(", ");
+  throw new Error(
+    `Unknown target "${targetName}". Available: ${available}.`
+  );
+}
+
+// src/lib/config.ts
+import fs3 from "fs";
+import path3 from "path";
+var CONFIG_FILE = "loom.config.json";
+function saveConfig(target, cwd = process.cwd()) {
+  const config = {
+    target: target.name,
+    targetDir: target.dir,
+    contextFile: target.contextFile
+  };
+  const filePath = path3.join(cwd, CONFIG_FILE);
+  fs3.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function loadConfig(cwd = process.cwd()) {
+  const filePath = path3.join(cwd, CONFIG_FILE);
+  if (!fs3.existsSync(filePath)) return null;
+  try {
+    const raw = fs3.readFileSync(filePath, "utf-8");
+    const config = JSON.parse(raw);
+    return resolveTarget(config.target, config.targetDir, config.contextFile);
+  } catch {
+    return null;
+  }
+}
 
 // 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 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);
+    }
+    if (!presetSlug && !hasFlags) {
+      await interactiveInit(opts.target, opts.targetExplicit);
+    } else {
+      await nonInteractiveInit(presetSlug, opts);
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(pc3.red(`
+  Error: ${error.message}
+`));
+    } else {
+      console.error(pc3.red("\n  An unknown error occurred.\n"));
+    }
+    process.exit(1);
+  }
+}
+async function interactiveInit(target, targetExplicit) {
+  p.intro(pc3.bgCyan(pc3.black(" loom init ")));
+  if (!targetExplicit) {
+    const builtinEntries = Object.values(BUILTIN_TARGETS);
+    const targetChoice = await p.select({
+      message: "Choose a target runtime",
+      options: [
+        ...builtinEntries.map((t) => ({
+          value: t.name,
+          label: t.description
+        })),
+        { value: "custom", label: "Custom \u2014 choose directory and context file" }
+      ],
+      initialValue: target.name
+    });
+    if (p.isCancel(targetChoice)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    if (targetChoice === "custom") {
+      const customDir = await p.text({
+        message: "Target directory",
+        placeholder: ".myruntime",
+        validate: (v) => !v || v.length === 0 ? "Required" : void 0
       });
-      const answer = await new Promise((resolve) => {
-        rl.question(pc3.cyan("\n  Choose a preset (number): "), (ans) => {
-          rl.close();
-          resolve(ans.trim());
-        });
+      if (p.isCancel(customDir)) {
+        p.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      const customFile = await p.text({
+        message: "Context file name",
+        placeholder: "CONTEXT.md",
+        validate: (v) => !v || v.length === 0 ? "Required" : void 0
       });
-      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);
+      if (p.isCancel(customFile)) {
+        p.cancel("Operation cancelled.");
+        process.exit(0);
       }
-      presetSlug = presets[index].slug;
-      preset = await getPreset(presetSlug);
+      target = resolveTarget("custom", customDir, customFile);
     } else {
-      preset = await getPreset(presetSlug);
+      target = BUILTIN_TARGETS[targetChoice];
     }
-    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))
+  } else {
+    p.log.info(`Target: ${target.description}`);
+  }
+  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, target);
+  saveConfig(target);
+  s.stop("Project files generated.");
+  p.outro(pc3.green(`Done! ${agentSlugs.length} agent(s), ${skillSlugs.length} skill(s), ${target.contextFile} ready.`));
+}
+async function nonInteractiveInit(presetSlug, opts) {
+  const target = opts.target;
+  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 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 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);
     }
-    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 (opts.removeAgent?.includes(agent.slug)) {
+      for (const sk of agent.skills) linkedToRemoved.add(sk);
     }
-    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.
+  }
+  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, target);
+  saveConfig(target);
+  console.log(
+    pc3.bold(
+      pc3.cyan(
+        `
+  Done! ${agentSlugs.length} agent(s), ${skillSlugs.length} skill(s), ${target.contextFile} ready.
 `
-        )
       )
+    )
+  );
+}
+async function generateAndWrite(preset, agentSlugs, skillSlugs, target) {
+  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(target, slug, result.value.rawContent);
+        console.log(pc3.green(`  \u2713 Agent: ${slug}`));
+      }
+      agentInfos.push({
+        slug,
+        name: fm.name || slug,
+        role: fm.role || "",
+        description: fm.description || ""
+      });
+      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
     );
-  } catch (error) {
-    if (error instanceof Error) {
-      console.error(pc3.red(`
-  Error: ${error.message}
-`));
+    writeOrchestrator(target, orchestratorContent);
+    console.log(pc3.green(`  \u2713 ${target.orchestratorFile} generated`));
+  }
+  for (let i = 0; i < skillSlugs.length; i++) {
+    const slug = skillSlugs[i];
+    const result = skillResults[i];
+    if (result.status === "fulfilled") {
+      writeSkill(target, slug, result.value.rawContent);
+      console.log(pc3.green(`  \u2713 Skill: ${slug}`));
     } else {
-      console.error(pc3.red("\n  An unknown error occurred.\n"));
+      console.log(pc3.yellow(`  \u26A0 Skill "${slug}" skipped: ${result.reason}`));
     }
-    process.exit(1);
   }
+  const contextContent = generateContextFile(preset, agentInfos, target, skillSlugs);
+  writeContextFile(target, contextContent);
+  console.log(pc3.green(`  \u2713 ${target.contextFile} 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("add").description("Download an agent or skill from the library").argument("<type>", "Type: agent or skill").argument("<slug>", "Slug of the agent or skill").option("--target <name>", `Output target: ${[...listTargetNames(), "custom"].join(", ")}`, DEFAULT_TARGET).option("--target-dir <dir>", "Custom target directory").option("--context-file <file>", "Custom context file name").action(async (type, slug, opts) => {
+  const savedConfig = loadConfig();
+  const target = opts.target !== DEFAULT_TARGET || opts.targetDir || opts.contextFile ? resolveTarget(opts.target, opts.targetDir, opts.contextFile) : savedConfig ?? BUILTIN_TARGETS[DEFAULT_TARGET];
+  await addCommand(type, slug, target);
 });
-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 + context file)").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").option("--claude", "Use Claude Code target (.claude/ + CLAUDE.md)").option("--cursor", "Use Cursor target (.cursor/ + .cursorrules)").option("--target <name>", `Output target: ${[...listTargetNames(), "custom"].join(", ")}`).option("--target-dir <dir>", "Custom target directory").option("--context-file <file>", "Custom context file name").action(async (preset, opts) => {
+  let target;
+  let targetExplicit = false;
+  if (opts.claude) {
+    target = BUILTIN_TARGETS["claude-code"];
+    targetExplicit = true;
+  } else if (opts.cursor) {
+    target = BUILTIN_TARGETS["cursor"];
+    targetExplicit = true;
+  } else if (opts.target) {
+    target = resolveTarget(
+      opts.target,
+      opts.targetDir,
+      opts.contextFile
+    );
+    targetExplicit = true;
+  } else {
+    target = BUILTIN_TARGETS[DEFAULT_TARGET];
+  }
+  await initCommand(preset, {
+    addAgent: opts.addAgent,
+    removeAgent: opts.removeAgent,
+    addSkill: opts.addSkill,
+    removeSkill: opts.removeSkill,
+    target,
+    targetExplicit
+  });
 });
 program.parse();