@arvoretech/hub 0.1.0

package/dist/index.js

@@ -0,0 +1,3271 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command16 } from "commander";
+
+// src/commands/init.ts
+import { Command } from "commander";
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+import { stringify } from "yaml";
+import chalk from "chalk";
+var SCHEMA_COMMENT = "# yaml-language-server: $schema=https://raw.githubusercontent.com/arvoreeducacao/rhm/main/schemas/hub.schema.json\n";
+var DEFAULT_HUB_CONFIG = {
+  name: "",
+  description: "",
+  repos: [],
+  services: [],
+  mcps: [],
+  integrations: {
+    github: {
+      pr_branch_pattern: "{linear_id}-{slug}"
+    },
+    slack: {
+      channels: {
+        prs: "#eng-prs"
+      }
+    }
+  },
+  workflow: {
+    task_folder: "./tasks/{task_id}/",
+    pipeline: [
+      { step: "refinement", agent: "refinement", output: "refinement.md" },
+      {
+        step: "coding",
+        agents: ["coding-backend", "coding-frontend"],
+        parallel: true
+      },
+      { step: "review", agent: "code-reviewer", output: "code-review.md" },
+      {
+        step: "qa",
+        agents: ["qa-backend", "qa-frontend"],
+        parallel: true,
+        tools: ["playwright"]
+      },
+      {
+        step: "deliver",
+        actions: ["create-pr", "notify-slack"]
+      }
+    ]
+  }
+};
+var initCommand = new Command("init").description("Initialize a new Repo Hub workspace").argument("[name]", "Hub name", "my-hub").action(async (name) => {
+  const hubDir = join(process.cwd(), name);
+  console.log(chalk.blue(`
+Initializing Repo Hub: ${name}
+`));
+  await mkdir(hubDir, { recursive: true });
+  await mkdir(join(hubDir, "tasks"), { recursive: true });
+  const config = { ...DEFAULT_HUB_CONFIG, name };
+  await writeFile(
+    join(hubDir, "hub.yaml"),
+    SCHEMA_COMMENT + stringify(config),
+    "utf-8"
+  );
+  const gitignore = [
+    "node_modules/",
+    ".DS_Store",
+    "",
+    "# Repositories (managed by hub)",
+    "# Add repos here as you add them with: hub add-repo",
+    "",
+    "# Docker volumes",
+    "*_data/",
+    "",
+    "# Environment files",
+    "*.env",
+    "*.env.local",
+    "!.env.example",
+    "",
+    "# Task documents",
+    "tasks/",
+    ""
+  ].join("\n");
+  await writeFile(join(hubDir, ".gitignore"), gitignore, "utf-8");
+  const readme = [
+    `# ${name}`,
+    "",
+    `Powered by [Repo Hub](https://github.com/arvoreeducacao/rhm).`,
+    "",
+    "## Getting Started",
+    "",
+    "```bash",
+    "# Add repositories",
+    "npx @arvoretech/hub add-repo git@github.com:org/api.git",
+    "npx @arvoretech/hub add-repo git@github.com:org/frontend.git",
+    "",
+    "# Setup workspace",
+    "npx @arvoretech/hub setup",
+    "",
+    "# Generate editor configs",
+    "npx @arvoretech/hub generate --editor cursor",
+    "```",
+    ""
+  ].join("\n");
+  await writeFile(join(hubDir, "README.md"), readme, "utf-8");
+  console.log(chalk.green("  Created hub.yaml"));
+  console.log(chalk.green("  Created .gitignore"));
+  console.log(chalk.green("  Created README.md"));
+  console.log();
+  console.log(chalk.cyan("Next steps:"));
+  console.log(`  cd ${name}`);
+  console.log("  npx @arvoretech/hub add-repo <git-url>");
+  console.log("  npx @arvoretech/hub setup");
+  console.log("  npx @arvoretech/hub generate --editor cursor");
+  console.log();
+});
+
+// src/commands/add-repo.ts
+import { Command as Command2 } from "commander";
+import { existsSync } from "fs";
+import { readFile, writeFile as writeFile2, appendFile } from "fs/promises";
+import { join as join2, basename } from "path";
+import { parse, stringify as stringify2 } from "yaml";
+import chalk2 from "chalk";
+var SCHEMA_COMMENT2 = "# yaml-language-server: $schema=https://raw.githubusercontent.com/arvoreeducacao/rhm/main/schemas/hub.schema.json\n";
+var addRepoCommand = new Command2("add-repo").description("Add a repository to the hub").argument("<url>", "Git repository URL").option("-n, --name <name>", "Repository name (defaults to repo name from URL)").option("-t, --tech <tech>", "Technology (nestjs, nextjs, elixir, react, etc)").action(async (url, opts) => {
+  const hubDir = process.cwd();
+  const configPath = join2(hubDir, "hub.yaml");
+  const content = await readFile(configPath, "utf-8");
+  const config = parse(content);
+  const repoName = opts.name || basename(url).replace(/\.git$/, "");
+  const repoPath = `./${repoName}`;
+  if (config.repos.some((r) => r.name === repoName)) {
+    console.log(chalk2.yellow(`Repository ${repoName} already exists in hub.yaml`));
+    return;
+  }
+  config.repos.push({
+    name: repoName,
+    path: repoPath,
+    url,
+    ...opts.tech && { tech: opts.tech }
+  });
+  const header = content.startsWith("# yaml-language-server") ? "" : SCHEMA_COMMENT2;
+  await writeFile2(configPath, header + stringify2(config), "utf-8");
+  const gitignorePath = join2(hubDir, ".gitignore");
+  await appendFile(gitignorePath, `${repoName}
+`);
+  const cursorignorePath = join2(hubDir, ".cursorignore");
+  if (existsSync(cursorignorePath)) {
+    await appendFile(cursorignorePath, `!${repoName}/
+`);
+    console.log(chalk2.cyan("  Updated: .cursorignore"));
+  }
+  console.log(chalk2.green(`
+Added ${repoName} to hub`));
+  console.log(chalk2.cyan("  Updated: hub.yaml"));
+  console.log(chalk2.cyan("  Updated: .gitignore"));
+  console.log();
+  console.log(`Run ${chalk2.bold("npx @arvoretech/hub setup")} to clone and install.`);
+  console.log();
+});
+
+// src/commands/setup.ts
+import { Command as Command3 } from "commander";
+import { existsSync as existsSync2 } from "fs";
+import { writeFile as writeFile3 } from "fs/promises";
+import { join as join4 } from "path";
+import { execSync } from "child_process";
+import chalk3 from "chalk";
+
+// src/core/hub-config.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join3 } from "path";
+import { parse as parse2 } from "yaml";
+async function loadHubConfig(dir) {
+  const configPath = join3(dir, "hub.yaml");
+  const content = await readFile2(configPath, "utf-8");
+  return parse2(content);
+}
+
+// src/core/docker-compose.ts
+import { stringify as stringify3 } from "yaml";
+function generateDockerCompose(services) {
+  const compose = {
+    services: {}
+  };
+  const svcMap = compose.services;
+  for (const svc of services) {
+    const entry = {
+      image: svc.image,
+      restart: "unless-stopped"
+    };
+    if (svc.port) {
+      entry.ports = [`${svc.port}:${svc.port}`];
+    } else if (svc.ports?.length) {
+      entry.ports = svc.ports.map((p) => `${p}:${p}`);
+    }
+    if (svc.env) {
+      entry.environment = svc.env;
+    }
+    entry.volumes = [`${svc.name}_data:/var/lib/${guessDataDir(svc.image)}`];
+    svcMap[svc.name] = entry;
+  }
+  const volumes = {};
+  for (const svc of services) {
+    volumes[`${svc.name}_data`] = null;
+  }
+  compose.volumes = volumes;
+  return stringify3(compose, { lineWidth: 120 });
+}
+function guessDataDir(image) {
+  const img = image.split(":")[0].split("/").pop() || "";
+  if (img.includes("mysql") || img.includes("mariadb")) return "mysql";
+  if (img.includes("postgres")) return "postgresql/data";
+  if (img.includes("redis")) return "redis";
+  if (img.includes("elasticsearch") || img.includes("opensearch")) return "elasticsearch";
+  if (img.includes("qdrant")) return "qdrant";
+  if (img.includes("mongo")) return "mongo";
+  return img;
+}
+
+// src/commands/setup.ts
+function run(cmd, cwd) {
+  execSync(cmd, { stdio: "inherit", cwd });
+}
+function runSilent(cmd, _cwd) {
+  return execSync(cmd, { encoding: "utf-8", cwd: _cwd, stdio: ["pipe", "pipe", "pipe"] }).trim();
+}
+function canSsh() {
+  try {
+    const out = runSilent("ssh -T git@github.com 2>&1 || true");
+    return out.includes("successfully authenticated");
+  } catch {
+    return false;
+  }
+}
+function hasGh() {
+  try {
+    runSilent("gh auth status");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasMise() {
+  try {
+    runSilent("mise --version");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function generateMiseToml(tools, settings) {
+  const lines = ["[tools]"];
+  for (const [tool, version] of Object.entries(tools)) {
+    lines.push(`${tool} = "${version}"`);
+  }
+  if (settings && Object.keys(settings).length > 0) {
+    lines.push("", "[settings]");
+    for (const [key, value] of Object.entries(settings)) {
+      if (typeof value === "boolean") lines.push(`${key} = ${value}`);
+      else if (typeof value === "string") lines.push(`${key} = "${value}"`);
+      else if (typeof value === "number") lines.push(`${key} = ${value}`);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+var setupCommand = new Command3("setup").description("Clone repos, start services, install tools, and install dependencies").option("--skip-services", "Skip Docker services").option("--skip-install", "Skip dependency installation").option("--skip-tools", "Skip tool installation via mise").action(async (opts) => {
+  const hubDir = process.cwd();
+  const config = await loadHubConfig(hubDir);
+  const useGh = !canSsh() && hasGh();
+  const hasTools = config.tools || config.repos.some((r) => r.tools);
+  const totalSteps = hasTools && !opts.skipTools ? 5 : 4;
+  let step = 1;
+  console.log(chalk3.blue(`
+\u2501\u2501\u2501 Step ${step}/${totalSteps}: Cloning repositories \u2501\u2501\u2501
+`));
+  for (const repo of config.repos) {
+    const fullPath = join4(hubDir, repo.path);
+    console.log(chalk3.yellow(`\u25B8 ${repo.name}`));
+    if (existsSync2(fullPath)) {
+      console.log(chalk3.green("  Already exists, skipping"));
+      continue;
+    }
+    if (useGh) {
+      const slug = repo.url.replace("git@github.com:", "").replace(".git", "");
+      run(`gh repo clone ${slug} ${fullPath}`);
+    } else {
+      run(`git clone ${repo.url} ${fullPath}`);
+    }
+    console.log(chalk3.green("  Cloned"));
+  }
+  step++;
+  if (!opts.skipServices && config.services?.length) {
+    console.log(chalk3.blue(`
+\u2501\u2501\u2501 Step ${step}/${totalSteps}: Starting services \u2501\u2501\u2501
+`));
+    const composePath = join4(hubDir, "docker-compose.yml");
+    const composeContent = generateDockerCompose(config.services);
+    await writeFile3(composePath, composeContent, "utf-8");
+    console.log(chalk3.green("  Generated docker-compose.yml"));
+    run("docker compose up -d", hubDir);
+    console.log(chalk3.green("  Services started"));
+    for (const svc of config.services) {
+      const port = svc.port || svc.ports?.[0];
+      if (port) {
+        console.log(chalk3.cyan(`  ${svc.name}: localhost:${port}`));
+      }
+    }
+  } else {
+    console.log(chalk3.blue(`
+\u2501\u2501\u2501 Step ${step}/${totalSteps}: Services (skipped) \u2501\u2501\u2501
+`));
+  }
+  step++;
+  if (hasTools && !opts.skipTools) {
+    console.log(chalk3.blue(`
+\u2501\u2501\u2501 Step ${step}/${totalSteps}: Installing tools \u2501\u2501\u2501
+`));
+    if (!hasMise()) {
+      console.log(chalk3.yellow("  mise not installed, skipping tool installation"));
+      console.log(chalk3.cyan("  Install mise: curl https://mise.run | sh"));
+    } else {
+      if (config.tools && Object.keys(config.tools).length > 0) {
+        const content = generateMiseToml(config.tools, config.mise_settings);
+        await writeFile3(join4(hubDir, ".mise.toml"), content, "utf-8");
+        console.log(chalk3.green(`  Generated .mise.toml (${Object.keys(config.tools).length} tools)`));
+        try {
+          run("mise trust && mise install", hubDir);
+          console.log(chalk3.green("  Hub tools installed"));
+        } catch {
+          console.log(chalk3.red("  Failed to install hub tools"));
+        }
+      }
+      for (const repo of config.repos) {
+        if (!repo.tools || Object.keys(repo.tools).length === 0) continue;
+        const repoDir = join4(hubDir, repo.path);
+        if (!existsSync2(repoDir)) continue;
+        const merged = { ...config.tools || {}, ...repo.tools };
+        const content = generateMiseToml(merged);
+        await writeFile3(join4(repoDir, ".mise.toml"), content, "utf-8");
+        console.log(chalk3.yellow(`\u25B8 ${repo.name}`));
+        try {
+          run("mise trust 2>/dev/null; mise install", repoDir);
+          console.log(chalk3.green("  Tools installed"));
+        } catch {
+          console.log(chalk3.red("  Failed to install tools"));
+        }
+      }
+    }
+    step++;
+  }
+  console.log(chalk3.blue(`
+\u2501\u2501\u2501 Step ${step}/${totalSteps}: Generating environment files \u2501\u2501\u2501
+`));
+  for (const repo of config.repos) {
+    if (!repo.env_file) continue;
+    const envPath = join4(hubDir, repo.path, repo.env_file);
+    const overrides = config.env?.overrides?.["local"]?.[repo.name];
+    if (overrides) {
+      const dir = join4(hubDir, repo.path);
+      if (existsSync2(dir)) {
+        const lines = Object.entries(overrides).map(([k, v]) => `${k}=${v}`);
+        await writeFile3(envPath, lines.join("\n") + "\n", "utf-8");
+        console.log(chalk3.green(`  ${repo.name}: Created ${repo.env_file} (${lines.length} vars)`));
+      }
+    } else {
+      console.log(chalk3.dim(`  ${repo.name}: No local overrides`));
+    }
+  }
+  step++;
+  if (!opts.skipInstall) {
+    console.log(chalk3.blue(`
+\u2501\u2501\u2501 Step ${step}/${totalSteps}: Installing dependencies \u2501\u2501\u2501
+`));
+    for (const repo of config.repos) {
+      const fullPath = join4(hubDir, repo.path);
+      if (!existsSync2(fullPath)) continue;
+      const installCmd = repo.commands?.install;
+      if (!installCmd) {
+        console.log(chalk3.dim(`  ${repo.name}: No install command`));
+        continue;
+      }
+      console.log(chalk3.yellow(`\u25B8 ${repo.name}`));
+      try {
+        run(installCmd, fullPath);
+        console.log(chalk3.green("  Installed"));
+      } catch {
+        console.log(chalk3.red(`  Failed: ${installCmd}`));
+      }
+    }
+  } else {
+    console.log(chalk3.blue(`
+\u2501\u2501\u2501 Step ${step}/${totalSteps}: Install (skipped) \u2501\u2501\u2501
+`));
+  }
+  console.log(chalk3.blue("\n\u2501\u2501\u2501 Setup complete \u2501\u2501\u2501\n"));
+  console.log("Next steps:");
+  console.log(`  npx @arvoretech/hub generate --editor cursor`);
+  console.log(`  Open the project in Cursor and start building`);
+  console.log();
+});
+
+// src/commands/generate.ts
+import { Command as Command4 } from "commander";
+import { existsSync as existsSync3 } from "fs";
+import { mkdir as mkdir2, writeFile as writeFile4, readdir, copyFile, readFile as readFile3, cp } from "fs/promises";
+import { join as join5, resolve } from "path";
+import chalk4 from "chalk";
+var HUB_MARKER_START = "# >>> hub-managed (do not edit this section)";
+var HUB_MARKER_END = "# <<< hub-managed";
+var HOOK_EVENT_MAP = {
+  session_start: { cursor: "sessionStart", claude: "SessionStart", kiro: void 0 },
+  session_end: { cursor: "sessionEnd", claude: "SessionEnd", kiro: void 0 },
+  pre_tool_use: { cursor: "preToolUse", claude: "PreToolUse", kiro: "pre_tool_use" },
+  post_tool_use: { cursor: "postToolUse", claude: "PostToolUse", kiro: "post_tool_use" },
+  post_tool_use_failure: { cursor: void 0, claude: "PostToolUseFailure", kiro: void 0 },
+  stop: { cursor: "stop", claude: "Stop", kiro: "agent_stop" },
+  subagent_start: { cursor: "subagentStart", claude: "SubagentStart", kiro: void 0 },
+  subagent_stop: { cursor: "subagentStop", claude: "SubagentStop", kiro: void 0 },
+  pre_compact: { cursor: "preCompact", claude: "PreCompact", kiro: void 0 },
+  before_submit_prompt: { cursor: "beforeSubmitPrompt", claude: "UserPromptSubmit", kiro: "prompt_submit" },
+  before_shell_execution: { cursor: "beforeShellExecution", claude: void 0, kiro: void 0 },
+  after_shell_execution: { cursor: "afterShellExecution", claude: void 0, kiro: void 0 },
+  before_mcp_execution: { cursor: "beforeMCPExecution", claude: void 0, kiro: void 0 },
+  after_mcp_execution: { cursor: "afterMCPExecution", claude: void 0, kiro: void 0 },
+  after_file_edit: { cursor: "afterFileEdit", claude: void 0, kiro: "file_save" },
+  before_read_file: { cursor: "beforeReadFile", claude: void 0, kiro: void 0 },
+  before_tab_file_read: { cursor: "beforeTabFileRead", claude: void 0, kiro: void 0 },
+  after_tab_file_edit: { cursor: "afterTabFileEdit", claude: void 0, kiro: void 0 },
+  after_agent_response: { cursor: "afterAgentResponse", claude: void 0, kiro: void 0 },
+  after_agent_thought: { cursor: "afterAgentThought", claude: void 0, kiro: void 0 },
+  notification: { cursor: void 0, claude: "Notification", kiro: void 0 },
+  permission_request: { cursor: void 0, claude: "PermissionRequest", kiro: void 0 },
+  task_completed: { cursor: void 0, claude: "TaskCompleted", kiro: void 0 },
+  teammate_idle: { cursor: void 0, claude: "TeammateIdle", kiro: void 0 }
+};
+function buildCursorHooks(hooks) {
+  const cursorHooks = {};
+  for (const [event, entries] of Object.entries(hooks)) {
+    const mapped = HOOK_EVENT_MAP[event]?.cursor;
+    if (!mapped) continue;
+    const cursorEntries = entries.map((entry) => {
+      const obj = { type: entry.type };
+      if (entry.type === "command" && entry.command) obj.command = entry.command;
+      if (entry.type === "prompt" && entry.prompt) obj.prompt = entry.prompt;
+      if (entry.matcher) obj.matcher = entry.matcher;
+      if (entry.timeout_ms) obj.timeout = entry.timeout_ms;
+      return obj;
+    });
+    if (cursorEntries.length > 0) {
+      cursorHooks[mapped] = cursorEntries;
+    }
+  }
+  if (Object.keys(cursorHooks).length === 0) return null;
+  return { version: 1, hooks: cursorHooks };
+}
+function buildClaudeHooks(hooks) {
+  const claudeHooks = {};
+  for (const [event, entries] of Object.entries(hooks)) {
+    const mapped = HOOK_EVENT_MAP[event]?.claude;
+    if (!mapped) continue;
+    const claudeEntries = entries.map((entry) => {
+      const obj = { type: entry.type };
+      if (entry.type === "command" && entry.command) obj.command = entry.command;
+      if (entry.type === "prompt" && entry.prompt) obj.prompt = entry.prompt;
+      if (entry.matcher) obj.matcher = entry.matcher;
+      if (entry.timeout_ms) obj.timeout = entry.timeout_ms;
+      return obj;
+    });
+    if (claudeEntries.length > 0) {
+      claudeHooks[mapped] = claudeEntries;
+    }
+  }
+  if (Object.keys(claudeHooks).length === 0) return null;
+  return claudeHooks;
+}
+async function generateCursorCommands(config, hubDir, cursorDir) {
+  const commandsDir = join5(cursorDir, "commands");
+  let count = 0;
+  if (config.commands_dir) {
+    const srcDir = resolve(hubDir, config.commands_dir);
+    try {
+      const files = await readdir(srcDir);
+      const mdFiles = files.filter((f) => f.endsWith(".md"));
+      if (mdFiles.length > 0) {
+        await mkdir2(commandsDir, { recursive: true });
+        for (const file of mdFiles) {
+          await copyFile(join5(srcDir, file), join5(commandsDir, file));
+          count++;
+        }
+      }
+    } catch {
+      console.log(chalk4.yellow(`  Commands directory ${config.commands_dir} not found, skipping`));
+    }
+  }
+  if (config.commands) {
+    await mkdir2(commandsDir, { recursive: true });
+    for (const [name, filePath] of Object.entries(config.commands)) {
+      const src = resolve(hubDir, filePath);
+      const dest = join5(commandsDir, name.endsWith(".md") ? name : `${name}.md`);
+      try {
+        await copyFile(src, dest);
+        count++;
+      } catch {
+        console.log(chalk4.yellow(`  Command file ${filePath} not found, skipping`));
+      }
+    }
+  }
+  if (count > 0) {
+    console.log(chalk4.green(`  Copied ${count} commands to .cursor/commands/`));
+  }
+}
+async function writeManagedFile(filePath, managedLines) {
+  const managedBlock = [HUB_MARKER_START, ...managedLines, HUB_MARKER_END].join("\n");
+  if (existsSync3(filePath)) {
+    const existing = await readFile3(filePath, "utf-8");
+    const startIdx = existing.indexOf(HUB_MARKER_START);
+    const endIdx = existing.indexOf(HUB_MARKER_END);
+    if (startIdx !== -1 && endIdx !== -1) {
+      const before = existing.substring(0, startIdx);
+      const after = existing.substring(endIdx + HUB_MARKER_END.length);
+      await writeFile4(filePath, before + managedBlock + after, "utf-8");
+      return;
+    }
+    await writeFile4(filePath, managedBlock + "\n\n" + existing, "utf-8");
+    return;
+  }
+  await writeFile4(filePath, managedBlock + "\n", "utf-8");
+}
+async function generateCursor(config, hubDir) {
+  const cursorDir = join5(hubDir, ".cursor");
+  await mkdir2(join5(cursorDir, "rules"), { recursive: true });
+  await mkdir2(join5(cursorDir, "agents"), { recursive: true });
+  const gitignoreLines = buildGitignoreLines(config);
+  await writeManagedFile(join5(hubDir, ".gitignore"), gitignoreLines);
+  console.log(chalk4.green("  Generated .gitignore"));
+  const cursorignoreLines = [
+    "# Re-include repositories for AI context"
+  ];
+  for (const repo of config.repos) {
+    const repoDir = repo.path.replace("./", "");
+    cursorignoreLines.push(`!${repoDir}/`);
+  }
+  cursorignoreLines.push("", "# Re-include tasks for agent collaboration", "!tasks/");
+  await writeManagedFile(join5(hubDir, ".cursorignore"), cursorignoreLines);
+  console.log(chalk4.green("  Generated .cursorignore"));
+  if (config.mcps?.length) {
+    const mcpConfig = {};
+    for (const mcp of config.mcps) {
+      mcpConfig[mcp.name] = buildCursorMcpEntry(mcp);
+    }
+    await writeFile4(
+      join5(cursorDir, "mcp.json"),
+      JSON.stringify({ mcpServers: mcpConfig }, null, 2) + "\n",
+      "utf-8"
+    );
+    console.log(chalk4.green("  Generated .cursor/mcp.json"));
+  }
+  const orchestratorRule = buildOrchestratorRule(config);
+  await writeFile4(join5(cursorDir, "rules", "orchestrator.mdc"), orchestratorRule, "utf-8");
+  console.log(chalk4.green("  Generated .cursor/rules/orchestrator.mdc"));
+  const agentsDir = resolve(hubDir, "agents");
+  try {
+    const agentFiles = await readdir(agentsDir);
+    const mdFiles = agentFiles.filter((f) => f.endsWith(".md"));
+    for (const file of mdFiles) {
+      await copyFile(join5(agentsDir, file), join5(cursorDir, "agents", file));
+    }
+    console.log(chalk4.green(`  Copied ${mdFiles.length} agent definitions`));
+  } catch {
+    console.log(chalk4.yellow("  No agents/ directory found, skipping agent copy"));
+  }
+  const skillsDir = resolve(hubDir, "skills");
+  try {
+    const skillFolders = await readdir(skillsDir);
+    const cursorSkillsDir = join5(cursorDir, "skills");
+    await mkdir2(cursorSkillsDir, { recursive: true });
+    let count = 0;
+    for (const folder of skillFolders) {
+      const skillFile = join5(skillsDir, folder, "SKILL.md");
+      try {
+        await readFile3(skillFile);
+        const srcDir = join5(skillsDir, folder);
+        const targetDir = join5(cursorSkillsDir, folder);
+        await cp(srcDir, targetDir, { recursive: true });
+        count++;
+      } catch {
+      }
+    }
+    if (count > 0) {
+      console.log(chalk4.green(`  Copied ${count} skills`));
+    }
+  } catch {
+  }
+  if (config.hooks) {
+    const cursorHooks = buildCursorHooks(config.hooks);
+    if (cursorHooks) {
+      await writeFile4(
+        join5(cursorDir, "hooks.json"),
+        JSON.stringify(cursorHooks, null, 2) + "\n",
+        "utf-8"
+      );
+      console.log(chalk4.green("  Generated .cursor/hooks.json"));
+    }
+  }
+  await generateCursorCommands(config, hubDir, cursorDir);
+}
+function buildCursorMcpEntry(mcp) {
+  if (mcp.url) {
+    return { url: mcp.url, ...mcp.env && { env: mcp.env } };
+  }
+  if (mcp.image) {
+    const args = ["run", "-i", "--rm"];
+    if (mcp.env) {
+      for (const [key, value] of Object.entries(mcp.env)) {
+        args.push("-e", `${key}=${value}`);
+      }
+    }
+    args.push(mcp.image);
+    return { command: "docker", args };
+  }
+  return {
+    command: "npx",
+    args: ["-y", mcp.package],
+    ...mcp.env && { env: mcp.env }
+  };
+}
+function buildClaudeCodeMcpEntry(mcp) {
+  if (mcp.url) {
+    return { type: "http", url: mcp.url };
+  }
+  if (mcp.image) {
+    const args = ["run", "-i", "--rm"];
+    if (mcp.env) {
+      for (const [key, value] of Object.entries(mcp.env)) {
+        args.push("-e", `${key}=${value}`);
+      }
+    }
+    args.push(mcp.image);
+    return { command: "docker", args };
+  }
+  return {
+    command: "npx",
+    args: ["-y", mcp.package],
+    ...mcp.env && { env: mcp.env }
+  };
+}
+function buildKiroMcpEntry(mcp) {
+  if (mcp.url) {
+    return { url: mcp.url, ...mcp.env && { env: mcp.env } };
+  }
+  if (mcp.image) {
+    const args = ["run", "-i", "--rm"];
+    if (mcp.env) {
+      for (const [key, value] of Object.entries(mcp.env)) {
+        args.push("-e", `${key}=${value}`);
+      }
+    }
+    args.push(mcp.image);
+    return { command: "docker", args };
+  }
+  return {
+    command: "npx",
+    args: ["-y", mcp.package],
+    ...mcp.env && { env: mcp.env }
+  };
+}
+function buildKiroSteeringContent(content, inclusion = "always", meta) {
+  const frontMatter = ["---", `inclusion: ${inclusion}`];
+  if (meta?.name) frontMatter.push(`name: ${meta.name}`);
+  if (meta?.description) frontMatter.push(`description: ${meta.description}`);
+  frontMatter.push("---");
+  return `${frontMatter.join("\n")}
+
+${content}`;
+}
+function buildKiroOrchestratorRule(config) {
+  const taskFolder = config.workflow?.task_folder || "./tasks/<TASK_ID>/";
+  const steps = config.workflow?.pipeline || [];
+  const prompt = config.workflow?.prompt;
+  const sections = [];
+  sections.push(`# Orchestrator
+
+## Your Main Responsibility
+
+You are the development orchestrator. Your job is to ensure that any feature or task requested by the user is completed end-to-end by following a structured pipeline. You work as a single agent but follow specialized instructions from steering files for each phase of development.
+
+> **Note:** This workspace uses steering files in \`.kiro/steering/\` to provide role-specific instructions for each pipeline step. When a step says "follow the instructions from steering file X", read that file and apply its guidelines to the current task.`);
+  if (prompt?.prepend) {
+    sections.push(`
+${prompt.prepend.trim()}`);
+  }
+  if (config.integrations?.linear) {
+    const linear = config.integrations.linear;
+    sections.push(`
+## Task Management
+
+If the user doesn't have a task in their project management tool, create one using the Linear MCP.${linear.team ? ` Add it to the **${linear.team}** team.` : ""} Provide the link to the user so they can review and modify as needed.`);
+  }
+  sections.push(`
+## Repositories
+`);
+  for (const repo of config.repos) {
+    const parts = [`- **${repo.path}**`];
+    if (repo.description) parts.push(`\u2014 ${repo.description}`);
+    else if (repo.tech) parts.push(`\u2014 ${repo.tech}`);
+    if (repo.skills?.length) parts.push(`(skills: ${repo.skills.join(", ")})`);
+    sections.push(parts.join(" "));
+    if (repo.commands) {
+      const cmds = Object.entries(repo.commands).filter(([, v]) => v).map(([k, v]) => `\`${k}\`: \`${v}\``).join(", ");
+      if (cmds) sections.push(`  Commands: ${cmds}`);
+    }
+  }
+  if (prompt?.sections?.after_repositories) {
+    sections.push(`
+${prompt.sections.after_repositories.trim()}`);
+  }
+  const docStructure = buildDocumentStructure(steps, taskFolder);
+  sections.push(docStructure);
+  const pipelineSection = buildKiroPipelineSection(steps);
+  sections.push(pipelineSection);
+  if (prompt?.sections?.after_pipeline) {
+    sections.push(`
+${prompt.sections.after_pipeline.trim()}`);
+  }
+  if (config.integrations?.slack || config.integrations?.github) {
+    sections.push(buildDeliverySection(config));
+  }
+  if (prompt?.sections?.after_delivery) {
+    sections.push(`
+${prompt.sections.after_delivery.trim()}`);
+  }
+  sections.push(`
+## Troubleshooting and Debugging
+
+For bug reports or unexpected behavior, follow the debugging process from the \`agent-debugger.md\` steering file (if available), or:
+1. Collect context (symptoms, environment, timeline)
+2. Analyze logs and stack traces
+3. Form and test hypotheses systematically
+4. Identify the root cause
+5. Propose and implement the fix`);
+  if (prompt?.sections) {
+    const reservedKeys = /* @__PURE__ */ new Set(["after_repositories", "after_pipeline", "after_delivery"]);
+    for (const [name, content] of Object.entries(prompt.sections)) {
+      if (reservedKeys.has(name)) continue;
+      const title = name.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+      sections.push(`
+## ${title}
+
+${content.trim()}`);
+    }
+  }
+  if (prompt?.append) {
+    sections.push(`
+${prompt.append.trim()}`);
+  }
+  return sections.join("\n");
+}
+function buildKiroPipelineSection(steps) {
+  if (steps.length === 0) {
+    return `
+## Development Pipeline
+
+Since Kiro does not support sub-agents, follow each step sequentially, applying the guidelines from the corresponding steering file:
+
+1. **Refinement** \u2014 Read and follow \`agent-refinement.md\` steering file to collect requirements. Write output to the task document.
+2. **Coding** \u2014 Follow the coding steering files (\`agent-coding-backend.md\`, \`agent-coding-frontend.md\`) to implement the feature.
+3. **Review** \u2014 Follow \`agent-code-reviewer.md\` to review the implementation.
+4. **QA** \u2014 Follow \`agent-qa-backend.md\` and/or \`agent-qa-frontend.md\` to test.
+5. **Delivery** \u2014 Create PRs and notify the team.`;
+  }
+  const parts = [`
+## Development Pipeline
+
+Follow each step sequentially, applying the role-specific instructions from the corresponding steering file at each phase.
+`];
+  for (const step of steps) {
+    if (step.actions) {
+      parts.push(`### Delivery`);
+      parts.push(`After all validations pass, execute these actions:`);
+      for (const action of step.actions) {
+        parts.push(`- ${formatAction(action)}`);
+      }
+      continue;
+    }
+    const stepTitle = step.step.charAt(0).toUpperCase() + step.step.slice(1);
+    parts.push(`### ${stepTitle}`);
+    if (step.agent) {
+      parts.push(`Follow the instructions from the \`agent-${step.agent}.md\` steering file.${step.output ? ` Write output to \`${step.output}\`.` : ""}`);
+      if (step.step === "refinement") {
+        parts.push(`
+After completing the refinement, validate with the user:
+- If there are unanswered questions, ask the user one at a time
+- If the user requests adjustments, revisit the refinement
+- Do not proceed until the document is complete and approved by the user`);
+      }
+    }
+    if (Array.isArray(step.agents)) {
+      const agentList = step.agents.map((a) => {
+        if (typeof a === "string") return { agent: a };
+        return a;
+      });
+      parts.push(`Follow the instructions from these steering files sequentially:`);
+      for (const a of agentList) {
+        let line = `- \`agent-${a.agent}.md\``;
+        if (a.output) line += ` \u2192 write to \`${a.output}\``;
+        if (a.when) line += ` (when: ${a.when})`;
+        parts.push(line);
+      }
+      if (step.step === "coding" || step.step === "code" || step.step === "implementation") {
+        parts.push(`
+If you encounter doubts during coding, write questions in the task document and validate with the user before proceeding.`);
+      }
+      if (step.step === "validation" || step.step === "review" || step.step === "qa") {
+        parts.push(`
+If any validation step reveals issues requiring fixes, go back to the relevant coding step to address them.`);
+      }
+    }
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+function buildOrchestratorRule(config) {
+  const taskFolder = config.workflow?.task_folder || "./tasks/<TASK_ID>/";
+  const steps = config.workflow?.pipeline || [];
+  const prompt = config.workflow?.prompt;
+  const sections = [];
+  sections.push(`---
+description: "Orchestrator agent \u2014 coordinates sub-agents through the development pipeline"
+alwaysApply: true
+---
+
+# Orchestrator
+
+## Your Main Responsibility
+
+You are an agent orchestrator. Your job is to ensure that any feature or task requested by the user is completed end-to-end using specialized sub-agents.`);
+  if (prompt?.prepend) {
+    sections.push(`
+${prompt.prepend.trim()}`);
+  }
+  if (config.integrations?.linear) {
+    const linear = config.integrations.linear;
+    sections.push(`
+## Task Management
+
+If the user doesn't have a task in their project management tool, create one using the Linear MCP.${linear.team ? ` Add it to the **${linear.team}** team.` : ""} Provide the link to the user so they can review and modify as needed.`);
+  }
+  sections.push(`
+## Repositories
+`);
+  for (const repo of config.repos) {
+    const parts = [`- **${repo.path}**`];
+    if (repo.description) parts.push(`\u2014 ${repo.description}`);
+    else if (repo.tech) parts.push(`\u2014 ${repo.tech}`);
+    if (repo.skills?.length) parts.push(`(skills: ${repo.skills.join(", ")})`);
+    sections.push(parts.join(" "));
+    if (repo.commands) {
+      const cmds = Object.entries(repo.commands).filter(([, v]) => v).map(([k, v]) => `\`${k}\`: \`${v}\``).join(", ");
+      if (cmds) sections.push(`  Commands: ${cmds}`);
+    }
+  }
+  if (prompt?.sections?.after_repositories) {
+    sections.push(`
+${prompt.sections.after_repositories.trim()}`);
+  }
+  const docStructure = buildDocumentStructure(steps, taskFolder);
+  sections.push(docStructure);
+  const pipelineSection = buildPipelineSection(steps);
+  sections.push(pipelineSection);
+  if (prompt?.sections?.after_pipeline) {
+    sections.push(`
+${prompt.sections.after_pipeline.trim()}`);
+  }
+  if (config.integrations?.slack || config.integrations?.github) {
+    sections.push(buildDeliverySection(config));
+  }
+  if (prompt?.sections?.after_delivery) {
+    sections.push(`
+${prompt.sections.after_delivery.trim()}`);
+  }
+  sections.push(`
+## Troubleshooting and Debugging
+
+For bug reports or unexpected behavior, use the \`debugger\` agent directly.
+It will:
+1. Collect context (symptoms, environment, timeline)
+2. Analyze logs and stack traces
+3. Form and test hypotheses systematically
+4. Identify the root cause
+5. Propose a solution or call coding agents to implement the fix`);
+  if (prompt?.sections) {
+    const reservedKeys = /* @__PURE__ */ new Set(["after_repositories", "after_pipeline", "after_delivery"]);
+    for (const [name, content] of Object.entries(prompt.sections)) {
+      if (reservedKeys.has(name)) continue;
+      const title = name.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+      sections.push(`
+## ${title}
+
+${content.trim()}`);
+    }
+  }
+  if (prompt?.append) {
+    sections.push(`
+${prompt.append.trim()}`);
+  }
+  return sections.join("\n");
+}
+function buildDocumentStructure(steps, taskFolder) {
+  const outputs = [];
+  for (const step of steps) {
+    if (step.output) {
+      outputs.push(step.output);
+    }
+    if (Array.isArray(step.agents)) {
+      for (const a of step.agents) {
+        if (typeof a === "object" && a.output) {
+          outputs.push(a.output);
+        }
+      }
+    }
+  }
+  if (outputs.length === 0) {
+    outputs.push("refinement.md", "code-backend.md", "code-frontend.md", "code-review.md", "qa-backend.md", "qa-frontend.md");
+  }
+  const tree = outputs.map((o) => `\u251C\u2500\u2500 ${o}`);
+  if (tree.length > 0) {
+    tree[tree.length - 1] = tree[tree.length - 1].replace("\u251C\u2500\u2500", "\u2514\u2500\u2500");
+  }
+  return `
+## Document Structure
+
+All task documents are stored in \`${taskFolder}\`:
+
+\`\`\`
+${taskFolder}
+${tree.join("\n")}
+\`\`\``;
+}
+function buildPipelineSection(steps) {
+  if (steps.length === 0) {
+    return `
+## Development Pipeline
+
+1. Use the \`refinement\` agent to collect requirements
+2. Use \`coding-backend\` and/or \`coding-frontend\` agents to implement
+3. Use \`code-reviewer\` to review the implementation
+4. Use \`qa-backend\` and/or \`qa-frontend\` to test
+5. Create PRs and notify the team`;
+  }
+  const parts = [`
+## Development Pipeline
+`];
+  for (const step of steps) {
+    if (step.actions) {
+      parts.push(`### Delivery`);
+      parts.push(`After all validations pass, execute these actions:`);
+      for (const action of step.actions) {
+        parts.push(`- ${formatAction(action)}`);
+      }
+      continue;
+    }
+    const stepTitle = step.step.charAt(0).toUpperCase() + step.step.slice(1);
+    parts.push(`### ${stepTitle}`);
+    if (step.agent) {
+      parts.push(`Call the \`${step.agent}\` agent.${step.output ? ` It writes to \`${step.output}\`.` : ""}`);
+      if (step.step === "refinement") {
+        parts.push(`
+After it runs, read the document and validate with the user:
+- If there are unanswered questions, ask the user one at a time
+- If the user requests adjustments, send back to the refinement agent
+- Do not proceed until the document is complete and approved by the user`);
+      }
+    }
+    if (Array.isArray(step.agents)) {
+      const agentList = step.agents.map((a) => {
+        if (typeof a === "string") return { agent: a };
+        return a;
+      });
+      if (step.parallel) {
+        parts.push(`Call these agents${step.parallel ? " in parallel" : ""}:`);
+      } else {
+        parts.push(`Call these agents in sequence:`);
+      }
+      for (const a of agentList) {
+        let line = `- \`${a.agent}\``;
+        if (a.output) line += ` \u2192 writes to \`${a.output}\``;
+        if (a.when) line += ` (when: ${a.when})`;
+        parts.push(line);
+      }
+      if (step.step === "coding" || step.step === "code" || step.step === "implementation") {
+        parts.push(`
+If any coding agent has doubts, they will write questions in their document. Apply the same Q&A logic as refinement \u2014 validate with the user before proceeding.`);
+      }
+      if (step.step === "validation" || step.step === "review" || step.step === "qa") {
+        parts.push(`
+If any validation agent leaves comments requiring fixes, call the relevant coding agents again to address them.`);
+      }
+    }
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+function buildDeliverySection(config) {
+  const parts = [`
+## Delivery Details
+`];
+  if (config.integrations?.github) {
+    const gh = config.integrations.github;
+    parts.push(`### Pull Requests`);
+    parts.push(`For each repository with changes, push the branch and create a PR using the GitHub MCP.`);
+    if (gh.pr_branch_pattern) {
+      parts.push(`Branch naming pattern: \`${gh.pr_branch_pattern}\``);
+    }
+  }
+  if (config.integrations?.slack) {
+    const slack = config.integrations.slack;
+    if (slack.channels) {
+      parts.push(`
+### Slack Notifications`);
+      for (const [purpose, channel] of Object.entries(slack.channels)) {
+        parts.push(`- **${purpose}**: Post to \`${channel}\``);
+      }
+    }
+    if (slack.templates) {
+      parts.push(`
+Message templates:`);
+      for (const [name, template] of Object.entries(slack.templates)) {
+        parts.push(`- **${name}**: \`${template}\``);
+      }
+    }
+  }
+  if (config.integrations?.linear) {
+    parts.push(`
+### Task Management`);
+    parts.push(`Update the Linear task status after PR creation.`);
+  }
+  return parts.join("\n");
+}
+function formatAction(action) {
+  const map = {
+    "create-pr": "Create pull requests for each repository with changes",
+    "notify-slack": "Send notification to the configured Slack channel",
+    "notify-slack-prs": "Send PR notification to the Slack PRs channel",
+    "update-linear": "Update the Linear task status",
+    "update-linear-status": "Update the Linear task status to Review",
+    "update-jira": "Update the Jira task status"
+  };
+  return map[action] || action;
+}
+async function generateClaudeCode(config, hubDir) {
+  const claudeDir = join5(hubDir, ".claude");
+  await mkdir2(join5(claudeDir, "agents"), { recursive: true });
+  const orchestratorRule = buildOrchestratorRule(config);
+  const cleanedOrchestrator = orchestratorRule.replace(/^---[\s\S]*?---\n/m, "").trim();
+  const claudeMdSections = [];
+  claudeMdSections.push(cleanedOrchestrator);
+  const agentsDir = resolve(hubDir, "agents");
+  try {
+    const agentFiles = await readdir(agentsDir);
+    const mdFiles = agentFiles.filter((f) => f.endsWith(".md"));
+    for (const file of mdFiles) {
+      await copyFile(join5(agentsDir, file), join5(claudeDir, "agents", file));
+    }
+    console.log(chalk4.green(`  Copied ${mdFiles.length} agents to .claude/agents/`));
+  } catch {
+    console.log(chalk4.yellow("  No agents/ directory found, skipping agent copy"));
+  }
+  const skillsDir = resolve(hubDir, "skills");
+  try {
+    const skillFolders = await readdir(skillsDir);
+    const claudeSkillsDir = join5(claudeDir, "skills");
+    await mkdir2(claudeSkillsDir, { recursive: true });
+    let count = 0;
+    for (const folder of skillFolders) {
+      const skillFile = join5(skillsDir, folder, "SKILL.md");
+      try {
+        await readFile3(skillFile);
+        const srcDir = join5(skillsDir, folder);
+        const targetDir = join5(claudeSkillsDir, folder);
+        await cp(srcDir, targetDir, { recursive: true });
+        count++;
+      } catch {
+      }
+    }
+    if (count > 0) {
+      console.log(chalk4.green(`  Copied ${count} skills to .claude/skills/`));
+    }
+  } catch {
+  }
+  await writeFile4(join5(hubDir, "CLAUDE.md"), claudeMdSections.join("\n"), "utf-8");
+  console.log(chalk4.green("  Generated CLAUDE.md"));
+  if (config.mcps?.length) {
+    const mcpJson = {};
+    for (const mcp of config.mcps) {
+      mcpJson[mcp.name] = buildClaudeCodeMcpEntry(mcp);
+    }
+    await writeFile4(
+      join5(hubDir, ".mcp.json"),
+      JSON.stringify({ mcpServers: mcpJson }, null, 2) + "\n",
+      "utf-8"
+    );
+    console.log(chalk4.green("  Generated .mcp.json"));
+  }
+  const mcpServerNames = config.mcps?.map((m) => m.name) || [];
+  const claudeSettings = {
+    $schema: "https://json.schemastore.org/claude-code-settings.json",
+    permissions: {
+      allow: [
+        "Read(*)",
+        "Edit(*)",
+        "Write(*)",
+        "Bash(git *)",
+        "Bash(npm *)",
+        "Bash(pnpm *)",
+        "Bash(npx *)",
+        "Bash(ls *)",
+        "Bash(echo *)",
+        "Bash(grep *)",
+        ...mcpServerNames.map((name) => `mcp__${name}__*`)
+      ],
+      deny: [
+        "Read(.env)",
+        "Read(.env.*)",
+        "Read(**/.env)",
+        "Read(**/.env.*)",
+        "Read(**/credentials*)",
+        "Read(**/secrets*)",
+        "Read(**/*.pem)",
+        "Read(**/*.key)"
+      ]
+    },
+    enableAllProjectMcpServers: true
+  };
+  if (config.hooks) {
+    const claudeHooks = buildClaudeHooks(config.hooks);
+    if (claudeHooks) {
+      claudeSettings.hooks = claudeHooks;
+    }
+  }
+  await writeFile4(
+    join5(claudeDir, "settings.json"),
+    JSON.stringify(claudeSettings, null, 2) + "\n",
+    "utf-8"
+  );
+  console.log(chalk4.green("  Generated .claude/settings.json"));
+  const gitignoreLines = buildGitignoreLines(config);
+  await writeManagedFile(join5(hubDir, ".gitignore"), gitignoreLines);
+  console.log(chalk4.green("  Generated .gitignore"));
+}
+async function generateKiro(config, hubDir) {
+  const kiroDir = join5(hubDir, ".kiro");
+  const steeringDir = join5(kiroDir, "steering");
+  const settingsDir = join5(kiroDir, "settings");
+  await mkdir2(steeringDir, { recursive: true });
+  await mkdir2(settingsDir, { recursive: true });
+  const gitignoreLines = buildGitignoreLines(config);
+  await writeManagedFile(join5(hubDir, ".gitignore"), gitignoreLines);
+  console.log(chalk4.green("  Generated .gitignore"));
+  const kiroRule = buildKiroOrchestratorRule(config);
+  const kiroOrchestrator = buildKiroSteeringContent(kiroRule);
+  await writeFile4(join5(steeringDir, "orchestrator.md"), kiroOrchestrator, "utf-8");
+  console.log(chalk4.green("  Generated .kiro/steering/orchestrator.md"));
+  await writeFile4(join5(hubDir, "AGENTS.md"), kiroRule + "\n", "utf-8");
+  console.log(chalk4.green("  Generated AGENTS.md"));
+  const agentsDir = resolve(hubDir, "agents");
+  try {
+    const agentFiles = await readdir(agentsDir);
+    const mdFiles = agentFiles.filter((f) => f.endsWith(".md"));
+    for (const file of mdFiles) {
+      const agentContent = await readFile3(join5(agentsDir, file), "utf-8");
+      const agentName = file.replace(/\.md$/, "");
+      const steeringContent = buildKiroSteeringContent(agentContent, "auto", {
+        name: agentName,
+        description: `Role-specific instructions for the ${agentName} phase. Include when working on ${agentName}-related tasks.`
+      });
+      const steeringName = `agent-${file}`;
+      await writeFile4(join5(steeringDir, steeringName), steeringContent, "utf-8");
+    }
+    console.log(chalk4.green(`  Copied ${mdFiles.length} agents as steering files`));
+  } catch {
+    console.log(chalk4.yellow("  No agents/ directory found, skipping agent copy"));
+  }
+  const skillsDir = resolve(hubDir, "skills");
+  try {
+    const skillFolders = await readdir(skillsDir);
+    const kiroSkillsDir = join5(kiroDir, "skills");
+    await mkdir2(kiroSkillsDir, { recursive: true });
+    let count = 0;
+    for (const folder of skillFolders) {
+      const skillFile = join5(skillsDir, folder, "SKILL.md");
+      try {
+        await readFile3(skillFile);
+        const srcDir = join5(skillsDir, folder);
+        const targetDir = join5(kiroSkillsDir, folder);
+        await cp(srcDir, targetDir, { recursive: true });
+        count++;
+      } catch {
+      }
+    }
+    if (count > 0) {
+      console.log(chalk4.green(`  Copied ${count} skills to .kiro/skills/`));
+    }
+  } catch {
+  }
+  if (config.mcps?.length) {
+    const mcpConfig = {};
+    for (const mcp of config.mcps) {
+      mcpConfig[mcp.name] = buildKiroMcpEntry(mcp);
+    }
+    await writeFile4(
+      join5(settingsDir, "mcp.json"),
+      JSON.stringify({ mcpServers: mcpConfig }, null, 2) + "\n",
+      "utf-8"
+    );
+    console.log(chalk4.green("  Generated .kiro/settings/mcp.json"));
+  }
+  if (config.hooks) {
+    const hookNotes = [];
+    for (const [event, entries] of Object.entries(config.hooks)) {
+      const mapped = HOOK_EVENT_MAP[event]?.kiro;
+      if (!mapped) continue;
+      for (const entry of entries) {
+        hookNotes.push(`- **${mapped}**: ${entry.type === "command" ? entry.command : entry.prompt}`);
+      }
+    }
+    if (hookNotes.length > 0) {
+      console.log(chalk4.yellow(`  Note: Kiro hooks are managed via the Kiro panel UI.`));
+      console.log(chalk4.yellow(`  The following hooks should be configured manually:`));
+      for (const note of hookNotes) {
+        console.log(chalk4.yellow(`    ${note}`));
+      }
+    }
+  }
+}
+function buildGitignoreLines(config) {
+  const lines = [
+    "node_modules/",
+    ".DS_Store",
+    "",
+    "# Repositories (managed by hub)"
+  ];
+  for (const repo of config.repos) {
+    lines.push(repo.path.replace("./", ""));
+  }
+  lines.push(
+    "",
+    "# Docker volumes",
+    "*_data/",
+    "",
+    "# Environment files",
+    "*.env",
+    "*.env.local",
+    "!.env.example",
+    "",
+    "# Generated files",
+    "docker-compose.yml",
+    "",
+    "# Task documents",
+    "tasks/"
+  );
+  return lines;
+}
+var generators = {
+  cursor: { name: "Cursor", generate: generateCursor },
+  "claude-code": { name: "Claude Code", generate: generateClaudeCode },
+  kiro: { name: "Kiro", generate: generateKiro }
+};
+var generateCommand = new Command4("generate").description("Generate editor-specific configuration files from hub.yaml").option("-e, --editor <editor>", "Target editor (cursor, claude-code, kiro)", "cursor").action(async (opts) => {
+  const hubDir = process.cwd();
+  const config = await loadHubConfig(hubDir);
+  const generator = generators[opts.editor];
+  if (!generator) {
+    console.log(
+      chalk4.red(`Unknown editor: ${opts.editor}. Available: ${Object.keys(generators).join(", ")}`)
+    );
+    return;
+  }
+  console.log(chalk4.blue(`
+Generating ${generator.name} configuration
+`));
+  await generator.generate(config, hubDir);
+  console.log(chalk4.green("\nDone!\n"));
+});
+
+// src/commands/env.ts
+import { Command as Command5 } from "commander";
+import { existsSync as existsSync4 } from "fs";
+import { writeFile as writeFile5, readFile as readFile4 } from "fs/promises";
+import { join as join6 } from "path";
+import { execSync as execSync2 } from "child_process";
+import chalk5 from "chalk";
+var authenticatedProfiles = /* @__PURE__ */ new Set();
+function awsAuthenticated(profile) {
+  if (authenticatedProfiles.has(profile)) return true;
+  try {
+    execSync2(`AWS_PROFILE=${profile} aws sts get-caller-identity`, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    authenticatedProfiles.add(profile);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function fetchSecret(secretName, profile) {
+  try {
+    const raw = execSync2(
+      `AWS_PROFILE=${profile} aws secretsmanager get-secret-value --secret-id "${secretName}" --query SecretString --output text`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function resolveSecret(secretConfig, defaultProfile) {
+  if (typeof secretConfig === "string") {
+    return { secretName: secretConfig, profile: defaultProfile };
+  }
+  return {
+    secretName: secretConfig.secret,
+    profile: secretConfig.profile || defaultProfile
+  };
+}
+function buildDatabaseUrlFromSecret(secretData, buildConfig) {
+  const vars = buildConfig.vars || {};
+  const user = secretData[vars.user || "DB_USERNAME"];
+  const password = secretData[vars.password || "DB_PASSWORD"];
+  const host = secretData[vars.host || "DB_HOSTNAME"];
+  const port = secretData[vars.port || "DB_PORT"] || "3306";
+  const database = secretData[vars.database || "DB_NAME"];
+  if (!user || !host || !database) return null;
+  if (buildConfig.template) {
+    return buildConfig.template.replace("{user}", user).replace("{password}", password || "").replace("{host}", host).replace("{port}", port).replace("{database}", database);
+  }
+  return `mysql://${user}:${password || ""}@${host}:${port}/${database}`;
+}
+var envCommand = new Command5("env").description("Generate environment files from hub.yaml profiles").argument("[profile]", "Environment profile (local, staging, prod)", "local").action(async (profile) => {
+  const hubDir = process.cwd();
+  const config = await loadHubConfig(hubDir);
+  const profiles = config.env?.profiles;
+  if (!profiles) {
+    console.log(chalk5.yellow("\nNo env.profiles defined in hub.yaml\n"));
+    return;
+  }
+  const profileConfig = profiles[profile];
+  if (!profileConfig) {
+    const available = Object.keys(profiles).join(", ");
+    console.log(chalk5.red(`
+Unknown profile: ${profile}. Available: ${available}
+`));
+    return;
+  }
+  console.log(chalk5.blue(`
+\u2501\u2501\u2501 Generating environment files (${profile}) \u2501\u2501\u2501
+`));
+  const defaultAwsProfile = profileConfig.aws_profile || "";
+  const secrets = profileConfig.secrets || {};
+  const buildDbConfigs = profileConfig.build_database_url || {};
+  if (profile !== "local" && defaultAwsProfile) {
+    console.log(chalk5.cyan(`  Default AWS profile: ${defaultAwsProfile}`));
+    if (!awsAuthenticated(defaultAwsProfile)) {
+      console.log(chalk5.red(`  AWS profile ${defaultAwsProfile} not authenticated`));
+      console.log(chalk5.cyan(`  Run: aws sso login --profile ${defaultAwsProfile}`));
+      return;
+    }
+    console.log(chalk5.green(`  AWS authenticated`));
+  }
+  for (const repo of config.repos) {
+    if (!repo.env_file) continue;
+    const repoDir = join6(hubDir, repo.path);
+    if (!existsSync4(repoDir)) {
+      console.log(chalk5.dim(`  ${repo.name}: repo not cloned, skipping`));
+      continue;
+    }
+    console.log(chalk5.yellow(`\u25B8 ${repo.name}`));
+    const envVars = {};
+    if (profile !== "local" && secrets[repo.name]) {
+      const { secretName, profile: secretProfile } = resolveSecret(
+        secrets[repo.name],
+        defaultAwsProfile
+      );
+      if (!secretProfile) {
+        console.log(chalk5.red(`  No AWS profile available for secret: ${secretName}`));
+      } else {
+        if (!awsAuthenticated(secretProfile)) {
+          console.log(chalk5.red(`  AWS profile ${secretProfile} not authenticated`));
+          console.log(chalk5.cyan(`  Run: aws sso login --profile ${secretProfile}`));
+          continue;
+        }
+        console.log(chalk5.cyan(`  Fetching: ${secretName} (profile: ${secretProfile})`));
+        const secretData = fetchSecret(secretName, secretProfile);
+        if (secretData) {
+          Object.assign(envVars, secretData);
+          console.log(chalk5.green(`  Loaded ${Object.keys(secretData).length} vars from AWS`));
+        } else {
+          console.log(chalk5.red(`  Failed to fetch secret: ${secretName}`));
+        }
+      }
+    }
+    if (profile !== "local" && buildDbConfigs[repo.name]) {
+      const buildConfig = buildDbConfigs[repo.name];
+      const dbProfile = buildConfig.profile || defaultAwsProfile;
+      if (!dbProfile) {
+        console.log(chalk5.red(`  No AWS profile available for build_database_url`));
+      } else {
+        if (!awsAuthenticated(dbProfile)) {
+          console.log(chalk5.red(`  AWS profile ${dbProfile} not authenticated`));
+          console.log(chalk5.cyan(`  Run: aws sso login --profile ${dbProfile}`));
+        } else {
+          console.log(chalk5.cyan(`  Building DATABASE_URL from ${buildConfig.from_secret} (profile: ${dbProfile})`));
+          const dbSecretData = fetchSecret(buildConfig.from_secret, dbProfile);
+          if (dbSecretData) {
+            const dbUrl = buildDatabaseUrlFromSecret(dbSecretData, buildConfig);
+            if (dbUrl) {
+              envVars["DATABASE_URL"] = dbUrl;
+              envVars["IDENTITY_DATABASE_URL"] = dbUrl;
+              console.log(chalk5.green(`  Built DATABASE_URL from ${buildConfig.from_secret}`));
+            } else {
+              console.log(chalk5.red(`  Could not build DATABASE_URL - missing required fields`));
+            }
+          } else {
+            console.log(chalk5.red(`  Failed to fetch secret: ${buildConfig.from_secret}`));
+          }
+        }
+      }
+    }
+    const overrides = config.env?.overrides?.[profile]?.[repo.name];
+    if (overrides) {
+      for (const [key, value] of Object.entries(overrides)) {
+        envVars[key] = value;
+      }
+      console.log(chalk5.cyan(`  Applied ${Object.keys(overrides).length} overrides`));
+    }
+    const envPath = join6(repoDir, repo.env_file);
+    const existingVars = {};
+    try {
+      const existing = await readFile4(envPath, "utf-8");
+      for (const line of existing.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx > 0) {
+          existingVars[trimmed.slice(0, eqIdx)] = trimmed.slice(eqIdx + 1);
+        }
+      }
+    } catch {
+    }
+    const merged = { ...existingVars, ...envVars };
+    const lines = Object.entries(merged).map(([k, v]) => `${k}=${v}`);
+    await writeFile5(envPath, lines.join("\n") + "\n", "utf-8");
+    console.log(chalk5.green(`  Created ${repo.env_file} (${lines.length} vars)`));
+  }
+  console.log();
+  if (profile === "local") {
+    console.log(chalk5.cyan("Using local Docker services only"));
+    console.log(chalk5.cyan("Run: npx @arvoretech/hub services up"));
+  } else if (profile === "prod") {
+    console.log(chalk5.red("WARNING: Using PRODUCTION database!"));
+    console.log(chalk5.red("Be careful with write operations!"));
+  } else {
+    console.log(chalk5.cyan(`Using ${profile} environment`));
+  }
+  console.log();
+});
+
+// src/commands/services.ts
+import { Command as Command6 } from "commander";
+import { existsSync as existsSync5 } from "fs";
+import { writeFile as writeFile6 } from "fs/promises";
+import { join as join7 } from "path";
+import { execSync as execSync3 } from "child_process";
+import chalk6 from "chalk";
+async function ensureCompose(hubDir) {
+  const composePath = join7(hubDir, "docker-compose.yml");
+  if (!existsSync5(composePath)) {
+    const config = await loadHubConfig(hubDir);
+    if (!config.services?.length) {
+      console.log(chalk6.yellow("No services defined in hub.yaml"));
+      process.exit(1);
+    }
+    const content = generateDockerCompose(config.services);
+    await writeFile6(composePath, content, "utf-8");
+    console.log(chalk6.green("Generated docker-compose.yml"));
+  }
+  return composePath;
+}
+function isDockerRunning() {
+  try {
+    execSync3("docker info", { stdio: ["pipe", "pipe", "pipe"] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var servicesCommand = new Command6("services").description("Manage Docker development services").argument("[action]", "up, down, restart, ps, logs, clean", "up").argument("[service...]", "Specific services (for logs)").action(async (action, serviceNames) => {
+  if (!isDockerRunning()) {
+    console.log(chalk6.red("\nDocker daemon is not running."));
+    console.log(chalk6.dim("Start Docker Desktop or the Docker daemon and try again.\n"));
+    return;
+  }
+  const hubDir = process.cwd();
+  const composePath = await ensureCompose(hubDir);
+  const compose = `docker compose -f ${composePath}`;
+  try {
+    switch (action) {
+      case "up":
+      case "start": {
+        console.log(chalk6.blue("\nStarting services\n"));
+        execSync3(`${compose} up -d`, { stdio: "inherit", cwd: hubDir });
+        const config = await loadHubConfig(hubDir);
+        console.log(chalk6.green("\nServices running:"));
+        for (const svc of config.services || []) {
+          const port = svc.port || svc.ports?.[0];
+          if (port) console.log(chalk6.cyan(`  ${svc.name}: localhost:${port}`));
+        }
+        console.log();
+        break;
+      }
+      case "down":
+      case "stop":
+        console.log(chalk6.blue("\nStopping services\n"));
+        execSync3(`${compose} down`, { stdio: "inherit", cwd: hubDir });
+        console.log(chalk6.green("\nServices stopped\n"));
+        break;
+      case "restart":
+        execSync3(`${compose} restart`, { stdio: "inherit", cwd: hubDir });
+        console.log(chalk6.green("\nServices restarted\n"));
+        break;
+      case "ps":
+      case "status":
+        execSync3(`${compose} ps`, { stdio: "inherit", cwd: hubDir });
+        break;
+      case "logs":
+        if (serviceNames.length) {
+          execSync3(`${compose} logs -f ${serviceNames.join(" ")}`, { stdio: "inherit", cwd: hubDir });
+        } else {
+          execSync3(`${compose} logs -f`, { stdio: "inherit", cwd: hubDir });
+        }
+        break;
+      case "clean":
+        console.log(chalk6.blue("\nCleaning services (removing volumes)\n"));
+        execSync3(`${compose} down -v`, { stdio: "inherit", cwd: hubDir });
+        console.log(chalk6.green("\nServices and volumes removed\n"));
+        break;
+      default:
+        console.log(chalk6.red(`Unknown action: ${action}`));
+        console.log("Usage: hub services [up|down|restart|ps|logs|clean]");
+        process.exit(1);
+    }
+  } catch {
+    console.log(chalk6.red("\nFailed to execute docker compose command."));
+    console.log(chalk6.dim("Check if Docker is running and the docker-compose.yml is valid.\n"));
+  }
+});
+
+// src/commands/skills.ts
+import { Command as Command8 } from "commander";
+import { existsSync as existsSync6, statSync } from "fs";
+import { mkdir as mkdir4, readdir as readdir2, readFile as readFile5, rm, cp as cp2 } from "fs/promises";
+import { join as join9, resolve as resolve2 } from "path";
+import { execSync as execSync4 } from "child_process";
+import chalk8 from "chalk";
+
+// src/commands/registry.ts
+import { Command as Command7 } from "commander";
+import { mkdir as mkdir3, writeFile as writeFile7 } from "fs/promises";
+import { join as join8 } from "path";
+import chalk7 from "chalk";
+var DEFAULT_REGISTRY_REPO = process.env.HUB_REGISTRY || "arvoreeducacao/rhm";
+var DEFAULT_BRANCH = "main";
+async function downloadDirFromGitHub(repo, remotePath, destDir, branch = DEFAULT_BRANCH) {
+  const apiUrl = `https://api.github.com/repos/${repo}/contents/${remotePath}?ref=${branch}`;
+  const res = await fetch(apiUrl, {
+    headers: { Accept: "application/vnd.github.v3+json" }
+  });
+  if (!res.ok) {
+    if (res.status === 404) {
+      throw new Error(`Not found: ${remotePath} in ${repo}`);
+    }
+    throw new Error(`GitHub API error: ${res.status} ${res.statusText}`);
+  }
+  const items = await res.json();
+  await mkdir3(destDir, { recursive: true });
+  for (const item of items) {
+    if (item.type === "file" && item.download_url) {
+      const fileRes = await fetch(item.download_url);
+      if (!fileRes.ok) continue;
+      const content = await fileRes.text();
+      await writeFile7(join8(destDir, item.name), content, "utf-8");
+    } else if (item.type === "dir") {
+      await downloadDirFromGitHub(repo, item.path, join8(destDir, item.name), branch);
+    }
+  }
+}
+async function listRegistryDir(repo, remotePath, branch = DEFAULT_BRANCH) {
+  const apiUrl = `https://api.github.com/repos/${repo}/contents/${remotePath}?ref=${branch}`;
+  const res = await fetch(apiUrl, {
+    headers: { Accept: "application/vnd.github.v3+json" }
+  });
+  if (!res.ok) return [];
+  return await res.json();
+}
+async function listRegistrySkills(repo) {
+  const items = await listRegistryDir(repo, "skills");
+  const skills = [];
+  for (const item of items) {
+    if (item.type !== "dir") continue;
+    const skillUrl = `https://raw.githubusercontent.com/${repo}/${DEFAULT_BRANCH}/skills/${item.name}/SKILL.md`;
+    try {
+      const res = await fetch(skillUrl);
+      if (!res.ok) continue;
+      const content = await res.text();
+      const descMatch = content.match(/^description:\s*(.+)$/m);
+      skills.push({
+        name: item.name,
+        description: descMatch?.[1]?.replace(/^["']|["']$/g, "") || ""
+      });
+    } catch {
+      skills.push({ name: item.name, description: "" });
+    }
+  }
+  return skills;
+}
+async function listRegistryAgents(repo) {
+  const items = await listRegistryDir(repo, "agents");
+  const agents = [];
+  for (const item of items) {
+    if (item.type !== "file" || !item.name.endsWith(".md")) continue;
+    const agentUrl = `https://raw.githubusercontent.com/${repo}/${DEFAULT_BRANCH}/agents/${item.name}`;
+    try {
+      const res = await fetch(agentUrl);
+      if (!res.ok) continue;
+      const content = await res.text();
+      const descMatch = content.match(/^description:\s*(.+)$/m);
+      const name = item.name.replace(/\.md$/, "");
+      agents.push({
+        name,
+        description: descMatch?.[1]?.replace(/^["']|["']$/g, "") || ""
+      });
+    } catch {
+      agents.push({ name: item.name.replace(/\.md$/, ""), description: "" });
+    }
+  }
+  return agents;
+}
+async function listRegistryHooks(repo) {
+  const items = await listRegistryDir(repo, "hooks");
+  const hooks = [];
+  for (const item of items) {
+    if (item.type !== "dir") continue;
+    const readmeUrl = `https://raw.githubusercontent.com/${repo}/${DEFAULT_BRANCH}/hooks/${item.name}/README.md`;
+    try {
+      const res = await fetch(readmeUrl);
+      if (!res.ok) {
+        hooks.push({ name: item.name, description: "" });
+        continue;
+      }
+      const content = await res.text();
+      const firstLine = content.split("\n").find((l) => l.trim() && !l.startsWith("#"));
+      hooks.push({
+        name: item.name,
+        description: firstLine?.trim() || ""
+      });
+    } catch {
+      hooks.push({ name: item.name, description: "" });
+    }
+  }
+  return hooks;
+}
+async function listRegistryCommands(repo) {
+  const items = await listRegistryDir(repo, "commands");
+  const commands = [];
+  for (const item of items) {
+    if (item.type !== "file" || !item.name.endsWith(".md")) continue;
+    const cmdUrl = `https://raw.githubusercontent.com/${repo}/${DEFAULT_BRANCH}/commands/${item.name}`;
+    try {
+      const res = await fetch(cmdUrl);
+      if (!res.ok) continue;
+      const content = await res.text();
+      const firstLine = content.split("\n").find((l) => l.trim() && !l.startsWith("#"));
+      const name = item.name.replace(/\.md$/, "");
+      commands.push({
+        name,
+        description: firstLine?.trim() || ""
+      });
+    } catch {
+      commands.push({ name: item.name.replace(/\.md$/, ""), description: "" });
+    }
+  }
+  return commands;
+}
+var TYPE_LABELS = {
+  skill: (t) => chalk7.green(t),
+  agent: (t) => chalk7.blue(t),
+  hook: (t) => chalk7.magenta(t),
+  command: (t) => chalk7.cyan(t)
+};
+var INSTALL_HINTS = {
+  skill: "hub skills add <name>",
+  agent: "hub agents add <name>",
+  hook: "hub hooks add <name>",
+  command: "hub commands add <name>"
+};
+var registryCommand = new Command7("registry").description("Browse and install skills, agents, hooks, and commands from the registry").option("-r, --repo <repo>", "Registry repository (owner/repo)", DEFAULT_REGISTRY_REPO).addCommand(
+  new Command7("search").description("Search the registry").argument("[query]", "Search term").option("-t, --type <type>", "Filter by type (skill, agent, hook, command)").action(async (query, opts) => {
+    const repo = registryCommand.opts().repo || DEFAULT_REGISTRY_REPO;
+    console.log(chalk7.blue(`
+\u2501\u2501\u2501 Hub Registry (${repo}) \u2501\u2501\u2501
+`));
+    const results = [];
+    const typeFilter = opts?.type;
+    if (!typeFilter || typeFilter === "skill") {
+      try {
+        const skills = await listRegistrySkills(repo);
+        for (const s of skills) results.push({ type: "skill", ...s });
+      } catch {
+        console.log(chalk7.yellow("  Could not fetch skills from registry."));
+      }
+    }
+    if (!typeFilter || typeFilter === "agent") {
+      try {
+        const agents = await listRegistryAgents(repo);
+        for (const a of agents) results.push({ type: "agent", ...a });
+      } catch {
+        console.log(chalk7.yellow("  Could not fetch agents from registry."));
+      }
+    }
+    if (!typeFilter || typeFilter === "hook") {
+      try {
+        const hooks = await listRegistryHooks(repo);
+        for (const h of hooks) results.push({ type: "hook", ...h });
+      } catch {
+        console.log(chalk7.yellow("  Could not fetch hooks from registry."));
+      }
+    }
+    if (!typeFilter || typeFilter === "command") {
+      try {
+        const commands = await listRegistryCommands(repo);
+        for (const c of commands) results.push({ type: "command", ...c });
+      } catch {
+        console.log(chalk7.yellow("  Could not fetch commands from registry."));
+      }
+    }
+    let filtered = results;
+    if (query) {
+      const q = query.toLowerCase();
+      filtered = results.filter(
+        (e) => e.name.toLowerCase().includes(q) || e.description.toLowerCase().includes(q)
+      );
+    }
+    if (filtered.length === 0) {
+      console.log(chalk7.dim("  No results found.\n"));
+      return;
+    }
+    for (const entry of filtered) {
+      const labelFn = TYPE_LABELS[entry.type] || ((t) => t);
+      console.log(`  ${labelFn(`[${entry.type}]`)} ${chalk7.yellow(entry.name)}`);
+      if (entry.description) console.log(`    ${entry.description}`);
+      console.log();
+    }
+    console.log(chalk7.cyan(`  ${filtered.length} result(s)
+`));
+    const types = [...new Set(filtered.map((e) => e.type))];
+    for (const type of types) {
+      const hint = INSTALL_HINTS[type];
+      if (hint) console.log(chalk7.dim(`  Install ${type}:  ${hint}`));
+    }
+    console.log();
+  })
+).addCommand(
+  new Command7("list").description("List everything in the registry").option("-t, --type <type>", "Filter by type (skill, agent, hook, command)").action(async (opts) => {
+    const repo = registryCommand.opts().repo || DEFAULT_REGISTRY_REPO;
+    console.log(chalk7.blue(`
+\u2501\u2501\u2501 Hub Registry (${repo}) \u2501\u2501\u2501
+`));
+    const typeFilter = opts?.type;
+    if (!typeFilter || typeFilter === "skill") {
+      try {
+        const skills = await listRegistrySkills(repo);
+        if (skills.length) {
+          console.log(chalk7.green(`Skills (${skills.length}):`));
+          for (const s of skills) {
+            console.log(`  ${chalk7.yellow(s.name)}${s.description ? ` \u2014 ${s.description}` : ""}`);
+          }
+          console.log();
+        }
+      } catch {
+        console.log(chalk7.yellow("  Could not fetch skills.\n"));
+      }
+    }
+    if (!typeFilter || typeFilter === "agent") {
+      try {
+        const agents = await listRegistryAgents(repo);
+        if (agents.length) {
+          console.log(chalk7.blue(`Agents (${agents.length}):`));
+          for (const a of agents) {
+            console.log(`  ${chalk7.yellow(a.name)}${a.description ? ` \u2014 ${a.description}` : ""}`);
+          }
+          console.log();
+        }
+      } catch {
+        console.log(chalk7.yellow("  Could not fetch agents.\n"));
+      }
+    }
+    if (!typeFilter || typeFilter === "hook") {
+      try {
+        const hooks = await listRegistryHooks(repo);
+        if (hooks.length) {
+          console.log(chalk7.magenta(`Hooks (${hooks.length}):`));
+          for (const h of hooks) {
+            console.log(`  ${chalk7.yellow(h.name)}${h.description ? ` \u2014 ${h.description}` : ""}`);
+          }
+          console.log();
+        }
+      } catch {
+        console.log(chalk7.yellow("  Could not fetch hooks.\n"));
+      }
+    }
+    if (!typeFilter || typeFilter === "command") {
+      try {
+        const commands = await listRegistryCommands(repo);
+        if (commands.length) {
+          console.log(chalk7.cyan(`Commands (${commands.length}):`));
+          for (const c of commands) {
+            console.log(`  ${chalk7.yellow(c.name)}${c.description ? ` \u2014 ${c.description}` : ""}`);
+          }
+          console.log();
+        }
+      } catch {
+        console.log(chalk7.yellow("  Could not fetch commands.\n"));
+      }
+    }
+  })
+);
+
+// src/commands/skills.ts
+var DEFAULT_REGISTRY_REPO2 = process.env.HUB_REGISTRY || "arvoreeducacao/rhm";
+function tmpDir() {
+  return join9(process.env.TMPDIR || "/tmp", `hub-skills-${Date.now()}`);
+}
+async function listLocalSkills(hubDir) {
+  const skillsDir = join9(hubDir, "skills");
+  const skills = [];
+  if (!existsSync6(skillsDir)) return skills;
+  const folders = await readdir2(skillsDir);
+  for (const folder of folders) {
+    const skillFile = join9(skillsDir, folder, "SKILL.md");
+    if (!existsSync6(skillFile)) continue;
+    const content = await readFile5(skillFile, "utf-8");
+    const descMatch = content.match(/^description:\s*(.+)$/m);
+    skills.push({
+      name: folder,
+      description: descMatch?.[1] || ""
+    });
+  }
+  return skills;
+}
+async function installSkillsFromDir(sourceSkillsDir, hubDir, opts) {
+  if (!existsSync6(sourceSkillsDir)) {
+    console.log(chalk8.red("  No skills/ directory found in source"));
+    return;
+  }
+  const available = await readdir2(sourceSkillsDir);
+  const skillFolders = available.filter(
+    (f) => existsSync6(join9(sourceSkillsDir, f, "SKILL.md"))
+  );
+  if (skillFolders.length === 0) {
+    console.log(chalk8.red("  No skills found (looking for skills/*/SKILL.md)"));
+    return;
+  }
+  const toInstall = opts.skill ? skillFolders.filter((s) => s === opts.skill) : skillFolders;
+  if (opts.skill && toInstall.length === 0) {
+    console.log(chalk8.red(`  Skill '${opts.skill}' not found. Available: ${skillFolders.join(", ")}`));
+    return;
+  }
+  const targetBase = opts.global ? join9(process.env.HOME || "~", ".cursor", "skills") : join9(hubDir, "skills");
+  await mkdir4(targetBase, { recursive: true });
+  for (const skill of toInstall) {
+    const src = join9(sourceSkillsDir, skill);
+    const dest = join9(targetBase, skill);
+    await cp2(src, dest, { recursive: true });
+    console.log(chalk8.green(`  Installed: ${skill}`));
+  }
+  console.log(
+    chalk8.green(
+      `
+  ${toInstall.length} skill(s) installed to ${opts.global ? "global" : "project"}
+`
+    )
+  );
+}
+async function addFromRegistry(skillName, hubDir, opts) {
+  const repo = opts.repo || DEFAULT_REGISTRY_REPO2;
+  const remotePath = `skills/${skillName}`;
+  const targetBase = opts.global ? join9(process.env.HOME || "~", ".cursor", "skills") : join9(hubDir, "skills");
+  const dest = join9(targetBase, skillName);
+  console.log(chalk8.cyan(`  Downloading ${skillName} from ${repo}...`));
+  try {
+    await downloadDirFromGitHub(repo, remotePath, dest);
+    if (!existsSync6(join9(dest, "SKILL.md"))) {
+      await rm(dest, { recursive: true }).catch(() => {
+      });
+      console.log(chalk8.red(`  Skill '${skillName}' not found in registry (${repo})`));
+      console.log(chalk8.dim("  Run 'hub registry list' to see available skills."));
+      return;
+    }
+    console.log(chalk8.green(`  Installed: ${skillName}`));
+    console.log(chalk8.green(`
+  1 skill(s) installed to ${opts.global ? "global" : "project"}
+`));
+  } catch (err) {
+    console.log(chalk8.red(`  Failed to download skill '${skillName}': ${err.message}`));
+    console.log(chalk8.dim("  Run 'hub registry list' to see available skills."));
+  }
+}
+async function addFromGitHubSkill(owner, repo, skillName, hubDir, opts) {
+  const fullRepo = `${owner}/${repo}`;
+  const remotePath = `skills/${skillName}`;
+  const targetBase = opts.global ? join9(process.env.HOME || "~", ".cursor", "skills") : join9(hubDir, "skills");
+  const dest = join9(targetBase, skillName);
+  console.log(chalk8.cyan(`  Downloading ${skillName} from ${fullRepo} via GitHub API...`));
+  try {
+    await downloadDirFromGitHub(fullRepo, remotePath, dest);
+    if (!existsSync6(join9(dest, "SKILL.md"))) {
+      await rm(dest, { recursive: true }).catch(() => {
+      });
+      console.log(chalk8.red(`  Skill '${skillName}' not found in ${fullRepo}/skills/`));
+      console.log(chalk8.dim(`  Check available skills: hub skills add ${fullRepo} --list`));
+      return;
+    }
+    console.log(chalk8.green(`  Installed: ${skillName} (from ${fullRepo})`));
+    console.log(chalk8.green(`
+  1 skill(s) installed to ${opts.global ? "global" : "project"}
+`));
+  } catch (err) {
+    console.log(chalk8.red(`  Failed to download: ${err.message}`));
+  }
+}
+async function listRemoteSkills(owner, repo) {
+  const fullRepo = `${owner}/${repo}`;
+  console.log(chalk8.cyan(`  Fetching skills from ${fullRepo}...
+`));
+  try {
+    const apiUrl = `https://api.github.com/repos/${fullRepo}/contents/skills`;
+    const res = await fetch(apiUrl, {
+      headers: { Accept: "application/vnd.github.v3+json" }
+    });
+    if (!res.ok) {
+      console.log(chalk8.red(`  Could not list skills from ${fullRepo}`));
+      return;
+    }
+    const items = await res.json();
+    const dirs = items.filter((i) => i.type === "dir");
+    if (dirs.length === 0) {
+      console.log(chalk8.dim("  No skills found."));
+      return;
+    }
+    console.log(chalk8.green(`  Available skills (${dirs.length}):
+`));
+    for (const dir of dirs) {
+      console.log(`    ${chalk8.yellow(dir.name)}`);
+    }
+    console.log(chalk8.dim(`
+  Install with: hub skills add ${fullRepo}/<skill-name>`));
+    console.log(chalk8.dim(`  Install all:  hub skills add ${fullRepo}
+`));
+  } catch {
+    console.log(chalk8.red(`  Failed to fetch skill list from ${fullRepo}`));
+  }
+}
+async function addFromLocalPath(localPath, hubDir, opts) {
+  const absPath = resolve2(localPath);
+  if (!existsSync6(absPath)) {
+    console.log(chalk8.red(`  Path not found: ${absPath}`));
+    return;
+  }
+  if (!statSync(absPath).isDirectory()) {
+    console.log(chalk8.red(`  Path is not a directory: ${absPath}`));
+    return;
+  }
+  const sourceSkillsDir = join9(absPath, "skills");
+  await installSkillsFromDir(sourceSkillsDir, hubDir, opts);
+}
+async function addFromGitRepo(source, hubDir, opts) {
+  const tmp = tmpDir();
+  try {
+    console.log(chalk8.cyan(`  Cloning ${source}...`));
+    try {
+      execSync4(`git clone --depth 1 ${source} ${tmp}`, {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch {
+      console.log(chalk8.red(`  Repository not found or not accessible: ${source}`));
+      console.log(chalk8.dim("  Make sure the URL is correct and you have access to the repository."));
+      return;
+    }
+    const sourceSkillsDir = join9(tmp, "skills");
+    await installSkillsFromDir(sourceSkillsDir, hubDir, opts);
+  } finally {
+    if (existsSync6(tmp)) {
+      await rm(tmp, { recursive: true });
+    }
+  }
+}
+function isLocalPath(source) {
+  return source.startsWith("/") || source.startsWith("./") || source.startsWith("../") || source.startsWith("~");
+}
+function parseGitHubSource(source) {
+  const parts = source.split("/");
+  if (parts.length === 2) return { owner: parts[0], repo: parts[1] };
+  if (parts.length === 3) return { owner: parts[0], repo: parts[1], skill: parts[2] };
+  return null;
+}
+var skillsCommand = new Command8("skills").description("Manage agent skills").addCommand(
+  new Command8("add").description("Install skills from registry, GitHub (skills.sh compatible), git URL, or local path").argument("<source>", "Skill name, owner/repo, owner/repo/skill, git URL, or local path").option("-s, --skill <name>", "Install a specific skill only (for repo sources)").option("-g, --global", "Install to global ~/.cursor/skills/").option("-r, --repo <repo>", "Registry repository (owner/repo)").option("-l, --list", "List available skills without installing").action(async (source, opts) => {
+    const hubDir = process.cwd();
+    if (isLocalPath(source)) {
+      console.log(chalk8.blue(`
+Installing skills from ${source}
+`));
+      await addFromLocalPath(source, hubDir, opts);
+      return;
+    }
+    if (source.startsWith("git@") || source.startsWith("https://")) {
+      console.log(chalk8.blue(`
+Installing skills from ${source}
+`));
+      await addFromGitRepo(source, hubDir, opts);
+      return;
+    }
+    const parsed = parseGitHubSource(source);
+    if (parsed && opts.list) {
+      console.log(chalk8.blue(`
+Listing skills from ${parsed.owner}/${parsed.repo}
+`));
+      await listRemoteSkills(parsed.owner, parsed.repo);
+      return;
+    }
+    if (parsed?.skill) {
+      console.log(chalk8.blue(`
+Installing skill ${parsed.skill} from ${parsed.owner}/${parsed.repo}
+`));
+      await addFromGitHubSkill(parsed.owner, parsed.repo, parsed.skill, hubDir, opts);
+      return;
+    }
+    if (parsed && !parsed.skill) {
+      console.log(chalk8.blue(`
+Installing skills from ${source}
+`));
+      const url = `https://github.com/${source}.git`;
+      await addFromGitRepo(url, hubDir, opts);
+      return;
+    }
+    console.log(chalk8.blue(`
+Installing skill ${source} from registry
+`));
+    await addFromRegistry(source, hubDir, opts);
+  })
+).addCommand(
+  new Command8("find").description("Browse community skills on skills.sh").argument("[query]", "Search term (opens skills.sh)").action(async (query) => {
+    const url = query ? `https://skills.sh/?q=${encodeURIComponent(query)}` : "https://skills.sh";
+    console.log(chalk8.blue("\n  Browse community skills at:\n"));
+    console.log(chalk8.cyan(`  ${url}
+`));
+    console.log(chalk8.dim("  Install with: hub skills add <owner>/<repo>/<skill-name>"));
+    console.log(chalk8.dim("  Example:      hub skills add vercel-labs/agent-skills/react-best-practices\n"));
+  })
+).addCommand(
+  new Command8("list").description("List installed skills").action(async () => {
+    const hubDir = process.cwd();
+    console.log(chalk8.blue("\nInstalled skills\n"));
+    const projectSkills = await listLocalSkills(hubDir);
+    if (projectSkills.length > 0) {
+      console.log(chalk8.cyan("Project:"));
+      for (const s of projectSkills) {
+        console.log(`  ${chalk8.yellow(s.name)} \u2014 ${s.description}`);
+      }
+    } else {
+      console.log(chalk8.dim("  No project skills (skills/)"));
+    }
+    const globalDir = join9(process.env.HOME || "~", ".cursor", "skills");
+    const globalSkills = await listLocalSkills(join9(globalDir, ".."));
+    console.log();
+    if (globalSkills.length > 0) {
+      console.log(chalk8.cyan("Global:"));
+      for (const s of globalSkills) {
+        console.log(`  ${chalk8.yellow(s.name)} \u2014 ${s.description}`);
+      }
+    } else {
+      console.log(chalk8.dim("  No global skills (~/.cursor/skills/)"));
+    }
+    console.log();
+  })
+).addCommand(
+  new Command8("remove").description("Remove a skill").argument("<name>", "Skill name to remove").option("-g, --global", "Remove from global skills").action(async (name, opts) => {
+    const hubDir = process.cwd();
+    const base = opts.global ? join9(process.env.HOME || "~", ".cursor", "skills") : join9(hubDir, "skills");
+    const target = join9(base, name);
+    if (!existsSync6(target)) {
+      console.log(chalk8.red(`
+Skill '${name}' not found in ${opts.global ? "global" : "project"}
+`));
+      return;
+    }
+    await rm(target, { recursive: true });
+    console.log(chalk8.green(`
+Removed skill: ${name}
+`));
+  })
+);
+
+// src/commands/agents.ts
+import { Command as Command9 } from "commander";
+import { existsSync as existsSync7, statSync as statSync2 } from "fs";
+import { mkdir as mkdir5, readdir as readdir3, readFile as readFile6, rm as rm2, copyFile as copyFile2, writeFile as writeFile8 } from "fs/promises";
+import { join as join10, resolve as resolve3 } from "path";
+import { execSync as execSync5 } from "child_process";
+import chalk9 from "chalk";
+var DEFAULT_REGISTRY_REPO3 = process.env.HUB_REGISTRY || "arvoreeducacao/rhm";
+var DEFAULT_BRANCH2 = "main";
+function tmpDir2() {
+  return join10(process.env.TMPDIR || "/tmp", `hub-agents-${Date.now()}`);
+}
+async function listLocalAgents(agentsDir) {
+  const agents = [];
+  if (!existsSync7(agentsDir)) return agents;
+  const files = await readdir3(agentsDir);
+  for (const file of files) {
+    if (!file.endsWith(".md")) continue;
+    const content = await readFile6(join10(agentsDir, file), "utf-8");
+    const descMatch = content.match(/^description:\s*(.+)$/m);
+    agents.push({
+      name: file.replace(/\.md$/, ""),
+      description: descMatch?.[1]?.replace(/^["']|["']$/g, "") || ""
+    });
+  }
+  return agents;
+}
+async function addFromRegistry2(agentName, hubDir, opts) {
+  const repo = opts.repo || DEFAULT_REGISTRY_REPO3;
+  const fileName = agentName.endsWith(".md") ? agentName : `${agentName}.md`;
+  const rawUrl = `https://raw.githubusercontent.com/${repo}/${DEFAULT_BRANCH2}/agents/${fileName}`;
+  console.log(chalk9.cyan(`  Downloading ${agentName} from ${repo}...`));
+  try {
+    const res = await fetch(rawUrl);
+    if (!res.ok) {
+      console.log(chalk9.red(`  Agent '${agentName}' not found in registry (${repo})`));
+      console.log(chalk9.dim("  Run 'hub registry list' to see available agents."));
+      return;
+    }
+    const content = await res.text();
+    const targetBase = opts.global ? join10(process.env.HOME || "~", ".cursor", "agents") : join10(hubDir, "agents");
+    await mkdir5(targetBase, { recursive: true });
+    await writeFile8(join10(targetBase, fileName), content, "utf-8");
+    console.log(chalk9.green(`  Installed: ${agentName}`));
+    console.log(chalk9.green(`
+  1 agent(s) installed to ${opts.global ? "global" : "project"}
+`));
+  } catch (err) {
+    console.log(chalk9.red(`  Failed to download agent '${agentName}': ${err.message}`));
+  }
+}
+async function addFromLocalPath2(localPath, hubDir, opts) {
+  const absPath = resolve3(localPath);
+  if (!existsSync7(absPath)) {
+    console.log(chalk9.red(`  Path not found: ${absPath}`));
+    return;
+  }
+  const sourceAgentsDir = statSync2(absPath).isDirectory() ? join10(absPath, "agents") : absPath;
+  await installAgentsFromDir(sourceAgentsDir, hubDir, opts);
+}
+async function installAgentsFromDir(sourceAgentsDir, hubDir, opts) {
+  if (!existsSync7(sourceAgentsDir)) {
+    console.log(chalk9.red("  No agents/ directory found in source"));
+    return;
+  }
+  const files = await readdir3(sourceAgentsDir);
+  const mdFiles = files.filter((f) => f.endsWith(".md"));
+  if (mdFiles.length === 0) {
+    console.log(chalk9.red("  No agent files found (looking for agents/*.md)"));
+    return;
+  }
+  const toInstall = opts.agent ? mdFiles.filter((f) => f === `${opts.agent}.md` || f === opts.agent) : mdFiles;
+  if (opts.agent && toInstall.length === 0) {
+    const available = mdFiles.map((f) => f.replace(/\.md$/, "")).join(", ");
+    console.log(chalk9.red(`  Agent '${opts.agent}' not found. Available: ${available}`));
+    return;
+  }
+  const targetBase = opts.global ? join10(process.env.HOME || "~", ".cursor", "agents") : join10(hubDir, "agents");
+  await mkdir5(targetBase, { recursive: true });
+  for (const file of toInstall) {
+    await copyFile2(join10(sourceAgentsDir, file), join10(targetBase, file));
+    console.log(chalk9.green(`  Installed: ${file.replace(/\.md$/, "")}`));
+  }
+  console.log(
+    chalk9.green(
+      `
+  ${toInstall.length} agent(s) installed to ${opts.global ? "global" : "project"}
+`
+    )
+  );
+}
+async function addFromGitRepo2(source, hubDir, opts) {
+  const tmp = tmpDir2();
+  try {
+    console.log(chalk9.cyan(`  Cloning ${source}...`));
+    try {
+      execSync5(`git clone --depth 1 ${source} ${tmp}`, {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch {
+      console.log(chalk9.red(`  Repository not found or not accessible: ${source}`));
+      return;
+    }
+    const sourceAgentsDir = join10(tmp, "agents");
+    await installAgentsFromDir(sourceAgentsDir, hubDir, opts);
+  } finally {
+    if (existsSync7(tmp)) {
+      await rm2(tmp, { recursive: true });
+    }
+  }
+}
+function isLocalPath2(source) {
+  return source.startsWith("/") || source.startsWith("./") || source.startsWith("../") || source.startsWith("~");
+}
+function isRepoReference(source) {
+  return source.startsWith("git@") || source.startsWith("https://") || source.includes("/");
+}
+var agentsCommand = new Command9("agents").description("Manage agent definitions").addCommand(
+  new Command9("add").description("Install agents from the registry, a git repository, or local path").argument("<source>", "Agent name (from registry), GitHub shorthand (org/repo), git URL, or local path").option("-a, --agent <name>", "Install a specific agent only (for repo sources)").option("-g, --global", "Install to global ~/.cursor/agents/").option("-r, --repo <repo>", "Registry repository (owner/repo)").action(async (source, opts) => {
+    const hubDir = process.cwd();
+    console.log(chalk9.blue(`
+Installing agents from ${source}
+`));
+    if (isLocalPath2(source)) {
+      await addFromLocalPath2(source, hubDir, opts);
+    } else if (isRepoReference(source)) {
+      if (source.startsWith("git@") || source.startsWith("https://")) {
+        await addFromGitRepo2(source, hubDir, opts);
+      } else {
+        const url = `https://github.com/${source}.git`;
+        await addFromGitRepo2(url, hubDir, opts);
+      }
+    } else {
+      await addFromRegistry2(source, hubDir, opts);
+    }
+  })
+).addCommand(
+  new Command9("list").description("List installed agents").action(async () => {
+    const hubDir = process.cwd();
+    console.log(chalk9.blue("\nInstalled agents\n"));
+    const projectAgents = await listLocalAgents(join10(hubDir, "agents"));
+    if (projectAgents.length > 0) {
+      console.log(chalk9.cyan("Project:"));
+      for (const a of projectAgents) {
+        console.log(`  ${chalk9.yellow(a.name)}${a.description ? ` \u2014 ${a.description}` : ""}`);
+      }
+    } else {
+      console.log(chalk9.dim("  No project agents (agents/)"));
+    }
+    const globalDir = join10(process.env.HOME || "~", ".cursor", "agents");
+    const globalAgents = await listLocalAgents(globalDir);
+    console.log();
+    if (globalAgents.length > 0) {
+      console.log(chalk9.cyan("Global:"));
+      for (const a of globalAgents) {
+        console.log(`  ${chalk9.yellow(a.name)}${a.description ? ` \u2014 ${a.description}` : ""}`);
+      }
+    } else {
+      console.log(chalk9.dim("  No global agents (~/.cursor/agents/)"));
+    }
+    console.log();
+  })
+).addCommand(
+  new Command9("remove").description("Remove an agent").argument("<name>", "Agent name to remove").option("-g, --global", "Remove from global agents").action(async (name, opts) => {
+    const hubDir = process.cwd();
+    const base = opts.global ? join10(process.env.HOME || "~", ".cursor", "agents") : join10(hubDir, "agents");
+    const fileName = name.endsWith(".md") ? name : `${name}.md`;
+    const target = join10(base, fileName);
+    if (!existsSync7(target)) {
+      console.log(chalk9.red(`
+Agent '${name}' not found in ${opts.global ? "global" : "project"}
+`));
+      return;
+    }
+    await rm2(target);
+    console.log(chalk9.green(`
+Removed agent: ${name}
+`));
+  })
+);
+
+// src/commands/hooks.ts
+import { Command as Command10 } from "commander";
+import { existsSync as existsSync8, statSync as statSync3 } from "fs";
+import { mkdir as mkdir6, readdir as readdir4, readFile as readFile7, rm as rm3, copyFile as copyFile3, cp as cp3 } from "fs/promises";
+import { join as join11, resolve as resolve4 } from "path";
+import { execSync as execSync6 } from "child_process";
+import chalk10 from "chalk";
+var DEFAULT_REGISTRY_REPO4 = process.env.HUB_REGISTRY || "arvoreeducacao/rhm";
+function tmpDir3() {
+  return join11(process.env.TMPDIR || "/tmp", `hub-hooks-${Date.now()}`);
+}
+async function listLocalHooks(hooksDir) {
+  const hooks = [];
+  if (!existsSync8(hooksDir)) return hooks;
+  const entries = await readdir4(hooksDir);
+  for (const entry of entries) {
+    const entryPath = join11(hooksDir, entry);
+    const stat = statSync3(entryPath);
+    if (stat.isFile() && entry.endsWith(".sh")) {
+      hooks.push({ name: entry.replace(/\.sh$/, ""), description: "" });
+    } else if (stat.isDirectory()) {
+      const readmePath = join11(entryPath, "README.md");
+      let description = "";
+      if (existsSync8(readmePath)) {
+        const content = await readFile7(readmePath, "utf-8");
+        const firstLine = content.split("\n").find((l) => l.trim() && !l.startsWith("#"));
+        description = firstLine?.trim() || "";
+      }
+      hooks.push({ name: entry, description });
+    }
+  }
+  return hooks;
+}
+async function addFromRegistry3(hookName, hubDir, opts) {
+  const repo = opts.repo || DEFAULT_REGISTRY_REPO4;
+  const targetDir = join11(hubDir, "hooks", hookName);
+  console.log(chalk10.cyan(`  Downloading hook '${hookName}' from ${repo}...`));
+  try {
+    await downloadDirFromGitHub(repo, `hooks/${hookName}`, targetDir);
+    console.log(chalk10.green(`  Installed: ${hookName}`));
+    console.log(chalk10.dim("\n  Add the hook to hub.yaml to bind it to an event. Example:"));
+    console.log(chalk10.dim(`  hooks:`));
+    console.log(chalk10.dim(`    after_file_edit:`));
+    console.log(chalk10.dim(`      - type: command`));
+    console.log(chalk10.dim(`        command: "./hooks/${hookName}/hook.sh"
+`));
+  } catch {
+    console.log(chalk10.red(`  Hook '${hookName}' not found in registry (${repo})`));
+    console.log(chalk10.dim("  Run 'hub registry list --type hook' to see available hooks."));
+  }
+}
+async function addFromLocalPath3(localPath, hubDir, opts) {
+  const absPath = resolve4(localPath);
+  if (!existsSync8(absPath)) {
+    console.log(chalk10.red(`  Path not found: ${absPath}`));
+    return;
+  }
+  const stat = statSync3(absPath);
+  const sourceHooksDir = stat.isDirectory() ? existsSync8(join11(absPath, "hooks")) ? join11(absPath, "hooks") : absPath : absPath;
+  await installHooksFromDir(sourceHooksDir, hubDir, opts);
+}
+async function installHooksFromDir(sourceDir, hubDir, opts) {
+  if (!existsSync8(sourceDir)) {
+    console.log(chalk10.red("  No hooks directory found in source"));
+    return;
+  }
+  const entries = await readdir4(sourceDir);
+  const hookEntries = entries.filter((e) => {
+    const p = join11(sourceDir, e);
+    return e.endsWith(".sh") || statSync3(p).isDirectory();
+  });
+  if (hookEntries.length === 0) {
+    console.log(chalk10.red("  No hook files found"));
+    return;
+  }
+  const toInstall = opts.hook ? hookEntries.filter((e) => e === opts.hook || e === `${opts.hook}.sh` || e.replace(/\.sh$/, "") === opts.hook) : hookEntries;
+  if (opts.hook && toInstall.length === 0) {
+    const available = hookEntries.map((e) => e.replace(/\.sh$/, "")).join(", ");
+    console.log(chalk10.red(`  Hook '${opts.hook}' not found. Available: ${available}`));
+    return;
+  }
+  const targetBase = join11(hubDir, "hooks");
+  await mkdir6(targetBase, { recursive: true });
+  for (const entry of toInstall) {
+    const src = join11(sourceDir, entry);
+    const stat = statSync3(src);
+    if (stat.isDirectory()) {
+      await cp3(src, join11(targetBase, entry), { recursive: true });
+    } else {
+      await copyFile3(src, join11(targetBase, entry));
+    }
+    console.log(chalk10.green(`  Installed: ${entry.replace(/\.sh$/, "")}`));
+  }
+  console.log(chalk10.green(`
+  ${toInstall.length} hook(s) installed
+`));
+}
+async function addFromGitRepo3(source, hubDir, opts) {
+  const tmp = tmpDir3();
+  try {
+    console.log(chalk10.cyan(`  Cloning ${source}...`));
+    try {
+      execSync6(`git clone --depth 1 ${source} ${tmp}`, {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch {
+      console.log(chalk10.red(`  Repository not found or not accessible: ${source}`));
+      return;
+    }
+    const sourceHooksDir = join11(tmp, "hooks");
+    await installHooksFromDir(sourceHooksDir, hubDir, opts);
+  } finally {
+    if (existsSync8(tmp)) {
+      await rm3(tmp, { recursive: true });
+    }
+  }
+}
+function isLocalPath3(source) {
+  return source.startsWith("/") || source.startsWith("./") || source.startsWith("../") || source.startsWith("~");
+}
+function isRepoReference2(source) {
+  return source.startsWith("git@") || source.startsWith("https://") || source.includes("/");
+}
+var hooksCommand = new Command10("hooks").description("Manage editor hooks").addCommand(
+  new Command10("add").description("Install hooks from the registry, a git repository, or local path").argument("<source>", "Hook name (from registry), GitHub shorthand (org/repo), git URL, or local path").option("--hook <name>", "Install a specific hook only (for repo sources)").option("-r, --repo <repo>", "Registry repository (owner/repo)").action(async (source, opts) => {
+    const hubDir = process.cwd();
+    console.log(chalk10.blue(`
+Installing hooks from ${source}
+`));
+    if (isLocalPath3(source)) {
+      await addFromLocalPath3(source, hubDir, opts);
+    } else if (isRepoReference2(source)) {
+      if (source.startsWith("git@") || source.startsWith("https://")) {
+        await addFromGitRepo3(source, hubDir, opts);
+      } else {
+        const url = `https://github.com/${source}.git`;
+        await addFromGitRepo3(url, hubDir, opts);
+      }
+    } else {
+      await addFromRegistry3(source, hubDir, opts);
+    }
+  })
+).addCommand(
+  new Command10("list").description("List installed hooks").action(async () => {
+    const hubDir = process.cwd();
+    const hooksDir = join11(hubDir, "hooks");
+    console.log(chalk10.blue("\nInstalled hooks\n"));
+    const hooks = await listLocalHooks(hooksDir);
+    if (hooks.length > 0) {
+      for (const h of hooks) {
+        console.log(`  ${chalk10.yellow(h.name)}${h.description ? ` \u2014 ${h.description}` : ""}`);
+      }
+    } else {
+      console.log(chalk10.dim("  No hooks installed (hooks/)"));
+    }
+    console.log();
+  })
+).addCommand(
+  new Command10("remove").description("Remove a hook").argument("<name>", "Hook name to remove").action(async (name) => {
+    const hubDir = process.cwd();
+    const hooksDir = join11(hubDir, "hooks");
+    const shFile = join11(hooksDir, `${name}.sh`);
+    const dirPath = join11(hooksDir, name);
+    if (existsSync8(dirPath) && statSync3(dirPath).isDirectory()) {
+      await rm3(dirPath, { recursive: true });
+      console.log(chalk10.green(`
+Removed hook: ${name}
+`));
+    } else if (existsSync8(shFile)) {
+      await rm3(shFile);
+      console.log(chalk10.green(`
+Removed hook: ${name}
+`));
+    } else {
+      console.log(chalk10.red(`
+Hook '${name}' not found in hooks/
+`));
+    }
+  })
+);
+
+// src/commands/commands.ts
+import { Command as Command11 } from "commander";
+import { existsSync as existsSync9, statSync as statSync4 } from "fs";
+import { mkdir as mkdir7, readdir as readdir5, readFile as readFile8, rm as rm4, copyFile as copyFile4, writeFile as writeFile9 } from "fs/promises";
+import { join as join12, resolve as resolve5 } from "path";
+import { execSync as execSync7 } from "child_process";
+import chalk11 from "chalk";
+var DEFAULT_REGISTRY_REPO5 = process.env.HUB_REGISTRY || "arvoreeducacao/rhm";
+var DEFAULT_BRANCH3 = "main";
+function tmpDir4() {
+  return join12(process.env.TMPDIR || "/tmp", `hub-commands-${Date.now()}`);
+}
+async function listLocalCommands(commandsDir) {
+  const commands = [];
+  if (!existsSync9(commandsDir)) return commands;
+  const files = await readdir5(commandsDir);
+  for (const file of files) {
+    if (!file.endsWith(".md")) continue;
+    const content = await readFile8(join12(commandsDir, file), "utf-8");
+    const firstLine = content.split("\n").find((l) => l.trim() && !l.startsWith("#"));
+    commands.push({
+      name: file.replace(/\.md$/, ""),
+      description: firstLine?.trim() || ""
+    });
+  }
+  return commands;
+}
+async function addFromRegistry4(commandName, hubDir, opts) {
+  const repo = opts.repo || DEFAULT_REGISTRY_REPO5;
+  const fileName = commandName.endsWith(".md") ? commandName : `${commandName}.md`;
+  const rawUrl = `https://raw.githubusercontent.com/${repo}/${DEFAULT_BRANCH3}/commands/${fileName}`;
+  console.log(chalk11.cyan(`  Downloading command '${commandName}' from ${repo}...`));
+  try {
+    const res = await fetch(rawUrl);
+    if (!res.ok) {
+      console.log(chalk11.red(`  Command '${commandName}' not found in registry (${repo})`));
+      console.log(chalk11.dim("  Run 'hub registry list --type command' to see available commands."));
+      return;
+    }
+    const content = await res.text();
+    const targetDir = join12(hubDir, "commands");
+    await mkdir7(targetDir, { recursive: true });
+    await writeFile9(join12(targetDir, fileName), content, "utf-8");
+    console.log(chalk11.green(`  Installed: ${commandName}`));
+    console.log(chalk11.dim(`
+  Use it in Cursor with /${commandName}`));
+    console.log(chalk11.dim(`  Make sure hub.yaml has: commands_dir: ./commands
+`));
+  } catch (err) {
+    console.log(chalk11.red(`  Failed to download command '${commandName}': ${err.message}`));
+  }
+}
+async function addFromLocalPath4(localPath, hubDir, opts) {
+  const absPath = resolve5(localPath);
+  if (!existsSync9(absPath)) {
+    console.log(chalk11.red(`  Path not found: ${absPath}`));
+    return;
+  }
+  const stat = statSync4(absPath);
+  if (stat.isFile() && absPath.endsWith(".md")) {
+    const targetDir = join12(hubDir, "commands");
+    await mkdir7(targetDir, { recursive: true });
+    const fileName = absPath.split("/").pop();
+    await copyFile4(absPath, join12(targetDir, fileName));
+    console.log(chalk11.green(`  Installed: ${fileName.replace(/\.md$/, "")}`));
+    console.log(chalk11.green(`
+  1 command(s) installed
+`));
+    return;
+  }
+  const sourceDir = stat.isDirectory() ? existsSync9(join12(absPath, "commands")) ? join12(absPath, "commands") : absPath : absPath;
+  await installCommandsFromDir(sourceDir, hubDir, opts);
+}
+async function installCommandsFromDir(sourceDir, hubDir, opts) {
+  if (!existsSync9(sourceDir)) {
+    console.log(chalk11.red("  No commands directory found in source"));
+    return;
+  }
+  const files = await readdir5(sourceDir);
+  const mdFiles = files.filter((f) => f.endsWith(".md"));
+  if (mdFiles.length === 0) {
+    console.log(chalk11.red("  No command files found (looking for *.md)"));
+    return;
+  }
+  const toInstall = opts.command ? mdFiles.filter((f) => f === `${opts.command}.md` || f === opts.command) : mdFiles;
+  if (opts.command && toInstall.length === 0) {
+    const available = mdFiles.map((f) => f.replace(/\.md$/, "")).join(", ");
+    console.log(chalk11.red(`  Command '${opts.command}' not found. Available: ${available}`));
+    return;
+  }
+  const targetDir = join12(hubDir, "commands");
+  await mkdir7(targetDir, { recursive: true });
+  for (const file of toInstall) {
+    await copyFile4(join12(sourceDir, file), join12(targetDir, file));
+    console.log(chalk11.green(`  Installed: ${file.replace(/\.md$/, "")}`));
+  }
+  console.log(chalk11.green(`
+  ${toInstall.length} command(s) installed
+`));
+}
+async function addFromGitRepo4(source, hubDir, opts) {
+  const tmp = tmpDir4();
+  try {
+    console.log(chalk11.cyan(`  Cloning ${source}...`));
+    try {
+      execSync7(`git clone --depth 1 ${source} ${tmp}`, {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch {
+      console.log(chalk11.red(`  Repository not found or not accessible: ${source}`));
+      return;
+    }
+    const sourceCommandsDir = join12(tmp, "commands");
+    await installCommandsFromDir(sourceCommandsDir, hubDir, opts);
+  } finally {
+    if (existsSync9(tmp)) {
+      await rm4(tmp, { recursive: true });
+    }
+  }
+}
+function isLocalPath4(source) {
+  return source.startsWith("/") || source.startsWith("./") || source.startsWith("../") || source.startsWith("~");
+}
+function isRepoReference3(source) {
+  return source.startsWith("git@") || source.startsWith("https://") || source.includes("/");
+}
+var commandsCommand = new Command11("commands").description("Manage slash commands (Cursor)").addCommand(
+  new Command11("add").description("Install commands from the registry, a git repository, or local path").argument("<source>", "Command name (from registry), GitHub shorthand (org/repo), git URL, or local path").option("-c, --command <name>", "Install a specific command only (for repo sources)").option("-r, --repo <repo>", "Registry repository (owner/repo)").action(async (source, opts) => {
+    const hubDir = process.cwd();
+    console.log(chalk11.blue(`
+Installing commands from ${source}
+`));
+    if (isLocalPath4(source)) {
+      await addFromLocalPath4(source, hubDir, opts);
+    } else if (isRepoReference3(source)) {
+      if (source.startsWith("git@") || source.startsWith("https://")) {
+        await addFromGitRepo4(source, hubDir, opts);
+      } else {
+        const url = `https://github.com/${source}.git`;
+        await addFromGitRepo4(url, hubDir, opts);
+      }
+    } else {
+      await addFromRegistry4(source, hubDir, opts);
+    }
+  })
+).addCommand(
+  new Command11("list").description("List installed commands").action(async () => {
+    const hubDir = process.cwd();
+    const commandsDir = join12(hubDir, "commands");
+    console.log(chalk11.blue("\nInstalled commands\n"));
+    const commands = await listLocalCommands(commandsDir);
+    if (commands.length > 0) {
+      for (const c of commands) {
+        console.log(`  ${chalk11.yellow(`/${c.name}`)}${c.description ? ` \u2014 ${c.description}` : ""}`);
+      }
+    } else {
+      console.log(chalk11.dim("  No commands installed (commands/)"));
+    }
+    console.log();
+  })
+).addCommand(
+  new Command11("remove").description("Remove a command").argument("<name>", "Command name to remove").action(async (name) => {
+    const hubDir = process.cwd();
+    const commandsDir = join12(hubDir, "commands");
+    const fileName = name.endsWith(".md") ? name : `${name}.md`;
+    const target = join12(commandsDir, fileName);
+    if (!existsSync9(target)) {
+      console.log(chalk11.red(`
+Command '${name}' not found in commands/
+`));
+      return;
+    }
+    await rm4(target);
+    console.log(chalk11.green(`
+Removed command: ${name}
+`));
+  })
+);
+
+// src/commands/repos.ts
+import { Command as Command12 } from "commander";
+import { existsSync as existsSync10 } from "fs";
+import { join as join13 } from "path";
+import { execSync as execSync8 } from "child_process";
+import chalk12 from "chalk";
+var pullCommand = new Command12("pull").description("Pull latest changes in all repositories").action(async () => {
+  const hubDir = process.cwd();
+  const config = await loadHubConfig(hubDir);
+  console.log(chalk12.blue("\n\u2501\u2501\u2501 Pulling latest changes \u2501\u2501\u2501\n"));
+  for (const repo of config.repos) {
+    const fullPath = join13(hubDir, repo.path);
+    if (!existsSync10(fullPath)) {
+      console.log(chalk12.red(`  ${repo.name}: not cloned`));
+      continue;
+    }
+    console.log(chalk12.yellow(`\u25B8 ${repo.name}`));
+    try {
+      execSync8("git pull --rebase", { cwd: fullPath, stdio: "inherit" });
+      console.log(chalk12.green("  Updated"));
+    } catch {
+      console.log(chalk12.red("  Failed to pull"));
+    }
+  }
+  console.log();
+});
+var statusCommand = new Command12("status").description("Show git status for all repositories").action(async () => {
+  const hubDir = process.cwd();
+  const config = await loadHubConfig(hubDir);
+  console.log(chalk12.blue("\n\u2501\u2501\u2501 Git status \u2501\u2501\u2501\n"));
+  for (const repo of config.repos) {
+    const fullPath = join13(hubDir, repo.path);
+    if (!existsSync10(fullPath)) {
+      console.log(chalk12.red(`  ${repo.name}: not cloned`));
+      continue;
+    }
+    console.log(chalk12.yellow(`\u25B8 ${repo.name}`));
+    try {
+      const branch = execSync8("git branch --show-current", {
+        cwd: fullPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      const changes = execSync8("git status --porcelain", {
+        cwd: fullPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim().split("\n").filter(Boolean).length;
+      let ahead = "0";
+      let behind = "0";
+      try {
+        ahead = execSync8("git rev-list --count @{u}..HEAD", {
+          cwd: fullPath,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+        behind = execSync8("git rev-list --count HEAD..@{u}", {
+          cwd: fullPath,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+      } catch {
+      }
+      console.log(`  Branch: ${branch}`);
+      console.log(`  Changes: ${changes} file(s)`);
+      console.log(`  Ahead: ${ahead} | Behind: ${behind}`);
+    } catch {
+      console.log(chalk12.red("  Failed to get status"));
+    }
+    console.log();
+  }
+});
+var execCommand = new Command12("exec").description("Execute a command in all repositories").argument("<cmd...>", "Command to execute").passThroughOptions().allowUnknownOption().action(async (cmd) => {
+  const hubDir = process.cwd();
+  const config = await loadHubConfig(hubDir);
+  const command = cmd.join(" ");
+  console.log(chalk12.blue(`
+\u2501\u2501\u2501 Executing: ${command} \u2501\u2501\u2501
+`));
+  for (const repo of config.repos) {
+    const fullPath = join13(hubDir, repo.path);
+    if (!existsSync10(fullPath)) {
+      console.log(chalk12.red(`  ${repo.name}: not cloned`));
+      continue;
+    }
+    console.log(chalk12.yellow(`\u25B8 ${repo.name}`));
+    try {
+      execSync8(command, { cwd: fullPath, stdio: "inherit" });
+    } catch {
+      console.log(chalk12.red(`  Command failed in ${repo.name}`));
+    }
+  }
+  console.log();
+});
+
+// src/commands/worktree.ts
+import { Command as Command13 } from "commander";
+import { existsSync as existsSync11 } from "fs";
+import { cp as cp4, mkdir as mkdir8 } from "fs/promises";
+import { join as join14 } from "path";
+import { execSync as execSync9 } from "child_process";
+import chalk13 from "chalk";
+function getWorktreeBase() {
+  return join14(process.env.HOME || "~", ".cursor", "worktrees", "repo-hub");
+}
+function isGitRepo(dir) {
+  try {
+    execSync9("git rev-parse --is-inside-work-tree", {
+      cwd: dir,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var worktreeCommand = new Command13("worktree").description("Manage git worktrees for parallel work").addCommand(
+  new Command13("add").description("Create a new worktree with environment files copied").argument("<name>", "Worktree name").action(async (name) => {
+    const hubDir = process.cwd();
+    if (!isGitRepo(hubDir)) {
+      console.log(chalk13.red("\nThis directory is not a git repository."));
+      console.log(chalk13.dim("Run 'git init' first or use worktrees from a repo directory.\n"));
+      return;
+    }
+    const config = await loadHubConfig(hubDir);
+    const worktreeBase = getWorktreeBase();
+    const worktreePath = join14(worktreeBase, name);
+    console.log(chalk13.blue(`
+\u2501\u2501\u2501 Creating worktree: ${name} \u2501\u2501\u2501
+`));
+    await mkdir8(worktreeBase, { recursive: true });
+    console.log(chalk13.cyan("  Creating git worktree..."));
+    try {
+      execSync9(`git worktree add "${worktreePath}" --detach`, {
+        cwd: hubDir,
+        stdio: "inherit"
+      });
+    } catch {
+      console.log(chalk13.red("  Failed to create worktree. Make sure you have commits in this repo.\n"));
+      return;
+    }
+    console.log(chalk13.cyan("  Copying environment files..."));
+    for (const repo of config.repos) {
+      if (!repo.env_file) continue;
+      const srcEnv = join14(hubDir, repo.path, repo.env_file);
+      if (!existsSync11(srcEnv)) continue;
+      const destDir = join14(worktreePath, repo.path);
+      if (existsSync11(destDir)) {
+        const destEnv = join14(destDir, repo.env_file);
+        try {
+          await cp4(srcEnv, destEnv);
+          console.log(chalk13.green(`  ${repo.name}: Copied ${repo.env_file}`));
+        } catch {
+          console.log(chalk13.dim(`  ${repo.name}: Could not copy env file`));
+        }
+      }
+    }
+    console.log(chalk13.green(`
+Worktree created at: ${worktreePath}`));
+    console.log(chalk13.cyan(`Open in Cursor: cursor ${worktreePath}
+`));
+  })
+).addCommand(
+  new Command13("list").description("List all worktrees").action(async () => {
+    const hubDir = process.cwd();
+    if (!isGitRepo(hubDir)) {
+      console.log(chalk13.red("\nThis directory is not a git repository."));
+      console.log(chalk13.dim("Worktrees require a git repository.\n"));
+      return;
+    }
+    console.log(chalk13.blue("\n\u2501\u2501\u2501 Git Worktrees \u2501\u2501\u2501\n"));
+    execSync9("git worktree list", { cwd: hubDir, stdio: "inherit" });
+    console.log();
+  })
+).addCommand(
+  new Command13("remove").description("Remove a worktree").argument("<name>", "Worktree name").action(async (name) => {
+    const hubDir = process.cwd();
+    if (!isGitRepo(hubDir)) {
+      console.log(chalk13.red("\nThis directory is not a git repository."));
+      console.log(chalk13.dim("Worktrees require a git repository.\n"));
+      return;
+    }
+    const worktreePath = join14(getWorktreeBase(), name);
+    console.log(chalk13.blue(`
+\u2501\u2501\u2501 Removing worktree: ${name} \u2501\u2501\u2501
+`));
+    try {
+      execSync9(`git worktree remove "${worktreePath}" --force`, {
+        cwd: hubDir,
+        stdio: "inherit"
+      });
+      console.log(chalk13.green("  Worktree removed\n"));
+    } catch {
+      console.log(chalk13.red(`  Failed to remove worktree '${name}'.
+`));
+    }
+  })
+).addCommand(
+  new Command13("copy-envs").description("Copy environment files to a worktree").argument("[name]", "Worktree name (copies to that worktree)").action(async (name) => {
+    const hubDir = process.cwd();
+    const config = await loadHubConfig(hubDir);
+    const targetDir = name ? join14(getWorktreeBase(), name) : hubDir;
+    if (!existsSync11(targetDir)) {
+      console.log(chalk13.red(`
+Worktree '${name}' not found at ${targetDir}
+`));
+      return;
+    }
+    console.log(chalk13.blue("\n\u2501\u2501\u2501 Copying environment files \u2501\u2501\u2501\n"));
+    console.log(chalk13.cyan(`  Source: ${hubDir}`));
+    console.log(chalk13.cyan(`  Target: ${targetDir}
+`));
+    for (const repo of config.repos) {
+      if (!repo.env_file) continue;
+      const srcEnv = join14(hubDir, repo.path, repo.env_file);
+      if (!existsSync11(srcEnv)) continue;
+      const destDir = join14(targetDir, repo.path);
+      if (!existsSync11(destDir)) continue;
+      const destEnv = join14(destDir, repo.env_file);
+      try {
+        await cp4(srcEnv, destEnv);
+        console.log(chalk13.green(`  ${repo.name}: Copied ${repo.env_file}`));
+      } catch {
+        console.log(chalk13.red(`  ${repo.name}: Failed to copy`));
+      }
+    }
+    console.log();
+  })
+);
+
+// src/commands/doctor.ts
+import { Command as Command14 } from "commander";
+import { existsSync as existsSync12 } from "fs";
+import { join as join15 } from "path";
+import { execSync as execSync10 } from "child_process";
+import chalk14 from "chalk";
+var CHECKS = [
+  { name: "git", command: "git", versionFlag: "--version", required: true },
+  { name: "docker", command: "docker", versionFlag: "--version", required: true },
+  { name: "node", command: "node", versionFlag: "--version", required: true },
+  { name: "pnpm", command: "pnpm", versionFlag: "--version", required: false },
+  { name: "mise", command: "mise", versionFlag: "--version", required: false },
+  { name: "gh", command: "gh", versionFlag: "--version", required: false },
+  { name: "aws", command: "aws", versionFlag: "--version", required: false }
+];
+function checkCommand(check) {
+  try {
+    const output = execSync10(`${check.command} ${check.versionFlag || "--version"}`, {
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf-8"
+    }).trim();
+    const version = output.split("\n")[0];
+    return { found: true, version };
+  } catch {
+    return { found: false };
+  }
+}
+function getToolVersion(tool) {
+  const versionFlags = {
+    node: "--version",
+    pnpm: "--version",
+    yarn: "--version",
+    erlang: "+V",
+    elixir: "--version",
+    ruby: "--version",
+    python: "--version",
+    go: "version",
+    rust: "--version",
+    direnv: "--version"
+  };
+  const flag = versionFlags[tool] || "--version";
+  try {
+    const cmd = tool === "erlang" ? "erl" : tool;
+    const output = execSync10(`${cmd} ${flag}`, {
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf-8"
+    }).trim();
+    return output.split("\n")[0];
+  } catch {
+    return null;
+  }
+}
+function versionMatches(actual, expected) {
+  const extractVersion2 = (s) => {
+    const match = s.match(/(\d+\.\d+[.\d]*)/);
+    return match?.[1] || s;
+  };
+  const actualClean = extractVersion2(actual);
+  return actualClean.startsWith(expected) || expected.startsWith(actualClean);
+}
+var doctorCommand = new Command14("doctor").description("Check required dependencies and tool versions from hub.yaml").action(async () => {
+  const hubDir = process.cwd();
+  let config;
+  try {
+    config = await loadHubConfig(hubDir);
+  } catch {
+    config = null;
+  }
+  console.log(chalk14.blue("\nChecking dependencies\n"));
+  let allOk = true;
+  const required = CHECKS.filter((c) => c.required);
+  const recommended = CHECKS.filter((c) => !c.required);
+  console.log(chalk14.cyan("Required:"));
+  for (const check of required) {
+    const result = checkCommand(check);
+    if (result.found) {
+      console.log(chalk14.green(`  \u2713 ${check.name}: ${result.version}`));
+    } else {
+      console.log(chalk14.red(`  \u2717 ${check.name}: not found`));
+      allOk = false;
+    }
+  }
+  console.log();
+  console.log(chalk14.cyan("Recommended:"));
+  for (const check of recommended) {
+    const result = checkCommand(check);
+    if (result.found) {
+      console.log(chalk14.green(`  \u2713 ${check.name}: ${result.version}`));
+    } else {
+      console.log(chalk14.dim(`  - ${check.name}: not found`));
+    }
+  }
+  if (config?.tools && Object.keys(config.tools).length > 0) {
+    console.log();
+    console.log(chalk14.cyan("Hub tools (from hub.yaml):"));
+    for (const [tool, expected] of Object.entries(config.tools)) {
+      const actual = getToolVersion(tool);
+      if (!actual) {
+        console.log(chalk14.red(`  \u2717 ${tool}: not found (expected ${expected})`));
+        allOk = false;
+      } else if (versionMatches(actual, expected)) {
+        console.log(chalk14.green(`  \u2713 ${tool}: ${actual} (expected ${expected})`));
+      } else {
+        console.log(chalk14.yellow(`  \u26A0 ${tool}: ${actual} (expected ${expected})`));
+      }
+    }
+  }
+  if (config?.repos) {
+    const reposWithTools = config.repos.filter(
+      (r) => r.tools && Object.keys(r.tools).length > 0
+    );
+    if (reposWithTools.length > 0) {
+      console.log();
+      console.log(chalk14.cyan("Repo-specific tools:"));
+      for (const repo of reposWithTools) {
+        const repoDir = join15(hubDir, repo.path);
+        if (!existsSync12(repoDir)) {
+          console.log(chalk14.dim(`  ${repo.name}: not cloned, skipping`));
+          continue;
+        }
+        console.log(chalk14.yellow(`  \u25B8 ${repo.name}`));
+        for (const [tool, expected] of Object.entries(repo.tools)) {
+          const actual = getToolVersion(tool);
+          if (!actual) {
+            console.log(chalk14.red(`    \u2717 ${tool}: not found (expected ${expected})`));
+          } else if (versionMatches(actual, expected)) {
+            console.log(chalk14.green(`    \u2713 ${tool}: ${actual} (expected ${expected})`));
+          } else {
+            console.log(chalk14.yellow(`    \u26A0 ${tool}: ${actual} (expected ${expected})`));
+          }
+        }
+      }
+    }
+  }
+  console.log();
+  if (allOk) {
+    console.log(chalk14.green("All checks passed!\n"));
+  } else {
+    console.log(chalk14.red("Some checks failed.\n"));
+    if (config?.tools) {
+      console.log(chalk14.cyan("Fix with: hub tools install\n"));
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/tools.ts
+import { Command as Command15 } from "commander";
+import { existsSync as existsSync13 } from "fs";
+import { writeFile as writeFile10 } from "fs/promises";
+import { join as join16 } from "path";
+import { execSync as execSync11 } from "child_process";
+import chalk15 from "chalk";
+function hasMise2() {
+  try {
+    execSync11("mise --version", { stdio: ["pipe", "pipe", "pipe"] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function generateMiseToml2(tools, settings) {
+  const lines = [];
+  lines.push("[tools]");
+  for (const [tool, version] of Object.entries(tools)) {
+    lines.push(`${tool} = "${version}"`);
+  }
+  if (settings && Object.keys(settings).length > 0) {
+    lines.push("");
+    lines.push("[settings]");
+    for (const [key, value] of Object.entries(settings)) {
+      if (typeof value === "boolean") {
+        lines.push(`${key} = ${value}`);
+      } else if (typeof value === "string") {
+        lines.push(`${key} = "${value}"`);
+      } else if (typeof value === "number") {
+        lines.push(`${key} = ${value}`);
+      }
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function mergeTools(global, local) {
+  return { ...global, ...local };
+}
+async function generateMiseFiles(config, hubDir) {
+  let count = 0;
+  if (config.tools && Object.keys(config.tools).length > 0) {
+    const content = generateMiseToml2(config.tools, config.mise_settings);
+    await writeFile10(join16(hubDir, ".mise.toml"), content, "utf-8");
+    console.log(chalk15.green(`  Generated .mise.toml (${Object.keys(config.tools).length} tools)`));
+    count++;
+  }
+  for (const repo of config.repos) {
+    if (!repo.tools || Object.keys(repo.tools).length === 0) continue;
+    const repoDir = join16(hubDir, repo.path);
+    if (!existsSync13(repoDir)) {
+      console.log(chalk15.dim(`  ${repo.name}: not cloned, skipping`));
+      continue;
+    }
+    const merged = mergeTools(config.tools || {}, repo.tools);
+    const content = generateMiseToml2(merged);
+    await writeFile10(join16(repoDir, ".mise.toml"), content, "utf-8");
+    console.log(chalk15.green(`  ${repo.name}: Generated .mise.toml (${Object.keys(merged).length} tools)`));
+    count++;
+  }
+  return count;
+}
+var toolsCommand = new Command15("tools").description("Manage development tool versions via mise").addCommand(
+  new Command15("install").description("Install all tools defined in hub.yaml using mise").option("--generate", "Generate .mise.toml files before installing").action(async (opts) => {
+    const hubDir = process.cwd();
+    const config = await loadHubConfig(hubDir);
+    if (!hasMise2()) {
+      console.log(chalk15.red("\nmise is not installed."));
+      console.log(chalk15.cyan("Install with: curl https://mise.run | sh"));
+      console.log(chalk15.cyan("Or: brew install mise\n"));
+      return;
+    }
+    if (!config.tools && !config.repos.some((r) => r.tools)) {
+      console.log(chalk15.yellow("\nNo tools defined in hub.yaml\n"));
+      return;
+    }
+    console.log(chalk15.blue("\n\u2501\u2501\u2501 Installing tools \u2501\u2501\u2501\n"));
+    if (opts.generate) {
+      await generateMiseFiles(config, hubDir);
+      console.log();
+    }
+    if (config.tools && Object.keys(config.tools).length > 0) {
+      console.log(chalk15.cyan("Installing hub-level tools..."));
+      try {
+        execSync11("mise trust && mise install", {
+          cwd: hubDir,
+          stdio: "inherit"
+        });
+        console.log(chalk15.green("  Hub tools installed\n"));
+      } catch {
+        console.log(chalk15.red("  Failed to install hub tools\n"));
+      }
+    }
+    for (const repo of config.repos) {
+      if (!repo.tools || Object.keys(repo.tools).length === 0) continue;
+      const repoDir = join16(hubDir, repo.path);
+      if (!existsSync13(repoDir)) {
+        console.log(chalk15.dim(`  ${repo.name}: not cloned, skipping`));
+        continue;
+      }
+      console.log(chalk15.yellow(`\u25B8 ${repo.name}`));
+      try {
+        execSync11("mise trust 2>/dev/null; mise install", {
+          cwd: repoDir,
+          stdio: "inherit"
+        });
+        console.log(chalk15.green("  Tools installed"));
+      } catch {
+        console.log(chalk15.red("  Failed to install tools"));
+      }
+    }
+    console.log(chalk15.green("\nAll tools installed!\n"));
+    console.log(chalk15.cyan("Make sure mise is activated in your shell:"));
+    console.log('  eval "$(mise activate zsh)"   # zsh');
+    console.log('  eval "$(mise activate bash)"  # bash\n');
+  })
+).addCommand(
+  new Command15("generate").description("Generate .mise.toml files from hub.yaml").action(async () => {
+    const hubDir = process.cwd();
+    const config = await loadHubConfig(hubDir);
+    if (!config.tools && !config.repos.some((r) => r.tools)) {
+      console.log(chalk15.yellow("\nNo tools defined in hub.yaml\n"));
+      return;
+    }
+    console.log(chalk15.blue("\n\u2501\u2501\u2501 Generating .mise.toml files \u2501\u2501\u2501\n"));
+    const count = await generateMiseFiles(config, hubDir);
+    console.log(chalk15.green(`
+Generated ${count} .mise.toml file(s)
+`));
+    console.log(chalk15.cyan("Install with: hub tools install\n"));
+  })
+).addCommand(
+  new Command15("check").description("Verify installed tool versions match hub.yaml").action(async () => {
+    const hubDir = process.cwd();
+    const config = await loadHubConfig(hubDir);
+    if (!config.tools && !config.repos.some((r) => r.tools)) {
+      console.log(chalk15.yellow("\nNo tools defined in hub.yaml\n"));
+      return;
+    }
+    console.log(chalk15.blue("\n\u2501\u2501\u2501 Checking tool versions \u2501\u2501\u2501\n"));
+    let allOk = true;
+    if (config.tools) {
+      console.log(chalk15.cyan("Hub tools:"));
+      for (const [tool, expected] of Object.entries(config.tools)) {
+        const actual = getInstalledVersion(tool);
+        if (!actual) {
+          console.log(chalk15.red(`  \u2717 ${tool}: not found (expected ${expected})`));
+          allOk = false;
+        } else if (actual.includes(expected) || expected.includes(extractVersion(actual))) {
+          console.log(chalk15.green(`  \u2713 ${tool} ${expected}`));
+        } else {
+          console.log(chalk15.yellow(`  \u26A0 ${tool}: ${extractVersion(actual)} (expected ${expected})`));
+          allOk = false;
+        }
+      }
+    }
+    for (const repo of config.repos) {
+      if (!repo.tools || Object.keys(repo.tools).length === 0) continue;
+      const repoDir = join16(hubDir, repo.path);
+      if (!existsSync13(repoDir)) {
+        console.log(chalk15.dim(`
+  ${repo.name}: not cloned`));
+        continue;
+      }
+      console.log(chalk15.yellow(`
+  \u25B8 ${repo.name}`));
+      for (const [tool, expected] of Object.entries(repo.tools)) {
+        const actual = getInstalledVersion(tool);
+        if (!actual) {
+          console.log(chalk15.red(`    \u2717 ${tool}: not found (expected ${expected})`));
+          allOk = false;
+        } else if (actual.includes(expected) || expected.includes(extractVersion(actual))) {
+          console.log(chalk15.green(`    \u2713 ${tool} ${expected}`));
+        } else {
+          console.log(chalk15.yellow(`    \u26A0 ${tool}: ${extractVersion(actual)} (expected ${expected})`));
+          allOk = false;
+        }
+      }
+    }
+    console.log();
+    if (allOk) {
+      console.log(chalk15.green("All tool versions match!\n"));
+    } else {
+      console.log(chalk15.red("Some tools are missing or have wrong versions.\n"));
+      console.log(chalk15.cyan("Fix with: hub tools install --generate\n"));
+    }
+  })
+);
+function getInstalledVersion(tool) {
+  const cmds = {
+    node: "node --version",
+    pnpm: "pnpm --version",
+    yarn: "yarn --version",
+    erlang: "erl +V 2>&1",
+    elixir: "elixir --version",
+    ruby: "ruby --version",
+    python: "python3 --version",
+    go: "go version",
+    rust: "rustc --version",
+    direnv: "direnv --version",
+    java: "java --version"
+  };
+  const cmd = cmds[tool] || `${tool} --version`;
+  try {
+    return execSync11(cmd, {
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf-8"
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function extractVersion(s) {
+  const match = s.match(/(\d+\.\d+[.\d]*)/);
+  return match?.[1] || s;
+}
+
+// src/index.ts
+var program = new Command16();
+program.name("hub").description(
+  "Give your AI coding assistant the full picture. Multi-repo context, agent orchestration, and end-to-end workflows."
+).version("0.1.0");
+program.addCommand(initCommand);
+program.addCommand(addRepoCommand);
+program.addCommand(setupCommand);
+program.addCommand(generateCommand);
+program.addCommand(envCommand);
+program.addCommand(servicesCommand);
+program.addCommand(skillsCommand);
+program.addCommand(agentsCommand);
+program.addCommand(hooksCommand);
+program.addCommand(commandsCommand);
+program.addCommand(registryCommand);
+program.addCommand(pullCommand);
+program.addCommand(statusCommand);
+program.addCommand(execCommand);
+program.addCommand(worktreeCommand);
+program.addCommand(doctorCommand);
+program.addCommand(toolsCommand);
+program.parse();