infraweaver 0.1.0

package/dist/mcp/terraform/tools/authorPolicy.d.ts

@@ -0,0 +1,59 @@
+export declare const PolicyAuthorParams: import("arktype/internal/variants/object.ts").ObjectType<{
+    id: string;
+    title: string;
+    source_requirement: string;
+    resource_type: string;
+    attribute: string;
+    operator: string;
+    value?: string | number | boolean | (string | number)[];
+    when_absent: "compliant" | "violation";
+    severity: "critical" | "high" | "info" | "low" | "medium";
+    theme: string;
+    message: string;
+    example_compliant?: string | number | boolean;
+    example_violating?: string | number | boolean;
+}, {}>;
+/**
+ * §5.2 — the authoring surface. Turns one requirement from a written standard
+ * into reviewed policy-as-code plus the fixtures that prove it is not vacuous.
+ *
+ * The tool is NON-MUTATING on purpose. It returns file CONTENT, never writes it:
+ * the whole premise of §5.2 is that the output is reviewed code a human commits,
+ * not a policy that appears in the repo because a model decided it should. That
+ * also keeps the push allow-list untouched.
+ *
+ * It takes no `LocalToolContext` for the same reason: nothing here reads the
+ * workspace, the run payload or the scan session. Spec in, artifacts out — which
+ * is what lets the whole path be unit-tested without a fixture repo.
+ */
+export declare function PolicyAuthorTool(): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    id: string;
+    title: string;
+    source_requirement: string;
+    resource_type: string;
+    attribute: string;
+    operator: string;
+    value?: string | number | boolean | (string | number)[];
+    when_absent: "compliant" | "violation";
+    severity: "critical" | "high" | "info" | "low" | "medium";
+    theme: string;
+    message: string;
+    example_compliant?: string | number | boolean;
+    example_violating?: string | number | boolean;
+}, {
+    id: string;
+    title: string;
+    source_requirement: string;
+    resource_type: string;
+    attribute: string;
+    operator: string;
+    value?: string | number | boolean | (string | number)[];
+    when_absent: "compliant" | "violation";
+    severity: "critical" | "high" | "info" | "low" | "medium";
+    theme: string;
+    message: string;
+    example_compliant?: string | number | boolean;
+    example_violating?: string | number | boolean;
+}>> & {
+    mutates?: boolean;
+};

package/dist/mcp/terraform/tools/detectPlanDrift.d.ts

@@ -0,0 +1,20 @@
+import type { LocalToolContext } from "#app/mcp/localContext";
+export declare const DetectPlanDriftParams: import("arktype/internal/variants/object.ts").ObjectType<{
+    path?: string;
+    severity_threshold?: "critical" | "high" | "info" | "low" | "medium";
+    noise_fields?: string[];
+    noise_filter?: boolean;
+}, {}>;
+export declare function DetectPlanDriftTool(ctx: LocalToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    path?: string;
+    severity_threshold?: "critical" | "high" | "info" | "low" | "medium";
+    noise_fields?: string[];
+    noise_filter?: boolean;
+}, {
+    path?: string;
+    severity_threshold?: "critical" | "high" | "info" | "low" | "medium";
+    noise_fields?: string[];
+    noise_filter?: boolean;
+}>> & {
+    mutates?: boolean;
+};

package/dist/mcp/terraform/tools/emitCost.d.ts

@@ -0,0 +1,11 @@
+import type { LocalToolContext } from "#app/mcp/localContext";
+/** No `output_path`: the artifact name is FIXED. The guardrail carve-out that
+ *  lets this file be pushed is the single literal `cost.md` (see
+ *  `COST_ALLOWED_PATHS`), so an agent-chosen path could either be rejected at
+ *  push time or — worse, for a path like `main.tf` that IS allow-listed —
+ *  overwrite Terraform source with markdown. Fixing the name makes the tool's
+ *  write surface exactly the surface the guardrail permits. */
+export declare const TerraformEmitCostParams: import("arktype/internal/variants/object.ts").ObjectType<object, {}>;
+export declare function TerraformEmitCostTool(ctx: LocalToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<object, object>> & {
+    mutates?: boolean;
+};

package/dist/mcp/terraform/tools/emitSarif.d.ts

@@ -0,0 +1,14 @@
+import type { LocalToolContext } from "#app/mcp/localContext";
+export declare const TerraformEmitSarifParams: import("arktype/internal/variants/object.ts").ObjectType<{
+    output_path?: string;
+    severity_threshold?: "critical" | "high" | "info" | "low" | "medium";
+}, {}>;
+export declare function TerraformEmitSarifTool(ctx: LocalToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    output_path?: string;
+    severity_threshold?: "critical" | "high" | "info" | "low" | "medium";
+}, {
+    output_path?: string;
+    severity_threshold?: "critical" | "high" | "info" | "low" | "medium";
+}>> & {
+    mutates?: boolean;
+};

package/dist/mcp/terraform/tools/fixMemory.d.ts

@@ -0,0 +1,19 @@
+import type { LocalToolContext } from "#app/mcp/localContext";
+export declare const TerraformFixMemoryParams: import("arktype/internal/variants/object.ts").ObjectType<object, {}>;
+export declare function runFixMemory(ctx: LocalToolContext): import("#app/mcp/shared").ToolOk<{
+    enabled: boolean;
+    patterns: {
+        finding_type: string;
+        title: string;
+        canonical_class: string | undefined;
+        remediation_hint: string | undefined;
+        before_example: string | undefined;
+        times_proven: number | undefined;
+        repos_count: number | undefined;
+        last_proven: string | undefined;
+    }[];
+    note: string;
+}>;
+export declare function TerraformFixMemoryTool(ctx: LocalToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<object, object>> & {
+    mutates?: boolean;
+};

package/dist/mcp/terraform/tools/infracostDiff.d.ts

@@ -0,0 +1,22 @@
+import type { LocalToolContext } from "#app/mcp/localContext";
+import { infracostBaseline, runInfracostBreakdown } from "#app/mcp/terraform/cost";
+export declare const InfracostDiffParams: import("arktype/internal/variants/object.ts").ObjectType<object, {}>;
+export interface InfracostRunners {
+    runInfracostBreakdown: typeof runInfracostBreakdown;
+    infracostBaseline: typeof infracostBaseline;
+}
+export declare function runInfracostDiff(ctx: LocalToolContext, runners?: InfracostRunners): Promise<Record<string, any> | import("#app/mcp/shared").ToolOk<{
+    ran: boolean;
+    currency: string;
+    current_monthly_cost: number | null;
+    baseline_monthly_cost: number | null;
+    monthly_delta: number | null;
+    direction: "decrease" | "increase" | "no-change" | "unknown";
+    needs_human: boolean;
+    cost_escalation_reason?: string;
+    top_resource_costs?: import("#app/mcp/terraform/cost").ResourceCost[];
+    note?: string;
+}>>;
+export declare function InfracostDiffTool(ctx: LocalToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<object, object>> & {
+    mutates?: boolean;
+};

package/dist/mcp/terraform/tools/ingestExternalFindings.d.ts

@@ -0,0 +1,21 @@
+import type { LocalToolContext } from "#app/mcp/localContext";
+export declare const IngestExternalFindingsParams: import("arktype/internal/variants/object.ts").ObjectType<{
+    path?: string;
+    severity_threshold?: "critical" | "high" | "info" | "low" | "medium";
+    group_by?: "file" | "rule";
+}, {}>;
+/** the findings feed is untrusted third-party output parsed with JSON.parse in
+ * one shot — cap it well below V8's ~1 GiB string limit so a hostile or
+ * runaway feed degrades to a named skip instead of an OOM crash. */
+export declare const MAX_FEED_BYTES: number;
+export declare function IngestExternalFindingsTool(ctx: LocalToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    path?: string;
+    severity_threshold?: "critical" | "high" | "info" | "low" | "medium";
+    group_by?: "file" | "rule";
+}, {
+    path?: string;
+    severity_threshold?: "critical" | "high" | "info" | "low" | "medium";
+    group_by?: "file" | "rule";
+}>> & {
+    mutates?: boolean;
+};

package/dist/mcp/terraform/tools/moduleLookup.d.ts

@@ -0,0 +1,14 @@
+import type { LocalToolContext } from "#app/mcp/localContext";
+export declare const TerraformModuleLookupParams: import("arktype/internal/variants/object.ts").ObjectType<{
+    source: string;
+    version?: string;
+}, {}>;
+export declare function TerraformModuleLookupTool(ctx: LocalToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    source: string;
+    version?: string;
+}, {
+    source: string;
+    version?: string;
+}>> & {
+    mutates?: boolean;
+};

package/dist/mcp/terraform/tools/moduleSearch.d.ts

@@ -0,0 +1,23 @@
+import type { LocalToolContext } from "#app/mcp/localContext";
+export declare const TerraformModuleSearchParams: import("arktype/internal/variants/object.ts").ObjectType<{
+    query: string;
+    namespace?: string;
+    provider?: string;
+    verified?: boolean;
+    limit?: number;
+}, {}>;
+export declare function TerraformModuleSearchTool(_ctx: LocalToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    query: string;
+    namespace?: string;
+    provider?: string;
+    verified?: boolean;
+    limit?: number;
+}, {
+    query: string;
+    namespace?: string;
+    provider?: string;
+    verified?: boolean;
+    limit?: number;
+}>> & {
+    mutates?: boolean;
+};

package/dist/mcp/terraform/tools/plan.d.ts

@@ -0,0 +1,59 @@
+import type { LocalToolContext } from "#app/mcp/localContext";
+import { type PlanSummary } from "#app/mcp/terraform/plan";
+interface RootPlanOutcome {
+    ran: boolean;
+    skipReason?: string | undefined;
+    summary?: PlanSummary | undefined;
+    stable?: boolean | undefined;
+    stabilityReason?: string | undefined;
+    planText?: string | undefined;
+}
+export declare function collectCloudCredentials(): Record<string, string>;
+export declare const TerraformPlanParams: import("arktype/internal/variants/object.ts").ObjectType<object, {}>;
+export interface PlanRunners {
+    planOneRoot: (absDir: string, creds: Record<string, string>) => RootPlanOutcome;
+    hasCloudCredentials: () => boolean;
+}
+export declare function runPlan(ctx: LocalToolContext, runners?: PlanRunners): Promise<Record<string, any> | import("#app/mcp/shared").ToolOk<{
+    ran: boolean;
+    roots_planned: string[];
+    to_add: number;
+    to_change: number;
+    to_destroy: number;
+    has_destroy_or_replace: boolean;
+    destructive: {
+        address: string;
+        action: string;
+    }[];
+    stateful_destructive: {
+        address: string;
+        action: string;
+        type: string;
+    }[];
+    blocked_destructive?: {
+        address: string;
+        action: string;
+        type: string;
+    }[];
+    push_will_block: boolean;
+    blast_radius: import("#app/mcp/terraform/plan").BlastRadius;
+    idempotent: boolean;
+    idempotency_warning: string | undefined;
+    moved_count: number;
+    moved?: {
+        address: string;
+        previousAddress: string | null;
+    }[];
+    refactor_safe: boolean;
+    needs_human: boolean;
+    needs_human_reasons?: string[];
+    plan_text?: string;
+    roots_skipped?: {
+        dir: string;
+        reason: string | undefined;
+    }[];
+}>>;
+export declare function TerraformPlanTool(ctx: LocalToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<object, object>> & {
+    mutates?: boolean;
+};
+export {};

package/dist/mcp/terraform/tools/providerUpgrade.d.ts

@@ -0,0 +1,55 @@
+import type { LocalToolContext } from "#app/mcp/localContext";
+export declare const TerraformProviderUpgradeParams: import("arktype/internal/variants/object.ts").ObjectType<object, {}>;
+export declare function runProviderUpgrade(ctx: LocalToolContext): import("#app/mcp/shared").ToolOk<{
+    applicable: boolean;
+    pinned_providers: {
+        provider: string;
+        major: number | null;
+        constraint: string | null;
+    }[];
+    transforms: never[];
+    note: string;
+}> | import("#app/mcp/shared").ToolOk<{
+    applicable: boolean;
+    pinned_providers: {
+        provider: string;
+        major: number | null;
+        constraint: string | null;
+    }[];
+    packs: {
+        provider: string;
+        from_major: number;
+        to_major: number;
+        pack_version: string;
+        source: string;
+        exhaustive: boolean;
+        official_tool?: string;
+        matched: number;
+    }[];
+    matched_sites: number;
+    transforms_detected: number;
+    transforms_needing_human: number;
+    transforms: {
+        id: string;
+        kind: import("#app/mcp/terraform/transformPacks").TransformKind;
+        resource_type?: string;
+        from: string;
+        to?: string;
+        file?: string;
+        resource_name?: string;
+        confidence: import("#app/mcp/terraform/transformPacks").MatchConfidence;
+        schema_agreement: import("#app/mcp/terraform/transformPacks").SchemaAgreement;
+        state_move: import("#app/mcp/terraform/transformPacks").StateMove;
+        needs_human: boolean;
+        needs_human_reason?: string;
+        value_change?: string;
+        note: string;
+        fleet_times_proven?: number;
+        fleet_repos_count?: number;
+    }[];
+    truncated?: string;
+    note: string;
+}>;
+export declare function TerraformProviderUpgradeTool(ctx: LocalToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<object, object>> & {
+    mutates?: boolean;
+};

package/dist/mcp/terraform/tools/readFindings.d.ts

@@ -0,0 +1,17 @@
+import type { LocalToolContext } from "#app/mcp/localContext";
+export declare const ReadFindingsParams: import("arktype/internal/variants/object.ts").ObjectType<{
+    path?: string;
+    severity_threshold?: "critical" | "high" | "info" | "low" | "medium";
+    group_by?: "file" | "rule";
+}, {}>;
+export declare function ReadFindingsTool(ctx: LocalToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    path?: string;
+    severity_threshold?: "critical" | "high" | "info" | "low" | "medium";
+    group_by?: "file" | "rule";
+}, {
+    path?: string;
+    severity_threshold?: "critical" | "high" | "info" | "low" | "medium";
+    group_by?: "file" | "rule";
+}>> & {
+    mutates?: boolean;
+};

package/dist/mcp/terraform/tools/scan.d.ts

@@ -0,0 +1,114 @@
+import type { LocalToolContext } from "#app/mcp/localContext";
+import { type PreventiveControl } from "#app/mcp/terraform/decisions";
+import { runScannersCached } from "#app/mcp/terraform/scannerCache";
+import { changedTerraformFiles } from "#app/mcp/terraform/scanners";
+import { type Severity } from "#app/mcp/terraform/types";
+export declare const TerraformScanParams: import("arktype/internal/variants/object.ts").ObjectType<{
+    scan_scope?: "diff" | "full";
+    severity_threshold?: "critical" | "high" | "info" | "low" | "medium";
+    group_by?: "file" | "rule";
+    download_external_modules?: boolean;
+}, {}>;
+export interface ScanScanners {
+    runScannersCached: typeof runScannersCached;
+    changedTerraformFiles: typeof changedTerraformFiles;
+}
+export declare function runScan(ctx: LocalToolContext, { scan_scope, severity_threshold, group_by, download_external_modules, }: typeof TerraformScanParams.infer, scanners?: ScanScanners): Promise<import("#app/mcp/shared").ToolOk<{
+    scanned_dir: string;
+    scope: string;
+    scope_note?: string;
+    grouping: "file" | "rule";
+    scanners_ran: ("checkov" | "infraweaver" | "reviewer" | "terraform-fmt" | "terraform-validate" | "tflint" | "trivy")[];
+    scanners_skipped: {
+        source: "checkov" | "infraweaver" | "reviewer" | "terraform-fmt" | "terraform-validate" | "tflint" | "trivy";
+        reason: string | undefined;
+    }[];
+    scanners_partial?: {
+        check: string;
+        reason: string;
+    }[];
+    tool_selection: {
+        licence_gated: import("#app/utils/toolSelection").ToolId[];
+        disabled: import("#app/utils/toolSelection").ToolId[];
+    };
+    summary: {
+        total: number;
+        suppressed: number;
+        groups: number;
+        by_severity: Record<string, number>;
+    };
+    groups: {
+        doc_urls: Record<string, string>;
+        id: string;
+        file: string;
+        files?: string[];
+        grouping?: "file" | "rule";
+        severity: Severity;
+        concern_count: number;
+        rule_ids: string[];
+        concern_ids: string[];
+        autonomy?: import("#app/mcp/terraform/types").Autonomy;
+        autonomy_reasons?: string[];
+    }[];
+    batch_plan: import("#app/mcp/terraform/decisions").BatchPlan;
+    co_located: import("#app/mcp/terraform/decisions").LocationCluster[];
+    refusal_candidates: {
+        concern_id: string;
+        reason: string | undefined;
+    }[];
+    prevention: Record<string, PreventiveControl>;
+    top_risks: import("#app/mcp/terraform/risk").RankedConcern[];
+    concerns: {
+        doc_url: string | null;
+        risk_score: number;
+        noise_reason?: string;
+        id: string;
+        source: "terraform-fmt" | "terraform-validate" | "tflint" | "trivy" | "checkov" | "infraweaver" | "reviewer";
+        rule_id: string;
+        severity: Severity;
+        category: "security" | "style" | "correctness" | "cost";
+        evidence: string;
+        location: {
+            file: string;
+            line: number | null;
+        };
+        language?: import("../iacLanguages.ts").IacLanguage;
+        code_snippet?: string | null;
+        remediation_hint: string | null;
+        suppression?: import("#app/mcp/terraform/types").ConcernSuppression;
+        canonical_class?: string;
+        flagged_by?: string[];
+    }[];
+    orphan_native_skips?: {
+        file: string;
+        line: number;
+        tool: string;
+        rule: string;
+        reason: string;
+        expires?: string;
+    }[];
+    suppressed?: {
+        id: string;
+        rule_id: string;
+        severity: "critical" | "high" | "info" | "low" | "medium";
+        location: {
+            file: string;
+            line: number | null;
+        };
+        suppression: import("#app/mcp/terraform/types").ConcernSuppression | undefined;
+    }[];
+    untrusted_data: string;
+}>>;
+export declare function TerraformScanTool(ctx: LocalToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    scan_scope?: "diff" | "full";
+    severity_threshold?: "critical" | "high" | "info" | "low" | "medium";
+    group_by?: "file" | "rule";
+    download_external_modules?: boolean;
+}, {
+    scan_scope?: "diff" | "full";
+    severity_threshold?: "critical" | "high" | "info" | "low" | "medium";
+    group_by?: "file" | "rule";
+    download_external_modules?: boolean;
+}>> & {
+    mutates?: boolean;
+};

package/dist/mcp/terraform/tools/validate.d.ts

@@ -0,0 +1,31 @@
+import type { LocalToolContext } from "#app/mcp/localContext";
+import { checkArgumentsAgainstSchema, collectProviderRequirements, scanFmt, scanTflint, scanValidate } from "#app/mcp/terraform/scanners";
+export declare const TerraformValidateParams: import("arktype/internal/variants/object.ts").ObjectType<{
+    paths?: string[];
+}, {}>;
+export interface ValidateScanners {
+    scanFmt: typeof scanFmt;
+    scanValidate: typeof scanValidate;
+    scanTflint: typeof scanTflint;
+    collectProviderRequirements: typeof collectProviderRequirements;
+    checkArgumentsAgainstSchema: typeof checkArgumentsAgainstSchema;
+}
+export declare function runValidate(ctx: LocalToolContext, scanners?: ValidateScanners): Promise<import("#app/mcp/shared").ToolOk<{
+    passed: boolean;
+    checks_ran: ("checkov" | "infraweaver" | "reviewer" | "terraform-fmt" | "terraform-validate" | "tflint" | "trivy")[];
+    validate_incomplete: boolean;
+    remaining_issues: import("#app/mcp/terraform/types").Concern[];
+    preexisting_fmt_drift: string[];
+    providers: import("#app/mcp/terraform/scanners").ProviderRequirement[];
+    schema_checked: boolean;
+    unknown_arguments: import("#app/mcp/terraform/scanners").UnknownArgument[];
+    roots_validated: string[];
+    untrusted_data: string;
+}>>;
+export declare function TerraformValidateTool(ctx: LocalToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    paths?: string[];
+}, {
+    paths?: string[];
+}>> & {
+    mutates?: boolean;
+};

package/dist/mcp/terraform/tools/verifyRemediation.d.ts

@@ -0,0 +1,31 @@
+import type { LocalToolContext } from "#app/mcp/localContext";
+import { runScanners } from "#app/mcp/terraform/scanners";
+export declare const TerraformVerifyRemediationParams: import("arktype/internal/variants/object.ts").ObjectType<{
+    concern_ids: string[];
+    download_external_modules?: boolean;
+}, {}>;
+export interface VerifyScanners {
+    runScanners: typeof runScanners;
+}
+export declare function runVerifyRemediation(ctx: LocalToolContext, { concern_ids, download_external_modules, }: typeof TerraformVerifyRemediationParams.infer, scanners?: VerifyScanners): Promise<import("#app/mcp/shared").ToolOk<{
+    verified: boolean;
+    resolved_count: number;
+    remaining_count: number;
+    resolved: string[];
+    remaining: string[];
+    has_regressions: boolean;
+    regressions: string[];
+    regressions_note?: string;
+    confidence: import("#app/mcp/terraform/decisions").Confidence;
+    confidence_reasons: string[];
+    scanners_ran: ("checkov" | "infraweaver" | "reviewer" | "terraform-fmt" | "terraform-validate" | "tflint" | "trivy")[];
+}>>;
+export declare function TerraformVerifyRemediationTool(ctx: LocalToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<{
+    concern_ids: string[];
+    download_external_modules?: boolean;
+}, {
+    concern_ids: string[];
+    download_external_modules?: boolean;
+}>> & {
+    mutates?: boolean;
+};

package/dist/mcp/terraform/tools/versionCurrency.d.ts

@@ -0,0 +1,5 @@
+import type { LocalToolContext } from "#app/mcp/localContext";
+export declare const TerraformVersionCurrencyParams: import("arktype/internal/variants/object.ts").ObjectType<object, {}>;
+export declare function TerraformVersionCurrencyTool(ctx: LocalToolContext): import("fastmcp").Tool<any, import("@standard-schema/spec").StandardSchemaV1<object, object>> & {
+    mutates?: boolean;
+};

package/dist/mcp/terraform/tools.d.ts

@@ -0,0 +1,16 @@
+export { PolicyAuthorParams, PolicyAuthorTool, } from "#app/mcp/terraform/tools/authorPolicy";
+export { DetectPlanDriftParams, DetectPlanDriftTool, } from "#app/mcp/terraform/tools/detectPlanDrift";
+export { TerraformEmitCostParams, TerraformEmitCostTool, } from "#app/mcp/terraform/tools/emitCost";
+export { TerraformEmitSarifParams, TerraformEmitSarifTool, } from "#app/mcp/terraform/tools/emitSarif";
+export { TerraformFixMemoryParams, TerraformFixMemoryTool, } from "#app/mcp/terraform/tools/fixMemory";
+export { InfracostDiffParams, InfracostDiffTool, } from "#app/mcp/terraform/tools/infracostDiff";
+export { IngestExternalFindingsParams, IngestExternalFindingsTool, } from "#app/mcp/terraform/tools/ingestExternalFindings";
+export { TerraformModuleLookupParams, TerraformModuleLookupTool, } from "#app/mcp/terraform/tools/moduleLookup";
+export { TerraformModuleSearchParams, TerraformModuleSearchTool, } from "#app/mcp/terraform/tools/moduleSearch";
+export { collectCloudCredentials, TerraformPlanParams, TerraformPlanTool, } from "#app/mcp/terraform/tools/plan";
+export { TerraformProviderUpgradeParams, TerraformProviderUpgradeTool, } from "#app/mcp/terraform/tools/providerUpgrade";
+export { ReadFindingsParams, ReadFindingsTool, } from "#app/mcp/terraform/tools/readFindings";
+export { TerraformScanParams, TerraformScanTool } from "#app/mcp/terraform/tools/scan";
+export { TerraformValidateParams, TerraformValidateTool, } from "#app/mcp/terraform/tools/validate";
+export { TerraformVerifyRemediationParams, TerraformVerifyRemediationTool, } from "#app/mcp/terraform/tools/verifyRemediation";
+export { TerraformVersionCurrencyParams, TerraformVersionCurrencyTool, } from "#app/mcp/terraform/tools/versionCurrency";