infraweaver 0.1.0

package/dist/mcp/crosswalk.d.ts

@@ -0,0 +1,178 @@
+import type { LocalToolContext } from "#app/mcp/localContext";
+import type { Concern } from "#app/mcp/terraform/types";
+import { type ConcernVerificationStatus } from "#app/mcp/terraform/verification";
+/**
+ * Compliance crosswalk ("explain like I'm the auditor", the
+ * seed of the moat). Maps a best-practice concern → the control families
+ * it touches across UK public-sector + general frameworks, so a remediation can
+ * be narrated to an assessor in their own language ("this closes NCSC Cloud
+ * Principle 2 / Cyber Essentials Secure Configuration") rather than as a raw
+ * scanner rule id.
+ *
+ * SCOPE / HONESTY: this is a deterministic STARTER rule-pack keyed on the
+ * defect's THEME (encryption, public exposure, least-privilege, logging, …),
+ * not a certified control-by-control mapping. The durable product is a
+ * versioned, framework-revision-pinned crosswalk — so every mapping
+ * carries the pack version + date and is labelled indicative, never an audit
+ * verdict. No open crosswalk to UK frameworks exists; this is the wedge.
+ */
+export declare const CROSSWALK_VERSION = "0.6.0";
+/** the date this rule-pack's framework references were last reviewed (absolute). */
+export declare const CROSSWALK_REVIEWED = "2026-07-26";
+export interface ControlRef {
+    /** the framework, e.g. "NCSC Cloud Security Principles". */
+    framework: string;
+    /** the control id within that framework, e.g. "Principle 2". */
+    control: string;
+    /** the control's short title. */
+    title: string;
+}
+/**
+ * THE HUB TABLE (§5.14 step 2): defect theme → the 800-53 rev 5 controls it
+ * evidences. Hand-curated to the technically-enforceable band an IaC scan can
+ * honestly speak to (crypto, IAM, segmentation, logging, secure-config, backup
+ * topology) — never the organisational/process/physical bands. The theme layer
+ * insulates every downstream framework from an 800-53 rev 6 restructure.
+ */
+export declare const THEME_TO_NIST: Record<string, string[]>;
+/**
+ * The hub-derived control refs for a set of themes: the 800-53 spine controls
+ * (sorted) plus every hub-layer requirement whose anchors intersect those spine
+ * ids. Deterministic + pure. Conservative fan-out is by design — an exposure
+ * finding lights all boundary controls rather than risk a false pass on a
+ * related one.
+ */
+export declare function hubControlsForThemes(themes: string[]): ControlRef[];
+/**
+ * Map a single concern to the indicative control references it touches. Matches
+ * the concern's `rule_id` + `evidence` (and an optional `category`) against the
+ * crosswalk themes; unions the controls of every theme that fires. Pure.
+ * Returns an empty array when nothing matches (honest — better than a forced
+ * mapping). De-duplicates identical control refs.
+ */
+export declare function mapConcernToControls(concern: {
+    rule_id: string;
+    evidence: string;
+    category?: string;
+}): {
+    themes: string[];
+    controls: ControlRef[];
+};
+/** The canonical payload of the curated crosswalk tables + version stamps. Pure. */
+export declare function canonicalCrosswalkPayload(): string;
+/** sha256 (hex) of the canonical crosswalk payload. Pure. */
+export declare function crosswalkDigest(): string;
+/** The digest of the crosswalk actually loaded in this build (computed once). */
+export declare const CROSSWALK_DIGEST: string;
+/**
+ * Fail-closed integrity gate. Throws when the loaded crosswalk doesn't match the
+ * pinned, reviewed digest — so no compliance verdict can be produced from a tampered
+ * or poisoned table. Every verdict-producing entry calls this. The args are injectable
+ * so a test can exercise the mismatch path without corrupting the real module.
+ */
+export declare function assertCrosswalkIntegrity(actual?: string, expected?: string): void;
+/** The maintained-pack control ids a concern's themes evidence (deduped, sorted).
+ *  Empty when nothing maps. Pure. See {@link THEME_TO_PACK_CONTROLS}. */
+export declare function packControlsForThemes(themes: string[]): string[];
+/**
+ * The maintained Cloud-pack control ids a single concern maps to — the values
+ * the cloud report puts in each finding's `compliance[]` so the dashboard's
+ * control verdicts and required-control gate join on real findings. Pure.
+ */
+export declare function packControlsForConcern(concern: {
+    rule_id: string;
+    evidence: string;
+    category?: string;
+}): string[];
+export interface ConcernForCrosswalk {
+    id: string;
+    rule_id: string;
+    evidence: string;
+    category?: string;
+    severity?: string;
+    location?: {
+        file: string;
+        line: number | null;
+    };
+}
+export interface CrosswalkEntry {
+    concern_id: string;
+    rule_id: string;
+    themes: string[];
+    controls: ControlRef[];
+    /** the five-status verdict for this control statement: `fail` (code-verified
+     * violation) or `not-code-verifiable` (a human-decision control the engine can
+     * flag but not prove). Lets an assessor read the crosswalk honestly. */
+    status: ConcernVerificationStatus;
+}
+export interface CrosswalkReport {
+    version: string;
+    reviewed: string;
+    /** per-concern control mappings (only concerns that mapped to ≥1 control). */
+    entries: CrosswalkEntry[];
+    /** framework → the distinct controls this scan touched, for an auditor index. */
+    by_framework: Record<string, {
+        control: string;
+        title: string;
+    }[]>;
+    /** concerns that did not map to any control (honest coverage signal). */
+    unmapped_concern_ids: string[];
+}
+/**
+ * Build the auditor crosswalk for a set of concerns: per-concern control refs
+ * plus a `by_framework` index (which controls this scan touched, deduped) and an
+ * honest `unmapped` list. Pure + deterministic. Carries the pack version + date
+ * so the report is reproducible and clearly indicative.
+ */
+export declare function buildCrosswalkReport(concerns: ConcernForCrosswalk[]): CrosswalkReport;
+/**
+ * The tokens a `required_controls` policy can match a concern on (lower-cased):
+ * each mapped control's framework, control id, `framework|control` key and title,
+ * the defect themes, AND the maintained-pack control ids the concern evidences.
+ * So a policy entry can require a whole framework ("Cyber Essentials"), a single
+ * control ("Secure Configuration" or "Cyber Essentials|Secure Configuration"), a
+ * theme ("encryption-at-rest"), or a Cloud-pack control id ("A2.1") — the last is
+ * what the Cloud "required controls" policy sends down via run-context. Pure.
+ */
+export declare function controlMatchTokens(concern: {
+    rule_id: string;
+    evidence: string;
+    category?: string;
+}): string[];
+/**
+ * The OPEN concerns that map to at least one REQUIRED compliance control — these
+ * fail the CI gate regardless of severity (the 2g-vi "required control" policy:
+ * a CISO marks the controls that MUST stay clean, e.g. encryption-at-rest for
+ * SOC 2). `required` is matched case-insensitively against each concern's
+ * framework / control / `framework|control` / title / theme (see
+ * `controlMatchTokens`). Suppressed (accepted) concerns never count. Pure.
+ */
+export declare function requiredControlViolations(concerns: Concern[], required: string[]): Concern[];
+export declare const ComplianceCrosswalkParams: import("arktype/internal/variants/object.ts").ObjectType<{
+    concerns: {
+        id: string;
+        rule_id: string;
+        evidence: string;
+        category?: string;
+        severity?: string;
+    }[];
+}, {}>;
+export declare function ComplianceCrosswalkTool(ctx: LocalToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    concerns: {
+        id: string;
+        rule_id: string;
+        evidence: string;
+        category?: string;
+        severity?: string;
+    }[];
+}, {
+    concerns: {
+        id: string;
+        rule_id: string;
+        evidence: string;
+        category?: string;
+        severity?: string;
+    }[];
+}>> & {
+    mutates?: boolean;
+};

package/dist/mcp/crosswalkDigest.d.ts

@@ -0,0 +1 @@
+export declare const EXPECTED_CROSSWALK_DIGEST = "a42bd438bbc32ba302c3bc7a74238adb97560e534f5c94d908f4e81ffe7c6a05";

package/dist/mcp/cyberEssentials.d.ts

@@ -0,0 +1,24 @@
+import type { Concern } from "#app/mcp/terraform/types";
+/**
+ * Cyber Essentials posture, derived from the indicative crosswalk. Pure and
+ * dependency-light (crosswalk + types only) so BOTH the read-only Assess report
+ * and the Cloud report compute the identical number from the identical inputs —
+ * the score is never the model's word.
+ */
+export declare const CE_FRAMEWORK = "Cyber Essentials";
+/** The Cyber Essentials control labels a concern touches (via the indicative
+ *  crosswalk), or `[]` when it maps to none — what the finding-detail "Maps to
+ *  Cyber Essentials" panel renders. */
+export declare function cyberEssentialsControls(concern: Concern): string[];
+/**
+ * The repo's Cyber Essentials posture as a deterministic 0–100 score — what the
+ * dashboard's "CE SCORE" shows. Honest by construction: only OPEN (non-suppressed)
+ * concerns that map to a Cyber Essentials control deduct from a perfect 100, so a
+ * suppressed/accepted finding or one that doesn't touch a CE control never moves
+ * the score, and a clean repo scores 100. Pure.
+ */
+export declare function cyberEssentialsScore(concerns: Concern[]): number;
+/** The distinct Cyber Essentials controls left at risk by the OPEN concern set —
+ *  the "N control(s) at risk" the assessment headline names. Sorted for a stable
+ *  report; empty when nothing open maps to a CE control. */
+export declare function cyberEssentialsControlsAtRisk(concerns: Concern[]): string[];

package/dist/mcp/dashboard.d.ts

@@ -0,0 +1,125 @@
+import type { GitHubToolContext } from "#app/mcp/capabilityContext";
+import type { UserFacingLanguage } from "#app/utils/payload";
+/**
+ * The per-repo "Remediation Dashboard" issue (Renovate's single pinned
+ * Dependency Dashboard, mapped to Infraweaver). ONE issue per repo gives the
+ * maintainer a stable, at-a-glance view of the Terraform remediation state:
+ * which remediation PRs are open, which concern-groups are waiting (held back by
+ * the per-run/concurrency caps), and which findings are suppressed. A waiting
+ * group is opened on demand from the dashboard's Remediate button or a
+ * `@infraweaver fix …` comment — the surfaces that actually dispatch a run.
+ *
+ * This file is the engine seam: a pure body renderer (`buildDashboardBody`) and
+ * an upsert tool that finds-or-creates the single issue. Each waiting row carries
+ * a hidden `<!-- group:ID -->` anchor reserved for a future tick-to-request
+ * consumer (a Renovate-style checkbox read back on the next run); that consumer
+ * is not yet wired, so the body renders a plain list rather than a checkbox that
+ * would silently do nothing. In keeping with the product's hard rule, the
+ * dashboard never merges or deploys anything.
+ */
+/** trailing marker that identifies the dashboard issue when we search for it. */
+export declare const DASHBOARD_MARKER = "<!-- infraweaver:remediation-dashboard -->";
+/** label applied to the dashboard issue (the primary find key + a pin target). */
+export declare const DASHBOARD_LABEL = "infraweaver-dashboard";
+export declare const DASHBOARD_TITLE = "Infraweaver \u2014 Remediation Dashboard";
+export interface DashboardOpenPr {
+    number: number;
+    title: string;
+    url: string;
+    group_id?: string;
+    zombie?: boolean;
+}
+export interface DashboardPending {
+    title: string;
+    severity?: string;
+    files?: string;
+    group_id?: string;
+    reason?: string;
+}
+export interface DashboardSuppressed {
+    title: string;
+    reason?: string;
+}
+export interface DashboardData {
+    open_prs: DashboardOpenPr[];
+    pending: DashboardPending[];
+    suppressed?: DashboardSuppressed[];
+    note?: string;
+}
+/**
+ * Render the dashboard issue body (pure — no I/O). The trailing {@link
+ * DASHBOARD_MARKER} lets the upsert recognise the issue on the next run. The
+ * fixed section headers/notes are localized by the run's `language` (default
+ * English); the data rows (PR titles, counts, group markers) are unchanged.
+ */
+export declare function buildDashboardBody(data: DashboardData, language?: UserFacingLanguage): string;
+export declare const RemediationDashboardParams: import("arktype/internal/variants/object.ts").ObjectType<{
+    open_prs: {
+        number: number;
+        title: string;
+        url: string;
+        group_id?: string;
+        zombie?: boolean;
+    }[];
+    pending: {
+        title: string;
+        severity?: string;
+        files?: string;
+        group_id?: string;
+        reason?: string;
+    }[];
+    suppressed?: {
+        title: string;
+        reason?: string;
+    }[];
+    note?: string;
+}, {}>;
+/**
+ * Create or update the single per-repo Remediation Dashboard issue. Idempotent:
+ * finds the existing issue by the {@link DASHBOARD_LABEL} + marker and updates
+ * its body, else creates it. Bound by the same `push: disabled` read-only gate as
+ * the other issue/PR writes.
+ */
+export declare function UpsertRemediationDashboardTool(ctx: GitHubToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    open_prs: {
+        number: number;
+        title: string;
+        url: string;
+        group_id?: string;
+        zombie?: boolean;
+    }[];
+    pending: {
+        title: string;
+        severity?: string;
+        files?: string;
+        group_id?: string;
+        reason?: string;
+    }[];
+    suppressed?: {
+        title: string;
+        reason?: string;
+    }[];
+    note?: string;
+}, {
+    open_prs: {
+        number: number;
+        title: string;
+        url: string;
+        group_id?: string;
+        zombie?: boolean;
+    }[];
+    pending: {
+        title: string;
+        severity?: string;
+        files?: string;
+        group_id?: string;
+        reason?: string;
+    }[];
+    suppressed?: {
+        title: string;
+        reason?: string;
+    }[];
+    note?: string;
+}>> & {
+    mutates?: boolean;
+};

package/dist/mcp/dependencies.d.ts

@@ -0,0 +1,12 @@
+import type { ToolContext } from "#app/mcp/server";
+/**
+ * start dependency installation in the background (non-blocking, idempotent).
+ * called eagerly from main.ts at startup and also available via MCP tools.
+ */
+export declare function startInstallation(ctx: ToolContext): void;
+export declare function StartDependencyInstallationTool(ctx: ToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<object, object>> & {
+    mutates?: boolean;
+};
+export declare function AwaitDependencyInstallationTool(ctx: ToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<object, object>> & {
+    mutates?: boolean;
+};

package/dist/mcp/frameworks.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The unified framework registry (§5.14 step 1).
+ *
+ * One `FrameworkDef` per compliance framework the crosswalk references, shared
+ * by the engine's indicative crosswalk (`crosswalk.ts`) and — by hand-sync,
+ * exactly like the report wire schema — the Cloud pack
+ * (infraweaver-ui `src/features/crosswalk/pack.ts`). Before this registry the
+ * engine used free-text framework names and the Cloud pack used slug ids: two
+ * hand-synced naming systems with nothing enforcing either.
+ *
+ * The `licence` field makes the free-only constraint MACHINE-ENFORCED: we build
+ * only on frameworks whose text is free to access and lawful to use
+ * commercially (we pay for nothing), and for paywalled/no-derivative texts we
+ * ship control IDS + short editorial titles only, never framework text — the
+ * lawful lane NIST OLIR itself uses for its ISO mappings. `crosswalk.test.ts`
+ * fails any crosswalk entry that embeds text against an `ids-only` licence.
+ */
+/** What we may lawfully ship for a framework, commercially, at zero cost. */
+export type FrameworkLicence = 
+/** US-government work / CC0 (e.g. NIST OSCAL) — full control text embeddable. */
+"public-domain"
+/** OGL v3 / EUR-Lex (Decision 2011/833/EU) — reproducible with attribution. */
+ | "open-government"
+/** CC BY 4.0 — reproducible with attribution. */
+ | "cc-by-4.0"
+/** Paywalled or no-derivatives text (ISO, CIS, AICPA) — control ids + short
+ *  editorial titles ONLY; never reproduce the framework's own text. */
+ | "ids-only";
+/** Whether a framework ships free in the OSS engine (`starter`) or is part of the
+ *  maintained subscription pack (`maintained`). NOTE this is the ENGINE view: the
+ *  Cloud `STARTER_FRAMEWORK_IDS` gate is narrower (Cyber Essentials only) because
+ *  most `starter` frameworks here exist solely as the engine`s indicative
+ *  narration and have no Cloud pack rows to gate. */
+export type FrameworkTier = "starter" | "maintained";
+export interface FrameworkDef {
+    /** Stable slug id — the Cloud pack / API join key. */
+    id: string;
+    /** Display name — the value the engine's `ControlRef.framework` carries. */
+    name: string;
+    /** Publishing authority, e.g. "NIST", "NCSC". */
+    authority: string;
+    /** Where the framework applies, e.g. "UK", "EU", "US", "International". */
+    jurisdiction: string;
+    /** The pinned upstream revision this crosswalk layer was authored against. */
+    revision: string;
+    /** ISO date this REGISTRY ENTRY (name/revision/licence classification) was
+     *  last reviewed. Mapping-layer review dates live with each layer (the engine
+     *  `CROSSWALK_REVIEWED`, the Cloud pack's per-framework `reviewed`) and
+     *  version independently (§5.14 step 5). */
+    reviewed: string;
+    licence: FrameworkLicence;
+    tier: FrameworkTier;
+    /** Mapped through the themes → NIST 800-53 hub (`THEME_TO_NIST`) rather than
+     *  hand-themed directly — the §5.14 "one mechanical, auditable hop" path. */
+    hubAnchored: boolean;
+}
+/** True when the licence permits embedding the framework's own control text. */
+export declare function canEmbedControlText(licence: FrameworkLicence): boolean;
+/**
+ * Every framework the crosswalk references. Ordered starter-first, then the
+ * NIST hub, then the remaining maintained layers.
+ *
+ * NB the slug for NCSC Cloud Security Principles is the legacy `ncsc-caf` —
+ * the Cloud pack and persisted `framework_reporting` rows already use it, so a
+ * rename is a data migration. The real CAF therefore ships as `ncsc-caf-v4`
+ * (B.2); when the legacy slug is eventually migrated, THAT is the moment to
+ * consider collapsing the version suffix — not before, because two frameworks
+ * would briefly answer to the same key.
+ */
+export declare const FRAMEWORKS: readonly FrameworkDef[];
+/** Look up a framework by its display name (the engine `ControlRef.framework`). */
+export declare function frameworkByName(name: string): FrameworkDef | undefined;
+/** Look up a framework by its slug id (the Cloud pack / API join key). */
+export declare function frameworkById(id: string): FrameworkDef | undefined;

package/dist/mcp/geminiSanitizer.d.ts

@@ -0,0 +1,28 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { Tool } from "fastmcp";
+import type { ToolContext } from "#app/mcp/server";
+/**
+ * Recursively transform a JSON schema to gemini's stricter subset.
+ * See module header for the exact transforms applied.
+ */
+export declare function sanitizeForGemini(schema: unknown): unknown;
+export declare function wrapSchemaForGemini<S extends StandardSchemaV1<any>>(schema: S): S;
+export declare function sanitizeToolForGemini<T extends Tool<any, any>>(tool: T): T;
+/**
+ * true when the effective upstream model is — or might become — google
+ * generative language API traffic. matches:
+ *   - direct `google/*`, opencode `opencode/gemini-*`, openrouter
+ *     `openrouter/google/gemini-*` (slug substring "gemini" wins).
+ *   - any unresolved specifier: `undefined`, `"auto"`, or a slug that
+ *     didn't map through the alias registry (no `provider/` prefix).
+ *     these flow through the agent's own auto-select, which may land
+ *     on gemini *after* the MCP server has already registered tools —
+ *     at which point sanitization is too late to apply. erring on the
+ *     side of sanitizing is safe: cases 1 + 2 are universally
+ *     compatible JSON-Schema normalizations (enum-only → typed string,
+ *     collapsible const-unions → string enum); case 3 is gemini-
+ *     specific but only fires on non-collapsible unions, which arktype
+ *     does not emit for our current tool schemas. see issue #676 for
+ *     the prod failure that motivated this widening.
+ */
+export declare function isGeminiRouted(ctx: ToolContext): boolean;

package/dist/mcp/git.d.ts

@@ -0,0 +1,60 @@
+import type { GitToolContext } from "#app/mcp/capabilityContext";
+export declare function rejectIfLeadingDash(value: string, kind: string): void;
+export declare function rejectSpecialRef(value: string, kind: string): void;
+export declare function validateTagName(tag: string): void;
+export declare const PushBranch: import("arktype/internal/variants/object.ts").ObjectType<{
+    branchName?: string;
+    force: import("arktype/internal/attributes.ts").Default<boolean, false>;
+}, {}>;
+export type PushErrorKind = "concurrent-push" | "transient" | "transient-auth" | "unknown";
+export declare function classifyPushError(msg: string): PushErrorKind;
+export declare function PushBranchTool(ctx: GitToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    branchName?: string;
+    force?: boolean;
+}, {
+    branchName?: string;
+    force?: boolean;
+}>> & {
+    mutates?: boolean;
+};
+export declare const AUTH_REQUIRED_REDIRECT: Record<string, string>;
+export declare const NOSHELL_BLOCKED_SUBCOMMANDS: Record<string, string>;
+export declare const NOSHELL_BLOCKED_ARGS: string[];
+export declare const NOSHELL_BLOCKED_WRITE_ARGS: string[];
+/** true when `arg` is a native-file-write flag: `--output`, `--output=<path>`,
+ * `-o`, or attached `-o<path>`. */
+export declare function isBlockedWriteArg(arg: string): boolean;
+export declare function GitTool(ctx: GitToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    command: string;
+    args?: string[];
+}, {
+    command: string;
+    args?: string[];
+}>> & {
+    mutates?: boolean;
+};
+export declare function GitFetchTool(ctx: GitToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    ref: string;
+    depth?: number;
+}, {
+    ref: string;
+    depth?: number;
+}>> & {
+    mutates?: boolean;
+};
+export declare function DeleteBranchTool(ctx: GitToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    branchName: string;
+}, {
+    branchName: string;
+}>> & {
+    mutates?: boolean;
+};
+export declare function PushTagsTool(ctx: GitToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    tag: string;
+    force?: boolean;
+}, {
+    tag: string;
+    force?: boolean;
+}>> & {
+    mutates?: boolean;
+};