plugins 0.4.2 → 1.0.1

package/dist/index.js

@@ -0,0 +1,946 @@
+#!/usr/bin/env node
+
+// index.ts
+import { parseArgs } from "util";
+import { resolve, join as join4 } from "path";
+import { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync3, rmSync, mkdirSync } from "fs";
+import { createInterface } from "readline";
+
+// lib/discover.ts
+import { join } from "path";
+import { readFile, readdir, stat } from "fs/promises";
+import { existsSync } from "fs";
+
+// lib/ui.ts
+var isColorSupported = process.env.FORCE_COLOR !== "0" && !process.env.NO_COLOR && (process.env.FORCE_COLOR !== void 0 || process.stdout.isTTY);
+function ansi(code) {
+  return isColorSupported ? `\x1B[${code}m` : "";
+}
+var reset = ansi("0");
+var bold = ansi("1");
+var dim = ansi("2");
+var italic = ansi("3");
+var underline = ansi("4");
+var red = ansi("31");
+var green = ansi("32");
+var yellow = ansi("33");
+var blue = ansi("34");
+var magenta = ansi("35");
+var cyan = ansi("36");
+var gray = ansi("90");
+var bgGreen = ansi("42");
+var bgRed = ansi("41");
+var bgYellow = ansi("43");
+var bgCyan = ansi("46");
+var black = ansi("30");
+var c = {
+  bold: (s) => `${bold}${s}${reset}`,
+  dim: (s) => `${dim}${s}${reset}`,
+  italic: (s) => `${italic}${s}${reset}`,
+  underline: (s) => `${underline}${s}${reset}`,
+  red: (s) => `${red}${s}${reset}`,
+  green: (s) => `${green}${s}${reset}`,
+  yellow: (s) => `${yellow}${s}${reset}`,
+  blue: (s) => `${blue}${s}${reset}`,
+  magenta: (s) => `${magenta}${s}${reset}`,
+  cyan: (s) => `${cyan}${s}${reset}`,
+  gray: (s) => `${gray}${s}${reset}`,
+  bgGreen: (s) => `${bgGreen}${black}${s}${reset}`,
+  bgRed: (s) => `${bgRed}${black}${s}${reset}`,
+  bgYellow: (s) => `${bgYellow}${black}${s}${reset}`,
+  bgCyan: (s) => `${bgCyan}${black}${s}${reset}`
+};
+var S = {
+  // Box drawing
+  bar: "\u2502",
+  barEnd: "\u2514",
+  barStart: "\u250C",
+  barH: "\u2500",
+  corner: "\u256E",
+  // Bullets
+  diamond: "\u25C7",
+  diamondFilled: "\u25C6",
+  bullet: "\u25CF",
+  circle: "\u25CB",
+  check: "\u2714",
+  cross: "\u2716",
+  arrow: "\u2192",
+  warning: "\u25B2",
+  info: "\u2139",
+  step: "\u25C7",
+  stepActive: "\u25C6",
+  stepComplete: "\u25CF",
+  stepError: "\u25A0"
+};
+function barLine(content = "") {
+  console.log(`${c.gray(S.bar)}  ${content}`);
+}
+function barEmpty() {
+  console.log(`${c.gray(S.bar)}`);
+}
+function step(content) {
+  console.log(`${c.gray(S.step)}  ${content}`);
+}
+function stepDone(content) {
+  console.log(`${c.green(S.stepComplete)}  ${content}`);
+}
+function stepError(content) {
+  console.log(`${c.red(S.stepError)}  ${content}`);
+}
+function header(label) {
+  console.log();
+  console.log(`${c.gray(S.barStart)}  ${c.bgCyan(` ${label} `)}`);
+}
+function footer(message) {
+  if (message) {
+    console.log(`${c.gray(S.barEnd)}  ${message}`);
+  } else {
+    console.log(`${c.gray(S.barEnd)}`);
+  }
+}
+function error(title, details) {
+  console.log(`${c.red(S.stepError)}  ${c.red(c.bold(title))}`);
+  if (details) {
+    for (const line of details) {
+      barLine(c.dim(line));
+    }
+  }
+}
+var BANNER_LINES = [
+  "\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557     \u2588\u2588\u2557   \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557",
+  "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D",
+  "\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557",
+  "\u2588\u2588\u2554\u2550\u2550\u2550\u255D \u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551",
+  "\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551",
+  "\u255A\u2550\u255D     \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D"
+];
+var GRADIENT = [
+  [60, 60, 60],
+  [90, 90, 90],
+  [125, 125, 125],
+  [160, 160, 160],
+  [200, 200, 200],
+  [240, 240, 240]
+];
+function rgb(r, g, b) {
+  return isColorSupported ? `\x1B[38;2;${r};${g};${b}m` : "";
+}
+function banner() {
+  console.log();
+  for (let i = 0; i < BANNER_LINES.length; i++) {
+    const [r, g, b] = GRADIENT[i];
+    console.log(`${rgb(r, g, b)}${BANNER_LINES[i]}${reset}`);
+  }
+}
+
+// lib/discover.ts
+async function discover(repoPath) {
+  const marketplacePaths = [
+    join(repoPath, "marketplace.json"),
+    join(repoPath, ".plugin", "marketplace.json"),
+    join(repoPath, ".claude-plugin", "marketplace.json"),
+    join(repoPath, ".cursor-plugin", "marketplace.json")
+  ];
+  for (const mp of marketplacePaths) {
+    if (await fileExists(mp)) {
+      const data = await readJson(mp);
+      if (data && typeof data === "object" && "plugins" in data && Array.isArray(data.plugins)) {
+        return discoverFromMarketplace(repoPath, data);
+      }
+    }
+  }
+  if (await isPluginDir(repoPath)) {
+    const plugin = await inspectPlugin(repoPath);
+    return plugin ? [plugin] : [];
+  }
+  const plugins = [];
+  await scanForPlugins(repoPath, plugins, 2);
+  return plugins;
+}
+async function scanForPlugins(dirPath, results, depth) {
+  if (depth <= 0) return;
+  const entries = await readDirSafe(dirPath);
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    const childPath = join(dirPath, entry.name);
+    if (await isPluginDir(childPath)) {
+      const plugin = await inspectPlugin(childPath);
+      if (plugin) results.push(plugin);
+    } else {
+      await scanForPlugins(childPath, results, depth - 1);
+    }
+  }
+}
+async function discoverFromMarketplace(repoPath, marketplace) {
+  const plugins = [];
+  const root = marketplace.metadata?.pluginRoot ?? ".";
+  for (const entry of marketplace.plugins) {
+    const sourcePath = join(repoPath, root, entry.source.replace(/^\.\//, ""));
+    if (!await dirExists(sourcePath)) {
+      barLine(`${c.yellow(S.warning)}  ${c.yellow(`Plugin source not found: ${entry.source}`)}`);
+      continue;
+    }
+    let skills;
+    if (entry.skills && Array.isArray(entry.skills)) {
+      skills = [];
+      for (const skillPath of entry.skills) {
+        const resolvedPath = join(repoPath, root, skillPath.replace(/^\.\//, ""));
+        const skillMd = join(resolvedPath, "SKILL.md");
+        if (await fileExists(skillMd)) {
+          const content = await readFile(skillMd, "utf-8");
+          const fm = parseFrontmatter(content);
+          skills.push({
+            name: fm.name ?? dirName(resolvedPath),
+            description: fm.description ?? ""
+          });
+        }
+      }
+    } else {
+      skills = await discoverSkills(sourcePath);
+    }
+    let manifest = null;
+    for (const manifestDir of [".plugin", ".claude-plugin", ".cursor-plugin"]) {
+      const manifestPath = join(sourcePath, manifestDir, "plugin.json");
+      if (await fileExists(manifestPath)) {
+        manifest = await readJson(manifestPath);
+        break;
+      }
+    }
+    const [commands, agents, rules, hasHooks, hasMcp, hasLsp] = await Promise.all([
+      discoverCommands(sourcePath),
+      discoverAgents(sourcePath),
+      discoverRules(sourcePath),
+      fileExists(join(sourcePath, "hooks", "hooks.json")),
+      fileExists(join(sourcePath, ".mcp.json")),
+      fileExists(join(sourcePath, ".lsp.json"))
+    ]);
+    const name = entry.name || manifest?.name || dirName(sourcePath);
+    plugins.push({
+      name,
+      version: entry.version || manifest?.version || void 0,
+      description: entry.description || manifest?.description || void 0,
+      path: sourcePath,
+      marketplace: marketplace.name,
+      skills,
+      commands,
+      agents,
+      rules,
+      hasHooks,
+      hasMcp,
+      hasLsp,
+      manifest,
+      explicitSkillPaths: entry.skills,
+      marketplaceEntry: entry
+    });
+  }
+  return plugins;
+}
+async function isPluginDir(dirPath) {
+  const checks = [
+    join(dirPath, ".plugin", "plugin.json"),
+    join(dirPath, ".claude-plugin", "plugin.json"),
+    join(dirPath, ".cursor-plugin", "plugin.json"),
+    join(dirPath, "skills"),
+    join(dirPath, "commands"),
+    join(dirPath, "agents"),
+    join(dirPath, "SKILL.md")
+  ];
+  for (const check of checks) {
+    if (await pathExists(check)) return true;
+  }
+  return false;
+}
+async function inspectPlugin(pluginPath) {
+  let manifest = null;
+  for (const manifestDir of [".plugin", ".claude-plugin", ".cursor-plugin"]) {
+    const manifestPath = join(pluginPath, manifestDir, "plugin.json");
+    if (await fileExists(manifestPath)) {
+      manifest = await readJson(manifestPath);
+      break;
+    }
+  }
+  const name = manifest?.name ?? dirName(pluginPath);
+  const [skills, commands, agents, rules, hasHooks, hasMcp, hasLsp] = await Promise.all([
+    discoverSkills(pluginPath),
+    discoverCommands(pluginPath),
+    discoverAgents(pluginPath),
+    discoverRules(pluginPath),
+    fileExists(join(pluginPath, "hooks", "hooks.json")),
+    fileExists(join(pluginPath, ".mcp.json")),
+    fileExists(join(pluginPath, ".lsp.json"))
+  ]);
+  return {
+    name,
+    version: manifest?.version,
+    description: manifest?.description,
+    path: pluginPath,
+    marketplace: void 0,
+    skills,
+    commands,
+    agents,
+    rules,
+    hasHooks,
+    hasMcp,
+    hasLsp,
+    manifest,
+    explicitSkillPaths: void 0,
+    marketplaceEntry: void 0
+  };
+}
+async function discoverSkills(pluginPath) {
+  const skillsDir = join(pluginPath, "skills");
+  const entries = await readDirSafe(skillsDir);
+  const skills = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillMd = join(skillsDir, entry.name, "SKILL.md");
+    if (await fileExists(skillMd)) {
+      const content = await readFile(skillMd, "utf-8");
+      const fm = parseFrontmatter(content);
+      skills.push({
+        name: fm.name ?? entry.name,
+        description: fm.description ?? ""
+      });
+    }
+  }
+  if (skills.length === 0) {
+    const rootSkill = join(pluginPath, "SKILL.md");
+    if (await fileExists(rootSkill)) {
+      const content = await readFile(rootSkill, "utf-8");
+      const fm = parseFrontmatter(content);
+      skills.push({
+        name: fm.name ?? dirName(pluginPath),
+        description: fm.description ?? ""
+      });
+    }
+  }
+  return skills;
+}
+async function discoverCommands(pluginPath) {
+  const commandsDir = join(pluginPath, "commands");
+  const entries = await readDirSafe(commandsDir);
+  const commands = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.match(/\.(md|mdc|markdown)$/)) continue;
+    const filePath = join(commandsDir, entry.name);
+    const content = await readFile(filePath, "utf-8");
+    const fm = parseFrontmatter(content);
+    commands.push({
+      name: entry.name.replace(/\.(md|mdc|markdown)$/, ""),
+      description: fm.description ?? ""
+    });
+  }
+  return commands;
+}
+async function discoverAgents(pluginPath) {
+  const agentsDir = join(pluginPath, "agents");
+  const entries = await readDirSafe(agentsDir);
+  const agents = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.match(/\.(md|mdc|markdown)$/)) continue;
+    const filePath = join(agentsDir, entry.name);
+    const content = await readFile(filePath, "utf-8");
+    const fm = parseFrontmatter(content);
+    if (fm.name && fm.description) {
+      agents.push({
+        name: fm.name,
+        description: fm.description
+      });
+    }
+  }
+  return agents;
+}
+async function discoverRules(pluginPath) {
+  const rulesDir = join(pluginPath, "rules");
+  const entries = await readDirSafe(rulesDir);
+  const rules = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.match(/\.(mdc|md|markdown)$/)) continue;
+    const filePath = join(rulesDir, entry.name);
+    const content = await readFile(filePath, "utf-8");
+    const fm = parseFrontmatter(content);
+    rules.push({
+      name: entry.name.replace(/\.(mdc|md|markdown)$/, ""),
+      description: fm.description ?? ""
+    });
+  }
+  return rules;
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match?.[1]) return {};
+  const result = {};
+  for (const line of match[1].split("\n")) {
+    const kv = line.match(/^(\w[\w-]*):\s*(.+)$/);
+    if (kv) {
+      let val = kv[2].trim();
+      if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+        val = val.slice(1, -1);
+      }
+      if (val === "true") {
+        result[kv[1]] = true;
+      } else if (val === "false") {
+        result[kv[1]] = false;
+      } else {
+        result[kv[1]] = val;
+      }
+    }
+  }
+  return result;
+}
+function dirName(p) {
+  const parts = p.replace(/\/$/, "").split("/");
+  return parts[parts.length - 1] ?? "unknown";
+}
+async function fileExists(path) {
+  try {
+    const s = await stat(path);
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
+async function dirExists(dirPath) {
+  try {
+    const s = await stat(dirPath);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function pathExists(p) {
+  return existsSync(p);
+}
+async function readJson(path) {
+  try {
+    const content = await readFile(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function readDirSafe(dirPath) {
+  try {
+    return await readdir(dirPath, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+
+// lib/targets.ts
+import { join as join2 } from "path";
+import { homedir } from "os";
+import { execSync } from "child_process";
+var HOME = homedir();
+var TARGET_DEFS = [
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    description: "Anthropic's CLI coding agent",
+    configPath: join2(HOME, ".claude")
+  },
+  {
+    id: "cursor",
+    name: "Cursor",
+    description: "AI-powered code editor",
+    configPath: join2(HOME, ".cursor")
+  }
+  // Future targets can be added here:
+  // {
+  //   id: "opencode",
+  //   name: "OpenCode",
+  //   description: "Open-source coding agent",
+  //   configPath: join(HOME, ".config", "opencode"),
+  // },
+];
+async function getTargets() {
+  const targets = [];
+  for (const def of TARGET_DEFS) {
+    const detected = detectTarget(def);
+    targets.push({ ...def, detected });
+  }
+  return targets;
+}
+function detectTarget(def) {
+  switch (def.id) {
+    case "claude-code":
+      return detectBinary("claude");
+    case "cursor":
+      return detectBinary("cursor") && detectBinary("claude");
+    default:
+      return false;
+  }
+}
+function detectBinary(name) {
+  try {
+    execSync(`which ${name}`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// lib/install.ts
+import { join as join3, relative } from "path";
+import { mkdir, cp, readFile as readFile2, writeFile } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { homedir as homedir2 } from "os";
+function installerKey(targetId) {
+  switch (targetId) {
+    case "claude-code":
+    case "cursor":
+      return "claude-code";
+    default:
+      return targetId;
+  }
+}
+var completedInstallers = /* @__PURE__ */ new Set();
+async function installPlugins(plugins, target, scope, repoPath, source) {
+  const key = installerKey(target.id);
+  if (completedInstallers.has(key)) {
+    return;
+  }
+  switch (key) {
+    case "claude-code":
+      await installToClaudeCode(plugins, scope, repoPath, source);
+      break;
+    default:
+      throw new Error(`Unsupported target: ${target.id}`);
+  }
+  completedInstallers.add(key);
+}
+async function installToClaudeCode(plugins, scope, repoPath, source) {
+  const marketplaceName = plugins[0]?.marketplace ?? deriveMarketplaceName(source);
+  step("Preparing plugins for Claude Code...");
+  barEmpty();
+  await prepareForClaudeCode(plugins, repoPath, marketplaceName);
+  const claudePath = findClaude();
+  step("Adding marketplace");
+  barLine(c.dim(`Binary: ${claudePath}`));
+  try {
+    const version = execSync2(`${claudePath} --version`, { encoding: "utf-8", stdio: "pipe" }).trim();
+    barLine(c.dim(`Version: ${version}`));
+  } catch {
+    barLine(c.dim(`Warning: could not get claude version`));
+  }
+  try {
+    const result = execSync2(`${claudePath} plugin marketplace add ${repoPath}`, {
+      encoding: "utf-8",
+      stdio: "pipe"
+    });
+    if (result.trim()) barLine(c.dim(result.trim()));
+    stepDone("Marketplace added");
+  } catch (err) {
+    const stderr = err.stderr?.toString().trim() ?? "";
+    const stdout = err.stdout?.toString().trim() ?? "";
+    if (stderr.includes("already") || stdout.includes("already")) {
+      stepDone(`Marketplace ${c.dim("'" + marketplaceName + "'")} already on disk`);
+    } else {
+      stepError("Failed to add marketplace.");
+      barLine(c.dim(`Command: ${claudePath} plugin marketplace add ${repoPath}`));
+      if (stdout) barLine(c.dim(`stdout: ${stdout}`));
+      if (stderr) barLine(c.dim(`stderr: ${stderr}`));
+      barLine(c.dim(`exit code: ${err.status}`));
+      process.exit(1);
+    }
+  }
+  barEmpty();
+  for (const plugin of plugins) {
+    const pluginRef = `${plugin.name}@${marketplaceName}`;
+    step(`Installing ${c.bold(pluginRef)}...`);
+    try {
+      execSync2(`${claudePath} plugin install ${pluginRef} --scope ${scope}`, {
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+      stepDone(`Installed ${c.cyan(pluginRef)}`);
+    } catch (err) {
+      const stderr = err.stderr?.toString().trim() ?? "";
+      const stdout = err.stdout?.toString().trim() ?? "";
+      if (stderr.includes("already") || stdout.includes("already")) {
+        stepDone(`${c.cyan(pluginRef)} ${c.dim("already installed")}`);
+      } else {
+        stepError(`Failed to install ${pluginRef}`);
+        barLine(c.dim(`Command: ${claudePath} plugin install ${pluginRef} --scope ${scope}`));
+        if (stdout) barLine(c.dim(`stdout: ${stdout}`));
+        if (stderr) barLine(c.dim(`stderr: ${stderr}`));
+        barLine(c.dim(`exit code: ${err.status}`));
+      }
+    }
+  }
+}
+async function prepareForClaudeCode(plugins, repoPath, marketplaceName) {
+  const claudePluginDir = join3(repoPath, ".claude-plugin");
+  await mkdir(claudePluginDir, { recursive: true });
+  const marketplaceJson = {
+    name: marketplaceName,
+    owner: { name: "plugins" },
+    plugins: plugins.map((p) => {
+      const rel = relative(repoPath, p.path);
+      const sourcePath = rel === "" ? "./" : `./${rel}`;
+      const entry = {
+        name: p.name,
+        source: sourcePath,
+        description: p.description ?? ""
+      };
+      if (p.version) entry.version = p.version;
+      if (p.manifest?.author) entry.author = p.manifest.author;
+      if (p.manifest?.license) entry.license = p.manifest.license;
+      if (p.manifest?.keywords) entry.keywords = p.manifest.keywords;
+      return entry;
+    })
+  };
+  await writeFile(
+    join3(claudePluginDir, "marketplace.json"),
+    JSON.stringify(marketplaceJson, null, 2)
+  );
+  barLine(c.dim("Generated .claude-plugin/marketplace.json"));
+  for (const plugin of plugins) {
+    await preparePluginDirForVendor(plugin, ".claude-plugin", "CLAUDE_PLUGIN_ROOT");
+  }
+}
+function findClaude() {
+  try {
+    const path = execSync2("which claude", { encoding: "utf-8", stdio: "pipe" }).trim();
+    if (path) return path;
+  } catch {
+  }
+  const home = homedir2();
+  const candidates = [
+    join3(home, ".local", "bin", "claude"),
+    join3(home, ".bun", "bin", "claude"),
+    "/usr/local/bin/claude"
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(candidate)) return candidate;
+  }
+  return "claude";
+}
+async function preparePluginDirForVendor(plugin, vendorDir, envVar) {
+  const pluginPath = plugin.path;
+  const openPluginDir = join3(pluginPath, ".plugin");
+  const vendorPluginDir = join3(pluginPath, vendorDir);
+  const hasOpenPlugin = existsSync2(join3(openPluginDir, "plugin.json"));
+  const hasVendorPlugin = existsSync2(join3(vendorPluginDir, "plugin.json"));
+  if (hasOpenPlugin && !hasVendorPlugin) {
+    await cp(openPluginDir, vendorPluginDir, { recursive: true });
+    barLine(c.dim(`${plugin.name}: translated .plugin/ \u2192 ${vendorDir}/`));
+  }
+  if (!hasOpenPlugin && !hasVendorPlugin) {
+    await mkdir(vendorPluginDir, { recursive: true });
+    await writeFile(
+      join3(vendorPluginDir, "plugin.json"),
+      JSON.stringify(
+        {
+          name: plugin.name,
+          description: plugin.description ?? "",
+          version: plugin.version ?? "0.0.0"
+        },
+        null,
+        2
+      )
+    );
+    barLine(c.dim(`${plugin.name}: generated ${vendorDir}/plugin.json`));
+  }
+  await translateEnvVars(pluginPath, plugin.name, envVar);
+}
+var KNOWN_PLUGIN_ROOT_VARS = [
+  "PLUGIN_ROOT",
+  "CLAUDE_PLUGIN_ROOT",
+  "CURSOR_PLUGIN_ROOT"
+];
+async function translateEnvVars(pluginPath, pluginName, envVar) {
+  const configFiles = [
+    join3(pluginPath, "hooks", "hooks.json"),
+    join3(pluginPath, ".mcp.json"),
+    join3(pluginPath, ".lsp.json")
+  ];
+  const target = `\${${envVar}}`;
+  const patterns = KNOWN_PLUGIN_ROOT_VARS.filter((v) => v !== envVar).map((v) => `\${${v}}`);
+  for (const filePath of configFiles) {
+    if (!existsSync2(filePath)) continue;
+    let content = await readFile2(filePath, "utf-8");
+    let changed = false;
+    for (const pattern of patterns) {
+      if (content.includes(pattern)) {
+        content = content.replaceAll(pattern, target);
+        changed = true;
+      }
+    }
+    if (changed) {
+      await writeFile(filePath, content);
+      barLine(
+        c.dim(`${pluginName}: translated plugin root \u2192 \${${envVar}} in ${filePath.split("/").pop()}`)
+      );
+    }
+  }
+}
+function deriveMarketplaceName(source) {
+  if (source.match(/^[\w-]+\/[\w.-]+$/)) {
+    return source.replace("/", "-");
+  }
+  const sshMatch = source.match(/^git@[^:]+:(.+?)(?:\.git)?$/);
+  if (sshMatch) {
+    const parts2 = sshMatch[1].split("/").filter(Boolean);
+    if (parts2.length >= 2) {
+      return `${parts2[parts2.length - 2]}-${parts2[parts2.length - 1]}`;
+    }
+  }
+  try {
+    const url = new URL(source);
+    const parts2 = url.pathname.replace(/\.git$/, "").split("/").filter(Boolean);
+    if (parts2.length >= 2) {
+      return `${parts2[parts2.length - 2]}-${parts2[parts2.length - 1]}`;
+    }
+  } catch {
+  }
+  const parts = source.replace(/\/$/, "").split("/");
+  return parts[parts.length - 1] ?? "plugins";
+}
+
+// index.ts
+var { values, positionals } = parseArgs({
+  args: process.argv.slice(2),
+  options: {
+    help: { type: "boolean", short: "h" },
+    target: { type: "string", short: "t" },
+    scope: { type: "string", short: "s", default: "user" },
+    yes: { type: "boolean", short: "y" }
+  },
+  allowPositionals: true,
+  strict: true
+});
+var [command, ...rest] = positionals;
+if (values.help || !command) {
+  printUsage();
+  process.exit(0);
+}
+switch (command) {
+  case "add":
+    await cmdInstall(rest[0], values);
+    break;
+  case "discover":
+    await cmdDiscover(rest[0]);
+    break;
+  case "targets":
+    await cmdTargets();
+    break;
+  default:
+    await cmdInstall(command, values);
+}
+function printUsage() {
+  console.log(`
+${c.bold("plugins")} \u2014 Install open-plugin format plugins into agent tools
+
+${c.dim("Usage:")}
+  ${c.cyan("plugins add")} <repo-path-or-url>          Install plugins from a repo
+  ${c.cyan("plugins discover")} <repo-path-or-url>     Discover plugins in a repo
+  ${c.cyan("plugins targets")}                         List available install targets
+  ${c.cyan("plugins")} <repo-path-or-url>              Shorthand for add
+
+${c.dim("Options:")}
+  ${c.yellow("-t, --target")} <target>   Target tool (e.g. claude-code). Default: auto-detect
+  ${c.yellow("-s, --scope")} <scope>     Install scope: user, project, local. Default: user
+  ${c.yellow("-y, --yes")}               Skip confirmation prompts
+  ${c.yellow("-h, --help")}              Show this help
+`);
+}
+async function cmdDiscover(source) {
+  if (!source) {
+    error("Provide a repo path or URL");
+    process.exit(1);
+  }
+  banner();
+  header("plugins");
+  const repoPath = resolveSource(source);
+  const plugins = await discover(repoPath);
+  if (plugins.length === 0) {
+    barEmpty();
+    step("No plugins found.");
+    footer();
+    return;
+  }
+  barEmpty();
+  step(`Found ${c.bold(String(plugins.length))} plugin(s) in ${c.dim(source)}`);
+  barEmpty();
+  for (const p of plugins) {
+    printPlugin(p);
+  }
+  footer();
+}
+async function cmdTargets() {
+  const targets = await getTargets();
+  banner();
+  header("plugins");
+  if (targets.length === 0) {
+    barEmpty();
+    step("No supported targets detected.");
+    footer();
+    return;
+  }
+  barEmpty();
+  step("Available install targets");
+  barEmpty();
+  for (const t of targets) {
+    barLine(`  ${c.bold(t.name)}`);
+    barLine(`  ${c.dim(t.description)}`);
+    barLine(`  Config: ${c.dim(t.configPath)}`);
+    barLine(`  Status: ${t.detected ? c.green("detected") : c.dim("not found")}`);
+    barEmpty();
+  }
+  footer();
+}
+async function cmdInstall(source, opts) {
+  if (!source) {
+    error("Provide a repo path or URL");
+    process.exit(1);
+  }
+  banner();
+  header("plugins");
+  const repoPath = resolveSource(source);
+  const plugins = await discover(repoPath);
+  if (plugins.length === 0) {
+    barEmpty();
+    step("No plugins found.");
+    footer();
+    return;
+  }
+  const targets = await getTargets();
+  const detectedTargets = targets.filter((t) => t.detected);
+  let installTargets;
+  if (opts.target) {
+    const found = targets.find((t) => t.id === opts.target);
+    if (!found) {
+      barEmpty();
+      stepError(`Unknown target: ${c.bold(opts.target)}`);
+      barLine(c.dim(`Available: ${targets.map((t) => t.id).join(", ")}`));
+      footer();
+      process.exit(1);
+    }
+    installTargets = [found];
+  } else if (detectedTargets.length === 0) {
+    barEmpty();
+    stepError("No supported targets detected.");
+    barLine(c.dim("Use --target to specify one."));
+    footer();
+    process.exit(1);
+  } else {
+    installTargets = detectedTargets;
+  }
+  barEmpty();
+  step(`Found ${c.bold(String(plugins.length))} plugin(s)`);
+  barEmpty();
+  for (const p of plugins) {
+    printPlugin(p);
+  }
+  barLine(`${c.dim("Targets:")}  ${installTargets.map((t) => c.cyan(t.name)).join(c.dim(", "))}`);
+  barLine(`${c.dim("Scope:")}    ${c.cyan(opts.scope ?? "user")}`);
+  barEmpty();
+  if (!opts.yes) {
+    const response = await readLine(`${c.cyan(S.stepActive)}  Install? ${c.dim("[Y/n]")} `);
+    if (response.trim().toLowerCase() === "n") {
+      step("Aborted.");
+      footer();
+      return;
+    }
+  }
+  const scope = opts.scope ?? "user";
+  for (const target of installTargets) {
+    await installPlugins(plugins, target, scope, repoPath, source);
+  }
+  barEmpty();
+  stepDone(c.green("Done.") + "  Restart your agent tools to load the plugins.");
+  footer();
+}
+function printPlugin(p) {
+  barLine(`${c.bold(p.name)} ${p.version ? c.dim(`(v${p.version})`) : ""}`);
+  if (p.description) barLine(`${c.dim(p.description)}`);
+  const parts = [];
+  if (p.skills.length) parts.push(`${p.skills.length} skill(s)`);
+  if (p.commands.length) parts.push(`${p.commands.length} command(s)`);
+  if (p.agents.length) parts.push(`${p.agents.length} agent(s)`);
+  if (p.rules.length) parts.push(`${p.rules.length} rule(s)`);
+  if (p.hasHooks) parts.push("hooks");
+  if (p.hasMcp) parts.push("MCP servers");
+  if (p.hasLsp) parts.push("LSP servers");
+  if (parts.length) barLine(`${c.dim("Components:")} ${parts.join(c.dim(", "))}`);
+  barEmpty();
+}
+function sshToHttps(sshUrl) {
+  const m = sshUrl.match(/^git@([^:]+):(.+)$/);
+  if (!m) return null;
+  return `https://${m[1]}/${m[2]}`;
+}
+function resolveSource(source) {
+  if (source.startsWith("https://") || source.startsWith("git@") || source.match(/^[\w-]+\/[\w.-]+$/)) {
+    const url = source.match(/^[\w-]+\/[\w.-]+$/) ? `https://github.com/${source}` : source;
+    const cacheDir = join4(process.env.HOME ?? "~", ".cache", "plugins");
+    mkdirSync(cacheDir, { recursive: true });
+    const slug = url.replace(/^https?:\/\//, "").replace(/^git@/, "").replace(/\.git$/, "").replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+    const tmpDir = join4(cacheDir, slug);
+    if (existsSync3(join4(tmpDir, ".git", "HEAD"))) {
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+    step(`Source: ${c.dim(url)}`);
+    barEmpty();
+    try {
+      execSync3(`git clone --depth 1 -q ${url} ${tmpDir}`, { stdio: "pipe" });
+    } catch (err) {
+      const stderr = err.stderr?.toString() ?? "";
+      if (url.startsWith("git@") && stderr.includes("Permission denied")) {
+        const httpsUrl = sshToHttps(url);
+        if (httpsUrl) {
+          barLine(c.yellow("SSH authentication failed. Retrying over HTTPS..."));
+          step(`Source: ${c.dim(httpsUrl)}`);
+          barEmpty();
+          try {
+            execSync3(`git clone --depth 1 -q ${httpsUrl} ${tmpDir}`, { stdio: "inherit" });
+            stepDone("Repository cloned");
+            barEmpty();
+            return tmpDir;
+          } catch {
+          }
+        }
+      }
+      if (existsSync3(tmpDir)) {
+        rmSync(tmpDir, { recursive: true, force: true });
+      }
+      if (stderr.includes("Permission denied") || stderr.includes("Could not read from remote repository")) {
+        barEmpty();
+        stepError(`Could not access ${c.bold(url)}`);
+        barEmpty();
+        barLine(c.dim("Make sure you have access to this repository. For private repos, try:"));
+        barLine(`  ${c.dim("HTTPS:")} plugins add https://github.com/owner/repo`);
+        barLine(`  ${c.dim("       (uses git credential helper / browser auth)")}`);
+        barLine(`  ${c.dim("SSH:")}   plugins add git@github.com:owner/repo.git`);
+        barLine(`  ${c.dim("       (requires SSH keys)")}`);
+      } else if (stderr.includes("not found") || stderr.includes("does not exist") || err.status === 128) {
+        barEmpty();
+        stepError(`Repository not found: ${c.bold(url)}`);
+        barLine(c.dim("Check that the URL is correct and the repository exists."));
+      } else {
+        barEmpty();
+        stepError("git clone failed.");
+        if (stderr.trim()) barLine(c.dim(stderr.trim()));
+      }
+      footer();
+      process.exit(1);
+    }
+    stepDone("Repository cloned");
+    barEmpty();
+    return tmpDir;
+  }
+  return resolve(source);
+}
+function readLine(prompt) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve2) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      if (!process.stdin.isTTY) process.stdout.write("\n");
+      resolve2(answer);
+    });
+  });
+}