@oh-my-pi/pi-utils 17.2.10 → 17.2.12

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [17.2.11] - 2026-08-07
+
+### Added
+
+- Added `repair` and `rawKeys` options to `parseFrontmatter` to support spec-conformant loading (disabling lenient recovery and preserving keys verbatim), and exported `normalizeFrontmatterKeys` for manual key normalization.
+
+### Fixed
+
+- Fixed the in-house `marked` list tokenizer incorrectly consuming trailing blank lines at the end of input, ensuring correct list tightness and token generation matching standard `marked` behavior.
+
 ## [17.2.10] - 2026-08-06
 
 ### Added

package/dist/types/frontmatter.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Recursively normalize object keys from kebab-case to camelCase — the
+ * representation convention for frontmatter consumed inside this codebase.
+ * Exported for loaders that parse with `rawKeys: true` to validate exact
+ * spec-defined keys, then normalize for storage.
+ */
+export declare function normalizeFrontmatterKeys<T>(obj: T): T;
 export declare class FrontmatterError extends Error {
     readonly source?: unknown;
     constructor(error: Error, source?: unknown);
@@ -14,6 +21,20 @@ export interface FrontmatterOptions {
     normalize?: boolean;
     /** Level of error handling */
     level?: "off" | "warn" | "fatal";
+    /**
+     * Attempt lenient recovery of near-miss input before failing: quote
+     * ambiguous plain scalars, replace tabs with spaces, and strip leading HTML
+     * comments ahead of the opening delimiter. Default `true`. Spec-conformant
+     * loaders set `false` so malformed input is rejected instead of silently
+     * repaired (CRLF newline normalization still applies).
+     */
+    repair?: boolean;
+    /**
+     * Preserve frontmatter keys verbatim instead of normalizing kebab-case to
+     * camelCase. Default `false`. Strict spec loaders use this so a standard
+     * key (e.g. `allowed-tools`) is never aliased with its camelCase form.
+     */
+    rawKeys?: boolean;
 }
 /**
  * Parse YAML frontmatter from markdown content

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-utils",
-	"version": "17.2.10",
+	"version": "17.2.12",
 	"description": "Shared utilities for pi packages",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -31,7 +31,7 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "17.2.10"
+		"@oh-my-pi/pi-natives": "17.2.12"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/frontmatter.ts

@@ -12,15 +12,20 @@ function kebabToCamel(key: string): string {
 	return key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 }
 
-/** Recursively normalize object keys from kebab-case to camelCase */
-function normalizeKeys<T>(obj: T): T {
+/**
+ * Recursively normalize object keys from kebab-case to camelCase — the
+ * representation convention for frontmatter consumed inside this codebase.
+ * Exported for loaders that parse with `rawKeys: true` to validate exact
+ * spec-defined keys, then normalize for storage.
+ */
+export function normalizeFrontmatterKeys<T>(obj: T): T {
 	if (obj === null || typeof obj !== "object") return obj;
 	if (Array.isArray(obj)) {
 		let changed = false;
 		const out: unknown[] = new Array(obj.length);
 		for (let i = 0; i < obj.length; i++) {
 			const v = obj[i];
-			const nv = normalizeKeys(v);
+			const nv = normalizeFrontmatterKeys(v);
 			out[i] = nv;
 			if (nv !== v) changed = true;
 		}
@@ -30,7 +35,7 @@ function normalizeKeys<T>(obj: T): T {
 	const result: Record<string, unknown> = {};
 	for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
 		const nk = key.includes("-") ? kebabToCamel(key) : key;
-		const nv = normalizeKeys(value);
+		const nv = normalizeFrontmatterKeys(value);
 		result[nk] = nv;
 		if (nk !== key || nv !== value) changed = true;
 	}
@@ -55,8 +60,8 @@ function quoteAmbiguousPlainScalars(metadata: string): string | undefined {
 	return changed ? lines.join("\n") : undefined;
 }
 
-function parseYamlRecord(metadata: string): Record<string, unknown> | null {
-	const loaded = YAML.parse(metadata.replaceAll("\t", "  "));
+function parseYamlRecord(metadata: string, repairTabs: boolean): Record<string, unknown> | null {
+	const loaded = YAML.parse(repairTabs ? metadata.replaceAll("\t", "  ") : metadata);
 	if (loaded === null || loaded === undefined) return null;
 	if (typeof loaded !== "object" || Array.isArray(loaded)) return null;
 	return loaded as Record<string, unknown>;
@@ -97,6 +102,20 @@ export interface FrontmatterOptions {
 	normalize?: boolean;
 	/** Level of error handling */
 	level?: "off" | "warn" | "fatal";
+	/**
+	 * Attempt lenient recovery of near-miss input before failing: quote
+	 * ambiguous plain scalars, replace tabs with spaces, and strip leading HTML
+	 * comments ahead of the opening delimiter. Default `true`. Spec-conformant
+	 * loaders set `false` so malformed input is rejected instead of silently
+	 * repaired (CRLF newline normalization still applies).
+	 */
+	repair?: boolean;
+	/**
+	 * Preserve frontmatter keys verbatim instead of normalizing kebab-case to
+	 * camelCase. Default `false`. Strict spec loaders use this so a standard
+	 * key (e.g. `allowed-tools`) is never aliased with its camelCase form.
+	 */
+	rawKeys?: boolean;
 }
 
 /**
@@ -107,11 +126,22 @@ export function parseFrontmatter(
 	content: string,
 	options?: FrontmatterOptions,
 ): { frontmatter: Record<string, unknown>; body: string } {
-	const { location, source, fallback, normalize = true, level = "warn" } = options ?? {};
+	const {
+		location,
+		source,
+		fallback,
+		normalize = true,
+		level = "warn",
+		repair = true,
+		rawKeys = false,
+	} = options ?? {};
+	const finalizeKeys = (fm: Record<string, unknown>): Record<string, unknown> =>
+		rawKeys ? fm : normalizeFrontmatterKeys(fm);
 	const loc = location ?? source;
 	const frontmatter: Record<string, unknown> = { ...fallback };
 
-	const normalized = normalize ? stripHtmlComments(content.replace(/\r\n?/g, "\n")) : content;
+	const newlineNormalized = normalize ? content.replace(/\r\n?/g, "\n") : content;
+	const normalized = normalize && repair ? stripHtmlComments(newlineNormalized) : newlineNormalized;
 	if (!normalized.startsWith("---")) {
 		return { frontmatter, body: normalized };
 	}
@@ -125,14 +155,14 @@ export function parseFrontmatter(
 	const body = normalized.slice(endIndex + 4).trim();
 
 	try {
-		const loaded = parseYamlRecord(metadata);
-		return { frontmatter: normalizeKeys({ ...frontmatter, ...loaded }), body };
+		const loaded = parseYamlRecord(metadata, repair);
+		return { frontmatter: finalizeKeys({ ...frontmatter, ...loaded }), body };
 	} catch (error) {
-		const quotedMetadata = quoteAmbiguousPlainScalars(metadata);
+		const quotedMetadata = repair ? quoteAmbiguousPlainScalars(metadata) : undefined;
 		if (quotedMetadata) {
 			try {
-				const loaded = parseYamlRecord(quotedMetadata);
-				return { frontmatter: normalizeKeys({ ...frontmatter, ...loaded }), body };
+				const loaded = parseYamlRecord(quotedMetadata, true);
+				return { frontmatter: finalizeKeys({ ...frontmatter, ...loaded }), body };
 			} catch {
 				// Fall through to the existing warning + simple key/value fallback.
 			}
@@ -170,6 +200,6 @@ export function parseFrontmatter(
 			frontmatter[match[1]] = value;
 		}
 
-		return { frontmatter: normalizeKeys(frontmatter) as Record<string, unknown>, body };
+		return { frontmatter: finalizeKeys(frontmatter), body };
 	}
 }

package/src/marked/core.ts

@@ -826,23 +826,23 @@ function parseList(lines: string[], index: number, lexer: Lexer): { token: Token
 			if (/^\s*\n$/.test(next)) {
 				let lookahead = cursor + 1;
 				while (lookahead < lines.length && /^\s*\n$/.test(lines[lookahead]!)) lookahead++;
-				if (lookahead < lines.length) {
-					// A blank line closes the list unless the next top-level line is a
-					// compatible item (same bullet char / ordered delimiter) or indented
-					// item content. The blank must stay OUTSIDE the list raw (it becomes
-					// a `space` token) so token shape never depends on what follows —
-					// real marked does the same, and the TUI's streaming freeze relies
-					// on that append-stability.
-					const following = lines[lookahead]!;
-					const followingIndent = /^ */.exec(following)![0].length;
-					if (followingIndent <= first[1]!.length) {
-						const followingList = isList(following);
-						const compatible =
-							followingList !== null &&
-							/^\d/.test(followingList[2]!) === ordered &&
-							(ordered ? followingList[2]!.at(-1) === delimiter : followingList[2] === delimiter);
-						if (!compatible) break;
-					}
+				// A blank line closes the list unless the next top-level line is a
+				// compatible item (same bullet char / ordered delimiter) or indented
+				// item content. The blank must stay OUTSIDE the list raw (it becomes
+				// a `space` token) so token shape never depends on what follows —
+				// real marked does the same, and the TUI's streaming freeze relies
+				// on that append-stability. A blank run at end of input closes the
+				// list the same way, keeping it tight and its raw blank-free.
+				if (lookahead >= lines.length) break;
+				const following = lines[lookahead]!;
+				const followingIndent = /^ */.exec(following)![0].length;
+				if (followingIndent <= first[1]!.length) {
+					const followingList = isList(following);
+					const compatible =
+						followingList !== null &&
+						/^\d/.test(followingList[2]!) === ordered &&
+						(ordered ? followingList[2]!.at(-1) === delimiter : followingList[2] === delimiter);
+					if (!compatible) break;
 				}
 				text += next;
 			} else {