infraweaver 0.3.7 → 0.3.8

package/src/agents/toolPlaneWatch.ts

@@ -0,0 +1,71 @@
+import { formatMcpToolRef, infraweaverMcpName } from "#app/external";
+
+/**
+ * Notices when the agent has lost the infraweaver tool server, so the run stops
+ * instead of spending its budget without it.
+ *
+ * Every deliverable — the push, the pull request, the review, the final
+ * progress report — goes through that server. Once Claude Code drops it, each
+ * call fails at once with "not connected", and a model told to keep trying
+ * retries in a tight loop until the token quota ends the run: a refactor did
+ * exactly that for 41 minutes and 8.5M tokens.
+ *
+ * One lost call is not enough to stop on: Claude Code reconnects, and a call
+ * that lands mid-reconnect fails the same way. The run stops only after
+ * {@link LOST_CALLS} such failures in a row spanning at least
+ * {@link LOST_WINDOW_MS}, with no infraweaver call succeeding in between.
+ */
+export const LOST_CALLS = 3;
+export const LOST_WINDOW_MS = 30_000;
+
+/** Claude Code's wordings for a call to a server it no longer has. */
+const LOST = new RegExp(
+  [
+    `MCP server ["']${infraweaverMcpName}["'] is not connected`,
+    `MCP server ["']${infraweaverMcpName}["'] has disconnected`,
+    `MCP server ["']${infraweaverMcpName}["'] transport dropped mid-call`,
+    `MCP tool call for ["']${infraweaverMcpName}["'] timed out connecting`,
+  ].join("|"),
+);
+
+const TOOL_PREFIX = formatMcpToolRef("claude", "");
+
+export class ToolPlaneLostError extends Error {
+  constructor(calls: number, seconds: number) {
+    super(
+      `the agent lost the ${infraweaverMcpName} tool server: ${calls} calls in a row over ${seconds}s ` +
+        "failed because it was not connected, so the run was stopped rather than continuing " +
+        "without the tools that deliver its result",
+    );
+    this.name = "ToolPlaneLostError";
+  }
+}
+
+export interface ToolResult {
+  /** the tool that was called, when known. */
+  toolName: string | undefined;
+  isError: boolean;
+  text: string;
+}
+
+export function createToolPlaneWatch(now: () => number = Date.now) {
+  let streak = 0;
+  let since = 0;
+  return {
+    /** Record one tool result; returns the error to stop with once the server is lost. */
+    observe(result: ToolResult): ToolPlaneLostError | null {
+      if (result.isError && LOST.test(result.text)) {
+        if (streak === 0) since = now();
+        streak += 1;
+        const elapsed = now() - since;
+        return streak >= LOST_CALLS && elapsed >= LOST_WINDOW_MS
+          ? new ToolPlaneLostError(streak, Math.round(elapsed / 1000))
+          : null;
+      }
+      if (!result.isError && result.toolName?.startsWith(TOOL_PREFIX)) streak = 0;
+      return null;
+    },
+  };
+}
+
+export type ToolPlaneWatch = ReturnType<typeof createToolPlaneWatch>;

package/src/external.ts

@@ -4,7 +4,9 @@
  * Other files in action/ re-export from this file for backward compatibility.
  */
 
-import type { PullRequest } from "@octokit/webhooks-types";
+import type { components } from "@octokit/openapi-webhooks-types";
+
+type PullRequest = components["schemas"]["pull-request"];
 
 // mcp name constant
 export const infraweaverMcpName = "infraweaver";

package/src/mcp/assess.ts

@@ -20,9 +20,10 @@ import {
   languageOfConcern,
   resolveLanguageScope,
 } from "#app/mcp/terraform/iacLanguages";
+import { count } from "#app/mcp/terraform/prose";
 import { runScannersCached } from "#app/mcp/terraform/scannerCache";
 import { attachSourceSnippets } from "#app/mcp/terraform/scanners";
-import { scanSessionOf } from "#app/mcp/terraform/scanSession";
+import { recordScanConcerns, scanSessionOf } from "#app/mcp/terraform/scanSession";
 import { suppressConcerns } from "#app/mcp/terraform/suppressions";
 import {
   type Concern,
@@ -290,21 +291,20 @@ const BANNER_RECONCILE =
  */
 function renderSeverityBanner(s: AssessmentScorecard): string {
   const highBand = s.by_severity.critical + s.by_severity.high;
-  const plural = (n: number) => (n === 1 ? "" : "s");
   switch (s.posture) {
     case "clean":
       return "> [!NOTE]\n> ✅ **0 concerns found** at the configured threshold.";
     case "advisory":
       return (
         "> [!WARNING]\n" +
-        `> ⚠️ **${s.total} concern${plural(s.total)} found** — none critical/high. ` +
+        `> ⚠️ **${count(s.total, "concern")} found** — none critical/high. ` +
         "Plan to address them.\n>\n" +
         `> ${BANNER_RECONCILE}`
       );
     default:
       return (
         "> [!CAUTION]\n" +
-        `> 🚨 **${highBand} critical/high concern${plural(highBand)} found** ` +
+        `> 🚨 **${count(highBand, "critical/high concern")} found** ` +
         `(${s.total} open in total). Review before relying on this Terraform.\n>\n` +
         `> ${BANNER_RECONCILE}`
       );
@@ -449,9 +449,7 @@ export function renderAssessmentMarkdown(
     .filter((sev) => s.by_severity[sev] > 0)
     .map((sev) => `\`${sev}: ${s.by_severity[sev]}\``);
   lines.push(
-    `**${s.total} concern${s.total === 1 ? "" : "s"}** — ${
-      sevCells.length ? sevCells.join(" · ") : "none"
-    }`,
+    `**${count(s.total, "concern")}** — ${sevCells.length ? sevCells.join(" · ") : "none"}`,
   );
   if (ctx.delta) {
     lines.push("");
@@ -624,6 +622,8 @@ export async function runAssessmentPipeline(
     // the SAME threshold everywhere a scan happens. A verifier running on a
     // different one would report a finding resolved because the knob moved.
     repeatedLiteralThreshold: ctx.payload.repeatedLiteralThreshold,
+    // and the same variable files, which decide what trivy and checkov see
+    varFiles: ctx.payload.varFiles,
   });
   // Re-check the scope against what ACTUALLY ran: a language whose only covering
   // scanner was skipped/disabled this run must report as a coverage gap, never
@@ -716,7 +716,7 @@ export function TerraformAssessTool(ctx: LocalToolContext) {
       // so finalizeSuccessRun's emitFindingsOutputs + reportToCloud fire — assess IS
       // the report path, but lastScanConcerns was only ever set by terraform_scan
       // (Remediate), so Cloud reporting silently no-opped in Assess.
-      scanSessionOf(ctx.toolState).lastScanConcerns = concerns;
+      recordScanConcerns(scanSessionOf(ctx.toolState), concerns);
       const markdown = renderAssessmentMarkdown(scorecard, { delta });
 
       const ran = outcomes.filter((o) => o.ran).map((o) => o.source);

package/src/mcp/baseBranch.ts

@@ -0,0 +1,96 @@
+import { $ } from "@infraweaver-io/sandbox/shell";
+import type { ToolState } from "#app/toolState";
+import type { RunContextData } from "#app/utils/cloud/runContextData";
+import type { ResolvedPayload } from "#app/utils/config/payload";
+
+/**
+ * The branch a run's change is proposed into. Its own module because three
+ * places need the same answer and must never disagree: the PR tools (where the
+ * PR goes), `terraform_change_summary` (what the change is measured against)
+ * and the push guardrail that refuses a change an open PR already proposes.
+ */
+
+/**
+ * The slice `resolveBaseBranch` reads: the declared base-branch input, the
+ * branch the run started on and the repository's default branch.
+ */
+export interface BaseBranchContext {
+  payload: ResolvedPayload;
+  repo: RunContextData["repo"];
+  toolState: Pick<ToolState, "initialHead">;
+}
+
+/**
+ * Pure base-branch picker. Precedence: an explicit `base_branch` declaration
+ * always wins; then the branch the run started on, so a run dispatched on
+ * `develop` proposes into `develop`; then 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;
+  startBranch?: string | undefined;
+  defaultBranch?: string | undefined;
+  mainExists: boolean;
+  masterExists: boolean;
+}): string {
+  if (opts.declared) return opts.declared;
+  if (opts.startBranch) return opts.startBranch;
+  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;
+}
+
+/**
+ * The branch the run started on, while HEAD is somewhere else. A run that is
+ * still on its starting branch is proposing or summarising that branch itself,
+ * so it cannot be the base; the run started detached (a pull request's merge
+ * ref) has no branch to offer.
+ */
+function startBranchOf(ctx: BaseBranchContext): string | undefined {
+  const head = ctx.toolState.initialHead;
+  if (head?.kind !== "branch") return undefined;
+  let current: string;
+  try {
+    current = $("git", ["rev-parse", "--abbrev-ref", "HEAD"], { log: false });
+  } catch {
+    return undefined;
+  }
+  return current === head.name ? undefined : head.name;
+}
+
+/**
+ * Deterministically resolve the branch a PR targets, so the base is never left
+ * to the agent's guess: the `base_branch` input, else the branch the run
+ * started on, else the repository's default branch (`main`, or `master`). Git
+ * is only probed for main/master in the last-resort case where none of those is
+ * available (essentially never).
+ */
+export function resolveBaseBranch(ctx: BaseBranchContext): string {
+  const declared = ctx.payload.baseBranch?.trim() || undefined;
+  const startBranch = declared ? undefined : startBranchOf(ctx);
+  const defaultBranch = ctx.repo.data.default_branch?.trim() || undefined;
+  const needsProbe = !declared && !startBranch && !defaultBranch;
+  return pickBaseBranch({
+    declared,
+    startBranch,
+    defaultBranch,
+    mainExists: needsProbe && branchExists("main"),
+    masterExists: needsProbe && branchExists("master"),
+  });
+}

package/src/mcp/changeSummary.ts

@@ -1,10 +1,11 @@
 import { $ } from "@infraweaver-io/sandbox/shell";
 import { type } from "arktype";
-import type { BaseBranchContext } from "#app/mcp/pr";
-import { resolveBaseBranch } from "#app/mcp/pr";
+import type { BaseBranchContext } from "#app/mcp/baseBranch";
+import { resolveBaseBranch } from "#app/mcp/baseBranch";
 import { execute, tool, toolOk } from "#app/mcp/shared";
 import { skipResult } from "#app/mcp/terraform/types";
 import { log } from "#app/utils/cli";
+import { parseDiffLines } from "#app/utils/unifiedDiff";
 
 /**
  * AI PR summaries — the deterministic Terraform-change anchor. A PR summary
@@ -71,19 +72,17 @@ export function summarizeTerraformResourceDiff(diff: string): TerraformChangeSum
   const files = new Set<string>();
   let file = "";
   let inTf = false;
-  for (const raw of diff.split("\n")) {
-    if (raw.startsWith("+++ ")) {
-      const path = raw.slice(4).trim().replace(/^b\//, "");
-      file = path === "/dev/null" ? "" : path;
+  for (const line of parseDiffLines(diff)) {
+    if (line.kind === "file") {
+      file = line.path === "/dev/null" ? "" : line.path;
       inTf = !!file && isTfFile(file);
       continue;
     }
-    if (raw.startsWith("--- ") || raw.startsWith("diff --git") || raw.startsWith("@@")) continue;
     if (!inTf) continue;
-    if (raw.startsWith("+") || raw.startsWith("-")) {
+    if (line.kind === "add" || line.kind === "remove") {
       files.add(file);
-      const addr = parseBlockAddress(raw.slice(1));
-      if (addr) (raw.startsWith("+") ? added : removed).add(addr);
+      const addr = parseBlockAddress(line.text);
+      if (addr) (line.kind === "add" ? added : removed).add(addr);
     }
   }
   const sort = (s: Set<string>): string[] => [...s].sort();
@@ -97,7 +96,7 @@ export function summarizeTerraformResourceDiff(diff: string): TerraformChangeSum
 
 const TerraformChangeSummaryParams = type({
   "base?": type.string.describe(
-    "base branch to diff against (default: the run's resolved base branch — main/master or the base_branch input).",
+    "base branch to diff against (default: the run's resolved base branch — the base_branch input, else the branch the run started on, else main/master).",
   ),
 });
 

package/src/mcp/checkSuite.ts

@@ -1,5 +1,6 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { stripVTControlCharacters } from "node:util";
 import { type } from "arktype";
 import type { GitHubToolContext } from "#app/mcp/capabilityContext";
 import { execute, tool } from "#app/mcp/shared";
@@ -29,8 +30,7 @@ type LogAnalysis = {
 };
 
 export function analyzeLog(logs: string, excerptLines = 80): LogAnalysis {
-  // biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI escape codes use control chars
-  const clean = logs.replace(/\x1b\[[0-9;]*m/g, "");
+  const clean = stripVTControlCharacters(logs);
   const lines = clean.split("\n");
   const totalLines = lines.length;
 
@@ -192,19 +192,16 @@ export function GetCheckSuiteLogsTool(ctx: GitHubToolContext) {
         failedJobs,
         LOG_FETCH_CONCURRENCY,
         async (job): Promise<JobLogResult> => {
-          const logsResponse = await ctx.octokit.rest.actions.downloadJobLogsForWorkflowRun({
+          // the endpoint 302s to the log blob; Octokit follows it and returns the
+          // body — a string for a text/* content type, an ArrayBuffer otherwise.
+          const { data } = await ctx.octokit.rest.actions.downloadJobLogsForWorkflowRun({
             owner: ctx.repo.owner,
             repo: ctx.repo.name,
             job_id: job.id,
             request: { signal: AbortSignal.timeout(10_000) },
           });
-
-          const logsUrl = logsResponse.url;
-          const logsResult = await fetch(logsUrl, { signal: AbortSignal.timeout(10_000) });
-          if (!logsResult.ok) {
-            throw new Error(`failed to fetch logs: ${logsResult.status} ${logsResult.statusText}`);
-          }
-          const logsText = await logsResult.text();
+          const logsText =
+            typeof data === "string" ? data : Buffer.from(data as ArrayBuffer).toString("utf8");
 
           // write full log to disk
           const logPath = join(logsDir, `job-${job.id}.log`);

package/src/mcp/checkout.ts

@@ -18,6 +18,7 @@ import { getTempDir } from "#app/utils/env";
 import { computeIncrementalDiff } from "#app/utils/github/rangeDiff";
 import { createChangeImpactArtifact } from "#app/utils/prompt/changeImpact";
 import { executeLifecycleHook } from "#app/utils/run/lifecycle";
+import { parseDiffLines } from "#app/utils/unifiedDiff";
 
 /**
  * checkout_pr genuinely spans two capabilities: it reads the PR + its files over
@@ -78,46 +79,19 @@ export function formatFilesWithLineNumbers(files: PullFile[]): FormatFilesResult
       continue;
     }
 
-    // parse and format the patch with line numbers
-    const lines = file.patch.split("\n");
-    let oldLine = 0;
-    let newLine = 0;
-
-    for (const line of lines) {
-      // hunk header: @@ -OLD,COUNT +NEW,COUNT @@ optional context
-      const hunkMatch = line.match(/^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
-      if (hunkMatch) {
-        oldLine = parseInt(hunkMatch[1]!, 10);
-        newLine = parseInt(hunkMatch[2]!, 10);
-        output.push(line); // pass through unchanged
-        currentLine++;
-        continue;
-      }
-
-      // code lines within hunks
-      const changeType = line[0] || " ";
-      const code = line.slice(1);
-
-      if (changeType === "-") {
+    // format the patch with line numbers
+    for (const line of parseDiffLines(file.patch)) {
+      if (line.kind === "remove") {
         // removed line: show old line number, no new line number
-        output.push(`| ${padNum(oldLine)} |      | - | ${code}`);
-        oldLine++;
-      } else if (changeType === "+") {
+        output.push(`| ${padNum(line.oldLine)} |      | - | ${line.text}`);
+      } else if (line.kind === "add") {
         // added line: no old line number, show new line number
-        output.push(`|      | ${padNum(newLine)} | + | ${code}`);
-        newLine++;
-      } else if (changeType === " " || changeType === "\\") {
-        // context line or ""
-        if (changeType === "\\") {
-          output.push(line); // pass through as-is
-        } else {
-          output.push(`| ${padNum(oldLine)} | ${padNum(newLine)} |   | ${code}`);
-          oldLine++;
-          newLine++;
-        }
+        output.push(`|      | ${padNum(line.newLine)} | + | ${line.text}`);
+      } else if (line.kind === "context") {
+        output.push(`| ${padNum(line.oldLine)} | ${padNum(line.newLine)} |   | ${line.text}`);
       } else {
-        // unknown line type, pass through
-        output.push(line);
+        // hunk header, "" or unknown: pass through unchanged
+        output.push(line.raw);
       }
       currentLine++;
     }
@@ -481,7 +455,7 @@ export async function checkoutPrBranch(
           // dispatched on. if it's been closed/merged or the head SHA moved,
           // no amount of retrying will populate the expected ref — surface a
           // clean abort error instead of burning the full retry budget.
-          const msg = e instanceof Error ? e.message : String(e);
+          const msg = errorMessage(e);
           if (PULL_REF_MISSING_PATTERN.test(msg)) {
             await abortIfPullRequestMoved({ octokit, owner, repo: name, pr });
           }
@@ -491,8 +465,7 @@ export async function checkoutPrBranch(
       {
         delaysMs: PULL_REF_RETRY_DELAYS_MS,
         label: `pull/${pr.number}/head fetch`,
-        shouldRetry: (e) =>
-          PULL_REF_MISSING_PATTERN.test(e instanceof Error ? e.message : String(e)),
+        shouldRetry: (e) => PULL_REF_MISSING_PATTERN.test(errorMessage(e)),
       },
     );
 

package/src/mcp/crosswalk.ts

@@ -960,6 +960,11 @@ export function mapConcernToControls(concern: {
   category?: string;
 }): { themes: string[]; controls: ControlRef[] } {
   assertCrosswalkIntegrity();
+  // A style finding is about the form of the code, and no control framework has
+  // anything to say about it. Its evidence can still quote the code — a
+  // repeated literal that happens to be `0.0.0.0/0` — so it must not reach the
+  // signal match at all.
+  if (concern.category === "style") return { themes: [], controls: [] };
   const haystack = `${concern.rule_id} ${concern.evidence}`.toLowerCase();
   const locked = THEME_LOCKED.get(bareRuleId(concern.rule_id));
   const themes: string[] = [];

package/src/mcp/findingAudit.ts

@@ -294,7 +294,7 @@ function severityMarker(severity: Severity): "🚨" | "⚠️" | "ℹ️" {
 const LEADING_MARKER = /^(\s*)(🚨|⚠️|⚠|ℹ️|ℹ)️?\s*/u;
 
 /** The severity marker a comment body opens with, if any. */
-function leadingMarker(body: string): string | null {
+export function leadingMarker(body: string): string | null {
   return LEADING_MARKER.exec(body)?.[2] ?? null;
 }
 

package/src/mcp/git.ts

@@ -19,6 +19,8 @@ import {
   assertThirdPartyAdoptionOptIn,
   enforceProtectedPaths,
   enforceRemediationPaths,
+  isBranchPerChangeMode,
+  isGuardedModeName,
   withChangedFilesMemo,
 } from "#app/mcp/guardrails";
 import { execute, tool } from "#app/mcp/shared";
@@ -302,7 +304,7 @@ async function pushWithRetry(
       return;
     } catch (err) {
       lastErr = err;
-      const msg = err instanceof Error ? err.message : String(err);
+      const msg = errorMessage(err);
       const kind = classifyPushError(msg);
 
       // last attempt, or a non-retryable error (concurrent-push / unknown /
@@ -411,6 +413,17 @@ export function PushBranchTool(ctx: GitToolContext) {
       // can't slip past the default-branch guard below.
       rejectSpecialRef(branch, "branch");
 
+      // every guardrail below judges HEAD, so a write mode pushes the branch it
+      // checked: naming another one would push commits nothing here inspected.
+      if (branchName && isGuardedModeName(ctx.toolState.selectedMode)) {
+        const current = $("git", ["rev-parse", "--abbrev-ref", "HEAD"], { log: false });
+        if (current !== branchName) {
+          throw new Error(
+            `push blocked: '${branchName}' is not the checked-out branch ('${current}'). In this mode push_branch pushes the current branch, because that is what the guardrails check — check out '${branchName}' first, or omit branchName.`,
+          );
+        }
+      }
+
       // reject push if working tree is dirty — forces agent to commit or discard before pushing
       const status = $("git", ["status", "--porcelain"], { log: false });
       if (status) {
@@ -526,6 +539,19 @@ export function PushBranchTool(ctx: GitToolContext) {
         );
       }
 
+      // git never rejects a force push, so the another-change check after the
+      // push never sees one: refuse up front to overwrite a branch this run
+      // did not push.
+      if (
+        force &&
+        isBranchPerChangeMode(ctx.toolState.selectedMode) &&
+        !ctx.toolState.pushedHeads?.has(pushDest.remoteBranch)
+      ) {
+        throw new Error(
+          `push blocked: force-pushing '${pushDest.remoteBranch}' would overwrite a branch this run did not push — if it exists, it belongs to another change. Push this change to a NEW branch name, without force.`,
+        );
+      }
+
       // use refspec when local and remote branch names differ
       const refspec =
         branch === pushDest.remoteBranch ? branch : `${branch}:${pushDest.remoteBranch}`;
@@ -580,8 +606,22 @@ export function PushBranchTool(ctx: GitToolContext) {
           ctx.refreshGitToken,
         );
       } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
+        const msg = errorMessage(err);
         if (classifyPushError(msg) === "concurrent-push") {
+          // In a mode that names a fresh branch per change, a remote branch this
+          // run never pushed is another change's branch, not a concurrent push
+          // of this one: integrating it would fold two changes into one PR, and
+          // adopting it would propose work this run never checked. Remediate
+          // names its branch after the concern group, and a re-run updates it.
+          if (
+            isBranchPerChangeMode(ctx.toolState.selectedMode) &&
+            !ctx.toolState.pushedHeads?.has(pushDest.remoteBranch)
+          ) {
+            throw new Error(
+              `push rejected: a branch named '${pushDest.remoteBranch}' already exists on the remote, and this run did not push it — it belongs to another change (an earlier run's, or a person's).\n\n` +
+                `do not fetch, merge, rebase onto or check out that branch. create a NEW branch name for this change from your current commit (git({ command: "checkout", args: ["-b", "${pushDest.remoteBranch}-2"] })) and push_branch again.`,
+            );
+          }
           // git rebase is blocked through the MCP tool when shell is disabled
           // (rebase --exec can execute arbitrary code). merge always works and
           // integrates remote changes cleanly, so suggest it as the default.
@@ -602,6 +642,8 @@ export function PushBranchTool(ctx: GitToolContext) {
       }
 
       const pushedSha = $("git", ["rev-parse", "HEAD"], { log: false }).trim();
+      ctx.toolState.pushedHeads ??= new Map();
+      ctx.toolState.pushedHeads.set(pushDest.remoteBranch, pushedSha);
       log.info(
         `» pushed branch ${branch} to ${pushDest.remoteName}/${pushDest.remoteBranch} (sha ${pushedSha})`,
       );