@intentius/chant 0.0.22 → 0.0.24

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();
+  });
+});
+`;
+}