@folpe/loom 0.1.0

package/data/agents/ux-ui/AGENT.md

@@ -0,0 +1,58 @@
+---
+name: UX/UI
+description: Designs UI components, creates design system tokens, and handles accessibility
+role: design
+color: "#EC4899"
+tools:
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+model: claude-sonnet-4-6
+---
+
+# UX/UI Agent
+
+You are a senior UX/UI designer and design engineer for the Loom project. You create design system foundations, component styles, interaction patterns, and ensure the application meets high standards for usability and accessibility.
+
+## Design System
+
+- Maintain design tokens (colors, spacing, typography, radii, shadows) in a centralized configuration file (e.g., `tailwind.config.ts` or a dedicated `tokens.ts`).
+- Use a consistent spacing scale based on multiples of 4px (0.25rem).
+- Define a color palette with semantic names: `primary`, `secondary`, `accent`, `neutral`, `success`, `warning`, `error`.
+- Every color must meet WCAG AA contrast ratios against its intended background (4.5:1 for normal text, 3:1 for large text).
+
+## Component Design
+
+- Design components from the outside in: define the API (props) first, then the visual structure.
+- Use composition over configuration. Prefer small, composable primitives over monolithic components with many props.
+- Define component variants explicitly (e.g., `variant: "primary" | "secondary" | "ghost"`) rather than relying on arbitrary className overrides.
+- Include hover, focus, active, and disabled states for all interactive elements.
+
+## Accessibility (a11y)
+
+- Every interactive element must be keyboard-navigable. Use `tabIndex`, `onKeyDown`, and proper focus management.
+- Use ARIA roles and properties correctly. Prefer native semantic HTML (`<button>`, `<nav>`, `<dialog>`) over `div` with ARIA.
+- Ensure all form inputs have associated `<label>` elements. Use `aria-describedby` for help text and error messages.
+- Test focus order: it should follow a logical reading sequence, not jump unpredictably.
+- Provide visible focus indicators that meet the 3:1 contrast ratio requirement.
+
+## Responsive Design
+
+- Design mobile-first. Start with the smallest breakpoint and layer on complexity for larger screens.
+- Use Tailwind's responsive prefixes (`sm:`, `md:`, `lg:`, `xl:`) consistently.
+- Ensure touch targets are at least 44x44px on mobile.
+- Test layouts at common breakpoints: 320px, 768px, 1024px, 1440px.
+
+## Animation and Interaction
+
+- Use subtle animations (150-300ms) for state transitions. Avoid animations that block user interaction.
+- Respect `prefers-reduced-motion`. Provide a reduced or no-animation fallback.
+- Use CSS transitions for simple state changes. Reserve JavaScript animation libraries for complex sequences.
+
+## Before Finishing
+
+- Verify all colors meet contrast requirements.
+- Check that every interactive element has visible focus and hover states.
+- Confirm responsive behavior at all standard breakpoints.

package/data/presets/saas-default.yaml

@@ -0,0 +1,53 @@
+name: SaaS Default
+description: Standard SaaS project preset with full agent team, Next.js conventions, and Tailwind patterns. Includes
+  orchestrator-driven multi-agent workflow.
+boilerplate:
+  repo: https://github.com/vercel/next.js.git
+  branch: canary
+  shallow: true
+agents:
+  - orchestrator
+  - frontend
+  - backend
+  - marketing
+  - ux-ui
+  - database
+  - tests
+  - review-qa
+  - performance
+  - security
+skills:
+  - nextjs-conventions
+  - tailwind-patterns
+  - hero-copywriting
+constitution:
+  principles:
+    - Ship fast, iterate often — prefer working software over perfect plans
+    - User-first design — every feature must solve a real user problem
+    - Type safety everywhere — leverage TypeScript strict mode
+    - Convention over configuration — follow established patterns
+  stack:
+    - Next.js 16+ (App Router)
+    - React 19
+    - TypeScript 5 (strict)
+    - Tailwind CSS 4
+    - ShadCN UI
+    - Supabase (auth + database)
+    - Vercel (deployment)
+  conventions:
+    - Use Server Components by default, Client Components only when needed
+    - Server Actions for all mutations
+    - Zod validation at API boundaries
+    - Mobile-first responsive design
+    - Semantic HTML with ARIA attributes for accessibility
+claudemd:
+  projectDescription: >
+    This is a SaaS application scaffolded with Loom. It uses a multi-agent architecture where the orchestrator delegates
+    tasks to specialized agents (frontend, backend, database, etc.). Each agent follows the conventions defined in the
+    linked skills.
+  orchestratorRef: >
+    The orchestrator agent (.claude/agents/orchestrator.md) is the main entry point. Always start by delegating to the
+    orchestrator, which will route tasks to the appropriate specialized agent.
+specKit:
+  enabled: true
+  aiFlag: claude

package/data/skills/hero-copywriting/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: hero-copywriting
+description: "Guidelines for writing high-converting hero sections. Use when creating landing pages, marketing pages, or any page with a hero section."
+allowed-tools: "Read, Write, Edit"
+---
+
+# Hero Section Copywriting
+
+## Headline Rules
+
+- **Lead with the outcome**, not the feature. What does the user GET?
+  - Bad: "AI-powered project management"
+  - Good: "Ship projects 3x faster with your AI co-pilot"
+- Keep headlines to **8-12 words maximum**.
+- Use **power words**: effortless, instant, proven, transform, unlock, accelerate.
+- Include a **specific number or metric** when possible for credibility.
+
+## Subheadline
+
+- Expand on the headline with **how** it works in one sentence.
+- Keep it under 25 words.
+- Address the primary pain point directly.
+- Example: "Stop juggling spreadsheets. One dashboard to plan, track, and deliver — powered by AI."
+
+## Call to Action (CTA)
+
+- Use **action verbs**: "Start", "Get", "Try", "Launch", "Build".
+- Make the CTA specific: "Start your free trial" > "Sign up".
+- Add urgency or ease: "Get started in 30 seconds" / "No credit card required".
+- Primary CTA should be visually prominent (filled button, large size).
+- Optional secondary CTA: "See how it works" / "Watch demo" (outline button).
+
+## Social Proof
+
+- Place immediately below or beside the CTA.
+- Options (pick 1-2):
+  - Customer logos: "Trusted by teams at [logos]"
+  - Metric: "Join 10,000+ teams already shipping faster"
+  - Rating: "4.9/5 on G2 — 500+ reviews"
+  - Testimonial snippet: short quote with name and company
+
+## Visual Guidelines
+
+- Hero should occupy the full viewport height on desktop (`min-h-screen` or `min-h-[80vh]`).
+- Text should be left-aligned or center-aligned. Never justify.
+- Maximum content width: `max-w-2xl` for centered, `max-w-xl` for left-aligned.
+- Generous whitespace. Don't crowd the hero.
+
+## Tone
+
+- Conversational but confident. Not corporate-speak.
+- Speak directly to the reader: "you" and "your".
+- Avoid jargon unless the audience expects it.
+- Be specific over generic. "Save 5 hours a week" > "Save time".
+
+## Structure Template
+
+```
+[Badge or category label — optional]
+[Headline — 8-12 words, outcome-focused]
+[Subheadline — 1 sentence, addresses pain point]
+[Primary CTA button]  [Secondary CTA — optional]
+[Social proof — logos, metric, or testimonial]
+```

package/data/skills/nextjs-conventions/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: nextjs-conventions
+description: "Enforces Next.js 15+ / React 19 / TypeScript conventions and best practices. Use when working on any Next.js project to ensure consistent patterns."
+allowed-tools: "Read, Write, Edit, Glob, Grep"
+---
+
+# Next.js Conventions
+
+## App Router
+
+- Use the App Router (`src/app/`) exclusively. Never use the Pages Router.
+- Every route segment should have a `page.tsx`. Use `layout.tsx` for shared UI.
+- Use `loading.tsx` for Suspense boundaries and `error.tsx` for error boundaries.
+- Use `not-found.tsx` for 404 pages at the appropriate route level.
+
+## Server vs Client Components
+
+- **Default to Server Components**. Only add `"use client"` when you need:
+  - Event handlers (`onClick`, `onChange`, etc.)
+  - React hooks (`useState`, `useEffect`, `useRef`, etc.)
+  - Browser-only APIs (`window`, `localStorage`, etc.)
+- Never import server-only modules in client components.
+- Pass server data to client components via props, not by importing server functions.
+
+## Data Fetching
+
+- Fetch data in Server Components using `async/await` directly.
+- Use Server Actions (`"use server"`) for mutations. Define them in `src/actions/`.
+- Always revalidate with `revalidatePath()` or `revalidateTag()` after mutations.
+- Use `Suspense` boundaries for streaming and progressive rendering.
+
+## File Naming
+
+- Components: `PascalCase.tsx` (e.g., `UserProfile.tsx`)
+- Utilities: `kebab-case.ts` (e.g., `format-date.ts`)
+- Types: define in `src/types/` with `.ts` extension
+- Server Actions: `src/actions/{entity}.actions.ts`
+
+## TypeScript
+
+- Enable `strict: true` in `tsconfig.json`.
+- Prefer `interface` over `type` for object shapes.
+- Never use `any`. Use `unknown` if the type is truly unknown.
+- Use `satisfies` operator for type-safe object literals.
+
+## Styling
+
+- Use Tailwind CSS utility classes as the primary styling method.
+- Use `cn()` from `@/lib/utils` to merge conditional classes.
+- Avoid inline styles. Avoid CSS modules unless absolutely necessary.
+- Follow mobile-first responsive design: base styles for mobile, `md:` and `lg:` for larger screens.
+
+## Imports
+
+- Use the `@/` path alias for all imports from `src/`.
+- Group imports: React/Next.js first, then external libs, then internal modules.
+- Prefer named exports over default exports (except for page/layout components).
+
+## Performance
+
+- Use `next/image` for all images with proper `width`, `height`, and `alt`.
+- Use `next/link` for internal navigation. Never use `<a>` for internal links.
+- Use `next/font` for font loading.
+- Lazy load heavy client components with `dynamic()` from `next/dynamic`.

package/data/skills/tailwind-patterns/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: tailwind-patterns
+description: "Provides Tailwind CSS patterns, utility conventions, and component styling guidelines. Use when building UI with Tailwind CSS."
+allowed-tools: "Read, Write, Edit"
+---
+
+# Tailwind CSS Patterns
+
+## Utility-First Approach
+
+- Always use utility classes directly in JSX. Avoid `@apply` except in global base styles.
+- Use `cn()` helper for conditional and merged classes:
+  ```tsx
+  className={cn("base-classes", condition && "conditional-classes", className)}
+  ```
+
+## Spacing & Layout
+
+- Use consistent spacing scale: `gap-2` (8px), `gap-4` (16px), `gap-6` (24px), `gap-8` (32px).
+- Prefer `flex` and `grid` for layout. Avoid absolute positioning except for overlays.
+- Use `container mx-auto px-4` for page-level content width.
+- Standard page padding: `p-6` for main content areas.
+
+## Responsive Design
+
+- Mobile-first: write base styles for mobile, add `sm:`, `md:`, `lg:`, `xl:` for larger screens.
+- Common breakpoints:
+  - `sm:` (640px) — small tablets
+  - `md:` (768px) — tablets
+  - `lg:` (1024px) — laptops
+  - `xl:` (1280px) — desktops
+- Grid responsive pattern: `grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3`
+
+## Typography
+
+- Headings: `text-3xl font-bold tracking-tight` (h1), `text-2xl font-semibold` (h2), `text-lg font-semibold` (h3)
+- Body text: `text-sm` or `text-base`
+- Muted text: `text-muted-foreground`
+- Truncation: `truncate` or `line-clamp-2`
+
+## Colors & Theming
+
+- Always use CSS variable-based colors from the design system: `bg-background`, `text-foreground`, `bg-card`, `text-muted-foreground`, etc.
+- Never hardcode hex colors. Use the semantic tokens.
+- For dark mode, rely on the `dark:` variant only when CSS variables don't handle it.
+
+## Interactive States
+
+- Hover: `hover:bg-accent` or `hover:bg-accent/50`
+- Focus: handled by ShadCN defaults via `outline-ring/50`
+- Transitions: `transition-colors` for color changes, `transition-all` sparingly
+- Disabled: `disabled:opacity-50 disabled:pointer-events-none`
+
+## Component Patterns
+
+- Card: use ShadCN `Card` components. Add `hover:bg-accent/50 transition-colors` for clickable cards.
+- Forms: stack fields with `space-y-4`, use `grid gap-4 md:grid-cols-2` for side-by-side fields.
+- Buttons: use ShadCN `Button` with appropriate `variant` and `size`.
+- Badges: use ShadCN `Badge` with `variant="secondary"` for tags, `variant="outline"` for less emphasis.

package/dist/index.js

@@ -0,0 +1,400 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/list.ts
+import pc from "picocolors";
+
+// src/lib/library.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import matter from "gray-matter";
+import YAML from "yaml";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var DATA_DIR = path.resolve(__dirname, "../data");
+function listSubDirs(dir) {
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+}
+function listFiles(dir) {
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isFile()).map((d) => d.name).sort();
+}
+async function listAgents() {
+  const agentsDir = path.join(DATA_DIR, "agents");
+  const slugs = listSubDirs(agentsDir);
+  const agents = [];
+  for (const slug of slugs) {
+    const filePath = path.join(agentsDir, slug, "AGENT.md");
+    try {
+      const raw = fs.readFileSync(filePath, "utf-8");
+      const { data } = matter(raw);
+      agents.push({
+        slug,
+        name: data.name || slug,
+        description: data.description || "",
+        role: data.role || ""
+      });
+    } catch {
+      agents.push({ slug, name: slug, description: "", role: "" });
+    }
+  }
+  return agents;
+}
+async function listSkills() {
+  const skillsDir = path.join(DATA_DIR, "skills");
+  const slugs = listSubDirs(skillsDir);
+  const skills = [];
+  for (const slug of slugs) {
+    const filePath = path.join(skillsDir, slug, "SKILL.md");
+    try {
+      const raw = fs.readFileSync(filePath, "utf-8");
+      const { data } = matter(raw);
+      skills.push({
+        slug,
+        name: data.name || slug,
+        description: data.description || ""
+      });
+    } catch {
+      skills.push({ slug, name: slug, description: "" });
+    }
+  }
+  return skills;
+}
+async function listPresets() {
+  const presetsDir = path.join(DATA_DIR, "presets");
+  const files = listFiles(presetsDir);
+  const presets = [];
+  for (const file of files) {
+    if (!file.endsWith(".yaml")) continue;
+    const slug = file.replace(/\.yaml$/, "");
+    try {
+      const raw = fs.readFileSync(path.join(presetsDir, file), "utf-8");
+      const data = YAML.parse(raw);
+      presets.push({
+        slug,
+        name: data.name || slug,
+        description: data.description || "",
+        agentCount: data.agents?.length || 0,
+        skillCount: data.skills?.length || 0
+      });
+    } catch {
+      presets.push({ slug, name: slug, description: "", agentCount: 0, skillCount: 0 });
+    }
+  }
+  return presets;
+}
+async function getAgent(slug) {
+  const filePath = path.join(DATA_DIR, "agents", slug, "AGENT.md");
+  const raw = fs.readFileSync(filePath, "utf-8");
+  return { slug, rawContent: raw };
+}
+async function getSkill(slug) {
+  const filePath = path.join(DATA_DIR, "skills", slug, "SKILL.md");
+  const raw = fs.readFileSync(filePath, "utf-8");
+  return { slug, rawContent: raw };
+}
+async function getPreset(slug) {
+  const filePath = path.join(DATA_DIR, "presets", `${slug}.yaml`);
+  const raw = fs.readFileSync(filePath, "utf-8");
+  const data = YAML.parse(raw);
+  return { ...data, slug };
+}
+
+// src/commands/list.ts
+function truncate(str, max) {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 1) + "\u2026";
+}
+function padEnd(str, len) {
+  return str + " ".repeat(Math.max(0, len - str.length));
+}
+async function listCommand(type) {
+  try {
+    if (!type || type === "agents") {
+      const agents = await listAgents();
+      console.log(pc.bold(pc.cyan("\n  Agents")));
+      console.log(pc.dim("  " + "\u2500".repeat(60)));
+      if (agents.length === 0) {
+        console.log(pc.dim("  No agents found."));
+      }
+      for (const a of agents) {
+        console.log(
+          `  ${padEnd(pc.green(a.slug), 30)} ${padEnd(a.name, 25)} ${pc.dim(truncate(a.description, 40))}`
+        );
+      }
+    }
+    if (!type || type === "skills") {
+      const skills = await listSkills();
+      console.log(pc.bold(pc.cyan("\n  Skills")));
+      console.log(pc.dim("  " + "\u2500".repeat(60)));
+      if (skills.length === 0) {
+        console.log(pc.dim("  No skills found."));
+      }
+      for (const s of skills) {
+        console.log(
+          `  ${padEnd(pc.green(s.slug), 30)} ${padEnd(s.name, 25)} ${pc.dim(truncate(s.description, 40))}`
+        );
+      }
+    }
+    if (!type || type === "presets") {
+      const presets = await listPresets();
+      console.log(pc.bold(pc.cyan("\n  Presets")));
+      console.log(pc.dim("  " + "\u2500".repeat(60)));
+      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)`);
+        console.log(
+          `  ${padEnd(pc.green(p.slug), 30)} ${padEnd(p.name, 25)} ${meta}`
+        );
+      }
+    }
+    console.log();
+  } catch (error) {
+    handleError(error);
+  }
+}
+function handleError(error) {
+  if (error instanceof Error) {
+    console.error(pc.red(`
+  Error: ${error.message}
+`));
+  } else {
+    console.error(pc.red("\n  An unknown error occurred.\n"));
+  }
+  process.exit(1);
+}
+
+// src/commands/add.ts
+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");
+  ensureDir(dir);
+  const filePath = path2.join(dir, `${slug}.md`);
+  fs2.writeFileSync(filePath, content, "utf-8");
+  return filePath;
+}
+function writeSkill(slug, content, cwd = process.cwd()) {
+  const dir = path2.join(cwd, CLAUDE_DIR, "skills");
+  ensureDir(dir);
+  const filePath = path2.join(dir, `${slug}.md`);
+  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");
+  return filePath;
+}
+
+// src/commands/add.ts
+async function addCommand(type, slug) {
+  if (type !== "agent" && type !== "skill") {
+    console.error(pc2.red(`
+  Error: Invalid type "${type}". Use "agent" or "skill".
+`));
+    process.exit(1);
+  }
+  try {
+    if (type === "agent") {
+      const agent = await getAgent(slug);
+      const filePath = writeAgent(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);
+      console.log(pc2.green(`
+  \u2713 Skill "${slug}" written to ${filePath}
+`));
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(pc2.red(`
+  Error: ${error.message}
+`));
+    } else {
+      console.error(pc2.red("\n  An unknown error occurred.\n"));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/init.ts
+import pc3 from "picocolors";
+import matter2 from "gray-matter";
+
+// src/lib/generator.ts
+function generateClaudeMd(preset, agents) {
+  const lines = [];
+  lines.push(`# ${preset.name}`);
+  lines.push("");
+  lines.push(preset.claudemd.projectDescription);
+  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}`);
+    }
+    lines.push("");
+  }
+  if (preset.constitution.conventions.length > 0) {
+    lines.push("## Conventions");
+    for (const c of preset.constitution.conventions) {
+      lines.push(`- ${c}`);
+    }
+    lines.push("");
+  }
+  if (preset.constitution.customSections) {
+    for (const [title, content] of Object.entries(preset.constitution.customSections)) {
+      lines.push(`## ${title}`);
+      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("");
+  }
+  if (preset.claudemd.orchestratorRef) {
+    lines.push("## Orchestrator");
+    lines.push(preset.claudemd.orchestratorRef);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/commands/init.ts
+async function initCommand(presetSlug) {
+  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}`));
+      }
+    }
+    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}`));
+      }
+    }
+    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(`
+  Error: ${error.message}
+`));
+    } else {
+      console.error(pc3.red("\n  An unknown error occurred.\n"));
+    }
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("loom").description("Integrate Loom library (agents, skills, presets) into your project").version("0.1.0");
+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.parse();