@kud/gh-cockpit 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Erwann Mest
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,162 @@
+# @kud/gh-cockpit
+
+A configurable GitHub cockpit for the terminal — your PRs, reviews and issues in one Ink TUI, grouped by **whose move it is**.
+
+A tab tells you which relationship you are looking at. It never told you whether there was anything to _do_ once you got there, so red CI, merge conflicts and drafts sat interleaved with the rows you could actually act on. This bands every tab into `Your move` / `Their move` instead.
+
+```
+Review (20)
+
+  » Your move (2)
+  ── acme/api-gateway ─────
+  ◆ ← #1495  support statementPeriodIds…    6d
+  ── acme/event-bus ───────
+  ·   #290   delete the legacy path        14h
+
+  » Their move (9)
+  ── acme/monorepo ────────
+  ~   #10    add internalNotes field        1w
+  ── acme/api-gateway ─────
+  ✗ ← #1496  point history at the route     2d
+  !   #1449  guard null ids                 6w
+```
+
+## Install
+
+```sh
+npm install @kud/gh-cockpit
+```
+
+It is a **library, not a CLI**: you write the thin entry point, because the interesting decisions — which searches are tabs, which repos rank first, what a check drills into — are yours and not portable.
+
+## Whose move is it
+
+The band comes from the row's health _and_ where you stand relative to it. Those are different questions, and the same token means opposite things depending on the answer:
+
+|                                                       | `authored`<br>your PR | `queued`<br>a review was asked of you | `spoken`<br>you already reviewed |
+| ----------------------------------------------------- | --------------------- | ------------------------------------- | -------------------------------- |
+| `✗` CI failing · `!` conflict · `±` changes requested | **you**               | them                                  | them                             |
+| `·` awaiting review · `*` checks running              | them                  | **you**                               | them                             |
+| `✓` approved                                          | **you**               | **you**                               | them                             |
+| `◆` open threads                                      | **you**               | **you**                               | **you**                          |
+| `~` draft                                             | them                  | them                                  | them                             |
+
+Red CI on a PR you wrote is your afternoon. The same red CI on one you were asked to review is the author's, and reviewing it is wasted. Nothing on the row records that difference — it is a property of the _search_ the row arrived from, which is why `standing` is declared per search rather than inferred.
+
+> [!NOTE]
+> Every state has its own glyph, never a colour alone. Colour reinforces; it never carries meaning by itself.
+
+## Configure
+
+```ts
+import { defineCockpit } from "@kud/gh-cockpit"
+import { delegateExtension } from "@kud/gh-cockpit/extensions"
+
+export default defineCockpit({
+  repoPriority: ["acme/monorepo", "acme/", "me/"],
+  tabs: [
+    {
+      label: "Mine",
+      help: "your PRs, draft and open",
+      searches: ["is:open author:@me"],
+    },
+    {
+      label: "Review",
+      help: "theirs — asked of you, or you reviewed",
+      searches: [
+        { q: "is:open review-requested:@me", standing: "queued" },
+        {
+          q: "is:open reviewed-by:@me -author:@me -review-requested:@me",
+          standing: "spoken",
+        },
+      ],
+    },
+  ],
+  extensions: [delegateExtension],
+})
+```
+
+`defineCockpit` is identity, but typed — a config file is checked against the schema at build time rather than producing an empty tab at runtime.
+
+### Repo priority
+
+Ordered, best first. An entry ending in `/` matches an owner; anything else must equal `owner/name`, so a single repo can outrank the owner containing it. Repos matching nothing sort last, together.
+
+Grouping is a separate key from ranking: repos stay clustered whatever the priority list says, because repo headers depend on same-repo rows being adjacent.
+
+## Filtering
+
+```sh
+gh-cockpit --include 'acme/*,me/acme-*'
+```
+
+`*` matches within one path segment and never across the `/`, so `acme/*` cannot reach another owner and `acme` will not claim `acmecorp`. A bare owner is sugar for all its repos.
+
+```sh
+gh-cockpit --exclude 'acme/legacy'
+```
+
+Exclude is applied after include and wins, so you can take a whole org and drop one repo without listing the rest.
+
+```sh
+gh-cockpit --here
+```
+
+`--here` is not a filter. It resolves the repo from your git remote — `upstream` if present, else `origin` — and scopes every search **server-side** with `repo:owner/name`, so other repos are never fetched at all. On a fork that matters: `origin` is your copy and `upstream` is where the PRs actually live.
+
+## Extensions
+
+Extensions live behind their own entry point because they are a choice, not a default — each one claims a keybinding on a surface where every key is already spoken for.
+
+```ts
+import {
+  delegateExtension,
+  copyPromptExtension,
+} from "@kud/gh-cockpit/extensions"
+```
+
+Both act on the row under the cursor and shell out to nothing, so neither assumes anything about what you have installed.
+
+## Check drill-ins
+
+Activating a CI check opens its log. GitHub Actions is built in; anything else is yours to register, and an unregistered check opens in a browser rather than drilling into a view that renders nothing.
+
+```ts
+import { registerCheckDrills } from "@kud/gh-cockpit"
+
+registerCheckDrills([
+  {
+    match: (url) => url.includes("ci.example"),
+    render: ({ url, name, onBack }) => <MyBuildView url={url} name={name} onBack={onBack} />,
+  },
+])
+```
+
+## Host configuration
+
+The library holds no opinion about your machine. `configureInbox` (from `@kud/gh-ink`) is where you supply one, and **every default is empty** — an unconfigured host gets flat repo ranking and no local-checkout resolution, never a guess at where you keep your code.
+
+```ts
+import { configureInbox } from "@kud/gh-cockpit"
+
+configureInbox({
+  repoPriority: ["acme/", "me/"],
+  checkoutDir: `${process.env.HOME}/src`,
+  cacheNamespace: "my-cockpit",
+  cacheTtlMs: 20 * 60_000,
+})
+```
+
+> [!TIP]
+> `cacheTtlMs` is the single knob between "always current" and "always slow, and drawing 502s from the API" — every launch past it pays the full query. It can be generous: acting on a row drops the cache entry outright, and `r` refetches on demand.
+
+## Refreshing
+
+The cockpit does not poll. A poller spends quota on the long stretches where nothing changed and is still up to a full interval late when something did. Instead, pass `watchPath` and have whatever mutates GitHub write a byte to that file — every open cockpit refetches, debounced. The filesystem is the broker: no daemon, no socket, no fan-out to manage.
+
+> [!IMPORTANT]
+> Write a byte rather than `touch`ing. At second-granularity mtime with no size change, two touches inside the same second are indistinguishable and some watch backends coalesce them away.
+
+## Licence
+
+MIT © Erwann Mest

package/dist/chunk-A3NXVFEI.js

@@ -0,0 +1,311 @@
+import * as gh_ink_star from '@kud/gh-ink';
+import { relativeTime, inboxConfig } from '@kud/gh-ink';
+import { mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { buildInboxQuery, computeHealth as computeHealth$1, latestChecks, isPendingCheck, isFailCheck, isPassCheck } from '@kud/gh';
+export { buildInboxQuery } from '@kud/gh';
+import { useWindowSize, Box, Text, useInput } from 'ink';
+import { Panel, colors, FooterHints, useListCursor } from '@kud/ink-ui';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { $ } from 'zx';
+import { useRef, useEffect, useState } from 'react';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+// src/lib.ts
+var lib_exports = {};
+__export(lib_exports, {
+  buildInboxQuery: () => buildInboxQuery,
+  computeHealth: () => computeHealth,
+  signalPath: () => signalPath,
+  toGHItem: () => toGHItem,
+  withRetry: () => withRetry
+});
+__reExport(lib_exports, gh_ink_star);
+var withRetry = async (fn, attempts = 3, delayMs = 1e3) => {
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (err) {
+      const msg = err.message ?? "";
+      const isTransient = /50[234]/.test(msg);
+      if (!isTransient || i === attempts - 1) throw err;
+      await new Promise((r) => setTimeout(r, delayMs * (i + 1)));
+    }
+  }
+  throw new Error("unreachable");
+};
+var computeHealth = (node) => computeHealth$1({
+  state: node.state,
+  isDraft: "isDraft" in node ? node.isDraft : void 0,
+  checks: node.statusCheckRollup?.contexts?.nodes ?? [],
+  mergeable: node.mergeable,
+  reviewDecision: node.reviewDecision,
+  unresolvedThreads: (node.reviewThreads?.nodes ?? []).filter(
+    (t) => t && !t.isResolved
+  ).length
+});
+var conversationOf = (node) => {
+  const events = [];
+  let count = node.comments?.totalCount ?? 0;
+  const isBot = (author) => author?.__typename === "Bot";
+  for (const c of node.comments?.nodes ?? [])
+    events.push({
+      at: c.createdAt,
+      login: c.author?.login,
+      bot: isBot(c.author)
+    });
+  for (const r of node.reviews?.nodes ?? [])
+    if (r.state !== "PENDING")
+      events.push({
+        at: r.submittedAt,
+        login: r.author?.login,
+        bot: isBot(r.author)
+      });
+  for (const t of node.reviewThreads?.nodes ?? []) {
+    count += t.comments?.totalCount ?? 0;
+    for (const c of t.comments?.nodes ?? [])
+      events.push({
+        at: c.createdAt,
+        login: c.author?.login,
+        bot: isBot(c.author)
+      });
+  }
+  const last = events.filter((e) => e.at).sort((a, b) => a.at.localeCompare(b.at)).pop();
+  const pushedAt = node.commits?.nodes?.[0]?.commit?.committedDate;
+  if (last?.bot && pushedAt && pushedAt > last.at)
+    return { count, lastActor: node.author?.login, lastEventAt: pushedAt };
+  return { count, lastActor: last?.login, lastEventAt: last?.at };
+};
+var detailOf = (node, lastEventAt) => {
+  const active = latestChecks(node.statusCheckRollup?.contexts?.nodes ?? []);
+  return {
+    reviewDecision: node.reviewDecision ?? void 0,
+    mergeable: node.mergeable ?? void 0,
+    checksPass: active.filter(isPassCheck).length,
+    checksFail: active.filter(isFailCheck).length,
+    checksPending: active.filter(isPendingCheck).length,
+    threadsTotal: (node.reviewThreads?.nodes ?? []).length,
+    lastCommitAt: node.commits?.nodes?.[0]?.commit?.committedDate,
+    lastEventAt
+  };
+};
+var toGHItem = (node, opts = {}) => {
+  const completedAt = node.mergedAt ?? node.closedAt ?? node.createdAt;
+  const convo = conversationOf(node);
+  const activityAt = [
+    node.createdAt,
+    convo.lastEventAt,
+    node.commits?.nodes?.[0]?.commit?.committedDate
+  ].filter(Boolean).sort().pop();
+  const isDone = Boolean(node.mergedAt ?? node.closedAt);
+  const sortAt = isDone ? completedAt : activityAt ?? completedAt;
+  return {
+    // Prefer GraphQL's own discriminator; fall back to field-presence only when
+    // a fragment omitted __typename. Field-presence alone mislabels PRs as issues
+    // whenever a fragment (reviewRequests, assigned, reviewed…) skips isDraft /
+    // headRefName — which sent PR drills to the issues endpoint.
+    kind: node.__typename === "PullRequest" ? "pr" : node.__typename === "Issue" ? "issue" : "isDraft" in node || "headRefName" in node ? "pr" : "issue",
+    number: node.number,
+    title: node.title ?? "",
+    repo: node.repository?.nameWithOwner ?? "",
+    url: node.url ?? "",
+    branch: node.headRefName,
+    health: computeHealth(node),
+    author: node.author?.login,
+    age: completedAt ? relativeTime(completedAt) : "",
+    activityAge: !isDone && activityAt ? relativeTime(activityAt) : void 0,
+    ts: sortAt ? new Date(sortAt).getTime() : 0,
+    unresolved: (node.reviewThreads?.nodes ?? []).filter(
+      (t) => t && !t.isResolved
+    ).length,
+    conversation: convo.count,
+    lastActor: convo.lastActor,
+    labels: (node.labels?.nodes ?? []).map((l) => l?.name).filter((n) => typeof n === "string"),
+    detail: detailOf(node, convo.lastEventAt),
+    indent: opts.indent ?? false
+  };
+};
+var signalPath = () => {
+  const dir = join(
+    process.env.XDG_CACHE_HOME || join(homedir(), ".cache"),
+    inboxConfig().cacheNamespace
+  );
+  mkdirSync(dir, { recursive: true });
+  return join(dir, "cockpit-dirty");
+};
+var DrillView = ({
+  title,
+  subtitle,
+  hints,
+  children
+}) => {
+  const { rows } = useWindowSize();
+  return /* @__PURE__ */ jsx(Panel, { children: /* @__PURE__ */ jsxs(Box, { flexDirection: "column", height: rows - 2, paddingX: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: colors.accent, bold: true, children: title }),
+      subtitle ? /* @__PURE__ */ jsxs(Box, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx(Text, { bold: true, children: "Title: " }),
+        /* @__PURE__ */ jsx(Text, { children: subtitle })
+      ] }) : null
+    ] }),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", flexGrow: 1, children }),
+    /* @__PURE__ */ jsx(FooterHints, { hints })
+  ] }) });
+};
+var CANDIDATES = [
+  { id: "claude", label: "Claude Code", cmd: "claude", acceptsPrompt: true },
+  { id: "opencode", label: "opencode", cmd: "opencode" },
+  { id: "codex", label: "Codex", cmd: "codex", acceptsPrompt: true }
+];
+var PLACEMENTS = [
+  { id: "here", label: "Right here" },
+  { id: "tab", label: "New tab" },
+  { id: "vpane", label: "New pane  \u2192  (right)" },
+  { id: "hpane", label: "New pane  \u2193  (below)" }
+];
+var isInstalled = async (cmd) => (await $({ nothrow: true, quiet: true })`command -v ${cmd}`).exitCode === 0;
+var shellQuote = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+var seedPromptFor = (item) => item.kind === "pr" ? `/k-pr ${item.number}` : item.labels?.includes("plan") ? `/k-project plan ${item.number}` : `/k-project ${item.url}`;
+var portablePromptFor = (item) => item.kind === "pr" ? `/k-pr ${item.url}` : item.labels?.includes("plan") ? `/k-project plan ${item.number} ${item.repo}` : `/k-project ${item.url}`;
+var CopyPromptNotice = ({
+  item,
+  onBack
+}) => {
+  const prompt = portablePromptFor(item);
+  const back = useRef(onBack);
+  back.current = onBack;
+  useEffect(() => {
+    (0, lib_exports.clipboard)(prompt);
+    const timer = setTimeout(() => back.current(), 1400);
+    return () => clearTimeout(timer);
+  }, [prompt]);
+  useInput(() => back.current());
+  return /* @__PURE__ */ jsx(
+    DrillView,
+    {
+      title: `Copy prompt \xB7 #${item.number} \xB7 ${item.repo}`,
+      subtitle: "paste it into a session that is already running",
+      hints: [["any key", "back"]],
+      children: /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx(Text, { color: colors.success, children: "\u2713 copied to clipboard" }),
+        /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: `prompt  ${prompt}` }) })
+      ] })
+    }
+  );
+};
+var AiLauncher = ({
+  item,
+  login,
+  prompt,
+  onBack
+}) => {
+  const [agents, setAgents] = useState(null);
+  const [step, setStep] = useState("agent");
+  const [agent, setAgent] = useState(null);
+  const [note, setNote] = useState(null);
+  useEffect(() => {
+    let live = true;
+    Promise.all(
+      CANDIDATES.map(async (a) => await isInstalled(a.cmd) ? a : null)
+    ).then((found) => {
+      if (!live) return;
+      const shell = { id: "shell", label: "Shell (no AI)", cmd: "" };
+      setAgents([...found.filter((a) => a !== null), shell]);
+    });
+    return () => {
+      live = false;
+    };
+  }, []);
+  const list = step === "agent" ? (agents ?? []).map((a) => ({ label: a.label, hint: a.cmd })) : PLACEMENTS.map((p) => ({ label: p.label }));
+  const { cursor, setCursor } = useListCursor(list.length);
+  const safeCursor = Math.min(cursor, Math.max(0, list.length - 1));
+  const focused = step === "agent" ? (agents ?? [])[safeCursor] : agent;
+  const launch = async (a, placement) => {
+    setNote(`\u22EF opening ${a.label}\u2026`);
+    try {
+      const base = await (0, lib_exports.buildCheckoutCmd)(item.repo, item.branch ?? "", login);
+      const run = prompt && a.acceptsPrompt ? `${a.cmd} ${shellQuote(prompt)}` : a.cmd;
+      const full = a.cmd ? `${base} && ${run}` : base;
+      if (placement === "here") {
+        (0, lib_exports.runHere)(full);
+        process.exit(0);
+      }
+      if (placement === "tab") await (0, lib_exports.openInTab)(full);
+      if (placement === "vpane") await (0, lib_exports.runInPane)(full);
+      if (placement === "hpane") await (0, lib_exports.runInPaneHorizontal)(full);
+      setNote(`\u2197 ${a.label} launched${item.branch ? ` \xB7 ${item.branch}` : ""}`);
+      setTimeout(onBack, 900);
+    } catch (e) {
+      setNote(`\u2717 ${e.message}`);
+    }
+  };
+  useInput((input, key) => {
+    if (key.escape || input === "q") {
+      if (step === "place") {
+        setStep("agent");
+        setCursor(0);
+        return;
+      }
+      return onBack();
+    }
+    if (key.return) {
+      if (step === "agent") {
+        setAgent((agents ?? [])[safeCursor] ?? null);
+        setStep("place");
+        setCursor(0);
+      } else if (agent) {
+        void launch(agent, PLACEMENTS[safeCursor].id);
+      }
+    }
+  });
+  return /* @__PURE__ */ jsx(
+    DrillView,
+    {
+      title: `Run AI \xB7 #${item.number} \xB7 ${item.repo}`,
+      subtitle: step === "agent" ? "choose an agent" : `${agent?.label} \u2014 choose where`,
+      hints: [
+        ["\u2191\u2193", "nav"],
+        ["\u21B5", step === "agent" ? "choose" : "launch"],
+        ["q/esc", step === "place" ? "back" : "close"]
+      ],
+      children: !agents ? /* @__PURE__ */ jsx(Text, { color: colors.info, children: "Detecting agents\u2026" }) : /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+        list.map((row, i) => /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Text, { color: colors.info, children: i === safeCursor ? "  \u276F " : "    " }),
+          /* @__PURE__ */ jsx(Text, { bold: i === safeCursor, children: row.label }),
+          row.hint ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  " + row.hint }) : null
+        ] }, row.label)),
+        prompt ? /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: `prompt  ${prompt}` }),
+          focused && focused.cmd && !focused.acceptsPrompt ? /* @__PURE__ */ jsx(
+            Text,
+            {
+              dimColor: true,
+              children: `        ${focused.label} takes no prompt \u2014 starts cold`
+            }
+          ) : null
+        ] }) : null,
+        note ? /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: colors.success, children: note }) }) : null
+      ] })
+    }
+  );
+};
+
+export { AiLauncher, CopyPromptNotice, DrillView, __export, __reExport, computeHealth, lib_exports, seedPromptFor, signalPath, toGHItem, withRetry };

package/dist/extensions/index.d.ts

@@ -0,0 +1,7 @@
+import { InboxExtension } from '@kud/gh-ink';
+
+declare const delegateExtension: InboxExtension;
+
+declare const copyPromptExtension: InboxExtension;
+
+export { copyPromptExtension, delegateExtension };

package/dist/extensions/index.js

@@ -0,0 +1,69 @@
+import { AiLauncher, seedPromptFor, CopyPromptNotice } from '../chunk-A3NXVFEI.js';
+import { useEffect } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var isDelegatable = (item) => item?.kind === "pr" || item?.kind === "issue";
+var DelegateScreen = ({
+  item,
+  login,
+  onExit
+}) => {
+  const delegatable = isDelegatable(item);
+  useEffect(() => {
+    if (!delegatable) onExit();
+  }, [delegatable, onExit]);
+  if (!delegatable) return null;
+  return /* @__PURE__ */ jsx(
+    AiLauncher,
+    {
+      item,
+      login,
+      prompt: seedPromptFor(item),
+      onBack: onExit
+    }
+  );
+};
+var delegateExtension = {
+  id: "delegate",
+  title: "Delegate to an agent",
+  key: "a",
+  // Short enough for the footer strip, where "delegate to an agent" would crowd out
+  // the bindings either side of it. Matches the drill views' own `a AI` hint.
+  hint: "AI",
+  // Item-scoped: this acts on the selected row, so it earns a place in that row's
+  // action menu under `m`. Without this it would still work as a keypress and stay
+  // absent from the menu, which is exactly the gap that prompted 0.5.0.
+  scope: "item",
+  body: (onExit, target) => /* @__PURE__ */ jsx(
+    DelegateScreen,
+    {
+      item: target?.item,
+      login: target?.login ?? "",
+      onExit
+    }
+  )
+};
+var isCopyable = (item) => item?.kind === "pr" || item?.kind === "issue";
+var CopyPromptScreen = ({
+  item,
+  onExit
+}) => {
+  const copyable = isCopyable(item);
+  useEffect(() => {
+    if (!copyable) onExit();
+  }, [copyable, onExit]);
+  if (!copyable) return null;
+  return /* @__PURE__ */ jsx(CopyPromptNotice, { item, onBack: onExit });
+};
+var copyPromptExtension = {
+  id: "copy-prompt",
+  title: "Copy prompt to clipboard",
+  // `y` for yank: `c` and `b` are gh-ink's own copy-URL and copy-branch, and `p`
+  // is open-repo-in-pane.
+  key: "y",
+  hint: "copy prompt",
+  scope: "item",
+  body: (onExit, target) => /* @__PURE__ */ jsx(CopyPromptScreen, { item: target?.item, onExit })
+};
+
+export { copyPromptExtension, delegateExtension };