opencode-magi 0.9.0 → 0.11.0

package/dist/constant.js

@@ -0,0 +1,135 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import commonPermissions from "./permissions/common.json" with { type: "json" };
+export const CONFIG_PATH = {
+    GLOBAL: join(homedir(), ".config", "opencode", "magi.json"),
+    PROJECT: join(".opencode", "magi.json"),
+};
+export const DEFAULT_CONFIG = {
+    agents: {
+        permissions: commonPermissions,
+    },
+    clear: {
+        branch: true,
+        output: true,
+        session: true,
+        worktree: true,
+    },
+    github: {
+        host: "github.com",
+        owner: "",
+        repo: "",
+        retryApiAttempts: 3,
+        url: "",
+    },
+    language: "en",
+    merge: {
+        automation: {
+            close: false,
+            conflict: false,
+            merge: true,
+        },
+        checks: {
+            wait: true,
+        },
+        maxThreadResolutionCycles: 5,
+    },
+    mode: "single",
+    output: {
+        repairAttempts: 3,
+    },
+    review: {
+        automation: {
+            close: false,
+            merge: true,
+        },
+        checks: {
+            exclude: [],
+            retryFailedJobs: 3,
+            wait: true,
+        },
+        concurrency: {
+            reviewers: 3,
+            runs: 3,
+        },
+        merge: {
+            approvalPolicy: "majority",
+            auto: true,
+            deleteBranch: true,
+            method: "squash",
+            queue: false,
+        },
+        output: ".magi/runs/pr",
+        safety: {
+            allowAuthors: [],
+            blockedPaths: [],
+            requiredLabels: [],
+        },
+        worktree: ".magi/worktrees/pr",
+    },
+    triage: {
+        automation: {
+            close: false,
+            create: false,
+            label: [
+                { 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" } },
+            ],
+            merge: false,
+            review: false,
+        },
+        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"],
+            },
+        ],
+        concurrency: {
+            runs: 3,
+        },
+        output: ".magi/runs/issue",
+        safety: {
+            allowAuthors: [],
+            allowMentionActors: [],
+            allowMentionRoles: ["AUTHOR", "OWNER", "MEMBER", "COLLABORATOR"],
+            blockedLabels: [],
+            requiredLabels: ["triage"],
+        },
+        worktree: ".magi/worktrees/issue",
+    },
+};

package/dist/graphql/index.generated.js

@@ -0,0 +1,125 @@
+import gql from 'graphql-tag';
+export const ClosingIssuesDocument = gql `
+    query closingIssues($cursor: String, $owner: String!, $repo: String!, $pr: Int!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $pr) {
+      closingIssuesReferences(first: 50, after: $cursor) {
+        nodes {
+          author {
+            login
+          }
+          body
+          comments(last: 50) {
+            nodes {
+              author {
+                login
+              }
+              body
+              createdAt
+              databaseId
+              url
+            }
+          }
+          number
+          state
+          title
+          url
+        }
+        pageInfo {
+          endCursor
+          hasNextPage
+        }
+      }
+    }
+  }
+}
+    `;
+export const EnqueuePullRequestDocument = gql `
+    mutation enqueuePullRequest($id: ID!) {
+  enqueuePullRequest(input: {pullRequestId: $id}) {
+    mergeQueueEntry {
+      id
+    }
+  }
+}
+    `;
+export const MergeQueueStatusDocument = gql `
+    query mergeQueueStatus($owner: String!, $repo: String!, $pr: Int!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $pr) {
+      state
+      isInMergeQueue
+      mergeQueueEntry {
+        id
+      }
+      timelineItems(last: 1, itemTypes: REMOVED_FROM_MERGE_QUEUE_EVENT) {
+        nodes {
+          ... on RemovedFromMergeQueueEvent {
+            createdAt
+            reason
+          }
+        }
+      }
+    }
+  }
+}
+    `;
+export const ResolveReviewThreadDocument = gql `
+    mutation resolveReviewThread($threadId: ID!) {
+  resolveReviewThread(input: {threadId: $threadId}) {
+    thread {
+      id
+    }
+  }
+}
+    `;
+export const ReviewThreadsDocument = gql `
+    query reviewThreads($cursor: String, $owner: String!, $repo: String!, $pr: Int!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $pr) {
+      reviewThreads(first: 50, after: $cursor) {
+        nodes {
+          comments(last: 50) {
+            nodes {
+              author {
+                login
+              }
+              body
+              createdAt
+              databaseId
+              url
+            }
+          }
+          id
+          isResolved
+          line
+          path
+        }
+        pageInfo {
+          endCursor
+          hasNextPage
+        }
+      }
+    }
+  }
+}
+    `;
+export function getSdk(requester) {
+    return {
+        closingIssues(variables, options) {
+            return requester(ClosingIssuesDocument, variables, options);
+        },
+        enqueuePullRequest(variables, options) {
+            return requester(EnqueuePullRequestDocument, variables, options);
+        },
+        mergeQueueStatus(variables, options) {
+            return requester(MergeQueueStatusDocument, variables, options);
+        },
+        resolveReviewThread(variables, options) {
+            return requester(ResolveReviewThreadDocument, variables, options);
+        },
+        reviewThreads(variables, options) {
+            return requester(ReviewThreadsDocument, variables, options);
+        }
+    };
+}

package/dist/graphql/index.js

@@ -0,0 +1,49 @@
+import { isObject } from "@/utils";
+import { getSdk } from "./index.generated";
+function isConnection(value) {
+    if (!value || !isObject(value))
+        return false;
+    return "nodes" in value && "pageInfo" in value;
+}
+function findConnection(value) {
+    if (isConnection(value))
+        return value;
+    if (!value || !isObject(value))
+        return undefined;
+    for (const child of Object.values(value)) {
+        const connection = findConnection(child);
+        if (connection)
+            return connection;
+    }
+    return undefined;
+}
+export function graphql(requester) {
+    const sdk = getSdk(requester);
+    const bound = Object.fromEntries(Object.entries(sdk).map(([key, req]) => [key, req.bind(sdk)]));
+    async function paginate(req, params) {
+        let cursor = params.cursor ?? null;
+        let result;
+        for (;;) {
+            const page = (await req({
+                ...params,
+                cursor,
+            }));
+            const connection = findConnection(page);
+            if (!connection)
+                return page;
+            if (!result) {
+                result = page;
+            }
+            else {
+                const target = findConnection(result);
+                target?.nodes?.push(...(connection.nodes ?? []));
+            }
+            if (!connection.pageInfo?.hasNextPage)
+                return result;
+            cursor = connection.pageInfo.endCursor ?? null;
+            if (!cursor)
+                throw new Error("GraphQL page was truncated");
+        }
+    }
+    return { ...bound, paginate };
+}