@fjall/generator 0.88.4

package/dist/src/ast/astSurgicalModification.d.ts

@@ -0,0 +1,47 @@
+import { type StatementType, type CustomCodeBlock } from "./astInfrastructureParser.js";
+export interface SurgicalModificationResult {
+    content: string;
+    success: boolean;
+    error?: string;
+    /** e.g., orphaned custom code */
+    warnings?: string[];
+}
+export interface InsertionOptions {
+    /** The type of resource being inserted */
+    resourceType: StatementType;
+    /** The resource name (e.g., "MyDatabase") */
+    resourceName: string;
+    /** The code to insert (complete statement) */
+    code: string;
+    /** Insert after a specific resource (by name) */
+    afterResource?: {
+        type: StatementType;
+        name: string;
+    };
+}
+export interface UpdateOptions {
+    /** The type of resource being updated */
+    resourceType: StatementType;
+    /** The resource name to update */
+    resourceName: string;
+    /** The new code for the resource (complete statement) */
+    newCode: string;
+}
+export interface DeleteOptions {
+    /** The type of resource being deleted */
+    resourceType: StatementType;
+    /** The resource name to delete */
+    resourceName: string;
+    /** How to handle custom code that was after this resource */
+    orphanHandling: "preserve-with-warning" | "move-to-previous" | "delete";
+}
+export declare function addResourceSurgically(content: string, options: InsertionOptions): SurgicalModificationResult;
+export declare function updateResourceSurgically(content: string, options: UpdateOptions): SurgicalModificationResult;
+export declare function removeResourceSurgically(content: string, options: DeleteOptions): SurgicalModificationResult;
+export declare function ensureImports(content: string, requiredImports: string[]): SurgicalModificationResult;
+export declare function injectCustomCodeBlocks(generatedCode: string, customBlocks: CustomCodeBlock[], resourceMapping?: Map<string, string>): SurgicalModificationResult;
+export interface FileValidationResult {
+    valid: boolean;
+    errors?: string[];
+}
+export declare function validateModifiedFile(content: string): FileValidationResult;

package/dist/src/ast/astSurgicalModification.js

@@ -0,0 +1,400 @@
+import * as ts from "typescript";
+import { parseInfrastructure, classifyStatements, findManagedResourcePosition, } from "./astInfrastructureParser.js";
+import { getErrorMessage } from "../util/errorUtils.js";
+function insertAtPosition(content, position, text) {
+    return content.slice(0, position) + text + content.slice(position);
+}
+function findClassification(classifications, type) {
+    return classifications.find((c) => c.type === type);
+}
+function findLastClassification(classifications, type) {
+    return classifications.filter((c) => c.type === type).pop();
+}
+function parseSourceFile(content) {
+    return ts.createSourceFile("infrastructure.ts", content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+}
+function formatLeadingNewlines(beforeText, codeToInsert) {
+    if (beforeText.endsWith("\n\n") || codeToInsert.startsWith("\n")) {
+        return "";
+    }
+    if (!beforeText.endsWith("\n")) {
+        return "\n\n";
+    }
+    return "\n";
+}
+function getContextBeforePosition(content, position) {
+    return content.slice(Math.max(0, position - 2), position);
+}
+// getErrorMessage is now imported from errorUtils.ts
+function formatResourceId(type, name) {
+    return name ? `${type}:${name}` : type;
+}
+function createErrorResult(error, content) {
+    return { content, success: false, error: getErrorMessage(error) };
+}
+function findResourceOrFail(sourceFile, content, resourceType, resourceName) {
+    const resourcePos = findManagedResourcePosition(sourceFile, resourceType, resourceName);
+    if (!resourcePos) {
+        return createErrorResult(new Error(`Resource not found: ${formatResourceId(resourceType, resourceName)}`), content);
+    }
+    return resourcePos;
+}
+function isFailureResult(result) {
+    return "success" in result && !result.success;
+}
+export function addResourceSurgically(content, options) {
+    const { resourceType, code, afterResource } = options;
+    try {
+        const sourceFile = parseSourceFile(content);
+        let insertPosition;
+        if (afterResource) {
+            const afterPos = findManagedResourcePosition(sourceFile, afterResource.type, afterResource.name);
+            if (!afterPos) {
+                return createErrorResult(new Error(`Insertion target not found: ${formatResourceId(afterResource.type, afterResource.name)}`), content);
+            }
+            insertPosition = afterPos.endPos;
+        }
+        else {
+            insertPosition = findInsertionPositionByType(sourceFile, resourceType);
+        }
+        const codeToInsert = formatCodeForInsertion(content, insertPosition, code);
+        const newContent = insertAtPosition(content, insertPosition, codeToInsert);
+        return {
+            content: newContent,
+            success: true,
+        };
+    }
+    catch (error) {
+        return createErrorResult(error, content);
+    }
+}
+/**
+ * Find the best insertion position for a resource type.
+ * Resources are ordered: imports > app-init > tags > database > storage > compute > network > pattern
+ */
+function findInsertionPositionByType(sourceFile, resourceType) {
+    const classifications = classifyStatements(sourceFile);
+    // Define ordering for resource types
+    const typeOrder = [
+        "import",
+        "app-init",
+        "tags",
+        "database",
+        "storage",
+        "messaging",
+        "compute",
+        "network",
+        "cdn",
+        "pattern",
+    ];
+    const targetIndex = typeOrder.indexOf(resourceType);
+    // Find the last statement of the same type or earlier types
+    let lastRelevantStatement = null;
+    for (const classification of classifications) {
+        if (classification.isManaged) {
+            const classIndex = typeOrder.indexOf(classification.type);
+            if (classIndex !== -1 && classIndex <= targetIndex) {
+                lastRelevantStatement = classification;
+            }
+        }
+    }
+    if (lastRelevantStatement) {
+        return lastRelevantStatement.endPos;
+    }
+    // Fall back to end of file
+    return sourceFile.getEnd();
+}
+function formatCodeForInsertion(content, position, code) {
+    const beforeText = getContextBeforePosition(content, position);
+    const afterText = content.slice(position, Math.min(content.length, position + 2));
+    const leadingNewlines = formatLeadingNewlines(beforeText, code);
+    const trailingNewlines = afterText.startsWith("\n") ? "" : "\n";
+    return leadingNewlines + code + trailingNewlines;
+}
+export function updateResourceSurgically(content, options) {
+    const { resourceType, resourceName, newCode } = options;
+    try {
+        const sourceFile = parseSourceFile(content);
+        const result = findResourceOrFail(sourceFile, content, resourceType, resourceName);
+        if (isFailureResult(result))
+            return result;
+        const resourcePos = result;
+        // getFullStart() includes leading comments/whitespace
+        const fullStart = resourcePos.node.getFullStart();
+        const end = resourcePos.endPos;
+        // Preserve any leading whitespace from the original
+        const originalLeading = content.slice(fullStart, resourcePos.node.getStart());
+        const leadingWhitespace = extractLeadingWhitespace(originalLeading);
+        const newContent = content.slice(0, fullStart) +
+            leadingWhitespace +
+            newCode +
+            content.slice(end);
+        return {
+            content: newContent,
+            success: true,
+        };
+    }
+    catch (error) {
+        return createErrorResult(error, content);
+    }
+}
+function extractLeadingWhitespace(text) {
+    const match = text.match(/^[\s]*[\n\r]+[\s]*/);
+    return match ? match[0] : "";
+}
+// Track search offset to avoid matching the same location twice when
+// similar text appears in multiple places.
+function insertOrphanMarkers(content, blocks, resourceType, resourceName) {
+    let result = content;
+    let searchFrom = 0;
+    for (const block of blocks) {
+        const orphanComment = `// [ORPHANED: was after ${formatResourceId(resourceType, resourceName)}]\n`;
+        const trimmedText = block.sourceText.trim();
+        const blockPos = result.indexOf(trimmedText, searchFrom);
+        if (blockPos !== -1) {
+            result = insertAtPosition(result, blockPos, orphanComment);
+            searchFrom = blockPos + orphanComment.length + trimmedText.length;
+        }
+    }
+    return result;
+}
+export function removeResourceSurgically(content, options) {
+    const { resourceType, resourceName, orphanHandling } = options;
+    const warnings = [];
+    try {
+        const sourceFile = parseSourceFile(content);
+        const result = findResourceOrFail(sourceFile, content, resourceType, resourceName);
+        if (isFailureResult(result))
+            return result;
+        const resourcePos = result;
+        // Check for custom code blocks that reference this resource
+        const parsed = parseInfrastructure(content, { extractCustomCode: true });
+        const affectedCustomBlocks = (parsed.customCodeBlocks ?? []).filter((block) => block.position === "after-resource" &&
+            block.afterManagedResource?.type === resourceType &&
+            block.afterManagedResource?.name === resourceName);
+        if (affectedCustomBlocks.length > 0) {
+            if (orphanHandling === "preserve-with-warning") {
+                warnings.push(`Custom code after ${formatResourceId(resourceType, resourceName)} will be orphaned. ` +
+                    `Added // [ORPHANED] marker comment.`);
+            }
+        }
+        // Get the removal range including leading whitespace
+        const fullStart = resourcePos.node.getFullStart();
+        const end = resourcePos.endPos;
+        // Check if there's a trailing newline to clean up
+        const removeEnd = content[end] === "\n" ? end + 1 : end;
+        let newContent = content.slice(0, fullStart) + content.slice(removeEnd);
+        if (affectedCustomBlocks.length > 0 &&
+            orphanHandling === "preserve-with-warning") {
+            newContent = insertOrphanMarkers(newContent, affectedCustomBlocks, resourceType, resourceName);
+        }
+        return {
+            content: newContent,
+            success: true,
+            warnings: warnings.length > 0 ? warnings : undefined,
+        };
+    }
+    catch (error) {
+        return createErrorResult(error, content);
+    }
+}
+export function ensureImports(content, requiredImports) {
+    try {
+        const sourceFile = parseSourceFile(content);
+        const existingImports = new Set();
+        for (const statement of sourceFile.statements) {
+            if (ts.isImportDeclaration(statement)) {
+                existingImports.add(statement.getText(sourceFile).trim());
+            }
+        }
+        const importsToAdd = [];
+        for (const importStmt of requiredImports) {
+            const normalisedImport = importStmt.trim();
+            const exists = [...existingImports].some((existing) => importsAreEquivalent(existing, normalisedImport));
+            if (!exists) {
+                importsToAdd.push(normalisedImport);
+            }
+        }
+        if (importsToAdd.length === 0) {
+            return {
+                content,
+                success: true,
+            };
+        }
+        const lastImportEnd = sourceFile.statements.filter(ts.isImportDeclaration).at(-1)?.getEnd() ??
+            0;
+        const importText = "\n" + importsToAdd.join("\n");
+        const newContent = insertAtPosition(content, lastImportEnd, importText);
+        return {
+            content: newContent,
+            success: true,
+        };
+    }
+    catch (error) {
+        return createErrorResult(error, content);
+    }
+}
+function parseNamedImports(raw) {
+    return new Set(raw
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean));
+}
+/** Existing import (import1) is a superset of or equal to the required one (import2). */
+function existingImportCoversRequired(existingRaw, requiredRaw) {
+    const existing = parseNamedImports(existingRaw);
+    const required = parseNamedImports(requiredRaw);
+    for (const name of required) {
+        if (!existing.has(name))
+            return false;
+    }
+    return true;
+}
+/**
+ * Check if two import statements are equivalent (same module, overlapping named imports).
+ */
+function importsAreEquivalent(import1, import2) {
+    const moduleMatch1 = import1.match(FROM_MODULE_REGEX);
+    const moduleMatch2 = import2.match(FROM_MODULE_REGEX);
+    if (!moduleMatch1 || !moduleMatch2) {
+        return false;
+    }
+    if (moduleMatch1[1] !== moduleMatch2[1]) {
+        return false;
+    }
+    // Same module - compare named import bindings when both use them
+    const namedMatch1 = import1.match(NAMED_IMPORTS_REGEX);
+    const namedMatch2 = import2.match(NAMED_IMPORTS_REGEX);
+    if (namedMatch1 && namedMatch2) {
+        return existingImportCoversRequired(namedMatch1[1], namedMatch2[1]);
+    }
+    return true;
+}
+const FROM_MODULE_REGEX = /from\s+["']([^"']+)["']/;
+const NAMED_IMPORTS_REGEX = /\{([^}]+)\}/;
+const POSITION_ORDER = {
+    "before-imports": 0,
+    "after-imports": 1,
+    "after-app-init": 2,
+    "after-tags": 3,
+    "after-resource": 4,
+    "end-of-file": 5,
+};
+function sortCustomBlocksForInsertion(blocks) {
+    return [...blocks].sort((a, b) => {
+        const positionDiff = POSITION_ORDER[b.position] - POSITION_ORDER[a.position];
+        if (positionDiff !== 0)
+            return positionDiff;
+        return (b.originalLine ?? 0) - (a.originalLine ?? 0);
+    });
+}
+function insertOrOrphanBlock(content, block, insertPos, warnings) {
+    if (insertPos !== null) {
+        const codeToInsert = formatCustomCodeForInsertion(content, insertPos, block);
+        return insertAtPosition(content, insertPos, codeToInsert);
+    }
+    const orphanComment = block.afterManagedResource
+        ? `// [ORPHANED: was after ${formatResourceId(block.afterManagedResource.type, block.afterManagedResource.name)}]\n`
+        : "// [ORPHANED]\n";
+    warnings.push(`Custom code from line ${block.originalLine} could not be positioned. Added at end of file.`);
+    return content + "\n" + orphanComment + block.sourceText;
+}
+export function injectCustomCodeBlocks(generatedCode, customBlocks, resourceMapping) {
+    if (!customBlocks || customBlocks.length === 0) {
+        return { content: generatedCode, success: true };
+    }
+    try {
+        const sourceFile = parseSourceFile(generatedCode);
+        const classifications = classifyStatements(sourceFile);
+        const warnings = [];
+        const processedBlocks = sortCustomBlocksForInsertion(customBlocks);
+        let result = generatedCode;
+        for (const block of processedBlocks) {
+            const insertPos = findCustomCodeInsertPosition(sourceFile, classifications, block, resourceMapping, warnings);
+            result = insertOrOrphanBlock(result, block, insertPos, warnings);
+        }
+        return {
+            content: result,
+            success: true,
+            warnings: warnings.length > 0 ? warnings : undefined,
+        };
+    }
+    catch (error) {
+        return createErrorResult(error, generatedCode);
+    }
+}
+function findAfterResourcePosition(classifications, block, resourceMapping, warnings) {
+    if (!block.afterManagedResource)
+        return null;
+    const afterResource = block.afterManagedResource;
+    const targetName = (afterResource.name && resourceMapping?.get(afterResource.name)) ??
+        afterResource.name;
+    const resource = classifications.find((c) => c.type === afterResource.type && c.resourceName === targetName);
+    if (resource)
+        return resource.endPos;
+    // Fallback: if exactly one resource of this type, use it
+    const typeMatches = classifications.filter((c) => c.type === afterResource.type && c.isManaged);
+    if (typeMatches.length === 1)
+        return typeMatches[0].endPos;
+    if (warnings) {
+        warnings.push(`Resource ${formatResourceId(block.afterManagedResource.type, block.afterManagedResource.name)} not found. ` +
+            `Custom code may be orphaned.`);
+    }
+    return null;
+}
+function findCustomCodeInsertPosition(sourceFile, classifications, block, resourceMapping, warnings) {
+    switch (block.position) {
+        case "before-imports":
+            return 0;
+        case "after-imports":
+            return findLastClassification(classifications, "import")?.endPos ?? 0;
+        case "after-app-init":
+            return findClassification(classifications, "app-init")?.endPos ?? null;
+        case "after-tags":
+            return findClassification(classifications, "tags")?.endPos ?? null;
+        case "after-resource":
+            return findAfterResourcePosition(classifications, block, resourceMapping, warnings);
+        case "end-of-file":
+            return sourceFile.getEnd();
+        default:
+            return null;
+    }
+}
+function formatCustomCodeForInsertion(content, position, block) {
+    const beforeText = getContextBeforePosition(content, position);
+    let code = block.sourceText;
+    const leadingNewlines = formatLeadingNewlines(beforeText, code);
+    code = leadingNewlines + code;
+    if (!code.endsWith("\n")) {
+        code += "\n";
+    }
+    return code;
+}
+export function validateModifiedFile(content) {
+    try {
+        const sourceFile = parseSourceFile(content);
+        // ts.createSourceFile doesn't fully validate, but it catches major syntax errors
+        const diagnostics = [];
+        // Walk the tree looking for problematic nodes
+        function visit(node) {
+            if (node.kind === ts.SyntaxKind.Unknown) {
+                diagnostics.push("Unknown node found in AST - possible parse error");
+            }
+            ts.forEachChild(node, visit);
+        }
+        visit(sourceFile);
+        if (diagnostics.length > 0) {
+            return {
+                valid: false,
+                errors: diagnostics,
+            };
+        }
+        return { valid: true };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            errors: [getErrorMessage(error)],
+        };
+    }
+}

package/dist/src/ast/index.d.ts

@@ -0,0 +1,2 @@
+export { type ParsedInfrastructure, type ParsedDatabaseResource, type ParsedS3Resource, type ParsedComputeResource, type ParsedSQSResource, type ParsedCDNResource, type ParsedNetworkResource, type ParsedDynamoDBResource, type ParsedLambdaConfig, type ParsedPatternResource, type ImportInfo, type StatementType, type ClassifiedStatement, type CustomCodeBlock, parseInfrastructure, convertToResourcePlan, classifyStatements, extractCustomCodeBlocks, findManagedResourcePosition, getLastManagedStatementOfType, getManagedResourcesByType, } from "./astInfrastructureParser.js";
+export { type SurgicalModificationResult, type InsertionOptions, type UpdateOptions, type DeleteOptions, type FileValidationResult, addResourceSurgically, updateResourceSurgically, removeResourceSurgically, ensureImports, injectCustomCodeBlocks, validateModifiedFile, } from "./astSurgicalModification.js";

package/dist/src/ast/index.js

@@ -0,0 +1,2 @@
+export { parseInfrastructure, convertToResourcePlan, classifyStatements, extractCustomCodeBlocks, findManagedResourcePosition, getLastManagedStatementOfType, getManagedResourcesByType, } from "./astInfrastructureParser.js";
+export { addResourceSurgically, updateResourceSurgically, removeResourceSurgically, ensureImports, injectCustomCodeBlocks, validateModifiedFile, } from "./astSurgicalModification.js";

package/dist/src/aws/regions.d.ts

@@ -0,0 +1,30 @@
+export interface RegionInfo {
+    code: string;
+    name: string;
+    city: string;
+    country: string;
+}
+export declare const DEFAULT_REGION = "us-east-2";
+export declare const regions: readonly string[];
+export declare const AWS_REGIONS_METADATA: readonly RegionInfo[];
+export declare const topRegions: readonly RegionInfo[];
+export declare const commonRegions: readonly string[];
+export declare function parseRegionList(value: string): string[];
+export declare function isValidRegion(region: string): boolean;
+export declare function isValidRegionFormat(region: string): boolean;
+export declare function getSuggestions(input: string): string[];
+export declare function validateRegion(region: string): true | string;
+export declare function validateRegionList(value: string): string | boolean;
+export declare function filterDuplicateRegions(regions: string[], primaryRegion: string): string[];
+export declare function getRegionOptions(): Array<{
+    label: string;
+    value: string;
+    description: string;
+}>;
+export declare function getRegionOptionsExcluding(excludeCode: string): Array<{
+    label: string;
+    value: string;
+    description: string;
+}>;
+export declare function getRegionName(code: string): string;
+export declare function createRegionFormatter(primaryRegion: string): (value: string) => string[];