task-while 0.0.1

package/src/runtime/git.ts

@@ -0,0 +1,137 @@
+import path from 'node:path'
+
+import { execa } from 'execa'
+
+import { filterPorcelainStatus } from '../utils/fs'
+
+import type {
+  GitCheckoutBranchOptions,
+  GitCommitTaskInput,
+  GitCommitTaskResult,
+  GitPort,
+  GitPushBranchOptions,
+} from '../core/runtime'
+
+function normalizeRelativePath(value: string) {
+  return value.split(path.sep).join('/')
+}
+
+async function runGit(cwd: string, args: string[]) {
+  const result = await execa('git', args, { cwd })
+  return result.stdout.trim()
+}
+
+export class GitRuntime implements GitPort {
+  private readonly runtimeDirRelative: string
+
+  public constructor(
+    private readonly workspaceRoot: string,
+    runtimeDir: string,
+  ) {
+    this.runtimeDirRelative = normalizeRelativePath(
+      path.relative(this.workspaceRoot, runtimeDir),
+    )
+  }
+
+  public async checkoutBranch(
+    name: string,
+    options?: GitCheckoutBranchOptions,
+  ) {
+    if (options?.create) {
+      const args = ['checkout', '-b', name]
+      if (options.startPoint) {
+        args.push(options.startPoint)
+      }
+      await runGit(this.workspaceRoot, args)
+      return
+    }
+    await runGit(this.workspaceRoot, ['checkout', name])
+  }
+
+  public async checkoutRemoteBranch(name: string) {
+    await runGit(this.workspaceRoot, ['fetch', 'origin', name])
+    await runGit(this.workspaceRoot, ['checkout', '-B', name, 'FETCH_HEAD'])
+  }
+
+  public async commitTask(
+    input: GitCommitTaskInput,
+  ): Promise<GitCommitTaskResult> {
+    await runGit(this.workspaceRoot, ['add', '-A', '.'])
+    await runGit(this.workspaceRoot, ['reset', '--', this.runtimeDirRelative])
+    await runGit(this.workspaceRoot, [
+      'commit',
+      '--allow-empty',
+      '-m',
+      input.message,
+    ])
+    const commitSha = await runGit(this.workspaceRoot, ['rev-parse', 'HEAD'])
+    return { commitSha }
+  }
+
+  public async deleteLocalBranch(name: string) {
+    await runGit(this.workspaceRoot, ['branch', '-D', name])
+  }
+
+  public async getChangedFilesSinceHead() {
+    const [changed, untracked] = await Promise.all([
+      runGit(this.workspaceRoot, ['diff', '--name-only', 'HEAD']),
+      runGit(this.workspaceRoot, [
+        'ls-files',
+        '--others',
+        '--exclude-standard',
+      ]),
+    ])
+    const files = new Set(
+      [...changed.split('\n'), ...untracked.split('\n')]
+        .map((item) => item.trim())
+        .filter(Boolean)
+        .filter(
+          (item) =>
+            item !== this.runtimeDirRelative &&
+            !item.startsWith(`${this.runtimeDirRelative}/`),
+        ),
+    )
+    return [...files].sort()
+  }
+
+  public async getCurrentBranch() {
+    return runGit(this.workspaceRoot, ['branch', '--show-current'])
+  }
+
+  public async getHeadSha() {
+    return runGit(this.workspaceRoot, ['rev-parse', 'HEAD'])
+  }
+
+  public async getHeadSubject() {
+    return runGit(this.workspaceRoot, ['log', '-1', '--format=%s', 'HEAD'])
+  }
+
+  public async getHeadTimestamp() {
+    return runGit(this.workspaceRoot, ['log', '-1', '--format=%cI', 'HEAD'])
+  }
+
+  public async pullFastForward(branch: string) {
+    await runGit(this.workspaceRoot, ['pull', '--ff-only', 'origin', branch])
+  }
+
+  public async pushBranch(name: string, options?: GitPushBranchOptions) {
+    const args = ['push']
+    if (options?.setUpstream) {
+      args.push('-u')
+    }
+    args.push('origin', name)
+    await runGit(this.workspaceRoot, args)
+  }
+
+  public async requireCleanWorktree() {
+    const status = await runGit(this.workspaceRoot, ['status', '--porcelain'])
+    const relevantLines = filterPorcelainStatus(
+      status.split('\n').filter(Boolean),
+      this.runtimeDirRelative,
+    )
+
+    if (relevantLines.length !== 0) {
+      throw new Error('Worktree must be clean before running task-while')
+    }
+  }
+}

package/src/runtime/github-pr-snapshot-decode.ts

@@ -0,0 +1,307 @@
+import type {
+  PullRequestDiscussionComment,
+  PullRequestReaction,
+  PullRequestReviewSummary,
+  PullRequestReviewThreadComment,
+} from '../core/runtime'
+
+export interface ConnectionPage<T> {
+  nodes: T[]
+  pageInfo: ConnectionPageInfo
+}
+
+export interface ConnectionPageInfo {
+  endCursor: null | string
+  hasNextPage: boolean
+}
+
+export interface PullRequestSnapshotPage {
+  comments: ConnectionPage<PullRequestDiscussionComment> | null
+  files: ConnectionPage<string> | null
+  reactions: ConnectionPage<PullRequestReaction> | null
+  reviews: ConnectionPage<PullRequestReviewSummary> | null
+  reviewThreads: ConnectionPage<ReviewThreadPageNode> | null
+}
+
+export interface ReviewThreadPageNode {
+  comments: PullRequestReviewThreadComment[]
+  commentsPageInfo: ConnectionPageInfo
+  id: string
+  isOutdated: boolean
+  isResolved: boolean
+}
+
+export interface RequestedSnapshotConnections {
+  comments: boolean
+  files: boolean
+  reactions: boolean
+  reviews: boolean
+  reviewThreads: boolean
+}
+
+export interface ParseRequestedConnectionInput<T> {
+  label: string
+  mapNode: (node: Record<string, unknown>) => T
+  requested: boolean
+  value: unknown
+}
+
+function asBoolean(value: unknown) {
+  return value === true
+}
+
+function asNullableNumber(value: unknown) {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null
+}
+
+function asNullableString(value: unknown) {
+  return typeof value === 'string' ? value : null
+}
+
+function asNumericId(value: unknown) {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return value
+  }
+  if (typeof value === 'string' && value.trim() !== '') {
+    const parsed = Number(value)
+    return Number.isFinite(parsed) ? parsed : 0
+  }
+  return 0
+}
+
+function asRecord(value: unknown) {
+  return value && typeof value === 'object'
+    ? (value as Record<string, unknown>)
+    : null
+}
+
+function asString(value: unknown) {
+  return typeof value === 'string' ? value : ''
+}
+
+interface GraphQLReviewThreadCommentsNode {
+  comments?: Record<string, unknown>
+}
+
+interface GraphQLReviewThreadCommentsData {
+  node?: GraphQLReviewThreadCommentsNode
+}
+
+interface GraphQLReviewThreadCommentsPayload {
+  data?: GraphQLReviewThreadCommentsData
+}
+
+interface GraphQLRepositoryPullRequestPayload {
+  pullRequest?: Record<string, unknown>
+}
+
+interface GraphQLSnapshotRepository {
+  repository?: GraphQLRepositoryPullRequestPayload
+}
+
+interface GraphQLSnapshotPayload {
+  data?: GraphQLSnapshotRepository
+}
+
+interface LoginLike {
+  login?: unknown
+}
+
+function invalidGraphQLError(label: string) {
+  return new Error(`Invalid GraphQL connection: ${label}`)
+}
+
+function missingGraphQLError(label: string) {
+  return new Error(`Missing GraphQL connection: ${label}`)
+}
+
+function requirePageInfo(value: unknown, label: string) {
+  const record = asRecord(value)
+  if (!record) {
+    throw invalidGraphQLError(`${label}.pageInfo`)
+  }
+  if (record.endCursor !== null && typeof record.endCursor !== 'string') {
+    throw invalidGraphQLError(`${label}.pageInfo.endCursor`)
+  }
+  if (typeof record.hasNextPage !== 'boolean') {
+    throw invalidGraphQLError(`${label}.pageInfo.hasNextPage`)
+  }
+  if (record.hasNextPage && typeof record.endCursor !== 'string') {
+    throw invalidGraphQLError(`${label}.pageInfo.endCursor`)
+  }
+  return {
+    endCursor: record.endCursor,
+    hasNextPage: record.hasNextPage,
+  }
+}
+
+function requireConnectionRecord(value: unknown, label: string) {
+  const record = asRecord(value)
+  if (!record) {
+    throw missingGraphQLError(label)
+  }
+  if (!Array.isArray(record.nodes)) {
+    throw invalidGraphQLError(`${label}.nodes`)
+  }
+  return {
+    nodes: record.nodes as Record<string, unknown>[],
+    pageInfo: requirePageInfo(record.pageInfo, label),
+  }
+}
+
+function parseConnection<T>(
+  value: unknown,
+  label: string,
+  mapNode: (node: Record<string, unknown>) => T,
+): ConnectionPage<T> {
+  const record = requireConnectionRecord(value, label)
+  return {
+    nodes: record.nodes.map((node) => mapNode(node)),
+    pageInfo: record.pageInfo,
+  }
+}
+
+function parseRequestedConnection<T>(
+  input: ParseRequestedConnectionInput<T>,
+): ConnectionPage<T> | null {
+  if (!input.requested) {
+    return null
+  }
+  return parseConnection(input.value, input.label, input.mapNode)
+}
+
+export function parseReviewThreadCommentsPage(
+  raw: string,
+): ConnectionPage<PullRequestReviewThreadComment> {
+  const payload = JSON.parse(raw) as GraphQLReviewThreadCommentsPayload
+  return parseConnection(
+    payload.data?.node?.comments,
+    'reviewThread.comments',
+    (node) => toReviewThreadComment(node),
+  )
+}
+
+export function parseSnapshotPage(
+  raw: string,
+  requested: RequestedSnapshotConnections,
+): PullRequestSnapshotPage {
+  const payload = JSON.parse(raw) as GraphQLSnapshotPayload
+  const repository = asRecord(payload.data?.repository)
+  const record = asRecord(repository?.pullRequest)
+  if (!record) {
+    throw new Error('Missing GraphQL node: repository.pullRequest')
+  }
+  return {
+    comments: parseRequestedConnection({
+      label: 'comments',
+      requested: requested.comments,
+      value: record.comments,
+      mapNode: (node) => toDiscussionComment(node),
+    }),
+    files: parseRequestedConnection({
+      label: 'files',
+      requested: requested.files,
+      value: record.files,
+      mapNode: (node) => asString(node.path),
+    }),
+    reactions: parseRequestedConnection({
+      label: 'reactions',
+      requested: requested.reactions,
+      value: record.reactions,
+      mapNode: (node) => toReaction(node),
+    }),
+    reviews: parseRequestedConnection({
+      label: 'reviews',
+      requested: requested.reviews,
+      value: record.reviews,
+      mapNode: (node) => toReviewSummary(node),
+    }),
+    reviewThreads: parseRequestedConnection({
+      label: 'reviewThreads',
+      requested: requested.reviewThreads,
+      value: record.reviewThreads,
+      mapNode: (node) => toReviewThreadPageNode(node),
+    }),
+  }
+}
+
+function toDiscussionComment(
+  item: Record<string, unknown>,
+): PullRequestDiscussionComment {
+  return {
+    id: asNumericId(item.id ?? item.databaseId),
+    body: asString(item.body),
+    createdAt: asString(item.created_at ?? item.createdAt),
+    url: asString(item.html_url ?? item.url),
+    userLogin: asString(
+      (item.user as LoginLike | null)?.login ??
+        (item.author as LoginLike | null)?.login,
+    ),
+  }
+}
+
+function toReaction(item: Record<string, unknown>): PullRequestReaction {
+  return {
+    content: toReactionContent(asString(item.content)),
+    createdAt: asString(item.created_at ?? item.createdAt),
+    userLogin: asString((item.user as LoginLike | null)?.login),
+  }
+}
+
+function toReactionContent(value: string) {
+  switch (value) {
+    case 'THUMBS_DOWN':
+      return '-1'
+    case 'THUMBS_UP':
+      return '+1'
+    default:
+      return value.toLowerCase()
+  }
+}
+
+function toReviewSummary(
+  item: Record<string, unknown>,
+): PullRequestReviewSummary {
+  return {
+    id: asNumericId(item.id ?? item.fullDatabaseId),
+    body: asString(item.body),
+    state: asString(item.state),
+    submittedAt: asNullableString(item.submitted_at ?? item.submittedAt),
+    url: asString(item.html_url ?? item.url),
+    userLogin: asString(
+      (item.user as LoginLike | null)?.login ??
+        (item.author as LoginLike | null)?.login,
+    ),
+  }
+}
+
+function toReviewThreadComment(
+  item: Record<string, unknown>,
+): PullRequestReviewThreadComment {
+  return {
+    body: asString(item.body),
+    createdAt: asString(item.createdAt),
+    line: asNullableNumber(item.line),
+    path: asString(item.path),
+    url: asString(item.url),
+    userLogin: asString((item.author as LoginLike | null)?.login),
+  }
+}
+
+function toReviewThreadPageNode(
+  item: Record<string, unknown>,
+): ReviewThreadPageNode {
+  const commentsConnection = requireConnectionRecord(
+    item.comments,
+    'reviewThreads.comments',
+  )
+  return {
+    id: asString(item.id),
+    commentsPageInfo: commentsConnection.pageInfo,
+    isOutdated: asBoolean(item.isOutdated),
+    isResolved: asBoolean(item.isResolved),
+    comments: commentsConnection.nodes.map((comment) =>
+      toReviewThreadComment(comment),
+    ),
+  }
+}

package/src/runtime/github-pr-snapshot-queries.ts

@@ -0,0 +1,137 @@
+export interface BuildReviewThreadCommentsArgsInput {
+  after?: null | string
+  threadId: string
+}
+
+export interface BuildSnapshotArgsInput {
+  commentsAfter?: null | string
+  filesAfter?: null | string
+  includeComments: boolean
+  includeFiles: boolean
+  includeReactions: boolean
+  includeReviews: boolean
+  includeReviewThreads: boolean
+  number: number
+  owner: string
+  reactionsAfter?: null | string
+  repo: string
+  reviewsAfter?: null | string
+  reviewThreadsAfter?: null | string
+}
+
+export function buildReviewThreadCommentsArgs(
+  input: BuildReviewThreadCommentsArgsInput,
+) {
+  const args = ['api', 'graphql', '-F', `threadId=${input.threadId}`]
+  if (input.after) {
+    args.push('-f', `commentsAfter=${input.after}`)
+  }
+  args.push(
+    '-f',
+    `query=${[
+      'query($threadId: ID!, $commentsAfter: String) {',
+      '  node(id: $threadId) {',
+      '    ... on PullRequestReviewThread {',
+      '      comments(first: 100, after: $commentsAfter) {',
+      '        pageInfo { hasNextPage endCursor }',
+      '        nodes { author { login } body createdAt path line url }',
+      '      }',
+      '    }',
+      '  }',
+      '}',
+    ].join('\n')}`,
+  )
+  return args
+}
+
+export function buildSnapshotArgs(input: BuildSnapshotArgsInput) {
+  const args = [
+    'api',
+    'graphql',
+    '-f',
+    `owner=${input.owner}`,
+    '-f',
+    `repo=${input.repo}`,
+    '-F',
+    `number=${input.number}`,
+    '-F',
+    `includeFiles=${String(input.includeFiles)}`,
+    '-F',
+    `includeReactions=${String(input.includeReactions)}`,
+    '-F',
+    `includeReviews=${String(input.includeReviews)}`,
+    '-F',
+    `includeComments=${String(input.includeComments)}`,
+    '-F',
+    `includeReviewThreads=${String(input.includeReviewThreads)}`,
+  ]
+  if (input.filesAfter) {
+    args.push('-f', `filesAfter=${input.filesAfter}`)
+  }
+  if (input.reactionsAfter) {
+    args.push('-f', `reactionsAfter=${input.reactionsAfter}`)
+  }
+  if (input.reviewsAfter) {
+    args.push('-f', `reviewsAfter=${input.reviewsAfter}`)
+  }
+  if (input.commentsAfter) {
+    args.push('-f', `commentsAfter=${input.commentsAfter}`)
+  }
+  if (input.reviewThreadsAfter) {
+    args.push('-f', `reviewThreadsAfter=${input.reviewThreadsAfter}`)
+  }
+  args.push(
+    '-f',
+    `query=${[
+      'query(',
+      '  $owner: String!,',
+      '  $repo: String!,',
+      '  $number: Int!,',
+      '  $includeFiles: Boolean!,',
+      '  $includeReactions: Boolean!,',
+      '  $includeReviews: Boolean!,',
+      '  $includeComments: Boolean!,',
+      '  $includeReviewThreads: Boolean!,',
+      '  $filesAfter: String,',
+      '  $reactionsAfter: String,',
+      '  $reviewsAfter: String,',
+      '  $commentsAfter: String,',
+      '  $reviewThreadsAfter: String',
+      ') {',
+      '  repository(owner: $owner, name: $repo) {',
+      '    pullRequest(number: $number) {',
+      '      files(first: 100, after: $filesAfter) @include(if: $includeFiles) {',
+      '        pageInfo { hasNextPage endCursor }',
+      '        nodes { path }',
+      '      }',
+      '      reactions(first: 100, after: $reactionsAfter) @include(if: $includeReactions) {',
+      '        pageInfo { hasNextPage endCursor }',
+      '        nodes { content createdAt user { login } }',
+      '      }',
+      '      reviews(first: 100, after: $reviewsAfter) @include(if: $includeReviews) {',
+      '        pageInfo { hasNextPage endCursor }',
+      '        nodes { author { login } body fullDatabaseId state submittedAt url }',
+      '      }',
+      '      comments(first: 100, after: $commentsAfter) @include(if: $includeComments) {',
+      '        pageInfo { hasNextPage endCursor }',
+      '        nodes { author { login } body createdAt databaseId url }',
+      '      }',
+      '      reviewThreads(first: 100, after: $reviewThreadsAfter) @include(if: $includeReviewThreads) {',
+      '        pageInfo { hasNextPage endCursor }',
+      '        nodes {',
+      '          id',
+      '          isResolved',
+      '          isOutdated',
+      '          comments(first: 100) {',
+      '            pageInfo { hasNextPage endCursor }',
+      '            nodes { author { login } body createdAt path line url }',
+      '          }',
+      '        }',
+      '      }',
+      '    }',
+      '  }',
+      '}',
+    ].join('\n')}`,
+  )
+  return args
+}