@intentius/chant-lexicon-gitlab 0.0.15 → 0.0.18

package/src/lint/post-synth/wgl027.test.ts

@@ -0,0 +1,84 @@
+import { describe, test, expect } from "bun:test";
+import { DECLARABLE_MARKER, type Declarable } from "@intentius/chant/declarable";
+import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
+import { wgl027 } from "./wgl027";
+
+class MockJob implements Declarable {
+  readonly [DECLARABLE_MARKER] = true as const;
+  readonly lexicon = "gitlab";
+  readonly entityType = "GitLab::CI::Job";
+  readonly kind = "resource" as const;
+  readonly props: Record<string, unknown>;
+
+  constructor(props: Record<string, unknown> = {}) {
+    this.props = props;
+  }
+}
+
+function makeCtx(entities: Map<string, Declarable>): PostSynthContext {
+  return {
+    outputs: new Map(),
+    entities,
+    buildResult: {
+      outputs: new Map(),
+      entities,
+      warnings: [],
+      errors: [],
+      sourceFileCount: 1,
+    },
+  };
+}
+
+describe("WGL027: Empty Script", () => {
+  test("check metadata", () => {
+    expect(wgl027.id).toBe("WGL027");
+    expect(wgl027.description).toContain("Empty script");
+  });
+
+  test("flags empty script array", () => {
+    const entities = new Map<string, Declarable>([
+      ["emptyJob", new MockJob({ script: [] })],
+    ]);
+    const diags = wgl027.check(makeCtx(entities));
+    expect(diags).toHaveLength(1);
+    expect(diags[0].severity).toBe("error");
+    expect(diags[0].message).toContain("emptyJob");
+  });
+
+  test("flags script with only empty strings", () => {
+    const entities = new Map<string, Declarable>([
+      ["blankJob", new MockJob({ script: ["", "  "] })],
+    ]);
+    const diags = wgl027.check(makeCtx(entities));
+    expect(diags).toHaveLength(1);
+  });
+
+  test("flags empty string script", () => {
+    const entities = new Map<string, Declarable>([
+      ["strJob", new MockJob({ script: "" })],
+    ]);
+    const diags = wgl027.check(makeCtx(entities));
+    expect(diags).toHaveLength(1);
+  });
+
+  test("does not flag valid script", () => {
+    const entities = new Map<string, Declarable>([
+      ["validJob", new MockJob({ script: ["npm test"] })],
+    ]);
+    const diags = wgl027.check(makeCtx(entities));
+    expect(diags).toHaveLength(0);
+  });
+
+  test("does not flag job without script", () => {
+    const entities = new Map<string, Declarable>([
+      ["triggerJob", new MockJob({ trigger: "other-project" })],
+    ]);
+    const diags = wgl027.check(makeCtx(entities));
+    expect(diags).toHaveLength(0);
+  });
+
+  test("no diagnostics on empty entities", () => {
+    const diags = wgl027.check(makeCtx(new Map()));
+    expect(diags).toHaveLength(0);
+  });
+});

package/src/lint/post-synth/wgl027.ts

@@ -0,0 +1,54 @@
+/**
+ * WGL027: Empty Script
+ *
+ * Detects jobs with `script: []` or scripts containing only empty strings.
+ * GitLab rejects jobs with empty scripts at pipeline validation time.
+ */
+
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { isPropertyDeclarable } from "@intentius/chant/declarable";
+
+export const wgl027: PostSynthCheck = {
+  id: "WGL027",
+  description: "Empty script — jobs with empty or blank script entries",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    const diagnostics: PostSynthDiagnostic[] = [];
+
+    for (const [entityName, entity] of ctx.entities) {
+      if (isPropertyDeclarable(entity)) continue;
+      const entityType = (entity as Record<string, unknown>).entityType as string;
+      if (entityType !== "GitLab::CI::Job") continue;
+
+      const props = (entity as Record<string, unknown>).props as Record<string, unknown> | undefined;
+      if (!props) continue;
+
+      const script = props.script;
+      if (script === undefined || script === null) continue;
+
+      let isEmpty = false;
+
+      if (Array.isArray(script)) {
+        if (script.length === 0) {
+          isEmpty = true;
+        } else if (script.every((s) => typeof s === "string" && s.trim() === "")) {
+          isEmpty = true;
+        }
+      } else if (typeof script === "string" && script.trim() === "") {
+        isEmpty = true;
+      }
+
+      if (isEmpty) {
+        diagnostics.push({
+          checkId: "WGL027",
+          severity: "error",
+          message: `Job "${entityName}" has an empty script — GitLab will reject this pipeline`,
+          entity: entityName,
+          lexicon: "gitlab",
+        });
+      }
+    }
+
+    return diagnostics;
+  },
+};

package/src/lint/post-synth/wgl028.test.ts

@@ -0,0 +1,95 @@
+import { describe, test, expect } from "bun:test";
+import { wgl028, checkRedundantNeeds } from "./wgl028";
+
+describe("WGL028: Redundant Needs", () => {
+  test("check metadata", () => {
+    expect(wgl028.id).toBe("WGL028");
+    expect(wgl028.description).toContain("Redundant");
+  });
+
+  test("flags needs pointing to earlier stage job", () => {
+    const yaml = `stages:
+  - build
+  - test
+  - deploy
+
+build-app:
+  stage: build
+  script:
+    - npm build
+
+deploy-app:
+  stage: deploy
+  needs:
+    - build-app
+  script:
+    - deploy.sh
+`;
+    const diags = checkRedundantNeeds(yaml);
+    expect(diags).toHaveLength(1);
+    expect(diags[0].severity).toBe("info");
+    expect(diags[0].message).toContain("deploy-app");
+    expect(diags[0].message).toContain("build-app");
+    expect(diags[0].message).toContain("earlier stage");
+  });
+
+  test("does not flag needs within same stage", () => {
+    const yaml = `stages:
+  - build
+  - test
+
+test-a:
+  stage: test
+  script:
+    - test-a
+
+test-b:
+  stage: test
+  needs:
+    - test-a
+  script:
+    - test-b
+`;
+    const diags = checkRedundantNeeds(yaml);
+    expect(diags).toHaveLength(0);
+  });
+
+  test("does not flag when no stages defined", () => {
+    const yaml = `build-app:
+  script:
+    - npm build
+
+deploy-app:
+  needs:
+    - build-app
+  script:
+    - deploy.sh
+`;
+    const diags = checkRedundantNeeds(yaml);
+    expect(diags).toHaveLength(0);
+  });
+
+  test("does not flag when no needs defined", () => {
+    const yaml = `stages:
+  - build
+  - test
+
+build-app:
+  stage: build
+  script:
+    - npm build
+
+test-app:
+  stage: test
+  script:
+    - npm test
+`;
+    const diags = checkRedundantNeeds(yaml);
+    expect(diags).toHaveLength(0);
+  });
+
+  test("no diagnostics on empty yaml", () => {
+    const diags = checkRedundantNeeds("");
+    expect(diags).toHaveLength(0);
+  });
+});

package/src/lint/post-synth/wgl028.ts

@@ -0,0 +1,67 @@
+/**
+ * WGL028: Redundant Needs
+ *
+ * Detects `needs:` entries that list jobs already implied by stage ordering.
+ * While not incorrect, redundant needs add noise and make the pipeline
+ * harder to maintain. This is informational only.
+ */
+
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { getPrimaryOutput, extractStages, extractJobs } from "./yaml-helpers";
+
+export function checkRedundantNeeds(yaml: string): PostSynthDiagnostic[] {
+  const diagnostics: PostSynthDiagnostic[] = [];
+
+  const stages = extractStages(yaml);
+  if (stages.length === 0) return diagnostics;
+
+  const stageIndex = new Map<string, number>();
+  for (let i = 0; i < stages.length; i++) {
+    stageIndex.set(stages[i], i);
+  }
+
+  const jobs = extractJobs(yaml);
+
+  for (const [jobName, job] of jobs) {
+    if (!job.needs || !job.stage) continue;
+
+    const jobStageIdx = stageIndex.get(job.stage);
+    if (jobStageIdx === undefined) continue;
+
+    for (const need of job.needs) {
+      const neededJob = jobs.get(need);
+      if (!neededJob?.stage) continue;
+
+      const needStageIdx = stageIndex.get(neededJob.stage);
+      if (needStageIdx === undefined) continue;
+
+      // If the needed job is in an earlier stage, it's already implied
+      // by GitLab's default stage-based ordering
+      if (needStageIdx < jobStageIdx) {
+        diagnostics.push({
+          checkId: "WGL028",
+          severity: "info",
+          message: `Job "${jobName}" lists "${need}" in needs: but it's already in an earlier stage (${neededJob.stage} → ${job.stage})`,
+          entity: jobName,
+          lexicon: "gitlab",
+        });
+      }
+    }
+  }
+
+  return diagnostics;
+}
+
+export const wgl028: PostSynthCheck = {
+  id: "WGL028",
+  description: "Redundant needs — needs listing jobs already implied by stage ordering",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    const diagnostics: PostSynthDiagnostic[] = [];
+    for (const [, output] of ctx.outputs) {
+      const yaml = getPrimaryOutput(output);
+      diagnostics.push(...checkRedundantNeeds(yaml));
+    }
+    return diagnostics;
+  },
+};

package/src/lint/post-synth/yaml-helpers.ts

@@ -141,3 +141,85 @@ export function extractJobs(yaml: string): Map<string, ParsedJob> {
 export function hasInclude(yaml: string): boolean {
   return /^include:/m.test(yaml);
 }
+
+/**
+ * Extract global variables from serialized YAML.
+ */
+export function extractGlobalVariables(yaml: string): Map<string, string> {
+  const vars = new Map<string, string>();
+  const match = yaml.match(/^variables:\n((?:\s+.+\n?)+)/m);
+  if (!match) return vars;
+
+  for (const line of match[1].split("\n")) {
+    const kv = line.match(/^\s+(\w+):\s+(.+)$/);
+    if (kv) {
+      vars.set(kv[1], kv[2].trim().replace(/^['"]|['"]$/g, ""));
+    }
+  }
+  return vars;
+}
+
+/**
+ * Extract the full section text for a given job name.
+ */
+export function extractJobSection(yaml: string, jobName: string): string | null {
+  const sections = yaml.split("\n\n");
+  for (const section of sections) {
+    const lines = section.split("\n");
+    if (lines.length > 0 && lines[0].startsWith(`${jobName}:`)) {
+      return section;
+    }
+  }
+  return null;
+}
+
+/**
+ * Extract rules from a job section.
+ */
+export function extractJobRules(section: string): ParsedRule[] {
+  const rules: ParsedRule[] = [];
+  const lines = section.split("\n");
+
+  let inRules = false;
+  let currentRule: ParsedRule = {};
+
+  for (const line of lines) {
+    if (line.match(/^\s+rules:$/)) {
+      inRules = true;
+      continue;
+    }
+
+    if (inRules) {
+      const ruleStart = line.match(/^\s+- (if|when|changes):\s*(.*)$/);
+      if (ruleStart) {
+        if (Object.keys(currentRule).length > 0) {
+          rules.push(currentRule);
+        }
+        currentRule = {};
+        if (ruleStart[1] === "if") currentRule.if = ruleStart[2].trim();
+        if (ruleStart[1] === "when") currentRule.when = ruleStart[2].trim();
+        continue;
+      }
+
+      const whenMatch = line.match(/^\s+when:\s+(.+)$/);
+      if (whenMatch) {
+        currentRule.when = whenMatch[1].trim();
+        continue;
+      }
+
+      // End of rules block
+      if (!line.match(/^\s+\s/) || line.match(/^\s+[a-z_]+:/) && !line.match(/^\s+when:/)) {
+        if (Object.keys(currentRule).length > 0) {
+          rules.push(currentRule);
+        }
+        inRules = false;
+      }
+    }
+  }
+
+  if (inRules && Object.keys(currentRule).length > 0) {
+    rules.push(currentRule);
+  }
+
+  return rules;
+}

package/src/lsp/completions.test.ts

@@ -1,7 +1,12 @@
 import { describe, test, expect } from "bun:test";
-import { gitlabCompletions } from "./completions";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
 import type { CompletionContext } from "@intentius/chant/lsp/types";
 
+const generatedDir = join(dirname(dirname(fileURLToPath(import.meta.url))), "generated");
+const hasGenerated = existsSync(join(generatedDir, "lexicon-gitlab.json"));
+
 function makeCtx(overrides: Partial<CompletionContext>): CompletionContext {
   return {
     uri: "file:///test.ts",
@@ -14,7 +19,8 @@ function makeCtx(overrides: Partial<CompletionContext>): CompletionContext {
 }
 
 describe("gitlabCompletions", () => {
-  test("returns resource completions for 'new ' prefix", () => {
+  test.skipIf(!hasGenerated)("returns resource completions for 'new ' prefix", async () => {
+    const { gitlabCompletions } = await import("./completions");
     const ctx = makeCtx({
       linePrefix: "const j = new Job",
       wordAtCursor: "Job",
@@ -29,7 +35,8 @@ describe("gitlabCompletions", () => {
     expect(job!.kind).toBe("resource");
   });
 
-  test("returns all resource completions when no filter", () => {
+  test.skipIf(!hasGenerated)("returns all resource completions when no filter", async () => {
+    const { gitlabCompletions } = await import("./completions");
     const ctx = makeCtx({
       linePrefix: "const x = new ",
       wordAtCursor: "",
@@ -44,7 +51,8 @@ describe("gitlabCompletions", () => {
     expect(labels).toContain("Workflow");
   });
 
-  test("filters completions by prefix", () => {
+  test.skipIf(!hasGenerated)("filters completions by prefix", async () => {
+    const { gitlabCompletions } = await import("./completions");
     const ctx = makeCtx({
       linePrefix: "const x = new D",
       wordAtCursor: "D",
@@ -58,7 +66,8 @@ describe("gitlabCompletions", () => {
     expect(labels).not.toContain("Job");
   });
 
-  test("returns empty for non-constructor context", () => {
+  test.skipIf(!hasGenerated)("returns empty for non-constructor context", async () => {
+    const { gitlabCompletions } = await import("./completions");
     const ctx = makeCtx({
       linePrefix: "const x = foo(",
       wordAtCursor: "",
@@ -70,7 +79,8 @@ describe("gitlabCompletions", () => {
     expect(items).toHaveLength(0);
   });
 
-  test("completion items have detail with resource type", () => {
+  test.skipIf(!hasGenerated)("completion items have detail with resource type", async () => {
+    const { gitlabCompletions } = await import("./completions");
     const ctx = makeCtx({
       linePrefix: "const j = new Job",
       wordAtCursor: "Job",

package/src/lsp/hover.test.ts

@@ -1,7 +1,12 @@
 import { describe, test, expect } from "bun:test";
-import { gitlabHover } from "./hover";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
 import type { HoverContext } from "@intentius/chant/lsp/types";
 
+const generatedDir = join(dirname(dirname(fileURLToPath(import.meta.url))), "generated");
+const hasGenerated = existsSync(join(generatedDir, "lexicon-gitlab.json"));
+
 function makeCtx(overrides: Partial<HoverContext>): HoverContext {
   return {
     uri: "file:///test.ts",
@@ -14,7 +19,8 @@ function makeCtx(overrides: Partial<HoverContext>): HoverContext {
 }
 
 describe("gitlabHover", () => {
-  test("returns hover for Job class", () => {
+  test.skipIf(!hasGenerated)("returns hover for Job class", async () => {
+    const { gitlabHover } = await import("./hover");
     const ctx = makeCtx({ word: "Job" });
     const hover = gitlabHover(ctx);
     expect(hover).toBeDefined();
@@ -23,7 +29,8 @@ describe("gitlabHover", () => {
     expect(hover!.contents).toContain("Resource entity");
   });
 
-  test("returns hover for property entity", () => {
+  test.skipIf(!hasGenerated)("returns hover for property entity", async () => {
+    const { gitlabHover } = await import("./hover");
     const ctx = makeCtx({ word: "Cache" });
     const hover = gitlabHover(ctx);
     expect(hover).toBeDefined();
@@ -32,27 +39,31 @@ describe("gitlabHover", () => {
     expect(hover!.contents).toContain("Property entity");
   });
 
-  test("returns hover for Default", () => {
+  test.skipIf(!hasGenerated)("returns hover for Default", async () => {
+    const { gitlabHover } = await import("./hover");
     const ctx = makeCtx({ word: "Default" });
     const hover = gitlabHover(ctx);
     expect(hover).toBeDefined();
     expect(hover!.contents).toContain("GitLab::CI::Default");
   });
 
-  test("returns hover for Artifacts", () => {
+  test.skipIf(!hasGenerated)("returns hover for Artifacts", async () => {
+    const { gitlabHover } = await import("./hover");
     const ctx = makeCtx({ word: "Artifacts" });
     const hover = gitlabHover(ctx);
     expect(hover).toBeDefined();
     expect(hover!.contents).toContain("GitLab::CI::Artifacts");
   });
 
-  test("returns undefined for unknown word", () => {
+  test.skipIf(!hasGenerated)("returns undefined for unknown word", async () => {
+    const { gitlabHover } = await import("./hover");
     const ctx = makeCtx({ word: "UnknownEntity" });
     const hover = gitlabHover(ctx);
     expect(hover).toBeUndefined();
   });
 
-  test("returns undefined for empty word", () => {
+  test.skipIf(!hasGenerated)("returns undefined for empty word", async () => {
+    const { gitlabHover } = await import("./hover");
     const ctx = makeCtx({ word: "" });
     const hover = gitlabHover(ctx);
     expect(hover).toBeUndefined();

package/src/plugin.test.ts

@@ -83,7 +83,7 @@ describe("gitlabPlugin", () => {
 
   test("returns post-synth checks", () => {
     const checks = gitlabPlugin.postSynthChecks!();
-    expect(checks).toHaveLength(6);
+    expect(checks).toHaveLength(19);
     const ids = checks.map((c) => c.id);
     expect(ids).toContain("WGL010");
     expect(ids).toContain("WGL011");
@@ -91,6 +91,19 @@ describe("gitlabPlugin", () => {
     expect(ids).toContain("WGL013");
     expect(ids).toContain("WGL014");
     expect(ids).toContain("WGL015");
+    expect(ids).toContain("WGL016");
+    expect(ids).toContain("WGL017");
+    expect(ids).toContain("WGL018");
+    expect(ids).toContain("WGL019");
+    expect(ids).toContain("WGL020");
+    expect(ids).toContain("WGL021");
+    expect(ids).toContain("WGL022");
+    expect(ids).toContain("WGL023");
+    expect(ids).toContain("WGL024");
+    expect(ids).toContain("WGL025");
+    expect(ids).toContain("WGL026");
+    expect(ids).toContain("WGL027");
+    expect(ids).toContain("WGL028");
   });
 
   // -----------------------------------------------------------------------
@@ -182,7 +195,7 @@ describe("gitlabPlugin", () => {
 
   test("returns skills", () => {
     const skills = gitlabPlugin.skills!();
-    expect(skills).toHaveLength(1);
+    expect(skills.length).toBeGreaterThanOrEqual(2);
     expect(skills[0].name).toBe("chant-gitlab");
     expect(skills[0].description).toBeDefined();
     expect(skills[0].content).toContain("skill: chant-gitlab");

package/src/plugin.ts

@@ -31,7 +31,24 @@ export const gitlabPlugin: LexiconPlugin = {
     const { wgl013 } = require("./lint/post-synth/wgl013");
     const { wgl014 } = require("./lint/post-synth/wgl014");
     const { wgl015 } = require("./lint/post-synth/wgl015");
-    return [wgl010, wgl011, wgl012, wgl013, wgl014, wgl015];
+    const { wgl016 } = require("./lint/post-synth/wgl016");
+    const { wgl017 } = require("./lint/post-synth/wgl017");
+    const { wgl018 } = require("./lint/post-synth/wgl018");
+    const { wgl019 } = require("./lint/post-synth/wgl019");
+    const { wgl020 } = require("./lint/post-synth/wgl020");
+    const { wgl021 } = require("./lint/post-synth/wgl021");
+    const { wgl022 } = require("./lint/post-synth/wgl022");
+    const { wgl023 } = require("./lint/post-synth/wgl023");
+    const { wgl024 } = require("./lint/post-synth/wgl024");
+    const { wgl025 } = require("./lint/post-synth/wgl025");
+    const { wgl026 } = require("./lint/post-synth/wgl026");
+    const { wgl027 } = require("./lint/post-synth/wgl027");
+    const { wgl028 } = require("./lint/post-synth/wgl028");
+    return [
+      wgl010, wgl011, wgl012, wgl013, wgl014, wgl015,
+      wgl016, wgl017, wgl018, wgl019, wgl020, wgl021,
+      wgl022, wgl023, wgl024, wgl025, wgl026, wgl027, wgl028,
+    ];
   },
 
   intrinsics(): IntrinsicDef[] {
@@ -342,7 +359,7 @@ export const deploy = new Job({
   },
 
   skills(): SkillDefinition[] {
-    return [
+    const skills: SkillDefinition[] = [
       {
         name: "chant-gitlab",
         description: "GitLab CI/CD pipeline lifecycle — build, validate, deploy, monitor, rollback, and troubleshoot",
@@ -495,7 +512,7 @@ Add \`"dry_run": true, "include_merged_yaml": true\` for full expansion with inc
 | Step | Catches | When to run |
 |------|---------|-------------|
 | \`chant lint\` | Deprecated only/except (WGL001), missing script (WGL002), missing stage (WGL003), artifacts without expiry (WGL004) | Every edit |
-| \`chant build\` | Post-synth checks: undefined stages (WGL010), unreachable jobs (WGL011), deprecated properties (WGL012), invalid needs targets (WGL013), invalid extends targets (WGL014), circular needs chains (WGL015) | Before push |
+| \`chant build\` | Post-synth checks: undefined stages (WGL010), unreachable jobs (WGL011), deprecated properties (WGL012), invalid needs/extends targets (WGL013-014), circular needs (WGL015), secrets in variables (WGL016), insecure registry (WGL017), missing timeout/retry (WGL018-019), duplicate jobs (WGL020), unused variables (WGL021), missing artifacts expiry (WGL022), overly broad rules (WGL023), manual without allow_failure (WGL024), missing cache key (WGL025), DinD without TLS (WGL026), empty script (WGL027), redundant needs (WGL028) | Before push |
 | CI Lint API | GitLab-specific validation: include resolution, variable expansion, YAML schema errors | Before merge to default branch |
 
 Always run all three before deploying. Lint catches things the API cannot (and vice versa).
@@ -944,5 +961,51 @@ curl --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \\
         ],
       },
     ];
+
+    // Load file-based skills from src/skills/
+    const { readFileSync } = require("fs");
+    const { join, dirname } = require("path");
+    const { fileURLToPath } = require("url");
+    const dir = dirname(fileURLToPath(import.meta.url));
+
+    const skillFiles = [
+      {
+        file: "gitlab-ci-patterns.md",
+        name: "gitlab-ci-patterns",
+        description: "GitLab CI/CD pipeline stages, caching, artifacts, includes, and advanced patterns",
+        triggers: [
+          { type: "context" as const, value: "gitlab pipeline" },
+          { type: "context" as const, value: "gitlab cache" },
+          { type: "context" as const, value: "gitlab artifacts" },
+          { type: "context" as const, value: "gitlab include" },
+          { type: "context" as const, value: "gitlab stages" },
+          { type: "context" as const, 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/\"] });",
+          },
+        ],
+      },
+    ];
+
+    for (const skill of skillFiles) {
+      try {
+        const content = readFileSync(join(dir, "skills", skill.file), "utf-8");
+        skills.push({
+          name: skill.name,
+          description: skill.description,
+          content,
+          triggers: skill.triggers,
+          parameters: skill.parameters,
+          examples: skill.examples,
+        });
+      } catch { /* skip missing skills */ }
+    }
+
+    return skills;
   },
 };