toolcraft 0.0.39 → 0.0.41

package/dist/mcp.js

@@ -128,14 +128,24 @@ function formatAvailableList(values) {
     return `Available: ${[...values].sort().join(", ")}.`;
 }
 function applySchemaCasing(schema, casing) {
+    const oneOf = schema.oneOf?.map((child) => applySchemaCasing(child, casing));
+    const additionalProperties = typeof schema.additionalProperties === "object" && schema.additionalProperties !== null
+        ? applySchemaCasing(schema.additionalProperties, casing)
+        : schema.additionalProperties;
     if (schema.type !== "object" || schema.properties === undefined) {
         if (schema.type === "array" && schema.items !== undefined) {
             return {
                 ...schema,
-                items: applySchemaCasing(schema.items, casing)
+                ...(additionalProperties === undefined ? {} : { additionalProperties }),
+                items: applySchemaCasing(schema.items, casing),
+                ...(oneOf === undefined ? {} : { oneOf })
             };
         }
-        return schema;
+        return {
+            ...schema,
+            ...(additionalProperties === undefined ? {} : { additionalProperties }),
+            ...(oneOf === undefined ? {} : { oneOf })
+        };
     }
     const properties = Object.fromEntries(Object.entries(schema.properties).map(([key, value]) => [
         formatSegment(key, casing),
@@ -144,8 +154,10 @@ function applySchemaCasing(schema, casing) {
     const required = schema.required?.map((key) => formatSegment(key, casing));
     return {
         ...schema,
+        ...(additionalProperties === undefined ? {} : { additionalProperties }),
         properties,
-        ...(required === undefined ? {} : { required })
+        ...(required === undefined ? {} : { required }),
+        ...(oneOf === undefined ? {} : { oneOf })
     };
 }
 function collectParamSummaries(schema, casing, path = [], inheritedOptional = false) {
@@ -162,16 +174,32 @@ function collectParamSummaries(schema, casing, path = [], inheritedOptional = fa
     }
     return summaries;
 }
-function buildToolDescription(description, params, casing) {
+function buildToolDescription(description, params, examples, commandName, casing) {
     const summary = collectParamSummaries(params, casing);
     const parameterSummary = summary.length === 0 ? "" : `Parameters: ${summary.join(", ")}.`;
+    const exampleSummary = examples.length === 0
+        ? ""
+        : `\n\nExamples:\n${examples
+            .map((example) => `- ${example.title}: ${commandName} ${formatMcpExampleParams(example.params)}`)
+            .join("\n")}`;
     if (description === undefined) {
-        return parameterSummary;
+        return `${parameterSummary}${exampleSummary}`;
     }
     if (parameterSummary.length === 0) {
-        return description;
+        return `${description}${exampleSummary}`;
     }
-    return `${description} ${parameterSummary}`;
+    return `${description} ${parameterSummary}${exampleSummary}`;
+}
+function formatMcpExampleParams(params) {
+    return Object.entries(params)
+        .map(([key, value]) => `${key}=${formatMcpExampleValue(value)}`)
+        .join(" ");
+}
+function formatMcpExampleValue(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    return JSON.stringify(value);
 }
 function matchesAllowlist(toolName, allowlist) {
     if (allowlist === undefined) {
@@ -216,6 +244,9 @@ function enumerateTools(root, casing, allowlist, omitRootToolNamePrefix) {
                 throw new ToolcraftBugError(`command "${name}" must define an object params schema for MCP.`);
             }
             validateUniqueMCPParameterFields(params, casing);
+            if (node.result !== undefined) {
+                validateUniqueMCPParameterFields(node.result, casing);
+            }
             const resolvedCommandPath = [...commandPath, node.name].join(".");
             const existingPath = commandPathsByToolName.get(name);
             if (existingPath !== undefined) {
@@ -226,8 +257,14 @@ function enumerateTools(root, casing, allowlist, omitRootToolNamePrefix) {
                 command: node,
                 commandPath: resolvedCommandPath,
                 name,
-                description: buildToolDescription(node.description, params, casing),
-                inputSchema: applySchemaCasing(toJsonSchema(params), casing)
+                description: buildToolDescription(node.description, params, node.examples, node.name, casing),
+                inputSchema: applySchemaCasing(toJsonSchema(params), casing),
+                ...(node.result === undefined
+                    ? {}
+                    : {
+                        outputSchema: applySchemaCasing(toJsonSchema(node.result), casing),
+                        resultSchema: node.result
+                    })
             });
             return;
         }
@@ -466,6 +503,166 @@ function validateToolArguments(schema, argumentsValue, casing) {
     throwValidationErrors(errors);
     return result;
 }
+function serializeResultValue(schema, value, casing, label, errors) {
+    const unwrappedSchema = unwrapOptional(schema);
+    if (value === null && unwrappedSchema.nullable === true) {
+        return null;
+    }
+    switch (unwrappedSchema.kind) {
+        case "object":
+            return serializeResultObject(unwrappedSchema, value, casing, label, errors);
+        case "array":
+            if (!Array.isArray(value)) {
+                errors.push({
+                    path: label,
+                    message: `Invalid value for "${label}". Expected an array, got ${describeReceived(value)}.`
+                });
+                return value;
+            }
+            return value.map((item, index) => serializeResultValue(unwrappedSchema.item, item, casing, `${label}[${index}]`, errors));
+        case "record":
+            if (!isPlainObject(value)) {
+                errors.push({
+                    path: label,
+                    message: `Invalid value for "${label}". Expected an object, got ${describeReceived(value)}.`
+                });
+                return value;
+            }
+            return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+                key,
+                serializeResultValue(unwrappedSchema.value, item, casing, `${label}.${key}`, errors)
+            ]));
+        case "oneOf": {
+            if (!isPlainObject(value)) {
+                errors.push({
+                    path: label,
+                    message: `Invalid value for "${label}". Expected an object, got ${describeReceived(value)}.`
+                });
+                return value;
+            }
+            const discriminator = value[unwrappedSchema.discriminator];
+            const branch = typeof discriminator === "string" ? unwrappedSchema.branches[discriminator] : undefined;
+            if (branch === undefined) {
+                const branchNames = Object.keys(unwrappedSchema.branches);
+                errors.push({
+                    path: label.length === 0 ? unwrappedSchema.discriminator : `${label}.${unwrappedSchema.discriminator}`,
+                    message: `Invalid value for "${label.length === 0 ? unwrappedSchema.discriminator : `${label}.${unwrappedSchema.discriminator}`}". Expected one of: ${branchNames.join(", ")}, got ${describeReceived(discriminator)}.`
+                });
+                return value;
+            }
+            const { [unwrappedSchema.discriminator]: ignoredDiscriminator, ...branchValue } = value;
+            void ignoredDiscriminator;
+            return {
+                [formatSegment(unwrappedSchema.discriminator, casing)]: discriminator,
+                ...serializeResultObject(branch, branchValue, casing, label, errors)
+            };
+        }
+        case "union": {
+            if (!isPlainObject(value)) {
+                errors.push({
+                    path: label,
+                    message: `Invalid value for "${label}". Expected an object, got ${describeReceived(value)}.`
+                });
+                return value;
+            }
+            const branch = unwrappedSchema.branches.find((candidate) => Object.keys(candidate.shape).every((key) => candidate.shape[key]?.kind === "optional" ||
+                Object.prototype.hasOwnProperty.call(value, key)));
+            if (branch === undefined) {
+                errors.push({
+                    path: label,
+                    message: `Invalid value for "${label}". Expected one union branch, got ${describeReceived(value)}.`
+                });
+                return value;
+            }
+            return serializeResultObject(branch, value, casing, label, errors);
+        }
+        default:
+            return validateSchemaValue(schema, value, casing, label, errors);
+    }
+}
+function serializeResultObject(schema, value, casing, label, errors) {
+    if (!isPlainObject(value)) {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}". Expected an object, got ${describeReceived(value)}.`
+        });
+        return {};
+    }
+    const result = {};
+    const expectedKeys = new Set(Object.keys(schema.shape));
+    for (const key of Object.keys(value)) {
+        if (!expectedKeys.has(key) && schema.additionalProperties !== true) {
+            const fieldLabel = label.length === 0 ? key : `${label}.${key}`;
+            errors.push({
+                path: fieldLabel,
+                message: `Unexpected result field "${fieldLabel}". ${formatAvailableList([...expectedKeys].map((expectedKey) => label.length === 0 ? expectedKey : `${label}.${expectedKey}`))}`
+            });
+        }
+    }
+    for (const [sourceKey, rawChildSchema] of Object.entries(schema.shape)) {
+        const childSchema = unwrapOptional(rawChildSchema);
+        const hasValue = Object.prototype.hasOwnProperty.call(value, sourceKey);
+        const wireKey = formatSegment(sourceKey, casing);
+        const fieldLabel = label.length === 0 ? sourceKey : `${label}.${sourceKey}`;
+        if (!hasValue) {
+            if (childSchema.default !== undefined) {
+                Object.defineProperty(result, wireKey, {
+                    value: childSchema.default,
+                    enumerable: true,
+                    configurable: true,
+                    writable: true
+                });
+                continue;
+            }
+            if (isOptional(rawChildSchema)) {
+                continue;
+            }
+            errors.push({ path: fieldLabel, message: `Missing required result field "${fieldLabel}".` });
+            continue;
+        }
+        Object.defineProperty(result, wireKey, {
+            value: serializeResultValue(rawChildSchema, value[sourceKey], casing, fieldLabel, errors),
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    }
+    if (schema.additionalProperties === true) {
+        for (const key of Object.keys(value)) {
+            if (!expectedKeys.has(key)) {
+                Object.defineProperty(result, key, {
+                    value: value[key],
+                    enumerable: true,
+                    configurable: true,
+                    writable: true
+                });
+            }
+        }
+    }
+    return result;
+}
+function validateCommandResult(schema, value, casing) {
+    const errors = [];
+    const result = serializeResultObject(schema, value, casing, "", errors);
+    throwResultValidationErrors(errors);
+    return result;
+}
+function throwResultValidationErrors(errors) {
+    if (errors.length === 0) {
+        return;
+    }
+    if (errors.length === 1) {
+        throw new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, errors[0]?.message ?? "Invalid command result.");
+    }
+    const rendered = errors
+        .slice(0, 10)
+        .map((error) => `  - ${error.path}: ${error.message}`);
+    const remaining = errors.length - rendered.length;
+    if (remaining > 0) {
+        rendered.push(`  ... and ${remaining} more`);
+    }
+    throw new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, `${errors.length} result errors:\n${rendered.join("\n")}`);
+}
 function isContentBlock(value) {
     if (!isPlainObject(value) || typeof value.type !== "string") {
         return false;
@@ -491,7 +688,9 @@ function toToolContent(result) {
     if (isContentBlock(result)) {
         return [result];
     }
-    return [{ type: "text", text: JSON.stringify(result) }];
+    const fallbackValue = result;
+    const fallbackText = JSON.stringify(fallbackValue);
+    return [{ type: "text", text: fallbackText }];
 }
 function toToolError(error) {
     if (error instanceof ToolError) {
@@ -524,7 +723,7 @@ function createResolvedMCPServer(root, options) {
         validateToolArguments: false
     });
     for (const tool of tools) {
-        server.tool(tool.name, tool.description, tool.inputSchema, async (argumentsValue) => {
+        const handler = async (argumentsValue) => {
             let params;
             let secrets;
             try {
@@ -548,6 +747,13 @@ function createResolvedMCPServer(root, options) {
                 if (isHumanInLoopPending(result)) {
                     return renderPendingApproval(result);
                 }
+                if (tool.resultSchema !== undefined) {
+                    const structuredContent = validateCommandResult(tool.resultSchema, result, casing);
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(structuredContent) }],
+                        structuredContent
+                    };
+                }
                 return toToolContent(result);
             }
             catch (error) {
@@ -566,7 +772,13 @@ function createResolvedMCPServer(root, options) {
                 });
                 throw toToolError(error);
             }
-        });
+        };
+        if (tool.outputSchema === undefined) {
+            server.tool(tool.name, tool.description, tool.inputSchema, handler);
+        }
+        else {
+            server.tool(tool.name, tool.description, tool.inputSchema, handler, tool.outputSchema);
+        }
     }
     return {
         ...server,

package/dist/number-schema.js

@@ -1,8 +1,15 @@
 export function isValidNumberSchemaValue(value, schema) {
     return (typeof value === "number" &&
         Number.isFinite(value) &&
-        (schema.jsonType !== "integer" || Number.isInteger(value)));
+        (schema.jsonType !== "integer" || Number.isInteger(value)) &&
+        (schema.minimum === undefined || value >= schema.minimum) &&
+        (schema.maximum === undefined || value <= schema.maximum));
 }
 export function getExpectedNumberDescription(schema) {
-    return schema.jsonType === "integer" ? "an integer" : "a number";
+    const type = schema.jsonType === "integer" ? "an integer" : "a number";
+    const bounds = [
+        schema.minimum === undefined ? undefined : `greater than or equal to ${schema.minimum}`,
+        schema.maximum === undefined ? undefined : `less than or equal to ${schema.maximum}`
+    ].filter((bound) => bound !== undefined);
+    return bounds.length === 0 ? type : `${type} ${bounds.join(" and ")}`;
 }

package/node_modules/@poe-code/agent-defs/dist/agents/claude-code.js

@@ -11,7 +11,7 @@ export const claudeCodeAgent = {
             CLAUDE_CODE_ENABLE_TELEMETRY: "1"
         }
     },
-    configPath: "~/.claude/settings.json",
+    configPath: "~/.claude.json",
     branding: {
         colors: {
             dark: "#C15F3C",

package/node_modules/@poe-code/agent-defs/dist/agents/claude-desktop.js

@@ -3,7 +3,12 @@ export const claudeDesktopAgent = {
     name: "claude-desktop",
     label: "Claude Desktop",
     summary: "Anthropic's official desktop application for Claude",
-    configPath: "~/.claude/settings.json",
+    configPath: "~/.config/Claude/claude_desktop_config.json",
+    configPaths: {
+        darwin: "~/Library/Application Support/Claude/claude_desktop_config.json",
+        linux: "~/.config/Claude/claude_desktop_config.json",
+        win32: "~/AppData/Roaming/Claude/claude_desktop_config.json"
+    },
     branding: {
         colors: {
             dark: "#D97757",

package/node_modules/@poe-code/agent-defs/dist/agents/cursor.js

@@ -5,7 +5,7 @@ export const cursorAgent = {
     label: "Cursor",
     summary: "Cursor's CLI coding agent.",
     binaryName: "cursor-agent",
-    configPath: "~/.cursor/cli-config.json",
+    configPath: "~/.cursor/mcp.json",
     branding: {
         colors: {
             dark: "#FFFFFF",

package/node_modules/@poe-code/agent-defs/dist/agents/kimi.js

@@ -6,7 +6,7 @@ export const kimiAgent = {
     aliases: ["kimi-cli"],
     binaryName: "kimi",
     apiShapes: ["openai-chat-completions"],
-    configPath: "~/.kimi/config.toml",
+    configPath: "~/.kimi/mcp.json",
     branding: {
         colors: {
             dark: "#7B68EE",

package/node_modules/@poe-code/agent-defs/dist/agents/opencode.js

@@ -10,7 +10,7 @@ export const openCodeAgent = {
             OPENCODE_CONFIG_CONTENT: '{"experimental":{"openTelemetry":true}}'
         }
     },
-    configPath: "~/.config/opencode/config.json",
+    configPath: "~/.config/opencode/opencode.json",
     branding: {
         colors: {
             dark: "#4A4F55",

package/node_modules/@poe-code/agent-defs/dist/specifier.js

@@ -2,24 +2,33 @@ import { resolveAgentId } from "./registry.js";
 function getOwnModel(specifier) {
     return Object.prototype.hasOwnProperty.call(specifier, "model") ? specifier.model : undefined;
 }
+function requireNonBlank(value, field) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new TypeError(`${field} must not be empty`);
+    }
+    return trimmed;
+}
 export function parseAgentSpecifier(input) {
     const colonIndex = input.indexOf(":");
     if (colonIndex === -1) {
-        return { agent: input.trim() };
+        return { agent: requireNonBlank(input, "agent") };
     }
-    const agent = input.slice(0, colonIndex).trim();
+    const agent = requireNonBlank(input.slice(0, colonIndex), "agent");
     const model = input.slice(colonIndex + 1).trim();
     return {
         agent,
-        ...(model.length > 0 ? { model } : {}),
+        ...(model.length > 0 ? { model } : {})
     };
 }
 export function formatAgentSpecifier(specifier) {
+    const agent = requireNonBlank(specifier.agent, "agent");
     const model = getOwnModel(specifier);
-    if (model) {
-        return `${specifier.agent}:${model}`;
+    const normalizedModel = model?.trim();
+    if (normalizedModel) {
+        return `${agent}:${normalizedModel}`;
     }
-    return specifier.agent;
+    return agent;
 }
 export function normalizeAgentId(input) {
     const specifier = parseAgentSpecifier(input.trim());

package/node_modules/@poe-code/agent-defs/dist/types.d.ts

@@ -14,6 +14,11 @@ export interface AgentDefinition {
     readonly apiShapes?: readonly ApiShapeId[];
     readonly otelCapture?: OtelCaptureDefinition;
     configPath: string;
+    readonly configPaths?: {
+        readonly darwin: string;
+        readonly linux: string;
+        readonly win32: string;
+    };
     branding: {
         colors: {
             dark: string;

package/node_modules/@poe-code/agent-mcp-config/dist/apply.js

@@ -15,6 +15,32 @@ export class UnsupportedAgentError extends Error {
 function isConfigObject(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function assertNonEmptyString(value, message) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(message);
+    }
+}
+function assertHttpUrl(value) {
+    assertNonEmptyString(value, "MCP HTTP URL must be a valid http or https URL.");
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new Error("MCP HTTP URL must be a valid http or https URL.");
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error("MCP HTTP URL must be a valid http or https URL.");
+    }
+}
+function validateServerEntry(server) {
+    assertNonEmptyString(server.name, "MCP server name must be a non-empty string.");
+    if (server.config.transport === "stdio") {
+        assertNonEmptyString(server.config.command, "MCP stdio command must be a non-empty string.");
+        return;
+    }
+    assertHttpUrl(server.config.url);
+}
 function resolveServerMap(document, configKey) {
     const value = document[configKey];
     if (value === undefined) {
@@ -32,12 +58,15 @@ export async function configure(agentId, server, options) {
     if (!isSupported(agentId)) {
         throw new UnsupportedAgentError(agentId);
     }
+    validateServerEntry(server);
     const config = getAgentConfig(agentId);
     const configPath = resolveConfigPath(config, options.platform);
     const shapeTransformer = getShapeTransformer(config.shape);
     const shaped = shapeTransformer(server);
+    const enabledServer = { ...server, enabled: true };
+    const enabledShaped = shapeTransformer(enabledServer);
     if (shaped === undefined) {
-        await unconfigure(agentId, server.name, options);
+        await unconfigure(agentId, enabledServer, options);
         return;
     }
     const configDir = getConfigDirectory(configPath);
@@ -57,10 +86,13 @@ export async function configure(agentId, server, options) {
                     ? servers[server.name]
                     : undefined;
                 const shapedServer = shaped;
+                const enabledShapedServer = enabledShaped;
                 if (existingServer !== undefined && isDeepStrictEqual(existingServer, shapedServer)) {
                     return { changed: false, content: document };
                 }
-                if (existingServer !== undefined && server.enabled !== false) {
+                if (existingServer !== undefined &&
+                    (enabledShapedServer === undefined ||
+                        !isDeepStrictEqual(existingServer, enabledShapedServer))) {
                     throw new Error(`MCP server "${server.name}" already exists with different configuration in ${configPath}.`);
                 }
                 const newServers = {
@@ -98,7 +130,8 @@ export async function unconfigure(agentId, server, options) {
                 if (!Object.hasOwn(servers, serverName)) {
                     return { changed: false, content: document };
                 }
-                if (expectedServer !== undefined && !isDeepStrictEqual(servers[serverName], expectedServer)) {
+                if (expectedServer !== undefined &&
+                    !isDeepStrictEqual(servers[serverName], expectedServer)) {
                     return { changed: false, content: document };
                 }
                 const newServers = { ...servers };

package/node_modules/@poe-code/frontmatter/README.md

@@ -0,0 +1,35 @@
+# @poe-code/frontmatter
+
+Shared YAML frontmatter parsing for poe-code packages.
+
+## API
+
+```ts
+import {
+  FrontmatterParseError,
+  parseFrontmatter,
+  parseFrontmatterDocument,
+  stringifyFrontmatter
+} from "@poe-code/frontmatter";
+```
+
+- `parseFrontmatter(source)` returns `{ frontmatter, body }`.
+- `parseFrontmatterDocument(source)` returns `{ frontmatter, body, errors, lineCounter }` for callers that need YAML diagnostics.
+- `stringifyFrontmatter(frontmatter, body)` writes `---` fences, YAML, and the body.
+- `FrontmatterParseError` is thrown for malformed frontmatter, invalid YAML, non-object frontmatter, and stringify failures.
+
+When no leading frontmatter block exists, parsing returns `{ frontmatter: {}, body: source }`.
+The returned `body` is sliced from the original input and is otherwise byte-for-byte unchanged.
+YAML mappings that contain `__proto__` keep it as an own property without changing the object's prototype.
+
+Duplicate mapping keys use YAML's last-wins behavior by default, matching the
+legacy frontmatter readers. Callers that need strict YAML mappings can pass
+`{ uniqueKeys: true }` to `parseFrontmatter` or `parseFrontmatterDocument`.
+
+## Environment
+
+This package reads no environment variables.
+
+## Config
+
+This package has no configuration options.

package/node_modules/@poe-code/frontmatter/dist/fences.d.ts

@@ -0,0 +1,8 @@
+export type FrontmatterBlock = {
+    raw: string;
+    body: string;
+};
+export type SplitFrontmatterResult = FrontmatterBlock | {
+    body: string;
+};
+export declare function splitFrontmatterBlock(source: string): SplitFrontmatterResult;

package/node_modules/@poe-code/frontmatter/dist/fences.js

@@ -0,0 +1,72 @@
+export function splitFrontmatterBlock(source) {
+    const content = source.startsWith("\uFEFF") ? source.slice(1) : source;
+    const opening = readOpeningFence(content);
+    if (opening === undefined) {
+        return { body: source };
+    }
+    const closing = findClosingFence(content, opening.next);
+    if (closing === undefined) {
+        throw new Error("Missing YAML frontmatter end delimiter (---).");
+    }
+    return {
+        raw: content.slice(opening.next, closing.index),
+        body: content.slice(closing.end + closing.lineBreakLength)
+    };
+}
+function readOpeningFence(source) {
+    if (!source.startsWith("---")) {
+        return undefined;
+    }
+    const lineEnd = findLineEnd(source, 0);
+    if (lineEnd.lineBreakLength === 0 || source.slice(0, lineEnd.index) !== "---") {
+        return undefined;
+    }
+    return { next: lineEnd.index + lineEnd.lineBreakLength };
+}
+function findClosingFence(source, start) {
+    let lineStart = start;
+    while (lineStart <= source.length) {
+        const lineEnd = findLineEnd(source, lineStart);
+        if (isClosingFenceLine(source.slice(lineStart, lineEnd.index))) {
+            return {
+                index: lineStart,
+                end: lineEnd.index,
+                lineBreakLength: lineEnd.lineBreakLength
+            };
+        }
+        if (lineEnd.lineBreakLength === 0) {
+            break;
+        }
+        lineStart = lineEnd.index + lineEnd.lineBreakLength;
+    }
+    return undefined;
+}
+function isClosingFenceLine(line) {
+    if (!line.startsWith("---")) {
+        return false;
+    }
+    for (let index = 3; index < line.length; index += 1) {
+        const character = line[index];
+        if (character !== " " && character !== "\t") {
+            return false;
+        }
+    }
+    return true;
+}
+function findLineEnd(source, start) {
+    let index = start;
+    while (index < source.length) {
+        const character = source[index];
+        if (character === "\n") {
+            return { index, lineBreakLength: 1 };
+        }
+        if (character === "\r") {
+            return {
+                index,
+                lineBreakLength: source[index + 1] === "\n" ? 2 : 1
+            };
+        }
+        index += 1;
+    }
+    return { index: source.length, lineBreakLength: 0 };
+}

package/node_modules/@poe-code/frontmatter/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { splitFrontmatterBlock, type FrontmatterBlock, type SplitFrontmatterResult } from "./fences.js";
+export { FrontmatterParseError, parseFrontmatter, parseFrontmatterDocument, type ParsedFrontmatter, type ParsedFrontmatterDocument, type ParseFrontmatterOptions } from "./parse.js";
+export { stringifyFrontmatter } from "./stringify.js";

package/node_modules/@poe-code/frontmatter/dist/index.js

@@ -0,0 +1,3 @@
+export { splitFrontmatterBlock } from "./fences.js";
+export { FrontmatterParseError, parseFrontmatter, parseFrontmatterDocument } from "./parse.js";
+export { stringifyFrontmatter } from "./stringify.js";

package/node_modules/@poe-code/frontmatter/dist/parse.d.ts

@@ -0,0 +1,20 @@
+import { LineCounter } from "yaml";
+export interface ParsedFrontmatter {
+    frontmatter: Record<string, unknown>;
+    body: string;
+}
+export interface ParsedFrontmatterDocument extends ParsedFrontmatter {
+    errors: readonly {
+        message: string;
+        pos?: [number, number];
+    }[];
+    lineCounter: LineCounter;
+}
+export interface ParseFrontmatterOptions {
+    uniqueKeys?: boolean;
+}
+export declare class FrontmatterParseError extends Error {
+    constructor(message: string);
+}
+export declare function parseFrontmatter(source: string, options?: ParseFrontmatterOptions): ParsedFrontmatter;
+export declare function parseFrontmatterDocument(source: string, options?: ParseFrontmatterOptions): ParsedFrontmatterDocument;