@google/jules-fleet 0.0.1-experimental.0

package/dist/cli/merge.command.mjs

@@ -0,0 +1,859 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/cli/merge.command.ts
+import { defineCommand } from "citty";
+
+// src/merge/spec.ts
+import { z } from "zod";
+var MergeMode = z.enum(["label", "fleet-run"]);
+var MergeInputSchema = z.object({
+  mode: MergeMode.default("label"),
+  runId: z.string().optional(),
+  baseBranch: z.string().default("main"),
+  admin: z.boolean().default(false),
+  maxCIWaitSeconds: z.number().positive().default(600),
+  maxRetries: z.number().nonnegative().default(2),
+  reDispatch: z.boolean().default(false),
+  pollTimeoutSeconds: z.number().positive().default(900),
+  owner: z.string().min(1),
+  repo: z.string().min(1)
+}).refine((d) => d.mode !== "fleet-run" || !!d.runId, {
+  message: "--run-id is required when mode is fleet-run",
+  path: ["runId"]
+});
+var MergeErrorCode = z.enum([
+  "NO_PRS_FOUND",
+  "CI_FAILED",
+  "CI_TIMEOUT",
+  "MERGE_FAILED",
+  "CONFLICT_RETRIES_EXHAUSTED",
+  "REDISPATCH_TIMEOUT",
+  "GITHUB_API_ERROR",
+  "UNKNOWN_ERROR"
+]);
+
+// src/shared/result/create-result-schemas.ts
+import { z as z2 } from "zod";
+// src/shared/result/ok.ts
+function ok(data) {
+  return { success: true, data };
+}
+// src/shared/result/fail.ts
+function fail(code, message, recoverable = false, suggestion) {
+  return {
+    success: false,
+    error: { code, message, recoverable, suggestion }
+  };
+}
+// src/merge/select/by-label.ts
+async function selectByLabel(octokit, owner, repo, baseBranch) {
+  const { data: pulls } = await octokit.rest.pulls.list({
+    owner,
+    repo,
+    state: "open",
+    base: baseBranch,
+    per_page: 100
+  });
+  const labeledPRs = pulls.filter((pr) => pr.labels.some((label) => label.name === "fleet-merge-ready")).sort((a, b) => a.number - b.number).map((pr) => ({
+    number: pr.number,
+    headRef: pr.head.ref,
+    headSha: pr.head.sha,
+    body: pr.body
+  }));
+  return labeledPRs;
+}
+
+// src/merge/select/by-fleet-run.ts
+var FLEET_RUN_MARKER_PREFIX = "<!-- fleet-run:";
+async function selectByFleetRun(octokit, owner, repo, baseBranch, runId) {
+  const { data: pulls } = await octokit.rest.pulls.list({
+    owner,
+    repo,
+    state: "open",
+    base: baseBranch,
+    per_page: 100
+  });
+  const marker = `${FLEET_RUN_MARKER_PREFIX} ${runId} -->`;
+  const matchingPRs = pulls.filter((pr) => pr.body?.includes(marker)).sort((a, b) => a.number - b.number).map((pr) => ({
+    number: pr.number,
+    headRef: pr.head.ref,
+    headSha: pr.head.sha,
+    body: pr.body
+  }));
+  return matchingPRs;
+}
+
+// src/merge/ops/update-branch.ts
+async function updateBranch(octokit, owner, repo, prNumber, emit) {
+  try {
+    emit({ type: "merge:branch:updating", prNumber });
+    await octokit.rest.pulls.updateBranch({
+      owner,
+      repo,
+      pull_number: prNumber
+    });
+    emit({ type: "merge:branch:updated", prNumber });
+    return { ok: true, conflict: false };
+  } catch (error) {
+    const status = error && typeof error === "object" && "status" in error ? error.status : 0;
+    if (status === 422) {
+      emit({ type: "merge:conflict:detected", prNumber });
+      return { ok: false, conflict: true };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, conflict: false, error: message };
+  }
+}
+
+// src/merge/ops/wait-for-ci.ts
+async function waitForCI(octokit, owner, repo, prNumber, maxWaitMs, emit, sleep) {
+  const { data: prData } = await octokit.rest.pulls.get({
+    owner,
+    repo,
+    pull_number: prNumber
+  });
+  const headSha = prData.head.sha;
+  emit({ type: "merge:ci:waiting", prNumber });
+  const start = Date.now();
+  while (Date.now() - start < maxWaitMs) {
+    const { data } = await octokit.rest.checks.listForRef({
+      owner,
+      repo,
+      ref: headSha
+    });
+    if (data.check_runs.length === 0) {
+      emit({ type: "merge:ci:none", prNumber });
+      return "none";
+    }
+    for (const run of data.check_runs) {
+      if (run.status === "completed") {
+        const passed = run.conclusion === "success" || run.conclusion === "skipped";
+        const durationMs = run.started_at && run.completed_at ? new Date(run.completed_at).getTime() - new Date(run.started_at).getTime() : undefined;
+        emit({
+          type: "merge:ci:check",
+          name: run.name,
+          status: passed ? "pass" : "fail",
+          duration: durationMs ? Math.round(durationMs / 1000) : undefined
+        });
+      }
+    }
+    const allComplete = data.check_runs.every((run) => run.status === "completed");
+    const allPassed = data.check_runs.every((run) => run.conclusion === "success" || run.conclusion === "skipped");
+    if (allComplete && allPassed) {
+      emit({ type: "merge:ci:passed", prNumber });
+      return "pass";
+    }
+    if (allComplete && !allPassed) {
+      emit({ type: "merge:ci:failed", prNumber });
+      return "fail";
+    }
+    await sleep(30000);
+  }
+  emit({ type: "merge:ci:timeout", prNumber });
+  return "timeout";
+}
+
+// src/merge/ops/squash-merge.ts
+async function squashMerge(octokit, owner, repo, prNumber) {
+  try {
+    await octokit.rest.pulls.merge({
+      owner,
+      repo,
+      pull_number: prNumber,
+      merge_method: "squash"
+    });
+    return { ok: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, error: message };
+  }
+}
+
+// src/merge/ops/redispatch.ts
+async function redispatch(octokit, owner, repo, oldPr, baseBranch, pollTimeoutSeconds, emit, sleep) {
+  emit({ type: "merge:redispatch:start", oldPr: oldPr.number });
+  try {
+    await octokit.rest.pulls.update({
+      owner,
+      repo,
+      pull_number: oldPr.number,
+      state: "closed",
+      body: `${oldPr.body ?? ""}
+
+---
+⚠️ Closed by fleet-merge: merge conflict detected. Task re-dispatched.`
+    });
+  } catch {}
+  try {
+    const { jules } = await import("@google/jules-sdk");
+    const session = await jules.session({
+      prompt: oldPr.body ?? "",
+      source: {
+        github: `${owner}/${repo}`,
+        baseBranch
+      }
+    });
+    emit({ type: "merge:redispatch:waiting", oldPr: oldPr.number });
+    const start = Date.now();
+    const timeoutMs = pollTimeoutSeconds * 1000;
+    const pollIntervalMs = 30000;
+    while (Date.now() - start < timeoutMs) {
+      await sleep(pollIntervalMs);
+      const { data: pulls } = await octokit.rest.pulls.list({
+        owner,
+        repo,
+        state: "open",
+        base: baseBranch,
+        per_page: 100
+      });
+      const newPr = pulls.find((pr) => pr.head.ref.includes(session.id) || pr.body?.includes(session.id));
+      if (newPr) {
+        const result = {
+          number: newPr.number,
+          headRef: newPr.head.ref,
+          headSha: newPr.head.sha,
+          body: newPr.body
+        };
+        emit({
+          type: "merge:redispatch:done",
+          oldPr: oldPr.number,
+          newPr: newPr.number
+        });
+        return result;
+      }
+    }
+  } catch (error) {
+    emit({
+      type: "error",
+      code: "REDISPATCH_FAILED",
+      message: `Re-dispatch failed: ${error instanceof Error ? error.message : error}`
+    });
+  }
+  return null;
+}
+
+// src/merge/handler.ts
+var defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+class MergeHandler {
+  octokit;
+  emit;
+  sleep;
+  constructor(deps) {
+    this.octokit = deps.octokit;
+    this.emit = deps.emit ?? (() => {});
+    this.sleep = deps.sleep ?? defaultSleep;
+  }
+  async execute(input) {
+    try {
+      const prs = await this.selectPRs(input);
+      if (prs.length === 0) {
+        this.emit({ type: "merge:no-prs" });
+        return ok({ merged: [], skipped: [], redispatched: [] });
+      }
+      this.emit({
+        type: "merge:start",
+        owner: input.owner,
+        repo: input.repo,
+        mode: input.mode,
+        prCount: prs.length
+      });
+      const merged = [];
+      const skipped = [];
+      const redispatched = [];
+      for (const pr of prs) {
+        let currentPr = pr;
+        let retryCount = 0;
+        let prMerged = false;
+        while (!prMerged) {
+          this.emit({
+            type: "merge:pr:processing",
+            number: currentPr.number,
+            title: currentPr.body?.split(`
+`)[0] ?? `PR #${currentPr.number}`,
+            retry: retryCount > 0 ? retryCount : undefined
+          });
+          if (prs.indexOf(pr) > 0 || retryCount > 0) {
+            const updateResult = await updateBranch(this.octokit, input.owner, input.repo, currentPr.number, this.emit);
+            if (!updateResult.ok && updateResult.conflict) {
+              if (!input.reDispatch) {
+                return fail("CONFLICT_RETRIES_EXHAUSTED", `Merge conflict detected for PR #${currentPr.number}. Use --re-dispatch to automatically retry.`, false, `Review PR: https://github.com/${input.owner}/${input.repo}/pull/${currentPr.number}`);
+              }
+              if (retryCount >= input.maxRetries) {
+                return fail("CONFLICT_RETRIES_EXHAUSTED", `Conflict persists for PR #${currentPr.number} after ${input.maxRetries} retries. Human intervention required.`, false, `Review PR: https://github.com/${input.owner}/${input.repo}/pull/${currentPr.number}`);
+              }
+              const newPr = await redispatch(this.octokit, input.owner, input.repo, currentPr, input.baseBranch, input.pollTimeoutSeconds, this.emit, this.sleep);
+              if (!newPr) {
+                return fail("REDISPATCH_TIMEOUT", `Timed out waiting for re-dispatched PR for #${currentPr.number}.`, true);
+              }
+              redispatched.push({
+                oldPr: currentPr.number,
+                newPr: newPr.number
+              });
+              currentPr = newPr;
+              retryCount++;
+              continue;
+            }
+            if (!updateResult.ok && !updateResult.conflict) {
+              return fail("GITHUB_API_ERROR", `Failed to update branch for PR #${currentPr.number}: ${updateResult.error}`, true);
+            }
+            await this.sleep(5000);
+          }
+          const ciResult = await waitForCI(this.octokit, input.owner, input.repo, currentPr.number, input.maxCIWaitSeconds * 1000, this.emit, this.sleep);
+          if (ciResult === "none") {} else if (ciResult === "fail") {
+            this.emit({
+              type: "merge:pr:skipped",
+              prNumber: currentPr.number,
+              reason: "CI failure"
+            });
+            skipped.push(currentPr.number);
+            break;
+          } else if (ciResult === "timeout") {
+            this.emit({
+              type: "merge:pr:skipped",
+              prNumber: currentPr.number,
+              reason: "CI timeout"
+            });
+            skipped.push(currentPr.number);
+            break;
+          }
+          this.emit({ type: "merge:pr:merging", prNumber: currentPr.number });
+          const mergeResult = await squashMerge(this.octokit, input.owner, input.repo, currentPr.number);
+          if (!mergeResult.ok) {
+            return fail("MERGE_FAILED", `Failed to merge PR #${currentPr.number}: ${mergeResult.error}`, false);
+          }
+          this.emit({ type: "merge:pr:merged", prNumber: currentPr.number });
+          merged.push(currentPr.number);
+          prMerged = true;
+        }
+        await this.sleep(5000);
+      }
+      this.emit({ type: "merge:done", merged, skipped, redispatched });
+      return ok({ merged, skipped, redispatched });
+    } catch (error) {
+      return fail("UNKNOWN_ERROR", error instanceof Error ? error.message : String(error), false);
+    }
+  }
+  async selectPRs(input) {
+    if (input.mode === "fleet-run") {
+      return selectByFleetRun(this.octokit, input.owner, input.repo, input.baseBranch, input.runId);
+    }
+    return selectByLabel(this.octokit, input.owner, input.repo, input.baseBranch);
+  }
+}
+
+// src/shared/auth/octokit.ts
+import { Octokit } from "octokit";
+import { createAppAuth } from "@octokit/auth-app";
+
+// src/shared/auth/cache-plugin.ts
+function cachePlugin(octokit) {
+  const cache = new Map;
+  octokit.hook.wrap("request", async (request, options) => {
+    const key = `${options.method} ${options.url}`;
+    const cached = cache.get(key);
+    if (cached) {
+      options.headers = {
+        ...options.headers,
+        "if-none-match": cached.etag
+      };
+    }
+    try {
+      const response = await request(options);
+      const etag = response.headers.etag;
+      if (etag) {
+        cache.set(key, { etag, data: response.data });
+      }
+      return response;
+    } catch (error) {
+      if (error.status === 304 && cached) {
+        return { ...error.response, data: cached.data, status: 200 };
+      }
+      throw error;
+    }
+  });
+}
+
+// src/shared/auth/resolve-key.ts
+function resolvePrivateKey(base64Value, rawValue) {
+  if (base64Value) {
+    return Buffer.from(base64Value, "base64").toString("utf-8");
+  }
+  if (rawValue) {
+    return rawValue.replace(/\\n/g, `
+`);
+  }
+  throw new Error("No private key provided. Set GITHUB_APP_PRIVATE_KEY_BASE64 (recommended) or GITHUB_APP_PRIVATE_KEY.");
+}
+
+// src/shared/auth/octokit.ts
+var CachedOctokit = Octokit.plugin(cachePlugin);
+function getAuthOptions() {
+  const appId = process.env.GITHUB_APP_ID;
+  const privateKeyBase64 = process.env.GITHUB_APP_PRIVATE_KEY_BASE64;
+  const privateKeyRaw = process.env.GITHUB_APP_PRIVATE_KEY;
+  const installationId = process.env.GITHUB_APP_INSTALLATION_ID;
+  if (appId && (privateKeyBase64 || privateKeyRaw) && installationId) {
+    return {
+      authStrategy: createAppAuth,
+      auth: {
+        appId,
+        privateKey: resolvePrivateKey(privateKeyBase64, privateKeyRaw),
+        installationId: Number(installationId)
+      }
+    };
+  }
+  const token = process.env.GITHUB_TOKEN;
+  if (token) {
+    return { auth: token };
+  }
+  throw new Error("GitHub auth not configured. Set GITHUB_APP_ID + GITHUB_APP_PRIVATE_KEY + GITHUB_APP_INSTALLATION_ID for App auth, or GITHUB_TOKEN for PAT auth.");
+}
+function createFleetOctokit() {
+  return new CachedOctokit(getAuthOptions());
+}
+
+// src/shared/auth/git.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function getGitRepoInfo(remoteName = "origin") {
+  const ghRepo = process.env.GITHUB_REPOSITORY;
+  if (ghRepo) {
+    const [owner, repo] = ghRepo.split("/");
+    return { owner, repo, fullName: ghRepo };
+  }
+  const { stdout } = await execAsync(`git remote get-url ${remoteName}`);
+  return parseGitRemoteUrl(stdout.trim());
+}
+function parseGitRemoteUrl(remoteUrl) {
+  const sshMatch = remoteUrl.match(/git@github\.com:([^/]+)\/(.+?)(\.git)?$/);
+  if (sshMatch) {
+    const [, owner, repo] = sshMatch;
+    return {
+      owner,
+      repo: repo.replace(/\.git$/, ""),
+      fullName: `${owner}/${repo.replace(/\.git$/, "")}`
+    };
+  }
+  const httpsMatch = remoteUrl.match(/https?:\/\/github\.com\/([^/]+)\/(.+?)(\.git)?$/);
+  if (httpsMatch) {
+    const [, owner, repo] = httpsMatch;
+    return {
+      owner,
+      repo: repo.replace(/\.git$/, ""),
+      fullName: `${owner}/${repo.replace(/\.git$/, "")}`
+    };
+  }
+  throw new Error(`Unable to parse git remote URL: ${remoteUrl}`);
+}
+
+// src/shared/ui/interactive.ts
+import * as p from "@clack/prompts";
+
+// src/shared/ui/render/init.ts
+function renderInitEvent(event, ctx) {
+  switch (event.type) {
+    case "init:start":
+      ctx.info(`Initializing fleet for ${event.owner}/${event.repo}`);
+      break;
+    case "init:branch:creating":
+      ctx.startSpinner(`Creating branch ${event.name} from ${event.base}`);
+      break;
+    case "init:branch:created":
+      ctx.stopSpinner(`Branch ${event.name} created`);
+      break;
+    case "init:file:committed":
+      ctx.info(`  ✓ ${event.path}`);
+      break;
+    case "init:file:skipped":
+      ctx.warn(`  ⊘ ${event.path} — ${event.reason}`);
+      break;
+    case "init:pr:creating":
+      ctx.startSpinner("Creating pull request…");
+      break;
+    case "init:pr:created":
+      ctx.stopSpinner(`PR #${event.number} created`);
+      ctx.info(`  ${event.url}`);
+      break;
+    case "init:done":
+      ctx.success(`Fleet initialized — PR: ${event.prUrl}`);
+      break;
+    case "init:auth:detected":
+      ctx.success(`Auth: ${event.method === "token" ? "GITHUB_TOKEN" : "GitHub App"}`);
+      break;
+    case "init:secret:uploading":
+      ctx.startSpinner(`Uploading secret ${event.name}…`);
+      break;
+    case "init:secret:uploaded":
+      ctx.stopSpinner(`Secret ${event.name} saved`);
+      break;
+    case "init:secret:skipped":
+      ctx.warn(`  ⊘ ${event.name} — ${event.reason}`);
+      break;
+    case "init:dry-run":
+      ctx.info("Would create:");
+      event.files.forEach((f) => ctx.message(`  ${f}`));
+      break;
+    case "init:already-initialized":
+      ctx.warn("Repository is already initialized");
+      break;
+  }
+}
+
+// src/shared/ui/render/configure.ts
+function renderConfigureEvent(event, ctx) {
+  switch (event.type) {
+    case "configure:start":
+      ctx.info(`Configuring ${event.resource} for ${event.owner}/${event.repo}`);
+      break;
+    case "configure:label:created":
+      ctx.info(`  ✓ Label "${event.name}" created`);
+      break;
+    case "configure:label:exists":
+      ctx.warn(`  ⊘ Label "${event.name}" already exists`);
+      break;
+    case "configure:secret:uploading":
+      ctx.startSpinner(`Uploading secret ${event.name}…`);
+      break;
+    case "configure:secret:uploaded":
+      ctx.stopSpinner(`Secret ${event.name} uploaded`);
+      break;
+    case "configure:done":
+      ctx.success("Configuration complete");
+      break;
+  }
+}
+
+// src/shared/ui/session-url.ts
+var JULES_BASE_URL = "https://jules.google.com";
+function sessionUrl(sessionId) {
+  return `${JULES_BASE_URL}/sessions/${sessionId}`;
+}
+
+// src/shared/ui/render/analyze.ts
+function renderAnalyzeEvent(event, ctx) {
+  switch (event.type) {
+    case "analyze:start":
+      ctx.info(`Analyzing ${event.goalCount} goal(s) for ${event.owner}/${event.repo}`);
+      break;
+    case "analyze:goal:start":
+      if (event.total > 1) {
+        ctx.step(`[${event.index}/${event.total}] ${event.file}`);
+      } else {
+        ctx.step(event.file);
+      }
+      if (event.milestone)
+        ctx.info(`  Milestone: ${event.milestone}`);
+      break;
+    case "analyze:milestone:resolved":
+      ctx.info(`  Milestone "${event.title}" (#${event.id})`);
+      break;
+    case "analyze:context:fetched":
+      ctx.info(`  Context: ${event.openIssues} open, ${event.closedIssues} closed, ${event.prs} PRs`);
+      break;
+    case "analyze:session:dispatching":
+      ctx.startSpinner(`Dispatching session for ${event.goal}…`);
+      break;
+    case "analyze:session:started":
+      ctx.stopSpinner(`Session started: ${event.id}`);
+      ctx.info(`  ${sessionUrl(event.id)}`);
+      break;
+    case "analyze:session:failed":
+      ctx.stopSpinner();
+      ctx.error(`  Failed: ${event.error}`);
+      break;
+    case "analyze:done":
+      ctx.success(`Analysis complete — ${event.sessionsStarted} session(s) from ${event.goalsProcessed} goal(s)`);
+      break;
+  }
+}
+
+// src/shared/ui/render/dispatch.ts
+function renderDispatchEvent(event, ctx) {
+  switch (event.type) {
+    case "dispatch:start":
+      ctx.info(`Dispatching from milestone ${event.milestone}`);
+      break;
+    case "dispatch:scanning":
+      ctx.startSpinner("Scanning for fleet issues…");
+      break;
+    case "dispatch:found":
+      ctx.stopSpinner(`Found ${event.count} undispatched issue(s)`);
+      break;
+    case "dispatch:issue:dispatching":
+      ctx.startSpinner(`#${event.number}: ${event.title}`);
+      break;
+    case "dispatch:issue:dispatched":
+      ctx.stopSpinner(`#${event.number} → session ${event.sessionId}`);
+      ctx.info(`  ${sessionUrl(event.sessionId)}`);
+      break;
+    case "dispatch:issue:skipped":
+      ctx.warn(`  ⊘ #${event.number}: ${event.reason}`);
+      break;
+    case "dispatch:done":
+      ctx.success(`Dispatch complete — ${event.dispatched} dispatched, ${event.skipped} skipped`);
+      break;
+  }
+}
+
+// src/shared/ui/render/merge.ts
+function renderMergeEvent(event, ctx) {
+  switch (event.type) {
+    case "merge:start":
+      ctx.info(`Merging ${event.prCount} PR(s) in ${event.owner}/${event.repo} [${event.mode}]`);
+      break;
+    case "merge:no-prs":
+      ctx.info("No PRs ready to merge.");
+      break;
+    case "merge:pr:processing":
+      ctx.startSpinner(`PR #${event.number}: ${event.title}${event.retry ? ` (retry ${event.retry})` : ""}`);
+      break;
+    case "merge:branch:updating":
+      ctx.startSpinner(`Updating branch for PR #${event.prNumber}…`);
+      break;
+    case "merge:branch:updated":
+      ctx.stopSpinner(`Branch updated for PR #${event.prNumber}`);
+      break;
+    case "merge:ci:waiting":
+      ctx.startSpinner(`Waiting for CI on PR #${event.prNumber}…`);
+      break;
+    case "merge:ci:check": {
+      const icon = event.status === "pass" ? "✓" : event.status === "fail" ? "✗" : "…";
+      const dur = event.duration ? ` (${event.duration}s)` : "";
+      ctx.info(`  ${icon} ${event.name}${dur}`);
+      break;
+    }
+    case "merge:ci:passed":
+      ctx.stopSpinner(`CI passed for PR #${event.prNumber}`);
+      break;
+    case "merge:ci:failed":
+      ctx.stopSpinner(`CI failed for PR #${event.prNumber}`);
+      break;
+    case "merge:ci:timeout":
+      ctx.stopSpinner(`CI timed out for PR #${event.prNumber}`);
+      break;
+    case "merge:ci:none":
+      ctx.stopSpinner(`No CI checks for PR #${event.prNumber}`);
+      break;
+    case "merge:pr:merging":
+      ctx.startSpinner(`Merging PR #${event.prNumber}…`);
+      break;
+    case "merge:pr:merged":
+      ctx.stopSpinner(`PR #${event.prNumber} merged ✓`);
+      break;
+    case "merge:pr:skipped":
+      ctx.warn(`  ⊘ PR #${event.prNumber}: ${event.reason}`);
+      break;
+    case "merge:conflict:detected":
+      ctx.stopSpinner(`Conflict detected on PR #${event.prNumber}`);
+      break;
+    case "merge:redispatch:start":
+      ctx.startSpinner(`Re-dispatching PR #${event.oldPr}…`);
+      break;
+    case "merge:redispatch:waiting":
+      ctx.startSpinner(`Waiting for re-dispatched PR (was #${event.oldPr})…`);
+      break;
+    case "merge:redispatch:done":
+      ctx.stopSpinner(`Re-dispatched: #${event.oldPr} → #${event.newPr}`);
+      break;
+    case "merge:done":
+      ctx.success(`Merge complete — ${event.merged.length} merged, ${event.skipped.length} skipped`);
+      break;
+  }
+}
+
+// src/shared/ui/render/error.ts
+function renderErrorEvent(event, ctx) {
+  ctx.stopSpinner();
+  ctx.error(`[${event.code}] ${event.message}`);
+  if (event.suggestion)
+    ctx.info(`  \uD83D\uDCA1 ${event.suggestion}`);
+}
+
+// src/shared/ui/interactive.ts
+class InteractiveRenderer {
+  spinner = null;
+  ctx = {
+    info: (msg) => p.log.info(msg),
+    success: (msg) => p.log.success(msg),
+    warn: (msg) => p.log.warn(msg),
+    error: (msg) => p.log.error(msg),
+    message: (msg) => p.log.message(msg),
+    step: (msg) => p.log.step(msg),
+    startSpinner: (msg) => this.startSpinner(msg),
+    stopSpinner: (msg) => this.stopSpinner(msg)
+  };
+  start(title) {
+    p.intro(title);
+  }
+  end(message) {
+    this.stopSpinner();
+    p.outro(message);
+  }
+  error(message) {
+    this.stopSpinner();
+    p.log.error(message);
+  }
+  render(event) {
+    if (event.type.startsWith("init:"))
+      return renderInitEvent(event, this.ctx);
+    if (event.type.startsWith("configure:"))
+      return renderConfigureEvent(event, this.ctx);
+    if (event.type.startsWith("analyze:"))
+      return renderAnalyzeEvent(event, this.ctx);
+    if (event.type.startsWith("dispatch:"))
+      return renderDispatchEvent(event, this.ctx);
+    if (event.type.startsWith("merge:"))
+      return renderMergeEvent(event, this.ctx);
+    if (event.type === "error")
+      return renderErrorEvent(event, this.ctx);
+  }
+  startSpinner(message) {
+    this.stopSpinner();
+    this.spinner = p.spinner();
+    this.spinner.start(message);
+  }
+  stopSpinner(message) {
+    if (this.spinner) {
+      this.spinner.stop(message);
+      this.spinner = null;
+    }
+  }
+}
+
+// src/shared/ui/plain.ts
+class PlainRenderer {
+  ctx = {
+    info: (msg) => console.log(msg),
+    success: (msg) => console.log(msg),
+    warn: (msg) => console.log(msg),
+    error: (msg) => console.error(msg),
+    message: (msg) => console.log(msg),
+    step: (msg) => console.log(msg),
+    startSpinner: (msg) => console.log(msg),
+    stopSpinner: (msg) => {
+      if (msg)
+        console.log(`  ✓ ${msg}`);
+    }
+  };
+  start(title) {
+    console.log(`
+═══ ${title} ═══
+`);
+  }
+  end(message) {
+    console.log(`
+═══ ${message} ═══
+`);
+  }
+  error(message) {
+    console.error(`ERROR: ${message}`);
+  }
+  render(event) {
+    if (event.type.startsWith("init:"))
+      return renderInitEvent(event, this.ctx);
+    if (event.type.startsWith("configure:"))
+      return renderConfigureEvent(event, this.ctx);
+    if (event.type.startsWith("analyze:"))
+      return renderAnalyzeEvent(event, this.ctx);
+    if (event.type.startsWith("dispatch:"))
+      return renderDispatchEvent(event, this.ctx);
+    if (event.type.startsWith("merge:"))
+      return renderMergeEvent(event, this.ctx);
+    if (event.type === "error")
+      return renderErrorEvent(event, this.ctx);
+  }
+}
+
+// src/shared/ui/index.ts
+function isInteractive() {
+  if (process.env.CI === "true")
+    return false;
+  if (!process.stdout.isTTY)
+    return false;
+  return true;
+}
+function createRenderer(interactive) {
+  const useInteractive = interactive ?? isInteractive();
+  return useInteractive ? new InteractiveRenderer : new PlainRenderer;
+}
+function createEmitter(renderer) {
+  return (event) => renderer.render(event);
+}
+
+// src/cli/merge.command.ts
+var merge_command_default = defineCommand({
+  meta: {
+    name: "merge",
+    description: "Sequentially merge fleet PRs (label or fleet-run mode)"
+  },
+  args: {
+    mode: {
+      type: "string",
+      description: "PR selection mode: label or fleet-run",
+      default: "label"
+    },
+    "run-id": {
+      type: "string",
+      description: "Fleet run ID (required for fleet-run mode)",
+      default: ""
+    },
+    base: {
+      type: "string",
+      description: "Base branch to merge into",
+      default: process.env.FLEET_BASE_BRANCH || "main"
+    },
+    admin: {
+      type: "boolean",
+      description: "Use admin privileges to bypass branch protection",
+      default: false
+    },
+    "re-dispatch": {
+      type: "boolean",
+      description: "Automatically re-dispatch tasks on merge conflict (requires JULES_API_KEY)",
+      default: false
+    },
+    owner: {
+      type: "string",
+      description: "Repository owner (auto-detected from git remote if omitted)"
+    },
+    repo: {
+      type: "string",
+      description: "Repository name (auto-detected from git remote if omitted)"
+    }
+  },
+  async run({ args }) {
+    const renderer = createRenderer();
+    let owner = args.owner;
+    let repo = args.repo;
+    if (!owner || !repo) {
+      const repoInfo = await getGitRepoInfo();
+      owner = owner || repoInfo.owner;
+      repo = repo || repoInfo.repo;
+    }
+    renderer.start(`Fleet Merge — ${owner}/${repo} (${args.mode} mode)`);
+    const input = MergeInputSchema.parse({
+      mode: args.mode,
+      runId: args["run-id"] || undefined,
+      baseBranch: args.base,
+      admin: args.admin,
+      reDispatch: args["re-dispatch"],
+      owner,
+      repo
+    });
+    const octokit = createFleetOctokit();
+    const emit = createEmitter(renderer);
+    const handler = new MergeHandler({ octokit, emit });
+    const result = await handler.execute(input);
+    if (!result.success) {
+      renderer.error(result.error.message);
+      process.exit(1);
+    }
+    renderer.end("Sequential merge complete.");
+  }
+});
+export {
+  merge_command_default as default
+};