opencode-forgekeeper 1.0.0

package/dist/tui.js

@@ -0,0 +1,1529 @@
+// @bun
+// packages/forgekeeper/src/tui.tsx
+import { memo as _$memo } from "@opentui/solid";
+import { createTextNode as _$createTextNode } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { effect as _$effect } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+import { createEffect, createMemo, createSignal, For, onCleanup, Show } from "solid-js";
+// packages/_shared/src/exec.ts
+import { execFile } from "child_process";
+function exec(file, args, options = {}) {
+  return new Promise((resolve) => {
+    execFile(file, args, {
+      cwd: options.cwd,
+      env: options.env ? { ...process.env, ...options.env } : process.env,
+      timeout: options.timeout,
+      maxBuffer: 16 * 1024 * 1024,
+      encoding: "utf8"
+    }, (error, stdout, stderr) => {
+      if (!error) {
+        resolve({ stdout, stderr, code: 0 });
+        return;
+      }
+      const code = typeof error.code === "number" ? error.code : -1;
+      resolve({ stdout, stderr: stderr || error.message, code });
+    });
+  });
+}
+// packages/forgekeeper/src/exec.ts
+var execWithTimeout = (timeout) => (file, args, cwd) => exec(file, args, { cwd, timeout });
+var exec2 = execWithTimeout(30000);
+
+// packages/forgekeeper/src/forge.ts
+var ownedBy = (kind) => (request) => request.forge === kind;
+var titlePrefix = (title) => title?.match(/^\[[^\]]*\]/)?.[0] ?? "";
+function prefixReferences(title, sigil) {
+  return titlePrefix(title).slice(1, -1).split(/[\s,]+/).flatMap((token) => token.startsWith(sigil) && /^[1-9]\d*$/.test(token.slice(sigil.length)) ? [token.slice(sigil.length)] : []);
+}
+function parseWebUrl(kind, value, pattern) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return;
+  }
+  if (!["https:", "http:"].includes(url.protocol))
+    return;
+  const match = url.pathname.match(pattern);
+  if (!match)
+    return;
+  return {
+    forge: kind,
+    host: url.hostname.toLowerCase(),
+    project: decodeURIComponent(match[1]),
+    iid: match[2]
+  };
+}
+var yesNo = (value) => value ? "yes" : "no";
+var humanize = (value) => value.toLowerCase().replace(/_/g, " ");
+
+class ForgeError extends Error {
+  kind;
+  constructor(kind, message) {
+    super(message);
+    this.kind = kind;
+  }
+}
+
+// packages/forgekeeper/src/gitlab-feedback.ts
+var PAGE_SIZE = 100;
+var MAX_COMMENT_PAGES = 20;
+var COMMENTS_QUERY = `query($project: ID!, $iid: String!, $before: String) {
+  currentUser { id }
+  project(fullPath: $project) {
+    mergeRequest(iid: $iid) {
+      notes(last: ${PAGE_SIZE}, before: $before, filter: ONLY_COMMENTS) {
+        pageInfo { hasPreviousPage startCursor }
+        nodes {
+          id url createdAt updatedAt lastEditedAt system
+          discussion { resolved }
+          author { id username bot }
+        }
+      }
+    }
+  }
+}`;
+var noteNumber = (id) => id.slice(id.lastIndexOf("/") + 1);
+var timestamp = (node) => Date.parse(node.lastEditedAt ?? node.updatedAt ?? node.createdAt);
+function toComment(node) {
+  const editedAt = timestamp(node);
+  const id = noteNumber(node.id);
+  if (node.system || !node.author || !Number.isFinite(editedAt) || !/^\d+$/.test(id))
+    return;
+  return {
+    id,
+    order: Number(id),
+    url: node.url ?? "",
+    editedAt,
+    resolved: node.discussion?.resolved === true,
+    bot: node.author.bot,
+    authorID: node.author.id,
+    username: node.author.username
+  };
+}
+async function fetchComments(graphql, host, project, iid) {
+  const pages = [];
+  let viewerID;
+  let before;
+  const snapshot = (complete) => ({
+    complete: complete && viewerID !== undefined,
+    viewerID,
+    comments: pages.toReversed().flat()
+  });
+  for (let page = 0;page < MAX_COMMENT_PAGES; page++) {
+    const variables = { project, iid };
+    if (before)
+      variables.before = before;
+    const data = await graphql(host, COMMENTS_QUERY, variables);
+    viewerID ??= data?.currentUser?.id ?? undefined;
+    const connection = data?.project?.mergeRequest?.notes;
+    if (!connection)
+      return page === 0 ? undefined : snapshot(false);
+    pages.push(connection.nodes.flatMap((node) => toComment(node) ?? []));
+    if (!connection.pageInfo.hasPreviousPage)
+      return snapshot(true);
+    before = connection.pageInfo.startCursor ?? undefined;
+    if (!before)
+      return snapshot(false);
+  }
+  return snapshot(true);
+}
+
+// packages/forgekeeper/src/gitlab.ts
+var DISCUSSIONS = "pageInfo { hasNextPage endCursor } nodes { resolvable resolved }";
+var PAGE_SIZE2 = 100;
+var MAX_DISCUSSION_PAGES = 50;
+var MERGE_REQUEST_FIELDS = `
+  iid title webUrl state draft conflicts approved detailedMergeStatus diffHeadSha updatedAt targetBranch
+  approvedBy(first: 100) { nodes { id bot } }
+  sourceProject { fullPath }
+  targetProject { fullPath }
+  headPipeline { status path detailedStatus { label } }
+  reviewers(first: 100) { nodes { type username bot mergeRequestInteraction { reviewState approved } } }
+  discussions(first: ${PAGE_SIZE2}) { ${DISCUSSIONS} }
+`;
+function mergeRequestsQuery(projectCount) {
+  const variables = Array.from({ length: projectCount }, (_, index) => `$p${index}: ID!`).join(", ");
+  const projects = Array.from({ length: projectCount }, (_, index) => `p${index}: project(fullPath: $p${index}) {
+        mergeRequests(sourceBranches: [$branch], state: opened, first: 20) { nodes { ${MERGE_REQUEST_FIELDS} } }
+      }`).join(`
+`);
+  return `query($branch: String!, ${variables}) {
+${projects}
+}`;
+}
+function mergeRequestQuery(projectCount) {
+  const variables = Array.from({ length: projectCount }, (_, index) => `$p${index}: ID!`).join(", ");
+  const projects = Array.from({ length: projectCount }, (_, index) => `p${index}: project(fullPath: $p${index}) { mergeRequest(iid: $iid) { ${MERGE_REQUEST_FIELDS} } }`).join(`
+`);
+  return `query($iid: String!, ${variables}) {
+${projects}
+}`;
+}
+function mergeRequestNumbersQuery(projectCount) {
+  const variables = Array.from({ length: projectCount }, (_, index) => `$p${index}: ID!`).join(", ");
+  const projects = Array.from({ length: projectCount }, (_, index) => `p${index}: project(fullPath: $p${index}) {
+        mergeRequests(sourceBranches: [$branch], state: opened, first: 20) { nodes { iid updatedAt sourceProject { fullPath } } }
+      }`).join(`
+`);
+  return `query($branch: String!, ${variables}) {
+${projects}
+}`;
+}
+var SOURCE_BRANCH_QUERY = `query($project: ID!, $iid: String!) {
+  project(fullPath: $project) { mergeRequest(iid: $iid) { sourceBranch } }
+}`;
+var DISCUSSIONS_QUERY = `query($project: ID!, $iid: String!, $after: String) {
+  project(fullPath: $project) {
+    mergeRequest(iid: $iid) { discussions(first: ${PAGE_SIZE2}, after: $after) { ${DISCUSSIONS} } }
+  }
+}`;
+function classifyError(message, code) {
+  const text = message.trim().replace(/^glab:\s*/, "") || `glab exited with code ${code}`;
+  if (/ENOENT|command not found/i.test(text))
+    return new ForgeError("missing-glab", "glab is not installed");
+  if (/\b401\b|unauthori[sz]ed|not logged in|authenticate|invalid token|token.*expired/i.test(text)) {
+    return new ForgeError("auth", "GitLab authentication failed. Run `glab auth status`.");
+  }
+  if (/\b429\b|rate limit|too many requests/i.test(text))
+    return new ForgeError("rate-limit", "GitLab rate limit reached");
+  return new ForgeError("request", text.split(`
+`)[0]);
+}
+var isResponse = (body) => typeof body === "object" && body !== null && (!("errors" in body) || Array.isArray(body.errors)) && (!("data" in body) || typeof body.data === "object");
+function glabGraphQL(run, cwd) {
+  return async (host, query, variables) => {
+    const args = ["api", "graphql", "--hostname", host, "-f", `query=${query}`];
+    for (const [name, value] of Object.entries(variables))
+      args.push("-f", `${name}=${value}`);
+    const result = await run("glab", args, cwd);
+    let body;
+    try {
+      body = JSON.parse(result.stdout);
+    } catch {
+      throw classifyError(result.stderr, result.code);
+    }
+    if (!isResponse(body))
+      throw classifyError(result.stderr || "Unexpected GitLab response", result.code);
+    if (body.errors?.length)
+      throw classifyError(String(body.errors[0]?.message ?? ""), result.code);
+    if (result.code !== 0)
+      throw classifyError(result.stderr, result.code);
+    if (!body.data)
+      throw classifyError("GitLab returned no data", result.code);
+    return body.data;
+  };
+}
+var countUnresolved = (page) => page.nodes.filter((discussion) => discussion.resolvable && !discussion.resolved).length;
+var gitlabTraits = {
+  kind: "gitlab",
+  noun: "MR",
+  ci: "pipeline",
+  recognizes: (host) => /(^|\.)gitlab\./.test(host),
+  open: (run, directory) => new GitLabForge(glabGraphQL(run, directory)),
+  owns: ownedBy("gitlab"),
+  parseUrl: (url) => parseWebUrl("gitlab", url, /^\/(.+)\/-\/merge_requests\/([1-9]\d*)\/?$/),
+  parseIssueUrl: (url) => parseWebUrl("gitlab", url, /^\/(.+)\/-\/(?:issues|work_items)\/([1-9]\d*)\/?$/),
+  reference: (iid) => `!${iid}`,
+  issueReference: (iid) => `#${iid}`,
+  titleReferences: (title) => prefixReferences(title, "!"),
+  indicators: () => [],
+  details(request) {
+    const requirements = request.approvalRequirementsSatisfied === null ? "unknown" : yesNo(request.approvalRequirementsSatisfied);
+    const lines = [
+      `Human approvals: ${yesNo(request.hasApprovals)} \xB7 Approval requirements satisfied: ${requirements}`
+    ];
+    if (request.mergeStatus)
+      lines.push(`Merge status: ${humanize(request.mergeStatus)}`);
+    return lines;
+  },
+  automatedReview: {
+    name: "GitLab Duo",
+    status(request) {
+      const state = request.duoReviewState;
+      if (!state)
+        return;
+      return { state: duoState(state), label: humanize(state) };
+    }
+  },
+  feedback: {
+    async fetch(run, directory, request) {
+      const ref = gitlabTraits.parseUrl(request.url);
+      return ref ? fetchComments(glabGraphQL(run, directory), ref.host, ref.project, ref.iid) : undefined;
+    }
+  }
+};
+var DUO_FEEDBACK = new Set(["REVIEWED", "REQUESTED_CHANGES"]);
+function duoState(state) {
+  if (state === "REVIEW_STARTED")
+    return "running";
+  return DUO_FEEDBACK.has(state) ? "feedback" : "settled";
+}
+
+class GitLabForge {
+  graphql;
+  traits = gitlabTraits;
+  constructor(graphql) {
+    this.graphql = graphql;
+  }
+  async findByBranch(repository) {
+    const { source, targets, sourceBranch } = repository;
+    const variables = { branch: sourceBranch };
+    targets.forEach((target, index) => variables[`p${index}`] = target.path);
+    const data = await this.graphql(source.host, mergeRequestsQuery(targets.length), variables);
+    const sourcePath = source.path.toLowerCase();
+    const seen = new Set;
+    const nodes = [];
+    targets.forEach((_, index) => {
+      for (const node of data?.[`p${index}`]?.mergeRequests?.nodes ?? []) {
+        if (node.sourceProject?.fullPath.toLowerCase() !== sourcePath)
+          continue;
+        const key = `${node.targetProject.fullPath}!${node.iid}`;
+        if (seen.has(key))
+          continue;
+        seen.add(key);
+        nodes.push(node);
+      }
+    });
+    const requests = await Promise.all(nodes.map((node) => this.normalize(source.host, node)));
+    return requests.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""));
+  }
+  async findNumberByBranch(repository) {
+    const { source, targets, sourceBranch } = repository;
+    const variables = { branch: sourceBranch };
+    targets.forEach((target, index) => variables[`p${index}`] = target.path);
+    const data = await this.graphql(source.host, mergeRequestNumbersQuery(targets.length), variables);
+    const sourcePath = source.path.toLowerCase();
+    const nodes = targets.flatMap((_, index) => data?.[`p${index}`]?.mergeRequests?.nodes ?? []);
+    return nodes.filter((node) => node.sourceProject?.fullPath.toLowerCase() === sourcePath).sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))[0]?.iid;
+  }
+  async sourceBranch(ref) {
+    const data = await this.graphql(ref.host, SOURCE_BRANCH_QUERY, {
+      project: ref.project,
+      iid: ref.iid
+    });
+    const branch = data?.project?.mergeRequest?.sourceBranch;
+    return typeof branch === "string" && branch ? branch : undefined;
+  }
+  async findByNumber(projects, iid) {
+    if (projects.length === 0)
+      return;
+    const host = projects[0].host;
+    const variables = { iid };
+    projects.forEach((project, index) => variables[`p${index}`] = project.path);
+    const data = await this.graphql(host, mergeRequestQuery(projects.length), variables);
+    for (let index = 0;index < projects.length; index++) {
+      const node = data?.[`p${index}`]?.mergeRequest ?? undefined;
+      if (node)
+        return this.normalize(host, node);
+    }
+    return;
+  }
+  async unresolvedThreads(host, node) {
+    let count = countUnresolved(node.discussions);
+    let page = node.discussions.pageInfo;
+    let pages = 1;
+    while (page.hasNextPage && page.endCursor && pages < MAX_DISCUSSION_PAGES) {
+      const data = await this.graphql(host, DISCUSSIONS_QUERY, {
+        project: node.targetProject.fullPath,
+        iid: node.iid,
+        after: page.endCursor
+      });
+      const next = data?.project?.mergeRequest?.discussions;
+      if (!next)
+        break;
+      count += countUnresolved(next);
+      page = next.pageInfo;
+      pages++;
+    }
+    return { count, complete: !page.hasNextPage };
+  }
+  async normalize(host, node) {
+    const threads = await this.unresolvedThreads(host, node);
+    const pipeline = node.headPipeline;
+    const hasApprovals = (node.approvedBy?.nodes ?? []).some((approver) => approver.bot !== true);
+    const awaitingReviewers = (node.reviewers?.nodes ?? []).filter((reviewer) => reviewer.bot !== true && reviewer.username && reviewer.mergeRequestInteraction?.approved !== true).map((reviewer) => reviewer.username);
+    return {
+      forge: "gitlab",
+      iid: node.iid,
+      title: node.title,
+      url: node.webUrl,
+      state: node.state.toLowerCase(),
+      draft: node.draft,
+      conflicts: node.conflicts,
+      conflictsKnown: true,
+      approved: node.approved === true && hasApprovals && awaitingReviewers.length === 0,
+      hasApprovals,
+      approvalRequirementsSatisfied: node.approved,
+      awaitingReviewers,
+      reviewersComplete: true,
+      mergeStatus: node.detailedMergeStatus ?? undefined,
+      targetProject: node.targetProject.fullPath,
+      targetBranch: node.targetBranch,
+      headSha: node.diffHeadSha ?? undefined,
+      updatedAt: node.updatedAt ?? undefined,
+      pipeline: pipeline ? {
+        status: pipeline.status,
+        label: pipeline.detailedStatus?.label ?? pipeline.status.toLowerCase().replace(/_/g, " "),
+        url: pipeline.path ? `https://${host}${pipeline.path}` : undefined
+      } : undefined,
+      unresolvedThreads: threads.count,
+      threadsComplete: threads.complete,
+      duoReviewState: node.reviewers?.nodes.find((reviewer) => reviewer.type === "DUO_CODE_REVIEW_BOT")?.mergeRequestInteraction?.reviewState ?? undefined
+    };
+  }
+}
+
+// packages/forgekeeper/src/github.ts
+var fields = `number title url state isDraft mergeable reviewDecision headRefOid headRefName
+  headRepository { nameWithOwner } baseRepository { nameWithOwner } baseRefName updatedAt
+  reviewThreads(first:100) { nodes { isResolved } pageInfo { hasNextPage endCursor } }
+  reviewRequests(first:100) { nodes { requestedReviewer { ... on User { login } ... on Team { name } } } pageInfo { hasNextPage } }
+  commits(last:1) { nodes { commit { statusCheckRollup { contexts(first:100) {
+    nodes { __typename ... on CheckRun { status conclusion detailsUrl } ... on StatusContext { state targetUrl } }
+    pageInfo { hasNextPage endCursor }
+  } } } } }`;
+var MAX_PAGES = 50;
+function ghGraphQL(run, cwd) {
+  return async (host, query, variables) => {
+    const args = ["api", "graphql", "--hostname", host, "-f", `query=${query}`];
+    for (const [name, value] of Object.entries(variables))
+      args.push(typeof value === "number" ? "-F" : "-f", `${name}=${value}`);
+    const result = await run("gh", args, cwd);
+    let body;
+    try {
+      body = JSON.parse(result.stdout);
+    } catch {
+      throw classifyError2(result.stderr, result.code);
+    }
+    const errors = (body.errors ?? []).filter((error) => error.type !== "NOT_FOUND");
+    if (!body.data || errors.length || result.code !== 0 && !body.errors?.length) {
+      throw classifyError2(errors[0]?.message ?? result.stderr, result.code);
+    }
+    return body.data;
+  };
+}
+function classifyError2(message, code) {
+  const text = message.trim() || `gh exited with code ${code}`;
+  if (/ENOENT|command not found/i.test(text))
+    return new ForgeError("missing-gh", "gh is not installed");
+  if (/401|unauthori[sz]ed|authenticate|not logged|token.*expired/i.test(text))
+    return new ForgeError("auth", "GitHub authentication failed. Run `gh auth status`.");
+  if (/429|rate limit|too many requests/i.test(text))
+    return new ForgeError("rate-limit", "GitHub rate limit reached");
+  return new ForgeError("request", text.split(`
+`)[0]);
+}
+var FAILED = [
+  "FAILURE",
+  "ERROR",
+  "TIMED_OUT",
+  "CANCELLED",
+  "ACTION_REQUIRED",
+  "STARTUP_FAILURE",
+  "STALE"
+];
+var CONCLUSIONS = [
+  "SUCCESS",
+  "NEUTRAL",
+  "SKIPPED",
+  "FAILURE",
+  "TIMED_OUT",
+  "CANCELLED",
+  "ACTION_REQUIRED",
+  "STARTUP_FAILURE",
+  "STALE"
+];
+var STATES = ["SUCCESS", "FAILURE", "ERROR", "PENDING", "EXPECTED"];
+function checks(nodes, complete, url) {
+  const failed = nodes.filter((node) => FAILED.includes(node.conclusion ?? node.state ?? "")).length;
+  const pending = nodes.filter((node) => node.status ? node.status !== "COMPLETED" : ["PENDING", "EXPECTED"].includes(node.state ?? "")).length;
+  const unknown = nodes.some((node) => node.status === "COMPLETED" ? !CONCLUSIONS.includes(node.conclusion ?? "") : !node.status && !STATES.includes(node.state ?? ""));
+  if (failed)
+    return {
+      status: "FAILED",
+      label: `${failed} failed${pending ? `, ${pending} pending` : ""}${complete ? "" : " (partial)"}`,
+      url
+    };
+  if (pending || !complete || unknown)
+    return {
+      status: "PENDING",
+      label: `${pending ? `${pending} pending` : "unknown"}${complete ? "" : " (partial)"}`,
+      url
+    };
+  return { status: "SUCCESS", label: `${nodes.length} passed or skipped`, url };
+}
+function parseGitHubUrl(url, pattern) {
+  const ref = parseWebUrl("github", url, pattern);
+  return ref && !gitlabTraits.recognizes(ref.host) ? ref : undefined;
+}
+var githubTraits = {
+  kind: "github",
+  noun: "PR",
+  ci: "checks",
+  recognizes: () => false,
+  open: (run, directory) => new GitHubForge(ghGraphQL(run, directory)),
+  owns: ownedBy("github"),
+  parseUrl: (url) => parseGitHubUrl(url, /^\/([^/]+\/[^/]+)\/pull\/([1-9]\d*)\/?$/),
+  parseIssueUrl: (url) => parseGitHubUrl(url, /^\/([^/]+\/[^/]+)\/issues\/([1-9]\d*)\/?$/),
+  reference: (iid) => `#${iid}`,
+  issueReference: (iid) => `#${iid}`,
+  titleReferences: (title) => prefixReferences(title, "#"),
+  indicators: (request) => request.reviewDecision === "CHANGES_REQUESTED" ? [{ text: "changes requested", tone: "warning", essential: true }] : [],
+  details: (request) => [
+    `Review decision: ${request.reviewDecision ? humanize(request.reviewDecision) : "not reported"}`
+  ]
+};
+
+class GitHubForge {
+  graphql;
+  traits = githubTraits;
+  constructor(graphql) {
+    this.graphql = graphql;
+  }
+  async findByNumber(projects, number) {
+    for (const project of projects) {
+      const [owner, repo] = project.path.split("/");
+      const data = await this.graphql(project.host, `query($owner:String!,$repo:String!,$number:Int!) {
+        repository(owner:$owner,name:$repo) { pullRequest(number:$number) { ${fields} } }
+      }`, { owner, repo, number: Number(number) });
+      const node = data.repository?.pullRequest;
+      if (node)
+        return this.normalize(project.host, node);
+    }
+    return;
+  }
+  async findNumberByBranch(repository) {
+    let newest;
+    for (const target of repository.targets) {
+      const [owner, repo] = target.path.split("/");
+      const data = await this.graphql(target.host, `query($owner:String!,$repo:String!,$branch:String!) {
+        repository(owner:$owner,name:$repo) { pullRequests(first:100,states:OPEN,headRefName:$branch,orderBy:{field:UPDATED_AT,direction:DESC}) {
+          nodes { number updatedAt headRepository { nameWithOwner } }
+        } } }`, { owner, repo, branch: repository.sourceBranch });
+      const nodes = data.repository?.pullRequests?.nodes ?? [];
+      for (const node of nodes) {
+        if (node.headRepository?.nameWithOwner.toLowerCase() !== repository.source.path.toLowerCase())
+          continue;
+        if (!newest || node.updatedAt > newest.updatedAt)
+          newest = node;
+      }
+    }
+    return newest ? String(newest.number) : undefined;
+  }
+  async sourceBranch(ref) {
+    const [owner, repo] = ref.project.split("/");
+    const data = await this.graphql(ref.host, `query($owner:String!,$repo:String!,$number:Int!) {
+      repository(owner:$owner,name:$repo) { pullRequest(number:$number) { headRefName } }
+    }`, { owner, repo, number: Number(ref.iid) });
+    const branch = data.repository?.pullRequest?.headRefName;
+    return typeof branch === "string" && branch ? branch : undefined;
+  }
+  async findByBranch(repository) {
+    const found = new Map;
+    for (const target of repository.targets) {
+      const [owner, repo] = target.path.split("/");
+      let after;
+      let complete = false;
+      for (let page = 0;page < MAX_PAGES; page++) {
+        const data = await this.graphql(target.host, `query($owner:String!,$repo:String!,$branch:String!${after ? ",$after:String!" : ""}) {
+          repository(owner:$owner,name:$repo) { pullRequests(first:100,states:OPEN,headRefName:$branch${after ? ",after:$after" : ""}) {
+            nodes { ${fields} } pageInfo { hasNextPage endCursor }
+          } } }`, { owner, repo, branch: repository.sourceBranch, ...after ? { after } : {} });
+        const pulls = data.repository?.pullRequests;
+        if (!pulls)
+          throw new ForgeError("request", "GitHub repository unavailable");
+        for (const node of pulls.nodes) {
+          if (node.headRepository?.nameWithOwner.toLowerCase() !== repository.source.path.toLowerCase())
+            continue;
+          if (!found.has(node.url))
+            found.set(node.url, await this.normalize(target.host, node));
+        }
+        if (!pulls.pageInfo?.hasNextPage) {
+          complete = true;
+          break;
+        }
+        after = pulls.pageInfo.endCursor;
+        if (!after)
+          break;
+      }
+      if (!complete)
+        throw new ForgeError("request", "GitHub PR discovery exceeded its pagination limit");
+    }
+    return [...found.values()].sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""));
+  }
+  async threads(host, node) {
+    const [owner, repo] = node.baseRepository.nameWithOwner.split("/");
+    const threads = [...node.reviewThreads.nodes];
+    let page = node.reviewThreads.pageInfo;
+    for (let count = 1;page?.hasNextPage && page.endCursor && count < MAX_PAGES; count++) {
+      const data = await this.graphql(host, `query($owner:String!,$repo:String!,$number:Int!,$after:String!) {
+        repository(owner:$owner,name:$repo) { pullRequest(number:$number) {
+          reviewThreads(first:100,after:$after) { nodes { isResolved } pageInfo { hasNextPage endCursor } }
+        } } }`, { owner, repo, number: node.number, after: page.endCursor });
+      const next = data.repository?.pullRequest?.reviewThreads;
+      if (!next)
+        break;
+      threads.push(...next.nodes);
+      page = next.pageInfo;
+    }
+    return {
+      unresolved: threads.filter((thread) => !thread.isResolved).length,
+      complete: !page?.hasNextPage
+    };
+  }
+  async contexts(host, node) {
+    const [owner, repo] = node.baseRepository.nameWithOwner.split("/");
+    const rollup = node.commits.nodes[0]?.commit.statusCheckRollup?.contexts;
+    const contexts = [...rollup?.nodes ?? []];
+    let cursor = rollup?.pageInfo;
+    for (let count = 1;cursor?.hasNextPage && cursor.endCursor && count < MAX_PAGES; count++) {
+      const data = await this.graphql(host, `query($owner:String!,$repo:String!,$oid:GitObjectID!,$after:String!) {
+        repository(owner:$owner,name:$repo) { object(oid:$oid) { ... on Commit { statusCheckRollup {
+          contexts(first:100,after:$after) { nodes { __typename ... on CheckRun { status conclusion detailsUrl } ... on StatusContext { state targetUrl } } pageInfo { hasNextPage endCursor } }
+        } } } } }`, { owner, repo, oid: node.headRefOid, after: cursor.endCursor });
+      const next = data.repository?.object?.statusCheckRollup?.contexts;
+      if (!next)
+        break;
+      contexts.push(...next.nodes);
+      cursor = next.pageInfo;
+    }
+    return { nodes: contexts, complete: !cursor?.hasNextPage };
+  }
+  async normalize(host, node) {
+    const [threads, contexts] = [await this.threads(host, node), await this.contexts(host, node)];
+    return {
+      forge: "github",
+      iid: String(node.number),
+      title: node.title,
+      url: node.url,
+      state: node.state === "OPEN" ? "opened" : node.state.toLowerCase(),
+      draft: node.isDraft,
+      conflicts: node.mergeable === "CONFLICTING",
+      conflictsKnown: node.mergeable !== "UNKNOWN",
+      approved: node.reviewDecision === "APPROVED",
+      reviewDecision: node.reviewDecision ?? undefined,
+      awaitingReviewers: node.reviewRequests.nodes.flatMap((request) => {
+        const reviewer = request.requestedReviewer;
+        return reviewer?.login ? [reviewer.login] : reviewer?.name ? [reviewer.name] : [];
+      }),
+      reviewersComplete: !node.reviewRequests.pageInfo?.hasNextPage,
+      targetProject: node.baseRepository.nameWithOwner,
+      targetBranch: node.baseRefName,
+      headSha: node.headRefOid,
+      updatedAt: node.updatedAt,
+      pipeline: contexts.nodes.length || !contexts.complete ? checks(contexts.nodes, contexts.complete, `${node.url}/checks`) : undefined,
+      unresolvedThreads: threads.unresolved,
+      threadsComplete: threads.complete
+    };
+  }
+}
+
+// packages/forgekeeper/src/forges.ts
+var registry = { gitlab: gitlabTraits, github: githubTraits };
+var kinds = Object.keys(registry);
+var traitsOf = (request) => registry[request.forge];
+var reference = (request) => traitsOf(request).reference(request.iid);
+
+// packages/forgekeeper/src/automated-review-watch.ts
+function automatedReview(request) {
+  const reviewer = traitsOf(request).automatedReview;
+  const status = reviewer?.status(request);
+  return reviewer && status ? { name: reviewer.name, ...status } : undefined;
+}
+var RETRY_DELAY = 10 * 60000;
+var PENDING_RETENTION = 24 * 60 * 60000;
+
+// packages/forgekeeper/src/format.ts
+var RUNNING = new Set([
+  "CREATED",
+  "WAITING_FOR_RESOURCE",
+  "PREPARING",
+  "PENDING",
+  "RUNNING",
+  "SCHEDULED",
+  "WAITING_FOR_CALLBACK",
+  "CANCELING"
+]);
+function pipelineTone(pipeline) {
+  if (!pipeline)
+    return "muted";
+  if (pipeline.status === "FAILED")
+    return "error";
+  if (pipeline.status === "SUCCESS")
+    return pipeline.label.includes("warning") ? "warning" : "success";
+  if (RUNNING.has(pipeline.status))
+    return "warning";
+  return "muted";
+}
+var plural = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+var capitalize = (value) => value.charAt(0).toUpperCase() + value.slice(1);
+var COMPACT_CI = {
+  success: "CI \u2713",
+  error: "CI \u2717",
+  warning: "CI \u2026"
+};
+function awaitingText(reviewers) {
+  if (reviewers.length > 2)
+    return `awaiting ${reviewers.length} reviewers`;
+  return `awaiting ${reviewers.map((username) => `@${username}`).join(", ")}`;
+}
+function threadsText(request) {
+  return `${request.unresolvedThreads}${request.threadsComplete ? "" : "+"} unresolved thread${request.unresolvedThreads === 1 && request.threadsComplete ? "" : "s"}`;
+}
+var link = (request) => ({
+  text: reference(request),
+  tone: "muted",
+  url: request.url,
+  essential: true
+});
+function ci(request) {
+  const tone = pipelineTone(request.pipeline);
+  if (!request.pipeline)
+    return { text: `no ${traitsOf(request).ci}`, compact: "no CI", tone };
+  return {
+    text: `CI ${request.pipeline.label}`,
+    compact: COMPACT_CI[tone],
+    tone,
+    url: request.pipeline.url
+  };
+}
+function targetsSummary(requests) {
+  const nouns = new Set(requests.map((request) => traitsOf(request).noun));
+  const noun = nouns.size === 1 ? [...nouns][0] : "PR/MR";
+  const count = requests.length === 1 ? `1 ${noun}` : `${requests.length} ${noun === "PR/MR" ? "PRs/MRs" : `${noun}s`}`;
+  const open = requests.filter((request) => request.state === "opened");
+  const segments = [{ text: count, tone: "muted", essential: true }];
+  const reviewing = open.filter((request) => automatedReview(request)?.state === "running").length;
+  if (reviewing)
+    segments.push({
+      text: `\uD83E\uDD16 ${reviewing} reviewing`,
+      compact: `\uD83E\uDD16 ${reviewing}`,
+      tone: "warning",
+      essential: true
+    });
+  const failing = open.filter((request) => pipelineTone(request.pipeline) === "error").length;
+  if (failing)
+    segments.push({ text: `${failing} CI failed`, compact: `CI \u2717 ${failing}`, tone: "error" });
+  const conflicts = open.filter((request) => request.conflicts).length;
+  if (conflicts)
+    segments.push({ text: plural(conflicts, "conflict"), tone: "error", essential: true });
+  const approved = open.filter((request) => request.approved && request.awaitingReviewers.length === 0).length;
+  if (approved)
+    segments.push({ text: `${approved} approved`, tone: "success" });
+  const merged = requests.filter((request) => request.state === "merged").length;
+  if (merged)
+    segments.push({ text: `${merged} merged`, tone: "success" });
+  const closed = requests.length - open.length - merged;
+  if (closed)
+    segments.push({ text: `${closed} closed`, tone: "muted" });
+  return segments;
+}
+function footerSegments(snapshot) {
+  const { lookup, error } = snapshot;
+  const stale = error ? [{ text: "stale", tone: "warning", essential: true }] : [];
+  if (!lookup || lookup.kind === "none" || lookup.requests.length === 0) {
+    return error ? [{ text: "PR/MR status unavailable", tone: "warning" }] : [];
+  }
+  if (lookup.failed?.length) {
+    stale.unshift({
+      text: `${lookup.failed.length} unavailable`,
+      tone: "warning",
+      essential: true
+    });
+  }
+  const requests = lookup.requests;
+  if (lookup.explicitTarget && requests.length > 1)
+    return [...targetsSummary(requests), ...stale];
+  if (requests.length > 1) {
+    const noun = traitsOf(requests[0]).noun;
+    return [
+      ...requests.map(link),
+      {
+        text: `${plural(requests.length, `open ${noun}`)}, run /${noun.toLowerCase()}-status`,
+        tone: "warning"
+      },
+      ...stale
+    ];
+  }
+  const [request] = requests;
+  if (request.state !== "opened") {
+    return [
+      link(request),
+      {
+        text: request.state,
+        tone: request.state === "merged" ? "success" : "muted",
+        essential: true
+      },
+      ...stale
+    ];
+  }
+  const segments = [link(request), ci(request)];
+  if (request.unresolvedThreads > 0 || !request.threadsComplete) {
+    const text = threadsText(request);
+    segments.push({ text, compact: text.replace("unresolved ", ""), tone: "warning" });
+  }
+  if (automatedReview(request)?.state === "running") {
+    segments.push({ text: "\uD83E\uDD16 reviewing", compact: "\uD83E\uDD16", tone: "warning", essential: true });
+  }
+  segments.push(...traitsOf(request).indicators(request));
+  if (request.conflicts)
+    segments.push({ text: "conflicts", tone: "error", essential: true });
+  if (!request.conflictsKnown)
+    segments.push({ text: "mergeability unknown", tone: "muted" });
+  if (request.awaitingReviewers.length)
+    segments.push({ text: awaitingText(request.awaitingReviewers), tone: "muted" });
+  else if (request.approved)
+    segments.push({ text: "approved", tone: "success" });
+  return [...segments, ...stale];
+}
+var segmentsWidth = (segments) => Bun.stringWidth(segments.map((segment) => segment.text).join(" \xB7 "));
+function responsiveFooterSegments(snapshot, width) {
+  const full = footerSegments(snapshot);
+  if (segmentsWidth(full) <= width)
+    return full;
+  const compact = full.map((segment) => ({
+    ...segment,
+    text: segment.compact ?? segment.text
+  }));
+  if (segmentsWidth(compact) <= width)
+    return compact;
+  const minimal = compact.filter((segment) => segment.essential);
+  if (segmentsWidth(minimal) <= width)
+    return minimal;
+  if (minimal[0] && segmentsWidth([minimal[0]]) > width)
+    return [];
+  const fitted = [];
+  for (const segment of minimal) {
+    if (segmentsWidth([...fitted, segment]) <= width)
+      fitted.push(segment);
+  }
+  return fitted;
+}
+var time = (value) => new Date(value).toLocaleTimeString();
+function describe(request, head) {
+  const traits = traitsOf(request);
+  const lines = [
+    `${reference(request)} ${request.title}${request.state === "opened" ? "" : ` (${request.state})`}`,
+    `Target: ${request.targetProject} \u2192 ${request.targetBranch}`,
+    `${capitalize(traits.ci)}: ${request.pipeline ? request.pipeline.label : "none"}${request.pipeline?.url ? ` (${request.pipeline.url})` : ""}`,
+    `Unresolved threads: ${request.unresolvedThreads}${request.threadsComplete ? "" : "+"}`,
+    `Draft: ${yesNo(request.draft)} \xB7 Conflicts: ${request.conflictsKnown ? yesNo(request.conflicts) : "unknown"}`,
+    ...traits.details(request)
+  ];
+  const review = automatedReview(request);
+  if (review)
+    lines.push(`${review.name} review: ${review.label}`);
+  if (request.awaitingReviewers.length) {
+    lines.push(`Awaiting review: ${request.awaitingReviewers.map((username) => `@${username}`).join(", ")}`);
+  }
+  if (!request.reviewersComplete)
+    lines.push("Reviewer list is partial");
+  if (head && request.headSha && head !== request.headSha) {
+    lines.push(`Local HEAD differs from the ${traits.noun} head commit (unpushed or not fetched)`);
+  }
+  lines.push(request.url);
+  return lines;
+}
+function detailsMessage(snapshot) {
+  const { lookup, error, fetchedAt } = snapshot;
+  const lines = [];
+  if (!lookup) {
+    lines.push(error ? "Could not look up the PR/MR." : "No data yet.");
+  } else if (lookup.kind === "none") {
+    lines.push(`No PR/MR lookup: ${lookup.reason}.`);
+  } else {
+    const { repository, sessionTarget, requests } = lookup;
+    if (repository) {
+      const branch = repository.branch === repository.sourceBranch ? repository.branch : `${repository.branch} (pushes to ${repository.sourceBranch})`;
+      lines.push(`Branch: ${branch} in ${repository.source.path}`);
+      if (requests.length === 0)
+        lines.push("", "No open PR/MR for this branch.");
+    } else if (sessionTarget) {
+      lines.push(`Session target: ${sessionTarget}`);
+    }
+    for (const { url, reason } of lookup.failed ?? [])
+      lines.push(`Unavailable: ${url} (${reason})`);
+    for (const request of requests)
+      lines.push("", ...describe(request, repository?.head ?? ""));
+  }
+  if (error)
+    lines.push("", `Last refresh failed at ${time(error.at)}: ${error.message}`);
+  if (fetchedAt !== undefined)
+    lines.push("", `Last fetched: ${time(fetchedAt)}`);
+  return lines.join(`
+`);
+}
+
+// packages/forgekeeper/src/rpc.ts
+var urls = {
+  url: { type: "string" },
+  issueUrl: { type: "string" }
+};
+var target = {
+  type: "object",
+  properties: {
+    ...urls,
+    targets: {
+      type: "array",
+      items: { type: "object", properties: urls, required: ["url"], additionalProperties: false }
+    }
+  },
+  additionalProperties: false
+};
+var key = { type: "string" };
+var snapshot = { type: "object" };
+var status = {
+  type: "object",
+  properties: { enabled: { type: "boolean" }, snapshot },
+  required: ["enabled", "snapshot"]
+};
+var ForgeSessionRpc = {
+  id: "opencode-forge-session-title",
+  methods: {
+    target: {
+      input: {
+        type: "object",
+        properties: { sessionID: { type: "string" } },
+        required: ["sessionID"],
+        additionalProperties: false
+      },
+      output: target
+    },
+    watch: {
+      input: {
+        type: "object",
+        properties: {
+          clientID: { type: "string" },
+          keys: { type: "array", items: key },
+          visible: key
+        },
+        required: ["clientID", "keys"],
+        additionalProperties: false
+      },
+      output: {
+        type: "object",
+        properties: { enabled: { type: "boolean" }, statuses: { type: "object" } },
+        required: ["enabled", "statuses"]
+      }
+    },
+    release: {
+      input: {
+        type: "object",
+        properties: { clientID: { type: "string" } },
+        required: ["clientID"],
+        additionalProperties: false
+      },
+      output: { type: "object" }
+    },
+    refresh: {
+      input: {
+        type: "object",
+        properties: { key },
+        required: ["key"],
+        additionalProperties: false
+      },
+      output: status
+    }
+  },
+  events: {
+    targetChanged: {
+      schema: {
+        type: "object",
+        properties: { sessionID: { type: "string" }, ...target.properties },
+        required: ["sessionID"],
+        additionalProperties: false
+      }
+    },
+    status: {
+      schema: {
+        type: "object",
+        properties: { directory: { type: "string" }, key, snapshot },
+        required: ["directory", "key", "snapshot"]
+      }
+    },
+    notice: {
+      schema: {
+        type: "object",
+        properties: {
+          sessionID: { type: "string" },
+          title: { type: "string" },
+          message: { type: "string" },
+          variant: { type: "string", enum: ["info", "error"] }
+        },
+        required: ["message", "variant"]
+      }
+    }
+  }
+};
+var HOME = "";
+var HEARTBEAT = 60000;
+var LEASE_TIME = 3 * HEARTBEAT;
+
+// packages/forgekeeper/src/status-client.ts
+var samePlace = (a, b) => a.directory === b.directory && a.key === b.key;
+var placeID = (place) => JSON.stringify([place.directory, place.key]);
+function createStatusClient(options) {
+  const now = options.now ?? Date.now;
+  const setTimer = options.setTimer ?? ((callback, delay) => setTimeout(callback, delay));
+  const clearTimer = options.clearTimer ?? ((timer) => clearTimeout(timer));
+  const defer = options.defer ?? queueMicrotask;
+  const snapshots = new Map;
+  const shown = new Map;
+  const enabled = new Map;
+  let visible;
+  let disposed = false;
+  const isShown = (place) => shown.get(place.directory)?.has(place.key) === true;
+  function apply(place, snapshot2) {
+    const id = placeID(place);
+    if ((snapshot2.revision ?? -1) >= (snapshots.get(id)?.revision ?? -1))
+      snapshots.set(id, snapshot2);
+  }
+  function unavailable(directory, error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    const failure = {
+      kind: "request",
+      message: `PR/MR status service unavailable: ${reason}`,
+      at: now()
+    };
+    for (const key2 of shown.get(directory) ?? []) {
+      const id = placeID({ directory, key: key2 });
+      snapshots.set(id, { ...snapshots.get(id) ?? {}, loading: false, error: failure });
+    }
+    options.onChange();
+  }
+  const failures = new Map;
+  const retries = new Map;
+  function retryLater(directory) {
+    const count = (failures.get(directory) ?? 0) + 1;
+    failures.set(directory, count);
+    const timer = retries.get(directory);
+    if (timer !== undefined)
+      clearTimer(timer);
+    retries.set(directory, setTimer(() => void renew(directory), Math.min(HEARTBEAT, 1000 * 2 ** count)));
+  }
+  async function renew(directory) {
+    if (disposed)
+      return;
+    const timer = retries.get(directory);
+    if (timer !== undefined)
+      clearTimer(timer);
+    retries.delete(directory);
+    const keys = [...shown.get(directory) ?? []];
+    try {
+      const result = await options.watch(directory, {
+        clientID: options.clientID,
+        keys,
+        ...visible?.directory === directory ? { visible: visible.key } : {}
+      });
+      failures.delete(directory);
+      enabled.set(directory, result.enabled);
+      for (const [key2, snapshot2] of Object.entries(result.statuses)) {
+        if (isShown({ directory, key: key2 }))
+          apply({ directory, key: key2 }, snapshot2);
+      }
+      options.onChange();
+    } catch (error) {
+      unavailable(directory, error);
+      retryLater(directory);
+    }
+  }
+  const due = new Set;
+  function renewSoon(directory) {
+    if (due.has(directory))
+      return;
+    due.add(directory);
+    defer(() => {
+      due.delete(directory);
+      renew(directory);
+    });
+  }
+  return {
+    snapshot: (place) => snapshots.get(placeID(place)) ?? { loading: false },
+    enabled: (directory) => enabled.get(directory) ?? true,
+    show(place) {
+      if (place.key !== HOME) {
+        for (const [directory, keys2] of shown) {
+          if (directory === place.directory || !keys2.delete(place.key))
+            continue;
+          snapshots.delete(placeID({ directory, key: place.key }));
+          if (visible && samePlace(visible, { directory, key: place.key }))
+            visible = undefined;
+          renewSoon(directory);
+        }
+      }
+      const keys = shown.get(place.directory) ?? new Set;
+      shown.set(place.directory, keys);
+      keys.add(place.key);
+      visible = place;
+      renewSoon(place.directory);
+    },
+    hide(place) {
+      if (visible && samePlace(visible, place))
+        visible = undefined;
+      renewSoon(place.directory);
+    },
+    async refresh(place) {
+      const id = placeID(place);
+      snapshots.set(id, { ...snapshots.get(id) ?? {}, loading: true });
+      options.onChange();
+      try {
+        const result = await options.refresh(place.directory, place.key);
+        enabled.set(place.directory, result.enabled);
+        apply(place, result.snapshot);
+        options.onChange();
+      } catch (error) {
+        unavailable(place.directory, error);
+      }
+    },
+    heartbeat() {
+      for (const directory of shown.keys())
+        renew(directory);
+    },
+    receive(directory, key2, snapshot2) {
+      if (!isShown({ directory, key: key2 }))
+        return;
+      apply({ directory, key: key2 }, snapshot2);
+      options.onChange();
+    },
+    hasShown: (sessionID) => [...shown.values()].some((keys) => keys.has(sessionID)),
+    dispose() {
+      disposed = true;
+      for (const timer of retries.values())
+        clearTimer(timer);
+      for (const directory of shown.keys())
+        options.release(directory, options.clientID).catch(() => {});
+    }
+  };
+}
+
+// packages/forgekeeper/src/tui.tsx
+var tui_default = {
+  id: "pedropombeiro.forgekeeper",
+  async setup(context) {
+    const rpc = context.client.rpc(ForgeSessionRpc);
+    const [version, setVersion] = createSignal(0);
+    const client = createStatusClient({
+      clientID: crypto.randomUUID(),
+      watch: async (directory, input) => await rpc.watch(input, {
+        location: {
+          directory
+        }
+      }),
+      refresh: async (directory, key2) => await rpc.refresh({
+        key: key2
+      }, {
+        location: {
+          directory
+        }
+      }),
+      release: (directory, clientID) => rpc.release({
+        clientID
+      }, {
+        location: {
+          directory
+        }
+      }),
+      onChange: () => setVersion((value) => value + 1)
+    });
+    const directoryFor = (sessionID) => (sessionID ? context.data.session.get(sessionID)?.location.directory : undefined) ?? context.location?.directory ?? context.data.location.default().directory;
+    const placeFor = (sessionID) => ({
+      directory: directoryFor(sessionID),
+      key: sessionID ?? HOME
+    });
+    const currentPlace = () => {
+      const route = context.ui.router.current();
+      return placeFor(route.type === "session" ? route.sessionID : undefined);
+    };
+    const snapshotOf = (place) => {
+      version();
+      return client.snapshot(place);
+    };
+    const enabledFor = (directory) => {
+      version();
+      return client.enabled(directory);
+    };
+    const refresh = (place) => client.refresh(place);
+    const heartbeat = setInterval(() => client.heartbeat(), HEARTBEAT);
+    const color = (tone) => {
+      const feedback = context.theme.text.feedback;
+      if (tone === "success")
+        return feedback.success.base;
+      if (tone === "warning")
+        return feedback.warning.base;
+      if (tone === "error")
+        return feedback.error.base;
+      return context.theme.text.muted;
+    };
+    function Footer(props) {
+      const place = createMemo(() => placeFor(props.sessionID), undefined, {
+        equals: samePlace
+      });
+      createEffect(() => {
+        const current = place();
+        client.show(current);
+        onCleanup(() => client.hide(current));
+      });
+      createEffect(() => {
+        context.data.location.vcs.sync({
+          directory: place().directory
+        }).catch(() => {});
+      });
+      const snapshot2 = createMemo(() => snapshotOf(place()));
+      const fullWidth = createMemo(() => enabledFor(place().directory) ? segmentsWidth(footerSegments(snapshot2())) : 0);
+      const [availableWidth, setAvailableWidth] = createSignal(0);
+      const segments = createMemo(() => responsiveFooterSegments(snapshot2(), availableWidth()));
+      return _$createComponent(Show, {
+        get when() {
+          return fullWidth() > 0;
+        },
+        get children() {
+          var _el$ = _$createElement("box");
+          _$setProp(_el$, "flexDirection", "row");
+          _$setProp(_el$, "flexShrink", 1);
+          _$setProp(_el$, "minWidth", 0);
+          _$setProp(_el$, "height", 1);
+          _$setProp(_el$, "overflow", "hidden");
+          _$setProp(_el$, "onSizeChange", function() {
+            const width = this.width;
+            queueMicrotask(() => setAvailableWidth(width));
+          });
+          _$insert(_el$, _$createComponent(For, {
+            get each() {
+              return segments();
+            },
+            children: (segment, index) => [_$createComponent(Show, {
+              get when() {
+                return index() > 0;
+              },
+              get children() {
+                var _el$2 = _$createElement("text");
+                _$insertNode(_el$2, _$createTextNode(` \xB7 `));
+                _$setProp(_el$2, "wrapMode", "none");
+                _$setProp(_el$2, "flexShrink", 0);
+                _$effect((_$p) => _$setProp(_el$2, "fg", context.theme.text.muted, _$p));
+                return _el$2;
+              }
+            }), _$createComponent(Show, {
+              get when() {
+                return segment.url;
+              },
+              get fallback() {
+                return (() => {
+                  var _el$4 = _$createElement("text");
+                  _$setProp(_el$4, "wrapMode", "none");
+                  _$setProp(_el$4, "flexShrink", 0);
+                  _$setProp(_el$4, "onMouseUp", () => showStatus(place()));
+                  _$insert(_el$4, () => segment.text);
+                  _$effect((_$p) => _$setProp(_el$4, "fg", color(segment.tone), _$p));
+                  return _el$4;
+                })();
+              },
+              children: (url) => (() => {
+                var _el$5 = _$createElement("text"), _el$6 = _$createElement("a"), _el$7 = _$createElement("u");
+                _$insertNode(_el$5, _el$6);
+                _$setProp(_el$5, "wrapMode", "none");
+                _$setProp(_el$5, "flexShrink", 0);
+                _$setProp(_el$5, "onMouseUp", () => openUrl(url()));
+                _$insertNode(_el$6, _el$7);
+                _$insert(_el$7, () => segment.text);
+                _$effect((_p$) => {
+                  var _v$ = color(segment.tone), _v$2 = url();
+                  _v$ !== _p$.e && (_p$.e = _$setProp(_el$5, "fg", _v$, _p$.e));
+                  _v$2 !== _p$.t && (_p$.t = _$setProp(_el$6, "href", _v$2, _p$.t));
+                  return _p$;
+                }, {
+                  e: undefined,
+                  t: undefined
+                });
+                return _el$5;
+              })()
+            })]
+          }));
+          _$effect((_$p) => _$setProp(_el$, "width", fullWidth(), _$p));
+          return _el$;
+        }
+      });
+    }
+    const openUrl = (url) => {
+      const opener = process.platform === "darwin" ? "open" : "xdg-open";
+      exec2(opener, [url], process.cwd()).then((result) => {
+        if (result.code !== 0)
+          context.ui.toast.show({
+            message: `Could not open ${url}`,
+            variant: "error"
+          });
+      });
+    };
+    const requestsFor = (place) => {
+      const lookup = snapshotOf(place).lookup;
+      return lookup?.kind === "found" ? lookup.requests : [];
+    };
+    const statusOff = (place) => {
+      if (enabledFor(place.directory))
+        return false;
+      context.ui.toast.show({
+        message: "PR/MR status is off in the plugin's options (reviewStatus: false)",
+        variant: "info"
+      });
+      return true;
+    };
+    function StatusDialog(props) {
+      const [terminalHeight, setTerminalHeight] = createSignal(context.renderer.height);
+      const onResize = () => setTerminalHeight(context.renderer.height);
+      context.renderer.on("resize", onResize);
+      onCleanup(() => context.renderer.off("resize", onResize));
+      const contentHeight = createMemo(() => Math.max(1, Math.min(24, Math.floor(terminalHeight() * 0.6) - 5)));
+      const snapshot2 = createMemo(() => snapshotOf(props.place));
+      const reload = () => {
+        if (!snapshot2().loading)
+          refresh(props.place);
+      };
+      const [activeAction, setActiveAction] = createSignal("refresh");
+      const moveAction = () => setActiveAction((action) => action === "refresh" || snapshot2().loading ? "close" : "refresh");
+      const close = () => context.ui.dialog.clear();
+      context.keymap.layer(() => ({
+        mode: "modal",
+        commands: [{
+          id: "forge.review.status.refresh",
+          bind: "ctrl+r",
+          enabled: () => !snapshot2().loading,
+          run: reload
+        }, {
+          bind: "tab",
+          title: "Next dialog action",
+          run: moveAction
+        }, {
+          bind: "shift+tab",
+          title: "Previous dialog action",
+          run: moveAction
+        }, {
+          bind: "left",
+          title: "Previous dialog action",
+          run: moveAction
+        }, {
+          bind: "right",
+          title: "Next dialog action",
+          run: moveAction
+        }, {
+          bind: "return",
+          title: "Activate dialog action",
+          run: () => {
+            if (activeAction() === "refresh")
+              reload();
+            else
+              close();
+          }
+        }]
+      }));
+      return (() => {
+        var _el$8 = _$createElement("box"), _el$9 = _$createElement("box"), _el$0 = _$createElement("text"), _el$1 = _$createElement("b"), _el$11 = _$createElement("text"), _el$13 = _$createElement("scrollbox"), _el$14 = _$createElement("text"), _el$15 = _$createElement("box");
+        _$insertNode(_el$8, _el$9);
+        _$insertNode(_el$8, _el$13);
+        _$insertNode(_el$8, _el$15);
+        _$setProp(_el$8, "paddingLeft", 2);
+        _$setProp(_el$8, "paddingRight", 2);
+        _$setProp(_el$8, "paddingBottom", 1);
+        _$setProp(_el$8, "gap", 1);
+        _$insertNode(_el$9, _el$0);
+        _$insertNode(_el$9, _el$11);
+        _$setProp(_el$9, "height", 1);
+        _$setProp(_el$9, "flexShrink", 0);
+        _$setProp(_el$9, "flexDirection", "row");
+        _$setProp(_el$9, "justifyContent", "space-between");
+        _$insertNode(_el$0, _el$1);
+        _$insertNode(_el$1, _$createTextNode(`PR/MR status`));
+        _$insertNode(_el$11, _$createTextNode(`esc`));
+        _$setProp(_el$11, "onMouseUp", close);
+        _$insertNode(_el$13, _el$14);
+        _$setProp(_el$13, "minHeight", 1);
+        _$setProp(_el$13, "flexShrink", 0);
+        _$setProp(_el$13, "scrollX", false);
+        _$setProp(_el$13, "contentOptions", {
+          flexShrink: 0
+        });
+        _$insert(_el$14, () => detailsMessage(snapshot2()));
+        _$setProp(_el$15, "height", 1);
+        _$setProp(_el$15, "flexShrink", 0);
+        _$setProp(_el$15, "flexDirection", "row");
+        _$setProp(_el$15, "justifyContent", "flex-end");
+        _$insert(_el$15, _$createComponent(For, {
+          each: ["close", "refresh"],
+          children: (action) => {
+            const disabled = () => action === "refresh" && snapshot2().loading;
+            const active = () => activeAction() === action && !disabled();
+            return (() => {
+              var _el$16 = _$createElement("box"), _el$17 = _$createElement("text");
+              _$insertNode(_el$16, _el$17);
+              _$setProp(_el$16, "paddingLeft", 1);
+              _$setProp(_el$16, "paddingRight", 1);
+              _$setProp(_el$16, "flexShrink", 0);
+              _$setProp(_el$16, "onMouseMove", () => {
+                if (!disabled())
+                  setActiveAction(action);
+              });
+              _$setProp(_el$16, "onMouseUp", () => {
+                if (disabled())
+                  return;
+                setActiveAction(action);
+                if (action === "refresh")
+                  reload();
+                else
+                  close();
+              });
+              _$setProp(_el$17, "wrapMode", "none");
+              _$insert(_el$17, () => action === "close" ? "Close" : snapshot2().loading ? "Refreshing\u2026" : "Refresh");
+              _$effect((_p$) => {
+                var _v$8 = active() ? context.theme.background.action.primary.focused : undefined, _v$9 = disabled() ? context.theme.text.action.primary.disabled : active() ? context.theme.text.action.primary.focused : context.theme.text.muted;
+                _v$8 !== _p$.e && (_p$.e = _$setProp(_el$16, "backgroundColor", _v$8, _p$.e));
+                _v$9 !== _p$.t && (_p$.t = _$setProp(_el$17, "fg", _v$9, _p$.t));
+                return _p$;
+              }, {
+                e: undefined,
+                t: undefined
+              });
+              return _el$16;
+            })();
+          }
+        }));
+        _$effect((_p$) => {
+          var _v$3 = contentHeight() + 5, _v$4 = context.theme.text.base, _v$5 = context.theme.text.muted, _v$6 = contentHeight(), _v$7 = context.theme.text.base;
+          _v$3 !== _p$.e && (_p$.e = _$setProp(_el$8, "height", _v$3, _p$.e));
+          _v$4 !== _p$.t && (_p$.t = _$setProp(_el$0, "fg", _v$4, _p$.t));
+          _v$5 !== _p$.a && (_p$.a = _$setProp(_el$11, "fg", _v$5, _p$.a));
+          _v$6 !== _p$.o && (_p$.o = _$setProp(_el$13, "height", _v$6, _p$.o));
+          _v$7 !== _p$.i && (_p$.i = _$setProp(_el$14, "fg", _v$7, _p$.i));
+          return _p$;
+        }, {
+          e: undefined,
+          t: undefined,
+          a: undefined,
+          o: undefined,
+          i: undefined
+        });
+        return _el$8;
+      })();
+    }
+    function showStatus(place = currentPlace()) {
+      if (statusOff(place))
+        return;
+      refresh(place);
+      context.ui.dialog.set({
+        size: "large",
+        centered: true
+      });
+      context.ui.dialog.show(() => _$createComponent(StatusDialog, {
+        place
+      }));
+    }
+    async function openRequest() {
+      const place = currentPlace();
+      if (statusOff(place))
+        return;
+      let requests = requestsFor(place);
+      if (requests.length === 0) {
+        await refresh(place);
+        requests = requestsFor(place);
+      }
+      if (requests.length === 0) {
+        context.ui.toast.show({
+          message: "No PR/MR for this session or branch",
+          variant: "info"
+        });
+        return;
+      }
+      if (requests.length === 1)
+        return openUrl(requests[0].url);
+      const url = await context.ui.dialog.select({
+        title: "Open PR/MR",
+        actions: [{
+          bind: "ctrl+w",
+          title: "Close",
+          side: "right",
+          selection: "none",
+          onTrigger: () => context.ui.dialog.clear()
+        }],
+        options: requests.map((mr) => ({
+          title: `${reference(mr)} ${mr.title}`,
+          value: mr.url,
+          description: mr.targetProject
+        }))
+      });
+      if (url)
+        openUrl(url);
+    }
+    context.ui.slot({
+      append: "prompt.footer.status",
+      render: (input) => _$createComponent(Footer, {
+        get sessionID() {
+          return input.sessionID;
+        }
+      })
+    });
+    context.ui.slot({
+      append: "app",
+      render: () => {
+        context.keymap.layer(() => ({
+          mode: "global",
+          commands: [{
+            id: "forge.review.status",
+            title: "Show PR/MR status",
+            group: "Forge",
+            palette: true,
+            slash: {
+              name: "forge-status",
+              aliases: ["mr-status", "pr-status"]
+            },
+            run: () => showStatus()
+          }, {
+            id: "forge.review.open",
+            title: "Open PR/MR in browser",
+            group: "Forge",
+            palette: true,
+            slash: {
+              name: "forge-open",
+              aliases: ["mr-open", "pr-open"]
+            },
+            run: openRequest
+          }]
+        }));
+        return null;
+      }
+    });
+    const stops = [
+      rpc.events.on("status", (event) => {
+        const {
+          directory,
+          key: key2,
+          snapshot: snapshot2
+        } = event.data;
+        client.receive(directory, key2, snapshot2);
+      }),
+      rpc.events.on("notice", (event) => {
+        const notice = event.data;
+        if (notice.sessionID && !client.hasShown(notice.sessionID))
+          return;
+        context.ui.toast.show({
+          ...notice.title ? {
+            title: notice.title
+          } : {},
+          message: notice.message,
+          variant: notice.variant
+        });
+      })
+    ];
+    return () => {
+      clearInterval(heartbeat);
+      for (const stop of stops)
+        stop();
+      client.dispose();
+    };
+  }
+};
+export {
+  tui_default as default
+};