@intentius/chant-lexicon-github 0.124.31 → 0.124.32

package/dist/composites/setup-python.js

@@ -0,0 +1,18 @@
+import { Composite, mergeDefaults } from "@intentius/chant";
+import { Step } from "../generated/index.js";
+export const SetupPython = Composite((props) => {
+    const { defaults } = props;
+    const withObj = {};
+    if (props.pythonVersion !== undefined)
+        withObj["python-version"] = props.pythonVersion;
+    if (props.cache !== undefined)
+        withObj.cache = props.cache;
+    if (props.architecture !== undefined)
+        withObj.architecture = props.architecture;
+    const step = new Step(mergeDefaults({
+        name: "Setup Python",
+        uses: "actions/setup-python@v5",
+        ...(Object.keys(withObj).length > 0 ? { with: withObj } : {}),
+    }, defaults?.step));
+    return { step };
+}, "SetupPython");

package/dist/composites/upload-artifact.js

@@ -0,0 +1,19 @@
+import { Composite, mergeDefaults } from "@intentius/chant";
+import { Step } from "../generated/index.js";
+export const UploadArtifact = Composite((props) => {
+    const { defaults } = props;
+    const withObj = {
+        name: props.name,
+        path: props.path,
+    };
+    if (props.retentionDays !== undefined)
+        withObj["retention-days"] = String(props.retentionDays);
+    if (props.compressionLevel !== undefined)
+        withObj["compression-level"] = String(props.compressionLevel);
+    const step = new Step(mergeDefaults({
+        name: "Upload Artifact",
+        uses: "actions/upload-artifact@v4",
+        with: withObj,
+    }, defaults?.step));
+    return { step };
+}, "UploadArtifact");

package/dist/coverage.js

@@ -0,0 +1,32 @@
+/**
+ * Coverage analysis for GitHub Actions lexicon.
+ */
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { computeCoverage, overallPct, formatSummary, formatVerbose, checkThresholds, } from "@intentius/chant/codegen/coverage";
+export { computeCoverage, overallPct, formatSummary, formatVerbose, checkThresholds };
+/**
+ * Run coverage analysis for the GitHub Actions lexicon.
+ */
+export async function analyzeGitHubCoverage(opts) {
+    const basePath = opts?.basePath ?? dirname(dirname(fileURLToPath(import.meta.url)));
+    const lexiconPath = join(basePath, "src", "generated", "lexicon-github.json");
+    const content = readFileSync(lexiconPath, "utf-8");
+    const report = computeCoverage(content);
+    if (opts?.verbose) {
+        console.error(formatVerbose(report));
+    }
+    else {
+        console.error(formatSummary(report));
+    }
+    if (typeof opts?.minOverall === "number") {
+        const result = checkThresholds(report, { minOverallPct: opts.minOverall });
+        if (!result.ok) {
+            for (const v of result.violations)
+                console.error(`  FAIL: ${v}`);
+            throw new Error("Coverage below threshold");
+        }
+    }
+    return report;
+}

package/dist/expression.js

@@ -0,0 +1,177 @@
+/**
+ * GitHub Actions expression system.
+ *
+ * Provides a typed Expression class and context accessors for building
+ * ${{ }} expressions in GitHub Actions workflows.
+ */
+import { INTRINSIC_MARKER } from "@intentius/chant/intrinsic";
+/**
+ * A GitHub Actions expression that serializes to `${{ raw }}`.
+ */
+export class Expression {
+    constructor(raw) {
+        this[INTRINSIC_MARKER] = true;
+        this._raw = raw;
+    }
+    /** The raw expression string without ${{ }} wrapper. */
+    raw() {
+        return this._raw;
+    }
+    /** Returns the expression wrapped in ${{ }}. */
+    toString() {
+        return `\${{ ${this._raw} }}`;
+    }
+    toJSON() {
+        return this.toString();
+    }
+    /** YAML serialization — plain string with ${{ }}. */
+    toYAML() {
+        return this.toString();
+    }
+    /** Logical AND with another expression. */
+    and(other) {
+        return new Expression(`${this._raw} && ${other._raw}`);
+    }
+    /** Logical OR with another expression. */
+    or(other) {
+        return new Expression(`${this._raw} || ${other._raw}`);
+    }
+    /** Logical NOT of this expression. */
+    not() {
+        return new Expression(`!(${this._raw})`);
+    }
+    /** Equality comparison. */
+    eq(value) {
+        const rhs = value instanceof Expression ? value._raw : `'${value}'`;
+        return new Expression(`${this._raw} == ${rhs}`);
+    }
+    /** Inequality comparison. */
+    ne(value) {
+        const rhs = value instanceof Expression ? value._raw : `'${value}'`;
+        return new Expression(`${this._raw} != ${rhs}`);
+    }
+}
+// ── Context accessors ─────────────────────────────────────────────
+/** GitHub context — github.* properties. */
+export const github = {
+    get ref() { return new Expression("github.ref"); },
+    get sha() { return new Expression("github.sha"); },
+    get actor() { return new Expression("github.actor"); },
+    get repository() { return new Expression("github.repository"); },
+    get repositoryOwner() { return new Expression("github.repository_owner"); },
+    get event() { return new Expression("github.event"); },
+    get eventName() { return new Expression("github.event_name"); },
+    get runId() { return new Expression("github.run_id"); },
+    get runNumber() { return new Expression("github.run_number"); },
+    get workflow() { return new Expression("github.workflow"); },
+    get workspace() { return new Expression("github.workspace"); },
+    get token() { return new Expression("github.token"); },
+    get job() { return new Expression("github.job"); },
+    get refName() { return new Expression("github.ref_name"); },
+    get refType() { return new Expression("github.ref_type"); },
+    get headRef() { return new Expression("github.head_ref"); },
+    get baseRef() { return new Expression("github.base_ref"); },
+    get serverUrl() { return new Expression("github.server_url"); },
+    get apiUrl() { return new Expression("github.api_url"); },
+    get graphqlUrl() { return new Expression("github.graphql_url"); },
+    get action() { return new Expression("github.action"); },
+    get actionPath() { return new Expression("github.action_path"); },
+    get triggeringActor() { return new Expression("github.triggering_actor"); },
+};
+/** Runner context — runner.* properties. */
+export const runner = {
+    get os() { return new Expression("runner.os"); },
+    get arch() { return new Expression("runner.arch"); },
+    get temp() { return new Expression("runner.temp"); },
+    get toolCache() { return new Expression("runner.tool_cache"); },
+    get name() { return new Expression("runner.name"); },
+};
+/** Access a secret by name. */
+export function secrets(name) {
+    return new Expression(`secrets.${name}`);
+}
+/** Access a matrix value by key. */
+export function matrix(key) {
+    return new Expression(`matrix.${key}`);
+}
+/** Access a step output. */
+export function steps(id) {
+    return {
+        outputs(name) {
+            return new Expression(`steps.${id}.outputs.${name}`);
+        },
+    };
+}
+/** Access a job output from a needed job. */
+export function needs(job) {
+    return {
+        outputs(name) {
+            return new Expression(`needs.${job}.outputs.${name}`);
+        },
+    };
+}
+/** Access a workflow input. */
+export function inputs(name) {
+    return new Expression(`inputs.${name}`);
+}
+/** Access a configuration variable. */
+export function vars(name) {
+    return new Expression(`vars.${name}`);
+}
+/** Access an environment variable. */
+export function env(name) {
+    return new Expression(`env.${name}`);
+}
+// ── Condition helpers ─────────────────────────────────────────────
+/** Always run, regardless of status. */
+export function always() {
+    return new Expression("always()");
+}
+/** Run only if a previous step has failed. */
+export function failure() {
+    return new Expression("failure()");
+}
+/** Run only if all previous steps succeeded (default). */
+export function success() {
+    return new Expression("success()");
+}
+/** Run only if the workflow was cancelled. */
+export function cancelled() {
+    return new Expression("cancelled()");
+}
+// ── Function helpers ──────────────────────────────────────────────
+/** Check if a string contains a substring. */
+export function contains(haystack, needle) {
+    const h = haystack instanceof Expression ? haystack.raw() : `'${haystack}'`;
+    const n = needle instanceof Expression ? needle.raw() : `'${needle}'`;
+    return new Expression(`contains(${h}, ${n})`);
+}
+/** Check if a string starts with a prefix. */
+export function startsWith(value, prefix) {
+    const v = value instanceof Expression ? value.raw() : `'${value}'`;
+    const p = prefix instanceof Expression ? prefix.raw() : `'${prefix}'`;
+    return new Expression(`startsWith(${v}, ${p})`);
+}
+/** Convert a value to JSON. */
+export function toJSON(value) {
+    return new Expression(`toJSON(${value.raw()})`);
+}
+/** Parse a JSON string. */
+export function fromJSON(json) {
+    const j = json instanceof Expression ? json.raw() : `'${json}'`;
+    return new Expression(`fromJSON(${j})`);
+}
+/** Format a string with placeholders. */
+export function format(template, ...args) {
+    const argStrs = args.map((a) => a.raw()).join(", ");
+    return new Expression(`format('${template}', ${argStrs})`);
+}
+// ── Convenience helpers ───────────────────────────────────────────
+/** Check if the ref matches a branch name. */
+export function branch(name) {
+    return github.ref.eq(`refs/heads/${name}`);
+}
+/** Check if the ref matches a tag prefix. */
+export function tag(name) {
+    return startsWith(github.ref, `refs/tags/${name}`);
+}

package/dist/generated/index.js

@@ -0,0 +1,26 @@
+// Code generated by chant generate. DO NOT EDIT.
+import { createResource, createProperty } from "./runtime.js";
+export const Job = /* @__PURE__ */ createResource("GitHub::Actions::Job", "github", {});
+export const ReusableWorkflowCallJob = /* @__PURE__ */ createResource("GitHub::Actions::ReusableWorkflowCallJob", "github", {});
+export const Workflow = /* @__PURE__ */ createResource("GitHub::Actions::Workflow", "github", {});
+export const Concurrency = /* @__PURE__ */ createProperty("GitHub::Actions::Concurrency", "github");
+export const Container = /* @__PURE__ */ createProperty("GitHub::Actions::Container", "github");
+export const Defaults = /* @__PURE__ */ createProperty("GitHub::Actions::Defaults", "github");
+export const Environment = /* @__PURE__ */ createProperty("GitHub::Actions::Environment", "github");
+export const Permissions = /* @__PURE__ */ createProperty("GitHub::Actions::Permissions", "github");
+export const PullRequestTargetTrigger = /* @__PURE__ */ createProperty("GitHub::Actions::PullRequestTargetTrigger", "github");
+export const PullRequestTrigger = /* @__PURE__ */ createProperty("GitHub::Actions::PullRequestTrigger", "github");
+export const PushTrigger = /* @__PURE__ */ createProperty("GitHub::Actions::PushTrigger", "github");
+export const RepositoryDispatchTrigger = /* @__PURE__ */ createProperty("GitHub::Actions::RepositoryDispatchTrigger", "github");
+export const ScheduleTrigger = /* @__PURE__ */ createProperty("GitHub::Actions::ScheduleTrigger", "github");
+export const Service = /* @__PURE__ */ createProperty("GitHub::Actions::Service", "github");
+export const Step = /* @__PURE__ */ createProperty("GitHub::Actions::Step", "github");
+export const Strategy = /* @__PURE__ */ createProperty("GitHub::Actions::Strategy", "github");
+export const WorkflowCallTrigger = /* @__PURE__ */ createProperty("GitHub::Actions::WorkflowCallTrigger", "github");
+export const WorkflowDispatchTrigger = /* @__PURE__ */ createProperty("GitHub::Actions::WorkflowDispatchTrigger", "github");
+export const WorkflowInput = /* @__PURE__ */ createProperty("GitHub::Actions::WorkflowInput", "github");
+export const WorkflowOutput = /* @__PURE__ */ createProperty("GitHub::Actions::WorkflowOutput", "github");
+export const WorkflowRunTrigger = /* @__PURE__ */ createProperty("GitHub::Actions::WorkflowRunTrigger", "github");
+export const WorkflowSecret = /* @__PURE__ */ createProperty("GitHub::Actions::WorkflowSecret", "github");
+// Re-exports for convenience
+export { GitHub, Runner } from "../variables.js";

package/dist/generated/runtime.js

@@ -0,0 +1,4 @@
+/**
+ * Runtime factory constructors — re-exported from core.
+ */
+export { createResource, createProperty } from "@intentius/chant/runtime";

package/dist/graph-edges.js

@@ -0,0 +1,174 @@
+/**
+ * GitHub Actions dependencies as graph edges (#3910).
+ *
+ * `chant graph` draws an edge for every typed reference it can find, and a
+ * workflow has almost none: a job names the jobs it waits for, the reusable
+ * workflow it calls and the workflows that trigger it as strings. This module
+ * resolves those strings against the declared entities, the way the
+ * serializer would place them, and reports each one through the plugin's
+ * `graphEdges` hook:
+ *
+ *  - `needs`    job -> job in the same workflow
+ *  - `calls`    job -> the workflow a `uses: ./.github/workflows/<file>` names,
+ *               and job -> a composite action a step uses by local path
+ *  - `triggers` workflow -> each workflow its `on.workflow_run.workflows` names
+ *
+ * A string that names nothing declared (another repository's workflow, a
+ * typo'd job, a composite action, which chant does not declare) is reported
+ * as dangling, never matched to a near name.
+ *
+ * Forgejo reuses this module: its entities are github entities, and Forgejo
+ * reads reusable workflows from `.forgejo/workflows/` as well.
+ */
+import { isPropertyDeclarable } from "@intentius/chant/declarable";
+const WORKFLOW = "GitHub::Actions::Workflow";
+const JOB_TYPES = new Set(["GitHub::Actions::Job", "GitHub::Actions::ReusableWorkflowCallJob"]);
+function toKebabCase(name) {
+    return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function entityType(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const t = value.entityType;
+    return typeof t === "string" ? t : undefined;
+}
+/** A Declarable's props bag, or the plain object itself (JSON-style jobs and steps). */
+function propsOf(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const props = value.props;
+    if (entityType(value) !== undefined) {
+        return props && typeof props === "object" ? props : undefined;
+    }
+    return value;
+}
+/**
+ * Which jobs land in which workflow, mirroring ./serializer.ts: a workflow's
+ * own `jobs:` map when it has one, and otherwise the standalone Job exports,
+ * which go to the first workflow only.
+ */
+function placeJobs(entities) {
+    const names = new Map();
+    const workflows = [];
+    const standalone = [];
+    for (const [name, entity] of entities) {
+        names.set(entity, name);
+        if (isPropertyDeclarable(entity))
+            continue;
+        const type = entityType(entity);
+        if (type === WORKFLOW)
+            workflows.push([name, entity]);
+        else if (type && JOB_TYPES.has(type))
+            standalone.push({ key: toKebabCase(name), node: name, props: propsOf(entity) ?? {} });
+    }
+    const placed = workflows.map(([name, wf], i) => {
+        const props = propsOf(wf) ?? {};
+        const inline = [];
+        const jobs = props.jobs;
+        if (jobs && typeof jobs === "object" && !Array.isArray(jobs)) {
+            for (const [key, value] of Object.entries(jobs)) {
+                const jobProps = propsOf(value);
+                if (!jobProps)
+                    continue;
+                inline.push({ key: toKebabCase(key), node: names.get(value), props: jobProps });
+            }
+        }
+        return { name, props, jobs: inline.length > 0 ? inline : i === 0 ? standalone : [] };
+    });
+    return { workflows: placed, orphans: workflows.length === 0 ? standalone : [] };
+}
+/** The file a declared workflow is written to. Every workflow after the first
+ * is `<kebab-name>.yml` (./serializer.ts); the first is written to the
+ * `--output` path, which the examples and templates name the same way. */
+function workflowFile(name) {
+    return `${toKebabCase(name)}.yml`;
+}
+const stripYamlExt = (file) => file.replace(/\.ya?ml$/, "");
+/** `needs:` as a list of job keys. A Job object held directly names itself. */
+function needsKeys(needs, names) {
+    const list = Array.isArray(needs) ? needs : needs === undefined ? [] : [needs];
+    const out = [];
+    for (const item of list) {
+        if (typeof item === "string")
+            out.push(item);
+        else if (names.has(item))
+            out.push(toKebabCase(names.get(item)));
+    }
+    return out;
+}
+/** `on.workflow_run.workflows`, read from the camelCase or snake_case key. */
+function workflowRunNames(on) {
+    const triggers = propsOf(on);
+    if (!triggers)
+        return [];
+    const run = propsOf(triggers.workflow_run ?? triggers.workflowRun);
+    const workflows = run?.workflows;
+    if (typeof workflows === "string")
+        return [workflows];
+    return Array.isArray(workflows) ? workflows.filter((w) => typeof w === "string") : [];
+}
+/** The graph edges and pipeline membership a GitHub (or Forgejo) project declares. */
+export function githubGraphEdges(entities) {
+    const { workflows, orphans } = placeJobs(entities);
+    if (workflows.length === 0 && orphans.length === 0)
+        return undefined;
+    const names = new Map();
+    for (const [name, entity] of entities)
+        names.set(entity, name);
+    const byFile = new Map();
+    const byDisplayName = new Map();
+    for (const wf of workflows) {
+        byFile.set(stripYamlExt(workflowFile(wf.name)), wf.name);
+        if (typeof wf.props.name === "string")
+            byDisplayName.set(wf.props.name, wf.name);
+    }
+    const references = [];
+    const pipelines = {};
+    const visitJobs = (jobs, workflow) => {
+        const byKey = new Map(jobs.map((j) => [j.key, j]));
+        for (const job of jobs) {
+            const from = job.node ?? workflow;
+            if (!from)
+                continue;
+            for (const key of needsKeys(job.props.needs, names)) {
+                const target = byKey.get(key);
+                const to = target ? (target.node ?? workflow) : undefined;
+                if (to)
+                    references.push({ from, to, kind: "needs", viaAttr: "needs" });
+                else
+                    references.push({ from, to: key, kind: "needs", viaAttr: "needs", dangling: true });
+            }
+            const uses = job.props.uses;
+            if (typeof uses === "string") {
+                const local = /^\.\/(?:.*\/)?workflows\/([^/]+\.ya?ml)$/.exec(uses);
+                const called = local ? byFile.get(stripYamlExt(local[1])) : undefined;
+                if (called)
+                    references.push({ from, to: called, kind: "calls", viaAttr: "uses", crossPipeline: true });
+                else
+                    references.push({ from, to: uses, kind: "calls", viaAttr: "uses", crossPipeline: true, dangling: true });
+            }
+            const steps = Array.isArray(job.props.steps) ? job.props.steps : [];
+            for (const step of steps) {
+                const stepUses = propsOf(step)?.uses;
+                // A local composite action. Remote actions (`owner/repo@ref`,
+                // `docker://`) are packages, not part of this project's graph.
+                if (typeof stepUses === "string" && stepUses.startsWith("./")) {
+                    references.push({ from, to: stepUses, kind: "calls", viaAttr: "steps.uses", dangling: true });
+                }
+            }
+        }
+    };
+    for (const wf of workflows) {
+        visitJobs(wf.jobs, wf.name);
+        pipelines[wf.name] = [wf.name, ...wf.jobs.map((j) => j.node).filter((n) => n !== undefined)];
+        for (const trigger of workflowRunNames(wf.props.on)) {
+            const to = byDisplayName.get(trigger);
+            if (to)
+                references.push({ from: wf.name, to, kind: "triggers", viaAttr: "workflow_run", crossPipeline: true });
+            else
+                references.push({ from: wf.name, to: trigger, kind: "triggers", viaAttr: "workflow_run", crossPipeline: true, dangling: true });
+        }
+    }
+    visitJobs(orphans);
+    return { references, ...(Object.keys(pipelines).length > 0 ? { pipelines } : {}) };
+}

package/dist/import/generator.js

@@ -0,0 +1,108 @@
+/**
+ * TypeScript code generator for GitHub Actions import.
+ *
+ * Converts a TemplateIR into TypeScript source code using
+ * the @intentius/chant-lexicon-github constructors.
+ */
+const TYPE_TO_CLASS = {
+    "GitHub::Actions::Workflow": "Workflow",
+    "GitHub::Actions::Job": "Job",
+    "GitHub::Actions::ReusableWorkflowCallJob": "ReusableWorkflowCallJob",
+};
+const PROPERTY_CONSTRUCTORS = {
+    strategy: "Strategy",
+    concurrency: "Concurrency",
+    container: "Container",
+    environment: "Environment",
+    permissions: "Permissions",
+    defaults: "Defaults",
+};
+/**
+ * Generate TypeScript source code from a GitHub Actions IR.
+ */
+export class GitHubActionsGenerator {
+    generate(ir) {
+        const lines = [];
+        const usedConstructors = new Set();
+        for (const resource of ir.resources) {
+            const cls = TYPE_TO_CLASS[resource.type];
+            if (cls)
+                usedConstructors.add(cls);
+            this.collectNestedConstructors(resource.properties, usedConstructors);
+        }
+        const imports = [...usedConstructors].sort().join(", ");
+        lines.push(`import { ${imports} } from "@intentius/chant-lexicon-github";`);
+        lines.push("");
+        for (const resource of ir.resources) {
+            const cls = TYPE_TO_CLASS[resource.type];
+            if (!cls)
+                continue;
+            const varName = resource.logicalId;
+            const propsStr = this.emitProps(resource.properties, 1);
+            lines.push(`export const ${varName} = new ${cls}(${propsStr});`);
+            lines.push("");
+        }
+        return [{ path: "main.ts", content: lines.join("\n") }];
+    }
+    collectNestedConstructors(props, used) {
+        for (const [key, value] of Object.entries(props)) {
+            const constructor = PROPERTY_CONSTRUCTORS[key];
+            if (constructor && typeof value === "object" && value !== null && !Array.isArray(value)) {
+                used.add(constructor);
+            }
+        }
+    }
+    emitProps(props, depth) {
+        const indent = "  ".repeat(depth);
+        const innerIndent = "  ".repeat(depth + 1);
+        const entries = [];
+        for (const [key, value] of Object.entries(props)) {
+            if (value === undefined || value === null)
+                continue;
+            const emitted = this.emitValue(key, value, depth + 1);
+            entries.push(`${innerIndent}${JSON.stringify(key)}: ${emitted},`);
+        }
+        if (entries.length === 0)
+            return "{}";
+        return `{\n${entries.join("\n")}\n${indent}}`;
+    }
+    emitValue(key, value, depth) {
+        if (value === null || value === undefined)
+            return "undefined";
+        const constructor = PROPERTY_CONSTRUCTORS[key];
+        if (constructor && typeof value === "object" && !Array.isArray(value)) {
+            const propsStr = this.emitProps(value, depth);
+            return `new ${constructor}(${propsStr})`;
+        }
+        return this.emitLiteral(value, depth);
+    }
+    emitLiteral(value, depth) {
+        if (value === null || value === undefined)
+            return "undefined";
+        if (typeof value === "string")
+            return JSON.stringify(value);
+        if (typeof value === "number" || typeof value === "boolean")
+            return String(value);
+        if (Array.isArray(value)) {
+            if (value.length === 0)
+                return "[]";
+            const items = value.map((item) => this.emitLiteral(item, depth + 1));
+            const oneLine = `[${items.join(", ")}]`;
+            if (oneLine.length < 80)
+                return oneLine;
+            const indent = "  ".repeat(depth);
+            const innerIndent = "  ".repeat(depth + 1);
+            return `[\n${items.map((i) => `${innerIndent}${i},`).join("\n")}\n${indent}]`;
+        }
+        if (typeof value === "object") {
+            const entries = Object.entries(value);
+            if (entries.length === 0)
+                return "{}";
+            const indent = "  ".repeat(depth);
+            const innerIndent = "  ".repeat(depth + 1);
+            const items = entries.map(([k, v]) => `${innerIndent}${JSON.stringify(k)}: ${this.emitLiteral(v, depth + 1)},`);
+            return `{\n${items.join("\n")}\n${indent}}`;
+        }
+        return String(value);
+    }
+}

package/dist/import/parser.js

@@ -0,0 +1,69 @@
+/**
+ * GitHub Actions YAML parser for `chant import`.
+ *
+ * Parses existing .github/workflows/*.yml files into TemplateIR.
+ */
+import { parseYAML } from "@intentius/chant/yaml";
+function kebabToCamelCase(name) {
+    return name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function snakeToCamelCase(name) {
+    return name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+/**
+ * GitHub Actions YAML parser implementation.
+ */
+export class GitHubActionsParser {
+    parse(content) {
+        const doc = parseYAML(content);
+        const resources = [];
+        // Extract workflow-level properties
+        const workflowProps = {};
+        if (doc.name)
+            workflowProps.name = doc.name;
+        if (doc["run-name"])
+            workflowProps["run-name"] = doc["run-name"];
+        if (doc.on)
+            workflowProps.on = doc.on;
+        if (doc.permissions)
+            workflowProps.permissions = doc.permissions;
+        if (doc.env)
+            workflowProps.env = doc.env;
+        if (doc.concurrency)
+            workflowProps.concurrency = doc.concurrency;
+        if (doc.defaults)
+            workflowProps.defaults = doc.defaults;
+        if (Object.keys(workflowProps).length > 0) {
+            resources.push({
+                logicalId: "workflow",
+                type: "GitHub::Actions::Workflow",
+                properties: workflowProps,
+            });
+        }
+        // Extract jobs
+        if (doc.jobs && typeof doc.jobs === "object") {
+            for (const [jobId, jobDef] of Object.entries(doc.jobs)) {
+                if (typeof jobDef !== "object" || jobDef === null)
+                    continue;
+                const jobObj = jobDef;
+                const logicalId = kebabToCamelCase(jobId);
+                // Determine if it's a reusable workflow call job
+                const type = jobObj.uses
+                    ? "GitHub::Actions::ReusableWorkflowCallJob"
+                    : "GitHub::Actions::Job";
+                resources.push({
+                    logicalId,
+                    type,
+                    properties: jobObj,
+                    metadata: {
+                        originalName: jobId,
+                    },
+                });
+            }
+        }
+        return {
+            resources,
+            parameters: [],
+        };
+    }
+}

package/dist/index.js

@@ -0,0 +1,22 @@
+// Serializer
+export { githubSerializer } from "./serializer.js";
+export { githubGraphEdges } from "./graph-edges.js";
+// Plugin
+export { githubPlugin } from "./plugin.js";
+// Expression system
+export { Expression, github, runner, secrets, matrix, steps, needs, inputs, vars, env, always, failure, success, cancelled, contains, startsWith, toJSON, fromJSON, format, branch, tag, } from "./expression.js";
+// Context Variables
+export { GitHub, Runner } from "./variables.js";
+// Generated entities — export everything from generated index
+// After running `chant generate`, this re-exports all entity classes
+export * from "./generated/index.js";
+// Action versions the composites emit, and their pinned commits
+export { ACTION_PINS, actionRef, actionPin } from "./action-pins.js";
+// Composites
+export { Checkout, SetupNode, SetupGo, SetupPython, CacheAction, UploadArtifact, DownloadArtifact, NodeCI, NodePipeline, BunPipeline, PnpmPipeline, YarnPipeline, PythonCI, DockerBuild, DeployEnvironment, GoCI, Dependabot, DependabotConfig, PrPlanReport, } from "./composites/index.js";
+// Spec utilities (for tooling)
+export { fetchWorkflowSchema, fetchSchemas } from "./spec/fetch.js";
+export { parseWorkflowSchema, githubShortName, githubServiceName } from "./codegen/parse.js";
+// Code generation pipeline
+export { generate, writeGeneratedFiles } from "./codegen/generate.js";
+export { packageLexicon } from "./codegen/package.js";

package/dist/integrity.json

@@ -1,7 +1,7 @@
 {
   "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "c023d92a6cad1bf225f73d5030d8e2a7ed5769383b94b62c4d6a15c3267f7373",
+    "manifest.json": "1ac5c53834d0d9e3f294436372ef80c67d915538899782e8188f48379b1c884d",
     "meta.json": "c50e0ef3845c370c3ad2210b8bba455980417c0f818aa6ed46e06d4fb8b1b9f9",
     "types/index.d.ts": "0ead95536e947ddfb98a5acf0ddb88547913b5a53a342df67711c59266f84b3e",
     "rules/deprecated-action-version.ts": "a9ba7cc924ff1c7055110416d8989273690415bfb5e8dcc32dc9431b9351f5ca",
@@ -78,5 +78,5 @@
     "skills/chant-github-patterns.md": "bb3abef289a8fdfcf07d6bb2d7289dcb2f38bc0cb0321ea320b78b45a6f548c0",
     "skills/chant-github-security.md": "aab111cb0871cad30281ce48d7da23663689619351029219e2be019a1a61e394"
   },
-  "composite": "5c3bb6c14a961e31e874986fd49382290366cd82727d8d72488a75296ad236a9"
+  "composite": "fb2f379e45edbc503f525d77958b302d4f546273f1b09ba0f2d5e7d0cdde1e2f"
 }