@google/jules-fleet 0.0.1-experimental.0

package/dist/cli/dispatch.command.mjs

@@ -0,0 +1,777 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/cli/dispatch.command.ts
+import { defineCommand } from "citty";
+
+// src/dispatch/spec.ts
+import { z } from "zod";
+var DispatchInputSchema = z.object({
+  milestone: z.string().min(1),
+  owner: z.string().min(1),
+  repo: z.string().min(1),
+  baseBranch: z.string().default("main")
+});
+var DispatchErrorCode = z.enum([
+  "NO_FLEET_ISSUES",
+  "MILESTONE_FETCH_FAILED",
+  "SESSION_DISPATCH_FAILED",
+  "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/analyze/milestone.ts
+var IGNORE_LABEL = "status: ignore";
+function isTargetIssue(issue) {
+  if (issue.pull_request)
+    return false;
+  const hasIgnoreLabel = issue.labels?.some((label) => {
+    const labelName = typeof label === "string" ? label : label.name;
+    return labelName === IGNORE_LABEL;
+  });
+  return !hasIgnoreLabel;
+}
+function toMilestoneIssue(raw) {
+  return {
+    number: raw.number,
+    title: raw.title,
+    state: raw.state,
+    labels: (raw.labels ?? []).map((l) => typeof l === "string" ? l : l.name),
+    body: raw.body ?? "",
+    createdAt: raw.created_at,
+    closedAt: raw.closed_at ?? undefined
+  };
+}
+function toPullRequest(raw) {
+  return {
+    number: raw.number,
+    title: raw.title,
+    head: raw.head.ref,
+    base: raw.base.ref,
+    body: raw.body ?? ""
+  };
+}
+async function getMilestoneContext(octokit, options) {
+  const { owner, repo, milestone, closedLookbackDays = 14 } = options;
+  let milestoneInfo;
+  if (milestone) {
+    const { data } = await octokit.rest.issues.getMilestone({
+      owner,
+      repo,
+      milestone_number: parseInt(milestone, 10)
+    });
+    milestoneInfo = { number: data.number, title: data.title };
+  }
+  const apiMilestoneFilter = milestone || "none";
+  const { data: openRaw } = await octokit.rest.issues.listForRepo({
+    owner,
+    repo,
+    state: "open",
+    milestone: apiMilestoneFilter,
+    per_page: 100
+  });
+  const since = new Date;
+  since.setDate(since.getDate() - closedLookbackDays);
+  const { data: closedRaw } = await octokit.rest.issues.listForRepo({
+    owner,
+    repo,
+    state: "closed",
+    milestone: apiMilestoneFilter,
+    since: since.toISOString(),
+    per_page: 100
+  });
+  const { data: openPRs } = await octokit.rest.pulls.list({
+    owner,
+    repo,
+    state: "open",
+    per_page: 100
+  });
+  return {
+    milestone: milestoneInfo,
+    issues: {
+      open: openRaw.filter(isTargetIssue).map(toMilestoneIssue),
+      closed: closedRaw.filter(isTargetIssue).map(toMilestoneIssue)
+    },
+    pullRequests: openPRs.map(toPullRequest)
+  };
+}
+
+// src/dispatch/status.ts
+var DISPATCH_MARKER = "\uD83E\uDD16 **Fleet Dispatch Event**";
+async function getDispatchStatus(octokit, owner, repo, issueNumbers) {
+  const { data: openPRs } = await octokit.rest.pulls.list({
+    owner,
+    repo,
+    state: "open",
+    per_page: 100
+  });
+  const results = [];
+  for (const issueNumber of issueNumbers) {
+    const { data: issue } = await octokit.rest.issues.get({
+      owner,
+      repo,
+      issue_number: issueNumber
+    });
+    const { data: comments } = await octokit.rest.issues.listComments({
+      owner,
+      repo,
+      issue_number: issueNumber,
+      per_page: 100
+    });
+    const dispatchComment = comments.find((c) => c.body?.includes(DISPATCH_MARKER));
+    let dispatchEvent = null;
+    if (dispatchComment?.body) {
+      const sessionMatch = dispatchComment.body.match(/Session:\s*`([^`]+)`/);
+      dispatchEvent = {
+        sessionId: sessionMatch?.[1] ?? "unknown",
+        timestamp: dispatchComment.created_at,
+        commentId: dispatchComment.id
+      };
+    }
+    const linkedPRs = openPRs.filter((pr) => pr.body?.includes(`#${issueNumber}`) || pr.body?.includes(`Fixes #${issueNumber}`) || pr.body?.includes(`Closes #${issueNumber}`)).map((pr) => pr.number);
+    results.push({
+      number: issueNumber,
+      open: issue.state === "open",
+      labels: (issue.labels ?? []).map((l) => typeof l === "string" ? l : l.name),
+      dispatchEvent,
+      linkedPRs
+    });
+  }
+  return results;
+}
+
+// src/dispatch/events.ts
+async function recordDispatch(octokit, owner, repo, issueNumber, sessionId) {
+  const timestamp = new Date().toISOString();
+  const body = [
+    `\uD83E\uDD16 **Fleet Dispatch Event**`,
+    `Session: \`${sessionId}\``,
+    `Timestamp: ${timestamp}`
+  ].join(`
+`);
+  const { data: comment } = await octokit.rest.issues.createComment({
+    owner,
+    repo,
+    issue_number: issueNumber,
+    body
+  });
+  return {
+    commentId: comment.id,
+    timestamp
+  };
+}
+
+// src/dispatch/handler.ts
+class DispatchHandler {
+  octokit;
+  dispatcher;
+  emit;
+  constructor(deps) {
+    this.octokit = deps.octokit;
+    this.dispatcher = deps.dispatcher;
+    this.emit = deps.emit ?? (() => {});
+  }
+  async execute(input) {
+    try {
+      this.emit({ type: "dispatch:start", milestone: input.milestone });
+      this.emit({ type: "dispatch:scanning" });
+      const ctx = await getMilestoneContext(this.octokit, {
+        owner: input.owner,
+        repo: input.repo,
+        milestone: input.milestone
+      });
+      const fleetIssues = ctx.issues.open.filter((issue) => issue.labels.includes("fleet"));
+      if (fleetIssues.length === 0) {
+        this.emit({ type: "dispatch:done", dispatched: 0, skipped: 0 });
+        return ok({ dispatched: [], skipped: 0 });
+      }
+      const statuses = await getDispatchStatus(this.octokit, input.owner, input.repo, fleetIssues.map((i) => i.number));
+      const undispatched = statuses.filter((s) => s.open && !s.dispatchEvent && s.linkedPRs.length === 0);
+      const skipped = statuses.length - undispatched.length;
+      if (undispatched.length === 0) {
+        this.emit({ type: "dispatch:done", dispatched: 0, skipped });
+        return ok({ dispatched: [], skipped });
+      }
+      this.emit({ type: "dispatch:found", count: undispatched.length });
+      const dispatched = [];
+      for (const status of undispatched) {
+        const issue = fleetIssues.find((i) => i.number === status.number);
+        this.emit({
+          type: "dispatch:issue:dispatching",
+          number: issue.number,
+          title: issue.title
+        });
+        const workerPrompt = `Fix Issue #${issue.number}: ${issue.title}
+
+IMPORTANT: Your PR title MUST start with "Fixes #${issue.number}" and your PR description MUST include "Fixes #${issue.number}" on its own line so the issue is auto-closed on merge.
+
+You are an autonomous execution agent. Implement the fix described below exactly as specified.
+
+---
+
+${issue.body}
+`;
+        try {
+          const session = await this.dispatcher.dispatch({
+            prompt: workerPrompt,
+            source: {
+              github: `${input.owner}/${input.repo}`,
+              baseBranch: input.baseBranch
+            },
+            requireApproval: false,
+            autoPr: true
+          });
+          await recordDispatch(this.octokit, input.owner, input.repo, issue.number, session.id);
+          dispatched.push({
+            issueNumber: issue.number,
+            sessionId: session.id
+          });
+          this.emit({
+            type: "dispatch:issue:dispatched",
+            number: issue.number,
+            sessionId: session.id
+          });
+        } catch (error) {
+          this.emit({
+            type: "error",
+            code: "DISPATCH_FAILED",
+            message: `Failed to dispatch #${issue.number}: ${error instanceof Error ? error.message : error}`
+          });
+        }
+      }
+      for (const status of statuses) {
+        if (!undispatched.includes(status)) {
+          this.emit({
+            type: "dispatch:issue:skipped",
+            number: status.number,
+            reason: status.dispatchEvent ? "already dispatched" : "has linked PRs"
+          });
+        }
+      }
+      this.emit({
+        type: "dispatch:done",
+        dispatched: dispatched.length,
+        skipped
+      });
+      return ok({ dispatched, skipped });
+    } catch (error) {
+      return fail("UNKNOWN_ERROR", error instanceof Error ? error.message : String(error), false);
+    }
+  }
+}
+
+// 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/dispatch.command.ts
+var dispatch_command_default = defineCommand({
+  meta: {
+    name: "dispatch",
+    description: "Poll for undispatched fleet issues and fire Jules worker sessions"
+  },
+  args: {
+    milestone: {
+      type: "string",
+      description: "Milestone ID to scope dispatch",
+      required: true
+    },
+    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 Dispatch — Milestone ${args.milestone}`);
+    const input = DispatchInputSchema.parse({
+      milestone: args.milestone,
+      owner,
+      repo,
+      baseBranch: process.env.FLEET_BASE_BRANCH || "main"
+    });
+    const { jules } = await import("@google/jules-sdk");
+    const dispatcher = {
+      async dispatch(options) {
+        return jules.session({
+          prompt: options.prompt,
+          source: options.source,
+          requireApproval: options.requireApproval,
+          autoPr: options.autoPr
+        });
+      }
+    };
+    const octokit = createFleetOctokit();
+    const emit = createEmitter(renderer);
+    const handler = new DispatchHandler({ octokit, dispatcher, emit });
+    const result = await handler.execute(input);
+    if (!result.success) {
+      renderer.error(result.error.message);
+      process.exit(1);
+    }
+    const { dispatched, skipped } = result.data;
+    renderer.end(`${dispatched.length} dispatched, ${skipped} skipped.`);
+  }
+});
+export {
+  dispatch_command_default as default
+};