@intentius/chant-lexicon-gitlab 0.124.31 → 0.124.32

package/dist/op/builders.js

@@ -0,0 +1,26 @@
+/**
+ * Typed step-builder wrapper for this lexicon's `gitlabPipeline` activity
+ * (chant #1288 Stage 2 — "regenerate the step builders as fully typed
+ * wrappers"). Core cannot import a lexicon's `*Args` types (lexicons depend
+ * on core, not the other way around), so a fully typed `gitlabPipeline` has
+ * to live beside {@link GitlabPipelineArgs} — here, next to
+ * `./activities/gitlab.ts`. `opts`'s type below IS `GitlabPipelineArgs`
+ * itself (via `Omit`/`WithStepRefs`) — never a hand-restated mirror.
+ *
+ * `core`'s own `gitlabPipeline` (in `@intentius/chant/op`) is UNCHANGED and
+ * produces a byte-identical `ActivityStep` for the same inputs — purely
+ * additive, and deliberately not swapped into core's barrel (see
+ * `lexicons/k8s/src/op/builders.ts`'s module doc for why: that would make
+ * core depend on this package at runtime). An author who wants the typed
+ * surface imports it from here — `@intentius/chant-lexicon-gitlab`.
+ */
+import { activity, takeProfileAndId, } from "@intentius/chant/op";
+/**
+ * Trigger and wait for a GitLab CI pipeline to complete — the fully typed
+ * twin of core's `gitlabPipeline`. `opts` is {@link GitlabPipelineArgs}
+ * itself, minus the positional `name`. Defaults to the `longInfra` profile.
+ */
+export const gitlabPipeline = (name, opts) => {
+    const { args, profile, id } = takeProfileAndId(opts);
+    return activity("gitlabPipeline", { name, ...args }, { profile: profile ?? "longInfra", ...(id ? { id } : {}) });
+};

package/dist/package-cli.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env tsx
+/**
+ * Thin entry point for `npm run bundle` in lexicon-gitlab.
+ * Generates src/generated/ files and writes dist/ bundle.
+ */
+import { generate, writeGeneratedFiles } from "./codegen/generate.js";
+import { packageLexicon } from "./codegen/package.js";
+import { writeBundleSpec } from "@intentius/chant/codegen/package";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
+// 1. Generate src/generated/ files
+const genResult = await generate({ verbose: true });
+writeGeneratedFiles(genResult, pkgDir);
+console.error(`Generated ${genResult.resources} entities, ${genResult.properties} property types, ${genResult.enums} enums`);
+// 2. Run package pipeline and write dist/
+const { spec, stats } = await packageLexicon({ verbose: true });
+const distDir = join(pkgDir, "dist");
+writeBundleSpec(spec, distDir);
+console.error(`Packaged ${stats.resources} entities, ${stats.ruleCount} rules, ${stats.skillCount} skills`);
+console.error(`dist/ written to ${distDir}`);

package/dist/plugin.js

@@ -0,0 +1,536 @@
+/**
+ * GitLab CI/CD lexicon plugin.
+ *
+ * Provides serializer, template detection, and code generation
+ * for GitLab CI/CD pipelines.
+ */
+import { compositeCatalog } from "./composites/catalog.js";
+import { postSynthChecks as postSynthCheckList } from "./lint/post-synth/index.js";
+import { gitlabAuditCatalog } from "./lint/audit-catalog.js";
+import { createSkillsLoader, createDiffTool, createCatalogResource } from "@intentius/chant/lexicon-plugin-helpers";
+import { gitlabSerializer } from "./serializer.js";
+import { gitlabGraphEdges } from "./graph-edges.js";
+import { gitlabContextTools } from "./mcp/context-tools.js";
+import { deprecatedOnlyExceptRule } from "./lint/rules/deprecated-only-except.js";
+import { missingScriptRule } from "./lint/rules/missing-script.js";
+import { missingStageRule } from "./lint/rules/missing-stage.js";
+import { artifactNoExpiryRule } from "./lint/rules/artifact-no-expiry.js";
+import { gitlabCompletions } from "./lsp/completions.js";
+import { gitlabHover } from "./lsp/hover.js";
+import { GitLabParser } from "./import/parser.js";
+import { GitLabGenerator } from "./import/generator.js";
+import { generateGitlabPipeline } from "./components/generate-pipeline.js";
+import { generateGitlabOpPipeline } from "./components/generate-op-pipeline.js";
+import { generateGitlabOpWavesPipeline } from "./components/generate-op-waves-pipeline.js";
+export const gitlabPlugin = {
+    name: "gitlab",
+    auditCatalog: () => gitlabAuditCatalog,
+    // Generate mode (#688): synthesize a .gitlab-ci.yml from the component graph.
+    generateComponentPipeline: (components, options) => generateGitlabPipeline(components, options),
+    // Generate mode, Op counterpart (#927): an Op → one GitLab CI job, on a
+    // Pipeline Schedule, a merge request or a push (#2084, #2256).
+    generateOpPipeline: (ops, options) => generateGitlabOpPipeline(ops, options),
+    // Ordered waves of Op runs, each behind one gate (#3679).
+    generateOpWavesPipeline: (spec, options) => generateGitlabOpWavesPipeline(spec, options),
+    // Self-upgrade: where the pinned GitLab schema version lives + its upstream (#685).
+    upstreamPin: {
+        file: "src/codegen/fetch.ts",
+        pattern: /export const GITLAB_SCHEMA_VERSION\s*=\s*"([^"]+)"/,
+        replace: (v, line) => line.replace(/export const GITLAB_SCHEMA_VERSION\s*=\s*"[^"]+"/, `export const GITLAB_SCHEMA_VERSION = "${v}"`),
+        upstream: { owner: "gitlab-org", repo: "gitlab", kind: "tags", tagSuffix: "-ee" },
+    },
+    serializer: gitlabSerializer,
+    // `needs`, stage order, `extends`, `trigger:` and `include:` as graph edges (#3910).
+    graphEdges: (entities) => gitlabGraphEdges(entities),
+    lintRules() {
+        return [deprecatedOnlyExceptRule, missingScriptRule, missingStageRule, artifactNoExpiryRule];
+    },
+    postSynthChecks() {
+        return postSynthCheckList;
+    },
+    intrinsics() {
+        return [
+            {
+                name: "reference",
+                // Authored as a plain call — `reference("job", "script")` — not a JS
+                // tagged template, so `isTag` (chant #1039: "authored as a tagged
+                // template", consumed by the static folder to recognize `Tag`...``)
+                // must be false. The `!reference` YAML tag it produces is rendered
+                // via `ReferenceIntrinsic.toYAML()` (see ../serializer.ts's generic
+                // `toYAML` duck-typing) — independent of this flag.
+                description: "!reference tag — reference another job's properties",
+                outputKey: "!reference",
+                isTag: false,
+            },
+        ];
+    },
+    initTemplates(template) {
+        if (template === "node-pipeline") {
+            return {
+                src: {
+                    "pipeline.ts": `import { NodePipeline } from "@intentius/chant-lexicon-gitlab";
+
+export const app = NodePipeline({
+  nodeVersion: "22",
+  installCommand: "npm install",
+  buildScript: "build",
+  testScript: "test",
+});
+`,
+                },
+            };
+        }
+        if (template === "python-pipeline") {
+            return {
+                src: {
+                    "pipeline.ts": `import { PythonPipeline } from "@intentius/chant-lexicon-gitlab";
+
+export const app = PythonPipeline({
+  pythonVersion: "3.12",
+  lintCommand: null,
+});
+`,
+                },
+            };
+        }
+        if (template === "docker-build") {
+            return {
+                src: {
+                    "pipeline.ts": `import { DockerBuild, Job, Image } from "@intentius/chant-lexicon-gitlab";
+
+export const docker = DockerBuild({
+  dockerfile: "Dockerfile",
+  tagLatest: true,
+});
+
+export const test = new Job({
+  stage: "test",
+  image: new Image({ name: "node:22-alpine" }),
+  script: ["node test.js"],
+});
+`,
+                },
+            };
+        }
+        if (template === "review-app") {
+            return {
+                src: {
+                    "pipeline.ts": `import { ReviewApp, Job, Image } from "@intentius/chant-lexicon-gitlab";
+
+export const review = ReviewApp({
+  name: "review",
+  deployScript: "echo deploy",
+});
+
+export const test = new Job({
+  stage: "test",
+  image: new Image({ name: "node:22-alpine" }),
+  script: ["node test.js"],
+});
+`,
+                },
+            };
+        }
+        // Default template — basic pipeline with shared config
+        return {
+            src: {
+                "config.ts": `/**
+ * Shared pipeline configuration
+ */
+
+import { Image, Cache } from "@intentius/chant-lexicon-gitlab";
+
+// Default image for all jobs
+export const defaultImage = new Image({
+  name: "node:20-alpine",
+});
+
+// Standard cache configuration
+export const npmCache = new Cache({
+  key: "$CI_COMMIT_REF_SLUG",
+  paths: ["node_modules/"],
+  policy: "pull-push",
+});
+`,
+                "pipeline.ts": `import { Job, Artifacts } from "@intentius/chant-lexicon-gitlab";
+import { defaultImage, npmCache } from "./config";
+
+export const junitReports = { junit: "coverage/junit.xml" };
+
+export const testArtifacts = new Artifacts({
+  reports: junitReports,
+  paths: ["coverage/"],
+  expire_in: "1 week",
+});
+
+export const build = new Job({
+  stage: "build",
+  image: defaultImage,
+  cache: npmCache,
+  script: ["npm install", "npm run build"],
+});
+
+export const test = new Job({
+  stage: "test",
+  image: defaultImage,
+  cache: npmCache,
+  script: ["npm install", "npm test"],
+  artifacts: testArtifacts,
+});
+`,
+            },
+        };
+    },
+    detectTemplate(data) {
+        if (typeof data !== "object" || data === null)
+            return false;
+        const obj = data;
+        // GitLab CI files typically have stages, or job-like top-level keys
+        if (Array.isArray(obj.stages))
+            return true;
+        if (obj.image !== undefined && obj.script !== undefined)
+            return true;
+        // Check for job-like entries (objects with "stage" or "script" properties)
+        for (const value of Object.values(obj)) {
+            if (typeof value === "object" && value !== null) {
+                const entry = value;
+                if (entry.stage !== undefined || entry.script !== undefined) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    },
+    completionProvider(ctx) {
+        return gitlabCompletions(ctx);
+    },
+    hoverProvider(ctx) {
+        return gitlabHover(ctx);
+    },
+    templateParser() {
+        return new GitLabParser();
+    },
+    templateGenerator() {
+        return new GitLabGenerator();
+    },
+    async generate(options) {
+        const { generate, writeGeneratedFiles } = await import("./codegen/generate.js");
+        const { dirname } = await import("path");
+        const { fileURLToPath } = await import("url");
+        const result = await generate({ verbose: options?.verbose ?? true });
+        const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
+        writeGeneratedFiles(result, pkgDir);
+        console.error(`Generated ${result.resources} entities, ${result.properties} property types, ${result.enums} enums`);
+        if (result.warnings.length > 0) {
+            console.error(`${result.warnings.length} warnings`);
+        }
+    },
+    async validate(options) {
+        const { validate } = await import("./validate.js");
+        const { printValidationResult } = await import("@intentius/chant/codegen/validate");
+        const result = await validate();
+        printValidationResult(result);
+    },
+    async coverage(options) {
+        const { analyzeGitLabCoverage } = await import("./coverage.js");
+        await analyzeGitLabCoverage({
+            verbose: options?.verbose,
+            minOverall: options?.minOverall,
+        });
+    },
+    async package(options) {
+        const { packageLexicon } = await import("./codegen/package.js");
+        const { writeBundleSpec } = await import("@intentius/chant/codegen/package");
+        const { join, dirname } = await import("path");
+        const { fileURLToPath } = await import("url");
+        const { spec, stats } = await packageLexicon({ verbose: options?.verbose, force: options?.force });
+        const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
+        const distDir = join(pkgDir, "dist");
+        writeBundleSpec(spec, distDir);
+        console.error(`Packaged ${stats.resources} entities, ${stats.ruleCount} rules, ${stats.skillCount} skills`);
+    },
+    composites() {
+        return compositeCatalog;
+    },
+    mcpTools() {
+        return [
+            createDiffTool(gitlabSerializer, "Compare current build output against previous output for GitLab CI", "gitlab"),
+            // Read-only context tools: what the pipeline does, what it pulls in, and
+            // its security findings — before anything runs (#327/#328).
+            ...gitlabContextTools(),
+            {
+                name: "gitlab:migrate",
+                description: "Translate a GitHub Actions workflow YAML into a GitLab CI/CD pipeline. Returns the rendered output plus diagnostic + provenance arrays.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        content: { type: "string", description: "Raw .github/workflows/*.yml content" },
+                        emit: { type: "string", enum: ["yaml", "ts"], description: "Output format (default: yaml)" },
+                        useComposites: { type: "boolean", description: "Recognise composite patterns and emit NodePipeline/NodeCI calls" },
+                        strict: { type: "boolean", description: "Escalate needs-review diagnostics to errors" },
+                        security: { type: "boolean", description: "Run security-aware migration analysis (classify property fates + GitLab security checks)" },
+                    },
+                    required: ["content"],
+                },
+                async handler(params) {
+                    const { transform } = await import("./migrate/from-github/index.js");
+                    const result = await transform(params.content, {
+                        emit: params.emit ?? "yaml",
+                        useComposites: !!params.useComposites,
+                        strict: !!params.strict,
+                        security: !!params.security,
+                        sourceFile: "<mcp-input>",
+                    });
+                    return {
+                        output: result.output,
+                        diagnostics: result.diagnostics,
+                        provenance: result.provenance,
+                        stages: result.stages,
+                        securityPosture: result.securityPosture,
+                    };
+                },
+            },
+        ];
+    },
+    migrationSource(from) {
+        if (from !== "github")
+            return undefined;
+        return {
+            detect(content) {
+                // Avoid bringing the migrate code into the import graph until needed
+                if (!/^\s*jobs\s*:/m.test(content))
+                    return false;
+                return /^\s*on\s*:/m.test(content) || /^\s*runs-on\s*:/m.test(content);
+            },
+            async transform(content, opts) {
+                const { transform } = await import("./migrate/from-github/index.js");
+                const result = await transform(content, {
+                    emit: opts.emit,
+                    useComposites: opts.useComposites,
+                    sourceFile: opts.sourceFile,
+                    strict: opts.strict,
+                    security: opts.security,
+                });
+                // The composites rewriter (when enabled) replaces several Job
+                // resources with a single Composite resource — stages: in the
+                // top-level YAML output is now stale for that path. The yaml
+                // emitter reads metadata.stages directly; no special handling
+                // needed at the call site.
+                return {
+                    output: result.output,
+                    provenance: result.provenance,
+                    diagnostics: result.diagnostics,
+                    securityPosture: result.securityPosture,
+                };
+            },
+        };
+    },
+    mcpResources() {
+        return [
+            createCatalogResource(import.meta.url, "GitLab CI Entity Catalog", "JSON list of all supported GitLab CI entity types", "lexicon-gitlab.json", "gitlab"),
+            {
+                uri: "examples/basic-pipeline",
+                name: "Basic Pipeline Example",
+                description: "A basic GitLab CI pipeline with build, test, and deploy stages",
+                mimeType: "text/typescript",
+                async handler() {
+                    return `import { Job, Image, Cache, Artifacts, CI } from "@intentius/chant-lexicon-gitlab";
+
+export const build = new Job({
+  stage: "build",
+  image: new Image({ name: "node:20" }),
+  cache: new Cache({ key: CI.CommitRef, paths: ["node_modules/"] }),
+  script: ["npm ci", "npm run build"],
+  artifacts: new Artifacts({ paths: ["dist/"], expireIn: "1 day" }),
+});
+
+export const test = new Job({
+  stage: "test",
+  image: new Image({ name: "node:20" }),
+  cache: new Cache({ key: CI.CommitRef, paths: ["node_modules/"], policy: "pull" }),
+  script: ["npm ci", "npm test"],
+  artifacts: new Artifacts({
+    reports: { junit: "coverage/junit.xml" },
+    expireIn: "1 week",
+  }),
+});
+
+export const deploy = new Job({
+  stage: "deploy",
+  script: ["./deploy.sh"],
+  rules: [{ if: "$CI_COMMIT_BRANCH == \\"main\\"", when: "manual" }],
+});
+`;
+                },
+            },
+        ];
+    },
+    async docs(options) {
+        const { generateDocs } = await import("./codegen/docs.js");
+        await generateDocs(options);
+    },
+    skills: createSkillsLoader(import.meta.url, [
+        {
+            file: "chant-gitlab.md",
+            name: "chant-gitlab",
+            description: "GitLab CI/CD pipeline lifecycle — build, validate, deploy, monitor, rollback, and troubleshoot",
+            triggers: [
+                { type: "file-pattern", value: "**/*.gitlab.ts" },
+                { type: "file-pattern", value: "**/.gitlab-ci.yml" },
+                { type: "context", value: "gitlab" },
+                { type: "context", value: "pipeline" },
+                { type: "context", value: "deploy" },
+            ],
+            preConditions: [
+                "chant CLI is installed (chant --version succeeds)",
+                "git is configured and can push to the remote",
+                "Project has chant source files in src/",
+            ],
+            postConditions: [
+                "Pipeline is in a stable state (success/manual/scheduled)",
+                "No failed jobs in the pipeline",
+            ],
+            parameters: [],
+            examples: [
+                {
+                    title: "Basic test job",
+                    description: "Create a test job with caching and artifacts",
+                    input: "Create a test job",
+                    output: `new Job({
+  stage: "test",
+  image: new Image({ name: "node:20" }),
+  script: ["npm ci", "npm test"],
+  cache: new Cache({
+    key: "$CI_COMMIT_REF_SLUG",
+    paths: ["node_modules/"],
+  }),
+  artifacts: new Artifacts({
+    reports: { junit: "coverage/junit.xml" },
+  }),
+})`,
+                },
+                {
+                    title: "Deploy pipeline update",
+                    description: "Build, validate, and deploy a pipeline change via MR workflow",
+                    input: "Deploy my pipeline changes to production",
+                    output: `chant lint src/
+chant build src/ --output .gitlab-ci.yml
+git checkout -b feature/pipeline-update
+git add .gitlab-ci.yml
+git commit -m "Update pipeline"
+git push -u origin feature/pipeline-update
+# Open MR in GitLab, review pipeline diff, then merge`,
+                },
+                {
+                    title: "Preview pipeline changes",
+                    description: "Validate pipeline configuration via lint and CI Lint API before deploying",
+                    input: "Check if my pipeline changes are valid before pushing",
+                    output: `chant lint src/
+chant build src/ --output .gitlab-ci.yml
+# Validate via GitLab CI Lint API
+curl --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \\
+  --header "Content-Type: application/json" \\
+  "https://gitlab.com/api/v4/projects/$PROJECT_ID/ci/lint" \\
+  --data-binary '{"content": "'$(cat .gitlab-ci.yml | jq -Rs .)'", "dry_run": true}'`,
+                },
+                {
+                    title: "Scaffold and deploy a Node.js pipeline",
+                    description: "Use --template to scaffold a Node.js project, build YAML, and push to GitLab",
+                    input: "Create a Node.js CI pipeline and deploy it to GitLab",
+                    output: `# Scaffold the project
+chant init --lexicon gitlab --template node-pipeline my-node-app
+cd my-node-app
+
+# Build the YAML
+chant build src/ --output .gitlab-ci.yml
+
+# The GitLab repo needs app files — create them
+echo '{"scripts":{"build":"echo build","test":"node test.js"}}' > package.json
+echo 'console.log("ok")' > test.js
+
+# Push to GitLab
+git init -b main
+git add .gitlab-ci.yml package.json test.js
+git commit -m "Initial pipeline"
+git remote add origin git@gitlab.com:YOUR_GROUP/YOUR_PROJECT.git
+git push -u origin main`,
+                },
+                {
+                    title: "Retry a failed pipeline",
+                    description: "Retry a failed pipeline and monitor its progress",
+                    input: "Pipeline 12345 failed, retry it",
+                    output: `# Retry the pipeline
+curl --request POST --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \\
+  "https://gitlab.com/api/v4/projects/$PROJECT_ID/pipelines/12345/retry"
+# Monitor status
+curl --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \\
+  "https://gitlab.com/api/v4/projects/$PROJECT_ID/pipelines/12345"`,
+                },
+            ],
+        },
+        {
+            file: "chant-gitlab-migrate.md",
+            name: "chant-gitlab-migrate",
+            description: "Translate GitHub Actions workflows into GitLab CI/CD pipelines via chant migrate",
+            triggers: [
+                { type: "file-pattern", value: "**/.github/workflows/*.yml" },
+                { type: "file-pattern", value: "**/.github/workflows/*.yaml" },
+                { type: "context", value: "migrate from github actions" },
+                { type: "context", value: "github actions to gitlab" },
+                { type: "context", value: "convert workflow" },
+            ],
+            preConditions: [
+                "chant CLI is installed (chant --version succeeds)",
+                "@intentius/chant-lexicon-gitlab is installed",
+            ],
+            postConditions: [
+                "Translated .gitlab-ci.yml or .ts source on disk",
+                "Migration report visible to the user (Markdown + SARIF if --report)",
+            ],
+            parameters: [],
+            examples: [
+                {
+                    title: "Translate a single workflow file",
+                    description: "Migrate .github/workflows/ci.yml into .gitlab-ci.yml with a SARIF report",
+                    input: "Migrate this GitHub workflow to GitLab CI",
+                    output: `npx chant migrate .github/workflows/ci.yml \\
+  --output .gitlab-ci.yml \\
+  --report migration.sarif`,
+                },
+                {
+                    title: "Translate to chant TypeScript",
+                    description: "Produce typed chant source instead of YAML so the user can maintain the pipeline in chant going forward",
+                    input: "I want to maintain this in chant — produce TypeScript",
+                    output: `npx chant migrate .github/workflows/ci.yml --emit ts --output src/pipeline.ts`,
+                },
+                {
+                    title: "Recognise and emit composites",
+                    description: "Collapse a 2-job NodePipeline-shaped workflow into a single NodePipeline() call",
+                    input: "Use composites for the upgrade",
+                    output: `npx chant migrate .github/workflows/ci.yml --emit ts --use-composites --output src/pipeline.ts`,
+                },
+            ],
+        },
+        {
+            file: "chant-gitlab-patterns.md",
+            name: "chant-gitlab-patterns",
+            description: "GitLab CI/CD pipeline stages, caching, artifacts, includes, and advanced patterns",
+            triggers: [
+                { type: "context", value: "gitlab pipeline" },
+                { type: "context", value: "gitlab cache" },
+                { type: "context", value: "gitlab artifacts" },
+                { type: "context", value: "gitlab include" },
+                { type: "context", value: "gitlab stages" },
+                { type: "context", value: "review app" },
+            ],
+            parameters: [],
+            examples: [
+                {
+                    title: "Pipeline with caching",
+                    input: "Set up a Node.js pipeline with proper caching",
+                    output: "import { Job, Cache } from \"@intentius/chant-lexicon-gitlab\";\n\nconst cache = new Cache({ key: { files: [\"package-lock.json\"] }, paths: [\"node_modules/\"] });",
+                },
+            ],
+        },
+    ]),
+};

package/dist/rules/wgl012.ts

@@ -7,6 +7,7 @@
 
 import { readFileSync } from "fs";
 import { join } from "path";
+import { moduleSourceDir } from "@intentius/chant/module-source";
 import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
 import { isPropertyDeclarable } from "@intentius/chant/declarable";
 
@@ -23,8 +24,7 @@ interface LexiconEntry {
 function loadDeprecatedProperties(): Map<string, Set<string>> {
   const map = new Map<string, Set<string>>();
   try {
-    const pkgDir = join(__dirname, "..", "..", "..");
-    const lexiconPath = join(pkgDir, "src", "generated", "lexicon-gitlab.json");
+    const lexiconPath = join(moduleSourceDir(import.meta.url), "..", "..", "generated", "lexicon-gitlab.json");
     const content = readFileSync(lexiconPath, "utf-8");
     const data = JSON.parse(content) as Record<string, LexiconEntry>;