@arvoretech/hub 0.6.0 → 0.6.1

package/dist/chunk-BLVKDXNY.js

@@ -0,0 +1,1175 @@
+// src/commands/generate.ts
+import { Command } from "commander";
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir2, writeFile as writeFile2, readdir as readdir2, copyFile, readFile as readFile3, cp } from "fs/promises";
+import { join as join3, resolve } from "path";
+import chalk2 from "chalk";
+import inquirer from "inquirer";
+
+// src/core/hub-config.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { parse } from "yaml";
+async function loadHubConfig(dir) {
+  const configPath = join(dir, "hub.yaml");
+  const content = await readFile(configPath, "utf-8");
+  return parse(content);
+}
+
+// src/core/hub-cache.ts
+import { createHash } from "crypto";
+import { existsSync } from "fs";
+import { mkdir, readdir, readFile as readFile2, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+import chalk from "chalk";
+var HUB_DIR = ".hub";
+var CONFIG_FILE = "config.json";
+async function readCache(hubDir) {
+  const filePath = join2(hubDir, HUB_DIR, CONFIG_FILE);
+  if (!existsSync(filePath)) return {};
+  try {
+    const content = await readFile2(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function writeCache(hubDir, cache) {
+  const dir = join2(hubDir, HUB_DIR);
+  await mkdir(dir, { recursive: true });
+  await writeFile(join2(dir, CONFIG_FILE), JSON.stringify(cache, null, 2) + "\n", "utf-8");
+}
+async function getSavedEditor(hubDir) {
+  const cache = await readCache(hubDir);
+  return cache.editor;
+}
+async function collectFileHashes(dir, extensions) {
+  if (!existsSync(dir)) return [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  const hashes = [];
+  for (const entry of entries) {
+    const fullPath = join2(dir, entry.name);
+    if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(ext))) {
+      const content = await readFile2(fullPath, "utf-8");
+      hashes.push(`${entry.name}:${createHash("sha256").update(content).digest("hex")}`);
+    } else if (entry.isDirectory()) {
+      const subHashes = await collectFileHashes(fullPath, extensions);
+      hashes.push(...subHashes.map((h) => `${entry.name}/${h}`));
+    }
+  }
+  return hashes.sort();
+}
+async function computeInputsHash(hubDir) {
+  const parts = [];
+  const hubYamlPath = join2(hubDir, "hub.yaml");
+  if (existsSync(hubYamlPath)) {
+    const content = await readFile2(hubYamlPath, "utf-8");
+    parts.push(`hub.yaml:${createHash("sha256").update(content).digest("hex")}`);
+  }
+  const dirs = ["agents", "skills", "hooks", "commands"];
+  for (const dir of dirs) {
+    const dirHashes = await collectFileHashes(join2(hubDir, dir), [".md", ".sh"]);
+    parts.push(...dirHashes.map((h) => `${dir}/${h}`));
+  }
+  return createHash("sha256").update(parts.join("\n")).digest("hex");
+}
+async function saveGenerateState(hubDir, editor) {
+  const hash = await computeInputsHash(hubDir);
+  const cache = await readCache(hubDir);
+  cache.editor = editor;
+  cache.lastGenerate = {
+    hash,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    editor
+  };
+  await writeCache(hubDir, cache);
+}
+async function checkOutdated(hubDir) {
+  const cache = await readCache(hubDir);
+  if (!cache.lastGenerate) {
+    return { outdated: false, reason: "no-previous-generate" };
+  }
+  const currentHash = await computeInputsHash(hubDir);
+  if (currentHash !== cache.lastGenerate.hash) {
+    return {
+      outdated: true,
+      editor: cache.editor,
+      reason: "inputs-changed"
+    };
+  }
+  return { outdated: false, editor: cache.editor };
+}
+async function checkAndAutoRegenerate(hubDir) {
+  try {
+    const result = await checkOutdated(hubDir);
+    if (!result.outdated) return;
+    if (!result.editor) {
+      console.log(
+        chalk.yellow(
+          "\n  Configs are outdated. Run 'hub generate' to regenerate.\n"
+        )
+      );
+      return;
+    }
+    console.log(chalk.yellow("\n  Detected outdated configs, auto-regenerating..."));
+    const { generators: generators2 } = await import("./generate-G3ZOX55F.js");
+    const generator = generators2[result.editor];
+    if (!generator) {
+      console.log(chalk.red(`  Unknown editor '${result.editor}' in cache. Run 'hub generate' manually.`));
+      return;
+    }
+    const config = await loadHubConfig(hubDir);
+    await generator.generate(config, hubDir);
+    await saveGenerateState(hubDir, result.editor);
+    console.log(chalk.green("  Auto-regeneration complete!\n"));
+  } catch (err) {
+    console.log(chalk.yellow(`  Auto-regeneration failed: ${err.message}`));
+    console.log(chalk.dim("  Run 'hub generate' manually to fix.\n"));
+  }
+}
+
+// src/commands/generate.ts
+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 = join3(cursorDir, "commands");
+  let count = 0;
+  if (config.commands_dir) {
+    const srcDir = resolve(hubDir, config.commands_dir);
+    try {
+      const files = await readdir2(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(join3(srcDir, file), join3(commandsDir, file));
+          count++;
+        }
+      }
+    } catch {
+      console.log(chalk2.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 = join3(commandsDir, name.endsWith(".md") ? name : `${name}.md`);
+      try {
+        await copyFile(src, dest);
+        count++;
+      } catch {
+        console.log(chalk2.yellow(`  Command file ${filePath} not found, skipping`));
+      }
+    }
+  }
+  if (count > 0) {
+    console.log(chalk2.green(`  Copied ${count} commands to .cursor/commands/`));
+  }
+}
+async function writeManagedFile(filePath, managedLines) {
+  const managedBlock = [HUB_MARKER_START, ...managedLines, HUB_MARKER_END].join("\n");
+  if (existsSync2(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 writeFile2(filePath, before + managedBlock + after, "utf-8");
+      return;
+    }
+    await writeFile2(filePath, managedBlock + "\n\n" + existing, "utf-8");
+    return;
+  }
+  await writeFile2(filePath, managedBlock + "\n", "utf-8");
+}
+async function generateCursor(config, hubDir) {
+  const cursorDir = join3(hubDir, ".cursor");
+  await mkdir2(join3(cursorDir, "rules"), { recursive: true });
+  await mkdir2(join3(cursorDir, "agents"), { recursive: true });
+  const gitignoreLines = buildGitignoreLines(config);
+  await writeManagedFile(join3(hubDir, ".gitignore"), gitignoreLines);
+  console.log(chalk2.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(join3(hubDir, ".cursorignore"), cursorignoreLines);
+  console.log(chalk2.green("  Generated .cursorignore"));
+  if (config.mcps?.length) {
+    const mcpConfig = {};
+    for (const mcp of config.mcps) {
+      mcpConfig[mcp.name] = buildCursorMcpEntry(mcp);
+    }
+    await writeFile2(
+      join3(cursorDir, "mcp.json"),
+      JSON.stringify({ mcpServers: mcpConfig }, null, 2) + "\n",
+      "utf-8"
+    );
+    console.log(chalk2.green("  Generated .cursor/mcp.json"));
+  }
+  const orchestratorRule = buildOrchestratorRule(config);
+  await writeFile2(join3(cursorDir, "rules", "orchestrator.mdc"), orchestratorRule, "utf-8");
+  console.log(chalk2.green("  Generated .cursor/rules/orchestrator.mdc"));
+  const agentsDir = resolve(hubDir, "agents");
+  try {
+    const agentFiles = await readdir2(agentsDir);
+    const mdFiles = agentFiles.filter((f) => f.endsWith(".md"));
+    for (const file of mdFiles) {
+      await copyFile(join3(agentsDir, file), join3(cursorDir, "agents", file));
+    }
+    console.log(chalk2.green(`  Copied ${mdFiles.length} agent definitions`));
+  } catch {
+    console.log(chalk2.yellow("  No agents/ directory found, skipping agent copy"));
+  }
+  const skillsDir = resolve(hubDir, "skills");
+  try {
+    const skillFolders = await readdir2(skillsDir);
+    const cursorSkillsDir = join3(cursorDir, "skills");
+    await mkdir2(cursorSkillsDir, { recursive: true });
+    let count = 0;
+    for (const folder of skillFolders) {
+      const skillFile = join3(skillsDir, folder, "SKILL.md");
+      try {
+        await readFile3(skillFile);
+        const srcDir = join3(skillsDir, folder);
+        const targetDir = join3(cursorSkillsDir, folder);
+        await cp(srcDir, targetDir, { recursive: true });
+        count++;
+      } catch {
+      }
+    }
+    if (count > 0) {
+      console.log(chalk2.green(`  Copied ${count} skills`));
+    }
+  } catch {
+  }
+  if (config.hooks) {
+    const cursorHooks = buildCursorHooks(config.hooks);
+    if (cursorHooks) {
+      await writeFile2(
+        join3(cursorDir, "hooks.json"),
+        JSON.stringify(cursorHooks, null, 2) + "\n",
+        "utf-8"
+      );
+      console.log(chalk2.green("  Generated .cursor/hooks.json"));
+    }
+  }
+  await generateCursorCommands(config, hubDir, cursorDir);
+  await generateVSCodeSettings(config, hubDir);
+}
+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 enforce = config.workflow?.enforce_workflow ?? false;
+  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 (enforce) {
+    sections.push(`
+## STRICT WORKFLOW ENFORCEMENT
+
+**YOU MUST FOLLOW THE PIPELINE DEFINED BELOW. NO EXCEPTIONS.**
+
+- NEVER skip a pipeline step, even if the task seems simple or obvious.
+- ALWAYS execute steps in the exact order defined. Do not reorder, merge, or parallelize steps unless the pipeline explicitly allows it.
+- ALWAYS follow the designated steering file for each step. Do not improvise if a steering file is assigned.
+- ALWAYS wait for a step to complete and validate its output before moving to the next step.
+- If a step produces a document, READ the document and confirm it is complete before proceeding.
+- If a step has unanswered questions or validation issues, RESOLVE them before advancing.
+- NEVER jump directly to coding without completing refinement first.
+- NEVER skip review or QA steps, even for small changes.
+- If the user asks you to skip a step, explain why the pipeline exists and ask for explicit confirmation before proceeding.`);
+  }
+  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()}`);
+  }
+  if (config.memory) {
+    sections.push(`
+## Team Memory
+
+This workspace has a team memory knowledge base available via the \`team-memory\` MCP.
+
+**Before starting any task**, use \`search_memories\` to find relevant context \u2014 past decisions, conventions, known issues, and domain knowledge. This avoids repeating mistakes and ensures consistency with previous choices.
+
+**After completing a task**, if you discovered something valuable (a decision, a gotcha, a convention, domain insight), use \`add_memory\` to capture it for the team.
+
+Available tools: \`search_memories\`, \`get_memory\`, \`add_memory\`, \`list_memories\`, \`archive_memory\`, \`remove_memory\`.`);
+  }
+  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.mode === "plan") {
+      parts.push(`**This step is a planning phase.** Do NOT make any code changes. Focus on reading, analyzing, and collaborating with the user to define requirements before proceeding.`);
+      parts.push(``);
+    }
+    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 enforce = config.workflow?.enforce_workflow ?? false;
+  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 (enforce) {
+    sections.push(`
+## STRICT WORKFLOW ENFORCEMENT
+
+**YOU MUST FOLLOW THE PIPELINE DEFINED BELOW. NO EXCEPTIONS.**
+
+- NEVER skip a pipeline step, even if the task seems simple or obvious.
+- ALWAYS execute steps in the exact order defined. Do not reorder, merge, or parallelize steps unless the pipeline explicitly allows it.
+- ALWAYS call the designated sub-agent for each step. Do not attempt to perform a step yourself if an agent is assigned to it.
+- ALWAYS wait for a step to complete and validate its output before moving to the next step.
+- If a step produces a document, READ the document and confirm it is complete before proceeding.
+- If a step has unanswered questions or validation issues, RESOLVE them before advancing.
+- NEVER jump directly to coding without completing refinement first.
+- NEVER skip review or QA steps, even for small changes.
+- If the user asks you to skip a step, explain why the pipeline exists and ask for explicit confirmation before proceeding.`);
+  }
+  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()}`);
+  }
+  if (config.memory) {
+    sections.push(`
+## Team Memory
+
+This workspace has a team memory knowledge base available via the \`team-memory\` MCP.
+
+**Before starting any task**, use \`search_memories\` to find relevant context \u2014 past decisions, conventions, known issues, and domain knowledge. This avoids repeating mistakes and ensures consistency with previous choices.
+
+**After completing a task**, if you discovered something valuable (a decision, a gotcha, a convention, domain insight), use \`add_memory\` to capture it for the team.
+
+Available tools: \`search_memories\`, \`get_memory\`, \`add_memory\`, \`list_memories\`, \`archive_memory\`, \`remove_memory\`.`);
+  }
+  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.mode === "plan") {
+      parts.push(`**Before starting this step, switch to Plan Mode** by calling \`SwitchMode\` with \`target_mode_id: "plan"\`. This ensures collaborative planning with the user in a read-only context before any implementation begins.`);
+      parts.push(``);
+    }
+    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.`);
+      }
+    }
+    if (step.mode === "plan") {
+      parts.push(`
+**After this step is complete and approved**, switch back to Agent Mode to proceed with the next step.`);
+    }
+    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 = join3(hubDir, ".claude");
+  await mkdir2(join3(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 readdir2(agentsDir);
+    const mdFiles = agentFiles.filter((f) => f.endsWith(".md"));
+    for (const file of mdFiles) {
+      await copyFile(join3(agentsDir, file), join3(claudeDir, "agents", file));
+    }
+    console.log(chalk2.green(`  Copied ${mdFiles.length} agents to .claude/agents/`));
+  } catch {
+    console.log(chalk2.yellow("  No agents/ directory found, skipping agent copy"));
+  }
+  const skillsDir = resolve(hubDir, "skills");
+  try {
+    const skillFolders = await readdir2(skillsDir);
+    const claudeSkillsDir = join3(claudeDir, "skills");
+    await mkdir2(claudeSkillsDir, { recursive: true });
+    let count = 0;
+    for (const folder of skillFolders) {
+      const skillFile = join3(skillsDir, folder, "SKILL.md");
+      try {
+        await readFile3(skillFile);
+        const srcDir = join3(skillsDir, folder);
+        const targetDir = join3(claudeSkillsDir, folder);
+        await cp(srcDir, targetDir, { recursive: true });
+        count++;
+      } catch {
+      }
+    }
+    if (count > 0) {
+      console.log(chalk2.green(`  Copied ${count} skills to .claude/skills/`));
+    }
+  } catch {
+  }
+  await writeFile2(join3(hubDir, "CLAUDE.md"), claudeMdSections.join("\n"), "utf-8");
+  console.log(chalk2.green("  Generated CLAUDE.md"));
+  if (config.mcps?.length) {
+    const mcpJson = {};
+    for (const mcp of config.mcps) {
+      mcpJson[mcp.name] = buildClaudeCodeMcpEntry(mcp);
+    }
+    await writeFile2(
+      join3(hubDir, ".mcp.json"),
+      JSON.stringify({ mcpServers: mcpJson }, null, 2) + "\n",
+      "utf-8"
+    );
+    console.log(chalk2.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 writeFile2(
+    join3(claudeDir, "settings.json"),
+    JSON.stringify(claudeSettings, null, 2) + "\n",
+    "utf-8"
+  );
+  console.log(chalk2.green("  Generated .claude/settings.json"));
+  const gitignoreLines = buildGitignoreLines(config);
+  await writeManagedFile(join3(hubDir, ".gitignore"), gitignoreLines);
+  console.log(chalk2.green("  Generated .gitignore"));
+}
+async function generateKiro(config, hubDir) {
+  const kiroDir = join3(hubDir, ".kiro");
+  const steeringDir = join3(kiroDir, "steering");
+  const settingsDir = join3(kiroDir, "settings");
+  await mkdir2(steeringDir, { recursive: true });
+  await mkdir2(settingsDir, { recursive: true });
+  const gitignoreLines = buildGitignoreLines(config);
+  await writeManagedFile(join3(hubDir, ".gitignore"), gitignoreLines);
+  console.log(chalk2.green("  Generated .gitignore"));
+  const kiroRule = buildKiroOrchestratorRule(config);
+  const kiroOrchestrator = buildKiroSteeringContent(kiroRule);
+  await writeFile2(join3(steeringDir, "orchestrator.md"), kiroOrchestrator, "utf-8");
+  console.log(chalk2.green("  Generated .kiro/steering/orchestrator.md"));
+  await writeFile2(join3(hubDir, "AGENTS.md"), kiroRule + "\n", "utf-8");
+  console.log(chalk2.green("  Generated AGENTS.md"));
+  const agentsDir = resolve(hubDir, "agents");
+  try {
+    const agentFiles = await readdir2(agentsDir);
+    const mdFiles = agentFiles.filter((f) => f.endsWith(".md"));
+    for (const file of mdFiles) {
+      const agentContent = await readFile3(join3(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 writeFile2(join3(steeringDir, steeringName), steeringContent, "utf-8");
+    }
+    console.log(chalk2.green(`  Copied ${mdFiles.length} agents as steering files`));
+  } catch {
+    console.log(chalk2.yellow("  No agents/ directory found, skipping agent copy"));
+  }
+  const skillsDir = resolve(hubDir, "skills");
+  try {
+    const skillFolders = await readdir2(skillsDir);
+    const kiroSkillsDir = join3(kiroDir, "skills");
+    await mkdir2(kiroSkillsDir, { recursive: true });
+    let count = 0;
+    for (const folder of skillFolders) {
+      const skillFile = join3(skillsDir, folder, "SKILL.md");
+      try {
+        await readFile3(skillFile);
+        const srcDir = join3(skillsDir, folder);
+        const targetDir = join3(kiroSkillsDir, folder);
+        await cp(srcDir, targetDir, { recursive: true });
+        count++;
+      } catch {
+      }
+    }
+    if (count > 0) {
+      console.log(chalk2.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 writeFile2(
+      join3(settingsDir, "mcp.json"),
+      JSON.stringify({ mcpServers: mcpConfig }, null, 2) + "\n",
+      "utf-8"
+    );
+    console.log(chalk2.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(chalk2.yellow(`  Note: Kiro hooks are managed via the Kiro panel UI.`));
+      console.log(chalk2.yellow(`  The following hooks should be configured manually:`));
+      for (const note of hookNotes) {
+        console.log(chalk2.yellow(`    ${note}`));
+      }
+    }
+  }
+  await generateVSCodeSettings(config, hubDir);
+}
+async function generateVSCodeSettings(config, hubDir) {
+  const vscodeDir = join3(hubDir, ".vscode");
+  await mkdir2(vscodeDir, { recursive: true });
+  const settingsPath = join3(vscodeDir, "settings.json");
+  let existing = {};
+  if (existsSync2(settingsPath)) {
+    try {
+      const raw = await readFile3(settingsPath, "utf-8");
+      existing = JSON.parse(raw);
+    } catch {
+      existing = {};
+    }
+  }
+  const managed = {
+    "git.autoRepositoryDetection": true,
+    "git.detectSubmodules": true,
+    "git.detectSubmodulesLimit": Math.max(config.repos.length * 2, 20)
+  };
+  const merged = { ...existing, ...managed };
+  await writeFile2(settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  console.log(chalk2.green("  Generated .vscode/settings.json (git multi-repo detection)"));
+}
+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(
+    "",
+    "# Hub local cache",
+    ".hub/",
+    "",
+    "# Docker volumes",
+    "*_data/",
+    "",
+    "# Environment files",
+    "*.env",
+    "*.env.local",
+    "!.env.example",
+    "",
+    "# Generated files",
+    "docker-compose.yml",
+    "",
+    "# Task documents",
+    "tasks/"
+  );
+  if (config.memory) {
+    const memPath = config.memory.path || "memories";
+    lines.push(
+      "",
+      "# Memory vector store (generated from markdown files)",
+      `${memPath}/.lancedb/`
+    );
+  }
+  return lines;
+}
+var generators = {
+  cursor: { name: "Cursor", generate: generateCursor },
+  "claude-code": { name: "Claude Code", generate: generateClaudeCode },
+  kiro: { name: "Kiro", generate: generateKiro }
+};
+async function resolveEditor(opts) {
+  const hubDir = process.cwd();
+  if (opts.resetEditor) {
+    const { editor: editor2 } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "editor",
+        message: "Which editor do you use?",
+        choices: Object.entries(generators).map(([key, gen]) => ({
+          name: gen.name,
+          value: key
+        }))
+      }
+    ]);
+    return editor2;
+  }
+  if (opts.editor) return opts.editor;
+  const saved = await getSavedEditor(hubDir);
+  if (saved) return saved;
+  const { editor } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "editor",
+      message: "No editor preference saved. Which editor do you use?",
+      choices: Object.entries(generators).map(([key, gen]) => ({
+        name: gen.name,
+        value: key
+      }))
+    }
+  ]);
+  return editor;
+}
+var generateCommand = new Command("generate").description("Generate editor-specific configuration files from hub.yaml").option("-e, --editor <editor>", "Target editor (cursor, claude-code, kiro)").option("--reset-editor", "Reset saved editor preference and choose again").action(async (opts) => {
+  const hubDir = process.cwd();
+  const config = await loadHubConfig(hubDir);
+  if (config.memory) {
+    const hasMemoryMcp = config.mcps?.some(
+      (m) => m.name === "team-memory" || m.package === "@arvoretech/memory-mcp"
+    );
+    if (!hasMemoryMcp) {
+      console.log(chalk2.red(`
+  Error: 'memory' is configured but no memory MCP is declared in 'mcps'.
+`));
+      console.log(chalk2.yellow(`  Add this to your hub.yaml:
+`));
+      console.log(chalk2.dim(`  mcps:`));
+      console.log(chalk2.dim(`    - name: team-memory`));
+      console.log(chalk2.dim(`      package: "@arvoretech/memory-mcp"`));
+      console.log(chalk2.dim(`      env:`));
+      console.log(chalk2.dim(`        MEMORY_PATH: ${config.memory.path || "./memories"}
+`));
+      process.exit(1);
+    }
+  }
+  const editorKey = await resolveEditor(opts);
+  const generator = generators[editorKey];
+  if (!generator) {
+    console.log(
+      chalk2.red(`Unknown editor: ${editorKey}. Available: ${Object.keys(generators).join(", ")}`)
+    );
+    return;
+  }
+  if (opts.editor || opts.resetEditor) {
+    console.log(chalk2.dim(`  Saving editor preference: ${generator.name}`));
+  }
+  console.log(chalk2.blue(`
+Generating ${generator.name} configuration
+`));
+  await generator.generate(config, hubDir);
+  await saveGenerateState(hubDir, editorKey);
+  console.log(chalk2.green("\nDone!\n"));
+});
+
+export {
+  loadHubConfig,
+  generators,
+  generateCommand,
+  checkAndAutoRegenerate
+};