infraweaver 0.1.0

package/dist/lifecycle.d.ts

@@ -0,0 +1,2 @@
+/** timeout for lifecycle hook scripts */
+export declare const LIFECYCLE_HOOK_TIMEOUT_MS = 600000;

package/dist/main.d.ts

@@ -0,0 +1,8 @@
+export { Inputs } from "#app/utils/payload";
+export interface MainResult {
+    success: boolean;
+    output?: string | undefined;
+    error?: string | undefined;
+    result?: string | undefined;
+}
+export declare function main(): Promise<MainResult>;

package/dist/mcp/arkConfig.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mcp/assess.d.ts

@@ -0,0 +1,157 @@
+import { type CrosswalkReport } from "#app/mcp/crosswalk";
+import type { LocalToolContext } from "#app/mcp/localContext";
+import { type BaselineDelta } from "#app/mcp/terraform/baseline";
+import { type IacLanguage, type LanguageScope } from "#app/mcp/terraform/iacLanguages";
+import { type Concern, type ScannerOutcome, type Severity } from "#app/mcp/terraform/types";
+import { type VerificationSummary } from "#app/mcp/terraform/verification";
+import { type ResolvedToolSelection } from "#app/utils/toolSelection";
+/**
+ * Assess pillar — the read-only product. Infraweaver's scanner
+ * engine has two modes off ONE codebase: Remediate = engine + fix loop + verify;
+ * **Assess = engine, read-only**. This surfaces that read-only half as a
+ * first-class deliverable: run the deterministic scanners, normalise into the
+ * findings schema, map to the compliance crosswalk, and produce a
+ * **scorecard** + an auditor-facing markdown report — WITHOUT touching the
+ * Terraform or opening a PR. No cloud credentials, no writes.
+ *
+ * The scorecard is deterministic (computed from tool results, never the model's
+ * word) so a CI gate can branch on `posture` and an assessor gets a reproducible,
+ * framework-mapped report.
+ */
+export type AssessPosture = "clean" | "advisory" | "action-required";
+export interface AssessTopRisk {
+    rule_id: string;
+    severity: Severity;
+    file: string;
+    line: number | null;
+    evidence: string;
+}
+/** A finding a human explicitly accepted (a suppression with a mandatory reason).
+ *  Surfaced as the report's audit trail — who waived what, why, and until when. */
+export interface AssessWaiver {
+    rule_id: string;
+    severity: Severity;
+    file: string;
+    line: number | null;
+    reason: string;
+    source: "inline" | "policy";
+    expires: string | null;
+}
+/** Per-language breadth line for the multi-language Assess scorecard. Honest by
+ *  construction: a language is either `scanned` (a scanner covered it) or listed
+ *  in `unsupported` (detected, but no static scanner can assess it — e.g. Pulumi),
+ *  never silently dropped. `by_language` counts OPEN concerns per scanned language. */
+export interface AssessmentLanguages {
+    /** every IaC language detected in the tree (superset of scanned + unsupported). */
+    detected: IacLanguage[];
+    /** languages this run reported on (scope ∩ what a scanner can read). */
+    scanned: IacLanguage[];
+    /** file count per detected language — the breadth signal. */
+    file_counts: Partial<Record<IacLanguage, number>>;
+    /** open-concern count per scanned language (0 for a clean language). */
+    by_language: Partial<Record<IacLanguage, number>>;
+    /** detected languages NO installed scanner can statically assess — surfaced,
+     * never scanned-and-silent (each with the honest reason). */
+    unsupported: {
+        language: IacLanguage;
+        reason: string;
+    }[];
+}
+export interface AssessmentScorecard {
+    /** clean (0 concerns) · advisory (only medium/low/info) · action-required (≥1 critical/high). */
+    posture: AssessPosture;
+    total: number;
+    by_severity: Record<Severity, number>;
+    /** multi-language breadth: which IaC languages were detected/scanned/unsupported
+     * and the open-concern count per scanned language. Terraform-only trees still
+     * report here (just one scanned language). */
+    languages: AssessmentLanguages;
+    /** highest-severity concerns first, capped — the "what to look at first" list. */
+    top_risks: AssessTopRisk[];
+    compliance: {
+        /** frameworks this scan touched (from the crosswalk's by_framework index). */
+        frameworks: string[];
+        /** distinct controls touched across all frameworks. */
+        controls_touched: number;
+        /** concerns that mapped to ≥1 control vs none (honest coverage signal). */
+        mapped: number;
+        unmapped: number;
+        version: string;
+        reviewed: string;
+    };
+    /** Cyber Essentials posture (0–100, indicative) + the distinct CE controls the
+     * OPEN concerns leave at risk — the report headline a CISO reads first. */
+    cyber_essentials: {
+        score: number;
+        controls_at_risk: string[];
+    };
+    /** findings a human explicitly accepted — the report's de-emphasised audit
+     * trail (excluded from posture/counts above; an expired waiver auto-resurfaces). */
+    waivers: AssessWaiver[];
+    /** five-status verification taxonomy: per-concern fail / not-code-verifiable +
+     * the scanner coverage (verified vs inconclusive). Keeps a "clean" posture
+     * honest — e.g. "clean, but tflint inconclusive (not run)". */
+    verification: VerificationSummary;
+}
+/** posture from the severity distribution: any critical/high ⇒ action-required;
+ * any lower-severity concern ⇒ advisory; nothing ⇒ clean. */
+export declare function assessPosture(bySeverity: Record<Severity, number>): AssessPosture;
+/**
+ * Build the deterministic assessment scorecard from a scan's concerns + their
+ * crosswalk report. Pure. `concerns` is the OPEN (non-suppressed) severity-sorted,
+ * deduped, Terraform-only set — posture, counts and the CE score reflect only what
+ * is unresolved; `suppressed` carries the accepted findings for the audit trail.
+ * `crosswalk` is `buildCrosswalkReport(concerns)`.
+ */
+export declare function buildAssessment(concerns: Concern[], crosswalk: CrosswalkReport, verification: VerificationSummary, suppressed?: Concern[], languageScope?: LanguageScope): AssessmentScorecard;
+/** Optional render-time context the scorecard can't hold on its own. `delta` is
+ *  the run-to-run change vs the committed baseline checkpoint (null when no
+ *  baseline exists — there's nothing to compare against). */
+export interface AssessRenderContext {
+    delta?: {
+        delta: BaselineDelta;
+        since: string | null;
+    } | null;
+}
+/**
+ * Render the scorecard as a deterministic, auditor-facing markdown report (the
+ * Assess deliverable). Built entirely from the scorecard so it's reproducible and
+ * model-independent. Pure.
+ */
+export declare function renderAssessmentMarkdown(s: AssessmentScorecard, ctx?: AssessRenderContext): string;
+export declare const TerraformAssessParams: import("arktype/internal/variants/object.ts").ObjectType<{
+    severity_threshold?: "critical" | "high" | "info" | "low" | "medium";
+}, {}>;
+/** the full read-only assessment pipeline: scan (honouring the licence gate
+ * + module-fetch credential) → crosswalk → verification taxonomy → scorecard.
+ * Shared by `terraform_assess` and the evidence-bundle emitter so both report the
+ * identical posture from the identical toolchain. Pure-ish (only the scanners do
+ * I/O); no writes. */
+export declare function runAssessmentPipeline(ctx: LocalToolContext, threshold: Severity): {
+    cwd: string;
+    selection: ResolvedToolSelection;
+    /** the resolved multi-language scope (detected / scanned / unsupported). */
+    languageScope: LanguageScope;
+    outcomes: ScannerOutcome[];
+    /** the full annotated set (suppression metadata attached) — what the Cloud report needs. */
+    concerns: Concern[];
+    /** the OPEN subset — what posture/score/crosswalk reflect. */
+    open: Concern[];
+    /** the accepted/waived subset — the audit trail. */
+    suppressed: Concern[];
+    crosswalk: CrosswalkReport;
+    verification: VerificationSummary;
+    scorecard: AssessmentScorecard;
+    /** run-to-run change vs the committed baseline; null when no baseline exists. */
+    delta: {
+        delta: BaselineDelta;
+        since: string | null;
+    } | null;
+};
+export declare function TerraformAssessTool(ctx: LocalToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    severity_threshold?: "critical" | "high" | "info" | "low" | "medium";
+}, {
+    severity_threshold?: "critical" | "high" | "info" | "low" | "medium";
+}>> & {
+    mutates?: boolean;
+};

package/dist/mcp/capabilityContext.d.ts

@@ -0,0 +1,71 @@
+import type { AgentId } from "#app/external";
+import type { ToolState } from "#app/toolState";
+import type { OctokitWithPlugins } from "#app/utils/github";
+import type { ResolvedPayload } from "#app/utils/payload";
+import type { RunContextData } from "#app/utils/runContextData";
+/**
+ * Capability contexts: the narrow, per-family subsets of the 28-field
+ * `ToolContext` (see `mcp/server.ts`). Each interface is a structural subset, so
+ * the full `ToolContext` is assignable to it — the server wires every tool with
+ * one `ToolContext` and each factory sees only the capability it declares.
+ *
+ * The point is the TEST SURFACE. A git tool typed `GitToolContext` is unit-tested
+ * by constructing seven real fields with real types — not a 28-field object cast
+ * `as unknown as ToolContext`, whose cast hides whichever field the tool actually
+ * reaches for. `LocalToolContext` (see `mcp/localContext.ts`) is the cwd-scoped
+ * member of this same family; these three add the GitHub / git / cloud surfaces.
+ *
+ * `payload` and `toolState` stay their full shared types — they are legitimately
+ * broad state carriers every family reads, and narrowing them buys nothing for
+ * the test surface (a fixture builds them either way). What each interface drops
+ * is the top-level capability fields a family never touches: a cloud tool needn't
+ * fabricate an `octokit`, a git tool needn't fabricate an `apiToken`.
+ */
+/**
+ * GitHub REST/GraphQL capability: the authenticated `octokit` client, the repo
+ * coordinates it addresses, the installation token (raw-asset fetch), and the
+ * review-surface fields (`agentId` for tool-ref rendering, `prApproveEnabled`).
+ * The home of the ~15 issue/PR/review/comment/label tools.
+ */
+export interface GitHubToolContext {
+    octokit: OctokitWithPlugins;
+    githubInstallationToken: string;
+    repo: RunContextData["repo"];
+    payload: ResolvedPayload;
+    toolState: ToolState;
+    tmpdir: string;
+    agentId: AgentId;
+    prApproveEnabled: boolean;
+}
+/**
+ * Git capability: the token pushes authenticate with, the single-flight re-minter
+ * (`refreshGitToken`), the prepush lifecycle hook, and the repo/payload/state the
+ * push guardrails read. No `octokit` — the git tools shell out, they don't call
+ * the API.
+ */
+export interface GitToolContext {
+    gitToken: string;
+    refreshGitToken?: ((stale: string) => Promise<string>) | undefined;
+    prepushScript: string | null;
+    repo: RunContextData["repo"];
+    payload: ResolvedPayload;
+    toolState: ToolState;
+    tmpdir: string;
+}
+/**
+ * Cloud capability: the identity a tool presents to Infraweaver Cloud — the run's
+ * `api_token` (a `tmnd_`/`tmpx_` bearer) and its `runId`. Consumed by the upload
+ * tool and by `patchWorkflowRunFields`. See `utils/cloudClient.ts` (E3).
+ */
+export interface CloudToolContext {
+    apiToken: string;
+    runId: number | undefined;
+}
+/**
+ * The write tools that create a GitHub artifact AND report its node-id back to
+ * Cloud via `patchWorkflowRunFields` (create_pull_request, create_issue,
+ * create_review, the plan-comment writers) genuinely span two capabilities: the
+ * GitHub surface plus the cloud identity. Naming the intersection keeps their
+ * signatures honest about both.
+ */
+export type GitHubWriteToolContext = GitHubToolContext & CloudToolContext;

package/dist/mcp/changeSummary.d.ts

@@ -0,0 +1,52 @@
+import type { BaseBranchContext } from "#app/mcp/pr";
+/**
+ * AI PR summaries — the deterministic Terraform-change anchor. A PR summary
+ * written purely by the model drifts (miscounts resources, invents changes). This
+ * parses the PR's unified diff for Terraform BLOCK changes (which resource /
+ * module / data / variable / output addresses were added or removed, which files
+ * were touched) so the human-readable summary is anchored to facts, not prose.
+ *
+ * Pure parser (`summarizeTerraformResourceDiff`) + a tool that runs the
+ * merge-base diff and feeds it in. Block ADDED/REMOVED is precise (a block header
+ * on a +/- line); in-place edits to an existing block surface as a touched FILE
+ * (attributing a sub-block edit to a specific address needs full-file parsing —
+ * we stay honest and report the file rather than guess).
+ */
+export interface TerraformChangeSummary {
+    /** addresses of blocks added in this diff (e.g. `aws_s3_bucket.logs`, `module.vpc`). */
+    added: string[];
+    /** addresses of blocks removed in this diff. */
+    removed: string[];
+    /** Terraform files touched (a superset signal — includes in-place edits). */
+    files: string[];
+    counts: {
+        added: number;
+        removed: number;
+        files: number;
+    };
+}
+/**
+ * Parse a Terraform block header into its address, or null when the line is not a
+ * top-level block header. Handles two-label blocks (`resource`/`data`) and
+ * single-label blocks (`module`/`variable`/`output`/`provider`). The line is the
+ * raw HCL (diff +/- prefix already stripped). Pure.
+ */
+export declare function parseBlockAddress(line: string): string | null;
+/**
+ * Summarise a unified `git diff` into added/removed Terraform block addresses +
+ * the touched Terraform files. Tracks the current file from `+++ b/<path>`
+ * headers and only considers `.tf`/`.tfvars` files. Pure; deterministic ordering
+ * (sorted, de-duplicated). A block counted as both added and removed (moved) is
+ * left in both lists — the prose can describe the move.
+ */
+export declare function summarizeTerraformResourceDiff(diff: string): TerraformChangeSummary;
+export declare const TerraformChangeSummaryParams: import("arktype/internal/variants/object.ts").ObjectType<{
+    base?: string;
+}, {}>;
+export declare function TerraformChangeSummaryTool(ctx: BaseBranchContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    base?: string;
+}, {
+    base?: string;
+}>> & {
+    mutates?: boolean;
+};

package/dist/mcp/checkSuite.d.ts

@@ -0,0 +1,27 @@
+import type { GitHubToolContext } from "#app/mcp/capabilityContext";
+export declare const GetCheckSuiteLogs: import("arktype/internal/variants/object.ts").ObjectType<{
+    check_suite_id: number;
+}, {}>;
+type LogLine = {
+    line: number;
+    content: string;
+    type: "error" | "warning" | "failure" | "trace";
+};
+type LogAnalysis = {
+    totalLines: number;
+    index: LogLine[];
+    excerpt: {
+        content: string;
+        startLine: number;
+        endLine: number;
+    };
+};
+export declare function analyzeLog(logs: string, excerptLines?: number): LogAnalysis;
+export declare function GetCheckSuiteLogsTool(ctx: GitHubToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    check_suite_id: number;
+}, {
+    check_suite_id: number;
+}>> & {
+    mutates?: boolean;
+};
+export {};

package/dist/mcp/checkout.d.ts

@@ -0,0 +1,92 @@
+import type { RestEndpointMethodTypes } from "@octokit/rest";
+import type { GitHubToolContext, GitToolContext } from "#app/mcp/capabilityContext";
+/**
+ * checkout_pr genuinely spans two capabilities: it reads the PR + its files over
+ * the GitHub API AND fetches/checks-out the branch over git, then runs the
+ * post-checkout lifecycle hook. Its context is the honest intersection of both
+ * surfaces plus that one lifecycle script.
+ */
+type CheckoutToolContext = GitHubToolContext & GitToolContext & {
+    postCheckoutScript: string | null;
+};
+type PullFile = RestEndpointMethodTypes["pulls"]["listFiles"]["response"]["data"][number];
+export type FormatFilesResult = {
+    content: string;
+    toc: string;
+};
+export type FetchAndFormatPrDiffResult = FormatFilesResult & {
+    files: PullFile[];
+};
+/**
+ * formats PR files with explicit line numbers for each code line.
+ * preserves all original diff info (file headers, hunk headers) and adds:
+ * | OLD | NEW | TYPE | code
+ * returns both the formatted content and a TOC with line ranges per file.
+ */
+export declare function formatFilesWithLineNumbers(files: PullFile[]): FormatFilesResult;
+export declare const CheckoutPr: import("arktype/internal/variants/object.ts").ObjectType<{
+    pull_number: number;
+}, {}>;
+export type CheckoutPrResult = {
+    success: true;
+    number: number;
+    title: string;
+    body: string | null;
+    base: string;
+    localBranch: string;
+    remoteBranch: string;
+    isFork: boolean;
+    maintainerCanModify: boolean;
+    url: string;
+    headRepo: string;
+    diffPath: string;
+    incrementalDiffPath?: string | undefined;
+    /** supplemental, explicitly-incomplete change-impact leads (references to the
+     * PR's changed HCL declarations). Absent when no TF declarations changed or
+     * generation was disabled/failed. Never a coverage source. */
+    impactPath?: string | undefined;
+    toc: string;
+    commitCount: number;
+    commitLog: string;
+    /** true when commitLog was capped because the PR has more commits than we render */
+    commitLogTruncated: boolean;
+    /** true when commit metadata could not be computed (e.g. base ref unreachable after shallow fetch). commitCount/commitLog are zero/empty in that case, not "no commits". */
+    commitLogUnavailable: boolean;
+    /** non-fatal warning from the post-checkout lifecycle hook, if any */
+    hookWarning?: string | undefined;
+    instructions: string;
+};
+/**
+ * fetches PR files from GitHub and formats them with line numbers and TOC.
+ * this is the core diff formatting logic, extracted for testability.
+ */
+export declare function fetchAndFormatPrDiff(ctx: CheckoutToolContext, pullNumber: number): Promise<FetchAndFormatPrDiffResult>;
+import { type GitContext } from "#app/utils/setup";
+export type PrData = {
+    number: number;
+    headSha: string;
+    headRef: string;
+    headRepoFullName: string;
+    baseRef: string;
+    baseRepoFullName: string;
+    maintainerCanModify: boolean;
+};
+type CheckoutPrBranchParams = GitContext & {
+    beforeSha?: string | undefined;
+};
+/**
+ * Shared helper to checkout a PR branch and configure fork remotes.
+ * Assumes origin remote is already configured with authentication.
+ * Updates toolState.issueNumber, toolState.checkoutSha, and toolState.pushUrl (for fork PRs).
+ */
+export declare function checkoutPrBranch(pr: PrData, params: CheckoutPrBranchParams): Promise<{
+    hookWarning?: string | undefined;
+}>;
+export declare function CheckoutPrTool(ctx: CheckoutToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    pull_number: number;
+}, {
+    pull_number: number;
+}>> & {
+    mutates?: boolean;
+};
+export {};

package/dist/mcp/comment.d.ts

@@ -0,0 +1,127 @@
+import type { GitHubToolContext, GitHubWriteToolContext } from "#app/mcp/capabilityContext";
+export { isLeapingIntoActionCommentBody, LEAPING_INTO_ACTION_PREFIX, } from "#app/utils/leapingComment";
+export declare function addFooter(ctx: GitHubToolContext, body: string): string;
+export declare const Comment: import("arktype/internal/variants/object.ts").ObjectType<{
+    issueNumber: number;
+    body: string;
+    type?: "Comment" | "Plan";
+}, {}>;
+export declare function CreateCommentTool(ctx: GitHubWriteToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    issueNumber: number;
+    body: string;
+    type?: "Comment" | "Plan";
+}, {
+    issueNumber: number;
+    body: string;
+    type?: "Comment" | "Plan";
+}>> & {
+    mutates?: boolean;
+};
+export declare const EditComment: import("arktype/internal/variants/object.ts").ObjectType<{
+    commentId: number;
+    body: string;
+}, {}>;
+export declare function EditCommentTool(ctx: GitHubWriteToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    commentId: number;
+    body: string;
+}, {
+    commentId: number;
+    body: string;
+}>> & {
+    mutates?: boolean;
+};
+export declare const ReportProgress: import("arktype/internal/variants/object.ts").ObjectType<{
+    body: string;
+    target_plan_comment?: boolean;
+}, {}>;
+/**
+ * Report progress to a GitHub comment.
+ *
+ * progressComment has three states:
+ *   - undefined: no comment yet — will create one if an issue/PR target exists
+ *   - object:    active comment — will update it in place via the right REST endpoint for its type
+ *   - null:      deliberately deleted (e.g. after submitting a PR review) — skips silently
+ *
+ * The body is tracked in lastProgressBody for the job summary regardless of comment state,
+ * EXCEPT for `liveProgress` (todo-tracker) writes — see the param note below.
+ *
+ * The "existing plan comment" path always targets a top-level issue comment (plan comments are
+ * created by create_issue_comment with type:"Plan", never as review-thread replies).
+ */
+export declare function reportProgress(ctx: GitHubWriteToolContext, params: {
+    body: string;
+    target_plan_comment?: boolean;
+    liveProgress?: boolean;
+}): Promise<{
+    commentId?: number;
+    url?: string;
+    body: string;
+    action: "created" | "updated" | "skipped";
+}>;
+export declare function ReportProgressTool(ctx: GitHubWriteToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    body: string;
+    target_plan_comment?: boolean;
+}, {
+    body: string;
+    target_plan_comment?: boolean;
+}>> & {
+    mutates?: boolean;
+};
+/**
+ * Delete the progress comment if it exists.
+ * Used by main.ts for stranded-comment cleanup (orphaned "Leaping into action" or
+ * checklist left by the todo tracker when the agent didn't call report_progress).
+ * Sets progressComment to null so subsequent report_progress calls are no-ops.
+ */
+export declare function deleteProgressComment(ctx: GitHubWriteToolContext): Promise<boolean>;
+export declare const ReplyToReviewComment: import("arktype/internal/variants/object.ts").ObjectType<{
+    pull_number: number;
+    comment_id: number;
+    body: string;
+}, {}>;
+/**
+ * decision returned by `duplicateReplyDecision` when a session has already
+ * posted an identical reply to the same parent review comment.
+ */
+export interface DuplicateReplyDecision {
+    kind: "already-replied";
+    commentId: number;
+    url: string | undefined;
+    reason: string;
+}
+/**
+ * decide whether a second reply_to_review_comment call in the same session
+ * is a duplicate of an earlier reply to the same parent comment.
+ *
+ * the agent is instructed to call reply_to_review_comment exactly once per
+ * parent comment per AddressReviews session, but in practice it sometimes
+ * emits the same call twice. PR #610 reproduced this with Kimi K2:
+ * identical body posted 3 seconds apart, only one tool_use event in the
+ * agent log. the second post is always redundant and clutters the PR thread.
+ *
+ * we key on (comment_id, bodyWithFooter) so a legitimate follow-up reply
+ * with different content still goes through. within a single run the
+ * footer is constant (workflow run + model + jobId), so byte-equal bodies
+ * catch the stutter without blocking real follow-ups.
+ *
+ * mirrors the shape of `duplicateReviewDecision` in mcp/review.ts.
+ */
+export declare function duplicateReplyDecision(params: {
+    existing: {
+        commentId: number;
+        url: string | undefined;
+        bodyWithFooter: string;
+    } | undefined;
+    bodyWithFooter: string;
+}): DuplicateReplyDecision | null;
+export declare function ReplyToReviewCommentTool(ctx: GitHubWriteToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    pull_number: number;
+    comment_id: number;
+    body: string;
+}, {
+    pull_number: number;
+    comment_id: number;
+    body: string;
+}>> & {
+    mutates?: boolean;
+};

package/dist/mcp/commitInfo.d.ts

@@ -0,0 +1,11 @@
+import type { GitHubToolContext } from "#app/mcp/capabilityContext";
+export declare const CommitInfo: import("arktype/internal/variants/object.ts").ObjectType<{
+    sha: string;
+}, {}>;
+export declare function CommitInfoTool(ctx: GitHubToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    sha: string;
+}, {
+    sha: string;
+}>> & {
+    mutates?: boolean;
+};