opencode-magi 0.10.0 → 0.11.0

package/dist/magi.js

@@ -0,0 +1,357 @@
+import { createOpencodeClient } from "@opencode-ai/sdk/v2";
+import { print } from "graphql";
+import { randomUUID } from "node:crypto";
+import { appendFile, mkdir, readdir, readFile, writeFile, } from "node:fs/promises";
+import { dirname, isAbsolute, join } from "node:path";
+import { Octokit } from "octokit";
+import { getConfig, resolvePermissions, validateConfig } from "@/config";
+import { graphql } from "@/graphql";
+import { command, createExec, filterEmpty, isArray, isNumber, isObject, isUndefined, merge, quote, rm, } from "@/utils";
+const active = new Set(["preparing", "running"]);
+export class MagiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = "MagiError";
+    }
+}
+export class Magi {
+    input;
+    options;
+    exec;
+    constructor(input, options) {
+        const client = createOpencodeClient({
+            baseUrl: input.serverUrl.toString(),
+            directory: input.directory,
+            fetch: input.client.session._client.getConfig().fetch,
+        });
+        this.input = { ...input, client };
+        this.options = options;
+        this.exec = createExec(input.directory);
+    }
+    getGhToken(account, signal) {
+        return this.exec(command("gh", "auth", "token", account && "--user", account && quote(account)), { signal });
+    }
+    async createOctokit(config, signal, account) {
+        const auth = await this.getGhToken(account, signal);
+        const retries = config.github.retryApiAttempts;
+        return new Octokit({
+            auth,
+            request: { signal },
+            retry: { retries },
+            throttle: {
+                onRateLimit(_, options) {
+                    if (options.request.retryCount < retries)
+                        return true;
+                },
+                onSecondaryRateLimit(_, options) {
+                    if (options.request.retryCount < retries)
+                        return true;
+                },
+            },
+        });
+    }
+    createGraphql(octokit) {
+        return graphql((document, variables) => octokit.graphql(print(document), variables));
+    }
+    async clear(config) {
+        const summary = {
+            branch: 0,
+            output: 0,
+            run: 0,
+            session: 0,
+            skipped: 0,
+            worktree: 0,
+        };
+        const states = await this.getStates(config);
+        for (const state of states) {
+            if (active.has(state.status)) {
+                summary.skipped += 1;
+                continue;
+            }
+            if (config.clear.session)
+                summary.session += await this.deleteSessions(state);
+            if (config.clear.worktree && state.worktree?.path)
+                summary.worktree += await this.deleteWorktree(state.worktree.path);
+            if (config.clear.branch && state.worktree?.branch)
+                summary.branch += await this.deleteBranch(state.worktree.branch);
+            if (config.clear.output && state.output)
+                summary.output += await this.deleteOutput(state.output);
+            summary.run += 1;
+        }
+        return summary;
+    }
+    getPath(value) {
+        return isAbsolute(value) ? value : join(this.input.directory, value);
+    }
+    async getConfig(require) {
+        const config = await getConfig(this.input);
+        const errors = await validateConfig(config, { exec: this.exec, require });
+        if (errors.length)
+            throw new Error(errors.join("\n"));
+        return config;
+    }
+    async getStates(config) {
+        const files = await Promise.all([
+            this.getStateFiles(config.review.output),
+            this.getStateFiles(config.triage.output),
+        ]);
+        return Promise.all(files
+            .flat()
+            .map(async (file) => JSON.parse(await readFile(file, "utf8"))));
+    }
+    async getState(dir) {
+        return JSON.parse(await readFile(join(dir, "state.json"), "utf8"));
+    }
+    async getStateFiles(dir) {
+        try {
+            const entries = await readdir(this.getPath(dir), {
+                recursive: true,
+                withFileTypes: true,
+            });
+            return entries
+                .filter((entry) => entry.isFile() && entry.name === "state.json")
+                .map((entry) => join(entry.parentPath, entry.name));
+        }
+        catch {
+            return [];
+        }
+    }
+    getAgents(state) {
+        return filterEmpty([
+            state.editor,
+            state.creator,
+            state.operator,
+            ...Object.values(state.reviewers ?? {}),
+            ...Object.values(state.voters ?? {}),
+        ]);
+    }
+    async createState(dir, initialState) {
+        const id = `run-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+        const createdAt = new Date().toISOString();
+        const state = {
+            createdAt,
+            id,
+            output: join(this.getPath(dir), id),
+            status: "preparing",
+            updatedAt: createdAt,
+            ...initialState,
+        };
+        await this.createStateFile(state);
+        return state;
+    }
+    async createStateFile(state) {
+        await mkdir(state.output, { recursive: true });
+        await writeFile(join(state.output, "state.json"), `${JSON.stringify(state, null, 2)}\n`);
+    }
+    async createAgentFile(output, phase, id, content, attempt = 1, cycle) {
+        const segments = [id, phase];
+        if (isNumber(cycle))
+            segments.push(cycle.toString());
+        if (isNumber(attempt))
+            segments.push(attempt.toString());
+        const path = join(output, segments.join("-") + ".md");
+        await writeFile(path, content);
+    }
+    async updateState(dir, next) {
+        next.updatedAt = new Date().toISOString();
+        const prev = await this.getState(dir);
+        const state = merge(prev, next);
+        await this.createStateFile(state);
+        return state;
+    }
+    async updateEvent(output, message) {
+        const event = {
+            createdAt: new Date().toISOString(),
+            message,
+        };
+        await appendFile(join(output, "events.jsonl"), `${JSON.stringify(event)}\n`);
+    }
+    async getEvents(output) {
+        try {
+            const content = await readFile(join(output, "events.jsonl"), "utf8");
+            return content
+                .split("\n")
+                .filter(Boolean)
+                .map((line) => JSON.parse(line));
+        }
+        catch (e) {
+            if (e instanceof Error && "code" in e && e.code === "ENOENT")
+                return [];
+            throw e;
+        }
+    }
+    getSessionIds(state) {
+        return [
+            state.sessionId,
+            ...filterEmpty(this.getAgents(state).map(({ sessionId }) => sessionId)),
+        ];
+    }
+    async createSession(parentID, title, { model, permissions, }, signal) {
+        if (isArray(model) || !isObject(model))
+            throw new Error();
+        const { id, variant } = model;
+        const [providerId, modelId] = id.split("/");
+        const result = await this.input.client.session.create({
+            model: {
+                id: modelId,
+                providerID: providerId,
+                variant,
+            },
+            parentID,
+            permission: resolvePermissions(permissions),
+            title,
+        }, { signal });
+        if (result.error) {
+            if (!isUndefined(result.response) && result.response.statusText)
+                throw new Error(result.response.statusText);
+            else if (result.error instanceof Error)
+                throw new Error(result.error.message);
+            else
+                throw new Error(JSON.stringify(result.error));
+        }
+        else {
+            const id = result.data.id;
+            return id;
+        }
+    }
+    async promptSession(sessionID, text, signal) {
+        const controller = new AbortController();
+        const events = await this.input.client.event.subscribe(undefined, {
+            signal: controller.signal,
+        });
+        try {
+            const result = await Promise.race([
+                this.input.client.session.prompt({
+                    parts: [{ text, type: "text" }],
+                    sessionID,
+                }, { signal }),
+                this.monitorSession(sessionID, events.stream),
+            ]);
+            if (result.error) {
+                if (!isUndefined(result.response) && result.response.statusText)
+                    throw new Error(result.response.statusText);
+                else if (result.error instanceof Error)
+                    throw new Error(result.error.message);
+                else
+                    throw new Error(JSON.stringify(result.error));
+            }
+            else {
+                const output = result.data.parts
+                    .filter((part) => part.type === "text")
+                    .map((part) => part.text)
+                    .join("\n");
+                if (!output)
+                    throw new Error("OpenCode session.prompt did not return text output.");
+                return output;
+            }
+        }
+        catch (e) {
+            if (e instanceof MagiError)
+                await this.input.client.session.abort({ sessionID });
+            throw e;
+        }
+        finally {
+            controller.abort();
+        }
+    }
+    async monitorSession(sessionID, events) {
+        for await (const ev of events) {
+            if (ev.type === "permission.asked" &&
+                ev.properties.sessionID === sessionID) {
+                const { id, patterns, permission } = ev.properties;
+                const result = await this.input.client.permission.reply({
+                    reply: "reject",
+                    requestID: id,
+                });
+                if (result.error)
+                    throw new MagiError("blocked", "Could not reject permission request.");
+                throw new MagiError("blocked", `OpenCode session requested ${permission} permission for ${patterns.join(", ")}.`);
+            }
+            if (ev.type === "question.asked" &&
+                ev.properties.sessionID === sessionID) {
+                const result = await this.input.client.question.reject({
+                    requestID: ev.properties.id,
+                });
+                if (result.error)
+                    throw new MagiError("blocked", "Could not reject user question.");
+                throw new MagiError("blocked", "OpenCode session requested user input.");
+            }
+        }
+        return new Promise(() => { });
+    }
+    async deleteSessions(state) {
+        const sessionIds = this.getSessionIds(state);
+        let count = 0;
+        for (const sessionID of sessionIds)
+            try {
+                await this.input.client.session.delete({ sessionID });
+                count += 1;
+            }
+            catch { }
+        return count;
+    }
+    async createWorktree(dir, number, id, signal) {
+        const path = this.getPath(join(dir, number.toString(), id));
+        try {
+            await mkdir(dirname(path), { recursive: true });
+            await this.exec(command("git", "worktree", "add", "--detach", quote(path)), { signal });
+            await this.exec(command("gh", "pr", "checkout", number, "--detach"), {
+                cwd: path,
+                signal,
+            });
+            const branch = await this.exec("git branch --show-current", {
+                cwd: path,
+                signal,
+            });
+            return { branch: branch || undefined, path };
+        }
+        catch (e) {
+            try {
+                await this.exec(command("git", "worktree", "remove", "--force", quote(path)));
+                await this.exec(command("git", "worktree", "prune"));
+            }
+            catch { }
+            throw e;
+        }
+    }
+    async deleteWorktree(value) {
+        try {
+            const path = this.getPath(value);
+            await this.exec(command("git", "worktree", "remove", "--force", quote(path)));
+            await rm(path, {
+                force: true,
+                prune: this.input.directory,
+                recursive: true,
+            });
+            return 1;
+        }
+        catch {
+            return 0;
+        }
+    }
+    async deleteBranch(branch) {
+        try {
+            await this.exec(command("git", "branch", "-D", quote(branch)));
+            return 1;
+        }
+        catch {
+            return 0;
+        }
+    }
+    async deleteOutput(path) {
+        try {
+            const resolvedPath = this.getPath(path);
+            await rm(resolvedPath, {
+                force: true,
+                prune: this.input.directory,
+                recursive: true,
+            });
+            return 1;
+        }
+        catch {
+            return 0;
+        }
+    }
+}

package/dist/permissions/common.json

@@ -1,24 +1,24 @@
 {
-    "bash": {
-        "*": "deny",
-        "git status*": "allow",
-        "git diff*": "allow",
-        "git show*": "allow",
-        "git grep*": "allow",
-        "git log*": "allow",
-        "git blame*": "allow",
-        "git ls-files*": "allow",
-        "git rev-parse*": "allow",
-        "git merge-base*": "allow",
-        "rg *": "allow"
-    },
-    "edit": "deny",
-    "glob": "allow",
-    "grep": "allow",
-    "list": "allow",
-    "question": "deny",
-    "read": "allow",
-    "task": "deny",
-    "webfetch": "deny",
-    "websearch": "deny"
+  "bash": {
+    "*": "deny",
+    "git status*": "allow",
+    "git diff*": "allow",
+    "git show*": "allow",
+    "git grep*": "allow",
+    "git log*": "allow",
+    "git blame*": "allow",
+    "git ls-files*": "allow",
+    "git rev-parse*": "allow",
+    "git merge-base*": "allow",
+    "rg *": "allow"
+  },
+  "edit": "deny",
+  "glob": "allow",
+  "grep": "allow",
+  "list": "allow",
+  "question": "deny",
+  "read": "allow",
+  "task": "deny",
+  "webfetch": "deny",
+  "websearch": "deny"
 }

package/dist/permissions/editor.json

@@ -1,14 +1,14 @@
 {
-    "bash": {
-        "bun *": "allow",
-        "bunx *": "allow",
-        "corepack *": "allow",
-        "git add*": "allow",
-        "git commit*": "allow",
-        "npm *": "allow",
-        "npx *": "allow",
-        "pnpm *": "allow",
-        "yarn *": "allow"
-    },
-    "edit": "allow"
+  "bash": {
+    "bun *": "allow",
+    "bunx *": "allow",
+    "corepack *": "allow",
+    "git add*": "allow",
+    "git commit*": "allow",
+    "npm *": "allow",
+    "npx *": "allow",
+    "pnpm *": "allow",
+    "yarn *": "allow"
+  },
+  "edit": "allow"
 }

package/dist/prompts/index.js

@@ -0,0 +1,98 @@
+import Ajv from "ajv";
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { isString, isUndefined } from "@/utils";
+export class Prompt {
+    magi;
+    config;
+    pathname;
+    validateSchema;
+    constructor(magi, config, pathname, validateSchema) {
+        this.magi = magi;
+        this.config = config;
+        this.pathname = pathname;
+        this.validateSchema = validateSchema;
+    }
+    static async init(magi, config, dir) {
+        const url = new URL(dir, import.meta.url);
+        let validateSchema;
+        try {
+            validateSchema = JSON.parse(await readFile(join(url.pathname, "validate.json"), "utf-8"));
+        }
+        catch { }
+        return new Prompt(magi, config, url.pathname, validateSchema);
+    }
+    async create(taskPath, tags, values) {
+        const [task, ...rest] = await Promise.all([
+            readFile(taskPath ? this.magi.getPath(taskPath) : join(this.pathname, "task.md"), "utf-8"),
+            ...tags.map(async (tag) => {
+                if (isString(tag)) {
+                    const path = join(this.pathname, `${tag.replaceAll("_", "-")}.md`);
+                    const content = await readFile(path, "utf-8");
+                    return { content, tag };
+                }
+                else {
+                    return { content: tag[1], tag: tag[0] };
+                }
+            }),
+        ]);
+        const content = [
+            `<task>\n${task}\n</task>`,
+            `<language>\n${this.config.language}\n</language>`,
+            ...rest.map(({ content, tag }) => `<${tag}>\n${content}\n</${tag}>`),
+        ].join("\n\n");
+        return Object.entries(values).reduce((prev, [key, value]) => prev.replaceAll(`{${key}}`, value), content);
+    }
+    async repair(e) {
+        const instructions = [
+            "Your previous output failed validation. Regenerate the result.",
+            !isUndefined(e)
+                ? `Validation error: ${e instanceof Error ? e.message : "Invalid output."}`
+                : undefined,
+            "Return only a JSON object matching the output contract below. Do not include analysis, explanation, apologies, markdown, or any text before or after the JSON object.",
+        ]
+            .filter((instruction) => !isUndefined(instruction))
+            .join("\n\n");
+        try {
+            const outputContract = await readFile(join(this.pathname, "output-contract.md"), "utf-8");
+            return [
+                instructions,
+                `<output_contract>\n${outputContract}\n</output_contract>`,
+            ].join("\n\n");
+        }
+        catch {
+            return instructions;
+        }
+    }
+    parse(content) {
+        const trimmed = content.trim();
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            const candidates = [];
+            for (const match of trimmed.matchAll(/```(?:json)?\s*([\s\S]*?)```/gi)) {
+                const candidate = match.at(1)?.trim();
+                if (candidate)
+                    candidates.unshift(candidate);
+            }
+            for (const match of trimmed.matchAll(/\{[\s\S]*?\}/g)) {
+                const candidate = match.at(0);
+                if (candidate)
+                    candidates.unshift(candidate);
+            }
+            for (const candidate of candidates)
+                try {
+                    return JSON.parse(candidate);
+                }
+                catch { }
+        }
+        return {};
+    }
+    validate(content) {
+        if (!this.validateSchema)
+            return true;
+        const validate = new Ajv({ allErrors: true }).compile(this.validateSchema);
+        return Boolean(validate(content));
+    }
+}

package/dist/prompts/merge/ci-classification/output-contract.md

@@ -0,0 +1,22 @@
+Return exactly one JSON object and nothing else. Do not wrap it in markdown.
+
+```json
+{
+  "checks": [
+    {
+      "id": "exact failed check ID",
+      "classification": "SCOPE_IN" | "SCOPE_OUT",
+      "comment": "Short reason."
+    }
+  ]
+}
+```
+
+Rules:
+
+- Return one item for every failed check.
+- `"id"` is the ID of the failed check.
+- `"SCOPE_IN"` means the failure should be treated as caused by the PR changes or the editor changes and passed to reviewers/editor.
+- `"SCOPE_OUT"` means the failure is likely flaky, external, or infrastructure-related and may be rerun.
+- `"comment"` is a short reason for the classification.
+- If uncertain, choose `"SCOPE_IN"`.

package/dist/prompts/merge/ci-classification/task.md

@@ -0,0 +1,10 @@
+Classify failed CI jobs after editor changes for pull request #{pr} in {owner}/{repo}.
+Decide whether each failure is caused by the PR changes or the editor changes, or is likely flaky, external, or infrastructure-related.
+The PR worktree is {worktreePath}.
+Review only the diff from {baseSha} to {headSha}.
+Use: git -C "{worktreePath}" diff {baseSha}...{headSha}
+
+Treat failures that appeared after the editor changes as `"SCOPE_IN"` unless there is strong evidence they are unrelated.
+If uncertain, choose `"SCOPE_IN"`.
+
+Failed checks with structured failure evidence are provided in `<failed_checks>`.

package/dist/prompts/merge/ci-classification/validate.json

@@ -0,0 +1,20 @@
+{
+  "type": "object",
+  "required": ["checks"],
+  "additionalProperties": false,
+  "properties": {
+    "checks": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "classification", "comment"],
+        "additionalProperties": false,
+        "properties": {
+          "id": { "type": "string", "minLength": 1 },
+          "classification": { "enum": ["SCOPE_IN", "SCOPE_OUT"] },
+          "comment": { "type": "string", "minLength": 1 }
+        }
+      }
+    }
+  }
+}

package/dist/prompts/merge/conflict/output-contract.md

@@ -0,0 +1,12 @@
+Return exactly one JSON object and nothing else. Do not wrap it in markdown.
+
+Resolve the conflicts, stage the resolved files, create the merge commit, then return this exact JSON object:
+
+```json
+{}
+```
+
+Rules:
+
+- Do not push. The orchestrator pushes after validating this envelope.
+- Do not include commit metadata, touched files, responses, explanation, or markdown.

package/dist/prompts/merge/conflict/task.md

@@ -0,0 +1,9 @@
+Fix pull request #{pr} for {owner}/{repo}.
+The PR worktree is {worktreePath}.
+
+Act as the PR author and resolve the merge conflicts provided in `<conflicted_files>`.
+
+The worktree is already in the middle of a no-commit merge and contains conflict markers.
+Preserve the intended PR behavior and the already-merged base branch changes.
+Resolve every merge conflict in the worktree, stage changes, and create the merge commit.
+Do not push.

package/dist/prompts/merge/conflict/validate.json

@@ -0,0 +1,4 @@
+{
+  "type": "object",
+  "additionalProperties": false
+}

package/dist/prompts/merge/edit/output-contract.md

@@ -0,0 +1,26 @@
+Return exactly one JSON object and nothing else. Do not wrap it in markdown.
+
+```json
+{
+  "mode": "EDITED" | "REPLIED",
+  "commitSha": "full sha, required only when mode is EDITED; omit when mode is REPLIED",
+  "commitMessage": "fix(scope): short description, required only when mode is EDITED; omit when mode is REPLIED",
+  "filesTouched": ["relative/path.ext"],
+  "responses": [{ "commentId": 123, "action": "FIXED" | "DISAGREE" | "ASK", "body": "Fixed." }]
+}
+```
+
+Rules:
+
+- Use `"EDITED"` only when you edited files, staged changes, and committed.
+- Use `"REPLIED"` when you only replied without code changes.
+- `"FIXED"` means you agreed with the reviewer and made a code change.
+- `"DISAGREE"` means you did not edit because the requested change is incorrect or unnecessary.
+- `"ASK"` means you need clarification and did not edit.
+- Do not make changes just because a reviewer requested them; edit only when you understand and agree.
+- Do not push. The orchestrator pushes after validating this envelope.
+- `filesTouched` is required for `"EDITED"` and must include every final changed file.
+- `responses` is required and must include a reply for each thread you addressed.
+- `"EDITED"` requires at least one response.
+- `"REPLIED"` may omit `filesTouched`. If present, it must be empty.
+- `"REPLIED"` requires at least one `"DISAGREE"` or `"ASK"` response.

package/dist/prompts/merge/edit/task.md

@@ -0,0 +1,10 @@
+Fix pull request #{pr} for {owner}/{repo}.
+The PR worktree is {worktreePath}.
+
+Act as the PR author and address the unresolved review threads provided in `<unresolved_threads>`.
+
+For each thread, decide whether you agree with the reviewer.
+If you understand and agree with the requested change, edit the code, stage changes, commit, and reply with action `"FIXED"` for each related thread.
+If a requested change in a thread is incorrect or unnecessary and you have a clear reason, do not edit for that thread; reply with action `"DISAGREE"` and explain why.
+If you cannot determine whether a threaded request is correct or what change is expected, do not blindly edit; reply with action `"ASK"` and ask a concrete question.
+Do not make changes just because a reviewer requested them. Do not push.