@timmo001/effect-gh 0.1.0-0

package/dist/gh.d.ts

@@ -0,0 +1,38 @@
+import { Context, Duration, Effect, Layer, Schema, Stream } from "effect";
+import { ChildProcessSpawner } from "effect/unstable/process";
+import { type GhError } from "./errors.js";
+export interface GhOptions {
+    readonly executable?: string;
+    readonly cwd?: string;
+    readonly env?: Readonly<Record<string, string | undefined>>;
+    /** Explicit undefined clears stdin inherited from the layer. */
+    readonly stdin?: string | Uint8Array | undefined;
+    /** Total subprocess duration, including output draining. Null disables a layer timeout. */
+    readonly timeout?: Duration.Input | null;
+}
+export declare const GhOutput: Schema.Struct<{
+    readonly stdout: Schema.String;
+    readonly stderr: Schema.String;
+    readonly exitCode: Schema.Int;
+}>;
+export interface GhOutput extends Schema.Schema.Type<typeof GhOutput> {
+}
+export declare const GhChunk: Schema.TaggedUnion<{
+    readonly Stderr: Schema.TaggedStruct<"Stderr", {
+        readonly text: Schema.String;
+    }>;
+    readonly Stdout: Schema.TaggedStruct<"Stdout", {
+        readonly text: Schema.String;
+    }>;
+}>;
+export type GhChunk = typeof GhChunk.Type;
+export interface Interface {
+    readonly execute: (args: ReadonlyArray<string>, options?: GhOptions) => Effect.Effect<GhOutput, GhError>;
+    readonly json: <S extends Schema.Constraint>(args: ReadonlyArray<string>, schema: S, options?: GhOptions) => Effect.Effect<S["Type"], GhError, S["DecodingServices"]>;
+    readonly stream: (args: ReadonlyArray<string>, options?: GhOptions) => Stream.Stream<GhChunk, GhError>;
+}
+declare const Gh_base: Context.ServiceClass<Gh, "@timmo001/effect-gh/Gh", Interface>;
+export declare class Gh extends Gh_base {
+}
+export declare const layer: (defaults?: GhOptions) => Layer.Layer<Gh, never, ChildProcessSpawner.ChildProcessSpawner>;
+export {};

package/dist/gh.js

@@ -0,0 +1,96 @@
+import { Context, Duration, Effect, Layer, Match, Predicate, Schema, Stream, } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { GhCommandError, GhDecodeError, GhPlatformError, GhTimeoutError, } from "./errors.js";
+export const GhOutput = Schema.Struct({
+    stdout: Schema.String,
+    stderr: Schema.String,
+    exitCode: Schema.Int,
+});
+export const GhChunk = Schema.TaggedUnion({
+    Stdout: { text: Schema.String },
+    Stderr: { text: Schema.String },
+});
+export class Gh extends Context.Service()("@timmo001/effect-gh/Gh") {
+}
+const stderrLimit = 65_536;
+export const layer = (defaults = {}) => Layer.effect(Gh, Effect.gen(function* () {
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+    const open = Effect.fn("Gh.stream")(function* (args, options) {
+        const executable = options.executable ?? "gh";
+        const handle = yield* spawner
+            .spawn(ChildProcess.make(executable, args, {
+            cwd: options.cwd,
+            env: {
+                ...defaults.env,
+                ...options.env,
+                GH_PROMPT_DISABLED: "1",
+                GH_PAGER: "cat",
+                PAGER: "cat",
+                NO_COLOR: "1",
+                CLICOLOR: "0",
+                CLICOLOR_FORCE: "0",
+                GH_FORCE_TTY: undefined,
+                GH_SPINNER_DISABLED: "1",
+            },
+            extendEnv: true,
+            shell: false,
+            stdin: options.stdin === undefined ? "ignore" : "pipe",
+            stdout: "pipe",
+            stderr: "pipe",
+            forceKillAfter: "1 second",
+        }))
+            .pipe(Effect.mapError((cause) => new GhPlatformError({ executable, cause })));
+        let stderr = "";
+        let stderrTruncated = false;
+        const output = Stream.merge(handle.stdout.pipe(Stream.decodeText(), Stream.map((text) => GhChunk.cases.Stdout.make({ text }))), handle.stderr.pipe(Stream.decodeText(), Stream.map((text) => {
+            stderrTruncated ||= stderr.length + text.length > stderrLimit;
+            stderr = (stderr + text).slice(-stderrLimit);
+            return GhChunk.cases.Stderr.make({ text });
+        }))).pipe(Stream.mapError((cause) => new GhPlatformError({ executable, cause })));
+        const completion = Effect.gen(function* () {
+            const exitCode = yield* handle.exitCode.pipe(Effect.mapError((cause) => new GhPlatformError({ executable, cause })));
+            if (exitCode !== 0) {
+                return yield* new GhCommandError({
+                    executable,
+                    exitCode,
+                    stderr,
+                    stderrTruncated,
+                });
+            }
+        });
+        const completed = output.pipe(Stream.concat(Stream.fromEffect(completion).pipe(Stream.drain)));
+        if (options.stdin === undefined)
+            return completed;
+        const input = Predicate.isString(options.stdin)
+            ? new TextEncoder().encode(options.stdin)
+            : options.stdin;
+        return completed.pipe(Stream.mergeEffect(Stream.run(Stream.succeed(input), handle.stdin).pipe(Effect.mapError((cause) => new GhPlatformError({ executable, cause })))));
+    });
+    const stream = (args, overrides) => Stream.suspend(() => {
+        const options = { ...defaults, ...overrides };
+        const output = Stream.unwrap(open(args, options));
+        if (options.timeout == null)
+            return output;
+        if (!Duration.isFinite(Duration.fromInputUnsafe(options.timeout)))
+            return output;
+        const timeoutMs = Duration.toMillis(options.timeout);
+        return output.pipe(Stream.mergeEffect(Effect.sleep(options.timeout).pipe(Effect.andThen(Effect.fail(new GhTimeoutError({
+            executable: options.executable ?? "gh",
+            timeoutMs,
+        }))))));
+    });
+    const execute = Effect.fn("Gh.execute")(function* (args, options) {
+        return yield* stream(args, options).pipe(Stream.runFold(() => ({ stdout: "", stderr: "", exitCode: 0 }), (output, chunk) => Match.value(chunk).pipe(Match.tag("Stdout", ({ text }) => ({
+            ...output,
+            stdout: output.stdout + text,
+        })), Match.tag("Stderr", ({ text }) => ({
+            ...output,
+            stderr: output.stderr + text,
+        })), Match.exhaustive)));
+    });
+    const json = Effect.fn("Gh.json")(function* (args, schema, options) {
+        const output = yield* execute(args, options);
+        return yield* Schema.decodeEffect(Schema.fromJsonString(schema))(output.stdout).pipe(Effect.mapError((cause) => new GhDecodeError({ cause })));
+    });
+    return Gh.of({ execute, json, stream });
+}));

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { Gh, GhChunk, GhOutput, layer, type GhOptions, type Interface, } from "./gh.js";
+export { GhCommandError, GhDecodeError, GhPlatformError, GhTimeoutError, type GhError, } from "./errors.js";
+export * as Api from "./api.js";
+export * as Repository from "./repository.js";
+export * as Issue from "./issue.js";
+export * as PullRequest from "./pull-request.js";
+export * as Workflow from "./workflow.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+export { Gh, GhChunk, GhOutput, layer, } from "./gh.js";
+export { GhCommandError, GhDecodeError, GhPlatformError, GhTimeoutError, } from "./errors.js";
+export * as Api from "./api.js";
+export * as Repository from "./repository.js";
+export * as Issue from "./issue.js";
+export * as PullRequest from "./pull-request.js";
+export * as Workflow from "./workflow.js";

package/dist/issue.d.ts

@@ -0,0 +1,58 @@
+import { Effect, Schema } from "effect";
+import { Gh, type GhOptions } from "./gh.js";
+export declare const IssueSummary: Schema.Struct<{
+    readonly number: Schema.Int;
+    readonly title: Schema.String;
+    readonly url: Schema.String;
+    readonly state: Schema.Literals<readonly ["OPEN", "CLOSED"]>;
+    readonly updatedAt: Schema.String;
+}>;
+export interface IssueSummary extends Schema.Schema.Type<typeof IssueSummary> {
+}
+export declare const Issue: Schema.Struct<{
+    readonly number: Schema.Int;
+    readonly title: Schema.String;
+    readonly url: Schema.String;
+    readonly state: Schema.Literals<readonly ["OPEN", "CLOSED"]>;
+    readonly updatedAt: Schema.String;
+    readonly body: Schema.String;
+}>;
+export interface Issue extends Schema.Schema.Type<typeof Issue> {
+}
+export interface ViewOptions {
+    /** Select [HOST/]OWNER/REPO instead of the working directory's repository. */
+    readonly repo?: string;
+}
+export interface ListOptions extends ViewOptions {
+    /** Defaults to open. */
+    readonly state?: "open" | "closed" | "all";
+    /** Maximum issues to fetch, defaults to gh's 30; not an unbounded list. */
+    readonly limit?: number;
+    /** Repeated gh label filters; comma-separated values follow gh's label syntax. */
+    readonly labels?: ReadonlyArray<string>;
+    readonly assignee?: string;
+    readonly search?: string;
+}
+declare const InvalidInput_base: Schema.Class<InvalidInput, Schema.TaggedStruct<"IssueInvalidInput", {
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidInput extends InvalidInput_base {
+}
+/** Fetch a bounded list using gh's default state and limit unless overridden. */
+export declare const list: (options?: ListOptions | undefined, execution?: GhOptions | undefined) => Effect.Effect<readonly {
+    readonly number: number;
+    readonly title: string;
+    readonly url: string;
+    readonly state: "CLOSED" | "OPEN";
+    readonly updatedAt: string;
+}[], InvalidInput | import("./errors.js").GhError, Gh>;
+/** View an issue by number or URL, including its body. */
+export declare const view: (issue: string | number, options?: ViewOptions | undefined, execution?: GhOptions | undefined) => Effect.Effect<{
+    readonly number: number;
+    readonly title: string;
+    readonly url: string;
+    readonly state: "CLOSED" | "OPEN";
+    readonly updatedAt: string;
+    readonly body: string;
+}, InvalidInput | import("./errors.js").GhError, Gh>;
+export {};

package/dist/issue.js

@@ -0,0 +1,49 @@
+import { Effect, Predicate, Schema } from "effect";
+import { Gh } from "./gh.js";
+export const IssueSummary = Schema.Struct({
+    number: Schema.Int,
+    title: Schema.String,
+    url: Schema.String,
+    state: Schema.Literals(["OPEN", "CLOSED"]),
+    updatedAt: Schema.String,
+});
+export const Issue = Schema.Struct({
+    ...IssueSummary.fields,
+    body: Schema.String,
+});
+export class InvalidInput extends Schema.TaggedError()("IssueInvalidInput", { cause: Schema.Defect() }) {
+}
+const positiveInteger = Schema.Int.check(Schema.isGreaterThan(0));
+const summaryFields = "number,title,url,state,updatedAt";
+/** Fetch a bounded list using gh's default state and limit unless overridden. */
+export const list = Effect.fn("Issue.list")(function* (options = {}, execution) {
+    const args = ["issue", "list", "--json", summaryFields];
+    if (options.repo !== undefined)
+        args.push("--repo", options.repo);
+    if (options.state !== undefined)
+        args.push("--state", options.state);
+    if (options.limit !== undefined) {
+        const limit = yield* Schema.decodeEffect(positiveInteger)(options.limit).pipe(Effect.mapError((cause) => new InvalidInput({ cause })));
+        args.push("--limit", String(limit));
+    }
+    for (const label of options.labels ?? [])
+        args.push("--label", label);
+    if (options.assignee !== undefined)
+        args.push("--assignee", options.assignee);
+    if (options.search !== undefined)
+        args.push("--search", options.search);
+    const gh = yield* Gh;
+    return yield* gh.json(args, Schema.Array(IssueSummary), execution);
+});
+/** View an issue by number or URL, including its body. */
+export const view = Effect.fn("Issue.view")(function* (issue, options = {}, execution) {
+    if (Predicate.isNumber(issue)) {
+        yield* Schema.decodeEffect(positiveInteger)(issue).pipe(Effect.mapError((cause) => new InvalidInput({ cause })));
+    }
+    const gh = yield* Gh;
+    const args = ["issue", "view", "--json", `${summaryFields},body`];
+    if (options.repo !== undefined)
+        args.push("--repo", options.repo);
+    args.push("--", String(issue));
+    return yield* gh.json(args, Issue, execution);
+});

package/dist/pull-request.d.ts

@@ -0,0 +1,78 @@
+import { Effect, Schema } from "effect";
+import { GhDecodeError } from "./errors.js";
+import { Gh, type GhOptions } from "./gh.js";
+export declare const Summary: Schema.Struct<{
+    readonly number: Schema.Int;
+    readonly title: Schema.String;
+    readonly url: Schema.String;
+    readonly state: Schema.Literals<readonly ["OPEN", "CLOSED", "MERGED"]>;
+    readonly isDraft: Schema.Boolean;
+    readonly headRefName: Schema.String;
+    readonly headRefOid: Schema.String;
+}>;
+export interface Summary extends Schema.Schema.Type<typeof Summary> {
+}
+export declare const Check: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly state: Schema.String;
+    readonly bucket: Schema.Literals<readonly ["pass", "fail", "pending", "skipping", "cancel"]>;
+    readonly link: Schema.NullOr<Schema.String>;
+    readonly workflow: Schema.NullOr<Schema.String>;
+}>;
+export interface Check extends Schema.Schema.Type<typeof Check> {
+}
+export declare const ChecksResult: Schema.Struct<{
+    readonly checks: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly state: Schema.String;
+        readonly bucket: Schema.Literals<readonly ["pass", "fail", "pending", "skipping", "cancel"]>;
+        readonly link: Schema.NullOr<Schema.String>;
+        readonly workflow: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly status: Schema.Literals<readonly ["success", "failure", "pending"]>;
+    readonly exitCode: Schema.Literals<readonly [0, 1, 8]>;
+}>;
+export interface ChecksResult extends Schema.Schema.Type<typeof ChecksResult> {
+}
+export interface Options extends GhOptions {
+    readonly repository: string;
+}
+export interface ListOptions extends Options {
+    readonly state?: "open" | "closed" | "merged" | "all";
+    readonly limit?: number;
+    readonly base?: string;
+    readonly head?: string;
+}
+export interface ChecksOptions extends Options {
+    readonly required?: boolean;
+}
+export declare const list: (options: ListOptions) => Effect.Effect<readonly {
+    readonly number: number;
+    readonly title: string;
+    readonly url: string;
+    readonly state: "CLOSED" | "MERGED" | "OPEN";
+    readonly isDraft: boolean;
+    readonly headRefName: string;
+    readonly headRefOid: string;
+}[], import("./errors.js").GhError, Gh>;
+export declare const view: (selector: string | number, options: Options) => Effect.Effect<{
+    readonly number: number;
+    readonly title: string;
+    readonly url: string;
+    readonly state: "CLOSED" | "MERGED" | "OPEN";
+    readonly isDraft: boolean;
+    readonly headRefName: string;
+    readonly headRefOid: string;
+}, import("./errors.js").GhError, Gh>;
+/** Failed and pending checks are data; invalid output retains the command error. */
+export declare const checks: (selector: string | number, options: ChecksOptions) => Effect.Effect<{
+    readonly checks: readonly {
+        readonly name: string;
+        readonly state: string;
+        readonly bucket: "cancel" | "fail" | "pass" | "pending" | "skipping";
+        readonly link: string | null;
+        readonly workflow: string | null;
+    }[];
+    readonly status: "failure" | "pending" | "success";
+    readonly exitCode: 0 | 1 | 8;
+}, import("./errors.js").GhCommandError | GhDecodeError | import("./errors.js").GhPlatformError | import("./errors.js").GhTimeoutError, Gh>;

package/dist/pull-request.js

@@ -0,0 +1,79 @@
+import { Effect, Match, Predicate, Schema, Stream } from "effect";
+import { GhDecodeError } from "./errors.js";
+import { Gh } from "./gh.js";
+export const Summary = Schema.Struct({
+    number: Schema.Int,
+    title: Schema.String,
+    url: Schema.String,
+    state: Schema.Literals(["OPEN", "CLOSED", "MERGED"]),
+    isDraft: Schema.Boolean,
+    headRefName: Schema.String,
+    headRefOid: Schema.String,
+});
+export const Check = Schema.Struct({
+    name: Schema.String,
+    state: Schema.String,
+    bucket: Schema.Literals(["pass", "fail", "pending", "skipping", "cancel"]),
+    link: Schema.NullOr(Schema.String),
+    workflow: Schema.NullOr(Schema.String),
+});
+export const ChecksResult = Schema.Struct({
+    checks: Schema.Array(Check),
+    status: Schema.Literals(["success", "failure", "pending"]),
+    exitCode: Schema.Literals([0, 1, 8]),
+});
+const fields = "number,title,url,state,isDraft,headRefName,headRefOid";
+export const list = Effect.fn("PullRequest.list")(function* (options) {
+    const gh = yield* Gh;
+    const args = [
+        "pr",
+        "list",
+        `--repo=${options.repository}`,
+        `--state=${options.state ?? "open"}`,
+        `--limit=${options.limit ?? 30}`,
+        `--json=${fields}`,
+    ];
+    if (options.base !== undefined)
+        args.push(`--base=${options.base}`);
+    if (options.head !== undefined)
+        args.push(`--head=${options.head}`);
+    return yield* gh.json(args, Schema.Array(Summary), options);
+});
+export const view = Effect.fn("PullRequest.view")(function* (selector, options) {
+    const gh = yield* Gh;
+    return yield* gh.json([
+        "pr",
+        "view",
+        `--repo=${options.repository}`,
+        `--json=${fields}`,
+        "--",
+        String(selector),
+    ], Summary, options);
+});
+/** Failed and pending checks are data; invalid output retains the command error. */
+export const checks = Effect.fn("PullRequest.checks")(function* (selector, options) {
+    const gh = yield* Gh;
+    const args = [
+        "pr",
+        "checks",
+        `--repo=${options.repository}`,
+        "--json=name,state,bucket,link,workflow",
+    ];
+    if (options.required)
+        args.push("--required");
+    args.push("--", String(selector));
+    let stdout = "";
+    const commandError = yield* gh.stream(args, options).pipe(Stream.runForEach((chunk) => Effect.sync(() => {
+        if (Predicate.isTagged(chunk, "Stdout"))
+            stdout += chunk.text;
+    })), Effect.as(undefined), Effect.catchTag("GhCommandError", (error) => error.exitCode === 1 || error.exitCode === 8
+        ? Effect.succeed(error)
+        : Effect.fail(error)));
+    const decoded = yield* Schema.decodeEffect(Schema.fromJsonString(Schema.Array(Check)))(stdout).pipe(Effect.mapError((cause) => commandError ?? new GhDecodeError({ cause })));
+    const exitCode = commandError?.exitCode === 8 ? 8 : commandError ? 1 : 0;
+    return ChecksResult.make({
+        checks: decoded,
+        status: Match.value(exitCode).pipe(Match.when(8, () => "pending"), Match.when(1, () => "failure"), Match.when(0, () => "success"), Match.exhaustive),
+        exitCode,
+    });
+});

package/dist/repository.d.ts

@@ -0,0 +1,21 @@
+import { Effect, Schema } from "effect";
+import { Gh, type GhOptions } from "./gh.js";
+export declare const Repository: Schema.Struct<{
+    readonly nameWithOwner: Schema.String;
+    readonly url: Schema.String;
+    readonly defaultBranchRef: Schema.NullOr<Schema.Struct<{
+        readonly name: Schema.String;
+    }>>;
+    readonly isPrivate: Schema.Boolean;
+}>;
+export interface Repository extends Schema.Schema.Type<typeof Repository> {
+}
+/** View [HOST/]OWNER/REPO, or the repository selected by the working directory. */
+export declare const view: (repo?: string | undefined, options?: GhOptions | undefined) => Effect.Effect<{
+    readonly nameWithOwner: string;
+    readonly url: string;
+    readonly defaultBranchRef: {
+        readonly name: string;
+    } | null;
+    readonly isPrivate: boolean;
+}, import("./errors.js").GhError, Gh>;

package/dist/repository.js

@@ -0,0 +1,21 @@
+import { Effect, Schema } from "effect";
+import { Gh } from "./gh.js";
+export const Repository = Schema.Struct({
+    nameWithOwner: Schema.String,
+    url: Schema.String,
+    defaultBranchRef: Schema.NullOr(Schema.Struct({ name: Schema.String })),
+    isPrivate: Schema.Boolean,
+});
+/** View [HOST/]OWNER/REPO, or the repository selected by the working directory. */
+export const view = Effect.fn("Repository.view")(function* (repo, options) {
+    const gh = yield* Gh;
+    const args = [
+        "repo",
+        "view",
+        "--json",
+        "nameWithOwner,url,defaultBranchRef,isPrivate",
+    ];
+    if (repo !== undefined)
+        args.push("--", repo);
+    return yield* gh.json(args, Repository, options);
+});

package/dist/workflow.d.ts

@@ -0,0 +1,89 @@
+import { Effect, Schema, Stream } from "effect";
+import { Gh, type GhOptions } from "./gh.js";
+export declare const Run: Schema.Struct<{
+    readonly databaseId: Schema.Int;
+    readonly attempt: Schema.Int;
+    readonly headBranch: Schema.NullOr<Schema.String>;
+    readonly headSha: Schema.String;
+    readonly status: Schema.String;
+    readonly conclusion: Schema.NullOr<Schema.String>;
+    readonly url: Schema.String;
+    readonly workflowName: Schema.NullOr<Schema.String>;
+}>;
+export interface Run extends Schema.Schema.Type<typeof Run> {
+}
+declare const listOptions: Schema.Struct<{
+    readonly repo: Schema.String;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+    readonly branch: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly commit: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly workflow: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly status: Schema.optionalKey<Schema.Literals<readonly ["queued", "completed", "in_progress", "requested", "waiting", "pending", "action_required", "cancelled", "failure", "neutral", "skipped", "stale", "startup_failure", "success", "timed_out"]>>;
+}>;
+export interface ListOptions extends Schema.Schema.Type<typeof listOptions> {
+}
+declare const viewOptions: Schema.Struct<{
+    readonly repo: Schema.String;
+    readonly runId: Schema.Int;
+    readonly attempt: Schema.optionalKey<Schema.Int>;
+}>;
+export interface ViewOptions extends Schema.Schema.Type<typeof viewOptions> {
+}
+declare const logsOptions: Schema.Struct<{
+    readonly repo: Schema.String;
+    readonly runId: Schema.Int;
+    readonly attempt: Schema.optionalKey<Schema.Int>;
+    readonly failedOnly: Schema.optionalKey<Schema.Boolean>;
+    readonly job: Schema.optionalKey<Schema.Int>;
+}>;
+export interface LogsOptions extends Schema.Schema.Type<typeof logsOptions> {
+}
+declare const watchOptions: Schema.Struct<{
+    readonly repo: Schema.String;
+    readonly runId: Schema.Int;
+    readonly interval: Schema.optionalKey<Schema.Int>;
+}>;
+export interface WatchOptions extends Schema.Schema.Type<typeof watchOptions> {
+}
+declare const InvalidOptions_base: Schema.Class<InvalidOptions, Schema.TaggedStruct<"WorkflowInvalidOptions", {
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidOptions extends InvalidOptions_base {
+}
+/** Fetch at most `limit` recent runs (default 20), without unbounded pagination. */
+export declare const list: (input: ListOptions, options?: GhOptions | undefined) => Effect.Effect<readonly {
+    readonly databaseId: number;
+    readonly attempt: number;
+    readonly headBranch: string | null;
+    readonly headSha: string;
+    readonly status: string;
+    readonly conclusion: string | null;
+    readonly url: string;
+    readonly workflowName: string | null;
+}[], InvalidOptions | import("./errors.js").GhError, Gh>;
+/** View the latest attempt unless an explicit attempt is supplied. */
+export declare const view: (input: ViewOptions, options?: GhOptions | undefined) => Effect.Effect<{
+    readonly databaseId: number;
+    readonly attempt: number;
+    readonly headBranch: string | null;
+    readonly headSha: string;
+    readonly status: string;
+    readonly conclusion: string | null;
+    readonly url: string;
+    readonly workflowName: string | null;
+}, InvalidOptions | import("./errors.js").GhError, Gh>;
+/** Fetch full logs or failed steps, optionally for one attempt and job. */
+export declare const logs: (input: LogsOptions, options?: GhOptions | undefined) => Effect.Effect<string, InvalidOptions | import("./errors.js").GhError, Gh>;
+/**
+ * Stream native CLI progress, failing if the run fails. Requires gh with
+ * `--compact` support; gh watch cannot authenticate with fine-grained PATs.
+ * Inherits the core timeout; pass `{ timeout: null }` to disable it.
+ */
+export declare const watch: (input: WatchOptions, options?: GhOptions) => Stream.Stream<{
+    readonly _tag: "Stderr";
+    readonly text: string;
+} | {
+    readonly _tag: "Stdout";
+    readonly text: string;
+}, InvalidOptions | import("./errors.js").GhError, Gh>;
+export {};