@folpe/loom 0.3.0 → 1.0.0

package/dist/index.js

@@ -23,6 +23,34 @@ function listFiles(dir) {
   if (!fs.existsSync(dir)) return [];
   return fs.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isFile()).map((d) => d.name).sort();
 }
+var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".md",
+  ".ts",
+  ".js",
+  ".sh",
+  ".dot",
+  ".yaml",
+  ".yml",
+  ".json",
+  ".css",
+  ".html"
+]);
+function walkDir(dir, base = "") {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const results = [];
+  for (const entry of entries) {
+    const rel = base ? `${base}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      results.push(...walkDir(path.join(dir, entry.name), rel));
+    } else if (entry.isFile()) {
+      const ext = path.extname(entry.name).toLowerCase();
+      if (TEXT_EXTENSIONS.has(ext)) {
+        results.push(rel);
+      }
+    }
+  }
+  return results;
+}
 async function listAgents() {
   const agentsDir = path.join(DATA_DIR, "agents");
   const slugs = listSubDirs(agentsDir);
@@ -94,10 +122,16 @@ async function getAgent(slug) {
   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 getSkillWithFiles(slug) {
+  const skillDir = path.join(DATA_DIR, "skills", slug);
+  const mainPath = path.join(skillDir, "SKILL.md");
+  const mainContent = fs.readFileSync(mainPath, "utf-8");
+  const relativePaths = walkDir(skillDir);
+  const files = relativePaths.map((relativePath) => ({
+    relativePath,
+    content: fs.readFileSync(path.join(skillDir, relativePath), "utf-8")
+  }));
+  return { slug, mainContent, files };
 }
 async function getPreset(slug) {
   const filePath = path.join(DATA_DIR, "presets", `${slug}.yaml`);
@@ -106,6 +140,116 @@ async function getPreset(slug) {
   return { ...data, slug };
 }
 
+// src/lib/local-library.ts
+import fs2 from "fs";
+import path2 from "path";
+import os from "os";
+var LIBRARY_DIR = path2.join(os.homedir(), ".loom", "library");
+function ensureDir(dir) {
+  fs2.mkdirSync(dir, { recursive: true });
+}
+function saveLocalAgent(slug, content) {
+  const dir = path2.join(LIBRARY_DIR, "agents", slug);
+  ensureDir(dir);
+  const filePath = path2.join(dir, "AGENT.md");
+  fs2.writeFileSync(filePath, content, "utf-8");
+  return filePath;
+}
+function saveLocalSkill(slug, files) {
+  const dir = path2.join(LIBRARY_DIR, "skills", slug);
+  for (const file of files) {
+    const filePath = path2.join(dir, file.relativePath);
+    ensureDir(path2.dirname(filePath));
+    fs2.writeFileSync(filePath, file.content, "utf-8");
+  }
+  return dir;
+}
+function saveLocalPreset(slug, content) {
+  const dir = path2.join(LIBRARY_DIR, "presets");
+  ensureDir(dir);
+  const filePath = path2.join(dir, `${slug}.yaml`);
+  fs2.writeFileSync(filePath, content, "utf-8");
+  return filePath;
+}
+function getLocalAgent(slug) {
+  const filePath = path2.join(LIBRARY_DIR, "agents", slug, "AGENT.md");
+  try {
+    const raw = fs2.readFileSync(filePath, "utf-8");
+    return { slug, rawContent: raw };
+  } catch {
+    return null;
+  }
+}
+var TEXT_EXTENSIONS2 = /* @__PURE__ */ new Set([
+  ".md",
+  ".ts",
+  ".js",
+  ".sh",
+  ".dot",
+  ".yaml",
+  ".yml",
+  ".json",
+  ".css",
+  ".html"
+]);
+function walkDir2(dir, base = "") {
+  let entries;
+  try {
+    entries = fs2.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const entry of entries) {
+    const rel = base ? `${base}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      results.push(...walkDir2(path2.join(dir, entry.name), rel));
+    } else if (entry.isFile()) {
+      const ext = path2.extname(entry.name).toLowerCase();
+      if (TEXT_EXTENSIONS2.has(ext)) {
+        results.push(rel);
+      }
+    }
+  }
+  return results;
+}
+function getLocalSkillWithFiles(slug) {
+  const dir = path2.join(LIBRARY_DIR, "skills", slug);
+  if (!fs2.existsSync(dir)) return null;
+  const relativePaths = walkDir2(dir);
+  if (relativePaths.length === 0) return null;
+  const files = relativePaths.map((relativePath) => ({
+    relativePath,
+    content: fs2.readFileSync(path2.join(dir, relativePath), "utf-8")
+  }));
+  return { slug, files };
+}
+function listSubDirs2(dir) {
+  try {
+    return fs2.readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+  } catch {
+    return [];
+  }
+}
+function listLocalResources() {
+  const items = [];
+  for (const slug of listSubDirs2(path2.join(LIBRARY_DIR, "agents"))) {
+    items.push({ slug, type: "agent" });
+  }
+  for (const slug of listSubDirs2(path2.join(LIBRARY_DIR, "skills"))) {
+    items.push({ slug, type: "skill" });
+  }
+  try {
+    const presetsDir = path2.join(LIBRARY_DIR, "presets");
+    const files = fs2.readdirSync(presetsDir).filter((f) => f.endsWith(".yaml"));
+    for (const f of files) {
+      items.push({ slug: f.replace(/\.yaml$/, ""), type: "preset" });
+    }
+  } catch {
+  }
+  return items;
+}
+
 // src/commands/list.ts
 function truncate(str, max) {
   if (str.length <= max) return str;
@@ -116,6 +260,7 @@ function padEnd(str, len) {
 }
 async function listCommand(type) {
   try {
+    const bundledSlugs = /* @__PURE__ */ new Set();
     if (!type || type === "agents") {
       const agents = await listAgents();
       console.log(pc.bold(pc.cyan("\n  Agents")));
@@ -124,6 +269,7 @@ async function listCommand(type) {
         console.log(pc.dim("  No agents found."));
       }
       for (const a of agents) {
+        bundledSlugs.add(`agent:${a.slug}`);
         console.log(
           `  ${padEnd(pc.green(a.slug), 30)} ${padEnd(a.name, 25)} ${pc.dim(truncate(a.description, 40))}`
         );
@@ -137,6 +283,7 @@ async function listCommand(type) {
         console.log(pc.dim("  No skills found."));
       }
       for (const s of skills) {
+        bundledSlugs.add(`skill:${s.slug}`);
         console.log(
           `  ${padEnd(pc.green(s.slug), 30)} ${padEnd(s.name, 25)} ${pc.dim(truncate(s.description, 40))}`
         );
@@ -150,12 +297,25 @@ async function listCommand(type) {
         console.log(pc.dim("  No presets found."));
       }
       for (const p2 of presets) {
+        bundledSlugs.add(`preset:${p2.slug}`);
         const meta = pc.dim(`(${p2.agentCount} agents, ${p2.skillCount} skills)`);
         console.log(
           `  ${padEnd(pc.green(p2.slug), 30)} ${padEnd(p2.name, 25)} ${meta}`
         );
       }
     }
+    const localItems = listLocalResources().filter(
+      (item) => !bundledSlugs.has(`${item.type}:${item.slug}`)
+    );
+    if (localItems.length > 0) {
+      console.log(pc.bold(pc.magenta("\n  Installed (marketplace)")));
+      console.log(pc.dim("  " + "\u2500".repeat(60)));
+      for (const item of localItems) {
+        console.log(
+          `  ${padEnd(pc.green(item.slug), 30)} ${pc.dim(`[${item.type}]`)}`
+        );
+      }
+    }
     console.log();
   } catch (error) {
     handleError(error);
@@ -176,40 +336,41 @@ function handleError(error) {
 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 });
+import fs3 from "fs";
+import path3 from "path";
+function ensureDir2(dirPath) {
+  fs3.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");
+function writeAgent(target, slug, content, cwd = process.cwd()) {
+  const dir = path3.join(cwd, target.dir, target.agentsSubdir, slug);
+  ensureDir2(dir);
+  const filePath = path3.join(dir, "AGENT.md");
+  fs3.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 writeSkillDir(target, slug, files, cwd = process.cwd()) {
+  const dir = path3.join(cwd, target.dir, target.skillsSubdir, slug);
+  for (const file of files) {
+    const filePath = path3.join(dir, file.relativePath);
+    ensureDir2(path3.dirname(filePath));
+    fs3.writeFileSync(filePath, file.content, "utf-8");
+  }
+  return dir;
 }
-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");
+function writeOrchestrator(target, content, cwd = process.cwd()) {
+  const filePath = path3.join(cwd, target.dir, target.orchestratorFile);
+  ensureDir2(path3.dirname(filePath));
+  fs3.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");
+function writeContextFile(target, content, cwd = process.cwd()) {
+  const filePath = path3.join(cwd, target.contextFile);
+  fs3.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".
@@ -219,25 +380,44 @@ 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 skill = await getSkillWithFiles(slug);
+      const dirPath = writeSkillDir(target, slug, skill.files);
+      const fileCount = skill.files.length;
       console.log(pc2.green(`
-  \u2713 Skill "${slug}" written to ${filePath}
+  \u2713 Skill "${slug}" written to ${dirPath} (${fileCount} file${fileCount !== 1 ? "s" : ""})
 `));
     }
-  } catch (error) {
-    if (error instanceof Error) {
-      console.error(pc2.red(`
-  Error: ${error.message}
+  } catch {
+    if (type === "agent") {
+      const local = getLocalAgent(slug);
+      if (local) {
+        const filePath = writeAgent(target, slug, local.rawContent);
+        console.log(pc2.green(`
+  \u2713 Agent "${slug}" written to ${filePath} ${pc2.dim("(from ~/.loom/library)")}
 `));
+        return;
+      }
     } else {
-      console.error(pc2.red("\n  An unknown error occurred.\n"));
+      const local = getLocalSkillWithFiles(slug);
+      if (local) {
+        const dirPath = writeSkillDir(target, slug, local.files);
+        const fileCount = local.files.length;
+        console.log(pc2.green(`
+  \u2713 Skill "${slug}" written to ${dirPath} (${fileCount} file${fileCount !== 1 ? "s" : ""}) ${pc2.dim("(from ~/.loom/library)")}
+`));
+        return;
+      }
     }
+    console.error(pc2.red(`
+  Error: ${type} "${slug}" not found.
+`));
+    console.log(pc2.dim(`  Try: loom marketplace search ${slug}
+`));
     process.exit(1);
   }
 }
@@ -249,28 +429,23 @@ import matter3 from "gray-matter";
 
 // src/lib/generator.ts
 import matter2 from "gray-matter";
-function generateClaudeMd(preset, agents) {
+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");
+    lines.push("");
     for (const p2 of preset.constitution.principles) {
       lines.push(`- ${p2}`);
     }
     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");
+    lines.push("");
     for (const c of preset.constitution.conventions) {
       lines.push(`- ${c}`);
     }
@@ -279,20 +454,52 @@ 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("");
+  }
+  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("## Orchestrator");
+  lines.push("## How to use");
   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(`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");
 }
@@ -315,6 +522,81 @@ function generateOrchestrator(templateContent, agents, presetSkills) {
   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 fs4 from "fs";
+import path4 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 = path4.join(cwd, CONFIG_FILE);
+  fs4.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function loadConfig(cwd = process.cwd()) {
+  const filePath = path4.join(cwd, CONFIG_FILE);
+  if (!fs4.existsSync(filePath)) return null;
+  try {
+    const raw = fs4.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, opts = {}) {
   try {
@@ -324,7 +606,7 @@ async function initCommand(presetSlug, opts = {}) {
       process.exit(1);
     }
     if (!presetSlug && !hasFlags) {
-      await interactiveInit();
+      await interactiveInit(opts.target, opts.targetExplicit);
     } else {
       await nonInteractiveInit(presetSlug, opts);
     }
@@ -339,8 +621,51 @@ async function initCommand(presetSlug, opts = {}) {
     process.exit(1);
   }
 }
-async function interactiveInit() {
+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
+      });
+      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
+      });
+      if (p.isCancel(customFile)) {
+        p.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      target = resolveTarget("custom", customDir, customFile);
+    } else {
+      target = BUILTIN_TARGETS[targetChoice];
+    }
+  } else {
+    p.log.info(`Target: ${target.description}`);
+  }
   const presets = await listPresets();
   if (presets.length === 0) {
     p.cancel("No presets available.");
@@ -403,11 +728,13 @@ async function interactiveInit() {
   }
   const s = p.spinner();
   s.start("Generating project files...");
-  await generateAndWrite(preset, agentSlugs, skillSlugs);
+  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), CLAUDE.md ready.`));
+  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];
@@ -448,23 +775,24 @@ async function nonInteractiveInit(presetSlug, opts) {
   console.log(pc3.bold(pc3.cyan(`
   Initializing preset "${preset.name}"...
 `)));
-  await generateAndWrite(preset, agentSlugs, skillSlugs);
+  await generateAndWrite(preset, agentSlugs, skillSlugs, target);
+  saveConfig(target);
   console.log(
     pc3.bold(
       pc3.cyan(
         `
-  Done! ${agentSlugs.length} agent(s), ${skillSlugs.length} skill(s), CLAUDE.md ready.
+  Done! ${agentSlugs.length} agent(s), ${skillSlugs.length} skill(s), ${target.contextFile} ready.
 `
       )
     )
   );
 }
-async function generateAndWrite(preset, agentSlugs, skillSlugs) {
+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))
+    skillSlugs.map((slug) => getSkillWithFiles(slug))
   );
   const agentInfos = [];
   const agentsWithSkills = [];
@@ -478,13 +806,14 @@ async function generateAndWrite(preset, agentSlugs, skillSlugs) {
       if (slug === "orchestrator") {
         orchestratorTemplate = result.value.rawContent;
       } else {
-        writeAgent(slug, result.value.rawContent);
+        writeAgent(target, slug, result.value.rawContent);
         console.log(pc3.green(`  \u2713 Agent: ${slug}`));
       }
       agentInfos.push({
         slug,
         name: fm.name || slug,
-        role: fm.role || ""
+        role: fm.role || "",
+        description: fm.description || ""
       });
       agentsWithSkills.push({
         slug,
@@ -502,22 +831,23 @@ async function generateAndWrite(preset, agentSlugs, skillSlugs) {
       agentsWithSkills,
       skillSlugs
     );
-    writeOrchestrator(orchestratorContent);
-    console.log(pc3.green(`  \u2713 orchestrator.md generated`));
+    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(slug, result.value.rawContent);
-      console.log(pc3.green(`  \u2713 Skill: ${slug}`));
+      writeSkillDir(target, slug, result.value.files);
+      const fileCount = result.value.files.length;
+      console.log(pc3.green(`  \u2713 Skill: ${slug} (${fileCount} file${fileCount !== 1 ? "s" : ""})`));
     } 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 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();
@@ -537,6 +867,106 @@ function computeAvailableSkills(preset, selectedAgentSlugs, allAgents, allSkillS
   });
 }
 
+// src/commands/marketplace.ts
+import pc4 from "picocolors";
+var DEFAULT_API_URL = "https://loom.voidcorp.io";
+function padEnd2(str, len) {
+  return str + " ".repeat(Math.max(0, len - str.length));
+}
+function truncate2(str, max) {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 1) + "\u2026";
+}
+function getApiUrl() {
+  return process.env.LOOM_API_URL ?? DEFAULT_API_URL;
+}
+async function marketplaceSearchCommand(query, opts) {
+  try {
+    const url = new URL("/api/cli/marketplace", getApiUrl());
+    if (query) url.searchParams.set("q", query);
+    if (opts?.type) url.searchParams.set("type", opts.type);
+    if (opts?.sort) url.searchParams.set("sort", opts.sort);
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const data = await res.json();
+    if (data.items.length === 0) {
+      console.log(pc4.dim("\n  No results found.\n"));
+      return;
+    }
+    console.log(
+      pc4.bold(pc4.cyan(`
+  Marketplace${query ? ` \u2014 "${query}"` : ""}`))
+    );
+    console.log(pc4.dim("  " + "\u2500".repeat(70)));
+    for (const item of data.items) {
+      const type = pc4.dim(`[${item.type}]`);
+      const installs = pc4.dim(`\u2193${item.installCount}`);
+      const author = item.authorName ? pc4.dim(`by ${item.authorName}`) : "";
+      console.log(
+        `  ${padEnd2(pc4.green(item.slug), 25)} ${padEnd2(type, 14)} ${padEnd2(truncate2(item.title, 25), 27)} ${installs} ${author}`
+      );
+    }
+    console.log(
+      pc4.dim(
+        `
+  Install with: ${pc4.reset("loom marketplace install <slug>")}
+`
+      )
+    );
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(pc4.red(`
+  \u2717 ${error.message}
+`));
+    } else {
+      console.error(pc4.red("\n  \u2717 Could not reach the marketplace.\n"));
+    }
+    process.exit(1);
+  }
+}
+async function marketplaceInstallCommand(slug) {
+  try {
+    const url = new URL("/api/cli/marketplace/install", getApiUrl());
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ slug })
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      throw new Error(body.error ?? `HTTP ${res.status}`);
+    }
+    const data = await res.json();
+    const r = data.resource;
+    if (r.type === "agent") {
+      saveLocalAgent(r.slug, r.content);
+    } else if (r.type === "skill") {
+      const files = r.files?.length ? r.files.map((f) => ({ relativePath: f.relativePath, content: f.content })) : [{ relativePath: "SKILL.md", content: r.content }];
+      saveLocalSkill(r.slug, files);
+    } else if (r.type === "preset") {
+      saveLocalPreset(r.slug, r.content);
+    }
+    console.log(
+      pc4.green(`
+  \u2713 Installed "${r.title}" (${r.type}) to ~/.loom/library/
+`)
+    );
+    console.log(
+      pc4.dim(`  Use it: loom add ${r.type} ${r.slug}
+`)
+    );
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(pc4.red(`
+  \u2717 ${error.message}
+`));
+    } else {
+      console.error(pc4.red("\n  \u2717 Installation failed.\n"));
+    }
+    process.exit(1);
+  }
+}
+
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
@@ -545,10 +975,46 @@ program.name("loom").description("Integrate Loom library (agents, skills, preset
 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)").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.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
+  });
+});
+var mp = program.command("marketplace").alias("mp").description("Browse and install community resources");
+mp.command("search").description("Search the marketplace").argument("[query]", "Search query").option("--type <type>", "Filter by type: agent, skill, preset").option("--sort <sort>", "Sort: popular, recent", "popular").action(
+  async (query, opts) => {
+    await marketplaceSearchCommand(query, opts);
+  }
+);
+mp.command("install").description("Install a resource from the marketplace").argument("<slug>", "Resource slug to install").action(async (slug) => {
+  await marketplaceInstallCommand(slug);
 });
 program.parse();