@specforge/cli 0.1.0

package/dist/cli/commands/init.js

@@ -0,0 +1,773 @@
+import inquirer from "inquirer";
+import ora from "ora";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  resolveConfig,
+  loadGlobalConfig,
+  tryLoadProjectConfig,
+  saveProjectConfig,
+  setAgentTeamsConfig,
+  addToGitignore,
+  getConfigPaths
+} from "../config/index.js";
+import { CONFIG_FILES } from "../config/types.js";
+import { withErrorHandler, CliError, NetworkError, ValidationError } from "../middleware/error-handler.js";
+import {
+  printSuccess,
+  printWarning,
+  printBlank,
+  printHeader,
+  printField,
+  printHint
+} from "../ui/output.js";
+import { colors } from "../ui/colors.js";
+import { printBanner } from "../ui/banner.js";
+import { forgeProgress } from "../ui/spinner.js";
+import { createCliClient } from "../../client/cli-client.js";
+import {
+  FORMAT_CHOICES,
+  DEFAULT_FORMAT,
+  STRATEGY_CHOICES,
+  SKILL_TEMPLATE_FILES
+} from "./init.types.js";
+import { TARGETS } from "./scaffold/targets.js";
+import { scaffoldMultiCli } from "./scaffold/files.js";
+import { detectInstalledTools } from "./scaffold/utils.js";
+async function fetchProjects(client) {
+  const response = await client.call("list_projects", {});
+  return response.projects || [];
+}
+async function fetchSpecifications(client, projectId) {
+  const response = await client.call(
+    "list_specifications",
+    { projectId }
+  );
+  return response.items || response.specifications || [];
+}
+function checkExistingFiles() {
+  const paths = getConfigPaths();
+  const mcpConfig = fs.existsSync(paths.mcpConfig);
+  const projectConfig = fs.existsSync(paths.projectConfig);
+  return {
+    mcpConfig,
+    projectConfig,
+    anyExists: mcpConfig || projectConfig
+  };
+}
+function buildProjectChoices(projects) {
+  return projects.map((p) => ({
+    name: `${p.name}${p.specCount ? ` (${p.specCount} specs)` : ""}`,
+    value: p.id,
+    short: p.name
+  }));
+}
+function buildSpecificationChoices(specs) {
+  const choices = specs.map((s) => {
+    const ticketInfo = s.ticketCount ? ` - ${s.completedTicketCount || 0}/${s.ticketCount} tickets` : "";
+    return {
+      name: `${s.title} [${s.status}]${ticketInfo}`,
+      value: s.id,
+      short: s.title
+    };
+  });
+  choices.push({
+    name: colors.muted("(skip - select later)"),
+    value: void 0
+  });
+  return choices;
+}
+async function promptForProject(projects, defaultId) {
+  const choices = buildProjectChoices(projects);
+  const { projectId } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "projectId",
+      message: "Select project for this directory:",
+      choices,
+      pageSize: 10,
+      // Resume-aware (M9.8): pre-select the currently-configured project.
+      ...defaultId ? { default: defaultId } : {}
+    }
+  ]);
+  const selected = projects.find((p) => p.id === projectId);
+  if (!selected) {
+    throw new CliError("Project selection failed");
+  }
+  return selected;
+}
+async function promptForSpecification(specs, defaultId) {
+  if (specs.length === 0) {
+    return void 0;
+  }
+  const choices = buildSpecificationChoices(specs);
+  const { specificationId } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "specificationId",
+      message: "Select default specification (optional):",
+      choices,
+      pageSize: 10,
+      // Resume-aware (M9.8): pre-select the currently-configured spec.
+      ...defaultId ? { default: defaultId } : {}
+    }
+  ]);
+  if (!specificationId) {
+    return void 0;
+  }
+  return specs.find((s) => s.id === specificationId);
+}
+async function promptForFormat() {
+  const { format } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "format",
+      message: "Default MCP response format (TOON or JSON):",
+      choices: FORMAT_CHOICES,
+      default: DEFAULT_FORMAT
+    }
+  ]);
+  return format;
+}
+function validateProjectId(projectId, projects) {
+  const project = projects.find((p) => p.id === projectId);
+  if (!project) {
+    const available = projects.map((p) => `  - ${p.id}: ${p.name}`).join("\n");
+    throw new ValidationError(
+      `Project not found: ${projectId}`,
+      `Available projects:
+${available}`
+    );
+  }
+  return project;
+}
+function validateSpecificationId(specId, specs) {
+  const spec = specs.find((s) => s.id === specId);
+  if (!spec) {
+    const available = specs.map((s) => `  - ${s.id}: ${s.title}`).join("\n");
+    throw new ValidationError(
+      `Specification not found: ${specId}`,
+      `Available specifications:
+${available}`
+    );
+  }
+  return spec;
+}
+function showSettings() {
+  const config = resolveConfig();
+  const globalConfig = loadGlobalConfig();
+  const projectConfig = tryLoadProjectConfig();
+  const paths = getConfigPaths();
+  printBlank();
+  printHeader("Current Configuration");
+  printBlank();
+  console.log(colors.bold("Resolved Settings"));
+  console.log(colors.muted("Values merged from all sources (env > project > global > default)"));
+  printBlank();
+  const apiKeyDisplay = config.apiKey ? `${config.apiKey.slice(0, 12)}...${config.apiKey.slice(-4)}` : null;
+  const sourceLabel = (source) => source ? colors.muted(` (from ${source})`) : "";
+  printField("API Key", apiKeyDisplay ? `${apiKeyDisplay}${sourceLabel(config.sources.apiKey)}` : void 0);
+  printField("Project ID", config.projectId ? `${config.projectId}${sourceLabel(config.sources.projectId)}` : void 0);
+  printField("Specification ID", config.specificationId ? `${config.specificationId}${sourceLabel(config.sources.specificationId)}` : void 0);
+  printField("MCP output format", `${config.mcpOutputFormat}${sourceLabel(config.sources.mcpOutputFormat)}`);
+  printField("Auto-context", config.autoSetContext ? "enabled" : "disabled");
+  printField("Debug", config.debug ? "enabled" : "disabled");
+  printField("API URL", config.apiUrl);
+  printBlank();
+  printHeader("Config Files");
+  printBlank();
+  const globalExists = fs.existsSync(paths.globalConfig);
+  const projectExists = fs.existsSync(paths.projectConfig);
+  const mcpExists = fs.existsSync(paths.mcpConfig);
+  printField("Global config", `${paths.globalConfig} ${globalExists ? colors.success("(exists)") : colors.muted("(not found)")}`);
+  printField("Project config", `${paths.projectConfig} ${projectExists ? colors.success("(exists)") : colors.muted("(not found)")}`);
+  printField("MCP config", `${paths.mcpConfig} ${mcpExists ? colors.success("(exists)") : colors.muted("(not found)")}`);
+  if (globalExists && Object.keys(globalConfig).length > 0) {
+    printBlank();
+    printHeader("Global Config (~/.specforge/config.json)");
+    printBlank();
+    if (globalConfig.apiKey) {
+      printField("apiKey", `${globalConfig.apiKey.slice(0, 12)}...${globalConfig.apiKey.slice(-4)}`);
+    }
+    if (globalConfig.mcpOutputFormat) {
+      printField("mcpOutputFormat", globalConfig.mcpOutputFormat);
+    }
+    if (globalConfig.defaultProjectId) {
+      printField("defaultProjectId", globalConfig.defaultProjectId);
+    }
+  }
+  if (projectExists && projectConfig) {
+    printBlank();
+    printHeader("Project Config (.specforge/config.json)");
+    printBlank();
+    if (projectConfig.projectId) {
+      printField("projectId", projectConfig.projectId);
+    }
+    if (projectConfig.specificationId) {
+      printField("specificationId", projectConfig.specificationId);
+    }
+    if (projectConfig.mcpOutputFormat) {
+      printField("mcpOutputFormat", projectConfig.mcpOutputFormat);
+    }
+    if (projectConfig.autoSetContext !== void 0) {
+      printField("autoSetContext", String(projectConfig.autoSetContext));
+    }
+  }
+  printBlank();
+}
+async function promptForAgentTeams() {
+  const { configure } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "configure",
+      message: "Configure Agent Teams (Claude Code)?",
+      default: false
+    }
+  ]);
+  if (!configure) {
+    return null;
+  }
+  const answers = await inquirer.prompt([
+    {
+      type: "list",
+      name: "strategy",
+      message: "Team strategy:",
+      choices: STRATEGY_CHOICES,
+      default: "auto"
+    },
+    {
+      type: "number",
+      name: "maxTicketsPerTeam",
+      message: "Max tickets per team (1-20):",
+      default: 10,
+      validate: (val) => {
+        if (!Number.isInteger(val) || val < 1 || val > 20) {
+          return "Must be an integer between 1 and 20";
+        }
+        return true;
+      }
+    },
+    {
+      type: "number",
+      name: "maxParallelEpics",
+      message: "Max parallel epics (1-10):",
+      default: 3,
+      validate: (val) => {
+        if (!Number.isInteger(val) || val < 1 || val > 10) {
+          return "Must be an integer between 1 and 10";
+        }
+        return true;
+      }
+    },
+    {
+      type: "list",
+      name: "branchPrefix",
+      message: "Branch prefix:",
+      choices: [
+        { name: "ticket/ (Recommended)", value: "ticket/" },
+        { name: "epic/", value: "epic/" },
+        { name: "spec/", value: "spec/" }
+      ],
+      default: "ticket/"
+    }
+  ]);
+  return {
+    enabled: true,
+    strategy: answers.strategy,
+    maxTicketsPerTeam: answers.maxTicketsPerTeam,
+    maxParallelEpics: answers.maxParallelEpics,
+    branchPrefix: answers.branchPrefix
+  };
+}
+function getTemplatesDir() {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  const packageRoot = path.resolve(__dirname, "..", "..", "..");
+  return path.join(packageRoot, "src", "cli", "templates", "skills");
+}
+async function scaffoldSkillFiles(projectName, skipPrompts) {
+  const templatesDir = getTemplatesDir();
+  const skillsRoot = path.resolve(process.cwd(), ".claude", "skills");
+  if (!fs.existsSync(templatesDir)) {
+    printWarning("Skill templates not found. Skipping scaffolding.");
+    return;
+  }
+  try {
+    fs.mkdirSync(skillsRoot, { recursive: true });
+  } catch {
+    printWarning("Could not create .claude/skills/ directory. Skipping skill scaffolding.");
+    return;
+  }
+  const targetFor = (skill) => path.join(skillsRoot, skill, "SKILL.md");
+  const existingSkills = SKILL_TEMPLATE_FILES.filter(
+    (skill) => fs.existsSync(targetFor(skill))
+  );
+  let overwritePolicy = "ask";
+  if (existingSkills.length > 0 && !skipPrompts) {
+    const { policy } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "policy",
+        message: `${existingSkills.length} skill(s) already exist. How should we proceed?`,
+        choices: [
+          { name: "Skip all existing", value: "skip" },
+          { name: "Overwrite all", value: "overwrite" },
+          { name: "Ask for each", value: "ask" }
+        ],
+        default: "ask"
+      }
+    ]);
+    overwritePolicy = policy;
+  } else if (skipPrompts) {
+    overwritePolicy = "skip";
+  }
+  const scaffolded = [];
+  for (const skill of SKILL_TEMPLATE_FILES) {
+    const sourcePath = path.join(templatesDir, `${skill}.md`);
+    const targetPath = targetFor(skill);
+    if (!fs.existsSync(sourcePath)) {
+      continue;
+    }
+    if (fs.existsSync(targetPath)) {
+      if (overwritePolicy === "skip") {
+        continue;
+      }
+      if (overwritePolicy === "ask") {
+        const { overwrite } = await inquirer.prompt([
+          {
+            type: "confirm",
+            name: "overwrite",
+            message: `Skill ${skill}/SKILL.md already exists. Overwrite?`,
+            default: false
+          }
+        ]);
+        if (!overwrite) continue;
+      }
+    }
+    try {
+      let content = fs.readFileSync(sourcePath, "utf-8");
+      if (projectName) {
+        content = content.replace(/\{\{PROJECT_NAME\}\}/g, projectName);
+      }
+      fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+      fs.writeFileSync(targetPath, content);
+      scaffolded.push(skill);
+    } catch {
+      continue;
+    }
+  }
+  if (scaffolded.length > 0) {
+    printBlank();
+    printSuccess(`Scaffolded ${scaffolded.length} skill(s) to .claude/skills/`);
+    for (const skill of scaffolded) {
+      console.log(`  ${colors.muted("\u2022")} ${skill}/SKILL.md`);
+    }
+  }
+}
+function refuseIfLegacyConfig() {
+  const legacyPath = path.resolve(CONFIG_FILES.LEGACY_PROJECT_CONFIG);
+  if (!fs.existsSync(legacyPath)) {
+    return;
+  }
+  throw new CliError(
+    "Legacy .specforge.json detected",
+    1,
+    `Delete ${legacyPath} before running \`specforge init\`. The config layout changed to .specforge/config.json in the first production release; no automatic migration is performed.`
+  );
+}
+async function initAction(options) {
+  if (options.show) {
+    showSettings();
+    return;
+  }
+  refuseIfLegacyConfig();
+  const config = resolveConfig();
+  if (!config.apiKey) {
+    throw new CliError(
+      "Not authenticated",
+      1,
+      "Run `specforge login` to authenticate first"
+    );
+  }
+  if (options.spec === true) {
+    const existing2 = tryLoadProjectConfig();
+    if (existing2?.projectId) {
+      const client2 = createCliClient({ apiKey: config.apiKey, apiUrl: config.apiUrl, debug: config.debug });
+      const specs = await fetchSpecifications(client2, existing2.projectId);
+      const selectedSpec2 = await promptForSpecification(specs);
+      if (selectedSpec2) {
+        saveProjectConfig({
+          ...existing2,
+          specificationId: selectedSpec2.id,
+          // Switching spec abandons the previous spec's planning session (M9.8).
+          planningSessionId: selectedSpec2.id === existing2.specificationId ? existing2.planningSessionId : void 0
+        });
+        printSuccess(`Switched to: ${selectedSpec2.title}`);
+      }
+      return;
+    }
+    printWarning("No project configured. Running full init...");
+    printBlank();
+  }
+  if (options.specOnly) {
+    const existing2 = tryLoadProjectConfig();
+    if (!existing2?.projectId) {
+      throw new CliError("No .specforge/config.json found \u2014 run `specforge init` first");
+    }
+    const client2 = createCliClient({ apiKey: config.apiKey, apiUrl: config.apiUrl, debug: config.debug });
+    const specs = await fetchSpecifications(client2, existing2.projectId);
+    let selectedSpec2;
+    if (typeof options.spec === "string") {
+      selectedSpec2 = validateSpecificationId(options.spec, specs);
+    } else {
+      const { specId } = await inquirer.prompt([{
+        type: "list",
+        name: "specId",
+        message: "Select specification:",
+        choices: specs.map((s) => ({ name: `${s.title} (${s.status})`, value: s.id }))
+      }]);
+      selectedSpec2 = specs.find((s) => s.id === specId);
+    }
+    saveProjectConfig({
+      ...existing2,
+      specificationId: selectedSpec2.id,
+      // Switching spec abandons the previous spec's planning session (M9.8).
+      planningSessionId: selectedSpec2.id === existing2.specificationId ? existing2.planningSessionId : void 0
+    });
+    printSuccess(`Switched to: ${selectedSpec2.title}`);
+    return;
+  }
+  printBlank();
+  printBanner("figlet");
+  printBlank();
+  const existing = checkExistingFiles();
+  const priorConfig = tryLoadProjectConfig();
+  const canResume = !!priorConfig?.projectId && !options.force;
+  if (existing.anyExists && !options.force && !canResume) {
+    printWarning("Configuration files already exist:");
+    if (existing.mcpConfig) {
+      console.log(`  ${colors.muted("\u2022")} .mcp.json`);
+    }
+    if (existing.projectConfig) {
+      console.log(`  ${colors.muted("\u2022")} ${CONFIG_FILES.PROJECT_CONFIG}`);
+    }
+    printBlank();
+    console.log(`Use ${colors.primary("--force")} to overwrite existing files.`);
+    printBlank();
+    return;
+  }
+  const client = createCliClient({
+    apiKey: config.apiKey,
+    apiUrl: config.apiUrl,
+    debug: config.debug
+  });
+  const spinner = ora({
+    text: "Connecting to SpecForge...",
+    color: "cyan"
+  }).start();
+  let projects;
+  try {
+    projects = await fetchProjects(client);
+    spinner.succeed("Connected to SpecForge");
+  } catch (error) {
+    spinner.fail("Connection failed");
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("401") || message.includes("Unauthorized")) {
+      throw new CliError(
+        "Authentication failed",
+        1,
+        "Your API key may be invalid. Run `specforge login` to re-authenticate"
+      );
+    }
+    throw new NetworkError(`Failed to fetch projects: ${message}`);
+  }
+  if (projects.length === 0) {
+    printBlank();
+    printWarning("No projects found in your account.");
+    console.log(
+      `Create a project at ${colors.primary.underline("https://specforge.com.br")} first.`
+    );
+    printBlank();
+    return;
+  }
+  let resumeMode = false;
+  let defaultProjectId;
+  let defaultSpecId;
+  let resumeSelectedSpec;
+  if (canResume) {
+    const currentProject = projects.find((p) => p.id === priorConfig.projectId);
+    if (currentProject) {
+      let currentSpecs = [];
+      try {
+        currentSpecs = await fetchSpecifications(client, currentProject.id);
+      } catch {
+      }
+      const currentSpec = priorConfig.specificationId ? currentSpecs.find((s) => s.id === priorConfig.specificationId) : void 0;
+      printBlank();
+      printHeader("Configuration already exists");
+      printBlank();
+      printField("Project", currentProject.name);
+      printField(
+        "Specification",
+        currentSpec ? `${currentSpec.title} [${currentSpec.status}]` : colors.muted("(none)")
+      );
+      if (priorConfig.planningSessionId) {
+        printField("Planning session", `${priorConfig.planningSessionId} ${colors.muted("(active)")}`);
+      }
+      printBlank();
+      const { choice } = await inquirer.prompt([
+        {
+          type: "list",
+          name: "choice",
+          message: "How do you want to proceed?",
+          choices: [
+            { name: "Resume \u2014 keep config, refresh scaffolding", value: "resume" },
+            { name: "Reconfigure \u2014 pick project/spec again (current pre-selected)", value: "reconfigure" },
+            { name: "Cancel", value: "cancel" }
+          ],
+          default: "resume"
+        }
+      ]);
+      if (choice === "cancel") {
+        printBlank();
+        console.log(colors.muted("Cancelled \u2014 no changes made."));
+        printBlank();
+        return;
+      }
+      if (choice === "resume") {
+        resumeMode = true;
+        resumeSelectedSpec = currentSpec;
+      } else {
+        defaultProjectId = currentProject.id;
+        defaultSpecId = currentSpec?.id;
+      }
+    }
+  }
+  let selectedProject;
+  let selectedSpec;
+  let selectedFormat;
+  if (resumeMode) {
+    selectedProject = projects.find((p) => p.id === priorConfig.projectId);
+    selectedSpec = resumeSelectedSpec;
+    selectedFormat = priorConfig.mcpOutputFormat ?? DEFAULT_FORMAT;
+  } else {
+    if (options.project) {
+      selectedProject = validateProjectId(options.project, projects);
+      console.log(colors.muted(`Using project: ${selectedProject.name}`));
+    } else {
+      selectedProject = await promptForProject(projects, defaultProjectId);
+    }
+    const specsSpinner = ora({
+      text: "Fetching specifications...",
+      color: "cyan"
+    }).start();
+    let specs;
+    try {
+      specs = await fetchSpecifications(client, selectedProject.id);
+      specsSpinner.succeed(`Found ${specs.length} specification(s)`);
+    } catch (error) {
+      specsSpinner.fail("Failed to fetch specifications");
+      throw new NetworkError(
+        `Failed to fetch specifications: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    if (typeof options.spec === "string") {
+      if (specs.length === 0) {
+        printWarning(`No specifications found. Ignoring --spec flag.`);
+      } else {
+        selectedSpec = validateSpecificationId(options.spec, specs);
+        console.log(colors.muted(`Using specification: ${selectedSpec.title}`));
+      }
+    } else if (specs.length > 0) {
+      selectedSpec = await promptForSpecification(specs, defaultSpecId);
+    }
+    if (options.format) {
+      if (options.format !== "json" && options.format !== "toon") {
+        throw new ValidationError(
+          `Invalid format: ${options.format}`,
+          "Valid formats are: json, toon"
+        );
+      }
+      selectedFormat = options.format;
+      console.log(colors.muted(`Using format: ${selectedFormat}`));
+    } else {
+      selectedFormat = await promptForFormat();
+    }
+  }
+  const isNonInteractive = !!(options.yes || options.project && typeof options.spec === "string" && options.format);
+  const detectedCLIs = detectInstalledTools();
+  let chosenTargets;
+  if (detectedCLIs.length > 1 && !isNonInteractive) {
+    const ordered = [
+      ...detectedCLIs.includes("claude") ? ["claude"] : [],
+      ...detectedCLIs.filter((t) => t !== "claude")
+    ];
+    const choices = ordered.map((t) => ({
+      name: t === "claude" ? `${TARGETS[t].name}  ${colors.dim("* Recommended")}` : TARGETS[t].name,
+      value: t
+    }));
+    printBlank();
+    const { chosen } = await inquirer.prompt([{
+      type: "list",
+      name: "chosen",
+      message: "Multiple AI CLIs detected \u2014 which one should SpecForge configure?",
+      choices,
+      default: detectedCLIs.includes("claude") ? "claude" : ordered[0]
+    }]);
+    chosenTargets = [chosen];
+  }
+  printBlank();
+  let addedSpecforge = false;
+  let addedMcp = false;
+  let scaffoldResult = { writes: [], detected: [] };
+  const keepPlanningSession = !!selectedSpec?.id && selectedSpec.id === priorConfig?.specificationId;
+  await forgeProgress("Forging spec", [
+    {
+      label: "save config",
+      fn: async () => {
+        saveProjectConfig({
+          projectId: selectedProject.id,
+          specificationId: selectedSpec?.id,
+          mcpOutputFormat: selectedFormat,
+          autoSetContext: true,
+          planningSessionId: keepPlanningSession ? priorConfig?.planningSessionId : void 0
+        });
+        const addedStable = addToGitignore(".specforge/");
+        const addedCanary = addToGitignore(".specforge-canary/");
+        addedSpecforge = addedStable || addedCanary;
+        addedMcp = addToGitignore(".mcp.json");
+      }
+    },
+    {
+      label: "scaffold files",
+      fn: async () => {
+        scaffoldResult = scaffoldMultiCli({
+          projectName: selectedProject.name,
+          apiKey: config.apiKey ?? void 0,
+          force: options.force,
+          targets: chosenTargets
+        });
+      }
+    }
+  ]);
+  printBlank();
+  printSuccess("Created .specforge/config.json");
+  if (addedSpecforge) {
+    printSuccess("Added .specforge/ + .specforge-canary/ to .gitignore");
+  }
+  if (addedMcp) {
+    printSuccess("Added .mcp.json to .gitignore");
+  }
+  const { writes, detected } = scaffoldResult;
+  const changedWrites = writes.filter((w) => w.changed);
+  if (changedWrites.length > 0) {
+    printBlank();
+    printSuccess(`Multi-CLI scaffolding (${detected.length} CLI(s) detected):`);
+    for (const w of changedWrites) {
+      console.log(`  ${colors.muted("\u2022")} ${w.relPath}`);
+    }
+    if (detected.length > 0) {
+      console.log(colors.dim(`  Detected: ${detected.map((t) => TARGETS[t].name).join(", ")}`));
+    }
+  }
+  let agentTeamsConfig = null;
+  if (isNonInteractive) {
+    agentTeamsConfig = {
+      enabled: false,
+      strategy: "auto",
+      maxTicketsPerTeam: 10,
+      maxParallelEpics: 3,
+      branchPrefix: "ticket/"
+    };
+  } else {
+    printBlank();
+    agentTeamsConfig = await promptForAgentTeams();
+  }
+  if (agentTeamsConfig?.enabled) {
+    setAgentTeamsConfig({
+      enabled: agentTeamsConfig.enabled,
+      strategy: agentTeamsConfig.strategy,
+      maxTicketsPerTeam: agentTeamsConfig.maxTicketsPerTeam,
+      maxParallelEpics: agentTeamsConfig.maxParallelEpics,
+      branchPrefix: agentTeamsConfig.branchPrefix
+    });
+    printSuccess("Saved Agent Teams configuration to .specforge/config.json");
+  }
+  printBlank();
+  printHeader("Configuration Complete");
+  printBlank();
+  printField("Project", selectedProject.name);
+  if (selectedSpec) {
+    printField("Specification", selectedSpec.title);
+  }
+  printField("Format", selectedFormat);
+  printField("Auto-context", "enabled");
+  if (agentTeamsConfig?.enabled) {
+    printField("Agent Teams", "enabled");
+    printField("Strategy", agentTeamsConfig.strategy);
+  }
+  if (!isNonInteractive) {
+    printBlank();
+    const { scaffoldNow } = await inquirer.prompt([{
+      type: "list",
+      name: "scaffoldNow",
+      message: "Scaffold SpecForge commands, agents, and skills for Claude Code?\n  Generates 8 slash commands (/sf-status, /sf-context, ...), 4 agent\n  definitions, and 4 skills for deeper AI integration.",
+      choices: [
+        { name: "Yes, scaffold now", value: true },
+        { name: "No, I'll run `specforge scaffold` later", value: false }
+      ],
+      default: true
+    }]);
+    if (scaffoldNow) {
+      const { scaffoldCommand } = await import("./scaffold/scaffold.js");
+      await scaffoldSkillFiles(selectedProject.name, isNonInteractive);
+      await scaffoldCommand({ target: "claude", update: true, project: true });
+      await scaffoldCommand({ agents: true, target: "claude", update: true, project: true });
+    } else {
+      printBlank();
+      console.log(
+        `Run ${colors.primary("specforge scaffold")} when ready.`
+      );
+    }
+  }
+  printBlank();
+  if (detected.length > 0) {
+    console.log(colors.warning(`Restart ${detected.map((t) => TARGETS[t].name).join(" / ")} to activate SpecForge MCP.`));
+  } else {
+    console.log(colors.warning("Restart your AI CLI tool to activate SpecForge MCP."));
+  }
+  printBlank();
+  console.log(colors.bold("Next steps:"));
+  printHint("specforge status", "verify your configuration");
+  printHint("specforge doctor", "check MCP server connectivity");
+  printBlank();
+}
+function registerInitCommand(program) {
+  program.command("init").description("Initialize SpecForge for this project").option("--project <id>", "Project ID (non-interactive)").option("--spec [id]", "Specification ID, or omit ID to pick from current project").option("--format <format>", "MCP response format: json or toon (default: toon)").option("-f, --force", "Overwrite existing configuration files").option("-s, --show", "Display current configuration settings").option("-y, --yes", "Skip interactive prompts, use defaults").option("--spec-only", "Switch active specification (quick switch)").addHelpText("after", `
+Examples:
+  $ specforge init                          # Interactive setup (resume-aware if already configured)
+  $ specforge init --show                   # Display current settings
+  $ specforge init --project proj_abc123    # Set project non-interactively
+  $ specforge init --project proj_abc --spec spec_xyz --format toon
+  $ specforge init --force                  # Overwrite existing config
+  $ specforge init --yes                    # Use defaults, skip prompts
+  $ specforge init --spec                   # Pick specification from current project
+  $ specforge init --spec-only              # Switch specification (alias)
+
+This command creates:
+  .specforge/config.json - Project-specific SpecForge settings
+  Per-CLI MCP config     - .mcp.json (Claude Code / Copilot / Cursor),
+                           .gemini/settings.json, .codex/config.toml, opencode.json
+  Per-CLI instruction file - CLAUDE.md, GEMINI.md, .github/copilot-instructions.md,
+                             or AGENTS.md (Codex / OpenCode / Cursor fallback)
+  Per-CLI skill files    - specforge-conventions
+
+After running init, restart your AI CLI tool to activate the MCP server.
+`).action(withErrorHandler(initAction));
+}
+export {
+  initAction,
+  registerInitCommand
+};
+//# sourceMappingURL=init.js.map