@timmo001/effect-gh 0.1.0-0

package/src/issue.ts

@@ -0,0 +1,94 @@
+import { Effect, Predicate, Schema } from "effect";
+import { Gh, type GhOptions } 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 interface IssueSummary extends Schema.Schema.Type<typeof IssueSummary> {}
+
+export const Issue = Schema.Struct({
+  ...IssueSummary.fields,
+  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;
+}
+
+export class InvalidInput extends Schema.TaggedError<InvalidInput>()(
+  "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: ListOptions = {},
+  execution?: GhOptions,
+) {
+  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: number | string,
+  options: ViewOptions = {},
+  execution?: GhOptions,
+) {
+  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/src/pull-request.ts

@@ -0,0 +1,144 @@
+import { Effect, Match, Predicate, Schema, Stream } from "effect";
+import { GhDecodeError } from "./errors.js";
+import { Gh, type GhOptions } 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 interface Summary extends Schema.Schema.Type<typeof Summary> {}
+
+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 interface Check extends Schema.Schema.Type<typeof Check> {}
+
+export const ChecksResult = Schema.Struct({
+  checks: Schema.Array(Check),
+  status: Schema.Literals(["success", "failure", "pending"]),
+  exitCode: Schema.Literals([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;
+}
+
+const fields = "number,title,url,state,isDraft,headRefName,headRefOid";
+
+export const list = Effect.fn("PullRequest.list")(function* (
+  options: ListOptions,
+) {
+  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: number | string,
+  options: 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: number | string,
+  options: ChecksOptions,
+) {
+  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" as const),
+      Match.when(1, () => "failure" as const),
+      Match.when(0, () => "success" as const),
+      Match.exhaustive,
+    ),
+    exitCode,
+  });
+});

package/src/repository.ts

@@ -0,0 +1,30 @@
+import { Effect, Schema } from "effect";
+import { Gh, type GhOptions } 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,
+});
+
+export interface Repository extends Schema.Schema.Type<typeof Repository> {}
+
+/** View [HOST/]OWNER/REPO, or the repository selected by the working directory. */
+export const view = Effect.fn("Repository.view")(function* (
+  repo?: string,
+  options?: GhOptions,
+) {
+  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/src/workflow.ts

@@ -0,0 +1,198 @@
+import { Effect, Schema, Stream } from "effect";
+import { Gh, type GhOptions } from "./gh.js";
+
+const positiveInteger = Schema.Int.check(Schema.isGreaterThan(0));
+
+const repository = Schema.String.check(
+  Schema.isPattern(
+    /^(?:[a-zA-Z0-9.-]+(?::[0-9]+)?\/)?[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/,
+  ),
+);
+
+export const Run = Schema.Struct({
+  databaseId: positiveInteger,
+  attempt: positiveInteger,
+  headBranch: Schema.NullOr(Schema.String),
+  headSha: Schema.String,
+  status: Schema.String,
+  conclusion: Schema.NullOr(Schema.String),
+  url: Schema.String,
+  workflowName: Schema.NullOr(Schema.String),
+});
+
+export interface Run extends Schema.Schema.Type<typeof Run> {}
+
+const fields = Object.keys(Run.fields).join(",");
+
+const listOptions = Schema.Struct({
+  repo: repository,
+  limit: Schema.optionalKey(positiveInteger),
+  branch: Schema.optionalKey(Schema.NonEmptyString),
+  commit: Schema.optionalKey(Schema.NonEmptyString),
+  workflow: Schema.optionalKey(Schema.NonEmptyString),
+  status: Schema.optionalKey(
+    Schema.Literals([
+      "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> {}
+
+const viewOptions = Schema.Struct({
+  repo: repository,
+  runId: positiveInteger,
+  attempt: Schema.optionalKey(positiveInteger),
+});
+
+export interface ViewOptions extends Schema.Schema.Type<typeof viewOptions> {}
+
+const logsOptions = Schema.Struct({
+  ...viewOptions.fields,
+  failedOnly: Schema.optionalKey(Schema.Boolean),
+  job: Schema.optionalKey(positiveInteger),
+});
+
+export interface LogsOptions extends Schema.Schema.Type<typeof logsOptions> {}
+
+const watchOptions = Schema.Struct({
+  repo: repository,
+  runId: positiveInteger,
+  interval: Schema.optionalKey(positiveInteger),
+});
+
+export interface WatchOptions extends Schema.Schema.Type<typeof watchOptions> {}
+
+export class InvalidOptions extends Schema.TaggedError<InvalidOptions>()(
+  "WorkflowInvalidOptions",
+  { cause: Schema.Defect() },
+) {}
+
+const decodeOptions = Effect.fn("Workflow.decodeOptions")(function* <
+  S extends Schema.Constraint,
+>(schema: S, input: S["Type"]) {
+  return yield* Schema.decodeUnknownEffect(schema)(input).pipe(
+    Effect.mapError((cause) => new InvalidOptions({ cause })),
+  );
+});
+
+/** Fetch at most `limit` recent runs (default 20), without unbounded pagination. */
+export const list = Effect.fn("Workflow.list")(function* (
+  input: ListOptions,
+  options?: GhOptions,
+) {
+  const query = yield* decodeOptions(listOptions, input);
+  const gh = yield* Gh;
+
+  const args = [
+    "run",
+    "list",
+    "--repo",
+    query.repo,
+    "--limit",
+    String(query.limit ?? 20),
+    "--json",
+    fields,
+  ];
+
+  if (query.branch !== undefined) args.push("--branch", query.branch);
+
+  if (query.commit !== undefined) args.push("--commit", query.commit);
+
+  if (query.workflow !== undefined) args.push("--workflow", query.workflow);
+
+  if (query.status !== undefined) args.push("--status", query.status);
+
+  return yield* gh.json(args, Schema.Array(Run), options);
+});
+
+/** View the latest attempt unless an explicit attempt is supplied. */
+export const view = Effect.fn("Workflow.view")(function* (
+  input: ViewOptions,
+  options?: GhOptions,
+) {
+  const query = yield* decodeOptions(viewOptions, input);
+  const gh = yield* Gh;
+
+  const args = [
+    "run",
+    "view",
+    String(query.runId),
+    "--repo",
+    query.repo,
+    "--json",
+    fields,
+  ];
+
+  if (query.attempt !== undefined)
+    args.push("--attempt", String(query.attempt));
+
+  return yield* gh.json(args, Run, options);
+});
+
+/** Fetch full logs or failed steps, optionally for one attempt and job. */
+export const logs = Effect.fn("Workflow.logs")(function* (
+  input: LogsOptions,
+  options?: GhOptions,
+) {
+  const query = yield* decodeOptions(logsOptions, input);
+  const gh = yield* Gh;
+
+  const args = [
+    "run",
+    "view",
+    String(query.runId),
+    "--repo",
+    query.repo,
+    query.failedOnly ? "--log-failed" : "--log",
+  ];
+
+  if (query.attempt !== undefined)
+    args.push("--attempt", String(query.attempt));
+
+  if (query.job !== undefined) args.push("--job", String(query.job));
+
+  return (yield* gh.execute(args, options)).stdout;
+});
+
+/**
+ * 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 const watch = (input: WatchOptions, options?: GhOptions) =>
+  Stream.unwrap(
+    Effect.gen(function* () {
+      const query = yield* decodeOptions(watchOptions, input);
+      const gh = yield* Gh;
+
+      return gh.stream(
+        [
+          "run",
+          "watch",
+          String(query.runId),
+          "--repo",
+          query.repo,
+          "--compact",
+          "--exit-status",
+          "--interval",
+          String(query.interval ?? 3),
+        ],
+        options,
+      );
+    }),
+  );