@demon-utils/playwright 0.1.6 → 0.1.7

package/src/git-context.ts

@@ -1,4 +1,5 @@
 import { readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
 
 export type ExecFn = (cmd: string[], cwd: string) => Promise<string>;
 export type ReadFileFn = (path: string) => string;
@@ -11,15 +12,44 @@ export interface RepoContext {
 export interface GetRepoContextOptions {
   exec?: ExecFn;
   readFile?: ReadFileFn;
+  diffBase?: string;  // Base commit/branch for diff (auto-detected if not provided)
+}
+
+async function detectDefaultBase(exec: ExecFn, gitRoot: string): Promise<string | null> {
+  // Get current branch name
+  let currentBranch: string;
+  try {
+    currentBranch = (await exec(["git", "rev-parse", "--abbrev-ref", "HEAD"], gitRoot)).trim();
+  } catch {
+    return null; // Detached HEAD or other issue
+  }
+
+  // If on main/master, no base to compare against
+  if (currentBranch === "main" || currentBranch === "master") {
+    return null;
+  }
+
+  // Try to find main or master as base
+  for (const candidate of ["main", "master"]) {
+    try {
+      await exec(["git", "rev-parse", "--verify", candidate], gitRoot);
+      return candidate;
+    } catch {
+      // Branch doesn't exist, try next
+    }
+  }
+
+  return null;
 }
 
 const defaultExec: ExecFn = async (cmd, cwd) => {
-  const proc = Bun.spawnSync(cmd, { cwd });
-  if (proc.exitCode !== 0) {
-    const stderr = proc.stderr.toString().trim();
-    throw new Error(`Command failed (exit ${proc.exitCode}): ${cmd.join(" ")}${stderr ? `: ${stderr}` : ""}`);
+  const [command, ...args] = cmd;
+  const proc = spawnSync(command!, args, { cwd, encoding: "utf-8" });
+  if (proc.status !== 0) {
+    const stderr = (proc.stderr ?? "").trim();
+    throw new Error(`Command failed (exit ${proc.status}): ${cmd.join(" ")}${stderr ? `: ${stderr}` : ""}`);
   }
-  return proc.stdout.toString();
+  return proc.stdout ?? "";
 };
 
 const defaultReadFile: ReadFileFn = (path) => {
@@ -35,12 +65,21 @@ export async function getRepoContext(
 
   const gitRoot = (await exec(["git", "rev-parse", "--show-toplevel"], demosDir)).trim();
 
+  // Determine the base for diff comparison
+  const diffBase = options?.diffBase ?? await detectDefaultBase(exec, gitRoot);
+
   let gitDiff: string;
-  const workingDiff = (await exec(["git", "diff", "HEAD"], gitRoot)).trim();
-  if (workingDiff.length > 0) {
-    gitDiff = workingDiff;
+  if (diffBase) {
+    // Use three-dot diff for merge-base comparison (shows changes on current branch)
+    gitDiff = (await exec(["git", "diff", `${diffBase}...HEAD`], gitRoot)).trim();
   } else {
-    gitDiff = (await exec(["git", "diff", "HEAD~1..HEAD"], gitRoot)).trim();
+    // Fallback: worktree diff or last commit
+    const workingDiff = (await exec(["git", "diff", "HEAD"], gitRoot)).trim();
+    if (workingDiff.length > 0) {
+      gitDiff = workingDiff;
+    } else {
+      gitDiff = (await exec(["git", "diff", "HEAD~1..HEAD"], gitRoot)).trim();
+    }
   }
 
   const lsOutput = (await exec(["git", "ls-files"], gitRoot)).trim();

package/src/github-issue.test.ts

@@ -0,0 +1,188 @@
+import { describe, test, expect } from "bun:test";
+
+import type { GraphQLFn } from "./github-issue.ts";
+import { fetchGitHubIssue } from "./github-issue.ts";
+
+function mockGraphQL(response: unknown): GraphQLFn {
+  return (async () => response) as unknown as GraphQLFn;
+}
+
+describe("fetchGitHubIssue", () => {
+  test("fetches issue successfully", async () => {
+    const graphql = mockGraphQL({
+      repository: {
+        issue: {
+          number: 42,
+          title: "Fix the bug",
+          body: "This bug needs fixing",
+          state: "OPEN",
+          labels: {
+            nodes: [{ name: "bug" }, { name: "priority" }],
+          },
+        },
+      },
+    });
+
+    const issue = await fetchGitHubIssue(42, {
+      graphql,
+      owner: "test-owner",
+      repo: "test-repo",
+      token: "fake-token",
+    });
+
+    expect(issue.number).toBe(42);
+    expect(issue.title).toBe("Fix the bug");
+    expect(issue.body).toBe("This bug needs fixing");
+    expect(issue.state).toBe("open");
+    expect(issue.labels).toEqual(["bug", "priority"]);
+  });
+
+  test("parses string issue ID", async () => {
+    const graphql = mockGraphQL({
+      repository: {
+        issue: {
+          number: 123,
+          title: "String ID test",
+          body: "",
+          state: "CLOSED",
+          labels: { nodes: [] },
+        },
+      },
+    });
+
+    const issue = await fetchGitHubIssue("123", {
+      graphql,
+      owner: "test-owner",
+      repo: "test-repo",
+      token: "fake-token",
+    });
+
+    expect(issue.number).toBe(123);
+    expect(issue.state).toBe("closed");
+  });
+
+  test("handles null body", async () => {
+    const graphql = mockGraphQL({
+      repository: {
+        issue: {
+          number: 1,
+          title: "No body",
+          body: null,
+          state: "OPEN",
+          labels: { nodes: [] },
+        },
+      },
+    });
+
+    const issue = await fetchGitHubIssue(1, {
+      graphql,
+      owner: "test-owner",
+      repo: "test-repo",
+      token: "fake-token",
+    });
+
+    expect(issue.body).toBe("");
+  });
+
+  test("handles empty labels", async () => {
+    const graphql = mockGraphQL({
+      repository: {
+        issue: {
+          number: 1,
+          title: "No labels",
+          body: "body",
+          state: "OPEN",
+          labels: { nodes: [] },
+        },
+      },
+    });
+
+    const issue = await fetchGitHubIssue(1, {
+      graphql,
+      owner: "test-owner",
+      repo: "test-repo",
+      token: "fake-token",
+    });
+
+    expect(issue.labels).toEqual([]);
+  });
+
+  test("throws on invalid issue ID", async () => {
+    const graphql = mockGraphQL({});
+
+    await expect(
+      fetchGitHubIssue("not-a-number", {
+        graphql,
+        owner: "test-owner",
+        repo: "test-repo",
+        token: "fake-token",
+      }),
+    ).rejects.toThrow("Invalid issue ID: not-a-number");
+  });
+
+  test("throws when no token provided and none in environment", async () => {
+    const originalToken = process.env["GITHUB_TOKEN"];
+    const originalGhToken = process.env["GH_TOKEN"];
+    delete process.env["GITHUB_TOKEN"];
+    delete process.env["GH_TOKEN"];
+
+    try {
+      await expect(
+        fetchGitHubIssue(1, {
+          owner: "test-owner",
+          repo: "test-repo",
+        }),
+      ).rejects.toThrow("No GitHub token found");
+    } finally {
+      if (originalToken) process.env["GITHUB_TOKEN"] = originalToken;
+      if (originalGhToken) process.env["GH_TOKEN"] = originalGhToken;
+    }
+  });
+
+  test("uses GITHUB_TOKEN from environment", async () => {
+    const originalToken = process.env["GITHUB_TOKEN"];
+    process.env["GITHUB_TOKEN"] = "env-token";
+
+    const graphql = mockGraphQL({
+      repository: {
+        issue: {
+          number: 1,
+          title: "Env token test",
+          body: "",
+          state: "OPEN",
+          labels: { nodes: [] },
+        },
+      },
+    });
+
+    try {
+      const issue = await fetchGitHubIssue(1, {
+        graphql,
+        owner: "test-owner",
+        repo: "test-repo",
+      });
+      expect(issue.number).toBe(1);
+    } finally {
+      if (originalToken) {
+        process.env["GITHUB_TOKEN"] = originalToken;
+      } else {
+        delete process.env["GITHUB_TOKEN"];
+      }
+    }
+  });
+
+  test("throws when GraphQL request fails", async () => {
+    const graphql = (async () => {
+      throw new Error("GraphQL request failed: Not Found");
+    }) as unknown as GraphQLFn;
+
+    await expect(
+      fetchGitHubIssue(999999, {
+        graphql,
+        owner: "test-owner",
+        repo: "test-repo",
+        token: "fake-token",
+      }),
+    ).rejects.toThrow("GraphQL request failed: Not Found");
+  });
+});

package/src/github-issue.ts

@@ -0,0 +1,139 @@
+import { graphql as defaultGraphql } from "@octokit/graphql";
+import { spawnSync } from "node:child_process";
+
+export interface GitHubIssue {
+  number: number;
+  title: string;
+  body: string;
+  labels: string[];
+  state: string;
+}
+
+interface GitHubIssueGraphQLResponse {
+  repository: {
+    issue: {
+      number: number;
+      title: string;
+      body: string;
+      state: string;
+      labels: {
+        nodes: Array<{ name: string }>;
+      };
+    };
+  };
+}
+
+export type GraphQLFn = typeof defaultGraphql;
+
+export interface FetchGitHubIssueOptions {
+  graphql?: GraphQLFn;
+  owner?: string;
+  repo?: string;
+  token?: string;
+}
+
+const ISSUE_QUERY = `
+  query($owner: String!, $repo: String!, $number: Int!) {
+    repository(owner: $owner, name: $repo) {
+      issue(number: $number) {
+        number
+        title
+        body
+        state
+        labels(first: 20) {
+          nodes {
+            name
+          }
+        }
+      }
+    }
+  }
+`;
+
+function getRepoInfoFromGit(): { owner: string; repo: string } | null {
+  try {
+    const proc = spawnSync("git", ["remote", "get-url", "origin"], { encoding: "utf-8" });
+    if (proc.status !== 0 || !proc.stdout) {
+      return null;
+    }
+
+    const url = proc.stdout.trim();
+    // Handle SSH format: git@github.com:owner/repo.git
+    const sshMatch = url.match(/git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/);
+    if (sshMatch) {
+      return { owner: sshMatch[1]!, repo: sshMatch[2]! };
+    }
+
+    // Handle HTTPS format: https://github.com/owner/repo.git
+    const httpsMatch = url.match(/https:\/\/github\.com\/([^/]+)\/(.+?)(?:\.git)?$/);
+    if (httpsMatch) {
+      return { owner: httpsMatch[1]!, repo: httpsMatch[2]! };
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function getTokenFromEnvironment(): string | null {
+  return process.env["GITHUB_TOKEN"] ?? process.env["GH_TOKEN"] ?? null;
+}
+
+export async function fetchGitHubIssue(
+  issueId: string | number,
+  options?: FetchGitHubIssueOptions,
+): Promise<GitHubIssue> {
+  const issueNumber = typeof issueId === "string" ? parseInt(issueId, 10) : issueId;
+  if (isNaN(issueNumber)) {
+    throw new Error(`Invalid issue ID: ${issueId}`);
+  }
+
+  // Get owner/repo from options or detect from git
+  let owner = options?.owner;
+  let repo = options?.repo;
+
+  if (!owner || !repo) {
+    const detected = getRepoInfoFromGit();
+    if (!detected) {
+      throw new Error(
+        "Could not detect repository owner/name from git remote. " +
+        "Please provide owner and repo options, or run from a git repository with a GitHub origin."
+      );
+    }
+    owner = owner ?? detected.owner;
+    repo = repo ?? detected.repo;
+  }
+
+  // Get token from options or environment
+  const token = options?.token ?? getTokenFromEnvironment();
+  if (!token) {
+    throw new Error(
+      "No GitHub token found. Please set GITHUB_TOKEN or GH_TOKEN environment variable, " +
+      "or provide token in options."
+    );
+  }
+
+  // Use provided graphql function or create one with the token
+  const graphqlFn = options?.graphql ?? defaultGraphql.defaults({
+    headers: {
+      authorization: `token ${token}`,
+    },
+  });
+
+  const response = await graphqlFn<GitHubIssueGraphQLResponse>(ISSUE_QUERY, {
+    owner,
+    repo,
+    number: issueNumber,
+  });
+
+  const issue = response.repository.issue;
+
+  return {
+    number: issue.number,
+    title: issue.title,
+    body: issue.body ?? "",
+    labels: issue.labels.nodes.map((l: { name: string }) => l.name),
+    state: issue.state.toLowerCase(),
+  };
+}