@c4a/context-cli 0.6.0-beta.8 → 0.6.1

package/scripts/build-plugin.ts

@@ -1,658 +0,0 @@
-#!/usr/bin/env bun
-/**
- * build-plugin.ts — materialize installable plugin trees from the human-edited
- * plugin/ source directory.
- *
- * The normal 0.6.x target is `dist/plugins` inside the @c4a/context-cli npm
- * package. `context plugin install` resolves that bundled directory at runtime
- * and installs it globally for Claude / Codex.
- * Source of truth:
- *   - plugin/commands/
- *   - plugin/skills/
- *   - plugin/.claude-plugin/plugin.json.template
- *   - plugin/.codex-plugin/plugin.json.template
- *   - plugin/.cursor-plugin/plugin.json.template
- *
- * Generated outputs under the target root:
- *   - claude/   — Claude plugin root
- *   - codex/    — Codex plugin root
- *   - cursor/   — Cursor plugin root
- *   - skills/   — Vercel-style standalone skills (no plugin manifest)
- *
- * Plus three marketplace.json files at the target root pointing at the
- * respective subdirs, so a single repo serves four install paths.
- */
-
-import { cp, mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
-import { basename, dirname, join, relative, resolve, sep } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const pkgRoot = resolve(__dirname, "..");
-const PLUGINS_ROOT = resolve(pkgRoot, "dist", "plugins");
-const MARKETPLACE_NAME = "c4a";
-const PLUGIN_NAME = "context";
-
-interface CommandSource {
-  slug: string;
-  title: string;
-  description: string;
-  body: string;
-}
-
-const INTERNAL_PROCEDURES_DIR = "references/internal-procedures";
-
-/**
- * Rewrite internal `skill-*` procedure references in a command body so
- * non-Claude agent surfaces get direct file references they can read.
- */
-function rewriteInternalProcedureReferences(body: string, pathFor: (skill: string) => string): string {
-  let out = body;
-
-  // Imperative: "Apply/Use/Invoke the internal `context:skill-X` procedure" -> read the file.
-  out = out.replace(
-    /\b(Apply|Use|Invoke|apply|use|invoke) the internal `(?:context:)?(skill-[a-z-]+)` procedure/g,
-    (_match, verb: string, skill: string) => `${verb} the procedure in \`${pathFor(skill)}\``,
-  );
-
-  // Imperative: "invoke the internal `skill-X` procedure" in sentence middles.
-  out = out.replace(
-    /\binvoke the internal `(?:context:)?(skill-[a-z-]+)` procedure/g,
-    (_match, skill: string) => `invoke the procedure in \`${pathFor(skill)}\``,
-  );
-
-  // Descriptive bare internal procedure references also become file paths for non-Claude builds.
-  out = out.replace(
-    /`(?:context:)?(skill-[a-z-]+)`/g,
-    (_match, skill: string) => `\`${pathFor(skill)}\``,
-  );
-
-  return out;
-}
-
-function publicEntrySkillPath(skill: string): string {
-  return `${INTERNAL_PROCEDURES_DIR}/${skill}.md`;
-}
-
-function cursorCommandSkillPath(skill: string): string {
-  // Cursor command files live under `commands/`; bundled skills live under
-  // sibling `skills/`. Use a plain relative path that any markdown reader can
-  // resolve from the command file's location.
-  return `../skills/${skill}/SKILL.md`;
-}
-
-function cursorCommandFileName(slug: string): string {
-  return `context-${slug}.md`;
-}
-
-function rewriteClaudeSlashCommandsForCursor(body: string): string {
-  return body
-    .replace(/\/context:\*/g, "/context-*")
-    .replace(/\/context:([a-z-]+)/g, (_match, slug: string) =>
-      slug === "context" ? "/context" : `/context-${slug}`
-    )
-    .replace(/^## Your [Tt]ask$/gm, "## Workflow")
-    .replace(/\bnot a user slash command\b/g, "not a user command");
-}
-
-/**
- * Scan a generated build root for residual unresolved internal procedure
- * references in agent-facing entry files (Codex / Vercel public skills,
- * Cursor commands).
- *
- * Skips internal procedure bodies — directories named `internal-procedures`
- * (the Codex/Vercel embed point) and directories whose name starts with
- * `skill-` (the cursor-build internal skills tree, mirrored from
- * `plugin/skills/`). Cross-skill mentions inside those bodies are descriptive
- * ("the next stage handles X") and stay in the source skill style.
- *
- * Throws on any leak so future commands or rewrite-pattern gaps fail the
- * build instead of silently shipping unactionable verbs.
- */
-async function verifyNoInternalProcedureReferenceLeak(root: string, label: string): Promise<void> {
-  const offenders: string[] = [];
-  const legacyProcedureTokenPattern = new RegExp("`context:" + "skill-[a-z-*]+`", "g");
-  const stack: string[] = [root];
-  while (stack.length > 0) {
-    const current = stack.pop()!;
-    const entries = await readdir(current, { withFileTypes: true });
-    for (const entry of entries) {
-      const path = join(current, entry.name);
-      if (entry.isDirectory()) {
-        if (entry.name === INTERNAL_PROCEDURES_DIR.split("/").at(-1) || entry.name.startsWith("skill-")) continue;
-        stack.push(path);
-        continue;
-      }
-      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const content = await readFile(path, "utf8");
-      const matches = [
-        ...(content.match(/`skill-[a-z-*]+`/g) ?? []),
-        ...(content.match(legacyProcedureTokenPattern) ?? []),
-      ];
-      if (matches && matches.length > 0) {
-        offenders.push(`${path}: ${[...new Set(matches)].join(", ")}`);
-      }
-    }
-  }
-  if (offenders.length > 0) {
-    throw new Error(
-      `${label} build still contains unresolved internal procedure references in agent-facing entry files — extend rewriteInternalProcedureReferences() to cover the new phrasing:\n${offenders.join("\n")}`,
-    );
-  }
-}
-
-/**
- * Rewrite `${CLAUDE_PLUGIN_ROOT}/skills/<name>/...` cross-skill references
- * inside bundled internal procedure copies to plain relative paths that any
- * agent can resolve. The number of `..` segments depends on how deep the
- * file is below its build's "skills siblings root" (the directory under
- * which all `skill-*` siblings live).
- */
-function rewriteClaudePluginRoot(content: string, levelsAboveSiblingsRoot: number): string {
-  const upPrefix = "../".repeat(levelsAboveSiblingsRoot);
-  return content.replace(/\$\{CLAUDE_PLUGIN_ROOT\}\/skills\//g, upPrefix);
-}
-
-function rewriteFlattenedProcedureReferences(content: string, skill: string): string {
-  const localReferences = content.replace(
-    /(?<![\w./-])references\/([A-Za-z0-9._/-]+\.md)/g,
-    `${skill}/references/$1`,
-  );
-  return localReferences.replace(
-    /(?<![\w./-])((?:\.\.\/)*)(skill-[a-z-]+)\/SKILL\.md/g,
-    (_match, prefix: string, procedure: string) => `${prefix}${procedure}.md`,
-  );
-}
-
-function depthOfFileBelowSiblingsRoot(filePath: string, siblingsRoot: string): number {
-  const rel = relative(siblingsRoot, dirname(filePath));
-  if (rel === "" || rel === ".") return 0;
-  return rel.split(sep).filter((seg: string) => seg.length > 0).length;
-}
-
-/**
- * Recursively copy a markdown tree, applying `rewriteClaudePluginRoot` to
- * every `.md` file based on its location below `siblingsRoot`. Non-markdown
- * files are copied verbatim. Empty subtrees (no files, no recursive content)
- * are skipped — the destination directory is created only when at least one
- * descendant is actually written, so accidental empty source dirs don't
- * propagate into build outputs.
- */
-async function copyMarkdownTreeRewrittenForPublicEntry(
-  src: string,
-  dest: string,
-  siblingsRoot: string,
-): Promise<boolean> {
-  const entries = await readdir(src, { withFileTypes: true });
-  let wroteSomething = false;
-  for (const entry of entries) {
-    const srcPath = join(src, entry.name);
-    const destPath = join(dest, entry.name);
-    if (entry.isDirectory()) {
-      const subtreeWrote = await copyMarkdownTreeRewrittenForPublicEntry(srcPath, destPath, siblingsRoot);
-      if (subtreeWrote) wroteSomething = true;
-      continue;
-    }
-    if (!entry.isFile()) continue;
-    if (!wroteSomething) {
-      await mkdir(dest, { recursive: true });
-    }
-    if (entry.name.endsWith(".md")) {
-      const content = await readFile(srcPath, "utf8");
-      const depth = depthOfFileBelowSiblingsRoot(destPath, siblingsRoot);
-      await writeFile(destPath, rewriteClaudePluginRoot(content, depth), "utf8");
-    } else {
-      await cp(srcPath, destPath);
-    }
-    wroteSomething = true;
-  }
-  return wroteSomething;
-}
-
-/**
- * Scan a generated build root for residual `${CLAUDE_PLUGIN_ROOT}` tokens.
- * That token is Claude-specific and must not survive into Codex / Cursor /
- * Vercel-style builds — agents on those platforms cannot resolve it.
- */
-async function verifyNoClaudePluginRootLeak(root: string, label: string): Promise<void> {
-  const offenders: string[] = [];
-  const stack: string[] = [root];
-  while (stack.length > 0) {
-    const current = stack.pop()!;
-    const entries = await readdir(current, { withFileTypes: true });
-    for (const entry of entries) {
-      const path = join(current, entry.name);
-      if (entry.isDirectory()) {
-        stack.push(path);
-        continue;
-      }
-      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const content = await readFile(path, "utf8");
-      if (content.includes("${CLAUDE_PLUGIN_ROOT}")) {
-        offenders.push(path);
-      }
-    }
-  }
-  if (offenders.length > 0) {
-    throw new Error(
-      `${label} build contains \${CLAUDE_PLUGIN_ROOT} tokens — extend rewriteClaudePluginRoot() so non-Claude agents can resolve cross-skill paths:\n${offenders.join("\n")}`,
-    );
-  }
-}
-
-async function rewriteMarkdownFiles(root: string, rewrite: (content: string) => string): Promise<void> {
-  const stack = [root];
-  while (stack.length > 0) {
-    const current = stack.pop()!;
-    const entries = await readdir(current, { withFileTypes: true });
-    for (const entry of entries) {
-      const path = join(current, entry.name);
-      if (entry.isDirectory()) {
-        stack.push(path);
-        continue;
-      }
-      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const original = await readFile(path, "utf8");
-      const next = rewrite(original);
-      if (next !== original) await writeFile(path, next, "utf8");
-    }
-  }
-}
-
-
-function generatedNotice(kind: string): string {
-  return [
-    `# Generated ${kind}`,
-    "",
-    "This directory is generated by `bun run build:plugin`.",
-    "Do not edit files here directly.",
-    "Edit `packages/context-cli/plugin/` and rerun the build instead.",
-    "",
-  ].join("\n");
-}
-
-function parseFrontmatter(markdown: string, fileName: string): { frontmatter: string; body: string } {
-  const match = markdown.match(/^---\n([\s\S]*?)\n---\n?/);
-  if (!match) throw new Error(`${fileName} must start with YAML frontmatter`);
-  return {
-    frontmatter: match[1] ?? "",
-    body: markdown.slice(match[0].length).trimStart(),
-  };
-}
-
-function quotedFrontmatterValue(frontmatter: string, key: string, fileName: string): string {
-  const match = frontmatter.match(new RegExp(`^${key}:\\s*["']([\\s\\S]*?)["']\\s*$`, "m"));
-  if (!match?.[1]) throw new Error(`${fileName} must declare quoted ${key}`);
-  return match[1];
-}
-
-function titleFromSlug(slug: string): string {
-  return slug
-    .split("-")
-    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-    .join(" ");
-}
-
-function skillNameForCommand(slug: string): string {
-  return `context-${slug}`;
-}
-
-function codexSkillNameForCommand(slug: string): string {
-  return slug;
-}
-
-const CURSOR_COMMAND_SUMMARIES: Record<string, string> = {
-  init: "Initialize a Context knowledge workspace.",
-  continue: "Continue the Context workflow from the current workspace state.",
-};
-
-function cursorCommandSummary(command: CommandSource): string {
-  return CURSOR_COMMAND_SUMMARIES[command.slug] ?? command.description;
-}
-
-function stripHtmlComments(markdown: string): string {
-  return markdown.replace(/<!--[\s\S]*?-->\n*/g, "");
-}
-
-function publicSkillBody(command: CommandSource, publicName: string): string {
-  const rewrittenBody = rewriteInternalProcedureReferences(command.body, publicEntrySkillPath)
-    .replace(/^## Your [Tt]ask$/gm, "## Workflow");
-  return `---\nname: ${publicName}\ndescription: >\n  ${command.description} Use the local \`context\` CLI for workspace writes.\ntools:\n  - Bash\n---\n\n# ${command.title}\n\nPublic Context entry for agents that expose skills instead of slash commands.\n\n- Public entry: \`${publicName}\`\n- Host command names are installation-specific; use the command or skill surfaced by the current host instead of deriving a filesystem path from an example name.\n- CLI primitive prefix: \`context ...\`\n- Internal procedures live under \`${INTERNAL_PROCEDURES_DIR}/\`; read each referenced file in full before following that step.\n\n---\n\n${rewrittenBody.trimEnd()}\n`;
-}
-
-async function readCommands(): Promise<CommandSource[]> {
-  const commandsRoot = join(pkgRoot, "plugin/commands");
-  const files = (await readdir(commandsRoot)).filter((file) => file.endsWith(".md")).sort();
-  const commands: CommandSource[] = [];
-  for (const file of files) {
-    const raw = await readFile(join(commandsRoot, file), "utf8");
-    const { frontmatter, body } = parseFrontmatter(raw, file);
-    const slug = basename(file, ".md");
-    commands.push({
-      slug,
-      title: titleFromSlug(slug),
-      description: quotedFrontmatterValue(frontmatter, "description", file),
-      body,
-    });
-  }
-  return commands;
-}
-
-async function renderManifest(input: {
-  templatePath: string;
-  outputPath: string;
-  version: string;
-  label: string;
-}): Promise<Record<string, unknown>> {
-  const template = await readFile(input.templatePath, "utf8");
-  const rendered = template.replace(/__VERSION__/g, input.version);
-  await mkdir(dirname(input.outputPath), { recursive: true });
-  await writeFile(input.outputPath, rendered, "utf8");
-
-  const parsed = JSON.parse(rendered) as Record<string, unknown>;
-  if (parsed.name !== PLUGIN_NAME) {
-    throw new Error(`${input.label} plugin.json name must be "${PLUGIN_NAME}", got "${String(parsed.name)}"`);
-  }
-  if (parsed.version !== input.version) {
-    throw new Error(`${input.label} plugin.json version mismatch: ${String(parsed.version)} vs ${input.version}`);
-  }
-  return parsed;
-}
-
-async function resetDir(dir: string): Promise<void> {
-  await rm(dir, { recursive: true, force: true });
-  await mkdir(dir, { recursive: true });
-}
-
-async function copyDir(from: string, to: string): Promise<void> {
-  await cp(from, to, { recursive: true });
-}
-
-async function copyAssetsIfPresent(outputRoot: string): Promise<void> {
-  const assetsRoot = join(pkgRoot, "plugin/assets");
-  if (await pathExists(assetsRoot)) {
-    await copyDir(assetsRoot, join(outputRoot, "assets"));
-  }
-}
-
-async function pathExists(path: string): Promise<boolean> {
-  try {
-    await stat(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function writeGeneratedGuards(root: string, agentFile: "CLAUDE.md" | "AGENTS.md", label: string): Promise<void> {
-  await writeFile(join(root, agentFile), generatedNotice(label), "utf8");
-  await writeFile(join(root, "README.md"), generatedNotice(label), "utf8");
-  await writeFile(join(root, ".generated"), "generated by packages/context-cli/scripts/build-plugin.ts\n", "utf8");
-}
-
-async function buildClaude(version: string): Promise<void> {
-  const out = join(PLUGINS_ROOT, "claude");
-  await resetDir(out);
-  await renderManifest({
-    label: "claude",
-    version,
-    templatePath: join(pkgRoot, "plugin/.claude-plugin/plugin.json.template"),
-    outputPath: join(out, ".claude-plugin/plugin.json"),
-  });
-  await copyDir(join(pkgRoot, "plugin/commands"), join(out, "commands"));
-  await copyDir(join(pkgRoot, "plugin/skills"), join(out, "skills"));
-  await writeGeneratedGuards(out, "CLAUDE.md", "Claude plugin build");
-}
-
-async function writePublicSkills(
-  outputRoot: string,
-  commands: readonly CommandSource[],
-  skillName: (slug: string) => string,
-): Promise<void> {
-  const skillsRoot = join(outputRoot, "skills");
-  await mkdir(skillsRoot, { recursive: true });
-  const internalSkillNames = (await readdir(join(pkgRoot, "plugin/skills")))
-    .filter((name) => name.startsWith("skill-"))
-    .sort();
-  for (const command of commands) {
-    const publicName = skillName(command.slug);
-    const skillRoot = join(skillsRoot, publicName);
-    await mkdir(skillRoot, { recursive: true });
-    await writeFile(join(skillRoot, "SKILL.md"), publicSkillBody(command, publicName), "utf8");
-    if (/`(?:context:)?skill-[a-z-]+`/.test(command.body)) {
-      const referencesRoot = join(skillRoot, INTERNAL_PROCEDURES_DIR);
-      await mkdir(referencesRoot, { recursive: true });
-      for (const skill of internalSkillNames) {
-        const sourceRoot = join(pkgRoot, "plugin/skills", skill);
-        // skill-X.md sits directly in the siblings root; depth = 0.
-        const skillBody = await readFile(join(sourceRoot, "SKILL.md"), "utf8");
-        await writeFile(
-          join(referencesRoot, `${skill}.md`),
-          rewriteFlattenedProcedureReferences(rewriteClaudePluginRoot(skillBody, 0), skill),
-          "utf8",
-        );
-        const refs = join(sourceRoot, "references");
-        if (await pathExists(refs)) {
-          await copyMarkdownTreeRewrittenForPublicEntry(
-            refs,
-            join(referencesRoot, skill, "references"),
-            referencesRoot,
-          );
-        }
-      }
-      await rewriteMarkdownFiles(referencesRoot, (content) =>
-        content.replace(
-          /(?<![\w./-])((?:\.\.\/)*)(skill-[a-z-]+)\/SKILL\.md/g,
-          (_match, prefix: string, procedure: string) => `${prefix}${procedure}.md`,
-        )
-      );
-    }
-  }
-}
-
-async function buildCodex(version: string, commands: readonly CommandSource[]): Promise<void> {
-  const out = join(PLUGINS_ROOT, "codex");
-  await resetDir(out);
-  const manifest = await renderManifest({
-    label: "codex",
-    version,
-    templatePath: join(pkgRoot, "plugin/.codex-plugin/plugin.json.template"),
-    outputPath: join(out, ".codex-plugin/plugin.json"),
-  });
-  if (manifest.skills !== "./skills/") {
-    throw new Error(`codex plugin.json must point skills to "./skills/", got "${String(manifest.skills)}"`);
-  }
-  await copyAssetsIfPresent(out);
-  await writePublicSkills(out, commands, codexSkillNameForCommand);
-  await writeGeneratedGuards(out, "AGENTS.md", "Codex plugin build");
-  await verifyNoInternalProcedureReferenceLeak(out, "codex");
-  await verifyNoClaudePluginRootLeak(out, "codex");
-}
-
-async function buildVercel(commands: readonly CommandSource[]): Promise<void> {
-  // Vercel-style standalone skills live directly under dist/plugins/skills/.
-  // No plugin manifest, no per-build README; the top-level dist/plugins/README.md
-  // owns onboarding for this install path.
-  const skillsRoot = join(PLUGINS_ROOT, "skills");
-  await resetDir(skillsRoot);
-  await writePublicSkills(PLUGINS_ROOT, commands, skillNameForCommand);
-  await verifyNoInternalProcedureReferenceLeak(skillsRoot, "vercel");
-  await verifyNoClaudePluginRootLeak(skillsRoot, "vercel");
-}
-
-async function writeCursorCommands(outRoot: string, commands: readonly CommandSource[]): Promise<void> {
-  const dest = join(outRoot, "commands");
-  await mkdir(dest, { recursive: true });
-  const sourceRoot = join(pkgRoot, "plugin/commands");
-  for (const command of commands) {
-    const sourcePath = join(sourceRoot, `${command.slug}.md`);
-    const raw = await readFile(sourcePath, "utf8");
-    const { frontmatter } = parseFrontmatter(raw, `${command.slug}.md`);
-    const rewrittenBody = rewriteClaudeSlashCommandsForCursor(
-      rewriteInternalProcedureReferences(command.body, cursorCommandSkillPath),
-    );
-    const body = stripHtmlComments(rewrittenBody).trimStart();
-    const file = `---\n${frontmatter}\n---\n\n${cursorCommandSummary(command)}\n\n---\n\n${body.trimEnd()}\n`;
-    await writeFile(join(dest, cursorCommandFileName(command.slug)), file, "utf8");
-  }
-}
-
-async function buildCursor(version: string, commands: readonly CommandSource[]): Promise<void> {
-  const out = join(PLUGINS_ROOT, "cursor");
-  await resetDir(out);
-  const manifest = await renderManifest({
-    label: "cursor",
-    version,
-    templatePath: join(pkgRoot, "plugin/.cursor-plugin/plugin.json.template"),
-    outputPath: join(out, ".cursor-plugin/plugin.json"),
-  });
-  if (manifest.skills !== "./skills/") {
-    throw new Error(`cursor plugin.json must point skills to "./skills/", got "${String(manifest.skills)}"`);
-  }
-  if (manifest.commands !== "./commands/") {
-    throw new Error(`cursor plugin.json must point commands to "./commands/", got "${String(manifest.commands)}"`);
-  }
-  await copyAssetsIfPresent(out);
-  await writeCursorCommands(out, commands);
-  // Cursor's internal skills tree is the siblings root; depth-aware rewrite
-  // turns `${CLAUDE_PLUGIN_ROOT}/skills/<name>/...` into the right number of
-  // `..` segments per file location.
-  await copyMarkdownTreeRewrittenForPublicEntry(
-    join(pkgRoot, "plugin/skills"),
-    join(out, "skills"),
-    join(out, "skills"),
-  );
-  await writeGeneratedGuards(out, "AGENTS.md", "Cursor plugin build");
-  await writeFile(
-    join(out, "README.md"),
-    [
-      generatedNotice("Cursor plugin build").trimEnd(),
-      "",
-      "Install shape:",
-      "",
-      "- Marketplace/GitHub plugin shape: this directory is a plugin root with `.cursor-plugin/plugin.json`, `commands/`, and `skills/`.",
-      "- User entries are under `commands/`; Cursor command files are prefixed as `context-*` to avoid global slash-command collisions.",
-      "- Local plugin fallback: symlink or copy this directory to `~/.cursor/plugins/local/context/` only when Marketplace import is unavailable.",
-      "",
-      "Do not copy these files into `.cursor/skills/` as the main install path. Cursor Marketplace installs this plugin root directly.",
-      "",
-    ].join("\n"),
-    "utf8",
-  );
-  await rewriteMarkdownFiles(out, rewriteClaudeSlashCommandsForCursor);
-  await verifyNoInternalProcedureReferenceLeak(out, "cursor");
-  await verifyNoClaudePluginRootLeak(out, "cursor");
-}
-
-async function writeMarketplaceManifests(version: string): Promise<void> {
-  const claudeMarketplace = {
-    name: MARKETPLACE_NAME,
-    owner: { name: "c4a" },
-    plugins: [{
-      name: PLUGIN_NAME,
-      source: "./claude",
-      description: "Local knowledge workspace. Initialize a project and use next-step guidance to maintain it.",
-    }],
-  };
-  const cursorMarketplace = {
-    name: MARKETPLACE_NAME,
-    owner: { name: "Context4AI", email: "support@context4ai.dev" },
-    metadata: { description: "C4A Context plugin marketplace" },
-    plugins: [{
-      name: PLUGIN_NAME,
-      source: "./cursor",
-      description: "Maintain a project-local knowledge workspace through init and continue-step guidance.",
-    }],
-  };
-  const codexMarketplace = {
-    name: MARKETPLACE_NAME,
-    interface: { displayName: "C4A Marketplace" },
-    plugins: [{
-      name: PLUGIN_NAME,
-      source: { source: "local", path: "./codex" },
-      policy: { installation: "AVAILABLE", authentication: "ON_INSTALL" },
-      category: "Productivity",
-    }],
-  };
-  await mkdir(join(PLUGINS_ROOT, ".claude-plugin"), { recursive: true });
-  await mkdir(join(PLUGINS_ROOT, ".cursor-plugin"), { recursive: true });
-  await mkdir(join(PLUGINS_ROOT, ".agents", "plugins"), { recursive: true });
-  await writeFile(
-    join(PLUGINS_ROOT, ".claude-plugin", "marketplace.json"),
-    `${JSON.stringify(claudeMarketplace, null, 2)}\n`,
-    "utf8",
-  );
-  await writeFile(
-    join(PLUGINS_ROOT, ".cursor-plugin", "marketplace.json"),
-    `${JSON.stringify(cursorMarketplace, null, 2)}\n`,
-    "utf8",
-  );
-  await writeFile(
-    join(PLUGINS_ROOT, ".agents", "plugins", "marketplace.json"),
-    `${JSON.stringify(codexMarketplace, null, 2)}\n`,
-    "utf8",
-  );
-  await writeFile(
-    join(PLUGINS_ROOT, "VERSION"),
-    `${version}\n`,
-    "utf8",
-  );
-}
-
-async function writePluginsTopLevelDocs(): Promise<void> {
-  for (const name of ["README.md", "README_CN.md"]) {
-    const body = await readFile(join(pkgRoot, "plugin", name), "utf8");
-    await writeFile(join(PLUGINS_ROOT, name), body, "utf8");
-  }
-
-  const assetsSrc = join(pkgRoot, "plugin/assets");
-  if (await pathExists(assetsSrc)) {
-    const assetsDst = join(PLUGINS_ROOT, "assets");
-    await rm(assetsDst, { recursive: true, force: true });
-    await copyDir(assetsSrc, assetsDst);
-  }
-
-  const gitignorePath = join(PLUGINS_ROOT, ".gitignore");
-  if (!(await pathExists(gitignorePath))) {
-    await writeFile(
-      gitignorePath,
-      [
-        ".DS_Store",
-        "node_modules/",
-        ".idea/",
-        ".vscode/",
-        "",
-      ].join("\n"),
-      "utf8",
-    );
-  }
-}
-
-async function main(): Promise<void> {
-  const pkgRaw = await readFile(resolve(pkgRoot, "package.json"), "utf-8");
-  const pkg = JSON.parse(pkgRaw) as { version?: string };
-  const version = pkg.version;
-  if (!version) throw new Error("package.json is missing `version`");
-
-  const targetLabel = "dist/plugins";
-  await resetDir(PLUGINS_ROOT);
-
-  const commands = await readCommands();
-  await buildClaude(version);
-  await buildCodex(version, commands);
-  await buildCursor(version, commands);
-  await buildVercel(commands);
-  await writeMarketplaceManifests(version);
-  await writePluginsTopLevelDocs();
-
-  process.stdout.write(`${targetLabel}/claude generated (version=${version})\n`);
-  process.stdout.write(`${targetLabel}/codex generated (version=${version}, publicSkills=${commands.length})\n`);
-  process.stdout.write(`${targetLabel}/cursor generated (version=${version}, publicSkills=${commands.length})\n`);
-  process.stdout.write(`${targetLabel}/skills generated (publicSkills=${commands.length})\n`);
-  process.stdout.write(`${targetLabel}/{marketplace.json,README.md,README_CN.md,VERSION} written\n`);
-}
-
-main().catch((err) => {
-  process.stderr.write(`build-plugin failed: ${err instanceof Error ? err.message : String(err)}\n`);
-  process.exit(1);
-});