open-xmen 0.1.0

package/dist/cli.js

@@ -0,0 +1,597 @@
+#!/usr/bin/env node
+import { copyFileSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const REQUIRED_AGENTS = [
+    "cerebro",
+    "legion",
+    "cypher",
+    "professor-x",
+    "cyclops",
+    "wolverine",
+    "storm",
+    "forge",
+    "nightcrawler",
+    "sage",
+    "beast",
+    "emma-frost",
+];
+const REQUIRED_COMMANDS = [
+    "cerebro-index",
+    "cerebro-plan",
+    "cerebro-start-work",
+    "cerebro-doctor",
+    "cerebro-reset",
+    "cerebro-upgrade",
+    "to-me-my-x-men",
+];
+const OPEN_XMEN_AGENT_BLOCK_START = "<!-- OPEN-XMEN:START -->";
+const OPEN_XMEN_AGENT_BLOCK_END = "<!-- OPEN-XMEN:END -->";
+const PACKAGE_NAME = "open-xmen";
+const OPENCODE_INSTRUCTIONS = ["AGENTS.md", ".cerebro/cerebro-identity.md", ".cerebro/opencode/model-routing.md"];
+const SKIP_COPY_NAMES = new Set(["node_modules", "__pycache__"]);
+const DENY_COPY_PATTERN = /(^|[/\\])(?:\.env(?:\.|$)|.*(?:secret|credential|token|private[-_]?key).*)/i;
+function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    if (!command)
+        return install([]);
+    if (command === "install")
+        return install(args.slice(1));
+    if (command === "doctor")
+        return doctor(args.slice(1));
+    if (command === "models")
+        return models();
+    if (command === "--help" || command === "-h") {
+        printHelp();
+        return 0;
+    }
+    console.error(`Unknown command: ${command}`);
+    console.error("Run `open-xmen --help` for usage information.");
+    return 1;
+}
+function printHelp() {
+    console.log(`Open X-Men installer
+
+Usage:
+  open-xmen [install] [OPTIONS]
+  open-xmen doctor [OPTIONS]
+  open-xmen models
+
+Install options:
+  --dir <path>    Project directory to install into (default: current directory)
+  --dry-run       Print planned writes without changing files
+  --reset         Refresh managed runtime/template files and replace existing Open X-Men blocks
+  --force         Alias for overwrite behavior used by --reset
+  --no-deps       Skip OpenCode plugin cache warm-up
+  -h, --help      Show this help message
+
+Doctor options:
+  --dir <path>    Project directory to validate (default: current directory)
+  --json          Print diagnostics as JSON
+  -h, --help      Show this help message
+
+Examples:
+  bunx open-xmen@latest install
+  bunx open-xmen@latest install --dir /path/to/project --dry-run
+  bunx open-xmen@latest install --reset --no-deps
+  open-xmen doctor --json
+`);
+}
+function printInstallHelp() {
+    console.log(`Usage: open-xmen install [--dir <path>] [--dry-run] [--reset] [--force] [--no-deps]
+
+By default, existing runtime/template files are skipped. Use --reset or --force to refresh them.
+opencode.jsonc is updated atomically and an opencode.jsonc.bak backup is created when replacing an existing config.`);
+}
+function printDoctorHelp() {
+    console.log("Usage: open-xmen doctor [--dir <path>] [--json]");
+}
+function install(args) {
+    if (args.includes("--help") || args.includes("-h")) {
+        printInstallHelp();
+        return 0;
+    }
+    const unknown = args.find((arg, index) => {
+        if (!arg.startsWith("-"))
+            return false;
+        if (args[index - 1] === "--dir")
+            return false;
+        return !["--dir", "--dry-run", "--force", "--reset", "--no-deps"].includes(arg);
+    });
+    if (unknown) {
+        console.error(`Unknown install option: ${unknown}`);
+        return 1;
+    }
+    const targetArg = valueAfter(args, "--dir");
+    if (args.includes("--dir") && !targetArg) {
+        console.error("Missing value for --dir");
+        return 1;
+    }
+    const options = {
+        dryRun: args.includes("--dry-run"),
+        force: args.includes("--force"),
+        reset: args.includes("--reset"),
+        skipDeps: args.includes("--no-deps"),
+        target: path.resolve(targetArg || process.cwd()),
+    };
+    const overwrite = options.force || options.reset;
+    const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+    const planned = [];
+    const copyOptions = { dryRun: options.dryRun, overwrite, planned };
+    console.log(`Open X-Men ${options.dryRun ? "dry run" : "install"}`);
+    console.log(`Target: ${options.target}`);
+    if (overwrite)
+        console.log("Mode: refresh existing managed files (--reset/--force)");
+    else
+        console.log("Mode: safe install (existing files are skipped)");
+    if (!options.dryRun)
+        mkdirSync(options.target, { recursive: true });
+    else
+        planned.push(`ensure directory ${options.target}`);
+    copyAny(path.join(packageRoot, ".opencode/.gitignore"), path.join(options.target, ".opencode/.gitignore"), copyOptions);
+    copyTree(path.join(packageRoot, ".opencode/agents"), path.join(options.target, ".opencode/agents"), copyOptions);
+    copyTree(path.join(packageRoot, ".opencode/commands"), path.join(options.target, ".opencode/commands"), copyOptions);
+    copyCerebroRuntime(packageRoot, options.target, copyOptions);
+    installAgentInstructions(packageRoot, options.target, { dryRun: options.dryRun, overwrite, planned });
+    updateOpencodeConfig(options.target, { dryRun: options.dryRun, planned });
+    if (options.dryRun) {
+        console.log("\nPlanned actions:");
+        for (const action of planned)
+            console.log(`- ${action}`);
+        console.log("\nopen-xmen install: DRY RUN PASS");
+        return 0;
+    }
+    if (!options.skipDeps)
+        warmOpenCodePluginCache(packageRoot);
+    else
+        console.log("Skipped OpenCode plugin cache warm-up (--no-deps)");
+    console.log("open-xmen install: PASS");
+    console.log(`Installed into ${options.target}`);
+    console.log("Next: run `opencode .`, then use `/cerebro-index`, `/cerebro-plan`, or `/to-me-my-x-men`.");
+    return 0;
+}
+function doctor(args = []) {
+    if (args.includes("--help") || args.includes("-h")) {
+        printDoctorHelp();
+        return 0;
+    }
+    const json = args.includes("--json");
+    const targetArg = valueAfter(args, "--dir");
+    const unknown = args.find((arg, index) => {
+        if (!arg.startsWith("-"))
+            return false;
+        if (args[index - 1] === "--dir")
+            return false;
+        return !["--dir", "--json"].includes(arg);
+    });
+    if (unknown) {
+        if (json)
+            console.log(JSON.stringify({ ok: false, error: `Unknown doctor option: ${unknown}` }, null, 2));
+        else
+            console.error(`Unknown doctor option: ${unknown}`);
+        return 1;
+    }
+    if (args.includes("--dir") && !targetArg) {
+        if (json)
+            console.log(JSON.stringify({ ok: false, error: "Missing value for --dir" }, null, 2));
+        else
+            console.error("Missing value for --dir");
+        return 1;
+    }
+    const cwd = path.resolve(targetArg || process.cwd());
+    const result = runDoctor(cwd);
+    if (json) {
+        console.log(JSON.stringify(result, null, 2));
+        return result.ok ? 0 : 1;
+    }
+    if (!result.ok) {
+        console.error("Cerebro OpenCode doctor: FAIL");
+        for (const error of result.errors)
+            console.error(`- ${error}`);
+        return 1;
+    }
+    console.log("Cerebro OpenCode doctor: PASS");
+    console.log(`Agents: ${result.agents}`);
+    console.log(`Commands: ${result.commands}`);
+    return 0;
+}
+function runDoctor(cwd) {
+    const errors = [];
+    const exists = (file) => existsSync(path.join(cwd, file));
+    const read = (file) => readFileSync(path.join(cwd, file), "utf8");
+    for (const file of ["opencode.jsonc", "AGENTS.md", ".cerebro/cerebro-identity.md"]) {
+        if (!exists(file))
+            errors.push(`missing ${file}`);
+    }
+    if (!opencodeConfigHasOpenXmenPlugin(cwd)) {
+        errors.push("opencode.jsonc does not include the open-xmen plugin entry");
+    }
+    for (const name of REQUIRED_AGENTS) {
+        const file = `.opencode/agents/${name}.md`;
+        if (!exists(file))
+            errors.push(`missing ${file}`);
+        else if (!read(file).startsWith("---\n"))
+            errors.push(`${file} missing frontmatter`);
+    }
+    for (const name of REQUIRED_COMMANDS) {
+        const file = `.opencode/commands/${name}.md`;
+        if (!exists(file))
+            errors.push(`missing ${file}`);
+        else if (!read(file).includes("agent: cerebro"))
+            errors.push(`${file} should run with agent: cerebro`);
+    }
+    for (const dir of [".cerebro/plans", ".cerebro/notepads", ".cerebro/team-runs"]) {
+        if (!exists(dir))
+            errors.push(`missing ${dir}`);
+    }
+    const opencode = spawnSync("opencode", ["--version"], { encoding: "utf8" });
+    if (opencode.status !== 0)
+        errors.push("opencode executable not found or not working");
+    let agents = 0;
+    let commands = 0;
+    agents = countMarkdownFiles(path.join(cwd, ".opencode/agents"));
+    commands = countMarkdownFiles(path.join(cwd, ".opencode/commands"));
+    return { ok: errors.length === 0, cwd, errors, agents, commands };
+}
+function models() {
+    console.log(JSON.stringify({
+        frontier: process.env.CEREBRO_MODEL_FRONTIER || "openai/gpt-5.4",
+        strong: process.env.CEREBRO_MODEL_STRONG || "openai/gpt-5.4",
+        coding: process.env.CEREBRO_MODEL_CODING || "openai/gpt-5.3-codex",
+        spark: process.env.CEREBRO_MODEL_SPARK || "openai/gpt-5.3-codex-spark",
+        fast: process.env.CEREBRO_MODEL_FAST || "openai/gpt-5.4-mini",
+        image: process.env.CEREBRO_MODEL_IMAGE || "openai/gpt-image-2",
+    }, null, 2));
+    return 0;
+}
+function copyCerebroRuntime(packageRoot, target, opts) {
+    const root = path.join(packageRoot, ".cerebro");
+    const entries = [
+        ".gitignore",
+        "cerebro-identity.md",
+        "docs",
+        "integrations",
+        "opencode",
+        "schemas",
+        "scripts",
+        "templates",
+        "upgrade-manifest.json",
+    ];
+    for (const entry of entries) {
+        copyAny(path.join(root, entry), path.join(target, ".cerebro", entry), opts);
+    }
+    for (const dir of ["plans", "notepads", "team-runs", "pending-todos"]) {
+        const targetDir = path.join(target, ".cerebro", dir);
+        const gitkeep = path.join(targetDir, ".gitkeep");
+        if (opts.dryRun) {
+            opts.planned.push(`ensure directory ${targetDir}`);
+            if (!existsSync(gitkeep))
+                opts.planned.push(`create ${gitkeep}`);
+            continue;
+        }
+        mkdirSync(targetDir, { recursive: true });
+        if (!existsSync(gitkeep))
+            writeFileSync(gitkeep, "", "utf8");
+    }
+}
+function installAgentInstructions(packageRoot, target, opts) {
+    const source = readFileSync(path.join(packageRoot, "AGENTS.md"), "utf8").trim();
+    const block = `${OPEN_XMEN_AGENT_BLOCK_START}\n${source}\n${OPEN_XMEN_AGENT_BLOCK_END}`;
+    const destination = path.join(target, "AGENTS.md");
+    if (!existsSync(destination)) {
+        if (opts.dryRun)
+            opts.planned.push(`create ${destination}`);
+        else
+            writeFileSync(destination, `${block}\n`, "utf8");
+        return;
+    }
+    const current = readFileSync(destination, "utf8");
+    const start = current.indexOf(OPEN_XMEN_AGENT_BLOCK_START);
+    const end = current.indexOf(OPEN_XMEN_AGENT_BLOCK_END);
+    if (start !== -1 && end !== -1 && end > start) {
+        if (!opts.overwrite) {
+            opts.planned.push(`skip existing Open X-Men AGENTS.md block ${destination}`);
+            return;
+        }
+        const next = `${current.slice(0, start)}${block}${current.slice(end + OPEN_XMEN_AGENT_BLOCK_END.length)}`;
+        if (next === current || `${next}\n` === current) {
+            opts.planned.push(`unchanged ${destination}`);
+            return;
+        }
+        if (opts.dryRun)
+            opts.planned.push(`refresh Open X-Men AGENTS.md block ${destination}`);
+        else
+            writeFileSync(destination, next.endsWith("\n") ? next : `${next}\n`, "utf8");
+        return;
+    }
+    if (opts.dryRun)
+        opts.planned.push(`append Open X-Men AGENTS.md block ${destination}`);
+    else
+        writeFileSync(destination, `${current.trimEnd()}\n\n${block}\n`, "utf8");
+}
+function opencodeConfigHasOpenXmenPlugin(cwd = process.cwd()) {
+    const configPath = path.join(cwd, "opencode.jsonc");
+    if (!existsSync(configPath))
+        return false;
+    try {
+        const config = parseJsonc(readFileSync(configPath, "utf8"));
+        return asArray(config.plugin).some((entry) => {
+            const spec = Array.isArray(entry) ? entry[0] : entry;
+            return typeof spec === "string" && isOpenXmenPluginEntry(spec);
+        });
+    }
+    catch {
+        return false;
+    }
+}
+function getPluginEntry() {
+    const cliEntryPath = process.argv[1];
+    if (!cliEntryPath)
+        return PACKAGE_NAME;
+    const packageRoot = findPackageRoot(cliEntryPath);
+    if (!packageRoot || isPackageManagerInstall(packageRoot))
+        return PACKAGE_NAME;
+    return packageRoot;
+}
+function replaceOpenXmenPluginEntries(items, pluginEntry) {
+    return [...items.filter((entry) => {
+            const spec = Array.isArray(entry) ? entry[0] : entry;
+            return !(typeof spec === "string" && isOpenXmenPluginEntry(spec));
+        }), pluginEntry];
+}
+function isOpenXmenPluginEntry(entry) {
+    return entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`) || entry.endsWith(".opencode/plugins/open-xmen.ts") || isLocalPackageRootEntry(entry);
+}
+function findPackageRoot(startPath) {
+    let current = path.dirname(startPath);
+    while (true) {
+        const packageJsonPath = path.join(current, "package.json");
+        if (existsSync(packageJsonPath)) {
+            const packageJson = readJsonFile(packageJsonPath);
+            if (isRecord(packageJson) && packageJson.name === PACKAGE_NAME)
+                return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+function isLocalPackageRootEntry(entry) {
+    if (!entry || entry.startsWith("file://"))
+        return false;
+    const packageJsonPath = path.join(entry, "package.json");
+    if (!existsSync(packageJsonPath))
+        return false;
+    const packageJson = readJsonFile(packageJsonPath);
+    return isRecord(packageJson) && packageJson.name === PACKAGE_NAME;
+}
+function isPackageManagerInstall(packageRoot) {
+    return packageRoot.replaceAll("\\", "/").includes(`/node_modules/${PACKAGE_NAME}`);
+}
+function warmOpenCodePluginCache(packageRoot) {
+    if (!isPackageManagerInstall(packageRoot)) {
+        console.log("Local development install - cache warm-up not required");
+        return;
+    }
+    const home = process.env.HOME;
+    if (!home)
+        return;
+    let version = "latest";
+    const packageJson = readJsonFile(path.join(packageRoot, "package.json"));
+    if (isRecord(packageJson) && typeof packageJson.version === "string")
+        version = packageJson.version;
+    const cacheRoot = process.env.XDG_CACHE_HOME || path.join(home, ".cache");
+    const cacheDir = path.join(cacheRoot, "opencode", "packages", `${PACKAGE_NAME}@${version}`);
+    mkdirSync(cacheDir, { recursive: true });
+    writeFileSync(path.join(cacheDir, "package.json"), `${JSON.stringify({ name: `${PACKAGE_NAME}-cache`, private: true, dependencies: { [PACKAGE_NAME]: version } }, null, 2)}\n`, "utf8");
+    const bun = spawnSync("bun", ["install", "--ignore-scripts"], { cwd: cacheDir, stdio: "inherit" });
+    if (bun.status !== 0)
+        console.warn("open-xmen install: skipped OpenCode plugin cache warm-up; bun install failed");
+    else
+        console.log(`OpenCode plugin cache warmed: ${cacheDir}`);
+}
+function updateOpencodeConfig(target, opts) {
+    const destination = path.join(target, "opencode.jsonc");
+    const parsed = existsSync(destination) ? parseJsonc(readFileSync(destination, "utf8")) : {};
+    const config = isRecord(parsed) ? parsed : {};
+    config.$schema ||= "https://opencode.ai/config.json";
+    config.plugin = replaceOpenXmenPluginEntries(asArray(config.plugin), getPluginEntry());
+    config.instructions = appendUnique(asArray(config.instructions), ...OPENCODE_INSTRUCTIONS);
+    config.share ??= "disabled";
+    config.permission ??= { edit: "ask", bash: "ask", webfetch: "ask" };
+    const content = `${JSON.stringify(config, null, 2)}\n`;
+    if (opts.dryRun) {
+        if (existsSync(destination))
+            opts.planned.push(`atomically update ${destination} (backup ${destination}.bak)`);
+        else
+            opts.planned.push(`create ${destination}`);
+        return;
+    }
+    writeAtomicConfig(destination, content);
+}
+function writeAtomicConfig(destination, content) {
+    mkdirSync(path.dirname(destination), { recursive: true });
+    if (existsSync(destination)) {
+        const current = readFileSync(destination, "utf8");
+        if (current === content)
+            return;
+        copyFileSync(destination, `${destination}.bak`);
+    }
+    const temp = `${destination}.tmp`;
+    writeFileSync(temp, content, "utf8");
+    renameSync(temp, destination);
+}
+function copyTree(source, destination, opts) {
+    copyAny(source, destination, opts);
+}
+function copyAny(source, destination, opts) {
+    if (!existsSync(source))
+        return;
+    if (isDeniedRuntimePath(source) || isDeniedRuntimePath(destination))
+        return;
+    const link = lstatSync(source);
+    if (link.isSymbolicLink())
+        return;
+    const stat = statSync(source);
+    if (stat.isDirectory()) {
+        if (SKIP_COPY_NAMES.has(path.basename(source)))
+            return;
+        assertContained(source, path.join(source, "placeholder"));
+        if (opts.dryRun)
+            opts.planned.push(`ensure directory ${destination}`);
+        else
+            mkdirSync(destination, { recursive: true });
+        for (const item of readdirSync(source)) {
+            copyAny(path.join(source, item), path.join(destination, item), opts);
+        }
+        return;
+    }
+    if (!stat.isFile())
+        return;
+    if (source.endsWith(".pyc"))
+        return;
+    assertContained(path.dirname(source), source);
+    if (existsSync(destination) && !opts.overwrite) {
+        opts.planned.push(`skip existing ${destination}`);
+        return;
+    }
+    if (opts.dryRun) {
+        opts.planned.push(`${existsSync(destination) ? "overwrite" : "copy"} ${destination}`);
+        return;
+    }
+    mkdirSync(path.dirname(destination), { recursive: true });
+    writeFileSync(destination, readFileSync(source));
+}
+function countMarkdownFiles(directory) {
+    if (!existsSync(directory))
+        return 0;
+    return readdirSync(directory).filter((file) => file.endsWith(".md")).length;
+}
+function readJsonFile(file) {
+    if (!existsSync(file))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(file, "utf8"));
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            return undefined;
+        throw error;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isDeniedRuntimePath(filePath) {
+    return DENY_COPY_PATTERN.test(filePath.replaceAll("\\", "/"));
+}
+function assertContained(root, candidate) {
+    const resolvedRoot = realpathSync(root);
+    const resolvedCandidate = existsSync(candidate) ? realpathSync(candidate) : path.resolve(candidate);
+    const relative = path.relative(resolvedRoot, resolvedCandidate);
+    if (relative.startsWith("..") || path.isAbsolute(relative))
+        throw new Error(`copy path escapes source root: ${candidate}`);
+}
+function parseJsonc(text) {
+    const stripped = removeTrailingCommas(stripJsonComments(text));
+    return stripped.trim() ? JSON.parse(stripped) : {};
+}
+function stripJsonComments(text) {
+    let out = "";
+    let inString = false;
+    let escape = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        const next = text[i + 1];
+        if (inString) {
+            out += ch;
+            if (escape)
+                escape = false;
+            else if (ch === "\\")
+                escape = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        if (ch === "/" && next === "/") {
+            while (i < text.length && text[i] !== "\n")
+                i++;
+            out += "\n";
+            continue;
+        }
+        if (ch === "/" && next === "*") {
+            i += 2;
+            while (i < text.length && !(text[i] === "*" && text[i + 1] === "/"))
+                i++;
+            i++;
+            continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+function removeTrailingCommas(text) {
+    let out = "";
+    let inString = false;
+    let escape = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            out += ch;
+            if (escape)
+                escape = false;
+            else if (ch === "\\")
+                escape = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        if (ch === ",") {
+            let j = i + 1;
+            while (/\s/.test(text[j] || ""))
+                j++;
+            if (text[j] === "}" || text[j] === "]")
+                continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+function appendUnique(items, ...values) {
+    const result = [...items];
+    for (const value of values) {
+        if (!result.includes(value))
+            result.push(value);
+    }
+    return result;
+}
+function asArray(value) {
+    return Array.isArray(value) ? value.filter(isJsonValue) : [];
+}
+function isJsonValue(value) {
+    if (value === null)
+        return true;
+    if (["boolean", "number", "string"].includes(typeof value))
+        return true;
+    if (Array.isArray(value))
+        return value.every(isJsonValue);
+    return isRecord(value) && Object.values(value).every(isJsonValue);
+}
+function valueAfter(args, flag) {
+    const index = args.indexOf(flag);
+    return index === -1 ? undefined : args[index + 1];
+}
+process.exitCode = main();

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const CerebroPlugin: Plugin;
+export declare const server: Plugin;
+export default CerebroPlugin;