opencode-magi 0.9.0 → 0.11.0

package/dist/config/resolve.js

@@ -1,256 +1,128 @@
-import editorPermission from "../permissions/editor.json" with { type: "json" };
-import commonPermission from "../permissions/common.json" with { type: "json" };
-const ID_PATTERN = /^[A-Za-z0-9_-]+$/;
-const DEFAULT_COMMON_PERMISSION = commonPermission;
-const DEFAULT_REVIEWER_PERMISSION = DEFAULT_COMMON_PERMISSION;
-const DEFAULT_EDITOR_PERMISSION = mergePermissions(DEFAULT_COMMON_PERMISSION, editorPermission);
-const DEFAULT_TRIAGE_CATEGORIES = [
-    {
-        description: "Something is broken or behaves incorrectly.",
-        id: "bug",
-        labels: ["bug"],
-        types: ["Bug"],
-    },
-    {
-        description: "Maintenance, refactoring, chores, or planned work.",
-        id: "task",
-        labels: ["task"],
-        types: ["Task"],
-    },
-    {
-        description: "New or improved user-facing capability.",
-        id: "feature",
-        labels: ["enhancement"],
-        types: ["Feature"],
-    },
-];
-export const DEFAULT_TRIAGE_LABEL_RULES = [
-    { remove: ["triage"], when: { disposition: "accepted" } },
-    {
-        add: ["duplicate"],
-        remove: ["triage"],
-        when: { disposition: "duplicate" },
-    },
-    {
-        add: ["duplicate"],
-        remove: ["triage"],
-        when: { disposition: "already_handled" },
-    },
-    {
-        add: ["wontfix"],
-        remove: ["triage"],
-        when: { disposition: "rejected" },
-    },
-    {
-        add: ["invalid"],
-        remove: ["triage"],
-        when: { disposition: "invalid" },
-    },
-    { add: ["question"], when: { disposition: "needs_category" } },
-    { add: ["question"], when: { disposition: "needs_acceptance" } },
-];
-export function reviewerKey(reviewer, index) {
-    return reviewer.id ?? `reviewer-${index + 1}`;
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { CONFIG_PATH, DEFAULT_CONFIG } from "@/constant";
+import editPermissions from "@/permissions/editor.json" with { type: "json" };
+import { filterEmpty, getModels, isArray, isObject, isString, merge, } from "@/utils";
+export function resolvePermissions(permissions) {
+    if (!permissions)
+        return undefined;
+    if (isString(permissions))
+        return [
+            "read",
+            "edit",
+            "glob",
+            "grep",
+            "bash",
+            "task",
+            "skill",
+            "lsp",
+            "webfetch",
+            "websearch",
+            "external_directory",
+            "doom_loop",
+        ].map((permission) => ({
+            action: permissions,
+            pattern: "*",
+            permission,
+        }));
+    else
+        return Object.entries(permissions).flatMap(([permission, rule]) => {
+            if (isString(rule))
+                return [{ action: rule, pattern: "*", permission }];
+            else
+                return Object.entries(rule).map(([pattern, action]) => ({
+                    action,
+                    pattern,
+                    permission,
+                }));
+        });
 }
-export function triageAgentKey(agent, index) {
-    return agent.id ?? `voter-${index + 1}`;
-}
-export function validateReviewerId(id) {
-    return ID_PATTERN.test(id);
+function mergePermissions(base, override) {
+    if (!override)
+        return base;
+    else if (isString(override) || isString(base))
+        return override;
+    else
+        return merge(base, override);
 }
-function normalizedModel(model) {
-    if (typeof model !== "string") {
-        throw new Error("model must be normalized before resolving agents");
-    }
-    return model;
+function mergeAgent(base, agent) {
+    if (base.agents.refs && agent.ref)
+        agent = { ...base.agents.refs[agent.ref], ...agent };
+    agent.permissions = mergePermissions(base.agents.permissions, agent.permissions);
+    if (base.account)
+        agent.account ??= base.account;
+    return agent;
 }
-function clonePermissionValue(value) {
-    return typeof value === "string" ? value : { ...value };
+function resolveModel(models, model) {
+    if (isArray(model))
+        model = model.find((model) => isString(model) ? models.includes(model) : models.includes(model.id));
+    if (!model)
+        return undefined;
+    if (isString(model))
+        return models.includes(model) ? { id: model } : undefined;
+    else
+        return models.includes(model.id) ? model : undefined;
 }
-export function mergePermissions(base, override) {
-    if (!override) {
-        return typeof base === "string"
-            ? base
-            : Object.fromEntries(Object.entries(base).map(([key, value]) => [
-                key,
-                clonePermissionValue(value),
-            ]));
+async function readConfig(path) {
+    try {
+        const config = JSON.parse(await readFile(path, "utf8"));
+        if (!isObject(config))
+            throw new Error(`Config must be a JSON object: ${path}`);
+        return config;
     }
-    if (typeof override === "string")
-        return override;
-    if (typeof base === "string") {
-        return Object.fromEntries(Object.entries(override).map(([key, value]) => [
-            key,
-            clonePermissionValue(value),
-        ]));
+    catch (e) {
+        if (e.code === "ENOENT")
+            return undefined;
+        throw e;
     }
-    const merged = Object.fromEntries(Object.entries(base).map(([key, value]) => [
-        key,
-        clonePermissionValue(value),
-    ]));
-    for (const [permission, value] of Object.entries(override)) {
-        const existing = merged[permission];
-        merged[permission] =
-            existing && typeof existing !== "string" && typeof value !== "string"
-                ? { ...existing, ...value }
-                : clonePermissionValue(value);
-    }
-    return merged;
-}
-export function resolveReviewerPermission(agents, reviewer) {
-    return mergePermissions(mergePermissions(DEFAULT_REVIEWER_PERMISSION, agents.permissions), reviewer.permissions);
-}
-export function resolveEditorPermission(agents, editor) {
-    return mergePermissions(mergePermissions(DEFAULT_EDITOR_PERMISSION, agents.permissions), editor.permissions);
 }
-export function resolveTriageAgentPermission(agents, agent) {
-    return mergePermissions(mergePermissions(DEFAULT_REVIEWER_PERMISSION, agents.permissions), agent.permissions);
-}
-export function resolveTriageCreatorPermission(agents, creator) {
-    return mergePermissions(mergePermissions(DEFAULT_EDITOR_PERMISSION, agents.permissions), creator.permissions);
-}
-export function resolveAgents(config) {
-    const agents = config.agents ?? {};
-    const editor = config.merge?.editor;
-    const creator = config.triage?.creator;
-    const singleReviewAccount = config.review && config.review.mode !== "multi"
-        ? config.review.account
-        : undefined;
-    return {
-        editor: editor
-            ? {
-                ...editor,
-                model: normalizedModel(editor.model),
-                permission: resolveEditorPermission(agents, editor),
-            }
-            : undefined,
-        reviewers: (config.review?.reviewers ?? []).map((reviewer, index) => ({
-            ...reviewer,
-            account: singleReviewAccount ?? reviewer.account ?? "",
-            key: reviewerKey(reviewer, index),
-            index,
-            model: normalizedModel(reviewer.model),
-            permission: resolveReviewerPermission(agents, reviewer),
-        })),
-        triage: (config.triage?.voters ?? []).map((agent, index) => ({
-            ...agent,
-            key: triageAgentKey(agent, index),
-            index,
-            model: normalizedModel(agent.model),
-            permission: resolveTriageAgentPermission(agents, agent),
-        })),
-        triageCreator: creator
-            ? {
-                ...creator,
-                account: creator.account ?? "",
-                model: normalizedModel(creator.model),
-                permission: resolveTriageCreatorPermission(agents, creator),
-            }
-            : undefined,
-    };
-}
-function resolveTriageCategories(config) {
-    return (config.triage?.categories ?? DEFAULT_TRIAGE_CATEGORIES).map((category) => ({
-        description: category.description,
-        id: category.id ?? "",
-        labels: category.labels ?? [],
-        types: category.types ?? [],
-    }));
-}
-export function resolveRepository(config) {
-    if (!config.github?.owner)
-        throw new Error("github.owner is required");
-    if (!config.github?.repo)
-        throw new Error("github.repo is required");
-    return {
-        alias: config.github.repo,
-        agents: resolveAgents(config),
-        automation: {
-            close: config.merge?.automation?.close ?? false,
-            conflict: config.merge?.automation?.conflict ?? false,
-            merge: config.merge?.automation?.merge ?? true,
-        },
-        checks: {
-            exclude: config.review?.checks?.exclude ?? [],
-            retryFailedJobs: config.review?.checks?.retryFailedJobs ?? 3,
-            wait: config.review?.checks?.wait ?? true,
-            waitAfterEdit: config.merge?.checks?.wait ?? true,
-            waitBeforeReview: config.review?.checks?.wait ?? true,
-        },
-        concurrency: {
-            runs: config.review?.concurrency?.runs ?? 3,
-            reviewers: config.review?.concurrency?.reviewers ?? 3,
-        },
-        github: {
-            apiRetryAttempts: config.github.apiRetryAttempts ?? 3,
-            host: config.github.host ?? "github.com",
-            owner: config.github.owner,
-            repo: config.github.repo,
-        },
-        language: config.language,
-        merge: {
-            approvalPolicy: config.review?.merge?.approvalPolicy ?? "majority",
-            method: config.review?.merge?.method ?? "squash",
-            auto: config.review?.merge?.auto ?? true,
-            deleteBranch: config.review?.merge?.deleteBranch ?? true,
-            queue: config.review?.merge?.queue ?? false,
-            mergeQueue: config.review?.merge?.queue ?? false,
-            maxThreadResolutionCycles: config.merge?.maxThreadResolutionCycles ?? 5,
-        },
-        prompts: {
-            ciClassification: config.review?.prompts?.ciClassification,
-            ciClassificationAfterEdit: config.merge?.prompts?.ciClassification,
-            closeReconsideration: config.review?.prompts?.closeReconsideration,
-            edit: config.merge?.prompts?.edit,
-            editGuidelines: config.merge?.prompts?.editGuidelines,
-            findingValidation: config.review?.prompts?.findingValidation,
-            rereview: config.review?.prompts?.rereview,
-            review: config.review?.prompts?.review,
-            reviewGuidelines: config.review?.prompts?.reviewGuidelines,
-        },
-        review: {
-            account: config.review?.account,
-            mode: config.review?.mode ?? "single",
-        },
-        reviewAutomation: {
-            close: config.review?.automation?.close ?? false,
-            merge: config.review?.automation?.merge ?? true,
-        },
-        safety: {
-            allowAuthors: config.review?.safety?.allowAuthors ?? [],
-            blockedPaths: config.review?.safety?.blockedPaths ?? [],
-            maxChangedFiles: config.review?.safety?.maxChangedFiles,
-            requiredLabels: config.review?.safety?.requiredLabels ?? [],
-        },
-        triage: {
-            automation: {
-                close: config.triage?.automation?.close ?? false,
-                create: config.triage?.automation?.create ?? false,
-                label: config.triage?.automation?.label ?? DEFAULT_TRIAGE_LABEL_RULES,
-                merge: config.triage?.automation?.merge ?? false,
-                review: config.triage?.automation?.review ?? false,
-            },
-            categories: resolveTriageCategories(config),
-            concurrency: {
-                runs: config.triage?.concurrency?.runs ?? 3,
-            },
-            output: config.triage?.output,
-            prompts: config.triage?.prompts ?? {},
-            reporter: config.triage?.reporter,
-            safety: {
-                allowAuthors: config.triage?.safety?.allowAuthors ?? [],
-                allowMentionActors: config.triage?.safety?.allowMentionActors ?? [],
-                allowMentionRoles: config.triage?.safety?.allowMentionRoles ?? [
-                    "AUTHOR",
-                    "OWNER",
-                    "MEMBER",
-                    "COLLABORATOR",
-                ],
-                blockedLabels: config.triage?.safety?.blockedLabels ?? [],
-                requiredLabels: config.triage?.safety?.requiredLabels ?? ["triage"],
-            },
-            signals: config.triage?.signals ?? [],
-            worktree: config.triage?.worktree,
-        },
-    };
+export async function getConfig(input) {
+    const projectPath = join(input.directory, CONFIG_PATH.PROJECT);
+    const [models, ...data] = await Promise.all([
+        getModels(input),
+        readConfig(CONFIG_PATH.GLOBAL),
+        readConfig(projectPath),
+    ]);
+    const results = filterEmpty(data);
+    if (!models.length)
+        throw new Error("No OpenCode models found.");
+    if (!results.length)
+        throw new Error(`No Magi config found. Expected ${CONFIG_PATH.GLOBAL} or ${projectPath}.`);
+    const config = results.reduce((prev, current) => merge(prev, current), DEFAULT_CONFIG);
+    config.github.url = `https://${config.github.host}/${config.github.owner}/${config.github.repo}`;
+    if (config.review.reviewers)
+        config.review.reviewers = config.review.reviewers.map((agent, index) => {
+            const { id, model, ...rest } = mergeAgent(config, agent);
+            return {
+                ...rest,
+                id: id || `reviewer-${index + 1}`,
+                model: resolveModel(models, model),
+            };
+        });
+    if (config.merge.editor) {
+        if (config.merge.editor.permissions)
+            config.merge.editor.permissions = mergePermissions(editPermissions, config.merge.editor.permissions);
+        else
+            config.merge.editor.permissions = editPermissions;
+        config.merge.editor = mergeAgent(config, config.merge.editor);
+        config.merge.editor.model = resolveModel(models, config.merge.editor.model);
+    }
+    if (config.triage.voters)
+        config.triage.voters = config.triage.voters.map((agent, index) => {
+            const { id, model, ...rest } = mergeAgent(config, agent);
+            return {
+                ...rest,
+                id: id || `voter-${index + 1}`,
+                model: resolveModel(models, model),
+            };
+        });
+    if (config.triage.creator) {
+        if (config.triage.creator.permissions)
+            config.triage.creator.permissions = mergePermissions(editPermissions, config.triage.creator.permissions);
+        else
+            config.triage.creator.permissions = editPermissions;
+        config.triage.creator = mergeAgent(config, config.triage.creator);
+        config.triage.creator.model = resolveModel(models, config.triage.creator.model);
+    }
+    return config;
 }