@intentius/chant-lexicon-forgejo 0.18.19 → 0.18.21

package/dist/components/generate-pipeline.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Generate mode — component → Forgejo Actions workflow YAML (#969, epic #885).
+ *
+ * The forgejo counterpart to the github generator
+ * (`@intentius/chant-lexicon-github/components/generate-pipeline`, #891). Forgejo
+ * Actions is a GitHub-Actions dialect, and this lexicon is already a thin
+ * github-dialect serializer, so the pipeline SHAPE is identical: one job per
+ * component, `needs:` mirroring `dependsOn`, cross-stack outputs threaded as
+ * workflow artifacts, thin trigger jobs. Rather than re-derive the component
+ * graph, this reuses github's `buildGithubPipelineDoc` to build the exact same
+ * `on`/`env`/`jobs` structure, then applies the Forgejo dialect
+ * ({@link transformWorkflowObject}) before emitting — the same transform the
+ * forgejo serializer applies to authored workflows:
+ *
+ *  - runner labels: `runs-on: ubuntu-latest` → the project's Forgejo label
+ *    (default `docker`, the label a fresh `act_runner` exposes);
+ *  - `uses:` refs (`actions/checkout@v4`, `actions/upload-artifact@v4`, …)
+ *    rewritten to a Forgejo-resolvable form;
+ *  - keys the Forgejo runner ignores (`permissions`, `continue-on-error`)
+ *    dropped — the github generator emits none today, but the transform keeps
+ *    the two dialects in lock-step if that changes.
+ *
+ * The output path convention is `.forgejo/workflows/` (vs github's
+ * `.github/workflows/`), set by the caller's `-o` flag — this module emits the
+ * workflow content, not its location, exactly like the github generator.
+ */
+import type { DriverComponent } from "@intentius/chant/components/driver";
+import type { ComponentPipelineOptions, ComponentPipelineResult } from "@intentius/chant/lexicon";
+import { type ForgejoDialectOptions } from "../dialect.js";
+/**
+ * Synthesize a `.forgejo/workflows/*.yml` pipeline from a set of components.
+ * Reuses github's job/`needs:`/artifact structure ({@link buildGithubPipelineDoc}),
+ * then applies the Forgejo dialect. Wired into core's generate mode via the
+ * forgejo lexicon plugin's `generateComponentPipeline` (../plugin.ts).
+ */
+export declare function generateForgejoPipeline(components: DriverComponent[], options?: ComponentPipelineOptions, dialectOptions?: ForgejoDialectOptions): ComponentPipelineResult;
+//# sourceMappingURL=generate-pipeline.d.ts.map

package/dist/components/generate-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-pipeline.d.ts","sourceRoot":"","sources":["../../src/components/generate-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAOH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,KAAK,EACV,wBAAwB,EACxB,uBAAuB,EACxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAA2B,KAAK,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAOjF;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,eAAe,EAAE,EAC7B,OAAO,GAAE,wBAA6B,EACtC,cAAc,GAAE,qBAA0B,GACzC,uBAAuB,CAYzB"}

package/dist/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAoC,MAAM,0BAA0B,CAAC;AAYhG,eAAO,MAAM,aAAa,EAAE,aAuJ3B,CAAC"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAoC,MAAM,0BAA0B,CAAC;AAahG,eAAO,MAAM,aAAa,EAAE,aA4J3B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-forgejo",
-  "version": "0.18.19",
+  "version": "0.18.21",
   "description": "Forgejo / Codeberg / Gitea Actions lexicon for chant — a thin GitHub Actions dialect",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",
@@ -53,8 +53,8 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@intentius/chant": "^0.18.19",
-    "@intentius/chant-lexicon-github": "^0.18.19"
+    "@intentius/chant": "^0.18.21",
+    "@intentius/chant-lexicon-github": "^0.18.21"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json && find dist -type f \\( -name \"*.js\" -o -name \"*.js.map\" \\) -delete",

package/src/components/generate-pipeline.test.ts

@@ -0,0 +1,105 @@
+/**
+ * Tests for generate mode's component → Forgejo Actions workflow YAML
+ * synthesis (#969, epic #885). Mirrors the github generator's suite
+ * (`lexicons/github/src/components/generate-pipeline.test.ts`) — Forgejo Actions
+ * is a GitHub-Actions dialect, so the pipeline SHAPE is identical (one job per
+ * component, `needs:` = `dependsOn`, cross-stack outputs as artifacts) and this
+ * suite additionally proves the Forgejo dialect is applied: runner labels
+ * remapped (`ubuntu-latest` → `docker`) and `uses:` refs rewritten to a
+ * Forgejo-resolvable form.
+ */
+
+import { describe, test, expect } from "vitest";
+import { parseYAML } from "@intentius/chant/yaml";
+import { generateForgejoPipeline } from "./generate-pipeline";
+import { generateGithubPipeline } from "@intentius/chant-lexicon-github/components/generate-pipeline";
+import { type DriverComponent } from "@intentius/chant/components/driver";
+import { searchService } from "@intentius/chant/components/pilots/alb-ecs.pilot";
+import { ordersTable } from "@intentius/chant/components/pilots/dynamodb.pilot";
+
+function pilotComponents(): DriverComponent[] {
+  return [
+    { name: ordersTable.name, dependsOn: ordersTable.dependsOn, deploy: ordersTable.deploy },
+    { name: "shared-alb", dependsOn: [], deploy: [] },
+    { name: searchService.name, dependsOn: searchService.dependsOn, deploy: searchService.deploy },
+  ];
+}
+
+interface ParsedStep {
+  name?: string;
+  uses?: string;
+  run?: string;
+  with?: Record<string, unknown>;
+}
+interface ParsedJob {
+  "runs-on"?: string;
+  container?: string;
+  needs?: string[];
+  steps: ParsedStep[];
+}
+function parsedJobs(yaml: string): Record<string, ParsedJob> {
+  return (parseYAML(yaml).jobs ?? {}) as Record<string, ParsedJob>;
+}
+function usesRefs(job: ParsedJob): string[] {
+  return job.steps.filter((s) => typeof s.uses === "string").map((s) => s.uses as string);
+}
+
+describe("generateForgejoPipeline: structure (github-shaped)", () => {
+  test("valid workflow — on: + one job per component with runs-on/steps", () => {
+    const result = generateForgejoPipeline(pilotComponents());
+    const parsed = parseYAML(result.yaml);
+    expect(parsed.on).toBeDefined();
+    const jobs = parsedJobs(result.yaml);
+    expect(Object.keys(jobs).sort()).toEqual(["orders-table", "search-service", "shared-alb"]);
+    for (const job of Object.values(jobs)) {
+      expect(job["runs-on"]).toBeDefined();
+      expect(Array.isArray(job.steps)).toBe(true);
+    }
+  });
+
+  test("needs: mirrors dependsOn — search-service waits on shared-alb, nothing else", () => {
+    const jobs = parsedJobs(generateForgejoPipeline(pilotComponents()).yaml);
+    expect(jobs["search-service"].needs).toEqual(["shared-alb"]);
+    expect(jobs["orders-table"].needs ?? []).toEqual([]);
+    expect(jobs["shared-alb"].needs ?? []).toEqual([]);
+  });
+
+  test("cross-stack outputs threaded as artifacts: producer uploads, dependent downloads", () => {
+    const jobs = parsedJobs(generateForgejoPipeline(pilotComponents()).yaml);
+    const upload = jobs["shared-alb"].steps.find((s) => (s.uses ?? "").includes("upload-artifact"));
+    expect(upload?.with).toEqual({ name: "shared-alb-outputs", path: "shared-alb.outputs.json" });
+    const download = jobs["search-service"].steps.find((s) => (s.uses ?? "").includes("download-artifact"));
+    expect(download?.with).toEqual({ name: "shared-alb-outputs", path: "." });
+  });
+
+  test("stages/jobs parity with the github generator (same graph resolution)", () => {
+    const fj = generateForgejoPipeline(pilotComponents());
+    const gh = generateGithubPipeline(pilotComponents());
+    expect(fj.stages).toEqual(gh.stages);
+    expect(fj.jobs).toEqual(gh.jobs);
+  });
+});
+
+describe("generateForgejoPipeline: dialect applied", () => {
+  test("runner label ubuntu-latest is remapped to the Forgejo default (docker)", () => {
+    const jobs = parsedJobs(generateForgejoPipeline(pilotComponents()).yaml);
+    for (const job of Object.values(jobs)) {
+      expect(job["runs-on"]).toBe("docker");
+    }
+    // The github generator uses the un-remapped label — proving the dialect ran.
+    const ghJobs = parsedJobs(generateGithubPipeline(pilotComponents()).yaml);
+    expect(ghJobs["shared-alb"]["runs-on"]).toBe("ubuntu-latest");
+  });
+
+  test("uses: refs are rewritten to a Forgejo-resolvable mirror (not bare actions/*)", () => {
+    const jobs = parsedJobs(generateForgejoPipeline(pilotComponents()).yaml);
+    const all = Object.values(jobs).flatMap(usesRefs);
+    expect(all.length).toBeGreaterThan(0);
+    for (const ref of all) {
+      expect(ref.startsWith("actions/")).toBe(false);
+      expect(ref).toContain("code.forgejo.org/actions/");
+    }
+    // checkout is present and mirrored.
+    expect(all.some((r) => r === "https://code.forgejo.org/actions/checkout@v4")).toBe(true);
+  });
+});

package/src/components/generate-pipeline.ts

@@ -0,0 +1,67 @@
+/**
+ * Generate mode — component → Forgejo Actions workflow YAML (#969, epic #885).
+ *
+ * The forgejo counterpart to the github generator
+ * (`@intentius/chant-lexicon-github/components/generate-pipeline`, #891). Forgejo
+ * Actions is a GitHub-Actions dialect, and this lexicon is already a thin
+ * github-dialect serializer, so the pipeline SHAPE is identical: one job per
+ * component, `needs:` mirroring `dependsOn`, cross-stack outputs threaded as
+ * workflow artifacts, thin trigger jobs. Rather than re-derive the component
+ * graph, this reuses github's `buildGithubPipelineDoc` to build the exact same
+ * `on`/`env`/`jobs` structure, then applies the Forgejo dialect
+ * ({@link transformWorkflowObject}) before emitting — the same transform the
+ * forgejo serializer applies to authored workflows:
+ *
+ *  - runner labels: `runs-on: ubuntu-latest` → the project's Forgejo label
+ *    (default `docker`, the label a fresh `act_runner` exposes);
+ *  - `uses:` refs (`actions/checkout@v4`, `actions/upload-artifact@v4`, …)
+ *    rewritten to a Forgejo-resolvable form;
+ *  - keys the Forgejo runner ignores (`permissions`, `continue-on-error`)
+ *    dropped — the github generator emits none today, but the transform keeps
+ *    the two dialects in lock-step if that changes.
+ *
+ * The output path convention is `.forgejo/workflows/` (vs github's
+ * `.github/workflows/`), set by the caller's `-o` flag — this module emits the
+ * workflow content, not its location, exactly like the github generator.
+ */
+
+import {
+  buildGithubPipelineDoc,
+  emitPipelineYAML,
+  type GithubPipelineDoc,
+} from "@intentius/chant-lexicon-github/components/generate-pipeline";
+import type { DriverComponent } from "@intentius/chant/components/driver";
+import type {
+  ComponentPipelineOptions,
+  ComponentPipelineResult,
+} from "@intentius/chant/lexicon";
+import { transformWorkflowObject, type ForgejoDialectOptions } from "../dialect";
+
+/** Apply the Forgejo dialect to one section of the pipeline doc. */
+function forgejoize(value: Record<string, unknown>, dialect: ForgejoDialectOptions): Record<string, unknown> {
+  return transformWorkflowObject(value, dialect).value as Record<string, unknown>;
+}
+
+/**
+ * Synthesize a `.forgejo/workflows/*.yml` pipeline from a set of components.
+ * Reuses github's job/`needs:`/artifact structure ({@link buildGithubPipelineDoc}),
+ * then applies the Forgejo dialect. Wired into core's generate mode via the
+ * forgejo lexicon plugin's `generateComponentPipeline` (../plugin.ts).
+ */
+export function generateForgejoPipeline(
+  components: DriverComponent[],
+  options: ComponentPipelineOptions = {},
+  dialectOptions: ForgejoDialectOptions = {},
+): ComponentPipelineResult {
+  const doc = buildGithubPipelineDoc(components, options);
+
+  const forgejoDoc: GithubPipelineDoc = {
+    on: forgejoize(doc.on, dialectOptions),
+    ...(doc.env ? { env: forgejoize(doc.env, dialectOptions) } : {}),
+    jobsDoc: forgejoize(doc.jobsDoc, dialectOptions),
+    stages: doc.stages,
+    jobs: doc.jobs,
+  };
+
+  return { yaml: emitPipelineYAML(forgejoDoc), stages: doc.stages, jobs: doc.jobs };
+}

package/src/plugin.ts

@@ -16,6 +16,7 @@ import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { forgejoSerializer } from "./serializer";
 import { forgejoContextTools } from "./mcp/context-tools";
+import { generateForgejoPipeline } from "./components/generate-pipeline";
 
 const reuseNote =
   "forgejo reuses the github lexicon's entities — run `chant generate` in the github lexicon instead.";
@@ -25,6 +26,11 @@ export const forgejoPlugin: LexiconPlugin = {
   auditCatalog: () => forgejoAuditCatalog,
   serializer: forgejoSerializer,
 
+  // Generate mode (#969): component graph → Forgejo Actions workflow. Reuses
+  // github's pipeline structure and applies the Forgejo dialect (runner labels,
+  // `uses:` resolution) — see ./components/generate-pipeline.
+  generateComponentPipeline: (components, options) => generateForgejoPipeline(components, options),
+
   initTemplates(template?: string): InitTemplateSet {
     if (template === "docker-build") {
       return {