@knid/agentx 0.1.0

package/dist/index.js

@@ -0,0 +1,2142 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command19 } from "commander";
+import { readFileSync as readFileSync12 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join17 } from "path";
+
+// src/commands/run.ts
+import { Command } from "commander";
+
+// src/runtime/runner.ts
+import { execa } from "execa";
+import { unlinkSync, existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+
+// src/config/agent-config.ts
+import { readFileSync, existsSync } from "fs";
+import { join as join2, resolve } from "path";
+import { parse } from "yaml";
+
+// src/schemas/agent-yaml.ts
+import { z } from "zod";
+var VALID_CATEGORIES = [
+  "productivity",
+  "devtools",
+  "communication",
+  "data",
+  "writing",
+  "research",
+  "automation",
+  "security",
+  "monitoring",
+  "other"
+];
+var AGENT_NAME_REGEX = /^[a-z0-9-]+$/;
+var SEMVER_REGEX = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?(\+[a-zA-Z0-9.]+)?$/;
+var mcpServerSchema = z.object({
+  command: z.string(),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string()).optional()
+});
+var secretSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  required: z.boolean().default(true)
+});
+var permissionsSchema = z.object({
+  filesystem: z.boolean().optional(),
+  network: z.boolean().optional(),
+  execute_commands: z.boolean().optional()
+});
+var configOptionSchema = z.object({
+  key: z.string(),
+  description: z.string().optional(),
+  default: z.string().optional()
+});
+var exampleSchema = z.object({
+  prompt: z.string(),
+  description: z.string().optional()
+});
+var requiresSchema = z.object({
+  claude_cli: z.string().optional(),
+  node: z.string().optional(),
+  os: z.array(z.string()).optional()
+});
+var agentYamlSchema = z.object({
+  name: z.string().min(1).max(100).regex(AGENT_NAME_REGEX, "Name must contain only lowercase letters, numbers, and hyphens"),
+  version: z.string().regex(SEMVER_REGEX, "Version must be valid semver (e.g. 1.0.0)"),
+  description: z.string().min(1).max(500),
+  author: z.string().refine((val) => val.startsWith("@"), {
+    message: "Author must start with @"
+  }),
+  license: z.string().default("MIT"),
+  tags: z.array(z.string()).max(10).optional(),
+  category: z.enum(VALID_CATEGORIES).optional(),
+  requires: requiresSchema.optional(),
+  mcp_servers: z.record(mcpServerSchema).optional(),
+  secrets: z.array(secretSchema).optional(),
+  permissions: permissionsSchema.optional(),
+  config: z.array(configOptionSchema).optional(),
+  examples: z.array(exampleSchema).optional()
+});
+
+// src/config/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+var AGENTX_HOME = join(homedir(), ".agentx");
+var AGENTS_DIR = join(AGENTX_HOME, "agents");
+var SECRETS_DIR = join(AGENTX_HOME, "secrets");
+var CONFIG_PATH = join(AGENTX_HOME, "config.yaml");
+var AUTH_PATH = join(AGENTX_HOME, "auth.json");
+var CACHE_DIR = join(AGENTX_HOME, "cache");
+var LOGS_DIR = join(AGENTX_HOME, "logs");
+
+// src/utils/errors.ts
+var AgentxError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AgentxError";
+  }
+};
+var AgentNotFoundError = class extends AgentxError {
+  constructor(agentName) {
+    super(`Agent not found: ${agentName}`);
+    this.name = "AgentNotFoundError";
+  }
+};
+var ConfigError = class extends AgentxError {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+var AuthError = class extends AgentxError {
+  constructor(message) {
+    super(message);
+    this.name = "AuthError";
+  }
+};
+var RegistryError = class extends AgentxError {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "RegistryError";
+  }
+};
+var ValidationError = class extends AgentxError {
+  constructor(message, details = []) {
+    super(message);
+    this.details = details;
+    this.name = "ValidationError";
+  }
+};
+
+// src/config/agent-config.ts
+function getAgentDir(agentName) {
+  if (agentName === "." || agentName.startsWith("/") || agentName.startsWith("./")) {
+    return resolve(agentName);
+  }
+  return join2(AGENTS_DIR, agentName);
+}
+function loadAgentYaml(agentDir) {
+  const yamlPath = join2(agentDir, "agent.yaml");
+  if (!existsSync(yamlPath)) {
+    throw new AgentNotFoundError(agentDir);
+  }
+  try {
+    const raw = readFileSync(yamlPath, "utf-8");
+    const parsed = parse(raw);
+    return agentYamlSchema.parse(parsed);
+  } catch (error) {
+    if (error instanceof Error && error.name === "ZodError") {
+      throw new ValidationError(`Invalid agent.yaml in ${agentDir}`, [error.message]);
+    }
+    throw error;
+  }
+}
+function loadSystemPrompt(agentDir) {
+  const promptPath = join2(agentDir, "system-prompt.md");
+  if (!existsSync(promptPath)) {
+    throw new ValidationError(`Missing system-prompt.md in ${agentDir}`);
+  }
+  return readFileSync(promptPath, "utf-8");
+}
+function loadAgentConfig(agentName) {
+  const agentDir = getAgentDir(agentName);
+  const manifest = loadAgentYaml(agentDir);
+  const systemPrompt = loadSystemPrompt(agentDir);
+  return {
+    manifest,
+    systemPrompt,
+    agentDir
+  };
+}
+
+// src/config/global-config.ts
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync3 } from "fs";
+import { parse as parse2, stringify } from "yaml";
+
+// src/schemas/config.ts
+import { z as z2 } from "zod";
+var globalConfigSchema = z2.object({
+  registry: z2.string().url().default("https://agentx-web.vercel.app"),
+  claude_path: z2.string().default("claude"),
+  default_output: z2.enum(["text", "json"]).default("text"),
+  telemetry: z2.boolean().default(true),
+  auto_update: z2.boolean().default(true),
+  claude_defaults: z2.object({
+    max_turns: z2.number().int().positive().default(10)
+  }).default({})
+});
+var DEFAULT_CONFIG = globalConfigSchema.parse({});
+
+// src/utils/init-dirs.ts
+import { mkdirSync, existsSync as existsSync2 } from "fs";
+var REQUIRED_DIRS = [AGENTX_HOME, AGENTS_DIR, SECRETS_DIR, CACHE_DIR, LOGS_DIR];
+function ensureDirectories() {
+  for (const dir of REQUIRED_DIRS) {
+    if (!existsSync2(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+
+// src/config/global-config.ts
+function loadGlobalConfig() {
+  ensureDirectories();
+  if (!existsSync3(CONFIG_PATH)) {
+    return DEFAULT_CONFIG;
+  }
+  try {
+    const raw = readFileSync2(CONFIG_PATH, "utf-8");
+    const parsed = parse2(raw);
+    return globalConfigSchema.parse(parsed);
+  } catch (error) {
+    if (error instanceof Error && error.name === "ZodError") {
+      throw new ConfigError(`Invalid config at ${CONFIG_PATH}: ${error.message}`);
+    }
+    throw new ConfigError(`Failed to read config: ${error.message}`);
+  }
+}
+function saveGlobalConfig(config) {
+  ensureDirectories();
+  try {
+    const yaml = stringify(config);
+    writeFileSync(CONFIG_PATH, yaml, "utf-8");
+  } catch (error) {
+    throw new ConfigError(`Failed to save config: ${error.message}`);
+  }
+}
+function getConfigValue(key) {
+  const config = loadGlobalConfig();
+  return config[key];
+}
+function setConfigValue(key, value) {
+  const config = loadGlobalConfig();
+  config[key] = value;
+  saveGlobalConfig(config);
+}
+
+// src/runtime/prompt-processor.ts
+function processSystemPrompt(template, configOptions, overrides) {
+  return template.replace(/\{\{config\.(\w+)\}\}/g, (_match, key) => {
+    if (key in overrides) {
+      return overrides[key];
+    }
+    const option = configOptions.find((opt) => opt.key === key);
+    if (option?.default !== void 0) {
+      return option.default;
+    }
+    return "";
+  });
+}
+
+// src/runtime/mcp-builder.ts
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, chmodSync } from "fs";
+import { join as join3 } from "path";
+import { tmpdir } from "os";
+import { randomUUID } from "crypto";
+function resolveMCPConfig(servers, secrets) {
+  const resolved = {};
+  for (const [name, server] of Object.entries(servers)) {
+    const resolvedEnv = {};
+    if (server.env) {
+      for (const [envKey, envValue] of Object.entries(server.env)) {
+        resolvedEnv[envKey] = envValue.replace(
+          /\$\{secrets\.(\w+)\}/g,
+          (_match, secretKey) => secrets[secretKey] ?? ""
+        );
+      }
+    }
+    resolved[name] = {
+      command: server.command,
+      ...server.args ? { args: server.args } : {},
+      ...server.env ? { env: resolvedEnv } : {}
+    };
+  }
+  return resolved;
+}
+async function writeTempMCPConfig(servers) {
+  const tempDir = join3(tmpdir(), "agentx-mcp");
+  mkdirSync2(tempDir, { recursive: true });
+  const configPath = join3(tempDir, `${randomUUID()}.json`);
+  const config = { mcpServers: servers };
+  writeFileSync2(configPath, JSON.stringify(config, null, 2), "utf-8");
+  chmodSync(configPath, 384);
+  return configPath;
+}
+
+// src/runtime/pipe-handler.ts
+async function detectPipedInput() {
+  return !process.stdin.isTTY;
+}
+async function readPipedInput() {
+  return new Promise((resolve6, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve6(data));
+    process.stdin.on("error", reject);
+  });
+}
+function buildPromptWithPipe(prompt, pipedContent) {
+  if (!pipedContent) {
+    return prompt;
+  }
+  if (!prompt) {
+    return pipedContent;
+  }
+  return `${pipedContent}
+
+${prompt}`;
+}
+
+// src/runtime/output-formatter.ts
+function formatOutput(data, format) {
+  if (format === "json") {
+    try {
+      const parsed = JSON.parse(data);
+      return JSON.stringify(parsed, null, 2);
+    } catch {
+      return JSON.stringify({ output: data });
+    }
+  }
+  return data;
+}
+
+// src/telemetry/reporter.ts
+function sendTelemetry(event) {
+  try {
+    const config = loadGlobalConfig();
+    if (!config.telemetry) {
+      return;
+    }
+    const url = `${config.registry}/api/v1/telemetry`;
+    fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(event),
+      signal: AbortSignal.timeout(5e3)
+    }).catch(() => {
+    });
+  } catch {
+  }
+}
+
+// src/runtime/runner.ts
+function buildClaudeArgs(options) {
+  const args = [];
+  if (!options.interactive && options.prompt) {
+    args.push("-p", options.prompt);
+  }
+  args.push("--system-prompt", options.systemPrompt);
+  if (options.mcpConfigPath) {
+    args.push("--mcp-config", options.mcpConfigPath);
+  }
+  if (options.maxTurns !== void 0) {
+    args.push("--max-turns", String(options.maxTurns));
+  }
+  if (options.outputFormat) {
+    args.push("--output-format", options.outputFormat);
+  }
+  return args;
+}
+async function runAgent(agentName, options) {
+  const agentConfig = loadAgentConfig(agentName);
+  const globalConfig = loadGlobalConfig();
+  const { manifest, systemPrompt, agentDir } = agentConfig;
+  const processedPrompt = processSystemPrompt(
+    systemPrompt,
+    manifest.config ?? [],
+    options.configOverrides ?? {}
+  );
+  let mcpConfigPath;
+  if (manifest.mcp_servers && Object.keys(manifest.mcp_servers).length > 0) {
+    const secrets = {};
+    const resolved = resolveMCPConfig(manifest.mcp_servers, secrets);
+    mcpConfigPath = await writeTempMCPConfig(resolved);
+  }
+  const startTime = Date.now();
+  const agentFullName = `@${manifest.author?.replace(/^@/, "") ?? "local"}/${manifest.name}`;
+  try {
+    let finalPrompt = options.prompt ?? "";
+    if (!options.interactive) {
+      const isPiped = await detectPipedInput();
+      if (isPiped) {
+        const pipedContent = await readPipedInput();
+        finalPrompt = buildPromptWithPipe(finalPrompt, pipedContent);
+      }
+      if (options.file) {
+        const fileContent = readFileSync3(options.file, "utf-8");
+        finalPrompt = buildPromptWithPipe(finalPrompt, fileContent);
+      }
+    }
+    const claudeArgs = buildClaudeArgs({
+      prompt: options.interactive ? void 0 : finalPrompt,
+      systemPrompt: processedPrompt,
+      mcpConfigPath,
+      maxTurns: globalConfig.claude_defaults.max_turns,
+      outputFormat: options.outputFormat ?? globalConfig.default_output,
+      interactive: options.interactive
+    });
+    if (options.debug) {
+      console.error(`[debug] claude ${claudeArgs.join(" ")}`);
+    }
+    const claudePath = globalConfig.claude_path;
+    if (options.interactive) {
+      await execa(claudePath, claudeArgs, { stdio: "inherit" });
+      sendTelemetry({
+        agent: agentFullName,
+        version: manifest.version,
+        success: true,
+        duration_ms: Date.now() - startTime
+      });
+      return "";
+    }
+    const result = await execa(claudePath, claudeArgs);
+    const output = formatOutput(result.stdout, options.outputFormat ?? "text");
+    if (!options.quiet) {
+      process.stdout.write(output);
+    }
+    sendTelemetry({
+      agent: agentFullName,
+      version: manifest.version,
+      success: true,
+      duration_ms: Date.now() - startTime
+    });
+    return output;
+  } catch (error) {
+    sendTelemetry({
+      agent: agentFullName,
+      version: manifest.version,
+      success: false,
+      duration_ms: Date.now() - startTime,
+      error_type: error instanceof Error ? error.constructor.name : "UnknownError"
+    });
+    throw error;
+  } finally {
+    if (mcpConfigPath && existsSync4(mcpConfigPath)) {
+      try {
+        unlinkSync(mcpConfigPath);
+      } catch {
+      }
+    }
+  }
+}
+
+// src/ui/colors.ts
+import chalk from "chalk";
+var noColor = process.env.NO_COLOR !== void 0 || process.argv.includes("--no-color");
+var identity = (s) => s;
+var colors = {
+  success: noColor ? identity : chalk.green,
+  error: noColor ? identity : chalk.red,
+  warn: noColor ? identity : chalk.yellow,
+  info: noColor ? identity : chalk.blue,
+  dim: noColor ? identity : chalk.dim,
+  bold: noColor ? identity : chalk.bold,
+  cyan: noColor ? identity : chalk.cyan,
+  magenta: noColor ? identity : chalk.magenta
+};
+
+// src/commands/run.ts
+var runCommand = new Command("run").description("Run a local or installed agent").argument("<agent>", 'Agent name, path, or "." for current directory').argument("[prompt...]", "Prompt to send to the agent").option("-i, --interactive", "Run in interactive mode (stdin/stdout)").option("--file <path>", "Include file content in the prompt").option("--json", "Output in JSON format").option("--quiet", "Suppress output (useful for scripting)").option("--debug", "Show debug information").option("--output-format <format>", "Output format: text or json", "text").addHelpText("after", `
+Examples:
+  $ agentx run data-analyst "summarize this data" --file data.csv
+  $ agentx run . "test prompt"
+  $ cat report.csv | agentx run data-analyst "find anomalies"
+  $ agentx run gmail-agent -i`).action(async (agent, promptParts, options) => {
+  try {
+    const prompt = promptParts.join(" ");
+    const outputFormat = options.json ? "json" : options.outputFormat;
+    await runAgent(agent, {
+      prompt: prompt || void 0,
+      interactive: options.interactive ?? (!prompt && !options.file),
+      file: options.file,
+      outputFormat,
+      quiet: options.quiet,
+      debug: options.debug
+    });
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+      if (options.debug && error.stack) {
+        console.error(colors.dim(error.stack));
+      }
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/configure.ts
+import { Command as Command2 } from "commander";
+
+// src/secrets/configure-flow.ts
+import * as p from "@clack/prompts";
+
+// src/secrets/store.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync6, unlinkSync as unlinkSync2, mkdirSync as mkdirSync3 } from "fs";
+import { join as join4 } from "path";
+
+// src/secrets/encrypt.ts
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "crypto";
+import { execFileSync } from "child_process";
+import { readFileSync as readFileSync4, existsSync as existsSync5 } from "fs";
+import { platform, hostname, homedir as homedir2 } from "os";
+var ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 12;
+var KEY_LENGTH = 32;
+var SALT = "agentx-salt";
+function getMachineId() {
+  const os = platform();
+  if (os === "linux" && existsSync5("/etc/machine-id")) {
+    return readFileSync4("/etc/machine-id", "utf-8").trim();
+  }
+  if (os === "darwin") {
+    try {
+      const output = execFileSync(
+        "ioreg",
+        ["-rd1", "-c", "IOPlatformExpertDevice"],
+        { encoding: "utf-8" }
+      );
+      const match = output.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/);
+      if (match) return match[1];
+    } catch {
+    }
+  }
+  return `${hostname()}-${homedir2()}`;
+}
+function deriveKey() {
+  const machineId = getMachineId();
+  return scryptSync(machineId, SALT, KEY_LENGTH);
+}
+async function encrypt(secrets) {
+  const key = deriveKey();
+  const iv = randomBytes(IV_LENGTH);
+  const cipher = createCipheriv(ALGORITHM, key, iv);
+  const plaintext = JSON.stringify(secrets);
+  const encrypted = Buffer.concat([cipher.update(plaintext, "utf-8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return {
+    iv: iv.toString("hex"),
+    tag: tag.toString("hex"),
+    data: encrypted.toString("hex")
+  };
+}
+async function decrypt(store) {
+  const key = deriveKey();
+  const iv = Buffer.from(store.iv, "hex");
+  const tag = Buffer.from(store.tag, "hex");
+  const data = Buffer.from(store.data, "hex");
+  const decipher = createDecipheriv(ALGORITHM, key, iv);
+  decipher.setAuthTag(tag);
+  const decrypted = Buffer.concat([decipher.update(data), decipher.final()]);
+  return JSON.parse(decrypted.toString("utf-8"));
+}
+
+// src/secrets/store.ts
+function getSecretsFilePath(agentName, secretsDir) {
+  return join4(secretsDir, `${agentName}.enc.json`);
+}
+async function saveSecrets(agentName, secrets, secretsDir = SECRETS_DIR) {
+  mkdirSync3(secretsDir, { recursive: true });
+  const encrypted = await encrypt(secrets);
+  const filePath = getSecretsFilePath(agentName, secretsDir);
+  writeFileSync3(filePath, JSON.stringify(encrypted, null, 2), "utf-8");
+}
+async function loadSecrets(agentName, secretsDir = SECRETS_DIR) {
+  const filePath = getSecretsFilePath(agentName, secretsDir);
+  if (!existsSync6(filePath)) {
+    return {};
+  }
+  const raw = readFileSync5(filePath, "utf-8");
+  const store = JSON.parse(raw);
+  return decrypt(store);
+}
+async function deleteSecrets(agentName, secretsDir = SECRETS_DIR) {
+  const filePath = getSecretsFilePath(agentName, secretsDir);
+  if (existsSync6(filePath)) {
+    unlinkSync2(filePath);
+  }
+}
+
+// src/secrets/configure-flow.ts
+async function runConfigureFlow(options) {
+  const { agentName, declarations, secretsDir } = options;
+  if (declarations.length === 0) {
+    p.log.info("This agent does not require any secrets.");
+    return;
+  }
+  p.intro(`Configure secrets for ${agentName}`);
+  const existing = await loadSecrets(agentName, secretsDir);
+  const secrets = { ...existing };
+  for (const decl of declarations) {
+    const currentValue = existing[decl.name];
+    const label = decl.description ? `${decl.name} (${decl.description})` : decl.name;
+    const hint = currentValue ? "Press enter to keep existing value" : void 0;
+    const value = await p.text({
+      message: label,
+      placeholder: hint,
+      validate(input) {
+        if (!input && !currentValue && decl.required !== false) {
+          return "This secret is required";
+        }
+      }
+    });
+    if (p.isCancel(value)) {
+      p.cancel("Configuration cancelled.");
+      process.exit(0);
+    }
+    if (value) {
+      secrets[decl.name] = value;
+    }
+  }
+  await saveSecrets(agentName, secrets, secretsDir);
+  p.outro(`Secrets saved for ${agentName}`);
+}
+
+// src/commands/configure.ts
+var configureCommand = new Command2("configure").description("Configure secrets for an agent").argument("<agent>", "Agent name or path").addHelpText("after", `
+Examples:
+  $ agentx configure gmail-agent
+  $ agentx configure ./my-agent`).action(async (agent) => {
+  try {
+    const agentDir = getAgentDir(agent);
+    const manifest = loadAgentYaml(agentDir);
+    if (!manifest.secrets || manifest.secrets.length === 0) {
+      console.log(colors.info(`Agent "${manifest.name}" does not declare any secrets.`));
+      return;
+    }
+    await runConfigureFlow({
+      agentName: manifest.name,
+      declarations: manifest.secrets
+    });
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/init.ts
+import { Command as Command3 } from "commander";
+import * as p2 from "@clack/prompts";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, existsSync as existsSync7 } from "fs";
+import { join as join5, resolve as resolve2 } from "path";
+function getTemplatesDir() {
+  const packageRoot = resolve2(new URL("..", import.meta.url).pathname);
+  const srcPath = join5(packageRoot, "src", "templates", "basic");
+  if (existsSync7(srcPath)) return srcPath;
+  return join5(packageRoot, "templates", "basic");
+}
+function loadTemplate(templatesDir, filename) {
+  return readFileSync6(join5(templatesDir, filename), "utf-8");
+}
+function replaceTemplateVars(content, vars) {
+  let result = content;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replaceAll(`{{${key}}}`, value);
+  }
+  return result;
+}
+var initCommand = new Command3("init").description("Scaffold a new agent project").argument("[directory]", "Directory to create the agent in", ".").addHelpText("after", `
+Examples:
+  $ agentx init
+  $ agentx init ./my-agent`).action(async (directory) => {
+  try {
+    p2.intro("Create a new agentx agent");
+    const name = await p2.text({
+      message: "Agent name",
+      placeholder: "my-agent",
+      validate(input) {
+        if (!input) return "Name is required";
+        if (!/^[a-z0-9-]+$/.test(input)) {
+          return "Name must contain only lowercase letters, numbers, and hyphens";
+        }
+      }
+    });
+    if (p2.isCancel(name)) {
+      p2.cancel("Init cancelled.");
+      process.exit(0);
+    }
+    const description = await p2.text({
+      message: "Description",
+      placeholder: "A helpful AI agent",
+      validate(input) {
+        if (!input) return "Description is required";
+        if (input.length > 500) return "Description must be 500 characters or less";
+      }
+    });
+    if (p2.isCancel(description)) {
+      p2.cancel("Init cancelled.");
+      process.exit(0);
+    }
+    const author = await p2.text({
+      message: "Author (e.g. @username)",
+      placeholder: "@username",
+      validate(input) {
+        if (!input) return "Author is required";
+        if (!input.startsWith("@")) return "Author must start with @";
+      }
+    });
+    if (p2.isCancel(author)) {
+      p2.cancel("Init cancelled.");
+      process.exit(0);
+    }
+    const category = await p2.select({
+      message: "Category",
+      options: VALID_CATEGORIES.map((c) => ({ value: c, label: c }))
+    });
+    if (p2.isCancel(category)) {
+      p2.cancel("Init cancelled.");
+      process.exit(0);
+    }
+    const license = await p2.text({
+      message: "License",
+      placeholder: "MIT",
+      initialValue: "MIT"
+    });
+    if (p2.isCancel(license)) {
+      p2.cancel("Init cancelled.");
+      process.exit(0);
+    }
+    const targetDir = directory === "." ? resolve2(name) : resolve2(directory);
+    if (existsSync7(targetDir)) {
+      const overwrite = await p2.confirm({
+        message: `Directory ${targetDir} already exists. Continue?`
+      });
+      if (p2.isCancel(overwrite) || !overwrite) {
+        p2.cancel("Init cancelled.");
+        process.exit(0);
+      }
+    }
+    mkdirSync4(targetDir, { recursive: true });
+    const vars = {
+      NAME: name,
+      DESCRIPTION: description,
+      AUTHOR: author,
+      CATEGORY: category,
+      LICENSE: license,
+      YEAR: (/* @__PURE__ */ new Date()).getFullYear().toString()
+    };
+    const templatesDir = getTemplatesDir();
+    const templates = ["agent.yaml", "system-prompt.md", "README.md", "LICENSE"];
+    for (const file of templates) {
+      const content = loadTemplate(templatesDir, file);
+      const populated = replaceTemplateVars(content, vars);
+      writeFileSync4(join5(targetDir, file), populated, "utf-8");
+    }
+    p2.outro(`Agent scaffolded at ${colors.cyan(targetDir)}`);
+    console.log();
+    console.log(`  Next steps:`);
+    console.log(`  ${colors.dim("1.")} cd ${name}`);
+    console.log(`  ${colors.dim("2.")} Edit system-prompt.md with your agent's instructions`);
+    console.log(`  ${colors.dim("3.")} agentx validate`);
+    console.log(`  ${colors.dim("4.")} agentx run . "test prompt"`);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/validate.ts
+import { Command as Command4 } from "commander";
+import { readFileSync as readFileSync7, existsSync as existsSync8 } from "fs";
+import { join as join6, resolve as resolve3 } from "path";
+import { parse as parse3 } from "yaml";
+function validateAgentDir(agentDir) {
+  const errors = [];
+  const warnings = [];
+  const yamlPath = join6(agentDir, "agent.yaml");
+  if (!existsSync8(yamlPath)) {
+    errors.push("agent.yaml not found");
+    return { valid: false, errors, warnings };
+  }
+  try {
+    const raw = readFileSync7(yamlPath, "utf-8");
+    const parsed = parse3(raw);
+    agentYamlSchema.parse(parsed);
+  } catch (error) {
+    if (error instanceof Error && error.name === "ZodError") {
+      const zodError = error;
+      for (const issue of zodError.issues) {
+        errors.push(`agent.yaml: ${issue.path.join(".")}: ${issue.message}`);
+      }
+    } else if (error instanceof Error) {
+      errors.push(`agent.yaml: ${error.message}`);
+    }
+  }
+  const promptPath = join6(agentDir, "system-prompt.md");
+  if (!existsSync8(promptPath)) {
+    errors.push("system-prompt.md not found");
+  }
+  const readmePath = join6(agentDir, "README.md");
+  if (!existsSync8(readmePath)) {
+    warnings.push("README.md not found (recommended)");
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+var validateCommand = new Command4("validate").description("Validate an agent project").argument("[directory]", "Agent directory to validate", ".").addHelpText("after", `
+Examples:
+  $ agentx validate
+  $ agentx validate ./my-agent`).action(async (directory) => {
+  const agentDir = resolve3(directory);
+  const result = validateAgentDir(agentDir);
+  if (result.valid) {
+    console.log(colors.success("  Agent is valid!"));
+  } else {
+    console.log(colors.error("  Validation failed:"));
+    for (const error of result.errors) {
+      console.log(colors.error(`    ${error}`));
+    }
+  }
+  for (const warning of result.warnings) {
+    console.log(colors.warn(`    ${warning}`));
+  }
+  if (!result.valid) {
+    process.exit(1);
+  }
+});
+
+// src/commands/test.ts
+import { Command as Command5 } from "commander";
+import { readFileSync as readFileSync8, existsSync as existsSync9 } from "fs";
+import { join as join7, resolve as resolve4 } from "path";
+import { parse as parse4 } from "yaml";
+import { execa as execa2 } from "execa";
+async function checkMCPServerStartability(servers) {
+  const results = [];
+  for (const [name, server] of Object.entries(servers)) {
+    try {
+      await execa2("which", [server.command]);
+      results.push({ name, reachable: true });
+    } catch {
+      results.push({
+        name,
+        reachable: false,
+        error: `Command "${server.command}" not found in PATH`
+      });
+    }
+  }
+  return results;
+}
+var testCommand = new Command5("test").description("Validate and test an agent project").argument("[directory]", "Agent directory to test", ".").addHelpText("after", `
+Examples:
+  $ agentx test
+  $ agentx test ./my-agent`).action(async (directory) => {
+  const agentDir = resolve4(directory);
+  console.log(colors.bold("Running validation..."));
+  const validation = validateAgentDir(agentDir);
+  if (validation.valid) {
+    console.log(colors.success("  Validation passed"));
+  } else {
+    console.log(colors.error("  Validation failed:"));
+    for (const error of validation.errors) {
+      console.log(colors.error(`    ${error}`));
+    }
+    process.exit(1);
+  }
+  for (const warning of validation.warnings) {
+    console.log(colors.warn(`    ${warning}`));
+  }
+  const yamlPath = join7(agentDir, "agent.yaml");
+  if (existsSync9(yamlPath)) {
+    try {
+      const raw = readFileSync8(yamlPath, "utf-8");
+      const parsed = parse4(raw);
+      const manifest = agentYamlSchema.parse(parsed);
+      if (manifest.mcp_servers && Object.keys(manifest.mcp_servers).length > 0) {
+        console.log(colors.bold("\nChecking MCP servers..."));
+        const mcpResults = await checkMCPServerStartability(manifest.mcp_servers);
+        for (const result of mcpResults) {
+          if (result.reachable) {
+            console.log(colors.success(`  ${result.name}: command found`));
+          } else {
+            console.log(colors.warn(`  ${result.name}: ${result.error}`));
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  console.log(colors.success("\n  All tests passed!"));
+});
+
+// src/commands/doctor.ts
+import { Command as Command6 } from "commander";
+import { execa as execa3 } from "execa";
+import { readFileSync as readFileSync9, existsSync as existsSync10 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join as join8 } from "path";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+async function checkClaudeCLI() {
+  try {
+    const whichResult = await execa3("which", ["claude"]);
+    if (!whichResult.stdout || whichResult.exitCode !== 0) {
+      return { found: false };
+    }
+    const claudePath = whichResult.stdout.trim();
+    try {
+      const versionResult = await execa3("claude", ["--version"]);
+      return {
+        found: true,
+        version: versionResult.stdout.trim(),
+        path: claudePath
+      };
+    } catch {
+      return { found: true, path: claudePath };
+    }
+  } catch {
+    return { found: false };
+  }
+}
+function checkNodeVersion() {
+  const version = process.version.replace(/^v/, "");
+  const major = parseInt(version.split(".")[0], 10);
+  return {
+    version,
+    supported: major >= 18
+  };
+}
+function checkAgentxVersion() {
+  const candidates = [
+    join8(__dirname2, "..", "..", "package.json"),
+    join8(__dirname2, "..", "package.json")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync10(candidate)) {
+      const pkg2 = JSON.parse(readFileSync9(candidate, "utf-8"));
+      return { version: pkg2.version };
+    }
+  }
+  return { version: "unknown" };
+}
+async function runDoctor() {
+  const results = [];
+  const claudeCheck = await checkClaudeCLI();
+  results.push({
+    label: "Claude CLI",
+    pass: claudeCheck.found,
+    detail: claudeCheck.found ? `found (v${claudeCheck.version ?? "unknown"})` : "not found - install with: npm install -g @anthropic-ai/claude-code"
+  });
+  const nodeCheck = checkNodeVersion();
+  results.push({
+    label: "Node.js",
+    pass: nodeCheck.supported,
+    detail: nodeCheck.supported ? `v${nodeCheck.version}` : `v${nodeCheck.version} (requires >= 18)`
+  });
+  const agentxCheck = checkAgentxVersion();
+  results.push({
+    label: "agentx",
+    pass: true,
+    detail: `v${agentxCheck.version}`
+  });
+  return results;
+}
+var doctorCommand = new Command6("doctor").description("Check system requirements and configuration").addHelpText("after", `
+Examples:
+  $ agentx doctor`).action(async () => {
+  const results = await runDoctor();
+  const allPassed = results.every((r) => r.pass);
+  for (const result of results) {
+    const icon = result.pass ? colors.success("  ") : colors.error("  ");
+    console.log(`${icon} ${result.label}: ${result.detail}`);
+  }
+  console.log();
+  if (allPassed) {
+    console.log(colors.success("  agentx ready!"));
+  } else {
+    console.log(colors.error("  Some checks failed. Please fix the issues above."));
+    process.exit(1);
+  }
+});
+
+// src/commands/login.ts
+import { Command as Command7 } from "commander";
+
+// src/auth/github-oauth.ts
+import { createServer } from "http";
+import { randomBytes as randomBytes2 } from "crypto";
+import { execFileSync as execFileSync2 } from "child_process";
+import { platform as platform2 } from "os";
+import { ofetch } from "ofetch";
+function openBrowser(url) {
+  const os = platform2();
+  try {
+    switch (os) {
+      case "darwin":
+        execFileSync2("open", [url]);
+        break;
+      case "linux":
+        execFileSync2("xdg-open", [url]);
+        break;
+      case "win32":
+        execFileSync2("cmd", ["/c", "start", url.replace(/&/g, "^&")]);
+        break;
+      default:
+        throw new AuthError(`Unsupported platform: ${os}. Please open this URL manually: ${url}`);
+    }
+  } catch (error) {
+    if (error instanceof AuthError) throw error;
+    throw new AuthError(`Failed to open browser. Please open this URL manually: ${url}`);
+  }
+}
+function parseQuery(url) {
+  const qIndex = url.indexOf("?");
+  if (qIndex === -1) return new URLSearchParams();
+  return new URLSearchParams(url.slice(qIndex + 1));
+}
+function startOAuthFlow(registryUrl) {
+  return new Promise((resolve6, reject) => {
+    const state = randomBytes2(16).toString("hex");
+    const server = createServer();
+    const timeout = setTimeout(() => {
+      server.close();
+      reject(new AuthError("OAuth flow timed out after 5 minutes"));
+    }, 5 * 60 * 1e3);
+    server.on("request", async (req, res) => {
+      const url = req.url ?? "";
+      if (!url.startsWith("/callback")) {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not Found");
+        return;
+      }
+      try {
+        const params = parseQuery(url);
+        const code = params.get("code");
+        const returnedState = params.get("state");
+        if (!code) {
+          throw new AuthError("No authorization code received from GitHub");
+        }
+        if (returnedState !== state) {
+          throw new AuthError("OAuth state mismatch - possible CSRF attack");
+        }
+        const authResponse = await ofetch(
+          `${registryUrl}/api/v1/auth/callback`,
+          {
+            method: "GET",
+            query: { code, state }
+          }
+        );
+        const token = {
+          token: authResponse.token,
+          username: authResponse.user.username,
+          github_id: authResponse.user.github_id,
+          created_at: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+          <html>
+            <body style="font-family: system-ui, sans-serif; text-align: center; padding: 40px;">
+              <h1>Authentication successful!</h1>
+              <p>You can close this tab and return to the terminal.</p>
+            </body>
+          </html>
+        `);
+        clearTimeout(timeout);
+        server.close();
+        resolve6(token);
+      } catch (error) {
+        res.writeHead(500, { "Content-Type": "text/html" });
+        res.end(`
+          <html>
+            <body style="font-family: system-ui, sans-serif; text-align: center; padding: 40px;">
+              <h1>Authentication failed</h1>
+              <p>Please return to the terminal for details.</p>
+            </body>
+          </html>
+        `);
+        clearTimeout(timeout);
+        server.close();
+        reject(
+          error instanceof AuthError ? error : new AuthError(`OAuth callback failed: ${error.message}`)
+        );
+      }
+    });
+    server.listen(0, "127.0.0.1", async () => {
+      try {
+        const address = server.address();
+        if (!address || typeof address === "string") {
+          throw new AuthError("Failed to start local OAuth server");
+        }
+        const port = address.port;
+        const redirectUri = `http://127.0.0.1:${port}/callback`;
+        const { auth_url } = await ofetch(
+          `${registryUrl}/api/v1/auth/github`,
+          {
+            method: "POST",
+            body: { redirect_uri: redirectUri, state }
+          }
+        );
+        openBrowser(auth_url);
+      } catch (error) {
+        clearTimeout(timeout);
+        server.close();
+        reject(
+          error instanceof AuthError ? error : new AuthError(`Failed to start OAuth flow: ${error.message}`)
+        );
+      }
+    });
+    server.on("error", (error) => {
+      clearTimeout(timeout);
+      reject(new AuthError(`OAuth server error: ${error.message}`));
+    });
+  });
+}
+
+// src/auth/token-store.ts
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync5, unlinkSync as unlinkSync3, existsSync as existsSync11, chmodSync as chmodSync2 } from "fs";
+function saveToken(token) {
+  ensureDirectories();
+  writeFileSync5(AUTH_PATH, JSON.stringify(token, null, 2), "utf-8");
+  chmodSync2(AUTH_PATH, 384);
+}
+function loadToken() {
+  if (!existsSync11(AUTH_PATH)) {
+    return null;
+  }
+  try {
+    const raw = readFileSync10(AUTH_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function clearToken() {
+  if (existsSync11(AUTH_PATH)) {
+    unlinkSync3(AUTH_PATH);
+  }
+}
+function isAuthenticated() {
+  return existsSync11(AUTH_PATH);
+}
+
+// src/ui/spinner.ts
+import { spinner } from "@clack/prompts";
+function createSpinner() {
+  const s = spinner();
+  return {
+    start(message) {
+      s.start(message);
+    },
+    stop(message) {
+      s.stop(message);
+    },
+    message(message) {
+      s.message(message);
+    }
+  };
+}
+
+// src/commands/login.ts
+var loginCommand = new Command7("login").description("Authenticate with the agentx registry via GitHub").addHelpText("after", `
+Examples:
+  $ agentx login`).action(async () => {
+  try {
+    if (isAuthenticated()) {
+      const existing = loadToken();
+      if (existing) {
+        console.log(
+          colors.info(`Already logged in as ${colors.bold(existing.username)}.`)
+        );
+        console.log(colors.dim('Run "agentx logout" first to switch accounts.'));
+        return;
+      }
+    }
+    const config = loadGlobalConfig();
+    const spin = createSpinner();
+    console.log(colors.info("Opening GitHub in your browser to authenticate..."));
+    spin.start("Waiting for authentication...");
+    const token = await startOAuthFlow(config.registry);
+    saveToken(token);
+    spin.stop(colors.success(`Logged in as ${colors.bold(token.username)}`));
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/logout.ts
+import { Command as Command8 } from "commander";
+var logoutCommand = new Command8("logout").description("Log out of the agentx registry").addHelpText("after", `
+Examples:
+  $ agentx logout`).action(() => {
+  try {
+    if (!isAuthenticated()) {
+      console.log(colors.info("Not currently logged in."));
+      return;
+    }
+    clearToken();
+    console.log(colors.success("Logged out successfully."));
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/whoami.ts
+import { Command as Command9 } from "commander";
+var whoamiCommand = new Command9("whoami").description("Display the currently authenticated user").addHelpText("after", `
+Examples:
+  $ agentx whoami`).action(() => {
+  try {
+    const token = loadToken();
+    if (!token) {
+      console.log(colors.warn('Not logged in. Run "agentx login" to authenticate.'));
+      return;
+    }
+    console.log(colors.bold(token.username));
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/publish.ts
+import { Command as Command10 } from "commander";
+import { resolve as resolve5 } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { join as join11 } from "path";
+
+// src/registry/publish.ts
+import { readFileSync as readFileSync11, existsSync as existsSync13 } from "fs";
+import { join as join10 } from "path";
+
+// src/registry/client.ts
+import { ofetch as ofetch2 } from "ofetch";
+function toRegistryError(error) {
+  if (error && typeof error === "object" && "status" in error) {
+    const status = error.status;
+    const message = error.data?.message ?? `Registry request failed with status ${status}`;
+    return new RegistryError(message, status);
+  }
+  return new RegistryError(
+    `Registry request failed: ${error.message}`
+  );
+}
+function createRegistryClient(options) {
+  const config = loadGlobalConfig();
+  const baseURL = `${config.registry}/api/v1`;
+  const authHeaders = {};
+  if (options?.token) {
+    authHeaders["Authorization"] = `Bearer ${options.token}`;
+  }
+  return {
+    async get(path) {
+      try {
+        return await ofetch2(path, {
+          baseURL,
+          method: "GET",
+          headers: authHeaders
+        });
+      } catch (error) {
+        throw toRegistryError(error);
+      }
+    },
+    async post(path, body) {
+      try {
+        return await ofetch2(path, {
+          baseURL,
+          method: "POST",
+          headers: authHeaders,
+          body
+        });
+      } catch (error) {
+        throw toRegistryError(error);
+      }
+    },
+    async put(path, body) {
+      try {
+        return await ofetch2(path, {
+          baseURL,
+          method: "PUT",
+          headers: authHeaders,
+          body
+        });
+      } catch (error) {
+        throw toRegistryError(error);
+      }
+    }
+  };
+}
+
+// src/utils/tar.ts
+import * as tar from "tar";
+import { existsSync as existsSync12 } from "fs";
+import { join as join9 } from "path";
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+import { readFile } from "fs/promises";
+function hashBuffer(buffer) {
+  return createHash("sha256").update(buffer).digest("hex");
+}
+
+// src/utils/tar.ts
+var INCLUDE_ENTRIES = [
+  "agent.yaml",
+  "system-prompt.md",
+  "README.md",
+  "LICENSE",
+  "prompts",
+  "tools"
+];
+async function createTarball(agentDir) {
+  const entries = INCLUDE_ENTRIES.filter((entry) => {
+    const fullPath = join9(agentDir, entry);
+    return existsSync12(fullPath);
+  });
+  if (entries.length === 0) {
+    throw new Error(`No packable files found in ${agentDir}`);
+  }
+  const chunks = [];
+  const stream = tar.create(
+    {
+      gzip: true,
+      cwd: agentDir,
+      portable: true
+    },
+    entries
+  );
+  for await (const chunk of stream) {
+    chunks.push(Buffer.from(chunk));
+  }
+  const buffer = Buffer.concat(chunks);
+  const sha256 = hashBuffer(buffer);
+  return { buffer, sha256 };
+}
+
+// src/registry/publish.ts
+async function publishAgent(agentDir, token) {
+  const manifest = loadAgentYaml(agentDir);
+  if (!manifest.author.startsWith("@")) {
+    throw new ValidationError("Agent author must start with @ (e.g. @username)");
+  }
+  const scope = manifest.author.slice(1);
+  const { buffer, sha256 } = await createTarball(agentDir);
+  const readmePath = join10(agentDir, "README.md");
+  const readme = existsSync13(readmePath) ? readFileSync11(readmePath, "utf-8") : "";
+  const formData = new FormData();
+  formData.append(
+    "tarball",
+    new Blob([new Uint8Array(buffer)], { type: "application/gzip" }),
+    `${manifest.name}-${manifest.version}.tar.gz`
+  );
+  formData.append("agent_yaml", JSON.stringify(manifest));
+  formData.append("readme", readme);
+  formData.append("sha256", sha256);
+  const client = createRegistryClient({ token });
+  return client.put(
+    `/agents/${scope}/${manifest.name}`,
+    formData
+  );
+}
+
+// src/commands/publish.ts
+var publishCommand = new Command10("publish").description("Publish an agent to the agentx registry").argument("[directory]", "Agent directory to publish", ".").addHelpText("after", `
+Examples:
+  $ agentx publish
+  $ agentx publish ./my-agent`).action(async (directory) => {
+  try {
+    const agentDir = resolve5(directory);
+    const yamlPath = join11(agentDir, "agent.yaml");
+    if (!existsSync14(yamlPath)) {
+      console.error(
+        colors.error(`No agent.yaml found in ${agentDir}. Run "agentx init" to create one.`)
+      );
+      process.exit(1);
+    }
+    const manifest = loadAgentYaml(agentDir);
+    const token = loadToken();
+    if (!token) {
+      console.error(
+        colors.error('Not logged in. Run "agentx login" to authenticate first.')
+      );
+      process.exit(1);
+    }
+    console.log(
+      colors.info(
+        `Publishing ${colors.bold(`${manifest.author}/${manifest.name}`)} v${manifest.version}...`
+      )
+    );
+    const spin = createSpinner();
+    spin.start("Packaging and uploading agent...");
+    const result = await publishAgent(agentDir, token.token);
+    spin.stop(
+      colors.success(
+        `Published ${colors.bold(result.full_name)} v${result.version}`
+      )
+    );
+    console.log();
+    console.log(`  ${colors.dim("View at:")} ${colors.cyan(result.url)}`);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/install.ts
+import { Command as Command11 } from "commander";
+import { existsSync as existsSync16 } from "fs";
+import { join as join13 } from "path";
+
+// src/registry/download.ts
+import { mkdirSync as mkdirSync5, existsSync as existsSync15, rmSync } from "fs";
+import { join as join12 } from "path";
+import { createHash as createHash2 } from "crypto";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+import * as tar2 from "tar";
+function verifyChecksum(buffer, expectedSha256) {
+  const actual = createHash2("sha256").update(buffer).digest("hex");
+  return actual === expectedSha256;
+}
+async function fetchTarball(url) {
+  const { ofetch: ofetch3 } = await import("ofetch");
+  const response = await ofetch3(url, { responseType: "arrayBuffer" });
+  return Buffer.from(response);
+}
+async function downloadAndExtract(scope, name, version, tarballBuffer, expectedSha256) {
+  if (!verifyChecksum(tarballBuffer, expectedSha256)) {
+    throw new RegistryError(
+      `SHA-256 checksum mismatch for ${scope}/${name}@${version}. The tarball may have been tampered with.`
+    );
+  }
+  const agentDir = join12(AGENTS_DIR, name);
+  if (existsSync15(agentDir)) {
+    rmSync(agentDir, { recursive: true, force: true });
+  }
+  mkdirSync5(agentDir, { recursive: true });
+  const stream = Readable.from(tarballBuffer);
+  await pipeline(
+    stream,
+    tar2.extract({ cwd: agentDir, strip: 0 })
+  );
+  return { agentDir, version, name, scope };
+}
+async function fetchAgentInfo(scope, name) {
+  const client = createRegistryClient();
+  return client.get(`/agents/${scope}/${name}`);
+}
+async function fetchDownloadInfo(scope, name, version) {
+  const client = createRegistryClient();
+  return client.get(`/agents/${scope}/${name}/download/${version}`);
+}
+async function installAgent(scope, name, requestedVersion) {
+  const info = await fetchAgentInfo(scope, name);
+  const version = requestedVersion ?? info.latest_version;
+  if (!version) {
+    throw new RegistryError(`No version found for ${scope}/${name}`);
+  }
+  const downloadInfo = await fetchDownloadInfo(scope, name, version);
+  const tarballBuffer = await fetchTarball(downloadInfo.tarball_url);
+  return downloadAndExtract(scope, name, version, tarballBuffer, downloadInfo.tarball_sha256);
+}
+
+// src/commands/install.ts
+function parseAgentSpecifier(spec) {
+  const atVersionIndex = spec.lastIndexOf("@");
+  if (atVersionIndex > 0) {
+    const beforeVersion = spec.slice(0, atVersionIndex);
+    const version = spec.slice(atVersionIndex + 1);
+    const slashIndex2 = beforeVersion.indexOf("/");
+    if (slashIndex2 > 0) {
+      return {
+        scope: beforeVersion.slice(0, slashIndex2),
+        name: beforeVersion.slice(slashIndex2 + 1),
+        version
+      };
+    }
+  }
+  const slashIndex = spec.indexOf("/");
+  if (slashIndex > 0) {
+    return {
+      scope: spec.slice(0, slashIndex),
+      name: spec.slice(slashIndex + 1)
+    };
+  }
+  return { scope: "@agentx", name: spec };
+}
+var installCommand = new Command11("install").description("Install an agent from the registry").argument("<agent>", "Agent to install (e.g. @scope/name or @scope/name@version)").option("-f, --force", "Force reinstall even if already installed").addHelpText("after", `
+Examples:
+  $ agentx install @agentx/data-analyst
+  $ agentx install @agentx/gmail-agent@1.2.0
+  $ agentx install @agentx/code-reviewer --force`).action(async (agentSpec, options) => {
+  try {
+    const { scope, name, version } = parseAgentSpecifier(agentSpec);
+    const displayName = `${scope}/${name}`;
+    const agentDir = join13(AGENTS_DIR, name);
+    if (existsSync16(agentDir) && !options.force) {
+      const existing = loadAgentYaml(agentDir);
+      console.log(
+        colors.warn(
+          `${displayName} v${existing.version} is already installed. Use --force to reinstall.`
+        )
+      );
+      return;
+    }
+    console.log(
+      colors.info(
+        `Installing ${colors.bold(displayName)}${version ? ` v${version}` : ""}...`
+      )
+    );
+    const spin = createSpinner();
+    spin.start("Downloading and extracting agent...");
+    const result = await installAgent(scope, name, version);
+    spin.stop(
+      colors.success(
+        `Installed ${colors.bold(`${result.scope}/${result.name}`)} v${result.version}`
+      )
+    );
+    const manifest = loadAgentYaml(result.agentDir);
+    if (manifest.secrets && manifest.secrets.length > 0) {
+      console.log();
+      console.log(
+        colors.warn(
+          `This agent requires secrets. Run ${colors.bold(`agentx configure ${name}`)} to set them up.`
+        )
+      );
+    }
+    console.log();
+    console.log(
+      `  ${colors.dim("Run with:")} ${colors.cyan(`agentx run ${name} "your prompt"`)}`
+    );
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/uninstall.ts
+import { Command as Command12 } from "commander";
+import { existsSync as existsSync17, rmSync as rmSync2 } from "fs";
+import { join as join14 } from "path";
+var uninstallCommand = new Command12("uninstall").description("Uninstall an agent").argument("<agent>", "Agent name to uninstall").option("--keep-secrets", "Keep secrets (do not delete encrypted secrets)").addHelpText("after", `
+Examples:
+  $ agentx uninstall data-analyst
+  $ agentx uninstall gmail-agent --keep-secrets`).action(async (agentName, options) => {
+  try {
+    const agentDir = join14(AGENTS_DIR, agentName);
+    if (!existsSync17(agentDir)) {
+      console.error(
+        colors.error(`Agent "${agentName}" is not installed.`)
+      );
+      process.exit(1);
+    }
+    rmSync2(agentDir, { recursive: true, force: true });
+    if (!options.keepSecrets) {
+      await deleteSecrets(agentName);
+    }
+    console.log(
+      colors.success(`Uninstalled ${colors.bold(agentName)}`)
+    );
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/list.ts
+import { Command as Command13 } from "commander";
+import { existsSync as existsSync18, readdirSync } from "fs";
+import { join as join15 } from "path";
+
+// src/ui/table.ts
+function formatTable(columns, rows) {
+  const widths = columns.map((col) => {
+    const maxContent = Math.max(col.label.length, ...rows.map((r) => (r[col.key] || "").length));
+    return col.width ?? Math.min(maxContent, 40);
+  });
+  const header = columns.map((col, i) => colors.bold(col.label.padEnd(widths[i]))).join("  ");
+  const separator = widths.map((w) => "\u2500".repeat(w)).join("\u2500\u2500");
+  const body = rows.map(
+    (row) => columns.map((col, i) => {
+      const value = row[col.key] || "";
+      const truncated = value.length > widths[i] ? value.slice(0, widths[i] - 1) + "\u2026" : value;
+      return col.align === "right" ? truncated.padStart(widths[i]) : truncated.padEnd(widths[i]);
+    }).join("  ")
+  ).join("\n");
+  return `${header}
+${separator}
+${body}`;
+}
+
+// src/commands/list.ts
+var listCommand = new Command13("list").alias("ls").description("List installed agents").option("--json", "Output as JSON").addHelpText("after", `
+Examples:
+  $ agentx list
+  $ agentx ls --json`).action((options) => {
+  try {
+    if (!existsSync18(AGENTS_DIR)) {
+      if (options.json) {
+        console.log(JSON.stringify([]));
+      } else {
+        console.log(colors.dim("No agents installed."));
+        console.log(
+          colors.dim(`Run ${colors.cyan("agentx install @scope/agent-name")} to install one.`)
+        );
+      }
+      return;
+    }
+    const entries = readdirSync(AGENTS_DIR, { withFileTypes: true }).filter((e) => e.isDirectory()).filter((e) => existsSync18(join15(AGENTS_DIR, e.name, "agent.yaml")));
+    if (entries.length === 0) {
+      if (options.json) {
+        console.log(JSON.stringify([]));
+      } else {
+        console.log(colors.dim("No agents installed."));
+        console.log(
+          colors.dim(`Run ${colors.cyan("agentx install @scope/agent-name")} to install one.`)
+        );
+      }
+      return;
+    }
+    const agentData = entries.map((entry) => {
+      const agentDir = join15(AGENTS_DIR, entry.name);
+      try {
+        const manifest = loadAgentYaml(agentDir);
+        return {
+          name: manifest.name,
+          version: manifest.version,
+          author: manifest.author,
+          description: manifest.description,
+          category: manifest.category ?? ""
+        };
+      } catch {
+        return {
+          name: entry.name,
+          version: "?",
+          author: "?",
+          description: "Error reading agent.yaml",
+          category: ""
+        };
+      }
+    });
+    if (options.json) {
+      console.log(JSON.stringify(agentData, null, 2));
+      return;
+    }
+    console.log(colors.bold(`Installed agents (${agentData.length}):
+`));
+    const table = formatTable(
+      [
+        { key: "name", label: "Name", width: 25 },
+        { key: "version", label: "Version", width: 10 },
+        { key: "author", label: "Author", width: 20 },
+        { key: "description", label: "Description", width: 40 }
+      ],
+      agentData
+    );
+    console.log(table);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/update.ts
+import { Command as Command14 } from "commander";
+import { existsSync as existsSync19, readdirSync as readdirSync2 } from "fs";
+import { join as join16 } from "path";
+
+// src/utils/semver.ts
+var SEMVER_REGEX2 = /^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9.]+))?(?:\+[a-zA-Z0-9.]+)?$/;
+function parseVersion(version) {
+  const match = version.match(SEMVER_REGEX2);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] || void 0
+  };
+}
+function compareVersions(a, b) {
+  const va = parseVersion(a);
+  const vb = parseVersion(b);
+  if (!va || !vb) return 0;
+  if (va.major !== vb.major) return va.major - vb.major;
+  if (va.minor !== vb.minor) return va.minor - vb.minor;
+  if (va.patch !== vb.patch) return va.patch - vb.patch;
+  if (va.prerelease && !vb.prerelease) return -1;
+  if (!va.prerelease && vb.prerelease) return 1;
+  if (va.prerelease && vb.prerelease) {
+    return va.prerelease < vb.prerelease ? -1 : va.prerelease > vb.prerelease ? 1 : 0;
+  }
+  return 0;
+}
+function isNewerThan(a, b) {
+  return compareVersions(a, b) > 0;
+}
+
+// src/commands/update.ts
+var updateCommand = new Command14("update").description("Update installed agents to the latest version").argument("[agent]", "Specific agent to update").option("--all", "Update all installed agents").addHelpText("after", `
+Examples:
+  $ agentx update data-analyst
+  $ agentx update --all`).action(async (agentName, options) => {
+  try {
+    if (!agentName && !options?.all) {
+      console.error(
+        colors.error("Specify an agent name or use --all to update all agents.")
+      );
+      process.exit(1);
+    }
+    const agentsToUpdate = [];
+    if (options?.all) {
+      if (!existsSync19(AGENTS_DIR)) {
+        console.log(colors.dim("No agents installed."));
+        return;
+      }
+      const entries = readdirSync2(AGENTS_DIR, { withFileTypes: true }).filter((e) => e.isDirectory()).filter((e) => existsSync19(join16(AGENTS_DIR, e.name, "agent.yaml")));
+      agentsToUpdate.push(...entries.map((e) => e.name));
+    } else if (agentName) {
+      agentsToUpdate.push(agentName);
+    }
+    if (agentsToUpdate.length === 0) {
+      console.log(colors.dim("No agents to update."));
+      return;
+    }
+    let updatedCount = 0;
+    for (const name of agentsToUpdate) {
+      const agentDir = join16(AGENTS_DIR, name);
+      if (!existsSync19(agentDir)) {
+        console.log(colors.warn(`Agent "${name}" is not installed. Skipping.`));
+        continue;
+      }
+      const manifest = loadAgentYaml(agentDir);
+      const scope = manifest.author;
+      const spin = createSpinner();
+      spin.start(`Checking ${colors.bold(name)} for updates...`);
+      try {
+        const info = await fetchAgentInfo(scope, name);
+        if (!info.latest_version || !isNewerThan(info.latest_version, manifest.version)) {
+          spin.stop(colors.dim(`${name} v${manifest.version} is already up to date`));
+          continue;
+        }
+        spin.message(`Updating ${name} from v${manifest.version} to v${info.latest_version}...`);
+        await installAgent(scope, name, info.latest_version);
+        spin.stop(
+          colors.success(
+            `Updated ${colors.bold(name)} from v${manifest.version} to v${info.latest_version}`
+          )
+        );
+        updatedCount++;
+      } catch (error) {
+        spin.stop(
+          colors.error(
+            `Failed to update ${name}: ${error.message}`
+          )
+        );
+      }
+    }
+    console.log();
+    if (updatedCount > 0) {
+      console.log(colors.success(`Updated ${updatedCount} agent${updatedCount !== 1 ? "s" : ""}.`));
+    } else {
+      console.log(colors.dim("All agents are up to date."));
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/info.ts
+import { Command as Command15 } from "commander";
+function parseInfoSpecifier(spec) {
+  const slashIndex = spec.indexOf("/");
+  if (slashIndex > 0) {
+    return {
+      scope: spec.slice(0, slashIndex),
+      name: spec.slice(slashIndex + 1)
+    };
+  }
+  return { scope: "@agentx", name: spec };
+}
+var infoCommand = new Command15("info").description("Display agent details from the registry").argument("<agent>", "Agent to look up (e.g. @scope/name)").option("--json", "Output as JSON").addHelpText("after", `
+Examples:
+  $ agentx info @agentx/data-analyst
+  $ agentx info @agentx/gmail-agent --json`).action(async (agentSpec, options) => {
+  try {
+    const { scope, name } = parseInfoSpecifier(agentSpec);
+    const info = await fetchAgentInfo(scope, name);
+    if (options.json) {
+      console.log(JSON.stringify(info, null, 2));
+      return;
+    }
+    console.log();
+    console.log(`  ${colors.bold(`${info.scope}/${info.name}`)} v${info.latest_version}`);
+    console.log(`  ${colors.dim(info.description ?? "")}`);
+    console.log();
+    if (info.author) {
+      console.log(`  ${colors.dim("Author:")}    ${info.author.username}`);
+    }
+    if (info.category) {
+      console.log(`  ${colors.dim("Category:")}  ${info.category}`);
+    }
+    if (info.license) {
+      console.log(`  ${colors.dim("License:")}   ${info.license}`);
+    }
+    if (info.tags && info.tags.length > 0) {
+      console.log(`  ${colors.dim("Tags:")}      ${info.tags.join(", ")}`);
+    }
+    console.log();
+    console.log(`  ${colors.dim("Downloads:")} ${info.download_count}`);
+    console.log(`  ${colors.dim("Stars:")}     ${info.star_count}`);
+    if (info.is_verified) {
+      console.log(`  ${colors.success("Verified")}`);
+    }
+    if (info.repository) {
+      console.log(`  ${colors.dim("Repository:")} ${colors.cyan(info.repository)}`);
+    }
+    if (info.homepage) {
+      console.log(`  ${colors.dim("Homepage:")}   ${colors.cyan(info.homepage)}`);
+    }
+    console.log();
+    console.log(
+      `  ${colors.dim("Install:")} ${colors.cyan(`agentx install ${scope}/${name}`)}`
+    );
+    if (info.versions && Array.isArray(info.versions)) {
+      console.log();
+      console.log(`  ${colors.dim("Versions:")}`);
+      for (const v of info.versions) {
+        console.log(`    ${v.version}  ${colors.dim(v.published_at ?? "")}`);
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/search.ts
+import { Command as Command16 } from "commander";
+
+// src/registry/search.ts
+async function searchAgents(query, options) {
+  const client = createRegistryClient();
+  const params = new URLSearchParams({ q: query });
+  if (options?.limit) {
+    params.set("limit", String(options.limit));
+  }
+  if (options?.category) {
+    params.set("category", options.category);
+  }
+  if (options?.sort) {
+    params.set("sort", options.sort);
+  }
+  return client.get(`/search?${params.toString()}`);
+}
+async function getTrending(options) {
+  const client = createRegistryClient();
+  const params = new URLSearchParams();
+  if (options?.period) {
+    params.set("period", options.period);
+  }
+  if (options?.limit) {
+    params.set("limit", String(options.limit));
+  }
+  const qs = params.toString();
+  return client.get(`/trending${qs ? `?${qs}` : ""}`);
+}
+
+// src/commands/search.ts
+var searchCommand = new Command16("search").description("Search for agents in the registry").argument("<query>", "Search query").option("-l, --limit <n>", "Maximum results to display", "20").option("-c, --category <category>", "Filter by category").option("-s, --sort <sort>", "Sort order: downloads, stars, newest", "downloads").option("--json", "Output as JSON").addHelpText("after", `
+Examples:
+  $ agentx search "data analysis"
+  $ agentx search email --category productivity
+  $ agentx search code --sort stars --limit 10`).action(
+  async (query, options) => {
+    try {
+      const limit = parseInt(options.limit, 10) || 20;
+      const response = await searchAgents(query, {
+        limit,
+        category: options.category,
+        sort: options.sort
+      });
+      if (options.json) {
+        console.log(JSON.stringify(response, null, 2));
+        return;
+      }
+      if (response.agents.length === 0) {
+        console.log(colors.dim(`  No agents found for "${query}".`));
+        return;
+      }
+      console.log();
+      console.log(
+        `  Found ${colors.bold(String(response.total))} agent${response.total === 1 ? "" : "s"} matching "${query}"`
+      );
+      console.log();
+      const table = formatTable(
+        [
+          { key: "name", label: "Name", width: 30 },
+          { key: "description", label: "Description", width: 40 },
+          { key: "version", label: "Version", width: 10 },
+          { key: "downloads", label: "DL", width: 8, align: "right" },
+          { key: "stars", label: "Stars", width: 6, align: "right" }
+        ],
+        response.agents.map((a) => ({
+          name: `${a.scope}/${a.name}`,
+          description: a.description,
+          version: a.latest_version,
+          downloads: String(a.download_count),
+          stars: String(a.star_count)
+        }))
+      );
+      console.log(
+        table.split("\n").map((line) => `  ${line}`).join("\n")
+      );
+      console.log();
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(colors.error(`Error: ${error.message}`));
+      }
+      process.exit(1);
+    }
+  }
+);
+
+// src/commands/trending.ts
+import { Command as Command17 } from "commander";
+var trendingCommand = new Command17("trending").description("Show trending agents").option("-p, --period <period>", "Time period: day, week, month", "week").option("-l, --limit <n>", "Maximum results to display", "20").option("--json", "Output as JSON").addHelpText("after", `
+Examples:
+  $ agentx trending
+  $ agentx trending --period month
+  $ agentx trending --period day --limit 5`).action(
+  async (options) => {
+    try {
+      const limit = parseInt(options.limit, 10) || 20;
+      const response = await getTrending({
+        period: options.period,
+        limit
+      });
+      if (options.json) {
+        console.log(JSON.stringify(response, null, 2));
+        return;
+      }
+      if (response.agents.length === 0) {
+        console.log(colors.dim("  No trending agents found."));
+        return;
+      }
+      const periodLabel = options.period === "day" ? "today" : options.period === "month" ? "this month" : "this week";
+      console.log();
+      console.log(`  ${colors.bold("Trending agents")} ${colors.dim(periodLabel)}`);
+      console.log();
+      const table = formatTable(
+        [
+          { key: "rank", label: "#", width: 4, align: "right" },
+          { key: "name", label: "Name", width: 30 },
+          { key: "description", label: "Description", width: 40 },
+          { key: "downloads", label: "DL", width: 8, align: "right" },
+          { key: "stars", label: "Stars", width: 6, align: "right" }
+        ],
+        response.agents.map((a, i) => ({
+          rank: String(i + 1),
+          name: `${a.scope}/${a.name}`,
+          description: a.description,
+          downloads: String(a.download_count),
+          stars: String(a.star_count)
+        }))
+      );
+      console.log(
+        table.split("\n").map((line) => `  ${line}`).join("\n")
+      );
+      console.log();
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(colors.error(`Error: ${error.message}`));
+      }
+      process.exit(1);
+    }
+  }
+);
+
+// src/commands/config.ts
+import { Command as Command18 } from "commander";
+var VALID_KEYS = Object.keys(globalConfigSchema.shape);
+function formatValue(value) {
+  if (typeof value === "object" && value !== null) {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function parseValue(key, raw) {
+  if (key === "telemetry" || key === "auto_update") {
+    if (raw === "true") return true;
+    if (raw === "false") return false;
+    throw new Error(`Value for "${key}" must be "true" or "false"`);
+  }
+  if (key === "default_output") {
+    if (raw === "text" || raw === "json") return raw;
+    throw new Error(`Value for "${key}" must be "text" or "json"`);
+  }
+  if (key === "claude_defaults") {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      throw new Error(`Value for "${key}" must be valid JSON`);
+    }
+  }
+  return raw;
+}
+var configCommand = new Command18("config").description("Manage global agentx configuration").addHelpText("after", `
+Examples:
+  $ agentx config list              Show all config values
+  $ agentx config get registry      Get a specific value
+  $ agentx config set telemetry false  Set a config value
+  $ agentx config path              Show config file path
+  $ agentx config reset             Reset to defaults`);
+configCommand.command("list").description("Show all configuration values").option("--json", "Output as JSON").action((options) => {
+  try {
+    const config = loadGlobalConfig();
+    if (options.json) {
+      console.log(JSON.stringify(config, null, 2));
+    } else {
+      console.log(colors.bold("agentx configuration:\n"));
+      for (const [key, value] of Object.entries(config)) {
+        console.log(`  ${colors.cyan(key)}: ${formatValue(value)}`);
+      }
+      console.log(`
+  ${colors.dim(`Config file: ${CONFIG_PATH}`)}`);
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+configCommand.command("get").description("Get a configuration value").argument("<key>", `Config key (${VALID_KEYS.join(", ")})`).action((key) => {
+  try {
+    if (!VALID_KEYS.includes(key)) {
+      console.error(colors.error(`Unknown config key: "${key}"`));
+      console.error(colors.dim(`Valid keys: ${VALID_KEYS.join(", ")}`));
+      process.exit(1);
+    }
+    const value = getConfigValue(key);
+    console.log(formatValue(value));
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+configCommand.command("set").description("Set a configuration value").argument("<key>", `Config key (${VALID_KEYS.join(", ")})`).argument("<value>", "Value to set").action((key, raw) => {
+  try {
+    if (!VALID_KEYS.includes(key)) {
+      console.error(colors.error(`Unknown config key: "${key}"`));
+      console.error(colors.dim(`Valid keys: ${VALID_KEYS.join(", ")}`));
+      process.exit(1);
+    }
+    const value = parseValue(key, raw);
+    setConfigValue(key, value);
+    console.log(colors.success(`Set ${colors.cyan(key)} = ${formatValue(value)}`));
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+configCommand.command("path").description("Show the config file path").action(() => {
+  console.log(CONFIG_PATH);
+});
+configCommand.command("reset").description("Reset configuration to defaults").action(() => {
+  try {
+    const defaults = globalConfigSchema.parse({});
+    saveGlobalConfig(defaults);
+    console.log(colors.success("Configuration reset to defaults."));
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(colors.error(`Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+var __filename3 = fileURLToPath2(import.meta.url);
+var __dirname3 = dirname2(__filename3);
+var pkg = JSON.parse(readFileSync12(join17(__dirname3, "..", "package.json"), "utf-8"));
+var program = new Command19();
+program.name("agentx").description("The package manager for AI agents powered by Claude Code").version(pkg.version).option("--verbose", "Show verbose output").option("--debug", "Show debug output including stack traces").hook("preAction", (_thisCommand, actionCommand) => {
+  const opts = program.opts();
+  if (opts.verbose) {
+    process.env.AGENTX_VERBOSE = "1";
+  }
+  if (opts.debug) {
+    process.env.AGENTX_DEBUG = "1";
+    process.env.AGENTX_VERBOSE = "1";
+  }
+});
+program.addCommand(runCommand);
+program.addCommand(configureCommand);
+program.addCommand(initCommand);
+program.addCommand(validateCommand);
+program.addCommand(testCommand);
+program.addCommand(doctorCommand);
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(publishCommand);
+program.addCommand(installCommand);
+program.addCommand(uninstallCommand);
+program.addCommand(listCommand);
+program.addCommand(updateCommand);
+program.addCommand(infoCommand);
+program.addCommand(searchCommand);
+program.addCommand(trendingCommand);
+program.addCommand(configCommand);
+program.parse();
+export {
+  program
+};