@intentius/chant 0.0.16 → 0.0.22

package/src/discovery/graph.test.ts

@@ -12,6 +12,7 @@ describe("buildDependencyGraph", () => {
 
   test("returns graph with no dependencies for single entity", () => {
     const entity: Declarable = {
+      lexicon: "test",
       entityType: "test",
       [DECLARABLE_MARKER]: true,
     };
@@ -25,11 +26,13 @@ describe("buildDependencyGraph", () => {
 
   test("returns graph with no dependencies for multiple unrelated entities", () => {
     const entity1: Declarable = {
+      lexicon: "test",
       entityType: "test",
       [DECLARABLE_MARKER]: true,
     };
 
     const entity2: Declarable = {
+      lexicon: "test",
       entityType: "test",
       [DECLARABLE_MARKER]: true,
     };
@@ -47,11 +50,13 @@ describe("buildDependencyGraph", () => {
 
   test("detects dependency from AttrRef", () => {
     const parent: Declarable = {
+      lexicon: "test",
       entityType: "parent",
       [DECLARABLE_MARKER]: true,
     };
 
     const child: Declarable & { ref: AttrRef } = {
+      lexicon: "test",
       entityType: "child",
       [DECLARABLE_MARKER]: true,
       ref: new AttrRef(parent, "someAttr"),
@@ -71,11 +76,13 @@ describe("buildDependencyGraph", () => {
 
   test("detects dependency from direct Declarable reference", () => {
     const entity1: Declarable = {
+      lexicon: "test",
       entityType: "type1",
       [DECLARABLE_MARKER]: true,
     };
 
     const entity2: Declarable & { dependency: Declarable } = {
+      lexicon: "test",
       entityType: "type2",
       [DECLARABLE_MARKER]: true,
       dependency: entity1,
@@ -95,16 +102,19 @@ describe("buildDependencyGraph", () => {
 
   test("detects multiple dependencies from one entity", () => {
     const entity1: Declarable = {
+      lexicon: "test",
       entityType: "type1",
       [DECLARABLE_MARKER]: true,
     };
 
     const entity2: Declarable = {
+      lexicon: "test",
       entityType: "type2",
       [DECLARABLE_MARKER]: true,
     };
 
     const entity3: Declarable & { dep1: Declarable; dep2: Declarable } = {
+      lexicon: "test",
       entityType: "type3",
       [DECLARABLE_MARKER]: true,
       dep1: entity1,
@@ -126,11 +136,13 @@ describe("buildDependencyGraph", () => {
 
   test("detects dependencies in nested objects", () => {
     const entity1: Declarable = {
+      lexicon: "test",
       entityType: "type1",
       [DECLARABLE_MARKER]: true,
     };
 
     const entity2: Declarable & { nested: { deep: Declarable } } = {
+      lexicon: "test",
       entityType: "type2",
       [DECLARABLE_MARKER]: true,
       nested: {
@@ -150,16 +162,19 @@ describe("buildDependencyGraph", () => {
 
   test("detects dependencies in arrays", () => {
     const entity1: Declarable = {
+      lexicon: "test",
       entityType: "type1",
       [DECLARABLE_MARKER]: true,
     };
 
     const entity2: Declarable = {
+      lexicon: "test",
       entityType: "type2",
       [DECLARABLE_MARKER]: true,
     };
 
     const entity3: Declarable & { deps: Declarable[] } = {
+      lexicon: "test",
       entityType: "type3",
       [DECLARABLE_MARKER]: true,
       deps: [entity1, entity2],
@@ -179,16 +194,19 @@ describe("buildDependencyGraph", () => {
 
   test("detects mixed AttrRef and Declarable dependencies", () => {
     const entity1: Declarable = {
+      lexicon: "test",
       entityType: "type1",
       [DECLARABLE_MARKER]: true,
     };
 
     const entity2: Declarable = {
+      lexicon: "test",
       entityType: "type2",
       [DECLARABLE_MARKER]: true,
     };
 
     const entity3: Declarable & { ref: AttrRef; dep: Declarable } = {
+      lexicon: "test",
       entityType: "type3",
       [DECLARABLE_MARKER]: true,
       ref: new AttrRef(entity1, "attr"),
@@ -209,17 +227,20 @@ describe("buildDependencyGraph", () => {
 
   test("handles transitive dependencies correctly", () => {
     const entity1: Declarable = {
+      lexicon: "test",
       entityType: "type1",
       [DECLARABLE_MARKER]: true,
     };
 
     const entity2: Declarable & { dep: Declarable } = {
+      lexicon: "test",
       entityType: "type2",
       [DECLARABLE_MARKER]: true,
       dep: entity1,
     };
 
     const entity3: Declarable & { dep: Declarable } = {
+      lexicon: "test",
       entityType: "type3",
       [DECLARABLE_MARKER]: true,
       dep: entity2,
@@ -241,16 +262,19 @@ describe("buildDependencyGraph", () => {
 
   test("ignores non-entity declarables", () => {
     const entity: Declarable = {
+      lexicon: "test",
       entityType: "test",
       [DECLARABLE_MARKER]: true,
     };
 
     const notInEntities: Declarable = {
+      lexicon: "test",
       entityType: "external",
       [DECLARABLE_MARKER]: true,
     };
 
     const entityWithExternal: Declarable & { dep: Declarable } = {
+      lexicon: "test",
       entityType: "test",
       [DECLARABLE_MARKER]: true,
       dep: notInEntities,
@@ -267,11 +291,13 @@ describe("buildDependencyGraph", () => {
 
   test("ignores AttrRef with parent not in entities", () => {
     const externalParent: Declarable = {
+      lexicon: "test",
       entityType: "external",
       [DECLARABLE_MARKER]: true,
     };
 
     const entity: Declarable & { ref: AttrRef } = {
+      lexicon: "test",
       entityType: "test",
       [DECLARABLE_MARKER]: true,
       ref: new AttrRef(externalParent, "attr"),
@@ -285,11 +311,13 @@ describe("buildDependencyGraph", () => {
 
   test("handles circular references without infinite loop", () => {
     const entity1: Declarable & { other?: Declarable } = {
+      lexicon: "test",
       entityType: "type1",
       [DECLARABLE_MARKER]: true,
     };
 
     const entity2: Declarable & { other: Declarable } = {
+      lexicon: "test",
       entityType: "type2",
       [DECLARABLE_MARKER]: true,
       other: entity1,
@@ -309,6 +337,7 @@ describe("buildDependencyGraph", () => {
 
   test("handles self-reference without infinite loop", () => {
     const entity: Declarable & { self?: Declarable } = {
+      lexicon: "test",
       entityType: "test",
       [DECLARABLE_MARKER]: true,
     };
@@ -329,6 +358,7 @@ describe("buildDependencyGraph", () => {
       bool: boolean;
       nul: null;
     } = {
+      lexicon: "test",
       entityType: "test",
       [DECLARABLE_MARKER]: true,
       str: "value",
@@ -348,6 +378,7 @@ describe("buildDependencyGraph", () => {
     // parent is the resource itself (e.g. bucket.arn, bucket.bucketName).
     // These are not real dependencies — they're just attribute accessors.
     const resource: Declarable & { arn?: AttrRef; bucketName?: AttrRef } = {
+      lexicon: "test",
       entityType: "AWS::S3::Bucket",
       [DECLARABLE_MARKER]: true,
     };
@@ -364,6 +395,7 @@ describe("buildDependencyGraph", () => {
     // A resource has its own AttrRefs (self-pointing) AND a property that
     // references a different entity. Only the cross-resource dep should appear.
     const defaults: Declarable = {
+      lexicon: "test",
       entityType: "AWS::S3::VersioningConfiguration",
       [DECLARABLE_MARKER]: true,
     };
@@ -372,6 +404,7 @@ describe("buildDependencyGraph", () => {
       arn?: AttrRef;
       versioningConfiguration?: Declarable;
     } = {
+      lexicon: "test",
       entityType: "AWS::S3::Bucket",
       [DECLARABLE_MARKER]: true,
     };
@@ -391,6 +424,7 @@ describe("buildDependencyGraph", () => {
 
   test("ignores plain objects without markers", () => {
     const entity: Declarable & { data: { key: string } } = {
+      lexicon: "test",
       entityType: "test",
       [DECLARABLE_MARKER]: true,
       data: { key: "value" },
@@ -404,6 +438,7 @@ describe("buildDependencyGraph", () => {
 
   test("handles AttrRef with garbage collected parent gracefully", () => {
     const entity: Declarable & { ref: AttrRef } = {
+      lexicon: "test",
       entityType: "test",
       [DECLARABLE_MARKER]: true,
       ref: new AttrRef({}, "attr"), // Using plain object that will be GC'd
@@ -418,6 +453,7 @@ describe("buildDependencyGraph", () => {
 
   test("detects dependencies deeply nested in arrays and objects", () => {
     const entity1: Declarable = {
+      lexicon: "test",
       entityType: "type1",
       [DECLARABLE_MARKER]: true,
     };
@@ -425,6 +461,7 @@ describe("buildDependencyGraph", () => {
     const entity2: Declarable & {
       complex: { nested: { array: Array<{ item: Declarable }> } };
     } = {
+      lexicon: "test",
       entityType: "type2",
       [DECLARABLE_MARKER]: true,
       complex: {
@@ -446,17 +483,20 @@ describe("buildDependencyGraph", () => {
 
   test("does not traverse into referenced declarables", () => {
     const entity1: Declarable = {
+      lexicon: "test",
       entityType: "type1",
       [DECLARABLE_MARKER]: true,
     };
 
     const entity2: Declarable & { internal: { data: string } } = {
+      lexicon: "test",
       entityType: "type2",
       [DECLARABLE_MARKER]: true,
       internal: { data: "should not traverse this" },
     };
 
     const entity3: Declarable & { dep: Declarable } = {
+      lexicon: "test",
       entityType: "type3",
       [DECLARABLE_MARKER]: true,
       dep: entity2,

package/src/discovery/import.test.ts

@@ -28,8 +28,8 @@ describe("importModule", () => {
 
       const module = await importModule(filePath);
       expect(module.default).toBeDefined();
-      expect(module.default.name).toBe("test");
-      expect(module.default.value).toBe(123);
+      expect((module.default as any).name).toBe("test");
+      expect((module.default as any).value).toBe(123);
     });
   });
 
@@ -125,7 +125,7 @@ describe("importModule", () => {
 
       const module = await importModule(filePath);
       expect(module.MyClass).toBeDefined();
-      const instance = new module.MyClass(100);
+      const instance = new (module.MyClass as any)(100);
       expect(instance.getValue()).toBe(100);
     });
   });
@@ -142,8 +142,8 @@ describe("importModule", () => {
       const module = await importModule(filePath);
       expect(module.add).toBeInstanceOf(Function);
       expect(module.multiply).toBeInstanceOf(Function);
-      expect(module.add(2, 3)).toBe(5);
-      expect(module.multiply(4, 5)).toBe(20);
+      expect((module.add as Function)(2, 3)).toBe(5);
+      expect((module.multiply as Function)(4, 5)).toBe(20);
     });
   });
 

package/src/discovery/resolve.test.ts

@@ -8,11 +8,13 @@ import { LOGICAL_NAME_SYMBOL, getLogicalName } from "../utils";
 describe("resolveAttrRefs", () => {
   test("sets logical names on all entities", () => {
     const entity1: Declarable = {
+      lexicon: "test",
       entityType: "Test1",
       [DECLARABLE_MARKER]: true,
     };
 
     const entity2: Declarable = {
+      lexicon: "test",
       entityType: "Test2",
       [DECLARABLE_MARKER]: true,
     };
@@ -30,11 +32,13 @@ describe("resolveAttrRefs", () => {
 
   test("resolves AttrRef with parent in entities collection", () => {
     const parent: Declarable = {
+      lexicon: "test",
       entityType: "Parent",
       [DECLARABLE_MARKER]: true,
     };
 
     const child: Declarable & { ref: AttrRef } = {
+      lexicon: "test",
       entityType: "Child",
       [DECLARABLE_MARKER]: true,
       ref: new AttrRef(parent, "Arn"),
@@ -55,11 +59,13 @@ describe("resolveAttrRefs", () => {
 
   test("resolves multiple AttrRefs on same entity", () => {
     const parent: Declarable = {
+      lexicon: "test",
       entityType: "Parent",
       [DECLARABLE_MARKER]: true,
     };
 
     const child: Declarable & { arn: AttrRef; name: AttrRef } = {
+      lexicon: "test",
       entityType: "Child",
       [DECLARABLE_MARKER]: true,
       arn: new AttrRef(parent, "Arn"),
@@ -83,16 +89,19 @@ describe("resolveAttrRefs", () => {
 
   test("resolves AttrRefs with different parents", () => {
     const parent1: Declarable = {
+      lexicon: "test",
       entityType: "Parent1",
       [DECLARABLE_MARKER]: true,
     };
 
     const parent2: Declarable = {
+      lexicon: "test",
       entityType: "Parent2",
       [DECLARABLE_MARKER]: true,
     };
 
     const child: Declarable & { ref1: AttrRef; ref2: AttrRef } = {
+      lexicon: "test",
       entityType: "Child",
       [DECLARABLE_MARKER]: true,
       ref1: new AttrRef(parent1, "Arn"),
@@ -119,6 +128,7 @@ describe("resolveAttrRefs", () => {
     const parent = {}; // Not a Declarable, not in entities
 
     const child: Declarable & { ref: AttrRef } = {
+      lexicon: "test",
       entityType: "Child",
       [DECLARABLE_MARKER]: true,
       ref: new AttrRef(parent, "Arn"),
@@ -133,11 +143,13 @@ describe("resolveAttrRefs", () => {
 
   test("handles entities with no AttrRefs", () => {
     const entity1: Declarable = {
+      lexicon: "test",
       entityType: "Test1",
       [DECLARABLE_MARKER]: true,
     };
 
     const entity2: Declarable & { prop: string } = {
+      lexicon: "test",
       entityType: "Test2",
       [DECLARABLE_MARKER]: true,
       prop: "value",
@@ -162,17 +174,20 @@ describe("resolveAttrRefs", () => {
 
   test("resolves chain of entities with AttrRefs", () => {
     const root: Declarable = {
+      lexicon: "test",
       entityType: "Root",
       [DECLARABLE_MARKER]: true,
     };
 
     const middle: Declarable & { rootRef: AttrRef } = {
+      lexicon: "test",
       entityType: "Middle",
       [DECLARABLE_MARKER]: true,
       rootRef: new AttrRef(root, "Id"),
     };
 
     const leaf: Declarable & { middleRef: AttrRef } = {
+      lexicon: "test",
       entityType: "Leaf",
       [DECLARABLE_MARKER]: true,
       middleRef: new AttrRef(middle, "Name"),
@@ -196,6 +211,7 @@ describe("resolveAttrRefs", () => {
 
   test("handles entity referencing itself", () => {
     const entity: Declarable & { selfRef: AttrRef } = {
+      lexicon: "test",
       entityType: "SelfReferencing",
       [DECLARABLE_MARKER]: true,
       selfRef: null as unknown as AttrRef, // Will be set below
@@ -214,6 +230,7 @@ describe("resolveAttrRefs", () => {
 
   test("preserves logical name symbol on entities", () => {
     const entity: Declarable = {
+      lexicon: "test",
       entityType: "Test",
       [DECLARABLE_MARKER]: true,
     };
@@ -228,6 +245,7 @@ describe("resolveAttrRefs", () => {
 
   test("uses export name as logical name", () => {
     const entity: Declarable = {
+      lexicon: "test",
       entityType: "Test",
       [DECLARABLE_MARKER]: true,
     };
@@ -243,11 +261,13 @@ describe("resolveAttrRefs", () => {
 
   test("handles complex attribute names in AttrRef", () => {
     const parent: Declarable = {
+      lexicon: "test",
       entityType: "Parent",
       [DECLARABLE_MARKER]: true,
     };
 
     const child: Declarable & { ref: AttrRef } = {
+      lexicon: "test",
       entityType: "Child",
       [DECLARABLE_MARKER]: true,
       ref: new AttrRef(parent, "Outputs.WebsiteURL"),

package/src/discovery/resolve.ts

@@ -1,6 +1,6 @@
 import type { Declarable } from "../declarable";
 import { AttrRef } from "../attrref";
-import { LOGICAL_NAME_SYMBOL, getAttributes } from "../utils";
+import { LOGICAL_NAME_SYMBOL, getAttributes, isAttrRefLike } from "../utils";
 
 /**
  * Resolves all AttrRef instances in a collection of entities
@@ -22,7 +22,7 @@ export function resolveAttrRefs(entities: Map<string, Declarable>): void {
     for (const attrName of attributes) {
       const attrRef = (entity as unknown as Record<string, unknown>)[attrName];
 
-      if (attrRef instanceof AttrRef) {
+      if (isAttrRefLike(attrRef)) {
         const parent = attrRef.parent.deref();
 
         if (!parent) {

package/src/index.ts

@@ -59,3 +59,5 @@ export * from "./child-project";
 export * from "./lsp/types";
 export * from "./lsp/lexicon-providers";
 export * from "./mcp/types";
+export * from "./state/index";
+export * from "./spell/index";

package/src/lexicon.ts

@@ -193,6 +193,30 @@ export interface LexiconPlugin {
 
   /** Return MCP resource contributions */
   mcpResources?(): McpResourceContribution[];
+
+  // State
+  /** Query deployed resources and return API metadata. Opt-in. */
+  describeResources?(options: {
+    environment: string;
+    buildOutput: string;
+    entityNames: string[];
+  }): Promise<Record<string, ResourceMetadata>>;
+}
+
+/**
+ * Metadata about a deployed resource, returned by describeResources.
+ */
+export interface ResourceMetadata {
+  /** Entity type (e.g. AWS::S3::Bucket, K8s::Apps::Deployment) */
+  type: string;
+  /** Provider-assigned physical ID (ARN, resource ID, pod name) */
+  physicalId?: string;
+  /** Provider-specific status string */
+  status: string;
+  /** ISO timestamp of last update */
+  lastUpdated?: string;
+  /** Cloud-assigned output properties */
+  attributes?: Record<string, unknown>;
 }
 
 /**

package/src/lint/rule-options.test.ts

@@ -2,7 +2,7 @@ import { describe, test, expect, beforeEach, afterEach } from "bun:test";
 import { parseRuleConfig, loadConfig } from "./config";
 import { fileDeclarableLimitRule } from "./rules/file-declarable-limit";
 import * as ts from "typescript";
-import type { LintContext } from "./rule";
+import type { LintContext, RuleConfig } from "./rule";
 import { writeFileSync, mkdirSync, rmSync } from "fs";
 import { join } from "path";
 
@@ -37,12 +37,12 @@ describe("parseRuleConfig", () => {
   });
 
   test("parses [severity, options] tuple", () => {
-    const result = parseRuleConfig(["warning", { max: 12 }]);
+    const result = parseRuleConfig(["warning" as const, { max: 12 }]);
     expect(result).toEqual({ severity: "warning", options: { max: 12 } });
   });
 
   test("throws for invalid tuple length", () => {
-    expect(() => parseRuleConfig([] as unknown as [string, Record<string, unknown>])).toThrow(
+    expect(() => parseRuleConfig([] as unknown as RuleConfig)).toThrow(
       /expected a severity string or \[severity, options\] tuple/
     );
   });

package/src/lint/rule-registry.test.ts

@@ -88,7 +88,7 @@ describe("buildRuleRegistry", () => {
 
   test("falls back to rule ID when description is missing", () => {
     const rule = mockRule("COR001");
-    delete (rule as Record<string, unknown>).description;
+    delete (rule as unknown as Record<string, unknown>).description;
 
     const entries = buildRuleRegistry([rule]);
     expect(entries[0].description).toBe("COR001");

package/src/lint/rules/composite-scope.ts

@@ -14,7 +14,7 @@ export function isInsideCompositeFactory(node: ts.Node): boolean {
 
   while (current) {
     if (ts.isArrowFunction(current) || ts.isFunctionExpression(current)) {
-      const parent = current.parent;
+      const parent: ts.Node | undefined = current.parent;
       if (parent && ts.isCallExpression(parent) && parent.arguments[0] === current) {
         const callee = parent.expression;
         if (isCompositeCallee(callee)) {

package/src/serializer-walker.ts

@@ -9,6 +9,7 @@ import type { Declarable } from "./declarable";
 import { isPropertyDeclarable } from "./declarable";
 import { INTRINSIC_MARKER } from "./intrinsic";
 import { AttrRef } from "./attrref";
+import { isAttrRefLike } from "./utils";
 
 export interface SerializerVisitor {
   /** Format an attribute reference (e.g. CFN Fn::GetAttr). */
@@ -33,7 +34,7 @@ export function walkValue(
   }
 
   // Handle AttrRef
-  if (value instanceof AttrRef) {
+  if (isAttrRefLike(value)) {
     const name = value.getLogicalName();
     if (!name) {
       throw new Error(