@intentius/chant-lexicon-gcp 0.1.6 → 0.1.9

package/dist/integrity.json

@@ -1,7 +1,7 @@
 {
   "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "8939a54211882426c712c23fd6cdf36237dd92741ce3b3d18227f84225e2c50c",
+    "manifest.json": "6636d10b3cf11525d4bd6755ff919fe37c8684e9ad46a3d58c01f05667efe1aa",
     "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": "a66d209a7b1a390307e1603ac89a5552e0bd6b095fe7c49ee968a4cb7640d8d6"
+  "composite": "1d080519bb42ffe93a28e56907721646621ff47638a7969eb9ccd87849aabcd3"
 }

package/dist/manifest.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-gcp",
-  "version": "0.1.6",
+  "version": "0.1.9",
   "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/describe-resources.test.ts

@@ -0,0 +1,147 @@
+import { describe, test, expect, vi, beforeEach } from "vitest";
+
+const execMock = vi.fn();
+vi.mock("node:child_process", async () => {
+  const actual = await vi.importActual<typeof import("node:child_process")>("node:child_process");
+  return { ...actual, exec: (cmd: string, cb: (err: Error | null, out: { stdout: string; stderr: string }) => void) => {
+    Promise.resolve(execMock(cmd)).then(
+      (out) => cb(null, out),
+      (err) => cb(err as Error, { stdout: "", stderr: "" }),
+    );
+  } };
+});
+
+const { describeResources } = await import("./describe-resources");
+
+function makeEntities(records: Array<{ name: string; entityType: string; props: Record<string, unknown> }>) {
+  return new Map(records.map((r) => [r.name, { entityType: r.entityType, props: r.props }]));
+}
+
+describe("gcp describeResources (Config Connector)", () => {
+  beforeEach(() => {
+    execMock.mockReset();
+  });
+
+  test("queries kubectl with the derived CC GVK and maps the response", async () => {
+    let receivedCmd = "";
+    execMock.mockImplementation((cmd: string) => {
+      receivedCmd = cmd;
+      return {
+        stdout: JSON.stringify({
+          metadata: { name: "data-bucket", namespace: "config-control", uid: "uid-1", creationTimestamp: "2026-05-01T00:00:00Z" },
+          status: { conditions: [{ type: "Ready", status: "True" }] },
+        }),
+        stderr: "",
+      };
+    });
+
+    const entities = makeEntities([
+      { name: "dataBucket", entityType: "GCP::Storage::Bucket", props: { metadata: { name: "data-bucket", namespace: "config-control" } } },
+    ]);
+
+    const result = await describeResources({ environment: "prod", buildOutput: "", entityNames: ["dataBucket"], entities });
+
+    // Resource name follows: <lowerKind>.<service>.cnrm.cloud.google.com
+    expect(receivedCmd).toContain("storagebucket.storage.cnrm.cloud.google.com");
+    expect(receivedCmd).toContain("data-bucket");
+    expect(receivedCmd).toContain("-n config-control");
+
+    expect(result["dataBucket"]).toMatchObject({
+      type: "GCP::Storage::Bucket",
+      physicalId: "uid-1",
+      status: "READY",
+    });
+  });
+
+  test("Compute resource derives correct GVK with service prefix", async () => {
+    let receivedCmd = "";
+    execMock.mockImplementation((cmd: string) => {
+      receivedCmd = cmd;
+      return {
+        stdout: JSON.stringify({
+          metadata: { name: "subnet-1", uid: "uid", creationTimestamp: "t" },
+          status: { conditions: [{ type: "Ready", status: "True" }] },
+        }),
+        stderr: "",
+      };
+    });
+
+    const entities = makeEntities([
+      { name: "sub", entityType: "GCP::Compute::Subnetwork", props: { metadata: { name: "subnet-1" } } },
+    ]);
+
+    await describeResources({ environment: "prod", buildOutput: "", entityNames: ["sub"], entities });
+
+    expect(receivedCmd).toContain("computesubnetwork.compute.cnrm.cloud.google.com");
+  });
+
+  test("Ready=False maps to the condition's reason", async () => {
+    execMock.mockResolvedValue({
+      stdout: JSON.stringify({
+        metadata: { name: "x", uid: "uid", creationTimestamp: "t" },
+        status: { conditions: [{ type: "Ready", status: "False", reason: "DependencyNotFound", message: "..." }] },
+      }),
+      stderr: "",
+    });
+
+    const entities = makeEntities([
+      { name: "x", entityType: "GCP::Storage::Bucket", props: { metadata: { name: "x" } } },
+    ]);
+
+    const result = await describeResources({ environment: "prod", buildOutput: "", entityNames: ["x"], entities });
+
+    expect(result["x"].status).toBe("DependencyNotFound");
+  });
+
+  test("missing Ready condition falls back to PRESENT", async () => {
+    execMock.mockResolvedValue({
+      stdout: JSON.stringify({
+        metadata: { name: "x", uid: "uid", creationTimestamp: "t" },
+        status: {},
+      }),
+      stderr: "",
+    });
+
+    const entities = makeEntities([
+      { name: "x", entityType: "GCP::Storage::Bucket", props: { metadata: { name: "x" } } },
+    ]);
+
+    const result = await describeResources({ environment: "prod", buildOutput: "", entityNames: ["x"], entities });
+
+    expect(result["x"].status).toBe("PRESENT");
+  });
+
+  test("kubectl-not-found leaves entity out of result", async () => {
+    execMock.mockImplementation(() => { throw new Error('Error from server (NotFound): storagebucket "x" not found'); });
+
+    const entities = makeEntities([
+      { name: "x", entityType: "GCP::Storage::Bucket", props: { metadata: { name: "x" } } },
+    ]);
+
+    const result = await describeResources({ environment: "prod", buildOutput: "", entityNames: ["x"], entities });
+
+    expect(result).toEqual({});
+  });
+
+  test("non-GCP entity types are skipped", async () => {
+    const entities = makeEntities([
+      { name: "x", entityType: "AWS::S3::Bucket", props: { metadata: { name: "x" } } },
+    ]);
+
+    const result = await describeResources({ environment: "prod", buildOutput: "", entityNames: ["x"], entities });
+
+    expect(result).toEqual({});
+    expect(execMock).not.toHaveBeenCalled();
+  });
+
+  test("entity without metadata.name is silently skipped", async () => {
+    const entities = makeEntities([
+      { name: "broken", entityType: "GCP::Storage::Bucket", props: {} },
+    ]);
+
+    const result = await describeResources({ environment: "prod", buildOutput: "", entityNames: ["broken"], entities });
+
+    expect(result).toEqual({});
+    expect(execMock).not.toHaveBeenCalled();
+  });
+});

package/src/describe-resources.ts

@@ -0,0 +1,118 @@
+/**
+ * Live introspection of a GCP project via Config Connector CRDs.
+ *
+ * GCP entities in chant are emitted as Config Connector custom resources
+ * (apiVersion <service>.cnrm.cloud.google.com/v1beta1, kind <Service><Kind>).
+ * To observe them at runtime we shell out to kubectl against a Config
+ * Connector-enabled cluster — the same pattern as the K8s lexicon.
+ *
+ *   GCP::Storage::Bucket    → kubectl get storagebucket.storage.cnrm.cloud.google.com
+ *   GCP::Compute::Subnetwork → kubectl get computesubnetwork.compute.cnrm.cloud.google.com
+ *
+ * Resource-not-found is silent — `state diff --live` reports it as missing.
+ */
+
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import type { ResourceMetadata } from "@intentius/chant/lexicon";
+
+const execAsync = promisify(exec);
+
+interface KubectlResponse {
+  metadata?: {
+    name?: string;
+    namespace?: string;
+    uid?: string;
+    creationTimestamp?: string;
+    labels?: Record<string, string>;
+    annotations?: Record<string, string>;
+  };
+  status?: {
+    conditions?: Array<{ type?: string; status?: string; reason?: string; message?: string }>;
+    [k: string]: unknown;
+  };
+}
+
+/**
+ * Mirror of `lexicons/gcp/src/serializer.ts:deriveGVKFromType` — keeping the
+ * derivation logic local so describeResources can compute the kubectl resource
+ * name without importing serializer internals.
+ */
+function deriveGVK(entityType: string): { group: string; kind: string } | null {
+  const parts = entityType.split("::");
+  if (parts.length !== 3 || parts[0] !== "GCP") return null;
+  const service = parts[1].toLowerCase();
+  const shortKind = parts[2];
+  return {
+    group: `${service}.cnrm.cloud.google.com`,
+    kind: `${parts[1]}${shortKind}`,
+  };
+}
+
+function pruneUndefined<T extends Record<string, unknown>>(obj: T): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== undefined) out[k] = v;
+  }
+  return out;
+}
+
+/**
+ * Config Connector encodes deployment state as a `Ready` condition on the
+ * resource's status. Fall back to listing all condition types if `Ready`
+ * isn't present.
+ */
+function statusFromCC(obj: KubectlResponse): string {
+  const conditions = obj.status?.conditions ?? [];
+  const ready = conditions.find((c) => c.type === "Ready");
+  if (ready) {
+    if (ready.status === "True") return "READY";
+    return ready.reason ?? "NOT_READY";
+  }
+  if (conditions.length > 0) {
+    return conditions.map((c) => `${c.type}=${c.status}`).join(",");
+  }
+  return "PRESENT";
+}
+
+export async function describeResources(options: {
+  environment: string;
+  buildOutput: string;
+  entityNames: string[];
+  entities: Map<string, { entityType: string; props: Record<string, unknown> }>;
+}): Promise<Record<string, ResourceMetadata>> {
+  const result: Record<string, ResourceMetadata> = {};
+
+  for (const [entityName, { entityType, props }] of options.entities) {
+    const gvk = deriveGVK(entityType);
+    if (!gvk) continue;
+
+    const metadata = props.metadata as { name?: string; namespace?: string } | undefined;
+    const name = metadata?.name;
+    if (!name) continue;
+
+    const kubectlResource = `${gvk.kind.toLowerCase()}.${gvk.group}`;
+    const nsArg = metadata.namespace ? ["-n", metadata.namespace] : [];
+    const cmd = ["kubectl", "get", kubectlResource, name, ...nsArg, "-o", "json"].join(" ");
+
+    try {
+      const { stdout } = await execAsync(cmd);
+      const obj: KubectlResponse = JSON.parse(stdout);
+      result[entityName] = {
+        type: entityType,
+        physicalId: obj.metadata?.uid,
+        status: statusFromCC(obj),
+        lastUpdated: obj.metadata?.creationTimestamp,
+        attributes: pruneUndefined({
+          namespace: obj.metadata?.namespace,
+          labels: obj.metadata?.labels,
+          annotations: obj.metadata?.annotations,
+        }),
+      };
+    } catch {
+      // CRD or instance not found — skip silently
+    }
+  }
+
+  return result;
+}

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.test.ts

@@ -214,7 +214,7 @@ describe("gcpPlugin", () => {
 
     test("diff tool has correct structure", () => {
       const tools = gcpPlugin.mcpTools!();
-      const diffTool = tools.find((t) => t.name === "diff");
+      const diffTool = tools.find((t) => t.name === "gcp:diff");
       expect(diffTool).toBeDefined();
       expect(diffTool!.description.length).toBeGreaterThan(0);
       expect(diffTool!.inputSchema.type).toBe("object");
@@ -230,7 +230,7 @@ describe("gcpPlugin", () => {
 
     test("resource-catalog has correct structure", () => {
       const resources = gcpPlugin.mcpResources!();
-      const catalog = resources.find((r) => r.uri === "resource-catalog");
+      const catalog = resources.find((r) => r.uri === "gcp:resource-catalog");
       expect(catalog).toBeDefined();
       expect(catalog!.mimeType).toBe("application/json");
       expect(typeof catalog!.handler).toBe("function");

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,131 +206,13 @@ 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")];
+    return [createDiffTool(gcpSerializer, "Compare current build output against previous output for GCP Config Connector manifests", "gcp")];
   },
 
   mcpResources() {
     return [
-      createCatalogResource(import.meta.url, "GCP Config Connector Resource Catalog", "JSON list of all supported GCP Config Connector resource types", "lexicon-gcp.json"),
+      createCatalogResource(import.meta.url, "GCP Config Connector Resource Catalog", "JSON list of all supported GCP Config Connector resource types", "lexicon-gcp.json", "gcp"),
       {
         uri: "examples/basic-bucket",
         name: "Basic GCS Bucket Example",
@@ -499,4 +380,9 @@ export const bucket = new StorageBucket({
     const { generateDocs } = await import("./codegen/docs");
     await generateDocs(options);
   },
+
+  async describeResources(options) {
+    const { describeResources } = await import("./describe-resources");
+    return describeResources(options);
+  },
 };