@specforge/cli 0.1.0

package/dist/cli/commands/scaffold/scaffold.js

@@ -0,0 +1,728 @@
+import path from "path";
+import fs from "fs";
+import { COMMAND_CATEGORIES } from "./types.js";
+import { AGENT_CATEGORIES } from "./agent-types.js";
+import {
+  TARGETS,
+  isValidTarget,
+  resolveTargetAlias,
+  getSupportedTargets,
+  getTargetPath,
+  getAgentPath,
+  getSkillPath,
+  getAgentSupportedTargets
+} from "./targets.js";
+import {
+  scaffoldMultiCli
+} from "./files.js";
+import { loadGlobalConfig } from "../../config/index.js";
+import { getCommandTemplates } from "../../templates/commands.js";
+import { getAgentTemplates } from "../../templates/agents/index.js";
+import {
+  detectInstalledTools,
+  generateCommandContent,
+  generateAgentContent,
+  ensureDirectory,
+  writeFile,
+  getCommandFilename,
+  getAgentFilename,
+  compareFiles,
+  generateDiff
+} from "./utils.js";
+import {
+  displayCommandList,
+  displayAgentList,
+  displayScaffoldHeader,
+  displayAgentScaffoldHeader,
+  displayFileOperation,
+  displayScaffoldSummary,
+  displayAgentScaffoldSummary,
+  displayTargetError,
+  displayAgentTargetError,
+  displayDiff,
+  displayCommandPreview,
+  displayAgentPreview
+} from "./display.js";
+import { colors } from "../../ui/colors.js";
+async function selectTarget(mode = "command") {
+  const installed = detectInstalledTools();
+  const inquirer = await import("inquirer");
+  const availableTargets = Object.entries(TARGETS).filter(([_, config]) => {
+    if (mode === "agent") return config.supportsAgents;
+    if (mode === "skill") return config.supportsSkills;
+    return true;
+  });
+  const choices = availableTargets.map(([key, config]) => ({
+    name: `${config.name}${installed.includes(key) ? colors.success(" (detected)") : ""}`,
+    value: key
+  }));
+  const { target } = await inquirer.default.prompt([
+    {
+      type: "list",
+      name: "target",
+      message: mode === "agent" ? "Select target AI CLI tool (agent support):" : mode === "skill" ? "Select target AI CLI tool (skill support):" : "Select target AI CLI tool:",
+      choices
+    }
+  ]);
+  return target;
+}
+async function interactivePreview(target) {
+  const inquirer = await import("inquirer");
+  const templates = getCommandTemplates();
+  const config = TARGETS[target];
+  const choices = [];
+  for (const [category, commandNames] of Object.entries(COMMAND_CATEGORIES)) {
+    choices.push(new inquirer.default.Separator(`\u2500\u2500 ${category} \u2500\u2500`));
+    for (const name of commandNames) {
+      const template = templates.find((t) => t.name === name);
+      if (template) {
+        choices.push({
+          name: `${name.padEnd(25)} ${colors.dim(template.description)}`,
+          value: name
+        });
+      }
+    }
+  }
+  let continuePreview = true;
+  while (continuePreview) {
+    const { command } = await inquirer.default.prompt([{
+      type: "list",
+      name: "command",
+      message: "Select command to preview (Ctrl+C to exit):",
+      choices: [
+        ...choices,
+        new inquirer.default.Separator(),
+        { name: "Exit", value: null }
+      ],
+      pageSize: 20
+    }]);
+    if (!command) {
+      continuePreview = false;
+    } else {
+      const template = templates.find((t) => t.name === command);
+      if (template) {
+        console.clear();
+        const content = generateCommandContent(template, config.needsFrontmatter, target);
+        displayCommandPreview(template.name, content);
+        await inquirer.default.prompt([{
+          type: "input",
+          name: "continue",
+          message: "Press Enter to continue..."
+        }]);
+        console.clear();
+      }
+    }
+  }
+}
+async function interactiveAgentPreview(target) {
+  const inquirer = await import("inquirer");
+  const templates = getAgentTemplates();
+  const config = TARGETS[target];
+  const choices = [];
+  for (const [category, agentNames] of Object.entries(AGENT_CATEGORIES)) {
+    choices.push(new inquirer.default.Separator(`\u2500\u2500 ${category} \u2500\u2500`));
+    for (const name of agentNames) {
+      const template = templates.find((t) => t.name === name);
+      if (template) {
+        choices.push({
+          name: `${name.padEnd(25)} ${colors.dim(`[${template.model}]`)} ${colors.dim(template.description)}`,
+          value: name
+        });
+      }
+    }
+  }
+  let continuePreview = true;
+  while (continuePreview) {
+    const { agent } = await inquirer.default.prompt([{
+      type: "list",
+      name: "agent",
+      message: "Select agent to preview (Ctrl+C to exit):",
+      choices: [
+        ...choices,
+        new inquirer.default.Separator(),
+        { name: "Exit", value: null }
+      ],
+      pageSize: 20
+    }]);
+    if (!agent) {
+      continuePreview = false;
+    } else {
+      const template = templates.find((t) => t.name === agent);
+      if (template) {
+        console.clear();
+        const content = generateAgentContent(template, config.agentFrontmatter, target);
+        displayAgentPreview(template.name, content, template.model);
+        await inquirer.default.prompt([{
+          type: "input",
+          name: "continue",
+          message: "Press Enter to continue..."
+        }]);
+        console.clear();
+      }
+    }
+  }
+}
+async function interactiveDiff(target) {
+  const inquirer = await import("inquirer");
+  const templates = getCommandTemplates();
+  const config = TARGETS[target];
+  const targetPath = getTargetPath(target, false);
+  const outdated = [];
+  for (const template of templates) {
+    const filename = getCommandFilename(template.name, config.fileExtension);
+    const filepath = path.join(targetPath, filename);
+    const content = generateCommandContent(template, config.needsFrontmatter, target);
+    const comparison = compareFiles(filepath, content);
+    if (comparison.status === "outdated") {
+      outdated.push({ name: template.name, template, kept: false });
+    }
+  }
+  if (outdated.length === 0) {
+    console.log(colors.success("\nAll commands are up to date!"));
+    return;
+  }
+  const buildChoices = () => outdated.map(({ name, template, kept }) => ({
+    name: `${kept ? colors.dim("\u25CB") : "\u26A0"} ${name.padEnd(23)} ${kept ? colors.dim("(keeping current)") : colors.dim(template.description)}`,
+    value: name
+  }));
+  let continueDiff = true;
+  while (continueDiff) {
+    const keptCount = outdated.filter((o) => o.kept).length;
+    const updateCount = outdated.length - keptCount;
+    const choices = buildChoices();
+    const { command } = await inquirer.default.prompt([{
+      type: "list",
+      name: "command",
+      message: `Select command to view diff (${updateCount} to update, ${keptCount} keeping):`,
+      choices: [
+        ...choices,
+        new inquirer.default.Separator(),
+        { name: "Apply changes & Exit", value: "apply" },
+        { name: "Exit without changes", value: null }
+      ],
+      pageSize: 15
+    }]);
+    if (!command) {
+      continueDiff = false;
+    } else if (command === "apply") {
+      const toUpdate = outdated.filter((o) => !o.kept);
+      if (toUpdate.length === 0) {
+        console.log(colors.dim("\nNo commands to update (all marked as keep)"));
+      } else {
+        console.log();
+        for (const item of toUpdate) {
+          const filename = getCommandFilename(item.name, config.fileExtension);
+          const filepath = path.join(targetPath, filename);
+          const content = generateCommandContent(item.template, config.needsFrontmatter, target);
+          writeFile(filepath, content);
+          console.log(colors.success(`  \u2713 Updated ${filename}`));
+        }
+        console.log(colors.success(`
+Updated ${toUpdate.length} commands`));
+      }
+      if (keptCount > 0) {
+        console.log(colors.dim(`Kept ${keptCount} commands unchanged`));
+      }
+      continueDiff = false;
+    } else {
+      console.clear();
+      const item = outdated.find((o) => o.name === command);
+      if (item) {
+        const filename = getCommandFilename(item.name, config.fileExtension);
+        const filepath = path.join(targetPath, filename);
+        const content = generateCommandContent(item.template, config.needsFrontmatter, target);
+        const comparison = compareFiles(filepath, content);
+        console.log(colors.bold(`
+Diff: ${item.name}`));
+        console.log("\u2500".repeat(50));
+        if (comparison.existingContent) {
+          displayDiff(generateDiff(comparison.existingContent, content, filename));
+        }
+        const { action } = await inquirer.default.prompt([{
+          type: "list",
+          name: "action",
+          message: "What do you want to do?",
+          choices: [
+            { name: item.kept ? "Mark for update" : "Keep current version (skip update)", value: "toggle" },
+            { name: "Back to list", value: "back" }
+          ]
+        }]);
+        if (action === "toggle") {
+          item.kept = !item.kept;
+        }
+        console.clear();
+      }
+    }
+  }
+}
+async function interactiveAgentDiff(target) {
+  const inquirer = await import("inquirer");
+  const templates = getAgentTemplates();
+  const config = TARGETS[target];
+  const targetPath = getAgentPath(target, false);
+  const outdated = [];
+  for (const template of templates) {
+    const filename = getAgentFilename(template.name, target);
+    const filepath = path.join(targetPath, filename);
+    const content = generateAgentContent(template, config.agentFrontmatter, target);
+    const comparison = compareFiles(filepath, content);
+    if (comparison.status === "outdated") {
+      outdated.push({ name: template.name, template, kept: false });
+    }
+  }
+  if (outdated.length === 0) {
+    console.log(colors.success("\nAll agents are up to date!"));
+    return;
+  }
+  const buildChoices = () => outdated.map(({ name, template, kept }) => ({
+    name: `${kept ? colors.dim("\u25CB") : "\u26A0"} ${name.padEnd(23)} ${kept ? colors.dim("(keeping current)") : colors.dim(template.description)}`,
+    value: name
+  }));
+  let continueDiff = true;
+  while (continueDiff) {
+    const keptCount = outdated.filter((o) => o.kept).length;
+    const updateCount = outdated.length - keptCount;
+    const choices = buildChoices();
+    const { agent } = await inquirer.default.prompt([{
+      type: "list",
+      name: "agent",
+      message: `Select agent to view diff (${updateCount} to update, ${keptCount} keeping):`,
+      choices: [
+        ...choices,
+        new inquirer.default.Separator(),
+        { name: "Apply changes & Exit", value: "apply" },
+        { name: "Exit without changes", value: null }
+      ],
+      pageSize: 15
+    }]);
+    if (!agent) {
+      continueDiff = false;
+    } else if (agent === "apply") {
+      const toUpdate = outdated.filter((o) => !o.kept);
+      if (toUpdate.length === 0) {
+        console.log(colors.dim("\nNo agents to update (all marked as keep)"));
+      } else {
+        console.log();
+        for (const item of toUpdate) {
+          const filename = getAgentFilename(item.name, target);
+          const filepath = path.join(targetPath, filename);
+          const content = generateAgentContent(item.template, config.agentFrontmatter, target);
+          writeFile(filepath, content);
+          console.log(colors.success(`  \u2713 Updated ${filename}`));
+        }
+        console.log(colors.success(`
+Updated ${toUpdate.length} agents`));
+      }
+      if (keptCount > 0) {
+        console.log(colors.dim(`Kept ${keptCount} agents unchanged`));
+      }
+      continueDiff = false;
+    } else {
+      console.clear();
+      const item = outdated.find((o) => o.name === agent);
+      if (item) {
+        const filename = getAgentFilename(item.name, target);
+        const filepath = path.join(targetPath, filename);
+        const content = generateAgentContent(item.template, config.agentFrontmatter, target);
+        const comparison = compareFiles(filepath, content);
+        console.log(colors.bold(`
+Diff: ${item.name}`));
+        console.log("\u2500".repeat(50));
+        if (comparison.existingContent) {
+          displayDiff(generateDiff(comparison.existingContent, content, filename));
+        }
+        const { action } = await inquirer.default.prompt([{
+          type: "list",
+          name: "action",
+          message: "What do you want to do?",
+          choices: [
+            { name: item.kept ? "Mark for update" : "Keep current version (skip update)", value: "toggle" },
+            { name: "Back to list", value: "back" }
+          ]
+        }]);
+        if (action === "toggle") {
+          item.kept = !item.kept;
+        }
+        console.clear();
+      }
+    }
+  }
+}
+async function scaffoldCommands(target, options) {
+  const config = TARGETS[target];
+  if (!config.supportsCommands) {
+    console.log(colors.warning(`
+${config.name} does not support slash commands.`));
+    console.log(colors.dim("Commands will be generated as skills instead.\n"));
+    await scaffoldSkills(target, options);
+    return;
+  }
+  const isProject = options.project === true;
+  const targetPath = getTargetPath(target, isProject);
+  const templates = getCommandTemplates();
+  displayScaffoldHeader(target, targetPath, options.dryRun === true);
+  if (!options.dryRun) {
+    ensureDirectory(targetPath);
+  }
+  const result = {
+    created: 0,
+    updated: 0,
+    skipped: 0,
+    outdated: 0,
+    targetPath
+  };
+  for (const template of templates) {
+    const filename = getCommandFilename(template.name, config.commandExtension);
+    const filepath = path.join(targetPath, filename);
+    const content = generateCommandContent(
+      template,
+      config.commandFrontmatter,
+      target
+    );
+    const comparison = compareFiles(filepath, content);
+    displayFileOperation(filename, comparison.status, options.dryRun === true, options.update === true);
+    if (options.diff && comparison.status === "outdated" && comparison.existingContent) {
+      const diff = generateDiff(comparison.existingContent, content, filename);
+      displayDiff(diff);
+    }
+    switch (comparison.status) {
+      case "new":
+        if (!options.dryRun) {
+          writeFile(filepath, content);
+        }
+        result.created++;
+        break;
+      case "identical":
+        result.skipped++;
+        break;
+      case "outdated":
+        if (options.update) {
+          if (!options.dryRun) {
+            writeFile(filepath, content);
+          }
+          result.updated++;
+        } else {
+          result.outdated++;
+        }
+        break;
+    }
+  }
+  displayScaffoldSummary(result, target, options.dryRun === true);
+}
+async function scaffoldSkills(target, options) {
+  const config = TARGETS[target];
+  if (!config.supportsSkills) {
+    console.error(colors.error(`
+${config.name} does not support skills.`));
+    return;
+  }
+  const isProject = options.project === true;
+  const targetPath = getSkillPath(target, isProject);
+  console.log(colors.bold(`
+Scaffolding SpecForge skills for ${config.name}`));
+  console.log(`Target: ${colors.primary(targetPath)}
+`);
+  if (options.dryRun) {
+    console.log(colors.warning("DRY RUN - No files will be written\n"));
+  }
+  const skillName = "specforge-conventions";
+  const skillDir = path.join(targetPath, skillName);
+  const skillFile = path.join(skillDir, "SKILL.md");
+  const { fileURLToPath } = await import("url");
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  const packageRoot = path.resolve(__dirname, "..", "..", "..");
+  const templatePath = path.join(packageRoot, "src", "cli", "templates", "skills", "specforge-conventions.md");
+  if (!fs.existsSync(templatePath)) {
+    console.log(colors.warning("Skill template not found. Skipping."));
+    return;
+  }
+  const templateContent = fs.readFileSync(templatePath, "utf-8");
+  const comparison = compareFiles(skillFile, templateContent);
+  displayFileOperation(`${skillName}/SKILL.md`, comparison.status, options.dryRun === true, options.update === true);
+  if (!options.dryRun) {
+    if (comparison.status === "new" || comparison.status === "outdated" && options.update) {
+      ensureDirectory(skillDir);
+      writeFile(skillFile, templateContent);
+    }
+  }
+  const created = comparison.status === "new" ? 1 : 0;
+  const updated = comparison.status === "outdated" && options.update ? 1 : 0;
+  const skipped = comparison.status === "identical" ? 1 : 0;
+  const outdated = comparison.status === "outdated" && !options.update ? 1 : 0;
+  console.log();
+  if (created > 0) console.log(colors.success(`\u2713 Created ${created} skill(s)`));
+  if (updated > 0) console.log(colors.secondary(`\u2713 Updated ${updated} skill(s)`));
+  if (skipped > 0) console.log(colors.dim(`\u25CB Skipped ${skipped} up-to-date skill(s)`));
+  if (outdated > 0) console.log(colors.warning(`\u26A0 ${outdated} outdated skill(s) (run with --update to update)`));
+  console.log();
+}
+async function scaffoldAgents(target, options) {
+  const config = TARGETS[target];
+  if (target === "codex") {
+    console.log(colors.warning("\nCodex CLI uses TOML agent roles, not markdown agent files."));
+    console.log(colors.dim("Agent scaffolding is not available for Codex. Configure roles in .codex/config.toml instead.\n"));
+    return;
+  }
+  const isProject = options.project === true;
+  const targetPath = getAgentPath(target, isProject);
+  let templates = getAgentTemplates();
+  if (options.category) {
+    const categoryLower = options.category.toLowerCase();
+    templates = templates.filter((t) => t.category.toLowerCase() === categoryLower);
+    if (templates.length === 0) {
+      console.error(colors.error(`
+No agents found in category "${options.category}"`));
+      console.error(colors.dim(`Available categories: Orchestration, SpecForge, Research`));
+      process.exit(1);
+      return;
+    }
+  }
+  displayAgentScaffoldHeader(target, targetPath, options.dryRun === true);
+  if (target === "gemini") {
+    console.log(colors.warning("Note: Gemini CLI agents require experimental.enableAgents: true in .gemini/settings.json\n"));
+  }
+  if (!options.dryRun) {
+    ensureDirectory(targetPath);
+  }
+  const result = {
+    created: 0,
+    updated: 0,
+    skipped: 0,
+    outdated: 0,
+    targetPath
+  };
+  for (const template of templates) {
+    const filename = getAgentFilename(template.name, target);
+    const filepath = path.join(targetPath, filename);
+    const content = generateAgentContent(template, config.agentFrontmatter, target);
+    const comparison = compareFiles(filepath, content);
+    displayFileOperation(filename, comparison.status, options.dryRun === true, options.update === true);
+    if (options.diff && comparison.status === "outdated" && comparison.existingContent) {
+      const diff = generateDiff(comparison.existingContent, content, filename);
+      displayDiff(diff);
+    }
+    switch (comparison.status) {
+      case "new":
+        if (!options.dryRun) {
+          writeFile(filepath, content);
+        }
+        result.created++;
+        break;
+      case "identical":
+        result.skipped++;
+        break;
+      case "outdated":
+        if (options.update) {
+          if (!options.dryRun) {
+            writeFile(filepath, content);
+          }
+          result.updated++;
+        } else {
+          result.outdated++;
+        }
+        break;
+    }
+    if (target === "claude" && isProject && template.memory === "project" && !options.dryRun) {
+      const claudeDir = path.dirname(targetPath);
+      const agentMemoryDir = path.join(claudeDir, "agent-memory", template.name);
+      ensureDirectory(agentMemoryDir);
+    }
+  }
+  displayAgentScaffoldSummary(result, target, options.dryRun === true);
+}
+function renderWriteResult(w) {
+  const action = w.action;
+  switch (action) {
+    case "created":
+      console.log(colors.success(`  + ${w.relPath} (created)`));
+      break;
+    case "overwrote":
+      console.log(colors.secondary(`  \u21BB ${w.relPath} (overwrote)`));
+      break;
+    case "skipped":
+      console.log(colors.dim(`  \u25CB ${w.relPath} (exists, skip \u2014 use --force)`));
+      break;
+    case "would-create":
+      console.log(colors.success(`  + ${w.relPath} (would create)`));
+      break;
+    case "would-overwrite":
+      console.log(colors.secondary(`  \u21BB ${w.relPath} (would overwrite)`));
+      break;
+    case "would-skip":
+      console.log(colors.dim(`  \u25CB ${w.relPath} (exists, skip \u2014 use --force)`));
+      break;
+  }
+}
+function runMultiCli(label, subset, targets, options) {
+  const apiKey = loadGlobalConfig().apiKey;
+  const { detected, writes } = scaffoldMultiCli({
+    targets,
+    dryRun: options.dryRun === true,
+    force: options.force === true,
+    apiKey,
+    skipConfigs: !subset.configs,
+    skipInstructions: !subset.instructions,
+    skipSkills: !subset.skills
+  });
+  console.log(colors.bold(`
+Scaffolding SpecForge ${label}`));
+  if (detected.length > 0) {
+    console.log(colors.dim(`Detected: ${detected.map((t) => TARGETS[t].name).join(", ")}`));
+  }
+  if (options.dryRun) {
+    console.log(colors.warning("\nDRY RUN \u2014 no files will be written"));
+  }
+  console.log();
+  for (const w of writes) {
+    renderWriteResult(w);
+  }
+  console.log();
+  return writes;
+}
+async function scaffoldCommand(options) {
+  if (options.target) {
+    options.target = resolveTargetAlias(options.target);
+  }
+  const isAgentMode = options.agents === true;
+  const isSkillMode = options.skills === true;
+  const isCommandMode = options.commands === true;
+  const isConfigsMode = options.configs === true;
+  const isInstructionsMode = options.instructions === true;
+  const anySubset = isAgentMode || isSkillMode || isCommandMode || isConfigsMode || isInstructionsMode;
+  const mode = isAgentMode ? "agent" : isSkillMode ? "skill" : "command";
+  if (options.list) {
+    if (isAgentMode) {
+      const templates = getAgentTemplates();
+      displayAgentList(templates, options.category);
+    } else {
+      const templates = getCommandTemplates();
+      displayCommandList(templates);
+    }
+    return;
+  }
+  if (typeof options.preview === "string") {
+    if (isAgentMode) {
+      const templates = getAgentTemplates();
+      const template = templates.find((t) => t.name === options.preview);
+      if (!template) {
+        console.error(colors.error(`
+Error: Unknown agent "${options.preview}"`));
+        console.error(`Run 'specforge scaffold --agents --list' to see available agents`);
+        process.exit(1);
+        return;
+      }
+      const content = generateAgentContent(template, true);
+      displayAgentPreview(template.name, content, template.model);
+    } else {
+      const templates = getCommandTemplates();
+      const template = templates.find((t) => t.name === options.preview);
+      if (!template) {
+        console.error(colors.error(`
+Error: Unknown command "${options.preview}"`));
+        console.error(`Run 'specforge scaffold --list' to see available commands`);
+        process.exit(1);
+        return;
+      }
+      const content = generateCommandContent(template, true, "claude");
+      displayCommandPreview(template.name, content);
+    }
+    return;
+  }
+  if (options.preview === true) {
+    let target2;
+    if (options.target && isValidTarget(options.target)) {
+      target2 = options.target;
+    } else {
+      target2 = await selectTarget(mode);
+    }
+    if (isAgentMode && !TARGETS[target2].supportsAgents) {
+      displayAgentTargetError(target2, getAgentSupportedTargets());
+      process.exit(1);
+      return;
+    }
+    if (isAgentMode) {
+      await interactiveAgentPreview(target2);
+    } else {
+      await interactivePreview(target2);
+    }
+    return;
+  }
+  if (options.diff && !options.update) {
+    let target2;
+    if (options.target && isValidTarget(options.target)) {
+      target2 = options.target;
+    } else {
+      target2 = await selectTarget(mode);
+    }
+    if (isAgentMode && !TARGETS[target2].supportsAgents) {
+      displayAgentTargetError(target2, getAgentSupportedTargets());
+      process.exit(1);
+      return;
+    }
+    if (isAgentMode) {
+      await interactiveAgentDiff(target2);
+    } else {
+      await interactiveDiff(target2);
+    }
+    return;
+  }
+  let scopedTargets;
+  if (options.target) {
+    if (!isValidTarget(options.target)) {
+      displayTargetError(options.target, getSupportedTargets());
+      process.exit(1);
+      return;
+    }
+    scopedTargets = [options.target];
+  }
+  if (isConfigsMode && !isInstructionsMode && !isSkillMode && !isCommandMode && !isAgentMode) {
+    runMultiCli("MCP configs", { configs: true, instructions: false, skills: false }, scopedTargets, options);
+    return;
+  }
+  if (isInstructionsMode && !isConfigsMode && !isSkillMode && !isCommandMode && !isAgentMode) {
+    runMultiCli("instruction files", { configs: false, instructions: true, skills: false }, scopedTargets, options);
+    return;
+  }
+  if (!anySubset) {
+    const writes = runMultiCli(
+      "integration artifacts",
+      { configs: true, instructions: true, skills: true },
+      scopedTargets,
+      options
+    );
+    const targetSet = scopedTargets ?? detectInstalledTools();
+    for (const t of targetSet) {
+      if (TARGETS[t].supportsCommands) {
+        await scaffoldCommands(t, options);
+      }
+      if (TARGETS[t].supportsAgents && t !== "codex") {
+        await scaffoldAgents(t, options);
+      }
+    }
+    void writes;
+    return;
+  }
+  let target;
+  if (options.target) {
+    target = options.target;
+  } else {
+    target = await selectTarget(mode);
+  }
+  if (isAgentMode && !TARGETS[target].supportsAgents && target !== "codex") {
+    displayAgentTargetError(target, getAgentSupportedTargets());
+    process.exit(1);
+    return;
+  }
+  if (isAgentMode) {
+    await scaffoldAgents(target, options);
+  } else if (isSkillMode) {
+    await scaffoldSkills(target, options);
+  } else {
+    await scaffoldCommands(target, options);
+  }
+}
+export {
+  scaffoldCommand
+};
+//# sourceMappingURL=scaffold.js.map