@fjall/generator 0.95.0 → 0.99.1

package/dist/src/codemod/llmFallback/morphTier.js

@@ -0,0 +1,3 @@
+import{gateEgress as o}from"./egressGate.js";import{buildPrompt as g}from"./prompt.js";import{withTierTimeout as m}from"./tierRunner.js";import{PARSE_GATE as T}from"./types.js";const k=15e3,t="morph";async function M(e,r){if(!e.orgAllowsFallback)return{state:"disabled",reason:"org-opt-out"};if(!r.isAvailable())return{state:"disabled",reason:"env-flag"};const s=o(e.content,t);if(s!==void 0)return s;const i=o(JSON.stringify(e.intent.properties),t);if(i!==void 0)return i;const{systemPrompt:c,userPrompt:p}=g({content:e.content,intent:e.intent,tier:t});return m(e.abortSignal,t,k,async({signal:u,started:l})=>{const n=await r.apply({originalFile:e.content,update:`${c}
+
+${p}`,signal:u}),d=Date.now()-l;if(n.content===e.content)return{state:"rejected",tier:t,failedGate:T,diagnostics:"Morph returned unchanged content"};const a=o(n.content,t);if(a!==void 0)return a;const f={tier:t,elapsedMs:d,inputTokens:n.usage?.inputTokens??0,outputTokens:n.usage?.outputTokens??0,opsApplied:1};return{state:"applied",content:n.content,telemetry:f}})}export{M as runMorphTier};

package/dist/src/codemod/llmFallback/prompt.d.ts

@@ -0,0 +1,12 @@
+import type { LlmFallbackTier } from "../types.js";
+import type { FallbackIntent } from "./types.js";
+export interface BuildPromptInput {
+    content: string;
+    intent: FallbackIntent;
+    tier: LlmFallbackTier;
+}
+export interface BuiltPrompt {
+    systemPrompt: string;
+    userPrompt: string;
+}
+export declare function buildPrompt(input: BuildPromptInput): BuiltPrompt;

package/dist/src/codemod/llmFallback/prompt.js

@@ -0,0 +1,36 @@
+import{z as u}from"zod";import{STATEMENT_REGISTRY as s}from"../registry.js";const p=[...new Set(Object.values(s).map(e=>e.factoryIdentifier))].join(", "),a=`You are a Fjall infrastructure code editor. You modify TypeScript infrastructure files that use the Fjall CDK factory pattern.
+
+Each resource is declared as a factory call:
+  \`XFactory.build("ResourceName", { ...properties })\`
+
+where X is one of: ${p}.
+
+## Rules
+
+1. Use ONLY the str_replace command to make changes. Never rewrite the entire file.
+2. Each str_replace must match EXACTLY ONE location in the file. If the old_str appears more than once, include enough surrounding context to make it unique.
+3. Preserve all existing imports. Do not remove or reorder import statements.
+4. Preserve the quote style used in the file (single or double quotes).
+5. Do not move resource declarations into conditional blocks, loops, or function bodies. All factory calls must remain at module top level.
+6. If you cannot produce a valid edit, respond with an empty tool_use \u2014 do not guess.
+7. Properties must conform to the schema provided below. Do not invent property names.`;function d(e){return e==="morph"?`${a}
+
+You are operating as a fast-apply tier. Produce minimal, precise edits only.`:a}function m(e){const t=s[e.type].factoryIdentifier;switch(e.op){case"add":return`Add a new ${e.type} resource named "${e.name}" using ${t}.build("${e.name}", { ... }) with the properties specified below.`;case"remove":return`Remove the ${e.type} resource named "${e.name}" (the ${t}.build("${e.name}", ...) call and any directly related code). Preserve all other resources.`;case"modify":return`Modify the ${e.type} resource named "${e.name}" by updating its properties to match the values specified below. Keep properties not mentioned in the update unchanged.`;case"resolve-drift-merge":return`Resolve a drift conflict on the ${e.type} resource named "${e.name}". The resource has been edited manually since Fjall last wrote it, and the requested properties conflict with the manual edits. Merge the two sets of changes: apply the requested properties below while preserving any manual edits to OTHER properties not listed in the update. Use ${t}.build("${e.name}", { ... }) with the merged property set.`}}function h(e){const o=s[e.type],t=u.toJSONSchema(o.schemaFragment,{io:"input"}),r=JSON.stringify(t,null,2),n=i(r);return`## Property Schema for ${e.type}
+
+${n}json
+${r}
+${n}`}function f(e){if(e.op==="remove")return"";const o=Object.fromEntries(Object.entries(e.properties).filter(([,n])=>n!==void 0));if(Object.keys(o).length===0)return"";const t=JSON.stringify(o,null,2),r=i(t);return`## Target Properties
+
+${r}json
+${t}
+${r}`}function i(e){const o=e.match(/`+/g)??[];let t=0;for(const r of o)r.length>t&&(t=r.length);return"`".repeat(Math.max(3,t+1))}function b(e){const o=d(e.tier),t=m(e.intent),r=h(e.intent),n=f(e.intent),c=i(e.content),l=`## Task
+
+${t}
+
+${r}
+${n}
+## Current File
+
+${c}typescript
+${e.content}
+${c}`.trim();return{systemPrompt:o,userPrompt:l}}export{b as buildPrompt};

package/dist/src/codemod/llmFallback/runFallback.d.ts

@@ -0,0 +1,13 @@
+import type { AnthropicClientProvider, FallbackInput, FallbackOutput, MorphClientProvider } from "./types.js";
+export interface FallbackClients {
+    claude: AnthropicClientProvider;
+    morph?: MorphClientProvider;
+}
+export interface RunFallbackInput {
+    content: string;
+    intent: FallbackInput["intent"];
+    orgAllowsFallback: boolean;
+    morphTierEnabled: boolean;
+    abortSignal?: AbortSignal;
+}
+export declare function runFallback(input: RunFallbackInput, clients: FallbackClients): Promise<FallbackOutput>;

package/dist/src/codemod/llmFallback/runFallback.js

@@ -0,0 +1 @@
+import{runClaudeTier as n}from"./claudeTier.js";import{runMorphTier as a}from"./morphTier.js";function o(r,e){return{content:r.content,intent:r.intent,tier:e,orgAllowsFallback:r.orgAllowsFallback,abortSignal:r.abortSignal}}async function u(r,e){const t=await n(o(r,"claude"),e.claude);return!(t.state==="rejected"||t.state==="timeout")||!r.morphTierEnabled||e.morph===void 0?t:a(o(r,"morph"),e.morph)}export{u as runFallback};

package/dist/src/codemod/llmFallback/shouldTryFallback.d.ts

@@ -0,0 +1,13 @@
+import type { CodemodError } from "../types.js";
+import type { TriggerReason } from "./types.js";
+export interface FallbackGuardConfig {
+    envEnabled: boolean;
+    orgAllowsFallback: boolean;
+}
+export type FallbackDecision = {
+    shouldTry: true;
+    trigger: TriggerReason;
+} | {
+    shouldTry: false;
+};
+export declare function shouldTryFallback(error: CodemodError, config: FallbackGuardConfig): FallbackDecision;

package/dist/src/codemod/llmFallback/shouldTryFallback.js

@@ -0,0 +1 @@
+const e={shouldTry:!1};function o(r,n){if(!n.envEnabled||!n.orgAllowsFallback)return e;const t=l(r);return t===void 0?e:{shouldTry:!0,trigger:t}}function l(r){switch(r.kind){case"TemplateLiteralNameError":return"template-literal-name";case"ResourceNotFoundError":return"resource-not-found";case"ControlFlowClassifierError":return r.reason==="anonymous-helper"?"control-flow-unclassifiable":void 0;case"DriftUnmergeableError":return"drift-unmergeable";default:return}}export{o as shouldTryFallback};

package/dist/src/codemod/llmFallback/signals.d.ts

@@ -0,0 +1,4 @@
+export declare function linkAbortSignals(outer: AbortSignal | undefined, controller: AbortController): {
+    signal: AbortSignal;
+    cleanup: () => void;
+};

package/dist/src/codemod/llmFallback/signals.js

@@ -0,0 +1 @@
+function e(a,n){if(a===void 0)return{signal:n.signal,cleanup:()=>{}};if(a.aborted)return n.abort(),{signal:n.signal,cleanup:()=>{}};const i=()=>n.abort();return a.addEventListener("abort",i,{once:!0}),{signal:n.signal,cleanup:()=>a.removeEventListener("abort",i)}}export{e as linkAbortSignals};

package/dist/src/codemod/llmFallback/telemetryEvents.d.ts

@@ -0,0 +1,141 @@
+import type { GateId } from "../validationGate/types.js";
+import type { FallbackOp, FallbackTelemetry, TriggerReason } from "./types.js";
+import type { EgressRiskReason } from "./egressGate.types.js";
+import type { LlmFallbackTier } from "../types.js";
+export declare const FALLBACK_EVENTS: {
+    readonly FIRED: "codemod.llm_fallback.fired";
+    readonly SUCCEEDED: "codemod.llm_fallback.succeeded";
+    readonly REJECTED: "codemod.llm_fallback.rejected";
+    readonly TIMEOUT: "codemod.llm_fallback.timeout";
+    readonly EGRESS_BLOCKED: "codemod.llm_fallback.egress_blocked";
+};
+export declare const GATE_EVENTS: {
+    readonly PASSED: "codemod.gate.passed";
+    readonly FAILED: "codemod.gate.failed";
+};
+export type TelemetrySource = "cli" | "webapp_service" | "webapp_api" | "webapp_ui" | "mcp";
+export interface FallbackFiredEvent {
+    event: typeof FALLBACK_EVENTS.FIRED;
+    properties: {
+        source: TelemetrySource;
+        operation: FallbackOp;
+        tier: LlmFallbackTier;
+        trigger: TriggerReason;
+        organisationId: string;
+    };
+}
+export interface FallbackSucceededEvent {
+    event: typeof FALLBACK_EVENTS.SUCCEEDED;
+    properties: {
+        source: TelemetrySource;
+        operation: FallbackOp;
+        tier: LlmFallbackTier;
+        durationMs: number;
+        estimatedCostUsd: number;
+        organisationId: string;
+    };
+}
+export interface FallbackRejectedEvent {
+    event: typeof FALLBACK_EVENTS.REJECTED;
+    properties: {
+        source: TelemetrySource;
+        operation: FallbackOp;
+        tier: LlmFallbackTier;
+        failedGate: GateId;
+        durationMs: number;
+        organisationId: string;
+    };
+}
+export interface FallbackTimeoutEvent {
+    event: typeof FALLBACK_EVENTS.TIMEOUT;
+    properties: {
+        source: TelemetrySource;
+        operation: FallbackOp;
+        tier: LlmFallbackTier;
+        elapsedMs: number;
+        organisationId: string;
+    };
+}
+export interface FallbackEgressBlockedEvent {
+    event: typeof FALLBACK_EVENTS.EGRESS_BLOCKED;
+    properties: {
+        source: TelemetrySource;
+        operation: FallbackOp;
+        tier: LlmFallbackTier;
+        reason: EgressRiskReason;
+        count: number;
+        organisationId: string;
+    };
+}
+export interface GatePassedEvent {
+    event: typeof GATE_EVENTS.PASSED;
+    properties: {
+        gate: GateId;
+        operation: FallbackOp | "validate";
+        durationMs: number;
+        source: TelemetrySource;
+        organisationId: string;
+    };
+}
+export interface GateFailedEvent {
+    event: typeof GATE_EVENTS.FAILED;
+    properties: {
+        gate: GateId;
+        operation: FallbackOp | "validate";
+        durationMs: number;
+        source: TelemetrySource;
+        organisationId: string;
+    };
+}
+export type FallbackTelemetryEvent = FallbackFiredEvent | FallbackSucceededEvent | FallbackRejectedEvent | FallbackTimeoutEvent | FallbackEgressBlockedEvent | GatePassedEvent | GateFailedEvent;
+export declare function estimateCostUsd(telemetry: FallbackTelemetry): number;
+export declare function buildFiredEvent(params: {
+    source: TelemetrySource;
+    operation: FallbackOp;
+    tier: LlmFallbackTier;
+    trigger: TriggerReason;
+    organisationId: string;
+}): FallbackFiredEvent;
+export declare function buildSucceededEvent(params: {
+    source: TelemetrySource;
+    operation: FallbackOp;
+    telemetry: FallbackTelemetry;
+    organisationId: string;
+}): FallbackSucceededEvent;
+export declare function buildRejectedEvent(params: {
+    source: TelemetrySource;
+    operation: FallbackOp;
+    tier: LlmFallbackTier;
+    failedGate: GateId;
+    durationMs: number;
+    organisationId: string;
+}): FallbackRejectedEvent;
+export declare function buildTimeoutEvent(params: {
+    source: TelemetrySource;
+    operation: FallbackOp;
+    tier: LlmFallbackTier;
+    elapsedMs: number;
+    organisationId: string;
+}): FallbackTimeoutEvent;
+export declare function buildEgressBlockedEvent(params: {
+    source: TelemetrySource;
+    operation: FallbackOp;
+    tier: LlmFallbackTier;
+    reason: EgressRiskReason;
+    count: number;
+    organisationId: string;
+}): FallbackEgressBlockedEvent;
+export declare function buildGatePassedEvent(params: {
+    gate: GateId;
+    operation: FallbackOp | "validate";
+    durationMs: number;
+    source: TelemetrySource;
+    organisationId: string;
+}): GatePassedEvent;
+export declare function buildGateFailedEvent(params: {
+    gate: GateId;
+    operation: FallbackOp | "validate";
+    durationMs: number;
+    source: TelemetrySource;
+    organisationId: string;
+}): GateFailedEvent;

package/dist/src/codemod/llmFallback/telemetryEvents.js

@@ -0,0 +1 @@
+const t={FIRED:"codemod.llm_fallback.fired",SUCCEEDED:"codemod.llm_fallback.succeeded",REJECTED:"codemod.llm_fallback.rejected",TIMEOUT:"codemod.llm_fallback.timeout",EGRESS_BLOCKED:"codemod.llm_fallback.egress_blocked"},o={PASSED:"codemod.gate.passed",FAILED:"codemod.gate.failed"},E=3/1e6,d=15/1e6;function i(e){if(e.tier!=="claude")return 0;const n=e.inputTokens*E,r=e.outputTokens*d;return Math.round((n+r)*1e6)/1e6}function u(e){return{event:t.FIRED,properties:e}}function c(e){return{event:t.SUCCEEDED,properties:{source:e.source,operation:e.operation,tier:e.telemetry.tier,durationMs:e.telemetry.elapsedMs,estimatedCostUsd:i(e.telemetry),organisationId:e.organisationId}}}function l(e){return{event:t.REJECTED,properties:e}}function s(e){return{event:t.TIMEOUT,properties:e}}function p(e){return{event:t.EGRESS_BLOCKED,properties:e}}function _(e){return{event:o.PASSED,properties:e}}function a(e){return{event:o.FAILED,properties:e}}export{t as FALLBACK_EVENTS,o as GATE_EVENTS,p as buildEgressBlockedEvent,u as buildFiredEvent,a as buildGateFailedEvent,_ as buildGatePassedEvent,l as buildRejectedEvent,c as buildSucceededEvent,s as buildTimeoutEvent,i as estimateCostUsd};

package/dist/src/codemod/llmFallback/tierRunner.d.ts

@@ -0,0 +1,7 @@
+import type { LlmFallbackTier } from "../types.js";
+import { type FallbackOutput } from "./types.js";
+export interface TierTimeoutContext {
+    signal: AbortSignal;
+    started: number;
+}
+export declare function withTierTimeout(abortSignal: AbortSignal | undefined, tier: LlmFallbackTier, timeoutMs: number, fn: (ctx: TierTimeoutContext) => Promise<FallbackOutput>): Promise<FallbackOutput>;

package/dist/src/codemod/llmFallback/tierRunner.js

@@ -0,0 +1 @@
+import{maskSensitiveOutput as m}from"@fjall/util";import{linkAbortSignals as d}from"./signals.js";import{RUNTIME_GATE as f}from"./types.js";async function w(r,n,l,s){const i=new AbortController,{signal:u,cleanup:c}=d(r,i);let t,a=!1;const o=Date.now();try{return t=setTimeout(()=>{a=!0,i.abort()},l),await s({signal:u,started:o})}catch(e){return r?.aborted?{state:"cancelled"}:a?{state:"timeout",tier:n,elapsedMs:Date.now()-o}:{state:"rejected",tier:n,failedGate:f,diagnostics:m(e instanceof Error?e.message:String(e))}}finally{t!==void 0&&clearTimeout(t),c()}}export{w as withTierTimeout};

package/dist/src/codemod/llmFallback/types.d.ts

@@ -0,0 +1,104 @@
+import type { StatementType, ResourceName, LlmFallbackTier } from "../types.js";
+import type { GateId } from "../validationGate/types.js";
+import type { EgressRiskReason } from "./egressGate.types.js";
+export declare const PARSE_GATE: GateId;
+export declare const RUNTIME_GATE: GateId;
+export type FallbackOp = "add" | "modify" | "remove" | "resolve-drift-merge";
+export interface FallbackIntent {
+    op: FallbackOp;
+    type: StatementType;
+    name: ResourceName;
+    properties: Record<string, unknown>;
+}
+export interface FallbackInput {
+    content: string;
+    intent: FallbackIntent;
+    tier: LlmFallbackTier;
+    orgAllowsFallback: boolean;
+    abortSignal?: AbortSignal;
+}
+export type FallbackOutput = {
+    state: "applied";
+    content: string;
+    telemetry: FallbackTelemetry;
+} | {
+    state: "egress-blocked";
+    tier: LlmFallbackTier;
+    reason: EgressRiskReason;
+    count: number;
+} | {
+    state: "timeout";
+    tier: LlmFallbackTier;
+    elapsedMs: number;
+} | {
+    state: "rejected";
+    tier: LlmFallbackTier;
+    failedGate: GateId;
+    diagnostics: string;
+} | {
+    state: "cancelled";
+} | {
+    state: "disabled";
+    reason: "env-flag" | "org-opt-out";
+};
+export interface FallbackTelemetry {
+    tier: LlmFallbackTier;
+    elapsedMs: number;
+    inputTokens: number;
+    outputTokens: number;
+    opsApplied: number;
+}
+export type TriggerReason = "template-literal-name" | "resource-not-found" | "control-flow-unclassifiable" | "drift-unmergeable";
+export interface StrReplaceOp {
+    old_str: string;
+    new_str: string;
+}
+export interface ApplyResult {
+    content: string;
+    appliedCount: number;
+    skippedCount: number;
+}
+export interface AnthropicClientProvider {
+    create(params: {
+        model: string;
+        max_tokens: number;
+        system: string;
+        messages: Array<{
+            role: "user";
+            content: string;
+        }>;
+        tools: readonly unknown[];
+        signal?: AbortSignal;
+    }): Promise<AnthropicResponse>;
+    resolveModelId(): string;
+}
+export interface AnthropicResponse {
+    content: readonly AnthropicContentBlock[];
+    usage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+    };
+}
+export type AnthropicContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool_use";
+    name: string;
+    input: Record<string, unknown>;
+};
+export interface MorphClientProvider {
+    apply(params: {
+        originalFile: string;
+        update: string;
+        signal?: AbortSignal;
+    }): Promise<MorphResponse>;
+    isAvailable(): boolean;
+}
+export interface MorphResponse {
+    content: string;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+    };
+}

package/dist/src/codemod/llmFallback/types.js

@@ -0,0 +1 @@
+const t="parse",e="runtime";export{t as PARSE_GATE,e as RUNTIME_GATE};

package/dist/src/codemod/registry.d.ts

@@ -25,7 +25,7 @@ export interface StatementTypeEntry {
     factoryIdentifier: FactoryIdentifier;
     locator: StatementLocator;
     generator: StatementGenerator;
-    schemaFragment: z.ZodObject;
+    schemaFragment: z.ZodObject<z.ZodRawShape>;
 }
 declare const FACTORY_IDENTIFIERS: {
     readonly database: "DatabaseFactory";
@@ -35,6 +35,9 @@ declare const FACTORY_IDENTIFIERS: {
     readonly cdn: "CdnFactory";
     readonly network: "NetworkFactory";
     readonly pattern: "PatternFactory";
+    readonly "vpc-peer": "VpcPeerFactory";
+    readonly "vpc-peer-accepter": "VpcPeerAccepterFactory";
+    readonly "cross-plan-connection": "CrossPlanConnectionFactory";
 };
 export type FactoryIdentifier = (typeof FACTORY_IDENTIFIERS)[StatementType];
 export declare const STATEMENT_REGISTRY: Record<StatementType, StatementTypeEntry>;

package/dist/src/codemod/registry.js

@@ -1 +1 @@
-import{z as c}from"zod";import{CDNResourcePlanSchema as m,ComputeResourcePlanSchema as u,DatabaseResourcePlanSchema as p,NetworkResourcePlanSchema as g,NextJSPatternConfigSchema as d,PayloadPatternConfigSchema as h,S3ResourcePlanSchema as S,SQSResourcePlanSchema as l}from"../schemas/index.js";import{failure as y}from"../types/Result.js";const r={database:"DatabaseFactory",storage:"StorageFactory",compute:"ComputeFactory",messaging:"MessagingFactory",cdn:"CdnFactory",network:"NetworkFactory",pattern:"PatternFactory"};function n(t){const{name:e,...o}=t.shape;return c.object(o).partial().strict()}const f=n(p),F=n(S),b=(()=>{const{name:t,...e}=u.shape;return c.object(e).partial().strict()})(),E=n(l),w=n(m),P=n(g),R=(()=>{const{name:t,...e}=h.shape,{name:o,...i}=d.shape;return c.object({...e,...i}).partial().strict()})();function s(t,e){return y({kind:"SemanticQueryError",reason:`StatementTypeEntry.${t} for ${e} is not wired; existing types dispatch through the shared locator/generator.`})}function C(t){return{factoryIdentifier:t,findByShape:()=>s("locator.findByShape",t),validateContext:()=>s("locator.validateContext",t)}}function T(t){return{build:()=>{throw new Error(`StatementTypeEntry.generator.build for ${t} is not wired; existing types dispatch through the shared buildFactoryStatement.`)}}}function a(t,e){return{factoryIdentifier:t,locator:C(t),generator:T(t),schemaFragment:e}}const x={database:a(r.database,f),storage:a(r.storage,F),compute:a(r.compute,b),messaging:a(r.messaging,E),cdn:a(r.cdn,w),network:a(r.network,P),pattern:a(r.pattern,R)};function j(t){for(const[e,o]of Object.entries(x))if(o.factoryIdentifier===t)return e}export{x as STATEMENT_REGISTRY,j as findTypeByIdentifier};
+import{z as c}from"zod";import{CDNResourcePlanSchema as i,ComputeResourcePlanSchema as u,CrossPlanConnectionResourcePlanSchema as g,DatabaseResourcePlanSchema as l,NetworkResourcePlanSchema as h,NextJSPatternConfigSchema as d,PayloadPatternConfigSchema as y,S3ResourcePlanSchema as S,SQSResourcePlanSchema as F,VpcPeerAccepterResourcePlanSchema as P,VpcPeerResourcePlanSchema as f}from"../schemas/index.js";import{failure as C}from"../types/Result.js";const r={database:"DatabaseFactory",storage:"StorageFactory",compute:"ComputeFactory",messaging:"MessagingFactory",cdn:"CdnFactory",network:"NetworkFactory",pattern:"PatternFactory","vpc-peer":"VpcPeerFactory","vpc-peer-accepter":"VpcPeerAccepterFactory","cross-plan-connection":"CrossPlanConnectionFactory"};function a(e){const{name:t,...o}=e.shape;return c.object(o).partial().strict()}const b=a(l),R=a(S),v=(()=>{const{name:e,...t}=u.shape;return c.object(t).partial().strict()})(),E=a(F),w=a(i),k=a(h),T=(()=>{const{name:e,type:t,...o}=y.shape,{name:D,type:V,...m}=d.shape;return c.object({...o,...m}).partial().strict()})(),_=a(f),x=a(P),N=a(g);function s(e,t){return C({kind:"SemanticQueryError",reason:`StatementTypeEntry.${e} for ${t} is not wired; existing types dispatch through the shared locator/generator.`})}function j(e){return{factoryIdentifier:e,findByShape:()=>s("locator.findByShape",e),validateContext:()=>s("locator.validateContext",e)}}function A(e){return{build:()=>{const t=s("generator.build",e);throw new Error(t.success?"unreachable":t.error.reason)}}}function n(e,t){return{factoryIdentifier:e,locator:j(e),generator:A(e),schemaFragment:t}}const p={database:n(r.database,b),storage:n(r.storage,R),compute:n(r.compute,v),messaging:n(r.messaging,E),cdn:n(r.cdn,w),network:n(r.network,k),pattern:n(r.pattern,T),"vpc-peer":n(r["vpc-peer"],_),"vpc-peer-accepter":n(r["vpc-peer-accepter"],x),"cross-plan-connection":n(r["cross-plan-connection"],N)};function I(e){const t=Object.keys(p);for(const o of t)if(p[o].factoryIdentifier===e)return o}export{p as STATEMENT_REGISTRY,I as findTypeByIdentifier};

package/dist/src/codemod/semanticIndex/classifyControlFlow.d.ts

@@ -0,0 +1,2 @@
+export type ControlFlowClassification = "top-level" | "conditional" | "loop" | "function-body" | "unknown";
+export declare function classifyControlFlow(node: unknown, ancestors: readonly unknown[]): ControlFlowClassification;

package/dist/src/codemod/semanticIndex/classifyControlFlow.js

@@ -0,0 +1 @@
+const u=new Set(["IfStatement","ConditionalExpression","SwitchStatement","SwitchCase","CatchClause"]),c=new Set(["ForStatement","ForInStatement","ForOfStatement","WhileStatement","DoWhileStatement"]),a=new Set(["FunctionDeclaration","FunctionExpression","ArrowFunctionExpression","ObjectMethod","ClassMethod"]);function p(n,t){if(t.length===0)return S(n);let e=n;for(let r=t.length-1;r>=0;r-=1){const o=t[r],i=f(o);if(i===void 0){e=o;continue}if(i==="TryStatement"){if(s(o,e))return"conditional";e=o;continue}if(u.has(i))return"conditional";if(c.has(i))return"loop";if(a.has(i))return"function-body";e=o}const l=f(t[0]);return l==="Program"||l==="File"?"top-level":"unknown"}function f(n){if(typeof n!="object"||n===null)return;const t=n.type;return typeof t=="string"?t:void 0}function s(n,t){if(typeof n!="object"||n===null)return!1;const e=n.finalizer;return e!==void 0&&e===t}function S(n){const t=f(n);return t==="Program"||t==="File"?"top-level":"unknown"}export{p as classifyControlFlow};

package/dist/src/codemod/semanticIndex/findReferences.js

@@ -1,2 +1,2 @@
-import{Node as d,SyntaxKind as m}from"ts-morph";import{failure as a,success as l}from"../../types/Result.js";import{DEFAULT_FILE_PATH as y}from"../_internal.js";import{getProject as S}from"./projectCache.js";const f=120;function T(r,n,e=y){let i;try{i=S().createSourceFile(e,r,{overwrite:!0})}catch(t){return a({kind:"SemanticQueryError",reason:"Failed to create source file",cause:t})}let o;try{o=p(i,n.start)}catch(t){return a({kind:"SemanticQueryError",reason:"Failed to resolve declaration at the supplied offset",cause:t})}if(o===void 0)return l([]);let s;try{s=o.getSymbol()}catch(t){return a({kind:"SemanticQueryError",reason:"Failed to resolve symbol for declaration",cause:t})}if(s===void 0)return l([]);let c;try{c=o.findReferencesAsNodes()}catch(t){return a({kind:"SemanticQueryError",reason:"findReferencesAsNodes failed",cause:t})}const u=[];try{for(const t of c)g(t,s)&&(F(t,o)||u.push(b(t)))}catch(t){return a({kind:"SemanticQueryError",reason:"Failed to map references to plain-data locations",cause:t})}return l(u)}function p(r,n){const e=r.getDescendantAtPos(n);return e===void 0?void 0:d.isVariableDeclaration(e)?e:e.getFirstAncestorByKind(m.VariableDeclaration)}function g(r,n){const e=r.getSymbol();return e===void 0?!1:e===n?!0:e.compilerSymbol===n.compilerSymbol}function F(r,n){const e=n.getNameNode();return r===e||r.getStart()===e.getStart()}function b(r){const n=r.getStart(),{line:e,column:i}=r.getSourceFile().getLineAndColumnAtPos(n),c=r.getSourceFile().getFullText().split(`
-`)[e-1]??"",u=c.length>f?c.slice(0,f):c;return{line:e,column:i,context:u}}export{T as findReferences};
+import{Node as m,SyntaxKind as y}from"ts-morph";import{failure as a,success as u}from"../../types/Result.js";import{DEFAULT_FILE_PATH as S}from"../_internal.js";import{getProject as p}from"./projectCache.js";const f=120;function D(r,n,e=S){let o;try{o=p().createSourceFile(e,r,{overwrite:!0})}catch(t){return a({kind:"SemanticQueryError",reason:"Failed to create source file",cause:t})}let c;try{c=g(o,n.start)}catch(t){return a({kind:"SemanticQueryError",reason:"Failed to resolve declaration at the supplied offset",cause:t})}if(c===void 0)return u([]);let i;try{i=c.getSymbol()}catch(t){return a({kind:"SemanticQueryError",reason:"Failed to resolve symbol for declaration",cause:t})}if(i===void 0)return u([]);let s;try{s=c.findReferencesAsNodes()}catch(t){return a({kind:"SemanticQueryError",reason:"findReferencesAsNodes failed",cause:t})}const d=o.getFullText().split(`
+`),l=[];try{for(const t of s)F(t,i)&&(b(t,c)||l.push(A(t,d)))}catch(t){return a({kind:"SemanticQueryError",reason:"Failed to map references to plain-data locations",cause:t})}return u(l)}function g(r,n){const e=r.getDescendantAtPos(n);return e===void 0?void 0:m.isVariableDeclaration(e)?e:e.getFirstAncestorByKind(y.VariableDeclaration)}function F(r,n){const e=r.getSymbol();return e===void 0?!1:e===n?!0:e.compilerSymbol===n.compilerSymbol}function b(r,n){const e=n.getNameNode();return r===e||r.getStart()===e.getStart()}function A(r,n){const e=r.getStart(),{line:o,column:c}=r.getSourceFile().getLineAndColumnAtPos(e),i=n[o-1]??"",s=i.length>f?i.slice(0,f):i;return{line:o,column:c,context:s}}export{D as findReferences};

package/dist/src/codemod/telemetry/errorKinds.d.ts

@@ -0,0 +1,2 @@
+export declare const CODEMOD_ERROR_KINDS: readonly ["ParseError", "ResourceNotFoundError", "DuplicateResourceError", "ReferencesRemainError", "InvalidPropertyError", "TemplateLiteralNameError", "SemanticQueryError", "ValidationError", "IoError", "DriftConflictError", "DriftUnmergeableError", "PermissionError", "ControlFlowClassifierError", "LlmFallbackRejectedError", "LlmFallbackTimeoutError", "LlmFallbackUnsafeInputError"];
+export type CodemodErrorKind = (typeof CODEMOD_ERROR_KINDS)[number];

package/dist/src/codemod/telemetry/errorKinds.js

@@ -0,0 +1 @@
+const r=["ParseError","ResourceNotFoundError","DuplicateResourceError","ReferencesRemainError","InvalidPropertyError","TemplateLiteralNameError","SemanticQueryError","ValidationError","IoError","DriftConflictError","DriftUnmergeableError","PermissionError","ControlFlowClassifierError","LlmFallbackRejectedError","LlmFallbackTimeoutError","LlmFallbackUnsafeInputError"],e=!0;export{r as CODEMOD_ERROR_KINDS};

package/dist/src/codemod/types.d.ts

@@ -1,4 +1,11 @@
 import { z } from "zod";
+import type { GateId } from "./validationGate/types.js";
+import type { EgressRiskReason } from "./llmFallback/egressGate.types.js";
+export declare const DriftPolicySchema: z.ZodObject<{
+    force: z.ZodOptional<z.ZodBoolean>;
+    resolutionMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type DriftPolicy = z.infer<typeof DriftPolicySchema>;
 /**
  * The wider `StatementTypeSchema` in `schemas/baseSchemas.ts` also
  * carries non-factory kinds (import, app-init, tags, custom) that the
@@ -12,6 +19,9 @@ export declare const StatementTypeSchema: z.ZodEnum<{
     network: "network";
     messaging: "messaging";
     cdn: "cdn";
+    "vpc-peer": "vpc-peer";
+    "vpc-peer-accepter": "vpc-peer-accepter";
+    "cross-plan-connection": "cross-plan-connection";
 }>;
 export type StatementType = z.infer<typeof StatementTypeSchema>;
 export declare const ResourceNameSchema: z.ZodString;
@@ -25,10 +35,18 @@ export declare const AddOptionsSchema: z.ZodObject<{
         network: "network";
         messaging: "messaging";
         cdn: "cdn";
+        "vpc-peer": "vpc-peer";
+        "vpc-peer-accepter": "vpc-peer-accepter";
+        "cross-plan-connection": "cross-plan-connection";
     }>;
     name: z.ZodString;
     properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     filePath: z.ZodOptional<z.ZodString>;
+    driftPolicy: z.ZodOptional<z.ZodObject<{
+        force: z.ZodOptional<z.ZodBoolean>;
+        resolutionMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+    branch: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type AddOptions = z.infer<typeof AddOptionsSchema>;
 export declare const RemoveOptionsSchema: z.ZodObject<{
@@ -40,10 +58,14 @@ export declare const RemoveOptionsSchema: z.ZodObject<{
         network: "network";
         messaging: "messaging";
         cdn: "cdn";
+        "vpc-peer": "vpc-peer";
+        "vpc-peer-accepter": "vpc-peer-accepter";
+        "cross-plan-connection": "cross-plan-connection";
     }>;
     name: z.ZodString;
     filePath: z.ZodOptional<z.ZodString>;
     force: z.ZodOptional<z.ZodBoolean>;
+    branch: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type RemoveOptions = z.infer<typeof RemoveOptionsSchema>;
 export declare const ModifyOptionsSchema: z.ZodObject<{
@@ -55,10 +77,18 @@ export declare const ModifyOptionsSchema: z.ZodObject<{
         network: "network";
         messaging: "messaging";
         cdn: "cdn";
+        "vpc-peer": "vpc-peer";
+        "vpc-peer-accepter": "vpc-peer-accepter";
+        "cross-plan-connection": "cross-plan-connection";
     }>;
     name: z.ZodString;
     properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     filePath: z.ZodOptional<z.ZodString>;
+    driftPolicy: z.ZodOptional<z.ZodObject<{
+        force: z.ZodOptional<z.ZodBoolean>;
+        resolutionMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+    branch: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type ModifyOptions = z.infer<typeof ModifyOptionsSchema>;
 export declare const ReferenceLocationSchema: z.ZodObject<{
@@ -81,6 +111,9 @@ export declare const ResourceListingEntrySchema: z.ZodObject<{
         network: "network";
         messaging: "messaging";
         cdn: "cdn";
+        "vpc-peer": "vpc-peer";
+        "vpc-peer-accepter": "vpc-peer-accepter";
+        "cross-plan-connection": "cross-plan-connection";
     }>;
     name: z.ZodString;
     filePath: z.ZodString;
@@ -99,6 +132,9 @@ export declare const ResourceListingSchema: z.ZodObject<{
             network: "network";
             messaging: "messaging";
             cdn: "cdn";
+            "vpc-peer": "vpc-peer";
+            "vpc-peer-accepter": "vpc-peer-accepter";
+            "cross-plan-connection": "cross-plan-connection";
         }>;
         name: z.ZodString;
         filePath: z.ZodString;
@@ -121,6 +157,11 @@ export declare const CodemodSuccessSchema: z.ZodObject<{
     warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 export type CodemodSuccess = z.infer<typeof CodemodSuccessSchema>;
+export interface EditOrchestratorSuccess {
+    content: string;
+    linesChanged: LinesChanged;
+    warnings?: string[];
+}
 /** @internal Bridging tuple across the ts-morph / recast boundary (ADR §1). */
 export interface NodeLocation {
     filePath: string;
@@ -169,4 +210,72 @@ export interface SemanticQueryError {
     reason: string;
     cause?: unknown;
 }
-export type CodemodError = ParseError | TemplateLiteralNameError | DuplicateResourceError | ResourceNotFoundError | ReferencesRemainError | InvalidPropertyError | SemanticQueryError;
+export declare const PropertyDeltaSchema: z.ZodObject<{
+    property: z.ZodString;
+    base: z.ZodOptional<z.ZodUnknown>;
+    theirs: z.ZodUnknown;
+    ours: z.ZodUnknown;
+    verdict: z.ZodEnum<{
+        clean: "clean";
+        "no-op": "no-op";
+        compatible: "compatible";
+        conflict: "conflict";
+    }>;
+}, z.core.$strict>;
+export type PropertyDelta = z.infer<typeof PropertyDeltaSchema>;
+export interface DriftConflictError {
+    kind: "DriftConflictError";
+    resource: {
+        type: StatementType;
+        name: string;
+    };
+    deltas: PropertyDelta[];
+    baselineSource: "pr" | "persistent" | "file" | "unknown";
+    remediation?: string;
+}
+export interface DriftUnmergeableError {
+    kind: "DriftUnmergeableError";
+    resource: {
+        type: StatementType;
+        name: string;
+    };
+    reason: string;
+}
+export interface PermissionError {
+    kind: "PermissionError";
+    reason: "cross-account-peer-requires-trust" | "cross-org-connection-refused" | "unknown-remote-app" | "wildcard-principal-rejected" | "wildcard-resource-rejected";
+    details: string;
+    remediation?: string;
+}
+export type ControlFlowRefusalReason = "try-catch" | "switch-fall-through" | "nested-ternary" | "loop" | "generator-function" | "async-iterator" | "anonymous-helper" | "decorator-return";
+export interface ControlFlowClassifierError {
+    kind: "ControlFlowClassifierError";
+    reason: ControlFlowRefusalReason;
+    resource: {
+        type: StatementType;
+        name: string;
+    };
+    location?: {
+        line: number;
+        column: number;
+    };
+    remediation?: string;
+}
+export type LlmFallbackTier = "claude" | "morph";
+export interface LlmFallbackRejectedError {
+    kind: "LlmFallbackRejectedError";
+    tier: LlmFallbackTier;
+    failedGate: GateId;
+    diagnostics: string;
+}
+export interface LlmFallbackTimeoutError {
+    kind: "LlmFallbackTimeoutError";
+    tier: LlmFallbackTier;
+    elapsedMs: number;
+}
+export interface LlmFallbackUnsafeInputError {
+    kind: "LlmFallbackUnsafeInputError";
+    reason: EgressRiskReason;
+    count: number;
+}
+export type CodemodError = ParseError | TemplateLiteralNameError | DuplicateResourceError | ResourceNotFoundError | ReferencesRemainError | InvalidPropertyError | SemanticQueryError | DriftConflictError | DriftUnmergeableError | PermissionError | ControlFlowClassifierError | LlmFallbackRejectedError | LlmFallbackTimeoutError | LlmFallbackUnsafeInputError;

package/dist/src/codemod/types.js

@@ -1 +1 @@
-import{z as e}from"zod";const t=e.enum(["database","storage","compute","messaging","cdn","network","pattern"]),n=e.string().regex(/^[A-Z][A-Za-z0-9]*$/,"Resource name must start with an uppercase letter and contain only alphanumerics (PascalCase)."),o=e.record(e.string(),e.unknown()),c=e.object({type:t,name:n,properties:o,filePath:e.string().optional()}).strict(),m=e.object({type:t,name:n,filePath:e.string().optional(),force:e.boolean().optional()}).strict(),p=e.object({type:t,name:n,properties:o,filePath:e.string().optional()}).strict(),r=e.object({line:e.number().int().nonnegative(),column:e.number().int().nonnegative(),context:e.string()}).strict(),a=e.object({added:e.number().int().nonnegative(),removed:e.number().int().nonnegative()}).strict(),i=e.object({type:t,name:e.string(),filePath:e.string(),start:e.number().int().nonnegative(),length:e.number().int().nonnegative()}).strict(),g=e.object({filePath:e.string(),resources:e.array(i)}).strict(),h=e.object({content:e.string(),linesChanged:a,references:e.array(r).optional(),warnings:e.array(e.string()).optional()}).strict();export{c as AddOptionsSchema,h as CodemodSuccessSchema,a as LinesChangedSchema,p as ModifyOptionsSchema,r as ReferenceLocationSchema,m as RemoveOptionsSchema,i as ResourceListingEntrySchema,g as ResourceListingSchema,n as ResourceNameSchema,t as StatementTypeSchema};
+import{z as t}from"zod";import{VALIDATION_MESSAGES as i,VALIDATION_PATTERNS as c}from"../validation/patterns.js";const o=t.object({force:t.boolean().optional(),resolutionMap:t.record(t.string(),t.unknown()).optional()}).strict(),e=t.enum(["database","storage","compute","messaging","cdn","network","pattern","vpc-peer","vpc-peer-accepter","cross-plan-connection"]),n=t.string().regex(c.PASCAL_CASE,i.PASCAL_CASE),r=t.record(t.string(),t.unknown()),g=t.object({type:e,name:n,properties:r,filePath:t.string().optional(),driftPolicy:o.optional(),branch:t.string().optional()}).strict(),h=t.object({type:e,name:n,filePath:t.string().optional(),force:t.boolean().optional(),branch:t.string().optional()}).strict(),b=t.object({type:e,name:n,properties:r,filePath:t.string().optional(),driftPolicy:o.optional(),branch:t.string().optional()}).strict(),a=t.object({line:t.number().int().positive(),column:t.number().int().positive(),context:t.string()}).strict(),s=t.object({added:t.number().int().nonnegative(),removed:t.number().int().nonnegative()}).strict(),p=t.object({type:e,name:t.string(),filePath:t.string(),start:t.number().int().nonnegative(),length:t.number().int().nonnegative()}).strict(),S=t.object({filePath:t.string(),resources:t.array(p)}).strict(),u=t.object({content:t.string(),linesChanged:s,references:t.array(a).optional(),warnings:t.array(t.string()).optional()}).strict(),d=t.object({property:t.string(),base:t.unknown().optional(),theirs:t.unknown(),ours:t.unknown(),verdict:t.enum(["clean","no-op","compatible","conflict"])}).strict();export{g as AddOptionsSchema,u as CodemodSuccessSchema,o as DriftPolicySchema,s as LinesChangedSchema,b as ModifyOptionsSchema,d as PropertyDeltaSchema,a as ReferenceLocationSchema,h as RemoveOptionsSchema,p as ResourceListingEntrySchema,S as ResourceListingSchema,n as ResourceNameSchema,e as StatementTypeSchema};

package/dist/src/codemod/validationGate/gates/classify.d.ts

@@ -0,0 +1,2 @@
+import type { Gate } from "../types.js";
+export declare const classifyGate: Gate;

package/dist/src/codemod/validationGate/gates/classify.js

@@ -0,0 +1 @@
+import{success as p,failure as y}from"../../../types/Result.js";import{parse as m}from"../../fileRewriter/parse.js";import{classifyControlFlow as h}from"../../semanticIndex/classifyControlFlow.js";import{locateAllShapes as A}from"../../semanticIndex/locateByShape.js";const C=new Set(["loc","tokens","comments","original","range"]);function f(o){return typeof o=="object"&&o!==null&&typeof o.type=="string"}function S(o,i){if(!f(o))return;const e=[{node:o,ancestors:[]}];for(;e.length>0;){const t=e.pop();if(t===void 0)continue;const{node:n,ancestors:s}=t;if(n.type==="StringLiteral"&&typeof n.start=="number"&&n.start===i)return{node:n,ancestors:s};const c=[...s,n];for(const u of Object.keys(n)){if(C.has(u))continue;const r=n[u];if(Array.isArray(r))for(let a=r.length-1;a>=0;a-=1){const l=r[a];f(l)&&e.push({node:l,ancestors:c})}else f(r)&&e.push({node:r,ancestors:c})}}}const g={conditional:"try-catch",loop:"loop","function-body":"anonymous-helper",unknown:"anonymous-helper"};function d(o){const i=A(o);if(!i.success)return[];const e=m(o);if(!e.success)return[];const t=[];for(const n of i.data){const s=S(e.data,n.start);if(s===void 0)continue;const c=h(s.node,s.ancestors);t.push({name:n.symbolName,type:n.type,classification:c})}return t}const O={id:"classify",run(o){if(o.inputContent===void 0)return p({action:"proceed"});const i=d(o.inputContent),e=d(o.content);for(const t of e){const n=i.find(s=>s.name===t.name&&s.type===t.type);if(n!==void 0&&n.classification==="top-level"&&t.classification!=="top-level")return y({kind:"ControlFlowClassifierError",reason:g[t.classification],resource:{type:t.type,name:t.name},location:void 0,remediation:"The LLM output moved a resource into a conditional or loop scope."})}return p({action:"proceed"})}};export{O as classifyGate};

package/dist/src/codemod/validationGate/gates/drift.d.ts

@@ -0,0 +1,2 @@
+import type { Gate } from "../types.js";
+export declare const driftGate: Gate;

package/dist/src/codemod/validationGate/gates/drift.js

@@ -0,0 +1 @@
+import{failure as i,success as o}from"../../../types/Result.js";import{detectDrift as n}from"../../drift/index.js";import{resolveDriftPolicy as f}from"../../edits/driftPolicy.js";const d={id:"drift",run(r){if(r.baseline===void 0)return o({action:"proceed"});const t=n(r.content,r.plan,r.baseline);if(!t.success)return i(t.error);const e=f(t.data,r.plan.op,r.policy);return e.action==="reject"?i({kind:"DriftConflictError",resource:e.driftState.resource,deltas:e.driftState.deltas,baselineSource:"file"}):o({action:e.action,driftState:e.driftState})}};export{d as driftGate};