@intentius/chant 0.0.18 → 0.0.24

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

@@ -2,6 +2,17 @@ import { existsSync, mkdirSync, writeFileSync, readdirSync } from "fs";
 import { join, resolve } from "path";
 import { formatSuccess, formatWarning } from "../format";
 
+// Template generators
+import { generatePluginTs, generateIndexTs } from "./init-lexicon/templates/plugin";
+import { generateCodegenGenerateTs, generateCodegenGenerateCliTs, generateCodegenNamingTs, generateCodegenPackageTs, generateCodegenDocsTs } from "./init-lexicon/templates/codegen";
+import { generateSpecFetchTs, generateSpecParseTs } from "./init-lexicon/templates/spec";
+import { generateSampleRuleTs, generateLintRulesIndexTs } from "./init-lexicon/templates/lint";
+import { generateLspCompletionsTs, generateLspHoverTs } from "./init-lexicon/templates/lsp";
+import { generatePackageJson, generateTsConfig, generateJustfile, generateGitignore, generateReadme, generateSerializerTs, generateValidateTs, generateValidateCliTs } from "./init-lexicon/templates/project";
+import { generatePluginTestTs, generateSerializerTestTs, generateCompletionsTestTs, generateHoverTestTs } from "./init-lexicon/templates/tests";
+import { generateDocsPackageJson, generateDocsTsConfig, generateDocsAstroConfig, generateDocsContentConfig, generateDocsIndexMdx } from "./init-lexicon/templates/docs";
+import { generateExamplePackageJson, generateExampleInfraTs } from "./init-lexicon/templates/examples";
+
 /**
  * Init-lexicon command options
  */
@@ -32,7 +43,7 @@ function toCamelCase(name: string): string {
   return name.replace(/[-_]+(.)/g, (_, c) => c.toUpperCase());
 }
 
-function deriveNames(name: string) {
+export function deriveNames(name: string) {
   const camel = toCamelCase(name);
   return {
     pluginVarName: `${camel}Plugin`,
@@ -59,860 +70,6 @@ function writeIfNotExists(
   }
 }
 
-// ── Template generators ──────────────────────────────────────────────
-
-function generatePluginTs(name: string, names: ReturnType<typeof deriveNames>): string {
-  return `import type { LexiconPlugin, SkillDefinition, IntrinsicDef } from "@intentius/chant/lexicon";
-import type { LintRule } from "@intentius/chant/lint/rule";
-import type { PostSynthCheck } from "@intentius/chant/lint/post-synth";
-import type { CompletionContext, CompletionItem, HoverContext, HoverInfo } from "@intentius/chant/lsp/types";
-import type { McpToolContribution, McpResourceContribution } from "@intentius/chant/mcp/types";
-import { ${names.serializerVarName} } from "./serializer";
-
-/**
- * ${name} lexicon plugin.
- *
- * Implements all required LexiconPlugin lifecycle methods.
- */
-export const ${names.pluginVarName}: LexiconPlugin = {
-  name: "${name}",
-  serializer: ${names.serializerVarName},
-
-  // ── 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");
-    const { printValidationResult } = await import("@intentius/chant/codegen/validate");
-    const result = await validate();
-    printValidationResult(result);
-  },
-
-  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");
-    const { writeBundleSpec } = await import("@intentius/chant/codegen/package");
-    const { join, dirname } = await import("path");
-    const { fileURLToPath } = await import("url");
-
-    const { spec, stats } = await packageLexicon(options);
-    const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
-    writeBundleSpec(spec, join(pkgDir, "dist"));
-
-    console.error(\`Packaged \${stats.resources} resources, \${stats.ruleCount} rules, \${stats.skillCount} skills\`);
-  },
-
-  // ── Optional extensions ────────────────────────────────────
-
-  lintRules() {
-    const { rules } = require("./lint/rules");
-    return rules;
-  },
-
-  postSynthChecks() {
-    return []; // TODO: Add post-synth checks
-  },
-
-  skills() {
-    return []; // TODO: Add skills
-  },
-
-  mcpTools() {
-    return []; // TODO: Implement MCP tools
-  },
-
-  mcpResources() {
-    return []; // TODO: Implement MCP resources
-  },
-
-  detectTemplate(data: unknown) {
-    return false; // TODO: Detect if a template belongs to this lexicon
-  },
-
-  completionProvider(ctx: CompletionContext) {
-    const { completions } = require("./lsp/completions");
-    return completions(ctx);
-  },
-
-  hoverProvider(ctx: HoverContext) {
-    const { hover } = require("./lsp/hover");
-    return hover(ctx);
-  },
-
-  async docs(options?) {
-    const { generateDocs } = await import("./codegen/docs");
-    return generateDocs(options);
-  },
-};
-`;
-}
-
-function generateIndexTs(names: ReturnType<typeof deriveNames>): string {
-  return `// Plugin
-export { ${names.pluginVarName} } from "./plugin";
-
-// Serializer
-export { ${names.serializerVarName} } from "./serializer";
-
-// Generated resources — export everything from generated index
-// After running \`chant generate\`, this re-exports all resource classes
-// export * from "./generated/index";
-`;
-}
-
-function generateSerializerTs(name: string, names: ReturnType<typeof deriveNames>): string {
-  return `import type { Serializer, Declarable } from "@intentius/chant";
-
-/**
- * ${name} serializer — produces minimal JSON output.
- *
- * TODO: Replace with your lexicon's output format.
- */
-export const ${names.serializerVarName}: Serializer = {
-  name: "${name}",
-  rulePrefix: "${names.rulePrefix}",
-
-  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);
-  },
-};
-`;
-}
-
-function generateCodegenGenerateTs(): string {
-  return `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,
-    },
-  });
-}
-`;
-}
-
-function generateCodegenGenerateCliTs(): string {
-  return `#!/usr/bin/env bun
-import { generate, writeGeneratedFiles } from "./generate";
-import { dirname } from "path";
-import { fileURLToPath } from "url";
-
-const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
-const result = await generate({ verbose: true });
-writeGeneratedFiles(result, pkgDir);
-`;
-}
-
-function generateCodegenNamingTs(): string {
-  return `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);
-}
-`;
-}
-
-function generateCodegenPackageTs(name: string): string {
-  return `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 ${name} 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: "${name}",
-      version: "0.0.1",
-    }),
-    srcDir,
-    collectSkills: () => new Map(),
-  });
-
-  console.error(\`Packaged \${stats.resources} resources, \${stats.ruleCount} rules\`);
-  return { spec, stats };
-}
-`;
-}
-
-function generateCodegenDocsTs(name: string): string {
-  return `import { docsPipeline, writeDocsSite } from "@intentius/chant/codegen/docs";
-
-/**
- * Generate documentation site for the ${name} lexicon.
- */
-export async function generateDocs(options?: { verbose?: boolean }): Promise<void> {
-  const config = {
-    name: "${name}",
-    displayName: "${name.charAt(0).toUpperCase() + name.slice(1)}",
-    description: "${name} lexicon documentation",
-    distDir: "./dist",
-    outDir: "./docs",
-    // TODO: Implement service grouping for your provider
-    serviceFromType: (type: string) => type.split("::")[1] ?? type,
-    // TODO: Implement resource documentation URLs
-    resourceTypeUrl: (type: string) => \`#\${type}\`,
-  };
-
-  const result = docsPipeline(config);
-  writeDocsSite(config, result);
-
-  if (options?.verbose) {
-    console.error("Documentation generated");
-  }
-}
-`;
-}
-
-function generateSpecFetchTs(): string {
-  return `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"));
-}
-`;
-}
-
-function generateSpecParseTs(): string {
-  return `/**
- * 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}\`);
-}
-`;
-}
-
-function generateSampleRuleTs(names: ReturnType<typeof deriveNames>): string {
-  return `import type { LintRule, LintDiagnostic, LintContext } from "@intentius/chant/lint/rule";
-
-/**
- * ${names.rulePrefix}001: Sample lint rule
- *
- * TODO: Replace with a real lint rule for your lexicon.
- */
-export const sampleRule: LintRule = {
-  id: "${names.rulePrefix}001",
-  severity: "warning",
-  category: "style",
-  description: "Sample lint rule — replace with real checks",
-
-  check(context: LintContext): LintDiagnostic[] {
-    // TODO: Implement rule logic
-    return [];
-  },
-};
-`;
-}
-
-function generateLintRulesIndexTs(): string {
-  return `export { sampleRule } from "./sample";
-`;
-}
-
-function generateLspCompletionsTs(name: string): string {
-  return `import type { CompletionContext, CompletionItem } from "@intentius/chant/lsp/types";
-// import { LexiconIndex, lexiconCompletions } from "@intentius/chant/lsp/lexicon-providers";
-
-/**
- * Provide LSP completions for ${name} 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, "${name} resource");
-  return [];
-}
-`;
-}
-
-function generateLspHoverTs(name: string): string {
-  return `import type { HoverContext, HoverInfo } from "@intentius/chant/lsp/types";
-// import { LexiconIndex, lexiconHover } from "@intentius/chant/lsp/lexicon-providers";
-
-/**
- * Provide LSP hover information for ${name} 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;
-}
-`;
-}
-
-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.
- *
- * Thin wrapper around the core validation framework
- * with ${name}-specific configuration.
- */
-
-import { dirname } from "path";
-import { fileURLToPath } from "url";
-import { validateLexiconArtifacts, type ValidateResult } from "@intentius/chant/codegen/validate";
-
-export type { ValidateCheck, ValidateResult } from "@intentius/chant/codegen/validate";
-
-// TODO: Add names of required entities for your lexicon
-const REQUIRED_NAMES: string[] = [];
-
-/**
- * Validate the generated lexicon-${name} artifacts.
- */
-export async function validate(opts?: { basePath?: string }): Promise<ValidateResult> {
-  const basePath = opts?.basePath ?? dirname(dirname(fileURLToPath(import.meta.url)));
-
-  return validateLexiconArtifacts({
-    lexiconJsonFilename: "lexicon-${name}.json",
-    requiredNames: REQUIRED_NAMES,
-    basePath,
-  });
-}
-`;
-}
-
-function generateValidateCliTs(): string {
-  return `#!/usr/bin/env bun
-import { validate } from "./validate";
-
-await validate({ verbose: true });
-`;
-}
-
-function generatePackageJson(name: string, names: ReturnType<typeof deriveNames>): string {
-  const pkg = {
-    name: names.packageName,
-    version: "0.0.1",
-    type: "module",
-    private: true,
-    files: ["src/", "dist/"],
-    exports: {
-      ".": "./src/index.ts",
-      "./*": "./src/*",
-      "./manifest": "./dist/manifest.json",
-      "./meta": "./dist/meta.json",
-      "./types": "./dist/types/index.d.ts",
-    },
-    scripts: {
-      generate: "bun run src/codegen/generate-cli.ts",
-      validate: "bun run src/validate-cli.ts",
-      docs: "bun src/codegen/docs-cli.ts",
-      prepack: "bun run generate && bun run validate",
-    },
-    dependencies: {
-      "@intentius/chant": "workspace:*",
-    },
-    devDependencies: {
-      typescript: "^5.9.3",
-    },
-  };
-
-  return JSON.stringify(pkg, null, 2) + "\n";
-}
-
-function generateTsConfig(): string {
-  const config = {
-    extends: "../../tsconfig.json",
-    compilerOptions: {
-      rootDir: "./src",
-      outDir: "./dist",
-    },
-    include: ["src/**/*"],
-  };
-
-  return JSON.stringify(config, null, 2) + "\n";
-}
-
-function generateJustfile(name: string): string {
-  return `# Default recipe - list all available commands
-default:
-    @just --list
-
-# Generate types and metadata from upstream schemas
-generate:
-    bun run src/codegen/generate-cli.ts
-
-# Validate generated artifacts
-validate:
-    bun run src/validate-cli.ts
-
-# Generate docs site, install deps, and start dev server
-docs:
-    bun run src/codegen/docs-cli.ts
-    bun install --cwd docs
-    bun --cwd docs dev
-
-# Build docs site for production
-docs-build:
-    bun run src/codegen/docs-cli.ts
-    bun install --cwd docs
-    bun --cwd docs build
-
-# Package the lexicon (generate + validate)
-package: generate validate
-`;
-}
-
-function generateGitignore(): string {
-  return `dist/
-node_modules/
-.cache/
-`;
-}
-
-function generateReadme(name: string, names: ReturnType<typeof deriveNames>): string {
-  return `# ${names.packageName}
-
-${name} lexicon plugin for [chant](https://github.com/intentius/chant).
-
-## Getting started
-
-\`\`\`bash
-# Generate types from upstream spec
-just generate
-
-# Validate generated artifacts
-just validate
-
-# Generate documentation
-just docs
-\`\`\`
-
-## Project structure
-
-- \`src/plugin.ts\` — LexiconPlugin with all lifecycle methods
-- \`src/serializer.ts\` — Build output serializer
-- \`src/codegen/\` — Code generation pipeline
-- \`src/spec/\` — Upstream schema fetching and parsing
-- \`src/lint/rules/\` — Lint rules
-- \`src/lsp/\` — LSP completions and hover
-- \`src/generated/\` — Generated artifacts (do not edit)
-`;
-}
-
-// ── Test file generators ─────────────────────────────────────────────
-
-function generatePluginTestTs(name: string, names: ReturnType<typeof deriveNames>): string {
-  return `import { describe, expect, it } from "bun:test";
-import { ${names.pluginVarName} } from "./plugin";
-import { isLexiconPlugin } from "@intentius/chant/lexicon";
-
-describe("${name} plugin", () => {
-  it("is a valid LexiconPlugin", () => {
-    expect(isLexiconPlugin(${names.pluginVarName})).toBe(true);
-  });
-
-  it("has the correct name", () => {
-    expect(${names.pluginVarName}.name).toBe("${name}");
-  });
-
-  it("has a serializer", () => {
-    expect(${names.pluginVarName}.serializer).toBeDefined();
-  });
-});
-`;
-}
-
-function generateSerializerTestTs(name: string, names: ReturnType<typeof deriveNames>): string {
-  return `import { describe, expect, it } from "bun:test";
-import { ${names.serializerVarName} } from "./serializer";
-
-describe("${name} serializer", () => {
-  it("serializes an empty map to valid JSON", () => {
-    const result = ${names.serializerVarName}.serialize(new Map());
-    expect(typeof result).toBe("string");
-    expect(() => JSON.parse(result)).not.toThrow();
-  });
-
-  it("has the correct name", () => {
-    expect(${names.serializerVarName}.name).toBe("${name}");
-  });
-});
-`;
-}
-
-function generateCompletionsTestTs(): string {
-  return `import { describe, expect, it } from "bun:test";
-import { completions } from "./completions";
-
-describe("LSP completions", () => {
-  it("returns an array", () => {
-    // TODO: Replace with a real CompletionContext
-    const result = completions({} as any);
-    expect(Array.isArray(result)).toBe(true);
-  });
-});
-`;
-}
-
-function generateHoverTestTs(): string {
-  return `import { describe, expect, it } from "bun:test";
-import { hover } from "./hover";
-
-describe("LSP hover", () => {
-  it("returns undefined for unknown context", () => {
-    // TODO: Replace with a real HoverContext
-    const result = hover({} as any);
-    expect(result).toBeUndefined();
-  });
-});
-`;
-}
-
-// ── Example generators ───────────────────────────────────────────────
-
-function generateExamplePackageJson(name: string): string {
-  return JSON.stringify(
-    {
-      name: `@intentius/chant-lexicon-${name}-example-getting-started`,
-      version: "0.0.1",
-      private: true,
-      dependencies: {
-        [`@intentius/chant-lexicon-${name}`]: "workspace:*",
-        "@intentius/chant": "workspace:*",
-      },
-    },
-    null,
-    2,
-  ) + "\n";
-}
-
-function generateExampleInfraTs(name: string, names: ReturnType<typeof deriveNames>): string {
-  return `/**
- * Getting-started example for the ${name} lexicon.
- *
- * TODO: Replace with a real infrastructure definition
- * that uses resources from the ${name} lexicon.
- */
-
-// import { SomeResource } from "${names.packageName}";
-//
-// export const myResource = SomeResource("example", {
-//   // properties...
-// });
-`;
-}
-
-// ── 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 {
-  return JSON.stringify(
-    {
-      name: `@intentius/chant-lexicon-${name}-docs`,
-      type: "module",
-      version: "0.0.1",
-      private: true,
-      scripts: {
-        dev: "astro dev",
-        build: "astro build",
-        preview: "astro preview",
-      },
-      dependencies: {
-        "@astrojs/starlight": "^0.37.6",
-        astro: "^5.6.1",
-        sharp: "^0.34.2",
-      },
-    },
-    null,
-    2,
-  ) + "\n";
-}
-
-function generateDocsTsConfig(): string {
-  return JSON.stringify(
-    {
-      extends: "astro/tsconfigs/strict",
-      include: [".astro/types.d.ts", "**/*"],
-      exclude: ["dist"],
-    },
-    null,
-    2,
-  ) + "\n";
-}
-
-function generateDocsAstroConfig(name: string): string {
-  const displayName = name.charAt(0).toUpperCase() + name.slice(1);
-  return `// @ts-check
-import { defineConfig } from 'astro/config';
-import starlight from '@astrojs/starlight';
-
-export default defineConfig({
-  integrations: [
-    starlight({
-      title: '${displayName}',
-      sidebar: [
-        { label: 'Overview', slug: '' },
-        { label: 'Getting Started', slug: 'getting-started' },
-        { label: 'Serialization', slug: 'serialization' },
-        { label: 'Lint Rules', slug: 'lint-rules' },
-      ],
-    }),
-  ],
-});
-`;
-}
-
-function generateDocsContentConfig(): string {
-  return `import { defineCollection } from 'astro:content';
-import { docsLoader } from '@astrojs/starlight/loaders';
-import { docsSchema } from '@astrojs/starlight/schema';
-
-export const collections = {
-  docs: defineCollection({ loader: docsLoader(), schema: docsSchema() }),
-};
-`;
-}
-
-function generateDocsIndexMdx(name: string): string {
-  const displayName = name.charAt(0).toUpperCase() + name.slice(1);
-  return `---
-title: Overview
-description: ${displayName} lexicon for chant
----
-
-Welcome to the ${displayName} lexicon documentation.
-
-Run \`just generate\` to populate this site with generated reference pages.
-`;
-}
-
 // ── Main command ─────────────────────────────────────────────────────
 
 /**
@@ -953,10 +110,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 +144,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 +158,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 +165,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) {