@arvoretech/hub 0.6.3 → 0.7.4

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

@@ -43,6 +43,15 @@ async function getSavedEditor(hubDir) {
   const cache = await readCache(hubDir);
   return cache.editor;
 }
+async function getKiroMode(hubDir) {
+  const cache = await readCache(hubDir);
+  return cache.kiroMode;
+}
+async function saveKiroMode(hubDir, mode) {
+  const cache = await readCache(hubDir);
+  cache.kiroMode = mode;
+  await writeCache(hubDir, cache);
+}
 async function collectFileHashes(dir, extensions) {
   if (!existsSync(dir)) return [];
   const entries = await readdir(dir, { withFileTypes: true });
@@ -112,7 +121,7 @@ async function checkAndAutoRegenerate(hubDir) {
       return;
     }
     console.log(chalk.yellow("\n  Detected outdated configs, auto-regenerating..."));
-    const { generators: generators2 } = await import("./generate-67HCNILJ.js");
+    const { generators: generators2 } = await import("./generate-75QAGHLE.js");
     const generator = generators2[result.editor];
     if (!generator) {
       console.log(chalk.red(`  Unknown editor '${result.editor}' in cache. Run 'hub generate' manually.`));
@@ -129,6 +138,35 @@ async function checkAndAutoRegenerate(hubDir) {
 }
 
 // src/commands/generate.ts
+var HUB_DOCS_URL = "https://hub.arvore.com.br/llms-full.txt";
+function stripFrontMatter(content) {
+  const match = content.match(/^---\n[\s\S]*?\n---\n*/);
+  if (match) return content.slice(match[0].length);
+  return content;
+}
+async function fetchHubDocsSkill(skillsDir) {
+  try {
+    const res = await fetch(HUB_DOCS_URL);
+    if (!res.ok) {
+      console.log(chalk2.yellow(`  Could not fetch hub docs (${res.status}), skipping hub-docs skill`));
+      return;
+    }
+    const content = await res.text();
+    const hubSkillDir = join3(skillsDir, "hub-docs");
+    await mkdir2(hubSkillDir, { recursive: true });
+    const skillContent = `---
+name: hub-docs
+description: Repo Hub (rhm) documentation. Use when working with hub.yaml, hub CLI commands, agent orchestration, MCP configuration, skills, workflows, or multi-repo workspace setup.
+triggers: [hub, rhm, hub.yaml, generate, scan, setup, orchestrator, multi-repo, workspace]
+---
+
+${content}`;
+    await writeFile2(join3(hubSkillDir, "SKILL.md"), skillContent, "utf-8");
+    console.log(chalk2.green("  Fetched hub-docs skill from hub.arvore.com.br"));
+  } catch {
+    console.log(chalk2.yellow(`  Could not fetch hub docs, skipping hub-docs skill`));
+  }
+}
 var HUB_MARKER_START = "# >>> hub-managed (do not edit this section)";
 var HUB_MARKER_END = "# <<< hub-managed";
 var HOOK_EVENT_MAP = {
@@ -269,8 +307,14 @@ async function generateCursor(config, hubDir) {
   console.log(chalk2.green("  Generated .cursorignore"));
   if (config.mcps?.length) {
     const mcpConfig = {};
+    const upstreamSet = getUpstreamNames(config.mcps);
     for (const mcp of config.mcps) {
-      mcpConfig[mcp.name] = buildCursorMcpEntry(mcp);
+      if (upstreamSet.has(mcp.name)) continue;
+      if (mcp.upstreams?.length) {
+        mcpConfig[mcp.name] = buildProxyMcpEntry(mcp, config.mcps, buildCursorMcpEntry);
+      } else {
+        mcpConfig[mcp.name] = buildCursorMcpEntry(mcp);
+      }
     }
     await writeFile2(
       join3(cursorDir, "mcp.json"),
@@ -282,6 +326,27 @@ async function generateCursor(config, hubDir) {
   const orchestratorRule = buildOrchestratorRule(config);
   await writeFile2(join3(cursorDir, "rules", "orchestrator.mdc"), orchestratorRule, "utf-8");
   console.log(chalk2.green("  Generated .cursor/rules/orchestrator.mdc"));
+  const hubSteeringDirCursor = resolve(hubDir, "steering");
+  try {
+    const steeringFiles = await readdir2(hubSteeringDirCursor);
+    const mdFiles = steeringFiles.filter((f) => f.endsWith(".md"));
+    for (const file of mdFiles) {
+      const raw = await readFile3(join3(hubSteeringDirCursor, file), "utf-8");
+      const content = stripFrontMatter(raw);
+      const mdcName = file.replace(/\.md$/, ".mdc");
+      const mdcContent = `---
+description: "${file.replace(/\.md$/, "")}"
+alwaysApply: true
+---
+
+${content}`;
+      await writeFile2(join3(cursorDir, "rules", mdcName), mdcContent, "utf-8");
+    }
+    if (mdFiles.length > 0) {
+      console.log(chalk2.green(`  Copied ${mdFiles.length} steering files to .cursor/rules/`));
+    }
+  } catch {
+  }
   const agentsDir = resolve(hubDir, "agents");
   try {
     const agentFiles = await readdir2(agentsDir);
@@ -315,6 +380,9 @@ async function generateCursor(config, hubDir) {
     }
   } catch {
   }
+  const cursorSkillsDirForDocs = join3(cursorDir, "skills");
+  await mkdir2(cursorSkillsDirForDocs, { recursive: true });
+  await fetchHubDocsSkill(cursorSkillsDirForDocs);
   if (config.hooks) {
     const cursorHooks = buildCursorHooks(config.hooks);
     if (cursorHooks) {
@@ -329,6 +397,62 @@ async function generateCursor(config, hubDir) {
   await generateEditorCommands(config, hubDir, cursorDir, ".cursor/commands/");
   await generateVSCodeSettings(config, hubDir);
 }
+function buildProxyUpstreams(proxyMcp, allMcps) {
+  const upstreamNames = new Set(proxyMcp.upstreams || []);
+  const upstreamEntries = [];
+  const collectedEnv = {};
+  for (const mcp of allMcps) {
+    if (!upstreamNames.has(mcp.name)) continue;
+    if (mcp.url || mcp.image) continue;
+    const entry = {
+      name: mcp.name,
+      command: "npx",
+      args: ["-y", mcp.package]
+    };
+    if (mcp.env) {
+      entry.env = {};
+      for (const [key, value] of Object.entries(mcp.env)) {
+        const envRef = value.match(/^\$\{(?:env:)?(\w+)\}$/);
+        if (envRef) {
+          entry.env[key] = `\${${envRef[1]}}`;
+          collectedEnv[envRef[1]] = value;
+        } else {
+          entry.env[key] = value;
+          collectedEnv[key] = value;
+        }
+      }
+    }
+    upstreamEntries.push(entry);
+  }
+  if (proxyMcp.env) {
+    for (const [key, value] of Object.entries(proxyMcp.env)) {
+      collectedEnv[key] = value;
+    }
+  }
+  return {
+    upstreamsJson: JSON.stringify(upstreamEntries),
+    collectedEnv
+  };
+}
+function buildProxyMcpEntry(proxyMcp, allMcps, buildEntry) {
+  const { upstreamsJson, collectedEnv } = buildProxyUpstreams(proxyMcp, allMcps);
+  const env = {
+    MCP_PROXY_UPSTREAMS: upstreamsJson,
+    ...collectedEnv
+  };
+  return buildEntry({ ...proxyMcp, env });
+}
+function getUpstreamNames(mcps) {
+  const names = /* @__PURE__ */ new Set();
+  for (const mcp of mcps) {
+    if (mcp.upstreams) {
+      for (const name of mcp.upstreams) {
+        names.add(name);
+      }
+    }
+  }
+  return names;
+}
 function buildCursorMcpEntry(mcp) {
   if (mcp.url) {
     return { url: mcp.url, ...mcp.env && { env: mcp.env } };
@@ -369,14 +493,22 @@ function buildClaudeCodeMcpEntry(mcp) {
     ...mcp.env && { env: mcp.env }
   };
 }
-function buildKiroMcpEntry(mcp) {
+function stripEnvPrefix(env) {
+  const result = {};
+  for (const [key, value] of Object.entries(env)) {
+    result[key] = value.replace(/\$\{env:(\w+)\}/g, "${$1}");
+  }
+  return result;
+}
+function buildKiroMcpEntry(mcp, mode = "editor") {
+  const env = mcp.env ? mode === "editor" ? stripEnvPrefix(mcp.env) : mcp.env : void 0;
   if (mcp.url) {
-    return { url: mcp.url, ...mcp.env && { env: mcp.env } };
+    return { url: mcp.url, ...env && { env } };
   }
   if (mcp.image) {
     const args = ["run", "-i", "--rm"];
-    if (mcp.env) {
-      for (const [key, value] of Object.entries(mcp.env)) {
+    if (env) {
+      for (const [key, value] of Object.entries(env)) {
         args.push("-e", `${key}=${value}`);
       }
     }
@@ -386,9 +518,41 @@ function buildKiroMcpEntry(mcp) {
   return {
     command: "npx",
     args: ["-y", mcp.package],
-    ...mcp.env && { env: mcp.env }
+    ...env && { env }
   };
 }
+function buildKiroAgentContent(rawContent) {
+  const fmMatch = rawContent.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!fmMatch) {
+    return `---
+name: agent
+tools: ["@builtin"]
+---
+
+${rawContent}`;
+  }
+  const fmBlock = fmMatch[1];
+  const body = fmMatch[2];
+  const attrs = {};
+  for (const line of fmBlock.split("\n")) {
+    const match = line.match(/^(\w+):\s*(.+)$/);
+    if (match) attrs[match[1]] = match[2].trim();
+  }
+  const lines = ["---"];
+  if (attrs.name) lines.push(`name: ${attrs.name}`);
+  if (attrs.description) lines.push(`description: ${attrs.description}`);
+  if (attrs.tools) {
+    lines.push(`tools: ${attrs.tools}`);
+  } else {
+    lines.push(`tools: ["@builtin"]`);
+  }
+  if (attrs.model && attrs.model !== "inherit") {
+    lines.push(`model: ${attrs.model}`);
+  }
+  lines.push("---");
+  return `${lines.join("\n")}
+${body}`;
+}
 function buildOpenCodeMcpEntry(mcp) {
   if (mcp.url) {
     return { type: "remote", url: mcp.url };
@@ -454,6 +618,43 @@ tools:
 ${body.trim()}
 `;
 }
+function buildMcpToolsSection(mcps) {
+  if (!mcps || mcps.length === 0) return "";
+  const proxyMcp = mcps.find((m) => m.upstreams && m.upstreams.length > 0);
+  const upstreamNames = getUpstreamNames(mcps);
+  const directMcps = mcps.filter((m) => !m.upstreams && !upstreamNames.has(m.name));
+  if (!proxyMcp && directMcps.length === 0) return "";
+  const lines = [];
+  lines.push(`
+## MCP Tools (Model Context Protocol)
+
+This workspace has multiple MCP servers available.`);
+  if (proxyMcp) {
+    lines.push(`
+Some MCPs are aggregated behind a proxy (\`${proxyMcp.name}\`). Their tools are NOT directly visible \u2014 you must use \`mcp_search\` to discover available tools and \`mcp_call\` to execute them.
+
+**How to use proxied tools:**
+1. \`mcp_search({ query: "your search term" })\` \u2014 find tools by name or description
+2. \`mcp_call({ ref: "tool-ref-from-search", args: { ... } })\` \u2014 execute the tool
+
+**MCPs available via proxy:**`);
+    for (const name of proxyMcp.upstreams) {
+      lines.push(`- \`${name}\``);
+    }
+  }
+  if (directMcps.length > 0) {
+    lines.push(`
+**MCPs available directly:**`);
+    for (const mcp of directMcps) {
+      lines.push(`- \`${mcp.name}\``);
+    }
+  }
+  if (proxyMcp) {
+    lines.push(`
+> When you need a capability and are unsure which tool to use, always try \`mcp_search\` first with relevant keywords. The proxy aggregates tools from all upstream MCPs.`);
+  }
+  return lines.join("\n");
+}
 function buildOpenCodeOrchestratorRule(config) {
   const taskFolder = config.workflow?.task_folder || "./tasks/<TASK_ID>/";
   const steps = config.workflow?.pipeline || [];
@@ -525,6 +726,10 @@ ${prompt.sections.after_pipeline.trim()}`);
     sections.push(`
 ${prompt.sections.after_delivery.trim()}`);
   }
+  const mcpToolsSectionOpenCode = buildMcpToolsSection(config.mcps);
+  if (mcpToolsSectionOpenCode) {
+    sections.push(mcpToolsSectionOpenCode);
+  }
   if (config.memory) {
     sections.push(`
 ## Team Memory
@@ -649,13 +854,33 @@ async function generateOpenCode(config, hubDir) {
   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 hubSteeringDirOC = resolve(hubDir, "steering");
+  try {
+    const steeringFiles = await readdir2(hubSteeringDirOC);
+    const mdFiles = steeringFiles.filter((f) => f.endsWith(".md"));
+    for (const file of mdFiles) {
+      const raw = await readFile3(join3(hubSteeringDirOC, file), "utf-8");
+      const content = stripFrontMatter(raw);
+      await writeFile2(join3(opencodeDir, "rules", file), content, "utf-8");
+    }
+    if (mdFiles.length > 0) {
+      console.log(chalk2.green(`  Copied ${mdFiles.length} steering files to .opencode/rules/`));
+    }
+  } catch {
+  }
   const opencodeConfig = {
     $schema: "https://opencode.ai/config.json"
   };
   if (config.mcps?.length) {
     const mcpConfig = {};
+    const upstreamSet = getUpstreamNames(config.mcps);
     for (const mcp of config.mcps) {
-      mcpConfig[mcp.name] = buildOpenCodeMcpEntry(mcp);
+      if (upstreamSet.has(mcp.name)) continue;
+      if (mcp.upstreams?.length) {
+        mcpConfig[mcp.name] = buildProxyMcpEntry(mcp, config.mcps, buildOpenCodeMcpEntry);
+      } else {
+        mcpConfig[mcp.name] = buildOpenCodeMcpEntry(mcp);
+      }
     }
     opencodeConfig.mcp = mcpConfig;
   }
@@ -698,6 +923,7 @@ async function generateOpenCode(config, hubDir) {
     }
   } catch {
   }
+  await fetchHubDocsSkill(join3(opencodeDir, "skills"));
   await generateEditorCommands(config, hubDir, opencodeDir, ".opencode/commands/");
   if (config.hooks) {
     const plugin = buildOpenCodeHooksPlugin(config.hooks);
@@ -727,9 +953,9 @@ function buildKiroOrchestratorRule(config) {
 
 ## 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.
+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 delegate specialized work to subagents defined in \`.kiro/agents/\`.
 
-> **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.`);
+> **Note:** This workspace has custom subagents in \`.kiro/agents/\`. Each pipeline step delegates to the appropriate subagent. Use \`/agent-name\` or instruct Kiro to "use the X subagent" to invoke them.`);
   if (enforce) {
     sections.push(`
 ## STRICT WORKFLOW ENFORCEMENT
@@ -738,7 +964,7 @@ You are the development orchestrator. Your job is to ensure that any feature or
 
 - 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 use the designated subagent for each step. Do not improvise if a subagent 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.
@@ -790,6 +1016,10 @@ ${prompt.sections.after_pipeline.trim()}`);
     sections.push(`
 ${prompt.sections.after_delivery.trim()}`);
   }
+  const mcpToolsSectionKiro = buildMcpToolsSection(config.mcps);
+  if (mcpToolsSectionKiro) {
+    sections.push(mcpToolsSectionKiro);
+  }
   if (config.memory) {
     sections.push(`
 ## Team Memory
@@ -833,18 +1063,18 @@ function buildKiroPipelineSection(steps) {
     return `
 ## Development Pipeline
 
-Since Kiro does not support sub-agents, follow each step sequentially, applying the guidelines from the corresponding steering file:
+Follow each step sequentially, delegating to the appropriate subagent:
 
-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.
+1. **Refinement** \u2014 Use the \`refinement\` subagent to collect requirements. Write output to the task document.
+2. **Coding** \u2014 Use the \`coding-backend\` and \`coding-frontend\` subagents to implement the feature.
+3. **Review** \u2014 Use the \`code-reviewer\` subagent to review the implementation.
+4. **QA** \u2014 Use the \`qa-backend\` and/or \`qa-frontend\` subagents 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.
+Follow each step sequentially, delegating to the appropriate subagent at each phase.
 `];
   for (const step of steps) {
     if (step.actions) {
@@ -862,7 +1092,7 @@ Follow each step sequentially, applying the role-specific instructions from the
       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}\`.` : ""}`);
+      parts.push(`Use the \`${step.agent}\` subagent.${step.output ? ` Write output to \`${step.output}\`.` : ""}`);
       if (step.step === "refinement") {
         parts.push(`
 After completing the refinement, validate with the user:
@@ -876,9 +1106,9 @@ After completing the refinement, validate with the user:
         if (typeof a === "string") return { agent: a };
         return a;
       });
-      parts.push(`Follow the instructions from these steering files sequentially:`);
+      parts.push(`Use these subagents sequentially:`);
       for (const a of agentList) {
-        let line = `- \`agent-${a.agent}.md\``;
+        let line = `- \`${a.agent}\``;
         if (a.output) line += ` \u2192 write to \`${a.output}\``;
         if (a.when) line += ` (when: ${a.when})`;
         parts.push(line);
@@ -972,6 +1202,10 @@ ${prompt.sections.after_pipeline.trim()}`);
     sections.push(`
 ${prompt.sections.after_delivery.trim()}`);
   }
+  const mcpToolsSectionCursor = buildMcpToolsSection(config.mcps);
+  if (mcpToolsSectionCursor) {
+    sections.push(mcpToolsSectionCursor);
+  }
   if (config.memory) {
     sections.push(`
 ## Team Memory
@@ -1120,8 +1354,9 @@ function buildDeliverySection(config) {
 `];
   if (config.integrations?.github) {
     const gh = config.integrations.github;
+    const tool = gh.pr_tool === "mcp" ? "GitHub MCP" : "GitHub CLI";
     parts.push(`### Pull Requests`);
-    parts.push(`For each repository with changes, push the branch and create a PR using the GitHub MCP.`);
+    parts.push(`For each repository with changes, push the branch and create a PR using the ${tool}.`);
     if (gh.pr_branch_pattern) {
       parts.push(`Branch naming pattern: \`${gh.pr_branch_pattern}\``);
     }
@@ -1201,12 +1436,37 @@ async function generateClaudeCode(config, hubDir) {
     }
   } catch {
   }
-  await writeFile2(join3(hubDir, "CLAUDE.md"), claudeMdSections.join("\n"), "utf-8");
+  const claudeSkillsDirForDocs = join3(claudeDir, "skills");
+  await mkdir2(claudeSkillsDirForDocs, { recursive: true });
+  await fetchHubDocsSkill(claudeSkillsDirForDocs);
+  const hubSteeringDirClaude = resolve(hubDir, "steering");
+  try {
+    const steeringFiles = await readdir2(hubSteeringDirClaude);
+    const mdFiles = steeringFiles.filter((f) => f.endsWith(".md"));
+    for (const file of mdFiles) {
+      const raw = await readFile3(join3(hubSteeringDirClaude, file), "utf-8");
+      const content = stripFrontMatter(raw).trim();
+      if (content) {
+        claudeMdSections.push(content);
+      }
+    }
+    if (mdFiles.length > 0) {
+      console.log(chalk2.green(`  Appended ${mdFiles.length} steering files to CLAUDE.md`));
+    }
+  } catch {
+  }
+  await writeFile2(join3(hubDir, "CLAUDE.md"), claudeMdSections.join("\n\n"), "utf-8");
   console.log(chalk2.green("  Generated CLAUDE.md"));
   if (config.mcps?.length) {
     const mcpJson = {};
+    const upstreamSet = getUpstreamNames(config.mcps);
     for (const mcp of config.mcps) {
-      mcpJson[mcp.name] = buildClaudeCodeMcpEntry(mcp);
+      if (upstreamSet.has(mcp.name)) continue;
+      if (mcp.upstreams?.length) {
+        mcpJson[mcp.name] = buildProxyMcpEntry(mcp, config.mcps, buildClaudeCodeMcpEntry);
+      } else {
+        mcpJson[mcp.name] = buildClaudeCodeMcpEntry(mcp);
+      }
     }
     await writeFile2(
       join3(hubDir, ".mcp.json"),
@@ -1267,6 +1527,25 @@ async function generateKiro(config, hubDir) {
   const settingsDir = join3(kiroDir, "settings");
   await mkdir2(steeringDir, { recursive: true });
   await mkdir2(settingsDir, { recursive: true });
+  let mode = await getKiroMode(hubDir);
+  if (!mode) {
+    const { kiroMode } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "kiroMode",
+        message: "How do you use Kiro?",
+        choices: [
+          { name: "Editor / IDE (e.g. Kiro IDE, VS Code)", value: "editor" },
+          { name: "CLI (e.g. kiro-cli)", value: "cli" }
+        ]
+      }
+    ]);
+    mode = kiroMode;
+    await saveKiroMode(hubDir, mode);
+    console.log(chalk2.dim(`  Saved Kiro mode: ${mode}`));
+  } else {
+    console.log(chalk2.dim(`  Using saved Kiro mode: ${mode}`));
+  }
   const gitignoreLines = buildGitignoreLines(config);
   await writeManagedFile(join3(hubDir, ".gitignore"), gitignoreLines);
   console.log(chalk2.green("  Generated .gitignore"));
@@ -1276,21 +1555,33 @@ async function generateKiro(config, hubDir) {
   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 hubSteeringDir = resolve(hubDir, "steering");
+  try {
+    const steeringFiles = await readdir2(hubSteeringDir);
+    const mdFiles = steeringFiles.filter((f) => f.endsWith(".md"));
+    for (const file of mdFiles) {
+      const raw = await readFile3(join3(hubSteeringDir, file), "utf-8");
+      const content = stripFrontMatter(raw);
+      const kiroSteering = buildKiroSteeringContent(content);
+      await writeFile2(join3(steeringDir, file), kiroSteering, "utf-8");
+    }
+    if (mdFiles.length > 0) {
+      console.log(chalk2.green(`  Copied ${mdFiles.length} steering files to .kiro/steering/`));
+    }
+  } catch {
+  }
   const agentsDir = resolve(hubDir, "agents");
   try {
+    const kiroAgentsDir = join3(kiroDir, "agents");
+    await mkdir2(kiroAgentsDir, { recursive: true });
     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");
+      const kiroAgent = buildKiroAgentContent(agentContent);
+      await writeFile2(join3(kiroAgentsDir, file), kiroAgent, "utf-8");
     }
-    console.log(chalk2.green(`  Copied ${mdFiles.length} agents as steering files`));
+    console.log(chalk2.green(`  Copied ${mdFiles.length} agents to .kiro/agents/`));
   } catch {
     console.log(chalk2.yellow("  No agents/ directory found, skipping agent copy"));
   }
@@ -1316,10 +1607,20 @@ async function generateKiro(config, hubDir) {
     }
   } catch {
   }
+  const kiroSkillsDirForDocs = join3(kiroDir, "skills");
+  await mkdir2(kiroSkillsDirForDocs, { recursive: true });
+  await fetchHubDocsSkill(kiroSkillsDirForDocs);
   if (config.mcps?.length) {
     const mcpConfig = {};
+    const upstreamSet = getUpstreamNames(config.mcps);
+    const buildEntry = (mcp) => buildKiroMcpEntry(mcp, mode);
     for (const mcp of config.mcps) {
-      mcpConfig[mcp.name] = buildKiroMcpEntry(mcp);
+      if (upstreamSet.has(mcp.name)) continue;
+      if (mcp.upstreams?.length) {
+        mcpConfig[mcp.name] = buildProxyMcpEntry(mcp, config.mcps, buildEntry);
+      } else {
+        mcpConfig[mcp.name] = buildKiroMcpEntry(mcp, mode);
+      }
     }
     await writeFile2(
       join3(settingsDir, "mcp.json"),
@@ -1368,6 +1669,59 @@ async function generateVSCodeSettings(config, hubDir) {
   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)"));
+  const workspaceFile = `${config.name}.code-workspace`;
+  const workspacePath = join3(hubDir, workspaceFile);
+  let existingWorkspace = {};
+  if (existsSync2(workspacePath)) {
+    try {
+      const raw = await readFile3(workspacePath, "utf-8");
+      existingWorkspace = JSON.parse(raw);
+    } catch {
+      existingWorkspace = {};
+    }
+  } else {
+    const files = await readdir2(hubDir);
+    const existing2 = files.find((f) => f.endsWith(".code-workspace"));
+    if (existing2) {
+      try {
+        const raw = await readFile3(join3(hubDir, existing2), "utf-8");
+        existingWorkspace = JSON.parse(raw);
+      } catch {
+        existingWorkspace = {};
+      }
+    }
+  }
+  const TECH_LABELS = {
+    nestjs: "NestJS",
+    nextjs: "Next.js",
+    react: "React",
+    elixir: "Elixir",
+    phoenix: "Phoenix",
+    django: "Django",
+    fastapi: "FastAPI",
+    rails: "Rails",
+    spring: "Spring",
+    go: "Go",
+    vue: "Vue",
+    svelte: "Svelte",
+    angular: "Angular",
+    express: "Express",
+    koa: "Koa"
+  };
+  const folders = [
+    { path: ".", name: "Root" }
+  ];
+  for (const repo of config.repos) {
+    const repoPath = repo.path.replace(/^\.\//, "");
+    const displayName = repo.display_name || (repo.tech ? `${repo.name} (${TECH_LABELS[repo.tech] || repo.tech})` : repo.name);
+    folders.push({ path: repoPath, name: displayName });
+  }
+  const workspace = {
+    folders,
+    settings: existingWorkspace.settings || {}
+  };
+  await writeFile2(workspacePath, JSON.stringify(workspace, null, "	") + "\n", "utf-8");
+  console.log(chalk2.green(`  Generated ${workspaceFile}`));
 }
 function buildGitignoreLines(config) {
   const lines = [
@@ -1428,6 +1782,9 @@ async function resolveEditor(opts) {
         }))
       }
     ]);
+    const cache = await readCache(hubDir);
+    delete cache.kiroMode;
+    await writeCache(hubDir, cache);
     return editor2;
   }
   if (opts.editor) return opts.editor;

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

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

package/dist/index.js

@@ -3,10 +3,10 @@ import {
   checkAndAutoRegenerate,
   generateCommand,
   loadHubConfig
-} from "./chunk-U5G47GMH.js";
+} from "./chunk-UIANILFI.js";
 
 // src/index.ts
-import { Command as Command18 } from "commander";
+import { Command as Command19 } from "commander";
 
 // src/commands/init.ts
 import { Command } from "commander";
@@ -2852,11 +2852,327 @@ var directoryCommand = new Command17("directory").alias("dir").description("Brow
   console.log(chalk17.dim("    hub commands add <owner>/<repo>\n"));
 });
 
+// src/commands/scan.ts
+import { Command as Command18 } from "commander";
+import { existsSync as existsSync14 } from "fs";
+import { readdir as readdir6, readFile as readFile8, cp as cp4, mkdir as mkdir9, writeFile as writeFile11 } from "fs/promises";
+import { execSync as execSync13 } from "child_process";
+import { join as join17 } from "path";
+import { parse as parse2 } from "yaml";
+import chalk18 from "chalk";
+import inquirer from "inquirer";
+var EDITOR_DIRS = [".kiro", ".cursor", ".opencode", ".claude"];
+async function findUnregisteredRepos(hubDir, config) {
+  const registeredPaths = new Set(
+    config.repos.map((r) => r.path.replace(/^\.\//, ""))
+  );
+  const entries = await readdir6(hubDir);
+  const unregistered = [];
+  for (const entry of entries) {
+    if (registeredPaths.has(entry)) continue;
+    const gitDir = join17(hubDir, entry, ".git");
+    if (existsSync14(gitDir)) {
+      unregistered.push(entry);
+    }
+  }
+  return unregistered;
+}
+function detectTech(repoDir) {
+  if (existsSync14(join17(repoDir, "mix.exs"))) return "elixir";
+  if (existsSync14(join17(repoDir, "next.config.js")) || existsSync14(join17(repoDir, "next.config.ts")) || existsSync14(join17(repoDir, "next.config.mjs"))) return "nextjs";
+  if (existsSync14(join17(repoDir, "nest-cli.json"))) return "nestjs";
+  if (existsSync14(join17(repoDir, "angular.json"))) return "angular";
+  if (existsSync14(join17(repoDir, "svelte.config.js"))) return "svelte";
+  if (existsSync14(join17(repoDir, "nuxt.config.ts")) || existsSync14(join17(repoDir, "nuxt.config.js"))) return "vue";
+  if (existsSync14(join17(repoDir, "go.mod"))) return "go";
+  if (existsSync14(join17(repoDir, "Gemfile"))) return "rails";
+  if (existsSync14(join17(repoDir, "manage.py"))) return "django";
+  if (existsSync14(join17(repoDir, "package.json"))) return "react";
+  return void 0;
+}
+function getGitRemote(repoDir) {
+  try {
+    return execSync13("git remote get-url origin", { cwd: repoDir, encoding: "utf-8" }).trim();
+  } catch {
+    return "";
+  }
+}
+function buildRepoYaml(repo) {
+  const lines = [];
+  lines.push(`  - name: ${repo.name}`);
+  lines.push(`    path: ${repo.path}`);
+  lines.push(`    url: ${repo.url}`);
+  if (repo.tech) lines.push(`    tech: ${repo.tech}`);
+  return lines.join("\n");
+}
+function findReposInsertionPoint(content) {
+  const lines = content.split("\n");
+  let lastRepoLine = -1;
+  let inRepos = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^repos:/.test(line)) {
+      inRepos = true;
+      continue;
+    }
+    if (inRepos) {
+      if (/^[a-z]/.test(line) || /^[A-Z]/.test(line)) break;
+      if (line.trim() !== "") lastRepoLine = i;
+    }
+  }
+  if (lastRepoLine === -1) return content.length;
+  let offset = 0;
+  for (let i = 0; i <= lastRepoLine; i++) {
+    offset += lines[i].length + 1;
+  }
+  return offset;
+}
+async function findUnsyncedAssets(hubDir) {
+  const unsynced = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const editor of EDITOR_DIRS) {
+    const editorSkillsDir = join17(hubDir, editor, "skills");
+    if (!existsSync14(editorSkillsDir)) continue;
+    try {
+      const folders = await readdir6(editorSkillsDir);
+      for (const folder of folders) {
+        if (folder === "hub-docs") continue;
+        const skillFile = join17(editorSkillsDir, folder, "SKILL.md");
+        if (!existsSync14(skillFile)) continue;
+        const canonicalSkillFile = join17(hubDir, "skills", folder, "SKILL.md");
+        if (existsSync14(canonicalSkillFile)) continue;
+        const key = `skill:${folder}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        unsynced.push({ type: "skill", name: folder, source: editor });
+      }
+    } catch {
+    }
+  }
+  for (const editor of EDITOR_DIRS) {
+    const editorAgentsDir = join17(hubDir, editor, "agents");
+    if (!existsSync14(editorAgentsDir)) continue;
+    try {
+      const files = await readdir6(editorAgentsDir);
+      for (const file of files) {
+        if (!file.endsWith(".md")) continue;
+        const canonicalFile = join17(hubDir, "agents", file);
+        if (existsSync14(canonicalFile)) continue;
+        const key = `agent:${file}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        unsynced.push({ type: "agent", name: file, source: editor });
+      }
+    } catch {
+    }
+  }
+  const steeringDir = join17(hubDir, ".kiro", "steering");
+  if (existsSync14(steeringDir)) {
+    const canonicalSteeringDir = join17(hubDir, "steering");
+    try {
+      const files = await readdir6(steeringDir);
+      for (const file of files) {
+        if (!file.endsWith(".md")) continue;
+        if (file === "orchestrator.md") continue;
+        const canonicalFile = join17(canonicalSteeringDir, file);
+        if (existsSync14(canonicalFile)) continue;
+        const key = `steering:${file}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        unsynced.push({ type: "steering", name: file, source: ".kiro" });
+      }
+    } catch {
+    }
+  }
+  const cursorRulesDir = join17(hubDir, ".cursor", "rules");
+  if (existsSync14(cursorRulesDir)) {
+    const canonicalSteeringDir = join17(hubDir, "steering");
+    try {
+      const files = await readdir6(cursorRulesDir);
+      for (const file of files) {
+        if (!file.endsWith(".mdc")) continue;
+        if (file === "orchestrator.mdc") continue;
+        const mdName = file.replace(/\.mdc$/, ".md");
+        const canonicalFile = join17(canonicalSteeringDir, mdName);
+        if (existsSync14(canonicalFile)) continue;
+        const key = `steering:${mdName}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        unsynced.push({ type: "steering", name: mdName, source: ".cursor" });
+      }
+    } catch {
+    }
+  }
+  const opencodeRulesDir = join17(hubDir, ".opencode", "rules");
+  if (existsSync14(opencodeRulesDir)) {
+    const canonicalSteeringDir = join17(hubDir, "steering");
+    try {
+      const files = await readdir6(opencodeRulesDir);
+      for (const file of files) {
+        if (!file.endsWith(".md")) continue;
+        if (file === "orchestrator.md") continue;
+        const canonicalFile = join17(canonicalSteeringDir, file);
+        if (existsSync14(canonicalFile)) continue;
+        const key = `steering:${file}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        unsynced.push({ type: "steering", name: file, source: ".opencode" });
+      }
+    } catch {
+    }
+  }
+  return unsynced;
+}
+function stripFrontMatter(content) {
+  const match = content.match(/^---\n[\s\S]*?\n---\n*/);
+  if (match) return content.slice(match[0].length);
+  return content;
+}
+async function syncAssets(hubDir, assets) {
+  for (const asset of assets) {
+    if (asset.type === "skill") {
+      const src = join17(hubDir, asset.source, "skills", asset.name);
+      const dest = join17(hubDir, "skills", asset.name);
+      await mkdir9(join17(hubDir, "skills"), { recursive: true });
+      await cp4(src, dest, { recursive: true });
+      const skillMd = join17(dest, "SKILL.md");
+      if (existsSync14(skillMd)) {
+        const raw = await readFile8(skillMd, "utf-8");
+        const cleaned = stripFrontMatter(raw);
+        if (cleaned !== raw) {
+          await writeFile11(skillMd, cleaned, "utf-8");
+        }
+      }
+      console.log(chalk18.green(`  Synced skill: ${asset.name} (from ${asset.source})`));
+    } else if (asset.type === "agent") {
+      const src = join17(hubDir, asset.source, "agents", asset.name);
+      const dest = join17(hubDir, "agents", asset.name);
+      await mkdir9(join17(hubDir, "agents"), { recursive: true });
+      const raw = await readFile8(src, "utf-8");
+      const cleaned = stripFrontMatter(raw);
+      await writeFile11(dest, cleaned, "utf-8");
+      console.log(chalk18.green(`  Synced agent: ${asset.name} (from ${asset.source})`));
+    } else if (asset.type === "steering") {
+      const dest = join17(hubDir, "steering", asset.name);
+      await mkdir9(join17(hubDir, "steering"), { recursive: true });
+      let raw;
+      if (asset.source === ".cursor") {
+        const mdcName = asset.name.replace(/\.md$/, ".mdc");
+        raw = await readFile8(join17(hubDir, ".cursor", "rules", mdcName), "utf-8");
+      } else if (asset.source === ".opencode") {
+        raw = await readFile8(join17(hubDir, ".opencode", "rules", asset.name), "utf-8");
+      } else {
+        raw = await readFile8(join17(hubDir, asset.source, "steering", asset.name), "utf-8");
+      }
+      const cleaned = stripFrontMatter(raw);
+      await writeFile11(dest, cleaned, "utf-8");
+      console.log(chalk18.green(`  Synced steering: ${asset.name} (from ${asset.source})`));
+    }
+  }
+}
+var scanCommand = new Command18("scan").description("Detect git repositories not registered in hub.yaml").option("-y, --yes", "Auto-add all found repos without prompting").action(async (opts) => {
+  const hubDir = process.cwd();
+  const configPath = join17(hubDir, "hub.yaml");
+  if (!existsSync14(configPath)) {
+    console.log(chalk18.red("No hub.yaml found in current directory."));
+    process.exit(1);
+  }
+  const content = await readFile8(configPath, "utf-8");
+  const config = parse2(content);
+  let hasChanges = false;
+  console.log(chalk18.blue("\nScanning for unregistered repositories...\n"));
+  const unregistered = await findUnregisteredRepos(hubDir, config);
+  if (unregistered.length === 0) {
+    console.log(chalk18.green("All repositories are registered in hub.yaml."));
+  } else {
+    console.log(chalk18.yellow(`Found ${unregistered.length} unregistered repo(s):
+`));
+    const repoDetails = unregistered.map((name) => {
+      const repoDir = join17(hubDir, name);
+      const tech = detectTech(repoDir);
+      const url = getGitRemote(repoDir);
+      return { name, tech, url, path: `./${name}` };
+    });
+    for (const repo of repoDetails) {
+      const techLabel = repo.tech ? chalk18.dim(` (${repo.tech})`) : "";
+      console.log(`  ${chalk18.cyan(repo.name)}${techLabel}`);
+    }
+    console.log();
+    let toAdd = repoDetails;
+    if (!opts.yes) {
+      const { selected } = await inquirer.prompt([
+        {
+          type: "checkbox",
+          name: "selected",
+          message: "Select repos to add to hub.yaml:",
+          choices: repoDetails.map((r) => ({
+            name: `${r.name}${r.tech ? ` (${r.tech})` : ""}`,
+            value: r.name,
+            checked: true
+          }))
+        }
+      ]);
+      toAdd = repoDetails.filter((r) => selected.includes(r.name));
+    }
+    if (toAdd.length > 0) {
+      const originalContent = await readFile8(configPath, "utf-8");
+      const insertAt = findReposInsertionPoint(originalContent);
+      const before = originalContent.slice(0, insertAt);
+      const after = originalContent.slice(insertAt);
+      const newEntries = toAdd.map(buildRepoYaml).join("\n");
+      const updatedContent = before + newEntries + "\n" + after;
+      await import("fs/promises").then((fs) => fs.writeFile(configPath, updatedContent, "utf-8"));
+      console.log(chalk18.green(`Added ${toAdd.length} repo(s) to hub.yaml.`));
+      hasChanges = true;
+    }
+  }
+  console.log(chalk18.blue("\nScanning for unsynced skills, agents, and steering...\n"));
+  const unsyncedAssets = await findUnsyncedAssets(hubDir);
+  if (unsyncedAssets.length === 0) {
+    console.log(chalk18.green("All assets are synced."));
+  } else {
+    console.log(chalk18.yellow(`Found ${unsyncedAssets.length} unsynced asset(s):
+`));
+    for (const asset of unsyncedAssets) {
+      console.log(`  ${chalk18.cyan(asset.name)} ${chalk18.dim(`(${asset.type} from ${asset.source})`)}`);
+    }
+    console.log();
+    let toSync = unsyncedAssets;
+    if (!opts.yes) {
+      const { selected } = await inquirer.prompt([
+        {
+          type: "checkbox",
+          name: "selected",
+          message: "Select assets to sync to canonical folders:",
+          choices: unsyncedAssets.map((a) => ({
+            name: `${a.name} (${a.type} from ${a.source})`,
+            value: `${a.type}:${a.name}`,
+            checked: true
+          }))
+        }
+      ]);
+      toSync = unsyncedAssets.filter((a) => selected.includes(`${a.type}:${a.name}`));
+    }
+    if (toSync.length > 0) {
+      await syncAssets(hubDir, toSync);
+      console.log(chalk18.green(`Synced ${toSync.length} asset(s).`));
+      hasChanges = true;
+    }
+  }
+  if (hasChanges) {
+    console.log(chalk18.cyan(`
+Run ${chalk18.bold("hub generate")} to update editor configs.
+`));
+  } else {
+    console.log();
+  }
+});
+
 // src/index.ts
-var program = new Command18();
+var program = new Command19();
 program.name("hub").description(
   "Give your AI coding assistant the full picture. Multi-repo context, agent orchestration, and end-to-end workflows."
-).version("0.6.2").enablePositionalOptions();
+).version("0.7.3").enablePositionalOptions();
 program.addCommand(initCommand);
 program.addCommand(addRepoCommand);
 program.addCommand(setupCommand);
@@ -2877,4 +3193,5 @@ program.addCommand(toolsCommand);
 program.addCommand(memoryCommand);
 program.addCommand(updateCommand);
 program.addCommand(directoryCommand);
+program.addCommand(scanCommand);
 program.parse();

package/package.json

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