agkit 0.7.0

package/dist/index.js

@@ -0,0 +1,1422 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync } from "fs";
+import { Command } from "commander";
+
+// src/commands/add.ts
+import fs6 from "fs";
+import path7 from "path";
+import * as p3 from "@clack/prompts";
+import pc2 from "picocolors";
+
+// src/lib/constants.ts
+var MARKETPLACE_SCHEMA_URL = "https://json.schemastore.org/claude-code-marketplace.json";
+var MARKETPLACE_DIR = ".claude-plugin";
+var MARKETPLACE_FILE = "marketplace.json";
+var PLUGIN_MANIFEST_FILE = "plugin.json";
+var DEFAULT_PLUGIN_ROOT = "./plugins";
+var RESERVED_MARKETPLACE_NAMES = [
+  "claude-code-marketplace",
+  "claude-code-plugins",
+  "claude-plugins-official",
+  "anthropic-marketplace",
+  "anthropic-plugins"
+];
+var KEBAB_CASE_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var PLUGIN_TEMPLATES = ["skill", "command", "agent", "hook", "mcp"];
+var TEMPLATE_DESCRIPTIONS = {
+  skill: "Plugin exposing an Agent Skill (SKILL.md): reference knowledge or a repeatable procedure Claude loads on demand.",
+  command: "Plugin exposing a slash command (commands/<name>.md): a prompt shortcut invoked as /<plugin>:<name>.",
+  agent: "Plugin exposing a subagent (agents/<name>.md): a named specialist with its own role and instructions.",
+  hook: "Plugin exposing an event handler (hooks/hooks.json + script): deterministic automation on Claude Code lifecycle events.",
+  mcp: "Plugin bundling an MCP server (.mcp.json + zero-dependency Node stdio server): external tools for Claude."
+};
+
+// src/lib/fsutils.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function packageRoot() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  let dir = here;
+  for (let i = 0; i < 5; i++) {
+    if (fs.existsSync(path.join(dir, "package.json"))) return dir;
+    dir = path.dirname(dir);
+  }
+  throw new Error("Unable to locate package root");
+}
+function templatesDir() {
+  return path.join(packageRoot(), "templates");
+}
+function renderTemplate(content, vars) {
+  return content.replace(
+    /\{\{([a-zA-Z0-9_]+)\}\}/g,
+    (match, key) => key in vars ? vars[key] : match
+  );
+}
+function copyTemplateDir(srcDir, destDir, vars) {
+  const written = [];
+  fs.mkdirSync(destDir, { recursive: true });
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    const renderedName = renderTemplate(entry.name, vars);
+    const srcPath = path.join(srcDir, entry.name);
+    if (entry.isDirectory()) {
+      written.push(
+        ...copyTemplateDir(srcPath, path.join(destDir, renderedName), vars)
+      );
+    } else if (renderedName.endsWith(".tpl")) {
+      const destPath = path.join(destDir, renderedName.slice(0, -4));
+      const content = renderTemplate(fs.readFileSync(srcPath, "utf8"), vars);
+      fs.writeFileSync(destPath, content, { mode: fs.statSync(srcPath).mode });
+      written.push(destPath);
+    } else {
+      const destPath = path.join(destDir, renderedName);
+      fs.copyFileSync(srcPath, destPath);
+      fs.chmodSync(destPath, fs.statSync(srcPath).mode);
+      written.push(destPath);
+    }
+  }
+  return written;
+}
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+function writeJson(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+
+// src/lib/templates.ts
+import { execFileSync } from "child_process";
+import fs2 from "fs";
+import os from "os";
+import path2 from "path";
+function parseGitSpec(spec) {
+  let ref;
+  let body = spec;
+  const hash = body.lastIndexOf("#");
+  if (hash > 0) {
+    ref = body.slice(hash + 1) || void 0;
+    body = body.slice(0, hash);
+  }
+  const shorthand = body.match(/^(gh|gl):([^/]+)\/([^/]+)(?:\/(.+))?$/);
+  if (shorthand) {
+    const host = shorthand[1] === "gh" ? "github.com" : "gitlab.com";
+    return {
+      cloneUrl: `https://${host}/${shorthand[2]}/${shorthand[3]}.git`,
+      subdir: shorthand[4],
+      ref
+    };
+  }
+  const looksLikeUrl = /^(https?|ssh|git|file):\/\//.test(body) || /^[\w.-]+@[\w.-]+:/.test(body);
+  if (looksLikeUrl) {
+    let subdir;
+    const protoEnd = body.indexOf("://");
+    const sep = body.indexOf("//", protoEnd === -1 ? 0 : protoEnd + 3);
+    if (sep !== -1) {
+      subdir = body.slice(sep + 2);
+      body = body.slice(0, sep);
+    }
+    return { cloneUrl: body, subdir, ref };
+  }
+  return void 0;
+}
+function assertTemplateDir(dir, label) {
+  const hasManifest = fs2.existsSync(path2.join(dir, ".claude-plugin", "plugin.json.tpl")) || fs2.existsSync(path2.join(dir, ".claude-plugin", "plugin.json"));
+  if (!hasManifest) {
+    throw new Error(
+      `"${label}" is not a plugin template: expected .claude-plugin/plugin.json(.tpl) in ${dir}`
+    );
+  }
+}
+function resolveTemplate(spec) {
+  if (PLUGIN_TEMPLATES.includes(spec)) {
+    return {
+      dir: path2.join(templatesDir(), "plugins", spec),
+      label: `built-in:${spec}`,
+      builtin: true
+    };
+  }
+  const localPath = spec.startsWith("path:") ? spec.slice(5) : spec.startsWith("./") || spec.startsWith("../") || path2.isAbsolute(spec) ? spec : void 0;
+  if (localPath !== void 0) {
+    const dir2 = path2.resolve(localPath);
+    if (!fs2.existsSync(dir2)) throw new Error(`Template directory not found: ${dir2}`);
+    assertTemplateDir(dir2, spec);
+    return { dir: dir2, label: spec, builtin: false };
+  }
+  const git2 = parseGitSpec(spec);
+  if (!git2) {
+    throw new Error(
+      `Unrecognized template "${spec}". Use a built-in name (${PLUGIN_TEMPLATES.join(", ")}), a local path, gh:owner/repo[/dir][#ref], gl:owner/repo[/dir][#ref], or a git URL.`
+    );
+  }
+  const tmp = fs2.mkdtempSync(path2.join(os.tmpdir(), "agkit-tpl-"));
+  const args = ["clone", "--depth", "1"];
+  if (git2.ref) args.push("--branch", git2.ref);
+  args.push(git2.cloneUrl, tmp);
+  try {
+    execFileSync("git", args, { stdio: "pipe" });
+  } catch (err) {
+    fs2.rmSync(tmp, { recursive: true, force: true });
+    const msg = err.stderr?.toString().trim();
+    throw new Error(`git clone failed for ${git2.cloneUrl}${msg ? `:
+${msg}` : ""}`);
+  }
+  const dir = git2.subdir ? path2.join(tmp, git2.subdir) : tmp;
+  if (!fs2.existsSync(dir)) {
+    fs2.rmSync(tmp, { recursive: true, force: true });
+    throw new Error(`Subdirectory "${git2.subdir}" not found in ${git2.cloneUrl}`);
+  }
+  fs2.rmSync(path2.join(tmp, ".git"), { recursive: true, force: true });
+  try {
+    assertTemplateDir(dir, spec);
+  } catch (err) {
+    fs2.rmSync(tmp, { recursive: true, force: true });
+    throw err;
+  }
+  return { dir, label: spec, cleanup: tmp, builtin: false };
+}
+
+// src/lib/marketplace.ts
+import fs3 from "fs";
+import path3 from "path";
+function marketplacePath(root) {
+  return path3.join(root, MARKETPLACE_DIR, MARKETPLACE_FILE);
+}
+function findMarketplaceRoot(startDir) {
+  let dir = path3.resolve(startDir);
+  for (; ; ) {
+    if (fs3.existsSync(marketplacePath(dir))) return dir;
+    const parent = path3.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function readMarketplace(root) {
+  return readJson(marketplacePath(root));
+}
+function writeMarketplace(root, data) {
+  writeJson(marketplacePath(root), data);
+}
+function pluginRootDir(root, mp) {
+  const rel = mp.metadata?.pluginRoot ?? DEFAULT_PLUGIN_ROOT;
+  return path3.resolve(root, rel);
+}
+function resolveLocalPluginDir(root, mp, entry) {
+  if (typeof entry.source !== "string") return void 0;
+  if (entry.source.startsWith("./") || entry.source.startsWith("../")) {
+    return path3.resolve(root, entry.source);
+  }
+  return path3.join(pluginRootDir(root, mp), entry.source);
+}
+function scanLocalPlugins(root, mp) {
+  const base = pluginRootDir(root, mp);
+  if (!fs3.existsSync(base)) return [];
+  const result = [];
+  for (const entry of fs3.readdirSync(base, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const manifestPath = path3.join(
+      base,
+      entry.name,
+      MARKETPLACE_DIR,
+      PLUGIN_MANIFEST_FILE
+    );
+    if (!fs3.existsSync(manifestPath)) continue;
+    result.push({
+      dir: path3.join(base, entry.name),
+      dirName: entry.name,
+      manifest: readJson(manifestPath)
+    });
+  }
+  return result;
+}
+
+// src/commands/sync.ts
+import fs5 from "fs";
+import path6 from "path";
+import * as p2 from "@clack/prompts";
+
+// src/commands/build.ts
+import fs4 from "fs";
+import path5 from "path";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+
+// src/lib/build-targets.ts
+import path4 from "path";
+function pluginRootRel(mp) {
+  const raw = mp.metadata?.pluginRoot ?? DEFAULT_PLUGIN_ROOT;
+  return raw.replace(/^\.\//, "").replace(/\/+$/, "");
+}
+function sourcePath(mp, dirName) {
+  return `./${path4.posix.join(pluginRootRel(mp), dirName)}`;
+}
+function json(value) {
+  return JSON.stringify(value, null, 2) + "\n";
+}
+function manifestCopy(local) {
+  return json(local.manifest);
+}
+function generateCursor(ctx) {
+  const { mp, plugins } = ctx;
+  const registry = {
+    name: mp.name,
+    owner: mp.owner,
+    ...mp.metadata ? {
+      metadata: {
+        ...mp.metadata.description ? { description: mp.metadata.description } : {},
+        ...mp.metadata.version ? { version: mp.metadata.version } : {}
+      }
+    } : {},
+    plugins: plugins.map((p8) => ({
+      name: p8.manifest.name || p8.dirName,
+      source: sourcePath(mp, p8.dirName)
+    }))
+  };
+  const files = [
+    { relPath: path4.posix.join(".cursor-plugin", "marketplace.json"), content: json(registry) }
+  ];
+  for (const p8 of plugins) {
+    files.push({
+      relPath: path4.posix.join(pluginRootRel(mp), p8.dirName, ".cursor-plugin", "plugin.json"),
+      content: manifestCopy(p8)
+    });
+  }
+  return files;
+}
+function generateCodex(ctx) {
+  const { mp, plugins } = ctx;
+  const registry = {
+    name: mp.name,
+    plugins: plugins.map((p8) => ({
+      name: p8.manifest.name || p8.dirName,
+      source: { source: "local", path: sourcePath(mp, p8.dirName) },
+      policy: { installation: "AVAILABLE", authentication: "ON_INSTALL" },
+      category: "Productivity"
+    }))
+  };
+  const files = [
+    {
+      relPath: path4.posix.join(".agents", "plugins", "marketplace.json"),
+      content: json(registry)
+    }
+  ];
+  for (const p8 of plugins) {
+    files.push({
+      relPath: path4.posix.join(pluginRootRel(mp), p8.dirName, ".codex-plugin", "plugin.json"),
+      content: manifestCopy(p8)
+    });
+  }
+  return files;
+}
+var TIER2_GENERATORS = {
+  cursor: generateCursor,
+  codex: generateCodex
+};
+var TIER2_ROOT_REGISTRY = {
+  cursor: path4.posix.join(".cursor-plugin", "marketplace.json"),
+  codex: path4.posix.join(".agents", "plugins", "marketplace.json")
+};
+function isTier2Buildable(id) {
+  return id in TIER2_GENERATORS;
+}
+
+// src/commands/build.ts
+function resolveTargets(mp, requested) {
+  if (requested) {
+    const ids2 = [];
+    const unknown = [];
+    for (const t of requested.split(",").map((s) => s.trim()).filter(Boolean)) {
+      if (isTier2Buildable(t)) ids2.push(t);
+      else unknown.push(t);
+    }
+    return { ids: ids2, unknown };
+  }
+  const ids = (mp.metadata?.targets ?? []).filter(isTier2Buildable);
+  return { ids, unknown: [] };
+}
+function computeFiles(root, mp, ids) {
+  const ctx = { mp, plugins: scanLocalPlugins(root, mp) };
+  const files = [];
+  for (const id of ids) {
+    const gen = TIER2_GENERATORS[id];
+    if (gen) files.push(...gen(ctx));
+  }
+  return files;
+}
+async function buildCommand(startDir, opts = {}) {
+  const root = findMarketplaceRoot(startDir);
+  if (!root) {
+    p.log.error("No .claude-plugin/marketplace.json found. Run `agkit init` first.");
+    process.exitCode = 1;
+    return;
+  }
+  const mp = readMarketplace(root);
+  const { ids, unknown } = resolveTargets(mp, opts.targets);
+  if (unknown.length > 0) {
+    p.log.warn(
+      `Not tier-2 buildable (ignored): ${unknown.join(", ")}. Buildable: ${Object.keys(TIER2_GENERATORS).join(", ")}.`
+    );
+  }
+  if (ids.length === 0) {
+    if (!opts.quiet) {
+      p.log.info(
+        "No tier-2 targets to build. Add one with `agkit init --agents \u2026` (codex, cursor) or pass `--target codex,cursor`."
+      );
+    }
+    return;
+  }
+  const files = computeFiles(root, mp, ids);
+  if (opts.check) {
+    const drift = [];
+    for (const f of files) {
+      const abs = path5.join(root, f.relPath);
+      let actual;
+      try {
+        actual = fs4.readFileSync(abs, "utf8");
+      } catch {
+        actual = void 0;
+      }
+      if (actual === void 0) drift.push(`missing: ${f.relPath}`);
+      else if (actual !== f.content) drift.push(`stale:   ${f.relPath}`);
+    }
+    if (drift.length > 0) {
+      p.log.error(
+        `Tier-2 artifacts out of date (${ids.join(", ")}):
+  ${drift.join("\n  ")}
+Run \`agkit build\` to regenerate.`
+      );
+      process.exitCode = 1;
+    } else if (!opts.quiet) {
+      p.log.success(`Tier-2 artifacts up to date (${ids.join(", ")}).`);
+    }
+    return;
+  }
+  for (const f of files) {
+    const abs = path5.join(root, f.relPath);
+    fs4.mkdirSync(path5.dirname(abs), { recursive: true });
+    fs4.writeFileSync(abs, f.content);
+  }
+  if (!opts.quiet) {
+    const registries = ids.map((id) => TIER2_ROOT_REGISTRY[id]).filter(Boolean).join(", ");
+    p.log.success(
+      `Built ${files.length} file(s) for ${pc.cyan(ids.join(", "))}.
+Registries: ${registries}
+Commit the generated files so consumers can install from these agents.`
+    );
+  }
+}
+function refreshBuiltTargets(root, mp) {
+  const built = (mp.metadata?.targets ?? []).filter(isTier2Buildable).filter((id) => fs4.existsSync(path5.join(root, TIER2_ROOT_REGISTRY[id])));
+  if (built.length === 0) return [];
+  const files = computeFiles(root, mp, built);
+  for (const f of files) {
+    const abs = path5.join(root, f.relPath);
+    fs4.mkdirSync(path5.dirname(abs), { recursive: true });
+    fs4.writeFileSync(abs, f.content);
+  }
+  return built;
+}
+
+// src/commands/sync.ts
+var README_START = "<!-- agkit:plugins:start -->";
+var README_END = "<!-- agkit:plugins:end -->";
+async function syncCommand(startDir, opts = {}) {
+  const root = findMarketplaceRoot(startDir);
+  if (!root) {
+    p2.log.error("No .claude-plugin/marketplace.json found. Run `agkit init` first.");
+    process.exitCode = 1;
+    return;
+  }
+  const mp = readMarketplace(root);
+  const locals = scanLocalPlugins(root, mp);
+  const changes = [];
+  for (const local of locals) {
+    const manifest = local.manifest;
+    const entryName = manifest.name || local.dirName;
+    let entry = mp.plugins.find((e) => e.name === entryName);
+    if (!entry) {
+      entry = {
+        name: entryName,
+        source: mp.metadata?.pluginRoot ? local.dirName : `./${path6.relative(root, local.dir).split(path6.sep).join("/")}`
+      };
+      mp.plugins.push(entry);
+      changes.push(`+ added "${entryName}" to the catalog`);
+    }
+    for (const field of ["version", "description", "author", "keywords", "homepage"]) {
+      const value = manifest[field];
+      if (value !== void 0 && JSON.stringify(entry[field]) !== JSON.stringify(value)) {
+        entry[field] = value;
+        changes.push(`~ updated ${field} of "${entryName}"`);
+      }
+    }
+  }
+  for (const entry of mp.plugins) {
+    const dir = resolveLocalPluginDir(root, mp, entry);
+    if (dir && !fs5.existsSync(dir)) {
+      changes.push(
+        `! "${entry.name}" points to missing directory ${path6.relative(root, dir)} \u2014 remove the entry or restore the plugin`
+      );
+    }
+  }
+  mp.plugins.sort((a, b) => a.name.localeCompare(b.name));
+  writeMarketplace(root, mp);
+  const refreshed = refreshBuiltTargets(root, mp);
+  for (const id of refreshed) changes.push(`~ refreshed ${id} tier-2 artifacts`);
+  const readmePath = path6.join(root, "README.md");
+  if (fs5.existsSync(readmePath)) {
+    const readme = fs5.readFileSync(readmePath, "utf8");
+    const start = readme.indexOf(README_START);
+    const end = readme.indexOf(README_END);
+    if (start !== -1 && end !== -1 && end > start) {
+      const table = mp.plugins.length === 0 ? "_No plugins yet. Add one with `agkit add <template> <name>`._" : [
+        "| Plugin | Version | Description |",
+        "| :----- | :------ | :---------- |",
+        ...mp.plugins.map(
+          (e) => `| \`${e.name}\` | ${e.version ?? "\u2014"} | ${e.description ?? ""} |`
+        )
+      ].join("\n");
+      const updated = readme.slice(0, start + README_START.length) + "\n" + table + "\n" + readme.slice(end);
+      if (updated !== readme) {
+        fs5.writeFileSync(readmePath, updated);
+        changes.push("~ refreshed plugin list in README.md");
+      }
+    }
+  }
+  if (!opts.quiet) {
+    if (changes.length === 0) {
+      p2.log.success("Catalog already in sync.");
+    } else {
+      p2.log.success(`Sync complete:
+  ${changes.join("\n  ")}`);
+      if (changes.some((c) => c.startsWith("!"))) process.exitCode = 1;
+    }
+  }
+}
+
+// src/commands/add.ts
+function titleCase(kebab) {
+  return kebab.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+async function addPlugin(startDir, templateArg, nameArg, opts = {}) {
+  const root = findMarketplaceRoot(startDir);
+  if (!root) {
+    p3.log.error(
+      "No .claude-plugin/marketplace.json found here or in any parent directory. Run `agkit init` first."
+    );
+    process.exitCode = 1;
+    return;
+  }
+  let templateSpec = templateArg;
+  if (!templateSpec) {
+    const answer = await p3.select({
+      message: "Plugin template",
+      options: PLUGIN_TEMPLATES.map((t) => ({
+        value: t,
+        label: t,
+        hint: TEMPLATE_DESCRIPTIONS[t]
+      }))
+    });
+    if (p3.isCancel(answer)) return cancel2();
+    templateSpec = answer;
+  }
+  let name = nameArg;
+  if (!name) {
+    const answer = await p3.text({
+      message: "Plugin name (kebab-case)",
+      placeholder: "my-plugin",
+      validate: (v) => KEBAB_CASE_RE.test(v) ? void 0 : "Must be kebab-case (lowercase, digits, hyphens)"
+    });
+    if (p3.isCancel(answer)) return cancel2();
+    name = answer;
+  }
+  if (!KEBAB_CASE_RE.test(name)) {
+    p3.log.error(`Plugin name "${name}" must be kebab-case.`);
+    process.exitCode = 1;
+    return;
+  }
+  const mp = readMarketplace(root);
+  if (mp.plugins.some((e) => e.name === name)) {
+    p3.log.error(`A plugin named "${name}" already exists in the catalog.`);
+    process.exitCode = 1;
+    return;
+  }
+  const destDir = path7.join(pluginRootDir(root, mp), name);
+  if (fs6.existsSync(destDir)) {
+    p3.log.error(`Directory already exists: ${destDir}`);
+    process.exitCode = 1;
+    return;
+  }
+  let description = opts.description;
+  if (description === void 0 && opts.interactive !== false) {
+    const answer = await p3.text({
+      message: "One-line description",
+      defaultValue: "",
+      placeholder: `What does ${name} do?`
+    });
+    if (p3.isCancel(answer)) return cancel2();
+    description = answer;
+  }
+  description = description || `TODO: describe what ${name} does.`;
+  const vars = {
+    pluginName: name,
+    pluginTitle: titleCase(name),
+    description,
+    authorName: mp.owner?.name ?? "Unknown"
+  };
+  let resolved;
+  try {
+    resolved = resolveTemplate(templateSpec);
+  } catch (err) {
+    p3.log.error(err.message);
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    copyTemplateDir(resolved.dir, destDir, vars);
+  } finally {
+    if (resolved.cleanup) fs6.rmSync(resolved.cleanup, { recursive: true, force: true });
+  }
+  const manifestPath = path7.join(destDir, ".claude-plugin", "plugin.json");
+  if (!resolved.builtin && fs6.existsSync(manifestPath)) {
+    try {
+      const manifest = readJson(manifestPath);
+      manifest.name = name;
+      if (opts.description) manifest.description = description;
+      writeJson(manifestPath, manifest);
+    } catch {
+      p3.log.warn("Template plugin.json could not be parsed; left as-is.");
+    }
+  }
+  const template = resolved.label;
+  const source = mp.metadata?.pluginRoot ? name : `./${path7.relative(root, destDir).split(path7.sep).join("/")}`;
+  mp.plugins.push({ name, source, description, version: "0.1.0" });
+  writeMarketplace(root, mp);
+  await syncCommand(root, { quiet: true });
+  p3.log.success(
+    `Created ${pc2.cyan(path7.relative(startDir, destDir) || destDir)} (${template} template) and registered it in marketplace.json`
+  );
+  p3.log.info(
+    `Edit the generated files, then test locally:
+  claude
+  /plugin marketplace add ${root}
+  /plugin install ${name}@${mp.name}`
+  );
+}
+function cancel2() {
+  p3.cancel("Cancelled.");
+  process.exitCode = 1;
+}
+
+// src/commands/bump.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import path8 from "path";
+import * as p4 from "@clack/prompts";
+import pc3 from "picocolors";
+function git(root, args) {
+  return execFileSync2("git", args, {
+    cwd: root,
+    stdio: ["ignore", "pipe", "pipe"]
+  }).toString().trim();
+}
+function incrementSemver(version2, level) {
+  const m = version2.match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!m) throw new Error(`"${version2}" is not a semver version`);
+  const [major, minor, patch] = [Number(m[1]), Number(m[2]), Number(m[3])];
+  if (level === "major") return `${major + 1}.0.0`;
+  if (level === "minor") return `${major}.${minor + 1}.0`;
+  return `${major}.${minor}.${patch + 1}`;
+}
+function lastReleaseTag(root, plugin) {
+  try {
+    const tags = git(root, [
+      "tag",
+      "--list",
+      `${plugin}@*`,
+      "--sort=-v:refname"
+    ]);
+    return tags.split("\n").filter(Boolean)[0];
+  } catch {
+    return void 0;
+  }
+}
+function analyzeCommits(root, pluginDir, since) {
+  const range = since ? [`${since}..HEAD`] : [];
+  let raw = "";
+  try {
+    raw = git(root, [
+      "log",
+      ...range,
+      "--format=%H%x1f%s%x1f%b%x1e",
+      "--",
+      path8.relative(root, pluginDir) || "."
+    ]);
+  } catch {
+    return { level: void 0, commits: 0, reasons: ["not a git repository"] };
+  }
+  const commits = raw.split("").map((c) => c.trim()).filter(Boolean);
+  if (commits.length === 0) return { level: void 0, commits: 0, reasons: [] };
+  let level = "patch";
+  const reasons = [];
+  for (const c of commits) {
+    const [, subject = "", body = ""] = c.split("");
+    const breaking = /^[a-z]+(\([^)]*\))?!:/.test(subject) || /BREAKING[ -]CHANGE/.test(body);
+    const feat = /^feat(\([^)]*\))?!?:/.test(subject);
+    if (breaking) {
+      level = "major";
+      reasons.push(`major  ${subject}`);
+    } else if (feat) {
+      if (level !== "major") level = "minor";
+      reasons.push(`minor  ${subject}`);
+    } else {
+      reasons.push(`patch  ${subject}`);
+    }
+  }
+  return { level, commits: commits.length, reasons };
+}
+async function bumpCommand(startDir, pluginName, levelArg, opts = {}) {
+  const root = findMarketplaceRoot(startDir);
+  if (!root) {
+    p4.log.error("No .claude-plugin/marketplace.json found. Run `agkit init` first.");
+    process.exitCode = 1;
+    return;
+  }
+  const mp = readMarketplace(root);
+  const locals = scanLocalPlugins(root, mp);
+  if (locals.length === 0) {
+    p4.log.error("No local plugins found under the plugin root.");
+    process.exitCode = 1;
+    return;
+  }
+  let name = pluginName;
+  if (!name) {
+    const answer = await p4.select({
+      message: "Plugin to bump",
+      options: locals.map((l) => ({
+        value: l.manifest.name || l.dirName,
+        label: `${l.manifest.name || l.dirName} (${l.manifest.version ?? "unversioned"})`
+      }))
+    });
+    if (p4.isCancel(answer)) {
+      p4.cancel("Cancelled.");
+      process.exitCode = 1;
+      return;
+    }
+    name = answer;
+  }
+  const local = locals.find((l) => (l.manifest.name || l.dirName) === name);
+  if (!local) {
+    p4.log.error(`No local plugin named "${name}". Known: ${locals.map((l) => l.manifest.name || l.dirName).join(", ")}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (levelArg && !["major", "minor", "patch", "auto"].includes(levelArg)) {
+    p4.log.error(`Invalid level "${levelArg}". Use major, minor, patch, or auto.`);
+    process.exitCode = 1;
+    return;
+  }
+  const current = local.manifest.version ?? "0.1.0";
+  let level;
+  if (!levelArg || levelArg === "auto") {
+    const sinceTag = lastReleaseTag(root, name);
+    const analysis = analyzeCommits(root, local.dir, sinceTag);
+    if (!analysis.level) {
+      p4.log.info(
+        `No commits touching ${path8.relative(root, local.dir)}${sinceTag ? ` since ${sinceTag}` : ""} \u2014 nothing to bump.`
+      );
+      return;
+    }
+    level = analysis.level;
+    p4.log.info(
+      `${analysis.commits} commit(s)${sinceTag ? ` since ${pc3.cyan(sinceTag)}` : " (no previous release tag)"}:
+  ` + analysis.reasons.slice(0, 12).join("\n  ") + (analysis.reasons.length > 12 ? `
+  \u2026 ${analysis.reasons.length - 12} more` : "")
+    );
+  } else {
+    level = levelArg;
+  }
+  const next = incrementSemver(current, level);
+  const tagName = `${name}@${next}`;
+  if (opts.dryRun) {
+    p4.log.info(`[dry-run] ${name}: ${current} -> ${pc3.green(next)} (${level})${opts.tag ? ` + tag ${tagName}` : ""}`);
+    return;
+  }
+  const manifestPath = path8.join(local.dir, MARKETPLACE_DIR, PLUGIN_MANIFEST_FILE);
+  const manifest = readJson(manifestPath);
+  manifest.version = next;
+  writeJson(manifestPath, manifest);
+  await syncCommand(root, { quiet: true });
+  p4.log.success(`${name}: ${current} -> ${pc3.green(next)} (${level})`);
+  if (opts.tag) {
+    try {
+      git(root, ["add", "-A"]);
+      git(root, ["commit", "-m", `chore(release): ${tagName}`]);
+      git(root, ["tag", tagName]);
+      p4.log.success(`Committed and tagged ${pc3.cyan(tagName)} \u2014 push with: git push --follow-tags`);
+    } catch (err) {
+      p4.log.warn(`Version bumped but commit/tag failed: ${err.message}`);
+    }
+  } else {
+    p4.log.info("Commit the change, then push. Use --tag to commit and tag in one step.");
+  }
+}
+
+// src/commands/init.ts
+import fs8 from "fs";
+import path10 from "path";
+import * as p5 from "@clack/prompts";
+import pc4 from "picocolors";
+
+// src/lib/agents.ts
+var claudeCode = {
+  id: "claude-code",
+  label: "Claude Code",
+  tier: 1,
+  install: (arg, name) => ({
+    lines: [`/plugin marketplace add ${arg}`, `/plugin install <plugin-name>@${name}`]
+  }),
+  teamSettings: { path: ".claude/settings.json" }
+};
+var copilot = {
+  id: "copilot",
+  label: "GitHub Copilot CLI",
+  tier: 1,
+  install: (arg, name) => ({
+    lines: [
+      `copilot plugin marketplace add ${arg}`,
+      `copilot plugin install <plugin-name>@${name}`
+    ],
+    note: "Copilot CLI and Copilot in VS Code read marketplace.json under .claude-plugin/ natively."
+  }),
+  teamSettings: { path: ".github/copilot/settings.json" }
+};
+var codex = {
+  id: "codex",
+  label: "OpenAI Codex CLI",
+  tier: 2,
+  install: (arg) => ({
+    lines: [`codex marketplace add ${arg}`],
+    note: "Requires a Codex registry (.agents/plugins/marketplace.json). Generate it with `agkit build --target codex` (planned); the Claude catalog alone is not read by Codex."
+  })
+};
+var cursor = {
+  id: "cursor",
+  label: "Cursor",
+  tier: 2,
+  install: () => ({
+    lines: ["# add the marketplace in Cursor, then: /plugin install <plugin-name>"],
+    note: "Requires a committed Cursor registry (.cursor-plugin/). Generate it with `agkit build --target cursor` (planned)."
+  })
+};
+var gemini = {
+  id: "gemini",
+  label: "Gemini CLI",
+  tier: 3,
+  install: () => ({
+    lines: ["gemini extensions install ."],
+    note: "Needs a transformed tree (gemini-extension.json + GEMINI.md) via `agkit build --target gemini` (planned). Note: Gemini CLI is being retired (2026-06-18) in favour of Antigravity CLI (`agy`)."
+  })
+};
+var opencode = {
+  id: "opencode",
+  label: "OpenCode",
+  tier: 3,
+  install: () => ({
+    lines: ["# clone the repo, then generate the OpenCode tree (.opencode/)"],
+    note: "Needs a transformed tree via `agkit build --target opencode` (planned). OpenCode reads AGENTS.md natively for context."
+  })
+};
+var kiro = {
+  id: "kiro",
+  label: "Kiro",
+  tier: 3,
+  install: () => ({
+    lines: ["# install the generated root artifact (POWER.md, .kiro/)"],
+    note: "Needs a transformed tree via `agkit build --target kiro` (planned)."
+  })
+};
+var AGENT_ADAPTERS = [
+  claudeCode,
+  copilot,
+  codex,
+  cursor,
+  gemini,
+  opencode,
+  kiro
+];
+var DEFAULT_AGENTS = ["claude-code", "copilot"];
+function getAdapter(id) {
+  return AGENT_ADAPTERS.find((a) => a.id === id);
+}
+function parseAgentList(raw) {
+  const ids = [];
+  const unknown = [];
+  for (const part of raw.split(",").map((s) => s.trim()).filter(Boolean)) {
+    if (getAdapter(part)) {
+      if (!ids.includes(part)) ids.push(part);
+    } else {
+      unknown.push(part);
+    }
+  }
+  return { ids, unknown };
+}
+function renderInstallSections(agentIds, marketplaceArg, marketplaceName) {
+  const blocks = [];
+  for (const id of agentIds) {
+    const a = getAdapter(id);
+    if (!a) continue;
+    const hint = a.install(marketplaceArg, marketplaceName);
+    const tierTag = a.tier === 1 ? "" : ` _(tier ${a.tier} \u2014 requires generation)_`;
+    blocks.push(
+      `**${a.label}**${tierTag}
+
+\`\`\`
+${hint.lines.join("\n")}
+\`\`\`` + (hint.note ? `
+
+> ${hint.note}` : "")
+    );
+  }
+  return blocks.join("\n\n");
+}
+function renderTeamSections(agentIds, teamSourceBlock, marketplaceName) {
+  const supported = agentIds.map(getAdapter).filter((a) => Boolean(a?.teamSettings));
+  if (supported.length === 0) return "";
+  const paths = supported.map((a) => `- **${a.label}** \u2014 \`${a.teamSettings.path}\``).join("\n");
+  return `Register the marketplace so teammates get it automatically when they trust the repository.
+
+${paths}
+
+Each accepts the same \`extraKnownMarketplaces\` block:
+
+\`\`\`json
+{
+  "extraKnownMarketplaces": {
+    "${marketplaceName}": {
+      "source": ${teamSourceBlock}
+    }
+  }
+}
+\`\`\``;
+}
+function renderAgentsMd(marketplaceName, description, agentIds) {
+  const labels = agentIds.map((id) => getAdapter(id)?.label ?? id).join(", ");
+  return `# ${marketplaceName}
+
+${description}
+
+This repository is a plugin marketplace managed with [agkit](https://www.npmjs.com/package/agkit).
+The catalog lives in \`.claude-plugin/marketplace.json\`; each plugin lives under \`plugins/<name>/\`.
+
+Target agents: ${labels}.
+
+## For agents working in this repo
+
+- Plugins are self-contained under \`plugins/<name>/\` with a \`.claude-plugin/plugin.json\` manifest and \`skills/\`, \`commands/\`, \`agents/\`, \`hooks/\` as needed.
+- After changing a plugin, run \`agkit sync\` to reconcile the catalog and \`agkit validate\` before committing.
+- Version a plugin with \`agkit bump <plugin>\` (conventional-commit aware).
+`;
+}
+
+// src/lib/git.ts
+import { execFileSync as execFileSync3 } from "child_process";
+import fs7 from "fs";
+import path9 from "path";
+function isGitAvailable() {
+  try {
+    execFileSync3("git", ["--version"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isGitRepo(dir) {
+  return fs7.existsSync(path9.join(dir, ".git"));
+}
+function gitInit(dir) {
+  execFileSync3("git", ["init", "--initial-branch=main"], {
+    cwd: dir,
+    stdio: "ignore"
+  });
+}
+function getOriginUrl(dir) {
+  try {
+    return execFileSync3("git", ["remote", "get-url", "origin"], {
+      cwd: dir,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+  } catch {
+    return void 0;
+  }
+}
+function parseRemoteUrl(raw) {
+  let host;
+  let repoPath;
+  const scp = raw.match(/^(?:[\w.-]+)@([\w.-]+):(.+?)(?:\.git)?\/?$/);
+  const url = raw.match(/^(?:https?|ssh|git):\/\/(?:[\w.-]+@)?([\w.-]+(?::\d+)?)\/(.+?)(?:\.git)?\/?$/);
+  if (scp) {
+    host = scp[1];
+    repoPath = scp[2];
+  } else if (url) {
+    host = url[1];
+    repoPath = url[2];
+  }
+  if (!host || !repoPath) return void 0;
+  const bareHost = host.replace(/:\d+$/, "");
+  const segments = repoPath.split("/").filter(Boolean);
+  const slug = segments.length === 2 ? `${segments[0]}/${segments[1]}` : void 0;
+  return {
+    httpsUrl: `https://${host}/${repoPath}.git`,
+    host: bareHost,
+    slug,
+    isGitHub: bareHost === "github.com",
+    isGitLab: bareHost === "gitlab.com" || bareHost.startsWith("gitlab.")
+  };
+}
+
+// src/commands/init.ts
+function validateName(name) {
+  if (!KEBAB_CASE_RE.test(name)) {
+    return "Name must be kebab-case (lowercase letters, digits, hyphens)";
+  }
+  if (RESERVED_MARKETPLACE_NAMES.includes(name)) {
+    return `"${name}" is reserved by Claude Code and cannot be used`;
+  }
+  return void 0;
+}
+function marketplaceTpl(file) {
+  return fs8.readFileSync(path10.join(templatesDir(), "marketplace", file), "utf8");
+}
+function addArgument(remote) {
+  if (!remote) return "<git-url-or-owner/repo>";
+  return remote.isGitHub && remote.slug ? remote.slug : remote.httpsUrl;
+}
+function teamSource(remote) {
+  const source = remote?.isGitHub && remote.slug ? { source: "github", repo: remote.slug } : { source: "url", url: remote?.httpsUrl ?? "https://<git-host>/<owner>/<repo>.git" };
+  return JSON.stringify(source, null, 2).split("\n").map((line, i) => i === 0 ? line : "      " + line).join("\n");
+}
+async function initCommand(dirArg, opts) {
+  p5.intro(pc4.bgCyan(pc4.black("  agkit init  ")));
+  const targetDir = path10.resolve(dirArg ?? ".");
+  const defaultName = path10.basename(targetDir).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  const gitAvailable = isGitAvailable();
+  const existingRemote = gitAvailable && fs8.existsSync(targetDir) ? getOriginUrl(targetDir) : void 0;
+  let name = opts.name;
+  let owner = opts.owner;
+  let email = opts.email;
+  let description = opts.description;
+  let repoUrl = opts.repo ?? existingRemote;
+  let ci = opts.ci;
+  let agentsRaw = opts.agents;
+  if (!opts.yes) {
+    if (!name) {
+      const answer = await p5.text({
+        message: "Marketplace name (kebab-case, shown in /plugin install <plugin>@<name>)",
+        initialValue: defaultName,
+        validate: (v) => validateName(v)
+      });
+      if (p5.isCancel(answer)) return cancel5();
+      name = answer;
+    }
+    if (!owner) {
+      const answer = await p5.text({
+        message: "Owner name (person or team)",
+        placeholder: "Your Team",
+        validate: (v) => v.trim() ? void 0 : "Owner name is required"
+      });
+      if (p5.isCancel(answer)) return cancel5();
+      owner = answer;
+    }
+    if (email === void 0) {
+      const answer = await p5.text({
+        message: "Owner email (optional)",
+        defaultValue: "",
+        placeholder: "team@example.com"
+      });
+      if (p5.isCancel(answer)) return cancel5();
+      email = answer;
+    }
+    if (description === void 0) {
+      const answer = await p5.text({
+        message: "Short description",
+        defaultValue: "",
+        placeholder: "A curated collection of Claude Code plugins"
+      });
+      if (p5.isCancel(answer)) return cancel5();
+      description = answer;
+    }
+    if (repoUrl === void 0) {
+      const answer = await p5.text({
+        message: "Git remote URL where this marketplace will be pushed (optional, any forge)",
+        defaultValue: "",
+        placeholder: "git@gitlab.example.com:team/my-marketplace.git"
+      });
+      if (p5.isCancel(answer)) return cancel5();
+      repoUrl = answer || void 0;
+    }
+    if (!ci) {
+      const answer = await p5.select({
+        message: "CI validation workflow",
+        options: [
+          { value: "github", label: "GitHub Actions" },
+          { value: "gitlab", label: "GitLab CI" },
+          { value: "none", label: "None" }
+        ],
+        initialValue: parseRemoteUrl(repoUrl ?? "")?.isGitLab ? "gitlab" : "github"
+      });
+      if (p5.isCancel(answer)) return cancel5();
+      ci = answer;
+    }
+    if (agentsRaw === void 0) {
+      const answer = await p5.multiselect({
+        message: "Target coding agents (space to toggle)",
+        options: AGENT_ADAPTERS.map((a) => ({
+          value: a.id,
+          label: `${a.label}${a.tier === 1 ? "" : `  (tier ${a.tier}, needs generation)`}`
+        })),
+        initialValues: DEFAULT_AGENTS,
+        required: true
+      });
+      if (p5.isCancel(answer)) return cancel5();
+      agentsRaw = answer.join(",");
+    }
+  }
+  name = name || defaultName;
+  const nameError = validateName(name);
+  if (nameError) {
+    p5.log.error(nameError);
+    process.exitCode = 1;
+    return;
+  }
+  owner = owner || "Unknown Owner";
+  ci = ci ?? "github";
+  const { ids: agentIds, unknown } = parseAgentList(agentsRaw ?? DEFAULT_AGENTS.join(","));
+  if (unknown.length > 0) {
+    p5.log.warn(
+      `Unknown agent(s) ignored: ${unknown.join(", ")}. Known: ${AGENT_ADAPTERS.map((a) => a.id).join(", ")}.`
+    );
+  }
+  const targets = agentIds.length > 0 ? agentIds : [...DEFAULT_AGENTS];
+  const remote = repoUrl ? parseRemoteUrl(repoUrl) : void 0;
+  if (repoUrl && !remote) {
+    p5.log.warn(`Could not parse remote URL "${repoUrl}"; install instructions will use placeholders.`);
+  }
+  const s = p5.spinner();
+  s.start("Scaffolding marketplace");
+  fs8.mkdirSync(targetDir, { recursive: true });
+  const marketplace = {
+    $schema: MARKETPLACE_SCHEMA_URL,
+    name,
+    owner: { name: owner, ...email ? { email } : {} },
+    metadata: {
+      ...description ? { description } : {},
+      version: "1.0.0",
+      pluginRoot: DEFAULT_PLUGIN_ROOT,
+      targets
+    },
+    plugins: []
+  };
+  writeJson(path10.join(targetDir, ".claude-plugin", "marketplace.json"), marketplace);
+  fs8.mkdirSync(path10.join(targetDir, "plugins"), { recursive: true });
+  fs8.writeFileSync(path10.join(targetDir, "plugins", ".gitkeep"), "");
+  const desc = description || "A curated collection of agent plugins.";
+  const mktArg = addArgument(remote);
+  const teamBlock = teamSource(remote);
+  const vars = {
+    marketplaceName: name,
+    description: desc,
+    addArgument: mktArg,
+    teamSource: teamBlock,
+    installSections: renderInstallSections(targets, mktArg, name),
+    teamSections: renderTeamSections(targets, teamBlock, name)
+  };
+  fs8.writeFileSync(
+    path10.join(targetDir, "README.md"),
+    renderTemplate(marketplaceTpl("README.md.tpl"), vars)
+  );
+  fs8.writeFileSync(
+    path10.join(targetDir, "AGENTS.md"),
+    renderAgentsMd(name, desc, targets)
+  );
+  const exampleDir = path10.join(targetDir, "examples");
+  fs8.mkdirSync(exampleDir, { recursive: true });
+  fs8.writeFileSync(
+    path10.join(exampleDir, "team-settings.json"),
+    renderTemplate(marketplaceTpl("team-settings.json.tpl"), vars)
+  );
+  if (ci === "github") {
+    const wfDir = path10.join(targetDir, ".github", "workflows");
+    fs8.mkdirSync(wfDir, { recursive: true });
+    fs8.writeFileSync(
+      path10.join(wfDir, "validate.yml"),
+      renderTemplate(marketplaceTpl("github-validate.yml.tpl"), vars)
+    );
+  } else if (ci === "gitlab") {
+    fs8.writeFileSync(
+      path10.join(targetDir, ".gitlab-ci.yml"),
+      renderTemplate(marketplaceTpl("gitlab-ci.yml.tpl"), vars)
+    );
+  }
+  fs8.writeFileSync(
+    path10.join(targetDir, ".gitignore"),
+    ["node_modules/", ".DS_Store", "*.log", ""].join("\n")
+  );
+  if (gitAvailable && !isGitRepo(targetDir)) {
+    try {
+      gitInit(targetDir);
+    } catch {
+      p5.log.warn("git init failed; initialize the repository manually.");
+    }
+  }
+  s.stop("Marketplace scaffolded");
+  if (!opts.yes) {
+    const wantStarter = await p5.confirm({
+      message: "Add a starter plugin now?",
+      initialValue: true
+    });
+    if (!p5.isCancel(wantStarter) && wantStarter) {
+      await addPlugin(targetDir, void 0, void 0, { interactive: true });
+    }
+  }
+  const rel = path10.relative(process.cwd(), targetDir) || ".";
+  p5.note(
+    [
+      `cd ${rel}`,
+      remote ? `git remote add origin ${remote.httpsUrl}  # if not already set` : "git remote add origin <your-git-url>",
+      "agkit add skill my-first-skill",
+      "agkit validate",
+      "git add -A && git commit -m 'feat: initial marketplace'",
+      "git push -u origin main",
+      "",
+      `Target agents: ${targets.map((id) => getAdapter(id)?.label ?? id).join(", ")}`,
+      `Native install (no build): ${targets.filter((id) => getAdapter(id)?.tier === 1).map((id) => getAdapter(id)?.label).join(", ") || "none"}`
+    ].join("\n"),
+    "Next steps"
+  );
+  const needBuild = targets.filter((id) => (getAdapter(id)?.tier ?? 1) > 1);
+  if (needBuild.length > 0) {
+    p5.log.warn(
+      `Recorded tier 2/3 target(s) in metadata.targets: ${needBuild.map((id) => getAdapter(id)?.label).join(", ")}.
+These are NOT installable from the Claude catalog alone \u2014 they need generated per-agent artifacts. agkit records the intent and documents it; artifact generation (\`agkit build --target \u2026\`) is not implemented yet. See README install notes.`
+    );
+  }
+  p5.outro("Done \u2714");
+}
+function cancel5() {
+  p5.cancel("Cancelled.");
+  process.exitCode = 1;
+}
+
+// src/commands/list.ts
+import * as p6 from "@clack/prompts";
+import pc5 from "picocolors";
+async function listCommand() {
+  p6.intro(pc5.bgCyan(pc5.black(" Available plugin templates ")));
+  for (const t of PLUGIN_TEMPLATES) {
+    p6.log.message(`${pc5.cyan(pc5.bold(t))}
+  ${TEMPLATE_DESCRIPTIONS[t]}`);
+  }
+  p6.log.message(
+    `Remote and local templates are also supported:
+  agkit add gh:owner/repo/dir my-plugin
+  agkit add gl:owner/repo#v2 my-plugin
+  agkit add https://git.company.io/team/templates.git//skill-fr my-plugin
+  agkit add ./local-template my-plugin`
+  );
+  p6.outro("Usage: agkit add <template|spec> <plugin-name>");
+}
+
+// src/commands/validate.ts
+import { execFileSync as execFileSync4 } from "child_process";
+import fs9 from "fs";
+import path11 from "path";
+import * as p7 from "@clack/prompts";
+import pc6 from "picocolors";
+async function validateCommand(startDir, opts = {}) {
+  const root = findMarketplaceRoot(startDir);
+  if (!root) {
+    p7.log.error("No .claude-plugin/marketplace.json found. Run `agkit init` first.");
+    process.exitCode = 1;
+    return;
+  }
+  const findings = [];
+  let mp;
+  try {
+    mp = readMarketplace(root);
+  } catch (err) {
+    findings.push({
+      level: "error",
+      message: `marketplace.json is not valid JSON: ${err.message}`
+    });
+  }
+  if (mp) {
+    if (!mp.name) {
+      findings.push({ level: "error", message: "Missing required field: name" });
+    } else {
+      if (!KEBAB_CASE_RE.test(mp.name)) {
+        findings.push({
+          level: "error",
+          message: `Marketplace name "${mp.name}" must be kebab-case`
+        });
+      }
+      if (RESERVED_MARKETPLACE_NAMES.includes(mp.name)) {
+        findings.push({
+          level: "error",
+          message: `Marketplace name "${mp.name}" is reserved by Claude Code`
+        });
+      }
+    }
+    if (!mp.owner?.name) {
+      findings.push({ level: "error", message: "Missing required field: owner.name" });
+    }
+    if (!Array.isArray(mp.plugins)) {
+      findings.push({ level: "error", message: "plugins must be an array" });
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const entry of mp.plugins ?? []) {
+      const label = entry.name ?? "<unnamed>";
+      if (!entry.name) {
+        findings.push({ level: "error", message: "A plugin entry is missing its name" });
+        continue;
+      }
+      if (!KEBAB_CASE_RE.test(entry.name)) {
+        findings.push({
+          level: "error",
+          message: `Plugin name "${label}" must be kebab-case`
+        });
+      }
+      if (seen.has(entry.name)) {
+        findings.push({ level: "error", message: `Duplicate plugin name "${label}"` });
+      }
+      seen.add(entry.name);
+      if (entry.source === void 0) {
+        findings.push({ level: "error", message: `Plugin "${label}" is missing source` });
+        continue;
+      }
+      const localDir = resolveLocalPluginDir(root, mp, entry);
+      if (localDir) {
+        if (!fs9.existsSync(localDir)) {
+          findings.push({
+            level: "error",
+            message: `Plugin "${label}" source resolves to missing directory ${path11.relative(root, localDir)}`
+          });
+        } else {
+          const manifestPath = path11.join(localDir, MARKETPLACE_DIR, PLUGIN_MANIFEST_FILE);
+          if (!fs9.existsSync(manifestPath)) {
+            findings.push({
+              level: "error",
+              message: `Plugin "${label}" has no ${MARKETPLACE_DIR}/${PLUGIN_MANIFEST_FILE}`
+            });
+          } else {
+            try {
+              const manifest = JSON.parse(fs9.readFileSync(manifestPath, "utf8"));
+              if (manifest.name && manifest.name !== entry.name) {
+                findings.push({
+                  level: "warn",
+                  message: `Catalog entry "${label}" but plugin.json declares "${manifest.name}" \u2014 run \`agkit sync\``
+                });
+              }
+              if (manifest.version && entry.version && manifest.version !== entry.version) {
+                findings.push({
+                  level: "warn",
+                  message: `Version drift for "${label}": catalog ${entry.version} vs plugin.json ${manifest.version} \u2014 run \`agkit sync\``
+                });
+              }
+            } catch {
+              findings.push({
+                level: "error",
+                message: `Plugin "${label}": plugin.json is not valid JSON`
+              });
+            }
+          }
+        }
+      }
+    }
+    const hasRelative = (mp.plugins ?? []).some((e) => typeof e.source === "string");
+    if (hasRelative) {
+      p7.log.info(
+        "Note: relative plugin sources resolve only when the marketplace is added via Git (any forge), not via a direct URL to marketplace.json."
+      );
+    }
+  }
+  if (mp?.metadata?.targets) {
+    const needBuild = mp.metadata.targets.filter((id) => (getAdapter(id)?.tier ?? 1) > 1);
+    if (needBuild.length > 0) {
+      p7.log.info(
+        `metadata.targets includes tier 2/3 agent(s): ${needBuild.join(", ")}. The Claude catalog validates here; run \`agkit build\` to (re)generate their registries and \`agkit build --check\` in CI.`
+      );
+    }
+  }
+  let officialRan = false;
+  try {
+    execFileSync4("claude", ["plugin", "validate", root, ...opts.strict ? ["--strict"] : []], { stdio: "pipe" });
+    officialRan = true;
+    p7.log.success("claude plugin validate: passed");
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT") {
+      p7.log.info(
+        "Claude Code CLI not found \u2014 skipped `claude plugin validate` (install it for the official schema check)."
+      );
+    } else {
+      officialRan = true;
+      const out = [e.stdout?.toString(), e.stderr?.toString()].filter(Boolean).join("\n").trim();
+      findings.push({
+        level: "error",
+        message: `claude plugin validate failed${out ? ":\n" + out : ""}`
+      });
+    }
+  }
+  const errors = findings.filter((f) => f.level === "error");
+  const warns = findings.filter((f) => f.level === "warn");
+  for (const f of warns) p7.log.warn(f.message);
+  for (const f of errors) p7.log.error(f.message);
+  if (errors.length > 0) {
+    p7.log.error(pc6.red(`Validation failed: ${errors.length} error(s), ${warns.length} warning(s).`));
+    process.exitCode = 1;
+  } else {
+    p7.log.success(
+      pc6.green(
+        `${path11.relative(process.cwd(), marketplacePath(root)) || marketplacePath(root)} is valid` + (warns.length ? ` (${warns.length} warning(s))` : "") + (officialRan ? "" : " [local checks only]")
+      )
+    );
+  }
+}
+
+// src/index.ts
+var { version } = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf8")
+);
+var program = new Command();
+program.name("agkit").description(
+  "Scaffold and manage plugin marketplaces for Claude Code and GitHub Copilot, distributed via any Git host."
+).version(version);
+program.command("init").argument("[dir]", "target directory (default: current directory)").description("Scaffold a new plugin marketplace (git-first)").option("-n, --name <name>", "marketplace name (kebab-case)").option("-o, --owner <owner>", "owner name").option("-e, --email <email>", "owner email").option("-d, --description <text>", "marketplace description").option("-r, --repo <url>", "git remote URL (any forge)").option("--ci <ci>", "CI workflow: github | gitlab | none").option("--agents <list>", "comma-separated target agents (e.g. claude-code,copilot,codex)").option("-y, --yes", "non-interactive, accept defaults").action(async (dir, opts) => {
+  await initCommand(dir, opts);
+});
+program.command("add").argument("[template]", "template name, local path, gh:/gl: shorthand, or git URL (see `agkit list`)").argument("[name]", "plugin name (kebab-case)").description("Scaffold a plugin from a template and register it in the catalog").option("-d, --description <text>", "one-line plugin description").action(async (template, name, opts) => {
+  await addPlugin(process.cwd(), template, name, {
+    description: opts.description,
+    interactive: opts.description === void 0
+  });
+});
+program.command("sync").description("Reconcile marketplace.json and README with the plugins on disk").action(async () => {
+  await syncCommand(process.cwd());
+});
+program.command("validate").description("Validate the catalog (local checks + `claude plugin validate` if available)").option("--strict", "treat warnings as errors in the official validator").action(async (opts) => {
+  await validateCommand(process.cwd(), { strict: opts.strict });
+});
+program.command("bump").argument("[plugin]", "plugin name (prompted if omitted)").argument("[level]", "major | minor | patch | auto (default: auto, from conventional commits)").description("Bump a plugin version (conventional-commit aware) and sync the catalog").option("-t, --tag", "commit the bump and create a release tag <plugin>@<version>").option("--dry-run", "show what would change without writing").action(async (plugin, level, opts) => {
+  await bumpCommand(process.cwd(), plugin, level, { tag: opts.tag, dryRun: opts.dryRun });
+});
+program.command("build").description("Generate tier-2 agent artifacts (codex, cursor) from the catalog").option("--target <list>", "comma-separated tier-2 targets (default: those in metadata.targets)").option("--check", "verify generated artifacts are up to date (CI); non-zero exit on drift").action(async (opts) => {
+  await buildCommand(process.cwd(), { targets: opts.target, check: opts.check });
+});
+program.command("list").description("List available plugin templates").action(async () => {
+  await listCommand();
+});
+program.parseAsync().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});