@ilya-lesikov/pi-pi 0.1.0

package/3p/pi-plannotator/packages/shared/pr-provider.test.ts

@@ -0,0 +1,266 @@
+import { describe, expect, test } from "bun:test";
+import {
+  getCliInstallUrl,
+  getCliName,
+  getDisplayRepo,
+  getMRLabel,
+  getMRNumberLabel,
+  getPlatformLabel,
+  isSameProject,
+  parsePRUrl,
+  prRefFromMetadata,
+  type PRMetadata,
+  type PRRef,
+} from "./pr-types";
+import {
+  getPRDiffScopeOptions,
+  getPRStackInfo,
+} from "./pr-stack";
+
+describe("pr-provider platform helpers", () => {
+  test("parses GitHub PR URLs including nested suffixes", () => {
+    const ref = parsePRUrl("https://github.com/backnotprop/plannotator/pull/364/files");
+
+    expect(ref).toEqual({
+      platform: "github",
+      host: "github.com",
+      owner: "backnotprop",
+      repo: "plannotator",
+      number: 364,
+    });
+  });
+
+  test("parses GitHub Enterprise PR URLs", () => {
+    const ref = parsePRUrl("https://ghe.company.com/org/repo/pull/99/files");
+
+    expect(ref).toEqual({
+      platform: "github",
+      host: "ghe.company.com",
+      owner: "org",
+      repo: "repo",
+      number: 99,
+    });
+  });
+
+  test("does not confuse GHE URL with GitLab", () => {
+    const ref = parsePRUrl("https://git.internal.corp/team/app/pull/5");
+
+    expect(ref).toEqual({
+      platform: "github",
+      host: "git.internal.corp",
+      owner: "team",
+      repo: "app",
+      number: 5,
+    });
+  });
+
+  test("parses GitLab.com MR URLs", () => {
+    const ref = parsePRUrl("https://gitlab.com/group/project/-/merge_requests/42/diffs");
+
+    expect(ref).toEqual({
+      platform: "gitlab",
+      host: "gitlab.com",
+      projectPath: "group/project",
+      iid: 42,
+    });
+  });
+
+  test("parses self-hosted GitLab MR URLs with nested groups", () => {
+    const ref = parsePRUrl("https://gitlab.example.com/group/subgroup/project/-/merge_requests/7");
+
+    expect(ref).toEqual({
+      platform: "gitlab",
+      host: "gitlab.example.com",
+      projectPath: "group/subgroup/project",
+      iid: 7,
+    });
+  });
+
+  test("returns null for unsupported URLs", () => {
+    expect(parsePRUrl("https://example.com/not-a-pr/123")).toBeNull();
+    expect(parsePRUrl("")).toBeNull();
+  });
+
+  test("formats platform-aware labels for GitHub and GitLab", () => {
+    const githubMeta: PRMetadata = {
+      platform: "github",
+      host: "github.com",
+      owner: "backnotprop",
+      repo: "plannotator",
+      number: 364,
+      title: "GitHub PR",
+      author: "backnotprop",
+      baseBranch: "main",
+      headBranch: "feature/github",
+      baseSha: "base",
+      headSha: "head",
+      url: "https://github.com/backnotprop/plannotator/pull/364",
+    };
+
+    const gitlabMeta: PRMetadata = {
+      platform: "gitlab",
+      host: "gitlab.example.com",
+      projectPath: "group/project",
+      iid: 42,
+      title: "GitLab MR",
+      author: "alice",
+      baseBranch: "main",
+      headBranch: "feature/gitlab",
+      baseSha: "base",
+      headSha: "head",
+      url: "https://gitlab.example.com/group/project/-/merge_requests/42",
+    };
+
+    expect(getPlatformLabel(githubMeta)).toBe("GitHub");
+    expect(getMRLabel(githubMeta)).toBe("PR");
+    expect(getMRNumberLabel(githubMeta)).toBe("#364");
+    expect(getDisplayRepo(githubMeta)).toBe("backnotprop/plannotator");
+
+    expect(getPlatformLabel(gitlabMeta)).toBe("GitLab");
+    expect(getMRLabel(gitlabMeta)).toBe("MR");
+    expect(getMRNumberLabel(gitlabMeta)).toBe("!42");
+    expect(getDisplayRepo(gitlabMeta)).toBe("group/project");
+  });
+
+  test("reconstructs refs and CLI metadata for each platform", () => {
+    const githubMeta: PRMetadata = {
+      platform: "github",
+      host: "github.com",
+      owner: "backnotprop",
+      repo: "plannotator",
+      number: 1,
+      title: "GitHub PR",
+      author: "backnotprop",
+      baseBranch: "main",
+      headBranch: "feature/github",
+      baseSha: "base",
+      headSha: "head",
+      url: "https://github.com/backnotprop/plannotator/pull/1",
+    };
+
+    const gitlabMeta: PRMetadata = {
+      platform: "gitlab",
+      host: "gitlab.example.com",
+      projectPath: "group/project",
+      iid: 2,
+      title: "GitLab MR",
+      author: "alice",
+      baseBranch: "main",
+      headBranch: "feature/gitlab",
+      baseSha: "base",
+      headSha: "head",
+      url: "https://gitlab.example.com/group/project/-/merge_requests/2",
+    };
+
+    const githubRef = prRefFromMetadata(githubMeta);
+    const gitlabRef = prRefFromMetadata(gitlabMeta);
+
+    expect(githubRef).toEqual({
+      platform: "github",
+      host: "github.com",
+      owner: "backnotprop",
+      repo: "plannotator",
+      number: 1,
+    });
+    expect(gitlabRef).toEqual({
+      platform: "gitlab",
+      host: "gitlab.example.com",
+      projectPath: "group/project",
+      iid: 2,
+    });
+
+    expect(getCliName(githubRef)).toBe("gh");
+    expect(getCliInstallUrl(githubRef)).toBe("https://cli.github.com");
+    expect(getCliName(gitlabRef)).toBe("glab");
+    expect(getCliInstallUrl(gitlabRef)).toBe("https://gitlab.com/gitlab-org/cli");
+  });
+});
+
+describe("PR stack helpers", () => {
+  const stackedMeta: PRMetadata = {
+    platform: "github",
+    host: "github.com",
+    owner: "backnotprop",
+    repo: "plannotator-stack-fixture",
+    number: 3,
+    title: "Validate user id",
+    author: "backnotprop",
+    baseBranch: "stack/auth-refactor",
+    headBranch: "stack/validation",
+    defaultBranch: "main",
+    baseSha: "base",
+    headSha: "head",
+    url: "https://github.com/backnotprop/plannotator-stack-fixture/pull/3",
+  };
+
+  test("infers a stacked PR when the base branch differs from the default branch", () => {
+    expect(getPRStackInfo(stackedMeta)).toEqual({
+      isStacked: true,
+      baseBranch: "stack/auth-refactor",
+      defaultBranch: "main",
+      label: "stack/validation stacked on stack/auth-refactor",
+      source: "branch-inferred",
+    });
+  });
+
+  test("does not infer a stack for the bottom PR targeting the default branch", () => {
+    expect(getPRStackInfo({
+      ...stackedMeta,
+      number: 1,
+      baseBranch: "main",
+      headBranch: "stack/base-cleanup",
+    })).toBeNull();
+  });
+
+  test("only enables full-stack scope when stacked metadata has a local checkout", () => {
+    expect(getPRDiffScopeOptions(stackedMeta, true)).toEqual([
+      {
+        id: "layer",
+        label: "Layer",
+        description: "Only changes relative to stack/auth-refactor.",
+        enabled: true,
+      },
+      {
+        id: "full-stack",
+        label: "Full stack",
+        description: "All changes from main to HEAD in the local checkout.",
+        enabled: true,
+      },
+    ]);
+
+    expect(getPRDiffScopeOptions(stackedMeta, false)[1].enabled).toBe(false);
+  });
+});
+
+describe("isSameProject", () => {
+  const ghRef: PRRef = { platform: "github", host: "github.com", owner: "acme", repo: "widgets", number: 1 };
+  const glRef: PRRef = { platform: "gitlab", host: "gitlab.com", projectPath: "acme/widgets", iid: 1 };
+
+  test("same GitHub project", () => {
+    expect(isSameProject(ghRef, { ...ghRef, number: 99 })).toBe(true);
+  });
+
+  test("different GitHub owner", () => {
+    expect(isSameProject(ghRef, { ...ghRef, owner: "other" })).toBe(false);
+  });
+
+  test("different GitHub repo", () => {
+    expect(isSameProject(ghRef, { ...ghRef, repo: "gadgets" })).toBe(false);
+  });
+
+  test("different GitHub host", () => {
+    expect(isSameProject(ghRef, { ...ghRef, host: "ghe.corp.com" })).toBe(false);
+  });
+
+  test("same GitLab project", () => {
+    expect(isSameProject(glRef, { ...glRef, iid: 99 })).toBe(true);
+  });
+
+  test("different GitLab projectPath", () => {
+    expect(isSameProject(glRef, { ...glRef, projectPath: "other/repo" })).toBe(false);
+  });
+
+  test("GitHub vs GitLab", () => {
+    expect(isSameProject(ghRef, glRef)).toBe(false);
+  });
+});

package/3p/pi-plannotator/packages/shared/pr-provider.ts

@@ -0,0 +1,123 @@
+/**
+ * Server-only PR/MR dispatch.
+ *
+ * Picks GitHub vs GitLab from PRRef.platform and delegates to the
+ * platform implementation in pr-github.ts / pr-gitlab.ts. These
+ * implementations may use Node built-ins (fs, os, path) for things
+ * like persisting failed comments — they must never be imported
+ * from browser code.
+ *
+ * Pure types and label helpers live in pr-types.ts, which is
+ * browser-safe.
+ */
+
+import { checkGhAuth, getGhUser, fetchGhPR, fetchGhPRContext, fetchGhPRFileContent, submitGhPRReview, fetchGhPRViewedFiles, markGhFilesViewed, fetchGhPRStack, fetchGhPRList } from "./pr-github";
+import { checkGlAuth, getGlUser, fetchGlMR, fetchGlMRContext, fetchGlFileContent, submitGlMRReview } from "./pr-gitlab";
+import type { PRRuntime, PRRef, PRMetadata, PRContext, PRReviewFileComment, PRStackTree, PRListItem } from "./pr-types";
+
+// Re-export the browser-safe surface so server callers can keep using
+// pr-provider as a single facade. Browser code imports from pr-types
+// directly to avoid pulling pr-github / pr-gitlab into the client bundle.
+export * from "./pr-types";
+
+// --- Dispatch Functions ---
+
+export async function checkAuth(runtime: PRRuntime, ref: PRRef): Promise<void> {
+  if (ref.platform === "github") return checkGhAuth(runtime, ref.host);
+  return checkGlAuth(runtime, ref.host);
+}
+
+export async function getUser(runtime: PRRuntime, ref: PRRef): Promise<string | null> {
+  if (ref.platform === "github") return getGhUser(runtime, ref.host);
+  return getGlUser(runtime, ref.host);
+}
+
+export async function fetchPR(
+  runtime: PRRuntime,
+  ref: PRRef,
+): Promise<{ metadata: PRMetadata; rawPatch: string }> {
+  if (ref.platform === "github") return fetchGhPR(runtime, ref);
+  return fetchGlMR(runtime, ref);
+}
+
+export async function fetchPRContext(
+  runtime: PRRuntime,
+  ref: PRRef,
+): Promise<PRContext> {
+  if (ref.platform === "github") return fetchGhPRContext(runtime, ref);
+  return fetchGlMRContext(runtime, ref);
+}
+
+export async function fetchPRFileContent(
+  runtime: PRRuntime,
+  ref: PRRef,
+  sha: string,
+  filePath: string,
+): Promise<string | null> {
+  if (ref.platform === "github") return fetchGhPRFileContent(runtime, ref, sha, filePath);
+  return fetchGlFileContent(runtime, ref, sha, filePath);
+}
+
+export async function submitPRReview(
+  runtime: PRRuntime,
+  ref: PRRef,
+  headSha: string,
+  action: "approve" | "comment",
+  body: string,
+  fileComments: PRReviewFileComment[],
+): Promise<void> {
+  if (ref.platform === "github") return submitGhPRReview(runtime, ref, headSha, action, body, fileComments);
+  return submitGlMRReview(runtime, ref, headSha, action, body, fileComments);
+}
+
+/**
+ * Fetch per-file "viewed" state for a PR.
+ * GitHub: returns { filePath: isViewed } map.
+ * GitLab: always returns {} (no server-side viewed state API).
+ */
+export async function fetchPRViewedFiles(
+  runtime: PRRuntime,
+  ref: PRRef,
+): Promise<Record<string, boolean>> {
+  if (ref.platform === "github") return fetchGhPRViewedFiles(runtime, ref);
+  return {}; // GitLab has no server-side viewed state
+}
+
+/**
+ * Mark or unmark files as viewed in a PR.
+ * GitHub: fires markFileAsViewed / unmarkFileAsViewed GraphQL mutations.
+ * GitLab: no-op (no server-side viewed state API).
+ */
+export async function markPRFilesViewed(
+  runtime: PRRuntime,
+  ref: PRRef,
+  prNodeId: string,
+  filePaths: string[],
+  viewed: boolean,
+): Promise<void> {
+  if (ref.platform === "github") return markGhFilesViewed(runtime, ref, prNodeId, filePaths, viewed);
+  // GitLab: no-op
+}
+
+/**
+ * Fetch the full stack tree for a stacked PR.
+ * Walks up from the current PR to the default branch, resolving
+ * PR numbers and titles for each intermediate branch.
+ * Returns null if the PR is not stacked or the API call fails.
+ */
+export async function fetchPRStack(
+  runtime: PRRuntime,
+  ref: PRRef,
+  metadata: PRMetadata,
+): Promise<PRStackTree | null> {
+  if (ref.platform === "github") return fetchGhPRStack(runtime, ref, metadata);
+  return null; // GitLab: not yet implemented
+}
+
+export async function fetchPRList(
+  runtime: PRRuntime,
+  ref: PRRef,
+): Promise<PRListItem[]> {
+  if (ref.platform === "github") return fetchGhPRList(runtime, ref);
+  return []; // GitLab: not yet implemented
+}

package/3p/pi-plannotator/packages/shared/pr-stack.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, test } from "bun:test";
+import type { PRMetadata } from "./pr-types";
+import type { GitCommandResult, ReviewGitRuntime } from "./review-core";
+import { runPRFullStackDiff } from "./pr-stack";
+
+function result(stdout = "", stderr = "", exitCode = 0): GitCommandResult {
+  return { stdout, stderr, exitCode };
+}
+
+const metadata: PRMetadata = {
+  platform: "github",
+  host: "github.com",
+  owner: "backnotprop",
+  repo: "plannotator-stack-fixture",
+  number: 3,
+  title: "Validate user id",
+  author: "backnotprop",
+  baseBranch: "stack/auth-refactor",
+  headBranch: "stack/validation",
+  defaultBranch: "main",
+  baseSha: "base",
+  headSha: "head",
+  url: "https://github.com/backnotprop/plannotator-stack-fixture/pull/3",
+};
+
+describe("runPRFullStackDiff", () => {
+  test("uses origin default branch when it is available", async () => {
+    const calls: string[][] = [];
+    const runtime: ReviewGitRuntime = {
+      async runGit(args) {
+        calls.push(args);
+        if (args[0] === "show-ref" && args[3] === "refs/remotes/origin/main") {
+          return result();
+        }
+        if (args[0] === "diff") {
+          return result("diff --git a/src/auth.ts b/src/auth.ts\n");
+        }
+        return result("", "unexpected", 1);
+      },
+      async readTextFile() {
+        return null;
+      },
+    };
+
+    const diff = await runPRFullStackDiff(runtime, metadata, "/tmp/repo");
+
+    expect(diff).toEqual({
+      patch: "diff --git a/src/auth.ts b/src/auth.ts\n",
+      label: "Full stack diff vs origin/main",
+    });
+    expect(calls.at(-1)).toEqual([
+      "diff",
+      "--no-ext-diff",
+      "--src-prefix=a/",
+      "--dst-prefix=b/",
+      "--end-of-options",
+      "origin/main...HEAD",
+    ]);
+  });
+
+  test("falls back to a local default branch", async () => {
+    const runtime: ReviewGitRuntime = {
+      async runGit(args) {
+        if (args[0] === "show-ref" && args[3] === "refs/remotes/origin/main") {
+          return result("", "", 1);
+        }
+        if (args[0] === "show-ref" && args[3] === "refs/heads/main") {
+          return result();
+        }
+        if (args[0] === "diff") {
+          return result("local branch patch");
+        }
+        return result("", "unexpected", 1);
+      },
+      async readTextFile() {
+        return null;
+      },
+    };
+
+    const diff = await runPRFullStackDiff(runtime, metadata);
+
+    expect(diff).toEqual({
+      patch: "local branch patch",
+      label: "Full stack diff vs main",
+    });
+  });
+
+  test("returns an error when no default branch ref exists locally", async () => {
+    const runtime: ReviewGitRuntime = {
+      async runGit() {
+        return result("", "", 1);
+      },
+      async readTextFile() {
+        return null;
+      },
+    };
+
+    const diff = await runPRFullStackDiff(runtime, metadata);
+
+    expect(diff.patch).toBe("");
+    expect(diff.label).toBe("Full stack diff unavailable");
+    expect(diff.error).toContain("Could not find origin/main or local main");
+  });
+});

package/3p/pi-plannotator/packages/shared/pr-stack.ts

@@ -0,0 +1,194 @@
+import type { DiffResult, ReviewGitRuntime } from "./review-core";
+import type {
+  PRDiffScopeOption,
+  PRMetadata,
+  PRStackInfo,
+  PRStackTree,
+  PRStackNode,
+} from "./pr-types";
+export type { PRDiffScope, PRDiffScopeOption, PRStackInfo, PRStackTree, PRStackNode } from "./pr-types";
+
+function branchNameIsSafe(branch: string): boolean {
+  return branch.trim().length > 0 && !branch.startsWith("-") && !branch.includes("\0");
+}
+
+export function getPRStackInfo(metadata: PRMetadata | undefined): PRStackInfo | null {
+  if (!metadata?.defaultBranch) return null;
+  if (metadata.baseBranch === metadata.defaultBranch) return null;
+
+  return {
+    isStacked: true,
+    baseBranch: metadata.baseBranch,
+    defaultBranch: metadata.defaultBranch,
+    label: `${metadata.headBranch} stacked on ${metadata.baseBranch}`,
+    source: "branch-inferred",
+  };
+}
+
+export function resolveStackInfo(
+  metadata: PRMetadata,
+  stackTree: PRStackTree | null,
+  existing?: PRStackInfo | null,
+): PRStackInfo | null {
+  if (existing) return existing;
+  if (!stackTree || stackTree.nodes.filter(n => !n.isDefaultBranch).length <= 1) return null;
+  return getPRStackInfo(metadata) ?? {
+    isStacked: true,
+    baseBranch: metadata.baseBranch,
+    defaultBranch: metadata.defaultBranch!,
+    label: `Root of stack — ${metadata.headBranch}`,
+    source: "tree-discovered",
+  };
+}
+
+export function getPRDiffScopeOptions(
+  metadata: PRMetadata | undefined,
+  hasLocalCheckout: boolean,
+): PRDiffScopeOption[] {
+  const stackInfo = getPRStackInfo(metadata);
+
+  return [
+    {
+      id: "layer",
+      label: "Layer",
+      description: metadata?.baseBranch
+        ? `Only changes relative to ${metadata.baseBranch}.`
+        : "Only changes from this review.",
+      enabled: true,
+    },
+    {
+      id: "full-stack",
+      label: "Full stack",
+      description: stackInfo?.defaultBranch
+        ? `All changes from ${stackInfo.defaultBranch} to HEAD in the local checkout.`
+        : "All changes from the default branch to HEAD in the local checkout.",
+      enabled: Boolean(stackInfo && hasLocalCheckout),
+    },
+  ];
+}
+
+export async function resolvePRFullStackBaseRef(
+  runtime: ReviewGitRuntime,
+  defaultBranch: string,
+  cwd?: string,
+): Promise<string | null> {
+  const remoteRef = `origin/${defaultBranch}`;
+  const remote = await runtime.runGit(
+    ["show-ref", "--verify", "--quiet", `refs/remotes/${remoteRef}`],
+    { cwd },
+  );
+  if (remote.exitCode === 0) return remoteRef;
+
+  const local = await runtime.runGit(
+    ["show-ref", "--verify", "--quiet", `refs/heads/${defaultBranch}`],
+    { cwd },
+  );
+  if (local.exitCode === 0) return defaultBranch;
+
+  return null;
+}
+
+export async function runPRFullStackDiff(
+  runtime: ReviewGitRuntime,
+  metadata: PRMetadata,
+  cwd?: string,
+): Promise<DiffResult> {
+  const defaultBranch = metadata.defaultBranch;
+  if (!defaultBranch || !branchNameIsSafe(defaultBranch)) {
+    return {
+      patch: "",
+      label: "Full stack diff unavailable",
+      error: "Could not determine a safe default branch for this review.",
+    };
+  }
+
+  const baseRef = await resolvePRFullStackBaseRef(runtime, defaultBranch, cwd);
+  if (!baseRef) {
+    return {
+      patch: "",
+      label: "Full stack diff unavailable",
+      error: `Could not find origin/${defaultBranch} or local ${defaultBranch} in this checkout.`,
+    };
+  }
+
+  const diffArgs = [
+    "diff",
+    "--no-ext-diff",
+    "--src-prefix=a/",
+    "--dst-prefix=b/",
+    "--end-of-options",
+    `${baseRef}...HEAD`,
+  ];
+  const diff = await runtime.runGit(diffArgs, { cwd });
+  if (diff.exitCode !== 0) {
+    const message = diff.stderr.trim() || `git ${diffArgs.join(" ")} failed`;
+    return {
+      patch: "",
+      label: "Full stack diff unavailable",
+      error: message.split("\n").find((line) => line.trim().length > 0) ?? message,
+    };
+  }
+
+  return {
+    patch: diff.stdout,
+    label: `Full stack diff vs ${baseRef}`,
+  };
+}
+
+/**
+ * Fetch and checkout a PR/MR head in a local worktree.
+ * Returns true if the checkout succeeded, false otherwise.
+ */
+export async function checkoutPRHead(
+  runtime: ReviewGitRuntime,
+  metadata: PRMetadata,
+  cwd: string,
+): Promise<boolean> {
+  const refSpec = metadata.platform === "github"
+    ? `refs/pull/${metadata.number}/head`
+    : `refs/merge-requests/${metadata.iid}/head`;
+
+  const fetch = await runtime.runGit(["fetch", "origin", refSpec], { cwd });
+  if (fetch.exitCode !== 0) return false;
+
+  const checkout = await runtime.runGit(["checkout", "FETCH_HEAD"], { cwd });
+  return checkout.exitCode === 0;
+}
+
+/**
+ * Build a minimal stack tree from existing metadata (no API calls).
+ * Used as a fallback when the full stack tree hasn't loaded yet.
+ */
+export function buildMinimalStackTree(
+  metadata: PRMetadata,
+  stackInfo: PRStackInfo,
+): PRStackTree {
+  const nodes: PRStackNode[] = [];
+
+  if (stackInfo.defaultBranch) {
+    nodes.push({
+      branch: stackInfo.defaultBranch,
+      isCurrent: false,
+      isDefaultBranch: true,
+    });
+  }
+
+  if (stackInfo.baseBranch !== stackInfo.defaultBranch) {
+    nodes.push({
+      branch: stackInfo.baseBranch,
+      isCurrent: false,
+      isDefaultBranch: false,
+    });
+  }
+
+  nodes.push({
+    branch: metadata.headBranch,
+    number: metadata.platform === "github" ? metadata.number : metadata.iid,
+    title: metadata.title,
+    url: metadata.url,
+    isCurrent: true,
+    isDefaultBranch: false,
+  });
+
+  return { nodes };
+}