feat: add get-pr-status command to dev-workflow - #193

import { writeFileSync } from 'node:fs'
import type { WorkflowResult } from '../workflow-runner/workflow-runner'
import type { CompleteTaskContext } from './complete-task'

const nextActionSchema = z.enum(['fix_errors', 'fix_review', 'resolve_feedback', 'done'])
type NextAction = z.infer<typeof nextActionSchema>

const failedReviewerSchema = z.object({
  name: z.string(),
  summary: z.string(),
  reportPath: z.string(),
})
type FailedReviewer = z.infer<typeof failedReviewerSchema>

const failedReviewerArraySchema = z.array(failedReviewerSchema)

const completeTaskResultSchema = z.object({
  success: z.boolean(),
  nextAction: nextActionSchema,
  nextInstructions: z.string(),
  output: z.unknown().optional(),
  prUrl: z.string().optional(),
  failedStep: z.string().optional(),
  logFile: z.string().optional(),
  failedReviewers: z.array(failedReviewerSchema).optional(),
})
export type CompleteTaskResult = z.infer<typeof completeTaskResultSchema>

function isFailedReviewerArray(value: unknown): value is FailedReviewer[] {
  return failedReviewerArraySchema.safeParse(value).success
}

const errorDetailsSchema = z.object({
  type: z.enum(['fix_errors', 'fix_review', 'resolve_feedback', 'done']),
  details: z.unknown(),
})

type ErrorDetails = z.infer<typeof errorDetailsSchema>

function isErrorDetails(value: unknown): value is ErrorDetails {
  return errorDetailsSchema.safeParse(value).success
}

function formatFailureInstructions(error: unknown): {
  nextAction: NextAction
  instructions: string
  failedReviewers?: FailedReviewer[]
} {
  if (!isErrorDetails(error)) {
    return {
      nextAction: 'fix_errors',
      instructions: String(error),
    }
  }

  const {
    type, details 
  } = error

  if (type === 'fix_errors') {
    return {
      nextAction: 'fix_errors',
      instructions: [
        'Build, lint, or test errors found.',
        '',
        'ERRORS:',
        String(details),
        '',
        'ACTION: Fix the errors above, then re-run /complete-task.',
      ].join('\n'),
    }
  }

  if (type === 'fix_review') {
    if (isFailedReviewerArray(details)) {
      const reports = details.map((f) => `- ${f.reportPath}: ${f.summary}`).join('\n')
      return {
        nextAction: 'fix_review',
        instructions: [
          'Code review found issues that must be addressed.',
          '',
          'REVIEW REPORTS:',
          reports,
          '',
          'ACTION: Read the review reports above, fix the issues, then re-run /complete-task.',
          '',
          'DECISION FRAMEWORK:',
          '- Fix automatically if: clear/unambiguous, low risk, mechanical (typos, formatting, simple refactors)',
          '- Report to user if: ambiguous (multiple valid approaches), high risk, requires judgment, conflicts with requirements',
          '- Default: fix automatically unless a "report" condition applies',
        ].join('\n'),
        failedReviewers: details,
      }
    }
    return {
      nextAction: 'fix_review',
      instructions: [
        'Code review found issues:',
        String(details),
        '',
        'ACTION: Fix the issues and re-run /complete-task.',
      ].join('\n'),
    }
  }

  if (type === 'resolve_feedback') {
    return {
      nextAction: 'resolve_feedback',
      instructions: [
        'PR has unresolved review feedback from humans.',
        '',
        'ACTION: Address each feedback item, then re-run /complete-task.',
      ].join('\n'),
    }
  }

  return {
    nextAction: 'fix_errors',
    instructions: String(details),
  }
}

export function formatCompleteTaskResult(
  result: WorkflowResult,
  ctx: CompleteTaskContext,
): CompleteTaskResult {
  if (!result.success) {
    const formatted = formatFailureInstructions(result.error)
    const failedStep = result.failedStep

    if (formatted.nextAction === 'fix_errors' && failedStep && ctx.reviewDir) {
      const logFile = `${ctx.reviewDir}/${failedStep}.log`
      writeFileSync(logFile, formatted.instructions, 'utf-8')

      return {
        success: false,
        nextAction: formatted.nextAction,
        nextInstructions: `Step "${failedStep}" failed. See ${logFile} for details.`,
        failedStep,
        logFile,
      }
    }

    return {
      success: false,
      nextAction: formatted.nextAction,
      nextInstructions: formatted.instructions,
      failedStep,
      failedReviewers: formatted.failedReviewers,

const workflowResultSchema = z.object({
  success: z.boolean(),
  output: z.unknown().optional(),
  error: z.unknown().optional(),
  failedStep: z.string().optional(),
})
export type WorkflowResult = z.infer<typeof workflowResultSchema>

export interface Step<T extends BaseContext> {
  name: string
  execute: (ctx: T) => Promise<StepResult>
}

export function success(output?: unknown): StepResult {
  return {
    type: 'success',
    output,
  }
}

export function failure(details: unknown): StepResult {
  return {
    type: 'failure',
    details,
  }
}

export function workflow<T extends BaseContext>(steps: Step<T>[]) {
  return async (ctx: T): Promise<WorkflowResult> => {
    for (const step of steps) {
      const result = await step.execute(ctx)

      if (result.type === 'failure') {
        return {
          success: false,
          error: result.details,
          failedStep: step.name,
        }
      }

      if (result.output !== undefined) {
        ctx.output = result.output

const DELETED_USER_PLACEHOLDER = '[deleted]'

type PRState = 'open' | 'closed' | 'merged'

interface PR {
  number: number
  url: string
}

interface PRWithState extends PR {state: PRState}

interface CreatePROptions {
  title: string
  body: string
  branch: string
  base?: string
}

interface FeedbackItem {
  threadId: string
  file: string | null
  line: number | null
  author: string
  body: string
}

interface CIResult {
  failed: boolean
  output: string
}

function determinePRState(mergedAt: string | null, state: string): PRState {
  if (mergedAt) {
    return 'merged'
  }
  if (state === 'open') {
    return 'open'
  }
  return 'closed'
}

const repo = simpleGit()

const GITHUB_HTTPS_URL_PATTERN = /github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/
const GITHUB_SSH_URL_PATTERN = /github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/

function parseGitHubUrl(url: string): {
  owner: string
  repo: string
} {
  const httpsMatch = GITHUB_HTTPS_URL_PATTERN.exec(url)
  if (httpsMatch) {
    return {
      owner: httpsMatch[1],
      repo: httpsMatch[2],
    }
  }

  const sshMatch = GITHUB_SSH_URL_PATTERN.exec(url)
  if (sshMatch) {
    return {
      owner: sshMatch[1],
      repo: sshMatch[2],
    }
  }

  throw new GitHubError(`Could not parse GitHub URL: ${url}`)
}

export async function getRepoInfo(): Promise<{
  owner: string
  repo: string
}> {
  const remotes = await repo.getRemotes(true)
  const origin = remotes.find((r) => r.name === 'origin')

  if (!origin?.refs.fetch) {
    throw new GitHubError('No origin remote found. Is this a git repository with a GitHub remote?')
  }

  return parseGitHubUrl(origin.refs.fetch)
}

export const github = {
  async findPRForBranch(branch: string): Promise<number | undefined> {
    const {
      owner, repo 
    } = await getRepoInfo()

    const response = await getOctokit().pulls.list({
      owner,
      repo,
      head: `${owner}:${branch}`,
      state: 'open',
    })

    if (response.data.length === 0) {
      return undefined
    }

    return response.data[0].number
  },

  async findPRForBranchWithState(branch: string): Promise<PRWithState | undefined> {
    const {
      owner, repo 
    } = await getRepoInfo()

    const response = await getOctokit().pulls.list({
      owner,
      repo,
      head: `${owner}:${branch}`,
      state: 'all',
    })

    if (response.data.length === 0) {
      return undefined
    }

    const pr = response.data[0]
    const prState = determinePRState(pr.merged_at, pr.state)

    return {
      number: pr.number,
      url: pr.html_url,
      state: prState,
    }
  },