plugins 0.4.1 → 1.0.0

package/README.md

@@ -1,237 +1,17 @@
-# plugins [![NPM version](https://badge.fury.io/js/plugins.svg)](http://badge.fury.io/js/plugins)
+# plugins
 
-> Run a string through a plugin stack.
+Install open-plugin format plugins into agent tools.
 
-## Install
+## Usage
 
-Install with [npm](https://www.npmjs.com/)
-
-```sh
-$ npm i plugins --save
-```
-
-See [the examples](examples/).
-
-## Table of contents
-
-<!-- toc -->
-
-* [Docs](#docs)
-* [Creating plugins](#creating-plugins)
-  - [sync](#sync)
-  - [async](#async)
-  - [Directly run plugins](#directly-run-plugins)
-* [API](#api)
-* [Related projects](#related-projects)
-* [Running tests](#running-tests)
-* [Contributing](#contributing)
-* [Author](#author)
-* [License](#license)
-
-_(Table of contents generated by [verb])_
-
-<!-- tocstop -->
-
-## Docs
-
-See [the examples](examples/).
-
-## Creating plugins
-
-> A plugin can take any arguments and **must return a function**.
-
-### sync
-
-Plugins just return a value.
-
-**Example:**
-
-```js
-var plugins = new Plugins();
-
-plugins
-  .use(function (str) {
-    return str + 'a';
-  })
-  .use(function (str) {
-    return str + 'b';
-  })
-  .use(function (str) {
-    return str + 'c';
-  });
-
-console.log(plugins.run('alphabet-'));
-//=> 'alphabet-abc'
-```
-
-### async
-
-Pass `next` as the last argument to run plugins asynchronously.
-
-**Example:**
-
-```js
-var plugins = new Plugins();
-
-plugins
-  .use(function (str, next) {
-    next(null, str + 'a');
-  })
-  .use(function (str, next) {
-    next(null, str + 'b');
-  })
-  .use(function (str, next) {
-    next(null, str + 'c');
-  });
-
-plugins.run('alphabet-', function (err, str) {
-  console.log(str); //=> 'alphabet-abc'
-});
-```
-
-### Directly run plugins
-
-To run plugins **without** `.use()`, pass an array of functions as a section argument to `.run()`.
-
-**sync example:**
-
-```js
-var plugins = new Plugins();
-
-var a = function(val) {
-  return val + 'a';
-};
-var b = function(val) {
-  return val + 'b';
-};
-var c = function(val) {
-  return val + 'c';
-};
-
-console.log(plugins.run('alphabet-', [a, b, c]));
-//=> 'alphabet-abc'
-```
-
-**async example:**
-
-```js
-var plugins = new Plugins();
-
-var a = function (str, next) {
-  next(null, str + 'a');
-};
-var b = function (str, next) {
-  next(null, str + 'b');
-};
-var c = function (str, next) {
-  next(null, str + 'c');
-};
-
-plugins.run('alphabet-', [a, b, c], function (err, str) {
-  console.log(str); //=> 'alphabet-abc'
-});
-```
-
-## API
-
-See [the examples](examples/).
-
-### [Plugins](index.js#L23)
-
-Initialize `Plugins`
-
-**Example**
-
-```js
-var Plugins = require('plugins');
-var plugins = new Plugins();
+```bash
+npx plugins add <repo-path-or-url>
 ```
 
-### [.use](index.js#L57)
-
-Add a plugin `fn` to the `plugins` stack.
-
-**Params**
-
-* `fn` **{Function}**: Plugin function to add to the `plugins` stack.
-* `returns` **{Object}** `Plugins`: to enable chaining.
+## Development
 
-**Example**
-
-```js
-plugins
-  .use(foo)
-  .use(bar)
-  .use(baz)
+```bash
+npm install
+npm run build
+node dist/index.js --help
 ```
-
-### [.run](index.js#L73)
-
-Call each `fn` in the `plugins` stack to iterate over `val`.
-
-**Params**
-
-* `val` **{Array|Object|String}**: The value to iterate over.
-
-**Example**
-
-```js
-plugins.run(value)
-```
-
-### [.iterator](index.js#L87)
-
-Register an iterator `fn` by its `type`.
-
-**Params**
-
-* `type` **{String}**: The iterator type.
-* `fn` **{Function}**: Iterator function
-
-### [.pipeline](index.js#L103)
-
-Add each plugin to a pipeline to be used with streams. Plugins must either be a stream or a function that returns a stream.
-
-**Params**
-
-* `val` **{Array|Object|String}**: The value to iterate over.
-
-**Example**
-
-```js
-var pipeline = plugins.pipeline(plugin());
-```
-
-## Related projects
-
-[async-array-reduce](https://github.com/jonschlinkert/async-array-reduce): Async reduce.
-
-## Running tests
-
-Install dev dependencies:
-
-```sh
-$ npm i -d && npm test
-```
-
-## Contributing
-
-Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](https://github.com/jonschlinkert/plugins/issues/new)
-
-## Author
-
-**Jon Schlinkert**
-
-+ [github/jonschlinkert](https://github.com/jonschlinkert)
-+ [twitter/jonschlinkert](http://twitter.com/jonschlinkert)
-
-## License
-
-Copyright © 2015 Jon Schlinkert
-Released under the MIT license.
-
-***
-
-_This file was generated by [verb-cli](https://github.com/assemble/verb-cli) on August 14, 2015._
-
-[verb]: https://github.com/assemble/verb

package/dist/index.js

@@ -0,0 +1,737 @@
+#!/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";
+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)) {
+      console.warn(`  Warning: 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);
+  console.log("\nPreparing plugins for Claude Code...");
+  await prepareForClaudeCode(plugins, repoPath, marketplaceName);
+  const claudePath = findClaude();
+  console.log(`Adding marketplace from local path: ${repoPath}`);
+  console.log(`  Using claude binary: ${claudePath}`);
+  try {
+    const version = execSync2(`${claudePath} --version`, { encoding: "utf-8", stdio: "pipe" }).trim();
+    console.log(`  Claude Code version: ${version}`);
+  } catch {
+    console.log(`  Warning: could not get claude version`);
+  }
+  try {
+    const result = execSync2(`${claudePath} plugin marketplace add ${repoPath}`, {
+      encoding: "utf-8",
+      stdio: "pipe"
+    });
+    console.log("  Marketplace added.");
+    if (result.trim()) console.log(`  Output: ${result.trim()}`);
+  } catch (err) {
+    const stderr = err.stderr?.toString().trim() ?? "";
+    const stdout = err.stdout?.toString().trim() ?? "";
+    if (stderr.includes("already") || stdout.includes("already")) {
+      console.log("  Marketplace already registered.");
+    } else {
+      console.error(`Failed to add marketplace.`);
+      console.error(`  Command: ${claudePath} plugin marketplace add ${repoPath}`);
+      console.error(`  stdout: ${stdout}`);
+      console.error(`  stderr: ${stderr}`);
+      console.error(`  exit code: ${err.status}`);
+      process.exit(1);
+    }
+  }
+  for (const plugin of plugins) {
+    const pluginRef = `${plugin.name}@${marketplaceName}`;
+    console.log(`
+Installing ${pluginRef}...`);
+    try {
+      execSync2(`${claudePath} plugin install ${pluginRef} --scope ${scope}`, {
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+      console.log(`  Installed.`);
+    } catch (err) {
+      const stderr = err.stderr?.toString().trim() ?? "";
+      const stdout = err.stdout?.toString().trim() ?? "";
+      if (stderr.includes("already") || stdout.includes("already")) {
+        console.log(`  Already installed.`);
+      } else {
+        console.error(`  Failed to install ${pluginRef}.`);
+        console.error(`  Command: ${claudePath} plugin install ${pluginRef} --scope ${scope}`);
+        console.error(`  stdout: ${stdout}`);
+        console.error(`  stderr: ${stderr}`);
+        console.error(`  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)
+  );
+  console.log("  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 });
+    console.log(`  ${plugin.name}: translated .plugin/ -> ${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
+      )
+    );
+    console.log(`  ${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);
+      console.log(
+        `  ${pluginName}: translated plugin root -> \${${envVar}} in ${filePath.split("/").pop()}`
+      );
+    }
+  }
+}
+function deriveMarketplaceName(source) {
+  if (source.match(/^[\w-]+\/[\w.-]+$/)) {
+    return source.replace("/", "-");
+  }
+  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(`
+plugins - Install open-plugin format plugins into agent tools
+
+Usage:
+  plugins add <repo-path-or-url>          Install plugins from a repo
+  plugins discover <repo-path-or-url>     Discover plugins in a repo
+  plugins targets                         List available install targets
+  plugins <repo-path-or-url>              Shorthand for add
+
+Options:
+  -t, --target <target>   Target tool (e.g. claude-code). Default: auto-detect
+  -s, --scope <scope>     Install scope: user, project, local. Default: user
+  -y, --yes               Skip confirmation prompts
+  -h, --help              Show this help
+`);
+}
+async function cmdDiscover(source) {
+  if (!source) {
+    console.error("Error: provide a repo path or URL");
+    process.exit(1);
+  }
+  const repoPath = resolveSource(source);
+  const plugins = await discover(repoPath);
+  if (plugins.length === 0) {
+    console.log("No plugins found.");
+    return;
+  }
+  console.log(`Found ${plugins.length} plugin(s) in ${source}:
+`);
+  for (const p of plugins) {
+    printPlugin(p);
+  }
+}
+async function cmdTargets() {
+  const targets = await getTargets();
+  if (targets.length === 0) {
+    console.log("No supported targets detected.");
+    return;
+  }
+  console.log("Available install targets:\n");
+  for (const t of targets) {
+    console.log(`  ${t.name}`);
+    console.log(`    ${t.description}`);
+    console.log(`    Config: ${t.configPath}`);
+    console.log(`    Status: ${t.detected ? "detected" : "not found"}`);
+    console.log();
+  }
+}
+async function cmdInstall(source, opts) {
+  if (!source) {
+    console.error("Error: provide a repo path or URL");
+    process.exit(1);
+  }
+  const repoPath = resolveSource(source);
+  const plugins = await discover(repoPath);
+  if (plugins.length === 0) {
+    console.log("No plugins found.");
+    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) {
+      console.error(`Unknown target: ${opts.target}`);
+      console.error(`Available: ${targets.map((t) => t.id).join(", ")}`);
+      process.exit(1);
+    }
+    installTargets = [found];
+  } else if (detectedTargets.length === 0) {
+    console.error("No supported targets detected. Use --target to specify one.");
+    process.exit(1);
+  } else {
+    installTargets = detectedTargets;
+  }
+  console.log(`Found ${plugins.length} plugin(s):
+`);
+  for (const p of plugins) {
+    printPlugin(p);
+  }
+  console.log(`Targets: ${installTargets.map((t) => t.name).join(", ")}`);
+  console.log(`Scope: ${opts.scope ?? "user"}
+`);
+  if (!opts.yes) {
+    const response = await readLine("Install? [y/N] ");
+    if (response.trim().toLowerCase() !== "y") {
+      console.log("Aborted.");
+      return;
+    }
+  }
+  const scope = opts.scope ?? "user";
+  for (const target of installTargets) {
+    await installPlugins(plugins, target, scope, repoPath, source);
+  }
+  console.log("\nDone. Restart your agent tools to load the plugins.");
+}
+function printPlugin(p) {
+  console.log(`  ${p.name} (v${p.version ?? "0.0.0"})`);
+  if (p.description) console.log(`    ${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) console.log(`    Components: ${parts.join(", ")}`);
+  console.log();
+}
+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(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+    const tmpDir = join4(cacheDir, slug);
+    if (existsSync3(join4(tmpDir, ".git", "HEAD"))) {
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+    console.log(`Cloning ${url}...`);
+    execSync3(`git clone --depth 1 -q ${url} ${tmpDir}`, { stdio: "inherit" });
+    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();
+      resolve2(answer);
+    });
+  });
+}

package/package.json

@@ -1,49 +1,20 @@
 {
   "name": "plugins",
-  "description": "Run a string through a plugin stack.",
-  "version": "0.4.1",
-  "homepage": "https://github.com/jonschlinkert/plugins",
-  "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
-  "repository": "jonschlinkert/plugins",
-  "bugs": {
-    "url": "https://github.com/jonschlinkert/plugins/issues"
+  "version": "1.0.0",
+  "description": "Install open-plugin format plugins into agent tools",
+  "type": "module",
+  "bin": {
+    "plugins": "dist/index.js"
   },
-  "license": "MIT",
   "files": [
-    "index.js",
-    "iterators.js"
+    "dist"
   ],
-  "main": "index.js",
-  "engines": {
-    "node": ">=0.10.0"
-  },
   "scripts": {
-    "test": "mocha"
+    "build": "tsup",
+    "start": "node dist/index.js"
   },
   "devDependencies": {
-    "fs-utils": "^0.6.0",
-    "mocha": "^2.2.5",
-    "should": "^7.0.4"
-  },
-  "dependencies": {
-    "async-array-reduce": "^0.1.0",
-    "event-stream": "^3.3.1"
-  },
-  "keywords": [
-    "extension",
-    "extensions",
-    "helper",
-    "helpers",
-    "middleware",
-    "use",
-    "plugin",
-    "fn",
-    "fns",
-    "plugins"
-  ],
-  "verb": {
-    "related": {
-      "list": "async-array-reduce"
-    }
+    "tsup": "^8",
+    "typescript": "^5"
   }
-}
+}

package/LICENSE

@@ -1,24 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014, 2015 Jon Schlinkert.
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.

package/index.js

@@ -1,119 +0,0 @@
-/*!
- * plugins <https://github.com/jonschlinkert/plugins>
- *
- * Copyright (c) 2014 Jon Schlinkert, contributors.
- * Licensed under the MIT License
- */
-
-'use strict';
-
-var iterators = require('./iterators');
-
-/**
- * Initialize `Plugins`
- *
- * ```js
- * var Plugins = require('plugins');
- * var plugins = new Plugins();
- * ```
- * @constructor
- * @api public
- */
-
-function Plugins(options) {
-  if (!(this instanceof Plugins)) {
-    return new Plugins(options);
-  }
-  this.iterators = {};
-  this.fns = [];
-  this.init();
-}
-
-/**
- * Register default iterators
- */
-
-Plugins.prototype.init = function() {
-  this.iterator('async', iterators.async.bind(this));
-  this.iterator('stream', iterators.stream.bind(this));
-  this.iterator('sync', iterators.sync.bind(this));
-};
-
-/**
- * Add a plugin `fn` to the `plugins` stack.
- *
- * ```js
- * plugins
- *   .use(foo)
- *   .use(bar)
- *   .use(baz)
- * ```
- *
- * @param {Function} `fn` Plugin function to add to the `plugins` stack.
- * @return {Object} `Plugins` to enable chaining.
- * @api public
- */
-
-Plugins.prototype.use = function (fn) {
-  this.fns.push(fn);
-  return this;
-};
-
-/**
- * Call each `fn` in the `plugins` stack
- * to iterate over `val`.
- *
- * ```js
- * plugins.run(value)
- * ```
- * @param {Array|Object|String} `val` The value to iterate over.
- * @api public
- */
-
-Plugins.prototype.run = function () {
-  var last = arguments[arguments.length - 1];
-  var type = isFunction(last) ? 'async' : 'sync';
-  return this.iterators[type].apply(this, arguments);
-};
-
-/**
- * Register an iterator `fn` by its `type`.
- *
- * @param {String} `type` The iterator type.
- * @param {Function} `fn` Iterator function
- * @api public
- */
-
-Plugins.prototype.iterator = function(type, fn) {
-  this.iterators[type] = fn;
-  return this;
-};
-
-/**
- * Add each plugin to a pipeline to be used with streams.
- * Plugins must either be a stream or a function that returns a stream.
- *
- * ```js
- * var pipeline = plugins.pipeline(plugin());
- * ```
- * @param {Array|Object|String} `val` The value to iterate over.
- * @api public
- */
-
-Plugins.prototype.pipeline = function() {
-  return this.iterators.stream.apply(this, arguments);
-};
-
-/**
- * Utilities
- */
-
-function isFunction(val) {
-  return typeof val === 'function';
-}
-
-/**
- * Expose `Plugins`
- */
-
-module.exports = Plugins;

package/iterators.js

@@ -1,102 +0,0 @@
-var reduce = require('async-array-reduce');
-var es = require('event-stream');
-
-/**
- * Expose `iterators`
- */
-
-var iterators = module.exports;
-
-/**
- * Async iterator
- */
-
-iterators.async = function asyncIterator(val) {
-  var args = [].slice.call(arguments);
-  var fns = this.fns;
-  var cb = args.pop();
-
-  // if the second arg is an array,
-  // assume it's a plugin array
-  if (Array.isArray(args[1])) {
-    fns = fns.concat(args.pop());
-  }
-
-  var isArray = Array.isArray(args[0]);
-  var self = this, i = 0;
-
-  return reduce(fns, args, function (acc, fn, next) {
-    acc = arrayify(acc);
-    if (isArray && i > 0) acc = [acc];
-    i++;
-    fn.apply(self, acc.concat(next));
-  }.bind(this), cb);
-};
-
-/**
- * Sync iterator
- */
-
-iterators.sync = function syncIterator() {
-  var args = [].slice.call(arguments);
-  var fns = this.fns;
-
-  if (Array.isArray(args[1])) {
-    fns = fns.concat(args.pop());
-  }
-
-  return fns.reduce(function (acc, fn) {
-    return fn.apply(this, arrayify(acc));
-  }, args);
-};
-
-/**
- * Stream iterator
- * TODO: this needs to be updated to work like an iterator.
- * currently it works like a plugin itself.
- */
-
-iterators.stream = function streamIterator() {
-  var args = [].slice.call(arguments);
-  var fns = this.fns;
-
-  if (Array.isArray(args[0])) {
-    fns = fns.concat(args.unshift());
-  }
-
-  var len = fns.length, i = -1;
-  var pipeline = [];
-
-  while (++i < len) {
-    var fn = fns[i];
-    // if stream, push into pipeline
-    if (isStream(fn)) {
-      pipeline.push(fn);
-      continue;
-    }
-    // otherwise, call the function and pass in the args
-    // expect a stream to be returned to push onto the pipeline
-    try {
-      pipeline.push(fn.apply(this, args));
-    } catch (err) {
-      throw err;
-    }
-  }
-  return es.pipe.apply(es, pipeline);
-};
-
-/**
- * Utilities
- */
-
-function isStream(obj) {
-  return typeof obj === 'object' && obj.pipe && isFunction(obj.pipe);
-}
-
-function isFunction(val) {
-  return typeof val === 'function';
-}
-
-function arrayify(val) {
-  return Array.isArray(val) ? val : [val];
-}