@intentius/chant-lexicon-k8s 0.0.12

package/src/codegen/generate-cli.ts

@@ -0,0 +1,41 @@
+#!/usr/bin/env bun
+/**
+ * CLI entry point for Kubernetes lexicon generation.
+ */
+
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { generate, writeGeneratedFiles } from "./generate";
+import { K8S_SCHEMA_VERSION } from "../spec/fetch";
+
+const pkgDir = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+
+async function main() {
+  const verbose = process.argv.includes("--verbose") || process.argv.includes("-v");
+  const force = process.argv.includes("--force") || process.argv.includes("-f");
+
+  // Parse --schema-version <ref>
+  const versionIdx = process.argv.indexOf("--schema-version");
+  const schemaVersion = versionIdx !== -1 ? process.argv[versionIdx + 1] : undefined;
+
+  console.error(`Generating Kubernetes lexicon (schema: ${schemaVersion ?? K8S_SCHEMA_VERSION})...`);
+
+  const result = await generate({ verbose, force, schemaVersion });
+  writeGeneratedFiles(result, pkgDir);
+
+  console.error(
+    `Generated ${result.resources} resources, ${result.properties} property types, ${result.enums} enums`,
+  );
+
+  if (result.warnings.length > 0) {
+    console.error(`${result.warnings.length} warnings:`);
+    for (const w of result.warnings) {
+      console.error(`  ${w.file}: ${w.error}`);
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error("Generation failed:", err);
+  process.exit(1);
+});

package/src/codegen/generate-lexicon.ts

@@ -0,0 +1,69 @@
+/**
+ * Lexicon JSON generator — produces lexicon-k8s.json with metadata
+ * for all Kubernetes resource and property types.
+ */
+
+import type { PropertyConstraints } from "@intentius/chant/codegen/json-schema";
+import type { K8sParseResult } from "../spec/parse";
+import { k8sShortName, gvkToApiVersion } from "../spec/parse";
+import type { NamingStrategy } from "./naming";
+import {
+  buildRegistry,
+  serializeRegistry,
+  type RegistryResource,
+} from "@intentius/chant/codegen/generate-registry";
+
+export interface K8sLexiconEntry {
+  resourceType: string;
+  kind: "resource" | "property";
+  lexicon: "k8s";
+  apiVersion?: string;
+  gvkKind?: string;
+  deprecatedProperties?: string[];
+  constraints?: Record<string, PropertyConstraints>;
+}
+
+/**
+ * Generate the lexicon-k8s.json content.
+ */
+export function generateLexiconJSON(
+  results: K8sParseResult[],
+  naming: NamingStrategy,
+): string {
+  const registryResources: RegistryResource[] = results.map((r) => ({
+    typeName: r.resource.typeName,
+    attributes: r.resource.attributes,
+    properties: r.resource.properties,
+    propertyTypes: r.propertyTypes.map((pt) => ({ name: pt.name, specType: pt.defType })),
+  }));
+
+  const entries = buildRegistry<K8sLexiconEntry>(registryResources, naming, {
+    shortName: k8sShortName,
+    buildEntry: (resource, _tsName, _attrs, propConstraints) => {
+      const r = results.find((res) => res.resource.typeName === resource.typeName);
+      const entry: K8sLexiconEntry = {
+        resourceType: resource.typeName,
+        kind: (r?.isProperty ? "property" : "resource") as "resource" | "property",
+        lexicon: "k8s" as const,
+      };
+      if (r && !r.isProperty) {
+        entry.apiVersion = gvkToApiVersion(r.gvk);
+        entry.gvkKind = r.gvk.kind;
+      }
+      if (r?.resource.deprecatedProperties?.length) {
+        entry.deprecatedProperties = r.resource.deprecatedProperties;
+      }
+      if (propConstraints && Object.keys(propConstraints).length > 0) {
+        entry.constraints = propConstraints;
+      }
+      return entry;
+    },
+    buildPropertyEntry: (resourceType, propertyType) => ({
+      resourceType: `${resourceType}.${propertyType}`,
+      kind: "property" as const,
+      lexicon: "k8s" as const,
+    }),
+  });
+
+  return serializeRegistry(entries);
+}

package/src/codegen/generate-typescript.ts

@@ -0,0 +1,97 @@
+/**
+ * TypeScript declaration file generator — produces index.d.ts with all
+ * Kubernetes resource and property type classes.
+ */
+
+import type { K8sParseResult } from "../spec/parse";
+import { k8sShortName } from "../spec/parse";
+import type { NamingStrategy } from "./naming";
+import { propertyTypeName, extractDefName } from "./naming";
+import {
+  writeResourceClass,
+  writePropertyClass,
+  writeEnumType,
+  type DtsProperty,
+  type DtsAttribute,
+} from "@intentius/chant/codegen/generate-typescript";
+
+interface ResourceEntry {
+  tsName: string;
+  isProperty: boolean;
+  properties: DtsProperty[];
+  attributes: DtsAttribute[];
+  remap: Map<string, string>;
+}
+
+/**
+ * Generate the complete .d.ts file content.
+ */
+export function generateTypeScriptDeclarations(
+  results: K8sParseResult[],
+  naming: NamingStrategy,
+): string {
+  const lines: string[] = [];
+  lines.push("// Code generated by chant k8s generate. DO NOT EDIT.");
+
+  const resources: ResourceEntry[] = [];
+
+  for (const r of results) {
+    const typeName = r.resource.typeName;
+    const tsName = naming.resolve(typeName);
+    if (!tsName) continue;
+
+    const shortName = k8sShortName(typeName);
+    const remap = new Map<string, string>();
+    for (const pt of r.propertyTypes) {
+      const defName = extractDefName(pt.name, shortName);
+      remap.set(pt.name, propertyTypeName(tsName, defName));
+    }
+    for (const e of r.enums) {
+      const defName = extractDefName(e.name, shortName);
+      remap.set(e.name, propertyTypeName(tsName, defName));
+    }
+
+    const dtsProps: DtsProperty[] = r.resource.properties.map((p) => ({
+      name: p.name,
+      type: p.tsType,
+      required: p.required,
+      description: p.description,
+    }));
+    const dtsAttrs: DtsAttribute[] = r.resource.attributes.map((a) => ({
+      name: a.name,
+      type: a.tsType,
+    }));
+
+    resources.push({ tsName, isProperty: !!r.isProperty, properties: dtsProps, attributes: dtsAttrs, remap });
+
+    for (const alias of naming.aliases(typeName)) {
+      resources.push({ tsName: alias, isProperty: !!r.isProperty, properties: dtsProps, attributes: dtsAttrs, remap });
+    }
+  }
+
+  // Sort alphabetically
+  resources.sort((a, b) => a.tsName.localeCompare(b.tsName));
+
+  // Resource classes
+  const resourceEntries = resources.filter((r) => !r.isProperty);
+  const propertyEntries = resources.filter((r) => r.isProperty);
+
+  if (resourceEntries.length > 0) {
+    lines.push("");
+    lines.push("// --- Kubernetes Resource classes ---");
+    for (const re of resourceEntries) {
+      writeResourceClass(lines, re.tsName, re.properties, re.attributes, re.remap);
+    }
+  }
+
+  if (propertyEntries.length > 0) {
+    lines.push("");
+    lines.push("// --- Property type classes ---");
+    for (const pe of propertyEntries) {
+      writePropertyClass(lines, pe.tsName, pe.properties, pe.remap);
+    }
+  }
+
+  lines.push("");
+  return lines.join("\n");
+}

package/src/codegen/generate.ts

@@ -0,0 +1,144 @@
+/**
+ * Kubernetes generation pipeline — uses core generatePipeline
+ * with K8s-specific fetch, parse, naming, and generation callbacks.
+ */
+
+import { join } from "path";
+import {
+  generatePipeline,
+  writeGeneratedArtifacts,
+  type GenerateOptions,
+  type GenerateResult,
+  type GeneratePipelineConfig,
+} from "@intentius/chant/codegen/generate";
+import { fetchSchemas } from "../spec/fetch";
+import { parseK8sSwagger, k8sShortName, type K8sParseResult } from "../spec/parse";
+import { NamingStrategy, propertyTypeName, extractDefName } from "./naming";
+import { generateLexiconJSON } from "./generate-lexicon";
+import { generateTypeScriptDeclarations } from "./generate-typescript";
+import {
+  generateRuntimeIndex as coreGenerateRuntimeIndex,
+  type RuntimeIndexEntry,
+  type RuntimeIndexPropertyEntry,
+} from "@intentius/chant/codegen/generate-runtime-index";
+
+export type { GenerateResult };
+
+export interface K8sGenerateOptions extends GenerateOptions {
+  /** Kubernetes version tag to fetch the schema from. */
+  schemaVersion?: string;
+}
+
+/**
+ * Run the full Kubernetes generation pipeline.
+ */
+export async function generate(opts: K8sGenerateOptions = {}): Promise<GenerateResult> {
+  // Pipeline state captured in closure — no module-level mutation
+  let pendingResults: K8sParseResult[] = [];
+
+  const config: GeneratePipelineConfig<K8sParseResult> = {
+    fetchSchemas: async (fetchOpts) => {
+      return fetchSchemas(fetchOpts.force, opts.schemaVersion);
+    },
+
+    parseSchema: (_typeName, data) => {
+      // The K8s schema is a single document — parseK8sSwagger returns multiple results.
+      // The pipeline calls this once per schema entry. We return the first result
+      // and use augmentResults to inject the rest.
+      const results = parseK8sSwagger(data);
+      if (results.length === 0) return null;
+      // Return the first result; stash the rest for augmentResults
+      pendingResults = results.slice(1);
+      return results[0];
+    },
+
+    createNaming: (results) => new NamingStrategy(results),
+
+    augmentResults: (results, _opts, log) => {
+      // Add the remaining results from the single-schema parse
+      if (pendingResults.length > 0) {
+        results.push(...pendingResults);
+        log(`Added ${pendingResults.length} additional K8s resources from OpenAPI spec`);
+        pendingResults = [];
+      }
+      log(`Total: ${results.length} K8s resource/property schemas`);
+      return { results };
+    },
+
+    generateRegistry: (results, naming) => {
+      return generateLexiconJSON(results, naming as NamingStrategy);
+    },
+
+    generateTypes: (results, naming) => {
+      return generateTypeScriptDeclarations(results, naming as NamingStrategy);
+    },
+
+    generateRuntimeIndex: (results, naming) => {
+      return generateRuntimeIndex(results, naming as NamingStrategy);
+    },
+  };
+
+  return generatePipeline(config, opts);
+}
+
+/**
+ * Write generated artifacts to disk.
+ */
+export function writeGeneratedFiles(result: GenerateResult, baseDir: string): void {
+  writeGeneratedArtifacts({
+    baseDir,
+    files: {
+      "lexicon-k8s.json": result.lexiconJSON,
+      "index.d.ts": result.typesDTS,
+      "index.ts": result.indexTS,
+      "runtime.ts": `/**\n * Runtime factory constructors — re-exported from core.\n */\nexport { createResource, createProperty } from "@intentius/chant/runtime";\n`,
+    },
+  });
+}
+
+/**
+ * Generate the runtime index.ts with factory constructor exports.
+ */
+function generateRuntimeIndex(
+  results: K8sParseResult[],
+  naming: NamingStrategy,
+): string {
+  const resourceEntries: RuntimeIndexEntry[] = [];
+  const propertyEntries: RuntimeIndexPropertyEntry[] = [];
+
+  for (const r of results) {
+    const typeName = r.resource.typeName;
+    const tsName = naming.resolve(typeName);
+    if (!tsName) continue;
+
+    const attrs: Record<string, string> = {};
+    for (const attr of r.resource.attributes) {
+      attrs[attr.name] = attr.name;
+    }
+
+    if (r.isProperty) {
+      propertyEntries.push({ tsName, resourceType: typeName });
+      for (const alias of naming.aliases(typeName)) {
+        propertyEntries.push({ tsName: alias, resourceType: typeName });
+      }
+    } else {
+      resourceEntries.push({ tsName, resourceType: typeName, attrs });
+      for (const alias of naming.aliases(typeName)) {
+        resourceEntries.push({ tsName: alias, resourceType: typeName, attrs });
+      }
+    }
+
+    // Nested property types
+    const shortName = k8sShortName(typeName);
+    for (const pt of r.propertyTypes) {
+      const defName = extractDefName(pt.name, shortName);
+      const ptName = propertyTypeName(tsName, defName);
+      const ptType = `${typeName}.${pt.defType}`;
+      propertyEntries.push({ tsName: ptName, resourceType: ptType });
+    }
+  }
+
+  return coreGenerateRuntimeIndex(resourceEntries, propertyEntries, {
+    lexiconName: "k8s",
+  });
+}

package/src/codegen/naming.test.ts

@@ -0,0 +1,63 @@
+import { describe, test, expect } from "bun:test";
+import { k8sShortName, type K8sParseResult } from "../spec/parse";
+import { NamingStrategy } from "./naming";
+
+/**
+ * Chant's naming philosophy: 1:1 with the K8s spec.
+ * Every priorityName must match the spec Kind exactly.
+ *
+ * This test guards against interpreted/abbreviated names creeping in
+ * (e.g. "RBACSubject" instead of "Subject", "HPABehavior" instead of
+ * "HorizontalPodAutoscalerBehavior").
+ */
+
+/** Build a minimal K8sParseResult for a given typeName. */
+function stubResult(typeName: string): K8sParseResult {
+  return {
+    resource: {
+      typeName,
+      properties: [],
+      attributes: [],
+      apiVersion: "v1",
+      kind: k8sShortName(typeName),
+    },
+    propertyTypes: [],
+    enums: [],
+  };
+}
+
+describe("naming spec fidelity", () => {
+  const typeNames = [
+    "K8s::Rbac::Subject",
+    "K8s::Autoscaling::HorizontalPodAutoscalerBehavior",
+    "K8s::Batch::Job",
+    "K8s::Core::Pod",
+    "K8s::Apps::Deployment",
+    "K8s::Core::Container",
+    "K8s::Networking::Ingress",
+    "K8s::Rbac::PolicyRule",
+    "K8s::Rbac::RoleRef",
+  ];
+
+  const results = typeNames.map(stubResult);
+  const strategy = new NamingStrategy(results);
+
+  test("all priority names match spec Kind (short name)", () => {
+    for (const typeName of typeNames) {
+      const resolved = strategy.resolve(typeName);
+      const specKind = k8sShortName(typeName);
+      expect(resolved).toBe(specKind);
+    }
+  });
+
+  test("no priority name uses abbreviated prefixes", () => {
+    const badPrefixes = ["K8s", "RBAC", "HPA"];
+
+    for (const typeName of typeNames) {
+      const resolved = strategy.resolve(typeName)!;
+      for (const prefix of badPrefixes) {
+        expect(resolved.startsWith(prefix)).toBe(false);
+      }
+    }
+  });
+});

package/src/codegen/naming.ts

@@ -0,0 +1,187 @@
+/**
+ * Kubernetes naming strategy — maps K8s::{Group}::{Kind} type names
+ * to user-friendly TypeScript class names.
+ */
+
+import {
+  NamingStrategy as CoreNamingStrategy,
+  type NamingConfig,
+  type NamingInput,
+} from "@intentius/chant/codegen/naming";
+import { k8sShortName, k8sServiceName, type K8sParseResult } from "../spec/parse";
+
+export { propertyTypeName, extractDefName } from "@intentius/chant/codegen/naming";
+
+const k8sNamingConfig: NamingConfig = {
+  priorityNames: {
+    // Core
+    "K8s::Core::Pod": "Pod",
+    "K8s::Core::Service": "Service",
+    "K8s::Core::ConfigMap": "ConfigMap",
+    "K8s::Core::Secret": "Secret",
+    "K8s::Core::Namespace": "Namespace",
+    "K8s::Core::ServiceAccount": "ServiceAccount",
+    "K8s::Core::PersistentVolume": "PersistentVolume",
+    "K8s::Core::PersistentVolumeClaim": "PersistentVolumeClaim",
+    "K8s::Core::Node": "Node",
+    "K8s::Core::Endpoints": "Endpoints",
+    "K8s::Core::ResourceQuota": "ResourceQuota",
+    "K8s::Core::LimitRange": "LimitRange",
+    "K8s::Core::ReplicationController": "ReplicationController",
+
+    // Apps
+    "K8s::Apps::Deployment": "Deployment",
+    "K8s::Apps::StatefulSet": "StatefulSet",
+    "K8s::Apps::DaemonSet": "DaemonSet",
+    "K8s::Apps::ReplicaSet": "ReplicaSet",
+    "K8s::Apps::ControllerRevision": "ControllerRevision",
+
+    // Batch
+    "K8s::Batch::Job": "Job",
+    "K8s::Batch::CronJob": "CronJob",
+
+    // Networking
+    "K8s::Networking::Ingress": "Ingress",
+    "K8s::Networking::IngressClass": "IngressClass",
+    "K8s::Networking::NetworkPolicy": "NetworkPolicy",
+
+    // RBAC
+    "K8s::Rbac::Role": "Role",
+    "K8s::Rbac::ClusterRole": "ClusterRole",
+    "K8s::Rbac::RoleBinding": "RoleBinding",
+    "K8s::Rbac::ClusterRoleBinding": "ClusterRoleBinding",
+
+    // Autoscaling
+    "K8s::Autoscaling::HorizontalPodAutoscaler": "HorizontalPodAutoscaler",
+
+    // Policy
+    "K8s::Policy::PodDisruptionBudget": "PodDisruptionBudget",
+
+    // Storage
+    "K8s::Storage::StorageClass": "StorageClass",
+    "K8s::Storage::CSIDriver": "CSIDriver",
+
+    // Scheduling
+    "K8s::Scheduling::PriorityClass": "PriorityClass",
+
+    // Coordination
+    "K8s::Coordination::Lease": "Lease",
+
+    // Discovery
+    "K8s::Discovery::EndpointSlice": "EndpointSlice",
+
+    // Certificates
+    "K8s::Certificates::CertificateSigningRequest": "CertificateSigningRequest",
+
+    // Admission
+    "K8s::Admissionregistration::ValidatingWebhookConfiguration": "ValidatingWebhookConfiguration",
+    "K8s::Admissionregistration::MutatingWebhookConfiguration": "MutatingWebhookConfiguration",
+
+    // Events (core vs events.k8s.io — the core version wins)
+    "K8s::Core::Event": "Event",
+
+    // Property types
+    "K8s::Core::Container": "Container",
+    "K8s::Core::ContainerPort": "ContainerPort",
+    "K8s::Core::EnvVar": "EnvVar",
+    "K8s::Core::EnvFromSource": "EnvFromSource",
+    "K8s::Core::Volume": "Volume",
+    "K8s::Core::VolumeMount": "VolumeMount",
+    "K8s::Core::PodSpec": "PodSpec",
+    "K8s::Core::PodTemplateSpec": "PodTemplateSpec",
+    "K8s::Core::ServicePort": "ServicePort",
+    "K8s::Core::Probe": "Probe",
+    "K8s::Core::ResourceRequirements": "ResourceRequirements",
+    "K8s::Core::SecurityContext": "SecurityContext",
+    "K8s::Core::PodSecurityContext": "PodSecurityContext",
+    "K8s::Core::Capabilities": "Capabilities",
+    "K8s::Core::ConfigMapKeySelector": "ConfigMapKeySelector",
+    "K8s::Core::SecretKeySelector": "SecretKeySelector",
+    "K8s::Core::EnvVarSource": "EnvVarSource",
+    "K8s::Core::ObjectReference": "ObjectReference",
+    "K8s::Core::LocalObjectReference": "LocalObjectReference",
+    "K8s::Core::Toleration": "Toleration",
+    "K8s::Core::Affinity": "Affinity",
+    "K8s::Core::TopologySpreadConstraint": "TopologySpreadConstraint",
+    "K8s::Core::PersistentVolumeClaimSpec": "PersistentVolumeClaimSpec",
+    "K8s::Core::HTTPGetAction": "HTTPGetAction",
+    "K8s::Core::TCPSocketAction": "TCPSocketAction",
+    "K8s::Core::ExecAction": "ExecAction",
+    "K8s::Core::HostAlias": "HostAlias",
+    "K8s::Core::EphemeralContainer": "EphemeralContainer",
+    "K8s::Core::KeyToPath": "KeyToPath",
+    "K8s::Apps::DeploymentStrategy": "DeploymentStrategy",
+    "K8s::Apps::RollingUpdateDeployment": "RollingUpdateDeployment",
+    "K8s::Networking::IngressRule": "IngressRule",
+    "K8s::Networking::IngressTLS": "IngressTLS",
+    "K8s::Networking::HTTPIngressPath": "HTTPIngressPath",
+    "K8s::Networking::IngressBackend": "IngressBackend",
+    "K8s::Networking::IngressServiceBackend": "IngressServiceBackend",
+    "K8s::Networking::ServiceBackendPort": "ServiceBackendPort",
+    "K8s::Networking::NetworkPolicyIngressRule": "NetworkPolicyIngressRule",
+    "K8s::Networking::NetworkPolicyEgressRule": "NetworkPolicyEgressRule",
+    "K8s::Networking::NetworkPolicyPeer": "NetworkPolicyPeer",
+    "K8s::Networking::NetworkPolicyPort": "NetworkPolicyPort",
+    "K8s::Rbac::PolicyRule": "PolicyRule",
+    "K8s::Rbac::RoleRef": "RoleRef",
+    "K8s::Rbac::Subject": "Subject",
+    "K8s::Autoscaling::MetricSpec": "MetricSpec",
+    "K8s::Autoscaling::HorizontalPodAutoscalerBehavior": "HorizontalPodAutoscalerBehavior",
+    "K8s::Policy::PodDisruptionBudgetSpec": "PodDisruptionBudgetSpec",
+    "K8s::Meta::ObjectMeta": "ObjectMeta",
+    "K8s::Meta::LabelSelector": "LabelSelector",
+    "K8s::Meta::LabelSelectorRequirement": "LabelSelectorRequirement",
+  },
+
+  priorityAliases: {
+    "K8s::Batch::Job": ["BatchJob"],
+    "K8s::Apps::Deployment": ["Deploy"],
+    "K8s::Core::ConfigMap": ["CM"],
+    "K8s::Core::ServiceAccount": ["SA"],
+    "K8s::Autoscaling::HorizontalPodAutoscaler": ["HPA"],
+    "K8s::Core::PersistentVolumeClaim": ["PVC"],
+    "K8s::Core::PersistentVolume": ["PV"],
+    "K8s::Policy::PodDisruptionBudget": ["PDB"],
+    "K8s::Core::Namespace": ["NS"],
+    "K8s::Apps::StatefulSet": ["STS"],
+    "K8s::Apps::DaemonSet": ["DS"],
+    "K8s::Core::Secret": ["Sec"],
+    "K8s::Networking::Ingress": ["Ing"],
+    "K8s::Networking::NetworkPolicy": ["NetPol"],
+  },
+
+  priorityPropertyAliases: {},
+
+  serviceAbbreviations: {
+    Core: "Core",
+    Apps: "Apps",
+    Batch: "Batch",
+    Networking: "Net",
+    Rbac: "Rbac",
+    Autoscaling: "AS",
+    Policy: "Pol",
+    Storage: "Stor",
+    Scheduling: "Sched",
+    Coordination: "Coord",
+    Discovery: "Disc",
+    Certificates: "Cert",
+    Admissionregistration: "Adm",
+  },
+
+  shortName: k8sShortName,
+  serviceName: k8sServiceName,
+};
+
+/**
+ * Kubernetes-specific naming strategy.
+ * Extends core NamingStrategy with K8s naming config.
+ */
+export class NamingStrategy extends CoreNamingStrategy {
+  constructor(results: K8sParseResult[]) {
+    const inputs: NamingInput[] = results.map((r) => ({
+      typeName: r.resource.typeName,
+      propertyTypes: r.propertyTypes,
+    }));
+    super(inputs, k8sNamingConfig);
+  }
+}

package/src/codegen/package.ts

@@ -0,0 +1,56 @@
+/**
+ * Kubernetes lexicon packaging — delegates to core packagePipeline
+ * with K8s-specific manifest building and skill collection.
+ */
+
+import { createRequire } from "module";
+import { readFileSync } from "fs";
+const require = createRequire(import.meta.url);
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import {
+  packagePipeline,
+  collectSkills,
+  type PackageOptions,
+  type PackageResult,
+} from "@intentius/chant/codegen/package";
+import { generate } from "./generate";
+
+export type { PackageOptions, PackageResult };
+
+const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
+
+/**
+ * Package the Kubernetes lexicon into a distributable BundleSpec.
+ */
+export async function packageLexicon(opts: PackageOptions = {}): Promise<PackageResult> {
+  const pkgJson = JSON.parse(readFileSync(join(pkgDir, "..", "package.json"), "utf-8"));
+
+  return packagePipeline(
+    {
+      generate: (genOpts) => generate({ verbose: genOpts.verbose, force: genOpts.force }),
+
+      buildManifest: (_genResult) => {
+        return {
+          name: "k8s",
+          version: pkgJson.version ?? "0.0.0",
+          chantVersion: ">=0.1.0",
+          namespace: "K8s",
+          intrinsics: [],
+          pseudoParameters: {},
+        };
+      },
+
+      srcDir: pkgDir,
+
+      collectSkills: () => {
+        const { k8sPlugin } = require("../plugin");
+        const skillDefs = k8sPlugin.skills?.() ?? [];
+        return collectSkills(skillDefs);
+      },
+
+      version: pkgJson.version ?? "0.0.0",
+    },
+    opts,
+  );
+}