@ayushporwal/coja 0.0.1

package/dist/forge/graphql.js

@@ -0,0 +1,106 @@
+import { ForgeError } from './forge.js';
+import { invalidateTokenCache } from './gh-cli.js';
+export const GITHUB_GRAPHQL_ENDPOINT = 'https://api.github.com/graphql';
+export const TOKEN_REJECTED = 'GitHub rejected the token from gh. Run `gh auth login` (or `gh auth refresh`) in your terminal and try again.';
+export function createGraphqlClient(opts) {
+    const { getToken, fetchImpl = fetch, endpoint = GITHUB_GRAPHQL_ENDPOINT, onUnauthorized = invalidateTokenCache, timeoutMs = 30_000, } = opts;
+    return async function gql(query, variables = {}) {
+        const token = await getToken();
+        let res;
+        try {
+            res = await fetchImpl(endpoint, {
+                method: 'POST',
+                // The token must only ever go to `endpoint`; a redirect elsewhere is a failure.
+                redirect: 'error',
+                headers: {
+                    authorization: `bearer ${token}`,
+                    'content-type': 'application/json',
+                    accept: 'application/json',
+                    'user-agent': 'coja',
+                },
+                body: JSON.stringify({ query, variables }),
+                signal: AbortSignal.timeout(timeoutMs),
+            });
+        }
+        catch (err) {
+            throw new ForgeError(`Could not reach GitHub: ${errorMessage(err)}`, 502);
+        }
+        if (res.status === 401) {
+            onUnauthorized();
+            throw new ForgeError(TOKEN_REJECTED, 401);
+        }
+        if (!res.ok) {
+            throw new ForgeError(describeHttpFailure(res, await safeText(res)), res.status);
+        }
+        let body;
+        try {
+            body = (await res.json());
+        }
+        catch {
+            throw new ForgeError('GitHub returned an unreadable response.', 502);
+        }
+        if (body.errors && body.errors.length > 0) {
+            throw new ForgeError(body.errors.map((e) => e.message).join('; '), statusForGraphqlErrors(body.errors), body.errors);
+        }
+        if (body.data == null)
+            throw new ForgeError('GitHub returned no data.', 502);
+        return body.data;
+    };
+}
+/**
+ * GitHub tags GraphQL errors with a `type`. Validation failures the user can
+ * act on (e.g. "Can not approve your own pull request") are UNPROCESSABLE →
+ * 422; missing objects → 404; permission problems → 403; the rest is the
+ * host's (or our query's) fault → 502.
+ */
+export function statusForGraphqlErrors(errors) {
+    const types = new Set(errors.map((e) => e.type));
+    if (types.has('UNPROCESSABLE'))
+        return 422;
+    if (types.has('NOT_FOUND'))
+        return 404;
+    if (types.has('FORBIDDEN') || types.has('INSUFFICIENT_SCOPES'))
+        return 403;
+    if (types.has('RATE_LIMITED'))
+        return 429;
+    return 502;
+}
+function describeHttpFailure(res, text) {
+    const retryAfter = res.headers.get('retry-after');
+    const remaining = res.headers.get('x-ratelimit-remaining');
+    if ((res.status === 403 || res.status === 429) && (retryAfter || remaining === '0')) {
+        const reset = res.headers.get('x-ratelimit-reset');
+        const when = retryAfter
+            ? `in ${retryAfter}s`
+            : reset
+                ? `at ${new Date(Number(reset) * 1000).toISOString()}`
+                : 'later';
+        return `GitHub rate limit exceeded; try again ${when}.`;
+    }
+    const detail = messageFromBody(text);
+    return `GitHub API request failed with HTTP ${res.status}${detail ? `: ${detail}` : ''}`;
+}
+function messageFromBody(text) {
+    try {
+        const parsed = JSON.parse(text);
+        return typeof parsed?.message === 'string' ? parsed.message : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function safeText(res) {
+    try {
+        return await res.text();
+    }
+    catch {
+        return '';
+    }
+}
+function errorMessage(err) {
+    if (err instanceof Error) {
+        const cause = err.cause;
+        return cause?.message ? `${err.message} (${cause.message})` : err.message;
+    }
+    return String(err);
+}

package/dist/forge/queries.js

@@ -0,0 +1,258 @@
+/**
+ * GraphQL documents for the GitHub forge, plus the raw response shapes they
+ * select (the `Raw*` / `*Data` types). Field names, argument names and enum
+ * values were verified against the live schema by introspection; a document
+ * and its data type must be changed together.
+ *
+ * Paging: every connection is requested with `first: 100` (GitHub's maximum)
+ * and exposes `pageInfo`; `*Page` documents fetch the following pages of one
+ * connection so the initial detail query is never repeated.
+ */
+// ---------------------------------------------------------------------------
+// Fragments
+// ---------------------------------------------------------------------------
+const PR_SUMMARY = /* GraphQL */ `
+fragment PrSummary on PullRequest {
+  id number title url isDraft createdAt updatedAt
+  additions deletions changedFiles
+  author { login avatarUrl }
+  headRefName baseRefName headRefOid baseRefOid
+  viewerReviews: reviews(author: $login, last: 20) { nodes { id state submittedAt } }
+  pendingReview: reviews(author: $login, states: [PENDING], first: 1) {
+    nodes { id comments(first: 1) { totalCount } }
+  }
+}`;
+const COMMENT_FIELDS = /* GraphQL */ `
+fragment CommentFields on PullRequestReviewComment {
+  id databaseId body bodyHTML createdAt url state
+  author { login avatarUrl }
+  pullRequestReview { id state }
+}`;
+const THREAD_FIELDS = /* GraphQL */ `
+fragment ThreadFields on PullRequestReviewThread {
+  id path line startLine originalLine diffSide startDiffSide isResolved isOutdated
+  comments(first: 100) {
+    pageInfo { hasNextPage endCursor }
+    nodes { ...CommentFields }
+  }
+}
+${COMMENT_FIELDS}`;
+const REVIEW_FIELDS = /* GraphQL */ `
+fragment ReviewFields on PullRequestReview {
+  id state body bodyHTML submittedAt createdAt url
+  author { login avatarUrl }
+  comments(first: 1) { totalCount }
+}`;
+const ISSUE_COMMENT_FIELDS = /* GraphQL */ `
+fragment IssueCommentFields on IssueComment {
+  id body bodyHTML createdAt url
+  author { login avatarUrl }
+}`;
+const COMMIT_FIELDS = /* GraphQL */ `
+fragment CommitFields on PullRequestCommit {
+  url
+  commit {
+    oid abbreviatedOid messageHeadline messageBody committedDate url
+    author { name user { login } }
+  }
+}`;
+const FILE_FIELDS = 'path additions deletions changeType viewerViewedState';
+const PAGE_INFO = 'pageInfo { hasNextPage endCursor }';
+// ---------------------------------------------------------------------------
+// Queries
+// ---------------------------------------------------------------------------
+export const VIEWER = /* GraphQL */ `
+query Viewer { viewer { login avatarUrl } }`;
+/** Open PRs, most recently updated first. Variables: owner, name, login, after? */
+export const PR_LIST = /* GraphQL */ `
+query PrList($owner: String!, $name: String!, $login: String!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequests(states: [OPEN], first: 100, after: $after,
+                 orderBy: { field: UPDATED_AT, direction: DESC }) {
+      totalCount
+      ${PAGE_INFO}
+      nodes { ...PrSummary }
+    }
+  }
+}
+${PR_SUMMARY}`;
+/**
+ * Filtered open PRs via GitHub's search API. The caller builds the query
+ * string (repo/is:pr/is:open plus qualifiers); search order is best-match,
+ * like GitHub's own filtered list. Variables: query (the full string),
+ * login, after?
+ */
+export const PR_SEARCH = /* GraphQL */ `
+query PrSearch($query: String!, $login: String!, $after: String) {
+  search(query: $query, type: ISSUE, first: 100, after: $after) {
+    issueCount
+    pageInfo { hasNextPage endCursor }
+    nodes { ... on PullRequest { ...PrSummary } }
+  }
+}
+${PR_SUMMARY}`;
+/** Variables: owner, name, number */
+export const PR_REFS = /* GraphQL */ `
+query PrRefs($owner: String!, $name: String!, $number: Int!) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) { id number headRefOid baseRefOid baseRefName headRefName }
+  }
+}`;
+/** First page of everything the review screen needs. Variables: owner, name, number, login */
+export const PR_DETAIL = /* GraphQL */ `
+query PrDetail($owner: String!, $name: String!, $number: Int!, $login: String!) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      ...PrSummary
+      body bodyHTML
+      commits(first: 100) { totalCount ${PAGE_INFO} nodes { ...CommitFields } }
+      files(first: 100) { totalCount ${PAGE_INFO} nodes { ${FILE_FIELDS} } }
+      reviewThreads(first: 100) { totalCount ${PAGE_INFO} nodes { ...ThreadFields } }
+      reviews(first: 100) { ${PAGE_INFO} nodes { ...ReviewFields } }
+      comments(first: 100) { ${PAGE_INFO} nodes { ...IssueCommentFields } }
+    }
+  }
+}
+${PR_SUMMARY}
+${COMMIT_FIELDS}
+${THREAD_FIELDS}
+${REVIEW_FIELDS}
+${ISSUE_COMMENT_FIELDS}`;
+const pageQuery = (name, connection, fragments = '') => /* GraphQL */ `
+query ${name}($owner: String!, $name: String!, $number: Int!, $after: String!) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) { ${connection} }
+  }
+}
+${fragments}`;
+/** Variables: owner, name, number, after */
+export const PR_COMMITS_PAGE = pageQuery('PrCommitsPage', `commits(first: 100, after: $after) { ${PAGE_INFO} nodes { ...CommitFields } }`, COMMIT_FIELDS);
+export const PR_FILES_PAGE = pageQuery('PrFilesPage', `files(first: 100, after: $after) { ${PAGE_INFO} nodes { ${FILE_FIELDS} } }`);
+export const PR_THREADS_PAGE = pageQuery('PrThreadsPage', `reviewThreads(first: 100, after: $after) { ${PAGE_INFO} nodes { ...ThreadFields } }`, THREAD_FIELDS);
+export const PR_REVIEWS_PAGE = pageQuery('PrReviewsPage', `reviews(first: 100, after: $after) { ${PAGE_INFO} nodes { ...ReviewFields } }`, REVIEW_FIELDS);
+export const PR_ISSUE_COMMENTS_PAGE = pageQuery('PrIssueCommentsPage', `comments(first: 100, after: $after) { ${PAGE_INFO} nodes { ...IssueCommentFields } }`, ISSUE_COMMENT_FIELDS);
+/** Comments of one thread beyond its first 100. Variables: id (thread node id), after */
+export const THREAD_COMMENTS_PAGE = /* GraphQL */ `
+query ThreadCommentsPage($id: ID!, $after: String!) {
+  node(id: $id) {
+    ... on PullRequestReviewThread {
+      comments(first: 100, after: $after) { ${PAGE_INFO} nodes { ...CommentFields } }
+    }
+  }
+}
+${COMMENT_FIELDS}`;
+/**
+ * The pull request a review comment / thread belongs to, for tying a
+ * client-supplied node id to the PR named in the route. Two documents, so an id
+ * of the other type resolves to no pull request at all. Variables: id
+ */
+const ownerQuery = (name, type) => /* GraphQL */ `
+query ${name}($id: ID!) {
+  node(id: $id) {
+    ... on ${type} { pullRequest { number repository { name owner { login } } } }
+  }
+}`;
+export const COMMENT_OWNER = ownerQuery('CommentOwner', 'PullRequestReviewComment');
+export const THREAD_OWNER = ownerQuery('ThreadOwner', 'PullRequestReviewThread');
+/** The viewer's pending review on a PR, if any. Variables: owner, name, number, login */
+export const PENDING_REVIEW = /* GraphQL */ `
+query PendingReview($owner: String!, $name: String!, $number: Int!, $login: String!) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      id
+      reviews(author: $login, states: [PENDING], first: 1) {
+        nodes { id comments(first: 1) { totalCount } }
+      }
+    }
+  }
+}`;
+// ---------------------------------------------------------------------------
+// Mutations — every one of these is reached only from an HTTP route handler
+// that a human triggered in the UI ("the AI drafts, the human sends").
+// ---------------------------------------------------------------------------
+/** Create a PENDING review anchored at a commit (no event). Variables: pullRequestId, commitOID */
+export const START_REVIEW = /* GraphQL */ `
+mutation StartReview($pullRequestId: ID!, $commitOID: GitObjectID) {
+  addPullRequestReview(input: { pullRequestId: $pullRequestId, commitOID: $commitOID }) {
+    pullRequestReview { id state }
+  }
+}`;
+/**
+ * Add a line/range thread to a pending review. Variables: input
+ * (AddPullRequestReviewThreadInput: pullRequestReviewId, path, body, line, side, startLine?, startSide?).
+ * `firstComment` reaches the owning review's updated comment count.
+ */
+export const ADD_THREAD = /* GraphQL */ `
+mutation AddThread($input: AddPullRequestReviewThreadInput!) {
+  addPullRequestReviewThread(input: $input) {
+    thread {
+      ...ThreadFields
+      firstComment: comments(first: 1) {
+        nodes { pullRequestReview { id comments(first: 1) { totalCount } } }
+      }
+    }
+  }
+}
+${THREAD_FIELDS}`;
+/**
+ * Reply to a thread without a pullRequestReviewId (decisions.md). Verified live: when the viewer
+ * has no pending review GitHub creates and submits a one-comment review, so the reply is public
+ * at once; when a pending review exists GitHub attaches the reply to it (state PENDING) and it
+ * publishes with the review. Variables: threadId, body
+ */
+export const REPLY = /* GraphQL */ `
+mutation Reply($threadId: ID!, $body: String!) {
+  addPullRequestReviewThreadReply(input: { pullRequestReviewThreadId: $threadId, body: $body }) {
+    comment {
+      ...CommentFields
+      pullRequestReview { id state comments(first: 1) { totalCount } }
+    }
+  }
+}
+${COMMENT_FIELDS}`;
+/** Variables: id, body */
+export const UPDATE_COMMENT = /* GraphQL */ `
+mutation UpdateComment($id: ID!, $body: String!) {
+  updatePullRequestReviewComment(input: { pullRequestReviewCommentId: $id, body: $body }) {
+    pullRequestReviewComment { ...CommentFields }
+  }
+}
+${COMMENT_FIELDS}`;
+/** Variables: id */
+export const DELETE_COMMENT = /* GraphQL */ `
+mutation DeleteComment($id: ID!) {
+  deletePullRequestReviewComment(input: { id: $id }) {
+    pullRequestReviewComment { id }
+  }
+}`;
+/** Submit an existing pending review. Variables: reviewId, event, body? */
+export const SUBMIT_REVIEW = /* GraphQL */ `
+mutation SubmitReview($reviewId: ID!, $event: PullRequestReviewEvent!, $body: String) {
+  submitPullRequestReview(input: { pullRequestReviewId: $reviewId, event: $event, body: $body }) {
+    pullRequestReview { id state url }
+  }
+}`;
+/** Create and submit a review in one call (no pending review exists). Variables: pullRequestId, commitOID, event, body? */
+export const ADD_AND_SUBMIT_REVIEW = /* GraphQL */ `
+mutation AddAndSubmitReview($pullRequestId: ID!, $commitOID: GitObjectID, $event: PullRequestReviewEvent!, $body: String) {
+  addPullRequestReview(input: { pullRequestId: $pullRequestId, commitOID: $commitOID, event: $event, body: $body }) {
+    pullRequestReview { id state url }
+  }
+}`;
+/** Delete a pending review and all its draft comments. Variables: reviewId */
+export const DISCARD_REVIEW = /* GraphQL */ `
+mutation DiscardReview($reviewId: ID!) {
+  deletePullRequestReview(input: { pullRequestReviewId: $reviewId }) {
+    pullRequestReview { id }
+  }
+}`;
+/** Variables: pullRequestId, path */
+export const MARK_VIEWED = /* GraphQL */ `
+mutation MarkViewed($pullRequestId: ID!, $path: String!) {
+  markFileAsViewed(input: { pullRequestId: $pullRequestId, path: $path }) { pullRequest { id } }
+}`;
+/** Variables: pullRequestId, path */
+export const UNMARK_VIEWED = /* GraphQL */ `
+mutation UnmarkViewed($pullRequestId: ID!, $path: String!) {
+  unmarkFileAsViewed(input: { pullRequestId: $pullRequestId, path: $path }) { pullRequest { id } }
+}`;