@intentius/chant 0.0.1

package/src/cli/commands/__fixtures__/init-lexicon-output/src/codegen/naming.ts

@@ -0,0 +1,33 @@
+import { NamingStrategy, type NamingConfig, type NamingInput } from "@intentius/chant/codegen/naming";
+
+/**
+ * Naming configuration for this lexicon.
+ *
+ * TODO: Populate these tables with your provider's naming conventions.
+ */
+export const namingConfig: NamingConfig = {
+  // High-priority short names for common resource types
+  priorityNames: {},
+
+  // Aliases for resource types that need alternate names
+  priorityAliases: {},
+
+  // Aliases for property types
+  priorityPropertyAliases: {},
+
+  // Abbreviations for service names (used in collision resolution)
+  serviceAbbreviations: {},
+
+  // Extract the short name from a fully-qualified type string
+  shortName: (typeName: string) => typeName.split("::").pop()!,
+
+  // Extract the service name from a fully-qualified type string
+  serviceName: (typeName: string) => typeName.split("::")[1] ?? typeName,
+};
+
+/**
+ * Create a NamingStrategy instance from parsed results.
+ */
+export function createNaming(inputs: NamingInput[]): NamingStrategy {
+  return new NamingStrategy(inputs, namingConfig);
+}

package/src/cli/commands/__fixtures__/init-lexicon-output/src/codegen/package.ts

@@ -0,0 +1,25 @@
+import { packagePipeline } from "@intentius/chant/codegen/package";
+import type { PackagePipelineConfig } from "@intentius/chant/codegen/package";
+import { generate } from "./generate";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+
+/**
+ * Package the fixture lexicon for distribution.
+ */
+export async function packageLexicon(options?: { verbose?: boolean; force?: boolean }) {
+  const srcDir = dirname(fileURLToPath(import.meta.url));
+
+  const { spec, stats } = await packagePipeline({
+    generate: (opts) => generate({ verbose: opts?.verbose, force: opts?.force }),
+    buildManifest: (genResult) => ({
+      name: "fixture",
+      version: "0.0.1",
+    }),
+    srcDir,
+    collectSkills: () => new Map(),
+  });
+
+  console.error(`Packaged ${stats.resources} resources, ${stats.ruleCount} rules`);
+  return { spec, stats };
+}

package/src/cli/commands/__fixtures__/init-lexicon-output/src/codegen/rollback.ts

@@ -0,0 +1,45 @@
+import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, cpSync } from "fs";
+import { join, basename } from "path";
+
+export interface Snapshot {
+  timestamp: string;
+  resources: number;
+  path: string;
+}
+
+/**
+ * List available generation snapshots.
+ */
+export function listSnapshots(snapshotsDir: string): Snapshot[] {
+  if (!existsSync(snapshotsDir)) return [];
+
+  return readdirSync(snapshotsDir)
+    .filter((d) => !d.startsWith("."))
+    .sort()
+    .reverse()
+    .map((dir) => {
+      const fullPath = join(snapshotsDir, dir);
+      const metaPath = join(fullPath, "meta.json");
+      let resources = 0;
+      if (existsSync(metaPath)) {
+        try {
+          const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+          resources = meta.resources ?? 0;
+        } catch {}
+      }
+      return { timestamp: dir, resources, path: fullPath };
+    });
+}
+
+/**
+ * Restore a snapshot to the generated directory.
+ */
+export function restoreSnapshot(timestamp: string, generatedDir: string): void {
+  const snapshotsDir = join(generatedDir, "..", "..", ".snapshots");
+  const snapshotDir = join(snapshotsDir, timestamp);
+  if (!existsSync(snapshotDir)) {
+    throw new Error(`Snapshot not found: ${timestamp}`);
+  }
+  mkdirSync(generatedDir, { recursive: true });
+  cpSync(snapshotDir, generatedDir, { recursive: true });
+}

package/src/cli/commands/__fixtures__/init-lexicon-output/src/coverage.ts

@@ -0,0 +1,11 @@
+/**
+ * Coverage analysis for the fixture 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.
+}

package/src/cli/commands/__fixtures__/init-lexicon-output/src/import/generator.ts

@@ -0,0 +1,10 @@
+import type { TypeScriptGenerator } from "@intentius/chant/import/generator";
+
+/**
+ * TypeScript generator for converting imported fixture templates.
+ *
+ * TODO: Implement the TypeScriptGenerator interface for your format.
+ */
+// export class FixtureGenerator implements TypeScriptGenerator {
+//   generate(ir: IR): string { ... }
+// }

package/src/cli/commands/__fixtures__/init-lexicon-output/src/import/parser.ts

@@ -0,0 +1,10 @@
+import type { TemplateParser } from "@intentius/chant/import/parser";
+
+/**
+ * Template parser for importing external fixture templates.
+ *
+ * TODO: Implement the TemplateParser interface for your format.
+ */
+// export class FixtureParser implements TemplateParser {
+//   parse(data: unknown): IR { ... }
+// }

package/src/cli/commands/__fixtures__/init-lexicon-output/src/index.ts

@@ -0,0 +1,9 @@
+// Plugin
+export { fixturePlugin } from "./plugin";
+
+// Serializer
+export { fixtureSerializer } from "./serializer";
+
+// Generated resources — export everything from generated index
+// After running `chant generate`, this re-exports all resource classes
+// export * from "./generated/index";

package/src/cli/commands/__fixtures__/init-lexicon-output/src/lint/rules/index.ts

@@ -0,0 +1 @@
+export { sampleRule } from "./sample";

package/src/cli/commands/__fixtures__/init-lexicon-output/src/lint/rules/sample.ts

@@ -0,0 +1,18 @@
+import type { LintRule, LintDiagnostic, LintContext } from "@intentius/chant/lint/rule";
+
+/**
+ * FIX001: Sample lint rule
+ *
+ * TODO: Replace with a real lint rule for your lexicon.
+ */
+export const sampleRule: LintRule = {
+  id: "FIX001",
+  severity: "warning",
+  category: "style",
+  description: "Sample lint rule — replace with real checks",
+
+  check(context: LintContext): LintDiagnostic[] {
+    // TODO: Implement rule logic
+    return [];
+  },
+};

package/src/cli/commands/__fixtures__/init-lexicon-output/src/lsp/completions.ts

@@ -0,0 +1,14 @@
+import type { CompletionContext, CompletionItem } from "@intentius/chant/lsp/types";
+// import { LexiconIndex, lexiconCompletions } from "@intentius/chant/lsp/lexicon-providers";
+
+/**
+ * Provide LSP completions for fixture resources.
+ *
+ * TODO: Build a LexiconIndex from your generated lexicon data
+ * and delegate to lexiconCompletions().
+ */
+export function completions(ctx: CompletionContext): CompletionItem[] {
+  // const index = new LexiconIndex(lexiconData);
+  // return lexiconCompletions(ctx, index, "fixture resource");
+  return [];
+}

package/src/cli/commands/__fixtures__/init-lexicon-output/src/lsp/hover.ts

@@ -0,0 +1,14 @@
+import type { HoverContext, HoverInfo } from "@intentius/chant/lsp/types";
+// import { LexiconIndex, lexiconHover } from "@intentius/chant/lsp/lexicon-providers";
+
+/**
+ * Provide LSP hover information for fixture resources.
+ *
+ * TODO: Build a LexiconIndex from your generated lexicon data
+ * and delegate to lexiconHover().
+ */
+export function hover(ctx: HoverContext): HoverInfo | undefined {
+  // const index = new LexiconIndex(lexiconData);
+  // return lexiconHover(ctx, index, myCustomHoverFormatter);
+  return undefined;
+}

package/src/cli/commands/__fixtures__/init-lexicon-output/src/plugin.ts

@@ -0,0 +1,110 @@
+import type { LexiconPlugin } from "@intentius/chant/lexicon";
+import { fixtureSerializer } from "./serializer";
+
+/**
+ * fixture lexicon plugin.
+ *
+ * Implements all required LexiconPlugin lifecycle methods.
+ */
+export const fixturePlugin: LexiconPlugin = {
+  name: "fixture",
+  serializer: fixtureSerializer,
+
+  // ── Required lifecycle methods ────────────────────────────────
+
+  async generate(options?: { verbose?: boolean }): Promise<void> {
+    const { generate } = await import("./codegen/generate");
+    await generate(options);
+  },
+
+  async validate(options?: { verbose?: boolean }): Promise<void> {
+    const { validate } = await import("./validate");
+    await validate(options);
+  },
+
+  async coverage(options?: { verbose?: boolean; minOverall?: number }): Promise<void> {
+    // TODO: Implement coverage analysis
+    console.error("Coverage analysis not yet implemented");
+  },
+
+  async package(options?: { verbose?: boolean; force?: boolean }): Promise<void> {
+    const { packageLexicon } = await import("./codegen/package");
+    await packageLexicon(options);
+  },
+
+  async rollback(options?: { restore?: string; verbose?: boolean }): Promise<void> {
+    const { listSnapshots, restoreSnapshot } = await import("./codegen/rollback");
+    const { join, dirname } = await import("path");
+    const { fileURLToPath } = await import("url");
+
+    const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
+    const snapshotsDir = join(pkgDir, ".snapshots");
+
+    if (options?.restore) {
+      const generatedDir = join(pkgDir, "src", "generated");
+      restoreSnapshot(String(options.restore), generatedDir);
+      console.error(`Restored snapshot: ${options.restore}`);
+    } else {
+      const snapshots = listSnapshots(snapshotsDir);
+      if (snapshots.length === 0) {
+        console.error("No snapshots available.");
+      } else {
+        console.error(`Available snapshots (${snapshots.length}):`);
+        for (const s of snapshots) {
+          console.error(`  ${s.timestamp}  ${s.resources} resources  ${s.path}`);
+        }
+      }
+    }
+  },
+
+  // ── Optional extensions (uncomment and implement as needed) ───
+
+  // lintRules(): LintRule[] {
+  //   return [];
+  // },
+
+  // declarativeRules(): RuleSpec[] {
+  //   return [];
+  // },
+
+  // postSynthChecks(): PostSynthCheck[] {
+  //   return [];
+  // },
+
+  // intrinsics(): IntrinsicDef[] {
+  //   return [];
+  // },
+
+  // pseudoParameters(): string[] {
+  //   return [];
+  // },
+
+  // detectTemplate(data: unknown): boolean {
+  //   return false;
+  // },
+
+  // templateParser(): TemplateParser {
+  //   // return new MyParser();
+  // },
+
+  // templateGenerator(): TypeScriptGenerator {
+  //   // return new MyGenerator();
+  // },
+
+  // skills(): SkillDefinition[] {
+  //   return [];
+  // },
+
+  // completionProvider(ctx: CompletionContext): CompletionItem[] {
+  //   return [];
+  // },
+
+  // hoverProvider(ctx: HoverContext): HoverInfo | undefined {
+  //   return undefined;
+  // },
+
+  // docs(options?: { verbose?: boolean }): Promise<void> {
+  //   const { generateDocs } = await import("./codegen/docs");
+  //   return generateDocs(options);
+  // },
+};

package/src/cli/commands/__fixtures__/init-lexicon-output/src/serializer.ts

@@ -0,0 +1,24 @@
+import type { Serializer, Declarable } from "@intentius/chant";
+
+/**
+ * fixture serializer — produces minimal JSON output.
+ *
+ * TODO: Replace with your lexicon's output format.
+ */
+export const fixtureSerializer: Serializer = {
+  name: "fixture",
+  rulePrefix: "FIX",
+
+  serialize(entities: Map<string, Declarable>): string {
+    const resources: Record<string, unknown> = {};
+
+    for (const [entityName, entity] of entities) {
+      resources[entityName] = {
+        type: entity.entityType,
+        // TODO: Convert entity properties to your output format
+      };
+    }
+
+    return JSON.stringify({ resources }, null, 2);
+  },
+};

package/src/cli/commands/__fixtures__/init-lexicon-output/src/spec/fetch.ts

@@ -0,0 +1,21 @@
+import { fetchWithCache, extractFromZip } from "@intentius/chant/codegen/fetch";
+
+// TODO: Set this to your upstream schema source URL
+const SCHEMA_URL = "https://example.com/schemas.zip";
+const CACHE_FILE = ".cache/schemas.zip";
+
+/**
+ * Fetch upstream schemas with caching.
+ *
+ * TODO: Point SCHEMA_URL at your real upstream schema source.
+ */
+export async function fetchSchemas(options?: { force?: boolean }): Promise<Map<string, string>> {
+  const zipData = await fetchWithCache({
+    url: SCHEMA_URL,
+    cacheFile: CACHE_FILE,
+    force: options?.force,
+  });
+
+  // TODO: Adjust the filter to match your schema file names
+  return extractFromZip(zipData, (name) => name.endsWith(".json"));
+}

package/src/cli/commands/__fixtures__/init-lexicon-output/src/spec/parse.ts

@@ -0,0 +1,25 @@
+/**
+ * Parsed schema result for a single schema file.
+ */
+export interface ParseResult {
+  typeName: string;
+  description?: string;
+  properties: Map<string, ParsedProperty>;
+  attributes: string[];
+}
+
+export interface ParsedProperty {
+  name: string;
+  type: string;
+  required: boolean;
+  description?: string;
+}
+
+/**
+ * Parse a single schema file into a ParseResult.
+ *
+ * TODO: Implement parsing for your schema format.
+ */
+export function parseSchema(name: string, content: string): ParseResult {
+  throw new Error(`TODO: implement parseSchema for ${name}`);
+}

package/src/cli/commands/__fixtures__/init-lexicon-output/src/validate-cli.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env bun
+import { validate } from "./validate";
+
+await validate({ verbose: true });

package/src/cli/commands/__fixtures__/init-lexicon-output/src/validate.ts

@@ -0,0 +1,24 @@
+/**
+ * Validate generated artifacts for the fixture lexicon.
+ *
+ * TODO: Add validation checks for your generated files.
+ */
+export async function validate(options?: { verbose?: boolean }): Promise<void> {
+  const checks = [
+    // TODO: Add checks — e.g. verify lexicon JSON exists, types compile,
+    // registry has expected resources, etc.
+    { name: "placeholder", ok: true, error: undefined as string | undefined },
+  ];
+
+  for (const check of checks) {
+    const status = check.ok ? "OK" : "FAIL";
+    const msg = check.error ? ` — ${check.error}` : "";
+    console.error(`  [${status}] ${check.name}${msg}`);
+  }
+
+  const failed = checks.filter((c) => !c.ok);
+  if (failed.length > 0) {
+    throw new Error("Validation failed");
+  }
+  console.error("All validation checks passed.");
+}

package/src/cli/commands/__fixtures__/init-lexicon-output/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist"
+  },
+  "include": [
+    "src/**/*"
+  ]
+}

package/src/cli/commands/__fixtures__/sample-rule.ts

@@ -0,0 +1,11 @@
+export const sampleRule = {
+  id: "TEST001",
+  severity: "warning" as const,
+  category: "style" as const,
+  check() {
+    return [];
+  },
+};
+
+// Non-rule export — should be silently skipped by the loader
+export const notARule = { foo: "bar" };

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

@@ -0,0 +1,222 @@
+// Bun Snapshot v1, https://bun.sh/docs/test/snapshots
+
+exports[`init-lexicon fixture snapshot fixture generate.ts matches snapshot 1`] = `
+"import { generatePipeline, writeGeneratedArtifacts } from "@intentius/chant/codegen/generate";
+import type { GenerateResult } from "@intentius/chant/codegen/generate";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+
+/**
+ * Run the code generation pipeline.
+ *
+ * Each callback has a TODO describing what to implement.
+ */
+export async function generate(options?: { verbose?: boolean }): Promise<GenerateResult> {
+  const result = await generatePipeline({
+    // Must return Map<typeName, Buffer> — each entry is one schema file.
+    // Example: fetch a zip, extract JSON files, key by type name.
+    // See lexicons/aws/src/spec/fetch.ts for a working example.
+    fetchSchemas: async (opts) => {
+      throw new Error("TODO: implement fetchSchemas — download your upstream spec");
+    },
+
+    // Must return a ParsedResult (with propertyTypes[] and enums[] at minimum).
+    // Return null to skip a schema file.
+    // See lexicons/aws/src/spec/parse.ts for a working example.
+    parseSchema: (name, data) => {
+      throw new Error("TODO: implement parseSchema — parse a single schema file");
+    },
+
+    // Must return a NamingStrategy instance.
+    // See lexicons/aws/src/codegen/naming.ts and ./naming.ts for setup.
+    createNaming: (results) => {
+      throw new Error("TODO: implement createNaming — return a NamingStrategy instance");
+    },
+
+    // Must return a string of JSON (the lexicon registry).
+    // Use buildRegistry + serializeRegistry from @intentius/chant/codegen/generate-registry.
+    // See lexicons/aws/src/codegen/generate.ts for a working example.
+    generateRegistry: (results, naming) => {
+      throw new Error("TODO: implement generateRegistry — produce lexicon JSON");
+    },
+
+    // Must return a string of TypeScript declarations (.d.ts content).
+    // See lexicons/aws/src/codegen/generate.ts for a working example.
+    generateTypes: (results, naming) => {
+      throw new Error("TODO: implement generateTypes — produce .d.ts content");
+    },
+
+    // Must return a string of TypeScript (runtime index with factory exports).
+    // Use generateRuntimeIndex from @intentius/chant/codegen/generate-runtime-index.
+    // See lexicons/aws/src/codegen/generate.ts for a working example.
+    generateRuntimeIndex: (results, naming) => {
+      throw new Error("TODO: implement generateRuntimeIndex — produce index.ts content");
+    },
+  });
+
+  if (options?.verbose) {
+    console.error(\`Generated \${result.resources} resources, \${result.properties} property types\`);
+  }
+
+  return result;
+}
+
+/**
+ * Write generated files to the package directory.
+ */
+export function writeGeneratedFiles(result: GenerateResult, pkgDir?: string): void {
+  const dir = pkgDir ?? dirname(dirname(fileURLToPath(import.meta.url)));
+  writeGeneratedArtifacts({
+    baseDir: dir,
+    files: {
+      "lexicon.json": result.lexiconJSON,
+      "index.d.ts": result.typesDTS,
+      "index.ts": result.indexTS,
+    },
+  });
+}
+"
+`;
+
+exports[`init-lexicon fixture snapshot fixture package.ts matches snapshot 1`] = `
+"import { packagePipeline } from "@intentius/chant/codegen/package";
+import type { PackagePipelineConfig } from "@intentius/chant/codegen/package";
+import { generate } from "./generate";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+
+/**
+ * Package the fixture lexicon for distribution.
+ */
+export async function packageLexicon(options?: { verbose?: boolean; force?: boolean }) {
+  const srcDir = dirname(fileURLToPath(import.meta.url));
+
+  const { spec, stats } = await packagePipeline({
+    generate: (opts) => generate({ verbose: opts?.verbose, force: opts?.force }),
+    buildManifest: (genResult) => ({
+      name: "fixture",
+      version: "0.0.1",
+    }),
+    srcDir,
+    collectSkills: () => new Map(),
+  });
+
+  console.error(\`Packaged \${stats.resources} resources, \${stats.ruleCount} rules\`);
+  return { spec, stats };
+}
+"
+`;
+
+exports[`init-lexicon fixture snapshot fixture plugin.ts matches snapshot 1`] = `
+"import type { LexiconPlugin } from "@intentius/chant/lexicon";
+import { fixtureSerializer } from "./serializer";
+
+/**
+ * fixture lexicon plugin.
+ *
+ * Implements all required LexiconPlugin lifecycle methods.
+ */
+export const fixturePlugin: LexiconPlugin = {
+  name: "fixture",
+  serializer: fixtureSerializer,
+
+  // ── Required lifecycle methods ────────────────────────────────
+
+  async generate(options?: { verbose?: boolean }): Promise<void> {
+    const { generate } = await import("./codegen/generate");
+    await generate(options);
+  },
+
+  async validate(options?: { verbose?: boolean }): Promise<void> {
+    const { validate } = await import("./validate");
+    await validate(options);
+  },
+
+  async coverage(options?: { verbose?: boolean; minOverall?: number }): Promise<void> {
+    // TODO: Implement coverage analysis
+    console.error("Coverage analysis not yet implemented");
+  },
+
+  async package(options?: { verbose?: boolean; force?: boolean }): Promise<void> {
+    const { packageLexicon } = await import("./codegen/package");
+    await packageLexicon(options);
+  },
+
+  async rollback(options?: { restore?: string; verbose?: boolean }): Promise<void> {
+    const { listSnapshots, restoreSnapshot } = await import("./codegen/rollback");
+    const { join, dirname } = await import("path");
+    const { fileURLToPath } = await import("url");
+
+    const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
+    const snapshotsDir = join(pkgDir, ".snapshots");
+
+    if (options?.restore) {
+      const generatedDir = join(pkgDir, "src", "generated");
+      restoreSnapshot(String(options.restore), generatedDir);
+      console.error(\`Restored snapshot: \${options.restore}\`);
+    } else {
+      const snapshots = listSnapshots(snapshotsDir);
+      if (snapshots.length === 0) {
+        console.error("No snapshots available.");
+      } else {
+        console.error(\`Available snapshots (\${snapshots.length}):\`);
+        for (const s of snapshots) {
+          console.error(\`  \${s.timestamp}  \${s.resources} resources  \${s.path}\`);
+        }
+      }
+    }
+  },
+
+  // ── Optional extensions (uncomment and implement as needed) ───
+
+  // lintRules(): LintRule[] {
+  //   return [];
+  // },
+
+  // declarativeRules(): RuleSpec[] {
+  //   return [];
+  // },
+
+  // postSynthChecks(): PostSynthCheck[] {
+  //   return [];
+  // },
+
+  // intrinsics(): IntrinsicDef[] {
+  //   return [];
+  // },
+
+  // pseudoParameters(): string[] {
+  //   return [];
+  // },
+
+  // detectTemplate(data: unknown): boolean {
+  //   return false;
+  // },
+
+  // templateParser(): TemplateParser {
+  //   // return new MyParser();
+  // },
+
+  // templateGenerator(): TypeScriptGenerator {
+  //   // return new MyGenerator();
+  // },
+
+  // skills(): SkillDefinition[] {
+  //   return [];
+  // },
+
+  // completionProvider(ctx: CompletionContext): CompletionItem[] {
+  //   return [];
+  // },
+
+  // hoverProvider(ctx: HoverContext): HoverInfo | undefined {
+  //   return undefined;
+  // },
+
+  // docs(options?: { verbose?: boolean }): Promise<void> {
+  //   const { generateDocs } = await import("./codegen/docs");
+  //   return generateDocs(options);
+  // },
+};
+"
+`;