@intentius/chant-lexicon-gcp 0.1.8 → 0.1.10

package/dist/integrity.json

@@ -1,7 +1,7 @@
 {
   "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "31ad54417045b2707c880b9b6176dd0aa8a5feeb1dfbc645f9d1a20707c525f5",
+    "manifest.json": "11955fe00ec8df4b79f7b69dfb982bc45413f927c4ccd7d70ece434adffe18c9",
     "meta.json": "2bc3713e9e01e90832d18dedaf4bf544dd4d8fe32f1363f7e95dc711d3d76e9d",
     "types/index.d.ts": "0554f7e883c6216ba735cbe79a8534ccad762bea28cc4d4c4884f8760a2f1dd3",
     "rules/hardcoded-project.ts": "228631d3159e1ffcce2359c66073d4ae59bb0285f378e46e446f416aec50481c",
@@ -37,5 +37,5 @@
     "skills/chant-gcp-patterns.md": "a7ef31c1eb2f7244d3f73952c300472ef94c1eb09bd7a1003281b89299b6b704",
     "skills/chant-gcp-gke.md": "be277019da9a722c851e47cd2dfb9c9536668948c3535fb20db7697e934c4e2b"
   },
-  "composite": "a1ac4dc45f5c0421e27da3284a16555e53820e14a09161ce3318d10cb75b5024"
+  "composite": "70dd59dee34491e8d1659ac7b17a12e492b505ceb6b11040a48a30aa4ef8209f"
 }

package/dist/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "gcp",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "chantVersion": ">=0.1.0",
   "namespace": "GCP",
   "intrinsics": [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-gcp",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Google Cloud lexicon for chant — declarative IaC in TypeScript",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",
@@ -44,7 +44,8 @@
   },
   "dependencies": {
     "fflate": "^0.8.2",
-    "js-yaml": "^4.1.0"
+    "js-yaml": "^4.1.0",
+    "@types/js-yaml": "^4.0.9"
   },
   "devDependencies": {
     "@intentius/chant": "*",

package/src/import/generator.test.ts

@@ -4,14 +4,19 @@ import { GcpGenerator } from "./generator";
 const generator = new GcpGenerator();
 
 function makeIR(resources: any[]) {
-  return { resources, parameters: [], outputs: [] };
+  return { resources, parameters: [] };
+}
+
+function content(ir: ReturnType<typeof makeIR>): string {
+  const files = generator.generate(ir);
+  return files[0].content;
 }
 
 describe("GcpGenerator", () => {
   test("generates valid TypeScript from IR", () => {
     const ir = makeIR([
       {
-        logicalName: "my-bucket",
+        logicalId: "my-bucket",
         type: "GCP::Storage::Bucket",
         properties: {
           metadata: { name: "my-bucket" },
@@ -19,7 +24,7 @@ describe("GcpGenerator", () => {
         },
       },
     ]);
-    const result = generator.generate(ir);
+    const result = content(ir);
     expect(result).toContain("import");
     expect(result).toContain("Bucket");
   });
@@ -27,29 +32,28 @@ describe("GcpGenerator", () => {
   test("correct import source (@intentius/chant-lexicon-gcp)", () => {
     const ir = makeIR([
       {
-        logicalName: "my-bucket",
+        logicalId: "my-bucket",
         type: "GCP::Storage::Bucket",
         properties: { location: "US" },
       },
     ]);
-    const result = generator.generate(ir);
-    expect(result).toContain('from "@intentius/chant-lexicon-gcp"');
+    expect(content(ir)).toContain('from "@intentius/chant-lexicon-gcp"');
   });
 
   test("multiple resources produce multiple exports", () => {
     const ir = makeIR([
       {
-        logicalName: "my-bucket",
+        logicalId: "my-bucket",
         type: "GCP::Storage::Bucket",
         properties: { location: "US" },
       },
       {
-        logicalName: "my-vm",
+        logicalId: "my-vm",
         type: "GCP::Compute::Instance",
         properties: { machineType: "e2-medium" },
       },
     ]);
-    const result = generator.generate(ir);
+    const result = content(ir);
     expect(result).toContain("export const myBucket");
     expect(result).toContain("export const myVm");
   });
@@ -57,26 +61,25 @@ describe("GcpGenerator", () => {
   test("camelCase variable names from kebab-case logical names", () => {
     const ir = makeIR([
       {
-        logicalName: "my-data-bucket",
+        logicalId: "my-data-bucket",
         type: "GCP::Storage::Bucket",
         properties: { location: "US" },
       },
     ]);
-    const result = generator.generate(ir);
-    expect(result).toContain("export const myDataBucket");
+    expect(content(ir)).toContain("export const myDataBucket");
   });
 
-  test("empty IR produces minimal output", () => {
+  test("empty IR still produces a generated file", () => {
     const ir = makeIR([]);
-    const result = generator.generate(ir);
-    // Should still produce valid TypeScript, even if no resources
-    expect(typeof result).toBe("string");
+    const files = generator.generate(ir);
+    expect(files).toHaveLength(1);
+    expect(typeof files[0].content).toBe("string");
   });
 
   test("nested object formatting", () => {
     const ir = makeIR([
       {
-        logicalName: "my-bucket",
+        logicalId: "my-bucket",
         type: "GCP::Storage::Bucket",
         properties: {
           location: "US",
@@ -84,7 +87,7 @@ describe("GcpGenerator", () => {
         },
       },
     ]);
-    const result = generator.generate(ir);
+    const result = content(ir);
     expect(result).toContain("versioning:");
     expect(result).toContain("enabled: true");
   });
@@ -92,29 +95,28 @@ describe("GcpGenerator", () => {
   test("uses new Constructor() syntax", () => {
     const ir = makeIR([
       {
-        logicalName: "my-bucket",
+        logicalId: "my-bucket",
         type: "GCP::Storage::Bucket",
         properties: { location: "US" },
       },
     ]);
-    const result = generator.generate(ir);
-    expect(result).toContain("new Bucket(");
+    expect(content(ir)).toContain("new Bucket(");
   });
 
   test("sorts imports alphabetically", () => {
     const ir = makeIR([
       {
-        logicalName: "vm",
+        logicalId: "vm",
         type: "GCP::Compute::Instance",
         properties: { machineType: "e2-medium" },
       },
       {
-        logicalName: "bucket",
+        logicalId: "bucket",
         type: "GCP::Storage::Bucket",
         properties: { location: "US" },
       },
     ]);
-    const result = generator.generate(ir);
+    const result = content(ir);
     const importLine = result.split("\n").find((l: string) => l.startsWith("import"));
     expect(importLine).toBeDefined();
     // Bucket should come before Instance alphabetically

package/src/import/generator.ts

@@ -4,10 +4,11 @@
  * Converts import IR from the parser into typed chant TypeScript code.
  */
 
-import type { TypeScriptGenerator, TemplateIR } from "@intentius/chant/import/generator";
+import type { TypeScriptGenerator, GeneratedFile } from "@intentius/chant/import/generator";
+import type { TemplateIR } from "@intentius/chant/import/parser";
 
 export class GcpGenerator implements TypeScriptGenerator {
-  generate(ir: TemplateIR): string {
+  generate(ir: TemplateIR): GeneratedFile[] {
     const lines: string[] = [];
     const imports = new Set<string>();
 
@@ -31,13 +32,13 @@ export class GcpGenerator implements TypeScriptGenerator {
     for (const resource of ir.resources) {
       const parts = resource.type.split("::");
       const className = parts.length >= 3 ? parts[2] : resource.type;
-      const varName = camelCase(resource.logicalName);
+      const varName = camelCase(resource.logicalId);
 
       lines.push(`export const ${varName} = new ${className}(${formatProps(resource.properties, 0)});`);
       lines.push("");
     }
 
-    return lines.join("\n");
+    return [{ path: "main.ts", content: lines.join("\n") + "\n" }];
   }
 }
 

package/src/import/import-fixtures.test.ts

@@ -16,7 +16,7 @@ spec:
 `;
     const ir = parser.parse(yaml);
     expect(ir.resources).toHaveLength(1);
-    expect(ir.resources[0].logicalName).toBe("my-bucket");
+    expect(ir.resources[0].logicalId).toBe("my-bucket");
     expect(ir.resources[0].type).toContain("Bucket");
   });
 
@@ -40,8 +40,8 @@ spec:
 `;
     const ir = parser.parse(yaml);
     expect(ir.resources).toHaveLength(2);
-    expect(ir.resources[0].logicalName).toBe("my-network");
-    expect(ir.resources[1].logicalName).toBe("my-subnet");
+    expect(ir.resources[0].logicalId).toBe("my-network");
+    expect(ir.resources[1].logicalId).toBe("my-subnet");
   });
 
   test("skips non-Config-Connector resources", () => {
@@ -91,7 +91,7 @@ spec:
 `;
     const ir = parser.parse(yaml);
     const generator = new GcpGenerator();
-    const ts = generator.generate(ir);
+    const ts = generator.generate(ir)[0].content;
     expect(ts).toContain("Bucket");
     expect(ts).toContain("import");
   });

package/src/import/parser.test.ts

@@ -88,7 +88,7 @@ spec:
     expect(ir.resources).toEqual([]);
   });
 
-  test("metadata.name extracted as logicalName", () => {
+  test("metadata.name extracted as logicalId", () => {
     const yaml = `
 apiVersion: compute.cnrm.cloud.google.com/v1beta1
 kind: ComputeNetwork
@@ -98,7 +98,7 @@ spec:
   autoCreateSubnetworks: false
 `;
     const ir = parser.parse(yaml);
-    expect((ir.resources[0] as any).logicalName).toBe("my-network");
+    expect((ir.resources[0] as any).logicalId).toBe("my-network");
   });
 
   test("properties include metadata and spec fields, exclude apiVersion/kind", () => {

package/src/import/parser.ts

@@ -51,7 +51,7 @@ export class GcpParser extends BaseValueParser implements TemplateParser {
       const metadata = doc.metadata as Record<string, unknown> | undefined;
       const spec = doc.spec as Record<string, unknown> | undefined;
 
-      const logicalName = (metadata?.name as string) ?? kind;
+      const logicalId = (metadata?.name as string) ?? kind;
 
       // Build properties from spec
       const properties: Record<string, unknown> = {};
@@ -65,7 +65,7 @@ export class GcpParser extends BaseValueParser implements TemplateParser {
       }
 
       resources.push({
-        logicalName,
+        logicalId,
         type: typeName,
         properties,
       });
@@ -74,7 +74,6 @@ export class GcpParser extends BaseValueParser implements TemplateParser {
     return {
       resources,
       parameters: [],
-      outputs: [],
     };
   }
 }

package/src/import/roundtrip.test.ts

@@ -18,7 +18,7 @@ describe("roundtrip: parse YAML → generate TypeScript", () => {
   test("StorageBucket roundtrip", () => {
     const yaml = readFileSync(join(testdataDir, "storage-bucket.yaml"), "utf-8");
     const ir = parser.parse(yaml);
-    const ts = generator.generate(ir);
+    const ts = generator.generate(ir)[0].content;
 
     expect(ir.resources.length).toBe(1);
     expect(ts).toContain("new Bucket");
@@ -28,7 +28,7 @@ describe("roundtrip: parse YAML → generate TypeScript", () => {
   test("ComputeInstance roundtrip", () => {
     const yaml = readFileSync(join(testdataDir, "compute-instance.yaml"), "utf-8");
     const ir = parser.parse(yaml);
-    const ts = generator.generate(ir);
+    const ts = generator.generate(ir)[0].content;
 
     expect(ir.resources.length).toBe(1);
     expect(ts).toContain("new Instance");
@@ -41,7 +41,7 @@ describe("roundtrip: parse YAML → generate TypeScript", () => {
     const ir = parser.parse(yaml);
     expect(ir.resources.length).toBe(3); // StorageBucket + IAMPolicyMember + ComputeNetwork
 
-    const ts = generator.generate(ir);
+    const ts = generator.generate(ir)[0].content;
     expect(ts).toContain("Bucket");
     expect(ts).toContain("PolicyMember");
     expect(ts).toContain("Network");
@@ -58,7 +58,7 @@ spec:
   storageClass: NEARLINE
 `;
     const ir = parser.parse(yaml);
-    const ts = generator.generate(ir);
+    const ts = generator.generate(ir)[0].content;
 
     expect(ts).toContain("new Bucket");
     expect(ts).toContain("export const");

package/src/lsp/hover.ts

@@ -3,11 +3,19 @@ import type { HoverContext, HoverInfo } from "@intentius/chant/lsp/types";
 import { LexiconIndex, lexiconHover, type LexiconEntry } from "@intentius/chant/lsp/lexicon-providers";
 const require = createRequire(import.meta.url);
 
+// GCP's generated lexicon JSON includes extra CRD-derived metadata (apiVersion,
+// gvkKind) that the core LexiconEntry interface doesn't carry. Type the data
+// locally as a GCP-specific extension.
+type GcpLexiconEntry = LexiconEntry & {
+  apiVersion?: string;
+  gvkKind?: string;
+};
+
 let cachedIndex: LexiconIndex | null = null;
 
 function getIndex(): LexiconIndex {
   if (cachedIndex) return cachedIndex;
-  const data = require("../generated/lexicon-gcp.json") as Record<string, LexiconEntry>;
+  const data = require("../generated/lexicon-gcp.json") as Record<string, GcpLexiconEntry>;
   cachedIndex = new LexiconIndex(data);
   return cachedIndex;
 }
@@ -18,17 +26,18 @@ export function gcpHover(ctx: HoverContext): HoverInfo | undefined {
 
 function resourceHover(className: string, entry: LexiconEntry): HoverInfo | undefined {
   const lines: string[] = [];
+  const gcpEntry = entry as GcpLexiconEntry;
 
   lines.push(`**${className}**`);
   lines.push("");
   lines.push(`GCP Config Connector resource: \`${entry.resourceType}\``);
 
-  if (entry.apiVersion) {
-    lines.push(`API Version: \`${entry.apiVersion}\``);
+  if (gcpEntry.apiVersion) {
+    lines.push(`API Version: \`${gcpEntry.apiVersion}\``);
   }
 
-  if (entry.gvkKind) {
-    lines.push(`Kind: \`${entry.gvkKind}\``);
+  if (gcpEntry.gvkKind) {
+    lines.push(`Kind: \`${gcpEntry.gvkKind}\``);
   }
 
   const customAttrs = Object.entries(entry.attrs ?? {})

package/src/plugin.ts

@@ -174,20 +174,19 @@ export const bucketReader = new IAMPolicyMember({
   },
 
   detectTemplate(data: unknown): boolean {
-    if (typeof data !== "object" || data === null) return false;
+    // Handle raw string input (unparsed YAML)
+    if (typeof data === "string") {
+      return data.includes("cnrm.cloud.google.com");
+    }
 
     // Handle parsed YAML objects
+    if (typeof data !== "object" || data === null) return false;
     const obj = data as Record<string, unknown>;
     const apiVersion = obj.apiVersion;
     if (typeof apiVersion === "string" && apiVersion.includes("cnrm.cloud.google.com")) {
       return true;
     }
 
-    // Handle string input
-    if (typeof data === "string") {
-      return data.includes("cnrm.cloud.google.com");
-    }
-
     return false;
   },
 
@@ -207,124 +206,6 @@ export const bucketReader = new IAMPolicyMember({
     return gcpHover(ctx);
   },
 
-  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> = {};
-
-    // Convert TypeScript variable names to kebab-case manifest names
-    // (mirrors serializer.ts:165 metadata.name assignment)
-    function entityToManifestName(name: string): string {
-      return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
-    }
-
-    // Detect namespace: prefer namespace from manifests, then kubectl context, fallback "default"
-    let namespace = "default";
-    try {
-      // Check manifests for an explicit namespace
-      const nsMatch = options.buildOutput.match(/^\s+namespace:\s*(.+)$/m);
-      if (nsMatch) {
-        namespace = nsMatch[1].trim();
-      } else {
-        // Try kubectl current context namespace
-        const nsResult = await rt.spawn([
-          "kubectl", "config", "view", "--minify", "-o", "jsonpath={..namespace}",
-        ]);
-        if (nsResult.exitCode === 0 && nsResult.stdout.trim()) {
-          namespace = nsResult.stdout.trim();
-        }
-      }
-    } catch (err) {
-      console.error(`[gcp] describeResources: namespace detection failed, using "default": ${err instanceof Error ? err.message : String(err)}`);
-    }
-
-    // Parse build output to extract kind/name pairs
-    let manifests: Array<{ kind: string; name: string; apiVersion: string; namespace?: string }> = [];
-    try {
-      const docs = options.buildOutput.split(/^---$/m).filter((d) => d.trim());
-      for (const doc of docs) {
-        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) {
-          const nsMatch = doc.match(/^\s+namespace:\s*(.+)$/m);
-          manifests.push({
-            kind: kindMatch[1].trim(),
-            name: nameMatch[1].trim(),
-            apiVersion: apiVersionMatch[1].trim(),
-            ...(nsMatch && { namespace: nsMatch[1].trim() }),
-          });
-        }
-      }
-    } catch (err) {
-      console.error(`[gcp] describeResources: failed to parse build output: ${err instanceof Error ? err.message : String(err)}`);
-    }
-
-    let resolved = 0;
-
-    for (const entityName of options.entityNames) {
-      const manifestName = entityToManifestName(entityName);
-      const manifest = manifests.find((m) => m.name === manifestName);
-      if (!manifest) {
-        console.error(`[gcp] describeResources: no manifest found for entity "${entityName}" (expected manifest name "${manifestName}")`);
-        continue;
-      }
-
-      const resourceNs = manifest.namespace ?? namespace;
-      const resourceType = manifest.kind.toLowerCase();
-      const getResult = await rt.spawn([
-        "kubectl", "get", resourceType, manifest.name,
-        "-n", resourceNs, "-o", "json",
-      ]);
-
-      if (getResult.exitCode !== 0) {
-        console.error(`[gcp] describeResources: kubectl get ${resourceType} ${manifest.name} -n ${resourceNs} failed (exit ${getResult.exitCode}): ${getResult.stderr.trim()}`);
-        continue;
-      }
-
-      try {
-        const obj = JSON.parse(getResult.stdout) as {
-          metadata: { name: string; uid: string; creationTimestamp: string };
-          status?: {
-            conditions?: Array<{ type: string; status: string }>;
-            externalRef?: string;
-          };
-        };
-
-        let status = "Unknown";
-        if (obj.status?.conditions) {
-          const ready = obj.status.conditions.find((c) => c.type === "Ready");
-          status = ready?.status === "True" ? "Ready" : "NotReady";
-        }
-
-        const attributes: Record<string, unknown> = {
-          uid: obj.metadata.uid,
-        };
-        if (obj.status?.externalRef) {
-          attributes.externalRef = obj.status.externalRef;
-        }
-
-        resources[entityName] = {
-          type: `${manifest.apiVersion}/${manifest.kind}`,
-          physicalId: obj.status?.externalRef ?? obj.metadata.name,
-          status,
-          lastUpdated: obj.metadata.creationTimestamp,
-          attributes,
-        };
-        resolved++;
-      } catch (err) {
-        console.error(`[gcp] describeResources: failed to parse kubectl output for "${entityName}": ${err instanceof Error ? err.message : String(err)}`);
-      }
-    }
-
-    console.error(`[gcp] describeResources: ${resolved}/${options.entityNames.length} resources resolved`);
-    return resources;
-  },
-
   mcpTools() {
     return [createDiffTool(gcpSerializer, "Compare current build output against previous output for GCP Config Connector manifests", "gcp")];
   },