@intentius/chant-lexicon-k8s 0.1.8 → 0.1.9

package/dist/integrity.json

@@ -1,7 +1,7 @@
 {
   "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "26168ff9d5f4d906e451b0e2c9e7a868b9ae3ab366579d9abf76a45ace9a3b95",
+    "manifest.json": "3b5e686ba2f5230ae91d763af4ce3eacde217b82c51db5063ae79415383ce2bc",
     "meta.json": "970c70eb6eea1686f7cb8ce6ceccc46ce2e57d696d344f1dd52460e266f9a56c",
     "types/index.d.ts": "07473e029254345488bc9952585e88bcf18da79d1026cc26744027683f472554",
     "rules/hardcoded-namespace.ts": "ba3f43f2adbffdd87db20a2c45839354ceecda1b9f04f29ae31c4c077dddc7ec",
@@ -42,5 +42,5 @@
     "skills/chant-k8s-gke.md": "8938840bf9ef5ed58d6333fdd773b3dd54ecaf25a9df35e58f7f5c3355d4928f",
     "skills/chant-k8s-aks.md": "e18f0e2b055f72cd7a37deaf258d7027c2d4d3e286e8fd4975b27a1f981a3ad9"
   },
-  "composite": "de04872487ff8b14bc40143791702adeea08ff52942eca65e90e6611623ed767"
+  "composite": "1cf502ba76b37beb544a97555310f41a48fc251e44330f3ac67faebeee530e2f"
 }

package/dist/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "k8s",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "chantVersion": ">=0.1.0",
   "namespace": "K8s",
   "intrinsics": [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-k8s",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Kubernetes lexicon for chant — declarative IaC in TypeScript",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",
@@ -43,11 +43,11 @@
     "prepack": "npm run generate && npm run bundle && npm run validate"
   },
   "dependencies": {
-    "js-yaml": "^4.1.1"
+    "js-yaml": "^4.1.1",
+    "@types/js-yaml": "^4.0.9"
   },
   "devDependencies": {
     "@intentius/chant": "*",
-    "@types/js-yaml": "^4.0.9",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {

package/src/index.ts

@@ -11,6 +11,9 @@ export { DEFAULT_LABELS_MARKER, DEFAULT_ANNOTATIONS_MARKER } from "./default-lab
 // Variables / label constants
 export { K8sLabels, K8sAnnotations } from "./variables";
 
+// MicroTime helpers — see micro-time.ts for why this exists.
+export { microTime, isMicroTimeFormatted } from "./micro-time";
+
 // Generated entities — export everything from generated index
 // After running `chant generate`, this re-exports all K8s resource classes
 export * from "./generated/index";

package/src/micro-time.test.ts

@@ -0,0 +1,48 @@
+import { describe, test, expect } from "vitest";
+import { microTime, isMicroTimeFormatted } from "./micro-time";
+
+describe("microTime", () => {
+  test("formats a Date with 6 fractional digits + Z", () => {
+    const d = new Date("2026-05-11T21:25:36.495Z");
+    expect(microTime(d)).toBe("2026-05-11T21:25:36.495000Z");
+  });
+
+  test("handles dates whose ms is zero", () => {
+    const d = new Date("2026-01-01T00:00:00.000Z");
+    expect(microTime(d)).toBe("2026-01-01T00:00:00.000000Z");
+  });
+
+  test("defaults to current time when called with no args", () => {
+    const out = microTime();
+    expect(out).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}Z$/);
+  });
+
+  test("output is accepted by isMicroTimeFormatted()", () => {
+    expect(isMicroTimeFormatted(microTime(new Date()))).toBe(true);
+  });
+});
+
+describe("isMicroTimeFormatted", () => {
+  test("accepts canonical MicroTime strings", () => {
+    expect(isMicroTimeFormatted("2026-05-11T21:25:36.495000Z")).toBe(true);
+    expect(isMicroTimeFormatted("2026-05-11T21:25:36.000000Z")).toBe(true);
+  });
+
+  test("rejects nanosecond precision (the bug this helper avoids)", () => {
+    // time.RFC3339Nano in Go: 9 fractional digits
+    expect(isMicroTimeFormatted("2026-05-11T21:25:36.495095754Z")).toBe(false);
+  });
+
+  test("rejects millisecond precision (Date.toISOString() shape)", () => {
+    expect(isMicroTimeFormatted("2026-05-11T21:25:36.495Z")).toBe(false);
+  });
+
+  test("rejects non-UTC offset", () => {
+    expect(isMicroTimeFormatted("2026-05-11T21:25:36.495000-05:00")).toBe(false);
+  });
+
+  test("rejects garbage", () => {
+    expect(isMicroTimeFormatted("yesterday")).toBe(false);
+    expect(isMicroTimeFormatted("")).toBe(false);
+  });
+});

package/src/micro-time.ts

@@ -0,0 +1,51 @@
+/**
+ * Helpers for K8s `MicroTime` fields.
+ *
+ * The K8s API server validates fields like `coordination.k8s.io/v1.Lease.spec.renewTime`
+ * (kind: MicroTime) with the exact format `2006-01-02T15:04:05.000000Z07:00`
+ * — microsecond precision, always 6 fractional digits, UTC offset.
+ *
+ * The naive JS `Date.toISOString()` (millisecond precision, 3 fractional
+ * digits) is accepted by the API server too — the schema is more permissive
+ * than the documented format string — but `time.RFC3339Nano`-style strings
+ * with nanosecond precision (9 fractional digits) are rejected as
+ * `422 Unprocessable Entity` with:
+ *
+ *   parsing time "...754Z" as "2006-01-02T15:04:05.000000Z07:00":
+ *     cannot parse "754Z" as "Z07:00"
+ *
+ * Pass a JS Date through `microTime()` to get a string the API server
+ * always accepts. This is the canonical way to populate MicroTime fields
+ * when authoring chant resources by hand.
+ */
+
+/**
+ * Format a Date as a K8s MicroTime string (UTC, exactly 6 fractional digits).
+ *
+ * @example
+ *   import { Lease } from "@intentius/chant-lexicon-k8s";
+ *   import { microTime } from "@intentius/chant-lexicon-k8s/micro-time";
+ *
+ *   new Lease({
+ *     metadata: { name: "my-lease", namespace: "default" },
+ *     spec: {
+ *       holderIdentity: "node-1",
+ *       leaseDurationSeconds: 15,
+ *       renewTime: microTime(new Date()),
+ *     },
+ *   });
+ */
+export function microTime(date: Date = new Date()): string {
+  const iso = date.toISOString(); // "2026-05-11T21:25:36.495Z" (3 digits)
+  // Replace the millisecond fragment with a 6-digit microsecond fragment.
+  // toISOString() always produces ms precision; pad to 6 by appending 3 zeros.
+  return iso.replace(/\.(\d{3})Z$/, ".$1000Z");
+}
+
+/**
+ * Returns true if `value` is a string in the K8s MicroTime canonical format
+ * (UTC, microsecond precision). Useful in lint/validation contexts.
+ */
+export function isMicroTimeFormatted(value: string): boolean {
+  return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}Z$/.test(value);
+}

package/src/plugin.ts

@@ -273,96 +273,6 @@ export const service = new Service({
     console.error(`Packaged ${stats.resources} resources, ${stats.ruleCount} rules, ${stats.skillCount} skills`);
   },
 
-  async describeResources(options: {
-    environment: string;
-    buildOutput: string;
-    entityNames: string[];
-  }): Promise<Record<string, ResourceMetadata>> {
-    const { getRuntime } = await import("@intentius/chant/runtime-adapter");
-    const rt = getRuntime();
-    const resources: Record<string, ResourceMetadata> = {};
-
-    // Resolve namespace from environment (convention: env name = namespace)
-    const namespace = options.environment;
-
-    // Parse build output to extract kind/name pairs for each entity
-    let manifests: Array<{ kind: string; metadata: { name: string; namespace?: string }; apiVersion: string }> = [];
-    try {
-      // K8s build output is YAML with --- separators
-      const docs = options.buildOutput.split(/^---$/m).filter((d) => d.trim());
-      for (const doc of docs) {
-        // Simple YAML parsing — look for kind: and metadata.name:
-        const kindMatch = doc.match(/^kind:\s*(.+)$/m);
-        const nameMatch = doc.match(/^\s+name:\s*(.+)$/m);
-        const apiVersionMatch = doc.match(/^apiVersion:\s*(.+)$/m);
-        if (kindMatch && nameMatch && apiVersionMatch) {
-          manifests.push({
-            kind: kindMatch[1].trim(),
-            metadata: { name: nameMatch[1].trim() },
-            apiVersion: apiVersionMatch[1].trim(),
-          });
-        }
-      }
-    } catch {
-      // If build output parsing fails, skip
-    }
-
-    // Query each resource
-    for (const entityName of options.entityNames) {
-      // Find the corresponding manifest
-      const manifest = manifests.find((m) => {
-        // Try matching by entity name convention
-        return m.metadata.name === entityName ||
-          entityName.toLowerCase().includes(m.metadata.name.toLowerCase());
-      });
-
-      if (!manifest) continue;
-
-      // Build kubectl resource type from apiVersion + kind
-      const resourceType = manifest.kind.toLowerCase();
-      const getResult = await rt.spawn([
-        "kubectl", "get", resourceType, manifest.metadata.name,
-        "-n", namespace,
-        "-o", "json",
-      ]);
-
-      if (getResult.exitCode !== 0) continue;
-
-      try {
-        const obj = JSON.parse(getResult.stdout) as {
-          metadata: { name: string; uid: string; creationTimestamp: string };
-          status?: { phase?: string; conditions?: Array<{ type: string; status: string }> };
-        };
-
-        // Derive status from conditions or phase
-        let status = "Unknown";
-        if (obj.status?.phase) {
-          status = obj.status.phase;
-        } else if (obj.status?.conditions) {
-          const ready = obj.status.conditions.find((c) => c.type === "Ready" || c.type === "Available");
-          status = ready?.status === "True" ? "Ready" : "NotReady";
-        }
-
-        // Build attributes, scrubbing sensitive data
-        const attributes: Record<string, unknown> = {
-          uid: obj.metadata.uid,
-        };
-
-        resources[entityName] = {
-          type: `${manifest.apiVersion}/${manifest.kind}`,
-          physicalId: obj.metadata.name,
-          status,
-          lastUpdated: obj.metadata.creationTimestamp,
-          attributes,
-        };
-      } catch {
-        // Skip parse failures
-      }
-    }
-
-    return resources;
-  },
-
   mcpTools() {
     return [createDiffTool(k8sSerializer, "Compare current build output against previous output for Kubernetes manifests", "k8s")];
   },