opencode-magi 0.0.0-dev-20260519011027

package/dist/index.js

@@ -0,0 +1,540 @@
+import { tool } from "@opencode-ai/plugin";
+import { exec as nodeExec } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { MAGI_COMMANDS } from "./commands";
+import { loadConfig, mergeMagiConfig } from "./config/load";
+import { outputBaseDirs } from "./config/output";
+import { worktreeBaseDirs } from "./config/worktree";
+import { resolveRepository } from "./config/resolve";
+import { validateConfig } from "./config/validate";
+import { withGitHubApiRetry } from "./github/retry";
+import { mapPool } from "./orchestrator/pool";
+import { MagiRunManager } from "./orchestrator/run-manager";
+const execAsync = promisify(nodeExec);
+const GLOBAL_CONFIG_PATH = join(homedir(), ".config", "opencode", "magi.json");
+const PROJECT_CONFIG_PATH = join(".opencode", "magi.json");
+function createExec(defaultCwd) {
+    return async (command, options) => {
+        const { stdout } = await execAsync(command, {
+            cwd: options?.cwd ?? defaultCwd,
+            env: { ...process.env, ...options?.env },
+            maxBuffer: 1024 * 1024 * 20,
+            signal: options?.signal,
+        });
+        return stdout;
+    };
+}
+function responseData(result) {
+    if (!result || typeof result !== "object")
+        return result;
+    return result.data ?? result;
+}
+function extractModelCatalog(result) {
+    const data = responseData(result);
+    if (!data || typeof data !== "object")
+        return undefined;
+    const providers = data.providers ??
+        data.all;
+    if (!Array.isArray(providers))
+        return undefined;
+    const catalog = {};
+    for (const provider of providers) {
+        if (!provider || typeof provider !== "object")
+            continue;
+        const id = provider.id;
+        const models = provider.models;
+        if (typeof id !== "string" || !models || typeof models !== "object")
+            continue;
+        catalog[id] = Object.keys(models);
+    }
+    return catalog;
+}
+function parsePrToken(value) {
+    const trimmed = value.trim();
+    const pullUrl = trimmed.match(/(?:^|\/)pull\/(\d+)(?:[/?#].*)?$/);
+    const raw = pullUrl?.[1] ?? trimmed.replace(/^#/, "");
+    const pr = Number.parseInt(raw, 10);
+    if (!Number.isInteger(pr) || pr <= 0 || String(pr) !== raw) {
+        throw new Error("Specify one or more PR numbers or PR URLs.");
+    }
+    return pr;
+}
+export function parsePrs(value) {
+    const prs = value
+        .split(/[\s,]+/)
+        .filter(Boolean)
+        .map(parsePrToken);
+    if (!prs.length)
+        throw new Error("Specify one or more PR numbers or PR URLs.");
+    return prs;
+}
+export function parseRunArguments(value, dryRun = false) {
+    const tokens = value.split(/[\s,]+/).filter(Boolean);
+    const prTokens = tokens.filter((token) => {
+        if (token === "--dry-run") {
+            dryRun = true;
+            return false;
+        }
+        return true;
+    });
+    return { dryRun, prs: parsePrs(prTokens.join(" ")) };
+}
+function parseOptionalPr(value) {
+    if (!value?.trim())
+        return undefined;
+    return parsePrToken(value);
+}
+function clearFlag(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+function clearToolFlag(value) {
+    if (value === true || value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    return undefined;
+}
+function hasBlankSelector(args) {
+    return !args.runId?.trim() && !args.pr?.trim();
+}
+function hasDefaultedFalseClearFlags(args) {
+    return (hasBlankSelector(args) &&
+        args.branch === "false" &&
+        args.output === "false" &&
+        args.session === "false" &&
+        args.worktree === "false");
+}
+function parseQuestionAnswers(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new Error("Specify at least one answer.");
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed) &&
+            parsed.length &&
+            parsed.every((item) => typeof item === "string")) {
+            return parsed;
+        }
+    }
+    catch {
+        // Plain text answers are accepted below.
+    }
+    return [trimmed];
+}
+function prMarkdownLink(repository, pr) {
+    const host = repository.github.host || "github.com";
+    const url = `https://${host}/${repository.github.owner}/${repository.github.repo}/pull/${pr}`;
+    return `[#${pr}](${url})`;
+}
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+async function readConfigFile(path, target) {
+    try {
+        const config = JSON.parse(await readFile(path, "utf8"));
+        if (!isPlainObject(config)) {
+            return {
+                error: `${target} config must be a JSON object: ${path}`,
+                exists: true,
+                path,
+                target,
+            };
+        }
+        return { config, exists: true, path, target };
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { exists: false, path, target };
+        }
+        return {
+            error: `${target} config is invalid JSON at ${path}: ${error.message}`,
+            exists: true,
+            path,
+            target,
+        };
+    }
+}
+function formatConfigStatus(status) {
+    if (!status.exists)
+        return `- ${status.target}: missing (${status.path})`;
+    if (status.error)
+        return `- ${status.target}: invalid (${status.path})`;
+    return `- ${status.target}: found (${status.path})`;
+}
+export async function validateMagiConfigFiles(directory, options = {}) {
+    const projectPath = join(directory, PROJECT_CONFIG_PATH);
+    const statuses = await Promise.all([
+        readConfigFile(GLOBAL_CONFIG_PATH, "global"),
+        readConfigFile(projectPath, "project"),
+    ]);
+    const existing = statuses.filter((status) => status.exists);
+    const hasProjectConfig = statuses.some((status) => status.target === "project" && status.exists);
+    const errors = statuses
+        .map((status) => status.error)
+        .filter((error) => Boolean(error));
+    const warnings = [];
+    let loadedFrom = "none";
+    if (!existing.length) {
+        errors.push(`No Magi config found. Expected ${GLOBAL_CONFIG_PATH} or ${projectPath}.`);
+    }
+    if (existing.length && !errors.length) {
+        const merged = existing.reduce((config, status) => mergeMagiConfig(config, status.config ?? {}), {});
+        const mergedConfig = merged;
+        const validation = await validateConfig(mergedConfig, {
+            checkAuth: options.checkAuth ?? true,
+            directory,
+            exec: options.exec
+                ? withGitHubApiRetry(options.exec, mergedConfig.github?.apiRetryAttempts ?? 3)
+                : undefined,
+            modelCatalog: options.modelCatalog,
+            requireGithub: hasProjectConfig && Boolean(mergedConfig.agents?.reviewers),
+        });
+        loadedFrom = existing.map((status) => status.path).join(", ");
+        errors.push(...validation.errors);
+        warnings.push(...validation.warnings);
+    }
+    return [
+        `Magi config validation: ${errors.length ? "failed" : "passed"}`,
+        "",
+        "Config files:",
+        ...statuses.map(formatConfigStatus),
+        "",
+        "Effective config:",
+        `- loaded from: ${loadedFrom}`,
+        `- auth checks: ${(options.checkAuth ?? true) ? "enabled" : "disabled"}`,
+        "",
+        "Errors:",
+        ...(errors.length ? errors.map((error) => `- ${error}`) : ["- None"]),
+        "",
+        "Warnings:",
+        ...(warnings.length
+            ? warnings.map((warning) => `- ${warning}`)
+            : ["- None"]),
+    ].join("\n");
+}
+export const MagiPlugin = async ({ client, directory }) => {
+    const exec = createExec(directory);
+    const modelClient = client;
+    const catalogClient = client;
+    let modelCatalogPromise;
+    const sessionOptions = new Map();
+    const runManager = new MagiRunManager({
+        client: modelClient,
+        directory,
+        exec,
+        setSessionOptions: (sessionId, options) => {
+            if (Object.keys(options).length)
+                sessionOptions.set(sessionId, options);
+        },
+    });
+    async function configuredOutputDir() {
+        return loadConfig(directory)
+            .then((loaded) => outputBaseDirs(directory, loaded.config))
+            .catch(() => undefined);
+    }
+    async function modelCatalog() {
+        modelCatalogPromise ??= catalogClient.config
+            ?.providers({ query: { directory } })
+            .then(extractModelCatalog)
+            .catch(() => catalogClient.provider
+            ?.list({ query: { directory } })
+            .then(extractModelCatalog));
+        return modelCatalogPromise;
+    }
+    return {
+        "chat.params": async (input, output) => {
+            const options = sessionOptions.get(input.sessionID);
+            if (options)
+                Object.assign(output.options, options);
+        },
+        "permission.ask": async (input, output) => {
+            const permissionInput = input;
+            const permissionOutput = output;
+            const sessionId = permissionInput.sessionID ?? permissionInput.sessionId;
+            if (typeof sessionId === "string" && runManager.hasSession(sessionId)) {
+                permissionOutput.status = permissionOutput.status ?? "ask";
+            }
+        },
+        event: async (input) => {
+            await runManager.handleEvent(input);
+        },
+        config: async (config) => {
+            config.command = { ...config.command, ...MAGI_COMMANDS };
+        },
+        tool: {
+            magi_merge: tool({
+                description: "Start background Magi merge runs for one or more GitHub pull requests with configured Magi agents.",
+                args: {
+                    prs: tool.schema.string(),
+                    dryRun: tool.schema.boolean().optional(),
+                },
+                async execute(args, context) {
+                    const parsed = parseRunArguments(args.prs, args.dryRun ?? false);
+                    const loaded = await loadConfig(directory);
+                    const retryingExec = withGitHubApiRetry(exec, loaded.config.github?.apiRetryAttempts ?? 3);
+                    const validation = await validateConfig(loaded.config, {
+                        checkAuth: true,
+                        directory,
+                        exec: retryingExec,
+                        modelCatalog: await modelCatalog(),
+                        requireEditor: true,
+                    });
+                    if (!validation.ok)
+                        return JSON.stringify(validation, null, 2);
+                    const repository = resolveRepository(loaded.config);
+                    const states = await mapPool(parsed.prs, repository.concurrency.runs, (pr) => runManager.startMerge({
+                        config: loaded.config,
+                        dryRun: parsed.dryRun,
+                        repository,
+                        pr,
+                        parentSessionId: context.sessionID,
+                        signal: context.abort,
+                    }), { signal: context.abort });
+                    return states
+                        .map((state) => `Started reviewing ${prMarkdownLink(repository, state.pr)}.`)
+                        .join("\n");
+                },
+            }),
+            magi_review: tool({
+                description: "Start background Magi review runs for one or more GitHub pull requests and post the reviews.",
+                args: {
+                    prs: tool.schema.string(),
+                    dryRun: tool.schema.boolean().optional(),
+                },
+                async execute(args, context) {
+                    const parsed = parseRunArguments(args.prs, args.dryRun ?? false);
+                    const loaded = await loadConfig(directory);
+                    const retryingExec = withGitHubApiRetry(exec, loaded.config.github?.apiRetryAttempts ?? 3);
+                    const validation = await validateConfig(loaded.config, {
+                        checkAuth: true,
+                        directory,
+                        exec: retryingExec,
+                        modelCatalog: await modelCatalog(),
+                    });
+                    if (!validation.ok)
+                        return JSON.stringify(validation, null, 2);
+                    const repository = resolveRepository(loaded.config);
+                    const states = await mapPool(parsed.prs, repository.concurrency.runs, (pr) => runManager.startReview({
+                        config: loaded.config,
+                        dryRun: parsed.dryRun,
+                        repository,
+                        pr,
+                        parentSessionId: context.sessionID,
+                        signal: context.abort,
+                    }), { signal: context.abort });
+                    return states
+                        .map((state) => `Started reviewing ${prMarkdownLink(repository, state.pr)}.`)
+                        .join("\n");
+                },
+            }),
+            magi_status: tool({
+                description: "Show Magi background run status. Optionally filter by runId or PR and wait for completion.",
+                args: {
+                    runId: tool.schema.string().optional(),
+                    pr: tool.schema.string().optional(),
+                    block: tool.schema.boolean().optional(),
+                    timeoutSeconds: tool.schema.number().optional(),
+                    verbose: tool.schema.boolean().optional(),
+                },
+                async execute(args) {
+                    const states = await runManager.status({
+                        block: args.block,
+                        outputDir: await configuredOutputDir(),
+                        pr: parseOptionalPr(args.pr),
+                        runId: args.runId,
+                        timeoutMs: args.timeoutSeconds == null
+                            ? undefined
+                            : args.timeoutSeconds * 1_000,
+                    });
+                    return runManager.formatStatesWithReports(states, {
+                        verbose: args.verbose ?? false,
+                    });
+                },
+            }),
+            magi_output: tool({
+                description: "Show artifacts and details for a Magi background run by runId or PR, optionally for a single reviewer.",
+                args: {
+                    runId: tool.schema.string().optional(),
+                    pr: tool.schema.string().optional(),
+                    reviewer: tool.schema.string().optional(),
+                },
+                async execute(args) {
+                    if (!args.runId && !args.pr)
+                        return "Specify runId or pr.";
+                    const outputDir = await configuredOutputDir();
+                    if (outputDir)
+                        await runManager.status({ outputDir });
+                    return runManager.output({
+                        outputDir,
+                        pr: parseOptionalPr(args.pr),
+                        reviewer: args.reviewer,
+                        runId: args.runId,
+                    });
+                },
+            }),
+            magi_cancel: tool({
+                description: "Cancel a Magi background run by runId or PR.",
+                args: {
+                    runId: tool.schema.string().optional(),
+                    pr: tool.schema.string().optional(),
+                },
+                async execute(args) {
+                    if (!args.runId && !args.pr)
+                        return "Specify runId or pr.";
+                    const outputDir = await configuredOutputDir();
+                    if (outputDir)
+                        await runManager.status({ outputDir });
+                    const pr = parseOptionalPr(args.pr);
+                    const state = await runManager.cancel({
+                        outputDir,
+                        pr,
+                        runId: args.runId,
+                    });
+                    if (!state) {
+                        return args.runId
+                            ? `Magi run not found: ${args.runId}`
+                            : `Magi run not found for PR #${pr}`;
+                    }
+                    return runManager.formatStates([state]);
+                },
+            }),
+            magi_clear: tool({
+                description: "Clear all inactive Magi runs by deleting configured sessions, worktrees, branches, and output artifacts.",
+                args: {
+                    runId: tool.schema.string().optional(),
+                    pr: tool.schema.string().optional(),
+                    branch: tool.schema.enum(["true", "false"]).optional(),
+                    output: tool.schema.enum(["true", "false"]).optional(),
+                    session: tool.schema.enum(["true", "false"]).optional(),
+                    worktree: tool.schema.enum(["true", "false"]).optional(),
+                },
+                async execute(args) {
+                    const loaded = await loadConfig(directory).catch(() => undefined);
+                    const clear = loaded?.config.clear;
+                    const useConfiguredDefaults = hasDefaultedFalseClearFlags(args);
+                    const options = {
+                        branch: (useConfiguredDefaults
+                            ? undefined
+                            : clearToolFlag(args.branch)) ?? clearFlag(clear?.branch),
+                        output: (useConfiguredDefaults
+                            ? undefined
+                            : clearToolFlag(args.output)) ?? clearFlag(clear?.output),
+                        session: (useConfiguredDefaults
+                            ? undefined
+                            : clearToolFlag(args.session)) ?? clearFlag(clear?.session),
+                        worktree: (useConfiguredDefaults
+                            ? undefined
+                            : clearToolFlag(args.worktree)) ?? clearFlag(clear?.worktree),
+                    };
+                    return runManager.clear({
+                        options,
+                        outputDir: loaded
+                            ? outputBaseDirs(directory, loaded.config)
+                            : undefined,
+                        pr: parseOptionalPr(args.pr),
+                        runId: args.runId,
+                        worktreeDir: loaded
+                            ? worktreeBaseDirs(directory, loaded.config)
+                            : undefined,
+                    });
+                },
+            }),
+            magi_permission_reply: tool({
+                description: "Reply to a pending Magi child-agent permission request by runId or PR.",
+                args: {
+                    runId: tool.schema.string().optional(),
+                    pr: tool.schema.string().optional(),
+                    agent: tool.schema.string().optional(),
+                    reviewer: tool.schema.string().optional(),
+                    requestId: tool.schema.string().optional(),
+                    reply: tool.schema.string(),
+                },
+                async execute(args) {
+                    if (!args.runId && !args.pr)
+                        return "Specify runId or pr.";
+                    if (!["always", "once", "reject"].includes(args.reply)) {
+                        return "reply must be once, always, or reject.";
+                    }
+                    const outputDir = await configuredOutputDir();
+                    if (outputDir)
+                        await runManager.status({ outputDir });
+                    return runManager.replyPermission({
+                        agent: args.agent ?? args.reviewer,
+                        outputDir,
+                        pr: parseOptionalPr(args.pr),
+                        reply: args.reply,
+                        requestId: args.requestId,
+                        runId: args.runId,
+                    });
+                },
+            }),
+            magi_question_reply: tool({
+                description: "Reply to a pending Magi child-agent question request by runId or PR.",
+                args: {
+                    runId: tool.schema.string().optional(),
+                    pr: tool.schema.string().optional(),
+                    agent: tool.schema.string().optional(),
+                    reviewer: tool.schema.string().optional(),
+                    requestId: tool.schema.string().optional(),
+                    answers: tool.schema.string(),
+                },
+                async execute(args) {
+                    if (!args.runId && !args.pr)
+                        return "Specify runId or pr.";
+                    const outputDir = await configuredOutputDir();
+                    if (outputDir)
+                        await runManager.status({ outputDir });
+                    return runManager.replyQuestion({
+                        agent: args.agent ?? args.reviewer,
+                        answers: parseQuestionAnswers(args.answers),
+                        outputDir,
+                        pr: parseOptionalPr(args.pr),
+                        requestId: args.requestId,
+                        runId: args.runId,
+                    });
+                },
+            }),
+            magi_question_reject: tool({
+                description: "Reject a pending Magi child-agent question request by runId or PR.",
+                args: {
+                    runId: tool.schema.string().optional(),
+                    pr: tool.schema.string().optional(),
+                    agent: tool.schema.string().optional(),
+                    reviewer: tool.schema.string().optional(),
+                    requestId: tool.schema.string().optional(),
+                },
+                async execute(args) {
+                    if (!args.runId && !args.pr)
+                        return "Specify runId or pr.";
+                    const outputDir = await configuredOutputDir();
+                    if (outputDir)
+                        await runManager.status({ outputDir });
+                    return runManager.rejectQuestion({
+                        agent: args.agent ?? args.reviewer,
+                        outputDir,
+                        pr: parseOptionalPr(args.pr),
+                        requestId: args.requestId,
+                        runId: args.runId,
+                    });
+                },
+            }),
+            magi_validate: tool({
+                description: "Validate global and project Magi config presence, merged settings, reviewer rules, model IDs, and GitHub authentication.",
+                args: {
+                    checkAuth: tool.schema.boolean().optional(),
+                },
+                async execute(args) {
+                    return validateMagiConfigFiles(directory, {
+                        checkAuth: args.checkAuth ?? true,
+                        exec,
+                        modelCatalog: await modelCatalog(),
+                    });
+                },
+            }),
+        },
+    };
+};
+export default MagiPlugin;

package/dist/orchestrator/abort.js

@@ -0,0 +1,9 @@
+export function throwIfAborted(signal) {
+    signal?.throwIfAborted();
+}
+export function withAbortSignal(exec, signal) {
+    return async (command, options) => {
+        throwIfAborted(signal);
+        return exec(command, { ...options, signal: options?.signal ?? signal });
+    };
+}