opencode-magi 0.0.0-dev-20260727045328 → 0.0.0-dev-20260727095903

package/dist/constant.js

@@ -60,11 +60,7 @@ export const DEFAULT_CONFIG = {
             queue: false,
         },
         output: ".magi/runs/pr",
-        safety: {
-            allowAuthors: [],
-            blockedPaths: [],
-            requiredLabels: [],
-        },
+        safety: [],
         worktree: ".magi/worktrees/pr",
     },
     triage: {

package/dist/tools/merge/index.js

@@ -127,7 +127,7 @@ export const merge = function (magi) {
                                 await run.editCycles(async () => editCycle(run));
                             const automation = await run.automate();
                             if (automation === "CONFLICT" &&
-                                run.config.merge.automation.conflict) {
+                                run.isAutomationEnabled(run.config.merge.automation.conflict)) {
                                 await run.editCycles(async (cycle) => editCycle(run, { conflict: true, cycle }));
                                 await run.automate();
                             }

package/dist/tools/review/action.js

@@ -1,6 +1,7 @@
 import { MagiError } from "@/magi";
 import { Prompt } from "@/prompts";
-import { command, filterEmpty, ignoreError, isArray, isObject, isString, loop, marker, omitNullish, quote, retry, wait, Worker, } from "@/utils";
+import { command, filterEmpty, ignoreError, isArray, isBoolean, isObject, isString, loop, marker, omitNullish, quote, retry, wait, Worker, } from "@/utils";
+import { getConditionErrors } from "./check";
 const events = {
     APPROVED: "APPROVE",
     CHANGES_REQUESTED: "REQUEST_CHANGES",
@@ -181,9 +182,8 @@ export async function automate() {
         throw new MagiError("blocked", "PR verdict not found.");
     if (!["APPROVED", "CLOSED"].includes(this.state.pr.verdict))
         return "SKIPPED";
-    const automation = this.config[this.state.command].automation;
     const action = this.state.pr.verdict === "APPROVED" ? "merge" : "close";
-    if (!automation[action]) {
+    if (!isAutomationEnabled.call(this, this.config[this.state.command].automation[action])) {
         await this.updateState({ pr: { automation: "SKIPPED" } });
         await this.updateEvent(`Skipped ${action} automation.`);
         return "SKIPPED";
@@ -345,6 +345,18 @@ export async function automate() {
     await this.updateEvent(`Finished ${action} automation.`);
     return action === "merge" ? "MERGED" : "CLOSED";
 }
+export function isAutomationEnabled(conditions) {
+    if (isBoolean(conditions))
+        return conditions;
+    const edited = !this.state.dryRun &&
+        this.state.editor?.outputs?.some(({ commitSha }) => !!commitSha);
+    return conditions.every(([expected, condition]) => {
+        const errors = getConditionErrors(condition, this.state.pr.metadata, this.state.pr.files ?? []);
+        const matches = !errors.length &&
+            (!("edited" in condition) || condition.edited === !!edited);
+        return matches === expected;
+    });
+}
 function hasFailedChecks(checks) {
     if (!isArray(checks))
         return false;

package/dist/tools/review/check.js

@@ -1,7 +1,7 @@
 import picomatch from "picomatch";
 import { MagiError } from "@/magi";
 import { Prompt } from "@/prompts";
-import { command, filterEmpty, isNumber, omitNullish, quote, retry, Worker, } from "@/utils";
+import { command, filterEmpty, isBoolean, isNumber, omitNullish, quote, retry, Worker, } from "@/utils";
 const ci = {
     isExcluded(exclude, { name }) {
         return exclude.some((pattern) => {
@@ -22,6 +22,65 @@ const ci = {
         return !this.isFailed(check) && !this.isPassed(check);
     },
 };
+function matchesValues(filter, values) {
+    if (!filter)
+        return true;
+    if ("include" in filter &&
+        !values.some((value) => filter.include.includes(value)))
+        return false;
+    return !("exclude" in filter &&
+        values.some((value) => filter.exclude.includes(value)));
+}
+function matchesPatterns(filter, values) {
+    if (!filter)
+        return true;
+    if ("include" in filter) {
+        const isIncluded = picomatch(filter.include, { dot: true });
+        if (!values.some((value) => isIncluded(value)))
+            return false;
+    }
+    if ("exclude" in filter) {
+        const isExcluded = picomatch(filter.exclude, { dot: true });
+        if (values.some((value) => isExcluded(value)))
+            return false;
+    }
+    return true;
+}
+export function getConditionErrors(condition, metadata, files) {
+    const errors = [];
+    const branches = condition.branches
+        ? {
+            base: "base" in condition.branches ? condition.branches.base : undefined,
+            head: "head" in condition.branches ? condition.branches.head : undefined,
+        }
+        : {};
+    if (!matchesValues(condition.authors, [metadata.user.login]))
+        errors.push(`Author does not match safety filter: ${metadata.user.login}.`);
+    if (!matchesPatterns(branches.base, [metadata.base.ref]))
+        errors.push(`Base branch does not match safety filter: ${metadata.base.ref}.`);
+    if (!matchesPatterns(branches.head, [metadata.head.ref]))
+        errors.push(`Head branch does not match safety filter: ${metadata.head.ref}.`);
+    if (!matchesValues(condition.labels, metadata.labels.map(({ name }) => name)))
+        errors.push(`Labels do not match safety filter.`);
+    if (!matchesPatterns(condition.paths, files))
+        errors.push(`Paths do not match safety filter.`);
+    if (isNumber(condition.maxChangedFiles) &&
+        metadata.changed_files > condition.maxChangedFiles)
+        errors.push(`Changed files exceed limit: ${metadata.changed_files} > ${condition.maxChangedFiles}.`);
+    return errors;
+}
+function getSafetyErrors(conditions, metadata, files) {
+    if (isBoolean(conditions))
+        return conditions ? [] : ["Safety is disabled."];
+    return conditions.flatMap(([expected, condition], index) => {
+        const errors = getConditionErrors(condition, metadata, files);
+        if (!errors.length === expected)
+            return [];
+        if (expected)
+            return errors;
+        return [`Safety condition ${index + 1} unexpectedly matched.`];
+    });
+}
 export async function checkPr() {
     this.context.abort.throwIfAborted();
     await this.updateState({ status: "running" });
@@ -31,26 +90,7 @@ export async function checkPr() {
         throw new MagiError("blocked", `PR is not open.`);
     if (metadata.draft)
         throw new MagiError("blocked", `PR is a draft.`);
-    const errors = [];
-    if (this.config.review.safety.allowAuthors.length)
-        if (!this.config.review.safety.allowAuthors.includes(metadata.user.login))
-            errors.push(`Author is not allowed: ${metadata.user.login}.`);
-    if (this.config.review.safety.requiredLabels.length) {
-        const missingLabels = this.config.review.safety.requiredLabels.filter((label) => !metadata.labels.some(({ name }) => name === label));
-        if (missingLabels.length)
-            errors.push(`Required labels missing: ${missingLabels.join(", ")}.`);
-    }
-    if (isNumber(this.config.review.safety.maxChangedFiles) &&
-        metadata.changed_files > this.config.review.safety.maxChangedFiles)
-        errors.push(`Changed files exceed limit: ${metadata.changed_files} > ${this.config.review.safety.maxChangedFiles}.`);
-    if (this.config.review.safety.blockedPaths.length) {
-        const isBlocked = picomatch(this.config.review.safety.blockedPaths, {
-            dot: true,
-        });
-        const blocked = files.filter((file) => isBlocked(file));
-        if (blocked.length)
-            errors.push(`Blocked paths changed: ${blocked.join(", ")}.`);
-    }
+    const errors = getSafetyErrors(this.config.review.safety, metadata, files);
     if (errors.length)
         throw new MagiError("blocked", `PR is safety blocked. ${errors.join(" ")}`);
     if (this.config.mode === "single") {

package/dist/tools/review/review.js

@@ -1,7 +1,7 @@
 import { join } from "node:path";
 import { MagiError } from "@/magi";
 import { createExecWithGitHubApiRetry, quote } from "@/utils";
-import { automate, postReviews } from "./action";
+import { automate, isAutomationEnabled, postReviews } from "./action";
 import { checkCi, checkPr, classifyChecks, rerunChecks } from "./check";
 import { checkExistingReviews, fetchReviewContext } from "./context";
 import { createReport } from "./report";
@@ -62,6 +62,7 @@ export class Review {
     validateFindings = validateFindings;
     reconsiderClose = reconsiderClose;
     postReviews = postReviews;
+    isAutomationEnabled = isAutomationEnabled;
     automate = automate;
     createReport = createReport;
     async cleanup() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-magi",
-  "version": "0.0.0-dev-20260727045328",
+  "version": "0.0.0-dev-20260727095903",
   "description": "Multi-agent PR review and merge orchestration plugin for OpenCode.",
   "license": "MIT",
   "author": "Hirotomo Yamada <hirotomo.yamada@avap.co.jp>",

package/schema.json

@@ -174,21 +174,125 @@
         "variant": { "type": "string" }
       }
     },
+    "safetyFilter": {
+      "type": "object",
+      "additionalProperties": false,
+      "minProperties": 1,
+      "properties": {
+        "exclude": { "type": "array", "items": { "type": "string" } },
+        "include": { "type": "array", "items": { "type": "string" } }
+      }
+    },
+    "safetyBranchFilter": {
+      "type": "object",
+      "additionalProperties": false,
+      "minProperties": 1,
+      "properties": {
+        "base": { "$ref": "#/$defs/safetyFilter" },
+        "head": { "$ref": "#/$defs/safetyFilter" }
+      }
+    },
+    "safety": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "authors": { "$ref": "#/$defs/safetyFilter" },
+        "branches": { "$ref": "#/$defs/safetyBranchFilter" },
+        "labels": { "$ref": "#/$defs/safetyFilter" },
+        "maxChangedFiles": { "type": "integer", "minimum": 0 },
+        "paths": { "$ref": "#/$defs/safetyFilter" }
+      }
+    },
+    "conditions": {
+      "oneOf": [
+        { "type": "boolean" },
+        {
+          "type": "array",
+          "items": {
+            "type": "array",
+            "minItems": 2,
+            "maxItems": 2,
+            "prefixItems": [{ "type": "boolean" }, { "$ref": "#/$defs/safety" }]
+          }
+        }
+      ]
+    },
+    "automationSafety": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "authors": { "$ref": "#/$defs/safetyFilter" },
+        "branches": { "$ref": "#/$defs/safetyBranchFilter" },
+        "labels": { "$ref": "#/$defs/safetyFilter" },
+        "paths": { "$ref": "#/$defs/safetyFilter" }
+      }
+    },
+    "automationConditions": {
+      "oneOf": [
+        { "type": "boolean" },
+        {
+          "type": "array",
+          "items": {
+            "type": "array",
+            "minItems": 2,
+            "maxItems": 2,
+            "prefixItems": [
+              { "type": "boolean" },
+              { "$ref": "#/$defs/automationSafety" }
+            ]
+          }
+        }
+      ]
+    },
+    "mergeAutomationConditions": {
+      "oneOf": [
+        { "type": "boolean" },
+        {
+          "type": "array",
+          "items": {
+            "type": "array",
+            "minItems": 2,
+            "maxItems": 2,
+            "prefixItems": [
+              { "type": "boolean" },
+              { "$ref": "#/$defs/mergeAutomationSafety" }
+            ]
+          }
+        }
+      ]
+    },
+    "mergeAutomationSafety": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "authors": { "$ref": "#/$defs/safetyFilter" },
+        "branches": { "$ref": "#/$defs/safetyBranchFilter" },
+        "edited": { "type": "boolean" },
+        "labels": { "$ref": "#/$defs/safetyFilter" },
+        "paths": { "$ref": "#/$defs/safetyFilter" }
+      }
+    },
     "automation": {
       "type": "object",
       "additionalProperties": false,
       "properties": {
-        "merge": { "type": "boolean", "default": true },
-        "close": { "type": "boolean" }
+        "merge": { "$ref": "#/$defs/automationConditions", "default": true },
+        "close": { "$ref": "#/$defs/automationConditions", "default": false }
       }
     },
     "mergeAutomation": {
       "type": "object",
       "additionalProperties": false,
       "properties": {
-        "merge": { "type": "boolean", "default": true },
-        "close": { "type": "boolean", "default": false },
-        "conflict": { "type": "boolean", "default": false }
+        "merge": {
+          "$ref": "#/$defs/mergeAutomationConditions",
+          "default": true
+        },
+        "close": {
+          "$ref": "#/$defs/mergeAutomationConditions",
+          "default": false
+        },
+        "conflict": { "$ref": "#/$defs/automationConditions", "default": false }
       }
     },
     "reviewChecks": {
@@ -222,16 +326,6 @@
         "runs": { "type": "integer", "minimum": 1, "default": 3 }
       }
     },
-    "safety": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "allowAuthors": { "type": "array", "items": { "type": "string" } },
-        "blockedPaths": { "type": "array", "items": { "type": "string" } },
-        "maxChangedFiles": { "type": "integer", "minimum": 0 },
-        "requiredLabels": { "type": "array", "items": { "type": "string" } }
-      }
-    },
     "reviewPrompts": {
       "type": "object",
       "additionalProperties": false,
@@ -376,7 +470,7 @@
         },
         "prompts": { "$ref": "#/$defs/reviewPrompts" },
         "checks": { "$ref": "#/$defs/reviewChecks" },
-        "safety": { "$ref": "#/$defs/safety" },
+        "safety": { "$ref": "#/$defs/conditions" },
         "automation": { "$ref": "#/$defs/automation" },
         "concurrency": { "$ref": "#/$defs/concurrency" },
         "merge": { "$ref": "#/$defs/reviewMerge" },