infraweaver 0.1.0

package/src/mcp/output.ts

@@ -0,0 +1,71 @@
+import type { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
+import { Ajv } from "ajv";
+import { type } from "arktype";
+import type { ToolContext } from "#app/mcp/server";
+import { execute, tool } from "#app/mcp/shared";
+
+export const SetOutputParams = type({
+  value: type.string.describe("the output value to expose as a GitHub Action output"),
+});
+
+type JsonSchema = Record<string, unknown>;
+
+function jsonSchemaToStandardSchema({
+  $schema: _,
+  ...jsonSchema
+}: JsonSchema): StandardJSONSchemaV1<any> & StandardSchemaV1<any> {
+  const ajv = new Ajv();
+  const validate = ajv.compile(jsonSchema);
+
+  return {
+    "~standard": {
+      version: 1,
+      vendor: "json-schema",
+      jsonSchema: {
+        input: () => jsonSchema,
+        output: () => jsonSchema,
+      },
+      validate(input: unknown) {
+        if (validate(input)) {
+          return { value: input };
+        }
+        return {
+          issues: (validate.errors ?? []).map((err) => ({
+            message: `${err.instancePath || "/"}: ${err.message ?? "validation error"}`,
+            path: err.instancePath ? err.instancePath.split("/").filter(Boolean) : [],
+          })),
+        };
+      },
+    },
+  };
+}
+
+function storeOutput(ctx: ToolContext, value: string) {
+  ctx.toolState.output = value;
+  return { success: true };
+}
+
+export function SetOutputTool(ctx: ToolContext, outputSchema?: JsonSchema) {
+  if (outputSchema) {
+    return tool({
+      mutates: true,
+      name: "set_output",
+      description:
+        "Set the structured action output. You MUST call this tool before finishing — the output is required. Pass the output object directly as the tool arguments (no wrapping needed).",
+      parameters: jsonSchemaToStandardSchema(outputSchema),
+      execute: execute(async (params) => {
+        return storeOutput(ctx, JSON.stringify(params));
+      }),
+    });
+  }
+
+  return tool({
+    name: "set_output",
+    description:
+      "Set the action output. Exposes the value as the 'result' GitHub Action output for downstream workflow steps. Do NOT use this for progress reporting — use report_progress instead.",
+    parameters: SetOutputParams,
+    execute: execute(async (params) => {
+      return storeOutput(ctx, params.value);
+    }),
+  });
+}

package/src/mcp/pathSafety.ts

@@ -0,0 +1,28 @@
+import { isAbsolute, relative, resolve } from "node:path";
+
+/**
+ * Resolve an agent-supplied path against `cwd` and confine it to that workspace.
+ *
+ * Returns the absolute path when it stays inside `cwd`; throws otherwise. Blocks
+ * both `..` traversal and absolute paths that point outside `cwd` (including a
+ * different drive on Windows, where `relative` returns an absolute path).
+ *
+ * Infraweaver treats the agent as semi-trusted (attacker-controlled PR content can
+ * prompt-inject it), so any tool that reads or writes a file path the agent
+ * controls — read_findings, terraform_emit_sarif, terraform_module_interface —
+ * must confine that path to the workspace. Without it the agent has an arbitrary
+ * file read (findings) or write (SARIF) primitive on the runner.
+ */
+export function resolveWithinCwd(cwd: string, userPath: string): string {
+  const base = resolve(cwd);
+  const target = resolve(base, userPath);
+  const rel = relative(base, target);
+  // rel === "" means target IS the workspace root; a child path neither starts
+  // with ".." nor is absolute. Anything else escaped the workspace.
+  if (rel === "" || (!rel.startsWith("..") && !isAbsolute(rel))) {
+    return target;
+  }
+  throw new Error(
+    `path '${userPath}' escapes the workspace; only paths inside the working directory are allowed.`,
+  );
+}

package/src/mcp/policy.ts

@@ -0,0 +1,226 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { type } from "arktype";
+import { resolveWithinCwd } from "#app/mcp/pathSafety";
+import type { LocalToolContext } from "#app/mcp/localContext";
+import { execute, tool, toolOk, toolSkip } from "#app/mcp/shared";
+import { SUBPROCESS_TIMEOUT_MS } from "#app/mcp/terraform/subprocess";
+import { log } from "#app/utils/cli";
+import { resolveEnv } from "#app/utils/secrets";
+
+/**
+ * Policy-as-code gate (OPA/Conftest). An optional, opt-in tool that runs
+ * the operator's own Rego policies against the Terraform plan JSON (or the HCL),
+ * so an org's policy-as-code can gate a remediation/generation the same way the
+ * deterministic scanners do — pairs with prevent recurrence. Infraweaver is
+ * an ORCHESTRATOR here, never a redistributor: it invokes the external
+ * `conftest` (OPA) binary as a separate process and consumes its normalized
+ * output. Degrades green — when conftest isn't installed or no policy dir
+ * exists, it returns `ok: false` with a `code` and never fails the run.
+ *
+ * The parsing is pure + unit-tested; the tool just shells out and parses.
+ */
+
+export interface PolicyFailure {
+  /** the policy rule message (the human-readable violation). */
+  msg: string;
+  /** the file conftest evaluated (repo-relative when conftest reported it). */
+  file: string;
+  /** "failure" (a deny) or "warning" (a warn). */
+  level: "failure" | "warning";
+}
+
+export interface PolicyResult {
+  /** true when there were zero failures (warnings don't fail the gate). */
+  passed: boolean;
+  failures: PolicyFailure[];
+  warnings: PolicyFailure[];
+  /** total tests conftest ran (across files), for a confidence signal. */
+  tested: number;
+}
+
+interface ConftestResultEntry {
+  filename?: string;
+  namespace?: string;
+  successes?: number;
+  failures?: { msg?: string }[];
+  warnings?: { msg?: string }[];
+}
+
+/**
+ * Parse `conftest test --output json` output into a normalized PolicyResult.
+ * Conftest emits an array of per-file result objects, each with `failures` /
+ * `warnings` / `successes`. Pure; tolerant of malformed/empty input (returns a
+ * clean pass). A non-empty `failures` anywhere means the gate did NOT pass;
+ * warnings are surfaced but don't fail it.
+ */
+export function parseConftestOutput(stdout: string): PolicyResult {
+  let parsed: ConftestResultEntry[];
+  try {
+    const raw = JSON.parse(stdout || "[]");
+    parsed = Array.isArray(raw) ? raw : [];
+  } catch {
+    return { passed: true, failures: [], warnings: [], tested: 0 };
+  }
+  const failures: PolicyFailure[] = [];
+  const warnings: PolicyFailure[] = [];
+  let tested = 0;
+  for (const entry of parsed) {
+    const file = entry.filename || "(plan)";
+    const fails = entry.failures ?? [];
+    const warns = entry.warnings ?? [];
+    tested += (entry.successes ?? 0) + fails.length + warns.length;
+    for (const f of fails)
+      failures.push({
+        msg: f.msg || "policy violation",
+        file,
+        level: "failure",
+      });
+    for (const w of warns)
+      warnings.push({ msg: w.msg || "policy warning", file, level: "warning" });
+  }
+  return { passed: failures.length === 0, failures, warnings, tested };
+}
+
+/** the default dirs a repo keeps Rego policies in (checked in order). */
+const DEFAULT_POLICY_DIRS = ["policy", "policies", ".conftest"];
+
+/** resolve the policy dir to use: the explicit arg, else the first default dir
+ * that exists. Returns null when none is found. */
+function resolvePolicyDir(
+  cwd: string,
+  explicit: string | undefined,
+): string | null {
+  if (explicit) {
+    // Confine the agent-supplied dir to the workspace so it can't load Rego from
+    // outside the repo; escape degrades to a skip (same doctrine as the siblings).
+    let abs: string;
+    try {
+      abs = resolveWithinCwd(cwd, explicit);
+    } catch {
+      return null;
+    }
+    return existsSync(abs) ? abs : null;
+  }
+  for (const d of DEFAULT_POLICY_DIRS) {
+    const abs = join(cwd, d);
+    if (existsSync(abs)) return abs;
+  }
+  return null;
+}
+
+export const PolicyCheckParams = type({
+  "target?": type.string.describe(
+    "the file conftest evaluates — a terraform plan JSON (preferred; produce it with `terraform show -json plan.tfplan`) or an HCL file. Default: ./plan.json, then ./tfplan.json, in the workspace.",
+  ),
+  "policy_dir?": type.string.describe(
+    "dir holding the Rego policies. Default: the first of ./policy, ./policies, ./.conftest that exists.",
+  ),
+});
+
+export function PolicyCheckTool(ctx: LocalToolContext) {
+  return tool({
+    name: "policy_check",
+    description:
+      "Run the repo's own policy-as-code (Rego) against the Terraform plan/HCL via the external `conftest` " +
+      "(OPA) binary, so org policy can gate a fix. Opt-in and degrades green — returns `ok: false` " +
+      "(never fails the run) when conftest isn't installed or no policy dir is present. On success returns " +
+      "`passed` (false when any policy DENY fired), the `failures` and `warnings` (each with msg + file), and " +
+      "the count `tested`. When `passed` is false, treat it like a failed validate: fix the violation or " +
+      "label the PR needs-human — do NOT push past a policy denial.",
+    parameters: PolicyCheckParams,
+    execute: execute(async ({ target, policy_dir }) => {
+      const cwd = ctx.payload.cwd ?? process.cwd();
+      const policyDir = resolvePolicyDir(cwd, policy_dir);
+      if (!policyDir) {
+        return toolSkip(
+          "no_policy_dir",
+          "no Rego policy dir found (looked for ./policy, ./policies, ./.conftest, or the policy_dir arg) — policy_check is opt-in",
+        );
+      }
+      // resolve the target file: explicit arg, else a conventional plan JSON.
+      let targetFile: string | null = null;
+      if (target) {
+        // Confine the agent-supplied target to the workspace (see resolvePolicyDir).
+        let abs: string | null = null;
+        try {
+          abs = resolveWithinCwd(cwd, target);
+        } catch {
+          abs = null;
+        }
+        targetFile = abs && existsSync(abs) ? abs : null;
+        if (!targetFile) {
+          return toolSkip(
+            "target_not_found",
+            `policy target '${target}' not found in the workspace`,
+          );
+        }
+      } else {
+        for (const candidate of ["plan.json", "tfplan.json"]) {
+          const abs = join(cwd, candidate);
+          if (existsSync(abs)) {
+            targetFile = abs;
+            break;
+          }
+        }
+        if (!targetFile) {
+          return toolSkip(
+            "no_target",
+            "no plan JSON to evaluate — produce one with `terraform show -json plan.tfplan > plan.json`, or pass `target`",
+          );
+        }
+      }
+      const r = spawnSync(
+        "conftest",
+        ["test", "--output", "json", "-p", policyDir, targetFile],
+        {
+          cwd,
+          encoding: "utf-8",
+          env: resolveEnv("restricted") as NodeJS.ProcessEnv,
+          stdio: ["ignore", "pipe", "pipe"],
+          maxBuffer: 64 * 1024 * 1024,
+          // bound a hung conftest (e.g. a policy that pulls a remote bundle).
+          timeout: SUBPROCESS_TIMEOUT_MS,
+        },
+      );
+      if (r.error && (r.error as NodeJS.ErrnoException).code === "ENOENT") {
+        return toolSkip(
+          "conftest_not_installed",
+          "conftest (OPA) is not installed — policy_check is opt-in and best-effort; install conftest to enable it",
+        );
+      }
+      // conftest exits non-zero when a policy DENY fires — that's a normal
+      // denial (JSON on stdout), not a tool error. But it ALSO exits non-zero
+      // when it couldn't evaluate at all (bad policy, parse error, no tests) —
+      // there it emits nothing parseable. Distinguish: a non-zero exit that
+      // yielded no evaluated tests AND no failures/warnings is a real error, so
+      // report it as a skip rather than a false PASS. A genuine denial has
+      // failures > 0 and flows through to `passed: false`.
+      const result = parseConftestOutput(r.stdout);
+      const evaluated =
+        result.tested > 0 ||
+        result.failures.length > 0 ||
+        result.warnings.length > 0;
+      if (r.status !== 0 && !evaluated) {
+        return toolSkip(
+          "conftest_failed",
+          `conftest could not evaluate the target: ${r.stderr.trim().slice(0, 300) || "unknown error"}`,
+        );
+      }
+      log.info(
+        `» policy_check: ${result.passed ? "PASS" : "FAIL"} — ${result.failures.length} failure(s), ${result.warnings.length} warning(s) over ${result.tested} test(s)`,
+      );
+      return toolOk({
+        passed: result.passed,
+        policy_dir: policyDir,
+        target: targetFile,
+        failure_count: result.failures.length,
+        warning_count: result.warnings.length,
+        failures: result.failures,
+        warnings: result.warnings,
+        tested: result.tested,
+      });
+    }),
+  });
+}

package/src/mcp/pr.ts

@@ -0,0 +1,238 @@
+import { type } from "arktype";
+import type { GitHubWriteToolContext } from "#app/mcp/capabilityContext";
+import {
+  assertUnderOpenPrCaps,
+  assertUnderPrCap,
+  recordRemediationPrOpened,
+} from "#app/mcp/guardrails";
+import { assertTargetInScope, recordCreatedTarget } from "#app/mcp/scope";
+import { execute, tool } from "#app/mcp/shared";
+import {
+  buildInfraweaverFooter,
+  stripExistingFooter,
+} from "#app/utils/buildInfraweaverFooter";
+import { log } from "#app/utils/cli";
+import { fixDoubleEscapedString } from "#app/utils/fixDoubleEscapedString";
+import { patchWorkflowRunFields } from "#app/utils/patchWorkflowRunFields";
+import type { ResolvedPayload } from "#app/utils/payload";
+import { redactSecrets } from "#app/utils/redact";
+import type { RunContextData } from "#app/utils/runContextData";
+import { $ } from "#app/utils/shell";
+
+/**
+ * The slice `resolveBaseBranch` reads: the declared base-branch input and the
+ * repository's default branch. Shared with `terraform_change_summary`, which
+ * resolves the same base without needing the rest of the GitHub surface.
+ */
+export interface BaseBranchContext {
+  payload: ResolvedPayload;
+  repo: RunContextData["repo"];
+}
+
+export const PullRequest = type({
+  title: type.string.describe("the title of the pull request"),
+  body: type.string.describe("the body content of the pull request"),
+  "base?": type.string.describe(
+    "the base branch to merge into (e.g. 'main'). Omit to use the run's resolved base branch: the `base_branch` input, else the repository's default branch (main, or master).",
+  ),
+  "draft?": type.boolean.describe(
+    "if true, create the pull request as a draft. use when the user explicitly asks for a draft PR.",
+  ),
+});
+
+/**
+ * Pure base-branch picker. Precedence: an explicit `base_branch` declaration
+ * always wins; otherwise the repository's default branch (GitHub reports it —
+ * normally `main`, sometimes `master`); otherwise prefer `main`, then `master`;
+ * final fallback `main`. Split out from git/ctx so it's exhaustively testable.
+ */
+export function pickBaseBranch(opts: {
+  declared?: string | undefined;
+  defaultBranch?: string | undefined;
+  mainExists: boolean;
+  masterExists: boolean;
+}): string {
+  if (opts.declared) return opts.declared;
+  if (opts.defaultBranch) return opts.defaultBranch;
+  if (opts.mainExists) return "main";
+  if (opts.masterExists) return "master";
+  return "main";
+}
+
+/** true when `branch` exists as a remote-tracking or local ref. */
+function branchExists(branch: string): boolean {
+  for (const ref of [`refs/remotes/origin/${branch}`, `refs/heads/${branch}`]) {
+    try {
+      $("git", ["rev-parse", "--verify", "--quiet", ref], { log: false });
+      return true;
+    } catch {
+      // ref absent — try the next form
+    }
+  }
+  return false;
+}
+
+/**
+ * Deterministically resolve the branch a PR targets, so the base is never left
+ * to the agent's guess. Resolves to the repository's default branch (`main`, or
+ * `master`), overridable by the `base_branch` input. Git is only probed for
+ * main/master in the last-resort case where neither an explicit declaration nor
+ * a GitHub default branch is available (essentially never).
+ */
+export function resolveBaseBranch(ctx: BaseBranchContext): string {
+  const declared = ctx.payload.baseBranch?.trim() || undefined;
+  const defaultBranch = ctx.repo.data.default_branch?.trim() || undefined;
+  const needsProbe = !declared && !defaultBranch;
+  return pickBaseBranch({
+    declared,
+    defaultBranch,
+    mainExists: needsProbe && branchExists("main"),
+    masterExists: needsProbe && branchExists("master"),
+  });
+}
+
+function buildPrBodyWithFooter(
+  ctx: GitHubWriteToolContext,
+  body: string,
+): string {
+  const footer = buildInfraweaverFooter({
+    triggeredBy: true,
+    model: ctx.toolState.model,
+    fallbackFrom: ctx.toolState.modelFallback?.from,
+    language: ctx.payload.language,
+  });
+
+  const bodyWithoutFooter = stripExistingFooter(fixDoubleEscapedString(body));
+  // LLM02: scrub any secret the agent echoed from a hostile repo before it lands in
+  // a durable, public artifact. redactSecrets is idempotent + a no-op on clean text.
+  return redactSecrets(`${bodyWithoutFooter}${footer}`);
+}
+
+export const UpdatePullRequestBody = type({
+  pull_number: type.number.describe("the pull request number to update"),
+  body: type.string.describe("the new body content for the pull request"),
+});
+
+export function UpdatePullRequestBodyTool(ctx: GitHubWriteToolContext) {
+  return tool({
+    mutates: true,
+    name: "update_pull_request_body",
+    description: "Update the body/description of an existing pull request",
+    parameters: UpdatePullRequestBody,
+    execute: execute(async (params) => {
+      assertTargetInScope(ctx, params.pull_number, "update the body of");
+      const bodyWithFooter = buildPrBodyWithFooter(ctx, params.body);
+
+      const result = await ctx.octokit.rest.pulls.update({
+        owner: ctx.repo.owner,
+        repo: ctx.repo.name,
+        pull_number: params.pull_number,
+        body: bodyWithFooter,
+      });
+      log.info(`» updated pull request #${result.data.number}`);
+
+      ctx.toolState.wasUpdated = true;
+
+      return {
+        success: true,
+        number: result.data.number,
+        url: result.data.html_url,
+      };
+    }),
+  });
+}
+
+export function CreatePullRequestTool(ctx: GitHubWriteToolContext) {
+  return tool({
+    mutates: true,
+    name: "create_pull_request",
+    description: "Create a pull request from the current branch",
+    parameters: PullRequest,
+    execute: execute(async (params) => {
+      // permission gate: opening a PR is a repo write. `push: disabled` means the
+      // repository is configured for read-only access, so block it here the same
+      // way push_branch/create_issue do — an injected or read-only-intended agent
+      // must not be able to open PRs.
+      if (ctx.payload.push === "disabled") {
+        throw new Error(
+          "Creating a pull request is disabled. This repository is configured for read-only access (push: disabled).",
+        );
+      }
+
+      // Remediate-mode guardrail: stop at the configured max_prs. No-op otherwise.
+      assertUnderPrCap(ctx);
+      // Cross-run flood guards: cap simultaneously-open and per-hour remediation
+      // PRs (queries GitHub). Complements the per-run max_prs cap above. No-op
+      // outside guarded mode or when both limits are disabled.
+      await assertUnderOpenPrCaps(ctx);
+
+      const currentBranch = $("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+        log: false,
+      });
+      const base = params.base ?? resolveBaseBranch(ctx);
+      log.debug(`Current branch: ${currentBranch}; PR base: ${base}`);
+
+      const bodyWithFooter = buildPrBodyWithFooter(ctx, params.body);
+
+      const result = await ctx.octokit.rest.pulls.create({
+        owner: ctx.repo.owner,
+        repo: ctx.repo.name,
+        // title bypasses buildPrBodyWithFooter, so redact it on its own (LLM02).
+        title: redactSecrets(params.title),
+        body: bodyWithFooter,
+        head: currentBranch,
+        base,
+        draft: params.draft ?? false,
+      });
+      log.info(
+        `» created pull request #${result.data.number} (id ${result.data.id})`,
+      );
+
+      // record so the agent may update THIS PR's body / comment on it later even
+      // though its number differs from the run's triggering issue_number.
+      recordCreatedTarget(ctx, result.data.number);
+
+      // best-effort: request review from the user who triggered the workflow
+      const reviewer = ctx.payload.triggerer;
+      if (reviewer) {
+        try {
+          log.debug(
+            `requesting review from ${reviewer} on PR #${result.data.number}`,
+          );
+          await ctx.octokit.rest.pulls.requestReviewers({
+            owner: ctx.repo.owner,
+            repo: ctx.repo.name,
+            pull_number: result.data.number,
+            reviewers: [reviewer],
+          });
+        } catch {
+          log.info(
+            `failed to request review from ${reviewer} on PR #${result.data.number}`,
+          );
+        }
+      }
+
+      if (
+        typeof result.data.node_id === "string" &&
+        result.data.node_id.length > 0
+      ) {
+        await patchWorkflowRunFields(ctx, {
+          prNodeId: result.data.node_id,
+        });
+      }
+
+      // count this toward the per-run remediation PR cap (Remediate mode only).
+      recordRemediationPrOpened(ctx);
+
+      return {
+        success: true,
+        pullRequestId: result.data.id,
+        number: result.data.number,
+        url: result.data.html_url,
+        title: result.data.title,
+        head: result.data.head.ref,
+        base: result.data.base.ref,
+      };
+    }),
+  });
+}

package/src/mcp/prInfo.ts

@@ -0,0 +1,91 @@
+import { type } from "arktype";
+import type { GitHubToolContext } from "#app/mcp/capabilityContext";
+import { execute, tool } from "#app/mcp/shared";
+import { resolveBodyAssets } from "#app/utils/body";
+
+const CLOSING_ISSUES_QUERY = `
+query($owner: String!, $repo: String!, $number: Int!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $number) {
+      closingIssuesReferences(first: 10) {
+        nodes { number title }
+      }
+    }
+  }
+}
+`;
+
+type ClosingIssuesResponse = {
+  repository: {
+    pullRequest: {
+      closingIssuesReferences: { nodes: Array<{ number: number; title: string }> };
+    };
+  };
+};
+
+export const PullRequestInfo = type({
+  pull_number: type.number.describe("The pull request number to fetch"),
+});
+
+export function PullRequestInfoTool(ctx: GitHubToolContext) {
+  return tool({
+    name: "get_pull_request",
+    description:
+      "Retrieve PR metadata (title, body, state, branches, author, labels, linked issues). " +
+      "Example: `get_pull_request({ pull_number: 1234 })`. " +
+      "To checkout a PR branch locally, use checkout_pr instead.",
+    parameters: PullRequestInfo,
+    execute: execute(async ({ pull_number }) => {
+      // fetch REST and GraphQL in parallel. the issues.get call is only for body_html
+      // (PRs are issues; the pulls.get response type omits body_html) so attachment urls
+      // resolve to signed CDN urls — see resolveBodyAssets.
+      const [restResponse, issueResponse, graphqlResponse] = await Promise.all([
+        ctx.octokit.rest.pulls.get({
+          owner: ctx.repo.owner,
+          repo: ctx.repo.name,
+          pull_number,
+        }),
+        ctx.octokit.rest.issues.get({
+          owner: ctx.repo.owner,
+          repo: ctx.repo.name,
+          issue_number: pull_number,
+          headers: { accept: "application/vnd.github.full+json" },
+        }),
+        ctx.octokit.graphql<ClosingIssuesResponse>(CLOSING_ISSUES_QUERY, {
+          owner: ctx.repo.owner,
+          repo: ctx.repo.name,
+          number: pull_number,
+        }),
+      ]);
+
+      const data = restResponse.data;
+      const isFork = data.head.repo?.full_name !== data.base.repo.full_name;
+      const closingIssues = graphqlResponse.repository.pullRequest.closingIssuesReferences.nodes;
+
+      const body = await resolveBodyAssets({
+        body: data.body,
+        bodyHtml: issueResponse.data.body_html,
+        tmpdir: ctx.tmpdir,
+        githubToken: ctx.githubInstallationToken,
+      });
+
+      return {
+        number: data.number,
+        url: data.html_url,
+        title: data.title,
+        body: body,
+        state: data.state,
+        draft: data.draft,
+        merged: data.merged,
+        maintainerCanModify: data.maintainer_can_modify,
+        base: data.base.ref,
+        head: data.head.ref,
+        isFork,
+        author: data.user?.login,
+        assignees: data.assignees?.map((a) => a.login),
+        labels: data.labels.map((l) => l.name),
+        closingIssues: closingIssues.map((i) => ({ number: i.number, title: i.title })),
+      };
+    }),
+  });
+}