@intentius/chant-lexicon-helm 0.0.18 → 0.0.22

package/dist/integrity.json

@@ -1,7 +1,7 @@
 {
   "algorithm": "xxhash64",
   "artifacts": {
-    "manifest.json": "a843f902eae9b442",
+    "manifest.json": "21f64ba92bab7858",
     "meta.json": "b7aab243e162dfaf",
     "types/index.d.ts": "e8011da51963f058",
     "rules/no-hardcoded-image.ts": "c75aa9c33016c3b9",
@@ -30,7 +30,7 @@
     "rules/whm501.ts": "e9a9f2b4e034a51f",
     "skills/chant-helm-chart-patterns.md": "7a2163247f44bf6d",
     "skills/chant-helm-chart-security-patterns.md": "a7b950513dac7d37",
-    "skills/chant-helm-create-chart.md": "d2cb222caa70736e"
+    "skills/chant-helm-create-chart.md": "52df5756e29c32bf"
   },
-  "composite": "36daf1691f70425f"
+  "composite": "987b6dfc47cf4f5d"
 }

package/dist/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "helm",
-  "version": "0.0.18",
+  "version": "0.0.22",
   "chantVersion": ">=0.1.0",
   "namespace": "Helm",
   "intrinsics": [

package/dist/skills/chant-helm-create-chart.md

@@ -8,7 +8,7 @@ user-invocable: true
 
 ## How chant and Helm relate
 
-chant is a **synthesis-only** tool — it compiles TypeScript source files into a complete Helm chart directory (Chart.yaml, values.yaml, templates/, etc.). chant does NOT call Helm CLI. Your job as an agent is to bridge the two:
+chant is a **synthesis compiler** — it compiles TypeScript source files into a complete Helm chart directory (Chart.yaml, values.yaml, templates/, etc.). `chant build` does not call the Helm CLI; synthesis is pure and deterministic. Your job as an agent is to bridge synthesis and deployment:
 
 - Use **chant** for: build, lint, diff (local chart comparison)
 - Use **helm** for: install, upgrade, rollback, test, dependency update

package/package.json

@@ -1,7 +1,25 @@
 {
   "name": "@intentius/chant-lexicon-helm",
-  "version": "0.0.18",
+  "version": "0.0.22",
+  "description": "Helm chart lexicon for chant — declarative IaC in TypeScript",
   "license": "Apache-2.0",
+  "homepage": "https://intentius.io/chant",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/intentius/chant.git",
+    "directory": "lexicons/helm"
+  },
+  "bugs": {
+    "url": "https://github.com/intentius/chant/issues"
+  },
+  "keywords": [
+    "infrastructure-as-code",
+    "iac",
+    "typescript",
+    "helm",
+    "kubernetes",
+    "chant"
+  ],
   "type": "module",
   "files": [
     "src/",
@@ -25,8 +43,8 @@
     "prepack": "bun run generate && bun run bundle && bun run validate"
   },
   "dependencies": {
-    "@intentius/chant": "0.0.18",
-    "@intentius/chant-lexicon-k8s": "0.0.18"
+    "@intentius/chant": "0.0.22",
+    "@intentius/chant-lexicon-k8s": "0.0.22"
   },
   "devDependencies": {
     "typescript": "^5.9.3"

package/src/codegen/docs.test.ts

@@ -0,0 +1,14 @@
+import { describe, test, expect } from "bun:test";
+
+describe("Helm docs generation", () => {
+  test("docs module is importable", async () => {
+    const mod = await import("./docs");
+    expect(mod.generateDocs).toBeFunction();
+  });
+
+  test("generateDocs function signature accepts options", async () => {
+    const mod = await import("./docs");
+    // Verify the function exists and has the expected shape
+    expect(typeof mod.generateDocs).toBe("function");
+  });
+});

package/src/codegen/generate.test.ts

@@ -0,0 +1,71 @@
+import { describe, test, expect } from "bun:test";
+import { generate } from "./generate";
+
+describe("Helm generate pipeline", () => {
+  test("generate module is importable", async () => {
+    const mod = await import("./generate");
+    expect(mod.generate).toBeFunction();
+    expect(mod.writeGeneratedFiles).toBeFunction();
+  });
+
+  test("generates lexicon JSON, types, and index", async () => {
+    const result = await generate();
+    expect(result.lexiconJSON).toBeTruthy();
+    expect(result.typesDTS).toBeTruthy();
+    expect(result.indexTS).toBeTruthy();
+  });
+
+  test("lexicon JSON contains known resource types", async () => {
+    const result = await generate();
+    const registry = JSON.parse(result.lexiconJSON);
+    expect(registry.Chart).toBeDefined();
+    expect(registry.Chart.resourceType).toBe("Helm::Chart");
+    expect(registry.Chart.kind).toBe("resource");
+    expect(registry.Values).toBeDefined();
+    expect(registry.HelmHook).toBeDefined();
+    expect(registry.HelmHook.kind).toBe("property");
+  });
+
+  test("types DTS contains class declarations", async () => {
+    const result = await generate();
+    expect(result.typesDTS).toContain("export interface ChartProps");
+    expect(result.typesDTS).toContain("export declare const Chart");
+    expect(result.typesDTS).toContain("export interface ValuesProps");
+    expect(result.typesDTS).toContain("export declare const Values");
+  });
+
+  test("runtime index contains createResource calls", async () => {
+    const result = await generate();
+    expect(result.indexTS).toContain('createResource("Helm::Chart"');
+    expect(result.indexTS).toContain('createResource("Helm::Values"');
+    expect(result.indexTS).toContain('createProperty("Helm::Hook"');
+  });
+
+  test("resource and property counts are correct", async () => {
+    const result = await generate();
+    expect(result.resources).toBeGreaterThan(0);
+    expect(result.properties).toBeGreaterThan(0);
+    expect(result.enums).toBe(0);
+    expect(result.warnings).toHaveLength(0);
+  });
+
+  test("lexicon JSON contains all Helm types", async () => {
+    const result = await generate();
+    const registry = JSON.parse(result.lexiconJSON);
+    expect(registry.HelmTest).toBeDefined();
+    expect(registry.HelmNotes).toBeDefined();
+    expect(registry.HelmDependency).toBeDefined();
+    expect(registry.HelmMaintainer).toBeDefined();
+    expect(registry.HelmCRD).toBeDefined();
+  });
+
+  test("Chart props include required fields", async () => {
+    const result = await generate();
+    const registry = JSON.parse(result.lexiconJSON);
+    const chartProps = registry.Chart.props;
+    expect(chartProps.apiVersion).toBeDefined();
+    expect(chartProps.apiVersion.required).toBe(true);
+    expect(chartProps.name.required).toBe(true);
+    expect(chartProps.version.required).toBe(true);
+  });
+});

package/src/codegen/package.test.ts

@@ -0,0 +1,36 @@
+import { describe, test, expect } from "bun:test";
+import { packageLexicon } from "./package";
+
+describe("Helm package pipeline", () => {
+  test("packageLexicon is importable", async () => {
+    const mod = await import("./package");
+    expect(mod.packageLexicon).toBeFunction();
+  });
+
+  test("packageLexicon returns a valid result", async () => {
+    const result = await packageLexicon({ verbose: false });
+    expect(result).toBeDefined();
+    expect(result.spec).toBeDefined();
+    expect(result.spec.manifest).toBeDefined();
+    expect(result.spec.manifest.name).toBe("helm");
+    expect(result.spec.manifest.namespace).toBe("Helm");
+    expect(result.spec.manifest.chantVersion).toBeTruthy();
+  });
+
+  test("manifest contains intrinsics", async () => {
+    const result = await packageLexicon();
+    const intrinsics = result.spec.manifest.intrinsics;
+    expect(intrinsics).toBeDefined();
+    expect(intrinsics!.length).toBeGreaterThan(0);
+    const names = intrinsics!.map((i: { name: string }) => i.name);
+    expect(names).toContain("values");
+    expect(names).toContain("Release");
+    expect(names).toContain("include");
+  });
+
+  test("stats have resource and property counts", async () => {
+    const result = await packageLexicon();
+    expect(result.stats.resources).toBeGreaterThan(0);
+    expect(result.stats.properties).toBeGreaterThan(0);
+  });
+});

package/src/import/roundtrip.test.ts

@@ -0,0 +1,144 @@
+import { describe, test, expect } from "bun:test";
+import { HelmParser } from "./parser";
+import { HelmGenerator } from "./generator";
+
+const parser = new HelmParser();
+const generator = new HelmGenerator();
+
+describe("roundtrip: parse -> generate", () => {
+  test("minimal chart roundtrip", () => {
+    const files = {
+      "Chart.yaml": "apiVersion: v2\nname: my-app\nversion: 0.1.0\n",
+    };
+    const ir = parser.parseFiles(files);
+    const generated = generator.generate(ir);
+
+    expect(generated).toHaveLength(1);
+    expect(generated[0].path).toBe("chart.ts");
+    expect(generated[0].content).toContain("import");
+    expect(generated[0].content).toContain("export const chart = new Chart(");
+  });
+
+  test("chart with values roundtrip", () => {
+    const files = {
+      "Chart.yaml": "apiVersion: v2\nname: my-app\nversion: 0.1.0\n",
+      "values.yaml": "replicaCount: 2\nimage:\n  repository: nginx\n  tag: latest\n",
+    };
+    const ir = parser.parseFiles(files);
+    expect(ir.parameters.length).toBeGreaterThan(0);
+
+    const generated = generator.generate(ir);
+    const content = generated[0].content;
+    expect(content).toContain("Chart");
+    expect(content).toContain("Values");
+    expect(content).toContain("export const valuesSchema = new Values(");
+  });
+
+  test("Deployment template roundtrip", () => {
+    const files = {
+      "Chart.yaml": "apiVersion: v2\nname: my-app\nversion: 0.1.0\n",
+      "templates/deploy.yaml": "apiVersion: apps/v1\nkind: Deployment\nmetadata:\n  name: my-app\nspec:\n  replicas: 1\n",
+    };
+    const ir = parser.parseFiles(files);
+    const deploy = ir.resources.find((r) => r.type === "K8s::Apps::Deployment");
+    expect(deploy).toBeDefined();
+
+    const generated = generator.generate(ir);
+    const content = generated[0].content;
+    expect(content).toContain("@intentius/chant-lexicon-k8s");
+    expect(content).toContain("Deployment");
+    expect(content).toContain("export const");
+  });
+
+  test("Service template roundtrip", () => {
+    const files = {
+      "Chart.yaml": "apiVersion: v2\nname: my-app\nversion: 0.1.0\n",
+      "templates/svc.yaml": "apiVersion: v1\nkind: Service\nmetadata:\n  name: my-app\nspec:\n  type: ClusterIP\n  ports:\n    - port: 80\n",
+    };
+    const ir = parser.parseFiles(files);
+    const svc = ir.resources.find((r) => r.type === "K8s::Core::Service");
+    expect(svc).toBeDefined();
+
+    const generated = generator.generate(ir);
+    const content = generated[0].content;
+    expect(content).toContain("Service");
+  });
+
+  test("template expressions produce intrinsic imports", () => {
+    const files = {
+      "Chart.yaml": "apiVersion: v2\nname: my-app\nversion: 0.1.0\n",
+      "templates/deploy.yaml": 'apiVersion: apps/v1\nkind: Deployment\nmetadata:\n  name: {{ include "my-app.fullname" . }}\nspec:\n  replicas: {{ .Values.replicaCount }}\n',
+    };
+    const ir = parser.parseFiles(files);
+    const generated = generator.generate(ir);
+    const content = generated[0].content;
+    expect(content).toContain("include");
+    expect(content).toContain("values");
+  });
+
+  test("NOTES.txt roundtrip", () => {
+    const files = {
+      "Chart.yaml": "apiVersion: v2\nname: my-app\nversion: 0.1.0\n",
+      "templates/NOTES.txt": "Thank you for installing {{ .Chart.Name }}",
+    };
+    const ir = parser.parseFiles(files);
+    const notes = ir.resources.find((r) => r.type === "Helm::Notes");
+    expect(notes).toBeDefined();
+
+    const generated = generator.generate(ir);
+    expect(generated[0].content).toContain("HelmNotes");
+  });
+
+  test("full chart with multiple resources roundtrip", () => {
+    const files = {
+      "Chart.yaml": "apiVersion: v2\nname: my-app\nversion: 0.1.0\n",
+      "values.yaml": "replicaCount: 1\nimage:\n  repository: nginx\n  tag: stable\n",
+      "templates/deploy.yaml": "apiVersion: apps/v1\nkind: Deployment\nmetadata:\n  name: my-app\nspec:\n  replicas: {{ .Values.replicaCount }}\n",
+      "templates/svc.yaml": "apiVersion: v1\nkind: Service\nmetadata:\n  name: my-app\nspec:\n  type: ClusterIP\n",
+      "templates/NOTES.txt": "Thank you for installing my-app!",
+    };
+    const ir = parser.parseFiles(files);
+    expect(ir.resources.length).toBeGreaterThanOrEqual(4);
+
+    const generated = generator.generate(ir);
+    const content = generated[0].content;
+    expect(content).toContain("Chart");
+    expect(content).toContain("Values");
+    expect(content).toContain("Deployment");
+    expect(content).toContain("Service");
+    expect(content).toContain("HelmNotes");
+    expect(content).toContain("export const");
+  });
+
+  test("IR metadata captures chart name", () => {
+    const files = {
+      "Chart.yaml": "apiVersion: v2\nname: cool-app\nversion: 1.0.0\n",
+    };
+    const ir = parser.parseFiles(files);
+    expect(ir.metadata?.chartName).toBe("cool-app");
+  });
+
+  test("ConfigMap template roundtrip", () => {
+    const files = {
+      "Chart.yaml": "apiVersion: v2\nname: my-app\nversion: 0.1.0\n",
+      "templates/configmap.yaml": "apiVersion: v1\nkind: ConfigMap\nmetadata:\n  name: my-config\ndata:\n  key: value\n",
+    };
+    const ir = parser.parseFiles(files);
+    const cm = ir.resources.find((r) => r.type === "K8s::Core::ConfigMap");
+    expect(cm).toBeDefined();
+
+    const generated = generator.generate(ir);
+    expect(generated[0].content).toContain("ConfigMap");
+  });
+
+  test("skips _helpers.tpl files", () => {
+    const files = {
+      "Chart.yaml": "apiVersion: v2\nname: my-app\nversion: 0.1.0\n",
+      "templates/_helpers.tpl": '{{- define "my-app.fullname" -}}\n{{ .Release.Name }}\n{{- end -}}\n',
+    };
+    const ir = parser.parseFiles(files);
+    // Only the chart resource, no template from _helpers.tpl
+    expect(ir.resources).toHaveLength(1);
+    expect(ir.resources[0].type).toBe("Helm::Chart");
+  });
+});

package/src/lint/post-synth/whm101.test.ts

@@ -0,0 +1,69 @@
+import { describe, test, expect } from "bun:test";
+import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
+import type { SerializerResult } from "@intentius/chant/serializer";
+import { whm101 } from "./whm101";
+
+function makeCtx(files: Record<string, string>): PostSynthContext {
+  const result: SerializerResult = { primary: files["Chart.yaml"] ?? "", files };
+  const outputs = new Map<string, string | SerializerResult>();
+  outputs.set("helm", result);
+  return {
+    outputs,
+    entities: new Map(),
+    buildResult: {
+      outputs,
+      entities: new Map(),
+      warnings: [],
+      errors: [],
+      sourceFileCount: 1,
+    },
+  };
+}
+
+describe("WHM101: Chart.yaml validation", () => {
+  test("passes with valid Chart.yaml", () => {
+    const ctx = makeCtx({
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\n",
+    });
+    expect(whm101.check(ctx)).toHaveLength(0);
+  });
+
+  test("fails when Chart.yaml is missing", () => {
+    const ctx = makeCtx({});
+    const diags = whm101.check(ctx);
+    expect(diags.length).toBeGreaterThan(0);
+    expect(diags[0].message).toContain("missing");
+  });
+
+  test("fails when apiVersion is not v2", () => {
+    const ctx = makeCtx({
+      "Chart.yaml": "apiVersion: v1\nname: test\nversion: 0.1.0\n",
+    });
+    const diags = whm101.check(ctx);
+    expect(diags.some((d) => d.message.includes("v2"))).toBe(true);
+  });
+
+  test("fails when name is missing", () => {
+    const ctx = makeCtx({
+      "Chart.yaml": "apiVersion: v2\nversion: 0.1.0\n",
+    });
+    const diags = whm101.check(ctx);
+    expect(diags.some((d) => d.message.includes("name"))).toBe(true);
+  });
+
+  test("fails when version is missing", () => {
+    const ctx = makeCtx({
+      "Chart.yaml": "apiVersion: v2\nname: test\n",
+    });
+    const diags = whm101.check(ctx);
+    expect(diags.some((d) => d.message.includes("version"))).toBe(true);
+  });
+
+  test("all diagnostics have checkId WHM101", () => {
+    const ctx = makeCtx({});
+    const diags = whm101.check(ctx);
+    for (const d of diags) {
+      expect(d.checkId).toBe("WHM101");
+    }
+  });
+});

package/src/lint/post-synth/whm102.test.ts

@@ -0,0 +1,57 @@
+import { describe, test, expect } from "bun:test";
+import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
+import type { SerializerResult } from "@intentius/chant/serializer";
+import { whm102 } from "./whm102";
+
+function makeCtx(files: Record<string, string>): PostSynthContext {
+  const result: SerializerResult = { primary: files["Chart.yaml"] ?? "", files };
+  const outputs = new Map<string, string | SerializerResult>();
+  outputs.set("helm", result);
+  return {
+    outputs,
+    entities: new Map(),
+    buildResult: {
+      outputs,
+      entities: new Map(),
+      warnings: [],
+      errors: [],
+      sourceFileCount: 1,
+    },
+  };
+}
+
+describe("WHM102: values.schema.json", () => {
+  test("passes when schema exists", () => {
+    const ctx = makeCtx({
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\n",
+      "values.yaml": "replicaCount: 1\n",
+      "values.schema.json": "{}",
+    });
+    expect(whm102.check(ctx)).toHaveLength(0);
+  });
+
+  test("warns when values are non-empty but schema is missing", () => {
+    const ctx = makeCtx({
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\n",
+      "values.yaml": "replicaCount: 1\n",
+    });
+    const diags = whm102.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].checkId).toBe("WHM102");
+  });
+
+  test("passes when values.yaml is empty object", () => {
+    const ctx = makeCtx({
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\n",
+      "values.yaml": "{}",
+    });
+    expect(whm102.check(ctx)).toHaveLength(0);
+  });
+
+  test("passes when values.yaml is absent", () => {
+    const ctx = makeCtx({
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\n",
+    });
+    expect(whm102.check(ctx)).toHaveLength(0);
+  });
+});

package/src/lint/post-synth/whm103.test.ts

@@ -0,0 +1,58 @@
+import { describe, test, expect } from "bun:test";
+import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
+import type { SerializerResult } from "@intentius/chant/serializer";
+import { whm103 } from "./whm103";
+
+function makeCtx(files: Record<string, string>): PostSynthContext {
+  const result: SerializerResult = { primary: files["Chart.yaml"] ?? "", files };
+  const outputs = new Map<string, string | SerializerResult>();
+  outputs.set("helm", result);
+  return {
+    outputs,
+    entities: new Map(),
+    buildResult: {
+      outputs,
+      entities: new Map(),
+      warnings: [],
+      errors: [],
+      sourceFileCount: 1,
+    },
+  };
+}
+
+describe("WHM103: template syntax", () => {
+  test("passes with balanced braces", () => {
+    const ctx = makeCtx({
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\n",
+      "templates/deploy.yaml": "name: {{ .Values.name }}\n",
+    });
+    expect(whm103.check(ctx)).toHaveLength(0);
+  });
+
+  test("fails with unbalanced braces (missing closing)", () => {
+    const ctx = makeCtx({
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\n",
+      "templates/deploy.yaml": "name: {{ .Values.name }\n",
+    });
+    const diags = whm103.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].message).toContain("Unbalanced");
+    expect(diags[0].checkId).toBe("WHM103");
+  });
+
+  test("passes with multiple balanced expressions", () => {
+    const ctx = makeCtx({
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\n",
+      "templates/deploy.yaml": "name: {{ .Values.name }}\nimage: {{ .Values.image }}\n",
+    });
+    expect(whm103.check(ctx)).toHaveLength(0);
+  });
+
+  test("ignores non-template files", () => {
+    const ctx = makeCtx({
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\n",
+      "values.yaml": "name: {{ broken\n",
+    });
+    expect(whm103.check(ctx)).toHaveLength(0);
+  });
+});

package/src/lint/post-synth/whm104.test.ts

@@ -0,0 +1,57 @@
+import { describe, test, expect } from "bun:test";
+import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
+import type { SerializerResult } from "@intentius/chant/serializer";
+import { whm104 } from "./whm104";
+
+function makeCtx(files: Record<string, string>): PostSynthContext {
+  const result: SerializerResult = { primary: files["Chart.yaml"] ?? "", files };
+  const outputs = new Map<string, string | SerializerResult>();
+  outputs.set("helm", result);
+  return {
+    outputs,
+    entities: new Map(),
+    buildResult: {
+      outputs,
+      entities: new Map(),
+      warnings: [],
+      errors: [],
+      sourceFileCount: 1,
+    },
+  };
+}
+
+describe("WHM104: NOTES.txt", () => {
+  test("info when NOTES.txt is missing for application chart", () => {
+    const ctx = makeCtx({
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\ntype: application\n",
+    });
+    const diags = whm104.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].severity).toBe("info");
+    expect(diags[0].checkId).toBe("WHM104");
+  });
+
+  test("passes for library charts without NOTES.txt", () => {
+    const ctx = makeCtx({
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\ntype: library\n",
+    });
+    expect(whm104.check(ctx)).toHaveLength(0);
+  });
+
+  test("passes when NOTES.txt exists", () => {
+    const ctx = makeCtx({
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\ntype: application\n",
+      "templates/NOTES.txt": "Hello!",
+    });
+    expect(whm104.check(ctx)).toHaveLength(0);
+  });
+
+  test("info when type is absent (defaults to application)", () => {
+    const ctx = makeCtx({
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\n",
+    });
+    const diags = whm104.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].severity).toBe("info");
+  });
+});

package/src/lint/post-synth/whm105.test.ts

@@ -0,0 +1,41 @@
+import { describe, test, expect } from "bun:test";
+import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
+import type { SerializerResult } from "@intentius/chant/serializer";
+import { whm105 } from "./whm105";
+
+function makeCtx(files: Record<string, string>): PostSynthContext {
+  const result: SerializerResult = { primary: files["Chart.yaml"] ?? "", files };
+  const outputs = new Map<string, string | SerializerResult>();
+  outputs.set("helm", result);
+  return {
+    outputs,
+    entities: new Map(),
+    buildResult: {
+      outputs,
+      entities: new Map(),
+      warnings: [],
+      errors: [],
+      sourceFileCount: 1,
+    },
+  };
+}
+
+describe("WHM105: _helpers.tpl", () => {
+  test("warns when _helpers.tpl is missing", () => {
+    const ctx = makeCtx({
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\n",
+    });
+    const diags = whm105.check(ctx);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].checkId).toBe("WHM105");
+    expect(diags[0].severity).toBe("warning");
+  });
+
+  test("passes when _helpers.tpl exists", () => {
+    const ctx = makeCtx({
+      "Chart.yaml": "apiVersion: v2\nname: test\nversion: 0.1.0\n",
+      "templates/_helpers.tpl": "{{/* helpers */}}",
+    });
+    expect(whm105.check(ctx)).toHaveLength(0);
+  });
+});