@oh-my-pi/pi-coding-agent 4.3.2 → 4.4.5

package/src/core/tools/todo-write.ts

@@ -0,0 +1,256 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
+import { Type } from "@sinclair/typebox";
+import chalk from "chalk";
+import type { Theme } from "../../modes/interactive/theme/theme";
+import todoWriteDescription from "../../prompts/tools/todo-write.md" with { type: "text" };
+import type { RenderResultOptions } from "../custom-tools/types";
+import { logger } from "../logger";
+import { renderPromptTemplate } from "../prompt-templates";
+import type { ToolSession } from "../sdk";
+import { ensureArtifactsDir, getArtifactsDir } from "./task/artifacts";
+
+const todoWriteSchema = Type.Object({
+	todos: Type.Array(
+		Type.Object({
+			id: Type.Optional(Type.String({ description: "Stable todo id" })),
+			content: Type.String({ minLength: 1, description: "Imperative task description (e.g., 'Run tests')" }),
+			activeForm: Type.String({ minLength: 1, description: "Present continuous form (e.g., 'Running tests')" }),
+			status: Type.Union([Type.Literal("pending"), Type.Literal("in_progress"), Type.Literal("completed")]),
+		}),
+		{ description: "The updated todo list" },
+	),
+});
+
+type TodoStatus = "pending" | "in_progress" | "completed";
+
+export interface TodoItem {
+	id: string;
+	content: string;
+	activeForm: string;
+	status: TodoStatus;
+}
+
+interface TodoFile {
+	updatedAt: number;
+	todos: TodoItem[];
+}
+
+export interface TodoWriteToolDetails {
+	todos: TodoItem[];
+	updatedAt: number;
+	storage: "session" | "memory";
+}
+
+const TODO_FILE_NAME = "todos.json";
+
+function normalizeTodoStatus(status?: string): TodoStatus {
+	switch (status) {
+		case "in_progress":
+			return "in_progress";
+		case "completed":
+		case "done":
+		case "complete":
+			return "completed";
+		default:
+			return "pending";
+	}
+}
+
+function normalizeTodos(
+	items: Array<{ id?: string; content?: string; activeForm?: string; status?: string }>,
+): TodoItem[] {
+	return items.map((item) => {
+		if (!item.content || !item.activeForm) {
+			throw new Error("Todo content and activeForm are required.");
+		}
+		const content = item.content.trim();
+		const activeForm = item.activeForm.trim();
+		if (!content) {
+			throw new Error("Todo content cannot be empty.");
+		}
+		if (!activeForm) {
+			throw new Error("Todo activeForm cannot be empty.");
+		}
+		return {
+			id: item.id && item.id.trim().length > 0 ? item.id : randomUUID(),
+			content,
+			activeForm,
+			status: normalizeTodoStatus(item.status),
+		};
+	});
+}
+
+function validateSequentialTodos(todos: TodoItem[]): { valid: boolean; error?: string } {
+	if (todos.length === 0) return { valid: true };
+
+	const firstIncompleteIndex = todos.findIndex((todo) => todo.status !== "completed");
+	if (firstIncompleteIndex >= 0) {
+		for (let i = firstIncompleteIndex + 1; i < todos.length; i++) {
+			if (todos[i].status === "completed") {
+				return {
+					valid: false,
+					error: `Error: Cannot complete "${todos[i].content}" before completing "${todos[firstIncompleteIndex].content}". Todos must be completed sequentially.`,
+				};
+			}
+		}
+	}
+
+	const inProgressIndices = todos.reduce<number[]>((acc, todo, index) => {
+		if (todo.status === "in_progress") acc.push(index);
+		return acc;
+	}, []);
+
+	if (inProgressIndices.length > 1) {
+		return { valid: false, error: "Only one todo can be in progress at a time." };
+	}
+
+	if (inProgressIndices.length === 1 && firstIncompleteIndex >= 0) {
+		if (inProgressIndices[0] !== firstIncompleteIndex) {
+			return { valid: false, error: "Todo in progress must be the next incomplete item." };
+		}
+	}
+
+	return { valid: true };
+}
+
+async function loadTodoFile(filePath: string): Promise<TodoFile | null> {
+	const file = Bun.file(filePath);
+	if (!(await file.exists())) return null;
+	try {
+		const text = await file.text();
+		const data = JSON.parse(text) as TodoFile;
+		if (!data || !Array.isArray(data.todos)) return null;
+		return data;
+	} catch (error) {
+		logger.warn("Failed to read todo file", { path: filePath, error: String(error) });
+		return null;
+	}
+}
+
+async function saveTodoFile(filePath: string, data: TodoFile): Promise<void> {
+	await Bun.write(filePath, JSON.stringify(data, null, 2));
+}
+
+function formatTodoLine(item: TodoItem, uiTheme: Theme, prefix: string): string {
+	const checkbox = uiTheme.checkbox;
+	const displayText =
+		item.status === "in_progress" && item.activeForm !== item.content ? item.activeForm : item.content;
+	switch (item.status) {
+		case "completed":
+			return uiTheme.fg("success", `${prefix}${checkbox.checked} ${chalk.strikethrough(item.content)}`);
+		case "in_progress":
+			return uiTheme.fg("accent", `${prefix}${checkbox.unchecked} ${displayText}`);
+		default:
+			return uiTheme.fg("dim", `${prefix}${checkbox.unchecked} ${item.content}`);
+	}
+}
+
+function formatTodoSummary(todos: TodoItem[]): string {
+	if (todos.length === 0) return "Todo list cleared.";
+	const completed = todos.filter((t) => t.status === "completed").length;
+	const inProgress = todos.filter((t) => t.status === "in_progress").length;
+	const pending = todos.filter((t) => t.status === "pending").length;
+	return `Saved ${todos.length} todos (${pending} pending, ${inProgress} in progress, ${completed} completed).`;
+}
+
+export function createTodoWriteTool(session: ToolSession): AgentTool<typeof todoWriteSchema, TodoWriteToolDetails> {
+	return {
+		name: "todo_write",
+		label: "Todo Write",
+		description: renderPromptTemplate(todoWriteDescription),
+		parameters: todoWriteSchema,
+		execute: async (
+			_toolCallId: string,
+			params: { todos: Array<{ id?: string; content?: string; activeForm?: string; status?: string }> },
+		) => {
+			const todos = normalizeTodos(params.todos ?? []);
+			const validation = validateSequentialTodos(todos);
+			if (!validation.valid) {
+				throw new Error(validation.error ?? "Todos must be completed sequentially.");
+			}
+			const updatedAt = Date.now();
+
+			const sessionFile = session.getSessionFile();
+			if (!sessionFile) {
+				return {
+					content: [{ type: "text", text: formatTodoSummary(todos) }],
+					details: { todos, updatedAt, storage: "memory" },
+				};
+			}
+
+			const artifactsDir = getArtifactsDir(sessionFile);
+			if (!artifactsDir) {
+				return {
+					content: [{ type: "text", text: formatTodoSummary(todos) }],
+					details: { todos, updatedAt, storage: "memory" },
+				};
+			}
+
+			ensureArtifactsDir(artifactsDir);
+			const todoPath = path.join(artifactsDir, TODO_FILE_NAME);
+			const existing = await loadTodoFile(todoPath);
+			const storedTodos = existing?.todos ?? [];
+			const merged = todos.length > 0 ? todos : [];
+			const fileData: TodoFile = { updatedAt, todos: merged };
+
+			try {
+				mkdirSync(artifactsDir, { recursive: true });
+				await saveTodoFile(todoPath, fileData);
+			} catch (error) {
+				logger.error("Failed to write todo file", { path: todoPath, error: String(error) });
+				return {
+					content: [{ type: "text", text: "Failed to save todos." }],
+					details: { todos: storedTodos, updatedAt, storage: "session" },
+				};
+			}
+
+			return {
+				content: [{ type: "text", text: formatTodoSummary(merged) }],
+				details: { todos: merged, updatedAt, storage: "session" },
+			};
+		},
+	};
+}
+
+// =============================================================================
+// TUI Renderer
+// =============================================================================
+
+interface TodoWriteRenderArgs {
+	todos?: Array<{ id?: string; content?: string; activeForm?: string; status?: string }>;
+}
+
+export const todoWriteToolRenderer = {
+	renderCall(args: TodoWriteRenderArgs, uiTheme: Theme): Component {
+		const count = args.todos?.length ?? 0;
+		const summary = count > 0 ? uiTheme.fg("accent", `${count} items`) : uiTheme.fg("toolOutput", "empty");
+		return new Text(`${uiTheme.fg("toolTitle", uiTheme.bold("Todo Write"))} ${summary}`, 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: TodoWriteToolDetails },
+		_options: RenderResultOptions,
+		uiTheme: Theme,
+		_args?: TodoWriteRenderArgs,
+	): Component {
+		const todos = result.details?.todos ?? [];
+		const indent = "  ";
+		const hook = uiTheme.tree.hook;
+		const lines = [indent + uiTheme.bold(uiTheme.fg("accent", "Todos"))];
+
+		if (todos.length > 0) {
+			const visibleTodos = todos;
+			visibleTodos.forEach((todo, index) => {
+				const prefix = `${indent}${index === 0 ? hook : " "} `;
+				lines.push(formatTodoLine(todo, uiTheme, prefix));
+			});
+		}
+
+		return new Text(lines.join("\n"), 0, 0);
+	},
+};

package/src/core/tools/web-fetch.ts

@@ -12,6 +12,7 @@ import { ensureTool } from "../../utils/tools-manager";
 import type { RenderResultOptions } from "../custom-tools/types";
 import { renderPromptTemplate } from "../prompt-templates";
 import type { ToolSession } from "./index";
+import { formatExpandHint } from "./render-utils";
 import { specialHandlers } from "./web-scrapers/index";
 import type { RenderResult } from "./web-scrapers/types";
 import { finalizeOutput, loadPage } from "./web-scrapers/types";
@@ -947,8 +948,9 @@ export function renderWebFetchResult(
 	const statusIcon = details.truncated
 		? uiTheme.styledSymbol("status.warning", "warning")
 		: uiTheme.styledSymbol("status.success", "success");
-	const expandHint = expanded ? "" : uiTheme.fg("dim", " (Ctrl+O to expand)");
-	let text = `${statusIcon} ${uiTheme.fg("accent", `(${domain})`)}${uiTheme.sep.dot}${uiTheme.fg("dim", details.method)}${expandHint}`;
+	const expandHint = formatExpandHint(uiTheme, expanded);
+	const expandSuffix = expandHint ? ` ${expandHint}` : "";
+	let text = `${statusIcon} ${uiTheme.fg("accent", `(${domain})`)}${uiTheme.sep.dot}${uiTheme.fg("dim", details.method)}${expandSuffix}`;
 
 	// Get content text
 	const contentText = result.content[0]?.text ?? "";

package/src/core/tools/web-scrapers/choosealicense.ts

@@ -1,4 +1,4 @@
-import { parseFrontmatter } from "../../../discovery/helpers";
+import { parseFrontmatter } from "../../../core/frontmatter";
 import type { RenderResult, SpecialHandler } from "./types";
 import { finalizeOutput, loadPage } from "./types";
 
@@ -69,7 +69,7 @@ export const handleChooseALicense: SpecialHandler = async (
 		const result = await loadPage(rawUrl, { timeout, headers: { Accept: "text/plain" }, signal });
 		if (!result.ok) return null;
 
-		const { frontmatter, body } = parseFrontmatter(result.content);
+		const { frontmatter, body } = parseFrontmatter(result.content, { source: rawUrl });
 
 		const title = asString(frontmatter.title) ?? formatLabel(licenseSlug);
 		const spdxId = asString(frontmatter["spdx-id"]) ?? "Unknown";

package/src/core/tools/web-search/render.ts

@@ -13,9 +13,9 @@ import {
 	formatCount,
 	formatExpandHint,
 	formatMoreItems,
+	formatStatusIcon,
 	getDomain,
 	getPreviewLines,
-	getStyledStatusIcon,
 	PREVIEW_LIMITS,
 	TRUNCATE_LENGTHS,
 	truncate,
@@ -38,8 +38,8 @@ function renderFallbackText(contentText: string, expanded: boolean, theme: Theme
 	const displayLines = lines.slice(0, maxLines).map((line) => truncate(line.trim(), 110, theme.format.ellipsis));
 	const remaining = lines.length - displayLines.length;
 
-	const headerIcon = getStyledStatusIcon("warning", theme);
-	const expandHint = formatExpandHint(expanded, remaining > 0, theme);
+	const headerIcon = formatStatusIcon("warning", theme);
+	const expandHint = formatExpandHint(theme, expanded, remaining > 0);
 	let text = `${headerIcon} ${theme.fg("dim", "Response")}${expandHint}`;
 
 	if (displayLines.length === 0) {
@@ -116,14 +116,14 @@ export function renderWebSearchResult(
 				: provider === "exa"
 					? "Exa"
 					: "Unknown";
-	const headerIcon = getStyledStatusIcon(sourceCount > 0 ? "success" : "warning", theme);
+	const headerIcon = formatStatusIcon(sourceCount > 0 ? "success" : "warning", theme);
 	const hasMore =
 		totalAnswerLines > answerPreview.length ||
 		sourceCount > 0 ||
 		citationCount > 0 ||
 		relatedCount > 0 ||
 		searchQueries.length > 0;
-	const expandHint = formatExpandHint(expanded, hasMore, theme);
+	const expandHint = formatExpandHint(theme, expanded, hasMore);
 	let text = `${headerIcon} ${theme.fg("dim", `(${providerLabel})`)}${theme.sep.dot}${theme.fg(
 		"dim",
 		formatCount("source", sourceCount),
@@ -257,7 +257,10 @@ export function renderWebSearchResult(
 	}
 	if (response.requestId) {
 		metaLines.push(
-			`${theme.fg("muted", "Request:")} ${theme.fg("text", truncate(response.requestId, MAX_REQUEST_ID_LEN, theme.format.ellipsis))}`,
+			`${theme.fg("muted", "Request:")} ${theme.fg(
+				"text",
+				truncate(response.requestId, MAX_REQUEST_ID_LEN, theme.format.ellipsis),
+			)}`,
 		);
 	}
 	if (searchQueries.length > 0) {
@@ -274,22 +277,22 @@ export function renderWebSearchResult(
 	const sections: Array<{ title: string; icon: string; lines: string[] }> = [
 		{
 			title: "Answer",
-			icon: getStyledStatusIcon("info", theme),
+			icon: formatStatusIcon("info", theme),
 			lines: answerSectionLines,
 		},
 		{
 			title: "Sources",
-			icon: getStyledStatusIcon(sourceCount > 0 ? "success" : "warning", theme),
+			icon: formatStatusIcon(sourceCount > 0 ? "success" : "warning", theme),
 			lines: sourceLines,
 		},
 		{
 			title: "Related",
-			icon: getStyledStatusIcon(relatedCount > 0 ? "info" : "warning", theme),
+			icon: formatStatusIcon(relatedCount > 0 ? "info" : "warning", theme),
 			lines: relatedLines,
 		},
 		{
 			title: "Meta",
-			icon: getStyledStatusIcon("info", theme),
+			icon: formatStatusIcon("info", theme),
 			lines: metaLines,
 		},
 	];

package/src/core/tools/write.ts

@@ -10,7 +10,7 @@ import type { ToolSession } from "../sdk";
 import { untilAborted } from "../utils";
 import { createLspWritethrough, type FileDiagnosticsResult, writethroughNoop } from "./lsp/index";
 import { resolveToCwd } from "./path-utils";
-import { formatDiagnostics, replaceTabs, shortenPath } from "./render-utils";
+import { formatDiagnostics, formatExpandHint, replaceTabs, shortenPath } from "./render-utils";
 
 const writeSchema = Type.Object({
 	path: Type.String({ description: "Path to the file to write (relative or absolute)" }),
@@ -132,7 +132,7 @@ export const writeToolRenderer = {
 				outputLines.push(
 					uiTheme.fg(
 						"toolOutput",
-						`${uiTheme.format.ellipsis} (${remaining} more lines, ${totalLines} total) ${uiTheme.format.bracketLeft}Ctrl+O to expand${uiTheme.format.bracketRight}`,
+						`${uiTheme.format.ellipsis} (${remaining} more lines, ${totalLines} total) ${formatExpandHint(uiTheme)}`,
 					),
 				);
 			}

package/src/discovery/builtin.ts

@@ -22,6 +22,7 @@ import { type SlashCommand, slashCommandCapability } from "../capability/slash-c
 import { type SystemPrompt, systemPromptCapability } from "../capability/system-prompt";
 import { type CustomTool, toolCapability } from "../capability/tool";
 import type { LoadContext, LoadResult } from "../capability/types";
+import { parseFrontmatter } from "../core/frontmatter";
 import {
 	createSourceMeta,
 	discoverExtensionModulePaths,
@@ -29,7 +30,6 @@ import {
 	getExtensionNameFromPath,
 	loadFilesFromDir,
 	loadSkillsFromDir,
-	parseFrontmatter,
 	parseJSON,
 	SOURCE_PATHS,
 } from "./helpers";
@@ -266,7 +266,7 @@ async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
 		const result = await loadFilesFromDir<Rule>(ctx, rulesDir, PROVIDER_ID, level, {
 			extensions: ["md", "mdc"],
 			transform: (name, content, path, source) => {
-				const { frontmatter, body } = parseFrontmatter(content);
+				const { frontmatter, body } = parseFrontmatter(content, { source: path });
 				return {
 					name: name.replace(/\.(md|mdc)$/, ""),
 					path,
@@ -516,7 +516,7 @@ async function loadInstructions(ctx: LoadContext): Promise<LoadResult<Instructio
 		const result = await loadFilesFromDir<Instruction>(ctx, instructionsDir, PROVIDER_ID, level, {
 			extensions: ["md"],
 			transform: (name, content, path, source) => {
-				const { frontmatter, body } = parseFrontmatter(content);
+				const { frontmatter, body } = parseFrontmatter(content, { source: path });
 				return {
 					name: name.replace(/\.instructions\.md$/, "").replace(/\.md$/, ""),
 					path,
@@ -636,7 +636,7 @@ async function loadTools(ctx: LoadContext): Promise<LoadResult<CustomTool>> {
 							_source: source,
 						};
 					}
-					const { frontmatter } = parseFrontmatter(content);
+					const { frontmatter } = parseFrontmatter(content, { source: path });
 					return {
 						name: (frontmatter.name as string) || name.replace(/\.md$/, ""),
 						path,

package/src/discovery/cline.ts

@@ -11,7 +11,8 @@ import { registerProvider } from "../capability/index";
 import type { Rule } from "../capability/rule";
 import { ruleCapability } from "../capability/rule";
 import type { LoadContext, LoadResult } from "../capability/types";
-import { createSourceMeta, loadFilesFromDir, parseFrontmatter } from "./helpers";
+import { parseFrontmatter } from "../core/frontmatter";
+import { createSourceMeta, loadFilesFromDir } from "./helpers";
 
 const PROVIDER_ID = "cline";
 const DISPLAY_NAME = "Cline";
@@ -54,7 +55,7 @@ async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
 		const result = await loadFilesFromDir(ctx, found.path, PROVIDER_ID, "project", {
 			extensions: ["md"],
 			transform: (name, content, path, source) => {
-				const { frontmatter, body } = parseFrontmatter(content);
+				const { frontmatter, body } = parseFrontmatter(content, { source: path });
 				const ruleName = name.replace(/\.md$/, "");
 
 				// Parse globs (can be array or single string)
@@ -88,7 +89,7 @@ async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
 			return { items, warnings };
 		}
 
-		const { frontmatter, body } = parseFrontmatter(content);
+		const { frontmatter, body } = parseFrontmatter(content, { source: found.path });
 		const source = createSourceMeta(PROVIDER_ID, found.path, "project");
 
 		// Parse globs (can be array or single string)

package/src/discovery/codex.ts

@@ -29,6 +29,7 @@ import { slashCommandCapability } from "../capability/slash-command";
 import type { CustomTool } from "../capability/tool";
 import { toolCapability } from "../capability/tool";
 import type { LoadContext, LoadResult } from "../capability/types";
+import { parseFrontmatter } from "../core/frontmatter";
 import { logger } from "../core/logger";
 import {
 	createSourceMeta,
@@ -36,7 +37,6 @@ import {
 	getExtensionNameFromPath,
 	loadFilesFromDir,
 	loadSkillsFromDir,
-	parseFrontmatter,
 	SOURCE_PATHS,
 } from "./helpers";
 
@@ -279,7 +279,7 @@ async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashComm
 	const transformCommand =
 		(level: "user" | "project") =>
 		(name: string, content: string, path: string, source: ReturnType<typeof createSourceMeta>) => {
-			const { frontmatter, body } = parseFrontmatter(content);
+			const { frontmatter, body } = parseFrontmatter(content, { source: path });
 			const commandName = frontmatter.name || name.replace(/\.md$/, "");
 			return {
 				name: String(commandName),
@@ -322,7 +322,7 @@ async function loadPrompts(ctx: LoadContext): Promise<LoadResult<Prompt>> {
 		path: string,
 		source: ReturnType<typeof createSourceMeta>,
 	) => {
-		const { frontmatter, body } = parseFrontmatter(content);
+		const { frontmatter, body } = parseFrontmatter(content, { source: path });
 		const promptName = frontmatter.name || name.replace(/\.md$/, "");
 		return {
 			name: String(promptName),

package/src/discovery/cursor.ts

@@ -22,13 +22,13 @@ import { ruleCapability } from "../capability/rule";
 import type { Settings } from "../capability/settings";
 import { settingsCapability } from "../capability/settings";
 import type { LoadContext, LoadResult } from "../capability/types";
+import { parseFrontmatter } from "../core/frontmatter";
 import {
 	createSourceMeta,
 	expandEnvVarsDeep,
 	getProjectPath,
 	getUserPath,
 	loadFilesFromDir,
-	parseFrontmatter,
 	parseJSON,
 } from "./helpers";
 
@@ -143,7 +143,7 @@ function transformMDCRule(
 	path: string,
 	source: ReturnType<typeof createSourceMeta>,
 ): Rule {
-	const { frontmatter, body } = parseFrontmatter(content);
+	const { frontmatter, body } = parseFrontmatter(content, { source: path });
 
 	// Extract frontmatter fields
 	const description = typeof frontmatter.description === "string" ? frontmatter.description : undefined;

package/src/discovery/github.ts

@@ -18,7 +18,8 @@ import { readFile } from "../capability/fs";
 import { registerProvider } from "../capability/index";
 import { type Instruction, instructionCapability } from "../capability/instruction";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
-import { calculateDepth, createSourceMeta, getProjectPath, loadFilesFromDir, parseFrontmatter } from "./helpers";
+import { parseFrontmatter } from "../core/frontmatter";
+import { calculateDepth, createSourceMeta, getProjectPath, loadFilesFromDir } from "./helpers";
 
 const PROVIDER_ID = "github";
 const DISPLAY_NAME = "GitHub Copilot";
@@ -79,7 +80,7 @@ function transformInstruction(name: string, content: string, path: string, sourc
 		return null;
 	}
 
-	const { frontmatter, body } = parseFrontmatter(content);
+	const { frontmatter, body } = parseFrontmatter(content, { source: path });
 
 	// Extract applyTo glob pattern from frontmatter
 	const applyTo = typeof frontmatter.applyTo === "string" ? frontmatter.applyTo : undefined;

package/src/discovery/helpers.test.ts

@@ -1,7 +1,9 @@
 import { describe, expect, test } from "bun:test";
-import { parseFrontmatter } from "./helpers";
+import { parseFrontmatter } from "../core/frontmatter";
 
 describe("parseFrontmatter", () => {
+	const parse = (content: string) => parseFrontmatter(content, { source: "tests:frontmatter", level: "off" });
+
 	test("parses simple key-value pairs", () => {
 		const content = `---
 name: test
@@ -9,7 +11,7 @@ enabled: true
 ---
 Body content`;
 
-		const result = parseFrontmatter(content);
+		const result = parse(content);
 		expect(result.frontmatter).toEqual({ name: "test", enabled: true });
 		expect(result.body).toBe("Body content");
 	});
@@ -23,7 +25,7 @@ tags:
 ---
 Body content`;
 
-		const result = parseFrontmatter(content);
+		const result = parse(content);
 		expect(result.frontmatter).toEqual({
 			tags: ["javascript", "typescript", "react"],
 		});
@@ -39,7 +41,7 @@ description: |
 ---
 Body content`;
 
-		const result = parseFrontmatter(content);
+		const result = parse(content);
 		expect(result.frontmatter).toEqual({
 			description: "This is a multi-line\ndescription block\nwith several lines\n",
 		});
@@ -57,7 +59,7 @@ config:
 ---
 Body content`;
 
-		const result = parseFrontmatter(content);
+		const result = parse(content);
 		expect(result.frontmatter).toEqual({
 			config: {
 				server: { port: 3000, host: "localhost" },
@@ -83,7 +85,7 @@ description: |
 ---
 Body content`;
 
-		const result = parseFrontmatter(content);
+		const result = parse(content);
 		expect(result.frontmatter).toEqual({
 			name: "complex-test",
 			version: "1.0.0",
@@ -99,7 +101,7 @@ Body content`;
 
 	test("handles missing frontmatter", () => {
 		const content = "Just body content";
-		const result = parseFrontmatter(content);
+		const result = parse(content);
 		expect(result.frontmatter).toEqual({});
 		expect(result.body).toBe("Just body content");
 	});
@@ -110,8 +112,10 @@ invalid: [unclosed array
 ---
 Body content`;
 
-		const result = parseFrontmatter(content);
-		expect(result.frontmatter).toEqual({}); // Fallback to empty
+		const result = parse(content);
+		// Simple fallback parser extracts key:value pairs it can parse
+		expect(result.frontmatter).toEqual({ invalid: "[unclosed array" });
+		// Body is still extracted even with invalid YAML
 		expect(result.body).toBe("Body content");
 	});
 
@@ -120,7 +124,7 @@ Body content`;
 ---
 Body content`;
 
-		const result = parseFrontmatter(content);
+		const result = parse(content);
 		expect(result.frontmatter).toEqual({});
 		expect(result.body).toBe("Body content");
 	});