@intentius/chant-lexicon-forgejo 0.49.0 → 0.50.0

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

@@ -0,0 +1,30 @@
+/**
+ * Generate mode — scheduled Op → Forgejo Actions workflow YAML (#927).
+ *
+ * The forgejo counterpart to the github Op generator
+ * (`@intentius/chant-lexicon-github/components/generate-op-pipeline`, #927),
+ * exactly like `./generate-pipeline.ts` is the forgejo counterpart to
+ * github's component generator (#969). Reuses github's
+ * `buildGithubOpPipelineDocs` to build the same cron-trigger/concurrency/job
+ * structure, then applies the Forgejo dialect ({@link transformWorkflowObject})
+ * before emitting.
+ *
+ * One difference from the component generator: Forgejo Actions ignores
+ * `permissions:` entirely (the dialect drops it wherever it appears, see
+ * ../dialect.ts's `DROPPED_KEYS`), so this omits the section outright rather
+ * than emitting a control the runner can't act on. The token a finding-mode
+ * needs still rides the trigger step's `env:` (`GH_TOKEN`/`GITHUB_TOKEN`,
+ * built by github's generator); actual write access on Forgejo is a property
+ * of the runner/token configuration, not the workflow YAML.
+ */
+import type { ComponentPipelineOptions, OpPipelineResult, ScheduledOpSpec } from "@intentius/chant/lexicon";
+import { type ForgejoDialectOptions } from "../dialect.js";
+/**
+ * Synthesize one `.forgejo/workflows/*.yml` per scheduled Op. Reuses github's
+ * trigger/job structure ({@link buildGithubOpPipelineDocs}), then applies the
+ * Forgejo dialect and drops `permissions:` (ignored by the Forgejo runner).
+ * Wired into core's Op generate mode via the forgejo lexicon plugin's
+ * `generateOpPipeline` (../plugin.ts).
+ */
+export declare function generateForgejoOpPipeline(ops: ScheduledOpSpec[], options?: ComponentPipelineOptions, dialectOptions?: ForgejoDialectOptions): OpPipelineResult;
+//# sourceMappingURL=generate-op-pipeline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generate-op-pipeline.d.ts","sourceRoot":"","sources":["../../src/components/generate-op-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAOH,OAAO,KAAK,EACV,wBAAwB,EACxB,gBAAgB,EAChB,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAA2B,KAAK,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAOjF;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,eAAe,EAAE,EACtB,OAAO,GAAE,wBAA6B,EACtC,cAAc,GAAE,qBAA0B,GACzC,gBAAgB,CAgBlB"}

package/dist/integrity.json

@@ -1,7 +1,7 @@
 {
   "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "6623c21fb54fb5a64579b71a367425d7c5adf93751f10b497f3a2d988d843536",
+    "manifest.json": "f286643dad112fe26479ee4d067f94ff94c45e8d3c5bcbf67c2ad99e62a65d3f",
     "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": "a1a560429db736c187e0b34cf8dd9efc6ad771afefcbf6f802d160d3d5274257"
   },
-  "composite": "cec0e30e1c4c62b7eb856d6824aecc90faed63759d5435d578f592580306e95f"
+  "composite": "e450abb18a6de4840867245499c64f4d4b7a7024e6fb6e0180a5ee34f55a5630"
 }

package/dist/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "forgejo",
-  "version": "0.49.0",
+  "version": "0.50.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;AAkBhG,eAAO,MAAM,aAAa,EAAE,aA8L3B,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;AAmBhG,eAAO,MAAM,aAAa,EAAE,aAiM3B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-forgejo",
-  "version": "0.49.0",
+  "version": "0.50.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.49.0",
-    "@intentius/chant-lexicon-github": "^0.49.0"
+    "@intentius/chant": "^0.50.0",
+    "@intentius/chant-lexicon-github": "^0.50.0"
   },
   "scripts": {
     "generate": "tsx src/codegen/generate-cli.ts",

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

@@ -0,0 +1,72 @@
+/**
+ * Tests for generate mode's scheduled Op → Forgejo Actions workflow YAML
+ * synthesis (#927). Mirrors `./generate-pipeline.test.ts`'s style: same
+ * trigger/job SHAPE as the github Op generator, plus proof the Forgejo
+ * dialect is applied (runner label remapped) and that `permissions:` — a key
+ * the Forgejo runner ignores — is dropped rather than emitted.
+ */
+
+import { describe, test, expect } from "vitest";
+import { parseYAML } from "@intentius/chant/yaml";
+import { generateForgejoOpPipeline } from "./generate-op-pipeline";
+import { generateGithubOpPipeline } from "@intentius/chant-lexicon-github/components/generate-op-pipeline";
+import type { ScheduledOpSpec } from "@intentius/chant/lexicon";
+
+interface ParsedJob {
+  "runs-on"?: string;
+  steps: Array<{ uses?: string; run?: string }>;
+}
+interface ParsedDoc {
+  on?: Record<string, unknown>;
+  permissions?: Record<string, string>;
+  jobs?: Record<string, ParsedJob>;
+}
+function parseFile(yaml: string): ParsedDoc {
+  return parseYAML(yaml) as ParsedDoc;
+}
+
+describe("generateForgejoOpPipeline: structure (github-shaped)", () => {
+  test("one file per scheduled Op, each a valid workflow with one job", () => {
+    const specs: ScheduledOpSpec[] = [
+      { name: "actions-audit", schedule: "0 6 * * *" },
+      { name: "prod-reconcile", schedule: "0 * * * *", findingMode: "issue" },
+    ];
+    const result = generateForgejoOpPipeline(specs);
+
+    expect(result.files).toHaveLength(2);
+    expect(result.files.map((f) => f.name)).toEqual(["actions-audit.yml", "prod-reconcile.yml"]);
+
+    const doc = parseFile(result.files[0].yaml);
+    expect(doc.on).toEqual({ schedule: [{ cron: "0 6 * * *" }], workflow_dispatch: {} });
+    expect(Object.keys(doc.jobs!)).toEqual(["actions-audit"]);
+  });
+
+  test("jobs/schedule/findingMode parity with the github generator (same input, same job list)", () => {
+    const specs: ScheduledOpSpec[] = [{ name: "actions-audit", schedule: "0 6 * * *", findingMode: "pull-request" }];
+    const fj = generateForgejoOpPipeline(specs);
+    const gh = generateGithubOpPipeline(specs);
+    expect(fj.jobs).toEqual(gh.jobs);
+  });
+});
+
+describe("generateForgejoOpPipeline: dialect applied", () => {
+  test("runner label ubuntu-latest is remapped to the Forgejo default (docker)", () => {
+    const specs: ScheduledOpSpec[] = [{ name: "actions-audit", schedule: "0 6 * * *" }];
+    const fjJob = parseFile(generateForgejoOpPipeline(specs).files[0].yaml).jobs!["actions-audit"];
+    const ghJob = parseFile(generateGithubOpPipeline(specs).files[0].yaml).jobs!["actions-audit"];
+
+    expect(fjJob["runs-on"]).toBe("docker");
+    expect(ghJob["runs-on"]).toBe("ubuntu-latest");
+  });
+
+  test("permissions: is dropped — the Forgejo runner ignores it", () => {
+    const specs: ScheduledOpSpec[] = [{ name: "prod-reconcile", schedule: "0 * * * *", findingMode: "pull-request" }];
+    const fjYaml = generateForgejoOpPipeline(specs).files[0].yaml;
+    const ghYaml = generateGithubOpPipeline(specs).files[0].yaml;
+
+    expect(fjYaml).not.toMatch(/^permissions:/m);
+    // The github counterpart, generated from the same spec, does declare it —
+    // proving the omission is the dialect, not an accident of the spec.
+    expect(ghYaml).toMatch(/^permissions:/m);
+  });
+});

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

@@ -0,0 +1,65 @@
+/**
+ * Generate mode — scheduled Op → Forgejo Actions workflow YAML (#927).
+ *
+ * The forgejo counterpart to the github Op generator
+ * (`@intentius/chant-lexicon-github/components/generate-op-pipeline`, #927),
+ * exactly like `./generate-pipeline.ts` is the forgejo counterpart to
+ * github's component generator (#969). Reuses github's
+ * `buildGithubOpPipelineDocs` to build the same cron-trigger/concurrency/job
+ * structure, then applies the Forgejo dialect ({@link transformWorkflowObject})
+ * before emitting.
+ *
+ * One difference from the component generator: Forgejo Actions ignores
+ * `permissions:` entirely (the dialect drops it wherever it appears, see
+ * ../dialect.ts's `DROPPED_KEYS`), so this omits the section outright rather
+ * than emitting a control the runner can't act on. The token a finding-mode
+ * needs still rides the trigger step's `env:` (`GH_TOKEN`/`GITHUB_TOKEN`,
+ * built by github's generator); actual write access on Forgejo is a property
+ * of the runner/token configuration, not the workflow YAML.
+ */
+
+import {
+  buildGithubOpPipelineDocs,
+  emitOpPipelineYAML,
+  type GithubOpPipelineDoc,
+} from "@intentius/chant-lexicon-github/components/generate-op-pipeline";
+import type {
+  ComponentPipelineOptions,
+  OpPipelineResult,
+  ScheduledOpSpec,
+} from "@intentius/chant/lexicon";
+import { transformWorkflowObject, type ForgejoDialectOptions } from "../dialect";
+
+/** Apply the Forgejo dialect to one section of a pipeline doc. */
+function forgejoize(value: Record<string, unknown>, dialect: ForgejoDialectOptions): Record<string, unknown> {
+  return transformWorkflowObject(value, dialect).value as Record<string, unknown>;
+}
+
+/**
+ * Synthesize one `.forgejo/workflows/*.yml` per scheduled Op. Reuses github's
+ * trigger/job structure ({@link buildGithubOpPipelineDocs}), then applies the
+ * Forgejo dialect and drops `permissions:` (ignored by the Forgejo runner).
+ * Wired into core's Op generate mode via the forgejo lexicon plugin's
+ * `generateOpPipeline` (../plugin.ts).
+ */
+export function generateForgejoOpPipeline(
+  ops: ScheduledOpSpec[],
+  options: ComponentPipelineOptions = {},
+  dialectOptions: ForgejoDialectOptions = {},
+): OpPipelineResult {
+  const { files, jobs } = buildGithubOpPipelineDocs(ops, options);
+
+  return {
+    files: files.map(({ name, doc }) => {
+      const forgejoDoc: GithubOpPipelineDoc = {
+        on: forgejoize(doc.on, dialectOptions),
+        ...(doc.env ? { env: forgejoize(doc.env, dialectOptions) } : {}),
+        concurrency: forgejoize(doc.concurrency, dialectOptions),
+        permissions: {},
+        jobsDoc: forgejoize(doc.jobsDoc, dialectOptions),
+      };
+      return { name, yaml: emitOpPipelineYAML(forgejoDoc) };
+    }),
+    jobs,
+  };
+}

package/src/plugin.ts

@@ -18,6 +18,7 @@ import { fileURLToPath } from "url";
 import { forgejoSerializer } from "./serializer";
 import { forgejoContextTools } from "./mcp/context-tools";
 import { generateForgejoPipeline } from "./components/generate-pipeline";
+import { generateForgejoOpPipeline } from "./components/generate-op-pipeline";
 import { forgejoLintRules } from "./lint/rules/delegate-to-github";
 import { forgejoCompletions } from "./lsp/completions";
 import { forgejoHover } from "./lsp/hover";
@@ -37,6 +38,9 @@ export const forgejoPlugin: LexiconPlugin = {
   // `uses:` resolution) — see ./components/generate-pipeline.
   generateComponentPipeline: (components, options) => generateForgejoPipeline(components, options),
 
+  // Generate mode, Op counterpart (#927): scheduled Op → Forgejo Actions workflow.
+  generateOpPipeline: (ops, options) => generateForgejoOpPipeline(ops, options),
+
   initTemplates(template?: string): InitTemplateSet {
     if (template === "docker-build") {
       return {