@aetherwing/fcp-terraform 0.1.0

package/dist/hcl.js

@@ -0,0 +1,176 @@
+/**
+ * Serialize a TerraformConfig to valid HCL.
+ */
+export function serializeToHcl(config) {
+    const sections = [];
+    // Group blocks by kind in Terraform-idiomatic order
+    const providers = getBlocksByKind(config, "provider");
+    const variables = getBlocksByKind(config, "variable");
+    const data = getBlocksByKind(config, "data");
+    const resources = getBlocksByKind(config, "resource");
+    const modules = getBlocksByKind(config, "module");
+    const outputs = getBlocksByKind(config, "output");
+    for (const block of providers)
+        sections.push(serializeProvider(block));
+    for (const block of variables)
+        sections.push(serializeVariable(block));
+    for (const block of data)
+        sections.push(serializeData(block));
+    for (const block of modules)
+        sections.push(serializeModule(block));
+    for (const block of resources)
+        sections.push(serializeResource(block, config));
+    for (const block of outputs)
+        sections.push(serializeOutput(block));
+    return sections.join("\n\n") + "\n";
+}
+function getBlocksByKind(config, kind) {
+    return config.blockOrder
+        .map((id) => config.blocks.get(id))
+        .filter((b) => b && b.kind === kind);
+}
+function serializeProvider(block) {
+    const lines = [];
+    lines.push(`provider "${block.fullType}" {`);
+    for (const attr of block.attributes.values()) {
+        lines.push(`  ${formatAttribute(attr)}`);
+    }
+    lines.push("}");
+    return lines.join("\n");
+}
+function serializeVariable(block) {
+    const lines = [];
+    lines.push(`variable "${block.label}" {`);
+    for (const attr of block.attributes.values()) {
+        if (attr.key === "type") {
+            // type is unquoted in variables
+            lines.push(`  type    = ${attr.value}`);
+        }
+        else {
+            lines.push(`  ${formatAttribute(attr)}`);
+        }
+    }
+    lines.push("}");
+    return lines.join("\n");
+}
+function serializeData(block) {
+    const lines = [];
+    lines.push(`data "${block.fullType}" "${block.label}" {`);
+    for (const attr of block.attributes.values()) {
+        lines.push(`  ${formatAttribute(attr)}`);
+    }
+    for (const nested of block.nestedBlocks) {
+        lines.push(...serializeNestedBlock(nested, 2));
+    }
+    lines.push("}");
+    return lines.join("\n");
+}
+function serializeModule(block) {
+    const lines = [];
+    lines.push(`module "${block.label}" {`);
+    for (const attr of block.attributes.values()) {
+        lines.push(`  ${formatAttribute(attr)}`);
+    }
+    lines.push("}");
+    return lines.join("\n");
+}
+function serializeResource(block, config) {
+    const lines = [];
+    lines.push(`resource "${block.fullType}" "${block.label}" {`);
+    // Attributes
+    for (const attr of block.attributes.values()) {
+        lines.push(`  ${formatAttribute(attr)}`);
+    }
+    // Meta: count
+    if (block.meta.count) {
+        lines.push(`  count = ${block.meta.count}`);
+    }
+    if (block.meta.forEach) {
+        lines.push(`  for_each = ${block.meta.forEach}`);
+    }
+    // Tags
+    if (block.tags.size > 0) {
+        lines.push("");
+        lines.push("  tags = {");
+        for (const [k, v] of block.tags) {
+            lines.push(`    ${k} = "${v}"`);
+        }
+        lines.push("  }");
+    }
+    // Nested blocks
+    for (const nested of block.nestedBlocks) {
+        lines.push("");
+        lines.push(...serializeNestedBlock(nested, 2));
+    }
+    // depends_on from connections
+    const deps = getDependsOn(block, config);
+    if (deps.length > 0) {
+        lines.push("");
+        lines.push(`  depends_on = [${deps.join(", ")}]`);
+    }
+    // Explicit depends_on from meta
+    if (block.meta.dependsOn.length > 0) {
+        const existing = deps.length > 0;
+        if (!existing) {
+            lines.push("");
+            lines.push(`  depends_on = [${block.meta.dependsOn.join(", ")}]`);
+        }
+    }
+    lines.push("}");
+    return lines.join("\n");
+}
+function serializeOutput(block) {
+    const lines = [];
+    lines.push(`output "${block.label}" {`);
+    for (const attr of block.attributes.values()) {
+        if (attr.key === "value" && (attr.valueType === "reference" || attr.valueType === "expression")) {
+            lines.push(`  value = ${attr.value}`);
+        }
+        else {
+            lines.push(`  ${formatAttribute(attr)}`);
+        }
+    }
+    lines.push("}");
+    return lines.join("\n");
+}
+function serializeNestedBlock(nested, indent) {
+    const pad = " ".repeat(indent);
+    const lines = [];
+    lines.push(`${pad}${nested.type} {`);
+    for (const attr of nested.attributes.values()) {
+        lines.push(`${pad}  ${formatAttribute(attr)}`);
+    }
+    lines.push(`${pad}}`);
+    return lines;
+}
+function formatAttribute(attr) {
+    const padded = attr.key.padEnd(Math.max(attr.key.length, 4));
+    switch (attr.valueType) {
+        case "string":
+            return `${padded} = "${attr.value}"`;
+        case "number":
+        case "bool":
+        case "reference":
+            return `${padded} = ${attr.value}`;
+        case "expression":
+            return `${padded} = ${attr.value}`;
+        case "list":
+            return `${padded} = ${attr.value}`;
+        case "map":
+            return `${padded} = jsonencode(${attr.value})`;
+        default:
+            return `${padded} = "${attr.value}"`;
+    }
+}
+function getDependsOn(block, config) {
+    const deps = [];
+    for (const conn of config.connections.values()) {
+        if (conn.sourceId === block.id) {
+            const target = config.blocks.get(conn.targetId);
+            if (target && (target.kind === "resource" || target.kind === "data")) {
+                deps.push(`${target.fullType}.${target.label}`);
+            }
+        }
+    }
+    return deps;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export declare const server: any;
+export { TerraformAdapter } from "./adapter.js";
+export type { TerraformConfig, TerraformEvent, TfBlock, Connection, Attribute } from "./types.js";

package/dist/index.js

@@ -0,0 +1,14 @@
+import { createFcpServer } from "@aetherwing/fcp-core";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { TerraformAdapter } from "./adapter.js";
+import { VERB_SPECS, REFERENCE_CARD_SECTIONS } from "./verbs.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const server = createFcpServer({
+    domain: "terraform",
+    adapter: new TerraformAdapter(),
+    verbs: VERB_SPECS,
+    referenceCard: { sections: REFERENCE_CARD_SECTIONS },
+});
+const transport = new StdioServerTransport();
+await server.connect(transport);
+export { TerraformAdapter } from "./adapter.js";

package/dist/model.d.ts

@@ -0,0 +1,38 @@
+import type { TerraformConfig, TfBlock, Connection, Attribute } from "./types.js";
+export declare function generateId(): string;
+/**
+ * Derive provider name from a Terraform resource type.
+ * "aws_s3_bucket" → "aws", "google_compute_instance" → "google", "azurerm_resource_group" → "azurerm"
+ */
+export declare function deriveProvider(fullType: string): string;
+/**
+ * Create a new empty TerraformConfig.
+ */
+export declare function createEmptyConfig(title: string): TerraformConfig;
+export declare function rebuildLabelIndex(config: TerraformConfig): void;
+/**
+ * Find a block by label. Returns the block if the label is unambiguous
+ * (only one block has that label). Returns undefined if no match or ambiguous.
+ */
+export declare function findByLabel(config: TerraformConfig, label: string): TfBlock | undefined;
+/**
+ * Find a block by qualified label: "fullType.label" (e.g., "aws_vpc.main").
+ */
+export declare function findByQualifiedLabel(config: TerraformConfig, input: string): TfBlock | undefined;
+export declare function findByType(config: TerraformConfig, fullType: string): TfBlock[];
+export declare function findByKind(config: TerraformConfig, kind: string): TfBlock[];
+export declare function findByProvider(config: TerraformConfig, provider: string): TfBlock[];
+export declare function findConnections(config: TerraformConfig, blockId: string): Connection[];
+export declare function addBlock(config: TerraformConfig, block: TfBlock): string | null;
+export declare function removeBlock(config: TerraformConfig, id: string): TfBlock | null;
+export declare function addConnection(config: TerraformConfig, conn: Connection): void;
+export declare function removeConnection(config: TerraformConfig, id: string): Connection | null;
+/**
+ * Create an Attribute from a string value, inferring the type.
+ * When forceString is true, skip number/bool detection (user explicitly quoted the value).
+ */
+export declare function makeAttribute(key: string, value: string, forceString?: boolean): Attribute;
+/**
+ * Create a TfBlock from components.
+ */
+export declare function createBlock(kind: TfBlock["kind"], fullType: string, label: string, attrs: Record<string, string>, quotedParams?: Set<string>): TfBlock;

package/dist/model.js

@@ -0,0 +1,233 @@
+let idCounter = 0;
+export function generateId() {
+    return `tf_${(++idCounter).toString(36).padStart(4, "0")}_${Math.random().toString(36).slice(2, 6)}`;
+}
+/**
+ * Derive provider name from a Terraform resource type.
+ * "aws_s3_bucket" → "aws", "google_compute_instance" → "google", "azurerm_resource_group" → "azurerm"
+ */
+export function deriveProvider(fullType) {
+    const idx = fullType.indexOf("_");
+    return idx > 0 ? fullType.slice(0, idx) : fullType;
+}
+/**
+ * Create a new empty TerraformConfig.
+ */
+export function createEmptyConfig(title) {
+    return {
+        id: generateId(),
+        title,
+        filePath: null,
+        blocks: new Map(),
+        connections: new Map(),
+        blockOrder: [],
+    };
+}
+// ── Label index for O(1) lookup ─────────────────────────
+const labelIndex = new Map(); // label → block IDs
+export function rebuildLabelIndex(config) {
+    labelIndex.clear();
+    for (const [id, block] of config.blocks) {
+        const key = block.label.toLowerCase();
+        const ids = labelIndex.get(key);
+        if (ids) {
+            ids.push(id);
+        }
+        else {
+            labelIndex.set(key, [id]);
+        }
+    }
+}
+/**
+ * Find a block by label. Returns the block if the label is unambiguous
+ * (only one block has that label). Returns undefined if no match or ambiguous.
+ */
+export function findByLabel(config, label) {
+    // Try qualified label first (e.g., "aws_vpc.main")
+    const qualified = findByQualifiedLabel(config, label);
+    if (qualified)
+        return qualified;
+    const ids = labelIndex.get(label.toLowerCase());
+    if (!ids || ids.length === 0)
+        return undefined;
+    if (ids.length === 1)
+        return config.blocks.get(ids[0]);
+    // Ambiguous — multiple blocks share this label
+    return undefined;
+}
+/**
+ * Find a block by qualified label: "fullType.label" (e.g., "aws_vpc.main").
+ */
+export function findByQualifiedLabel(config, input) {
+    const dotIdx = input.indexOf(".");
+    if (dotIdx <= 0)
+        return undefined;
+    const typePart = input.slice(0, dotIdx);
+    const labelPart = input.slice(dotIdx + 1).toLowerCase();
+    const ids = labelIndex.get(labelPart);
+    if (!ids)
+        return undefined;
+    for (const id of ids) {
+        const block = config.blocks.get(id);
+        if (block && block.fullType === typePart)
+            return block;
+    }
+    return undefined;
+}
+export function findByType(config, fullType) {
+    const results = [];
+    for (const block of config.blocks.values()) {
+        if (block.fullType === fullType)
+            results.push(block);
+    }
+    return results;
+}
+export function findByKind(config, kind) {
+    const results = [];
+    for (const block of config.blocks.values()) {
+        if (block.kind === kind)
+            results.push(block);
+    }
+    return results;
+}
+export function findByProvider(config, provider) {
+    const results = [];
+    for (const block of config.blocks.values()) {
+        if (block.provider === provider)
+            results.push(block);
+    }
+    return results;
+}
+export function findConnections(config, blockId) {
+    const results = [];
+    for (const conn of config.connections.values()) {
+        if (conn.sourceId === blockId || conn.targetId === blockId)
+            results.push(conn);
+    }
+    return results;
+}
+export function addBlock(config, block) {
+    // Check uniqueness: reject only if same fullType AND same label
+    for (const existing of config.blocks.values()) {
+        if (existing.fullType === block.fullType && existing.label.toLowerCase() === block.label.toLowerCase()) {
+            return `${block.fullType} "${block.label}" already exists`;
+        }
+    }
+    config.blocks.set(block.id, block);
+    config.blockOrder.push(block.id);
+    const key = block.label.toLowerCase();
+    const ids = labelIndex.get(key);
+    if (ids) {
+        ids.push(block.id);
+    }
+    else {
+        labelIndex.set(key, [block.id]);
+    }
+    return null;
+}
+export function removeBlock(config, id) {
+    const block = config.blocks.get(id);
+    if (!block)
+        return null;
+    config.blocks.delete(id);
+    config.blockOrder = config.blockOrder.filter((bid) => bid !== id);
+    const key = block.label.toLowerCase();
+    const ids = labelIndex.get(key);
+    if (ids) {
+        const filtered = ids.filter((bid) => bid !== id);
+        if (filtered.length === 0) {
+            labelIndex.delete(key);
+        }
+        else {
+            labelIndex.set(key, filtered);
+        }
+    }
+    // Remove connections involving this block
+    for (const [connId, conn] of config.connections) {
+        if (conn.sourceId === id || conn.targetId === id) {
+            config.connections.delete(connId);
+        }
+    }
+    return block;
+}
+export function addConnection(config, conn) {
+    config.connections.set(conn.id, conn);
+}
+export function removeConnection(config, id) {
+    const conn = config.connections.get(id);
+    if (!conn)
+        return null;
+    config.connections.delete(id);
+    return conn;
+}
+/**
+ * Create an Attribute from a string value, inferring the type.
+ * When forceString is true, skip number/bool detection (user explicitly quoted the value).
+ */
+export function makeAttribute(key, value, forceString) {
+    if (!forceString) {
+        if (value === "true" || value === "false") {
+            return { key, value, valueType: "bool" };
+        }
+        if (/^\d+(\.\d+)?$/.test(value)) {
+            return { key, value, valueType: "number" };
+        }
+    }
+    if (value.startsWith("[") && value.endsWith("]")) {
+        // Parse list elements and quote non-reference/non-numeric/non-bool values
+        const inner = value.slice(1, -1).trim();
+        if (inner === "") {
+            return { key, value: "[]", valueType: "list" };
+        }
+        const elements = inner.split(",").map((e) => e.trim());
+        const quoted = elements.map((elem) => {
+            // References: aws_*, var.*, local.*, data.*, module.*, etc.
+            if (/^(aws_|google_|azurerm_|var\.|local\.|data\.|module\.)/.test(elem))
+                return elem;
+            // Numbers
+            if (/^\d+(\.\d+)?$/.test(elem))
+                return elem;
+            // Bools
+            if (elem === "true" || elem === "false")
+                return elem;
+            // Already quoted
+            if (elem.startsWith('"') && elem.endsWith('"'))
+                return elem;
+            // Everything else: quote it
+            return `"${elem}"`;
+        });
+        return { key, value: `[${quoted.join(", ")}]`, valueType: "list" };
+    }
+    if (value.startsWith("{")) {
+        // JSON object (contains ":") → use map type for jsonencode()
+        if (value.includes(":")) {
+            return { key, value, valueType: "map" };
+        }
+        return { key, value, valueType: "expression" };
+    }
+    // Check for Terraform references: aws_xxx.name.attr or var.xxx
+    if (/^(aws_|google_|azurerm_|var\.|local\.|data\.|module\.)/.test(value)) {
+        return { key, value, valueType: "reference" };
+    }
+    return { key, value, valueType: "string" };
+}
+/**
+ * Create a TfBlock from components.
+ */
+export function createBlock(kind, fullType, label, attrs, quotedParams) {
+    const attributes = new Map();
+    for (const [k, v] of Object.entries(attrs)) {
+        attributes.set(k, makeAttribute(k, v, quotedParams?.has(k)));
+    }
+    return {
+        id: generateId(),
+        kind,
+        label,
+        fullType,
+        provider: deriveProvider(fullType),
+        attributes,
+        nestedBlocks: [],
+        tags: new Map(),
+        meta: { dependsOn: [] },
+    };
+}

package/dist/ops.d.ts

@@ -0,0 +1,4 @@
+import type { ParsedOp, OpResult } from "@aetherwing/fcp-core";
+import type { EventLog } from "@aetherwing/fcp-core";
+import type { TerraformConfig, TerraformEvent } from "./types.js";
+export declare function dispatchOp(op: ParsedOp, config: TerraformConfig, log: EventLog<TerraformEvent>): OpResult;