recipe-tmlanguage 0.3.2 → 0.3.4

package/bin/commands/generate.ts

@@ -0,0 +1,37 @@
+import { buildGrammar, serializeGrammar } from "#grammar";
+import { command, flag } from "@kjanat/dreamcli";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+import { cwd } from "node:process";
+
+const indentOf = (raw: string): "tab" | number => (raw === "tab" ? "tab" : Number(raw));
+const require = createRequire(import.meta.url);
+const DEFAULT_OUT = `${dirname(require.resolve("#pkg"))}/recipe.tmLanguage.json`;
+
+export const generateCmd = command("generate")
+	.description("Build the TextMate grammar from the tree-sitter-recipe vocabulary")
+	.flag("out", flag.string().alias("o").default(DEFAULT_OUT).describe("Output JSON path"))
+	.flag("indent", flag.enum(["tab", "2", "4"]).default("tab").describe("JSON indent"))
+	.flag("quiet", flag.boolean().alias("q").default(false).describe("Suppress stats on success"))
+	.action(({ flags, out }) => {
+		const { grammar, stats } = buildGrammar();
+		const serialized = serializeGrammar(grammar, indentOf(flags.indent));
+		const outAbs = resolve(cwd(), flags.out);
+		mkdirSync(dirname(outAbs), { recursive: true });
+		writeFileSync(outAbs, serialized);
+		const { json, jsonMode, log } = out;
+
+		if (jsonMode) {
+			json({ ok: true, outPath: outAbs, bytes: serialized.length, stats });
+			return;
+		}
+		if (flags.quiet) return;
+
+		log(`wrote ${outAbs}`);
+		log(`  ${stats.topLevelPatterns} top-level patterns · ${serialized.length} bytes`);
+		const v = stats.vocab;
+		log(
+			`  vocab: ${v.frequency} frequency · ${v.timing.single}+${v.timing.multi} timing · ${v.route.single}+${v.route.multi} route · ${v.dispensing.single}+${v.dispensing.multi} dispensing · ${v.forms.single}+${v.forms.multi} forms · ${v.compounding.single}+${v.compounding.multi} compounding · ${v.conditional.single}+${v.conditional.multi} conditional · ${v.warning} warning · ${v.units} units`,
+		);
+	});

package/bin/commands/verify.ts

@@ -0,0 +1,53 @@
+import { verify } from "#verifier";
+import { command, flag } from "@kjanat/dreamcli";
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+import { cwd, exit } from "node:process";
+
+const require = createRequire(import.meta.url);
+const TS_RX_DIR = resolve(dirname(require.resolve("tree-sitter-recipe/package.json")));
+const DEFAULT_FIXTURES_DIR = resolve(TS_RX_DIR, "test/highlight");
+const DEFAULT_ONIG_WASM = require.resolve("vscode-oniguruma/release/onig.wasm");
+const DEFAULT_OUT = `${dirname(require.resolve("#pkg"))}/recipe.tmLanguage.json`;
+
+export const verifyCmd = command("verify")
+	.description("Tokenize tree-sitter-recipe highlight fixtures and assert scope matches")
+	.flag("grammar", flag.string().alias("g").default(DEFAULT_OUT).describe("Path to .tmLanguage.json"))
+	.flag("fixtures", flag.string().alias("f").default(DEFAULT_FIXTURES_DIR).describe("Directory of .recipe fixtures"))
+	.flag("onig-wasm", flag.string().default(DEFAULT_ONIG_WASM).describe("Path to oniguruma WASM"))
+	.flag("max-failures", flag.number().default(40).describe("Max failures to print (0 = all)"))
+	.action(async ({ flags, out }) => {
+		const result = await verify({
+			grammarPath: resolve(cwd(), flags.grammar),
+			fixturesDir: resolve(cwd(), flags.fixtures),
+			onigWasmPath: resolve(cwd(), flags["onig-wasm"]),
+		});
+		const failuresLen = result.failures.length;
+		const { json, jsonMode, setExitCode, log } = out;
+
+		if (jsonMode) {
+			json(result);
+			if (failuresLen > 0) {
+				setExitCode(1);
+				exit();
+			}
+			return;
+		}
+
+		log(`${result.pass} / ${result.total} assertions pass`);
+		if (failuresLen === 0) return;
+
+		log("");
+		log("── failures ──");
+		const limit = flags["max-failures"] === 0 ? failuresLen : flags["max-failures"];
+		for (const f of result.failures.slice(0, limit)) {
+			const gotStr = f.got
+				? f.got.filter((s) => s !== "source.recipe").join(" · ") || "(root only)"
+				: "(no token)";
+			log(`  ${f.fixture}:${f.line}:${f.col}  expected ${f.capture}  got [${gotStr}]`);
+		}
+		if (failuresLen > limit) {
+			log(`  … +${failuresLen - limit} more`);
+		}
+		setExitCode(1);
+	});

package/bin/recipe-tmlang.mjs

@@ -0,0 +1,468 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { COUNTERS, NUMBER_WORDS, PERIODS, PERIOD_PLURALS } from "tree-sitter-recipe/grammar/dutch";
+import { COMPOUNDING, COMPOUNDING_MULTIWORD, CONDITIONAL, CONDITIONAL_MULTIWORD, DISPENSING, DISPENSING_MULTIWORD, FORMS, FORMS_MULTIWORD, FREQUENCY, ROUTE, ROUTE_MULTIWORD, TIMING, TIMING_MULTIWORD, WARNING } from "tree-sitter-recipe/grammar/latin";
+import { UNITS } from "tree-sitter-recipe/grammar/units";
+import { cli, command, flag } from "@kjanat/dreamcli";
+import { mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { cwd, exit } from "node:process";
+//#region src/grammar.ts
+/**
+* @file Pure grammar builder — imports the tree-sitter-recipe vocabulary and
+* compiles it into a TextMate grammar object. No filesystem I/O; the CLI
+* handles serialization and writes.
+*
+* Scopes are standard TextMate names with a `.recipe` suffix so themes paint
+* recipe blocks without a custom theme shipment.
+*/
+const SCOPE = {
+	rxMarker: "keyword.control.directive.rx.recipe",
+	dispenseMarker: "keyword.control.directive.dispense.recipe",
+	signaMarker: "keyword.control.directive.signa.recipe",
+	frequency: "keyword.other.frequency.recipe",
+	timing: "keyword.other.timing.recipe",
+	route: "support.function.route.recipe",
+	dispensing: "entity.other.attribute-name.recipe",
+	warning: "invalid.illegal.warning.recipe",
+	form: "storage.type.form.recipe",
+	compounding: "keyword.operator.compounding.recipe",
+	conditional: "keyword.control.conditional.recipe",
+	fillMarker: "keyword.operator.fill.recipe",
+	dtdKeyword: "keyword.operator.dtd.recipe",
+	number: "constant.numeric.recipe",
+	unit: "support.type.unit.recipe",
+	lineComment: "comment.line.number-sign.recipe",
+	docCommentLine: "comment.line.documentation.recipe",
+	blockComment: "comment.block.recipe",
+	docCommentBlock: "comment.block.documentation.recipe",
+	punctuation: "punctuation.separator.recipe",
+	ingredientWord: "variable.other.ingredient.recipe",
+	signaWord: "string.unquoted.signa.recipe",
+	dispenseWord: "variable.other.dispense.recipe"
+};
+const REGEX_METACHARS = /[.*+?^${}()|[\]\\]/g;
+const escapeRegex = (s) => s.replace(REGEX_METACHARS, "\\$&");
+const alt = (items) => [...new Set(items)].sort((a, b) => b.length - a.length).map(escapeRegex).join("|");
+const altMultiword = (items) => [...new Set(items)].sort((a, b) => b.length - a.length).map((s) => escapeRegex(s).replace(/\s+/g, "\\s+")).join("|");
+const wb = (pattern) => `(?<![\\w.])(?:${pattern})(?![\\w.])`;
+function buildGrammar() {
+	const doseMatch = {
+		match: `(\\d+(?:[.,]\\d+)?)\\s*(${alt(UNITS)})(?![A-Za-zÀ-ÿ])`,
+		captures: {
+			"1": { name: SCOPE.number },
+			"2": { name: SCOPE.unit }
+		}
+	};
+	const bareNumber = {
+		match: "\\d+(?:[.,]\\d+)?",
+		name: SCOPE.number
+	};
+	const compactFrequency = {
+		match: "[1-9]\\s*dd(?![A-Za-zÀ-ÿ0-9])",
+		name: SCOPE.frequency
+	};
+	const fillTo = {
+		match: "\\bad\\b(?=\\s+\\d)",
+		name: SCOPE.fillMarker
+	};
+	const dtdDirective = {
+		match: "(?i)(?<![\\w.])(d\\.?t\\.?d\\.?)(?:\\s+(no))?(?=\\s+\\d)",
+		captures: {
+			"1": { name: SCOPE.dtdKeyword },
+			"2": { name: SCOPE.dtdKeyword }
+		}
+	};
+	const warningAbbrev = {
+		match: wb(alt(WARNING)),
+		name: SCOPE.warning
+	};
+	const latinAbbrevs = [
+		{
+			match: wb(altMultiword(TIMING_MULTIWORD)),
+			name: SCOPE.timing
+		},
+		{
+			match: wb(altMultiword(ROUTE_MULTIWORD)),
+			name: SCOPE.route
+		},
+		{
+			match: wb(altMultiword(DISPENSING_MULTIWORD)),
+			name: SCOPE.dispensing
+		},
+		{
+			match: wb(altMultiword(FORMS_MULTIWORD)),
+			name: SCOPE.form
+		},
+		{
+			match: wb(altMultiword(COMPOUNDING_MULTIWORD)),
+			name: SCOPE.compounding
+		},
+		{
+			match: wb(altMultiword(CONDITIONAL_MULTIWORD)),
+			name: SCOPE.conditional
+		},
+		{
+			match: wb(alt(FREQUENCY)),
+			name: SCOPE.frequency
+		},
+		{
+			match: wb(alt(TIMING)),
+			name: SCOPE.timing
+		},
+		{
+			match: wb(alt(ROUTE)),
+			name: SCOPE.route
+		},
+		{
+			match: wb(alt(DISPENSING)),
+			name: SCOPE.dispensing
+		},
+		{
+			match: wb(alt(FORMS)),
+			name: SCOPE.form
+		},
+		{
+			match: wb(alt(COMPOUNDING)),
+			name: SCOPE.compounding
+		},
+		{
+			match: wb(alt(CONDITIONAL)),
+			name: SCOPE.conditional
+		}
+	];
+	const punctuation = {
+		match: "[-.,;:()]",
+		name: SCOPE.punctuation
+	};
+	const comments = [
+		{
+			name: SCOPE.docCommentBlock,
+			begin: "/\\*\\*",
+			end: "\\*/"
+		},
+		{
+			name: SCOPE.blockComment,
+			begin: "/\\*",
+			end: "\\*/"
+		},
+		{
+			name: SCOPE.docCommentLine,
+			match: "#!.*$"
+		},
+		{
+			name: SCOPE.lineComment,
+			match: "#.*$"
+		}
+	];
+	const period = alt(PERIODS);
+	const dutchFrequency = [
+		{
+			match: `(?i)\\bom[ \\t]+de(?:[ \\t]+andere)?(?:[ \\t]+\\d+)?[ \\t]+(?:${alt([...PERIOD_PLURALS, ...PERIODS])})\\b`,
+			name: SCOPE.frequency
+		},
+		{
+			match: `(?i)\\b\\d+[ \\t]*(?:${alt(COUNTERS)})[ \\t]+(?:per[ \\t]+(?:${period})|daags)\\b`,
+			name: SCOPE.frequency
+		},
+		{
+			match: `(?i)\\b(?:${alt(NUMBER_WORDS)})[ \\t]*maal(?:[ \\t]+(?:daags|per[ \\t]+(?:${period})))?\\b`,
+			name: SCOPE.frequency
+		}
+	];
+	const sharedAtoms = [
+		...comments,
+		warningAbbrev,
+		dtdDirective,
+		fillTo,
+		compactFrequency,
+		...dutchFrequency,
+		doseMatch,
+		...latinAbbrevs,
+		bareNumber,
+		punctuation
+	];
+	/**
+	* Sections end only at the literal next marker (R/, Da/, D/, S/) or EOF.
+	* The trailing slash is load-bearing: without it, `s\b` inside `s.o.s.`
+	* would spuriously close a signa section because `.` is non-word.
+	*/
+	const nextSection = "(?i)(?=R/|Da?/|S/)|\\z";
+	const makeSection = (begin, marker, wordScope) => ({
+		name: `meta.section.${wordScope.split(".")[2] ?? "unknown"}.recipe`,
+		begin,
+		beginCaptures: { "0": { name: marker } },
+		end: nextSection,
+		patterns: [...sharedAtoms, {
+			match: "[A-Za-zÀ-ÿ][A-Za-zÀ-ÿ0-9\\-]*",
+			name: wordScope
+		}]
+	});
+	const rxSection = makeSection("(?i)R/", SCOPE.rxMarker, SCOPE.ingredientWord);
+	const dispenseSection = makeSection("(?i)Da?/", SCOPE.dispenseMarker, SCOPE.dispenseWord);
+	const signaSection = makeSection("(?i)S/", SCOPE.signaMarker, SCOPE.signaWord);
+	const grammar = {
+		$schema: "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+		name: "Recipe",
+		scopeName: "source.recipe",
+		fileTypes: ["recipe"],
+		patterns: [
+			...comments,
+			rxSection,
+			dispenseSection,
+			signaSection,
+			warningAbbrev
+		],
+		repository: {
+			comments: { patterns: comments },
+			"shared-atoms": { patterns: sharedAtoms }
+		}
+	};
+	return {
+		grammar,
+		stats: {
+			topLevelPatterns: countPatterns(grammar.patterns),
+			vocab: {
+				frequency: FREQUENCY.length,
+				timing: {
+					single: TIMING.length,
+					multi: TIMING_MULTIWORD.length
+				},
+				route: {
+					single: ROUTE.length,
+					multi: ROUTE_MULTIWORD.length
+				},
+				dispensing: {
+					single: DISPENSING.length,
+					multi: DISPENSING_MULTIWORD.length
+				},
+				forms: {
+					single: FORMS.length,
+					multi: FORMS_MULTIWORD.length
+				},
+				compounding: {
+					single: COMPOUNDING.length,
+					multi: COMPOUNDING_MULTIWORD.length
+				},
+				conditional: {
+					single: CONDITIONAL.length,
+					multi: CONDITIONAL_MULTIWORD.length
+				},
+				warning: WARNING.length,
+				units: UNITS.length
+			}
+		}
+	};
+}
+function countPatterns(patterns) {
+	let n = 0;
+	for (const p of patterns) {
+		n += 1;
+		if ("patterns" in p && p.patterns) n += countPatterns(p.patterns);
+	}
+	return n;
+}
+function serializeGrammar(g, indent) {
+	return `${JSON.stringify(g, null, indent === "tab" ? "	" : indent)}\n`;
+}
+//#endregion
+//#region bin/commands/generate.ts
+const indentOf = (raw) => raw === "tab" ? "tab" : Number(raw);
+const DEFAULT_OUT$1 = `${dirname(createRequire(import.meta.url).resolve("#pkg"))}/recipe.tmLanguage.json`;
+const generateCmd = command("generate").description("Build the TextMate grammar from the tree-sitter-recipe vocabulary").flag("out", flag.string().alias("o").default(DEFAULT_OUT$1).describe("Output JSON path")).flag("indent", flag.enum([
+	"tab",
+	"2",
+	"4"
+]).default("tab").describe("JSON indent")).flag("quiet", flag.boolean().alias("q").default(false).describe("Suppress stats on success")).action(({ flags, out }) => {
+	const { grammar, stats } = buildGrammar();
+	const serialized = serializeGrammar(grammar, indentOf(flags.indent));
+	const outAbs = resolve(cwd(), flags.out);
+	mkdirSync(dirname(outAbs), { recursive: true });
+	writeFileSync(outAbs, serialized);
+	const { json, jsonMode, log } = out;
+	if (jsonMode) {
+		json({
+			ok: true,
+			outPath: outAbs,
+			bytes: serialized.length,
+			stats
+		});
+		return;
+	}
+	if (flags.quiet) return;
+	log(`wrote ${outAbs}`);
+	log(`  ${stats.topLevelPatterns} top-level patterns · ${serialized.length} bytes`);
+	const v = stats.vocab;
+	log(`  vocab: ${v.frequency} frequency · ${v.timing.single}+${v.timing.multi} timing · ${v.route.single}+${v.route.multi} route · ${v.dispensing.single}+${v.dispensing.multi} dispensing · ${v.forms.single}+${v.forms.multi} forms · ${v.compounding.single}+${v.compounding.multi} compounding · ${v.conditional.single}+${v.conditional.multi} conditional · ${v.warning} warning · ${v.units} units`);
+});
+//#endregion
+//#region src/verifier.ts
+/**
+* @file Pure verifier — tokenizes tree-sitter-recipe's own highlight fixtures
+* with the generated TextMate grammar and reports whether each caret assertion
+* lands on a matching scope.
+*
+* No CLI concerns here; the caller supplies paths and decides how to present
+* the result (text table / JSON / exit code).
+*/
+const require$1 = createRequire(import.meta.url);
+const oniguruma = require$1("vscode-oniguruma");
+const { parseRawGrammar, Registry } = require$1("vscode-textmate");
+const CAPTURE_EXPECTS = {
+	"keyword.directive": "keyword.control.directive",
+	"keyword.repeat": "keyword.other.frequency",
+	"keyword.error": "invalid.illegal.warning",
+	"keyword.operator": "keyword.operator",
+	"keyword.conditional": "keyword.control.conditional",
+	"keyword": "keyword.other.timing",
+	"function.macro": "support.function.route",
+	"attribute": "entity.other.attribute-name",
+	"type": "storage.type.form",
+	"type.builtin": "support.type.unit",
+	"number": "constant.numeric",
+	"variable": "variable.other.ingredient",
+	"string": "string.unquoted.signa",
+	"comment": "comment",
+	"comment.documentation": "comment",
+	"punctuation.delimiter": "punctuation.separator"
+};
+const ASSERT_RE = /^\s*#\s*(<-|\^+)\s+([\w.]+)\s*$/;
+const COMMENT_ONLY_RE = /^\s*#/;
+function parseFixture(content, name) {
+	const rawLines = content.split(/\r?\n/);
+	const sourceLines = [];
+	const asserts = [];
+	const sourceLineIndexForRawLine = [];
+	for (const raw of rawLines) if (!COMMENT_ONLY_RE.test(raw)) {
+		sourceLines.push(raw);
+		sourceLineIndexForRawLine.push(sourceLines.length);
+	} else sourceLineIndexForRawLine.push(sourceLines.length);
+	for (let i = 0; i < rawLines.length; i++) {
+		const raw = rawLines[i] ?? "";
+		if (!COMMENT_ONLY_RE.test(raw)) continue;
+		const match = raw.match(ASSERT_RE);
+		if (!match) continue;
+		const [, kind, capture] = match;
+		if (!kind || !capture) continue;
+		const targetLine = sourceLineIndexForRawLine[i] ?? 0;
+		if (targetLine === 0) continue;
+		const col = kind === "<-" ? 0 : raw.indexOf("^");
+		asserts.push({
+			fixture: name,
+			targetLine,
+			col,
+			capture
+		});
+	}
+	return {
+		source: sourceLines.join("\n"),
+		asserts
+	};
+}
+async function verify(opts) {
+	const wasmBin = readFileSync(opts.onigWasmPath);
+	await oniguruma.loadWASM(wasmBin.buffer);
+	const onigLib = Promise.resolve({
+		createOnigScanner: (patterns) => new oniguruma.OnigScanner(patterns),
+		createOnigString: (s) => new oniguruma.OnigString(s)
+	});
+	const rawGrammar = parseRawGrammar(readFileSync(opts.grammarPath, "utf-8"), opts.grammarPath);
+	const grammar = await new Registry({
+		onigLib,
+		loadGrammar: () => Promise.resolve(null)
+	}).addGrammar(rawGrammar);
+	const result = {
+		pass: 0,
+		total: 0,
+		failures: []
+	};
+	for (const name of readdirSync(opts.fixturesDir).sort()) {
+		if (!name.endsWith(".recipe")) continue;
+		const { source, asserts } = parseFixture(readFileSync(resolve(opts.fixturesDir, name), "utf-8"), name);
+		const sourceLines = source.split("\n");
+		let ruleStack = null;
+		const perLine = [];
+		for (const line of sourceLines) {
+			const r = grammar.tokenizeLine(line, ruleStack);
+			perLine.push(r.tokens.map((t) => ({
+				start: t.startIndex,
+				end: t.endIndex,
+				scopes: [...t.scopes]
+			})));
+			ruleStack = r.ruleStack;
+		}
+		for (const a of asserts) {
+			result.total += 1;
+			const tokens = perLine[a.targetLine - 1];
+			const hit = tokens?.find((t) => a.col >= t.start && a.col < t.end) ?? tokens?.find((t) => a.col === t.end);
+			const expected = CAPTURE_EXPECTS[a.capture];
+			if (!!(hit && expected && hit.scopes.some((s) => s.startsWith(expected)))) result.pass += 1;
+			else result.failures.push({
+				fixture: a.fixture,
+				line: a.targetLine,
+				col: a.col,
+				capture: a.capture,
+				got: hit ? hit.scopes : null
+			});
+		}
+	}
+	return result;
+}
+//#endregion
+//#region bin/commands/verify.ts
+const require = createRequire(import.meta.url);
+const DEFAULT_FIXTURES_DIR = resolve(resolve(dirname(require.resolve("tree-sitter-recipe/package.json"))), "test/highlight");
+const DEFAULT_ONIG_WASM = require.resolve("vscode-oniguruma/release/onig.wasm");
+const DEFAULT_OUT = `${dirname(require.resolve("#pkg"))}/recipe.tmLanguage.json`;
+const verifyCmd = command("verify").description("Tokenize tree-sitter-recipe highlight fixtures and assert scope matches").flag("grammar", flag.string().alias("g").default(DEFAULT_OUT).describe("Path to .tmLanguage.json")).flag("fixtures", flag.string().alias("f").default(DEFAULT_FIXTURES_DIR).describe("Directory of .recipe fixtures")).flag("onig-wasm", flag.string().default(DEFAULT_ONIG_WASM).describe("Path to oniguruma WASM")).flag("max-failures", flag.number().default(40).describe("Max failures to print (0 = all)")).action(async ({ flags, out }) => {
+	const result = await verify({
+		grammarPath: resolve(cwd(), flags.grammar),
+		fixturesDir: resolve(cwd(), flags.fixtures),
+		onigWasmPath: resolve(cwd(), flags["onig-wasm"])
+	});
+	const failuresLen = result.failures.length;
+	const { json, jsonMode, setExitCode, log } = out;
+	if (jsonMode) {
+		json(result);
+		if (failuresLen > 0) {
+			setExitCode(1);
+			exit();
+		}
+		return;
+	}
+	log(`${result.pass} / ${result.total} assertions pass`);
+	if (failuresLen === 0) return;
+	log("");
+	log("── failures ──");
+	const limit = flags["max-failures"] === 0 ? failuresLen : flags["max-failures"];
+	for (const f of result.failures.slice(0, limit)) {
+		const gotStr = f.got ? f.got.filter((s) => s !== "source.recipe").join(" · ") || "(root only)" : "(no token)";
+		log(`  ${f.fixture}:${f.line}:${f.col}  expected ${f.capture}  got [${gotStr}]`);
+	}
+	if (failuresLen > limit) log(`  … +${failuresLen - limit} more`);
+	setExitCode(1);
+});
+//#endregion
+//#region bin/recipe-tmlang.ts
+/**
+* recipe-tmlang — TextMate grammar generator & verifier for recipe-tmlanguage.
+*
+* Subcommands
+* - generate:   Build dist/recipe.tmLanguage.json from the tree-sitter-recipe vocab.
+* - verify:     Tokenize tree-sitter-recipe's highlight fixtures and assert scopes.
+*
+* Zero manual argparse — argument parsing, help, and completions all come from
+* {@link https://github.com/kjanat/dreamcli | DreamCLI}. `--json` is a DreamCLI built-in;
+* we branch on {@linkcode out.jsonMode | https://dreamcli.kjanat.com/reference/symbols/main/Out#jsonmode}.
+*/
+const app = cli("recipe-tmlanguage").packageJson({
+	repository: {
+		"type": "git",
+		"url": "git+https://github.com/kjanat/recipe-tmlanguage.git"
+	},
+	homepage: "https://github.com/kjanat/recipe-tmlanguage#recipe-tmlanguage",
+	version: "0.3.4"
+}).links().description("TextMate grammar generator & verifier for the recipe DSL").command(generateCmd).command(verifyCmd).completions();
+if (import.meta.main) app.run();
+//#endregion
+export {};

package/bin/recipe-tmlang.ts

@@ -8,98 +8,16 @@
  *
  * Zero manual argparse — argument parsing, help, and completions all come from
  * {@link https://github.com/kjanat/dreamcli | DreamCLI}. `--json` is a DreamCLI built-in;
- * we branch on {@linkcode Out.jsonMode}.
+ * we branch on {@linkcode out.jsonMode | https://dreamcli.kjanat.com/reference/symbols/main/Out#jsonmode}.
  */
-import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { cwd, exit } from "node:process";
-import { fileURLToPath } from "node:url";
+import { generateCmd } from "#bin/commands/generate";
+import { verifyCmd } from "#bin/commands/verify";
+import { homepage, name, repository, version } from "#pkg" with { type: "json" };
+import { cli } from "@kjanat/dreamcli";
 
-import { cli, command, flag } from "dreamcli";
-import type { Out } from "dreamcli";
-
-import { buildGrammar, serializeGrammar } from "#grammar";
-import { verify } from "#verifier";
-
-import { homepage, repository, version } from "#pkg" with { type: "json" };
-
-const DEFAULT_OUT = `${resolve(import.meta.dirname, "..")}/recipe.tmLanguage.json`;
-
-const TS_RX_DIR = resolve(dirname(fileURLToPath(import.meta.resolve("tree-sitter-recipe/package.json"))));
-const DEFAULT_FIXTURES_DIR = resolve(TS_RX_DIR, "test/highlight");
-const DEFAULT_ONIG_WASM = fileURLToPath(import.meta.resolve("vscode-oniguruma/release/onig.wasm"));
-
-const indentOf = (raw: string): "tab" | number => (raw === "tab" ? "tab" : Number(raw));
-
-const generate = command("generate")
-	.description("Build the TextMate grammar from the tree-sitter-recipe vocabulary")
-	.flag("out", flag.string().alias("o").default(DEFAULT_OUT).describe("Output JSON path"))
-	.flag("indent", flag.enum(["tab", "2", "4"]).default("tab").describe("JSON indent"))
-	.flag("quiet", flag.boolean().alias("q").default(false).describe("Suppress stats on success"))
-	.action(({ flags, out }) => {
-		const { grammar, stats } = buildGrammar();
-		const serialized = serializeGrammar(grammar, indentOf(flags.indent));
-		const outAbs = resolve(cwd(), flags.out);
-		mkdirSync(dirname(outAbs), { recursive: true });
-		writeFileSync(outAbs, serialized);
-		if (out.jsonMode) {
-			out.json({ ok: true, outPath: outAbs, bytes: serialized.length, stats });
-			return;
-		}
-		if (flags.quiet) return;
-
-		out.log(`wrote ${outAbs}`);
-		out.log(`  ${stats.topLevelPatterns} top-level patterns · ${serialized.length} bytes`);
-		const v = stats.vocab;
-		out.log(
-			`  vocab: ${v.frequency} frequency · ${v.timing.single}+${v.timing.multi} timing · ${v.route.single}+${v.route.multi} route · ${v.dispensing.single}+${v.dispensing.multi} dispensing · ${v.forms.single}+${v.forms.multi} forms · ${v.compounding.single}+${v.compounding.multi} compounding · ${v.conditional.single}+${v.conditional.multi} conditional · ${v.warning} warning · ${v.units} units`,
-		);
-	});
-
-const verifyCmd = command("verify")
-	.description("Tokenize tree-sitter-recipe highlight fixtures and assert scope matches")
-	.flag("grammar", flag.string().alias("g").default(DEFAULT_OUT).describe("Path to .tmLanguage.json"))
-	.flag("fixtures", flag.string().alias("f").default(DEFAULT_FIXTURES_DIR).describe("Directory of .recipe fixtures"))
-	.flag("onig-wasm", flag.string().default(DEFAULT_ONIG_WASM).describe("Path to oniguruma WASM"))
-	.flag("max-failures", flag.number().default(40).describe("Max failures to print (0 = all)"))
-	.action(async ({ flags, out }) => {
-		const result = await verify({
-			grammarPath: resolve(cwd(), flags.grammar),
-			fixturesDir: resolve(cwd(), flags.fixtures),
-			onigWasmPath: resolve(cwd(), flags["onig-wasm"]),
-		});
-		const failuresLen = result.failures.length;
-
-		if (out.jsonMode) {
-			out.json(result);
-			if (failuresLen > 0) {
-				out.setExitCode(1);
-				exit();
-			}
-			return;
-		}
-
-		out.log(`${result.pass} / ${result.total} assertions pass`);
-		if (failuresLen === 0) return;
-
-		out.log("");
-		out.log("── failures ──");
-		const limit = flags["max-failures"] === 0 ? failuresLen : flags["max-failures"];
-		for (const f of result.failures.slice(0, limit)) {
-			const gotStr = f.got
-				? f.got.filter((s) => s !== "source.recipe").join(" · ") || "(root only)"
-				: "(no token)";
-			out.log(`  ${f.fixture}:${f.line}:${f.col}  expected ${f.capture}  got [${gotStr}]`);
-		}
-		if (failuresLen > limit) {
-			out.log(`  … +${failuresLen - limit} more`);
-		}
-		out.setExitCode(1);
-	});
-
-export const app = cli("recipe-tmlang").packageJson({ repository, homepage, version }).links()
+const app = cli(name).packageJson({ repository, homepage, version }).links()
 	.description("TextMate grammar generator & verifier for the recipe DSL")
-	.command(generate)
+	.command(generateCmd)
 	.command(verifyCmd)
 	.completions();
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "recipe-tmlanguage",
-	"version": "0.3.2",
+	"version": "0.3.4",
 	"description": "TextMate grammar for the recipe (.recipe) pharmacological notation language.",
 	"keywords": [
 		"dreamcli",
@@ -21,6 +21,7 @@
 	},
 	"type": "module",
 	"imports": {
+		"#bin/*": "./bin/*.ts",
 		"#pkg": "./package.json",
 		"#grammar": "./src/grammar.ts",
 		"#verifier": "./src/verifier.ts"
@@ -53,11 +54,12 @@
 		"lint": "biome lint",
 		"prepack": "bun run generate && bun run bundle",
 		"recipe-tmlang": "bun bin/recipe-tmlang.ts",
+		"test": "bun test",
 		"typecheck": "tsc --noEmit",
 		"verify": "run recipe-tmlang verify"
 	},
 	"dependencies": {
-		"dreamcli": "npm:@kjanat/dreamcli@^2.4.0",
+		"@kjanat/dreamcli": "^2.4.1",
 		"tree-sitter-recipe": "^0.3.1",
 		"vscode-oniguruma": "^2.0.1",
 		"vscode-textmate": "^9.2.0"

package/src/grammar.ts

@@ -74,7 +74,7 @@ const alt = (items: readonly string[]): string =>
 const altMultiword = (items: readonly string[]): string =>
 	[...new Set(items)]
 		.sort((a, b) => b.length - a.length)
-		.map((s) => s.replace(/\./g, "\\.").replace(/\s+/g, "\\s+"))
+		.map((s) => escapeRegex(s).replace(/\s+/g, "\\s+"))
 		.join("|");
 
 // Word boundary that treats `.` as part of the token so `a.c.` doesn't match

package/src/verifier.ts

@@ -117,7 +117,7 @@ export async function verify(opts: VerifyOptions): Promise<VerifyResult> {
 		readFileSync(opts.grammarPath, "utf-8"),
 		opts.grammarPath,
 	);
-	const registry = new Registry({ onigLib, loadGrammar: async () => null });
+	const registry = new Registry({ onigLib, loadGrammar: () => Promise.resolve(null) });
 	const grammar = await registry.addGrammar(rawGrammar);
 
 	const result: VerifyResult = { pass: 0, total: 0, failures: [] };