@intentius/chant 0.0.18 → 0.0.24

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

@@ -0,0 +1,182 @@
+/**
+ * Project-level template generators for init-lexicon scaffold.
+ */
+
+export function generatePackageJson(name: string, names: { packageName: string }): 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";
+}
+
+export function generateTsConfig(): string {
+  const config = {
+    extends: "../../tsconfig.json",
+    compilerOptions: {
+      rootDir: "./src",
+      outDir: "./dist",
+    },
+    include: ["src/**/*"],
+  };
+
+  return JSON.stringify(config, null, 2) + "\n";
+}
+
+export 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
+`;
+}
+
+export function generateGitignore(): string {
+  return `dist/
+node_modules/
+.cache/
+`;
+}
+
+export function generateReadme(name: string, names: { packageName: string }): 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)
+`;
+}
+
+export function generateSerializerTs(name: string, names: { serializerVarName: string; rulePrefix: string }): 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);
+  },
+};
+`;
+}
+
+export 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,
+  });
+}
+`;
+}
+
+export function generateValidateCliTs(): string {
+  return `#!/usr/bin/env bun
+import { validate } from "./validate";
+
+await validate({ verbose: true });
+`;
+}

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

@@ -0,0 +1,57 @@
+/**
+ * Spec template generators for init-lexicon scaffold.
+ */
+
+export 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"));
+}
+`;
+}
+
+export 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}\`);
+}
+`;
+}

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

@@ -0,0 +1,70 @@
+/**
+ * Test file template generators for init-lexicon scaffold.
+ */
+
+export function generatePluginTestTs(name: string, names: { pluginVarName: string }): 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();
+  });
+});
+`;
+}
+
+export function generateSerializerTestTs(name: string, names: { serializerVarName: string }): 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}");
+  });
+});
+`;
+}
+
+export 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);
+  });
+});
+`;
+}
+
+export 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();
+  });
+});
+`;
+}

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) {