agentboot 0.1.0 → 0.3.0

package/scripts/cli.ts

@@ -27,7 +27,7 @@ import path from "node:path";
 import fs from "node:fs";
 import chalk from "chalk";
 import { createHash } from "node:crypto";
-import { loadConfig } from "./lib/config.js";
+import { loadConfig, type MarketplaceManifest, type MarketplaceEntry } from "./lib/config.js";
 
 // ---------------------------------------------------------------------------
 // Paths
@@ -93,6 +93,20 @@ function runScript({ script, args, verbose, quiet }: RunOptions): never {
 // Helpers
 // ---------------------------------------------------------------------------
 
+/** Recursively copy a directory tree. */
+function copyDirRecursive(src: string, dest: string): void {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src)) {
+    const srcPath = path.join(src, entry);
+    const destPath = path.join(dest, entry);
+    if (fs.statSync(srcPath).isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
 /** Collect global flags that should be forwarded to scripts. */
 function collectGlobalArgs(opts: { config?: string }): string[] {
   const args: string[] = [];
@@ -140,7 +154,7 @@ program
 program
   .command("validate")
   .description("Run pre-build validation checks")
-  .option("--strict", "treat warnings as errors")
+  .option("-s, --strict", "treat warnings as errors")
   .action((opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const args = collectGlobalArgs({ config: globalOpts.config });
@@ -163,7 +177,7 @@ program
   .command("sync")
   .description("Distribute compiled output to target repositories")
   .option("--repos-file <path>", "path to repos.json")
-  .option("--dry-run", "preview changes without writing")
+  .option("-d, --dry-run", "preview changes without writing")
   .action((opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const args = collectGlobalArgs({ config: globalOpts.config });
@@ -200,10 +214,10 @@ program
     });
   });
 
-// ---- full-build -----------------------------------------------------------
+// ---- dev-build -----------------------------------------------------------
 
 program
-  .command("full-build")
+  .command("dev-build")
   .description("Run clean → validate → build → dev-sync pipeline")
   .action((_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
@@ -224,6 +238,10 @@ program
       ["tsx", path.join(SCRIPTS_DIR, "validate.ts"), ...baseArgs],
       { cwd: ROOT, stdio: quiet ? ["inherit", "ignore", "pipe"] : "inherit" },
     );
+    if (valResult.error) {
+      console.error(`Validation failed to start: ${valResult.error.message}`);
+      process.exit(1);
+    }
     if (valResult.status !== 0) {
       console.error("Validation failed.");
       process.exit(valResult.status ?? 1);
@@ -236,6 +254,10 @@ program
       ["tsx", path.join(SCRIPTS_DIR, "compile.ts"), ...baseArgs],
       { cwd: ROOT, stdio: quiet ? ["inherit", "ignore", "pipe"] : "inherit" },
     );
+    if (buildResult.error) {
+      console.error(`Build failed to start: ${buildResult.error.message}`);
+      process.exit(1);
+    }
     if (buildResult.status !== 0) {
       console.error("Build failed.");
       process.exit(buildResult.status ?? 1);
@@ -248,12 +270,17 @@ program
       ["tsx", path.join(SCRIPTS_DIR, "dev-sync.ts"), ...baseArgs],
       { cwd: ROOT, stdio: quiet ? ["inherit", "ignore", "pipe"] : "inherit" },
     );
+    if (syncResult.error) {
+      console.error(`Dev-sync failed to start: ${syncResult.error.message}`);
+      process.exit(1);
+    }
     if (syncResult.status !== 0) {
       console.error("Dev-sync failed.");
       process.exit(syncResult.status ?? 1);
     }
 
-    if (!quiet) console.log("✓ full-build complete");
+    if (!quiet) console.log("✓ dev-build complete");
+    process.exit(0);
   });
 
 // ---- setup (AB-33) --------------------------------------------------------
@@ -293,7 +320,7 @@ program
       }
     } catch { /* no git, use default */ }
 
-    console.log(chalk.cyan(`  Detected org: ${orgName}`));
+    console.log(chalk.cyan(`  Detected org: ${orgName}`) + chalk.gray(" (edit agentboot.config.json to change)"));
 
     // Scaffold config
     const configContent = JSON.stringify({
@@ -346,13 +373,13 @@ program
 
 program
   .command("add")
-  .description("Scaffold a new persona, trait, or gotcha")
-  .argument("<type>", "what to add: persona, trait, gotcha")
+  .description("Scaffold a new persona, trait, gotcha, domain, or hook")
+  .argument("<type>", "what to add: persona, trait, gotcha, domain, hook")
   .argument("<name>", "name for the new item (lowercase-with-hyphens)")
   .action((type: string, name: string) => {
     // Validate name format
-    if (!/^[a-z][a-z0-9-]*$/.test(name)) {
-      console.error(chalk.red(`Name must be lowercase alphanumeric with hyphens: got '${name}'`));
+    if (!/^[a-z][a-z0-9-]{0,63}$/.test(name)) {
+      console.error(chalk.red(`Name must be 1-64 lowercase alphanumeric chars with hyphens: got '${name}'`));
       process.exit(1);
     }
 
@@ -509,8 +536,122 @@ paths:
       console.log(chalk.gray(`  core/gotchas/${name}.md\n`));
       console.log(chalk.gray(`  Next: Edit the paths: frontmatter and add your rules.\n`));
 
+    } else if (type === "domain") {
+      // AB-46/53: Domain layer scaffolding
+      const domainDir = path.join(cwd, "domains", name);
+      if (fs.existsSync(domainDir)) {
+        console.error(chalk.red(`Domain '${name}' already exists at domains/${name}/`));
+        process.exit(1);
+      }
+
+      fs.mkdirSync(path.join(domainDir, "traits"), { recursive: true });
+      fs.mkdirSync(path.join(domainDir, "personas"), { recursive: true });
+      fs.mkdirSync(path.join(domainDir, "instructions"), { recursive: true });
+
+      const domainManifest = JSON.stringify({
+        name,
+        version: "1.0.0",
+        description: `TODO — ${name} domain layer`,
+        traits: [],
+        personas: [],
+        instructions: [],
+        requires_core_version: ">=0.2.0",
+      }, null, 2);
+
+      fs.writeFileSync(path.join(domainDir, "agentboot.domain.json"), domainManifest + "\n", "utf-8");
+
+      const readmeMd = `# ${name.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ")} Domain
+
+## Purpose
+
+<!-- Describe what this domain layer adds: compliance regime, industry standards, etc. -->
+
+## Activation
+
+Add to \`agentboot.config.json\`:
+\`\`\`jsonc
+{
+  "domains": ["./domains/${name}"]
+}
+\`\`\`
+
+## Contents
+
+- \`traits/\` — domain-specific behavioral traits
+- \`personas/\` — domain-specific personas
+- \`instructions/\` — domain-level always-on instructions
+`;
+
+      fs.writeFileSync(path.join(domainDir, "README.md"), readmeMd, "utf-8");
+
+      console.log(chalk.bold(`\n${chalk.green("✓")} Created domain: ${name}\n`));
+      console.log(chalk.gray(`  domains/${name}/`));
+      console.log(chalk.gray(`  ├── agentboot.domain.json`));
+      console.log(chalk.gray(`  ├── README.md`));
+      console.log(chalk.gray(`  ├── traits/`));
+      console.log(chalk.gray(`  ├── personas/`));
+      console.log(chalk.gray(`  └── instructions/\n`));
+      console.log(chalk.gray(`  Next: Add domain to config: "domains": ["./domains/${name}"]`));
+      console.log(chalk.gray(`  Then: agentboot validate && agentboot build\n`));
+
+    } else if (type === "hook") {
+      // AB-46: Compliance hook scaffolding
+      const hooksDir = path.join(cwd, "hooks");
+      const hookPath = path.join(hooksDir, `${name}.sh`);
+      if (fs.existsSync(hookPath)) {
+        console.error(chalk.red(`Hook '${name}' already exists at hooks/${name}.sh`));
+        process.exit(1);
+      }
+
+      if (!fs.existsSync(hooksDir)) {
+        fs.mkdirSync(hooksDir, { recursive: true });
+      }
+
+      const hookScript = `#!/bin/bash
+# AgentBoot compliance hook: ${name}
+# Generated by \`agentboot add hook ${name}\`
+#
+# Hook events: PreToolUse, PostToolUse, Notification, Stop,
+#              SubagentStart, SubagentStop, UserPromptSubmit, SessionEnd
+#
+# Input: JSON on stdin with hook_event_name, agent_type, tool_name, etc.
+# Output: exit 0 = pass, exit 2 = block (for PreToolUse/UserPromptSubmit)
+#
+# To register this hook, add to agentboot.config.json:
+#   "claude": {
+#     "hooks": {
+#       "<EventName>": [{
+#         "matcher": "",
+#         "hooks": [{ "type": "command", "command": "hooks/${name}.sh" }]
+#       }]
+#     }
+#   }
+
+INPUT=$(cat)
+EVENT_NAME=$(echo "$INPUT" | jq -r '.hook_event_name // empty')
+
+# TODO: Add your compliance logic here
+# Example: block a tool if a condition is met
+# if [ "$EVENT_NAME" = "PreToolUse" ]; then
+#   TOOL=$(echo "$INPUT" | jq -r '.tool_name // empty')
+#   if [ "$TOOL" = "Bash" ]; then
+#     echo '{"decision":"block","reason":"Bash tool is restricted by policy"}' >&2
+#     exit 2
+#   fi
+# fi
+
+exit 0
+`;
+
+      fs.writeFileSync(hookPath, hookScript, { mode: 0o755 });
+
+      console.log(chalk.bold(`\n${chalk.green("✓")} Created hook: ${name}\n`));
+      console.log(chalk.gray(`  hooks/${name}.sh\n`));
+      console.log(chalk.gray(`  Next: Edit the hook script to add your compliance logic.`));
+      console.log(chalk.gray(`  Then: Register in agentboot.config.json under claude.hooks\n`));
+
     } else {
-      console.error(chalk.red(`Unknown type: '${type}'. Use: persona, trait, gotcha`));
+      console.error(chalk.red(`Unknown type: '${type}'. Use: persona, trait, gotcha, domain, hook`));
       process.exit(1);
     }
   });
@@ -636,7 +777,13 @@ program
       process.exit(1);
     }
 
-    const config = loadConfig(configPath);
+    let config;
+    try {
+      config = loadConfig(configPath);
+    } catch (e: unknown) {
+      console.error(chalk.red(`Failed to parse config: ${e instanceof Error ? e.message : String(e)}`));
+      process.exit(1);
+    }
     const pkgPath = path.join(ROOT, "package.json");
     const version = fs.existsSync(pkgPath) ? JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version : "unknown";
 
@@ -734,7 +881,13 @@ program
       process.exit(1);
     }
 
-    const config = loadConfig(configPath);
+    let config;
+    try {
+      config = loadConfig(configPath);
+    } catch (e: unknown) {
+      console.error(chalk.red(`Failed to parse config: ${e instanceof Error ? e.message : String(e)}`));
+      process.exit(1);
+    }
     const isJson = opts.format === "json";
     if (!isJson) console.log(chalk.bold("\nAgentBoot — lint\n"));
 
@@ -752,6 +905,7 @@ program
 
     const personasDir = path.join(cwd, "core", "personas");
     const enabledPersonas = config.personas?.enabled ?? [];
+    const enabledTraits = config.traits?.enabled ?? [];
     const tokenBudget = config.output?.tokenBudget?.warnAt ?? 8000;
 
     // Vague language patterns
@@ -861,7 +1015,6 @@ program
 
         // Check for unused trait
         const traitName = file.replace(/\.md$/, "");
-        const enabledTraits = config.traits?.enabled ?? [];
         if (enabledTraits.length > 0 && !enabledTraits.includes(traitName)) {
           findings.push({ rule: "unused-trait", severity: "info", file: `core/traits/${file}`, message: `Trait not in traits.enabled list` });
         }
@@ -921,7 +1074,7 @@ program
   .command("uninstall")
   .description("Remove AgentBoot managed files from a repository")
   .option("--repo <path>", "target repository path")
-  .option("--dry-run", "preview what would be removed")
+  .option("-d, --dry-run", "preview what would be removed")
   .action((opts) => {
     const targetRepo = opts.repo ? path.resolve(opts.repo) : process.cwd();
     const dryRun = opts.dryRun ?? false;
@@ -1023,9 +1176,12 @@ program
   .description("View configuration (read-only)")
   .argument("[key]", "config key (e.g., personas.enabled)")
   .argument("[value]", "not yet supported")
-  .action((key?: string, value?: string) => {
+  .action((key: string | undefined, value: string | undefined, _opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const configPath = path.join(cwd, "agentboot.config.json");
+    const configPath = globalOpts.config
+      ? path.resolve(globalOpts.config)
+      : path.join(cwd, "agentboot.config.json");
 
     if (!fs.existsSync(configPath)) {
       console.error(chalk.red("No agentboot.config.json found."));
@@ -1062,6 +1218,297 @@ program
     process.exit(1);
   });
 
+// ---- export (AB-40) -------------------------------------------------------
+
+program
+  .command("export")
+  .description("Export compiled output in a specific format")
+  .option("--format <fmt>", "export format: plugin, marketplace, managed", "plugin")
+  .option("--output <dir>", "output directory")
+  .action((opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const cwd = process.cwd();
+    const configPath = globalOpts.config
+      ? path.resolve(globalOpts.config)
+      : path.join(cwd, "agentboot.config.json");
+
+    if (!fs.existsSync(configPath)) {
+      console.error(chalk.red("No agentboot.config.json found. Run `agentboot setup`."));
+      process.exit(1);
+    }
+
+    let config;
+    try {
+      config = loadConfig(configPath);
+    } catch (e: unknown) {
+      console.error(chalk.red(`Failed to parse config: ${e instanceof Error ? e.message : String(e)}`));
+      process.exit(1);
+    }
+
+    const distPath = path.resolve(cwd, config.output?.distPath ?? "./dist");
+    const format = opts.format;
+
+    console.log(chalk.bold(`\nAgentBoot — export (${format})\n`));
+
+    if (format === "plugin") {
+      const pluginDir = path.join(distPath, "plugin");
+      const pluginJson = path.join(pluginDir, "plugin.json");
+
+      if (!fs.existsSync(pluginJson)) {
+        console.error(chalk.red("Plugin output not found. Run `agentboot build` first."));
+        console.error(chalk.gray("Ensure 'plugin' is in personas.outputFormats or build includes claude format."));
+        process.exit(1);
+      }
+
+      const outputDir = opts.output
+        ? path.resolve(opts.output)
+        : path.join(cwd, ".claude-plugin");
+
+      // Safety: only delete existing dir if it's within cwd or contains plugin.json
+      if (fs.existsSync(outputDir)) {
+        const resolvedCwd = path.resolve(cwd);
+        const isSafe = outputDir.startsWith(resolvedCwd + path.sep)
+          || outputDir === resolvedCwd
+          || fs.existsSync(path.join(outputDir, "plugin.json"));
+        if (!isSafe) {
+          console.error(chalk.red(`  Refusing to delete ${outputDir} — not within project directory.`));
+          console.error(chalk.gray("  Use a path within your project or an empty directory."));
+          process.exit(1);
+        }
+        fs.rmSync(outputDir, { recursive: true, force: true });
+      }
+      fs.mkdirSync(outputDir, { recursive: true });
+
+      copyDirRecursive(pluginDir, outputDir);
+
+      // Count files
+      let fileCount = 0;
+      function countFiles(dir: string): void {
+        for (const entry of fs.readdirSync(dir)) {
+          const full = path.join(dir, entry);
+          if (fs.statSync(full).isDirectory()) countFiles(full);
+          else fileCount++;
+        }
+      }
+      countFiles(outputDir);
+
+      console.log(chalk.green(`  ✓ Exported plugin to ${path.relative(cwd, outputDir)}/`));
+      console.log(chalk.gray(`    ${fileCount} files (plugin.json + agents, skills, traits, hooks, rules)`));
+      console.log(chalk.gray(`\n  Next: agentboot publish\n`));
+
+    } else if (format === "managed") {
+      const managedDir = path.join(distPath, "managed");
+
+      if (!fs.existsSync(managedDir)) {
+        console.error(chalk.red("Managed settings not found. Enable managed.enabled in config and rebuild."));
+        process.exit(1);
+      }
+
+      const outputDir = opts.output
+        ? path.resolve(opts.output)
+        : path.join(cwd, "managed-output");
+
+      fs.mkdirSync(outputDir, { recursive: true });
+      for (const entry of fs.readdirSync(managedDir)) {
+        const srcPath = path.join(managedDir, entry);
+        if (fs.statSync(srcPath).isFile()) {
+          fs.copyFileSync(srcPath, path.join(outputDir, entry));
+        }
+      }
+
+      console.log(chalk.green(`  ✓ Exported managed settings to ${path.relative(cwd, outputDir)}/`));
+      console.log(chalk.gray(`\n  Deploy via your MDM platform (Jamf, Intune, etc.)\n`));
+
+    } else if (format === "marketplace") {
+      // Export marketplace.json scaffold
+      const outputDir = opts.output ? path.resolve(opts.output) : cwd;
+      const marketplacePath = path.join(outputDir, "marketplace.json");
+
+      if (fs.existsSync(marketplacePath)) {
+        console.log(chalk.yellow(`  marketplace.json already exists at ${marketplacePath}`));
+        process.exit(0);
+      }
+
+      const marketplace: MarketplaceManifest = {
+        $schema: "https://agentboot.dev/schema/marketplace/v1",
+        name: `${config.org}-personas`,
+        description: `Agentic personas marketplace for ${config.orgDisplayName ?? config.org}`,
+        maintainer: config.orgDisplayName ?? config.org,
+        url: "",
+        entries: [],
+      };
+
+      fs.writeFileSync(marketplacePath, JSON.stringify(marketplace, null, 2) + "\n", "utf-8");
+      console.log(chalk.green(`  ✓ Created marketplace.json`));
+      console.log(chalk.gray(`\n  Next: agentboot publish to add entries\n`));
+
+    } else {
+      console.error(chalk.red(`Unknown export format: '${format}'. Use: plugin, marketplace, managed`));
+      process.exit(1);
+    }
+  });
+
+// ---- publish (AB-41) ------------------------------------------------------
+
+program
+  .command("publish")
+  .description("Publish compiled plugin to marketplace")
+  .option("--marketplace <path>", "path to marketplace.json", "marketplace.json")
+  .option("--bump <level>", "version bump: major, minor, patch")
+  .option("-d, --dry-run", "preview changes without writing")
+  .action((opts) => {
+    const cwd = process.cwd();
+    const dryRun = opts.dryRun ?? false;
+
+    console.log(chalk.bold("\nAgentBoot — publish\n"));
+    if (dryRun) console.log(chalk.yellow("  DRY RUN — no files will be modified\n"));
+
+    // Find plugin
+    const pluginJsonPath = path.join(cwd, ".claude-plugin", "plugin.json");
+    const distPluginPath = path.join(cwd, "dist", "plugin", "plugin.json");
+
+    let pluginDir: string;
+    let pluginManifest: Record<string, unknown>;
+
+    if (fs.existsSync(pluginJsonPath)) {
+      pluginDir = path.join(cwd, ".claude-plugin");
+      try {
+        pluginManifest = JSON.parse(fs.readFileSync(pluginJsonPath, "utf-8"));
+      } catch (e: unknown) {
+        console.error(chalk.red(`  Failed to parse plugin.json: ${e instanceof Error ? e.message : String(e)}`));
+        process.exit(1);
+      }
+    } else if (fs.existsSync(distPluginPath)) {
+      pluginDir = path.join(cwd, "dist", "plugin");
+      try {
+        pluginManifest = JSON.parse(fs.readFileSync(distPluginPath, "utf-8"));
+      } catch (e: unknown) {
+        console.error(chalk.red(`  Failed to parse plugin.json: ${e instanceof Error ? e.message : String(e)}`));
+        process.exit(1);
+      }
+    } else {
+      console.error(chalk.red("  No plugin found. Run `agentboot export --format plugin` first."));
+      process.exit(1);
+    }
+
+    let version = (pluginManifest["version"] as string) ?? "0.0.0";
+
+    // B8 fix: Validate semver format before bumping
+    if (!/^\d+\.\d+\.\d+$/.test(version)) {
+      console.error(chalk.red(`  Invalid version format: '${version}'. Expected X.Y.Z (e.g., 1.2.3)`));
+      process.exit(1);
+    }
+
+    // Version bump — B6 fix: bump BEFORE hash/copy so release gets correct version
+    if (opts.bump) {
+      const parts = version.split(".").map(Number);
+      if (opts.bump === "major") { parts[0]!++; parts[1] = 0; parts[2] = 0; }
+      else if (opts.bump === "minor") { parts[1]!++; parts[2] = 0; }
+      else if (opts.bump === "patch") { parts[2]!++; }
+      else {
+        console.error(chalk.red(`  Invalid bump level: '${opts.bump}'. Use: major, minor, patch`));
+        process.exit(1);
+      }
+      version = parts.join(".");
+      pluginManifest["version"] = version;
+
+      // Write bumped version to source plugin.json BEFORE hashing
+      fs.writeFileSync(
+        path.join(pluginDir, "plugin.json"),
+        JSON.stringify(pluginManifest, null, 2) + "\n",
+        "utf-8"
+      );
+      console.log(chalk.cyan(`  Version bumped to ${version}`));
+    }
+
+    // Path validation for version (prevent traversal via manipulated version field)
+    if (/[/\\]|\.\./.test(version)) {
+      console.error(chalk.red(`  Version contains unsafe characters: '${version}'`));
+      process.exit(1);
+    }
+
+    // Load or create marketplace.json
+    const marketplacePath = path.resolve(cwd, opts.marketplace);
+    let marketplace: MarketplaceManifest;
+
+    if (fs.existsSync(marketplacePath)) {
+      try {
+        marketplace = JSON.parse(fs.readFileSync(marketplacePath, "utf-8"));
+      } catch (e: unknown) {
+        console.error(chalk.red(`  Failed to parse marketplace.json: ${e instanceof Error ? e.message : String(e)}`));
+        process.exit(1);
+      }
+    } else {
+      console.log(chalk.yellow(`  marketplace.json not found — creating at ${marketplacePath}`));
+      marketplace = {
+        $schema: "https://agentboot.dev/schema/marketplace/v1",
+        name: (pluginManifest["name"] as string) ?? "agentboot-personas",
+        description: (pluginManifest["description"] as string) ?? "",
+        maintainer: (pluginManifest["author"] as string) ?? "",
+        entries: [],
+      };
+    }
+
+    // Compute hash of plugin directory (now includes bumped version)
+    const hash = createHash("sha256");
+    function hashDir(dir: string): void {
+      for (const entry of fs.readdirSync(dir).sort()) {
+        const full = path.join(dir, entry);
+        if (fs.statSync(full).isDirectory()) {
+          hashDir(full);
+        } else {
+          // Include relative path in hash for integrity (not just content)
+          hash.update(path.relative(pluginDir, full));
+          hash.update(fs.readFileSync(full));
+        }
+      }
+    }
+    hashDir(pluginDir);
+    const sha256 = hash.digest("hex");
+
+    // Create release entry
+    const releasePath = `releases/v${version}/`;
+    const entry: MarketplaceEntry = {
+      type: "plugin",
+      name: (pluginManifest["name"] as string) ?? "unknown",
+      version,
+      description: (pluginManifest["description"] as string) ?? "",
+      published_at: new Date().toISOString(),
+      sha256,
+      path: releasePath,
+    };
+
+    // B7 fix: Dedup by type+name+version (preserves version history)
+    const existingIdx = marketplace.entries.findIndex(
+      (e) => e.type === "plugin" && e.name === entry.name && e.version === entry.version
+    );
+    if (existingIdx >= 0) {
+      marketplace.entries[existingIdx] = entry;
+    } else {
+      marketplace.entries.push(entry);
+    }
+
+    if (dryRun) {
+      console.log(chalk.gray(`  Would write marketplace.json with entry:`));
+      console.log(chalk.gray(`    ${entry.name} v${entry.version} (${sha256.slice(0, 12)}...)`));
+      console.log(chalk.gray(`  Would copy plugin to ${releasePath}`));
+    } else {
+      // Write updated marketplace.json
+      fs.writeFileSync(marketplacePath, JSON.stringify(marketplace, null, 2) + "\n", "utf-8");
+
+      // Copy plugin to releases directory (version already bumped in source)
+      const releaseDir = path.resolve(cwd, releasePath);
+      fs.mkdirSync(releaseDir, { recursive: true });
+      copyDirRecursive(pluginDir, releaseDir);
+
+      console.log(chalk.green(`  ✓ Published ${entry.name} v${version}`));
+      console.log(chalk.gray(`    SHA-256: ${sha256.slice(0, 12)}...`));
+      console.log(chalk.gray(`    Path: ${releasePath}`));
+    }
+
+    console.log("");
+  });
+
 // ---------------------------------------------------------------------------
 // Parse
 // ---------------------------------------------------------------------------