@deftai/directive-core 0.55.0

package/dist/scm/binary.js

@@ -0,0 +1,35 @@
+import { execFileSync } from "node:child_process";
+import { BINARY_PREFERENCE } from "./constants.js";
+import { ScmStubError } from "./errors.js";
+/** Default PATH lookup mirroring Python `shutil.which`. Uses the
+ * platform-native resolver (`where` on Windows, `which` elsewhere) so
+ * executable resolution works cross-platform. */
+export function defaultWhich(name) {
+    const locator = process.platform === "win32" ? "where" : "which";
+    try {
+        const result = execFileSync(locator, [name], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        // `where` may return multiple lines; take the first non-empty match.
+        const first = result.split(/\r?\n/).find((line) => line.trim().length > 0);
+        return first !== undefined ? first.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Return `"ghx"` if on PATH, else `"gh"`; raise if neither is present.
+ * Mirrors `scripts/scm.py::resolve_binary`.
+ */
+export function resolveBinary(whichFn = defaultWhich) {
+    for (const candidate of BINARY_PREFERENCE) {
+        if (whichFn(candidate) !== null) {
+            return candidate;
+        }
+    }
+    throw new ScmStubError("neither 'ghx' nor 'gh' found on PATH; install GitHub CLI " +
+        "(https://cli.github.com/) or the ghx proxy (#884)");
+}
+//# sourceMappingURL=binary.js.map

package/dist/scm/build-command.d.ts

@@ -0,0 +1,11 @@
+import { resolveBinary } from "./binary.js";
+export interface BuildCommandOptions {
+    readonly binary?: string;
+    readonly whichFn?: Parameters<typeof resolveBinary>[0];
+}
+/**
+ * Construct the underlying `[binary, namespace, verb, *extra]` argv.
+ * Mirrors `scripts/scm.py::build_command`.
+ */
+export declare function buildCommand(namespace: string, verb: string, extra: readonly string[], options?: BuildCommandOptions): string[];
+//# sourceMappingURL=build-command.d.ts.map

package/dist/scm/build-command.js

@@ -0,0 +1,23 @@
+import { resolveBinary } from "./binary.js";
+import { ALLOWED_ISSUE_VERBS, ALLOWED_NAMESPACES } from "./constants.js";
+import { ScmStubError } from "./errors.js";
+import { pyRepr, pyTuple } from "./py-format.js";
+/**
+ * Construct the underlying `[binary, namespace, verb, *extra]` argv.
+ * Mirrors `scripts/scm.py::build_command`.
+ */
+export function buildCommand(namespace, verb, extra, options = {}) {
+    if (!ALLOWED_NAMESPACES.includes(namespace)) {
+        throw new ScmStubError(`unknown scm namespace ${pyRepr(namespace)}; expected one of ` +
+            `${pyTuple(ALLOWED_NAMESPACES)}. The full scm:* namespace lives at #881.`);
+    }
+    if (namespace === "issue" &&
+        !ALLOWED_ISSUE_VERBS.includes(verb)) {
+        throw new ScmStubError(`unknown scm:issue verb ${pyRepr(verb)}; expected one of ` +
+            `${pyTuple(ALLOWED_ISSUE_VERBS)}. The v1 stub only exposes these four; ` +
+            "additional scm:issue:* commands belong on #881.");
+    }
+    const resolved = options.binary ?? resolveBinary(options.whichFn ?? undefined);
+    return [resolved, namespace, verb, ...extra];
+}
+//# sourceMappingURL=build-command.js.map

package/dist/scm/call.d.ts

@@ -0,0 +1,25 @@
+import { resolveBinary } from "./binary.js";
+/** Mirrors Python `subprocess.CompletedProcess`. */
+export interface CompletedProcess {
+    readonly args: readonly string[];
+    readonly returncode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface CallOptions {
+    readonly check?: boolean;
+    readonly captureOutput?: boolean;
+    readonly text?: boolean;
+    readonly timeout?: number;
+    readonly cwd?: string;
+    readonly binary?: string;
+    readonly whichFn?: Parameters<typeof resolveBinary>[0];
+    readonly env?: NodeJS.ProcessEnv;
+    readonly input?: string;
+}
+/**
+ * Source-aware SCM invocation -- partial down-payment on #445 / #935 Workstream 6.
+ * Mirrors `scripts/scm.py::call`.
+ */
+export declare function call(source: string, verb: string, args?: readonly string[] | null, options?: CallOptions): CompletedProcess;
+//# sourceMappingURL=call.d.ts.map

package/dist/scm/call.js

@@ -0,0 +1,38 @@
+import { spawnSync } from "node:child_process";
+import { resolveBinary } from "./binary.js";
+import { SUPPORTED_CALL_SOURCES } from "./constants.js";
+import { pyRepr } from "./py-format.js";
+/**
+ * Source-aware SCM invocation -- partial down-payment on #445 / #935 Workstream 6.
+ * Mirrors `scripts/scm.py::call`.
+ */
+export function call(source, verb, args = null, options = {}) {
+    if (!SUPPORTED_CALL_SOURCES.includes(source)) {
+        throw new Error(`source=${pyRepr(source)} not yet supported; ` +
+            "see #445 / #935 Workstream 6 for the abstraction.");
+    }
+    const resolved = options.binary ?? resolveBinary(options.whichFn);
+    const argv = [resolved, verb, ...(args ?? [])];
+    const captureOutput = options.captureOutput ?? true;
+    const timeoutMs = options.timeout !== undefined ? Math.round(options.timeout * 1000) : undefined;
+    const result = spawnSync(resolved, [verb, ...(args ?? [])], {
+        cwd: options.cwd,
+        env: options.env ?? process.env,
+        input: options.input,
+        encoding: (options.text ?? true) ? "utf8" : undefined,
+        timeout: timeoutMs,
+        stdio: captureOutput ? ["pipe", "pipe", "pipe"] : "inherit",
+    });
+    if (options.check && result.status !== 0) {
+        const message = typeof result.stderr === "string" ? result.stderr : "";
+        const error = new Error(message || `Process exited with code ${result.status}`);
+        throw error;
+    }
+    return {
+        args: argv,
+        returncode: result.status ?? 1,
+        stdout: typeof result.stdout === "string" ? result.stdout : "",
+        stderr: typeof result.stderr === "string" ? result.stderr : "",
+    };
+}
+//# sourceMappingURL=call.js.map

package/dist/scm/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/scm/cli.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { main } from "./main.js";
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(main(process.argv.slice(2)));
+}
+//# sourceMappingURL=cli.js.map

package/dist/scm/constants.d.ts

@@ -0,0 +1,11 @@
+/** Allowed `<namespace>` argv[0] -- the v1 stub only exposes `issue`. */
+export declare const ALLOWED_NAMESPACES: readonly ["issue"];
+/** Source-aware shim (#1145 / N5) supported sources. */
+export declare const SUPPORTED_CALL_SOURCES: readonly ["github-issue"];
+/** Allowed `<verb>` argv[1] for the `issue` namespace. */
+export declare const ALLOWED_ISSUE_VERBS: readonly ["list", "view", "close", "edit"];
+/** Binary preference order (#884). */
+export declare const BINARY_PREFERENCE: readonly ["ghx", "gh"];
+/** Verbs that support the `--rest` opt-in. */
+export declare const REST_OPT_IN_VERBS: readonly ["view", "list"];
+//# sourceMappingURL=constants.d.ts.map

package/dist/scm/constants.js

@@ -0,0 +1,11 @@
+/** Allowed `<namespace>` argv[0] -- the v1 stub only exposes `issue`. */
+export const ALLOWED_NAMESPACES = ["issue"];
+/** Source-aware shim (#1145 / N5) supported sources. */
+export const SUPPORTED_CALL_SOURCES = ["github-issue"];
+/** Allowed `<verb>` argv[1] for the `issue` namespace. */
+export const ALLOWED_ISSUE_VERBS = ["list", "view", "close", "edit"];
+/** Binary preference order (#884). */
+export const BINARY_PREFERENCE = ["ghx", "gh"];
+/** Verbs that support the `--rest` opt-in. */
+export const REST_OPT_IN_VERBS = ["view", "list"];
+//# sourceMappingURL=constants.js.map

package/dist/scm/errors.d.ts

@@ -0,0 +1,5 @@
+/** Raised on argv-validation or binary-resolution failures. */
+export declare class ScmStubError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/scm/errors.js

@@ -0,0 +1,8 @@
+/** Raised on argv-validation or binary-resolution failures. */
+export class ScmStubError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ScmStubError";
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/scm/gh-rest.d.ts

@@ -0,0 +1,74 @@
+import { resolveBinary } from "./binary.js";
+export declare const DEFAULT_TIMEOUT_S = 60;
+/** Raised when the `"owner/repo"` argument is malformed. */
+export declare class InvalidRepoError extends Error {
+    constructor(repo: unknown);
+}
+/** Raised on non-zero `gh api` exit or non-JSON success response. */
+export declare class GhRestError extends Error {
+    readonly stderr: string;
+    readonly exitCode: number;
+    readonly endpoint: string;
+    readonly payload: Record<string, unknown> | null;
+    readonly hint: string;
+    constructor(options: {
+        stderr: string;
+        exitCode: number;
+        endpoint: string;
+        payload: Record<string, unknown> | null;
+        hint?: string;
+    });
+}
+export type RunGhApiFn = (args: readonly string[], options?: {
+    timeout?: number;
+    whichFn?: Parameters<typeof resolveBinary>[0];
+}) => {
+    returncode: number;
+    stdout: string;
+    stderr: string;
+};
+/** Single subprocess seam invoked by every helper. */
+export declare function runGhApi(args: readonly string[], options?: {
+    timeout?: number;
+    whichFn?: Parameters<typeof resolveBinary>[0];
+}): {
+    returncode: number;
+    stdout: string;
+    stderr: string;
+};
+export declare function splitRepo(repo: string): [string, string];
+export interface GhRestSeams {
+    readonly runGhApiFn?: RunGhApiFn;
+    readonly whichFn?: Parameters<typeof resolveBinary>[0];
+}
+/** `GET /repos/{owner}/{repo}/issues/{n}` -- read a single issue. */
+export declare function restIssueView(repo: string, n: number, seams?: GhRestSeams): Record<string, unknown>;
+export interface RestIssueListOptions {
+    readonly state?: string;
+    readonly labels?: readonly string[];
+    readonly author?: string | null;
+    readonly perPage?: number;
+}
+/** `GET /repos/{owner}/{repo}/issues` -- list issues (REST collection). */
+export declare function restIssueList(repo: string, options?: RestIssueListOptions, seams?: GhRestSeams): Record<string, unknown>[];
+export declare const REST_MAX_PER_PAGE = 100;
+export declare const REST_PAGINATION_MAX_PAGES = 100;
+export declare const PUBLIC_HELPERS: readonly ["restCreateIssue", "restPostComment", "restCloseIssue", "restOpenPr", "restMergePr", "restIssueView", "restPrView", "restIssueList", "restIssueListPaginated"];
+export declare function restCreateIssue(repo: string, title: string, body: string, labels?: readonly string[], seams?: GhRestSeams): Record<string, unknown>;
+export declare function restPostComment(repo: string, n: number, body: string, seams?: GhRestSeams): Record<string, unknown>;
+export declare function restCloseIssue(repo: string, n: number, reason?: string | null, seams?: GhRestSeams): Record<string, unknown>;
+export declare function restOpenPr(repo: string, head: string, base: string, title: string, body: string, options?: {
+    draft?: boolean;
+} & GhRestSeams): Record<string, unknown>;
+export declare function restMergePr(repo: string, n: number, options?: {
+    method?: string;
+    commitTitle?: string | null;
+    commitMessage?: string | null;
+} & GhRestSeams): Record<string, unknown>;
+export declare function restPrView(repo: string, n: number, seams?: GhRestSeams): Record<string, unknown>;
+export interface RestIssueListPaginatedOptions extends RestIssueListOptions {
+    readonly limit?: number | null;
+    readonly excludePulls?: boolean;
+}
+export declare function restIssueListPaginated(repo: string, options?: RestIssueListPaginatedOptions, seams?: GhRestSeams): Record<string, unknown>[];
+//# sourceMappingURL=gh-rest.d.ts.map

package/dist/scm/gh-rest.js

@@ -0,0 +1,326 @@
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
+import { resolveBinary } from "./binary.js";
+import { pyRepr } from "./py-format.js";
+export const DEFAULT_TIMEOUT_S = 60;
+/** Raised when the `"owner/repo"` argument is malformed. */
+export class InvalidRepoError extends Error {
+    constructor(repo) {
+        const message = typeof repo !== "string" || repo.length === 0
+            ? `repo must be a non-empty string of the form 'owner/repo'; got ${pyRepr(repo)}`
+            : `repo must match 'owner/repo' (single slash, both segments non-empty); got ${pyRepr(repo)}`;
+        super(message);
+        this.name = "InvalidRepoError";
+    }
+}
+/** Raised on non-zero `gh api` exit or non-JSON success response. */
+export class GhRestError extends Error {
+    stderr;
+    exitCode;
+    endpoint;
+    payload;
+    hint;
+    constructor(options) {
+        const hint = options.hint ?? "";
+        let msg = `gh api failed: endpoint=${pyRepr(options.endpoint)} ` +
+            `exit=${options.exitCode} stderr=${pyRepr(options.stderr)}`;
+        if (hint.length > 0) {
+            msg += `; hint: ${hint}`;
+        }
+        super(msg);
+        this.name = "GhRestError";
+        this.stderr = options.stderr;
+        this.exitCode = options.exitCode;
+        this.endpoint = options.endpoint;
+        this.payload = options.payload;
+        this.hint = hint;
+    }
+}
+/** Single subprocess seam invoked by every helper. */
+export function runGhApi(args, options = {}) {
+    const binary = resolveBinary(options.whichFn);
+    const timeoutMs = options.timeout !== undefined ? Math.round(options.timeout * 1000) : DEFAULT_TIMEOUT_S * 1000;
+    const result = spawnSync(binary, ["api", ...args], {
+        encoding: "utf8",
+        timeout: timeoutMs,
+        env: process.env,
+        maxBuffer: SUBPROCESS_MAX_BUFFER,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stderr = typeof result.stderr === "string" ? result.stderr : "";
+    // A spawn-level failure (e.g. ENOBUFS when stdout exceeds maxBuffer) yields a
+    // null status and empty stderr; surface error.message so the GhRestError that
+    // wraps this never reports a blank reason (#1867).
+    if (result.status === null && result.error && stderr.trim().length === 0) {
+        stderr = result.error.message;
+    }
+    return {
+        returncode: result.status ?? 1,
+        stdout: typeof result.stdout === "string" ? result.stdout : "",
+        stderr,
+    };
+}
+export function splitRepo(repo) {
+    if (typeof repo !== "string" || repo.length === 0) {
+        throw new InvalidRepoError(repo);
+    }
+    const parts = repo.split("/");
+    if (parts.length !== 2 || parts[0] === "" || parts[1] === "") {
+        throw new InvalidRepoError(repo);
+    }
+    return [parts[0], parts[1]];
+}
+function execApi(args, options) {
+    const runner = options.runGhApiFn ?? runGhApi;
+    const result = runner(args, { whichFn: options.whichFn });
+    if (result.returncode !== 0) {
+        throw new GhRestError({
+            stderr: result.stderr.trim(),
+            exitCode: result.returncode,
+            endpoint: options.endpoint,
+            payload: options.payload,
+            hint: options.hint ?? "",
+        });
+    }
+    const stdout = result.stdout.trim();
+    if (stdout.length === 0) {
+        return options.expectList ? [] : {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : String(exc);
+        throw new GhRestError({
+            stderr: `non-JSON response: ${message}; raw=${pyRepr(stdout)}`,
+            exitCode: 0,
+            endpoint: options.endpoint,
+            payload: options.payload,
+            hint: "REST endpoint returned non-JSON; check gh / ghx version",
+        });
+    }
+    const expectedList = options.expectList ?? false;
+    if (expectedList) {
+        if (!Array.isArray(parsed)) {
+            throw new GhRestError({
+                stderr: `unexpected top-level type ${typeof parsed}`,
+                exitCode: 0,
+                endpoint: options.endpoint,
+                payload: options.payload,
+                hint: "REST endpoint returned non-list; expected list",
+            });
+        }
+        return parsed;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new GhRestError({
+            stderr: `unexpected top-level type ${Array.isArray(parsed) ? "list" : typeof parsed}`,
+            exitCode: 0,
+            endpoint: options.endpoint,
+            payload: options.payload,
+            hint: "REST endpoint returned non-dict; expected dict",
+        });
+    }
+    return parsed;
+}
+/** `GET /repos/{owner}/{repo}/issues/{n}` -- read a single issue. */
+export function restIssueView(repo, n, seams = {}) {
+    const [owner, name] = splitRepo(repo);
+    const endpoint = `repos/${owner}/${name}/issues/${n}`;
+    return execApi([endpoint], {
+        endpoint,
+        payload: null,
+        hint: "verify repo and issue number; check gh auth status",
+        runGhApiFn: seams.runGhApiFn,
+        whichFn: seams.whichFn,
+    });
+}
+/** `GET /repos/{owner}/{repo}/issues` -- list issues (REST collection). */
+export function restIssueList(repo, options = {}, seams = {}) {
+    const state = options.state ?? "open";
+    const labels = options.labels ?? [];
+    const author = options.author ?? null;
+    const perPage = options.perPage ?? 30;
+    const [owner, name] = splitRepo(repo);
+    const endpoint = `repos/${owner}/${name}/issues`;
+    const args = [endpoint, "--method", "GET"];
+    args.push("--raw-field", `state=${state}`);
+    args.push("--raw-field", `per_page=${perPage}`);
+    if (labels.length > 0) {
+        args.push("--raw-field", `labels=${labels.join(",")}`);
+    }
+    if (author !== null && author.length > 0) {
+        args.push("--raw-field", `creator=${author}`);
+    }
+    return execApi(args, {
+        endpoint,
+        payload: null,
+        hint: "verify repo, state value (open|closed|all), labels exist, " +
+            "and core REST bucket has remaining quota",
+        expectList: true,
+        runGhApiFn: seams.runGhApiFn,
+        whichFn: seams.whichFn,
+    });
+}
+export const REST_MAX_PER_PAGE = 100;
+export const REST_PAGINATION_MAX_PAGES = 100;
+export const PUBLIC_HELPERS = [
+    "restCreateIssue",
+    "restPostComment",
+    "restCloseIssue",
+    "restOpenPr",
+    "restMergePr",
+    "restIssueView",
+    "restPrView",
+    "restIssueList",
+    "restIssueListPaginated",
+];
+function writeJsonPayload(payload) {
+    const dir = mkdtempSync(join(tmpdir(), "gh_rest_payload_"));
+    const path = join(dir, "payload.json");
+    writeFileSync(path, JSON.stringify(payload), "utf8");
+    return { path, dir };
+}
+function execMutation(args, options) {
+    const written = writeJsonPayload(options.payload);
+    try {
+        return execApi([...args, "--input", written.path], {
+            endpoint: options.endpoint,
+            payload: options.payload,
+            hint: options.hint,
+            runGhApiFn: options.runGhApiFn,
+            whichFn: options.whichFn,
+        });
+    }
+    finally {
+        rmSync(written.dir, { recursive: true, force: true });
+    }
+}
+export function restCreateIssue(repo, title, body, labels = [], seams = {}) {
+    const [owner, name] = splitRepo(repo);
+    const payload = { title, body };
+    if (labels.length > 0) {
+        payload.labels = [...labels];
+    }
+    const endpoint = `repos/${owner}/${name}/issues`;
+    return execMutation([endpoint, "--method", "POST"], {
+        endpoint,
+        payload,
+        hint: "verify repo permissions, label existence, and that the core REST bucket has remaining quota",
+        ...seams,
+    });
+}
+export function restPostComment(repo, n, body, seams = {}) {
+    const [owner, name] = splitRepo(repo);
+    const endpoint = `repos/${owner}/${name}/issues/${n}/comments`;
+    return execMutation([endpoint, "--method", "POST"], {
+        endpoint,
+        payload: { body },
+        hint: "verify repo permissions, that the issue/PR is open or lockable, and core REST bucket quota",
+        ...seams,
+    });
+}
+export function restCloseIssue(repo, n, reason = "completed", seams = {}) {
+    const [owner, name] = splitRepo(repo);
+    const endpoint = `repos/${owner}/${name}/issues/${n}`;
+    return execMutation([endpoint, "--method", "PATCH"], {
+        endpoint,
+        payload: { state: "closed", state_reason: reason },
+        hint: "verify repo permissions and that the issue is open (closing a closed issue is idempotent server-side)",
+        ...seams,
+    });
+}
+export function restOpenPr(repo, head, base, title, body, options = {}) {
+    const [owner, name] = splitRepo(repo);
+    const endpoint = `repos/${owner}/${name}/pulls`;
+    return execMutation([endpoint, "--method", "POST"], {
+        endpoint,
+        payload: { title, head, base, body, draft: options.draft ?? false },
+        hint: "verify branch exists on origin, head/base differ, repo permissions, and core REST bucket quota",
+        runGhApiFn: options.runGhApiFn,
+        whichFn: options.whichFn,
+    });
+}
+export function restMergePr(repo, n, options = {}) {
+    const [owner, name] = splitRepo(repo);
+    const payload = { merge_method: options.method ?? "squash" };
+    if (options.commitTitle !== undefined && options.commitTitle !== null) {
+        payload.commit_title = options.commitTitle;
+    }
+    if (options.commitMessage !== undefined && options.commitMessage !== null) {
+        payload.commit_message = options.commitMessage;
+    }
+    const endpoint = `repos/${owner}/${name}/pulls/${n}/merge`;
+    return execMutation([endpoint, "--method", "PUT"], {
+        endpoint,
+        payload,
+        hint: "verify PR is non-draft, mergeable, branch-protection checks pass, and required reviews are satisfied",
+        runGhApiFn: options.runGhApiFn,
+        whichFn: options.whichFn,
+    });
+}
+export function restPrView(repo, n, seams = {}) {
+    const [owner, name] = splitRepo(repo);
+    const endpoint = `repos/${owner}/${name}/pulls/${n}`;
+    return execApi([endpoint], {
+        endpoint,
+        payload: null,
+        hint: "verify repo and PR number; check gh auth status",
+        runGhApiFn: seams.runGhApiFn,
+        whichFn: seams.whichFn,
+    });
+}
+export function restIssueListPaginated(repo, options = {}, seams = {}) {
+    const cappedPerPage = Math.min(Math.max(1, options.perPage ?? REST_MAX_PER_PAGE), REST_MAX_PER_PAGE);
+    const [owner, name] = splitRepo(repo);
+    const endpoint = `repos/${owner}/${name}/issues`;
+    const out = [];
+    const excludePulls = options.excludePulls ?? true;
+    for (let page = 1; page <= REST_PAGINATION_MAX_PAGES; page += 1) {
+        const args = [endpoint, "--method", "GET"];
+        args.push("--raw-field", `state=${options.state ?? "open"}`);
+        args.push("--raw-field", `per_page=${cappedPerPage}`);
+        args.push("--raw-field", `page=${page}`);
+        if ((options.labels ?? []).length > 0) {
+            args.push("--raw-field", `labels=${(options.labels ?? []).join(",")}`);
+        }
+        if (options.author !== undefined && options.author !== null && options.author.length > 0) {
+            args.push("--raw-field", `creator=${options.author}`);
+        }
+        const pagePayload = execApi(args, {
+            endpoint,
+            payload: null,
+            hint: "verify repo, state value (open|closed|all), labels exist, and core REST bucket has remaining quota",
+            expectList: true,
+            runGhApiFn: seams.runGhApiFn,
+            whichFn: seams.whichFn,
+        });
+        if (pagePayload.length === 0) {
+            return out;
+        }
+        for (const item of pagePayload) {
+            if (excludePulls && "pull_request" in item) {
+                continue;
+            }
+            out.push(item);
+            if (options.limit !== undefined && options.limit !== null && out.length >= options.limit) {
+                return out.slice(0, options.limit);
+            }
+        }
+        if (pagePayload.length < cappedPerPage) {
+            return out;
+        }
+    }
+    throw new GhRestError({
+        stderr: `pagination exceeded REST_PAGINATION_MAX_PAGES=${REST_PAGINATION_MAX_PAGES}`,
+        exitCode: 0,
+        endpoint,
+        payload: null,
+        hint: "pass an explicit `limit` to bound the run, or open a follow-up to add explicit `page` cursor support",
+    });
+}
+//# sourceMappingURL=gh-rest.js.map

package/dist/scm/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./argv.js";
+export * from "./binary.js";
+export * from "./build-command.js";
+export * from "./call.js";
+export * from "./constants.js";
+export * from "./errors.js";
+export * from "./gh-rest.js";
+export * from "./main.js";
+export * from "./py-format.js";
+export * from "./rest-dispatch.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/scm/index.js

@@ -0,0 +1,11 @@
+export * from "./argv.js";
+export * from "./binary.js";
+export * from "./build-command.js";
+export * from "./call.js";
+export * from "./constants.js";
+export * from "./errors.js";
+export * from "./gh-rest.js";
+export * from "./main.js";
+export * from "./py-format.js";
+export * from "./rest-dispatch.js";
+//# sourceMappingURL=index.js.map

package/dist/scm/main.d.ts

@@ -0,0 +1,12 @@
+import type { GhRestSeams } from "./gh-rest.js";
+export interface MainOptions {
+    readonly whichFn?: Parameters<typeof import("./binary.js").resolveBinary>[0];
+    /** Subprocess seam threaded through the `--rest` path for test isolation. */
+    readonly runGhApiFn?: GhRestSeams["runGhApiFn"];
+}
+/**
+ * CLI entry point. Returns the underlying binary's exit code (or 2 on arg error).
+ * Mirrors `scripts/scm.py::main`.
+ */
+export declare function main(argv: readonly string[], options?: MainOptions): number;
+//# sourceMappingURL=main.d.ts.map