@recapt/mcp 0.0.5-beta → 0.0.7-beta

package/dist/cli/skill.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+/**
+ * Recapt Skills CLI
+ *
+ * Installs recapt workflow skills to .agents/recapt/ and manages AGENTS.md references.
+ * Works across all AI IDEs that support the AGENTS.md standard.
+ *
+ * Usage:
+ *   npx @recapt/mcp skill list
+ *   npx @recapt/mcp skill install self-healing
+ *   npx @recapt/mcp skill install --all
+ *   npx @recapt/mcp skill uninstall self-healing
+ */
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const SKILLS_DIR = path.resolve(__dirname, "../../skills");
+const AGENTS_DIR = ".agents/recapt";
+const AGENTS_MD = "AGENTS.md";
+const MARKER_START = "<!-- recapt:skills -->";
+const MARKER_END = "<!-- /recapt:skills -->";
+function getAvailableSkills() {
+    if (!fs.existsSync(SKILLS_DIR)) {
+        console.error(`Skills directory not found: ${SKILLS_DIR}`);
+        process.exit(1);
+    }
+    const files = fs.readdirSync(SKILLS_DIR).filter((f) => f.endsWith(".md"));
+    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) {
+    const skills = getAvailableSkills();
+    const skill = skills.find((s) => s.name === skillName);
+    return skill?.description ?? 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\n\n${newBlock}`;
+        }
+    }
+    writeAgentsMd(cwd, content + "\n");
+}
+function installSkill(cwd, skillName) {
+    const skills = getAvailableSkills();
+    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)) {
+        console.log(`Skill already installed: ${skillName}`);
+        return true;
+    }
+    fs.copyFileSync(sourcePath, destPath);
+    console.log(`Installed: ${skillName} → ${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) {
+    const available = getAvailableSkills();
+    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("\nUsage:");
+    console.log("  npx @recapt/mcp skill install <name>");
+    console.log("  npx @recapt/mcp skill install --all");
+    console.log("  npx @recapt/mcp skill uninstall <name>\n");
+}
+function printHelp() {
+    console.log(`
+Recapt Skills CLI
+
+Installs workflow skills to .agents/recapt/ for use with any AI IDE.
+
+Commands:
+  list                    Show available skills
+  install <name>          Install a skill
+  install --all           Install all skills
+  uninstall <name>        Remove a skill
+
+Examples:
+  npx @recapt/mcp skill list
+  npx @recapt/mcp skill install self-healing
+  npx @recapt/mcp skill install --all
+  npx @recapt/mcp skill uninstall deep-dive
+`);
+}
+function main() {
+    const args = process.argv.slice(2);
+    const cwd = process.cwd();
+    if (args[0] === "skill") {
+        args.shift();
+    }
+    const command = args[0];
+    switch (command) {
+        case "list":
+            listSkills(cwd);
+            break;
+        case "install": {
+            const target = args[1];
+            if (!target) {
+                console.error("Usage: npx @recapt/mcp skill install <name|--all>");
+                process.exit(1);
+            }
+            if (target === "--all") {
+                const skills = getAvailableSkills();
+                let success = true;
+                for (const skill of skills) {
+                    if (!installSkill(cwd, skill.name)) {
+                        success = false;
+                    }
+                }
+                if (success) {
+                    console.log(`\nAll skills installed. See ${AGENTS_MD} for references.`);
+                }
+            }
+            else {
+                if (installSkill(cwd, target)) {
+                    console.log(`\nSkill reference added to ${AGENTS_MD}`);
+                }
+            }
+            break;
+        }
+        case "uninstall": {
+            const target = args[1];
+            if (!target) {
+                console.error("Usage: npx @recapt/mcp skill uninstall <name>");
+                process.exit(1);
+            }
+            uninstallSkill(cwd, target);
+            break;
+        }
+        case "help":
+        case "--help":
+        case "-h":
+            printHelp();
+            break;
+        default:
+            if (command) {
+                console.error(`Unknown command: ${command}`);
+            }
+            printHelp();
+            process.exit(command ? 1 : 0);
+    }
+}
+main();

package/dist/cli/utils/ide-config.d.ts

@@ -0,0 +1,31 @@
+/**
+ * IDE Configuration Utilities
+ *
+ * Handles detection and configuration of MCP servers across different AI IDEs.
+ */
+export type ConfigFormat = "json" | "toml";
+export interface IdeConfig {
+    name: string;
+    globalPath: string | null;
+    projectPath: string;
+    rootKey: string;
+    format: ConfigFormat;
+}
+export declare const IDE_CONFIGS: IdeConfig[];
+export interface DetectedIde {
+    config: IdeConfig;
+    detected: boolean;
+    globalPathResolved: string | null;
+}
+export declare function detectInstalledIdes(): DetectedIde[];
+export interface McpServerConfig {
+    type?: string;
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+}
+export declare function readIdeConfig(configPath: string, format?: ConfigFormat): Record<string, unknown>;
+export declare function writeIdeConfig(configPath: string, config: Record<string, unknown>, format?: ConfigFormat): void;
+export declare function addRecaptToIdeConfig(ide: IdeConfig, secretKey: string, useGlobal?: boolean): string;
+export declare function removeRecaptFromIdeConfig(ide: IdeConfig, useGlobal?: boolean): boolean;
+export declare function isRecaptConfigured(ide: IdeConfig): boolean;

package/dist/cli/utils/ide-config.js

@@ -0,0 +1,294 @@
+/**
+ * IDE Configuration Utilities
+ *
+ * Handles detection and configuration of MCP servers across different AI IDEs.
+ */
+import fs from "fs";
+import path from "path";
+import os from "os";
+export const 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 path.join(os.homedir(), p.slice(2));
+    }
+    return p;
+}
+function ideExists(config) {
+    if (!config.globalPath) {
+        return false;
+    }
+    const resolved = expandPath(config.globalPath);
+    const dir = path.dirname(resolved);
+    if (config.name === "Claude Code") {
+        return (fs.existsSync(resolved) ||
+            fs.existsSync(path.join(os.homedir(), ".claude")));
+    }
+    if (config.name === "Zed") {
+        return fs.existsSync(path.join(os.homedir(), ".config", "zed"));
+    }
+    if (config.name === "Codex CLI") {
+        return fs.existsSync(path.join(os.homedir(), ".codex"));
+    }
+    return fs.existsSync(dir);
+}
+export 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,
+        },
+    };
+}
+export function readIdeConfig(configPath, format = "json") {
+    const resolved = expandPath(configPath);
+    if (!fs.existsSync(resolved)) {
+        return {};
+    }
+    try {
+        const content = fs.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 === undefined)
+            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);
+}
+export function writeIdeConfig(configPath, config, format = "json") {
+    const resolved = expandPath(configPath);
+    const dir = path.dirname(resolved);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    if (format === "toml") {
+        fs.writeFileSync(resolved, stringifyToml(config));
+    }
+    else {
+        fs.writeFileSync(resolved, JSON.stringify(config, null, 2) + "\n");
+    }
+}
+export 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;
+}
+export function removeRecaptFromIdeConfig(ide, useGlobal = true) {
+    const configPath = useGlobal && ide.globalPath ? ide.globalPath : ide.projectPath;
+    const resolved = expandPath(configPath);
+    if (!fs.existsSync(resolved)) {
+        return false;
+    }
+    const existing = readIdeConfig(configPath, ide.format);
+    const rootKey = ide.rootKey;
+    const servers = existing[rootKey] || {};
+    if (!("recapt" in servers)) {
+        return false;
+    }
+    delete servers["recapt"];
+    existing[rootKey] = servers;
+    writeIdeConfig(configPath, existing, ide.format);
+    return true;
+}
+export function isRecaptConfigured(ide) {
+    if (ide.globalPath) {
+        const globalConfig = readIdeConfig(ide.globalPath, ide.format);
+        const servers = globalConfig[ide.rootKey] || {};
+        if ("recapt" in servers) {
+            return true;
+        }
+    }
+    const projectConfig = readIdeConfig(ide.projectPath, ide.format);
+    const servers = projectConfig[ide.rootKey] || {};
+    return "recapt" in servers;
+}

package/dist/cli/utils/prompts.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Interactive Prompts
+ *
+ * Readline-based prompts for CLI interactions.
+ */
+export declare function confirm(message: string, defaultYes?: boolean): Promise<boolean>;
+export declare function input(message: string, defaultValue?: string): Promise<string>;
+export declare function secret(message: string): Promise<string>;
+export interface SelectOption<T = string> {
+    label: string;
+    value: T;
+    selected?: boolean;
+}
+export declare function multiSelect<T = string>(message: string, options: SelectOption<T>[]): Promise<T[]>;
+export declare function select<T = string>(message: string, options: SelectOption<T>[]): Promise<T | null>;
+export declare function print(message: string): void;
+export declare function success(message: string): void;
+export declare function error(message: string): void;
+export declare function info(message: string): void;
+export declare function warn(message: string): void;
+export declare function newline(): void;
+export declare function header(title: string): void;