add-plugin 0.0.1 → 0.0.2

package/README.md

@@ -0,0 +1,15 @@
+# add-plugin
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.3.8. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/dist/index.js

@@ -0,0 +1,690 @@
+#!/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");
+    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";
+async function installPlugins(plugins, target, scope, repoPath, source) {
+  switch (target.id) {
+    case "claude-code":
+      await installToVendor(plugins, scope, repoPath, source, {
+        vendorDir: ".claude-plugin",
+        cliCommand: "claude",
+        envVar: "CLAUDE_PLUGIN_ROOT",
+        displayName: "Claude Code"
+      });
+      break;
+    case "cursor":
+      await installToVendor(plugins, scope, repoPath, source, {
+        vendorDir: ".cursor-plugin",
+        cliCommand: "cursor",
+        envVar: "CURSOR_PLUGIN_ROOT",
+        displayName: "Cursor"
+      });
+      break;
+    default:
+      throw new Error(`Unsupported target: ${target.id}`);
+  }
+}
+async function installToVendor(plugins, scope, repoPath, source, vendor) {
+  const marketplaceName = plugins[0]?.marketplace ?? deriveMarketplaceName(source);
+  console.log(`
+Preparing plugins for ${vendor.displayName}...`);
+  await prepareForVendor(plugins, repoPath, marketplaceName, vendor);
+  console.log(`Adding marketplace from local path: ${repoPath}`);
+  try {
+    const output = execSync2(`${vendor.cliCommand} plugin marketplace add ${repoPath}`, {
+      encoding: "utf-8",
+      stdio: "pipe"
+    });
+    console.log("  Marketplace added.");
+  } 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: ${stderr || stdout}`);
+      process.exit(1);
+    }
+  }
+  for (const plugin of plugins) {
+    const pluginRef = `${plugin.name}@${marketplaceName}`;
+    console.log(`
+Installing ${pluginRef}...`);
+    try {
+      execSync2(`${vendor.cliCommand} 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: ${stderr || stdout}`);
+      }
+    }
+  }
+}
+async function prepareForVendor(plugins, repoPath, marketplaceName, vendor) {
+  const vendorPluginDir = join3(repoPath, vendor.vendorDir);
+  await mkdir(vendorPluginDir, { recursive: true });
+  const marketplaceJson = {
+    name: marketplaceName,
+    owner: { name: "add-plugin" },
+    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(vendorPluginDir, "marketplace.json"),
+    JSON.stringify(marketplaceJson, null, 2)
+  );
+  console.log(`  Generated ${vendor.vendorDir}/marketplace.json`);
+  for (const plugin of plugins) {
+    await preparePluginDir(plugin, vendor);
+  }
+}
+async function preparePluginDir(plugin, vendor) {
+  const pluginPath = plugin.path;
+  const openPluginDir = join3(pluginPath, ".plugin");
+  const vendorPluginDir = join3(pluginPath, vendor.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/ -> ${vendor.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 ${vendor.vendorDir}/plugin.json`);
+  }
+  await translateEnvVars(pluginPath, plugin.name, vendor);
+}
+async function translateEnvVars(pluginPath, pluginName, vendor) {
+  const configFiles = [
+    join3(pluginPath, "hooks", "hooks.json"),
+    join3(pluginPath, ".mcp.json"),
+    join3(pluginPath, ".lsp.json")
+  ];
+  for (const filePath of configFiles) {
+    if (!existsSync2(filePath)) continue;
+    let content = await readFile2(filePath, "utf-8");
+    if (content.includes("${PLUGIN_ROOT}")) {
+      content = content.replaceAll("${PLUGIN_ROOT}", `\${${vendor.envVar}}`);
+      await writeFile(filePath, content);
+      console.log(
+        `  ${pluginName}: translated \${PLUGIN_ROOT} -> \${${vendor.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] ?? "add-plugin";
+}
+
+// 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 "discover":
+    await cmdDiscover(rest[0]);
+    break;
+  case "targets":
+    await cmdTargets();
+    break;
+  case "install":
+    await cmdInstall(rest[0], values);
+    break;
+  default:
+    await cmdInstall(command, values);
+}
+function printUsage() {
+  console.log(`
+add-plugin - Install open-plugin format plugins into agent tools
+
+Usage:
+  add-plugin discover <repo-path-or-url>    Discover plugins in a repo
+  add-plugin targets                        List available install targets
+  add-plugin install <repo-path-or-url>     Install plugins from a repo
+  add-plugin <repo-path-or-url>             Shorthand for install
+
+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 target;
+  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);
+    }
+    target = found;
+  } else if (detectedTargets.length === 1) {
+    target = detectedTargets[0];
+  } else if (detectedTargets.length === 0) {
+    console.error("No supported targets detected. Use --target to specify one.");
+    process.exit(1);
+  } else {
+    console.log(`Multiple targets detected: ${detectedTargets.map((t) => t.id).join(", ")}`);
+    console.log(`Using: ${detectedTargets[0].id} (use --target to override)
+`);
+    target = detectedTargets[0];
+  }
+  console.log(`Found ${plugins.length} plugin(s):
+`);
+  for (const p of plugins) {
+    printPlugin(p);
+  }
+  console.log(`Target: ${target.name}`);
+  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";
+  await installPlugins(plugins, target, scope, repoPath, source);
+  console.log("\nDone. Restart your agent tool 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", "add-plugin");
+    mkdirSync(cacheDir, { recursive: true });
+    const tmpDir = join4(cacheDir, encodeURIComponent(url));
+    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,15 +1,20 @@
 {
   "name": "add-plugin",
-  "version": "0.0.1",
-  "publishConfig": {
-    "access": "public"
+  "version": "0.0.2",
+  "description": "Install open-plugin format plugins into agent tools",
+  "type": "module",
+  "bin": {
+    "add-plugin": "dist/index.js"
   },
-  "main": "index.js",
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsup",
+    "start": "node dist/index.js"
   },
-  "author": "",
-  "license": "ISC",
-  "description": "",
-  "packageManager": "pnpm@9.15.0+sha512.76e2379760a4328ec4415815bcd6628dee727af3779aaa4c914e3944156c4299921a89f976381ee107d41f12cfa4b66681ca9c718f0668fa0831ed4c6d8ba56c"
+  "devDependencies": {
+    "tsup": "^8",
+    "typescript": "^5"
+  }
 }

package/index.js

@@ -1 +0,0 @@
-console.log("Hello World");