@folpe/loom 0.1.0 → 0.3.0

package/data/skills/ui-ux-guidelines/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: ui-ux-guidelines
+description: "UI/UX design rules for accessibility, interaction, typography, color, and animation. Use when building user-facing interfaces, reviewing designs, checking accessibility compliance, or choosing fonts and color palettes."
+---
+
+# UI/UX Design Guidelines
+
+Comprehensive design guide covering accessibility, interaction, layout, typography, color, and animation — prioritized by impact.
+
+## Critical Rules
+
+- **Color contrast**: minimum 4.5:1 for normal text, 3:1 for large text.
+- **Touch targets**: minimum 44x44px on mobile.
+- **No `h-screen`** — use `h-dvh` for correct mobile viewport.
+- **No animation unless requested** — respect `prefers-reduced-motion`.
+- **Empty states must have one clear next action** — never blank screens.
+- **All icon-only buttons must have `aria-label`**.
+
+## Priority 1 — Accessibility (CRITICAL)
+
+- **Color is not enough**: never convey information by color alone — add icons or text.
+- **Alt text**: descriptive alt for all meaningful images. Use `alt=""` only for decorative images.
+- **Heading hierarchy**: sequential h1 → h2 → h3, one `<h1>` per page.
+- **Keyboard navigation**: tab order matches visual order, no keyboard traps.
+- **Focus states**: visible focus rings on all interactive elements — never `outline-none` without replacement.
+- **Form labels**: every input must have a visible `<label>` — placeholder alone is never enough.
+- **Error announcements**: use `aria-live="polite"` or `role="alert"` for dynamic errors.
+- **Skip links**: provide "Skip to main content" on navigation-heavy pages.
+- **Motion sensitivity**: always respect `prefers-reduced-motion` — disable parallax and scroll-jacking.
+
+## Priority 2 — Touch & Interaction (CRITICAL)
+
+- **Touch spacing**: minimum 8px gap between adjacent touch targets.
+- **Hover vs tap**: never rely on hover for primary interactions — use click/tap.
+- **Cursor pointer**: add `cursor-pointer` to all clickable elements.
+- **Focus states**: `focus:ring-2 focus:ring-primary` on interactive elements.
+- **Hover states**: `hover:bg-accent cursor-pointer` for visual feedback.
+- **Active states**: `active:scale-95` for press feedback.
+- **Disabled states**: `opacity-50 cursor-not-allowed pointer-events-none`.
+- **Loading buttons**: disable button and show spinner during async actions — prevent double submission.
+- **Error feedback**: show clear error message near the problem — never silent failures.
+- **Success feedback**: always confirm completed actions with toast or visual change.
+- **Confirmation dialogs**: require confirmation before any destructive/irreversible action.
+
+## Priority 3 — Layout & Responsive (HIGH)
+
+- **Mobile first**: base styles for mobile, `md:` and `lg:` for larger screens.
+- **Viewport**: always set `<meta name="viewport" content="width=device-width, initial-scale=1">`.
+- **No horizontal scroll**: ensure all content fits viewport — `max-w-full overflow-x-hidden`.
+- **Viewport units**: use `min-h-dvh` not `h-screen` — mobile browser chrome breaks `100vh`.
+- **Container width**: limit text to 65-75 characters per line — `max-w-prose`.
+- **Content jumping**: reserve space for async content — use `aspect-ratio` or fixed dimensions.
+- **Z-index scale**: use a fixed scale (10, 20, 30, 50) — never `z-[9999]`.
+- **Fixed elements**: account for safe areas, never stack multiple fixed elements carelessly.
+- **Breakpoint testing**: always test at 375px, 768px, 1024px, 1440px.
+- **Image scaling**: `max-w-full h-auto` on all images.
+- **Table handling**: wrap tables in `overflow-x-auto` for mobile.
+
+## Priority 4 — Typography (MEDIUM)
+
+- **Body font size**: minimum 16px (`text-base`) on mobile — never `text-xs` for body.
+- **Line height**: 1.5–1.75 for body text — `leading-relaxed`.
+- **Line length**: 65-75 characters max — `max-w-prose` or `max-w-3xl`.
+- **Heading hierarchy**: clear size/weight difference from body text.
+- **Font loading**: use `font-display: swap` with similar fallback to prevent layout shift.
+- **Numeric data**: use `tabular-nums` for aligned numbers in tables and dashboards.
+- **Text wrapping**: use `text-balance` for headings, `text-pretty` for paragraphs.
+- **Truncation**: `truncate` or `line-clamp-2` with expand option for long content.
+
+### Recommended Font Pairings
+
+| Style | Heading | Body | Best For |
+|-------|---------|------|----------|
+| Modern Professional | Poppins | Open Sans | SaaS, corporate, startups |
+| Tech Startup | Space Grotesk | DM Sans | Tech, developer tools, AI |
+| Minimal Swiss | Inter | Inter | Dashboards, admin panels, docs |
+| Friendly SaaS | Plus Jakarta Sans | Plus Jakarta Sans | Web apps, productivity tools |
+| Classic Elegant | Playfair Display | Inter | Luxury, fashion, editorial |
+| Bold Statement | Bebas Neue | Source Sans 3 | Marketing, portfolios, agencies |
+| Developer Mono | JetBrains Mono | IBM Plex Sans | Dev tools, documentation, CLI |
+| Playful Creative | Fredoka | Nunito | Children's apps, gaming, education |
+| Corporate Trust | Lexend | Source Sans 3 | Enterprise, government, healthcare |
+
+## Priority 5 — Color Palettes by Product Type (MEDIUM)
+
+| Product | Primary | CTA | Background | Text |
+|---------|---------|-----|------------|------|
+| SaaS (General) | `#2563EB` blue | `#F97316` orange | `#F8FAFC` | `#1E293B` |
+| Micro SaaS | `#6366F1` indigo | `#10B981` emerald | `#F5F3FF` | `#1E1B4B` |
+| E-commerce | `#059669` green | `#F97316` orange | `#ECFDF5` | `#064E3B` |
+| E-commerce Luxury | `#1C1917` black | `#CA8A04` gold | `#FAFAF9` | `#0C0A09` |
+| Landing Page | `#0EA5E9` sky | `#F97316` orange | `#F0F9FF` | `#0C4A6E` |
+| Financial Dashboard | `#0F172A` navy | `#22C55E` green | `#020617` | `#F8FAFC` |
+| Healthcare | `#0891B2` cyan | `#059669` green | `#ECFEFF` | `#164E63` |
+| Education | `#4F46E5` indigo | `#F97316` orange | `#EEF2FF` | `#1E1B4B` |
+| Creative Agency | `#EC4899` pink | `#06B6D4` cyan | `#FDF2F8` | `#831843` |
+| Portfolio | `#18181B` zinc | `#2563EB` blue | `#FAFAFA` | `#09090B` |
+| AI / Chatbot | `#7C3AED` purple | `#06B6D4` cyan | `#FAF5FF` | `#1E1B4B` |
+| Productivity | `#0D9488` teal | `#F97316` orange | `#F0FDFA` | `#134E4A` |
+
+> Use these as starting points. Always map to your design system's semantic tokens (`bg-primary`, `text-foreground`, etc.) rather than hardcoding hex values.
+
+## Priority 6 — Animation (MEDIUM)
+
+- **Only when needed**: never add animation unless explicitly requested.
+- **Timing**: 150-300ms for micro-interactions — never exceed 500ms for UI.
+- **Performance**: animate only `transform` and `opacity` — never `width`, `height`, `top`, `left`, `margin`, `padding`.
+- **Easing**: `ease-out` for entering, `ease-in` for exiting — never `linear` for UI.
+- **Continuous animation**: only for loading indicators — never for decorative elements.
+- **Reduced motion**: always check `prefers-reduced-motion` and disable non-essential animation.
+- **Maximum scope**: animate 1-2 key elements per view — never everything.
+- **No layout shift**: hover states must not cause layout shift — use `transform` not size changes.
+
+## Priority 7 — Forms (MEDIUM)
+
+- **Labels**: always visible above or beside input — never placeholder-only.
+- **Error placement**: show error directly below the related input, not at form top.
+- **Inline validation**: validate on blur for most fields, not only on submit.
+- **Input types**: use `email`, `tel`, `number`, `url` — not `text` for everything.
+- **Autofill**: use `autocomplete` attribute properly — never `autocomplete="off"` everywhere.
+- **Required fields**: mark clearly with asterisk `*` or "(required)" text.
+- **Password visibility**: always provide a show/hide toggle.
+- **Mobile keyboards**: use `inputmode="numeric"` for number-only inputs.
+- **Submit feedback**: show loading state → success/error — never no feedback.
+
+## Priority 8 — Feedback & Empty States (LOW-MEDIUM)
+
+- **Loading indicators**: show spinner/skeleton for operations > 300ms — never frozen UI.
+- **Empty states**: show helpful message + one clear action — never blank screen.
+- **Error recovery**: provide clear next steps — "Try again" button + help link.
+- **Progress indicators**: show "Step 2 of 4" for multi-step processes.
+- **Toast notifications**: auto-dismiss after 3-5 seconds — never persistent.
+- **Truncation**: handle long content gracefully with `line-clamp` + expand.
+- **No results**: show suggestions when search yields nothing — never just "0 results".
+
+## Pre-Delivery Checklist
+
+### Visual Quality
+- [ ] No emoji icons — use Lucide, Heroicons, or SF Symbols (SVG)
+- [ ] Consistent icon set throughout the interface
+- [ ] Hover states without layout shift
+- [ ] Semantic color tokens used (not hardcoded hex)
+- [ ] No purple/multicolor gradients unless explicitly requested
+- [ ] No glow effects as primary affordances
+- [ ] Empty states have one clear next action
+
+### Interaction
+- [ ] All clickable elements have `cursor-pointer`
+- [ ] Clear visual hover feedback on interactive elements
+- [ ] Smooth transitions (150-300ms)
+- [ ] Visible keyboard focus states
+- [ ] Destructive actions require `AlertDialog` confirmation
+- [ ] Loading buttons disabled during async actions
+
+### Light/Dark Mode
+- [ ] Light text contrast: 4.5:1 minimum
+- [ ] Borders visible in both modes
+- [ ] Test both themes before delivery
+
+### Layout
+- [ ] No content hidden behind fixed navbars
+- [ ] Responsive: 375px, 768px, 1024px, 1440px
+- [ ] No horizontal scroll on mobile
+- [ ] `min-h-dvh` used instead of `h-screen`
+- [ ] `safe-area-inset` respected for fixed elements
+
+### Accessibility
+- [ ] All images have alt text
+- [ ] All form inputs have labels
+- [ ] Color is not the sole indicator of state
+- [ ] `prefers-reduced-motion` respected
+- [ ] Icon-only buttons have `aria-label`
+- [ ] Skip link present on nav-heavy pages
+
+### Performance
+- [ ] Images optimized (WebP/AVIF, `srcset`, lazy loading)
+- [ ] No `will-change` outside active animations
+- [ ] No large `blur()` or `backdrop-filter` surfaces animated
+- [ ] No `useEffect` for what can be render logic

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.1.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",