@intentius/chant-lexicon-forgejo 0.115.0 → 0.117.0

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

@@ -0,0 +1,20 @@
+/**
+ * Op waves → Forgejo Actions workflow (#3679).
+ *
+ * The github workflow ({@link buildGithubOpWavesDoc}) under the Forgejo
+ * dialect: action refs rewritten, `permissions:` dropped (the runner reads
+ * none), and each wave's `environment:` dropped with a header line saying so,
+ * since Forgejo Actions has no environments. The wave's chant gate is what
+ * holds it there.
+ *
+ * With `resume` on the spec (#3683), `<name>-resume.yml` runs `chant run
+ * resume --op <name>` on that schedule. Forgejo has no API to re-run a run,
+ * so it dispatches the waves workflow again on its branch, with the
+ * `CHANT_FORGE_TOKEN` secret (a token with the `write:repository` scope).
+ */
+import type { OpWavesSpec } from "@intentius/chant/op/op-waves";
+import type { OpWavesPipelineOptions, OpWavesPipelineResult } from "@intentius/chant/lexicon";
+import { type ForgejoDialectOptions } from "../dialect.js";
+/** Render an Op waves spec as one Forgejo Actions workflow, `<name>.yml`. */
+export declare function generateForgejoOpWavesPipeline(spec: OpWavesSpec, options: OpWavesPipelineOptions, dialectOptions?: ForgejoDialectOptions): OpWavesPipelineResult;
+//# sourceMappingURL=generate-op-waves-pipeline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generate-op-waves-pipeline.d.ts","sourceRoot":"","sources":["../../src/components/generate-op-waves-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAC9F,OAAO,EAA2B,KAAK,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAMjF,6EAA6E;AAC7E,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,sBAAsB,EAC/B,cAAc,GAAE,qBAA0B,GACzC,qBAAqB,CA6CvB"}

package/dist/integrity.json

@@ -1,7 +1,7 @@
 {
   "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "a0c7472b522e4b439095a1bf9d0cdef9239a8a46c000e93b99e53c8f9ec61e33",
+    "manifest.json": "bd0b5cbea165a77cb8a066acbf0d382f8dd45d8d767a4d88ae874e60bac02d0d",
     "meta.json": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a",
     "types/index.d.ts": "66204549b2a864ab5489e3f02c1878e73ab4b3c9d938cfb480b66f71543a43de",
     "rules/delegate-to-github.ts": "1060cda40f4b73d6cca3ba3fa13b80b4886147d4034c88584c2d80c5510dbe5e",
@@ -9,5 +9,5 @@
     "rules/wfj011.ts": "fcb8bf6685d744af20ad804ce929488257995c74b9a3353b2eacae3768d1c83e",
     "skills/chant-forgejo.md": "f28d7fb69fb1cfd992496ef41fda0ea5ccd54a29b84ea1c501a44f6a3992c4d5"
   },
-  "composite": "45673c46187e15f40d82dedd6f92a7c89a077de57d8ae200fe686c41679ea468"
+  "composite": "73b7f0b11a0b2392b370713f429927c565a53e71742ae5a10f2d3be661e9fc4c"
 }

package/dist/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "forgejo",
-  "version": "0.115.0",
+  "version": "0.117.0",
   "chantVersion": ">=0.1.0",
   "namespace": "Forgejo",
   "intrinsics": [],

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;AAmBhG,eAAO,MAAM,aAAa,EAAE,aAiM3B,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;AAoBhG,eAAO,MAAM,aAAa,EAAE,aAmM3B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-forgejo",
-  "version": "0.115.0",
+  "version": "0.117.0",
   "description": "Forgejo / Codeberg / Gitea Actions lexicon for chant — a thin GitHub Actions dialect",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",
@@ -54,8 +54,8 @@
   },
   "peerDependencies": {
     "zod": "^4.3.6",
-    "@intentius/chant": "^0.115.0",
-    "@intentius/chant-lexicon-github": "^0.115.0"
+    "@intentius/chant": "^0.117.0",
+    "@intentius/chant-lexicon-github": "^0.117.0"
   },
   "scripts": {
     "generate": "tsx src/codegen/generate-cli.ts",

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

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "vitest";
+import type { OpWavesSpec } from "@intentius/chant/op/op-waves";
+import { generateForgejoOpWavesPipeline } from "./generate-op-waves-pipeline";
+
+const spec: OpWavesSpec = {
+  name: "migrations",
+  op: "migrate",
+  plan: ["./bin/plan", "{target}", "{plan}"],
+  waves: [
+    { name: "dev", runs: [{ target: "dev" }], gate: "never" },
+    { name: "staging", runs: [{ target: "staging" }] },
+    { name: "prod", runs: [{ target: "prod" }], environment: { name: "production" } },
+  ],
+};
+
+describe("generateForgejoOpWavesPipeline", () => {
+  test("the waves under the Forgejo dialect: chained by needs, no permissions, the environment named as dropped", () => {
+    const { files, jobs } = generateForgejoOpWavesPipeline(spec, { specFile: "waves.json" });
+    expect(jobs.map((j) => [j.jobName, j.needs])).toEqual([
+      ["wave-1-dev", []],
+      ["wave-2-staging", ["wave-1-dev"]],
+      ["wave-3-prod", ["wave-2-staging"]],
+    ]);
+    const yaml = files[0]!.yaml;
+    expect(files[0]!.name).toBe("migrations.yml");
+    expect(yaml).toContain("# chant dropped the environment of each of these waves: prod -> production.");
+    expect(yaml).not.toMatch(/^\s+environment:/m);
+    expect(yaml).not.toMatch(/^permissions:/m);
+    expect(yaml).toMatch(/wave-3-prod:\n\s+runs-on: docker\n\s+needs:\n\s+- wave-2-staging/);
+    expect(yaml).toContain("run: chant run wave --spec waves.json --wave 3\n");
+    expect(yaml).toContain("fetch-depth: 0");
+  });
+
+  test("resume renders a scheduled workflow that dispatches with the CHANT_FORGE_TOKEN secret (#3683)", () => {
+    const { files } = generateForgejoOpWavesPipeline({ ...spec, resume: { schedule: "*/10 * * * *" } }, { specFile: "waves.json" });
+    expect(files.map((f) => f.name)).toEqual(["migrations.yml", "migrations-resume.yml"]);
+    const yaml = files[1]!.yaml;
+    expect(yaml).toContain("run: chant run resume --op migrations");
+    expect(yaml).toContain("CHANT_FORGE_TOKEN: '${{ secrets.CHANT_FORGE_TOKEN }}'");
+    expect(yaml).not.toContain("github.token");
+    expect(yaml).not.toMatch(/^permissions:/m);
+  });
+});

package/src/components/generate-op-waves-pipeline.ts

@@ -0,0 +1,76 @@
+/**
+ * Op waves → Forgejo Actions workflow (#3679).
+ *
+ * The github workflow ({@link buildGithubOpWavesDoc}) under the Forgejo
+ * dialect: action refs rewritten, `permissions:` dropped (the runner reads
+ * none), and each wave's `environment:` dropped with a header line saying so,
+ * since Forgejo Actions has no environments. The wave's chant gate is what
+ * holds it there.
+ *
+ * With `resume` on the spec (#3683), `<name>-resume.yml` runs `chant run
+ * resume --op <name>` on that schedule. Forgejo has no API to re-run a run,
+ * so it dispatches the waves workflow again on its branch, with the
+ * `CHANT_FORGE_TOKEN` secret (a token with the `write:repository` scope).
+ */
+
+import { buildGithubOpWavesDoc } from "@intentius/chant-lexicon-github/components/generate-op-waves-pipeline";
+import { emitOpPipelineYAML, type GithubOpPipelineDoc } from "@intentius/chant-lexicon-github/components/generate-op-pipeline";
+import type { OpWavesSpec } from "@intentius/chant/op/op-waves";
+import type { OpWavesPipelineOptions, OpWavesPipelineResult } from "@intentius/chant/lexicon";
+import { transformWorkflowObject, type ForgejoDialectOptions } from "../dialect";
+
+function forgejoize(value: Record<string, unknown>, dialect: ForgejoDialectOptions): Record<string, unknown> {
+  return transformWorkflowObject(value, dialect).value as Record<string, unknown>;
+}
+
+/** Render an Op waves spec as one Forgejo Actions workflow, `<name>.yml`. */
+export function generateForgejoOpWavesPipeline(
+  spec: OpWavesSpec,
+  options: OpWavesPipelineOptions,
+  dialectOptions: ForgejoDialectOptions = {},
+): OpWavesPipelineResult {
+  const { doc, jobs, resumeDoc } = buildGithubOpWavesDoc(spec, options);
+  const jobsDoc = Object.fromEntries(
+    Object.entries(doc.jobsDoc).map(([name, job]) => {
+      const { environment: _dropped, ...rest } = job as Record<string, unknown>;
+      return [name, rest];
+    }),
+  );
+  const dropped = spec.waves.filter((w) => w.environment).map((w) => `${w.name} -> ${w.environment!.name}`);
+  const forgejoDoc: GithubOpPipelineDoc = {
+    ...(dropped.length > 0
+      ? {
+          header: [
+            `# chant dropped the environment of each of these waves: ${dropped.join(", ")}.`,
+            "# Forgejo Actions has no environments, so nothing on the forge holds these jobs.",
+            "# Each wave's own chant gate does: it records a pending fact on chant/lifecycle",
+            "# and the wave exits 3 until `chant approve` approves its set digest.",
+          ],
+        }
+      : {}),
+    name: doc.name,
+    on: forgejoize(doc.on, dialectOptions),
+    ...(doc.env ? { env: forgejoize(doc.env, dialectOptions) } : {}),
+    concurrency: forgejoize(doc.concurrency, dialectOptions),
+    permissions: {},
+    jobsDoc: forgejoize(jobsDoc, dialectOptions),
+  };
+  const files = [{ name: `${spec.name}.yml`, yaml: emitOpPipelineYAML(forgejoDoc) }];
+  if (resumeDoc) {
+    const resumeJobs = forgejoize(resumeDoc.jobsDoc, dialectOptions) as Record<string, { steps: Array<Record<string, unknown>> }>;
+    for (const job of Object.values(resumeJobs)) {
+      for (const step of job.steps) if (step.env) step.env = { CHANT_FORGE_TOKEN: "${{ secrets.CHANT_FORGE_TOKEN }}" };
+    }
+    files.push({
+      name: `${spec.name}-resume.yml`,
+      yaml: emitOpPipelineYAML({
+        name: resumeDoc.name!,
+        on: forgejoize(resumeDoc.on, dialectOptions),
+        concurrency: forgejoize(resumeDoc.concurrency, dialectOptions),
+        permissions: {},
+        jobsDoc: resumeJobs,
+      }),
+    });
+  }
+  return { files, jobs };
+}

package/src/plugin.ts

@@ -19,6 +19,7 @@ import { forgejoSerializer } from "./serializer";
 import { forgejoContextTools } from "./mcp/context-tools";
 import { generateForgejoPipeline } from "./components/generate-pipeline";
 import { generateForgejoOpPipeline } from "./components/generate-op-pipeline";
+import { generateForgejoOpWavesPipeline } from "./components/generate-op-waves-pipeline";
 import { forgejoLintRules } from "./lint/rules/delegate-to-github";
 import { forgejoCompletions } from "./lsp/completions";
 import { forgejoHover } from "./lsp/hover";
@@ -40,6 +41,8 @@ export const forgejoPlugin: LexiconPlugin = {
 
   // Generate mode, Op counterpart (#927): scheduled Op → Forgejo Actions workflow.
   generateOpPipeline: (ops, options) => generateForgejoOpPipeline(ops, options),
+  // Ordered waves of Op runs, each behind one gate (#3679).
+  generateOpWavesPipeline: (spec, options) => generateForgejoOpWavesPipeline(spec, options),
 
   initTemplates(template?: string): InitTemplateSet {
     if (template === "docker-build") {