@intentius/chant-lexicon-github 0.124.31 → 0.124.33

package/dist/serializer.js

@@ -0,0 +1,572 @@
+/**
+ * GitHub Actions YAML serializer.
+ *
+ * Converts Chant declarables to .github/workflows/*.yml YAML output.
+ * Uses kebab-case keys for job properties and snake_case for trigger
+ * event names.
+ */
+import { isPropertyDeclarable, isResourceDeclarable } from "@intentius/chant/declarable";
+import { walkValue } from "@intentius/chant/serializer-walker";
+import { INTRINSIC_MARKER } from "@intentius/chant/intrinsic";
+import { emitYAML, emitYAMLEntry } from "@intentius/chant/yaml";
+// ── Key conversion ────────────────────────────────────────────────
+/**
+ * Convert camelCase property names to kebab-case for YAML output.
+ * Examples: timeoutMinutes → timeout-minutes, runsOn → runs-on
+ */
+function toKebabCase(name) {
+    return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+/**
+ * Convert camelCase trigger names to snake_case event names.
+ * Examples: pullRequest → pull_request, workflowDispatch → workflow_dispatch
+ */
+function toSnakeCase(name) {
+    return name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+/**
+ * Map entity type names to YAML trigger event names.
+ */
+const TRIGGER_TYPE_TO_EVENT = {
+    "GitHub::Actions::PushTrigger": "push",
+    "GitHub::Actions::PullRequestTrigger": "pull_request",
+    "GitHub::Actions::PullRequestTargetTrigger": "pull_request_target",
+    "GitHub::Actions::ScheduleTrigger": "schedule",
+    "GitHub::Actions::WorkflowDispatchTrigger": "workflow_dispatch",
+    "GitHub::Actions::WorkflowCallTrigger": "workflow_call",
+    "GitHub::Actions::WorkflowRunTrigger": "workflow_run",
+    "GitHub::Actions::RepositoryDispatchTrigger": "repository_dispatch",
+};
+/** Check if an entity type is a trigger. */
+function isTriggerType(entityType) {
+    return entityType in TRIGGER_TYPE_TO_EVENT;
+}
+// ── Comments ──────────────────────────────────────────────────────
+/**
+ * Entity types whose `comment` prop is YAML comment lines, not a key (#3667):
+ * the workflow's above `name:`, a job's above its key, a step's above its
+ * `- `. The prop never reaches the emitted mapping.
+ */
+const COMMENTED_TYPES = new Set([
+    "GitHub::Actions::Workflow",
+    "GitHub::Actions::Job",
+    "GitHub::Actions::ReusableWorkflowCallJob",
+    "GitHub::Actions::Step",
+]);
+/**
+ * The comment for each serialized job or step mapping, keyed by the object
+ * the emitter will see. Attached after key conversion, which builds new
+ * objects, and read by `emitJobs`.
+ */
+const COMMENTS = new WeakMap();
+/** The `comment` of a workflow, job or step entity, if it has one. */
+function commentOf(value) {
+    if (!value || typeof value !== "object" || !("entityType" in value) || !("props" in value))
+        return undefined;
+    if (!COMMENTED_TYPES.has(value.entityType))
+        return undefined;
+    const comment = value.props?.comment;
+    return typeof comment === "string" && comment !== "" ? comment : undefined;
+}
+/** `props` without its `comment`, for an entity whose comment is not a key. */
+function withoutComment(props) {
+    if (!props || typeof props !== "object" || !("comment" in props))
+        return props;
+    const { comment: _comment, ...rest } = props;
+    return rest;
+}
+/** A comment as `#` lines at `indent` (two spaces each), one per line of the string. */
+function commentLines(comment, indent) {
+    const prefix = "  ".repeat(indent);
+    return comment.split("\n").map((l) => `${prefix}#${l.trimEnd() ? ` ${l.trimEnd()}` : ""}`).join("\n");
+}
+/** Record a serialized job's comment and its steps' comments, from the job entity it came from. */
+function attachComments(source, job) {
+    if (!job)
+        return;
+    const comment = commentOf(source);
+    if (comment)
+        COMMENTS.set(job, comment);
+    const rawSteps = source?.props?.steps;
+    if (!Array.isArray(rawSteps) || !Array.isArray(job.steps))
+        return;
+    rawSteps.forEach((raw, i) => {
+        const stepComment = commentOf(raw);
+        const step = job.steps[i];
+        if (stepComment && step && typeof step === "object")
+            COMMENTS.set(step, stepComment);
+    });
+}
+// ── Visitor ───────────────────────────────────────────────────────
+function githubVisitor(entityNames) {
+    return {
+        attrRef: (name, _attr) => name,
+        resourceRef: (name) => toKebabCase(name),
+        propertyDeclarable: (entity, walk) => {
+            if (!isResourceDeclarable(entity) || typeof entity.props !== "object" || entity.props === null) {
+                return undefined;
+            }
+            const props = entity.props;
+            const commented = COMMENTED_TYPES.has(entity.entityType);
+            const result = {};
+            for (const [key, value] of Object.entries(props)) {
+                if (commented && key === "comment")
+                    continue;
+                if (value !== undefined) {
+                    result[key] = walk(value);
+                }
+            }
+            return Object.keys(result).length > 0 ? result : undefined;
+        },
+    };
+}
+// ── Intrinsic preprocessing ───────────────────────────────────────
+function preprocessIntrinsics(value) {
+    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.toYAML();
+        }
+    }
+    // Leave Declarables untouched
+    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 = {};
+        for (const [k, v] of Object.entries(value)) {
+            result[k] = preprocessIntrinsics(v);
+        }
+        return result;
+    }
+    return value;
+}
+function toYAMLValue(value, entityNames) {
+    const preprocessed = preprocessIntrinsics(value);
+    return walkValue(preprocessed, entityNames, githubVisitor(entityNames));
+}
+// ── Inline job serialization ──────────────────────────────────────
+const JOB_ENTITY_TYPES = new Set([
+    "GitHub::Actions::Job",
+    "GitHub::Actions::ReusableWorkflowCallJob",
+]);
+/**
+ * Serialize a value from Workflow.props.jobs into a YAML job object.
+ *
+ * When the value is a Job entity (resource Declarable), its props are inlined
+ * directly rather than emitted as a resource reference. This allows callers to
+ * pass `new Job({...})` directly inside `Workflow({ jobs: { name: new Job({...}) } })`.
+ *
+ * Plain objects are accepted too (JSON-style job definitions).
+ */
+function serializeInlineJob(jobValue, entityNames) {
+    if (!jobValue || typeof jobValue !== "object")
+        return undefined;
+    const obj = jobValue;
+    if ("entityType" in obj && "props" in obj && JOB_ENTITY_TYPES.has(obj.entityType)) {
+        // Job entity: serialize its props inline (not as a resource reference)
+        const props = toYAMLValue(withoutComment(obj.props), entityNames);
+        const job = props && typeof props === "object"
+            ? convertKeys(props)
+            : undefined;
+        attachComments(obj, job);
+        return job;
+    }
+    // Plain object job definition (JSON-style)
+    return convertKeys(convertValueKeys(obj));
+}
+/**
+ * Build a jobs section from Workflow.props.jobs entries.
+ * Returns undefined when props.jobs is absent or empty.
+ */
+function buildInlineJobsSection(props, entityNames) {
+    if (!props.jobs || typeof props.jobs !== "object" || Array.isArray(props.jobs))
+        return undefined;
+    const jobsSection = {};
+    for (const [jName, jobValue] of Object.entries(props.jobs)) {
+        const serialized = serializeInlineJob(jobValue, entityNames);
+        if (serialized)
+            jobsSection[toKebabCase(jName)] = serialized;
+    }
+    return Object.keys(jobsSection).length > 0 ? jobsSection : undefined;
+}
+/**
+ * Build a jobs section from standalone top-level Job entity exports.
+ * Returns undefined when there are no standalone jobs.
+ */
+function buildStandaloneJobsSection(jobs, entityNames) {
+    if (jobs.length === 0)
+        return undefined;
+    const jobsSection = {};
+    for (const [name, job] of jobs) {
+        const jProps = toYAMLValue(withoutComment(isResourceDeclarable(job) ? job.props : undefined), entityNames);
+        if (!jProps)
+            continue;
+        const converted = convertKeys(jProps);
+        attachComments(job, converted);
+        jobsSection[toKebabCase(name)] = converted;
+    }
+    return Object.keys(jobsSection).length > 0 ? jobsSection : undefined;
+}
+// ── Key conversion for YAML output ────────────────────────────────
+/**
+ * Map keys whose entries are user-named, not schema properties. `env` names
+ * environment variables (`KUBECONFIG_DATA` must stay `KUBECONFIG_DATA`, not
+ * become `kubeconfig_data`), `with` names an action's declared inputs,
+ * `outputs`/`secrets`/`variables` name user identifiers referenced elsewhere
+ * by exact spelling. Kebab-casing inside these silently renames them.
+ */
+const VERBATIM_KEY_MAPS = new Set(["env", "with", "outputs", "secrets", "variables"]);
+/**
+ * Convert a props object keys from camelCase to kebab-case for job/step properties.
+ */
+function convertKeys(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (value === undefined || value === null)
+            continue;
+        // Zero and false are valid values, but undefined/null should be omitted
+        const yamlKey = toKebabCase(key);
+        result[yamlKey] = convertValueKeys(value, VERBATIM_KEY_MAPS.has(yamlKey));
+    }
+    return result;
+}
+function convertValueKeys(value, verbatim = false) {
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value !== "object")
+        return value;
+    if (Array.isArray(value))
+        return value.map((v) => convertValueKeys(v, verbatim));
+    const obj = value;
+    const result = {};
+    for (const [key, v] of Object.entries(obj)) {
+        if (v === undefined || v === null)
+            continue;
+        const yamlKey = verbatim ? key : toKebabCase(key);
+        result[yamlKey] = convertValueKeys(v, verbatim || VERBATIM_KEY_MAPS.has(yamlKey));
+    }
+    return result;
+}
+// ── Serializer ────────────────────────────────────────────────────
+/**
+ * GitHub Actions YAML serializer implementation.
+ */
+export const githubSerializer = {
+    name: "github",
+    rulePrefix: "GHA",
+    serialize(entities, _outputs) {
+        const entityNames = new Map();
+        for (const [name, entity] of entities) {
+            entityNames.set(entity, name);
+        }
+        // Categorize entities
+        const workflows = [];
+        const jobs = [];
+        const triggers = [];
+        const dependabot = [];
+        const others = [];
+        for (const [name, entity] of entities) {
+            if (isPropertyDeclarable(entity))
+                continue;
+            const entityType = entity.entityType;
+            if (entityType === "GitHub::Actions::Workflow") {
+                workflows.push([name, entity]);
+            }
+            else if (entityType === "GitHub::Actions::Job" || entityType === "GitHub::Actions::ReusableWorkflowCallJob") {
+                jobs.push([name, entity]);
+            }
+            else if (isTriggerType(entityType)) {
+                triggers.push([name, entity]);
+            }
+            else if (entityType === "GitHub::Dependabot::Config") {
+                dependabot.push([name, entity]);
+            }
+            else {
+                others.push([name, entity]);
+            }
+        }
+        const workflowOut = workflows.length > 1
+            ? serializeMultiWorkflow(workflows, jobs, triggers, entities, entityNames)
+            : serializeSingleWorkflow(workflows, jobs, triggers, entities, entityNames);
+        // A DependabotConfig emits an additional `.github/dependabot.yml` file
+        // alongside (or instead of) any workflow output.
+        if (dependabot.length > 0) {
+            const [, dep] = dependabot[0];
+            const depProps = (isResourceDeclarable(dep) ? dep.props : undefined);
+            const dependabotYaml = emitDependabotYaml(depProps);
+            if (typeof workflowOut === "string") {
+                return { primary: workflowOut, files: { "dependabot.yml": dependabotYaml } };
+            }
+            return { ...workflowOut, files: { ...(workflowOut.files ?? {}), "dependabot.yml": dependabotYaml } };
+        }
+        return workflowOut;
+    },
+};
+/** Deep camelCase → kebab-case key conversion for dependabot props. */
+function deepKebabKeys(value) {
+    if (Array.isArray(value))
+        return value.map(deepKebabKeys);
+    if (value !== null && typeof value === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[toKebabCase(k)] = deepKebabKeys(v);
+        }
+        return out;
+    }
+    return value;
+}
+/** Serialize a DependabotConfig's props into `.github/dependabot.yml`. */
+function emitDependabotYaml(props) {
+    const doc = deepKebabKeys(props);
+    return emitYAMLDocument(doc);
+}
+function serializeSingleWorkflow(workflows, jobs, triggers, _entities, entityNames) {
+    const doc = {};
+    // Workflow-level properties
+    if (workflows.length > 0) {
+        const [, wf] = workflows[0];
+        const props = toYAMLValue(isResourceDeclarable(wf) ? wf.props : undefined, entityNames);
+        if (props) {
+            if (props.name)
+                doc.name = props.name;
+            if (props["run-name"] || props.runName)
+                doc["run-name"] = props["run-name"] ?? props.runName;
+            if (props.permissions)
+                doc.permissions = convertValueKeys(props.permissions);
+            if (props.env)
+                doc.env = props.env;
+            if (props.concurrency)
+                doc.concurrency = convertValueKeys(props.concurrency);
+            if (props.defaults)
+                doc.defaults = convertValueKeys(props.defaults);
+            // Handle 'on' from workflow props
+            if (props.on) {
+                doc.on = convertTriggerProps(props.on);
+            }
+        }
+    }
+    // If triggers exist as separate entities, merge into 'on'
+    if (triggers.length > 0) {
+        const onSection = doc.on ?? {};
+        for (const [, trigger] of triggers) {
+            const entityType = trigger.entityType;
+            const eventName = TRIGGER_TYPE_TO_EVENT[entityType];
+            if (!eventName)
+                continue;
+            const props = toYAMLValue(isResourceDeclarable(trigger) ? trigger.props : undefined, entityNames);
+            if (props && Object.keys(props).length > 0) {
+                onSection[eventName] = convertValueKeys(props);
+            }
+            else {
+                onSection[eventName] = null;
+            }
+        }
+        doc.on = onSection;
+    }
+    // Jobs: prefer Workflow.props.jobs (raw) when present; fall back to standalone Job exports
+    let jobsSection;
+    if (workflows.length > 0) {
+        const rawProps = (isResourceDeclarable(workflows[0][1]) ? workflows[0][1].props : undefined);
+        jobsSection = buildInlineJobsSection(rawProps, entityNames);
+    }
+    if (!jobsSection)
+        jobsSection = buildStandaloneJobsSection(jobs, entityNames);
+    if (jobsSection)
+        doc.jobs = jobsSection;
+    return emitYAMLDocument(doc, workflows.length > 0 ? commentOf(workflows[0][1]) : undefined);
+}
+function serializeMultiWorkflow(workflows, jobs, triggers, _entities, entityNames) {
+    const files = {};
+    let primary = "";
+    for (let i = 0; i < workflows.length; i++) {
+        const [name, wf] = workflows[i];
+        const doc = {};
+        const props = toYAMLValue(isResourceDeclarable(wf) ? wf.props : undefined, entityNames);
+        if (props) {
+            if (props.name)
+                doc.name = props.name;
+            if (props.on)
+                doc.on = convertTriggerProps(props.on);
+            if (props.permissions)
+                doc.permissions = convertValueKeys(props.permissions);
+            if (props.env)
+                doc.env = props.env;
+            if (props.concurrency)
+                doc.concurrency = convertValueKeys(props.concurrency);
+            if (props.defaults)
+                doc.defaults = convertValueKeys(props.defaults);
+        }
+        // Attach all triggers to first workflow for now
+        if (i === 0 && triggers.length > 0) {
+            const onSection = doc.on ?? {};
+            for (const [, trigger] of triggers) {
+                const entityType = trigger.entityType;
+                const eventName = TRIGGER_TYPE_TO_EVENT[entityType];
+                if (!eventName)
+                    continue;
+                const tProps = toYAMLValue(isResourceDeclarable(trigger) ? trigger.props : undefined, entityNames);
+                if (tProps && Object.keys(tProps).length > 0) {
+                    onSection[eventName] = convertValueKeys(tProps);
+                }
+                else {
+                    onSection[eventName] = null;
+                }
+            }
+            doc.on = onSection;
+        }
+        // Jobs: use Workflow.props.jobs when defined, otherwise fall back to standalone exports
+        // (standalone exports only assigned to first workflow, for backwards compat with composites)
+        const rawProps = (isResourceDeclarable(wf) ? wf.props : undefined);
+        const inlineJobs = buildInlineJobsSection(rawProps, entityNames);
+        const jobsSection = inlineJobs ?? (i === 0 ? buildStandaloneJobsSection(jobs, entityNames) : undefined);
+        if (jobsSection)
+            doc.jobs = jobsSection;
+        const content = emitYAMLDocument(doc, commentOf(wf));
+        if (i === 0) {
+            primary = content;
+            // primary is written to the -o path by the CLI; don't also add it to files[]
+        }
+        else {
+            files[`${toKebabCase(name)}.yml`] = content;
+        }
+    }
+    return { primary, files };
+}
+/**
+ * Convert trigger props to YAML-compatible form.
+ */
+function convertTriggerProps(on) {
+    if (typeof on !== "object" || on === null)
+        return on;
+    if (Array.isArray(on))
+        return on;
+    const result = {};
+    for (const [key, value] of Object.entries(on)) {
+        const eventName = toSnakeCase(key);
+        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+            result[eventName] = convertValueKeys(value);
+        }
+        else {
+            result[eventName] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Emit a complete YAML document from a structured object.
+ */
+function emitYAMLDocument(doc, header) {
+    const sections = [];
+    if (header)
+        sections.push(commentLines(header, 0));
+    // Emit in canonical order: name, run-name, on, permissions, env, concurrency, defaults, jobs
+    const order = ["name", "run-name", "on", "permissions", "env", "concurrency", "defaults", "jobs"];
+    const emitted = new Set();
+    for (const key of order) {
+        if (key in doc && doc[key] !== undefined) {
+            emitted.add(key);
+            const value = doc[key];
+            if (value === null) {
+                sections.push(`${key}:`);
+            }
+            else if (key === "jobs" && hasComments(value)) {
+                sections.push(emitJobs(value));
+            }
+            else if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+                sections.push(`${key}: ${yamlScalar(value)}`);
+            }
+            else {
+                sections.push(emitYAMLEntry(key, value));
+            }
+        }
+    }
+    // Remaining keys
+    for (const [key, value] of Object.entries(doc)) {
+        if (emitted.has(key) || value === undefined)
+            continue;
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+            sections.push(`${key}: ${yamlScalar(value)}`);
+        }
+        else {
+            sections.push(emitYAMLEntry(key, value));
+        }
+    }
+    return unquotePinComments(sections.join("\n\n") + "\n");
+}
+/** Whether any job in a jobs section, or any of its steps, carries a comment. */
+function hasComments(jobs) {
+    if (!jobs || typeof jobs !== "object")
+        return false;
+    return Object.values(jobs).some((job) => !!job && typeof job === "object" && (COMMENTS.has(job) || stepsOf(job).some((s) => !!s && typeof s === "object" && COMMENTS.has(s))));
+}
+const stepsOf = (job) => {
+    const steps = job.steps;
+    return Array.isArray(steps) ? steps : [];
+};
+/**
+ * The jobs section with each comment above its job or step. Everything else
+ * is what `emitYAMLEntry("jobs", jobs)` writes: the job at indent 1, its keys
+ * at 2, its step items at 3.
+ */
+function emitJobs(jobs) {
+    const lines = ["jobs:"];
+    for (const [name, job] of Object.entries(jobs)) {
+        if (job === undefined)
+            continue;
+        if (!job || typeof job !== "object" || Array.isArray(job)) {
+            lines.push(emitYAMLEntry(name, job, 1));
+            continue;
+        }
+        const comment = COMMENTS.get(job);
+        if (comment)
+            lines.push(commentLines(comment, 1));
+        const steps = stepsOf(job);
+        if (!steps.some((s) => !!s && typeof s === "object" && COMMENTS.has(s))) {
+            lines.push(emitYAMLEntry(name, job, 1));
+            continue;
+        }
+        lines.push(`  ${name}:`);
+        for (const [key, value] of Object.entries(job)) {
+            if (value === undefined)
+                continue;
+            if (key !== "steps") {
+                lines.push(emitYAMLEntry(key, value, 2));
+                continue;
+            }
+            lines.push("    steps:");
+            for (const step of steps) {
+                const stepComment = step && typeof step === "object" ? COMMENTS.get(step) : undefined;
+                if (stepComment)
+                    lines.push(commentLines(stepComment, 3));
+                lines.push(emitYAML([step], 3).slice(1));
+            }
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * A SHA-pinned `uses:` carries its version as a trailing comment
+ * (`actions/checkout@<sha> # v7.0.1`). The YAML emitter quotes any string with
+ * a `#`, which would make the comment part of the ref GitHub resolves. A ref
+ * holds no whitespace, so `<ref> # <label>` inside quotes is always this
+ * pattern, and writing it unquoted turns the label back into a comment.
+ */
+function unquotePinComments(yaml) {
+    return yaml.replace(/^(\s*(?:- )?uses: )'([^\s']+) # ([^'\n]*)'$/gm, "$1$2 # $3");
+}
+function yamlScalar(value) {
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    if (typeof value === "number")
+        return String(value);
+    // Quote strings that might be ambiguous
+    if (/^[\d]|[:#\[\]{}|>&*!%@`]|true|false|null|yes|no/i.test(value)) {
+        return `'${value.replace(/'/g, "''")}'`;
+    }
+    return value;
+}

package/dist/spec/fetch.js

@@ -0,0 +1,46 @@
+/**
+ * GitHub Actions workflow schema fetching — downloads the JSON Schema
+ * and caches it locally.
+ */
+import { join } from "path";
+import { homedir } from "os";
+import { fetchWithCache, clearCacheFile } from "@intentius/chant/codegen/fetch";
+/**
+ * Schema URL from SchemaStore.
+ */
+const SCHEMA_URL = "https://json.schemastore.org/github-workflow.json";
+/**
+ * Get the cache file path for the workflow schema.
+ */
+export function getCachePath() {
+    return join(homedir(), ".chant", "github-workflow-schema.json");
+}
+/**
+ * Fetch the GitHub Actions Workflow JSON Schema.
+ * Uses local file caching with 24-hour TTL.
+ */
+export async function fetchWorkflowSchema(force) {
+    return fetchWithCache({
+        url: SCHEMA_URL,
+        cacheFile: getCachePath(),
+    }, force);
+}
+/**
+ * Fetch the workflow schema as a Map<typeName, Buffer>
+ * compatible with the generatePipeline fetchSchemas callback.
+ *
+ * Single document keyed by "GitHub::Actions::Workflow" — the parse
+ * step will split it into multiple entities.
+ */
+export async function fetchSchemas(force) {
+    const data = await fetchWorkflowSchema(force);
+    const schemas = new Map();
+    schemas.set("GitHub::Actions::Workflow", data);
+    return schemas;
+}
+/**
+ * Clear the cached schema file.
+ */
+export function clearCache() {
+    clearCacheFile(getCachePath());
+}

package/dist/validate-cli.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env tsx
+/**
+ * Thin entry point for `npm run validate` in lexicon-github.
+ */
+import { validate } from "./validate.js";
+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/dist/validate.js

@@ -0,0 +1,38 @@
+/**
+ * Validate generated lexicon-github artifacts.
+ */
+import { dirname, join } from "path";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+import { validateLexiconArtifacts } from "@intentius/chant/codegen/validate";
+const REQUIRED_NAMES = [
+    "Workflow", "Job", "ReusableWorkflowCallJob",
+    "Step", "Strategy", "Permissions", "Concurrency",
+    "Container", "Service", "Environment", "Defaults",
+    "PushTrigger", "PullRequestTrigger", "PullRequestTargetTrigger",
+    "ScheduleTrigger", "WorkflowDispatchTrigger", "WorkflowCallTrigger",
+    "WorkflowRunTrigger", "RepositoryDispatchTrigger",
+    "WorkflowInput", "WorkflowOutput", "WorkflowSecret",
+];
+/**
+ * Validate the generated lexicon-github artifacts.
+ */
+export async function validate(opts) {
+    const basePath = opts?.basePath ?? dirname(dirname(fileURLToPath(import.meta.url)));
+    const generatedDir = join(basePath, "src", "generated");
+    if (!existsSync(generatedDir)) {
+        return {
+            success: false,
+            checks: [{
+                    name: "generated-dir",
+                    ok: false,
+                    error: 'src/generated/ not found — run "chant dev generate" first',
+                }],
+        };
+    }
+    return validateLexiconArtifacts({
+        lexiconJsonFilename: "lexicon-github.json",
+        requiredNames: REQUIRED_NAMES,
+        basePath,
+    });
+}