@aetherwing/fcp-terraform 0.1.0

package/dist/ops.js

@@ -0,0 +1,346 @@
+import { findByLabel, addBlock, removeBlock, addConnection, removeConnection, createBlock, generateId, makeAttribute, rebuildLabelIndex, } from "./model.js";
+export function dispatchOp(op, config, log) {
+    const handler = HANDLERS[op.verb];
+    if (!handler) {
+        return { success: false, message: `unhandled verb "${op.verb}"` };
+    }
+    return handler(op, config, log);
+}
+// ── Verb handlers ──────────────────────────────────────────
+function handleAdd(op, config, log) {
+    const subKind = op.positionals[0]?.toLowerCase();
+    switch (subKind) {
+        case "resource": {
+            const fullType = op.positionals[1];
+            const label = op.positionals[2];
+            if (!fullType || !label) {
+                return { success: false, message: "add resource requires TYPE and LABEL" };
+            }
+            const block = createBlock("resource", fullType, label, op.params, op.quotedParams);
+            const err = addBlock(config, block);
+            if (err)
+                return { success: false, message: err };
+            log.append({ type: "block_added", block: structuredClone(block) });
+            return { success: true, message: `resource ${fullType}.${label}`, prefix: "+" };
+        }
+        case "provider": {
+            const name = op.positionals[1];
+            if (!name)
+                return { success: false, message: "add provider requires PROVIDER name" };
+            const block = createBlock("provider", name, name, op.params, op.quotedParams);
+            block.provider = name;
+            const err = addBlock(config, block);
+            if (err)
+                return { success: false, message: err };
+            log.append({ type: "block_added", block: structuredClone(block) });
+            return { success: true, message: `provider "${name}"`, prefix: "+" };
+        }
+        case "variable": {
+            const label = op.positionals[1];
+            if (!label)
+                return { success: false, message: "add variable requires NAME" };
+            const block = createBlock("variable", "variable", label, op.params, op.quotedParams);
+            block.provider = "";
+            const err = addBlock(config, block);
+            if (err)
+                return { success: false, message: err };
+            log.append({ type: "block_added", block: structuredClone(block) });
+            return { success: true, message: `variable "${label}"`, prefix: "+" };
+        }
+        case "output": {
+            const label = op.positionals[1];
+            if (!label)
+                return { success: false, message: "add output requires NAME" };
+            const block = createBlock("output", "output", label, op.params, op.quotedParams);
+            block.provider = "";
+            const err = addBlock(config, block);
+            if (err)
+                return { success: false, message: err };
+            log.append({ type: "block_added", block: structuredClone(block) });
+            return { success: true, message: `output "${label}"`, prefix: "+" };
+        }
+        case "data": {
+            const fullType = op.positionals[1];
+            const label = op.positionals[2];
+            if (!fullType || !label) {
+                return { success: false, message: "add data requires TYPE and LABEL" };
+            }
+            const block = createBlock("data", fullType, label, op.params, op.quotedParams);
+            block.kind = "data";
+            const err = addBlock(config, block);
+            if (err)
+                return { success: false, message: err };
+            log.append({ type: "block_added", block: structuredClone(block) });
+            return { success: true, message: `data ${fullType}.${label}`, prefix: "+" };
+        }
+        case "module": {
+            const label = op.positionals[1];
+            if (!label)
+                return { success: false, message: "add module requires LABEL" };
+            const block = createBlock("module", "module", label, op.params, op.quotedParams);
+            block.provider = "";
+            block.kind = "module";
+            const err = addBlock(config, block);
+            if (err)
+                return { success: false, message: err };
+            log.append({ type: "block_added", block: structuredClone(block) });
+            return { success: true, message: `module "${label}"`, prefix: "+" };
+        }
+        default:
+            return { success: false, message: `unknown add type "${subKind}". Use: resource, provider, variable, output, data, module` };
+    }
+}
+function handleSet(op, config, log) {
+    const label = op.positionals[0];
+    if (!label)
+        return { success: false, message: "set requires a block LABEL" };
+    const block = findByLabel(config, label);
+    if (!block)
+        return { success: false, message: `block "${label}" not found` };
+    const keys = Object.keys(op.params);
+    if (keys.length === 0)
+        return { success: false, message: "set requires at least one key:value" };
+    for (const [k, v] of Object.entries(op.params)) {
+        const before = block.attributes.get(k) ?? null;
+        const after = makeAttribute(k, v, op.quotedParams?.has(k));
+        block.attributes.set(k, after);
+        log.append({ type: "attribute_set", blockId: block.id, key: k, before: before ? structuredClone(before) : null, after: structuredClone(after) });
+    }
+    return { success: true, message: `${label}: set ${keys.join(", ")}`, prefix: "*" };
+}
+function handleRemove(op, config, log) {
+    // Selector-based removal
+    if (op.selectors.length > 0) {
+        const resolved = resolveSelectors(op.selectors, config);
+        if (resolved.length === 0)
+            return { success: false, message: "no blocks match selector" };
+        for (const block of resolved) {
+            removeBlock(config, block.id);
+            log.append({ type: "block_removed", block: structuredClone(block) });
+        }
+        return { success: true, message: `removed ${resolved.length} block(s)`, prefix: "@" };
+    }
+    // Label-based removal
+    const label = op.positionals[0];
+    if (!label)
+        return { success: false, message: "remove requires LABEL or @selector" };
+    const block = findByLabel(config, label);
+    if (!block)
+        return { success: false, message: `block "${label}" not found` };
+    removeBlock(config, block.id);
+    log.append({ type: "block_removed", block: structuredClone(block) });
+    return { success: true, message: `${block.kind} "${label}"`, prefix: "-" };
+}
+function handleConnect(op, config, log) {
+    // Expect: positionals = ["source", "->", "target"]
+    const arrowIdx = op.positionals.indexOf("->");
+    if (arrowIdx < 0)
+        return { success: false, message: "connect requires SRC -> TGT" };
+    const srcLabel = op.positionals.slice(0, arrowIdx).join(" ");
+    const tgtLabel = op.positionals.slice(arrowIdx + 1).join(" ");
+    if (!srcLabel || !tgtLabel)
+        return { success: false, message: "connect requires SRC -> TGT" };
+    const src = findByLabel(config, srcLabel);
+    const tgt = findByLabel(config, tgtLabel);
+    if (!src)
+        return { success: false, message: `source "${srcLabel}" not found` };
+    if (!tgt)
+        return { success: false, message: `target "${tgtLabel}" not found` };
+    const conn = {
+        id: generateId(),
+        sourceId: src.id,
+        targetId: tgt.id,
+        sourceLabel: src.label,
+        targetLabel: tgt.label,
+        label: op.params["label"],
+    };
+    addConnection(config, conn);
+    log.append({ type: "connection_added", connection: structuredClone(conn) });
+    return { success: true, message: `${srcLabel} -> ${tgtLabel}`, prefix: "~" };
+}
+function handleDisconnect(op, config, log) {
+    const arrowIdx = op.positionals.indexOf("->");
+    if (arrowIdx < 0)
+        return { success: false, message: "disconnect requires SRC -> TGT" };
+    const srcLabel = op.positionals.slice(0, arrowIdx).join(" ");
+    const tgtLabel = op.positionals.slice(arrowIdx + 1).join(" ");
+    const src = findByLabel(config, srcLabel);
+    const tgt = findByLabel(config, tgtLabel);
+    if (!src || !tgt)
+        return { success: false, message: "source or target not found" };
+    for (const [id, conn] of config.connections) {
+        if (conn.sourceId === src.id && conn.targetId === tgt.id) {
+            removeConnection(config, id);
+            log.append({ type: "connection_removed", connection: structuredClone(conn) });
+            return { success: true, message: `${srcLabel} -> ${tgtLabel}`, prefix: "-" };
+        }
+    }
+    return { success: false, message: `no connection from "${srcLabel}" to "${tgtLabel}"` };
+}
+function handleLabel(op, config, log) {
+    const oldLabel = op.positionals[0];
+    const newLabel = op.positionals[1];
+    if (!oldLabel || !newLabel)
+        return { success: false, message: "label requires OLD_LABEL NEW_LABEL" };
+    const block = findByLabel(config, oldLabel);
+    if (!block)
+        return { success: false, message: `block "${oldLabel}" not found` };
+    // Check for type+label conflict
+    for (const existing of config.blocks.values()) {
+        if (existing.id !== block.id && existing.fullType === block.fullType && existing.label.toLowerCase() === newLabel.toLowerCase()) {
+            return { success: false, message: `${block.fullType} "${newLabel}" already exists` };
+        }
+    }
+    const before = block.label;
+    block.label = newLabel;
+    rebuildLabelIndex(config);
+    log.append({ type: "block_renamed", blockId: block.id, before, after: newLabel });
+    return { success: true, message: `"${before}" → "${newLabel}"`, prefix: "*" };
+}
+function applyTags(block, tagsStr, log) {
+    const pairs = tagsStr.split(",").map((p) => p.trim());
+    for (const pair of pairs) {
+        const eqIdx = pair.indexOf("=");
+        if (eqIdx < 0)
+            continue;
+        const key = pair.slice(0, eqIdx).trim();
+        const val = pair.slice(eqIdx + 1).trim();
+        const before = block.tags.get(key) ?? null;
+        block.tags.set(key, val);
+        log.append({ type: "tag_set", blockId: block.id, key, before, after: val });
+    }
+}
+function handleStyle(op, config, log) {
+    const tagsStr = op.params["tags"];
+    if (!tagsStr)
+        return { success: false, message: "style requires tags:\"Key=Val,Key2=Val2\"" };
+    // Selector-based styling
+    if (op.selectors.length > 0) {
+        const resolved = resolveSelectors(op.selectors, config);
+        if (resolved.length === 0)
+            return { success: false, message: "no blocks match selector" };
+        for (const block of resolved) {
+            applyTags(block, tagsStr, log);
+        }
+        return { success: true, message: `styled ${resolved.length} block(s)`, prefix: "@" };
+    }
+    // Label-based styling
+    const label = op.positionals[0];
+    if (!label)
+        return { success: false, message: "style requires LABEL or @selector" };
+    const block = findByLabel(config, label);
+    if (!block)
+        return { success: false, message: `block "${label}" not found` };
+    applyTags(block, tagsStr, log);
+    return { success: true, message: `${label}: tags set`, prefix: "*" };
+}
+function handleNest(op, config, log) {
+    const label = op.positionals[0];
+    const blockType = op.positionals[1];
+    if (!label || !blockType)
+        return { success: false, message: "nest requires LABEL BLOCK_TYPE" };
+    const block = findByLabel(config, label);
+    if (!block)
+        return { success: false, message: `block "${label}" not found` };
+    const attrs = new Map();
+    for (const [k, v] of Object.entries(op.params)) {
+        attrs.set(k, makeAttribute(k, v, op.quotedParams?.has(k)));
+    }
+    const nested = { id: generateId(), type: blockType, attributes: attrs };
+    block.nestedBlocks.push(nested);
+    log.append({ type: "nested_block_added", blockId: block.id, nestedBlock: structuredClone(nested) });
+    return { success: true, message: `${label}: ${blockType} block added`, prefix: "+" };
+}
+function handleUnset(op, config, log) {
+    const label = op.positionals[0];
+    if (!label)
+        return { success: false, message: "unset requires LABEL" };
+    const block = findByLabel(config, label);
+    if (!block)
+        return { success: false, message: `block "${label}" not found` };
+    const keys = op.positionals.slice(1);
+    if (keys.length === 0)
+        return { success: false, message: "unset requires at least one KEY" };
+    for (const key of keys) {
+        const before = block.attributes.get(key);
+        if (before) {
+            block.attributes.delete(key);
+            log.append({ type: "attribute_removed", blockId: block.id, key, before: structuredClone(before) });
+        }
+    }
+    return { success: true, message: `${label}: unset ${keys.join(", ")}`, prefix: "*" };
+}
+function handleUnnest(op, config, log) {
+    const label = op.positionals[0];
+    const blockType = op.positionals[1];
+    if (!label || !blockType)
+        return { success: false, message: "unnest requires LABEL BLOCK_TYPE [INDEX]" };
+    const block = findByLabel(config, label);
+    if (!block)
+        return { success: false, message: `block "${label}" not found` };
+    const matching = block.nestedBlocks.filter((nb) => nb.type === blockType);
+    if (matching.length === 0)
+        return { success: false, message: `no "${blockType}" nested block on "${label}"` };
+    const indexStr = op.positionals[2];
+    let target;
+    if (indexStr !== undefined) {
+        const idx = parseInt(indexStr, 10);
+        if (isNaN(idx) || idx < 0 || idx >= matching.length) {
+            return { success: false, message: `index ${indexStr} out of range (0-${matching.length - 1})` };
+        }
+        target = matching[idx];
+    }
+    else {
+        // Remove last block of that type
+        target = matching[matching.length - 1];
+    }
+    block.nestedBlocks = block.nestedBlocks.filter((nb) => nb.id !== target.id);
+    log.append({ type: "nested_block_removed", blockId: block.id, nestedBlock: structuredClone(target) });
+    return { success: true, message: `${label}: ${blockType} block removed`, prefix: "-" };
+}
+// ── Selector resolution ─────────────────────────────────
+function resolveSelectors(selectors, config) {
+    let results = [...config.blocks.values()];
+    for (const sel of selectors) {
+        if (sel === "@all")
+            continue;
+        if (sel.startsWith("@type:")) {
+            const type = sel.slice(6);
+            results = results.filter((b) => b.fullType === type);
+        }
+        else if (sel.startsWith("@kind:")) {
+            const kind = sel.slice(6);
+            results = results.filter((b) => b.kind === kind);
+        }
+        else if (sel.startsWith("@provider:")) {
+            const provider = sel.slice(10);
+            results = results.filter((b) => b.provider === provider);
+        }
+        else if (sel.startsWith("@tag:")) {
+            const tagExpr = sel.slice(5);
+            const eqIdx = tagExpr.indexOf("=");
+            if (eqIdx >= 0) {
+                const key = tagExpr.slice(0, eqIdx);
+                const val = tagExpr.slice(eqIdx + 1);
+                results = results.filter((b) => b.tags.get(key) === val);
+            }
+            else {
+                results = results.filter((b) => b.tags.has(tagExpr));
+            }
+        }
+    }
+    return results;
+}
+// ── Handler registry ────────────────────────────────────
+const HANDLERS = {
+    add: handleAdd,
+    set: handleSet,
+    remove: handleRemove,
+    connect: handleConnect,
+    disconnect: handleDisconnect,
+    label: handleLabel,
+    style: handleStyle,
+    nest: handleNest,
+    unnest: handleUnnest,
+    unset: handleUnset,
+};

package/dist/queries.d.ts

@@ -0,0 +1,4 @@
+import type { TerraformConfig } from "./types.js";
+import type { EventLog } from "@aetherwing/fcp-core";
+import type { TerraformEvent } from "./types.js";
+export declare function dispatchQuery(query: string, config: TerraformConfig, eventLog?: EventLog<TerraformEvent>): string | Promise<string>;

package/dist/queries.js

@@ -0,0 +1,250 @@
+import { serializeToHcl } from "./hcl.js";
+import { findByLabel, findByKind } from "./model.js";
+export function dispatchQuery(query, config, eventLog) {
+    const parts = query.trim().split(/\s+/);
+    const cmd = parts[0]?.toLowerCase() ?? "";
+    const args = parts.slice(1);
+    switch (cmd) {
+        case "map":
+            return queryMap(config);
+        case "list":
+            return queryList(config, args);
+        case "describe":
+            return queryDescribe(config, args[0]);
+        case "plan":
+            return queryPlan(config);
+        case "graph":
+            return queryGraph(config);
+        case "validate":
+            return queryValidate(config);
+        case "stats":
+            return queryStats(config);
+        case "status":
+            return queryStatus(config);
+        case "find":
+            return queryFind(config, args.join(" "));
+        case "history":
+            return queryHistory(eventLog, parseInt(args[0]) || 10);
+        default:
+            return `Unknown query: "${cmd}". Available: map, list, describe, plan, graph, validate, stats, status, find, history`;
+    }
+}
+function queryMap(config) {
+    const lines = [];
+    lines.push(`Terraform Config: ${config.title}`);
+    lines.push("");
+    const resources = findByKind(config, "resource");
+    const variables = findByKind(config, "variable");
+    const outputs = findByKind(config, "output");
+    const providers = findByKind(config, "provider");
+    const data = findByKind(config, "data");
+    if (providers.length > 0) {
+        lines.push(`Providers: ${providers.map((p) => p.label).join(", ")}`);
+    }
+    if (resources.length > 0) {
+        const typeCounts = new Map();
+        for (const r of resources) {
+            typeCounts.set(r.fullType, (typeCounts.get(r.fullType) ?? 0) + 1);
+        }
+        const types = [...typeCounts.entries()].map(([t, c]) => `${t} x${c}`).join(", ");
+        lines.push(`Resources (${resources.length}): ${types}`);
+    }
+    if (data.length > 0)
+        lines.push(`Data Sources: ${data.length}`);
+    if (variables.length > 0)
+        lines.push(`Variables: ${variables.length}`);
+    if (outputs.length > 0)
+        lines.push(`Outputs: ${outputs.length}`);
+    if (config.connections.size > 0)
+        lines.push(`Connections: ${config.connections.size}`);
+    return lines.join("\n");
+}
+function queryList(config, args) {
+    let blocks = [...config.blocks.values()];
+    // Filter by selector if provided
+    if (args.length > 0 && args[0].startsWith("@")) {
+        const sel = args[0];
+        if (sel.startsWith("@type:")) {
+            const type = sel.slice(6);
+            blocks = blocks.filter((b) => b.fullType === type);
+        }
+        else if (sel.startsWith("@kind:")) {
+            const kind = sel.slice(6);
+            blocks = blocks.filter((b) => b.kind === kind);
+        }
+        else if (sel.startsWith("@provider:")) {
+            const provider = sel.slice(10);
+            blocks = blocks.filter((b) => b.provider === provider);
+        }
+    }
+    if (blocks.length === 0)
+        return "No blocks found.";
+    const lines = [];
+    for (const block of blocks) {
+        const type = block.kind === "resource" || block.kind === "data"
+            ? `${block.fullType}.${block.label}`
+            : `${block.kind}.${block.label}`;
+        const attrCount = block.attributes.size;
+        lines.push(`  ${block.kind.padEnd(10)} ${type.padEnd(35)} (${attrCount} attrs)`);
+    }
+    return lines.join("\n");
+}
+function queryDescribe(config, label) {
+    if (!label)
+        return "describe requires a LABEL";
+    const block = findByLabel(config, label);
+    if (!block)
+        return `block "${label}" not found`;
+    const lines = [];
+    const ref = block.kind === "resource" || block.kind === "data"
+        ? `${block.fullType}.${block.label}`
+        : `${block.kind} "${block.label}"`;
+    lines.push(`${block.kind}: ${ref}`);
+    if (block.provider)
+        lines.push(`  provider: ${block.provider}`);
+    if (block.attributes.size > 0) {
+        lines.push("  attributes:");
+        for (const attr of block.attributes.values()) {
+            lines.push(`    ${attr.key} = ${attr.valueType === "string" ? `"${attr.value}"` : attr.value} (${attr.valueType})`);
+        }
+    }
+    if (block.tags.size > 0) {
+        lines.push("  tags:");
+        for (const [k, v] of block.tags) {
+            lines.push(`    ${k} = "${v}"`);
+        }
+    }
+    if (block.nestedBlocks.length > 0) {
+        lines.push("  nested blocks:");
+        for (const nested of block.nestedBlocks) {
+            lines.push(`    ${nested.type} {}`);
+            for (const attr of nested.attributes.values()) {
+                lines.push(`      ${attr.key} = ${attr.value}`);
+            }
+        }
+    }
+    // Show connections
+    const conns = [...config.connections.values()].filter((c) => c.sourceId === block.id || c.targetId === block.id);
+    if (conns.length > 0) {
+        lines.push("  connections:");
+        for (const c of conns) {
+            if (c.sourceId === block.id) {
+                lines.push(`    → ${c.targetLabel}`);
+            }
+            else {
+                lines.push(`    ← ${c.sourceLabel}`);
+            }
+        }
+    }
+    if (block.meta.count)
+        lines.push(`  count: ${block.meta.count}`);
+    if (block.meta.forEach)
+        lines.push(`  for_each: ${block.meta.forEach}`);
+    if (block.meta.dependsOn.length > 0)
+        lines.push(`  depends_on: ${block.meta.dependsOn.join(", ")}`);
+    return lines.join("\n");
+}
+async function queryPlan(config) {
+    if (config.blocks.size === 0)
+        return "Empty configuration. Add some resources first.";
+    const hcl = serializeToHcl(config);
+    try {
+        const { parse } = await import("@cdktf/hcl2json");
+        await parse("plan.tf", hcl);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return hcl + `\n\n⚠ HCL validation failed: ${msg}`;
+    }
+    return hcl;
+}
+function queryGraph(config) {
+    if (config.connections.size === 0)
+        return "No connections. Use 'connect SRC -> TGT' to add dependencies.";
+    const lines = ["Dependency Graph:"];
+    for (const conn of config.connections.values()) {
+        const src = config.blocks.get(conn.sourceId);
+        const tgt = config.blocks.get(conn.targetId);
+        if (src && tgt) {
+            const label = conn.label ? ` (${conn.label})` : "";
+            lines.push(`  ${src.label} -> ${tgt.label}${label}`);
+        }
+    }
+    return lines.join("\n");
+}
+function queryValidate(config) {
+    const issues = [];
+    for (const block of config.blocks.values()) {
+        if (block.kind === "resource" && block.attributes.size === 0 && block.nestedBlocks.length === 0) {
+            issues.push(`  WARNING: resource ${block.fullType}.${block.label} has no attributes`);
+        }
+        if (block.kind === "output" && !block.attributes.has("value")) {
+            issues.push(`  ERROR: output "${block.label}" missing required "value" attribute`);
+        }
+        if (block.kind === "module" && !block.attributes.has("source")) {
+            issues.push(`  ERROR: module "${block.label}" missing required "source" attribute`);
+        }
+    }
+    // Check for dangling connections
+    for (const conn of config.connections.values()) {
+        if (!config.blocks.has(conn.sourceId)) {
+            issues.push(`  ERROR: connection references missing source block`);
+        }
+        if (!config.blocks.has(conn.targetId)) {
+            issues.push(`  ERROR: connection references missing target block`);
+        }
+    }
+    if (issues.length === 0)
+        return "Configuration is valid.";
+    return `Found ${issues.length} issue(s):\n${issues.join("\n")}`;
+}
+function queryStats(config) {
+    const counts = new Map();
+    for (const block of config.blocks.values()) {
+        counts.set(block.kind, (counts.get(block.kind) ?? 0) + 1);
+    }
+    const lines = [`Total blocks: ${config.blocks.size}`];
+    for (const [kind, count] of counts) {
+        lines.push(`  ${kind}: ${count}`);
+    }
+    lines.push(`Connections: ${config.connections.size}`);
+    return lines.join("\n");
+}
+function queryStatus(config) {
+    const lines = [];
+    lines.push(`Title: ${config.title}`);
+    lines.push(`File: ${config.filePath ?? "(unsaved)"}`);
+    lines.push(`Blocks: ${config.blocks.size}`);
+    lines.push(`Connections: ${config.connections.size}`);
+    return lines.join("\n");
+}
+function queryFind(config, text) {
+    if (!text)
+        return "find requires search text";
+    const lower = text.toLowerCase();
+    const matches = [...config.blocks.values()].filter((b) => b.label.toLowerCase().includes(lower) || b.fullType.toLowerCase().includes(lower));
+    if (matches.length === 0)
+        return `No blocks matching "${text}"`;
+    return matches.map((b) => `  ${b.kind} ${b.fullType}.${b.label}`).join("\n");
+}
+function queryHistory(eventLog, count) {
+    if (!eventLog)
+        return "No event log available.";
+    const events = eventLog.recent(count);
+    if (events.length === 0)
+        return "No events.";
+    return events.map((e, i) => {
+        switch (e.type) {
+            case "block_added": return `  ${i + 1}. + ${e.block.kind} ${e.block.label}`;
+            case "block_removed": return `  ${i + 1}. - ${e.block.kind} ${e.block.label}`;
+            case "attribute_set": return `  ${i + 1}. * set ${e.key} on block`;
+            case "attribute_removed": return `  ${i + 1}. * unset ${e.key}`;
+            case "connection_added": return `  ${i + 1}. ~ ${e.connection.sourceLabel} -> ${e.connection.targetLabel}`;
+            case "connection_removed": return `  ${i + 1}. - disconnect`;
+            case "tag_set": return `  ${i + 1}. * tag ${e.key}`;
+            case "tag_removed": return `  ${i + 1}. - tag ${e.key}`;
+            case "block_renamed": return `  ${i + 1}. * rename ${e.before} → ${e.after}`;
+            default: return `  ${i + 1}. ${e.type}`;
+        }
+    }).join("\n");
+}