@arvoretech/hub 0.6.2 → 0.6.3

package/dist/{chunk-BLVKDXNY.js → chunk-U5G47GMH.js}

@@ -112,7 +112,7 @@ async function checkAndAutoRegenerate(hubDir) {
       return;
     }
     console.log(chalk.yellow("\n  Detected outdated configs, auto-regenerating..."));
-    const { generators: generators2 } = await import("./generate-G3ZOX55F.js");
+    const { generators: generators2 } = await import("./generate-67HCNILJ.js");
     const generator = generators2[result.editor];
     if (!generator) {
       console.log(chalk.red(`  Unknown editor '${result.editor}' in cache. Run 'hub generate' manually.`));
@@ -132,30 +132,30 @@ async function checkAndAutoRegenerate(hubDir) {
 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 }
+  session_start: { cursor: "sessionStart", claude: "SessionStart", kiro: void 0, opencode: "session.created" },
+  session_end: { cursor: "sessionEnd", claude: "SessionEnd", kiro: void 0, opencode: "session.idle" },
+  pre_tool_use: { cursor: "preToolUse", claude: "PreToolUse", kiro: "pre_tool_use", opencode: "tool.execute.before" },
+  post_tool_use: { cursor: "postToolUse", claude: "PostToolUse", kiro: "post_tool_use", opencode: "tool.execute.after" },
+  post_tool_use_failure: { cursor: void 0, claude: "PostToolUseFailure", kiro: void 0, opencode: void 0 },
+  stop: { cursor: "stop", claude: "Stop", kiro: "agent_stop", opencode: "session.idle" },
+  subagent_start: { cursor: "subagentStart", claude: "SubagentStart", kiro: void 0, opencode: void 0 },
+  subagent_stop: { cursor: "subagentStop", claude: "SubagentStop", kiro: void 0, opencode: void 0 },
+  pre_compact: { cursor: "preCompact", claude: "PreCompact", kiro: void 0, opencode: "session.compacted" },
+  before_submit_prompt: { cursor: "beforeSubmitPrompt", claude: "UserPromptSubmit", kiro: "prompt_submit", opencode: void 0 },
+  before_shell_execution: { cursor: "beforeShellExecution", claude: void 0, kiro: void 0, opencode: "tool.execute.before" },
+  after_shell_execution: { cursor: "afterShellExecution", claude: void 0, kiro: void 0, opencode: "tool.execute.after" },
+  before_mcp_execution: { cursor: "beforeMCPExecution", claude: void 0, kiro: void 0, opencode: "tool.execute.before" },
+  after_mcp_execution: { cursor: "afterMCPExecution", claude: void 0, kiro: void 0, opencode: "tool.execute.after" },
+  after_file_edit: { cursor: "afterFileEdit", claude: void 0, kiro: "file_save", opencode: "file.edited" },
+  before_read_file: { cursor: "beforeReadFile", claude: void 0, kiro: void 0, opencode: void 0 },
+  before_tab_file_read: { cursor: "beforeTabFileRead", claude: void 0, kiro: void 0, opencode: void 0 },
+  after_tab_file_edit: { cursor: "afterTabFileEdit", claude: void 0, kiro: void 0, opencode: "file.edited" },
+  after_agent_response: { cursor: "afterAgentResponse", claude: void 0, kiro: void 0, opencode: void 0 },
+  after_agent_thought: { cursor: "afterAgentThought", claude: void 0, kiro: void 0, opencode: void 0 },
+  notification: { cursor: void 0, claude: "Notification", kiro: void 0, opencode: void 0 },
+  permission_request: { cursor: void 0, claude: "PermissionRequest", kiro: void 0, opencode: "permission.asked" },
+  task_completed: { cursor: void 0, claude: "TaskCompleted", kiro: void 0, opencode: "session.idle" },
+  teammate_idle: { cursor: void 0, claude: "TeammateIdle", kiro: void 0, opencode: void 0 }
 };
 function buildCursorHooks(hooks) {
   const cursorHooks = {};
@@ -197,8 +197,8 @@ function buildClaudeHooks(hooks) {
   if (Object.keys(claudeHooks).length === 0) return null;
   return claudeHooks;
 }
-async function generateCursorCommands(config, hubDir, cursorDir) {
-  const commandsDir = join3(cursorDir, "commands");
+async function generateEditorCommands(config, hubDir, targetDir, editorName) {
+  const commandsDir = join3(targetDir, "commands");
   let count = 0;
   if (config.commands_dir) {
     const srcDir = resolve(hubDir, config.commands_dir);
@@ -230,7 +230,7 @@ async function generateCursorCommands(config, hubDir, cursorDir) {
     }
   }
   if (count > 0) {
-    console.log(chalk2.green(`  Copied ${count} commands to .cursor/commands/`));
+    console.log(chalk2.green(`  Copied ${count} commands to ${editorName}`));
   }
 }
 async function writeManagedFile(filePath, managedLines) {
@@ -326,7 +326,7 @@ async function generateCursor(config, hubDir) {
       console.log(chalk2.green("  Generated .cursor/hooks.json"));
     }
   }
-  await generateCursorCommands(config, hubDir, cursorDir);
+  await generateEditorCommands(config, hubDir, cursorDir, ".cursor/commands/");
   await generateVSCodeSettings(config, hubDir);
 }
 function buildCursorMcpEntry(mcp) {
@@ -389,6 +389,325 @@ function buildKiroMcpEntry(mcp) {
     ...mcp.env && { env: mcp.env }
   };
 }
+function buildOpenCodeMcpEntry(mcp) {
+  if (mcp.url) {
+    return { type: "remote", url: mcp.url };
+  }
+  if (mcp.image) {
+    const cmd = ["docker", "run", "-i", "--rm"];
+    if (mcp.env) {
+      for (const [key, value] of Object.entries(mcp.env)) {
+        cmd.push("-e", `${key}=${value}`);
+      }
+    }
+    cmd.push(mcp.image);
+    return { type: "local", command: cmd, ...mcp.env && { environment: mcp.env } };
+  }
+  return {
+    type: "local",
+    command: ["npx", "-y", mcp.package],
+    ...mcp.env && { environment: mcp.env }
+  };
+}
+function buildOpenCodeHooksPlugin(hooks) {
+  const handlers = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [event, entries] of Object.entries(hooks)) {
+    const mapped = HOOK_EVENT_MAP[event]?.opencode;
+    if (!mapped || seen.has(mapped)) continue;
+    seen.add(mapped);
+    const commandEntries = entries.filter((e) => e.type === "command" && e.command);
+    if (commandEntries.length === 0) continue;
+    const cmds = commandEntries.map((e) => JSON.stringify(e.command));
+    handlers.push(`    "${mapped}": async (input, output) => {
+      for (const cmd of [${cmds.join(", ")}]) {
+        try { await $\`\${cmd}\`; } catch (e) { console.error("Hook failed:", cmd, e); }
+      }
+    }`);
+  }
+  if (handlers.length === 0) return null;
+  return `// Auto-generated by hub \u2014 maps hub.yaml hooks to OpenCode plugin events
+export const HubHooksPlugin = async ({ $ }) => {
+  return {
+${handlers.join(",\n")}
+  };
+};
+`;
+}
+function buildOpenCodeAgentMarkdown(name, content) {
+  const existingFrontmatter = content.match(/^---\n([\s\S]*?)\n---/);
+  let description = `Specialized agent for ${name} tasks`;
+  if (existingFrontmatter) {
+    const descMatch = existingFrontmatter[1].match(/^description:\s*["']?(.+?)["']?\s*$/m);
+    if (descMatch) description = descMatch[1];
+  }
+  const body = existingFrontmatter ? content.replace(/^---\n[\s\S]*?\n---\n*/, "") : content;
+  return `---
+description: "${description}"
+mode: subagent
+tools:
+  write: true
+  edit: true
+  bash: true
+---
+
+${body.trim()}
+`;
+}
+function buildOpenCodeOrchestratorRule(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 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. Use \`@agent-name\` to invoke sub-agents for each phase of the pipeline.`);
+  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 = buildOpenCodePipelineSection(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 buildOpenCodePipelineSection(steps) {
+  if (steps.length === 0) {
+    return `
+## Development Pipeline
+
+1. Use \`@refinement\` 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(`**This step is a planning phase.** Switch to the Plan agent (Tab key) for collaborative planning with the user before any implementation begins.`);
+      parts.push(``);
+    }
+    if (step.agent) {
+      parts.push(`Call \`@${step.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 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 Build agent to proceed with the next step.`);
+    }
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+async function generateOpenCode(config, hubDir) {
+  const opencodeDir = join3(hubDir, ".opencode");
+  await mkdir2(join3(opencodeDir, "agents"), { recursive: true });
+  await mkdir2(join3(opencodeDir, "rules"), { recursive: true });
+  await mkdir2(join3(opencodeDir, "skills"), { recursive: true });
+  await mkdir2(join3(opencodeDir, "commands"), { recursive: true });
+  await mkdir2(join3(opencodeDir, "plugins"), { recursive: true });
+  const gitignoreLines = buildGitignoreLines(config);
+  await writeManagedFile(join3(hubDir, ".gitignore"), gitignoreLines);
+  console.log(chalk2.green("  Generated .gitignore"));
+  const orchestratorRule = buildOpenCodeOrchestratorRule(config);
+  await writeFile2(join3(opencodeDir, "rules", "orchestrator.md"), orchestratorRule + "\n", "utf-8");
+  console.log(chalk2.green("  Generated .opencode/rules/orchestrator.md"));
+  const opencodeConfig = {
+    $schema: "https://opencode.ai/config.json"
+  };
+  if (config.mcps?.length) {
+    const mcpConfig = {};
+    for (const mcp of config.mcps) {
+      mcpConfig[mcp.name] = buildOpenCodeMcpEntry(mcp);
+    }
+    opencodeConfig.mcp = mcpConfig;
+  }
+  opencodeConfig.instructions = [".opencode/rules/*.md"];
+  await writeFile2(
+    join3(hubDir, "opencode.json"),
+    JSON.stringify(opencodeConfig, null, 2) + "\n",
+    "utf-8"
+  );
+  console.log(chalk2.green("  Generated opencode.json"));
+  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 content = await readFile3(join3(agentsDir, file), "utf-8");
+      const agentName = file.replace(/\.md$/, "");
+      const converted = buildOpenCodeAgentMarkdown(agentName, content);
+      await writeFile2(join3(opencodeDir, "agents", file), converted, "utf-8");
+    }
+    console.log(chalk2.green(`  Copied ${mdFiles.length} agents to .opencode/agents/`));
+  } catch {
+    console.log(chalk2.yellow("  No agents/ directory found, skipping agent copy"));
+  }
+  const skillsDir = resolve(hubDir, "skills");
+  try {
+    const skillFolders = await readdir2(skillsDir);
+    let count = 0;
+    for (const folder of skillFolders) {
+      const skillFile = join3(skillsDir, folder, "SKILL.md");
+      try {
+        await readFile3(skillFile);
+        await cp(join3(skillsDir, folder), join3(opencodeDir, "skills", folder), { recursive: true });
+        count++;
+      } catch {
+      }
+    }
+    if (count > 0) {
+      console.log(chalk2.green(`  Copied ${count} skills to .opencode/skills/`));
+    }
+  } catch {
+  }
+  await generateEditorCommands(config, hubDir, opencodeDir, ".opencode/commands/");
+  if (config.hooks) {
+    const plugin = buildOpenCodeHooksPlugin(config.hooks);
+    if (plugin) {
+      await writeFile2(join3(opencodeDir, "plugins", "hub-hooks.js"), plugin, "utf-8");
+      console.log(chalk2.green("  Generated .opencode/plugins/hub-hooks.js"));
+    }
+  }
+  await generateVSCodeSettings(config, hubDir);
+}
 function buildKiroSteeringContent(content, inclusion = "always", meta) {
   const frontMatter = ["---", `inclusion: ${inclusion}`];
   if (meta?.name) frontMatter.push(`name: ${meta.name}`);
@@ -1092,7 +1411,8 @@ function buildGitignoreLines(config) {
 var generators = {
   cursor: { name: "Cursor", generate: generateCursor },
   "claude-code": { name: "Claude Code", generate: generateClaudeCode },
-  kiro: { name: "Kiro", generate: generateKiro }
+  kiro: { name: "Kiro", generate: generateKiro },
+  opencode: { name: "OpenCode", generate: generateOpenCode }
 };
 async function resolveEditor(opts) {
   const hubDir = process.cwd();
@@ -1126,7 +1446,7 @@ async function resolveEditor(opts) {
   ]);
   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) => {
+var generateCommand = new Command("generate").description("Generate editor-specific configuration files from hub.yaml").option("-e, --editor <editor>", "Target editor (cursor, claude-code, kiro, opencode)").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) {

package/dist/{generate-G3ZOX55F.js → generate-67HCNILJ.js}

@@ -1,7 +1,7 @@
 import {
   generateCommand,
   generators
-} from "./chunk-BLVKDXNY.js";
+} from "./chunk-U5G47GMH.js";
 export {
   generateCommand,
   generators

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   checkAndAutoRegenerate,
   generateCommand,
   loadHubConfig
-} from "./chunk-BLVKDXNY.js";
+} from "./chunk-U5G47GMH.js";
 
 // src/index.ts
 import { Command as Command18 } from "commander";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arvoretech/hub",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "CLI for managing AI-aware multi-repository workspaces",
   "main": "dist/index.js",
   "type": "module",