@intentius/chant 0.0.18 → 0.0.22

package/bin/chant

@@ -15,6 +15,9 @@ MAIN_TS="$SCRIPT_DIR/../src/cli/main.ts"
 
 if command -v bun >/dev/null 2>&1; then
   exec bun "$MAIN_TS" "$@"
-else
+elif command -v npx >/dev/null 2>&1; then
   exec npx tsx "$MAIN_TS" "$@"
+else
+  echo "error: chant requires Bun (https://bun.sh) or Node.js (https://nodejs.org)" >&2
+  exit 1
 fi

package/package.json

@@ -1,7 +1,26 @@
 {
   "name": "@intentius/chant",
-  "version": "0.0.18",
+  "version": "0.0.22",
+  "description": "Declarative infrastructure-as-code toolkit — TypeScript on Bun",
   "license": "Apache-2.0",
+  "homepage": "https://intentius.io/chant",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/intentius/chant.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/intentius/chant/issues"
+  },
+  "keywords": [
+    "infrastructure-as-code",
+    "iac",
+    "typescript",
+    "declarative",
+    "cloudformation",
+    "aws",
+    "devops"
+  ],
   "type": "module",
   "files": [
     "src/",

package/src/build.test.ts

@@ -189,10 +189,12 @@ export const betaEntity = {
     expect(result.outputs.has("alpha")).toBe(true);
     expect(result.outputs.has("beta")).toBe(true);
 
-    const alphaOutput = JSON.parse(result.outputs.get("alpha")!);
+    const alphaRaw = result.outputs.get("alpha")!;
+    const alphaOutput = JSON.parse(typeof alphaRaw === "string" ? alphaRaw : alphaRaw.primary);
     expect(alphaOutput.alpha).toContain("alphaEntity");
 
-    const betaOutput = JSON.parse(result.outputs.get("beta")!);
+    const betaRaw = result.outputs.get("beta")!;
+    const betaOutput = JSON.parse(typeof betaRaw === "string" ? betaRaw : betaRaw.primary);
     expect(betaOutput.beta).toContain("betaEntity");
   });
 

package/src/build.ts

@@ -29,6 +29,8 @@ export interface BuildResult {
   outputs: Map<string, string | SerializerResult>;
   /** Map of entity name to Declarable entity */
   entities: Map<string, Declarable>;
+  /** Resource-level dependency graph from discovery */
+  dependencies: Map<string, Set<string>>;
   /** Array of warnings encountered during the build */
   warnings: string[];
   /** Array of errors encountered during discovery and build */
@@ -430,6 +432,7 @@ export async function build(
   return {
     outputs,
     entities: discoveryResult.entities,
+    dependencies: discoveryResult.dependencies,
     warnings,
     errors,
     manifest,

package/src/builder.test.ts

@@ -36,6 +36,7 @@ class SimpleResourceBuilder extends Builder<TestResource> {
       throw new Error("Name and type are required");
     }
     return {
+      lexicon: "test",
       entityType: "TestResource",
       [DECLARABLE_MARKER]: true,
       name: this.name,
@@ -72,6 +73,7 @@ class ValidatedResourceBuilder extends Builder<TestResource> {
       throw new Error("Name and type are required");
     }
     return {
+      lexicon: "test",
       entityType: "TestResource",
       [DECLARABLE_MARKER]: true,
       name: this.name,
@@ -103,6 +105,7 @@ class DefaultsResourceBuilder extends Builder<TestResource> {
 
   build(): TestResource {
     return {
+      lexicon: "test",
       entityType: "TestResource",
       [DECLARABLE_MARKER]: true,
       name: this.name,

package/src/cli/commands/__fixtures__/init-lexicon-output/docs/astro.config.mjs

@@ -8,9 +8,6 @@ export default defineConfig({
       title: 'Fixture',
       sidebar: [
         { label: 'Overview', slug: '' },
-        { label: 'Getting Started', slug: 'getting-started' },
-        { label: 'Serialization', slug: 'serialization' },
-        { label: 'Lint Rules', slug: 'lint-rules' },
       ],
     }),
   ],

package/src/cli/commands/build.ts

@@ -3,6 +3,7 @@ import type { Serializer, SerializerResult } from "../../serializer";
 import type { LexiconPlugin } from "../../lexicon";
 import { runPostSynthChecks } from "../../lint/post-synth";
 import type { PostSynthCheck } from "../../lint/post-synth";
+import { sortedJsonReplacer } from "../../utils";
 import { formatError, formatWarning, formatSuccess, formatBold, formatInfo } from "../format";
 import { writeFileSync } from "fs";
 import { resolve, dirname, join } from "path";
@@ -214,6 +215,10 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
   const resourceCount = result.entities.size;
   const fileCount = result.sourceFileCount;
 
+  if (fileCount === 0 && errors.length === 0) {
+    console.error(formatInfo("No source files found — create .ts files in the target directory"));
+  }
+
   if (options.verbose && errors.length === 0) {
     console.error(
       formatSuccess(
@@ -231,18 +236,6 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
   };
 }
 
-/**
- * JSON.stringify replacer that sorts object keys for deterministic output
- */
-function sortedJsonReplacer(_key: string, value: unknown): unknown {
-  if (value && typeof value === "object" && !Array.isArray(value)) {
-    return Object.fromEntries(
-      Object.entries(value as Record<string, unknown>).sort(([a], [b]) => a.localeCompare(b))
-    );
-  }
-  return value;
-}
-
 /**
  * Simple JSON to YAML converter
  */

package/src/cli/commands/diff.test.ts

@@ -86,7 +86,8 @@ export const myBucket = {
     const combined: Record<string, unknown> = {};
     const sortedSerializerNames = [...buildResult.outputs.keys()].sort();
     for (const serializerName of sortedSerializerNames) {
-      combined[serializerName] = JSON.parse(buildResult.outputs.get(serializerName)!);
+      const raw = buildResult.outputs.get(serializerName)!;
+      combined[serializerName] = JSON.parse(typeof raw === "string" ? raw : raw.primary);
     }
 
     // Sort keys to match diffCommand behavior

package/src/cli/commands/diff.ts

@@ -46,7 +46,8 @@ export async function diffCommand(options: DiffOptions): Promise<DiffResult> {
   const combined: Record<string, unknown> = {};
   const sortedLexiconNames = [...result.outputs.keys()].sort();
   for (const lexiconName of sortedLexiconNames) {
-    combined[lexiconName] = JSON.parse(result.outputs.get(lexiconName)!);
+    const raw = result.outputs.get(lexiconName)!;
+    combined[lexiconName] = JSON.parse(typeof raw === "string" ? raw : raw.primary);
   }
   const currentOutput = JSON.stringify(combined, sortedJsonReplacer, 2);
 

package/src/cli/commands/init-lexicon.test.ts

@@ -51,9 +51,6 @@ describe("initLexiconCommand", () => {
       "src/lsp/hover.ts",
       "src/lsp/completions.test.ts",
       "src/lsp/hover.test.ts",
-      "src/import/parser.ts",
-      "src/import/generator.ts",
-      "src/coverage.ts",
       "src/validate.ts",
       "src/validate-cli.ts",
       "package.json",
@@ -66,15 +63,9 @@ describe("initLexiconCommand", () => {
       "docs/astro.config.mjs",
       "docs/src/content.config.ts",
       "docs/src/content/docs/index.mdx",
-      "docs/src/content/docs/getting-started.mdx",
-      "docs/src/content/docs/serialization.mdx",
-      "docs/src/content/docs/lint-rules.mdx",
       "examples/getting-started/package.json",
       "examples/getting-started/src/infra.ts",
       "src/generated/.gitkeep",
-      "src/composites/.gitkeep",
-      "src/actions/.gitkeep",
-      "src/lint/post-synth/.gitkeep",
     ];
 
     for (const file of expectedFiles) {

package/src/cli/commands/init-lexicon.ts

@@ -498,49 +498,6 @@ export function hover(ctx: HoverContext): HoverInfo | undefined {
 `;
 }
 
-function generateImportParserTs(name: string): string {
-  return `import type { TemplateParser } from "@intentius/chant/import/parser";
-
-/**
- * Template parser for importing external ${name} templates.
- *
- * TODO: Implement the TemplateParser interface for your format.
- */
-// export class ${name.charAt(0).toUpperCase() + name.slice(1)}Parser implements TemplateParser {
-//   parse(data: unknown): IR { ... }
-// }
-`;
-}
-
-function generateImportGeneratorTs(name: string): string {
-  return `import type { TypeScriptGenerator } from "@intentius/chant/import/generator";
-
-/**
- * TypeScript generator for converting imported ${name} templates.
- *
- * TODO: Implement the TypeScriptGenerator interface for your format.
- */
-// export class ${name.charAt(0).toUpperCase() + name.slice(1)}Generator implements TypeScriptGenerator {
-//   generate(ir: IR): string { ... }
-// }
-`;
-}
-
-function generateCoverageTs(name: string): string {
-  return `/**
- * Coverage analysis for the ${name} lexicon.
- *
- * TODO: Implement coverage analysis that checks how much of the
- * upstream spec is covered by the generated types.
- */
-export async function analyzeCoverage(options?: { verbose?: boolean }): Promise<void> {
-  console.error("Coverage analysis not yet implemented");
-  // TODO: Read generated lexicon JSON, compare against upstream spec,
-  // and report coverage metrics.
-}
-`;
-}
-
 function generateValidateTs(name: string): string {
   return `/**
  * Validate generated lexicon-${name} artifacts.
@@ -795,41 +752,6 @@ function generateExampleInfraTs(name: string, names: ReturnType<typeof deriveNam
 `;
 }
 
-// ── Additional doc page generators ───────────────────────────────────
-
-function generateDocsGettingStartedMdx(name: string): string {
-  const displayName = name.charAt(0).toUpperCase() + name.slice(1);
-  return `---
-title: Getting Started
-description: Get started with the ${displayName} lexicon
----
-
-TODO: Document how to set up a project using the ${displayName} lexicon.
-`;
-}
-
-function generateDocsSerializationMdx(name: string): string {
-  const displayName = name.charAt(0).toUpperCase() + name.slice(1);
-  return `---
-title: Serialization
-description: ${displayName} output format
----
-
-TODO: Document the ${displayName} serialization format and output structure.
-`;
-}
-
-function generateDocsLintRulesMdx(name: string): string {
-  const displayName = name.charAt(0).toUpperCase() + name.slice(1);
-  return `---
-title: Lint Rules
-description: ${displayName} lint rules reference
----
-
-TODO: Document the lint rules provided by the ${displayName} lexicon.
-`;
-}
-
 // ── Docs site skeleton generators ────────────────────────────────────
 
 function generateDocsPackageJson(name: string): string {
@@ -879,9 +801,6 @@ export default defineConfig({
       title: '${displayName}',
       sidebar: [
         { label: 'Overview', slug: '' },
-        { label: 'Getting Started', slug: 'getting-started' },
-        { label: 'Serialization', slug: 'serialization' },
-        { label: 'Lint Rules', slug: 'lint-rules' },
       ],
     }),
   ],
@@ -953,10 +872,6 @@ export async function initLexiconCommand(options: InitLexiconOptions): Promise<I
     "src/lint",
     "src/lint/rules",
     "src/lsp",
-    "src/import",
-    "src/composites",
-    "src/actions",
-    "src/lint/post-synth",
     "src/generated",
     "docs",
     "docs/src",
@@ -991,9 +906,6 @@ export async function initLexiconCommand(options: InitLexiconOptions): Promise<I
     "src/lsp/hover.ts": generateLspHoverTs(name),
     "src/lsp/completions.test.ts": generateCompletionsTestTs(),
     "src/lsp/hover.test.ts": generateHoverTestTs(),
-    "src/import/parser.ts": generateImportParserTs(name),
-    "src/import/generator.ts": generateImportGeneratorTs(name),
-    "src/coverage.ts": generateCoverageTs(name),
     "src/plugin.test.ts": generatePluginTestTs(name, names),
     "src/serializer.test.ts": generateSerializerTestTs(name, names),
     "src/validate.ts": generateValidateTs(name),
@@ -1008,9 +920,6 @@ export async function initLexiconCommand(options: InitLexiconOptions): Promise<I
     "docs/astro.config.mjs": generateDocsAstroConfig(name),
     "docs/src/content.config.ts": generateDocsContentConfig(),
     "docs/src/content/docs/index.mdx": generateDocsIndexMdx(name),
-    "docs/src/content/docs/getting-started.mdx": generateDocsGettingStartedMdx(name),
-    "docs/src/content/docs/serialization.mdx": generateDocsSerializationMdx(name),
-    "docs/src/content/docs/lint-rules.mdx": generateDocsLintRulesMdx(name),
     "examples/getting-started/package.json": generateExamplePackageJson(name),
     "examples/getting-started/src/infra.ts": generateExampleInfraTs(name, names),
   };
@@ -1018,9 +927,6 @@ export async function initLexiconCommand(options: InitLexiconOptions): Promise<I
   // Write .gitkeep files
   const gitkeeps = [
     "src/generated/.gitkeep",
-    "src/composites/.gitkeep",
-    "src/actions/.gitkeep",
-    "src/lint/post-synth/.gitkeep",
   ];
 
   for (const gk of gitkeeps) {

package/src/cli/commands/init.ts

@@ -3,7 +3,6 @@ import { join, resolve, dirname } from "path";
 import { fileURLToPath } from "url";
 import { homedir } from "os";
 import { createInterface } from "readline";
-import { z } from "zod";
 import { formatSuccess, formatWarning } from "../format";
 import { loadPlugin } from "../plugins";
 
@@ -18,17 +17,6 @@ function getChantVersion(): string {
   }
 }
 
-/**
- * Schema for validating generated package.json — catches template bugs early.
- */
-const GeneratedPackageJsonSchema = z.object({
-  name: z.string().min(1),
-  version: z.string(),
-  type: z.literal("module"),
-  scripts: z.record(z.string(), z.string()),
-  dependencies: z.record(z.string(), z.string()),
-});
-
 /**
  * Init command options
  */
@@ -128,12 +116,6 @@ function generatePackageJson(lexicon: string, extraScripts?: Record<string, stri
     },
   };
 
-  // Validate generated output to catch template bugs
-  const result = GeneratedPackageJsonSchema.safeParse(pkg);
-  if (!result.success) {
-    throw new Error(`Bug: generated package.json is invalid: ${result.error.issues[0].message}`);
-  }
-
   return JSON.stringify(pkg, null, 2);
 }
 
@@ -240,7 +222,7 @@ export interface ChantConfig {
 /**
  * Generate MCP config
  */
-function generateMcpConfig(_ide: "claude-code" | "cursor" | "generic", pm: "bun" | "npm"): string {
+function generateMcpConfig(pm: "bun" | "npm"): string {
   const config = {
     mcpServers: {
       chant: {
@@ -454,7 +436,7 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
 
     writeIfNotExists(
       join(mcpDir, "mcp.json"),
-      generateMcpConfig(ide, detectPackageManager(targetDir)),
+      generateMcpConfig(detectPackageManager(targetDir)),
       `~/.${ide === "generic" ? "config/mcp" : ide}/mcp.json`,
       createdFiles,
       warnings,

package/src/cli/handlers/build.ts

@@ -1,5 +1,5 @@
 import { buildCommand, buildCommandWatch, printErrors, printWarnings } from "../commands/build";
-import { formatInfo } from "../format";
+import { formatError, formatInfo } from "../format";
 import type { CommandContext } from "../registry";
 
 export async function runBuild(ctx: CommandContext): Promise<number> {
@@ -10,14 +10,14 @@ export async function runBuild(ctx: CommandContext): Promise<number> {
   if (args.lexicon) {
     serializers = serializers.filter((s) => s.name === args.lexicon);
     if (serializers.length === 0) {
-      console.error(`No serializer found for lexicon "${args.lexicon}". Available: ${ctx.serializers.map((s) => s.name).join(", ")}`);
+      console.error(formatError({ message: `No serializer found for lexicon "${args.lexicon}". Available: ${ctx.serializers.map((s) => s.name).join(", ")}` }));
       return 1;
     }
   }
 
   const buildFormat = (args.format || "json") as "json" | "yaml";
   if (buildFormat !== "json" && buildFormat !== "yaml") {
-    console.error(`Invalid format for build: ${buildFormat}. Expected 'json' or 'yaml'.`);
+    console.error(formatError({ message: `Invalid format for build: ${buildFormat}. Expected 'json' or 'yaml'.` }));
     return 1;
   }
 

package/src/cli/handlers/lint.ts

@@ -1,5 +1,5 @@
 import { lintCommand, lintCommandWatch, printLintResult } from "../commands/lint";
-import { formatInfo } from "../format";
+import { formatError, formatInfo } from "../format";
 import type { CommandContext } from "../registry";
 
 export async function runLint(ctx: CommandContext): Promise<number> {
@@ -7,7 +7,7 @@ export async function runLint(ctx: CommandContext): Promise<number> {
 
   const lintFormat = (args.format || "stylish") as "stylish" | "json" | "sarif";
   if (lintFormat !== "stylish" && lintFormat !== "json" && lintFormat !== "sarif") {
-    console.error(`Invalid format for lint: ${lintFormat}. Expected 'stylish', 'json', or 'sarif'.`);
+    console.error(formatError({ message: `Invalid format for lint: ${lintFormat}. Expected 'stylish', 'json', or 'sarif'.` }));
     return 1;
   }