BBC2-10 add bb pr create to open a PR from the current branch (#10)

Flags: `--title` (required), `--body`, `--body-file`, `--base`,
`-R/--repository`. Body source: `--body` > `--body-file` > drop into
`$VISUAL || $EDITOR` with a blank tempfile. Destination defaults to
whatever `refs/remotes/origin/HEAD` points at locally; if unset,
errors with a hint to `git remote set-head origin --auto` or
`--base <branch>` so teams with a `develop`-in-the-middle flow can
flip the default once and forget it.

Pre-flight refuses to POST when the branch isn't in sync with the
remote. Uses `git ls-remote` (network-authoritative) rather than the
locally-cached tracking ref, so stale state can't mask unpushed
commits. Two distinct errors: "not on origin" vs. "local ahead of
remote" — both name the branch and suggest the fix.

Reviewers deliberately omitted on this first cut: the workspace
auto-assigns reviewers server-side based on code-owner settings, so
there's nothing useful to send. When we need explicit reviewers,
we'll accept nicknames and resolve to uuids (Bitbucket's reviewer
objects are keyed by uuid, not nickname).

Adds three `GitRunner` methods with integration coverage against a
real local bare remote: `getSha`, `getRemoteBranchSha`,
`getDefaultBranchFromRemote`. Adds a shared `openEditor` helper
(`$VISUAL || $EDITOR`, whitespace-split for `EDITOR="code --wait"`
style configs, tempfile lifecycle, non-zero exit surfaces as
`EditorError`). Adds `createPullRequest` backend via the typed
openapi-fetch client.

Author: b2l

src/backend/pullrequests/index.test.ts

@@ -1,6 +1,7 @@
 import { test, expect, describe } from "bun:test";
 import { http, HttpResponse } from "msw";
 import {
+  createPullRequest,
   findOpenPullRequestForBranch,
   getPullRequest,
   listPullRequests,
@@ -460,3 +461,56 @@ describe("findOpenPullRequestForBranch", () => {
     );
   });
 });
+
+describe("createPullRequest", () => {
+  test("POSTs title, description, and source/destination branches", async () => {
+    let seenBody: Record<string, any> | null = null;
+    server.use(
+      http.post(PR_LIST_PATH, async ({ request }) => {
+        seenBody = (await request.json()) as Record<string, any>;
+        return HttpResponse.json(
+          makePrDetail({ id: 100, title: "Add login" }),
+          { status: 201 },
+        );
+      }),
+    );
+
+    const result = await createPullRequest(creds, ref, {
+      title: "Add login",
+      description: "Wires up auth middleware.",
+      sourceBranch: "feature/login",
+      destinationBranch: "main",
+    });
+
+    expect(seenBody!).toEqual({
+      type: "pullrequest",
+      title: "Add login",
+      description: "Wires up auth middleware.",
+      source: { branch: { name: "feature/login" } },
+      destination: { branch: { name: "main" } },
+    });
+    expect(result.id).toBe(100);
+    expect(result.title).toBe("Add login");
+  });
+
+  test("throws PullRequestError on 400 (validation failure)", async () => {
+    server.use(
+      http.post(PR_LIST_PATH, () =>
+        HttpResponse.json(
+          { type: "error", error: { message: "Invalid source branch" } },
+          { status: 400 },
+        ),
+      ),
+    );
+
+    const err = await createPullRequest(creds, ref, {
+      title: "x",
+      description: "",
+      sourceBranch: "nope",
+      destinationBranch: "main",
+    }).catch((e) => e);
+
+    expect(err).toBeInstanceOf(PullRequestError);
+    expect((err as PullRequestError).status).toBe(400);
+  });
+});

src/backend/pullrequests/index.ts

@@ -187,6 +187,51 @@ function escapeBbql(value: string): string {
   return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
 
+export type CreatePullRequestInput = {
+  title: string;
+  description: string;
+  sourceBranch: string;
+  destinationBranch: string;
+};
+
+/**
+ * POSTs a new pull request to Bitbucket. The source repo is implied by the
+ * path (we only create PRs in the current repo, never from forks at this
+ * stage). Reviewers are omitted: our Bitbucket workspaces auto-assign
+ * reviewers based on code-owner settings.
+ */
+export async function createPullRequest(
+  credentials: Credentials,
+  ref: { workspace: string; slug: string },
+  input: CreatePullRequestInput,
+): Promise<PullRequestDetail> {
+  const client = createBitbucketClient(credentials);
+  const { data, response } = await client.POST(
+    "/repositories/{workspace}/{repo_slug}/pullrequests",
+    {
+      params: {
+        path: { workspace: ref.workspace, repo_slug: ref.slug },
+      },
+      body: {
+        type: "pullrequest",
+        title: input.title,
+        description: input.description,
+        source: { branch: { name: input.sourceBranch } },
+        destination: { branch: { name: input.destinationBranch } },
+      },
+    },
+  );
+
+  if (!response.ok || !data) {
+    throw new PullRequestError(
+      `Failed to create pull request: HTTP ${response.status}.`,
+      response.status,
+    );
+  }
+
+  return toPullRequestDetail(data as RawPullRequest);
+}
+
 /**
  * Fetches a single pull request by id. Single typed call — the overlay
  * (BBC2-38) gives us typed path params and response shape, so we stay on

src/commands/pullrequest/create.ts

@@ -0,0 +1,127 @@
+import {
+  createPullRequest,
+  PullRequestError,
+} from "../../backend/pullrequests/index.ts";
+import { loadConfigOrExit } from "../../shared/config/index.ts";
+import { openEditor, EditorError } from "../../shared/editor/index.ts";
+import type { Renderer } from "../../shared/renderer/index.ts";
+import {
+  resolveRepository,
+  RepositoryResolutionError,
+  defaultGitRunner,
+} from "../../shared/repository/index.ts";
+
+export type PullRequestCreateOptions = {
+  repository?: string;
+  title?: string;
+  body?: string;
+  bodyFile?: string;
+  base?: string;
+};
+
+export async function runPullRequestCreate(
+  renderer: Renderer,
+  options: PullRequestCreateOptions,
+): Promise<void> {
+  const config = await loadConfigOrExit(renderer);
+
+  if (!options.title) {
+    renderer.error("--title is required.");
+    process.exit(1);
+  }
+  if (options.body !== undefined && options.bodyFile !== undefined) {
+    renderer.error("Pass either --body or --body-file, not both.");
+    process.exit(1);
+  }
+
+  try {
+    const ref = await resolveRepository({ override: options.repository });
+    const cwd = process.cwd();
+
+    const branch = await defaultGitRunner.getCurrentBranch(cwd);
+    if (!branch) {
+      renderer.error(
+        "Could not determine the current branch (detached HEAD or not a git repo).",
+      );
+      process.exit(1);
+    }
+
+    await assertBranchPushedAndInSync(renderer, cwd, branch);
+
+    const destination = options.base ?? await defaultBase(renderer, cwd);
+
+    const body = await resolveBody(renderer, options);
+
+    const pr = await createPullRequest(config, ref, {
+      title: options.title,
+      description: body,
+      sourceBranch: branch,
+      destinationBranch: destination,
+    });
+
+    renderer.message(pr.url);
+  } catch (err) {
+    if (
+      err instanceof RepositoryResolutionError ||
+      err instanceof PullRequestError ||
+      err instanceof EditorError
+    ) {
+      renderer.error(err.message);
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+
+async function assertBranchPushedAndInSync(
+  renderer: Renderer,
+  cwd: string,
+  branch: string,
+): Promise<void> {
+  const remoteSha = await defaultGitRunner.getRemoteBranchSha(
+    cwd,
+    "origin",
+    branch,
+  );
+  if (!remoteSha) {
+    renderer.error(
+      `Branch '${branch}' is not on origin. Push it first: git push -u origin ${branch}`,
+    );
+    process.exit(1);
+  }
+  const localSha = await defaultGitRunner.getSha(cwd, "HEAD");
+  if (localSha && localSha !== remoteSha) {
+    renderer.error(
+      `Branch '${branch}' has unpushed commits (local ${localSha.slice(0, 7)} vs remote ${remoteSha.slice(0, 7)}). Push them first.`,
+    );
+    process.exit(1);
+  }
+}
+
+async function defaultBase(renderer: Renderer, cwd: string): Promise<string> {
+  const branch = await defaultGitRunner.getDefaultBranchFromRemote(cwd, "origin");
+  if (!branch) {
+    renderer.error(
+      "Could not determine the default branch. Run 'git remote set-head origin --auto' or pass --base explicitly.",
+    );
+    process.exit(1);
+  }
+  return branch;
+}
+
+async function resolveBody(
+  renderer: Renderer,
+  options: PullRequestCreateOptions,
+): Promise<string> {
+  if (options.body !== undefined) return options.body;
+  if (options.bodyFile !== undefined) {
+    const file = Bun.file(options.bodyFile);
+    if (!(await file.exists())) {
+      renderer.error(`--body-file '${options.bodyFile}' does not exist.`);
+      process.exit(1);
+    }
+    return await file.text();
+  }
+  // No flag: drop into the user's editor with a blank file.
+  return await openEditor();
+}

src/commands/pullrequest/index.ts

@@ -1,5 +1,6 @@
 import type { Command } from "commander";
 import { withRenderer } from "../../shared/renderer/commander.ts";
+import { runPullRequestCreate } from "./create.ts";
 import { runPullRequestList } from "./list.ts";
 import { runPullRequestView } from "./view.ts";
 
@@ -41,4 +42,23 @@ export function registerPullRequestCommands(program: Command): void {
       "Override repository detection",
     )
     .action(withRenderer(runPullRequestView));
+
+  pr
+    .command("create")
+    .description("Open a pull request from the current branch")
+    .option(
+      "-R, --repository <workspace/repo>",
+      "Override repository detection",
+    )
+    .option("-t, --title <title>", "Pull request title (required)")
+    .option("-b, --body <body>", "Pull request description")
+    .option(
+      "-F, --body-file <path>",
+      "Read description from a file ('-' for stdin support deferred)",
+    )
+    .option(
+      "--base <branch>",
+      "Destination branch (defaults to the remote's default branch)",
+    )
+    .action(withRenderer(runPullRequestCreate));
 }

src/shared/editor/index.test.ts

@@ -0,0 +1,82 @@
+import { test, expect, describe, afterEach, beforeAll, afterAll } from "bun:test";
+import { $ } from "bun";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { openEditor, EditorError } from "./index.ts";
+
+/**
+ * Integration tests. Real editors are interactive; we point `$EDITOR` at a
+ * tiny shell script that mutates the tempfile and exits.
+ */
+
+let scriptDir: string;
+let appendScript: string;
+let visualScript: string;
+let failScript: string;
+
+beforeAll(async () => {
+  scriptDir = await mkdtemp(join(tmpdir(), "bbcli-editor-test-"));
+
+  appendScript = join(scriptDir, "append.sh");
+  await Bun.write(appendScript, '#!/bin/sh\necho "hello from editor" >> "$1"\n');
+  await $`chmod +x ${appendScript}`.quiet();
+
+  visualScript = join(scriptDir, "visual.sh");
+  await Bun.write(visualScript, '#!/bin/sh\necho "VISUAL_ran" >> "$1"\n');
+  await $`chmod +x ${visualScript}`.quiet();
+
+  failScript = join(scriptDir, "fail.sh");
+  await Bun.write(failScript, "#!/bin/sh\nexit 2\n");
+  await $`chmod +x ${failScript}`.quiet();
+});
+
+afterAll(async () => {
+  if (scriptDir) await rm(scriptDir, { recursive: true, force: true });
+});
+
+const originalEditor = process.env["EDITOR"];
+const originalVisual = process.env["VISUAL"];
+
+afterEach(() => {
+  if (originalEditor === undefined) delete process.env["EDITOR"];
+  else process.env["EDITOR"] = originalEditor;
+  if (originalVisual === undefined) delete process.env["VISUAL"];
+  else process.env["VISUAL"] = originalVisual;
+});
+
+describe("openEditor", () => {
+  test("invokes $EDITOR and returns the file contents after exit", async () => {
+    process.env["EDITOR"] = appendScript;
+    delete process.env["VISUAL"];
+
+    const result = await openEditor("seed line\n");
+    expect(result).toBe("seed line\nhello from editor\n");
+  });
+
+  test("prefers $VISUAL over $EDITOR", async () => {
+    process.env["EDITOR"] = appendScript;
+    process.env["VISUAL"] = visualScript;
+
+    const result = await openEditor();
+    expect(result).toContain("VISUAL_ran");
+    expect(result).not.toContain("hello from editor");
+  });
+
+  test("throws EditorError when neither env var is set", async () => {
+    delete process.env["EDITOR"];
+    delete process.env["VISUAL"];
+
+    const err = await openEditor().catch((e) => e);
+    expect(err).toBeInstanceOf(EditorError);
+  });
+
+  test("throws EditorError when the editor exits non-zero", async () => {
+    process.env["EDITOR"] = failScript;
+    delete process.env["VISUAL"];
+
+    const err = await openEditor().catch((e) => e);
+    expect(err).toBeInstanceOf(EditorError);
+    expect((err as Error).message).toContain("code 2");
+  });
+});