opencode-magi 0.0.0-dev-20260519011027

package/dist/orchestrator/model.js

@@ -0,0 +1,202 @@
+import { repairPrompt } from "../prompts/contracts";
+import { throwIfAborted } from "./abort";
+const OPENCODE_PERMISSION_NAMES = [
+    "read",
+    "edit",
+    "glob",
+    "grep",
+    "list",
+    "bash",
+    "task",
+    "external_directory",
+    "todowrite",
+    "question",
+    "webfetch",
+    "websearch",
+    "repo_clone",
+    "repo_overview",
+    "lsp",
+    "doom_loop",
+    "skill",
+];
+function formatError(value) {
+    if (value instanceof Error)
+        return value.message;
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+export function toOpenCodePermissionRules(permission) {
+    if (!permission)
+        return undefined;
+    if (typeof permission === "string") {
+        return OPENCODE_PERMISSION_NAMES.map((name) => ({
+            action: permission,
+            pattern: "*",
+            permission: name,
+        }));
+    }
+    const rules = [];
+    for (const [name, value] of Object.entries(permission)) {
+        if (typeof value === "string") {
+            rules.push({ action: value, pattern: "*", permission: name });
+            continue;
+        }
+        for (const [pattern, action] of Object.entries(value)) {
+            rules.push({ action, pattern, permission: name });
+        }
+    }
+    return rules;
+}
+function modelBody(model) {
+    const [providerID, ...modelParts] = model.split("/");
+    if (!providerID || !modelParts.length)
+        return model;
+    return { modelID: modelParts.join("/"), providerID };
+}
+function extractSessionId(result) {
+    const data = result;
+    if (data.error) {
+        const status = data.response?.status
+            ? ` (${data.response.status}${data.response.statusText ? ` ${data.response.statusText}` : ""})`
+            : "";
+        throw new Error(`OpenCode session.create failed${status}: ${formatError(data.error)}`);
+    }
+    const id = data.data?.id ?? data.id;
+    if (!id)
+        throw new Error("OpenCode session.create did not return a session id");
+    return id;
+}
+function extractText(result, allowEmpty = false) {
+    const data = result;
+    const parts = data.data?.parts ?? data.parts;
+    const text = data.data?.info?.text ??
+        data.info?.text ??
+        parts
+            ?.filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .filter((value) => value != null)
+            .join("\n");
+    if (text == null || (!allowEmpty && !text))
+        throw new Error("OpenCode session.prompt did not return text output");
+    return text;
+}
+export async function createModelSession(input) {
+    return extractSessionId(await input.client.session.create({
+        body: {
+            permission: toOpenCodePermissionRules(input.permission),
+            title: input.title,
+        },
+    }));
+}
+export async function promptModelText(input) {
+    throwIfAborted(input.signal);
+    const result = await input.client.session.prompt({
+        body: {
+            model: modelBody(input.model),
+            parts: [{ type: "text", text: input.prompt }],
+        },
+        path: { id: input.sessionId },
+    });
+    throwIfAborted(input.signal);
+    return extractText(result, input.allowEmpty);
+}
+async function sendPrompt(client, sessionId, model, prompt, signal) {
+    return promptModelText({ client, model, prompt, sessionId, signal });
+}
+export async function runModelText(input) {
+    throwIfAborted(input.signal);
+    const sessionId = await createModelSession({
+        client: input.client,
+        permission: input.permission,
+        title: input.title,
+    });
+    await input.onProgress?.({
+        options: input.options,
+        runAttempt: 1,
+        sessionId,
+        type: "session_created",
+    });
+    if (input.initialPrompt?.trim()) {
+        await promptModelText({
+            client: input.client,
+            model: input.model,
+            prompt: input.initialPrompt,
+            sessionId,
+            signal: input.signal,
+        });
+    }
+    const raw = await promptModelText({
+        allowEmpty: input.allowEmpty,
+        client: input.client,
+        model: input.model,
+        prompt: input.prompt,
+        sessionId,
+        signal: input.signal,
+    });
+    await input.onProgress?.({ raw, runAttempt: 1, sessionId, type: "response" });
+    return { raw, sessionId };
+}
+export async function runModelWithRepair(input) {
+    throwIfAborted(input.signal);
+    const runAttempts = Math.max(1, Math.floor(input.runAttempts ?? 2));
+    let lastError;
+    for (let runAttempt = 1; runAttempt <= runAttempts; runAttempt += 1) {
+        throwIfAborted(input.signal);
+        const sessionId = runAttempt === 1 && input.sessionId
+            ? input.sessionId
+            : extractSessionId(await input.client.session.create({
+                body: {
+                    permission: toOpenCodePermissionRules(input.permission),
+                    title: input.title,
+                },
+            }));
+        await input.onProgress?.({
+            options: input.options,
+            runAttempt,
+            sessionId,
+            type: "session_created",
+        });
+        try {
+            let raw = await sendPrompt(input.client, sessionId, input.model, input.prompt, input.signal);
+            await input.onProgress?.({ raw, runAttempt, sessionId, type: "response" });
+            for (let attempt = 0; attempt <= input.repairAttempts; attempt += 1) {
+                throwIfAborted(input.signal);
+                try {
+                    return { raw, sessionId, value: input.parse(raw) };
+                }
+                catch (error) {
+                    lastError = error;
+                    if (attempt === input.repairAttempts)
+                        throw error;
+                    await input.onProgress?.({
+                        attempt: attempt + 1,
+                        runAttempt,
+                        sessionId,
+                        type: "repair",
+                    });
+                    raw = await sendPrompt(input.client, sessionId, input.model, repairPrompt(input.schemaName), input.signal);
+                    await input.onProgress?.({
+                        raw,
+                        runAttempt,
+                        sessionId,
+                        type: "response",
+                    });
+                }
+            }
+        }
+        catch (error) {
+            lastError = error;
+            if (runAttempt === runAttempts)
+                throw error;
+        }
+    }
+    throw lastError instanceof Error
+        ? lastError
+        : new Error("unreachable model retry state");
+}

package/dist/orchestrator/pool.js

@@ -0,0 +1,15 @@
+export async function mapPool(items, limit, worker, options = {}) {
+    const concurrency = Math.max(1, Math.floor(limit));
+    const results = Array.from({ length: items.length });
+    let nextIndex = 0;
+    async function runWorker() {
+        while (nextIndex < items.length) {
+            options.signal?.throwIfAborted();
+            const index = nextIndex;
+            nextIndex += 1;
+            results[index] = await worker(items[index], index);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => runWorker()));
+    return results;
+}

package/dist/orchestrator/report.js

@@ -0,0 +1,168 @@
+import { formatSafetyGateReport } from "./safety";
+function reportUrl(value) {
+    const trimmed = value?.trim();
+    if (!trimmed || trimmed.startsWith("skipped:"))
+        return undefined;
+    if (!/^https?:\/\//.test(trimmed))
+        return undefined;
+    return trimmed;
+}
+function linkOrText(text, url) {
+    return url ? `[${text}](${url})` : text;
+}
+function formatFinding(finding) {
+    const line = finding.startLine == null
+        ? `${finding.path}:${finding.line}`
+        : `${finding.path}:${finding.startLine}-${finding.line}`;
+    return `\`${line}\`: ${finding.issue}`;
+}
+function formatRereviewFinding(finding) {
+    const line = finding.startLine == null
+        ? `${finding.path}:${finding.line}`
+        : `${finding.path}:${finding.startLine}-${finding.line}`;
+    return `\`${line}\`: ${finding.body}`;
+}
+function isReviewOutput(output) {
+    return "findings" in output;
+}
+function discardedByReviewer(discarded) {
+    const grouped = {};
+    for (const item of discarded ?? []) {
+        grouped[item.reviewer] = [...(grouped[item.reviewer] ?? []), item.finding];
+    }
+    return grouped;
+}
+function checkLines(reports) {
+    const failures = reports.flatMap((report) => [
+        ...report.scopeInside.map((item) => ({
+            name: item.check.name,
+            reason: item.reason,
+        })),
+        ...report.scopeOutsideUnresolved.map((item) => ({
+            name: item.check.name,
+            reason: item.reason,
+        })),
+        ...(report.dryRunRerun ?? []).map((item) => ({
+            name: item.check.name,
+            reason: `Dry run would rerun scope-out job: ${item.reason}`,
+        })),
+    ]);
+    if (!failures.length)
+        return ["- **Check**: Pass"];
+    return [
+        "- **Check**: Failure",
+        ...failures.map((failure) => `  - **${failure.name}**: ${failure.reason}`),
+    ];
+}
+function dryRunLines(dryRun) {
+    return dryRun ? ["- **Dry run**: GitHub write operations were skipped"] : [];
+}
+function safetyLines(safety) {
+    return safety ? formatSafetyGateReport(safety).split("\n") : [];
+}
+function reviewerStatus(output, url) {
+    if (output.verdict === "MERGE")
+        return "Approved";
+    if (output.verdict === "CLOSE")
+        return linkOrText("Closed", url);
+    return linkOrText("Changes requested", url);
+}
+function reviewerDetailLines(output) {
+    if (isReviewOutput(output)) {
+        if (output.verdict === "CLOSE")
+            return output.reason ? [output.reason] : [];
+        if (output.verdict !== "CHANGES_REQUESTED")
+            return [];
+        return output.findings.map(formatFinding);
+    }
+    if (output.verdict === "CLOSE")
+        return output.reason ? [output.reason] : [];
+    if (output.verdict !== "CHANGES_REQUESTED")
+        return [];
+    return [
+        ...output.newFindings.map(formatRereviewFinding),
+        ...output.followUps.map((item) => `Comment #${item.commentId}: ${item.body}`),
+    ];
+}
+function reviewerLines(input) {
+    const discarded = discardedByReviewer(input.discardedFindings);
+    const lines = ["- **Reviewer**:"];
+    for (const reviewer of input.repository.agents.reviewers) {
+        const output = input.outputs[reviewer.key];
+        const url = reportUrl(input.posted[reviewer.key]);
+        if (!output) {
+            lines.push(`  - **${reviewer.key}**: Skipped`);
+            continue;
+        }
+        lines.push(`  - **${reviewer.key}**: ${reviewerStatus(output, url)}`);
+        for (const detail of reviewerDetailLines(output)) {
+            lines.push(`    - ${detail}`);
+        }
+        for (const finding of discarded[reviewer.key] ?? []) {
+            lines.push(`    - ~~${formatFinding(finding)}~~`);
+        }
+    }
+    return lines;
+}
+function mergeStatusLines(status) {
+    switch (status) {
+        case "merged":
+            return ["- **Status**: Merged"];
+        case "closed":
+            return ["- **Status**: Closed"];
+        case "approved":
+            return ["- **Status**: Approved"];
+        case "close_requested":
+            return ["- **Status**: Close requested"];
+        case "dequeued":
+            return ["- **Status**: Failed", "  - Removed from GitHub merge queue."];
+        case "ci_unresolved":
+            return ["- **Status**: Failed", "  - CI remained unresolved."];
+        case "safety_blocked":
+            return ["- **Status**: Safety blocked"];
+        case "changes_unresolved":
+            return [
+                "- **Status**: Failed",
+                "  - Changes remained unresolved after the per-thread resolution attempt limit.",
+            ];
+    }
+}
+function editorLines(outputs) {
+    if (!outputs?.length)
+        return [];
+    return [
+        "- **Editor**:",
+        ...outputs.flatMap((output, index) => {
+            const label = `  - Cycle ${index + 1}`;
+            if (output.mode === "REPLIED") {
+                return [
+                    `${label}: replied without code changes`,
+                    ...output.responses.map((response) => `    - ${response.action} comment #${response.commentId}: ${response.body}`),
+                ];
+            }
+            return [
+                `${label}: ${output.commitMessage} (${output.commitSha?.slice(0, 7)})`,
+                ...output.filesTouched.map((file) => `    - ${file}`),
+                ...output.responses.map((response) => `    - ${response.action} comment #${response.commentId}: ${response.body}`),
+            ];
+        }),
+    ];
+}
+export function formatReviewReport(input) {
+    return [
+        ...dryRunLines(input.dryRun),
+        ...safetyLines(input.safety),
+        ...checkLines(input.ciReports),
+        ...reviewerLines(input),
+    ].join("\n");
+}
+export function formatMergeReport(input) {
+    return [
+        ...mergeStatusLines(input.status),
+        ...dryRunLines(input.dryRun),
+        ...safetyLines(input.safety),
+        ...checkLines(input.ciReports),
+        ...reviewerLines(input),
+        ...editorLines(input.editorOutputs),
+    ].join("\n");
+}