@oh-my-pi/pi-coding-agent 13.8.0 → 13.9.2

package/src/tools/read.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs/promises";
 import path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
-import { FileType, glob } from "@oh-my-pi/pi-natives";
+import { glob } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { getRemoteDir, ptree, untilAborted } from "@oh-my-pi/pi-utils";
@@ -28,7 +28,7 @@ import { detectSupportedImageMimeTypeFromFile } from "../utils/mime";
 import { ensureTool } from "../utils/tools-manager";
 import { applyListLimit } from "./list-limit";
 import { formatFullOutputReference, formatStyledTruncationWarning, type OutputMeta } from "./output-meta";
-import { resolveReadPath, resolveToCwd } from "./path-utils";
+import { resolveReadPath } from "./path-utils";
 import { formatAge, formatBytes, shortenPath, wrapBrackets } from "./render-utils";
 import { ToolAbortError, ToolError, throwIfAborted } from "./tool-errors";
 import { toolResult } from "./tool-result";
@@ -254,251 +254,55 @@ async function streamLinesFromFile(
 
 // Maximum image file size (20MB) - larger images will be rejected to prevent OOM during serialization
 const MAX_IMAGE_SIZE = 20 * 1024 * 1024;
-const MAX_FUZZY_RESULTS = 5;
-const MAX_FUZZY_CANDIDATES = 20000;
-const MIN_BASE_SIMILARITY = 0.5;
-const MIN_FULL_SIMILARITY = 0.6;
 const GLOB_TIMEOUT_MS = 5000;
 
-function normalizePathForMatch(value: string): string {
-	return value
-		.replace(/\\/g, "/")
-		.replace(/^\.\/+/, "")
-		.replace(/\/+$/, "")
-		.toLowerCase();
-}
-
 function isNotFoundError(error: unknown): boolean {
 	if (!error || typeof error !== "object") return false;
 	const code = (error as { code?: string }).code;
 	return code === "ENOENT" || code === "ENOTDIR";
 }
 
-function isPathWithin(basePath: string, targetPath: string): boolean {
-	const relativePath = path.relative(basePath, targetPath);
-	return relativePath === "" || (!relativePath.startsWith("..") && !path.isAbsolute(relativePath));
-}
-
-async function findExistingDirectory(startDir: string, signal?: AbortSignal): Promise<string | null> {
-	let current = startDir;
-	const root = path.parse(startDir).root;
-
-	while (true) {
-		throwIfAborted(signal);
-		try {
-			const stat = await Bun.file(current).stat();
-			if (stat.isDirectory()) {
-				return current;
-			}
-		} catch {
-			// Keep walking up.
-		}
-
-		if (current === root) {
-			break;
-		}
-		current = path.dirname(current);
-	}
-
-	return null;
-}
-
-function formatScopeLabel(searchRoot: string, cwd: string): string {
-	const relative = path.relative(cwd, searchRoot).replace(/\\/g, "/");
-	if (relative === "" || relative === ".") {
-		return ".";
-	}
-	if (!relative.startsWith("..") && !path.isAbsolute(relative)) {
-		return relative;
-	}
-	return searchRoot;
-}
-
-function buildDisplayPath(searchRoot: string, cwd: string, relativePath: string): string {
-	const scopeLabel = formatScopeLabel(searchRoot, cwd);
-	const normalized = relativePath.replace(/\\/g, "/");
-	if (scopeLabel === ".") {
-		return normalized;
-	}
-	if (scopeLabel.startsWith("..") || path.isAbsolute(scopeLabel)) {
-		return path.join(searchRoot, normalized).replace(/\\/g, "/");
-	}
-	return `${scopeLabel}/${normalized}`;
-}
-
-function levenshteinDistance(a: string, b: string): number {
-	if (a === b) return 0;
-	const aLen = a.length;
-	const bLen = b.length;
-	if (aLen === 0) return bLen;
-	if (bLen === 0) return aLen;
-
-	let prev = new Array<number>(bLen + 1);
-	let curr = new Array<number>(bLen + 1);
-	for (let j = 0; j <= bLen; j++) {
-		prev[j] = j;
-	}
-
-	for (let i = 1; i <= aLen; i++) {
-		curr[0] = i;
-		const aCode = a.charCodeAt(i - 1);
-		for (let j = 1; j <= bLen; j++) {
-			const cost = aCode === b.charCodeAt(j - 1) ? 0 : 1;
-			const deletion = prev[j] + 1;
-			const insertion = curr[j - 1] + 1;
-			const substitution = prev[j - 1] + cost;
-			curr[j] = Math.min(deletion, insertion, substitution);
-		}
-		const tmp = prev;
-		prev = curr;
-		curr = tmp;
-	}
-
-	return prev[bLen];
-}
-
-function similarityScore(a: string, b: string): number {
-	if (a.length === 0 && b.length === 0) {
-		return 1;
-	}
-	const maxLen = Math.max(a.length, b.length);
-	if (maxLen === 0) {
-		return 1;
-	}
-	const distance = levenshteinDistance(a, b);
-	return 1 - distance / maxLen;
-}
-
-async function listCandidateFiles(
-	searchRoot: string,
+/**
+ * Attempt to resolve a non-existent path by finding a unique suffix match within the workspace.
+ * Uses a glob suffix pattern so the native engine handles matching directly.
+ * Returns null when 0 or >1 candidates match (ambiguous = no auto-resolution).
+ */
+async function findUniqueSuffixMatch(
+	rawPath: string,
+	cwd: string,
 	signal?: AbortSignal,
-	_notify?: (message: string) => void,
-): Promise<{ files: string[]; truncated: boolean; error?: string }> {
-	let files: string[];
+): Promise<{ absolutePath: string; displayPath: string } | null> {
+	const normalized = rawPath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+	if (!normalized) return null;
+
 	const timeoutSignal = AbortSignal.timeout(GLOB_TIMEOUT_MS);
 	const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+
+	let matches: string[];
 	try {
 		const result = await untilAborted(combinedSignal, () =>
 			glob({
-				pattern: "**/*",
-				path: searchRoot,
-				fileType: FileType.File,
+				pattern: `**/${normalized}`,
+				path: cwd,
+				// No fileType filter: matches both files and directories
 				hidden: true,
 			}),
 		);
-		files = result.matches.map(match => match.path);
+		matches = result.matches.map(m => m.path);
 	} catch (error) {
 		if (error instanceof Error && error.name === "AbortError") {
-			if (timeoutSignal.aborted && !signal?.aborted) {
-				const timeoutSeconds = Math.max(1, Math.round(GLOB_TIMEOUT_MS / 1000));
-				return { files: [], truncated: false, error: `find timed out after ${timeoutSeconds}s` };
-			}
+			if (!signal?.aborted) return null; // timeout — give up silently
 			throw new ToolAbortError();
 		}
-		const message = error instanceof Error ? error.message : String(error);
-		return { files: [], truncated: false, error: message };
-	}
-
-	const normalizedFiles = files.filter(line => line.length > 0);
-	const truncated = normalizedFiles.length > MAX_FUZZY_CANDIDATES;
-	const limited = truncated ? normalizedFiles.slice(0, MAX_FUZZY_CANDIDATES) : normalizedFiles;
-
-	return { files: limited, truncated };
-}
-
-async function findReadPathSuggestions(
-	rawPath: string,
-	cwd: string,
-	signal?: AbortSignal,
-	notify?: (message: string) => void,
-): Promise<{ suggestions: string[]; scopeLabel?: string; truncated?: boolean; error?: string } | null> {
-	const resolvedPath = resolveToCwd(rawPath, cwd);
-	const searchRoot = await findExistingDirectory(path.dirname(resolvedPath), signal);
-	if (!searchRoot) {
 		return null;
 	}
 
-	if (!isPathWithin(cwd, resolvedPath)) {
-		const root = path.parse(searchRoot).root;
-		if (searchRoot === root) {
-			return null;
-		}
-	}
-
-	const { files, truncated, error } = await listCandidateFiles(searchRoot, signal, notify);
-	const scopeLabel = formatScopeLabel(searchRoot, cwd);
-
-	if (error && files.length === 0) {
-		return { suggestions: [], scopeLabel, truncated, error };
-	}
-
-	if (files.length === 0) {
-		return null;
-	}
-
-	const queryPath = (() => {
-		if (path.isAbsolute(rawPath)) {
-			const relative = path.relative(cwd, resolvedPath).replace(/\\/g, "/");
-			if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) {
-				return normalizePathForMatch(relative);
-			}
-		}
-		return normalizePathForMatch(rawPath);
-	})();
-	const baseQuery = path.posix.basename(queryPath);
-
-	const matches: Array<{ path: string; score: number; baseScore: number; fullScore: number }> = [];
-	const seen = new Set<string>();
-
-	for (const file of files) {
-		throwIfAborted(signal);
-		const cleaned = file.replace(/\r$/, "").trim();
-		if (!cleaned) continue;
-
-		const relativePath = cleaned;
-
-		if (!relativePath || relativePath.startsWith("..")) {
-			continue;
-		}
-
-		const displayPath = buildDisplayPath(searchRoot, cwd, relativePath);
-		if (seen.has(displayPath)) {
-			continue;
-		}
-		seen.add(displayPath);
-
-		const normalizedDisplay = normalizePathForMatch(displayPath);
-		const baseCandidate = path.posix.basename(normalizedDisplay);
-
-		const fullScore = similarityScore(queryPath, normalizedDisplay);
-		const baseScore = baseQuery ? similarityScore(baseQuery, baseCandidate) : 0;
-
-		if (baseQuery) {
-			if (baseScore < MIN_BASE_SIMILARITY && fullScore < MIN_FULL_SIMILARITY) {
-				continue;
-			}
-		} else if (fullScore < MIN_FULL_SIMILARITY) {
-			continue;
-		}
-
-		const score = baseQuery ? baseScore * 0.75 + fullScore * 0.25 : fullScore;
-		matches.push({ path: displayPath, score, baseScore, fullScore });
-	}
+	if (matches.length !== 1) return null;
 
-	if (matches.length === 0) {
-		return { suggestions: [], scopeLabel, truncated };
-	}
-
-	matches.sort((a, b) => {
-		if (b.score !== a.score) return b.score - a.score;
-		if (b.baseScore !== a.baseScore) return b.baseScore - a.baseScore;
-		return a.path.localeCompare(b.path);
-	});
-
-	const listLimit = applyListLimit(matches, { limit: MAX_FUZZY_RESULTS });
-	const suggestions = listLimit.items.map(match => match.path);
-
-	return { suggestions, scopeLabel, truncated };
+	return {
+		absolutePath: path.resolve(cwd, matches[0]),
+		displayPath: matches[0],
+	};
 }
 
 async function convertWithMarkitdown(
@@ -540,6 +344,7 @@ export interface ReadToolDetails {
 	truncation?: TruncationResult;
 	isDirectory?: boolean;
 	resolvedPath?: string;
+	suffixResolution?: { from: string; to: string };
 	meta?: OutputMeta;
 }
 
@@ -560,11 +365,17 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	readonly strict = true;
 
 	readonly #autoResizeImages: boolean;
+	readonly #defaultLimit: number;
 
 	constructor(private readonly session: ToolSession) {
 		const displayMode = resolveFileDisplayMode(session);
 		this.#autoResizeImages = session.settings.get("images.autoResize");
+		this.#defaultLimit = Math.max(
+			1,
+			Math.min(session.settings.get("read.defaultLimit") ?? DEFAULT_MAX_LINES, DEFAULT_MAX_LINES),
+		);
 		this.description = renderPromptTemplate(readDescription, {
+			DEFAULT_LIMIT: String(this.#defaultLimit),
 			DEFAULT_MAX_LINES: String(DEFAULT_MAX_LINES),
 			IS_HASHLINE_MODE: displayMode.hashLines,
 			IS_LINE_NUMBER_MODE: !displayMode.hashLines && displayMode.lineNumbers,
@@ -576,7 +387,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		params: ReadParams,
 		signal?: AbortSignal,
 		_onUpdate?: AgentToolUpdateCallback<ReadToolDetails>,
-		toolContext?: AgentToolContext,
+		_toolContext?: AgentToolContext,
 	): Promise<AgentToolResult<ReadToolDetails>> {
 		const { path: readPath, offset, limit } = params;
 
@@ -588,7 +399,8 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			return this.#handleInternalUrl(readPath, offset, limit);
 		}
 
-		const absolutePath = resolveReadPath(readPath, this.session.cwd);
+		let absolutePath = resolveReadPath(readPath, this.session.cwd);
+		let suffixResolution: { from: string; to: string } | undefined;
 
 		let isDirectory = false;
 		let fileSize = 0;
@@ -598,34 +410,37 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			isDirectory = stat.isDirectory();
 		} catch (error) {
 			if (isNotFoundError(error)) {
-				let message = `File not found: ${readPath}`;
-
-				// Skip fuzzy matching for remote mounts (sshfs) to avoid hangs
+				// Attempt unique suffix resolution before falling back to fuzzy suggestions
 				if (!isRemoteMountPath(absolutePath)) {
-					const suggestions = await findReadPathSuggestions(readPath, this.session.cwd, signal, message =>
-						toolContext?.ui?.notify(message, "info"),
-					);
-
-					if (suggestions?.suggestions.length) {
-						const scopeLabel = suggestions.scopeLabel ? ` in ${suggestions.scopeLabel}` : "";
-						message += `\n\nClosest matches${scopeLabel}:\n${suggestions.suggestions.map(match => `- ${match}`).join("\n")}`;
-						if (suggestions.truncated) {
-							message += `\n[Search truncated to first ${MAX_FUZZY_CANDIDATES} paths. Refine the path if the match isn't listed.]`;
+					const suffixMatch = await findUniqueSuffixMatch(readPath, this.session.cwd, signal);
+					if (suffixMatch) {
+						try {
+							const retryStat = await Bun.file(suffixMatch.absolutePath).stat();
+							absolutePath = suffixMatch.absolutePath;
+							fileSize = retryStat.size;
+							isDirectory = retryStat.isDirectory();
+							suffixResolution = { from: readPath, to: suffixMatch.displayPath };
+						} catch {
+							// Suffix match candidate no longer stats — fall through to error path
 						}
-					} else if (suggestions?.error) {
-						message += `\n\nFuzzy match failed: ${suggestions.error}`;
-					} else if (suggestions?.scopeLabel) {
-						message += `\n\nNo similar paths found in ${suggestions.scopeLabel}.`;
 					}
 				}
 
-				throw new ToolError(message);
+				if (!suffixResolution) {
+					throw new ToolError(`Path '${readPath}' not found`);
+				}
+			} else {
+				throw error;
 			}
-			throw error;
 		}
 
 		if (isDirectory) {
-			return this.#readDirectory(absolutePath, limit, signal);
+			const dirResult = await this.#readDirectory(absolutePath, limit, signal);
+			if (suffixResolution) {
+				dirResult.details ??= {};
+				dirResult.details.suffixResolution = suffixResolution;
+			}
+			return dirResult;
 		}
 
 		const mimeType = await detectSupportedImageMimeTypeFromFile(absolutePath);
@@ -721,8 +536,9 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			const startLine = offset ? Math.max(0, offset - 1) : 0;
 			const startLineDisplay = startLine + 1; // For display (1-indexed)
 
-			const maxLinesToCollect = limit !== undefined ? Math.min(limit, DEFAULT_MAX_LINES) : DEFAULT_MAX_LINES;
-			const selectedLineLimit = limit ?? null;
+			const effectiveLimit = limit ?? this.#defaultLimit;
+			const maxLinesToCollect = Math.min(effectiveLimit, DEFAULT_MAX_LINES);
+			const selectedLineLimit = effectiveLimit;
 			const streamResult = await streamLinesFromFile(
 				absolutePath,
 				startLine,
@@ -747,13 +563,13 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					totalFileLines === 0
 						? "The file is empty."
 						: `Use offset=1 to read from the start, or offset=${totalFileLines} to read the last line.`;
-				return toolResult<ReadToolDetails>()
+				return toolResult<ReadToolDetails>({ resolvedPath: absolutePath, suffixResolution })
 					.text(`Offset ${offset} is beyond end of file (${totalFileLines} lines total). ${suggestion}`)
 					.done();
 			}
 
 			const selectedContent = collectedLines.join("\n");
-			const userLimitedLines = limit !== undefined ? collectedLines.length : undefined;
+			const userLimitedLines = collectedLines.length;
 
 			const totalSelectedLines = totalFileLines - startLine;
 			const totalSelectedBytes = collectedBytes;
@@ -812,7 +628,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					result: truncation,
 					options: { direction: "head", startLine: startLineDisplay, totalFileLines },
 				};
-			} else if (userLimitedLines !== undefined && startLine + userLimitedLines < totalFileLines) {
+			} else if (startLine + userLimitedLines < totalFileLines) {
 				const remaining = totalFileLines - (startLine + userLimitedLines);
 				const nextOffset = startLine + userLimitedLines + 1;
 
@@ -830,6 +646,17 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			content = [{ type: "text", text: outputText }];
 		}
 
+		if (suffixResolution) {
+			details.suffixResolution = suffixResolution;
+			// Inline resolution notice into first text block so the model sees the actual path
+			const notice = `[Path '${suffixResolution.from}' not found; resolved to '${suffixResolution.to}' via suffix match]`;
+			const firstText = content.find((c): c is TextContent => c.type === "text");
+			if (firstText) {
+				firstText.text = `${notice}\n${firstText.text}`;
+			} else {
+				content = [{ type: "text", text: notice }, ...content];
+			}
+		}
 		const resultBuilder = toolResult(details).content(content);
 		if (sourcePath) {
 			resultBuilder.sourcePath(sourcePath);
@@ -869,13 +696,10 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 
 		// Resolve the internal URL
 		const resource = await internalRouter.resolve(url);
+		const details: ReadToolDetails = { resolvedPath: resource.sourcePath };
 
 		// If extraction was used, return directly (no pagination)
 		if (hasExtraction) {
-			const details: ReadToolDetails = {};
-			if (resource.sourcePath) {
-				details.resolvedPath = resource.sourcePath;
-			}
 			return toolResult(details).text(resource.content).sourceInternal(url).done();
 		}
 
@@ -891,7 +715,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				allLines.length === 0
 					? "The resource is empty."
 					: `Use offset=1 to read from the start, or offset=${allLines.length} to read the last line.`;
-			return toolResult<ReadToolDetails>()
+			return toolResult<ReadToolDetails>(details)
 				.text(`Offset ${offset} is beyond end of resource (${allLines.length} lines total). ${suggestion}`)
 				.done();
 		}
@@ -916,7 +740,6 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		};
 
 		let outputText: string;
-		let details: ReadToolDetails = {};
 		let truncationInfo:
 			| { result: TruncationResult; options: { direction: "head"; startLine?: number; totalFileLines?: number } }
 			| undefined;
@@ -938,14 +761,14 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					firstLineBytes,
 				)}, exceeds ${formatBytes(DEFAULT_MAX_BYTES)} limit. Unable to display a valid UTF-8 snippet.]`;
 			}
-			details = { truncation };
+			details.truncation = truncation;
 			truncationInfo = {
 				result: truncation,
 				options: { direction: "head", startLine: startLineDisplay, totalFileLines: totalLines },
 			};
 		} else if (truncation.truncated) {
 			outputText = formatText(truncation.content, startLineDisplay);
-			details = { truncation };
+			details.truncation = truncation;
 			truncationInfo = {
 				result: truncation,
 				options: { direction: "head", startLine: startLineDisplay, totalFileLines: totalLines },
@@ -956,14 +779,9 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 
 			outputText = formatText(truncation.content, startLineDisplay);
 			outputText += `\n\n[${remaining} more lines in resource. Use offset=${nextOffset} to continue]`;
-			details = {};
+			details.truncation = truncation;
 		} else {
 			outputText = formatText(truncation.content, startLineDisplay);
-			details = {};
-		}
-
-		if (resource.sourcePath) {
-			details.resolvedPath = resource.sourcePath;
 		}
 
 		const resultBuilder = toolResult(details).text(outputText).sourceInternal(url);
@@ -1105,8 +923,11 @@ export const readToolRenderer = {
 		}
 
 		if (imageContent) {
+			const suffix = details?.suffixResolution;
+			const displayPath = suffix ? shortenPath(suffix.to) : filePath || rawPath || "image";
+			const correction = suffix ? ` ${uiTheme.fg("dim", `(corrected from ${shortenPath(suffix.from)})`)}` : "";
 			const header = renderStatusLine(
-				{ icon: "success", title: "Read", description: filePath || rawPath || "image" },
+				{ icon: suffix ? "warning" : "success", title: "Read", description: `${displayPath}${correction}` },
 				uiTheme,
 			);
 			const detailLines = contentText ? contentText.split("\n").map(line => uiTheme.fg("toolOutput", line)) : [];
@@ -1132,7 +953,10 @@ export const readToolRenderer = {
 			};
 		}
 
-		let title = filePath ? `Read ${filePath}` : "Read";
+		const suffix = details?.suffixResolution;
+		const displayPath = suffix ? shortenPath(suffix.to) : filePath;
+		const correction = suffix ? ` ${uiTheme.fg("dim", `(corrected from ${shortenPath(suffix.from)})`)}` : "";
+		let title = displayPath ? `Read ${displayPath}${correction}` : "Read";
 		if (args?.offset !== undefined || args?.limit !== undefined) {
 			const startLine = args.offset ?? 1;
 			const endLine = args.limit !== undefined ? startLine + args.limit - 1 : "";

package/src/utils/frontmatter.ts

@@ -5,6 +5,27 @@ function stripHtmlComments(content: string): string {
 	return content.replace(/<!--[\s\S]*?-->/g, "");
 }
 
+/** Convert kebab-case to camelCase (e.g. "thinking-level" -> "thinkingLevel") */
+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 {
+	if (obj === null || typeof obj !== "object") {
+		return obj;
+	}
+	if (Array.isArray(obj)) {
+		return obj.map(normalizeKeys) as T;
+	}
+	const result: Record<string, unknown> = {};
+	for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+		const normalizedKey = kebabToCamel(key);
+		result[normalizedKey] = normalizeKeys(value);
+	}
+	return result as T;
+}
+
 export class FrontmatterError extends Error {
 	constructor(
 		error: Error,
@@ -52,7 +73,7 @@ export function parseFrontmatter(
 ): { frontmatter: Record<string, unknown>; body: string } {
 	const { location, source, fallback, normalize = true, level = "warn" } = options ?? {};
 	const loc = location ?? source;
-	const frontmatter: Record<string, unknown> = Object.assign({}, fallback);
+	const frontmatter: Record<string, unknown> = { ...fallback };
 
 	const normalized = normalize ? stripHtmlComments(content.replace(/\r\n/g, "\n").replace(/\r/g, "\n")) : content;
 	if (!normalized.startsWith("---")) {
@@ -70,7 +91,7 @@ export function parseFrontmatter(
 	try {
 		// Replace tabs with spaces for YAML compatibility, use failsafe mode for robustness
 		const loaded = YAML.parse(metadata.replaceAll("\t", "  ")) as Record<string, unknown> | null;
-		return { frontmatter: Object.assign(frontmatter, loaded), body: body };
+		return { frontmatter: normalizeKeys({ ...frontmatter, ...loaded }), body };
 	} catch (error) {
 		const err = new FrontmatterError(
 			error instanceof Error ? error : new Error(`YAML: ${error}`),
@@ -85,12 +106,12 @@ export function parseFrontmatter(
 
 		// Simple YAML parsing - just key: value pairs
 		for (const line of metadata.split("\n")) {
-			const match = line.match(/^(\w+):\s*(.*)$/);
+			const match = line.match(/^([\w-]+):\s*(.*)$/);
 			if (match) {
 				frontmatter[match[1]] = match[2].trim();
 			}
 		}
 
-		return { frontmatter, body: body };
+		return { frontmatter: normalizeKeys(frontmatter) as Record<string, unknown>, body };
 	}
 }

package/src/web/scrapers/choosealicense.ts

@@ -67,7 +67,7 @@ export const handleChooseALicense: SpecialHandler = async (
 		const { frontmatter, body } = parseFrontmatter(result.content, { source: rawUrl });
 
 		const title = asString(frontmatter.title) ?? formatLabel(licenseSlug);
-		const spdxId = asString(frontmatter["spdx-id"]) ?? "Unknown";
+		const spdxId = asString(frontmatter.spdxId) ?? "Unknown";
 		const description = asString(frontmatter.description);
 		const permissions = normalizeList(frontmatter.permissions);
 		const conditions = normalizeList(frontmatter.conditions);