@intentius/chant-lexicon-gitlab 0.0.6 → 0.0.9

package/src/serializer.test.ts

@@ -1,6 +1,7 @@
 import { describe, test, expect } from "bun:test";
 import { gitlabSerializer } from "./serializer";
 import { DECLARABLE_MARKER, type Declarable } from "@intentius/chant/declarable";
+import { createProperty, createResource } from "@intentius/chant/runtime";
 
 // ── Mock entities ──────────────────────────────────────────────────
 
@@ -121,12 +122,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);
@@ -258,6 +259,145 @@ describe("string quoting", () => {
   });
 });
 
+describe("runtime-style entities (non-enumerable props)", () => {
+  // Real generated entities use createResource/createProperty which define
+  // DECLARABLE_MARKER, entityType, kind, and props as non-enumerable.
+  // Object.entries() skips non-enumerable properties — the serializer must
+  // handle these correctly.
+
+  const RuntimeImage = createProperty("GitLab::CI::Image", "gitlab");
+  const RuntimeCache = createProperty("GitLab::CI::Cache", "gitlab");
+  const RuntimeArtifacts = createProperty("GitLab::CI::Artifacts", "gitlab");
+  const RuntimeRule = createProperty("GitLab::CI::Rule", "gitlab");
+  const RuntimeEnvironment = createProperty("GitLab::CI::Environment", "gitlab");
+  const RuntimeJob = createResource("GitLab::CI::Job", "gitlab", {});
+
+  test("serializes runtime-style property entities in jobs", () => {
+    const image = new RuntimeImage({ name: "node:20-alpine" });
+    const cache = new RuntimeCache({
+      key: "$CI_COMMIT_REF_SLUG",
+      paths: ["node_modules/"],
+      policy: "pull-push",
+    });
+    const artifacts = new RuntimeArtifacts({
+      paths: ["dist/"],
+      expire_in: "1 hour",
+    });
+    const job = new RuntimeJob({
+      stage: "build",
+      image,
+      cache,
+      script: ["npm ci", "npm run build"],
+      artifacts,
+    });
+
+    const entities = new Map<string, Declarable>();
+    entities.set("build", job as unknown as Declarable);
+
+    const output = gitlabSerializer.serialize(entities);
+
+    // Image must expand to its properties, not {}
+    expect(output).toContain("image:");
+    expect(output).toContain("name: node:20-alpine");
+    expect(output).not.toContain("image: {}");
+
+    // Cache must expand
+    expect(output).toContain("cache:");
+    expect(output).toContain("paths:");
+    expect(output).toContain("- node_modules/");
+    expect(output).not.toContain("cache: {}");
+
+    // Artifacts must expand
+    expect(output).toContain("artifacts:");
+    expect(output).toContain("- dist/");
+    expect(output).not.toContain("artifacts: {}");
+  });
+
+  test("serializes runtime-style rules array", () => {
+    const rule1 = new RuntimeRule({ if: "$CI_MERGE_REQUEST_IID" });
+    const rule2 = new RuntimeRule({ if: "$CI_COMMIT_BRANCH" });
+    const job = new RuntimeJob({
+      stage: "test",
+      script: ["npm test"],
+      rules: [rule1, rule2],
+    });
+
+    const entities = new Map<string, Declarable>();
+    entities.set("test", job as unknown as Declarable);
+
+    const output = gitlabSerializer.serialize(entities);
+    expect(output).toContain("rules:");
+    expect(output).toContain("if: '$CI_MERGE_REQUEST_IID'");
+    expect(output).toContain("if: '$CI_COMMIT_BRANCH'");
+  });
+
+  test("serializes runtime-style environment", () => {
+    const env = new RuntimeEnvironment({
+      name: "production",
+      url: "https://example.com",
+    });
+    const job = new RuntimeJob({
+      stage: "deploy",
+      script: ["deploy.sh"],
+      environment: env,
+    });
+
+    const entities = new Map<string, Declarable>();
+    entities.set("deploy", job as unknown as Declarable);
+
+    const output = gitlabSerializer.serialize(entities);
+    expect(output).toContain("environment:");
+    expect(output).toContain("name: production");
+    expect(output).toContain("url: https://example.com");
+    expect(output).not.toContain("environment: {}");
+  });
+});
+
+describe("array-of-objects YAML formatting", () => {
+  test("serializes cache array with nested key object correctly", () => {
+    const entities = new Map<string, Declarable>();
+    entities.set("job", new MockJob({
+      stage: "build",
+      script: ["npm ci"],
+      cache: [
+        {
+          key: { files: ["package-lock.json"] },
+          paths: [".npm/"],
+          policy: "pull-push",
+        },
+      ],
+    }));
+
+    const output = gitlabSerializer.serialize(entities);
+    // The key object should be on a new line, properly indented
+    expect(output).toContain("cache:");
+    expect(output).toContain("- key:");
+    expect(output).toContain("files:");
+    expect(output).toContain("- package-lock.json");
+    expect(output).toContain("paths:");
+    expect(output).toContain("- .npm/");
+    expect(output).toContain("policy: pull-push");
+    // The key value should NOT be inlined as "key: files:"
+    expect(output).not.toMatch(/key: files:/);
+  });
+
+  test("serializes services array with nested objects", () => {
+    const entities = new Map<string, Declarable>();
+    entities.set("job", new MockJob({
+      stage: "build",
+      script: ["docker build ."],
+      services: [
+        { name: "docker:27-dind", alias: "docker" },
+      ],
+    }));
+
+    const output = gitlabSerializer.serialize(entities);
+    expect(output).toContain("services:");
+    expect(output).toContain("- name: docker:27-dind");
+    expect(output).toContain("alias: docker");
+  });
+});
+
 describe("nested objects and arrays", () => {
   test("serializes nested objects", () => {
     const entities = new Map<string, Declarable>();
@@ -270,7 +410,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 +429,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,20 +14,13 @@ 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.
  */
 function gitlabVisitor(entityNames: Map<Declarable, string>): SerializerVisitor {
   return {
     attrRef: (name, _attr) => name,
-    resourceRef: (name) => name,
+    resourceRef: (name) => name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(),
     propertyDeclarable: (entity, walk) => {
       if (!("props" in entity) || typeof entity.props !== "object" || entity.props === null) {
         return undefined;
@@ -36,20 +29,57 @@ 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,
   };
 }
 
+/**
+ * Pre-process values to convert intrinsics to their YAML representation
+ * before the walker (which would call toJSON instead of toYAML).
+ *
+ * IMPORTANT: Must not touch Declarable objects — their identity markers
+ * (DECLARABLE_MARKER, entityType, kind, props) are non-enumerable and
+ * would be stripped by Object.entries(), producing empty `{}` output.
+ */
+function preprocessIntrinsics(value: unknown): unknown {
+  if (value === null || value === undefined) return value;
+
+  if (typeof value === "object" && INTRINSIC_MARKER in value) {
+    if ("toYAML" in value && typeof value.toYAML === "function") {
+      return (value as { toYAML(): unknown }).toYAML();
+    }
+  }
+
+  // Leave Declarables untouched — the walker handles them
+  if (typeof value === "object" && value !== null && "entityType" in value) {
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(preprocessIntrinsics);
+  }
+
+  if (typeof value === "object") {
+    const result: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+      result[k] = preprocessIntrinsics(v);
+    }
+    return result;
+  }
+
+  return value;
+}
+
 /**
  * Convert a value to YAML-compatible form using the walker.
  */
 function toYAMLValue(value: unknown, entityNames: Map<Declarable, string>): unknown {
-  return walkValue(value, entityNames, gitlabVisitor(entityNames));
+  const preprocessed = preprocessIntrinsics(value);
+  return walkValue(preprocessed, entityNames, gitlabVisitor(entityNames));
 }
 
 /**
@@ -106,10 +136,21 @@ function emitYAML(value: unknown, indent: number): string {
         const entries = Object.entries(item as Record<string, unknown>);
         if (entries.length > 0) {
           const [firstKey, firstVal] = entries[0];
-          lines.push(`${prefix}- ${firstKey}: ${emitYAML(firstVal, indent + 2).trimStart()}`);
+          const firstEmitted = emitYAML(firstVal, indent + 2);
+          if (firstEmitted.startsWith("\n")) {
+            // Multi-line value: put on next line, indented under the key
+            lines.push(`${prefix}- ${firstKey}:${firstEmitted}`);
+          } else {
+            lines.push(`${prefix}- ${firstKey}: ${firstEmitted}`);
+          }
           for (let i = 1; i < entries.length; i++) {
             const [key, val] = entries[i];
-            lines.push(`${prefix}  ${key}: ${emitYAML(val, indent + 2).trimStart()}`);
+            const emitted = emitYAML(val, indent + 2);
+            if (emitted.startsWith("\n")) {
+              lines.push(`${prefix}  ${key}:${emitted}`);
+            } else {
+              lines.push(`${prefix}  ${key}: ${emitted}`);
+            }
           }
         }
       } else {
@@ -120,7 +161,16 @@ function emitYAML(value: unknown, indent: number): string {
   }
 
   if (typeof value === "object") {
-    const entries = Object.entries(value as Record<string, unknown>);
+    const obj = value as Record<string, unknown>;
+
+    // Handle tagged values (intrinsics like !reference)
+    if ("tag" in obj && "value" in obj && typeof obj.tag === "string") {
+      if (obj.tag === "!reference" && Array.isArray(obj.value)) {
+        return `!reference [${(obj.value as string[]).join(", ")}]`;
+      }
+    }
+
+    const entries = Object.entries(obj);
     if (entries.length === 0) return "{}";
     const lines: string[] = [];
     for (const [key, val] of entries) {

package/src/validate.ts

@@ -16,6 +16,7 @@ const REQUIRED_NAMES = [
   "Artifacts", "Cache", "Image", "Service", "Rule", "Retry",
   "AllowFailure", "Parallel", "Include", "Release",
   "Environment", "Trigger", "AutoCancel",
+  "WorkflowRule", "Need", "Inherit",
 ];
 
 /**

package/src/variables.ts

@@ -8,10 +8,12 @@
 export const CI = {
   CommitBranch: "$CI_COMMIT_BRANCH",
   CommitRef: "$CI_COMMIT_REF_NAME",
+  CommitRefSlug: "$CI_COMMIT_REF_SLUG",
   CommitSha: "$CI_COMMIT_SHA",
   CommitTag: "$CI_COMMIT_TAG",
   DefaultBranch: "$CI_DEFAULT_BRANCH",
   Environment: "$CI_ENVIRONMENT_NAME",
+  EnvironmentSlug: "$CI_ENVIRONMENT_SLUG",
   JobId: "$CI_JOB_ID",
   JobName: "$CI_JOB_NAME",
   JobStage: "$CI_JOB_STAGE",
@@ -24,4 +26,6 @@ export const CI = {
   ProjectPath: "$CI_PROJECT_PATH",
   Registry: "$CI_REGISTRY",
   RegistryImage: "$CI_REGISTRY_IMAGE",
+  RegistryUser: "$CI_REGISTRY_USER",
+  RegistryPassword: "$CI_REGISTRY_PASSWORD",
 } as const;

package/dist/skills/gitlab-ci.md

@@ -1,37 +0,0 @@
----
-name: gitlab-ci
-description: GitLab CI/CD best practices and common patterns
----
-
-# 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

package/src/codegen/rollback.ts

@@ -1,26 +0,0 @@
-/**
- * Rollback and snapshot management for GitLab CI lexicon.
- *
- * Wraps the core rollback module with GitLab-specific artifact names.
- */
-
-export type { ArtifactSnapshot, SnapshotInfo } from "@intentius/chant/codegen/rollback";
-export {
-  snapshotArtifacts,
-  saveSnapshot,
-  restoreSnapshot,
-  listSnapshots,
-} from "@intentius/chant/codegen/rollback";
-
-/**
- * GitLab-specific artifact filenames to snapshot.
- */
-export const GITLAB_ARTIFACT_NAMES = ["lexicon-gitlab.json", "index.d.ts", "index.ts"];
-
-/**
- * Snapshot GitLab lexicon artifacts.
- */
-export function snapshotGitLabArtifacts(generatedDir: string) {
-  const { snapshotArtifacts } = require("@intentius/chant/codegen/rollback");
-  return snapshotArtifacts(generatedDir, GITLAB_ARTIFACT_NAMES);
-}