opencode-magi 0.10.0 → 0.12.0

package/dist/prompts/triage/comment-classification/validate.json

@@ -0,0 +1,28 @@
+{
+  "type": "object",
+  "required": ["comments"],
+  "additionalProperties": false,
+  "properties": {
+    "comments": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["commentId", "classification", "reason"],
+        "additionalProperties": false,
+        "properties": {
+          "commentId": { "type": "integer" },
+          "classification": {
+            "enum": [
+              "OBJECTION",
+              "NEW_EVIDENCE",
+              "CLARIFICATION",
+              "ACKNOWLEDGEMENT",
+              "UNRELATED"
+            ]
+          },
+          "reason": { "type": "string", "minLength": 1 }
+        }
+      }
+    }
+  }
+}

package/dist/prompts/triage/create/output-contract.md

@@ -0,0 +1,28 @@
+Return exactly one JSON object and nothing else. Do not wrap it in markdown.
+
+The object must match this shape:
+
+```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"],
+  "pullRequest": {
+    "title": "PR title, required only when mode is EDITED; omit when mode is REPLIED",
+    "body": "PR body, required only when mode is EDITED; omit when mode is REPLIED"
+  },
+  "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.
+- For EDITED, pullRequest.title and pullRequest.body must be non-empty and follow the repository's PR conventions.
+- Do not push or create the PR. The orchestrator pushes and creates the PR using pullRequest exactly as provided.
+- filesTouched is required for EDITED and must include every final changed file.
+- responses may be omitted when no review threads were addressed.
+- REPLIED may omit filesTouched. If present, it must be empty.
+- REPLIED requires at least one DISAGREE or ASK response.

package/dist/prompts/triage/create/validate.json

@@ -0,0 +1,73 @@
+{
+  "type": "object",
+  "required": ["mode"],
+  "additionalProperties": false,
+  "properties": {
+    "mode": { "enum": ["EDITED", "REPLIED"] },
+    "commitSha": { "type": "string", "minLength": 1 },
+    "commitMessage": { "type": "string", "minLength": 1 },
+    "filesTouched": {
+      "type": "array",
+      "items": { "type": "string", "minLength": 1 }
+    },
+    "pullRequest": {
+      "type": "object",
+      "required": ["title", "body"],
+      "additionalProperties": false,
+      "properties": {
+        "title": { "type": "string", "minLength": 1 },
+        "body": { "type": "string", "minLength": 1 }
+      }
+    },
+    "responses": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["commentId", "action", "body"],
+        "additionalProperties": false,
+        "properties": {
+          "commentId": { "type": "integer" },
+          "action": { "enum": ["FIXED", "DISAGREE", "ASK"] },
+          "body": { "type": "string", "minLength": 1 }
+        }
+      }
+    }
+  },
+  "allOf": [
+    {
+      "if": { "properties": { "mode": { "const": "EDITED" } } },
+      "then": {
+        "required": [
+          "commitSha",
+          "commitMessage",
+          "filesTouched",
+          "pullRequest"
+        ],
+        "properties": { "filesTouched": { "type": "array", "minItems": 1 } }
+      }
+    },
+    {
+      "if": { "properties": { "mode": { "const": "REPLIED" } } },
+      "then": {
+        "required": ["responses"],
+        "not": {
+          "anyOf": [
+            { "required": ["commitSha"] },
+            { "required": ["commitMessage"] },
+            { "required": ["pullRequest"] }
+          ]
+        },
+        "properties": {
+          "filesTouched": { "type": "array", "maxItems": 0 },
+          "responses": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "properties": { "action": { "enum": ["DISAGREE", "ASK"] } }
+            }
+          }
+        }
+      }
+    }
+  ]
+}

package/dist/prompts/triage/deplicate/output-contract.md

@@ -0,0 +1,16 @@
+Return exactly one JSON object and nothing else. Do not wrap it in markdown.
+
+The object must match this shape:
+
+```json
+{
+  "vote": "DUPLICATE" | "NOT_DUPLICATE",
+  "duplicateOf": 123,
+  "reason": "Short rationale."
+}
+```
+
+Rules:
+
+- duplicateOf is required only when vote is DUPLICATE.
+- duplicateOf must be one of the provided duplicate candidate issue numbers.

package/dist/prompts/triage/deplicate/validate.json

@@ -0,0 +1,20 @@
+{
+  "type": "object",
+  "required": ["vote", "reason"],
+  "additionalProperties": false,
+  "properties": {
+    "vote": { "enum": ["DUPLICATE", "NOT_DUPLICATE"] },
+    "duplicateOf": { "type": "integer" },
+    "reason": { "type": "string", "minLength": 1 }
+  },
+  "allOf": [
+    {
+      "if": { "properties": { "vote": { "const": "DUPLICATE" } } },
+      "then": { "required": ["duplicateOf"] }
+    },
+    {
+      "if": { "properties": { "vote": { "const": "NOT_DUPLICATE" } } },
+      "then": { "not": { "required": ["duplicateOf"] } }
+    }
+  ]
+}

package/dist/prompts/triage/existing/output-contract.md

@@ -0,0 +1,16 @@
+Return exactly one JSON object and nothing else. Do not wrap it in markdown.
+
+The object must match this shape:
+
+```json
+{
+  "vote": "RELATED_PR_HANDLES_ISSUE" | "RELATED_PR_DOES_NOT_HANDLE_ISSUE",
+  "reason": "Short rationale.",
+  "body": "Required only when vote is ASK. Public issue comment body asking for the missing information."
+}
+```
+
+Rules:
+
+- body is required when vote is ASK and must be written for the issue author.
+- Omit body when vote is not ASK.

package/dist/prompts/triage/existing/validate.json

@@ -0,0 +1,13 @@
+{
+  "type": "object",
+  "required": ["vote", "reason"],
+  "additionalProperties": false,
+  "properties": {
+    "vote": {
+      "enum": ["RELATED_PR_HANDLES_ISSUE", "RELATED_PR_DOES_NOT_HANDLE_ISSUE"]
+    },
+    "reason": { "type": "string", "minLength": 1 },
+    "body": { "type": "string", "minLength": 1 }
+  },
+  "not": { "required": ["body"] }
+}

package/dist/prompts/triage/reconsider/output-contract.md

@@ -0,0 +1,16 @@
+Return exactly one JSON object and nothing else. Do not wrap it in markdown.
+
+The object must match this shape:
+
+```json
+{
+  "vote": "YES" | "NO" | "ASK",
+  "reason": "Short rationale.",
+  "body": "Required only when vote is ASK. Public issue comment body asking for the missing information."
+}
+```
+
+Rules:
+
+- body is required when vote is ASK and must be written for the issue author.
+- Omit body when vote is not ASK.

package/dist/prompts/triage/reconsider/validate.json

@@ -0,0 +1,23 @@
+{
+  "type": "object",
+  "required": ["vote", "reason"],
+  "additionalProperties": false,
+  "properties": {
+    "vote": { "enum": ["YES", "NO", "ASK"] },
+    "reason": { "type": "string", "minLength": 1 },
+    "body": { "type": "string", "minLength": 1 }
+  },
+  "allOf": [
+    {
+      "if": { "properties": { "vote": { "const": "ASK" } } },
+      "then": { "required": ["body"] }
+    },
+    {
+      "if": {
+        "properties": { "vote": { "not": { "const": "ASK" } } },
+        "required": ["vote"]
+      },
+      "then": { "not": { "required": ["body"] } }
+    }
+  ]
+}

package/dist/prompts/triage/signal/output-contract.md

@@ -0,0 +1,19 @@
+Return exactly one JSON object and nothing else. Do not wrap it in markdown.
+
+The object must match this shape:
+
+```json
+{
+  "signals": [
+    {
+      "id": "configured_signal_id",
+      "reason": "Short rationale."
+    }
+  ]
+}
+```
+
+Rules:
+
+- Return only configured signal IDs that apply.
+- Omit `"signals"` when none apply.

package/dist/prompts/triage/signal/validate.json

@@ -0,0 +1,18 @@
+{
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "signals": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "reason"],
+        "additionalProperties": false,
+        "properties": {
+          "id": { "type": "string", "minLength": 1 },
+          "reason": { "type": "string", "minLength": 1 }
+        }
+      }
+    }
+  }
+}

package/dist/tools/clear/index.js

@@ -0,0 +1,21 @@
+import { tool } from "@opencode-ai/plugin";
+export const clear = function (magi) {
+    return {
+        magi_clear: tool({
+            args: {},
+            description: "Clear all inactive Magi runs by deleting configured sessions, worktrees, branches, and output artifacts.",
+            async execute() {
+                const config = await magi.getConfig();
+                const summary = await magi.clear(config);
+                return [
+                    `Cleared Magi runs: ${summary.run}`,
+                    `Skipped active runs: ${summary.skipped}`,
+                    `Sessions deleted: ${summary.session}`,
+                    `Worktrees deleted: ${summary.worktree}`,
+                    `Branches deleted: ${summary.branch}`,
+                    `Outputs deleted: ${summary.output}`,
+                ].join("\n");
+            },
+        }),
+    };
+};

package/dist/tools/index.js

@@ -0,0 +1,12 @@
+import { clear } from "./clear";
+import { merge } from "./merge";
+import { review } from "./review";
+import { triage } from "./triage";
+import { validate } from "./validate";
+export const tools = {
+    clear,
+    merge,
+    review,
+    triage,
+    validate,
+};

package/dist/tools/merge/action.js

@@ -0,0 +1,47 @@
+import { MagiError } from "@/magi";
+import { retry } from "@/utils";
+export async function editCycles(cb) {
+    this.context.abort.throwIfAborted();
+    const error = new Error("Continue edit cycle.");
+    const verdict = await retry(async (cycle) => {
+        const verdict = await cb(cycle);
+        if (verdict === "CHANGES_REQUESTED")
+            throw error;
+        return verdict;
+    }, {
+        error: async (e, count) => {
+            if (e !== error)
+                throw e;
+            await this.updateEvent(`Attempt ${count} failed to edit cycles. Retrying...`);
+        },
+        retries: this.config.merge.maxThreadResolutionCycles,
+        signal: this.context.abort,
+    });
+    if (!verdict || verdict === "CHANGES_REQUESTED")
+        throw new MagiError("blocked", `Reached maximum edit cycles.`);
+}
+export async function postReplies() {
+    this.context.abort.throwIfAborted();
+    if (this.state.dryRun)
+        return;
+    const output = this.state.editor?.outputs?.at(-1);
+    if (!output)
+        throw new MagiError("blocked", "Editor output not found.");
+    if (!output.responses.length)
+        return;
+    await this.updateEvent(`Posting editor replies.`);
+    if (!this.state.editor?.account)
+        throw new MagiError("blocked", "Editor account not found.");
+    const octokit = await this.magi.createOctokit(this.config, this.context.abort, this.state.editor.account);
+    const args = {
+        owner: this.config.github.owner,
+        pull_number: this.number,
+        repo: this.config.github.repo,
+    };
+    await Promise.all(output.responses.map(({ body, commentId }) => octokit.rest.pulls.createReplyForReviewComment({
+        ...args,
+        body,
+        comment_id: commentId,
+    })));
+    await this.updateEvent(`Finished posting editor replies.`);
+}

package/dist/tools/merge/context.js

@@ -0,0 +1,116 @@
+import { MagiError } from "@/magi";
+import { getClosingIssues, getComments, getInlineCommentTargets, getReviewThreads, } from "@/tools/review/context";
+import { marker } from "@/utils";
+export async function fetchMergeContext() {
+    this.context.abort.throwIfAborted();
+    const output = this.state.editor?.outputs?.at(-1);
+    if (!output)
+        throw new MagiError("blocked", "Editor output not found.");
+    await this.updateEvent(`Fetching merge context.`);
+    const [comments, issues, threads] = await Promise.all([
+        getComments.call(this),
+        getClosingIssues.call(this),
+        getReviewThreads.call(this),
+    ]);
+    const inlineCommentTargets = await getInlineCommentTargets.call(this);
+    await this.updateState({
+        pr: {
+            comments,
+            inlineCommentTargets,
+            issues,
+            threads: this.state.dryRun
+                ? addSyntheticReplies.call(this, [
+                    ...createSyntheticThreads.call(this),
+                    ...threads,
+                ])
+                : threads,
+        },
+    });
+    await this.updateEvent(`Finished fetching merge context.`);
+}
+export async function markRepliedReviewers() {
+    this.context.abort.throwIfAborted();
+    await this.updateEvent(`Marking replied reviewers.`);
+    const output = this.state.editor?.outputs?.at(-1);
+    if (!output)
+        throw new MagiError("blocked", "Editor output not found.");
+    if (!this.state.pr?.threads)
+        throw new MagiError("blocked", "PR threads not found.");
+    if (!this.state.reviewers)
+        throw new MagiError("blocked", "Reviewers not found.");
+    const replied = output.responses.flatMap(({ commentId }) => {
+        const thread = this.state.pr.threads.find(({ comments }) => comments.some(({ databaseId }) => databaseId === commentId));
+        if (!thread)
+            return [];
+        if (this.config.mode === "single")
+            return thread.comments
+                .flatMap(({ body }) => marker.parse(body))
+                .flatMap(({ reviewer }) => (reviewer ? [reviewer] : []));
+        return Object.entries(this.state.reviewers)
+            .filter(([, { account }]) => thread.comments.some(({ author }) => account === author?.login))
+            .map(([id]) => id);
+    });
+    if (!replied.length)
+        throw new MagiError("blocked", "No replied reviewers found.");
+    const reviewers = Object.fromEntries(Object.keys(this.state.reviewers).map((id) => [
+        id,
+        { status: replied.includes(id) ? "reply" : "skip" },
+    ]));
+    await this.updateState({ reviewers });
+    await this.updateEvent(`Finished marking replied reviewers.`);
+}
+function createSyntheticThreads() {
+    const findings = Object.entries(this.state.reviewers ?? {}).flatMap(([reviewer, { account, outputs }]) => {
+        const output = outputs?.at(-1);
+        if (output?.verdict !== "CHANGES_REQUESTED")
+            return [];
+        return (output.findings ?? output.newFindings ?? []).map((finding) => ({
+            ...finding,
+            account,
+            reviewer,
+        }));
+    });
+    return findings.map(({ account, body, line, path, reviewer, state }, index) => ({
+        comments: [
+            {
+                author: { login: account ?? reviewer },
+                body: [
+                    body,
+                    marker.stringify({
+                        command: "review",
+                        reviewer,
+                        verdict: "CHANGES_REQUESTED",
+                    }),
+                ].join("\n\n"),
+                createdAt: new Date(0).toISOString(),
+                databaseId: -(index + 1),
+                url: "",
+            },
+        ],
+        id: `dry-run:${reviewer}:${index + 1}`,
+        isResolved: false,
+        line,
+        path,
+        state,
+    }));
+}
+function addSyntheticReplies(threads) {
+    const output = this.state.editor.outputs.at(-1);
+    return threads.map((thread) => ({
+        ...thread,
+        comments: [
+            ...thread.comments,
+            ...output.responses.flatMap(({ body, commentId }, index) => thread.comments.some(({ databaseId }) => databaseId === commentId)
+                ? [
+                    {
+                        author: { login: this.state.editor.account ?? "editor" },
+                        body,
+                        createdAt: new Date().toISOString(),
+                        databaseId: -(threads.length + index + 1),
+                        url: "",
+                    },
+                ]
+                : []),
+        ],
+    }));
+}