@recapt/mcp 0.0.19-beta → 0.0.20

package/dist/cli/index.js

@@ -1,26 +1,1064 @@
 #!/usr/bin/env node
-/**
- * Recapt MCP CLI
- *
- * Unified command-line interface for recapt MCP server management.
- *
- * Commands:
- *   setup                     - Configure recapt MCP server for your AI IDE(s)
- *   setup-self-improvement-gh - Set up automated self-improvement workflow for GitHub
- *   skill                     - Manage recapt workflow skills
- */
-import { Command } from "commander";
+
+// src/cli/index.ts
+import { Command as Command4 } from "commander";
 import { createRequire } from "module";
-import { skillCommand } from "./commands/skill.js";
-import { setupCommand } from "./commands/setup.js";
-import { setupSelfImprovementGhCommand } from "./commands/setup-self-improvement-gh.js";
-const require = createRequire(import.meta.url);
-const pkg = require("../../package.json");
-const program = new Command();
-program
-    .name("recapt")
-    .description("Recapt MCP CLI - Configure and manage recapt for AI IDEs")
-    .version(pkg.version);
+
+// src/cli/commands/skill.ts
+import { Command } from "commander";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var SKILLS_DIR = path.resolve(__dirname, "../../../skills");
+var AGENTS_DIR = ".agents/recapt";
+var AGENTS_MD = "AGENTS.md";
+var MARKER_START = "<!-- recapt:skills -->";
+var MARKER_END = "<!-- /recapt:skills -->";
+function getAvailableSkills() {
+  if (!fs.existsSync(SKILLS_DIR)) {
+    throw new Error(`Skills directory not found: ${SKILLS_DIR}`);
+  }
+  const files = fs.readdirSync(SKILLS_DIR).filter((f) => f.endsWith(".md"));
+  if (files.length === 0) {
+    throw new Error(`No skill files found in: ${SKILLS_DIR}`);
+  }
+  return files.map((file) => {
+    const content = fs.readFileSync(path.join(SKILLS_DIR, file), "utf-8");
+    const firstLine = content.split("\n")[0];
+    const description = firstLine.startsWith("# ") ? firstLine.slice(2).trim() : file.replace(".md", "");
+    return {
+      name: file.replace(".md", ""),
+      file,
+      description
+    };
+  });
+}
+function getInstalledSkills(cwd) {
+  const agentsDir = path.join(cwd, AGENTS_DIR);
+  if (!fs.existsSync(agentsDir)) {
+    return [];
+  }
+  return fs.readdirSync(agentsDir).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
+}
+function ensureAgentsDir(cwd) {
+  const agentsDir = path.join(cwd, AGENTS_DIR);
+  if (!fs.existsSync(agentsDir)) {
+    fs.mkdirSync(agentsDir, { recursive: true });
+    console.log(`Created ${AGENTS_DIR}/`);
+  }
+}
+function readAgentsMd(cwd) {
+  const agentsMdPath = path.join(cwd, AGENTS_MD);
+  if (!fs.existsSync(agentsMdPath)) {
+    return "";
+  }
+  return fs.readFileSync(agentsMdPath, "utf-8");
+}
+function writeAgentsMd(cwd, content) {
+  const agentsMdPath = path.join(cwd, AGENTS_MD);
+  fs.writeFileSync(agentsMdPath, content);
+}
+function getSkillDisplayName(skillName) {
+  try {
+    const skills = getAvailableSkills();
+    const skill = skills.find((s) => s.name === skillName);
+    return skill?.description ?? skillName;
+  } catch {
+    return skillName;
+  }
+}
+function updateAgentsMdReferences(cwd) {
+  const installed = getInstalledSkills(cwd);
+  let content = readAgentsMd(cwd);
+  if (installed.length === 0) {
+    if (content.includes(MARKER_START)) {
+      const regex = new RegExp(
+        `\\n?${MARKER_START}[\\s\\S]*?${MARKER_END}\\n?`,
+        "g"
+      );
+      content = content.replace(regex, "").trim();
+      if (content) {
+        writeAgentsMd(cwd, content + "\n");
+      } else {
+        const agentsMdPath = path.join(cwd, AGENTS_MD);
+        if (fs.existsSync(agentsMdPath)) {
+          fs.unlinkSync(agentsMdPath);
+          console.log(`Removed empty ${AGENTS_MD}`);
+        }
+      }
+    }
+    return;
+  }
+  const skillLinks = installed.map((name) => `- [${getSkillDisplayName(name)}](${AGENTS_DIR}/${name}.md)`).join("\n");
+  const newBlock = `${MARKER_START}
+For recapt behavioral intelligence workflows, see:
+${skillLinks}
+${MARKER_END}`;
+  if (content.includes(MARKER_START)) {
+    const regex = new RegExp(`${MARKER_START}[\\s\\S]*?${MARKER_END}`, "g");
+    content = content.replace(regex, newBlock);
+  } else {
+    if (content.trim()) {
+      content = content.trim() + "\n\n" + newBlock;
+    } else {
+      content = `# Project Agent Instructions
+
+${newBlock}`;
+    }
+  }
+  writeAgentsMd(cwd, content + "\n");
+}
+function installSkill(cwd, skillName, force = false) {
+  let skills;
+  try {
+    skills = getAvailableSkills();
+  } catch (err) {
+    console.error(
+      `Failed to load skills: ${err instanceof Error ? err.message : err}`
+    );
+    return false;
+  }
+  const skill = skills.find((s) => s.name === skillName);
+  if (!skill) {
+    console.error(`Unknown skill: ${skillName}`);
+    console.error(`Available skills: ${skills.map((s) => s.name).join(", ")}`);
+    return false;
+  }
+  ensureAgentsDir(cwd);
+  const sourcePath = path.join(SKILLS_DIR, skill.file);
+  const destPath = path.join(cwd, AGENTS_DIR, skill.file);
+  if (fs.existsSync(destPath)) {
+    const sourceContent = fs.readFileSync(sourcePath, "utf-8");
+    const destContent = fs.readFileSync(destPath, "utf-8");
+    if (sourceContent === destContent) {
+      console.log(`Skill already up to date: ${skillName}`);
+      return true;
+    }
+    if (!force) {
+      console.log(`Skill outdated: ${skillName} (use --force to update)`);
+      return true;
+    }
+    fs.copyFileSync(sourcePath, destPath);
+    console.log(`Updated: ${skillName} \u2192 ${AGENTS_DIR}/${skill.file}`);
+  } else {
+    fs.copyFileSync(sourcePath, destPath);
+    console.log(`Installed: ${skillName} \u2192 ${AGENTS_DIR}/${skill.file}`);
+  }
+  updateAgentsMdReferences(cwd);
+  return true;
+}
+function uninstallSkill(cwd, skillName) {
+  const skillPath = path.join(cwd, AGENTS_DIR, `${skillName}.md`);
+  if (!fs.existsSync(skillPath)) {
+    console.error(`Skill not installed: ${skillName}`);
+    return false;
+  }
+  fs.unlinkSync(skillPath);
+  console.log(`Uninstalled: ${skillName}`);
+  updateAgentsMdReferences(cwd);
+  const agentsDir = path.join(cwd, AGENTS_DIR);
+  const remaining = fs.readdirSync(agentsDir);
+  if (remaining.length === 0) {
+    fs.rmdirSync(agentsDir);
+    const parentDir = path.dirname(agentsDir);
+    if (fs.existsSync(parentDir) && fs.readdirSync(parentDir).length === 0) {
+      fs.rmdirSync(parentDir);
+    }
+    console.log(`Removed empty ${AGENTS_DIR}/`);
+  }
+  return true;
+}
+function listSkills(cwd) {
+  let available;
+  try {
+    available = getAvailableSkills();
+  } catch (err) {
+    console.error(
+      `Failed to load skills: ${err instanceof Error ? err.message : err}`
+    );
+    process.exit(1);
+  }
+  const installed = new Set(getInstalledSkills(cwd));
+  console.log("\nAvailable recapt skills:\n");
+  for (const skill of available) {
+    const status = installed.has(skill.name) ? "[installed]" : "";
+    console.log(`  ${skill.name.padEnd(20)} ${skill.description} ${status}`);
+  }
+  console.log();
+}
+function installAllSkills(cwd, force = false) {
+  let skills;
+  try {
+    skills = getAvailableSkills();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Failed to load skills: ${message}`);
+    return { success: false, installed: [], failed: [], error: message };
+  }
+  return installSelectedSkills(
+    cwd,
+    skills.map((s) => s.name),
+    force
+  );
+}
+function installSelectedSkills(cwd, skillNames, force = false) {
+  const installed = [];
+  const failed = [];
+  for (const skillName of skillNames) {
+    try {
+      if (installSkill(cwd, skillName, force)) {
+        installed.push(skillName);
+      } else {
+        failed.push(skillName);
+      }
+    } catch (err) {
+      console.error(`Failed to install ${skillName}: ${err}`);
+      failed.push(skillName);
+    }
+  }
+  const success2 = failed.length === 0 && installed.length > 0;
+  if (success2 && installed.length > 1) {
+    console.log(`
+All skills installed. See ${AGENTS_MD} for references.`);
+  }
+  return { success: success2, installed, failed };
+}
+var listCommand = new Command("list").description("Show available skills").action(() => {
+  listSkills(process.cwd());
+});
+var installCommand = new Command("install").description("Install a skill").argument("[name]", "Skill name to install").option("-a, --all", "Install all skills").option("-f, --force", "Force update if skill already exists").action(
+  (name, options) => {
+    const cwd = process.cwd();
+    if (options.all) {
+      installAllSkills(cwd, options.force);
+      return;
+    }
+    if (!name) {
+      console.error(
+        "Usage: recapt skill install <name> or recapt skill install --all"
+      );
+      process.exit(1);
+    }
+    if (installSkill(cwd, name, options.force)) {
+      console.log(`
+Skill reference added to ${AGENTS_MD}`);
+    }
+  }
+);
+var uninstallCommand = new Command("uninstall").description("Remove a skill").argument("<name>", "Skill name to uninstall").action((name) => {
+  uninstallSkill(process.cwd(), name);
+});
+var skillCommand = new Command("skill").description("Manage recapt workflow skills").addCommand(listCommand).addCommand(installCommand).addCommand(uninstallCommand);
+
+// src/cli/commands/setup.ts
+import { Command as Command2 } from "commander";
+import { exec } from "child_process";
+
+// src/cli/utils/ide-config.ts
+import fs2 from "fs";
+import path2 from "path";
+import os from "os";
+var IDE_CONFIGS = [
+  {
+    name: "Cursor",
+    globalPath: "~/.cursor/mcp.json",
+    projectPath: ".cursor/mcp.json",
+    rootKey: "mcpServers",
+    format: "json"
+  },
+  {
+    name: "Claude Code",
+    globalPath: "~/.claude.json",
+    projectPath: ".mcp.json",
+    rootKey: "mcpServers",
+    format: "json"
+  },
+  {
+    name: "Windsurf",
+    globalPath: "~/.windsurf/mcp.json",
+    projectPath: ".windsurf/mcp.json",
+    rootKey: "mcpServers",
+    format: "json"
+  },
+  {
+    name: "VS Code",
+    globalPath: null,
+    projectPath: ".vscode/mcp.json",
+    rootKey: "servers",
+    format: "json"
+  },
+  {
+    name: "Codex CLI",
+    globalPath: "~/.codex/config.toml",
+    projectPath: ".codex/config.toml",
+    rootKey: "mcp_servers",
+    format: "toml"
+  },
+  {
+    name: "Zed",
+    globalPath: "~/.config/zed/settings.json",
+    projectPath: ".zed/settings.json",
+    rootKey: "context_servers",
+    format: "json"
+  },
+  {
+    name: "GitHub Copilot",
+    globalPath: null,
+    projectPath: ".github/mcp.json",
+    rootKey: "servers",
+    format: "json"
+  }
+];
+function expandPath(p) {
+  if (p.startsWith("~/")) {
+    return path2.join(os.homedir(), p.slice(2));
+  }
+  return p;
+}
+function ideExists(config) {
+  if (!config.globalPath) {
+    return false;
+  }
+  const resolved = expandPath(config.globalPath);
+  const dir = path2.dirname(resolved);
+  if (config.name === "Claude Code") {
+    return fs2.existsSync(resolved) || fs2.existsSync(path2.join(os.homedir(), ".claude"));
+  }
+  if (config.name === "Zed") {
+    return fs2.existsSync(path2.join(os.homedir(), ".config", "zed"));
+  }
+  if (config.name === "Codex CLI") {
+    return fs2.existsSync(path2.join(os.homedir(), ".codex"));
+  }
+  return fs2.existsSync(dir);
+}
+function detectInstalledIdes() {
+  return IDE_CONFIGS.map((config) => ({
+    config,
+    detected: ideExists(config),
+    globalPathResolved: config.globalPath ? expandPath(config.globalPath) : null
+  }));
+}
+function getRecaptServerConfig(secretKey) {
+  return {
+    type: "stdio",
+    command: "npx",
+    args: ["-y", "@recapt/mcp@latest"],
+    env: {
+      RECAPT_SECRET_KEY: secretKey
+    }
+  };
+}
+function readIdeConfig(configPath, format = "json") {
+  const resolved = expandPath(configPath);
+  if (!fs2.existsSync(resolved)) {
+    return {};
+  }
+  try {
+    const content = fs2.readFileSync(resolved, "utf-8");
+    if (format === "toml") {
+      return parseToml(content);
+    }
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function parseToml(content) {
+  const result = {};
+  let currentSection = "";
+  let currentSubSection = "";
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const sectionMatch = trimmed.match(/^\[([^\]]+)\]$/);
+    if (sectionMatch) {
+      const section = sectionMatch[1];
+      const parts = section.split(".");
+      if (parts.length === 1) {
+        currentSection = parts[0];
+        currentSubSection = "";
+        if (!result[currentSection]) {
+          result[currentSection] = {};
+        }
+      } else if (parts.length === 2) {
+        currentSection = parts[0];
+        currentSubSection = parts[1];
+        if (!result[currentSection]) {
+          result[currentSection] = {};
+        }
+        const sectionObj = result[currentSection];
+        if (!sectionObj[currentSubSection]) {
+          sectionObj[currentSubSection] = {};
+        }
+      }
+      continue;
+    }
+    const kvMatch = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
+    if (kvMatch) {
+      const [, key, rawValue] = kvMatch;
+      const value = parseTomlValue(rawValue);
+      if (currentSubSection) {
+        const sectionObj = result[currentSection];
+        const subSectionObj = sectionObj[currentSubSection];
+        subSectionObj[key] = value;
+      } else if (currentSection) {
+        const sectionObj = result[currentSection];
+        sectionObj[key] = value;
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+function parseTomlValue(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed.slice(1, -1);
+  }
+  if (trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    const inner = trimmed.slice(1, -1);
+    if (!inner.trim()) return [];
+    return inner.split(",").map((item) => {
+      const t = item.trim();
+      if (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'")) {
+        return t.slice(1, -1);
+      }
+      return t;
+    });
+  }
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  const num = Number(trimmed);
+  if (!isNaN(num)) return num;
+  return trimmed;
+}
+function stringifyToml(obj, prefix = "") {
+  const lines = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === null || value === void 0) continue;
+    if (typeof value === "object" && !Array.isArray(value)) {
+      const sectionKey = prefix ? `${prefix}.${key}` : key;
+      const nested = value;
+      const hasNestedObjects = Object.values(nested).some(
+        (v) => typeof v === "object" && !Array.isArray(v)
+      );
+      if (hasNestedObjects) {
+        for (const [subKey, subValue] of Object.entries(nested)) {
+          if (typeof subValue === "object" && !Array.isArray(subValue)) {
+            lines.push(`[${sectionKey}.${subKey}]`);
+            for (const [k, v] of Object.entries(
+              subValue
+            )) {
+              lines.push(`${k} = ${tomlValue(v)}`);
+            }
+            lines.push("");
+          }
+        }
+      } else {
+        lines.push(`[${sectionKey}]`);
+        for (const [k, v] of Object.entries(nested)) {
+          lines.push(`${k} = ${tomlValue(v)}`);
+        }
+        lines.push("");
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function tomlValue(value) {
+  if (typeof value === "string") {
+    return `"${value}"`;
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((v) => typeof v === "string" ? `"${v}"` : String(v)).join(", ")}]`;
+  }
+  return String(value);
+}
+function writeIdeConfig(configPath, config, format = "json") {
+  const resolved = expandPath(configPath);
+  const dir = path2.dirname(resolved);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  if (format === "toml") {
+    fs2.writeFileSync(resolved, stringifyToml(config));
+  } else {
+    fs2.writeFileSync(resolved, JSON.stringify(config, null, 2) + "\n");
+  }
+}
+function addRecaptToIdeConfig(ide, secretKey, useGlobal = true) {
+  const configPath = useGlobal && ide.globalPath ? ide.globalPath : ide.projectPath;
+  const resolved = expandPath(configPath);
+  const existing = readIdeConfig(configPath, ide.format);
+  const rootKey = ide.rootKey;
+  const servers = existing[rootKey] || {};
+  servers["recapt"] = getRecaptServerConfig(secretKey);
+  existing[rootKey] = servers;
+  writeIdeConfig(configPath, existing, ide.format);
+  return resolved;
+}
+
+// src/cli/utils/prompts.ts
+import {
+  confirm as inquirerConfirm,
+  input as inquirerInput,
+  password as inquirerPassword,
+  select as inquirerSelect,
+  checkbox as inquirerCheckbox
+} from "@inquirer/prompts";
+async function confirm(message, defaultYes = true) {
+  return inquirerConfirm({
+    message,
+    default: defaultYes
+  });
+}
+async function input(message, defaultValue) {
+  return inquirerInput({
+    message,
+    default: defaultValue
+  });
+}
+async function secret(message) {
+  const value = await inquirerPassword({
+    message,
+    mask: "*"
+  });
+  return value.trim();
+}
+async function multiSelect(message, options) {
+  return inquirerCheckbox({
+    message,
+    choices: options.map((opt) => ({
+      name: opt.label,
+      value: opt.value,
+      checked: opt.selected ?? false
+    }))
+  });
+}
+async function select(message, options) {
+  if (options.length === 0) {
+    return null;
+  }
+  return inquirerSelect({
+    message,
+    choices: options.map((opt) => ({
+      name: opt.label,
+      value: opt.value
+    }))
+  });
+}
+function print(message) {
+  console.log(message);
+}
+function success(message) {
+  console.log(`\u2713 ${message}`);
+}
+function error(message) {
+  console.error(`\u2717 ${message}`);
+}
+function info(message) {
+  console.log(`\u2139 ${message}`);
+}
+function warn(message) {
+  console.log(`\u26A0 ${message}`);
+}
+function newline() {
+  console.log();
+}
+function header(title) {
+  console.log();
+  console.log(title);
+  console.log("=".repeat(title.length));
+  console.log();
+}
+
+// src/cli/commands/setup.ts
+var SETTINGS_URL = "https://dash.recapt.app/settings";
+var MCP_KEY_PREFIX = "mcp_sk_";
+function openBrowser(url) {
+  const platform = process.platform;
+  let command;
+  switch (platform) {
+    case "darwin":
+      command = `open "${url}"`;
+      break;
+    case "win32":
+      command = `start "" "${url}"`;
+      break;
+    default:
+      command = `xdg-open "${url}"`;
+  }
+  exec(command, (err) => {
+    if (err) {
+      info(`Could not open browser automatically. Please visit: ${url}`);
+    }
+  });
+}
+function validateMcpKey(key) {
+  return key.startsWith(MCP_KEY_PREFIX);
+}
+async function promptForKey() {
+  const hasKey = await confirm("Do you have a Recapt MCP key?", false);
+  if (!hasKey) {
+    newline();
+    info(`Opening ${SETTINGS_URL} (MCP Keys tab)...`);
+    info("Create a new MCP key and copy it.");
+    newline();
+    openBrowser(SETTINGS_URL);
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+  }
+  const key = await secret("Paste your MCP key");
+  if (!key) {
+    error("No key provided.");
+    return null;
+  }
+  if (!validateMcpKey(key)) {
+    error(
+      `Invalid MCP key format. Keys should start with "${MCP_KEY_PREFIX}".`
+    );
+    return null;
+  }
+  return key;
+}
+async function runSetup() {
+  header("Recapt MCP Setup");
+  const detectedIdes = detectInstalledIdes();
+  const installedIdes = detectedIdes.filter((ide) => ide.detected);
+  print("Detected AI IDEs:");
+  newline();
+  for (const ide of detectedIdes) {
+    const marker = ide.detected ? "[x]" : "[ ]";
+    const status = ide.detected ? `(${ide.globalPathResolved})` : "(not found)";
+    print(`  ${marker} ${ide.config.name} ${status}`);
+  }
+  newline();
+  if (installedIdes.length === 0) {
+    error("No supported AI IDEs detected.");
+    info("Supported IDEs: Cursor, Claude Code, Windsurf, VS Code");
+    info("Make sure at least one is installed before running setup.");
+    process.exit(1);
+  }
+  const options = installedIdes.map((ide) => ({
+    label: ide.config.name,
+    value: ide.config,
+    selected: true
+  }));
+  const selectedIdes = await multiSelect(
+    "Which IDE(s) do you want to configure?",
+    options
+  );
+  if (selectedIdes.length === 0) {
+    info("No IDEs selected. Exiting.");
+    return;
+  }
+  newline();
+  const mcpKey = await promptForKey();
+  if (!mcpKey) {
+    process.exit(1);
+  }
+  newline();
+  print("Writing configuration...");
+  newline();
+  const configuredPaths = [];
+  for (const ide of selectedIdes) {
+    try {
+      const configPath = addRecaptToIdeConfig(ide, mcpKey, true);
+      success(`${ide.name}: ${configPath}`);
+      configuredPaths.push(configPath);
+    } catch (err) {
+      error(`${ide.name}: Failed to write config - ${err}`);
+    }
+  }
+  if (configuredPaths.length === 0) {
+    error("Failed to configure any IDEs.");
+    process.exit(1);
+  }
+  newline();
+  const shouldInstallSkills = await confirm("Install recapt skills?", true);
+  if (shouldInstallSkills) {
+    newline();
+    let availableSkills;
+    try {
+      availableSkills = getAvailableSkills();
+    } catch (err) {
+      error(
+        `Failed to load skills: ${err instanceof Error ? err.message : err}`
+      );
+      availableSkills = [];
+    }
+    if (availableSkills.length > 0) {
+      const skillOptions = [
+        { label: "Install all skills", value: "__all__", selected: true },
+        ...availableSkills.map((skill) => ({
+          label: `${skill.name} - ${skill.description}`,
+          value: skill.name,
+          selected: false
+        }))
+      ];
+      const selectedSkills = await multiSelect(
+        "Which skills do you want to install?",
+        skillOptions
+      );
+      if (selectedSkills.length > 0) {
+        newline();
+        print("Installing skills...");
+        newline();
+        const cwd = process.cwd();
+        let result;
+        if (selectedSkills.includes("__all__")) {
+          result = installAllSkills(cwd);
+        } else {
+          result = installSelectedSkills(cwd, selectedSkills);
+        }
+        if (result.error) {
+          error(`Failed to load skills: ${result.error}`);
+        } else if (result.installed.length > 0) {
+          success(
+            `Installed ${result.installed.length} skill(s): ${result.installed.join(", ")}`
+          );
+          if (result.failed.length > 0) {
+            warn(`Failed to install: ${result.failed.join(", ")}`);
+          }
+        } else if (result.failed.length > 0) {
+          error(`Failed to install skills: ${result.failed.join(", ")}`);
+        } else {
+          info("No skills were installed.");
+        }
+      } else {
+        info("No skills selected.");
+      }
+    }
+  }
+  newline();
+  success("Setup complete!");
+  newline();
+  info("Restart your IDE(s) to activate the MCP server.");
+  newline();
+}
+var setupCommand = new Command2("setup").description("Configure recapt MCP server for your AI IDE(s)").action(async () => {
+  try {
+    await runSetup();
+  } catch (err) {
+    error(`Setup failed: ${err}`);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/setup-self-improvement-gh.ts
+import { Command as Command3 } from "commander";
+import { exec as exec2, execSync } from "child_process";
+import fs3 from "fs";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename3 = fileURLToPath2(import.meta.url);
+var __dirname3 = path3.dirname(__filename3);
+var TEMPLATES_DIR = path3.resolve(__dirname3, "../../../templates");
+var WORKFLOW_TEMPLATE = "self-improvement.md";
+var WORKFLOW_DEST = ".github/workflows/self-improvement.md";
+var ENGINES = [
+  { id: "claude", name: "Claude (Anthropic)", secretName: "ANTHROPIC_API_KEY" },
+  { id: "copilot", name: "GitHub Copilot", secretName: "COPILOT_GITHUB_TOKEN" },
+  { id: "codex", name: "Codex (OpenAI)", secretName: "OPENAI_API_KEY" }
+];
+var API_URL = process.env.RECAPT_API_URL || process.env.EXTERNAL_API_URL || "https://api.recapt.app";
+async function fetchDomains(secretKey) {
+  try {
+    const res = await fetch(`${API_URL}/v1beta/query/domains`, {
+      headers: {
+        "x-private-key": secretKey,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!res.ok) {
+      return null;
+    }
+    const data = await res.json();
+    return data;
+  } catch {
+    return null;
+  }
+}
+function commandExists(cmd) {
+  try {
+    execSync(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ghExtensionInstalled(extension) {
+  try {
+    const output = execSync("gh extension list", { encoding: "utf-8" });
+    return output.includes(extension);
+  } catch {
+    return false;
+  }
+}
+function isGitRepo() {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getRepoUrl() {
+  try {
+    const url = execSync("gh repo view --json url -q .url", {
+      encoding: "utf-8"
+    }).trim();
+    return url || null;
+  } catch {
+    return null;
+  }
+}
+function openBrowser2(url) {
+  const platform = process.platform;
+  let command;
+  switch (platform) {
+    case "darwin":
+      command = `open "${url}"`;
+      break;
+    case "win32":
+      command = `start "" "${url}"`;
+      break;
+    default:
+      command = `xdg-open "${url}"`;
+  }
+  exec2(command, (err) => {
+    if (err) {
+      info(`Could not open browser automatically. Please visit: ${url}`);
+    }
+  });
+}
+async function runSetupSelfImprovementGh() {
+  header("Recapt Self-Improvement GitHub Setup");
+  const cwd = process.cwd();
+  print("Checking prerequisites...");
+  newline();
+  const hasGh = commandExists("gh");
+  print(`  ${hasGh ? "[x]" : "[ ]"} gh CLI installed`);
+  if (!hasGh) {
+    newline();
+    error("GitHub CLI (gh) is required but not installed.");
+    info("Install it from: https://cli.github.com/");
+    process.exit(1);
+  }
+  const hasGhAw = ghExtensionInstalled("github/gh-aw");
+  print(`  ${hasGhAw ? "[x]" : "[ ]"} gh-aw extension installed`);
+  if (!hasGhAw) {
+    newline();
+    const shouldInstall = await confirm(
+      "gh-aw extension is required. Install it now?",
+      true
+    );
+    if (shouldInstall) {
+      print("Installing gh-aw extension...");
+      try {
+        execSync("gh extension install github/gh-aw", { stdio: "inherit" });
+        success("gh-aw extension installed");
+      } catch {
+        error("Failed to install gh-aw extension");
+        info("Try manually: gh extension install github/gh-aw");
+        process.exit(1);
+      }
+    } else {
+      error("gh-aw extension is required to continue.");
+      process.exit(1);
+    }
+  }
+  const inGitRepo = isGitRepo();
+  print(`  ${inGitRepo ? "[x]" : "[ ]"} Git repository detected`);
+  if (!inGitRepo) {
+    newline();
+    error("This command must be run from within a git repository.");
+    process.exit(1);
+  }
+  newline();
+  const engineOptions = ENGINES.map((engine) => ({
+    label: `${engine.name} (requires ${engine.secretName} secret)`,
+    value: engine
+  }));
+  const selectedEngine = await select(
+    "Which AI engine do you want to use?",
+    engineOptions
+  );
+  if (!selectedEngine) {
+    error("No engine selected.");
+    process.exit(1);
+  }
+  newline();
+  print("Configuring domain filter...");
+  info("You can optionally limit the workflow to specific domains.");
+  newline();
+  let selectedDomains = [];
+  const recaptKey = await input(
+    "Enter your RECAPT_SECRET_KEY to fetch domains (or press Enter to skip)"
+  );
+  if (recaptKey) {
+    const domains = await fetchDomains(recaptKey);
+    if (domains && domains.length > 0) {
+      const domainOptions = [
+        { label: "All domains", value: "__all__", selected: true },
+        ...domains.map((d) => ({
+          label: d.domainName,
+          value: d.domainName,
+          selected: false
+        }))
+      ];
+      const selected = await multiSelect(
+        "Which domains should this workflow analyze?",
+        domainOptions
+      );
+      if (!selected.includes("__all__") && selected.length > 0) {
+        selectedDomains = selected;
+        success(`Selected domains: ${selectedDomains.join(", ")}`);
+      } else {
+        info("Will analyze all domains");
+      }
+    } else {
+      warn("Could not fetch domains. Will analyze all domains.");
+    }
+  } else {
+    const manualDomain = await input(
+      "Enter a specific domain to filter (or press Enter for all domains)"
+    );
+    if (manualDomain) {
+      selectedDomains = [manualDomain];
+      success(`Selected domain: ${manualDomain}`);
+    } else {
+      info("Will analyze all domains");
+    }
+  }
+  newline();
+  print("Installing self-improvement skill...");
+  const skillInstalled = installSkill(cwd, "self-improvement", true);
+  if (!skillInstalled) {
+    error("Failed to install self-improvement skill");
+    process.exit(1);
+  }
+  newline();
+  print("Creating workflow...");
+  const templatePath = path3.join(TEMPLATES_DIR, WORKFLOW_TEMPLATE);
+  const destPath = path3.join(cwd, WORKFLOW_DEST);
+  const destDir = path3.dirname(destPath);
+  if (!fs3.existsSync(templatePath)) {
+    error(`Workflow template not found: ${templatePath}`);
+    process.exit(1);
+  }
+  if (!fs3.existsSync(destDir)) {
+    fs3.mkdirSync(destDir, { recursive: true });
+  }
+  const templateContent = fs3.readFileSync(templatePath, "utf-8");
+  let domainConfig = "";
+  if (selectedDomains.length > 0) {
+    const domainList = selectedDomains.join(", ");
+    domainConfig = `### Domain Restriction
+
+**Target domains:** ${domainList}
+
+Before doing any work:
+1. Call \`get_domains\` to verify the target domain(s) exist
+2. If any target domain is NOT in the list, stop immediately and report: "Domain not found: [domain]. Available domains: [list]"
+3. If domains are valid, pass the \`domain\` parameter to all tools that support filtering (e.g., \`run_full_diagnostic\`, \`get_page_metrics\`, etc.)
+
+Do NOT analyze or fix issues for domains not in the target list.
+
+`;
+  } else {
+    domainConfig = `### Domain Scope
+
+**Target:** All domains
+
+Analyze and fix issues across all domains configured in recapt. Call \`get_domains\` first to see available domains.
+
+`;
+  }
+  const workflowContent = templateContent.replace(/\{\s*\{\s*ENGINE\s*\}\s*\}/g, selectedEngine.id).replace(/\{\s*\{\s*DOMAIN_CONFIG\s*\}\s*\}/g, domainConfig);
+  if (fs3.existsSync(destPath)) {
+    const overwrite = await confirm(
+      "Workflow file already exists. Overwrite?",
+      false
+    );
+    if (!overwrite) {
+      info("Skipping workflow creation");
+    } else {
+      fs3.writeFileSync(destPath, workflowContent);
+      success(`Created: ${WORKFLOW_DEST}`);
+    }
+  } else {
+    fs3.writeFileSync(destPath, workflowContent);
+    success(`Created: ${WORKFLOW_DEST}`);
+  }
+  newline();
+  print("Compiling workflow...");
+  try {
+    execSync("gh aw compile", { cwd, stdio: "inherit" });
+    success("Created: .github/workflows/self-improvement.lock.yml");
+  } catch {
+    warn("Failed to compile workflow. You can run 'gh aw compile' manually.");
+  }
+  newline();
+  print("GitHub Secrets Required:");
+  info(
+    `1. ${selectedEngine.secretName} - For ${selectedEngine.name} to run the agent`
+  );
+  info("2. RECAPT_SECRET_KEY - For recapt behavioral intelligence");
+  newline();
+  const repoUrl = getRepoUrl();
+  if (repoUrl) {
+    const secretsUrl = `${repoUrl}/settings/secrets/actions`;
+    const openSecrets = await confirm("Open GitHub secrets page?", true);
+    if (openSecrets) {
+      openBrowser2(secretsUrl);
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+    }
+  } else {
+    info("Go to your repository Settings \u2192 Secrets and variables \u2192 Actions");
+    info(`Add ${selectedEngine.secretName} and RECAPT_SECRET_KEY as secrets.`);
+  }
+  newline();
+  success("Setup complete!");
+  newline();
+  print("Next steps:");
+  print(
+    '  1. git add . && git commit -m "Add recapt self-improvement workflow"'
+  );
+  print("  2. git push");
+  print("  3. Run manually: gh aw run self-improvement");
+  newline();
+  warn("Important: Enable PR creation permissions");
+  info("The workflow needs permission to create pull requests.");
+  info("Go to Settings \u2192 Actions \u2192 General \u2192 Workflow permissions");
+  info('Enable "Allow GitHub Actions to create and approve pull requests"');
+  info("(This may need to be set at the organization level)");
+  newline();
+}
+var setupSelfImprovementGhCommand = new Command3(
+  "setup-self-improvement-gh"
+).description("Set up automated self-improvement workflow for GitHub Actions").action(async () => {
+  try {
+    await runSetupSelfImprovementGh();
+  } catch (err) {
+    error(`Setup failed: ${err}`);
+    process.exit(1);
+  }
+});
+
+// src/cli/index.ts
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../../package.json");
+var program = new Command4();
+program.name("recapt").description("Recapt MCP CLI - Configure and manage recapt for AI IDEs").version(pkg.version);
 program.addCommand(setupCommand);
 program.addCommand(setupSelfImprovementGhCommand);
 program.addCommand(skillCommand);