@intentius/chant-lexicon-k8s 0.18.36 → 0.19.0

package/dist/types/index.d.ts

@@ -2,6 +2,17 @@
 
 // --- Kubernetes Resource classes ---
 
+export declare class Alert {
+  constructor(props: {
+    metadata?: Record<string, unknown>;
+    /** AlertSpec defines an alerting rule for events involving a list of objects. */
+    spec?: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly uid: string;
+}
+
 export declare class APIGroup {
   constructor(props: {
     /** name is the name of the group. */
@@ -137,6 +148,19 @@ export declare class Binding {
   readonly uid: string;
 }
 
+export declare class Bucket {
+  constructor(props: {
+    metadata?: Record<string, unknown>;
+    /** BucketSpec specifies the required configuration to produce an Artifact for
+an object storage bucket. */
+    spec?: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly status: Record<string, unknown>;
+  readonly uid: string;
+}
+
 export declare class Certificate {
   constructor(props: {
     metadata?: Record<string, unknown>;
@@ -858,6 +882,30 @@ export declare class FlowSchemaList {
   readonly uid: string;
 }
 
+export declare class FluxInstance {
+  constructor(props: {
+    metadata?: Record<string, unknown>;
+    /** FluxInstanceSpec defines the desired state of FluxInstance */
+    spec?: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly status: Record<string, unknown>;
+  readonly uid: string;
+}
+
+export declare class FluxReport {
+  constructor(props: {
+    metadata?: Record<string, unknown>;
+    /** FluxReportSpec defines the observed state of a Flux installation. */
+    spec?: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly status: Record<string, unknown>;
+  readonly uid: string;
+}
+
 export declare class Gateway {
   constructor(props: {
     /** Spec defines the desired state of Gateway. */
@@ -882,6 +930,19 @@ export declare class GatewayClass {
   readonly uid: string;
 }
 
+export declare class GitRepository {
+  constructor(props: {
+    metadata?: Record<string, unknown>;
+    /** GitRepositorySpec specifies the required configuration to produce an
+Artifact for a Git repository. */
+    spec?: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly status: Record<string, unknown>;
+  readonly uid: string;
+}
+
 export declare class GRPCRoute {
   constructor(props: {
     metadata?: Record<string, unknown>;
@@ -894,6 +955,43 @@ export declare class GRPCRoute {
   readonly uid: string;
 }
 
+export declare class HelmChart {
+  constructor(props: {
+    metadata?: Record<string, unknown>;
+    /** HelmChartSpec specifies the desired state of a Helm chart. */
+    spec?: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly status: Record<string, unknown>;
+  readonly uid: string;
+}
+
+export declare class HelmRelease {
+  constructor(props: {
+    metadata?: Record<string, unknown>;
+    /** HelmReleaseSpec defines the desired state of a Helm release. */
+    spec?: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly status: Record<string, unknown>;
+  readonly uid: string;
+}
+
+export declare class HelmRepository {
+  constructor(props: {
+    metadata?: Record<string, unknown>;
+    /** HelmRepositorySpec specifies the required configuration to produce an
+Artifact for a Helm repository index YAML. */
+    spec?: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly status: Record<string, unknown>;
+  readonly uid: string;
+}
+
 export declare class HorizontalPodAutoscaler {
   constructor(props: {
     /** spec is the specification for the behaviour of the autoscaler. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status. */
@@ -942,6 +1040,44 @@ export declare class HTTPRoute {
   readonly uid: string;
 }
 
+export declare class ImagePolicy {
+  constructor(props: {
+    metadata?: Record<string, unknown>;
+    /** ImagePolicySpec defines the parameters for calculating the
+ImagePolicy. */
+    spec?: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly status: Record<string, unknown>;
+  readonly uid: string;
+}
+
+export declare class ImageRepository {
+  constructor(props: {
+    metadata?: Record<string, unknown>;
+    /** ImageRepositorySpec defines the parameters for scanning an image
+repository, e.g., `fluxcd/flux`. */
+    spec?: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly status: Record<string, unknown>;
+  readonly uid: string;
+}
+
+export declare class ImageUpdateAutomation {
+  constructor(props: {
+    metadata?: Record<string, unknown>;
+    /** ImageUpdateAutomationSpec defines the desired state of ImageUpdateAutomation */
+    spec?: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly status: Record<string, unknown>;
+  readonly uid: string;
+}
+
 export declare class Ing {
   constructor(props: {
     /** Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata */
@@ -1062,6 +1198,19 @@ export declare class JobList {
   readonly uid: string;
 }
 
+export declare class Kustomization {
+  constructor(props: {
+    metadata?: Record<string, unknown>;
+    /** KustomizationSpec defines the configuration to calculate the desired state
+from a Source using Kustomize. */
+    spec?: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly status: Record<string, unknown>;
+  readonly uid: string;
+}
+
 export declare class Lease {
   constructor(props: {
     /** More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata */
@@ -1314,6 +1463,18 @@ export declare class NS {
   readonly uid: string;
 }
 
+export declare class OCIRepository {
+  constructor(props: {
+    metadata?: Record<string, unknown>;
+    /** OCIRepositorySpec defines the desired state of OCIRepository */
+    spec?: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly status: Record<string, unknown>;
+  readonly uid: string;
+}
+
 export declare class Order {
   constructor(props: {
     metadata: Record<string, unknown>;
@@ -1546,6 +1707,17 @@ export declare class PrometheusRule {
   readonly uid: string;
 }
 
+export declare class Provider {
+  constructor(props: {
+    metadata?: Record<string, unknown>;
+    /** ProviderSpec defines the desired state of the Provider. */
+    spec?: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly uid: string;
+}
+
 export declare class PV {
   constructor(props: {
     /** Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata */
@@ -1603,6 +1775,18 @@ export declare class RayService {
   readonly uid: string;
 }
 
+export declare class Receiver {
+  constructor(props: {
+    metadata?: Record<string, unknown>;
+    /** ReceiverSpec defines the desired state of the Receiver. */
+    spec?: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly status: Record<string, unknown>;
+  readonly uid: string;
+}
+
 export declare class ReferenceGrant {
   constructor(props: {
     metadata?: Record<string, unknown>;
@@ -1736,6 +1920,30 @@ export declare class ResourceQuotaList {
   readonly uid: string;
 }
 
+export declare class ResourceSet {
+  constructor(props: {
+    metadata?: Record<string, unknown>;
+    /** ResourceSetSpec defines the desired state of ResourceSet */
+    spec?: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly status: Record<string, unknown>;
+  readonly uid: string;
+}
+
+export declare class ResourceSetInputProvider {
+  constructor(props: {
+    metadata?: Record<string, unknown>;
+    /** ResourceSetInputProviderSpec defines the desired state of ResourceSetInputProvider */
+    spec?: Record<string, unknown>;
+  });
+  readonly name: string;
+  readonly namespace: string;
+  readonly status: Record<string, unknown>;
+  readonly uid: string;
+}
+
 export declare class ResourceSlice {
   constructor(props: {
     /** Contains the information published by the driver.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-k8s",
-  "version": "0.18.36",
+  "version": "0.19.0",
   "description": "Kubernetes lexicon for chant — declarative IaC in TypeScript",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",
@@ -75,7 +75,7 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@intentius/chant": "^0.18.36",
+    "@intentius/chant": "^0.19.0",
     "typescript": "^5.9.3"
   }
 }

package/src/crd/crd-sources.ts

@@ -107,6 +107,49 @@ const CERT_MANAGER_CRD_BUNDLE = `https://github.com/cert-manager/cert-manager/re
 const PROM_OPERATOR_VERSION = "v0.79.2";
 const PROM_OPERATOR_CRD_BASE = `https://raw.githubusercontent.com/prometheus-operator/prometheus-operator/${PROM_OPERATOR_VERSION}/example/prometheus-operator-crd`;
 
+/**
+ * Flux GitOps Toolkit CRDs — the five `*.toolkit.fluxcd.io` groups.
+ *
+ * The flux2 release `install.yaml` is a single multi-doc bundle (controllers,
+ * RBAC, and CRDs); the parser keeps only the CustomResourceDefinition docs, and
+ * the `kinds` allowlist below narrows those to the supported set — the bundle
+ * also carries `ExternalArtifact` and `ArtifactGenerator` (experimental, and a
+ * separate `source.extensions.fluxcd.io` group), which are intentionally left
+ * out. All groups map to the `Flux` namespace (see GROUP_NAMESPACE_OVERRIDES in
+ * crd/parser.ts):
+ *   K8s::Flux::GitRepository / OCIRepository / HelmRepository / HelmChart / Bucket
+ *                                          → source.toolkit.fluxcd.io/v1
+ *   K8s::Flux::Kustomization               → kustomize.toolkit.fluxcd.io/v1
+ *   K8s::Flux::HelmRelease                 → helm.toolkit.fluxcd.io/v2
+ *   K8s::Flux::Provider / Alert            → notification.toolkit.fluxcd.io/v1beta3
+ *   K8s::Flux::Receiver                    → notification.toolkit.fluxcd.io/v1
+ *   K8s::Flux::ImagePolicy / ImageRepository / ImageUpdateAutomation
+ *                                          → image.toolkit.fluxcd.io/v1
+ *
+ * Controller install: kubectl apply -f
+ *   https://github.com/fluxcd/flux2/releases/download/v2.9.1/install.yaml
+ */
+const FLUX_TOOLKIT_VERSION = "v2.9.1";
+const FLUX_TOOLKIT_INSTALL = `https://github.com/fluxcd/flux2/releases/download/${FLUX_TOOLKIT_VERSION}/install.yaml`;
+
+/**
+ * Flux Operator CRDs — fluxcd.controlplane.io/v1
+ *
+ * The operator that installs and manages a Flux instance declaratively. Its
+ * release `install.yaml` bundles the four CRDs alongside the operator
+ * Deployment/RBAC; the parser keeps only the CRDs. They map to the `Flux`
+ * namespace (GROUP_NAMESPACE_OVERRIDES):
+ *   K8s::Flux::FluxInstance              → fluxcd.controlplane.io/v1
+ *   K8s::Flux::FluxReport                → fluxcd.controlplane.io/v1
+ *   K8s::Flux::ResourceSet               → fluxcd.controlplane.io/v1
+ *   K8s::Flux::ResourceSetInputProvider  → fluxcd.controlplane.io/v1
+ *
+ * Operator install: kubectl apply -f
+ *   https://github.com/controlplaneio-fluxcd/flux-operator/releases/download/v0.54.1/install.yaml
+ */
+const FLUX_OPERATOR_VERSION = "v0.54.1";
+const FLUX_OPERATOR_INSTALL = `https://github.com/controlplaneio-fluxcd/flux-operator/releases/download/${FLUX_OPERATOR_VERSION}/install.yaml`;
+
 export const CRD_SOURCES: CRDSource[] = [
   { type: "url", url: `${KUBERAY_CRD_BASE}/ray.io_rayclusters.yaml` },
   { type: "url", url: `${KUBERAY_CRD_BASE}/ray.io_rayjobs.yaml` },
@@ -123,4 +166,28 @@ export const CRD_SOURCES: CRDSource[] = [
   { type: "url", url: CERT_MANAGER_CRD_BUNDLE },
   { type: "url", url: `${PROM_OPERATOR_CRD_BASE}/monitoring.coreos.com_servicemonitors.yaml` },
   { type: "url", url: `${PROM_OPERATOR_CRD_BASE}/monitoring.coreos.com_prometheusrules.yaml` },
+  {
+    type: "url",
+    url: FLUX_TOOLKIT_INSTALL,
+    kinds: [
+      "GitRepository",
+      "OCIRepository",
+      "HelmRepository",
+      "HelmChart",
+      "Bucket",
+      "Kustomization",
+      "HelmRelease",
+      "Provider",
+      "Alert",
+      "Receiver",
+      "ImagePolicy",
+      "ImageRepository",
+      "ImageUpdateAutomation",
+    ],
+  },
+  {
+    type: "url",
+    url: FLUX_OPERATOR_INSTALL,
+    kinds: ["FluxInstance", "FluxReport", "ResourceSet", "ResourceSetInputProvider"],
+  },
 ];

package/src/crd/loader.test.ts

@@ -0,0 +1,60 @@
+import { describe, test, expect, afterAll } from "vitest";
+import { writeFileSync, rmSync, mkdtempSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { loadCRDs } from "./loader";
+
+// A two-CRD bundle standing in for a multi-doc install.yaml.
+const BUNDLE = `
+apiVersion: apiextensions.k8s.io/v1
+kind: CustomResourceDefinition
+metadata:
+  name: gitrepositories.source.toolkit.fluxcd.io
+spec:
+  group: source.toolkit.fluxcd.io
+  names: { kind: GitRepository, plural: gitrepositories }
+  scope: Namespaced
+  versions:
+    - name: v1
+      served: true
+      storage: true
+      schema: { openAPIV3Schema: { type: object } }
+---
+apiVersion: apiextensions.k8s.io/v1
+kind: CustomResourceDefinition
+metadata:
+  name: externalartifacts.source.toolkit.fluxcd.io
+spec:
+  group: source.toolkit.fluxcd.io
+  names: { kind: ExternalArtifact, plural: externalartifacts }
+  scope: Namespaced
+  versions:
+    - name: v1
+      served: true
+      storage: true
+      schema: { openAPIV3Schema: { type: object } }
+`;
+
+const dir = mkdtempSync(join(tmpdir(), "chant-crd-loader-"));
+
+afterAll(() => {
+  rmSync(dir, { recursive: true, force: true });
+});
+
+describe("loadCRDs kinds allowlist", () => {
+  test("keeps only allowlisted kinds from a multi-doc bundle", async () => {
+    const path = join(dir, "bundle.yaml");
+    writeFileSync(path, BUNDLE);
+
+    const kept = await loadCRDs({ type: "file", path, kinds: ["GitRepository"] });
+    expect(kept.map((r) => r.gvk.kind)).toEqual(["GitRepository"]);
+  });
+
+  test("without a kinds filter, every CRD in the bundle is parsed", async () => {
+    const path = join(dir, "bundle.yaml");
+    writeFileSync(path, BUNDLE);
+
+    const all = await loadCRDs({ type: "file", path });
+    expect(all.map((r) => r.gvk.kind).sort()).toEqual(["ExternalArtifact", "GitRepository"]);
+  });
+});

package/src/crd/loader.ts

@@ -16,7 +16,12 @@ import { parseCRD } from "./parser";
  */
 export async function loadCRDs(source: CRDSource): Promise<K8sParseResult[]> {
   const content = await fetchCRDContent(source);
-  return parseCRD(content);
+  const parsed = parseCRD(content);
+  if (source.kinds && source.kinds.length > 0) {
+    const allow = new Set(source.kinds);
+    return parsed.filter((r) => allow.has(r.gvk.kind));
+  }
+  return parsed;
 }
 
 /**

package/src/crd/parser.test.ts

@@ -229,6 +229,26 @@ describe("parseCRDSpec", () => {
     expect(results[0].resource.typeName).toBe("K8s::Argo::Application");
   });
 
+  test("all Flux toolkit + operator groups collapse to the Flux namespace", () => {
+    const cases: Array<[string, string]> = [
+      ["source.toolkit.fluxcd.io", "GitRepository"],
+      ["kustomize.toolkit.fluxcd.io", "Kustomization"],
+      ["helm.toolkit.fluxcd.io", "HelmRelease"],
+      ["notification.toolkit.fluxcd.io", "Alert"],
+      ["image.toolkit.fluxcd.io", "ImagePolicy"],
+      ["fluxcd.controlplane.io", "FluxInstance"],
+    ];
+    for (const [group, kind] of cases) {
+      const results = parseCRDSpec({
+        group,
+        names: { kind, plural: `${kind.toLowerCase()}s` },
+        scope: "Namespaced" as const,
+        versions: [{ name: "v1", served: true, storage: true }],
+      });
+      expect(results[0].resource.typeName).toBe(`K8s::Flux::${kind}`);
+    }
+  });
+
   test("dedupes property-type names when a scalar and array sibling collide", () => {
     // Argo Application has both `source` (object) and `sources` (array of the
     // same shape); singularizing `sources` → `Source` would collide.

package/src/crd/parser.ts

@@ -16,9 +16,22 @@ import { loadAll } from "js-yaml";
  * Group names whose first segment doesn't yield the conventional namespace.
  * "argoproj.io" → "Argo" (not "Argoproj") to match the Argo CD vocabulary
  * and the ArgoAppFor / ArgoAppSetForRegions composites.
+ *
+ * The Flux toolkit spreads across five `*.toolkit.fluxcd.io` groups plus the
+ * Flux Operator's `fluxcd.controlplane.io`; all six collapse to a single `Flux`
+ * namespace so a GitRepository and a Kustomization read as `K8s::Flux::*`
+ * siblings rather than scattering to Source / Kustomize / Helm / Notification /
+ * Image / Fluxcd. (`helm.toolkit.fluxcd.io` → `Helm` would also collide
+ * confusingly with the separate helm lexicon.)
  */
 const GROUP_NAMESPACE_OVERRIDES: Record<string, string> = {
   "argoproj.io": "Argo",
+  "source.toolkit.fluxcd.io": "Flux",
+  "kustomize.toolkit.fluxcd.io": "Flux",
+  "helm.toolkit.fluxcd.io": "Flux",
+  "notification.toolkit.fluxcd.io": "Flux",
+  "image.toolkit.fluxcd.io": "Flux",
+  "fluxcd.controlplane.io": "Flux",
 };
 
 /**

package/src/crd/types.ts

@@ -19,6 +19,13 @@ export interface CRDSource {
   context?: string;
   /** Namespace to scope the CRD lookup for type="cluster" */
   namespace?: string;
+  /**
+   * Optional allowlist of CRD `kind` names to keep from this source. When a
+   * source is a multi-doc install bundle (as with Flux, whose release
+   * `install.yaml` also carries out-of-scope CRDs), this restricts codegen to
+   * the intended kinds. Omit to generate every CRD the source contains.
+   */
+  kinds?: string[];
 }
 
 /**