SCM

export interface SCM {
  readonly name: string;
  
  // PR Lifecycle
  detectPR(session: Session, project: ProjectConfig): Promise<PRInfo | null>;
  getPRState(pr: PRInfo): Promise<PRState>;
  getPRSummary?(pr: PRInfo): Promise<{
    state: PRState;
    title: string;
    additions: number;
    deletions: number;
  }>;
  mergePR(pr: PRInfo, method?: MergeMethod): Promise<void>;
  closePR(pr: PRInfo): Promise<void>;
  
  // CI Tracking
  getCIChecks(pr: PRInfo): Promise<CICheck[]>;
  getCISummary(pr: PRInfo): Promise<CIStatus>;
  
  // Review Tracking
  getReviews(pr: PRInfo): Promise<Review[]>;
  getReviewDecision(pr: PRInfo): Promise<ReviewDecision>;
  getPendingComments(pr: PRInfo): Promise<ReviewComment[]>;
  getAutomatedComments(pr: PRInfo): Promise<AutomatedComment[]>;
  
  // Merge Readiness
  getMergeability(pr: PRInfo): Promise<MergeReadiness>;
}

export interface PRInfo {
  number: number;
  url: string;
  title: string;
  owner: string;
  repo: string;
  branch: string;
  baseBranch: string;
  isDraft: boolean;
}

export type PRState = "open" | "merged" | "closed";

export interface CICheck {
  name: string;
  status: "pending" | "running" | "passed" | "failed" | "skipped";
  url?: string;
  conclusion?: string;
  startedAt?: Date;
  completedAt?: Date;
}

export type CIStatus = "pending" | "passing" | "failing" | "none";

export interface Review {
  author: string;
  state: "approved" | "changes_requested" | "commented" | "dismissed" | "pending";
  body?: string;
  submittedAt: Date;
}

export type ReviewDecision = "approved" | "changes_requested" | "pending" | "none";

export interface ReviewComment {
  id: string;
  author: string;
  body: string;
  path?: string;
  line?: number;
  isResolved: boolean;
  createdAt: Date;
  url: string;
}

export interface AutomatedComment {
  id: string;
  botName: string;
  body: string;
  path?: string;
  line?: number;
  severity: "error" | "warning" | "info";
  createdAt: Date;
  url: string;
}

export interface MergeReadiness {
  mergeable: boolean;
  ciPassing: boolean;
  approved: boolean;
  noConflicts: boolean;
  blockers: string[];
}

export type MergeMethod = "merge" | "squash" | "rebase";

import type { SCM, PRInfo, PRState, CIStatus, ReviewDecision, MergeReadiness } from "@composio/ao-core";
import { execFile } from "node:child_process";
import { promisify } from "node:util";

const execFileAsync = promisify(execFile);

export function create(): SCM {
  return {
    name: "github",
    
    async detectPR(session: Session, project: ProjectConfig): Promise<PRInfo | null> {
      if (!session.branch) return null;
      
      const { stdout } = await execFileAsync("gh", [
        "pr",
        "view",
        session.branch,
        "--repo", project.repo,
        "--json", "number,url,title,headRefName,baseRefName,isDraft"
      ], { timeout: 30_000 }).catch(() => ({ stdout: "" }));
      
      if (!stdout) return null;
      
      const data = JSON.parse(stdout);
      const [owner, repo] = project.repo.split("/");
      
      return {
        number: data.number,
        url: data.url,
        title: data.title,
        owner,
        repo,
        branch: data.headRefName,
        baseBranch: data.baseRefName,
        isDraft: data.isDraft
      };
    },
    
    async getPRState(pr: PRInfo): Promise<PRState> {
      const { stdout } = await execFileAsync("gh", [
        "pr",
        "view",
        pr.number.toString(),
        "--repo", `${pr.owner}/${pr.repo}`,
        "--json", "state"
      ], { timeout: 10_000 });
      
      const data = JSON.parse(stdout);
      return data.state.toLowerCase() as PRState;
    },
    
    async getCISummary(pr: PRInfo): Promise<CIStatus> {
      const checks = await this.getCIChecks(pr);
      
      if (checks.length === 0) return "none";
      
      const anyFailed = checks.some(c => c.status === "failed");
      const anyPending = checks.some(c => c.status === "pending" || c.status === "running");
      
      if (anyFailed) return "failing";
      if (anyPending) return "pending";
      return "passing";
    },
    
    async getReviewDecision(pr: PRInfo): Promise<ReviewDecision> {
      const { stdout } = await execFileAsync("gh", [
        "pr",
        "view",
        pr.number.toString(),
        "--repo", `${pr.owner}/${pr.repo}`,
        "--json", "reviewDecision"
      ], { timeout: 10_000 });
      
      const data = JSON.parse(stdout);
      
      if (!data.reviewDecision) return "none";
      
      const decision = data.reviewDecision.toLowerCase();
      if (decision === "approved") return "approved";
      if (decision === "changes_requested") return "changes_requested";
      if (decision === "review_required") return "pending";
      return "none";
    },
    
    async getMergeability(pr: PRInfo): Promise<MergeReadiness> {
      const [ciStatus, reviewDecision, state] = await Promise.all([
        this.getCISummary(pr),
        this.getReviewDecision(pr),
        this.getPRState(pr)
      ]);
      
      const ciPassing = ciStatus === "passing" || ciStatus === "none";
      const approved = reviewDecision === "approved";
      const noConflicts = true; // Would need to check mergeable state
      
      const blockers: string[] = [];
      if (!ciPassing) blockers.push("CI failing");
      if (!approved) blockers.push("Not approved");
      if (!noConflicts) blockers.push("Merge conflicts");
      
      return {
        mergeable: blockers.length === 0 && state === "open",
        ciPassing,
        approved,
        noConflicts,
        blockers
      };
    },
    
    async mergePR(pr: PRInfo, method = "squash"): Promise<void> {
      await execFileAsync("gh", [
        "pr",
        "merge",
        pr.number.toString(),
        "--repo", `${pr.owner}/${pr.repo}`,
        method === "merge" ? "--merge" : method === "rebase" ? "--rebase" : "--squash",
        "--delete-branch"
      ], { timeout: 30_000 });
    }
  };
}

import type { SCM } from "@composio/ao-core";

const scm: SCM = registry.get("scm", "github");

// Detect PR
const pr = await scm.detectPR(session, project);
if (pr) {
  // Check CI
  const ciStatus = await scm.getCISummary(pr);
  console.log(`CI status: ${ciStatus}`);
  
  // Check reviews
  const decision = await scm.getReviewDecision(pr);
  console.log(`Review decision: ${decision}`);
  
  // Check merge readiness
  const readiness = await scm.getMergeability(pr);
  if (readiness.mergeable) {
    await scm.mergePR(pr, "squash");
  } else {
    console.log(`Blockers: ${readiness.blockers.join(", ")}`);
  }
}