@intentius/chant-lexicon-helm 0.0.16

package/src/import/generator.ts

@@ -0,0 +1,285 @@
+/**
+ * TypeScript code generator for Helm chart import.
+ *
+ * Converts a TemplateIR (from parsed Helm charts) into TypeScript source code
+ * using @intentius/chant-lexicon-helm and @intentius/chant-lexicon-k8s constructors,
+ * mapping Go template expressions to Helm intrinsics.
+ */
+
+import type { TypeScriptGenerator, GeneratedFile } from "@intentius/chant/import/generator";
+import type { TemplateIR, ResourceIR } from "@intentius/chant/import/parser";
+import type { ExpressionKind } from "./template-stripper";
+
+/** K8s type to class name mapping. */
+const K8S_TYPE_TO_CLASS: Record<string, string> = {
+  "K8s::Core::Pod": "Pod",
+  "K8s::Core::Service": "Service",
+  "K8s::Core::ConfigMap": "ConfigMap",
+  "K8s::Core::Secret": "Secret",
+  "K8s::Core::ServiceAccount": "ServiceAccount",
+  "K8s::Apps::Deployment": "Deployment",
+  "K8s::Apps::StatefulSet": "StatefulSet",
+  "K8s::Apps::DaemonSet": "DaemonSet",
+  "K8s::Batch::Job": "Job",
+  "K8s::Batch::CronJob": "CronJob",
+  "K8s::Networking::Ingress": "Ingress",
+  "K8s::Networking::NetworkPolicy": "NetworkPolicy",
+  "K8s::Rbac::Role": "Role",
+  "K8s::Rbac::ClusterRole": "ClusterRole",
+  "K8s::Rbac::RoleBinding": "RoleBinding",
+  "K8s::Rbac::ClusterRoleBinding": "ClusterRoleBinding",
+  "K8s::Autoscaling::HorizontalPodAutoscaler": "HorizontalPodAutoscaler",
+  "K8s::Policy::PodDisruptionBudget": "PodDisruptionBudget",
+};
+
+/** Helm type to class name mapping. */
+const HELM_TYPE_TO_CLASS: Record<string, string> = {
+  "Helm::Chart": "Chart",
+  "Helm::Values": "Values",
+  "Helm::Notes": "HelmNotes",
+};
+
+export class HelmGenerator implements TypeScriptGenerator {
+  generate(ir: TemplateIR): GeneratedFile[] {
+    const lines: string[] = [];
+    const helmImports = new Set<string>();
+    const k8sImports = new Set<string>();
+    const intrinsicImports = new Set<string>();
+
+    // Classify resources and collect needed imports
+    for (const resource of ir.resources) {
+      const helmClass = HELM_TYPE_TO_CLASS[resource.type];
+      if (helmClass) {
+        helmImports.add(helmClass);
+      } else {
+        const k8sClass = this.resolveK8sClass(resource.type);
+        if (k8sClass) k8sImports.add(k8sClass);
+      }
+
+      // Scan for template expressions to determine intrinsic imports
+      this.collectIntrinsicImports(resource, intrinsicImports);
+    }
+
+    // Emit imports
+    if (helmImports.size > 0) {
+      lines.push(`import { ${[...helmImports].sort().join(", ")} } from "@intentius/chant-lexicon-helm";`);
+    }
+    if (intrinsicImports.size > 0) {
+      lines.push(`import { ${[...intrinsicImports].sort().join(", ")} } from "@intentius/chant-lexicon-helm";`);
+    }
+    if (k8sImports.size > 0) {
+      lines.push(`import { ${[...k8sImports].sort().join(", ")} } from "@intentius/chant-lexicon-k8s";`);
+    }
+    lines.push("");
+
+    // Emit resources
+    for (const resource of ir.resources) {
+      const cls = HELM_TYPE_TO_CLASS[resource.type] ?? this.resolveK8sClass(resource.type);
+      if (!cls) {
+        lines.push(`// TODO: unsupported type ${resource.type} (${resource.logicalId})`);
+        lines.push("");
+        continue;
+      }
+
+      // Replace placeholders with intrinsic calls in properties
+      const props = this.substituteExpressions(resource.properties, resource.metadata?.templateExpressions as Record<string, { expression: string; kind: string }> | undefined);
+      const propsStr = this.emitProps(props, 1);
+
+      lines.push(`export const ${resource.logicalId} = new ${cls}(${propsStr});`);
+      lines.push("");
+    }
+
+    return [{ path: "chart.ts", content: lines.join("\n") }];
+  }
+
+  private resolveK8sClass(type: string): string | undefined {
+    if (K8S_TYPE_TO_CLASS[type]) return K8S_TYPE_TO_CLASS[type];
+    const parts = type.split("::");
+    if (parts.length === 3 && parts[0] === "K8s") return parts[2];
+    return undefined;
+  }
+
+  private collectIntrinsicImports(resource: ResourceIR, imports: Set<string>): void {
+    const exprs = resource.metadata?.templateExpressions as Record<string, { expression: string; kind: string }> | undefined;
+    if (!exprs) return;
+
+    for (const entry of Object.values(exprs)) {
+      const kind = entry.kind as ExpressionKind;
+      switch (kind) {
+        case "values": imports.add("values"); break;
+        case "release": imports.add("Release"); break;
+        case "chart": imports.add("ChartRef"); break;
+        case "include": imports.add("include"); break;
+        case "toYaml": imports.add("toYaml"); imports.add("values"); break;
+        case "required": imports.add("required"); imports.add("values"); break;
+        case "default": imports.add("helmDefault"); imports.add("values"); break;
+        case "printf": imports.add("printf"); break;
+        case "quote": imports.add("quote"); imports.add("values"); break;
+        case "lookup": imports.add("lookup"); break;
+        case "tpl": imports.add("tpl"); break;
+      }
+    }
+  }
+
+  /**
+   * Walk through properties, replacing placeholder strings with intrinsic call representations.
+   */
+  private substituteExpressions(
+    props: Record<string, unknown>,
+    exprs: Record<string, { expression: string; kind: string }> | undefined,
+  ): Record<string, unknown> {
+    if (!exprs) return props;
+    return this.walkAndReplace(props, exprs) as Record<string, unknown>;
+  }
+
+  private walkAndReplace(
+    value: unknown,
+    exprs: Record<string, { expression: string; kind: string }>,
+  ): unknown {
+    if (typeof value === "string") {
+      // Check if the entire string is a placeholder
+      const expr = exprs[value];
+      if (expr) {
+        return { __intrinsicCall: this.expressionToIntrinsic(expr.expression, expr.kind as ExpressionKind) };
+      }
+      // Check if the string contains placeholders mixed with text
+      let result = value;
+      for (const [placeholder, entry] of Object.entries(exprs)) {
+        if (result.includes(placeholder)) {
+          result = result.replace(placeholder, `\${${this.expressionToIntrinsic(entry.expression, entry.kind as ExpressionKind)}}`);
+        }
+      }
+      if (result !== value) {
+        return { __intrinsicCall: result };
+      }
+      return value;
+    }
+
+    if (Array.isArray(value)) {
+      return value.map((item) => this.walkAndReplace(item, exprs));
+    }
+
+    if (value && typeof value === "object") {
+      const result: Record<string, unknown> = {};
+      for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+        result[k] = this.walkAndReplace(v, exprs);
+      }
+      return result;
+    }
+
+    return value;
+  }
+
+  /**
+   * Convert a Go template expression to a TypeScript intrinsic call string.
+   */
+  private expressionToIntrinsic(expression: string, kind: ExpressionKind): string {
+    switch (kind) {
+      case "values": {
+        const path = expression.replace(/^\.Values\./, "");
+        return `values.${path}`;
+      }
+      case "release": {
+        const field = expression.replace(/^\.Release\./, "");
+        return `Release.${field}`;
+      }
+      case "chart": {
+        const field = expression.replace(/^\.Chart\./, "");
+        return `ChartRef.${field}`;
+      }
+      case "include": {
+        const match = expression.match(/^include\s+"([^"]+)"\s+(.+)$/);
+        if (match) return `include("${match[1]}")`;
+        return `include(${JSON.stringify(expression)})`;
+      }
+      case "toYaml": {
+        const match = expression.match(/toYaml\s+(.+?)(?:\s*\|\s*nindent\s+(\d+))?$/);
+        if (match) {
+          const ref = this.refToIntrinsic(match[1]);
+          return match[2] ? `toYaml(${ref}, ${match[2]})` : `toYaml(${ref})`;
+        }
+        return `toYaml(${JSON.stringify(expression)})`;
+      }
+      case "required": {
+        const match = expression.match(/^required\s+"([^"]+)"\s+(.+)$/);
+        if (match) return `required("${match[1]}", ${this.refToIntrinsic(match[2])})`;
+        return `required(${JSON.stringify(expression)})`;
+      }
+      case "default": {
+        const match = expression.match(/^default\s+"([^"]+)"\s+(.+)$/);
+        if (match) return `helmDefault("${match[1]}", ${this.refToIntrinsic(match[2])})`;
+        return `helmDefault(${JSON.stringify(expression)})`;
+      }
+      case "printf": {
+        const match = expression.match(/^printf\s+"([^"]+)"\s+(.+)$/);
+        if (match) {
+          const args = match[2].split(/\s+/).map((a) => this.refToIntrinsic(a));
+          return `printf("${match[1]}", ${args.join(", ")})`;
+        }
+        return `printf(${JSON.stringify(expression)})`;
+      }
+      case "quote":
+        return `quote(${this.refToIntrinsic(expression.replace(/\s*\|\s*quote\s*$/, ""))})`;
+      case "lookup":
+        return `lookup(${JSON.stringify(expression)})`;
+      case "tpl":
+        return `tpl(${JSON.stringify(expression)})`;
+      default:
+        return `/* ${expression} */`;
+    }
+  }
+
+  /**
+   * Convert a Go template reference to a TypeScript expression.
+   */
+  private refToIntrinsic(ref: string): string {
+    const trimmed = ref.trim();
+    if (trimmed.startsWith(".Values.")) return `values.${trimmed.slice(8)}`;
+    if (trimmed.startsWith(".Release.")) return `Release.${trimmed.slice(9)}`;
+    if (trimmed.startsWith(".Chart.")) return `ChartRef.${trimmed.slice(7)}`;
+    if (trimmed === ".") return "context";
+    return JSON.stringify(trimmed);
+  }
+
+  private emitProps(props: Record<string, unknown>, depth: number): string {
+    const indent = "  ".repeat(depth);
+    const innerIndent = "  ".repeat(depth + 1);
+    const entries: string[] = [];
+
+    for (const [key, value] of Object.entries(props)) {
+      if (value === undefined || value === null) continue;
+      entries.push(`${innerIndent}${key}: ${this.emitValue(value, depth + 1)},`);
+    }
+
+    if (entries.length === 0) return "{}";
+    return `{\n${entries.join("\n")}\n${indent}}`;
+  }
+
+  private emitValue(value: unknown, depth: number): string {
+    if (value === null || value === undefined) return "undefined";
+
+    // Intrinsic call placeholder
+    if (typeof value === "object" && value !== null && "__intrinsicCall" in value) {
+      return (value as { __intrinsicCall: string }).__intrinsicCall;
+    }
+
+    if (typeof value === "string") return JSON.stringify(value);
+    if (typeof value === "number" || typeof value === "boolean") return String(value);
+
+    if (Array.isArray(value)) {
+      if (value.length === 0) return "[]";
+      const items = value.map((item) => this.emitValue(item, depth + 1));
+      const oneLine = `[${items.join(", ")}]`;
+      if (oneLine.length < 80) return oneLine;
+      const indent = "  ".repeat(depth);
+      const innerIndent = "  ".repeat(depth + 1);
+      return `[\n${items.map((i) => `${innerIndent}${i},`).join("\n")}\n${indent}]`;
+    }
+
+    if (typeof value === "object") {
+      return this.emitProps(value as Record<string, unknown>, depth);
+    }
+
+    return String(value);
+  }
+}

package/src/import/import.test.ts

@@ -0,0 +1,224 @@
+import { describe, test, expect } from "bun:test";
+import { stripTemplateExpressions, classifyExpression } from "./template-stripper";
+import { HelmParser } from "./parser";
+import { HelmGenerator } from "./generator";
+
+describe("template-stripper", () => {
+  test("strips inline expressions and replaces with placeholders", () => {
+    const template = `name: {{ .Values.name }}\nport: {{ .Values.service.port }}`;
+    const result = stripTemplateExpressions(template);
+    expect(result.yaml).toContain("__HELM_PLACEHOLDER0__");
+    expect(result.yaml).toContain("__HELM_PLACEHOLDER1__");
+    expect(result.expressions.size).toBe(2);
+  });
+
+  test("removes standalone block directives", () => {
+    const template = `{{- if .Values.ingress.enabled }}\napiVersion: v1\n{{- end }}`;
+    const result = stripTemplateExpressions(template);
+    expect(result.yaml).not.toContain("if .Values");
+    expect(result.yaml).not.toContain("end");
+    expect(result.yaml).toContain("apiVersion: v1");
+    expect(result.blockDirectives).toHaveLength(2);
+  });
+
+  test("handles whitespace-trimming markers", () => {
+    const template = `name: {{- .Values.name -}}`;
+    const result = stripTemplateExpressions(template);
+    expect(result.expressions.size).toBe(1);
+    const expr = [...result.expressions.values()][0];
+    expect(expr.expression).toBe(".Values.name");
+  });
+
+  test("preserves non-template lines", () => {
+    const template = `apiVersion: v1\nkind: Service\nmetadata:\n  name: {{ .Values.name }}`;
+    const result = stripTemplateExpressions(template);
+    expect(result.yaml).toContain("apiVersion: v1");
+    expect(result.yaml).toContain("kind: Service");
+  });
+});
+
+describe("classifyExpression", () => {
+  test("classifies .Values references", () => {
+    expect(classifyExpression(".Values.name")).toBe("values");
+    expect(classifyExpression(".Values.image.tag")).toBe("values");
+  });
+
+  test("classifies .Release references", () => {
+    expect(classifyExpression(".Release.Name")).toBe("release");
+  });
+
+  test("classifies .Chart references", () => {
+    expect(classifyExpression(".Chart.Name")).toBe("chart");
+  });
+
+  test("classifies include calls", () => {
+    expect(classifyExpression('include "my-app.fullname" .')).toBe("include");
+  });
+
+  test("classifies toYaml calls", () => {
+    expect(classifyExpression("toYaml .Values.resources | nindent 12")).toBe("toYaml");
+  });
+
+  test("classifies printf calls", () => {
+    expect(classifyExpression('printf "%s:%s" .Values.image.repo .Values.image.tag')).toBe("printf");
+  });
+
+  test("classifies pipe expressions", () => {
+    expect(classifyExpression(".Values.name | upper")).toBe("pipe");
+  });
+
+  test("classifies quote expressions", () => {
+    expect(classifyExpression(".Values.name | quote")).toBe("quote");
+  });
+});
+
+describe("HelmParser", () => {
+  test("parses Chart.yaml into Helm::Chart resource", () => {
+    const files = {
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\n",
+    };
+    const parser = new HelmParser();
+    const ir = parser.parseFiles(files);
+    const chartRes = ir.resources.find((r) => r.type === "Helm::Chart");
+    expect(chartRes).toBeDefined();
+    expect(chartRes!.properties.name).toBe("test");
+  });
+
+  test("parses values.yaml into parameters", () => {
+    const files = {
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\n",
+      "values.yaml": "replicaCount: 2\nimage:\n  repository: nginx\n  tag: latest\n",
+    };
+    const parser = new HelmParser();
+    const ir = parser.parseFiles(files);
+    expect(ir.parameters.length).toBeGreaterThan(0);
+    const replicaParam = ir.parameters.find((p) => p.name === "replicaCount");
+    expect(replicaParam).toBeDefined();
+    expect(replicaParam!.defaultValue).toBe(2);
+  });
+
+  test("parses template files as K8s resources", () => {
+    const files = {
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\n",
+      "templates/deploy.yaml": "apiVersion: apps/v1\nkind: Deployment\nmetadata:\n  name: test\n",
+    };
+    const parser = new HelmParser();
+    const ir = parser.parseFiles(files);
+    const deploy = ir.resources.find((r) => r.type === "K8s::Apps::Deployment");
+    expect(deploy).toBeDefined();
+  });
+
+  test("parses NOTES.txt as Helm::Notes", () => {
+    const files = {
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\n",
+      "templates/NOTES.txt": "Thank you for installing {{ .Chart.Name }}",
+    };
+    const parser = new HelmParser();
+    const ir = parser.parseFiles(files);
+    const notes = ir.resources.find((r) => r.type === "Helm::Notes");
+    expect(notes).toBeDefined();
+  });
+
+  test("strips Go template expressions from templates", () => {
+    const files = {
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\n",
+      "templates/svc.yaml": "apiVersion: v1\nkind: Service\nmetadata:\n  name: {{ include \"test.fullname\" . }}\n",
+    };
+    const parser = new HelmParser();
+    const ir = parser.parseFiles(files);
+    const svc = ir.resources.find((r) => r.type === "K8s::Core::Service");
+    expect(svc).toBeDefined();
+    expect(svc!.metadata?.templateExpressions).toBeDefined();
+  });
+
+  test("sets chart name in metadata", () => {
+    const files = {
+      "Chart.yaml": "apiVersion: v2\nname: my-app\nversion: 0.1.0\n",
+    };
+    const parser = new HelmParser();
+    const ir = parser.parseFiles(files);
+    expect(ir.metadata?.chartName).toBe("my-app");
+  });
+});
+
+describe("HelmGenerator", () => {
+  test("generates TypeScript with Helm imports", () => {
+    const ir = {
+      resources: [
+        { logicalId: "chart", type: "Helm::Chart", properties: { apiVersion: "v2", name: "test", version: "0.1.0" } },
+        { logicalId: "valuesSchema", type: "Helm::Values", properties: { replicaCount: 1 } },
+      ],
+      parameters: [],
+    };
+    const gen = new HelmGenerator();
+    const files = gen.generate(ir);
+    expect(files).toHaveLength(1);
+    expect(files[0].path).toBe("chart.ts");
+    expect(files[0].content).toContain("@intentius/chant-lexicon-helm");
+    expect(files[0].content).toContain("export const chart = new Chart(");
+    expect(files[0].content).toContain("export const valuesSchema = new Values(");
+  });
+
+  test("generates K8s resource imports", () => {
+    const ir = {
+      resources: [
+        {
+          logicalId: "deployment",
+          type: "K8s::Apps::Deployment",
+          properties: { metadata: { name: "test" } },
+        },
+      ],
+      parameters: [],
+    };
+    const gen = new HelmGenerator();
+    const files = gen.generate(ir);
+    expect(files[0].content).toContain("@intentius/chant-lexicon-k8s");
+    expect(files[0].content).toContain("export const deployment = new Deployment(");
+  });
+
+  test("substitutes template expressions with intrinsic calls", () => {
+    const ir = {
+      resources: [
+        {
+          logicalId: "service",
+          type: "K8s::Core::Service",
+          properties: {
+            metadata: { name: "__HELM_PLACEHOLDER0__" },
+          },
+          metadata: {
+            templateExpressions: {
+              "__HELM_PLACEHOLDER0__": { expression: 'include "test.fullname" .', kind: "include" },
+            },
+          },
+        },
+      ],
+      parameters: [],
+    };
+    const gen = new HelmGenerator();
+    const files = gen.generate(ir);
+    expect(files[0].content).toContain('include("test.fullname")');
+  });
+
+  test("imports intrinsics based on template expressions", () => {
+    const ir = {
+      resources: [
+        {
+          logicalId: "deploy",
+          type: "K8s::Apps::Deployment",
+          properties: { metadata: { name: "__HELM_PLACEHOLDER0__" }, spec: { replicas: "__HELM_PLACEHOLDER1__" } },
+          metadata: {
+            templateExpressions: {
+              "__HELM_PLACEHOLDER0__": { expression: 'include "test.fullname" .', kind: "include" },
+              "__HELM_PLACEHOLDER1__": { expression: ".Values.replicaCount", kind: "values" },
+            },
+          },
+        },
+      ],
+      parameters: [],
+    };
+    const gen = new HelmGenerator();
+    const files = gen.generate(ir);
+    expect(files[0].content).toContain("include");
+    expect(files[0].content).toContain("values");
+  });
+});

package/src/import/parser.ts

@@ -0,0 +1,160 @@
+/**
+ * Helm chart parser for `chant import`.
+ *
+ * Parses an existing Helm chart directory (Chart.yaml, values.yaml, templates/)
+ * into the core TemplateIR format, preserving Go template expressions as metadata
+ * for reconstruction as Helm intrinsics.
+ */
+
+import type { TemplateParser, TemplateIR, ResourceIR, ParameterIR } from "@intentius/chant/import/parser";
+import { parseYAML } from "@intentius/chant/yaml";
+import { stripTemplateExpressions, classifyExpression } from "./template-stripper";
+
+/**
+ * Helm chart parser.
+ *
+ * Input: a map of file paths to contents (as would be read from a chart directory).
+ * The parse() method accepts the contents as a JSON-encoded map.
+ */
+export class HelmParser implements TemplateParser {
+  parse(content: string): TemplateIR {
+    // Content is a JSON map of { "path": "content" }
+    const files: Record<string, string> = JSON.parse(content);
+    return this.parseFiles(files);
+  }
+
+  parseFiles(files: Record<string, string>): TemplateIR {
+    const resources: ResourceIR[] = [];
+    const parameters: ParameterIR[] = [];
+
+    // Parse Chart.yaml
+    const chartYaml = files["Chart.yaml"];
+    if (chartYaml) {
+      const chartData = parseYAML(chartYaml) as Record<string, unknown>;
+      resources.push({
+        logicalId: "chart",
+        type: "Helm::Chart",
+        properties: chartData,
+        metadata: { file: "Chart.yaml" },
+      });
+    }
+
+    // Parse values.yaml → extract parameters
+    const valuesYaml = files["values.yaml"];
+    if (valuesYaml) {
+      const valuesData = parseYAML(valuesYaml) as Record<string, unknown>;
+      if (valuesData && typeof valuesData === "object") {
+        resources.push({
+          logicalId: "valuesSchema",
+          type: "Helm::Values",
+          properties: valuesData,
+          metadata: { file: "values.yaml" },
+        });
+
+        // Flatten values into parameters
+        this.extractParameters(valuesData, "", parameters);
+      }
+    }
+
+    // Parse templates
+    for (const [path, content] of Object.entries(files)) {
+      if (!path.startsWith("templates/")) continue;
+      if (path.endsWith("_helpers.tpl")) continue;
+      if (path.endsWith("NOTES.txt")) {
+        resources.push({
+          logicalId: "notes",
+          type: "Helm::Notes",
+          properties: { content },
+          metadata: { file: path },
+        });
+        continue;
+      }
+
+      this.parseTemplate(path, content, resources);
+    }
+
+    return {
+      resources,
+      parameters,
+      metadata: {
+        chartName: (resources.find((r) => r.type === "Helm::Chart")?.properties?.name as string) ?? "unknown",
+      },
+    };
+  }
+
+  private parseTemplate(path: string, content: string, resources: ResourceIR[]): void {
+    const stripped = stripTemplateExpressions(content);
+    const parsed = parseYAML(stripped.yaml);
+
+    if (!parsed || typeof parsed !== "object") return;
+
+    const doc = parsed as Record<string, unknown>;
+    const apiVersion = doc.apiVersion as string | undefined;
+    const kind = doc.kind as string | undefined;
+
+    if (!apiVersion || !kind) return;
+
+    // Derive a logical ID from the file path
+    const fileName = path.replace("templates/", "").replace(/\.yaml$/, "").replace(/[/\\-]/g, "_");
+    const logicalId = kind.charAt(0).toLowerCase() + kind.slice(1) + capitalize(fileName);
+
+    // Restore template expressions as metadata
+    const templateExpressions: Record<string, { expression: string; kind: string }> = {};
+    for (const [placeholder, expr] of stripped.expressions) {
+      templateExpressions[placeholder] = {
+        expression: expr.expression,
+        kind: classifyExpression(expr.expression),
+      };
+    }
+
+    // Extract properties (skip apiVersion/kind)
+    const properties: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(doc)) {
+      if (key === "apiVersion" || key === "kind") continue;
+      properties[key] = value;
+    }
+
+    resources.push({
+      logicalId,
+      type: `K8s::${resolveGroup(apiVersion)}::${kind}`,
+      properties,
+      metadata: {
+        file: path,
+        apiVersion,
+        kind,
+        templateExpressions,
+        blockDirectives: stripped.blockDirectives,
+      },
+    });
+  }
+
+  private extractParameters(
+    obj: Record<string, unknown>,
+    prefix: string,
+    params: ParameterIR[],
+  ): void {
+    for (const [key, value] of Object.entries(obj)) {
+      const fullPath = prefix ? `${prefix}.${key}` : key;
+
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        this.extractParameters(value as Record<string, unknown>, fullPath, params);
+      } else {
+        params.push({
+          name: fullPath,
+          type: Array.isArray(value) ? "array" : typeof value,
+          defaultValue: value,
+        });
+      }
+    }
+  }
+}
+
+function resolveGroup(apiVersion: string): string {
+  if (!apiVersion.includes("/")) return "Core";
+  const group = apiVersion.split("/")[0].split(".")[0];
+  return group.charAt(0).toUpperCase() + group.slice(1);
+}
+
+function capitalize(s: string): string {
+  return s.split(/[_-]/).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}