@google/jules-fleet 0.0.1-experimental.0

package/dist/cli/init.command.mjs

@@ -0,0 +1,1287 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/cli/init.command.ts
+import { defineCommand } from "citty";
+
+// src/init/spec.ts
+import { z } from "zod";
+var InitInputSchema = z.object({
+  repo: z.string().regex(/^[^/]+\/[^/]+$/, "Must be in owner/repo format").optional(),
+  owner: z.string().min(1),
+  repoName: z.string().min(1),
+  baseBranch: z.string().default("main")
+});
+var InitErrorCode = z.enum([
+  "REPO_NOT_FOUND",
+  "BRANCH_CREATE_FAILED",
+  "FILE_COMMIT_FAILED",
+  "PR_CREATE_FAILED",
+  "LABEL_CREATE_FAILED",
+  "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/init/templates/analyze.ts
+var FLEET_ANALYZE_TEMPLATE = {
+  repoPath: ".github/workflows/fleet-analyze.yml",
+  content: `# Generated by @google/jules-fleet init
+# https://github.com/google-labs-code/jules-sdk
+
+name: Fleet Analyze
+
+on:
+  schedule:
+    - cron: '0 5 * * *' # Daily at 5am UTC — edit to your preference
+  workflow_dispatch:
+    inputs:
+      goal:
+        description: 'Path to goal file (or blank for all)'
+        type: string
+        default: ''
+      milestone:
+        description: 'Milestone ID override'
+        type: string
+        default: ''
+
+concurrency:
+  group: fleet-analyze
+  cancel-in-progress: false
+
+jobs:
+  analyze:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      issues: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+      - run: npx @google/jules-fleet analyze --goal "\${{ inputs.goal }}" --milestone "\${{ inputs.milestone }}"
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+          JULES_API_KEY: \${{ secrets.JULES_API_KEY }}
+`
+};
+// src/init/templates/dispatch.ts
+var FLEET_DISPATCH_TEMPLATE = {
+  repoPath: ".github/workflows/fleet-dispatch.yml",
+  content: `# Generated by @google/jules-fleet init
+# https://github.com/google-labs-code/jules-sdk
+
+name: Fleet Dispatch
+
+on:
+  schedule:
+    - cron: '0 6 * * *' # Daily at 6am UTC — edit to your preference
+  workflow_dispatch:
+    inputs:
+      milestone:
+        description: 'Milestone ID to dispatch'
+        type: string
+        required: true
+
+concurrency:
+  group: fleet-dispatch
+  cancel-in-progress: false
+
+jobs:
+  dispatch:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      issues: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+      - run: npx @google/jules-fleet dispatch --milestone \${{ inputs.milestone }}
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+          JULES_API_KEY: \${{ secrets.JULES_API_KEY }}
+`
+};
+// src/init/templates/merge.ts
+var FLEET_MERGE_TEMPLATE = {
+  repoPath: ".github/workflows/fleet-merge.yml",
+  content: `# Generated by @google/jules-fleet init
+# https://github.com/google-labs-code/jules-sdk
+
+name: Fleet Merge
+
+on:
+  schedule:
+    - cron: '0 */4 * * *' # Every 4 hours — edit to your preference
+  workflow_dispatch:
+    inputs:
+      mode:
+        description: 'PR selection mode'
+        type: choice
+        options:
+          - label
+          - fleet-run
+        default: 'label'
+      fleet_run_id:
+        description: 'Fleet run ID (required for fleet-run mode)'
+        type: string
+        default: ''
+      re_dispatch:
+        description: 'Auto re-dispatch on merge conflict'
+        type: boolean
+        default: true
+
+concurrency:
+  group: fleet-merge
+  cancel-in-progress: false
+
+jobs:
+  merge:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+      issues: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+      - run: |
+          REDISPATCH_FLAG=""
+          if [ "\${{ inputs.re_dispatch }}" = "true" ]; then
+            REDISPATCH_FLAG="--re-dispatch"
+          fi
+          npx @google/jules-fleet merge \\
+            --mode \${{ inputs.mode || 'label' }} \\
+            --run-id "\${{ inputs.fleet_run_id }}" \\
+            $REDISPATCH_FLAG
+        env:
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+          JULES_API_KEY: \${{ secrets.JULES_API_KEY }}
+`
+};
+// src/init/templates.ts
+var WORKFLOW_TEMPLATES = [
+  FLEET_ANALYZE_TEMPLATE,
+  FLEET_DISPATCH_TEMPLATE,
+  FLEET_MERGE_TEMPLATE
+];
+
+// src/init/templates/example-goal.ts
+var EXAMPLE_GOAL = `---
+milestone: "1"
+---
+
+# Example Fleet Goal
+
+Analyze the codebase for potential improvements and create
+issues for the engineering team.
+
+## Tools
+- Test Coverage: \`npx vitest --coverage --json\`
+
+## Assessment Hints
+- Focus on missing error handling in API routes
+- Look for hardcoded configuration values
+
+## Insight Hints
+- Report on overall test coverage metrics
+- Note any unusually complex functions (cyclomatic complexity)
+
+## Constraints
+- Do NOT propose changes already covered by open issues
+- Do NOT propose changes rejected in recently closed issues
+- Keep tasks small and isolated — one logical change per issue
+`;
+
+// src/init/ops/create-branch.ts
+async function createBranch(octokit, owner, repo, baseBranch, emit) {
+  const { data: refData } = await octokit.rest.git.getRef({
+    owner,
+    repo,
+    ref: `heads/${baseBranch}`
+  });
+  const baseSha = refData.object.sha;
+  const branchName = `fleet-init-${Date.now()}`;
+  emit({ type: "init:branch:creating", name: branchName, base: baseBranch });
+  try {
+    await octokit.rest.git.createRef({
+      owner,
+      repo,
+      ref: `refs/heads/${branchName}`,
+      sha: baseSha
+    });
+    emit({ type: "init:branch:created", name: branchName });
+  } catch (error) {
+    return fail("BRANCH_CREATE_FAILED", `Failed to create branch "${branchName}": ${error instanceof Error ? error.message : error}`, true);
+  }
+  return { branchName, baseSha };
+}
+function isBranchResult(result) {
+  return "success" in result;
+}
+
+// src/init/ops/commit-files.ts
+async function commitFiles(ctx, templates, exampleGoal) {
+  const filesCreated = [];
+  for (const tmpl of templates) {
+    try {
+      await ctx.octokit.rest.repos.createOrUpdateFileContents({
+        owner: ctx.owner,
+        repo: ctx.repo,
+        path: tmpl.repoPath,
+        message: `chore: add ${tmpl.repoPath}`,
+        content: Buffer.from(tmpl.content).toString("base64"),
+        branch: ctx.branchName
+      });
+      filesCreated.push(tmpl.repoPath);
+      ctx.emit({ type: "init:file:committed", path: tmpl.repoPath });
+    } catch (error) {
+      const status = error && typeof error === "object" && "status" in error ? error.status : 0;
+      if (status === 422) {
+        ctx.emit({ type: "init:file:skipped", path: tmpl.repoPath, reason: "already exists" });
+      } else {
+        return fail("FILE_COMMIT_FAILED", `Failed to commit "${tmpl.repoPath}": ${error instanceof Error ? error.message : error}`, true);
+      }
+    }
+  }
+  try {
+    await ctx.octokit.rest.repos.createOrUpdateFileContents({
+      owner: ctx.owner,
+      repo: ctx.repo,
+      path: ".fleet/goals/example.md",
+      message: "chore: add example fleet goal",
+      content: Buffer.from(exampleGoal).toString("base64"),
+      branch: ctx.branchName
+    });
+    filesCreated.push(".fleet/goals/example.md");
+    ctx.emit({ type: "init:file:committed", path: ".fleet/goals/example.md" });
+  } catch (error) {
+    const status = error && typeof error === "object" && "status" in error ? error.status : 0;
+    if (status !== 422) {
+      ctx.emit({
+        type: "init:file:skipped",
+        path: ".fleet/goals/example.md",
+        reason: `${error instanceof Error ? error.message : error}`
+      });
+    }
+  }
+  return filesCreated;
+}
+function isCommitResult(result) {
+  return !Array.isArray(result);
+}
+
+// src/init/ops/pr-body.ts
+function buildInitPRBody(filesCreated) {
+  return [
+    "## Fleet Initialization",
+    "",
+    "This PR adds the fleet workflow files for automated issue dispatch, merge, and analysis.",
+    "",
+    "### Files added",
+    ...filesCreated.map((f) => `- \`${f}\``),
+    "",
+    "### Next steps",
+    "1. Merge this PR",
+    "2. Add `JULES_API_KEY` to your repo secrets",
+    "3. Create milestones and issues with the `fleet` label",
+    "4. Run `jules-fleet configure labels` to set up labels (or they were already created)"
+  ].join(`
+`);
+}
+
+// src/init/ops/create-pr.ts
+async function createInitPR(ctx, baseBranch, filesCreated) {
+  ctx.emit({ type: "init:pr:creating" });
+  try {
+    const { data: pr } = await ctx.octokit.rest.pulls.create({
+      owner: ctx.owner,
+      repo: ctx.repo,
+      title: "chore: initialize fleet workflows",
+      body: buildInitPRBody(filesCreated),
+      head: ctx.branchName,
+      base: baseBranch
+    });
+    ctx.emit({ type: "init:pr:created", url: pr.html_url, number: pr.number });
+    return { prUrl: pr.html_url, prNumber: pr.number };
+  } catch (error) {
+    return fail("PR_CREATE_FAILED", `Failed to create PR: ${error instanceof Error ? error.message : error}`, true);
+  }
+}
+function isPRResult(result) {
+  return "success" in result;
+}
+
+// src/init/handler.ts
+class InitHandler {
+  octokit;
+  emit;
+  labelConfigurator;
+  constructor(deps) {
+    this.octokit = deps.octokit;
+    this.emit = deps.emit ?? (() => {});
+    this.labelConfigurator = deps.labelConfigurator;
+  }
+  async execute(input) {
+    try {
+      const { owner, repoName: repo, baseBranch } = input;
+      this.emit({ type: "init:start", owner, repo });
+      const branchResult = await createBranch(this.octokit, owner, repo, baseBranch, this.emit);
+      if (isBranchResult(branchResult))
+        return branchResult;
+      const { branchName } = branchResult;
+      const ctx = {
+        octokit: this.octokit,
+        owner,
+        repo,
+        branchName,
+        emit: this.emit
+      };
+      const filesResult = await commitFiles(ctx, WORKFLOW_TEMPLATES, EXAMPLE_GOAL);
+      if (isCommitResult(filesResult))
+        return filesResult;
+      const filesCreated = filesResult;
+      if (filesCreated.length === 0) {
+        this.emit({
+          type: "error",
+          code: "ALREADY_INITIALIZED",
+          message: "All fleet files already exist — nothing to commit.",
+          suggestion: "This repo appears to be already initialized. Use jules-fleet configure to update settings."
+        });
+        return fail("FILE_COMMIT_FAILED", "All fleet files already exist — nothing to commit.", false, "This repo appears to be already initialized. Use jules-fleet configure to update settings.");
+      }
+      const prResult = await createInitPR(ctx, baseBranch, filesCreated);
+      if (isPRResult(prResult))
+        return prResult;
+      const { prUrl, prNumber } = prResult;
+      let labelsCreated = [];
+      if (this.labelConfigurator) {
+        const labelResult = await this.labelConfigurator.execute({
+          resource: "labels",
+          action: "create",
+          owner,
+          repo
+        });
+        labelsCreated = labelResult.success ? labelResult.data.created : [];
+      }
+      this.emit({
+        type: "init:done",
+        prUrl,
+        files: filesCreated,
+        labels: labelsCreated
+      });
+      return ok({ prUrl, prNumber, filesCreated, labelsCreated });
+    } catch (error) {
+      return fail("UNKNOWN_ERROR", error instanceof Error ? error.message : String(error), false);
+    }
+  }
+}
+
+// src/configure/labels.ts
+var FLEET_LABELS = [
+  {
+    name: "fleet-merge-ready",
+    color: "0e8a16",
+    description: "Ready for fleet sequential merge"
+  },
+  {
+    name: "fleet",
+    color: "1d76db",
+    description: "Fleet-managed issue"
+  }
+];
+
+// src/configure/handler.ts
+class ConfigureHandler {
+  octokit;
+  emit;
+  constructor(deps) {
+    this.octokit = deps.octokit;
+    this.emit = deps.emit ?? (() => {});
+  }
+  async execute(input) {
+    try {
+      this.emit({
+        type: "configure:start",
+        resource: input.resource,
+        owner: input.owner,
+        repo: input.repo
+      });
+      if (input.resource === "labels") {
+        const result = input.action === "create" ? await this.createLabels(input.owner, input.repo) : await this.deleteLabels(input.owner, input.repo);
+        this.emit({ type: "configure:done" });
+        return result;
+      }
+      return fail("UNKNOWN_ERROR", `Unknown resource: ${input.resource}`, false);
+    } catch (error) {
+      return fail("UNKNOWN_ERROR", error instanceof Error ? error.message : String(error), false);
+    }
+  }
+  async createLabels(owner, repo) {
+    const created = [];
+    const skipped = [];
+    for (const label of FLEET_LABELS) {
+      try {
+        await this.octokit.rest.issues.createLabel({
+          owner,
+          repo,
+          name: label.name,
+          color: label.color,
+          description: label.description
+        });
+        created.push(label.name);
+        this.emit({ type: "configure:label:created", name: label.name });
+      } catch (error) {
+        const status = error && typeof error === "object" && "status" in error ? error.status : 0;
+        if (status === 422) {
+          skipped.push(label.name);
+          this.emit({ type: "configure:label:exists", name: label.name });
+        } else {
+          return fail("GITHUB_API_ERROR", `Failed to create label "${label.name}": ${error instanceof Error ? error.message : error}`, true);
+        }
+      }
+    }
+    return ok({ created, deleted: [], skipped });
+  }
+  async deleteLabels(owner, repo) {
+    const deleted = [];
+    const skipped = [];
+    for (const label of FLEET_LABELS) {
+      try {
+        await this.octokit.rest.issues.deleteLabel({
+          owner,
+          repo,
+          name: label.name
+        });
+        deleted.push(label.name);
+        this.emit({ type: "configure:label:created", name: label.name });
+      } catch (error) {
+        const status = error && typeof error === "object" && "status" in error ? error.status : 0;
+        if (status === 404) {
+          skipped.push(label.name);
+          this.emit({ type: "configure:label:exists", name: label.name });
+        } else {
+          return fail("GITHUB_API_ERROR", `Failed to delete label "${label.name}": ${error instanceof Error ? error.message : error}`, true);
+        }
+      }
+    }
+    return ok({ created: [], deleted, skipped });
+  }
+}
+
+// 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/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/init/wizard/interactive.ts
+import * as p2 from "@clack/prompts";
+
+// 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/init/wizard/interactive.ts
+async function runInitWizard(args, emit) {
+  let repoSlug = args.repo ?? process.env.GITHUB_REPOSITORY;
+  if (!repoSlug) {
+    try {
+      const info = await getGitRepoInfo();
+      repoSlug = info.fullName;
+    } catch {}
+  }
+  if (repoSlug) {
+    const confirmed = await p2.confirm({
+      message: `Detected repository: ${repoSlug}. Is this correct?`,
+      initialValue: true
+    });
+    if (p2.isCancel(confirmed))
+      return fail("UNKNOWN_ERROR", "Setup cancelled.", false);
+    if (!confirmed) {
+      const manual = await p2.text({
+        message: "Enter repository in owner/repo format:",
+        validate: (v) => !v || !/^[^/]+\/[^/]+$/.test(v) ? "Must be owner/repo format" : undefined
+      });
+      if (p2.isCancel(manual))
+        return fail("UNKNOWN_ERROR", "Setup cancelled.", false);
+      repoSlug = manual;
+    }
+  } else {
+    const manual = await p2.text({
+      message: "Enter repository in owner/repo format:",
+      validate: (v) => !v || !/^[^/]+\/[^/]+$/.test(v) ? "Must be owner/repo format" : undefined
+    });
+    if (p2.isCancel(manual))
+      return fail("UNKNOWN_ERROR", "Setup cancelled.", false);
+    repoSlug = manual;
+  }
+  const [owner, repo] = repoSlug.split("/");
+  const baseBranch = args.base ?? "main";
+  const hasToken = !!process.env.GITHUB_TOKEN;
+  const hasApp = !!(process.env.GITHUB_APP_ID && (process.env.GITHUB_APP_PRIVATE_KEY_BASE64 || process.env.GITHUB_APP_PRIVATE_KEY) && process.env.GITHUB_APP_INSTALLATION_ID);
+  let authMethod;
+  if (args.auth === "token" || args.auth === "app") {
+    authMethod = args.auth;
+  } else if (hasApp) {
+    authMethod = "app";
+    p2.log.success("GitHub App credentials detected");
+  } else if (hasToken) {
+    authMethod = "token";
+    p2.log.success("GITHUB_TOKEN detected");
+  } else {
+    const authChoice = await p2.select({
+      message: "How will Fleet authenticate with GitHub?",
+      options: [
+        { value: "token", label: "Personal Access Token (GITHUB_TOKEN)" },
+        { value: "app", label: "GitHub App (recommended for orgs)" }
+      ]
+    });
+    if (p2.isCancel(authChoice))
+      return fail("UNKNOWN_ERROR", "Setup cancelled.", false);
+    authMethod = authChoice;
+    if (authMethod === "token") {
+      if (!hasToken) {
+        const token = await p2.password({
+          message: "Paste your GitHub token:"
+        });
+        if (p2.isCancel(token))
+          return fail("UNKNOWN_ERROR", "Setup cancelled.", false);
+        process.env.GITHUB_TOKEN = token;
+      }
+    } else {
+      if (!process.env.GITHUB_APP_ID) {
+        const appId = await p2.text({ message: "Enter your GitHub App ID:" });
+        if (p2.isCancel(appId))
+          return fail("UNKNOWN_ERROR", "Setup cancelled.", false);
+        process.env.GITHUB_APP_ID = appId;
+      }
+      if (!process.env.GITHUB_APP_INSTALLATION_ID) {
+        const installId = await p2.text({ message: "Enter your Installation ID:" });
+        if (p2.isCancel(installId))
+          return fail("UNKNOWN_ERROR", "Setup cancelled.", false);
+        process.env.GITHUB_APP_INSTALLATION_ID = installId;
+      }
+      if (!process.env.GITHUB_APP_PRIVATE_KEY_BASE64 && !process.env.GITHUB_APP_PRIVATE_KEY) {
+        const key = await p2.password({ message: "Paste your private key (base64 encoded):" });
+        if (p2.isCancel(key))
+          return fail("UNKNOWN_ERROR", "Setup cancelled.", false);
+        process.env.GITHUB_APP_PRIVATE_KEY_BASE64 = key;
+      }
+    }
+  }
+  emit({ type: "init:auth:detected", method: authMethod });
+  const secretsToUpload = {};
+  const julesKey = process.env.JULES_API_KEY;
+  if (!julesKey) {
+    const wantKey = await p2.confirm({
+      message: "Fleet needs a JULES_API_KEY to dispatch sessions. Do you have one?",
+      initialValue: true
+    });
+    if (!p2.isCancel(wantKey) && wantKey) {
+      const key = await p2.password({ message: "Enter your Jules API key:" });
+      if (!p2.isCancel(key)) {
+        process.env.JULES_API_KEY = key;
+        secretsToUpload["JULES_API_KEY"] = key;
+      }
+    }
+  } else {
+    p2.log.success("JULES_API_KEY detected");
+    secretsToUpload["JULES_API_KEY"] = julesKey;
+  }
+  const shouldUpload = args["upload-secrets"] ?? true;
+  if (shouldUpload && Object.keys(secretsToUpload).length > 0) {
+    const confirmed = await p2.confirm({
+      message: `Upload ${Object.keys(secretsToUpload).length} secret(s) to GitHub Actions secrets?`,
+      initialValue: true
+    });
+    if (p2.isCancel(confirmed) || !confirmed) {
+      Object.keys(secretsToUpload).forEach((k) => delete secretsToUpload[k]);
+    }
+  }
+  if (shouldUpload && authMethod === "app") {
+    const uploadApp = await p2.confirm({
+      message: "Upload GitHub App credentials to repo secrets?",
+      initialValue: true
+    });
+    if (!p2.isCancel(uploadApp) && uploadApp) {
+      if (process.env.GITHUB_APP_ID)
+        secretsToUpload["GITHUB_APP_ID"] = process.env.GITHUB_APP_ID;
+      if (process.env.GITHUB_APP_PRIVATE_KEY_BASE64) {
+        secretsToUpload["GITHUB_APP_PRIVATE_KEY_BASE64"] = process.env.GITHUB_APP_PRIVATE_KEY_BASE64;
+      }
+      if (process.env.GITHUB_APP_INSTALLATION_ID) {
+        secretsToUpload["GITHUB_APP_INSTALLATION_ID"] = process.env.GITHUB_APP_INSTALLATION_ID;
+      }
+    }
+  }
+  const dryRun = args["dry-run"] ?? false;
+  if (!dryRun) {
+    const files = WORKFLOW_TEMPLATES.map((t) => t.repoPath);
+    files.push(".fleet/goals/example.md");
+    p2.log.info([
+      "Fleet will:",
+      `  • Create a branch from ${baseBranch}`,
+      `  • Commit ${files.length} files`,
+      "  • Open a pull request",
+      "  • Configure labels (fleet, fleet-merge-ready)"
+    ].join(`
+`));
+    const proceed = await p2.confirm({
+      message: "Create the PR now?",
+      initialValue: true
+    });
+    if (p2.isCancel(proceed))
+      return fail("UNKNOWN_ERROR", "Setup cancelled.", false);
+    if (!proceed) {
+      emit({ type: "init:dry-run", files });
+      return fail("UNKNOWN_ERROR", `Dry run: would create ${files.length} files. Run again to proceed.`, false);
+    }
+  }
+  return { owner, repo, baseBranch, authMethod, secretsToUpload, dryRun };
+}
+// src/init/wizard/headless.ts
+async function validateHeadlessInputs(args, emit) {
+  let repoSlug = args.repo ?? process.env.GITHUB_REPOSITORY;
+  if (!repoSlug) {
+    try {
+      const info = await getGitRepoInfo();
+      repoSlug = info.fullName;
+    } catch {
+      return fail("UNKNOWN_ERROR", "Missing repository. Set --repo, GITHUB_REPOSITORY env var, or run from a git repo.", true);
+    }
+  }
+  const [owner, repo] = repoSlug.split("/");
+  if (!owner || !repo) {
+    return fail("UNKNOWN_ERROR", `Invalid repo format: "${repoSlug}". Expected owner/repo.`, false);
+  }
+  const hasToken = !!process.env.GITHUB_TOKEN;
+  const hasApp = !!((args["app-id"] || process.env.GITHUB_APP_ID) && (process.env.GITHUB_APP_PRIVATE_KEY_BASE64 || process.env.GITHUB_APP_PRIVATE_KEY) && (args["installation-id"] || process.env.GITHUB_APP_INSTALLATION_ID));
+  let authMethod;
+  if (args.auth === "app" || !args.auth && hasApp) {
+    authMethod = "app";
+    if (args["app-id"])
+      process.env.GITHUB_APP_ID = args["app-id"];
+    if (args["installation-id"])
+      process.env.GITHUB_APP_INSTALLATION_ID = args["installation-id"];
+    if (!hasApp) {
+      const missing = [];
+      if (!process.env.GITHUB_APP_ID && !args["app-id"])
+        missing.push("GITHUB_APP_ID (env) or --app-id");
+      if (!process.env.GITHUB_APP_PRIVATE_KEY_BASE64 && !process.env.GITHUB_APP_PRIVATE_KEY) {
+        missing.push("GITHUB_APP_PRIVATE_KEY_BASE64 (env)");
+      }
+      if (!process.env.GITHUB_APP_INSTALLATION_ID && !args["installation-id"]) {
+        missing.push("GITHUB_APP_INSTALLATION_ID (env) or --installation-id");
+      }
+      return fail("UNKNOWN_ERROR", `Missing GitHub App credentials: ${missing.join(", ")}.
+Or run without --non-interactive for guided setup.`, true);
+    }
+  } else if (args.auth === "token" || !args.auth && hasToken) {
+    authMethod = "token";
+  } else {
+    return fail("UNKNOWN_ERROR", `Missing GitHub authentication.
+Set GITHUB_TOKEN or GITHUB_APP_ID + GITHUB_APP_PRIVATE_KEY_BASE64 + GITHUB_APP_INSTALLATION_ID.
+Or run without --non-interactive for guided setup.`, true);
+  }
+  emit({ type: "init:auth:detected", method: authMethod });
+  if (!process.env.JULES_API_KEY) {
+    emit({
+      type: "init:secret:skipped",
+      name: "JULES_API_KEY",
+      reason: "Not set — Fleet workflows will not be able to dispatch sessions."
+    });
+  }
+  const baseBranch = args.base ?? "main";
+  const dryRun = args["dry-run"] ?? false;
+  const secretsToUpload = {};
+  if (dryRun) {
+    const files = WORKFLOW_TEMPLATES.map((t) => t.repoPath);
+    files.push(".fleet/goals/example.md");
+    emit({ type: "init:dry-run", files });
+  }
+  return { owner, repo, baseBranch, authMethod, secretsToUpload, dryRun };
+}
+// src/init/ops/upload-secrets.ts
+async function uploadSecret(octokit, owner, repo, secretName, secretValue, emit) {
+  emit({ type: "init:secret:uploading", name: secretName });
+  try {
+    const { data: publicKey } = await octokit.rest.actions.getRepoPublicKey({
+      owner,
+      repo
+    });
+    const sodium = await import("libsodium-wrappers");
+    await sodium.default.ready;
+    const binKey = sodium.default.from_base64(publicKey.key, sodium.default.base64_variants.ORIGINAL);
+    const binSecret = sodium.default.from_string(secretValue);
+    const encrypted = sodium.default.crypto_box_seal(binSecret, binKey);
+    const encryptedBase64 = sodium.default.to_base64(encrypted, sodium.default.base64_variants.ORIGINAL);
+    await octokit.rest.actions.createOrUpdateRepoSecret({
+      owner,
+      repo,
+      secret_name: secretName,
+      encrypted_value: encryptedBase64,
+      key_id: publicKey.key_id
+    });
+    emit({ type: "init:secret:uploaded", name: secretName });
+    return { success: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    emit({
+      type: "init:secret:skipped",
+      name: secretName,
+      reason: message
+    });
+    return { success: false, error: message };
+  }
+}
+
+// src/cli/init.command.ts
+var init_command_default = defineCommand({
+  meta: {
+    name: "init",
+    description: "Scaffold fleet workflow files by creating a PR"
+  },
+  args: {
+    repo: {
+      type: "string",
+      description: "Repository in owner/repo format (auto-detected from git remote if omitted)"
+    },
+    base: {
+      type: "string",
+      description: "Base branch for the PR",
+      default: "main"
+    },
+    "non-interactive": {
+      type: "boolean",
+      description: "Disable wizard prompts — all inputs via flags/env vars",
+      default: false
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Show what would be created without making changes",
+      default: false
+    },
+    auth: {
+      type: "string",
+      description: "Auth mode: token | app (auto-detected from env vars)"
+    },
+    "app-id": {
+      type: "string",
+      description: "GitHub App ID (overrides GITHUB_APP_ID env var)"
+    },
+    "installation-id": {
+      type: "string",
+      description: "GitHub App Installation ID (overrides env var)"
+    },
+    "upload-secrets": {
+      type: "boolean",
+      description: "Upload secrets to GitHub Actions (default: true in interactive, false in non-interactive)"
+    }
+  },
+  async run({ args }) {
+    const nonInteractive = args["non-interactive"] || !isInteractive();
+    const renderer = createRenderer(!nonInteractive);
+    const emit = createEmitter(renderer);
+    const wizardArgs = args;
+    const inputs = nonInteractive ? await validateHeadlessInputs(wizardArgs, emit) : await runInitWizard(wizardArgs, emit);
+    if ("success" in inputs && !inputs.success) {
+      renderer.error(inputs.error.message);
+      if (inputs.error.suggestion) {
+        renderer.render({
+          type: "error",
+          code: inputs.error.code,
+          message: inputs.error.suggestion
+        });
+      }
+      process.exit(1);
+    }
+    const { owner, repo, baseBranch, secretsToUpload, dryRun } = inputs;
+    renderer.start(`Fleet Init — ${owner}/${repo}`);
+    if (dryRun) {
+      const files = WORKFLOW_TEMPLATES.map((t) => t.repoPath);
+      files.push(".fleet/goals/example.md");
+      emit({ type: "init:dry-run", files });
+      renderer.end(`Dry run complete. ${files.length} files would be created.`);
+      return;
+    }
+    const input = InitInputSchema.parse({
+      repo: `${owner}/${repo}`,
+      owner,
+      repoName: repo,
+      baseBranch
+    });
+    const octokit = createFleetOctokit();
+    const labelConfigurator = new ConfigureHandler({ octokit });
+    const handler = new InitHandler({ octokit, emit, labelConfigurator });
+    const result = await handler.execute(input);
+    if (!result.success) {
+      renderer.error(result.error.message);
+      if (result.error.suggestion) {
+        renderer.render({
+          type: "error",
+          code: result.error.code,
+          message: result.error.suggestion
+        });
+      }
+      process.exit(1);
+    }
+    const secretNames = Object.keys(secretsToUpload);
+    if (secretNames.length > 0) {
+      for (const name of secretNames) {
+        await uploadSecret(octokit, owner, repo, name, secretsToUpload[name], emit);
+      }
+    }
+    renderer.end("Fleet initialized! Merge the PR to activate Fleet.");
+  }
+});
+export {
+  init_command_default as default
+};