@codemcp/workflows 6.20.1 → 6.21.0

package/packages/cli/dist/{cli-MFHC7UWY.js → cli-O52P3RVC.js}

@@ -1,15 +1,16 @@
 import {
+  ConfigManager,
   StateMachineLoader,
   WorkflowManager,
   generateSystemPrompt
-} from "./chunk-4N42FFJE.js";
+} from "./chunk-KWAFQZUI.js";
 import "./chunk-R5U7XKVJ.js";
 
 // src/cli.ts
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname3, join as join5 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { dirname as dirname4, join as join6 } from "path";
 import {
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   mkdirSync,
   writeFileSync,
   readFileSync,
@@ -991,18 +992,354 @@ async function generateSkill(platform, outputDir = ".") {
   console.log(`\u2705 Skill generated successfully for ${platform}`);
 }
 
-// src/cli.ts
+// src/capability-generator.ts
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join5, dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import yaml from "js-yaml";
 var __filename3 = fileURLToPath3(import.meta.url);
 var __dirname3 = dirname3(__filename3);
-var isLocal = existsSync3(join5(__dirname3, "../../core/dist/index.js"));
+var SUPPORTED_CAPABILITIES = [
+  "thinking",
+  "coding",
+  "research"
+];
+var CapabilityGenerator = class {
+  /**
+   * Concrete orchestration: for each provided capability, resolve the output
+   * path, render the file, then write (or skip if it exists and `!force`).
+   * Finally, merge the matching `capability_models` entries into
+   * `.vibe/config.yaml` (target-agnostic; lives in the base).
+   */
+  async generate(opts) {
+    const { projectPath, models, force = false } = opts;
+    const generatedFiles = [];
+    const skippedFiles = [];
+    for (const capability of SUPPORTED_CAPABILITIES) {
+      const model = models[capability];
+      if (!model) {
+        continue;
+      }
+      const targetPath = this.getOutputPath(capability, projectPath);
+      const content = await this.renderCapabilityFile(capability, model);
+      if (existsSync3(targetPath) && !force) {
+        skippedFiles.push(targetPath);
+        continue;
+      }
+      await mkdir3(dirname3(targetPath), { recursive: true });
+      await writeFile3(targetPath, content, "utf-8");
+      generatedFiles.push(targetPath);
+    }
+    const configPath = join5(projectPath, ".vibe", "config.yaml");
+    const configUpdated = await mergeCapabilityModels(configPath, models);
+    return { generatedFiles, skippedFiles, configUpdated, configPath };
+  }
+};
+async function mergeCapabilityModels(configPath, models) {
+  const newEntries = {};
+  for (const capability of SUPPORTED_CAPABILITIES) {
+    const model = models[capability];
+    if (model) {
+      newEntries[capability] = { model, agent: capability };
+    }
+  }
+  if (Object.keys(newEntries).length === 0) {
+    return false;
+  }
+  let existingConfig = {};
+  let configExisted = false;
+  if (existsSync3(configPath)) {
+    configExisted = true;
+    const projectRoot = dirname3(dirname3(configPath));
+    const loaded = ConfigManager.loadProjectConfig(projectRoot);
+    if (loaded !== null) {
+      existingConfig = loaded;
+    } else {
+      const existingRaw = await readFile3(configPath, "utf-8");
+      const parsed = yaml.load(existingRaw);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        existingConfig = parsed;
+      }
+    }
+  }
+  const mergedConfig = {
+    ...existingConfig,
+    capability_models: {
+      ...existingConfig.capability_models,
+      ...newEntries
+    }
+  };
+  const serialized = yaml.dump(mergedConfig, { noRefs: true, sortKeys: false });
+  if (configExisted) {
+    const existingSerialized = yaml.dump(existingConfig, {
+      noRefs: true,
+      sortKeys: false
+    });
+    if (existingSerialized === serialized) {
+      return false;
+    }
+  }
+  await mkdir3(dirname3(configPath), { recursive: true });
+  await writeFile3(configPath, serialized, "utf-8");
+  return true;
+}
+function resolveOpencodeTemplatePath(capability) {
+  const filename = `${capability}.md.tmpl`;
+  const possiblePaths = [
+    // From src/ in dev (vitest): <cli>/resources/templates/opencode-agents/<file>
+    join5(
+      __dirname3,
+      "..",
+      "resources",
+      "templates",
+      "opencode-agents",
+      filename
+    ),
+    // From dist/ at runtime: <cli>/resources/templates/opencode-agents/<file>
+    join5(
+      __dirname3,
+      "..",
+      "..",
+      "resources",
+      "templates",
+      "opencode-agents",
+      filename
+    ),
+    // From dist/cli/ at runtime (alt bundled layout)
+    join5(
+      __dirname3,
+      "..",
+      "..",
+      "..",
+      "resources",
+      "templates",
+      "opencode-agents",
+      filename
+    ),
+    // Root canonical source of truth
+    join5(
+      __dirname3,
+      "..",
+      "..",
+      "..",
+      "..",
+      "resources",
+      "templates",
+      "opencode-agents",
+      filename
+    ),
+    // From core package resources
+    join5(
+      __dirname3,
+      "..",
+      "..",
+      "core",
+      "resources",
+      "templates",
+      "opencode-agents",
+      filename
+    )
+  ];
+  for (const candidate of possiblePaths) {
+    if (existsSync3(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    `Capability template not found: ${filename}. Searched: ${possiblePaths.join(", ")}`
+  );
+}
+function renderOpencodeTemplate(content, capability, model) {
+  return content.replace(/\$\{capability\}/g, capability).replace(/\$\{model\}/g, model);
+}
+var OpencodeCapabilityGenerator = class extends CapabilityGenerator {
+  name = "opencode";
+  description = "Generate .opencode/agents/<capability>.md (mode: subagent, model pinned)";
+  getOutputPath(capability, projectPath) {
+    return join5(projectPath, ".opencode", "agents", `${capability}.md`);
+  }
+  async renderCapabilityFile(capability, model) {
+    const templatePath = resolveOpencodeTemplatePath(capability);
+    const templateContent = await readFile3(templatePath, "utf-8");
+    return renderOpencodeTemplate(templateContent, capability, model);
+  }
+};
+function buildNotYetSupportedError(target) {
+  return new Error(
+    `Capability generation for ${target} is not yet supported \u2014 see \`setup capabilities --help\``
+  );
+}
+var KiroCapabilityGenerator = class extends CapabilityGenerator {
+  name = "kiro";
+  description = "Not yet supported for kiro \u2014 see `setup capabilities --help`";
+  getOutputPath() {
+    throw buildNotYetSupportedError(this.name);
+  }
+  renderCapabilityFile() {
+    return Promise.reject(buildNotYetSupportedError(this.name));
+  }
+};
+var ClaudeCapabilityGenerator = class extends CapabilityGenerator {
+  name = "claude";
+  description = "Not yet supported for claude \u2014 see `setup capabilities --help`";
+  getOutputPath() {
+    throw buildNotYetSupportedError(this.name);
+  }
+  renderCapabilityFile() {
+    return Promise.reject(buildNotYetSupportedError(this.name));
+  }
+};
+var GeminiCapabilityGenerator = class extends CapabilityGenerator {
+  name = "gemini";
+  description = "Not yet supported for gemini \u2014 see `setup capabilities --help`";
+  getOutputPath() {
+    throw buildNotYetSupportedError(this.name);
+  }
+  renderCapabilityFile() {
+    return Promise.reject(buildNotYetSupportedError(this.name));
+  }
+};
+var VSCodeCapabilityGenerator = class extends CapabilityGenerator {
+  name = "vscode";
+  description = "Not yet supported for vscode \u2014 see `setup capabilities --help`";
+  getOutputPath() {
+    throw buildNotYetSupportedError(this.name);
+  }
+  renderCapabilityFile() {
+    return Promise.reject(buildNotYetSupportedError(this.name));
+  }
+};
+var GithubCopilotCapabilityGenerator = class extends CapabilityGenerator {
+  name = "github-copilot";
+  description = "Not yet supported for github-copilot \u2014 see `setup capabilities --help`";
+  getOutputPath() {
+    throw buildNotYetSupportedError(this.name);
+  }
+  renderCapabilityFile() {
+    return Promise.reject(buildNotYetSupportedError(this.name));
+  }
+};
+var CapabilityGeneratorRegistry = class {
+  static generators = /* @__PURE__ */ new Map();
+  /**
+   * Register a generator with its metadata.
+   */
+  static register(metadata) {
+    this.generators.set(metadata.name.toLowerCase(), metadata);
+  }
+  /**
+   * Create a generator instance by name.
+   *
+   * - Throws `Unknown capability target: ...` when the name is not
+   *   registered at all.
+   * - Throws `Capability generation for <target> is not yet supported` when
+   *   the name is registered but `supported: false`.
+   * - Otherwise returns a fresh `CapabilityGenerator` instance.
+   */
+  static createGenerator(name) {
+    const metadata = this.generators.get(name.toLowerCase());
+    if (!metadata) {
+      const supported = this.getSupportedNames();
+      throw new Error(
+        `Unknown capability target: ${name}. Supported: ${supported.join(", ")}`
+      );
+    }
+    if (!metadata.supported) {
+      throw new Error(
+        `Capability generation for ${metadata.name} is not yet supported \u2014 see \`setup capabilities --help\``
+      );
+    }
+    return new metadata.generatorClass();
+  }
+  /**
+   * Get all registered generators (including unsupported stubs).
+   */
+  static getAllGenerators() {
+    return Array.from(this.generators.values());
+  }
+  /**
+   * Get the names of fully-supported generators (excludes stubs).
+   */
+  static getSupportedNames() {
+    return this.getAllGenerators().filter((g) => g.supported).map((g) => g.name);
+  }
+  /**
+   * Get formatted help text for all registered generators, with a status
+   * indicator (✅ supported / ⏳ not yet supported) and a padded name column
+   * so the descriptions line up as the list grows.
+   */
+  static getHelpText() {
+    const generators = this.getAllGenerators();
+    if (generators.length === 0) {
+      return "";
+    }
+    const maxNameLength = Math.max(...generators.map((g) => g.name.length));
+    return generators.map((g) => {
+      const icon = g.supported ? "\u2705" : "\u23F3";
+      const paddedName = g.name.padEnd(maxNameLength + 2, " ");
+      return `${icon} ${paddedName}${g.description}`;
+    }).join("\n");
+  }
+  /**
+   * Check if a generator is registered by name.
+   */
+  static exists(name) {
+    return this.generators.has(name.toLowerCase());
+  }
+};
+CapabilityGeneratorRegistry.register({
+  name: "opencode",
+  description: "Generate .opencode/agents/<capability>.md (mode: subagent, model pinned)",
+  generatorClass: OpencodeCapabilityGenerator,
+  supported: true
+});
+CapabilityGeneratorRegistry.register({
+  name: "kiro",
+  description: "Not yet supported for kiro \u2014 see `setup capabilities --help`",
+  generatorClass: KiroCapabilityGenerator,
+  supported: false
+});
+CapabilityGeneratorRegistry.register({
+  name: "claude",
+  description: "Not yet supported for claude \u2014 see `setup capabilities --help`",
+  generatorClass: ClaudeCapabilityGenerator,
+  supported: false
+});
+CapabilityGeneratorRegistry.register({
+  name: "gemini",
+  description: "Not yet supported for gemini \u2014 see `setup capabilities --help`",
+  generatorClass: GeminiCapabilityGenerator,
+  supported: false
+});
+CapabilityGeneratorRegistry.register({
+  name: "vscode",
+  description: "Not yet supported for vscode \u2014 see `setup capabilities --help`",
+  generatorClass: VSCodeCapabilityGenerator,
+  supported: false
+});
+CapabilityGeneratorRegistry.register({
+  name: "github-copilot",
+  description: "Not yet supported for github-copilot \u2014 see `setup capabilities --help`",
+  generatorClass: GithubCopilotCapabilityGenerator,
+  supported: false
+});
+function generateCapabilities(target, opts) {
+  return CapabilityGeneratorRegistry.createGenerator(target).generate(opts);
+}
+
+// src/cli.ts
+var __filename4 = fileURLToPath4(import.meta.url);
+var __dirname4 = dirname4(__filename4);
+var isLocal = existsSync4(join6(__dirname4, "../../core/dist/index.js"));
 var generateSystemPrompt2;
 var StateMachineLoader2;
 if (isLocal) {
-  const coreModule = await import("./dist-TDV3DJ2J.js");
+  const coreModule = await import("./dist-ZTAPC4IK.js");
   generateSystemPrompt2 = coreModule.generateSystemPrompt;
   StateMachineLoader2 = coreModule.StateMachineLoader;
 } else {
-  const coreModule = await import("./dist-TDV3DJ2J.js");
+  const coreModule = await import("./dist-ZTAPC4IK.js");
   generateSystemPrompt2 = coreModule.generateSystemPrompt;
   StateMachineLoader2 = coreModule.StateMachineLoader;
 }
@@ -1020,7 +1357,7 @@ function parseFlag(args, flag) {
 }
 async function parseCliArgs() {
   const args = process.argv.slice(2);
-  if (args.includes("--help") || args.includes("-h")) {
+  if (args[0] === "--help" || args[0] === "-h") {
     showHelp();
     return { shouldExit: true };
   }
@@ -1030,6 +1367,9 @@ async function parseCliArgs() {
     if (subcommand === "list") {
       handleSetupList();
       return { shouldExit: true };
+    } else if (subcommand === "capabilities") {
+      await handleSetupCapabilities(args.slice(2));
+      return { shouldExit: true };
     } else if (subcommand) {
       const mode = parseFlag(args, "--mode") ?? "config";
       if (mode !== "skill" && mode !== "config") {
@@ -1042,6 +1382,9 @@ async function parseCliArgs() {
       console.error("\u274C Error: setup requires a target");
       console.error("Usage: setup <target> [--mode config|skill]");
       console.error("       setup list");
+      console.error(
+        "       setup capabilities <target> [--model-thinking M] [--model-coding M] [--model-research M] [--force]"
+      );
       process.exit(1);
     }
   }
@@ -1201,8 +1544,8 @@ function handleWorkflowCopy(sourceWorkflow, customName) {
       process.exit(1);
     }
     const possibleSourcePaths = [
-      join5(
-        __dirname3,
+      join6(
+        __dirname4,
         "..",
         "..",
         "..",
@@ -1210,8 +1553,8 @@ function handleWorkflowCopy(sourceWorkflow, customName) {
         "workflows",
         `${sourceWorkflow}.yaml`
       ),
-      join5(
-        __dirname3,
+      join6(
+        __dirname4,
         "..",
         "..",
         "core",
@@ -1219,28 +1562,28 @@ function handleWorkflowCopy(sourceWorkflow, customName) {
         "workflows",
         `${sourceWorkflow}.yaml`
       ),
-      join5(process.cwd(), "resources", "workflows", `${sourceWorkflow}.yaml`)
+      join6(process.cwd(), "resources", "workflows", `${sourceWorkflow}.yaml`)
     ];
-    const foundPath = possibleSourcePaths.find((p) => existsSync3(p));
+    const foundPath = possibleSourcePaths.find((p) => existsSync4(p));
     if (!foundPath) {
       console.error(`\u274C Could not find source workflow: ${sourceWorkflow}`);
       process.exit(1);
     }
     const sourceContent = readFileSync(foundPath, "utf8");
-    const vibeDir = join5(process.cwd(), ".vibe");
-    const workflowsDir = join5(vibeDir, "workflows");
-    if (!existsSync3(vibeDir)) {
+    const vibeDir = join6(process.cwd(), ".vibe");
+    const workflowsDir = join6(vibeDir, "workflows");
+    if (!existsSync4(vibeDir)) {
       mkdirSync(vibeDir, { recursive: true });
     }
-    if (!existsSync3(workflowsDir)) {
+    if (!existsSync4(workflowsDir)) {
       mkdirSync(workflowsDir, { recursive: true });
     }
     const customContent = sourceContent.replace(
       new RegExp(`name: '${sourceWorkflow}'`, "g"),
       `name: '${customName}'`
     );
-    const workflowPath = join5(workflowsDir, `${customName}.yaml`);
-    if (existsSync3(workflowPath)) {
+    const workflowPath = join6(workflowsDir, `${customName}.yaml`);
+    if (existsSync4(workflowPath)) {
       console.error(
         `\u274C Workflow '${customName}' already exists at ${workflowPath}`
       );
@@ -1291,6 +1634,97 @@ async function handleSetup(target, mode) {
     process.exit(1);
   }
 }
+function printSetupCapabilitiesHelp() {
+  console.log(`
+setup capabilities <target> [flags]
+
+Wire up capability-routed subagents for a target IDE/CLI and merge the
+matching \`capability_models\` entries into \`.vibe/config.yaml\`.
+
+FLAGS:
+  --model-thinking <model>   Set the model for the thinking agent
+  --model-coding <model>     Set the model for the coding agent
+  --model-research <model>   Set the model for the research agent
+  --force                    Overwrite existing per-target agent files
+  --help, -h                 Show this help message
+
+TARGETS:
+${CapabilityGeneratorRegistry.getHelpText().split("\n").map((line) => `  ${line}`).join("\n")}
+
+USAGE:
+  setup capabilities opencode --model-thinking anthropic/claude-opus-4-7 --model-coding anthropic/claude-sonnet-4-5 --model-research anthropic/claude-haiku-4-5
+
+Only 'opencode' is currently implemented. Other targets listed above will
+throw a "not yet supported" error and exit non-zero.
+`);
+}
+async function handleSetupCapabilities(args) {
+  if (args[0] === "--help" || args[0] === "-h") {
+    printSetupCapabilitiesHelp();
+    return;
+  }
+  if (args.length === 0 || args[0].startsWith("--")) {
+    console.error("\u274C Error: setup capabilities requires a <target>");
+    console.error(
+      "Usage: setup capabilities <target> [--model-thinking M] [--model-coding M] [--model-research M] [--force]"
+    );
+    console.error(
+      `Supported targets: ${CapabilityGeneratorRegistry.getSupportedNames().join(", ")}`
+    );
+    console.error("Run `setup capabilities --help` for the full target list.");
+    process.exit(1);
+  }
+  const target = args[0];
+  const flagArgs = args.slice(1);
+  const thinking = parseFlag(flagArgs, "--model-thinking");
+  const coding = parseFlag(flagArgs, "--model-coding");
+  const research = parseFlag(flagArgs, "--model-research");
+  const force = flagArgs.includes("--force");
+  const models = {};
+  if (thinking !== void 0) models.thinking = thinking;
+  if (coding !== void 0) models.coding = coding;
+  if (research !== void 0) models.research = research;
+  if (Object.keys(models).length === 0) {
+    console.error(
+      "\u274C Error: setup capabilities requires at least one --model-* flag"
+    );
+    console.error(
+      "Usage: setup capabilities <target> [--model-thinking M] [--model-coding M] [--model-research M] [--force]"
+    );
+    process.exit(1);
+  }
+  for (const [capability, value] of Object.entries(models)) {
+    if (value.trim() === "") {
+      console.error(
+        `\u274C Error: --model-${capability} must be a non-empty string`
+      );
+      process.exit(1);
+    }
+  }
+  try {
+    const result = await generateCapabilities(target, {
+      projectPath: process.cwd(),
+      models,
+      force
+    });
+    for (const file of result.generatedFiles) {
+      console.log(`\u2705 Generated: ${file}`);
+    }
+    for (const file of result.skippedFiles) {
+      console.log(
+        `\u23ED\uFE0F  Skipped: ${file} (already exists; re-run with --force to overwrite)`
+      );
+    }
+    if (result.configUpdated) {
+      console.log(`\u2705 Config updated: ${result.configPath}`);
+    } else {
+      console.log(`\u2139\uFE0F  Config unchanged: ${result.configPath}`);
+    }
+  } catch (error) {
+    console.error(`\u274C Failed: ${error.message}`);
+    process.exit(1);
+  }
+}
 function handleSetupList() {
   const skillTargets = SkillGeneratorRegistry.getGeneratorNames();
   const configTargets = GeneratorRegistry.getGeneratorNames();
@@ -1316,12 +1750,12 @@ function handleSetupList() {
 function handleCrowdList() {
   try {
     const possibleAgentsPaths = [
-      join5(__dirname3, "..", "..", "..", "resources", "agents"),
-      join5(__dirname3, "..", "..", "core", "resources", "agents")
+      join6(__dirname4, "..", "..", "..", "resources", "agents"),
+      join6(__dirname4, "..", "..", "core", "resources", "agents")
     ];
     let agentsDir = null;
     for (const path of possibleAgentsPaths) {
-      if (existsSync3(path)) {
+      if (existsSync4(path)) {
         agentsDir = path;
         break;
       }
@@ -1339,7 +1773,7 @@ function handleCrowdList() {
     }
     console.log("\u{1F4CB} Available crowd agent configurations:\n");
     for (const file of files) {
-      const agentPath = join5(agentsDir, file);
+      const agentPath = join6(agentsDir, file);
       const content = readFileSync(agentPath, "utf8");
       const nameMatch = content.match(/^name:\s*(.+)$/m);
       const displayNameMatch = content.match(/^displayName:\s*(.+)$/m);
@@ -1358,12 +1792,12 @@ function handleCrowdList() {
 function handleCrowdCopy(outputDir) {
   try {
     const possibleAgentsPaths = [
-      join5(__dirname3, "..", "..", "..", "resources", "agents"),
-      join5(__dirname3, "..", "..", "core", "resources", "agents")
+      join6(__dirname4, "..", "..", "..", "resources", "agents"),
+      join6(__dirname4, "..", "..", "core", "resources", "agents")
     ];
     let sourceAgentsDir = null;
     for (const path of possibleAgentsPaths) {
-      if (existsSync3(path)) {
+      if (existsSync4(path)) {
         sourceAgentsDir = path;
         break;
       }
@@ -1372,8 +1806,8 @@ function handleCrowdCopy(outputDir) {
       console.error("\u274C Could not find source agents directory");
       process.exit(1);
     }
-    const targetDir = outputDir || join5(process.cwd(), ".crowd", "agents");
-    if (!existsSync3(targetDir)) {
+    const targetDir = outputDir || join6(process.cwd(), ".crowd", "agents");
+    if (!existsSync4(targetDir)) {
       mkdirSync(targetDir, { recursive: true });
     }
     const files = readdirSync(sourceAgentsDir).filter(
@@ -1390,9 +1824,9 @@ function handleCrowdCopy(outputDir) {
     let copiedCount = 0;
     let skippedCount = 0;
     for (const file of files) {
-      const sourcePath = join5(sourceAgentsDir, file);
-      const targetPath = join5(targetDir, file);
-      if (existsSync3(targetPath)) {
+      const sourcePath = join6(sourceAgentsDir, file);
+      const targetPath = join6(targetDir, file);
+      if (existsSync4(targetPath)) {
         console.log(`\u23ED\uFE0F  ${file} (already exists, skipping)`);
         skippedCount++;
       } else {
@@ -1430,6 +1864,7 @@ SETUP COMMANDS:
   setup <target> --mode config  Generate full agent configuration
   setup <target> --mode skill   Generate skill files only
   setup list                    List available targets
+  setup capabilities <target>   Wire up capability-routed agents (see --help)
 
 WORKFLOW COMMANDS:
   workflow list                 List available workflows