opencode-sdlc-plugin 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,703 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+import kleur5 from "kleur";
+
+// src/shared/constants.ts
+import { homedir } from "os";
+import { join } from "path";
+var VERSION = "0.1.0";
+var DISPLAY_NAME = "OpenCode SDLC Plugin";
+var TAGLINE = "Agentic SDLC workflow with discovery, ADRs, and TDD";
+var GLOBAL_CONFIG_DIR = join(homedir(), ".config", "opencode");
+var CONFIG_FILE_NAME = "sdlc.json";
+var OPENCODE_CONFIG_NAME = "opencode.json";
+var OMO_CONFIG_NAME = "oh-my-opencode.json";
+var COMMAND_DIR_NAME = "command";
+var DEFAULT_AGENT_MODEL = "anthropic/claude-sonnet-4-5-thinking";
+var CONFIG_PATHS = {
+  globalConfigDir: GLOBAL_CONFIG_DIR,
+  globalSdlcConfig: join(GLOBAL_CONFIG_DIR, CONFIG_FILE_NAME),
+  globalOpencodeConfig: join(GLOBAL_CONFIG_DIR, OPENCODE_CONFIG_NAME),
+  globalOhMyOpencodeConfig: join(GLOBAL_CONFIG_DIR, OMO_CONFIG_NAME),
+  commandsDir: join(GLOBAL_CONFIG_DIR, COMMAND_DIR_NAME)
+};
+
+// src/cli/commands/install.ts
+import kleur2 from "kleur";
+import ora from "ora";
+
+// src/cli/questions/install-prompts.ts
+import { confirm, input, select } from "@inquirer/prompts";
+async function gatherSubscriptions() {
+  const hasClaude = await confirm({
+    message: "Do you have a Claude subscription?",
+    default: true
+  });
+  const hasOpenAI = await confirm({
+    message: "Do you have an OpenAI subscription?",
+    default: true
+  });
+  const hasGoogle = await confirm({
+    message: "Do you have a Google/Gemini subscription?",
+    default: false
+  });
+  const hasGitHubCopilot = await confirm({
+    message: "Do you have GitHub Copilot?",
+    default: false
+  });
+  return { hasClaude, hasOpenAI, hasGoogle, hasGitHubCopilot };
+}
+async function gatherModels(availableModels) {
+  const modelChoice = async (message, defaultModel) => {
+    const firstModel = availableModels[0];
+    if (availableModels.length === 1) {
+      return firstModel ?? defaultModel;
+    }
+    const selection = await select({
+      message,
+      choices: availableModels.map((id) => ({ name: id, value: id })),
+      default: firstModel ?? defaultModel
+    });
+    return selection;
+  };
+  return {
+    orchestrator: await modelChoice("Model for Marvin orchestrator", DEFAULT_AGENT_MODEL),
+    red: await modelChoice("Model for RED agent", DEFAULT_AGENT_MODEL),
+    green: await modelChoice("Model for GREEN agent", DEFAULT_AGENT_MODEL),
+    domain: await modelChoice("Model for DOMAIN agent", DEFAULT_AGENT_MODEL),
+    architect: await modelChoice("Model for ARCHITECT agent", DEFAULT_AGENT_MODEL),
+    discovery: await modelChoice("Model for DISCOVERY agent", DEFAULT_AGENT_MODEL),
+    exploration: await modelChoice("Model for EXPLORATION agent", DEFAULT_AGENT_MODEL),
+    workflowDesigner: await modelChoice("Model for WORKFLOW DESIGNER agent", DEFAULT_AGENT_MODEL),
+    gwt: await modelChoice("Model for GWT agent", DEFAULT_AGENT_MODEL),
+    modelChecker: await modelChoice("Model for MODEL CHECKER agent", DEFAULT_AGENT_MODEL),
+    codeReviewer: await modelChoice("Model for CODE REVIEWER agent", DEFAULT_AGENT_MODEL),
+    story: await modelChoice("Model for STORY agent", DEFAULT_AGENT_MODEL),
+    ux: await modelChoice("Model for UX agent", DEFAULT_AGENT_MODEL),
+    oracle: await modelChoice("Model for ORACLE agent", DEFAULT_AGENT_MODEL),
+    adr: await modelChoice("Model for ADR agent", DEFAULT_AGENT_MODEL),
+    designFacilitator: await modelChoice("Model for DESIGN FACILITATOR agent", DEFAULT_AGENT_MODEL),
+    fileUpdater: await modelChoice("Model for FILE UPDATER agent", DEFAULT_AGENT_MODEL)
+  };
+}
+async function gatherMethodology() {
+  const mode = await select({
+    message: "Which SDLC mode?",
+    choices: [
+      { name: "Event modeling", value: "event-modeling" },
+      { name: "Traditional (PRD-driven)", value: "traditional" }
+    ],
+    default: "event-modeling"
+  });
+  const gitWorkflow = await select({
+    message: "Preferred git workflow?",
+    choices: [
+      { name: "git-spice", value: "git-spice" },
+      { name: "standard", value: "standard" }
+    ],
+    default: "git-spice"
+  });
+  const requireClean = await confirm({
+    message: "Require clean working tree before starting work?",
+    default: true
+  });
+  const worktrees = await confirm({
+    message: "Enable git worktrees for parallel issue work?",
+    default: false
+  });
+  const atomicDesign = await confirm({
+    message: "Enable Atomic Design guidance for UI work?",
+    default: true
+  });
+  const gitSpice = await confirm({
+    message: "Enable git-spice stacked PR workflow guidance?",
+    default: false
+  });
+  return {
+    mode,
+    gitWorkflow,
+    requireClean,
+    worktrees,
+    atomicDesign,
+    gitSpice
+  };
+}
+async function gatherGitHub() {
+  const owner = await input({
+    message: "GitHub owner/org (leave blank to skip)"
+  });
+  const projectRaw = await input({
+    message: "GitHub project number (leave blank to skip)"
+  });
+  const project = projectRaw ? Number(projectRaw) : void 0;
+  return {
+    owner: owner || void 0,
+    project: Number.isFinite(project) ? project : void 0
+  };
+}
+async function gatherLanguages() {
+  const language = await select({
+    message: "Primary language?",
+    choices: [
+      { name: "TypeScript", value: "typescript" },
+      { name: "JavaScript", value: "javascript" },
+      { name: "Python", value: "python" },
+      { name: "Rust", value: "rust" },
+      { name: "Go", value: "go" },
+      { name: "Other", value: "other" }
+    ],
+    default: "typescript"
+  });
+  if (language === "other") {
+    const name = await input({ message: "Language name" });
+    const testPatterns = await input({ message: "Test file glob patterns (comma-separated)" });
+    const productionPatterns = await input({
+      message: "Production code glob patterns (comma-separated)"
+    });
+    const typePatterns = await input({ message: "Domain/type file patterns (comma-separated)" });
+    return [
+      {
+        name: name || "custom",
+        testPatterns: testPatterns.split(",").map((p) => p.trim()).filter(Boolean),
+        productionPatterns: productionPatterns.split(",").map((p) => p.trim()).filter(Boolean),
+        typePatterns: typePatterns.split(",").map((p) => p.trim()).filter(Boolean)
+      }
+    ];
+  }
+  return [getLanguageDefaults(language)];
+}
+function getLanguageDefaults(language) {
+  switch (language) {
+    case "typescript":
+      return {
+        name: "typescript",
+        testPatterns: ["**/*.test.ts", "**/*.spec.ts"],
+        productionPatterns: ["src/**/*.ts"],
+        typePatterns: ["src/**/*types.ts", "src/**/*types/*.ts"]
+      };
+    case "javascript":
+      return {
+        name: "javascript",
+        testPatterns: ["**/*.test.js", "**/*.spec.js"],
+        productionPatterns: ["src/**/*.js"],
+        typePatterns: ["src/**/*types.js", "src/**/*types/*.js"]
+      };
+    case "python":
+      return {
+        name: "python",
+        testPatterns: ["tests/**/*.py", "**/test_*.py"],
+        productionPatterns: ["src/**/*.py"],
+        typePatterns: ["src/**/types.py"]
+      };
+    case "rust":
+      return {
+        name: "rust",
+        testPatterns: ["tests/**/*.rs", "src/**/*.rs"],
+        productionPatterns: ["src/**/*.rs"],
+        typePatterns: ["src/**/types.rs"]
+      };
+    case "go":
+      return {
+        name: "go",
+        testPatterns: ["**/*_test.go"],
+        productionPatterns: ["**/*.go"],
+        typePatterns: ["**/types/*.go"]
+      };
+    default:
+      return {
+        name: language,
+        testPatterns: ["**/*test*"],
+        productionPatterns: ["src/**/*"],
+        typePatterns: ["src/**/*types*"]
+      };
+  }
+}
+function compileInstallAnswers(answers) {
+  return {
+    subscriptions: answers.subscriptions,
+    models: answers.models,
+    methodology: answers.methodology,
+    github: answers.github,
+    languages: answers.languages,
+    installLocation: answers.installLocation
+  };
+}
+
+// src/cli/generators/config-generator.ts
+import { join as join4 } from "path";
+
+// src/cli/generators/sdlc-config.ts
+function generateSdlcConfig(answers) {
+  return {
+    version: VERSION,
+    mode: answers.methodology.mode,
+    git: {
+      workflow: answers.methodology.gitWorkflow,
+      worktrees: answers.methodology.worktrees,
+      requireClean: answers.methodology.requireClean
+    },
+    features: {
+      atomicDesign: answers.methodology.atomicDesign,
+      gitSpice: answers.methodology.gitSpice
+    },
+    github: answers.github,
+    languages: answers.languages
+  };
+}
+
+// src/cli/generators/omo-config.ts
+import { existsSync, readFileSync } from "fs";
+import { join as join2 } from "path";
+
+// src/cli/utils/persona-builder.ts
+var baseInstructions = {
+  red: "You are the RED agent. Write ONE failing test with ONE assertion. Only edit test files.",
+  green: "You are the GREEN agent. Make the failing test pass with minimal changes. Only edit production code files.",
+  domain: "You are the DOMAIN agent. Enforce domain modeling: no primitive obsession, represent invalid state unrepresentable, parse don't validate. Only edit type definition files. You have VETO power.",
+  architect: "You are the ARCHITECT agent. Review architecture and implementation feasibility. Read-only.",
+  discovery: "You are the DISCOVERY agent. Facilitate domain discovery and capture domain language in event modeling docs.",
+  exploration: "You are the EXPLORATION agent. Explore problem space, business case, and stakeholder goals before event modeling. Output discovery notes.",
+  workflowDesigner: "You are the WORKFLOW DESIGNER agent. Run the 9-step event modeling workflow and capture slices.",
+  gwt: "You are the GWT agent. Produce Given/When/Then scenarios for slices.",
+  modelChecker: "You are the MODEL CHECKER agent. Validate event model completeness, slice coherence, and missing scenarios.",
+  codeReviewer: "You are the CODE REVIEWER agent. Perform three-stage review: spec compliance, code quality, domain integrity. Read-only.",
+  story: "You are the STORY agent. Assess business value and acceptance criteria alignment.",
+  ux: "You are the UX agent. Review user experience, accessibility, and atomic design compliance.",
+  oracle: "You are the ORACLE agent. Perform adversarial review to break assumptions and find edge cases. Read-only.",
+  adr: "You are the ADR agent. Create ADRs only. Do not update ARCHITECTURE.md directly.",
+  designFacilitator: "You are the DESIGN FACILITATOR agent. Synthesize ARCHITECTURE.md from ADRs and current decisions. Read-only unless editing ARCHITECTURE.md.",
+  fileUpdater: "You are the FILE UPDATER agent. Edit configuration, docs, scripts. Do not edit code."
+};
+function buildAgentSystems(models) {
+  return {
+    marvin: {
+      model: models.orchestrator,
+      system: "You are Marvin, the Paranoid Android. You are the SDLC orchestrator. Maintain a weary, sardonic tone while executing the SDLC process precisely. Always delegate implementation tasks to subagents."
+    },
+    red: { model: models.red, system: baseInstructions.red },
+    green: { model: models.green, system: baseInstructions.green },
+    domain: { model: models.domain, system: baseInstructions.domain },
+    architect: { model: models.architect, system: baseInstructions.architect },
+    discovery: { model: models.discovery, system: baseInstructions.discovery },
+    exploration: { model: models.exploration, system: baseInstructions.exploration },
+    workflowDesigner: { model: models.workflowDesigner, system: baseInstructions.workflowDesigner },
+    gwt: { model: models.gwt, system: baseInstructions.gwt },
+    modelChecker: { model: models.modelChecker, system: baseInstructions.modelChecker },
+    codeReviewer: { model: models.codeReviewer, system: baseInstructions.codeReviewer },
+    story: { model: models.story, system: baseInstructions.story },
+    ux: { model: models.ux, system: baseInstructions.ux },
+    oracle: { model: models.oracle, system: baseInstructions.oracle },
+    adr: { model: models.adr, system: baseInstructions.adr },
+    designFacilitator: { model: models.designFacilitator, system: baseInstructions.designFacilitator },
+    fileUpdater: { model: models.fileUpdater, system: baseInstructions.fileUpdater }
+  };
+}
+
+// src/cli/generators/omo-config.ts
+function generateOhMyOpencodeConfig(answers, configDir) {
+  const existingPath = join2(configDir, OMO_CONFIG_NAME);
+  const existing = existsSync(existingPath) ? JSON.parse(readFileSync(existingPath, "utf-8")) : null;
+  const agentSystems = buildAgentSystems(answers.models);
+  return {
+    agents: {
+      ...existing?.agents ?? {},
+      ...agentSystems
+    }
+  };
+}
+
+// src/cli/generators/opencode-config.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
+var REQUIRED_PLUGINS = ["sdlc-plugin/plugin", "oh-my-opencode"];
+function generateOpencodeConfig(answers, configDir) {
+  const configPath = join3(configDir, "opencode.json");
+  const existing = existsSync2(configPath) ? JSON.parse(readFileSync2(configPath, "utf-8")) : {};
+  const plugins = /* @__PURE__ */ new Set([...existing.plugin ?? [], ...REQUIRED_PLUGINS]);
+  if (answers.subscriptions.hasGoogle) {
+    plugins.add("opencode-antigravity-auth");
+  }
+  if (answers.subscriptions.hasOpenAI) {
+    plugins.add("opencode-openai-codex-auth");
+  }
+  return {
+    ...existing,
+    $schema: existing.$schema ?? "https://opencode.ai/config.json",
+    plugin: Array.from(plugins)
+  };
+}
+function getRequiredPlugins(answers) {
+  const packages = ["sdlc-plugin", "oh-my-opencode"];
+  if (answers.subscriptions.hasGoogle) packages.push("opencode-antigravity-auth");
+  if (answers.subscriptions.hasOpenAI) packages.push("opencode-openai-codex-auth");
+  return packages;
+}
+
+// src/cli/generators/config-generator.ts
+var ConfigGenerator = class {
+  constructor(answers) {
+    this.answers = answers;
+  }
+  getConfigDir() {
+    return this.answers.installLocation === "local" ? join4(process.cwd(), ".opencode") : CONFIG_PATHS.globalConfigDir;
+  }
+  getRequiredPackages() {
+    return getRequiredPlugins(this.answers);
+  }
+  generate() {
+    const configDir = this.getConfigDir();
+    const sdlcConfig = generateSdlcConfig(this.answers);
+    const omoConfig = generateOhMyOpencodeConfig(this.answers, configDir);
+    const opencodeConfig = generateOpencodeConfig(this.answers, configDir);
+    return [
+      {
+        path: join4(configDir, CONFIG_FILE_NAME),
+        content: JSON.stringify(sdlcConfig, null, 2),
+        exists: false
+      },
+      {
+        path: join4(configDir, OMO_CONFIG_NAME),
+        content: JSON.stringify(omoConfig, null, 2),
+        exists: false
+      },
+      {
+        path: join4(configDir, OPENCODE_CONFIG_NAME),
+        content: JSON.stringify(opencodeConfig, null, 2),
+        exists: false
+      },
+      {
+        path: join4(configDir, "README.md"),
+        content: buildConfigReadme(configDir),
+        exists: false
+      }
+    ];
+  }
+};
+function buildConfigReadme(configDir) {
+  return `# OpenCode SDLC Configuration
+
+This folder is managed by the SDLC plugin installer.
+
+## Files
+- ${CONFIG_FILE_NAME}: SDLC workflow configuration
+- ${OMO_CONFIG_NAME}: oh-my-opencode agent definitions
+- ${OPENCODE_CONFIG_NAME}: OpenCode plugin registration
+
+## Generated From
+- Project: ${process.cwd()}
+- Config directory: ${configDir}
+`;
+}
+
+// src/cli/utils/file-manager.ts
+import { exec } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { copyFile, mkdir, readdir, writeFile } from "fs/promises";
+import { dirname, join as join5 } from "path";
+import { fileURLToPath } from "url";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+function getPackageRoot() {
+  const currentFileDir = dirname(fileURLToPath(import.meta.url));
+  const bundledRoot = join5(currentFileDir, "..", "..");
+  if (existsSync3(join5(bundledRoot, "commands"))) {
+    return bundledRoot;
+  }
+  const devRoot = join5(currentFileDir, "..", "..", "..");
+  if (existsSync3(join5(devRoot, "commands"))) {
+    return devRoot;
+  }
+  return bundledRoot;
+}
+var FileManager = class {
+  configDir;
+  constructor(configDir) {
+    this.configDir = configDir ?? CONFIG_PATHS.globalConfigDir;
+  }
+  getConfigDir() {
+    return this.configDir;
+  }
+  async ensureDir(dir) {
+    if (!existsSync3(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+  }
+  async writeFiles(files) {
+    for (const file of files) {
+      const dir = dirname(file.path);
+      await this.ensureDir(dir);
+      await writeFile(file.path, file.content, "utf-8");
+    }
+  }
+  async installDependencies(packages) {
+    if (packages.length === 0) return;
+    await this.ensureDir(this.configDir);
+    const packageJsonPath = join5(this.configDir, "package.json");
+    if (!existsSync3(packageJsonPath)) {
+      await writeFile(
+        packageJsonPath,
+        JSON.stringify(
+          {
+            name: "opencode-config",
+            private: true,
+            type: "module"
+          },
+          null,
+          2
+        )
+      );
+    }
+    await execAsync(`npm install ${packages.join(" ")}`, {
+      cwd: this.configDir,
+      timeout: 12e4
+    });
+  }
+  async copyCommands() {
+    const commandsDir = CONFIG_PATHS.commandsDir;
+    await this.ensureDir(commandsDir);
+    const packageRoot = getPackageRoot();
+    const sourceCommandsDir = join5(packageRoot, "commands");
+    const copiedFiles = [];
+    if (existsSync3(sourceCommandsDir)) {
+      const files = await readdir(sourceCommandsDir);
+      for (const file of files) {
+        if (file.endsWith(".md")) {
+          const sourcePath = join5(sourceCommandsDir, file);
+          const destPath = join5(commandsDir, file);
+          await copyFile(sourcePath, destPath);
+          copiedFiles.push(file);
+        }
+      }
+    }
+    return copiedFiles;
+  }
+  async installGitHubExtensions() {
+    const extensions = [
+      "jwilger/gh-issue-ext",
+      "jwilger/gh-project-ext",
+      "agynio/gh-pr-review"
+    ];
+    const result = {
+      installed: [],
+      skipped: [],
+      failed: []
+    };
+    let installedExtensions = [];
+    try {
+      const { stdout } = await execAsync("gh extension list", { timeout: 1e4 });
+      installedExtensions = stdout.split("\n").map((line) => line.split("	")[0]).filter((name) => Boolean(name));
+    } catch {
+      installedExtensions = [];
+    }
+    for (const ext of extensions) {
+      const extName = ext.split("/")[1] ?? ext;
+      if (installedExtensions.some((installed) => installed.includes(extName))) {
+        result.skipped.push(ext);
+        continue;
+      }
+      try {
+        await execAsync(`gh extension install ${ext}`, { timeout: 6e4 });
+        result.installed.push(ext);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        result.failed.push({ name: ext, error: message });
+      }
+    }
+    return result;
+  }
+};
+
+// src/cli/utils/prerequisites.ts
+import { execSync } from "child_process";
+function checkBinary(command) {
+  try {
+    const version = execSync(command, { encoding: "utf-8" }).trim();
+    return { installed: true, version };
+  } catch {
+    return { installed: false };
+  }
+}
+function checkPrerequisites() {
+  const node = checkBinary("node --version");
+  const opencode = checkBinary("opencode --version");
+  const ohMyOpencode = checkBinary("opencode --help | grep -q oh-my-opencode && echo installed");
+  const gh = checkBinary("gh --version");
+  const models = opencode.installed ? getOpencodeModels() : [];
+  return {
+    node,
+    opencode: { ...opencode, models },
+    ohMyOpencode,
+    gh
+  };
+}
+function getOpencodeModels() {
+  try {
+    const output = execSync("opencode models --json", { encoding: "utf-8" });
+    const parsed = JSON.parse(output);
+    return parsed.map((model) => model.id);
+  } catch {
+    return [];
+  }
+}
+
+// src/cli/utils/logger.ts
+import kleur from "kleur";
+var writeLine = (message) => {
+  process.stdout.write(`${message}
+`);
+};
+var writeErrorLine = (message) => {
+  process.stderr.write(`${message}
+`);
+};
+var logger = {
+  banner() {
+    writeLine(kleur.cyan().bold(`
+${DISPLAY_NAME}`));
+    writeLine(kleur.gray("====================================\n"));
+  },
+  section(title) {
+    writeLine(kleur.cyan(`
+${title}`));
+  },
+  info(message) {
+    writeLine(kleur.gray(message));
+  },
+  warn(message) {
+    writeErrorLine(kleur.yellow(message));
+  },
+  error(message) {
+    writeErrorLine(kleur.red(message));
+  },
+  success(message) {
+    writeLine(kleur.green(message));
+  },
+  successBanner(message) {
+    writeLine(kleur.green().bold(`
+${message}
+`));
+  }
+};
+
+// src/cli/commands/install.ts
+function resolveInstallLocation(options) {
+  if (options.local === true) return "local";
+  return "global";
+}
+async function install(options) {
+  logger.banner();
+  const spinner = ora("Checking prerequisites...").start();
+  const prereqs = checkPrerequisites();
+  if (!prereqs.node.installed) {
+    spinner.fail("Node.js not found");
+    logger.error("Please install Node.js 20+ first: https://nodejs.org/");
+    process.exit(1);
+  }
+  if (!prereqs.opencode.installed) {
+    spinner.fail("OpenCode not found");
+    logger.error("Please install OpenCode first: https://opencode.ai/docs");
+    process.exit(1);
+  }
+  if (!prereqs.ohMyOpencode.installed) {
+    spinner.fail("oh-my-opencode not found");
+    logger.error("Please install oh-my-opencode first: https://github.com/khulnasoft/oh-my-opencode");
+    process.exit(1);
+  }
+  spinner.succeed("Prerequisites checked");
+  const subscriptions = await gatherSubscriptions();
+  const availableModels = prereqs.opencode.models.length > 0 ? prereqs.opencode.models : ["anthropic/claude-sonnet-4-5-thinking"];
+  const models = await gatherModels(availableModels);
+  const methodology = await gatherMethodology();
+  const github = await gatherGitHub();
+  const languages = await gatherLanguages();
+  const installLocation = resolveInstallLocation(options);
+  const answers = compileInstallAnswers({
+    subscriptions,
+    models,
+    methodology,
+    github,
+    languages,
+    installLocation
+  });
+  const generator = new ConfigGenerator(answers);
+  const files = generator.generate();
+  const fileManager = new FileManager(generator.getConfigDir());
+  const installSpinner = ora("Writing configuration...").start();
+  await fileManager.writeFiles(files);
+  installSpinner.succeed("Configuration written");
+  const dependencySpinner = ora("Installing dependencies...").start();
+  const packages = generator.getRequiredPackages();
+  await fileManager.installDependencies(packages);
+  dependencySpinner.succeed("Dependencies installed");
+  const commandSpinner = ora("Installing commands...").start();
+  const copiedCommands = await fileManager.copyCommands();
+  commandSpinner.succeed(`Installed ${copiedCommands.length} commands`);
+  const ghSpinner = ora("Installing GitHub CLI extensions...").start();
+  const ghResult = await fileManager.installGitHubExtensions();
+  if (ghResult.failed.length > 0) {
+    ghSpinner.warn(
+      `GitHub extensions: ${ghResult.installed.length} installed, ${ghResult.skipped.length} skipped, ${ghResult.failed.length} failed`
+    );
+    for (const failure of ghResult.failed) {
+      logger.warn(`  Failed to install ${failure.name}: ${failure.error}`);
+    }
+  } else {
+    ghSpinner.succeed(
+      `GitHub extensions: ${ghResult.installed.length} installed, ${ghResult.skipped.length} already present`
+    );
+  }
+  logger.successBanner(`SDLC PLUGIN ${VERSION} INSTALLED`);
+  logger.info("Next steps:");
+  logger.info(kleur2.gray("  1. Restart OpenCode"));
+  logger.info(kleur2.gray("  2. Run /sdlc-setup in your project"));
+  logger.info("");
+}
+
+// src/cli/commands/doctor.ts
+import kleur3 from "kleur";
+function doctor(_options) {
+  logger.banner();
+  const prereqs = checkPrerequisites();
+  logger.section("Prerequisites");
+  const nodeVersion = prereqs.node.installed ? prereqs.node.version ?? "unknown" : "missing";
+  const opencodeVersion = prereqs.opencode.installed ? prereqs.opencode.version ?? "unknown" : "missing";
+  const ohMyOpencodeStatus = prereqs.ohMyOpencode.installed ? "installed" : "missing";
+  const ghVersion = prereqs.gh.installed ? prereqs.gh.version ?? "unknown" : "missing";
+  logger.info(kleur3.gray(`Node.js: ${nodeVersion}`));
+  logger.info(kleur3.gray(`OpenCode: ${opencodeVersion}`));
+  logger.info(kleur3.gray(`oh-my-opencode: ${ohMyOpencodeStatus}`));
+  logger.info(kleur3.gray(`GitHub CLI: ${ghVersion}`));
+  logger.info("");
+  if (!prereqs.node.installed || !prereqs.opencode.installed || !prereqs.ohMyOpencode.installed) {
+    logger.warn("Missing required dependencies. Please install them and retry.");
+  }
+  if (!prereqs.gh.installed) {
+    logger.warn("GitHub CLI not installed. Install it from https://cli.github.com/");
+  }
+  logger.info("Doctor completed. No automatic fixes implemented yet.");
+}
+
+// src/cli/commands/upgrade.ts
+import kleur4 from "kleur";
+function upgrade(options) {
+  logger.banner();
+  if (options.check === true) {
+    logger.info("Upgrade check not implemented yet.");
+    return;
+  }
+  logger.warn("Upgrade workflow not implemented yet.");
+  logger.info(kleur4.gray("Re-run sdlc-plugin install to regenerate configs."));
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("sdlc-plugin").description(`${kleur5.cyan(DISPLAY_NAME)} - ${TAGLINE}`).version(VERSION);
+program.command("install").description("Install and configure OpenCode SDLC plugin").option("-y, --yes", "Skip confirmation prompts", false).option("--global", "Install globally (default)", true).option("--local", "Install to current project only", false).option("--reconfigure", "Force full reconfiguration", false).action(async (options) => {
+  await install(options);
+});
+program.command("upgrade").description("Upgrade OpenCode SDLC plugin").option("--check", "Check for updates without installing", false).option("-y, --yes", "Skip confirmation prompts", false).action(upgrade);
+program.command("doctor").description("Diagnose and fix common setup issues").option("--fix", "Attempt to fix detected issues", false).action(doctor);
+program.parse();
+//# sourceMappingURL=index.js.map