@intentius/chant-lexicon-gitlab 0.0.4 → 0.0.8

package/src/validate.test.ts

@@ -6,38 +6,29 @@ import { fileURLToPath } from "url";
 const basePath = dirname(dirname(fileURLToPath(import.meta.url)));
 
 describe("validate", () => {
-  test("passes validation for current generated artifacts", async () => {
+  test("runs validation checks on 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 () => {
+  test("checks lexicon JSON exists and parses", 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");
+    const jsonCheck = result.checks.find((c) => c.name === "lexicon-json-exists");
+    expect(jsonCheck).toBeDefined();
+    expect(jsonCheck?.ok).toBe(true);
   });
 
-  test("checks file existence", async () => {
+  test("checks types exist", 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);
-    }
+    const typesCheck = result.checks.find((c) => c.name === "types-exist");
+    expect(typesCheck).toBeDefined();
+    expect(typesCheck?.ok).toBe(true);
   });
 
-  test("checks index.d.ts class declarations", async () => {
+  test("checks required names are present", 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);
-    }
+    const requiredCheck = result.checks.find((c) => c.name === "required-names");
+    expect(requiredCheck).toBeDefined();
+    expect(requiredCheck?.ok).toBe(true);
   });
 });

package/src/validate.ts

@@ -1,125 +1,34 @@
 /**
- * Semantic validation for GitLab CI lexicon artifacts.
+ * Validate generated lexicon-gitlab artifacts.
  *
- * Checks that generated files exist, contain expected entities,
- * and pass basic structural validation.
+ * Thin wrapper around the core validation framework
+ * with GitLab-specific configuration.
  */
 
-import { existsSync, readFileSync } from "fs";
-import { join, dirname } from "path";
+import { dirname } from "path";
 import { fileURLToPath } from "url";
+import { validateLexiconArtifacts, type ValidateResult } from "@intentius/chant/codegen/validate";
 
-export interface ValidateCheck {
-  name: string;
-  ok: boolean;
-  error?: string;
-}
-
-export interface ValidateResult {
-  success: boolean;
-  checks: ValidateCheck[];
-}
+export type { ValidateCheck, ValidateResult } from "@intentius/chant/codegen/validate";
 
-const EXPECTED_RESOURCES = ["Job", "Default", "Workflow"];
-const EXPECTED_PROPERTIES = [
-  "Artifacts", "Cache", "Image", "Rule", "Retry",
+const REQUIRED_NAMES = [
+  "Job", "Default", "Workflow",
+  "Artifacts", "Cache", "Image", "Service", "Rule", "Retry",
   "AllowFailure", "Parallel", "Include", "Release",
   "Environment", "Trigger", "AutoCancel",
 ];
 
 /**
- * Validate lexicon artifacts.
+ * Validate the generated lexicon-gitlab artifacts.
+ *
+ * @param opts.basePath - Override the package directory (defaults to lexicon-gitlab package root)
  */
 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,
-  };
+  return validateLexiconArtifacts({
+    lexiconJsonFilename: "lexicon-gitlab.json",
+    requiredNames: REQUIRED_NAMES,
+    basePath,
+  });
 }

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);
-}