dsh-pstack 0.1.0 → 0.2.0-beta.1

package/assets/skills/poteto-mode/scripts/watch-pr/render.ts

@@ -1,169 +0,0 @@
-import type * as T from "./types.ts";
-export const renderJson = (verdict: T.WatcherVerdict): string =>
-  `${JSON.stringify(verdict)}\n`;
-function ciCell(row: T.PrSnapshot): string {
-  if (row.kind !== "open") return "\u2014";
-  const was = row.ci.hadPreviousPassingCi ? ", was ✅" : "";
-  switch (row.ci.kind) {
-    case "ci-clean":
-      return "✅";
-    case "ci-pending":
-      return `⏳ ${row.ci.pending.length} pending${was}`;
-    case "ci-failing":
-      return `❌ ${row.ci.failed.length} failed${row.ci.pending.length ? `, ${row.ci.pending.length} pending` : ""}${was}`;
-    case "ci-github-rejected":
-      return `❌ GitHub reports failing checks${was}`;
-    default: {
-      const exhaustive: never = row.ci;
-      return exhaustive;
-    }
-  }
-}
-function reviewCell(row: T.PrSnapshot): string {
-  if (row.kind !== "open") return "\u2014";
-  const open = row.threads.length;
-  return row.reviewAutomationRunning
-    ? open
-      ? `🤖 running, ${open} open`
-      : "🤖 running"
-    : open
-      ? `📝 ${open} open`
-      : "✅";
-}
-function mergeCell(row: T.PrSnapshot): string {
-  if (row.kind === "merged") return "✅ merged";
-  if (row.kind === "closed") return "❌ closed";
-  if (row.facts.isDraft) return "⏸ draft";
-  if (row.facts.reviewDecision === "CHANGES_REQUESTED")
-    return "⚠️ changes requested";
-  return row.facts.mergeable === "CONFLICTING" ||
-    row.facts.mergeStateStatus === "DIRTY" ||
-    row.facts.mergeStateStatus === "CONFLICTING"
-    ? "⚠️ conflict"
-    : "✅";
-}
-export function renderStatusTable(rows: T.NonEmpty<T.PrSnapshot>): string {
-  const lines = ["| PR | CI | Review | Merge |", "| --- | --- | --- | --- |"];
-  for (const row of rows) {
-    const url = `https://github.com/${row.context.owner}/${row.context.repo}/pull/${row.context.number}`;
-    lines.push(
-      `| [#${row.context.number}](${url}) | ${ciCell(row)} | ${reviewCell(row)} | ${mergeCell(row)} |`
-    );
-  }
-  return `${lines.join("\n")}\n`;
-}
-function threadLine(thread: T.ReviewThread): string {
-  const comment = thread.firstComment;
-  return [
-    thread.id,
-    comment?.path ?? "None",
-    comment?.line ?? "None",
-    comment?.authorLogin ?? "None",
-    `isBugBot=${thread.isBugbot}`,
-    `bugbotReviewPasses=${thread.bugbotReviewPasses}`,
-    (comment?.body ?? "").split(/\r?\n/, 1)[0]?.slice(0, 180) ?? "",
-  ].join(" ");
-}
-type StatusQueryBlocker = {
-  readonly kind: "status-query";
-  readonly failures: number;
-  readonly failure: { readonly detail: string };
-};
-function renderBlocker(blocker: T.MergeBlocker | StatusQueryBlocker): string {
-  switch (blocker.kind) {
-    case "merge-conflicts":
-      return [
-        "BLOCKER: merge-conflicts",
-        `pr=${blocker.pr.number}`,
-        `mergeable=${blocker.facts.mergeable}`,
-        `mergeStateStatus=${blocker.facts.mergeStateStatus}`,
-        "action=resolve merge conflicts before waiting for CI",
-      ].join("\n");
-    case "review-threads":
-      return [
-        "BLOCKER: review-threads",
-        `pr=${blocker.pr.number}`,
-        `unresolved=${blocker.threads.length}`,
-        ...blocker.threads.map(threadLine),
-      ].join("\n");
-    case "failing-checks": {
-      const failed = blocker.ci.kind === "ci-failing" ? blocker.ci.failed : [];
-      const details = failed.map(
-        (check) =>
-          `${check.name} ${check.reportedState} ${check.description} ${check.link}`
-      );
-      if (blocker.ci.kind === "ci-github-rejected")
-        details.push(
-          `mergeStateStatus=${blocker.ci.github.mergeStateStatus}`,
-          `headRollupState=${blocker.ci.github.headRollupState}`
-        );
-      return [
-        "BLOCKER: failing-checks",
-        `pr=${blocker.pr.number}`,
-        `failed=${failed.length}`,
-        ...details,
-      ].join("\n");
-    }
-    case "merge-gate": {
-      const action =
-        blocker.reason === "closed-without-merge"
-          ? "restore or remove the closed PR from the queued stack"
-          : blocker.reason === "draft-pr"
-            ? "mark the PR ready for review before waiting for the merge queue"
-            : "resolve the changes-requested review before waiting for the merge queue";
-      return [
-        `BLOCKER: ${blocker.reason}`,
-        `pr=${blocker.pr.number}`,
-        `action=${action}`,
-      ].join("\n");
-    }
-    case "status-query":
-      return [
-        "BLOCKER: status-query",
-        `failures=${blocker.failures}`,
-        `detail=${blocker.failure.detail}`,
-        "action=verify current PR context, GitHub authentication, and API availability, then rearm",
-      ].join("\n");
-    default: {
-      const exhaustive: never = blocker;
-      return exhaustive;
-    }
-  }
-}
-export function renderPretty(verdict: T.WatcherVerdict): string {
-  switch (verdict.kind) {
-    case "QUEUE":
-      return `QUEUE: captured ${verdict.queue.length} PR${verdict.queue.length === 1 ? "" : "s"} bottom-to-top: ${verdict.queue.map((pr) => `#${pr.number}`).join(",")}\n`;
-    case "STATUS":
-      return renderStatusTable(verdict.rows);
-    case "WAITING":
-      return verdict.reason.kind === "pending-checks"
-        ? `WAITING: frontier=#${verdict.frontier.number}; ${verdict.reason.pending.length} check${verdict.reason.pending.length === 1 ? "" : "s"} pending\n`
-        : `WAITING: frontier=#${verdict.frontier.number} is blocker-free; waiting for merge queue (${verdict.reason.unmergedCount} PR${verdict.reason.unmergedCount === 1 ? "" : "s"} unmerged)\n`;
-    case "ADVANCE":
-      return `ADVANCE: merged #${verdict.merged.number}; next=#${verdict.frontier.number}; remaining=${verdict.remaining}\n`;
-    case "RETRY":
-      return `RETRY: GitHub status query failed; retrying in ${verdict.retryInSeconds}s\ndetail=${verdict.failure.detail}\n`;
-    case "BLOCKER":
-      return `${renderBlocker(verdict.blocker)}\n`;
-    case "READY": {
-      const detail =
-        verdict.scope.kind === "single" && verdict.scope.pr.kind === "ready-pr"
-          ? `\nmergeStateStatus=${verdict.scope.pr.proof.ci.github.mergeStateStatus}\nreviewDecision=${verdict.scope.pr.proof.gate.reviewDecision}\nisDraft=${verdict.scope.pr.proof.gate.draft === "draft-allowed"}${verdict.scope.pr.proof.gate.draft === "draft-allowed" ? "\nnote=draft allowed (--allow-draft); leave draft \u2014 do not mark ready" : ""}`
-          : "";
-      return `READY: no merge conflicts, no unresolved review threads, no failing or pending checks${detail}\n`;
-    }
-    case "COMPLETE":
-      return `COMPLETE: queued stack merged (${verdict.queue.length} PR${verdict.queue.length === 1 ? "" : "s"})\n`;
-    case "TIMEOUT":
-      if (verdict.reason.kind === "pending-checks")
-        return "TIMEOUT: checks still pending\n";
-      if (verdict.reason.kind === "status-unavailable")
-        return "TIMEOUT: GitHub status remained unavailable\n";
-      return `TIMEOUT: queued stack still has ${verdict.reason.unmergedCount} PR${verdict.reason.unmergedCount === 1 ? "" : "s"} unmerged; frontier=#${verdict.reason.frontier.number}\n`;
-    default: {
-      const exhaustive: never = verdict;
-      return exhaustive;
-    }
-  }
-}

package/assets/skills/poteto-mode/scripts/watch-pr/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "allowImportingTsExtensions": true,
-    "module": "esnext",
-    "moduleResolution": "bundler",
-    "noEmit": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "target": "esnext",
-    "types": ["bun-types"]
-  },
-  "include": ["*.ts"]
-}

package/assets/skills/poteto-mode/scripts/watch-pr/types.compile.ts

@@ -1,93 +0,0 @@
-import { parsePrNumber } from "./types.ts";
-import type {
-  CiClean,
-  GitHubMergeAllowed,
-  PrContext,
-  ReadyPr,
-  TerminalVerdict,
-} from "./types.ts";
-
-type ReadyVerdict = Extract<TerminalVerdict, { readonly kind: "READY" }>;
-
-const context = {
-  owner: "octocat",
-  repo: "hello-world",
-  number: parsePrNumber(123),
-} satisfies PrContext;
-const cleanCi = {
-  kind: "ci-clean",
-  source: "gh-pr-checks",
-  all: [
-    {
-      kind: "passed",
-      name: "ci",
-      reportedState: "SUCCESS",
-      description: "",
-      link: "",
-      workflow: "",
-    },
-  ],
-  failed: [],
-  pending: [],
-  hadPreviousPassingCi: false,
-  github: {
-    kind: "allowed",
-    basis: "merge-state",
-    mergeStateStatus: "CLEAN",
-    headRollupState: "SUCCESS",
-  },
-} satisfies CiClean;
-const readyPr = {
-  kind: "ready-pr",
-  context,
-  proof: {
-    mergeability: "clear",
-    threads: [],
-    ci: cleanCi,
-    gate: {
-      state: "OPEN",
-      reviewDecision: "APPROVED",
-      draft: "not-draft",
-    },
-  },
-} satisfies ReadyPr;
-const ready = {
-  schemaVersion: 1,
-  sequence: 1,
-  observedAt: "2026-07-26T00:00:00.000Z",
-  mode: "single",
-  kind: "READY",
-  terminal: true,
-  exitCode: 0,
-  scope: { kind: "single", pr: readyPr },
-} satisfies ReadyVerdict;
-
-void ready;
-
-// PR 179929's shape. Each assertion below stays a single short statement so a
-// reformat cannot drift the directive away from the line that actually errors.
-const refused = {
-  kind: "allowed",
-  basis: "rollup",
-  mergeStateStatus: "BLOCKED",
-  headRollupState: "FAILURE",
-} as const;
-
-// @ts-expect-error BLOCKED with a failing rollup is a refusal, not an allowance.
-const refusalIsNotAllowed: GitHubMergeAllowed = refused;
-
-// @ts-expect-error CI cannot be clean while GitHub refuses the merge.
-const refusalIsNotClean: CiClean = { ...cleanCi, github: refused };
-
-// @ts-expect-error READY cannot carry the failing-checks exit code.
-const readyWithBlockerExit: ReadyVerdict = { ...ready, exitCode: 4 };
-
-const unprovenPr = { kind: "ready-pr", context } as const;
-
-// @ts-expect-error An open READY row must carry positive readiness proof.
-const readyWithoutProof: ReadyPr = unprovenPr;
-
-void refusalIsNotAllowed;
-void refusalIsNotClean;
-void readyWithBlockerExit;
-void readyWithoutProof;

package/assets/skills/poteto-mode/scripts/watch-pr/types.ts

@@ -1,413 +0,0 @@
-declare const prNumberBrand: unique symbol;
-export type PrNumber = number & { readonly [prNumberBrand]: "PrNumber" };
-export type NonEmpty<T> = readonly [T, ...T[]];
-export function nonEmpty<T>(items: readonly T[]): NonEmpty<T> | null {
-  return items.length === 0 ? null : [items[0], ...items.slice(1)];
-}
-export function parsePrNumber(value: unknown, label = "PR number"): PrNumber {
-  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0)
-    throw new Error(`${label} must be a positive integer`);
-  return value as PrNumber;
-}
-export interface Repository {
-  readonly owner: string;
-  readonly repo: string;
-}
-export interface PrContext extends Repository {
-  readonly number: PrNumber;
-}
-export type MergeStateStatus =
-  | "BEHIND"
-  | "BLOCKED"
-  | "CLEAN"
-  | "CONFLICTING"
-  | "DIRTY"
-  | "DRAFT"
-  | "HAS_HOOKS"
-  | "UNKNOWN"
-  | "UNSTABLE";
-export type RollupState =
-  | "ERROR"
-  | "EXPECTED"
-  | "FAILURE"
-  | "PENDING"
-  | "SUCCESS"
-  | null;
-export type ReviewDecision =
-  | "APPROVED"
-  | "CHANGES_REQUESTED"
-  | "REVIEW_REQUIRED"
-  | null;
-export interface PullRequestFacts {
-  readonly context: PrContext;
-  readonly mergeable: "MERGEABLE" | "CONFLICTING" | "UNKNOWN";
-  readonly mergeStateStatus: MergeStateStatus;
-  readonly reviewDecision: ReviewDecision;
-  readonly headRefOid: string | null;
-  readonly headRefName: string;
-  readonly baseRefName: string;
-  readonly state: "OPEN" | "CLOSED" | "MERGED";
-  readonly mergedAt: string | null;
-  readonly isDraft: boolean;
-}
-export interface OpenPullRequest {
-  readonly number: PrNumber;
-  readonly headRefName: string;
-  readonly baseRefName: string;
-}
-export interface ReviewComment {
-  readonly authorLogin: string | null;
-  readonly body: string;
-  readonly path: string | null;
-  readonly line: number | null;
-  readonly createdAt: string;
-}
-export interface ReviewThread {
-  readonly id: string;
-  readonly firstComment: ReviewComment | null;
-  readonly isBugbot: boolean;
-  readonly bugbotReviewPasses: number;
-}
-interface CheckDetails {
-  readonly name: string;
-  readonly reportedState: string;
-  readonly description: string;
-  readonly link: string;
-  readonly workflow: string;
-}
-export type Check =
-  | (CheckDetails & { readonly kind: "passed" })
-  | (CheckDetails & { readonly kind: "skipped" })
-  | (CheckDetails & { readonly kind: "failed" })
-  | (CheckDetails & { readonly kind: "pending" })
-  | (CheckDetails & {
-      readonly kind: "code-review-gate";
-      readonly name: "Code Review Gate";
-    });
-export type FailedCheck = Extract<Check, { readonly kind: "failed" }>;
-export type PendingCheck = Extract<Check, { readonly kind: "pending" }>;
-export interface CheckRead {
-  readonly source: "gh-pr-checks" | "graphql-rollup";
-  readonly checks: NonEmpty<Check>;
-}
-export interface CommitRollup {
-  readonly oid: string;
-  readonly state: RollupState;
-}
-export interface GitHubMergeRefusal {
-  readonly kind: "refused";
-  readonly mergeStateStatus: "BLOCKED";
-  readonly headRollupState: "ERROR" | "FAILURE";
-}
-export type GitHubMergeAllowed =
-  | {
-      readonly kind: "allowed";
-      readonly basis: "merge-state";
-      readonly mergeStateStatus: Exclude<MergeStateStatus, "BLOCKED">;
-      readonly headRollupState: RollupState;
-    }
-  | {
-      readonly kind: "allowed";
-      readonly basis: "rollup";
-      readonly mergeStateStatus: "BLOCKED";
-      readonly headRollupState: Exclude<RollupState, "ERROR" | "FAILURE">;
-    };
-export type GitHubMergeAssessment = GitHubMergeAllowed | GitHubMergeRefusal;
-interface CiBase {
-  readonly source: CheckRead["source"];
-  readonly all: NonEmpty<Check>;
-  readonly hadPreviousPassingCi: boolean;
-}
-export type CiFailing = CiBase & {
-  readonly kind: "ci-failing";
-  readonly failed: NonEmpty<FailedCheck>;
-  readonly pending: readonly PendingCheck[];
-  readonly github: GitHubMergeAssessment;
-};
-export type CiGithubRejected = CiBase & {
-  readonly kind: "ci-github-rejected";
-  readonly failed: readonly [];
-  readonly pending: readonly PendingCheck[];
-  readonly github: GitHubMergeRefusal;
-};
-export type CiPending = CiBase & {
-  readonly kind: "ci-pending";
-  readonly failed: readonly [];
-  readonly pending: NonEmpty<PendingCheck>;
-};
-export type CiClean = CiBase & {
-  readonly kind: "ci-clean";
-  readonly failed: readonly [];
-  readonly pending: readonly [];
-  readonly github: GitHubMergeAllowed;
-};
-export type CiState = CiFailing | CiGithubRejected | CiPending | CiClean;
-export type PrSnapshot =
-  | {
-      readonly kind: "merged" | "closed";
-      readonly context: PrContext;
-      readonly facts: PullRequestFacts;
-    }
-  | {
-      readonly kind: "open";
-      readonly context: PrContext;
-      readonly facts: PullRequestFacts;
-      readonly threads: readonly ReviewThread[];
-      readonly ci: CiState;
-      readonly reviewAutomationRunning: boolean;
-    };
-export interface ReadyPr {
-  readonly kind: "ready-pr";
-  readonly context: PrContext;
-  readonly proof: {
-    readonly mergeability: "clear";
-    readonly threads: readonly [];
-    readonly ci: CiClean;
-    readonly gate: {
-      readonly state: "OPEN";
-      readonly reviewDecision: Exclude<ReviewDecision, "CHANGES_REQUESTED">;
-      readonly draft: "not-draft" | "draft-allowed";
-    };
-  };
-}
-export interface MergedPr {
-  readonly kind: "merged-pr";
-  readonly context: PrContext;
-  readonly mergedAt: string | null;
-}
-export type MergeGateReason =
-  | "closed-without-merge"
-  | "draft-pr"
-  | "changes-requested";
-export type MergeBlocker =
-  | {
-      readonly kind: "merge-conflicts";
-      readonly pr: PrContext;
-      readonly facts: PullRequestFacts;
-    }
-  | {
-      readonly kind: "review-threads";
-      readonly pr: PrContext;
-      readonly threads: NonEmpty<ReviewThread>;
-    }
-  | {
-      readonly kind: "failing-checks";
-      readonly pr: PrContext;
-      readonly ci: CiFailing | CiGithubRejected;
-    }
-  | {
-      readonly kind: "merge-gate";
-      readonly pr: PrContext;
-      readonly reason: MergeGateReason;
-    };
-export type QueryFailure =
-  | {
-      readonly kind: "json-parse";
-      readonly retryable: true;
-      readonly detail: string;
-    }
-  | {
-      readonly kind: "missing-key";
-      readonly retryable: true;
-      readonly detail: string;
-      readonly rawValue?: string;
-    }
-  | {
-      readonly kind: "command-exit";
-      readonly retryable: true;
-      readonly detail: string;
-      readonly code: number;
-    }
-  | {
-      readonly kind: "checks-unavailable";
-      readonly retryable: true;
-      readonly detail: string;
-    }
-  | {
-      readonly kind: "invalid-context-url";
-      readonly retryable: false;
-      readonly detail: string;
-      readonly rawValue: string;
-    };
-/**
- * `frontier` names the lowest unmerged PR that is actually waiting, and
- * `pending` is that PR's checks only. Pooling every row's pending under the
- * bottom PR's number misattributed upstack waits to the frontier.
- *
- * This decision serves single and `--stack` mode. Queued mode deliberately
- * reports its own merge frontier instead: when that PR is blocker-free it
- * emits a merge-queue wait that ignores upstack pending, because upstack
- * checks do not block the frontier's merge. That is the Python watcher's
- * contract, not an attribution bug.
- */
-export interface WaitingDecision {
-  readonly kind: "waiting";
-  readonly frontier: PrContext;
-  readonly pending: NonEmpty<PendingCheck>;
-}
-export type PrDecision =
-  | { readonly kind: "blocker"; readonly blocker: MergeBlocker }
-  | WaitingDecision
-  | { readonly kind: "ready"; readonly pr: ReadyPr }
-  | { readonly kind: "merged"; readonly pr: MergedPr };
-export type StackDecision =
-  | { readonly kind: "blocker"; readonly blocker: MergeBlocker }
-  | WaitingDecision
-  | { readonly kind: "clear"; readonly prs: NonEmpty<ReadyPr | MergedPr> };
-export type WatchMode = "single" | "stack" | "queued-stack";
-interface EventBase<K extends string, M extends WatchMode = WatchMode> {
-  readonly schemaVersion: 1;
-  readonly sequence: number;
-  readonly observedAt: string;
-  readonly mode: M;
-  readonly kind: K;
-}
-interface Progress<K extends string, M extends WatchMode = WatchMode>
-  extends EventBase<K, M> {
-  readonly terminal: false;
-}
-interface Terminal<
-  K extends string,
-  C extends number,
-  M extends WatchMode = WatchMode,
-> extends EventBase<K, M> {
-  readonly terminal: true;
-  readonly exitCode: C;
-}
-export type ProgressVerdict =
-  | (Progress<"QUEUE", "queued-stack"> & {
-      readonly queue: NonEmpty<PrContext>;
-    })
-  | (Progress<"STATUS", "stack" | "queued-stack"> & {
-      readonly reason: "poll" | "whole-stack-sweep";
-      readonly rows: NonEmpty<PrSnapshot>;
-    })
-  | (Progress<"WAITING"> & {
-      readonly frontier: PrContext;
-      readonly reason:
-        | {
-            readonly kind: "pending-checks";
-            readonly pending: NonEmpty<PendingCheck>;
-          }
-        | { readonly kind: "merge-queue"; readonly unmergedCount: number };
-    })
-  | (Progress<"ADVANCE", "queued-stack"> & {
-      readonly merged: PrContext;
-      readonly frontier: PrContext;
-      readonly remaining: number;
-    })
-  | (Progress<"RETRY"> & {
-      readonly failure: QueryFailure;
-      readonly consecutiveFailures: number;
-      readonly retryInSeconds: number;
-    });
-export type BlockerVerdict =
-  | (Terminal<"BLOCKER", 2> & {
-      readonly blocker: Extract<
-        MergeBlocker,
-        { readonly kind: "merge-conflicts" }
-      >;
-    })
-  | (Terminal<"BLOCKER", 3> & {
-      readonly blocker: Extract<
-        MergeBlocker,
-        { readonly kind: "review-threads" }
-      >;
-    })
-  | (Terminal<"BLOCKER", 4> & {
-      readonly blocker: Extract<
-        MergeBlocker,
-        { readonly kind: "failing-checks" }
-      >;
-    })
-  | (Terminal<"BLOCKER", 6> & {
-      readonly blocker: Extract<MergeBlocker, { readonly kind: "merge-gate" }>;
-    })
-  | (Terminal<"BLOCKER", 7> & {
-      readonly blocker: {
-        readonly kind: "status-query";
-        readonly failures: number;
-        readonly failure: QueryFailure;
-      };
-    });
-export type TimeoutVerdict = Terminal<"TIMEOUT", 5> & {
-  readonly reason:
-    | {
-        readonly kind: "pending-checks";
-        readonly pending: NonEmpty<PendingCheck>;
-      }
-    | { readonly kind: "status-unavailable"; readonly failure: QueryFailure }
-    | {
-        readonly kind: "queued-stack";
-        readonly frontier: PrContext;
-        readonly unmergedCount: number;
-      };
-};
-export type TerminalVerdict =
-  | (Terminal<"STATUS", 0> & {
-      readonly reason: "status-only";
-      readonly rows: NonEmpty<PrSnapshot>;
-    })
-  | (Terminal<"READY", 0, "single" | "stack"> & {
-      readonly scope:
-        | { readonly kind: "single"; readonly pr: ReadyPr | MergedPr }
-        | {
-            readonly kind: "stack";
-            readonly prs: NonEmpty<ReadyPr | MergedPr>;
-          };
-    })
-  | (Terminal<"COMPLETE", 0, "queued-stack"> & {
-      readonly queue: NonEmpty<PrContext>;
-      readonly merged: NonEmpty<MergedPr>;
-    })
-  | BlockerVerdict
-  | TimeoutVerdict;
-export type WatcherVerdict = ProgressVerdict | TerminalVerdict;
-export type ExitCode = TerminalVerdict["exitCode"];
-export type QueueTerminalVerdict =
-  | Extract<TerminalVerdict, { readonly kind: "COMPLETE" }>
-  | BlockerVerdict
-  | TimeoutVerdict;
-export type ChecksFastPath =
-  | { readonly kind: "checks"; readonly checks: readonly Check[] }
-  | {
-      readonly kind: "unusable";
-      readonly exitCode: number;
-      readonly stderr: string;
-    };
-export interface RollupPage {
-  readonly checks: readonly Check[];
-  readonly endCursor: string | null;
-}
-export interface RawReviewThread {
-  readonly id: string;
-  readonly firstComment: ReviewComment | null;
-  readonly resolved: boolean;
-}
-export interface ReviewThreadPage {
-  readonly threads: readonly RawReviewThread[];
-  readonly endCursor: string | null;
-}
-export interface GitHubReader {
-  originRepo(): Promise<Repository | null>;
-  currentPr(pr: PrNumber | null): Promise<PrContext>;
-  pullRequest(context: PrContext): Promise<PullRequestFacts>;
-  openPullRequests(repository: Repository): Promise<readonly OpenPullRequest[]>;
-  checksFastPath(context: PrContext): Promise<ChecksFastPath>;
-  checkRollupPage(
-    context: PrContext,
-    after: string | null
-  ): Promise<RollupPage>;
-  reviewThreadPage(
-    context: PrContext,
-    after: string | null
-  ): Promise<ReviewThreadPage>;
-  commitRollups(context: PrContext): Promise<readonly CommitRollup[]>;
-}
-export interface PollingOptions {
-  readonly interval: number;
-  readonly sweepInterval: number;
-  readonly timeout: number;
-  readonly maxQueryErrors: number;
-  readonly allowDraft: boolean;
-}

package/assets/skills/poteto-mode/scripts/watch-pr/watch-pr

@@ -1,6 +0,0 @@
-#!/usr/bin/env bun
-import { ensureDependenciesInstalled } from "../bootstrap.ts";
-
-ensureDependenciesInstalled();
-const { main } = await import("./cli.ts");
-process.exitCode = await main(process.argv.slice(2));