infraweaver 0.1.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/env.ts

@@ -0,0 +1,84 @@
+/**
+ * Small typed accessors for process env — read once, in one place, instead of
+ * re-implementing the same `process.env.X` guard at every call site. Provider
+ * API-key names live in `models.ts`; the Cloud host/allowlist in
+ * `cloudFetchCore.ts`; this module holds the generic presence/read helpers plus
+ * the shared-temp-dir accessor.
+ */
+
+/** True when `name` is set to a non-empty string. Folds the copy that lived
+ *  privately in agent.ts / apiKeys.ts / byokFallback.ts / vertex.ts. */
+export function hasEnvVar(name: string): boolean {
+  const value = process.env[name];
+  return typeof value === "string" && value.length > 0;
+}
+
+/** The trimmed value of `name`, or undefined when unset/blank. */
+export function readEnv(name: string): string | undefined {
+  const value = process.env[name]?.trim();
+  return value && value.length > 0 ? value : undefined;
+}
+
+/** The action's shared temp dir, or undefined outside a Infraweaver action run
+ *  (created by `createTempDirectory()` in setup.ts, which sets INFRAWEAVER_TEMP_DIR). */
+export function readTempDir(): string | undefined {
+  return process.env.INFRAWEAVER_TEMP_DIR || undefined;
+}
+
+/**
+ * The GitHub Actions run context (the `GITHUB_*` env the runner injects), read
+ * through one typed accessor instead of `process.env.GITHUB_*` at ~30 sites.
+ * Every field is optional — the vars are absent outside a GHA runner (local dev,
+ * the stdio server), and callers already treat them as best-effort metadata.
+ */
+export type GitHubContext = {
+  /** `owner/repo`. */
+  repository: string | undefined;
+  /** the commit SHA under test. */
+  sha: string | undefined;
+  /** the short branch/tag name (`GITHUB_REF_NAME`). */
+  refName: string | undefined;
+  /** the full ref (`refs/heads/…`). */
+  ref: string | undefined;
+  runId: string | undefined;
+  runNumber: string | undefined;
+  eventName: string | undefined;
+  actor: string | undefined;
+  workflow: string | undefined;
+  serverUrl: string | undefined;
+  workspace: string | undefined;
+};
+
+export function githubContext(): GitHubContext {
+  return {
+    repository: readEnv("GITHUB_REPOSITORY"),
+    sha: readEnv("GITHUB_SHA"),
+    refName: readEnv("GITHUB_REF_NAME"),
+    ref: readEnv("GITHUB_REF"),
+    runId: readEnv("GITHUB_RUN_ID"),
+    runNumber: readEnv("GITHUB_RUN_NUMBER"),
+    eventName: readEnv("GITHUB_EVENT_NAME"),
+    actor: readEnv("GITHUB_ACTOR"),
+    workflow: readEnv("GITHUB_WORKFLOW"),
+    serverUrl: readEnv("GITHUB_SERVER_URL"),
+    workspace: readEnv("GITHUB_WORKSPACE"),
+  };
+}
+
+/**
+ * The action's shared temp dir, throwing when it isn't set — the single home for
+ * the guard that ~9 call sites previously re-implemented with drifting messages.
+ * Pass `context` (a tool name) to keep the "must run in infraweaver action context"
+ * hint the checkout/commit tools surfaced.
+ */
+export function getTempDir(context?: string): string {
+  const tempDir = readTempDir();
+  if (!tempDir) {
+    throw new Error(
+      context
+        ? `INFRAWEAVER_TEMP_DIR not set - ${context} must run in infraweaver action context`
+        : "INFRAWEAVER_TEMP_DIR not set",
+    );
+  }
+  return tempDir;
+}

package/src/utils/errorReport.ts

@@ -0,0 +1,94 @@
+import { chromeStrings } from "#app/i18n/scaffolding";
+import type { ToolState } from "#app/toolState";
+import { getApiUrl } from "#app/utils/apiUrl";
+import { buildInfraweaverFooter } from "#app/utils/buildInfraweaverFooter";
+import { log } from "#app/utils/cli";
+import { createOctokit, parseRepoContext } from "#app/utils/github";
+import { updateProgressComment } from "#app/utils/progressComment";
+import {
+  getGitHubInstallationToken,
+  getMcpTokenRefresh,
+} 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(),
+    getMcpTokenRefresh(),
+  );
+  const runId = process.env.GITHUB_RUN_ID
+    ? Number.parseInt(process.env.GITHUB_RUN_ID, 10)
+    : undefined;
+
+  const customParts: string[] = [];
+  if (runId) {
+    const apiUrl = getApiUrl();
+    const label = chromeStrings(ctx.toolState.language).rerunFailedJob;
+    customParts.push(
+      `[${label} ➔](${apiUrl}/trigger/${repoContext.owner}/${repoContext.name}/${runId}?action=rerun)`,
+    );
+  }
+
+  const footer = buildInfraweaverFooter({
+    triggeredBy: true,
+    customParts,
+    model: ctx.toolState.model,
+    fallbackFrom: ctx.toolState.modelFallback?.from,
+    language: ctx.toolState.language,
+  });
+
+  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}`);
+}