open-xmen 0.1.0 → 0.1.2

package/dist/cli/config.js

@@ -0,0 +1,228 @@
+import { spawnSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+const PACKAGE_NAME = "open-xmen";
+const OPENCODE_INSTRUCTIONS = ["AGENTS.md", ".cerebro/cerebro-identity.md", ".cerebro/opencode/model-routing.md"];
+export 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);
+}
+export 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}`);
+}
+export 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 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 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 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 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);
+}

package/dist/cli/doctor.d.ts

@@ -0,0 +1,8 @@
+export type DoctorResult = {
+    ok: boolean;
+    cwd: string;
+    errors: string[];
+    agents: number;
+    commands: number;
+};
+export declare function runOpenCodeDoctor(cwd: string): DoctorResult;

package/dist/cli/doctor.js

@@ -0,0 +1,48 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { CEREBRO_AGENTS, CEREBRO_COMMANDS } from "../runtime/index.js";
+import { opencodeConfigHasOpenXmenPlugin } from "./config.js";
+const REQUIRED_AGENTS = [...CEREBRO_AGENTS];
+const REQUIRED_COMMANDS = CEREBRO_COMMANDS.map((command) => command.slice(1));
+export function runOpenCodeDoctor(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");
+    const agents = countMarkdownFiles(path.join(cwd, ".opencode/agents"));
+    const commands = countMarkdownFiles(path.join(cwd, ".opencode/commands"));
+    return { ok: errors.length === 0, cwd, errors, agents, commands };
+}
+function countMarkdownFiles(directory) {
+    if (!existsSync(directory))
+        return 0;
+    return readdirSync(directory).filter((file) => file.endsWith(".md")).length;
+}

package/dist/cli/runtime.d.ts

@@ -0,0 +1,7 @@
+export type ManagedWriteOptions = {
+    dryRun: boolean;
+    overwrite: boolean;
+    planned: string[];
+};
+export declare function installManagedRuntime(target: string, opts: ManagedWriteOptions): void;
+export declare function installManagedAgentInstructions(target: string, opts: ManagedWriteOptions): void;

package/dist/cli/runtime.js

@@ -0,0 +1,94 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { runtimeAssetMap, runtimeAssetsByPrefix } from "../runtime/index.js";
+const OPEN_XMEN_AGENT_BLOCK_START = "<!-- OPEN-XMEN:START -->";
+const OPEN_XMEN_AGENT_BLOCK_END = "<!-- OPEN-XMEN:END -->";
+const RUNTIME_ASSET_MAP = runtimeAssetMap();
+export function installManagedRuntime(target, opts) {
+    for (const asset of runtimeAssetsByPrefix(".opencode/").concat(runtimeAssetsByPrefix(".cerebro/"))) {
+        writeManagedFile(path.join(target, asset.path), asset.content, opts);
+    }
+    for (const dir of ["plans", "notepads", "team-runs", "pending-todos"]) {
+        const targetDir = path.join(target, ".cerebro", dir);
+        if (opts.dryRun)
+            opts.planned.push(`ensure directory ${targetDir}`);
+        else
+            mkdirSync(targetDir, { recursive: true });
+    }
+    appendGitignoreEntry(target, ".cerebro/", opts);
+}
+export function installManagedAgentInstructions(target, opts) {
+    const source = requiredRuntimeAsset("AGENTS.md").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 appendGitignoreEntry(target, entry, opts) {
+    const destination = path.join(target, ".gitignore");
+    const normalized = entry.endsWith("\n") ? entry : `${entry}\n`;
+    if (existsSync(destination)) {
+        const current = readFileSync(destination, "utf8");
+        const lines = current.split("\n");
+        if (lines.some((line) => line.trim() === entry.trim()))
+            return;
+        if (opts.dryRun) {
+            opts.planned.push(`append ${entry.trim()} to ${destination}`);
+            return;
+        }
+        writeFileSync(destination, `${current.trimEnd()}\n${normalized}`, "utf8");
+    }
+    else {
+        if (opts.dryRun) {
+            opts.planned.push(`create ${destination} with ${entry.trim()}`);
+            return;
+        }
+        writeFileSync(destination, normalized, "utf8");
+    }
+}
+function requiredRuntimeAsset(assetPath) {
+    const content = RUNTIME_ASSET_MAP.get(assetPath);
+    if (typeof content !== "string")
+        throw new Error(`Missing generated runtime asset: ${assetPath}`);
+    return content;
+}
+function writeManagedFile(destination, content, opts) {
+    if (existsSync(destination) && !opts.overwrite) {
+        opts.planned.push(`skip existing ${destination}`);
+        return;
+    }
+    if (opts.dryRun) {
+        opts.planned.push(`${existsSync(destination) ? "overwrite" : "write"} ${destination}`);
+        return;
+    }
+    mkdirSync(path.dirname(destination), { recursive: true });
+    writeFileSync(destination, content, "utf8");
+}