terramend 0.2.0

package/src/utils/diffCoverage.ts

@@ -0,0 +1,404 @@
+import { isAbsolute, normalize, resolve } from "node:path";
+
+export type DiffLineRange = {
+  startLine: number;
+  endLine: number;
+};
+
+export type DiffTocEntry = {
+  filename: string;
+  startLine: number;
+  endLine: number;
+};
+
+export type DiffCoverageFileBreakdown = {
+  filename: string;
+  startLine: number;
+  endLine: number;
+  totalLines: number;
+  coveredLines: number;
+  coveredRanges: DiffLineRange[];
+  unreadRanges: DiffLineRange[];
+};
+
+export type DiffCoverageBreakdown = {
+  totalLines: number;
+  coveredLines: number;
+  unreadLines: number;
+  coveragePercent: number;
+  coveredRanges: DiffLineRange[];
+  unreadRanges: DiffLineRange[];
+  files: DiffCoverageFileBreakdown[];
+};
+
+export type DiffCoverageState = {
+  diffPath: string;
+  totalLines: number;
+  tocEntries: DiffTocEntry[];
+  coveredRanges: DiffLineRange[];
+  coveragePreflightRan: boolean;
+  lastBreakdown?: string | undefined;
+};
+
+type ReadTarget = {
+  path: string;
+  offset?: number | undefined;
+  limit?: number | undefined;
+  startLine?: number | undefined;
+  endLine?: number | undefined;
+};
+
+type OffsetBase = "zero" | "one";
+
+export function countLines(params: { content: string }): number {
+  const content = params.content;
+  if (content.length === 0) return 0;
+  return content.split("\n").length;
+}
+
+export function parseDiffTocEntries(params: { toc: string }): DiffTocEntry[] {
+  const lines = params.toc.split("\n");
+  const entries: DiffTocEntry[] = [];
+  // production TOC lines (see formatFilesWithLineNumbers in checkout.ts) append
+  // ` · diff-<sha256>` so the agent has the GitHub "Files Changed" anchor
+  // precomputed. accept that suffix optionally so we also parse the shorter
+  // shape used in tests and in reviewComments.
+  for (const line of lines) {
+    const match = line.match(/^- (.+) (?:→|->) lines (\d+)-(\d+)(?: · diff-[0-9a-f]+)?$/);
+    if (!match) continue;
+    const startLine = Number.parseInt(match[2]!, 10);
+    const endLine = Number.parseInt(match[3]!, 10);
+    if (!Number.isFinite(startLine) || !Number.isFinite(endLine)) continue;
+    entries.push({ filename: match[1]!, startLine, endLine });
+  }
+  return entries;
+}
+
+export function createDiffCoverageState(params: {
+  diffPath: string;
+  totalLines: number;
+  toc: string;
+  previous?: DiffCoverageState | undefined;
+}): DiffCoverageState {
+  return {
+    diffPath: params.diffPath,
+    totalLines: params.totalLines,
+    tocEntries: parseDiffTocEntries({ toc: params.toc }),
+    coveredRanges: [],
+    // carry forward across checkout_pr refreshes so the nudge stays "once per
+    // review session". coveredRanges are intentionally not carried because
+    // line numbers are tied to the previous diff's content.
+    coveragePreflightRan: params.previous?.coveragePreflightRan ?? false,
+  };
+}
+
+export function recordDiffReadFromToolUse(params: {
+  state: DiffCoverageState | undefined;
+  toolName: string;
+  input: unknown;
+  cwd: string;
+}): boolean {
+  const state = params.state;
+  if (!state) return false;
+  if (!isReadTool(params.toolName)) return false;
+  const readTarget = extractReadTarget({ input: params.input });
+  if (!readTarget) return false;
+
+  const normalizedReadPath = normalizePath({ path: readTarget.path, cwd: params.cwd });
+  const normalizedDiffPath = normalize(state.diffPath);
+  if (normalizedReadPath !== normalizedDiffPath) return false;
+
+  const range = resolveReadRange({
+    totalLines: state.totalLines,
+    offset: readTarget.offset,
+    limit: readTarget.limit,
+    startLine: readTarget.startLine,
+    endLine: readTarget.endLine,
+    offsetBase: resolveOffsetBase({ toolName: params.toolName }),
+  });
+  if (!range) return false;
+
+  state.coveredRanges = mergeRanges({ ranges: state.coveredRanges, nextRange: range });
+  return true;
+}
+
+export function getDiffCoverageBreakdown(params: {
+  state: DiffCoverageState;
+}): DiffCoverageBreakdown {
+  const state = params.state;
+  const coveredRanges = mergeRangesList({ ranges: state.coveredRanges });
+  const unreadRanges = invertRanges({ totalLines: state.totalLines, coveredRanges });
+  const coveredLines = countLinesInRanges({ ranges: coveredRanges });
+  const unreadLines = Math.max(0, state.totalLines - coveredLines);
+  const coveragePercent = state.totalLines
+    ? Number(((coveredLines / state.totalLines) * 100).toFixed(2))
+    : 100;
+
+  const files: DiffCoverageFileBreakdown[] = [];
+  for (const entry of state.tocEntries) {
+    const fileRange: DiffLineRange = { startLine: entry.startLine, endLine: entry.endLine };
+    const coveredInFile = intersectRangesWithRange({ ranges: coveredRanges, target: fileRange });
+    const unreadInFile = intersectRangesWithRange({ ranges: unreadRanges, target: fileRange });
+    const totalFileLines = Math.max(0, entry.endLine - entry.startLine + 1);
+    const fileCoveredLines = countLinesInRanges({ ranges: coveredInFile });
+    files.push({
+      filename: entry.filename,
+      startLine: entry.startLine,
+      endLine: entry.endLine,
+      totalLines: totalFileLines,
+      coveredLines: fileCoveredLines,
+      coveredRanges: coveredInFile,
+      unreadRanges: unreadInFile,
+    });
+  }
+
+  return {
+    totalLines: state.totalLines,
+    coveredLines,
+    unreadLines,
+    coveragePercent,
+    coveredRanges,
+    unreadRanges,
+    files,
+  };
+}
+
+export function renderDiffCoverageBreakdown(params: {
+  diffPath: string;
+  breakdown: DiffCoverageBreakdown;
+}): string {
+  const breakdown = params.breakdown;
+  const lines: string[] = [];
+  lines.push(`diff coverage report for \`${params.diffPath}\``);
+  lines.push(
+    `overall: ${breakdown.coveredLines}/${breakdown.totalLines} lines read (${breakdown.coveragePercent}%), unread: ${breakdown.unreadLines}`,
+  );
+  lines.push(`covered ranges: ${formatRanges({ ranges: breakdown.coveredRanges })}`);
+  lines.push(`unread ranges: ${formatRanges({ ranges: breakdown.unreadRanges })}`);
+  lines.push("");
+  lines.push("per-file TOC coverage:");
+  for (const file of breakdown.files) {
+    const filePercent = file.totalLines
+      ? Number(((file.coveredLines / file.totalLines) * 100).toFixed(2))
+      : 100;
+    lines.push(
+      `- ${file.filename} (toc lines ${file.startLine}-${file.endLine}): ${file.coveredLines}/${file.totalLines} lines read (${filePercent}%)`,
+    );
+    lines.push(`  read: ${formatRanges({ ranges: file.coveredRanges })}`);
+    lines.push(`  unread: ${formatRanges({ ranges: file.unreadRanges })}`);
+  }
+  return lines.join("\n");
+}
+
+function resolveOffsetBase(params: { toolName: string }): OffsetBase {
+  const lower = params.toolName.toLowerCase();
+  if (lower === "readfile" || lower.endsWith(".readfile")) {
+    return "one";
+  }
+  return "zero";
+}
+
+function isReadTool(toolName: string): boolean {
+  const lower = toolName.toLowerCase();
+  if (lower === "read" || lower === "readfile") return true;
+  if (lower.endsWith(".read") || lower.endsWith(".readfile")) return true;
+  return false;
+}
+
+function extractReadTarget(params: { input: unknown }): ReadTarget | null {
+  const inputRecord = asRecord(params.input);
+  if (!inputRecord) return null;
+
+  const direct = extractReadTargetFromRecord({ record: inputRecord });
+  if (direct) return direct;
+
+  const nestedCandidates = [inputRecord.args, inputRecord.params, inputRecord.input];
+  for (const candidate of nestedCandidates) {
+    const nestedRecord = asRecord(candidate);
+    if (!nestedRecord) continue;
+    const nested = extractReadTargetFromRecord({ record: nestedRecord });
+    if (nested) return nested;
+  }
+
+  return null;
+}
+
+function extractReadTargetFromRecord(params: {
+  record: Record<string, unknown>;
+}): ReadTarget | null {
+  const record = params.record;
+  const pathValue =
+    readString({ value: record.path }) ??
+    readString({ value: record.file_path }) ??
+    readString({ value: record.filePath }) ??
+    readString({ value: record.filepath }) ??
+    readString({ value: record.file }) ??
+    readString({ value: record.target_file });
+
+  if (!pathValue) return null;
+
+  const offset = readNumber({ value: record.offset });
+  const limit = readNumber({ value: record.limit });
+  const startLine =
+    readNumber({ value: record.start_line }) ??
+    readNumber({ value: record.startLine }) ??
+    readNumber({ value: record.line_start });
+  const endLine =
+    readNumber({ value: record.end_line }) ??
+    readNumber({ value: record.endLine }) ??
+    readNumber({ value: record.line_end });
+
+  return { path: pathValue, offset, limit, startLine, endLine };
+}
+
+function resolveReadRange(params: {
+  totalLines: number;
+  offset?: number | undefined;
+  limit?: number | undefined;
+  startLine?: number | undefined;
+  endLine?: number | undefined;
+  offsetBase: OffsetBase;
+}): DiffLineRange | null {
+  const totalLines = params.totalLines;
+  if (totalLines <= 0) return null;
+
+  if (params.startLine !== undefined || params.endLine !== undefined) {
+    const rawStart = params.startLine ?? 1;
+    const rawEnd = params.endLine ?? totalLines;
+    const startLine = clampLine({ value: rawStart, totalLines });
+    const endLine = clampLine({ value: rawEnd, totalLines });
+    if (endLine < startLine) return null;
+    return { startLine, endLine };
+  }
+
+  let startLine = 1;
+  if (params.offset !== undefined) {
+    if (params.offset >= 0) {
+      const normalizedOffset =
+        params.offsetBase === "zero" ? params.offset + 1 : params.offset === 0 ? 1 : params.offset;
+      startLine = clampLine({ value: normalizedOffset, totalLines });
+    } else {
+      startLine = clampLine({ value: totalLines + params.offset + 1, totalLines });
+    }
+  }
+
+  let endLine = totalLines;
+  if (params.limit !== undefined) {
+    if (params.limit <= 0) return null;
+    endLine = clampLine({ value: startLine + params.limit - 1, totalLines });
+  }
+
+  if (endLine < startLine) return null;
+  return { startLine, endLine };
+}
+
+function normalizePath(params: { path: string; cwd: string }): string {
+  if (isAbsolute(params.path)) return normalize(params.path);
+  return normalize(resolve(params.cwd, params.path));
+}
+
+function mergeRanges(params: {
+  ranges: DiffLineRange[];
+  nextRange: DiffLineRange;
+}): DiffLineRange[] {
+  return mergeRangesList({ ranges: [...params.ranges, params.nextRange] });
+}
+
+function mergeRangesList(params: { ranges: DiffLineRange[] }): DiffLineRange[] {
+  if (params.ranges.length === 0) return [];
+  const sorted = [...params.ranges].sort((a, b) => a.startLine - b.startLine);
+  const merged: DiffLineRange[] = [];
+  for (const range of sorted) {
+    const last = merged[merged.length - 1];
+    if (!last) {
+      merged.push({ startLine: range.startLine, endLine: range.endLine });
+      continue;
+    }
+    if (range.startLine <= last.endLine + 1) {
+      if (range.endLine > last.endLine) {
+        last.endLine = range.endLine;
+      }
+      continue;
+    }
+    merged.push({ startLine: range.startLine, endLine: range.endLine });
+  }
+  return merged;
+}
+
+function invertRanges(params: {
+  totalLines: number;
+  coveredRanges: DiffLineRange[];
+}): DiffLineRange[] {
+  if (params.totalLines <= 0) return [];
+  if (params.coveredRanges.length === 0) {
+    return [{ startLine: 1, endLine: params.totalLines }];
+  }
+
+  const unread: DiffLineRange[] = [];
+  let cursor = 1;
+  for (const range of params.coveredRanges) {
+    if (cursor < range.startLine) {
+      unread.push({ startLine: cursor, endLine: range.startLine - 1 });
+    }
+    cursor = Math.max(cursor, range.endLine + 1);
+  }
+  if (cursor <= params.totalLines) {
+    unread.push({ startLine: cursor, endLine: params.totalLines });
+  }
+  return unread;
+}
+
+function intersectRangesWithRange(params: {
+  ranges: DiffLineRange[];
+  target: DiffLineRange;
+}): DiffLineRange[] {
+  const intersections: DiffLineRange[] = [];
+  for (const range of params.ranges) {
+    if (range.endLine < params.target.startLine) continue;
+    if (range.startLine > params.target.endLine) continue;
+    const startLine = Math.max(range.startLine, params.target.startLine);
+    const endLine = Math.min(range.endLine, params.target.endLine);
+    if (endLine >= startLine) {
+      intersections.push({ startLine, endLine });
+    }
+  }
+  return intersections;
+}
+
+export function countLinesInRanges(params: { ranges: DiffLineRange[] }): number {
+  let total = 0;
+  for (const range of params.ranges) {
+    total += range.endLine - range.startLine + 1;
+  }
+  return total;
+}
+
+function formatRanges(params: { ranges: DiffLineRange[] }): string {
+  if (params.ranges.length === 0) return "none";
+  return params.ranges.map((range) => `${range.startLine}-${range.endLine}`).join(", ");
+}
+
+function clampLine(params: { value: number; totalLines: number }): number {
+  if (params.value < 1) return 1;
+  if (params.value > params.totalLines) return params.totalLines;
+  return params.value;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return Object.fromEntries(Object.entries(value));
+}
+
+function readString(params: { value: unknown }): string | undefined {
+  if (typeof params.value === "string") return params.value;
+  return undefined;
+}
+
+function readNumber(params: { value: unknown }): number | undefined {
+  if (typeof params.value === "number" && Number.isFinite(params.value)) return params.value;
+  if (typeof params.value === "string") {
+    const parsed = Number.parseInt(params.value, 10);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return undefined;
+}

package/src/utils/errorReport.test.ts

@@ -0,0 +1,135 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { ToolState } from "#app/toolState";
+import { reportErrorToComment } from "#app/utils/errorReport";
+import { updateProgressComment } from "#app/utils/progressComment";
+
+const createComment = vi.hoisted(() => vi.fn());
+
+vi.mock("#app/utils/github", () => ({
+  parseRepoContext: vi.fn(() => ({ owner: "acme", name: "repo" })),
+  createOctokit: vi.fn(() => ({ rest: { issues: { createComment } } })),
+}));
+
+vi.mock("#app/utils/token", () => ({
+  getGitHubInstallationToken: vi.fn(() => "installation-token"),
+}));
+
+vi.mock("#app/utils/progressComment", () => ({
+  updateProgressComment: vi.fn(async () => ({})),
+}));
+
+function makeToolState(overrides: Partial<ToolState> = {}): ToolState {
+  return {
+    prepushFailureCount: 0,
+    backgroundProcesses: new Map(),
+    progressComment: undefined,
+    hadProgressComment: false,
+    usageEntries: [],
+    ...overrides,
+  };
+}
+
+function updatedBody(): string {
+  const call = vi.mocked(updateProgressComment).mock.calls[0];
+  if (!call) throw new Error("expected updateProgressComment to have been called");
+  return call[2];
+}
+
+beforeEach(() => {
+  createComment.mockResolvedValue({ data: { id: 777 } });
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+  vi.unstubAllEnvs();
+});
+
+describe("reportErrorToComment", () => {
+  it("updates an existing progress comment with title, error, and rerun link", async () => {
+    vi.stubEnv("GITHUB_RUN_ID", "12345");
+    const toolState = makeToolState({
+      progressComment: { id: 5, type: "issue" },
+      model: "anthropic/claude-opus-4-7",
+    });
+
+    await reportErrorToComment({ toolState, error: "boom", title: "**Run failed**" });
+
+    expect(updateProgressComment).toHaveBeenCalledTimes(1);
+    const call = vi.mocked(updateProgressComment).mock.calls[0];
+    if (!call) throw new Error("expected updateProgressComment to have been called");
+    expect(call[1]).toEqual({ id: 5, type: "issue" });
+    const body = call[2];
+    expect(body).toContain("**Run failed**\n\nboom");
+    expect(body).toContain("Rerun failed job");
+    expect(body).toContain("/trigger/acme/repo/12345?action=rerun");
+    expect(toolState.wasUpdated).toBe(true);
+    expect(createComment).not.toHaveBeenCalled();
+  });
+
+  it("omits the rerun link and title prefix when GITHUB_RUN_ID / title are absent", async () => {
+    vi.stubEnv("GITHUB_RUN_ID", undefined);
+    const toolState = makeToolState({ progressComment: { id: 9, type: "review" } });
+
+    await reportErrorToComment({ toolState, error: "plain failure" });
+
+    const body = updatedBody();
+    expect(body.startsWith("plain failure")).toBe(true);
+    expect(body).not.toContain("Rerun failed job");
+  });
+
+  it("returns silently when there is no comment and createIfMissing is unset", async () => {
+    const toolState = makeToolState({ issueNumber: 42 });
+
+    await reportErrorToComment({ toolState, error: "boom" });
+
+    expect(updateProgressComment).not.toHaveBeenCalled();
+    expect(createComment).not.toHaveBeenCalled();
+    expect(toolState.wasUpdated).toBeUndefined();
+  });
+
+  it("returns silently when createIfMissing is set but there is no issue number", async () => {
+    const toolState = makeToolState();
+
+    await reportErrorToComment({ toolState, error: "boom", createIfMissing: true });
+
+    expect(createComment).not.toHaveBeenCalled();
+    expect(toolState.wasUpdated).toBeUndefined();
+  });
+
+  it("creates a fresh issue comment for terminal errors on silent triggers", async () => {
+    const toolState = makeToolState({ issueNumber: 42 });
+
+    await reportErrorToComment({ toolState, error: "billing exhausted", createIfMissing: true });
+
+    expect(createComment).toHaveBeenCalledTimes(1);
+    expect(createComment).toHaveBeenCalledWith({
+      owner: "acme",
+      repo: "repo",
+      issue_number: 42,
+      body: expect.stringContaining("billing exhausted"),
+    });
+    expect(toolState.progressComment).toEqual({ id: 777, type: "issue" });
+    expect(toolState.wasUpdated).toBe(true);
+  });
+
+  it("swallows a failed fallback comment create instead of throwing", async () => {
+    createComment.mockRejectedValueOnce(new Error("403 Forbidden"));
+    const toolState = makeToolState({ issueNumber: 42 });
+
+    await expect(
+      reportErrorToComment({ toolState, error: "boom", createIfMissing: true }),
+    ).resolves.toBeUndefined();
+    expect(toolState.wasUpdated).toBeUndefined();
+    expect(toolState.progressComment).toBeUndefined();
+  });
+
+  it("stringifies a non-Error rejection from the fallback create", async () => {
+    createComment.mockRejectedValueOnce("string rejection");
+    const toolState = makeToolState({ issueNumber: 42 });
+
+    await expect(
+      reportErrorToComment({ toolState, error: "boom", createIfMissing: true }),
+    ).resolves.toBeUndefined();
+    expect(toolState.wasUpdated).toBeUndefined();
+  });
+});

package/src/utils/errorReport.ts

@@ -0,0 +1,83 @@
+import type { ToolState } from "#app/toolState";
+import { getApiUrl } from "#app/utils/apiUrl";
+import { buildTerramendFooter } from "#app/utils/buildTerramendFooter";
+import { log } from "#app/utils/cli";
+import { createOctokit, parseRepoContext } from "#app/utils/github";
+import { updateProgressComment } from "#app/utils/progressComment";
+import { getGitHubInstallationToken } from "#app/utils/token";
+
+interface ReportErrorParams {
+  toolState: ToolState;
+  error: string;
+  title?: string;
+  /**
+   * When the run has no pre-existing progress comment to update (silent
+   * IncrementalReview / pull_request_synchronize, mode-less polls), create
+   * a fresh issue comment on `toolState.issueNumber` instead of returning
+   * silently. Used for terminal errors (BillingError, TransientError) where
+   * the GH job summary is the only other surface and most users never open
+   * it. see #775.
+   */
+  createIfMissing?: boolean;
+}
+
+export async function reportErrorToComment(ctx: ReportErrorParams): Promise<void> {
+  const formattedError = ctx.title ? `${ctx.title}\n\n${ctx.error}` : ctx.error;
+
+  const repoContext = parseRepoContext();
+  const octokit = createOctokit(getGitHubInstallationToken());
+  const runId = process.env.GITHUB_RUN_ID
+    ? Number.parseInt(process.env.GITHUB_RUN_ID, 10)
+    : undefined;
+
+  const customParts: string[] = [];
+  if (runId) {
+    const apiUrl = getApiUrl();
+    customParts.push(
+      `[Rerun failed job ➔](${apiUrl}/trigger/${repoContext.owner}/${repoContext.name}/${runId}?action=rerun)`,
+    );
+  }
+
+  const footer = buildTerramendFooter({
+    triggeredBy: true,
+    customParts,
+    model: ctx.toolState.model,
+    fallbackFrom: ctx.toolState.modelFallback?.from,
+  });
+
+  const body = `${formattedError}${footer}`;
+
+  const comment = ctx.toolState.progressComment;
+  if (comment) {
+    await updateProgressComment(
+      { octokit, owner: repoContext.owner, repo: repoContext.name },
+      comment,
+      body,
+    );
+    ctx.toolState.wasUpdated = true;
+    return;
+  }
+
+  // silent triggers (pull_request_synchronize IncrementalReview, etc.)
+  // intentionally have no progress comment. for terminal errors that need
+  // user action — billing exhaustion, transient billing-service outage —
+  // surface a fresh issue comment instead of leaving the GH job summary as
+  // the only signal. see #775.
+  if (!ctx.createIfMissing) return;
+  if (!ctx.toolState.issueNumber) return;
+
+  try {
+    const created = await octokit.rest.issues.createComment({
+      owner: repoContext.owner,
+      repo: repoContext.name,
+      issue_number: ctx.toolState.issueNumber,
+      body,
+    });
+    ctx.toolState.progressComment = { id: created.data.id, type: "issue" };
+    ctx.toolState.wasUpdated = true;
+  } catch (error) {
+    log.warning(
+      `[errorReport] fallback comment create failed: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}

package/src/utils/exitHandler.ts

@@ -0,0 +1,35 @@
+import os from "node:os";
+
+type ExitSignalHandler = (signal: "SIGINT" | "SIGTERM") => void | Promise<void>;
+
+const handlers = new Set<ExitSignalHandler>();
+let installed = false;
+
+/**
+ * Register a handler to run when the process receives SIGINT or SIGTERM.
+ * Returns a dispose function that removes the handler.
+ */
+export function onExitSignal(handler: ExitSignalHandler): () => void {
+  installSignalHandlers();
+  handlers.add(handler);
+  return () => {
+    handlers.delete(handler);
+  };
+}
+
+function installSignalHandlers(): void {
+  if (installed) return;
+  installed = true;
+
+  async function handleSignal(signal: "SIGINT" | "SIGTERM") {
+    await Promise.allSettled([...handlers].map((h) => Promise.try(h, signal)));
+    exitWithSignal(signal);
+  }
+
+  process.on("SIGINT", handleSignal);
+  process.on("SIGTERM", handleSignal);
+}
+
+export function exitWithSignal(signal: "SIGINT" | "SIGTERM") {
+  process.exit(128 + os.constants.signals[signal]);
+}

package/src/utils/fixDoubleEscapedString.ts

@@ -0,0 +1,9 @@
+// LLMs sometimes double-escape JSON strings, producing literal \n \t \"
+// instead of actual newline/tab/quote characters.
+// detected when the string contains literal \n but no actual newlines.
+export function fixDoubleEscapedString(str: string): string {
+  if (!str.includes("\n") && str.includes("\\n")) {
+    return str.replace(/\\n/g, "\n").replace(/\\t/g, "\t").replace(/\\"/g, '"');
+  }
+  return str;
+}

package/src/utils/ghaCore.ts

@@ -0,0 +1,13 @@
+/** stdlib-only GitHub Actions helpers for entryPost.ts (no node_modules). */
+
+export function getState(name: string): string {
+  return process.env[`STATE_${name}`] ?? "";
+}
+
+export function info(message: string): void {
+  console.log(message);
+}
+
+export function warning(message: string): void {
+  console.log(`::warning::${message}`);
+}