@intentius/chant-lexicon-gitlab 0.0.4 → 0.0.8

package/src/codegen/generate-lexicon.ts

@@ -29,7 +29,7 @@ export function generateLexiconJSON(
     typeName: r.resource.typeName,
     attributes: r.resource.attributes,
     properties: r.resource.properties,
-    propertyTypes: r.propertyTypes.map((pt) => ({ name: pt.name, cfnType: pt.defType })),
+    propertyTypes: r.propertyTypes.map((pt) => ({ name: pt.name, specType: pt.defType })),
   }));
 
   const entries = buildRegistry<LexiconEntry>(registryResources, naming, {

package/src/codegen/package.ts

@@ -3,7 +3,9 @@
  * with GitLab-specific manifest building and skill collection.
  */
 
+import { createRequire } from "module";
 import { readFileSync } from "fs";
+const require = createRequire(import.meta.url);
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import type { IntrinsicDef } from "@intentius/chant/lexicon";

package/src/codegen/parse.test.ts

@@ -5,9 +5,9 @@ import { loadSchemaFixture } from "../testdata/load-fixtures";
 const fixture = loadSchemaFixture();
 
 describe("parseCISchema", () => {
-  test("returns 15 entities", () => {
+  test("returns 16 entities", () => {
     const results = parseCISchema(fixture);
-    expect(results).toHaveLength(15);
+    expect(results).toHaveLength(16);
   });
 
   test("returns 3 resource entities", () => {
@@ -20,14 +20,15 @@ describe("parseCISchema", () => {
     expect(names).toContain("GitLab::CI::Workflow");
   });
 
-  test("returns 12 property entities", () => {
+  test("returns 13 property entities", () => {
     const results = parseCISchema(fixture);
     const properties = results.filter((r) => r.isProperty);
-    expect(properties).toHaveLength(12);
+    expect(properties).toHaveLength(13);
     const names = properties.map((r) => r.resource.typeName);
     expect(names).toContain("GitLab::CI::Artifacts");
     expect(names).toContain("GitLab::CI::Cache");
     expect(names).toContain("GitLab::CI::Image");
+    expect(names).toContain("GitLab::CI::Service");
     expect(names).toContain("GitLab::CI::Rule");
     expect(names).toContain("GitLab::CI::Retry");
     expect(names).toContain("GitLab::CI::AllowFailure");

package/src/codegen/parse.ts

@@ -132,6 +132,7 @@ const PROPERTY_ENTITIES: Array<{
   { typeName: "GitLab::CI::Artifacts", source: "#/definitions/artifacts", description: "Job artifact configuration" },
   { typeName: "GitLab::CI::Cache", source: "#/definitions/cache_item", description: "Cache configuration" },
   { typeName: "GitLab::CI::Image", source: "#/definitions/image", description: "Docker image for a job" },
+  { typeName: "GitLab::CI::Service", source: "#/definitions/services:item", description: "Docker service container for a job" },
   { typeName: "GitLab::CI::Rule", source: "#/definitions/rules:item", description: "Conditional rule for job execution" },
   { typeName: "GitLab::CI::Retry", source: "#/definitions/retry", description: "Job retry configuration" },
   { typeName: "GitLab::CI::AllowFailure", source: "#/definitions/allow_failure", description: "Allow failure configuration" },
@@ -266,17 +267,14 @@ function extractPropertyEntity(
  * Resolve a source path to a schema definition.
  */
 function resolveSource(schema: CISchema, source: string): CISchemaDefinition | null {
-  // Special case: rules array item extraction
-  if (source === "#/definitions/rules:item") {
-    const rulesDef = schema.definitions?.rules;
-    if (!rulesDef) return null;
-    // rules is an array — get items
-    const items = rulesDef.items;
-    if (!items) return null;
-    return findObjectVariant(items);
-  }
-
   if (source.startsWith("#/definitions/")) {
+    // Array item extraction: "#/definitions/foo:item" → foo.items object variant
+    if (source.includes(":item")) {
+      const defName = source.slice("#/definitions/".length).replace(":item", "");
+      const arrayDef = schema.definitions?.[defName];
+      if (!arrayDef?.items) return null;
+      return findObjectVariant(arrayDef.items);
+    }
     const defName = source.slice("#/definitions/".length);
     return schema.definitions?.[defName] ?? null;
   }

package/src/codegen/snapshot.test.ts

@@ -10,7 +10,7 @@ describe("generated lexicon-gitlab.json", () => {
   const registry = JSON.parse(content);
 
   test("is valid JSON with expected entries", () => {
-    expect(Object.keys(registry)).toHaveLength(15);
+    expect(Object.keys(registry)).toHaveLength(16);
   });
 
   test("contains all resource entities", () => {
@@ -30,7 +30,7 @@ describe("generated lexicon-gitlab.json", () => {
     const propertyNames = [
       "AllowFailure", "Artifacts", "AutoCancel", "Cache",
       "Environment", "Image", "Include", "Parallel",
-      "Release", "Retry", "Rule", "Trigger",
+      "Release", "Retry", "Rule", "Service", "Trigger",
     ];
     for (const name of propertyNames) {
       expect(registry[name]).toBeDefined();
@@ -55,7 +55,7 @@ describe("generated index.d.ts", () => {
       "Job", "Default", "Workflow",
       "AllowFailure", "Artifacts", "AutoCancel", "Cache",
       "Environment", "Image", "Include", "Parallel",
-      "Release", "Retry", "Rule", "Trigger",
+      "Release", "Retry", "Rule", "Service", "Trigger",
     ];
     for (const cls of expectedClasses) {
       expect(content).toContain(`export declare class ${cls}`);

package/src/generated/index.d.ts

@@ -203,6 +203,19 @@ export declare class Rule {
   });
 }
 
+export declare class Service {
+  constructor(props: {
+    /** Full name of the image that should be used. It should contain the Registry part if needed. */
+    name: string;
+    alias?: string;
+    command?: string[];
+    docker?: Record<string, unknown>;
+    entrypoint?: string[];
+    pull_policy?: "always" | "never" | "if-not-present" | "always" | "never" | "if-not-present"[];
+    variables?: Record<string, unknown>;
+  });
+}
+
 export declare class Trigger {
   constructor(props: {
     /** Path to the project, e.g. `group/project`, or `group/sub-group/project`. */

package/src/generated/index.ts

@@ -16,6 +16,7 @@ export const Parallel = createProperty("GitLab::CI::Parallel", "gitlab");
 export const Release = createProperty("GitLab::CI::Release", "gitlab");
 export const Retry = createProperty("GitLab::CI::Retry", "gitlab");
 export const Rule = createProperty("GitLab::CI::Rule", "gitlab");
+export const Service = createProperty("GitLab::CI::Service", "gitlab");
 export const Trigger = createProperty("GitLab::CI::Trigger", "gitlab");
 
 // Re-exports for convenience

package/src/generated/lexicon-gitlab.json

@@ -64,6 +64,11 @@
     "kind": "property",
     "lexicon": "gitlab"
   },
+  "Service": {
+    "resourceType": "GitLab::CI::Service",
+    "kind": "property",
+    "lexicon": "gitlab"
+  },
   "Trigger": {
     "resourceType": "GitLab::CI::Trigger",
     "kind": "property",

package/src/import/parser.test.ts

@@ -65,7 +65,7 @@ workflow:
     expect(workflow!.properties.name).toBe("My Pipeline");
   });
 
-  test("converts snake_case keys to camelCase", () => {
+  test("preserves spec-native snake_case property keys", () => {
     const yaml = `
 test-job:
   stage: test
@@ -77,8 +77,8 @@ test-job:
     - npm test
 `;
     const ir = parser.parse(yaml);
-    expect(ir.resources[0].properties.beforeScript).toEqual(["echo setup"]);
-    expect(ir.resources[0].properties.afterScript).toEqual(["echo done"]);
+    expect(ir.resources[0].properties.before_script).toEqual(["echo setup"]);
+    expect(ir.resources[0].properties.after_script).toEqual(["echo done"]);
   });
 
   test("converts kebab-case job names to camelCase", () => {

package/src/import/parser.ts

@@ -10,6 +10,14 @@ import type { TemplateParser, TemplateIR, ResourceIR } from "@intentius/chant/im
 /**
  * Reserved top-level keys in .gitlab-ci.yml that are NOT job definitions.
  */
+/**
+ * Convert snake_case to camelCase — used only for TS variable names (logicalId),
+ * NOT for spec property names.
+ */
+function snakeToCamelCase(name: string): string {
+  return name.replace(/_([a-z])/g, (_, c: string) => c.toUpperCase());
+}
+
 const RESERVED_KEYS = new Set([
   "stages",
   "variables",
@@ -24,28 +32,6 @@ const RESERVED_KEYS = new Set([
   "pages",
 ]);
 
-/**
- * Map snake_case GitLab CI keys to camelCase for Chant properties.
- */
-function toCamelCase(name: string): string {
-  return name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
-}
-
-/**
- * Recursively convert snake_case keys in an object to camelCase.
- */
-function camelCaseKeys(value: unknown): unknown {
-  if (value === null || value === undefined) return value;
-  if (Array.isArray(value)) return value.map(camelCaseKeys);
-  if (typeof value === "object") {
-    const result: Record<string, unknown> = {};
-    for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
-      result[toCamelCase(key)] = camelCaseKeys(val);
-    }
-    return result;
-  }
-  return value;
-}
 
 /**
  * Parse a YAML document into a plain object.
@@ -227,7 +213,7 @@ export class GitLabParser implements TemplateParser {
       resources.push({
         logicalId: "defaults",
         type: "GitLab::CI::Default",
-        properties: camelCaseKeys(doc.default) as Record<string, unknown>,
+        properties: doc.default as Record<string, unknown>,
       });
     }
 
@@ -236,7 +222,7 @@ export class GitLabParser implements TemplateParser {
       resources.push({
         logicalId: "workflow",
         type: "GitLab::CI::Workflow",
-        properties: camelCaseKeys(doc.workflow) as Record<string, unknown>,
+        properties: doc.workflow as Record<string, unknown>,
       });
     }
 
@@ -256,9 +242,9 @@ export class GitLabParser implements TemplateParser {
         obj.needs !== undefined
       ) {
         resources.push({
-          logicalId: toCamelCase(key.replace(/-/g, "_")),
+          logicalId: snakeToCamelCase(key.replace(/-/g, "_")),
           type: "GitLab::CI::Job",
-          properties: camelCaseKeys(obj) as Record<string, unknown>,
+          properties: obj as Record<string, unknown>,
           metadata: {
             originalName: key,
             stage: typeof obj.stage === "string" ? obj.stage : undefined,

package/src/lsp/completions.ts

@@ -1,5 +1,7 @@
+import { createRequire } from "module";
 import type { CompletionContext, CompletionItem } from "@intentius/chant/lsp/types";
 import { LexiconIndex, lexiconCompletions, type LexiconEntry } from "@intentius/chant/lsp/lexicon-providers";
+const require = createRequire(import.meta.url);
 
 let cachedIndex: LexiconIndex | null = null;
 

package/src/lsp/hover.ts

@@ -1,5 +1,7 @@
+import { createRequire } from "module";
 import type { HoverContext, HoverInfo } from "@intentius/chant/lsp/types";
 import { LexiconIndex, lexiconHover, type LexiconEntry } from "@intentius/chant/lsp/lexicon-providers";
+const require = createRequire(import.meta.url);
 
 let cachedIndex: LexiconIndex | null = null;
 

package/src/plugin.test.ts

@@ -96,7 +96,6 @@ describe("gitlabPlugin", () => {
   test("returns init templates", () => {
     const templates = gitlabPlugin.initTemplates!();
     expect(templates).toBeDefined();
-    expect(templates["_.ts"]).toBeDefined();
     expect(templates["config.ts"]).toBeDefined();
     expect(templates["test.ts"]).toBeDefined();
   });
@@ -160,9 +159,12 @@ describe("gitlabPlugin", () => {
   test("returns skills", () => {
     const skills = gitlabPlugin.skills!();
     expect(skills).toHaveLength(1);
-    expect(skills[0].name).toBe("gitlab-ci");
+    expect(skills[0].name).toBe("chant-gitlab");
     expect(skills[0].description).toBeDefined();
-    expect(skills[0].content).toContain("GitLab CI/CD");
+    expect(skills[0].content).toContain("skill: chant-gitlab");
+    expect(skills[0].content).toContain("user-invocable: true");
+    expect(skills[0].content).toContain("chant build");
+    expect(skills[0].content).toContain("chant lint");
     expect(skills[0].triggers).toHaveLength(2);
     expect(skills[0].examples).toHaveLength(1);
   });
@@ -192,7 +194,7 @@ describe("gitlabPlugin", () => {
     const result = await catalog.handler();
     const parsed = JSON.parse(result);
     expect(Array.isArray(parsed)).toBe(true);
-    expect(parsed.length).toBe(15);
+    expect(parsed.length).toBe(16);
     const job = parsed.find((e: { className: string }) => e.className === "Job");
     expect(job).toBeDefined();
     expect(job.kind).toBe("resource");
@@ -218,10 +220,6 @@ describe("gitlabPlugin", () => {
     expect(typeof gitlabPlugin.coverage).toBe("function");
   });
 
-  test("has rollback method", () => {
-    expect(typeof gitlabPlugin.rollback).toBe("function");
-  });
-
   test("has docs method", () => {
     expect(typeof gitlabPlugin.docs).toBe("function");
   });

package/src/plugin.ts

@@ -5,7 +5,9 @@
  * for GitLab CI/CD pipelines.
  */
 
+import { createRequire } from "module";
 import type { LexiconPlugin, IntrinsicDef, SkillDefinition } from "@intentius/chant/lexicon";
+const require = createRequire(import.meta.url);
 import type { LintRule } from "@intentius/chant/lint/rule";
 import type { PostSynthCheck } from "@intentius/chant/lint/post-synth";
 import { gitlabSerializer } from "./serializer";
@@ -41,20 +43,19 @@ export const gitlabPlugin: LexiconPlugin = {
 
   initTemplates(): Record<string, string> {
     return {
-      "_.ts": `export * from "./config";\n`,
       "config.ts": `/**
  * Shared pipeline configuration
  */
 
-import * as gl from "@intentius/chant-lexicon-gitlab";
+import { Image, Cache } from "@intentius/chant-lexicon-gitlab";
 
 // Default image for all jobs
-export const defaultImage = new gl.Image({
+export const defaultImage = new Image({
   name: "node:20-alpine",
 });
 
 // Standard cache configuration
-export const npmCache = new gl.Cache({
+export const npmCache = new Cache({
   key: "$CI_COMMIT_REF_SLUG",
   paths: ["node_modules/"],
   policy: "pull-push",
@@ -64,15 +65,15 @@ export const npmCache = new gl.Cache({
  * Test job
  */
 
-import * as gl from "@intentius/chant-lexicon-gitlab";
-import * as _ from "./_";
+import { Job, Artifacts } from "@intentius/chant-lexicon-gitlab";
+import { defaultImage, npmCache } from "./config";
 
-export const test = new gl.Job({
+export const test = new Job({
   stage: "test",
-  image: _.defaultImage,
-  cache: _.npmCache,
+  image: defaultImage,
+  cache: npmCache,
   script: ["npm ci", "npm test"],
-  artifacts: new gl.Artifacts({
+  artifacts: new Artifacts({
     reports: { junit: "coverage/junit.xml" },
     paths: ["coverage/"],
     expireIn: "1 week",
@@ -142,18 +143,9 @@ export const test = new gl.Job({
 
   async validate(options?: { verbose?: boolean }): Promise<void> {
     const { validate } = await import("./validate");
+    const { printValidationResult } = await import("@intentius/chant/codegen/validate");
     const result = await validate();
-
-    for (const check of result.checks) {
-      const status = check.ok ? "OK" : "FAIL";
-      const msg = check.error ? ` — ${check.error}` : "";
-      console.error(`  [${status}] ${check.name}${msg}`);
-    }
-
-    if (!result.success) {
-      throw new Error("Validation failed");
-    }
-    console.error("All validation checks passed.");
+    printValidationResult(result);
   },
 
   async coverage(options?: { verbose?: boolean; minOverall?: number }): Promise<void> {
@@ -166,7 +158,7 @@ export const test = new gl.Job({
 
   async package(options?: { verbose?: boolean; force?: boolean }): Promise<void> {
     const { packageLexicon } = await import("./codegen/package");
-    const { writeFileSync, mkdirSync } = await import("fs");
+    const { writeBundleSpec } = await import("@intentius/chant/codegen/package");
     const { join, dirname } = await import("path");
     const { fileURLToPath } = await import("url");
 
@@ -174,53 +166,11 @@ export const test = new gl.Job({
 
     const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
     const distDir = join(pkgDir, "dist");
-    mkdirSync(join(distDir, "types"), { recursive: true });
-    mkdirSync(join(distDir, "rules"), { recursive: true });
-    mkdirSync(join(distDir, "skills"), { recursive: true });
-
-    writeFileSync(join(distDir, "manifest.json"), JSON.stringify(spec.manifest, null, 2));
-    writeFileSync(join(distDir, "meta.json"), spec.registry);
-    writeFileSync(join(distDir, "types", "index.d.ts"), spec.typesDTS);
-
-    for (const [name, content] of spec.rules) {
-      writeFileSync(join(distDir, "rules", name), content);
-    }
-    for (const [name, content] of spec.skills) {
-      writeFileSync(join(distDir, "skills", name), content);
-    }
-
-    if (spec.integrity) {
-      writeFileSync(join(distDir, "integrity.json"), JSON.stringify(spec.integrity, null, 2));
-    }
+    writeBundleSpec(spec, distDir);
 
     console.error(`Packaged ${stats.resources} entities, ${stats.ruleCount} rules, ${stats.skillCount} skills`);
   },
 
-  async rollback(options?: { restore?: string; verbose?: boolean }): Promise<void> {
-    const { listSnapshots, restoreSnapshot } = await import("./codegen/rollback");
-    const { join, dirname } = await import("path");
-    const { fileURLToPath } = await import("url");
-
-    const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
-    const snapshotsDir = join(pkgDir, ".snapshots");
-
-    if (options?.restore) {
-      const generatedDir = join(pkgDir, "src", "generated");
-      restoreSnapshot(String(options.restore), generatedDir);
-      console.error(`Restored snapshot: ${options.restore}`);
-    } else {
-      const snapshots = listSnapshots(snapshotsDir);
-      if (snapshots.length === 0) {
-        console.error("No snapshots available.");
-      } else {
-        console.error(`Available snapshots (${snapshots.length}):`);
-        for (const s of snapshots) {
-          console.error(`  ${s.timestamp}  ${s.resourceCount} resources  ${s.path}`);
-        }
-      }
-    }
-  },
-
   mcpTools() {
     return [
       {
@@ -310,45 +260,67 @@ export const deploy = new Job({
   skills(): SkillDefinition[] {
     return [
       {
-        name: "gitlab-ci",
-        description: "GitLab CI/CD best practices and common patterns",
+        name: "chant-gitlab",
+        description: "GitLab CI/CD pipeline management — workflows, patterns, and troubleshooting",
         content: `---
-name: gitlab-ci
-description: GitLab CI/CD best practices and common patterns
+skill: chant-gitlab
+description: Build, validate, and deploy GitLab CI pipelines from a chant project
+user-invocable: true
 ---
 
-# GitLab CI/CD with Chant
-
-## Common Entity Types
-
-- \`Job\` — Pipeline job definition
-- \`Default\` — Default settings inherited by all jobs
-- \`Workflow\` — Pipeline-level configuration
-- \`Artifacts\` — Job artifact configuration
-- \`Cache\` — Cache configuration
-- \`Image\` — Docker image for a job
-- \`Rule\` — Conditional execution rule
-- \`Environment\` — Deployment environment
-- \`Trigger\` — Trigger downstream pipeline
-- \`Include\` — Include external CI configuration
-
-## Predefined Variables
-
-- \`CI.CommitBranch\` — Current branch name
-- \`CI.CommitSha\` — Current commit SHA
-- \`CI.PipelineSource\` — What triggered the pipeline
-- \`CI.ProjectPath\` — Project path (group/project)
-- \`CI.Registry\` — Container registry URL
-- \`CI.MergeRequestIid\` — MR internal ID
-
-## Best Practices
-
-1. **Use stages** — Organize jobs into logical stages (build, test, deploy)
-2. **Cache dependencies** — Cache node_modules, pip packages, etc.
-3. **Use rules** — Prefer \`rules:\` over \`only:/except:\` for conditional execution
-4. **Minimize artifacts** — Only preserve files needed by later stages
-5. **Use includes** — Share common configuration across projects
-6. **Set timeouts** — Prevent stuck jobs from blocking pipelines
+# Deploying GitLab CI Pipelines from Chant
+
+This project defines GitLab CI jobs as TypeScript in \`src/\`. Use these steps to build, validate, and deploy.
+
+## Build the pipeline
+
+\`\`\`bash
+chant build src/ --output .gitlab-ci.yml
+\`\`\`
+
+## Validate before pushing
+
+\`\`\`bash
+chant lint src/
+\`\`\`
+
+For API-level validation against your GitLab instance:
+\`\`\`bash
+curl --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \\
+  "https://gitlab.com/api/v4/ci/lint" \\
+  --data "{\\"content\\": \\"$(cat .gitlab-ci.yml)\\"}"
+\`\`\`
+
+## Deploy
+
+Commit and push the generated \`.gitlab-ci.yml\` — GitLab runs the pipeline automatically:
+
+\`\`\`bash
+chant build src/ --output .gitlab-ci.yml
+git add .gitlab-ci.yml
+git commit -m "Update pipeline"
+git push
+\`\`\`
+
+## Check pipeline status
+
+- GitLab UI: project → CI/CD → Pipelines
+- API: \`curl --header "PRIVATE-TOKEN: $GITLAB_TOKEN" "https://gitlab.com/api/v4/projects/$PROJECT_ID/pipelines?per_page=5"\`
+
+## Retry a failed job
+
+- GitLab UI: click Retry on the failed job
+- API: \`curl --request POST --header "PRIVATE-TOKEN: $GITLAB_TOKEN" "https://gitlab.com/api/v4/projects/$PROJECT_ID/jobs/$JOB_ID/retry"\`
+
+## Cancel a running pipeline
+
+- API: \`curl --request POST --header "PRIVATE-TOKEN: $GITLAB_TOKEN" "https://gitlab.com/api/v4/projects/$PROJECT_ID/pipelines/$PIPELINE_ID/cancel"\`
+
+## Troubleshooting
+
+- Check job logs in GitLab UI: project → CI/CD → Jobs → click the job
+- \`chant lint src/\` catches: missing scripts (WGL002), deprecated only/except (WGL001), missing stages (WGL003), artifacts without expiry (WGL004)
+- Post-synth checks (WGL010, WGL011) run during build
 `,
         triggers: [
           { type: "file-pattern", value: "**/*.gitlab.ts" },

package/src/serializer.test.ts

@@ -121,12 +121,12 @@ describe("gitlabSerializer.serialize", () => {
     expect(output).toContain("my-test-job:");
   });
 
-  test("converts camelCase property keys to snake_case", () => {
+  test("passes through spec-native snake_case property keys", () => {
     const entities = new Map<string, Declarable>();
     entities.set("job", new MockJob({
-      beforeScript: ["echo hello"],
-      afterScript: ["echo done"],
-      expireIn: "1 week",
+      before_script: ["echo hello"],
+      after_script: ["echo done"],
+      expire_in: "1 week",
     }));
 
     const output = gitlabSerializer.serialize(entities);
@@ -270,7 +270,7 @@ describe("nested objects and arrays", () => {
 
     const output = gitlabSerializer.serialize(entities);
     expect(output).toContain("variables:");
-    expect(output).toContain("node_env: production");
+    expect(output).toContain("NODE_ENV: production");
   });
 
   test("serializes arrays of strings", () => {
@@ -289,7 +289,7 @@ describe("nested objects and arrays", () => {
     const entities = new Map<string, Declarable>();
     entities.set("job", new MockJob({
       interruptible: true,
-      allowFailure: false,
+      allow_failure: false,
     }));
 
     const output = gitlabSerializer.serialize(entities);

package/src/serializer.ts

@@ -14,13 +14,6 @@ import type { LexiconOutput } from "@intentius/chant/lexicon-output";
 import { walkValue, type SerializerVisitor } from "@intentius/chant/serializer-walker";
 import { INTRINSIC_MARKER } from "@intentius/chant/intrinsic";
 
-/**
- * Convert camelCase or PascalCase to snake_case.
- */
-function toSnakeCase(name: string): string {
-  return name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
-}
-
 /**
  * GitLab CI visitor for the generic serializer walker.
  */
@@ -36,12 +29,11 @@ function gitlabVisitor(entityNames: Map<Declarable, string>): SerializerVisitor
       const result: Record<string, unknown> = {};
       for (const [key, value] of Object.entries(props)) {
         if (value !== undefined) {
-          result[toSnakeCase(key)] = walk(value);
+          result[key] = walk(value);
         }
       }
       return Object.keys(result).length > 0 ? result : undefined;
     },
-    transformKey: toSnakeCase,
   };
 }