agentboot 0.2.0 → 0.3.1

package/README.md

@@ -166,7 +166,7 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
 
 ## License
 
-Apache 2.0 — see [LICENSE](LICENSE).
+Apache 2.0 — see [LICENSE](LICENSE). "AgentBoot" is a trademark of Michel Saavedra — see [TRADEMARK.md](TRADEMARK.md).
 
 ---
 

package/bin/agentboot.js

@@ -3,14 +3,22 @@
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
+import { createRequire } from "node:module";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const cli = join(__dirname, "..", "scripts", "cli.ts");
 
+// Resolve tsx from this package's own node_modules, not the user's cwd.
+// When installed globally (npm -g, brew), Node resolves bare specifiers
+// from cwd which fails. Using createRequire anchors resolution to this file.
+const require = createRequire(import.meta.url);
+const tsxPkgDir = dirname(require.resolve("tsx/package.json"));
+const tsxEntry = join(tsxPkgDir, "dist", "esm", "index.mjs");
+
 const result = spawnSync(
   process.execPath,
-  ["--import", "tsx", cli, ...process.argv.slice(2)],
+  ["--import", `file://${tsxEntry}`, cli, ...process.argv.slice(2)],
   { stdio: "inherit", env: { ...process.env } }
 );
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentboot",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Convention over configuration for agentic development teams. The Spring Boot of Claude Code governance.",
   "license": "Apache-2.0",
   "author": "Mike Saavedra <mike@agentboot.dev>",

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[] = [];
@@ -359,8 +373,8 @@ 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
@@ -522,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);
     }
   });
@@ -1090,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
 // ---------------------------------------------------------------------------