gherkin-cli 0.0.0

package/dist/cli.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+//#region src/cli.d.ts
+declare function main(argv: string[]): Promise<void>;
+//#endregion
+export { main };

package/dist/cli.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+import { a as diffFeatures, i as GitError, n as parseFeatures, r as parseFeaturesAst, t as validateFeatures } from "./validate-BjVkCi7A.js";
+import { Command, CommanderError } from "commander";
+
+//#region src/output.ts
+/** Line threshold above which a rendered TOON result is truncated (never JSON). */
+const TRUNCATE_THRESHOLD = 50;
+const INDENT = "  ";
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isScalar(value) {
+	return value === null || value === void 0 || typeof value !== "object";
+}
+function isScalarArray(value) {
+	return Array.isArray(value) && value.every(isScalar);
+}
+function isObjectArray(value) {
+	return Array.isArray(value) && value.length > 0 && value.every(isPlainObject);
+}
+/** A tabular object array has only scalar or scalar-array fields — no nesting. */
+function isSimpleObjectArray(value) {
+	return isObjectArray(value) && value.every((item) => Object.values(item).every((field) => isScalar(field) || isScalarArray(field)));
+}
+function needsQuote(text) {
+	return text === "" || /[,:\s[\]{}"]/.test(text);
+}
+/** Render a single scalar, quoting strings that carry commas/spaces/structure. */
+function formatScalar(value) {
+	if (value === null || value === void 0) return "null";
+	if (typeof value === "boolean" || typeof value === "number") return String(value);
+	const text = String(value);
+	return needsQuote(text) ? `"${text.replace(/"/g, "\\\"")}"` : text;
+}
+function formatInlineArray(items) {
+	return `[${items.map(formatScalar).join(",")}]`;
+}
+function columnUnion(items) {
+	const cols = [];
+	for (const item of items) for (const key of Object.keys(item)) if (!cols.includes(key)) cols.push(key);
+	return cols;
+}
+function formatCell(value) {
+	if (isScalarArray(value)) return formatInlineArray(value);
+	if (value === void 0) return "";
+	return formatScalar(value);
+}
+function encodeObject(obj, indent, lines) {
+	const pad = INDENT.repeat(indent);
+	for (const [key, value] of Object.entries(obj)) if (Array.isArray(value)) if (isSimpleObjectArray(value)) {
+		const cols = columnUnion(value);
+		lines.push(`${pad}${key}[${value.length}]{${cols.join(",")}}:`);
+		const rowPad = INDENT.repeat(indent + 1);
+		for (const item of value) lines.push(rowPad + cols.map((col) => formatCell(item[col])).join(","));
+	} else if (isObjectArray(value)) {
+		lines.push(`${pad}${key}[${value.length}]:`);
+		for (const item of value) encodeListItem(item, indent + 1, lines);
+	} else lines.push(`${pad}${key}: ${formatInlineArray(value)}`);
+	else if (isPlainObject(value)) {
+		lines.push(`${pad}${key}:`);
+		encodeObject(value, indent + 1, lines);
+	} else lines.push(`${pad}${key}: ${formatScalar(value)}`);
+}
+function encodeListItem(item, indent, lines) {
+	const start = lines.length;
+	encodeObject(item, indent, lines);
+	const firstPad = INDENT.repeat(indent);
+	const markerPad = INDENT.repeat(indent - 1) + "- ";
+	const first = lines[start];
+	if (first !== void 0) lines[start] = markerPad + first.slice(firstPad.length);
+}
+/** Encode a plain data object as deterministic TOON. */
+function encodeToon(data) {
+	const lines = [];
+	if (isPlainObject(data)) encodeObject(data, 0, lines);
+	else lines.push(formatScalar(data));
+	return lines.join("\n");
+}
+/** Render a result in the requested machine format. */
+function render(data, format) {
+	return format === "json" ? JSON.stringify(data, null, 2) : encodeToon(data);
+}
+/** Truncate an over-long TOON result with a size hint; JSON is never truncated. */
+function truncate(text, opts) {
+	if (opts.format === "json" || opts.full) return text;
+	const lines = text.split("\n");
+	if (lines.length <= TRUNCATE_THRESHOLD) return text;
+	const kept = lines.slice(0, TRUNCATE_THRESHOLD);
+	const remaining = lines.length - TRUNCATE_THRESHOLD;
+	kept.push(`… +${remaining} lines — rerun with --full`);
+	return kept.join("\n");
+}
+function writeLine(stream, text) {
+	stream.write(text.endsWith("\n") ? text : text + "\n");
+}
+/** Write the machine result to STDOUT (the only thing that goes there). */
+function writeResult(text, out = process.stdout) {
+	writeLine(out, text);
+}
+/** Write a human affordance (next-step, warning) to STDERR. */
+function writeStderr(text, err = process.stderr) {
+	writeLine(err, text);
+}
+/** Print a structured error to STDERR honoring the format, then exit 1. */
+function fail(code, message, format = "toon", opts = {}) {
+	writeStderr(format === "json" ? JSON.stringify({ error: {
+		code,
+		message
+	} }, null, 2) : `error: true\ncode: ${code}\nmessage: ${formatScalar(message)}`, opts.err);
+	(opts.exit ?? process.exit)(1);
+}
+
+//#endregion
+//#region src/cli.ts
+function resolveFormat(raw) {
+	return raw === "json" ? "json" : "toon";
+}
+/** Best-effort format read for the error path, before commander has parsed. */
+function preScanFormat(argv) {
+	const i = argv.indexOf("--format");
+	return i >= 0 && argv[i + 1] === "json" ? "json" : "toon";
+}
+function emit(data, format, full) {
+	writeResult(truncate(render(data, format), {
+		full,
+		format
+	}));
+}
+function addFormat(cmd) {
+	return cmd.option("--format <fmt>", "output format: toon | json", "toon");
+}
+function buildProgram() {
+	const program = new Command();
+	program.name("gherkin-cli").description("Agent-first Gherkin CLI — parse, validate, and diff .feature files.").option("--format <fmt>", "output format: toon | json", "toon");
+	addFormat(program.command("parse").description("Project .feature files to a token-efficient summary").argument("<files...>", ".feature files to parse").option("--full", "include stepCount, exampleRows, and steps").option("--tag <name>", "keep only scenarios carrying this tag").option("--ast", "dump the raw GherkinDocument JSON (ignores projection)")).addHelpText("after", "\nExample:\n  $ gherkin-cli parse features/login.feature --tag @smoke").action((files, opts, command) => {
+		const format = resolveFormat(command.optsWithGlobals().format);
+		const full = Boolean(opts.full);
+		if (opts.ast) {
+			const ast = parseFeaturesAst(files);
+			const missing$1 = ast.find((f) => f.error?.code === "ENOENT");
+			if (missing$1) return fail("ENOENT", `file not found: ${missing$1.file}`, format);
+			return writeResult(render(ast, "json"));
+		}
+		const result = parseFeatures(files, {
+			full,
+			tag: opts.tag
+		});
+		const missing = result.files.find((f) => f.error?.code === "ENOENT");
+		if (missing) return fail("ENOENT", `file not found: ${missing.file}`, format);
+		emit(result, format, full);
+		if (result.summary.files === 0 || result.summary.scenarios === 0) writeStderr(`0 scenarios across ${result.summary.files} files`);
+		writeStderr(`→ gherkin-cli diff --base <ref> ${files.join(" ")}`);
+	});
+	addFormat(program.command("validate").description("Validate .feature syntax (the CI/gate verb)").argument("<files...>", ".feature files to validate")).addHelpText("after", "\nExample:\n  $ gherkin-cli validate features/login.feature").action((files, _opts, command) => {
+		const format = resolveFormat(command.optsWithGlobals().format);
+		const result = validateFeatures(files);
+		emit(result, format, false);
+		if (result.summary.errors === 0) {
+			writeStderr("0 errors");
+			writeStderr(`→ gherkin-cli parse ${files.join(" ")}`);
+			return;
+		}
+		writeStderr(`→ ${result.summary.errors} error(s) across ${result.summary.files} file(s)`);
+		process.exit(1);
+	});
+	addFormat(program.command("diff").description("Classify scenario changes against a base git ref").argument("<files...>", ".feature files to diff").requiredOption("--base <ref>", "base git ref to compare against").option("--full", "include unchanged scenarios in full detail")).addHelpText("after", "\nExample:\n  $ gherkin-cli diff features/login.feature --base HEAD~1").action((files, opts, command) => {
+		const format = resolveFormat(command.optsWithGlobals().format);
+		const full = Boolean(opts.full);
+		let result;
+		try {
+			result = diffFeatures(files, { base: opts.base });
+		} catch (err) {
+			if (err instanceof GitError) return fail("EGIT", err.message, format);
+			throw err;
+		}
+		emit(result, format, full);
+		const { added, modified, removed } = result.summary;
+		if (added + modified + removed === 0) {
+			writeStderr("0 changes (all unchanged)");
+			writeStderr(`→ gherkin-cli parse ${files.join(" ")}`);
+			return;
+		}
+		writeStderr(`→ review ${added} added / ${modified} modified / ${removed} removed scenario(s)`);
+	});
+	return program;
+}
+async function main(argv) {
+	const program = buildProgram();
+	const silence = { writeErr: () => {} };
+	program.exitOverride().configureOutput(silence);
+	for (const cmd of program.commands) cmd.exitOverride().configureOutput(silence);
+	if (argv.length === 0) {
+		writeStderr(program.helpInformation());
+		return;
+	}
+	try {
+		await program.parseAsync(argv, { from: "user" });
+	} catch (err) {
+		if (err instanceof CommanderError) {
+			if (err.code === "commander.helpDisplayed" || err.code === "commander.help" || err.code === "commander.version") return;
+			return fail("EBADFLAG", err.message, preScanFormat(argv));
+		}
+		throw err;
+	}
+}
+/* c8 ignore start */
+if (process.argv[1]?.endsWith("cli.js") || process.argv[1]?.endsWith("cli.ts")) main(process.argv.slice(2)).catch((err) => {
+	writeStderr(`error: ${err.message}`);
+	process.exit(1);
+});
+/* c8 ignore stop */
+
+//#endregion
+export { main };

package/dist/index.d.ts

@@ -0,0 +1,115 @@
+//#region src/diff.d.ts
+type ChangeKind = 'added' | 'modified' | 'removed' | 'unchanged';
+interface DiffScenario {
+  name: string;
+  change: ChangeKind;
+}
+interface DiffFileError {
+  code: 'EGIT' | 'EPARSE' | 'ENOENT';
+  message: string;
+}
+interface DiffFile {
+  file: string;
+  addOnly: boolean;
+  scenarios: DiffScenario[];
+  error?: DiffFileError;
+}
+interface DiffResult {
+  summary: {
+    added: number;
+    modified: number;
+    removed: number;
+    unchanged: number;
+    files: number;
+    addOnly: boolean;
+  };
+  files: DiffFile[];
+}
+/** Reads a file's working-tree and base-ref text. Injectable so tests can skip git. */
+type DiffReader = (file: string, base: string) => {
+  head?: string;
+  base?: string;
+};
+interface DiffOptions {
+  base: string;
+  reader?: DiffReader;
+}
+/** Thrown for genuine git/ref failures so the CLI can map it to `fail('EGIT', …)`. */
+declare class GitError extends Error {
+  constructor(message: string);
+}
+/**
+ * Classify each file's scenarios against its `--base` version. Git/ref failures
+ * surface as a thrown `GitError` for the CLI to convert into `fail('EGIT', …)`;
+ * parse failures surface as a per-file `error` field (no throw).
+ */
+declare function diffFeatures(paths: string[], opts: DiffOptions): DiffResult;
+//#endregion
+//#region src/parse.d.ts
+interface ParseStep {
+  keyword: string;
+  text: string;
+}
+interface ParseScenario {
+  name: string;
+  keyword: string;
+  tags: string[];
+  stepCount?: number;
+  exampleRows?: number;
+  steps?: ParseStep[];
+}
+interface ParseFileError {
+  code: 'EPARSE' | 'ENOENT';
+  line: number;
+  message: string;
+}
+interface ParseFile {
+  file: string;
+  featureTags: string[];
+  scenarioCount: number;
+  sectionComments: number;
+  scenarios: ParseScenario[];
+  error?: ParseFileError;
+}
+interface ParseResult {
+  summary: {
+    files: number;
+    scenarios: number;
+    errors: number;
+  };
+  files: ParseFile[];
+}
+interface ParseOptions {
+  full?: boolean;
+  tag?: string;
+}
+/**
+ * Project each `.feature` file to the `parse` data shape. Pure: a missing or
+ * malformed file becomes an `error` entry rather than throwing — the CLI layer
+ * decides the exit code (ENOENT is a hard fail; EPARSE is best-effort, exit 0).
+ */
+declare function parseFeatures(paths: string[], opts?: ParseOptions): ParseResult;
+//#endregion
+//#region src/validate.d.ts
+interface ValidateError {
+  line: number;
+  message: string;
+  code: 'EPARSE' | 'ENOENT';
+}
+interface ValidateFile {
+  file: string;
+  ok: boolean;
+  errors: ValidateError[];
+}
+interface ValidateResult {
+  summary: {
+    files: number;
+    errors: number;
+  };
+  files: ValidateFile[];
+}
+type ValidateOptions = Record<string, never>;
+/** Parse each file and collect syntax errors. The CLI exits 1 if any file is invalid. */
+declare function validateFeatures(paths: string[], _opts?: ValidateOptions): ValidateResult;
+//#endregion
+export { type ChangeKind, type DiffFile, type DiffFileError, type DiffOptions, type DiffReader, type DiffResult, type DiffScenario, GitError, type ParseFile, type ParseFileError, type ParseOptions, type ParseResult, type ParseScenario, type ParseStep, type ValidateError, type ValidateFile, type ValidateOptions, type ValidateResult, diffFeatures, parseFeatures, validateFeatures };

package/dist/index.js

@@ -0,0 +1,3 @@
+import { a as diffFeatures, i as GitError, n as parseFeatures, t as validateFeatures } from "./validate-BjVkCi7A.js";
+
+export { GitError, diffFeatures, parseFeatures, validateFeatures };

package/dist/validate-BjVkCi7A.js

@@ -0,0 +1,370 @@
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherkin";
+import { IdGenerator } from "@cucumber/messages";
+
+//#region src/diff.ts
+/** Thrown for genuine git/ref failures so the CLI can map it to `fail('EGIT', …)`. */
+var GitError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "GitError";
+	}
+};
+function newParser$2() {
+	return new Parser(new AstBuilder(IdGenerator.incrementing()), new GherkinClassicTokenMatcher());
+}
+/** Default reader: working-tree text from fs, base text from `git show <ref>:<relpath>`. */
+function gitReader(file, base) {
+	const abs = path.resolve(file);
+	const dir = path.dirname(abs);
+	let head;
+	try {
+		head = readFileSync(abs, "utf8");
+	} catch {
+		head = void 0;
+	}
+	const gitIo = {
+		cwd: dir,
+		encoding: "utf8",
+		stdio: [
+			"ignore",
+			"pipe",
+			"ignore"
+		]
+	};
+	let rel;
+	try {
+		rel = execFileSync("git", [
+			"ls-files",
+			"--full-name",
+			"--",
+			abs
+		], gitIo).trim();
+	} catch (err) {
+		throw new GitError(`git ls-files failed for ${file}: ${err.message}`);
+	}
+	if (rel === "") {
+		const top = execFileSync("git", ["rev-parse", "--show-toplevel"], gitIo).trim();
+		rel = path.relative(top, abs).split(path.sep).join("/");
+	}
+	let baseText;
+	try {
+		baseText = execFileSync("git", ["show", `${base}:${rel}`], gitIo);
+	} catch {
+		try {
+			execFileSync("git", [
+				"rev-parse",
+				"--verify",
+				"--quiet",
+				`${base}^{commit}`
+			], {
+				cwd: dir,
+				stdio: "ignore"
+			});
+			baseText = void 0;
+		} catch {
+			throw new GitError(`git could not resolve base ref '${base}'`);
+		}
+	}
+	return {
+		head,
+		base: baseText
+	};
+}
+/** Canonical signature of a scenario: name + steps + tags + examples. */
+function signature(scenario) {
+	const steps = (scenario.steps ?? []).map((s) => `${s.keyword.trim()} ${s.text}`);
+	const tags = (scenario.tags ?? []).map((t) => t.name);
+	const examples = (scenario.examples ?? []).map((ex) => ({
+		header: ex.tableHeader?.cells.map((c) => c.value) ?? [],
+		body: (ex.tableBody ?? []).map((r) => r.cells.map((c) => c.value))
+	}));
+	return JSON.stringify({
+		steps,
+		tags,
+		examples
+	});
+}
+/** Map scenario name → signature, in document order. Returns null on parse failure. */
+function scenarioMap(text) {
+	if (text === void 0) return /* @__PURE__ */ new Map();
+	let doc;
+	try {
+		doc = newParser$2().parse(text);
+	} catch {
+		return null;
+	}
+	const map = /* @__PURE__ */ new Map();
+	for (const child of doc.feature?.children ?? []) if (child.scenario) map.set(child.scenario.name, signature(child.scenario));
+	return map;
+}
+function classifyFile(file, head, base) {
+	const headMap = scenarioMap(head);
+	const baseMap = scenarioMap(base);
+	if (headMap === null || baseMap === null) return {
+		file,
+		addOnly: false,
+		scenarios: [],
+		error: {
+			code: "EPARSE",
+			message: "failed to parse feature"
+		}
+	};
+	const scenarios = [];
+	for (const [name, headSig] of headMap) if (!baseMap.has(name)) scenarios.push({
+		name,
+		change: "added"
+	});
+	else if (baseMap.get(name) !== headSig) scenarios.push({
+		name,
+		change: "modified"
+	});
+	else scenarios.push({
+		name,
+		change: "unchanged"
+	});
+	for (const name of baseMap.keys()) if (!headMap.has(name)) scenarios.push({
+		name,
+		change: "removed"
+	});
+	return {
+		file,
+		addOnly: !scenarios.some((s) => s.change === "modified" || s.change === "removed"),
+		scenarios
+	};
+}
+/**
+* Classify each file's scenarios against its `--base` version. Git/ref failures
+* surface as a thrown `GitError` for the CLI to convert into `fail('EGIT', …)`;
+* parse failures surface as a per-file `error` field (no throw).
+*/
+function diffFeatures(paths, opts) {
+	const reader = opts.reader ?? gitReader;
+	const files = paths.map((file) => {
+		const { head, base } = reader(file, opts.base);
+		return classifyFile(file, head, base);
+	});
+	const summary = {
+		added: 0,
+		modified: 0,
+		removed: 0,
+		unchanged: 0,
+		files: files.length,
+		addOnly: true
+	};
+	for (const f of files) for (const s of f.scenarios) summary[s.change] += 1;
+	summary.addOnly = summary.modified === 0 && summary.removed === 0;
+	return {
+		summary,
+		files
+	};
+}
+
+//#endregion
+//#region src/parse.ts
+/** Build a fresh parser with a deterministic (incrementing) id generator. */
+function newParser$1() {
+	return new Parser(new AstBuilder(IdGenerator.incrementing()), new GherkinClassicTokenMatcher());
+}
+/** A comment counts as a "section" rule if it draws a box-drawing rule or a 3+ run of -/=. */
+function isSectionComment(text) {
+	const body = text.replace(/^\s*#/, "");
+	return /[─-╿]/.test(body) || /([-=])\1{2,}/.test(body);
+}
+function normalizeTag(tag) {
+	return tag.replace(/^@/, "");
+}
+function firstErrorLine(err) {
+	return err.location?.line ?? 0;
+}
+function errorMessage(err) {
+	return err.message.split("\n")[0] ?? err.message;
+}
+function projectDoc(doc, opts) {
+	const feature = doc.feature;
+	const featureTags = (feature?.tags ?? []).map((t) => t.name);
+	const sectionComments = (doc.comments ?? []).filter((c) => isSectionComment(c.text)).length;
+	const scenarios = [];
+	for (const child of feature?.children ?? []) {
+		const scenario = child.scenario;
+		if (!scenario) continue;
+		const tags = (scenario.tags ?? []).map((t) => t.name);
+		if (opts.tag !== void 0) {
+			const wanted = normalizeTag(opts.tag);
+			if (!tags.some((t) => normalizeTag(t) === wanted)) continue;
+		}
+		const steps = (scenario.steps ?? []).map((s) => ({
+			keyword: s.keyword.trim(),
+			text: s.text
+		}));
+		const exampleRows = (scenario.examples ?? []).reduce((sum, ex) => sum + (ex.tableBody?.length ?? 0), 0);
+		const projected = {
+			name: scenario.name,
+			keyword: scenario.keyword,
+			tags
+		};
+		if (opts.full) {
+			projected.stepCount = steps.length;
+			projected.exampleRows = exampleRows;
+			projected.steps = steps;
+		}
+		scenarios.push(projected);
+	}
+	return {
+		featureTags,
+		scenarios,
+		sectionComments
+	};
+}
+function parseOne(path$1, opts) {
+	let text;
+	try {
+		text = readFileSync(path$1, "utf8");
+	} catch (err) {
+		return {
+			file: path$1,
+			featureTags: [],
+			scenarioCount: 0,
+			sectionComments: 0,
+			scenarios: [],
+			error: {
+				code: "ENOENT",
+				line: 0,
+				message: err.message
+			}
+		};
+	}
+	try {
+		const { featureTags, scenarios, sectionComments } = projectDoc(newParser$1().parse(text), opts);
+		return {
+			file: path$1,
+			featureTags,
+			scenarioCount: scenarios.length,
+			sectionComments,
+			scenarios
+		};
+	} catch (err) {
+		const composite = err;
+		const first = composite.errors?.[0] ?? composite;
+		return {
+			file: path$1,
+			featureTags: [],
+			scenarioCount: 0,
+			sectionComments: 0,
+			scenarios: [],
+			error: {
+				code: "EPARSE",
+				line: firstErrorLine(first),
+				message: errorMessage(first)
+			}
+		};
+	}
+}
+/**
+* Project each `.feature` file to the `parse` data shape. Pure: a missing or
+* malformed file becomes an `error` entry rather than throwing — the CLI layer
+* decides the exit code (ENOENT is a hard fail; EPARSE is best-effort, exit 0).
+*/
+function parseFeatures(paths, opts = {}) {
+	const files = paths.map((path$1) => parseOne(path$1, opts));
+	return {
+		summary: {
+			files: files.length,
+			scenarios: files.reduce((sum, f) => sum + f.scenarioCount, 0),
+			errors: files.filter((f) => f.error).length
+		},
+		files
+	};
+}
+/** Dump the raw GherkinDocument for each file (backs `parse --ast`). */
+function parseFeaturesAst(paths) {
+	return paths.map((path$1) => {
+		let text;
+		try {
+			text = readFileSync(path$1, "utf8");
+		} catch (err) {
+			return {
+				file: path$1,
+				error: {
+					code: "ENOENT",
+					line: 0,
+					message: err.message
+				}
+			};
+		}
+		try {
+			return {
+				file: path$1,
+				ast: newParser$1().parse(text)
+			};
+		} catch (err) {
+			const composite = err;
+			const first = composite.errors?.[0] ?? composite;
+			return {
+				file: path$1,
+				error: {
+					code: "EPARSE",
+					line: firstErrorLine(first),
+					message: errorMessage(first)
+				}
+			};
+		}
+	});
+}
+
+//#endregion
+//#region src/validate.ts
+function newParser() {
+	return new Parser(new AstBuilder(IdGenerator.incrementing()), new GherkinClassicTokenMatcher());
+}
+function validateOne(path$1) {
+	let text;
+	try {
+		text = readFileSync(path$1, "utf8");
+	} catch (err) {
+		return {
+			file: path$1,
+			ok: false,
+			errors: [{
+				line: 0,
+				message: err.message,
+				code: "ENOENT"
+			}]
+		};
+	}
+	try {
+		newParser().parse(text);
+		return {
+			file: path$1,
+			ok: true,
+			errors: []
+		};
+	} catch (err) {
+		const composite = err;
+		return {
+			file: path$1,
+			ok: false,
+			errors: (composite.errors ?? [composite]).map((e) => ({
+				line: e.location?.line ?? 0,
+				message: e.message.split("\n")[0] ?? e.message,
+				code: "EPARSE"
+			}))
+		};
+	}
+}
+/** Parse each file and collect syntax errors. The CLI exits 1 if any file is invalid. */
+function validateFeatures(paths, _opts = {}) {
+	const files = paths.map(validateOne);
+	return {
+		summary: {
+			files: files.length,
+			errors: files.reduce((sum, f) => sum + f.errors.length, 0)
+		},
+		files
+	};
+}
+
+//#endregion
+export { diffFeatures as a, GitError as i, parseFeatures as n, parseFeaturesAst as r, validateFeatures as t };

package/package.json

@@ -0,0 +1,57 @@
+{
+	"name": "gherkin-cli",
+	"version": "0.0.0",
+	"description": "Agent-first Gherkin CLI — parse, validate, and diff .feature files with token-efficient, AXI-conformant output.",
+	"keywords": [
+		"gherkin",
+		"cucumber",
+		"feature",
+		"cli",
+		"agent",
+		"axi",
+		"toon"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/cyberuni/gherkin-cli.git"
+	},
+	"author": "unional <homawong@gmail.com>",
+	"license": "MIT",
+	"type": "module",
+	"files": [
+		"dist",
+		"!dist/**/*.test.*"
+	],
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
+	"bin": {
+		"gherkin-cli": "dist/cli.js"
+	},
+	"scripts": {
+		"build": "tsdown",
+		"dev": "tsx src/cli.ts",
+		"format": "biome format --write .",
+		"test": "vitest run src",
+		"test:watch": "vitest",
+		"typecheck": "tsc --noEmit"
+	},
+	"dependencies": {
+		"@cucumber/gherkin": "^41.0.0",
+		"@cucumber/messages": "^33.0.0",
+		"commander": "^14.0.0"
+	},
+	"devDependencies": {
+		"@types/node": "^25.9.1",
+		"tsdown": "^0.16.6",
+		"tsx": "^4.19.4",
+		"typescript": "^6.0.3",
+		"vitest": "^4.1.7"
+	},
+	"engines": {
+		"node": ">=22"
+	}
+}