@intentius/chant-lexicon-gitlab 0.0.1

package/src/testdata/create-fixture.ts

@@ -0,0 +1,46 @@
+#!/usr/bin/env bun
+/**
+ * Script to create a minimal CI schema fixture for tests.
+ * Run once: bun run src/testdata/create-fixture.ts
+ */
+
+import { readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+const schema = JSON.parse(readFileSync(join(homedir(), ".chant", "gitlab-ci-schema.json"), "utf-8"));
+
+const neededDefs = [
+  "job_template", "image", "services", "artifacts", "cache_item",
+  "rules", "retry", "allow_failure", "parallel", "include_item",
+  "when", "retry_errors", "workflowAutoCancel",
+  "before_script", "after_script", "script", "optional_script",
+  "globalVariables", "jobVariables", "rulesVariables",
+  "id_tokens", "secrets", "timeout", "start_in",
+];
+
+const defs: Record<string, unknown> = {};
+for (const name of neededDefs) {
+  if (schema.definitions?.[name]) {
+    defs[name] = schema.definitions[name];
+  }
+}
+
+const keepProps = ["default", "workflow", "stages", "variables", "include"];
+const filteredProps: Record<string, unknown> = {};
+for (const key of keepProps) {
+  if (schema.properties?.[key]) filteredProps[key] = schema.properties[key];
+}
+
+const minimal = {
+  definitions: defs,
+  properties: filteredProps,
+  patternProperties: schema.patternProperties || {},
+  required: schema.required || [],
+};
+
+const outPath = join(import.meta.dir, "ci-schema-fixture.json");
+writeFileSync(outPath, JSON.stringify(minimal, null, 2));
+console.log(`Fixture written to ${outPath}`);
+console.log(`Definitions: ${Object.keys(defs).length}`);
+console.log(`Missing: ${neededDefs.filter(n => !defs[n]).join(", ") || "none"}`);

package/src/testdata/load-fixtures.ts

@@ -0,0 +1,23 @@
+/**
+ * Test fixture loader for the GitLab CI lexicon.
+ */
+
+import { readFileSync } from "fs";
+import { join } from "path";
+
+/**
+ * Load the minimal CI schema fixture for offline testing.
+ */
+export function loadSchemaFixture(): Buffer {
+  const fixturePath = join(import.meta.dir, "ci-schema-fixture.json");
+  return Buffer.from(readFileSync(fixturePath));
+}
+
+/**
+ * Load the schema fixture as a Map compatible with generatePipeline.
+ */
+export function loadSchemaFixtureMap(): Map<string, Buffer> {
+  const schemas = new Map<string, Buffer>();
+  schemas.set("GitLab::CI::Pipeline", loadSchemaFixture());
+  return schemas;
+}

package/src/validate-cli.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env bun
+/**
+ * Thin entry point for `bun run validate` in lexicon-gitlab.
+ */
+import { validate } from "./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) {
+  console.error("Validation failed");
+  process.exit(1);
+}
+console.error("All validation checks passed.");

package/src/validate.test.ts

@@ -0,0 +1,43 @@
+import { describe, test, expect } from "bun:test";
+import { validate } from "./validate";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+
+const basePath = dirname(dirname(fileURLToPath(import.meta.url)));
+
+describe("validate", () => {
+  test("passes validation for current generated artifacts", async () => {
+    const result = await validate({ basePath });
+    expect(result.success).toBe(true);
+    expect(result.checks.length).toBeGreaterThan(0);
+  });
+
+  test("checks all expected entities are present", async () => {
+    const result = await validate({ basePath });
+    const checkNames = result.checks.map((c) => c.name);
+    expect(checkNames).toContain("resource Job present");
+    expect(checkNames).toContain("resource Default present");
+    expect(checkNames).toContain("resource Workflow present");
+    expect(checkNames).toContain("property Artifacts present");
+    expect(checkNames).toContain("property Cache present");
+    expect(checkNames).toContain("property Image present");
+  });
+
+  test("checks file existence", async () => {
+    const result = await validate({ basePath });
+    const fileChecks = result.checks.filter((c) => c.name.endsWith("exists"));
+    expect(fileChecks.length).toBeGreaterThan(0);
+    for (const check of fileChecks) {
+      expect(check.ok).toBe(true);
+    }
+  });
+
+  test("checks index.d.ts class declarations", async () => {
+    const result = await validate({ basePath });
+    const dtsChecks = result.checks.filter((c) => c.name.startsWith("index.d.ts declares"));
+    expect(dtsChecks.length).toBeGreaterThan(0);
+    for (const check of dtsChecks) {
+      expect(check.ok).toBe(true);
+    }
+  });
+});

package/src/validate.ts

@@ -0,0 +1,125 @@
+/**
+ * Semantic validation for GitLab CI lexicon artifacts.
+ *
+ * Checks that generated files exist, contain expected entities,
+ * and pass basic structural validation.
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+export interface ValidateCheck {
+  name: string;
+  ok: boolean;
+  error?: string;
+}
+
+export interface ValidateResult {
+  success: boolean;
+  checks: ValidateCheck[];
+}
+
+const EXPECTED_RESOURCES = ["Job", "Default", "Workflow"];
+const EXPECTED_PROPERTIES = [
+  "Artifacts", "Cache", "Image", "Rule", "Retry",
+  "AllowFailure", "Parallel", "Include", "Release",
+  "Environment", "Trigger", "AutoCancel",
+];
+
+/**
+ * Validate lexicon artifacts.
+ */
+export async function validate(opts?: { basePath?: string }): Promise<ValidateResult> {
+  const basePath = opts?.basePath ?? dirname(dirname(fileURLToPath(import.meta.url)));
+  const generatedDir = join(basePath, "src", "generated");
+  const checks: ValidateCheck[] = [];
+
+  // Check files exist
+  for (const file of ["lexicon-gitlab.json", "index.d.ts", "index.ts", "runtime.ts"]) {
+    const path = join(generatedDir, file);
+    checks.push({
+      name: `${file} exists`,
+      ok: existsSync(path),
+      error: existsSync(path) ? undefined : `File not found: ${path}`,
+    });
+  }
+
+  // Validate lexicon JSON structure
+  const lexiconPath = join(generatedDir, "lexicon-gitlab.json");
+  if (existsSync(lexiconPath)) {
+    try {
+      const content = readFileSync(lexiconPath, "utf-8");
+      const registry = JSON.parse(content);
+      const entries = Object.keys(registry);
+
+      // Check expected count
+      const expectedCount = EXPECTED_RESOURCES.length + EXPECTED_PROPERTIES.length;
+      checks.push({
+        name: `lexicon-gitlab.json has ${expectedCount} entries`,
+        ok: entries.length === expectedCount,
+        error: entries.length !== expectedCount
+          ? `Expected ${expectedCount} entries, found ${entries.length}`
+          : undefined,
+      });
+
+      // Check resource entities present
+      for (const name of EXPECTED_RESOURCES) {
+        const entry = registry[name];
+        const ok = entry !== undefined && entry.kind === "resource";
+        checks.push({
+          name: `resource ${name} present`,
+          ok,
+          error: ok ? undefined : `Missing or invalid resource entry: ${name}`,
+        });
+      }
+
+      // Check property entities present
+      for (const name of EXPECTED_PROPERTIES) {
+        const entry = registry[name];
+        const ok = entry !== undefined && entry.kind === "property";
+        checks.push({
+          name: `property ${name} present`,
+          ok,
+          error: ok ? undefined : `Missing or invalid property entry: ${name}`,
+        });
+      }
+
+      // Check all entries have required fields
+      for (const [name, entry] of Object.entries(registry)) {
+        const e = entry as Record<string, unknown>;
+        const hasRequired = e.resourceType && e.kind && e.lexicon === "gitlab";
+        checks.push({
+          name: `${name} has required fields`,
+          ok: !!hasRequired,
+          error: hasRequired ? undefined : `Entry ${name} missing required fields`,
+        });
+      }
+    } catch (err) {
+      checks.push({
+        name: "lexicon-gitlab.json is valid JSON",
+        ok: false,
+        error: `Parse error: ${err}`,
+      });
+    }
+  }
+
+  // Validate index.d.ts has class declarations
+  const dtsPath = join(generatedDir, "index.d.ts");
+  if (existsSync(dtsPath)) {
+    const dts = readFileSync(dtsPath, "utf-8");
+    for (const name of [...EXPECTED_RESOURCES, ...EXPECTED_PROPERTIES]) {
+      const has = dts.includes(`export declare class ${name}`);
+      checks.push({
+        name: `index.d.ts declares ${name}`,
+        ok: has,
+        error: has ? undefined : `Missing class declaration: ${name}`,
+      });
+    }
+  }
+
+  return {
+    success: checks.every((c) => c.ok),
+    checks,
+  };
+}

package/src/variables.ts

@@ -0,0 +1,27 @@
+/**
+ * GitLab CI/CD predefined variable references.
+ *
+ * These expand to $CI_* variable strings in the serialized YAML.
+ * Provided for type-safe access and autocompletion.
+ */
+
+export const CI = {
+  CommitBranch: "$CI_COMMIT_BRANCH",
+  CommitRef: "$CI_COMMIT_REF_NAME",
+  CommitSha: "$CI_COMMIT_SHA",
+  CommitTag: "$CI_COMMIT_TAG",
+  DefaultBranch: "$CI_DEFAULT_BRANCH",
+  Environment: "$CI_ENVIRONMENT_NAME",
+  JobId: "$CI_JOB_ID",
+  JobName: "$CI_JOB_NAME",
+  JobStage: "$CI_JOB_STAGE",
+  MergeRequestIid: "$CI_MERGE_REQUEST_IID",
+  PipelineId: "$CI_PIPELINE_ID",
+  PipelineSource: "$CI_PIPELINE_SOURCE",
+  ProjectDir: "$CI_PROJECT_DIR",
+  ProjectId: "$CI_PROJECT_ID",
+  ProjectName: "$CI_PROJECT_NAME",
+  ProjectPath: "$CI_PROJECT_PATH",
+  Registry: "$CI_REGISTRY",
+  RegistryImage: "$CI_REGISTRY_IMAGE",
+} as const;