toolcraft 0.0.84 → 0.0.86

package/dist/cli.d.ts

@@ -1,7 +1,8 @@
+import "./node-require-shim.js";
 import { configureTheme } from "toolcraft-design";
 import type { Group, LogLevel, RuntimeLoggerInput } from "./index.js";
 import { type ErrorReportsOption } from "./error-report.js";
-import type { HumanInLoopRuntimeOptions } from "./human-in-loop/index.js";
+import type { HumanInLoopRuntimeOptions } from "./human-in-loop/types.js";
 export { configureTheme };
 type Casing = "kebab" | "snake";
 export interface CLIControls {

package/dist/cli.js

@@ -1,13 +1,11 @@
+import "./node-require-shim.js";
 import { access, lstat, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { Command as CommanderCommand, CommanderError, InvalidArgumentError, Option } from "commander";
 import { cancel, configureTheme, confirm, createLogger, formatCommandList, formatOptionList, getTheme, helpFormatterPlain, isCancel, note, promptText, renderTable, resetOutputFormatCache, select, text } from "toolcraft-design";
-import { ApprovalDeclinedError, UserError, assertCommandRequirements, getCommandSourcePath, resolveCommandSecrets } from "./index.js";
+import { ApprovalDeclinedError, UserError, assertCommandRequirements, getCommandSourcePath, hasMcpProxyConfig, resolveCommandSecrets } from "./index.js";
 import { hasOwnErrorCode } from "./error-codes.js";
-import { mergeApprovalsGroup } from "./human-in-loop/approvals-commands.js";
 import { writeErrorReport } from "./error-report.js";
-import { invokeWithHumanInLoop } from "./human-in-loop/index.js";
-import { resolveMcpProxies } from "./mcp-proxy.js";
 import { getExpectedNumberDescription, isValidNumberSchemaValue } from "./number-schema.js";
 import { findEntrypointPackageMetadata } from "./package-metadata.js";
 import { redactHttpBody, redactHttpHeaderValue } from "./redaction.js";
@@ -33,6 +31,14 @@ const RESERVED_SERVICE_NAMES = new Set([
 ]);
 const RESERVED_SERVICE_NAMES_MESSAGE = "Available reserved names: params, secrets, fetch, fs, env, diagnostics, progress, runtimeOptions, root.";
 const NULL_OPTION_VALUE = Symbol("toolcraft.cli.null");
+const optionalModulePaths = {
+    approvals: "./human-in-loop/approvals-commands.js",
+    humanInLoop: "./human-in-loop/gate.js",
+    mcpProxy: "./mcp-proxy.js"
+};
+function importOptionalModule(specifier) {
+    return import(specifier);
+}
 function inferProgramName(argv) {
     const entrypoint = argv[1];
     if (typeof entrypoint !== "string" || entrypoint.length === 0) {
@@ -2875,7 +2881,9 @@ async function executeCommand(state, services, requirementOptions, runtimeFetch,
                     throw new UserError("Operation cancelled.");
                 }
             }
-            const result = await invokeWithHumanInLoop(state.command, context, runtimeOptions, state.commandPath);
+            const result = state.command.humanInLoop
+                ? await (await importOptionalModule(optionalModulePaths.humanInLoop)).invokeWithHumanInLoop(state.command, context, runtimeOptions, state.commandPath)
+                : await state.command.handler(context);
             if (output === "rich" && runtime.isFixture) {
                 writeRichHeader(`${state.command.name} (fixture)`);
             }
@@ -3419,8 +3427,12 @@ export async function runCLI(roots, options = {}) {
     let errorReportContext;
     try {
         const normalizedRoot = normalizeRoots(roots, argv);
-        const root = options.approvals === true ? mergeApprovalsGroup(normalizedRoot) : normalizedRoot;
-        await resolveMcpProxies(root, { projectRoot: options.projectRoot });
+        const root = options.approvals === true
+            ? (await importOptionalModule(optionalModulePaths.approvals)).mergeApprovalsGroup(normalizedRoot)
+            : normalizedRoot;
+        if (hasMcpProxyConfig(root)) {
+            await (await importOptionalModule(optionalModulePaths.mcpProxy)).resolveMcpProxies(root, { projectRoot: options.projectRoot });
+        }
         const casing = options.casing ?? "kebab";
         const services = (options.services ?? {});
         const runtimeOptions = options.humanInLoop ?? {};

package/dist/design/render-markdown-plaintext.d.ts

@@ -0,0 +1,2 @@
+export { renderMarkdownPlaintext, renderPlaintext } from "toolcraft-design/render-markdown-plaintext";
+export type { PlaintextRenderOptions } from "toolcraft-design/render-markdown-plaintext";

package/dist/design/render-markdown-plaintext.js

@@ -0,0 +1 @@
+export { renderMarkdownPlaintext, renderPlaintext } from "toolcraft-design/render-markdown-plaintext";

package/dist/error-report.js

@@ -4,8 +4,8 @@ import os from "node:os";
 import path from "node:path";
 import { CommanderError } from "commander";
 import { ApprovalDeclinedError } from "./human-in-loop/types.js";
-import { findProjectRoot } from "./mcp-proxy.js";
 import { findPackageMetadata } from "./package-metadata.js";
+import { findProjectRoot } from "./project-root.js";
 import { isSensitiveName, redactHttpBody, redactHttpHeaderValue } from "./redaction.js";
 import { UserError } from "./user-error.js";
 const ERROR_REPORTS_ENV = "TOOLCRAFT_ERROR_REPORTS";

package/dist/index.d.ts

@@ -200,6 +200,7 @@ export declare function defineGroup<TServices extends object = EmptyServices, TN
     humanInLoop?: TOwnHumanInLoop;
 }): Group<TServices> & TypedGroupMetadata<TServices, TName, TChildren, TOwnScope, ResolveOwnHumanInLoopMode<TOwnHumanInLoop>>;
 export declare function getCommandSourcePath(command: Command<any, any, any, any>): string | undefined;
+export declare function hasMcpProxyConfig(group: Group<any>): boolean;
 export { S, toJsonSchema } from "toolcraft-schema";
 export { AuthenticationError, BadRequestError, ClientError, ConflictError, HttpError, InternalServerError, NotFoundError, PermissionDeniedError, RateLimitError, ServerError, ServiceUnavailableError, UnprocessableEntityError, createHttpError } from "./http-errors.js";
 export type { HttpErrorRequest, HttpErrorResponse } from "./http-errors.js";

package/dist/index.js

@@ -469,6 +469,17 @@ export function defineGroup(config) {
 export function getCommandSourcePath(command) {
     return command[commandSourcePathSymbol];
 }
+export function hasMcpProxyConfig(group) {
+    const configSymbol = Object.getOwnPropertySymbols(group).find((candidate) => candidate.description === groupConfigSymbol.description);
+    const config = configSymbol === undefined
+        ? undefined
+        : group[configSymbol];
+    if (config?.mcp !== undefined) {
+        return true;
+    }
+    const children = config?.children ?? group.children;
+    return children.some((child) => child.kind === "group" && hasMcpProxyConfig(child));
+}
 export { S, toJsonSchema } from "toolcraft-schema";
 export { AuthenticationError, BadRequestError, ClientError, ConflictError, HttpError, InternalServerError, NotFoundError, PermissionDeniedError, RateLimitError, ServerError, ServiceUnavailableError, UnprocessableEntityError, createHttpError } from "./http-errors.js";
 export { ApprovalDeclinedError, ToolcraftBugError, UserError };

package/dist/mcp-proxy.d.ts

@@ -1,11 +1,11 @@
 import type { McpServerConfig } from "@poe-code/agent-mcp-config";
 import { McpClient } from "tiny-mcp-client";
 import type { Group } from "./index.js";
+export { findProjectRoot } from "./project-root.js";
 export interface ResolveMcpProxyOptions {
     projectRoot?: string;
 }
 export declare function hasMcpProxyGroups(root: Group<any>): boolean;
-export declare function findProjectRoot(from?: string): string | undefined;
 export declare function resolveCachePath(name: string, projectRoot?: string): string;
 export declare function parseRefreshEnv(value: string | undefined): "all" | Set<string> | undefined;
 export declare function dialUpstream(name: string, config: McpServerConfig): Promise<McpClient>;

package/dist/mcp-proxy.js

@@ -1,4 +1,3 @@
-import { existsSync } from "node:fs";
 import { lstat, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { createHash, randomUUID } from "node:crypto";
@@ -6,6 +5,8 @@ import { createLogger } from "toolcraft-design";
 import { HttpTransport, McpClient, StdioTransport } from "tiny-mcp-client";
 import { hasOwnErrorCode } from "./error-codes.js";
 import { convertJsonSchema } from "./json-schema-converter.js";
+import { findProjectRoot } from "./project-root.js";
+export { findProjectRoot } from "./project-root.js";
 const GROUP_CONFIG_SYMBOL_DESCRIPTION = "toolcraft.group.config";
 const MCP_PROXY_SCHEMA_URL = "https://poe-platform.github.io/poe-code/schemas/toolcraft/mcp-proxy.schema.json";
 const DEFAULT_CLIENT_INFO = {
@@ -400,22 +401,6 @@ function collectProxyGroups(root) {
 export function hasMcpProxyGroups(root) {
     return collectProxyGroups(root).length > 0;
 }
-export function findProjectRoot(from = process.cwd()) {
-    let current = process.cwd();
-    if (from !== current) {
-        current = path.resolve(from);
-    }
-    while (true) {
-        if (existsSync(path.join(current, "package.json"))) {
-            return current;
-        }
-        const parent = path.dirname(current);
-        if (parent === current) {
-            return undefined;
-        }
-        current = parent;
-    }
-}
 export function resolveCachePath(name, projectRoot) {
     const resolvedProjectRoot = projectRoot ?? findProjectRoot();
     if (resolvedProjectRoot === undefined) {

package/dist/node-require-shim.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node-require-shim.js

@@ -0,0 +1,4 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+const globalWithRequire = globalThis;
+globalWithRequire.require ??= createRequire(path.join(process.cwd(), "package.json"));

package/dist/project-root.d.ts

@@ -0,0 +1 @@
+export declare function findProjectRoot(from?: string): string | undefined;

package/dist/project-root.js

@@ -0,0 +1,15 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+export function findProjectRoot(from = process.cwd()) {
+    let current = from === process.cwd() ? process.cwd() : path.resolve(from);
+    while (true) {
+        if (existsSync(path.join(current, "package.json"))) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return undefined;
+        }
+        current = parent;
+    }
+}

package/node_modules/toolcraft-design/dist/index.d.ts

@@ -44,8 +44,8 @@ export { promptTheme } from "./prompts/theme.js";
 export * as staticRender from "./static/index.js";
 export { SPINNER_FRAMES, renderSpinnerFrame, renderSpinnerStopped, renderMenu } from "./static/index.js";
 export type { SpinnerFrameOptions, SpinnerStoppedOptions, MenuOption, RenderMenuOptions } from "./static/index.js";
-export { parse, render, renderHtml, renderMarkdown, renderMarkdownHtml } from "./terminal-markdown/index.js";
-export type { CodeToken, CodeTokenKind, HtmlRenderOptions, MdNode, RenderOptions } from "./terminal-markdown/index.js";
+export { parse, render, renderHtml, renderMarkdown, renderMarkdownHtml, renderPlaintext, renderMarkdownPlaintext } from "./terminal-markdown/index.js";
+export type { CodeToken, CodeTokenKind, HtmlRenderOptions, MdNode, PlaintextRenderOptions, RenderOptions } from "./terminal-markdown/index.js";
 export { getTheme, resolveThemeName, resetThemeCache } from "./internal/theme-detect.js";
 export type { ThemeEnv } from "./internal/theme-detect.js";
 export { configureTheme, getThemeConfig, resetTheme } from "./internal/theme-state.js";

package/node_modules/toolcraft-design/dist/index.js

@@ -37,7 +37,7 @@ export { promptTheme } from "./prompts/theme.js";
 export * as staticRender from "./static/index.js";
 export { SPINNER_FRAMES, renderSpinnerFrame, renderSpinnerStopped, renderMenu } from "./static/index.js";
 // Terminal markdown
-export { parse, render, renderHtml, renderMarkdown, renderMarkdownHtml } from "./terminal-markdown/index.js";
+export { parse, render, renderHtml, renderMarkdown, renderMarkdownHtml, renderPlaintext, renderMarkdownPlaintext } from "./terminal-markdown/index.js";
 // Internal utilities (for advanced use)
 export { getTheme, resolveThemeName, resetThemeCache } from "./internal/theme-detect.js";
 export { configureTheme, getThemeConfig, resetTheme } from "./internal/theme-state.js";

package/node_modules/toolcraft-design/dist/render-markdown-plaintext.d.ts

@@ -0,0 +1,2 @@
+export { renderMarkdownPlaintext, renderPlaintext } from "./terminal-markdown/index.js";
+export type { PlaintextRenderOptions } from "./terminal-markdown/index.js";

package/node_modules/toolcraft-design/dist/render-markdown-plaintext.js

@@ -0,0 +1 @@
+export { renderMarkdownPlaintext, renderPlaintext } from "./terminal-markdown/index.js";

package/node_modules/toolcraft-design/dist/terminal-markdown/index.d.ts

@@ -3,6 +3,8 @@ import { type RenderOptions } from "./renderer.js";
 export type { CodeToken, CodeTokenKind, MdNode } from "./ast.js";
 export { renderHtml } from "./html-renderer.js";
 export type { HtmlRenderOptions } from "./html-renderer.js";
+export { renderPlaintext, renderMarkdownPlaintext } from "./plaintext-renderer.js";
+export type { PlaintextRenderOptions } from "./plaintext-renderer.js";
 export { parse } from "./parser.js";
 export { render } from "./renderer.js";
 export type { RenderOptions } from "./renderer.js";

package/node_modules/toolcraft-design/dist/terminal-markdown/index.js

@@ -2,6 +2,7 @@ import { parse } from "./parser.js";
 import { renderHtml } from "./html-renderer.js";
 import { render } from "./renderer.js";
 export { renderHtml } from "./html-renderer.js";
+export { renderPlaintext, renderMarkdownPlaintext } from "./plaintext-renderer.js";
 export { parse } from "./parser.js";
 export { render } from "./renderer.js";
 export function renderMarkdown(markdown, options) {

package/node_modules/toolcraft-design/dist/terminal-markdown/parser/inline.js

@@ -853,9 +853,12 @@ function parseInlineHtmlTag(input, start, offsets) {
             return null;
         }
         if (input[index] === ">") {
+            const tagEnd = index + 1;
+            const closingTagEnd = findClosingInlineHtmlTagEnd(input, tagEnd, tagName);
+            const nodeEnd = closingTagEnd ?? tagEnd;
             return {
-                node: withRange({ type: "html", value: input.slice(start, index + 1) }, offsets === undefined ? { start, end: index + 1 } : createRange(offsets, start, index + 1)),
-                end: index + 1
+                node: withRange({ type: "html", value: input.slice(start, nodeEnd) }, offsets === undefined ? { start, end: nodeEnd } : createRange(offsets, start, nodeEnd)),
+                end: nodeEnd
             };
         }
         if (input[index] === "/") {
@@ -907,6 +910,39 @@ function parseInlineHtmlTag(input, start, offsets) {
     }
     return null;
 }
+function findClosingInlineHtmlTagEnd(input, start, tagName) {
+    let index = start;
+    while (index < input.length) {
+        if (input[index] !== "<") {
+            index += 1;
+            continue;
+        }
+        const closingEnd = readClosingInlineHtmlTagEnd(input, index, tagName);
+        if (closingEnd !== undefined) {
+            return closingEnd;
+        }
+        index += 1;
+    }
+    return undefined;
+}
+function readClosingInlineHtmlTagEnd(input, start, tagName) {
+    let index = start + 1;
+    if (index >= input.length || input[index] !== "/") {
+        return undefined;
+    }
+    index += 1;
+    for (const expectedChar of tagName) {
+        if (index >= input.length || input[index]?.toLowerCase() !== expectedChar) {
+            return undefined;
+        }
+        index += 1;
+    }
+    index = skipHtmlWhitespace(input, index);
+    if (index >= input.length || input[index] !== ">") {
+        return undefined;
+    }
+    return index + 1;
+}
 function decodeEscapes(value) {
     let result = "";
     let index = 0;

package/node_modules/toolcraft-design/dist/terminal-markdown/plaintext-renderer.d.ts

@@ -0,0 +1,11 @@
+import type { MdNode } from "./ast.js";
+export interface PlaintextRenderOptions {
+    announceHeadings?: boolean;
+    announceCode?: boolean;
+    announceAlerts?: boolean;
+    showLinks?: boolean;
+    expandLinks?: boolean;
+    includeFrontmatter?: boolean;
+}
+export declare function renderPlaintext(ast: MdNode, options?: PlaintextRenderOptions): string;
+export declare function renderMarkdownPlaintext(markdown: string, options?: PlaintextRenderOptions): string;

package/node_modules/toolcraft-design/dist/terminal-markdown/plaintext-renderer.js

@@ -0,0 +1,228 @@
+import { stripAnsi } from "../internal/strip-ansi.js";
+import { parse } from "./parser.js";
+function renderInline(node, ctx) {
+    switch (node.type) {
+        case "text":
+            return stripAnsi(node.value);
+        case "emphasis":
+        case "strong":
+            return renderChildren(node.children, ctx);
+        case "strikethrough":
+            return "";
+        case "inlineCode":
+            return stripAnsi(node.value);
+        case "break":
+            return " ";
+        case "html":
+            return "";
+        case "link": {
+            const childText = renderChildren(node.children, ctx) || node.url;
+            if (ctx.expandLinks) {
+                return `${childText} ${stripAnsi(node.url)}`;
+            }
+            if (ctx.showLinks) {
+                return `${childText} (link)`;
+            }
+            return childText;
+        }
+        case "image":
+            return stripAnsi(node.alt);
+        case "footnoteReference": {
+            if (!ctx.footnoteOrder.includes(node.label)) {
+                ctx.footnoteOrder.push(node.label);
+            }
+            const index = ctx.footnoteOrder.indexOf(node.label) + 1;
+            return `[${index}]`;
+        }
+        default:
+            return "";
+    }
+}
+function renderChildren(nodes, ctx) {
+    return nodes.map((node) => renderInline(node, ctx)).join("");
+}
+function renderBlock(node, ctx) {
+    switch (node.type) {
+        case "root": {
+            collectFootnoteDefinitions(node.children, ctx);
+            const text = trimBlockSeparators(renderBlockChildren(node.children, ctx));
+            const footnotes = renderReferencedFootnotes(ctx);
+            return footnotes.length === 0 ? text : trimBlockSeparators(`${text}\n\n${footnotes}`);
+        }
+        case "paragraph":
+            return `${renderChildren(node.children, ctx)}\n\n`;
+        case "thematicBreak":
+            return "";
+        case "heading": {
+            const prefix = ctx.announceHeadings && node.depth === 1
+                ? "Section: "
+                : ctx.announceHeadings && node.depth === 2
+                    ? "Subsection: "
+                    : ctx.announceHeadings
+                        ? "Topic: "
+                        : "";
+            return `${prefix}${renderChildren(node.children, ctx).trim()}\n\n`;
+        }
+        case "blockquote":
+            return `Quote: ${renderBlockChildren(node.children, ctx).trim()}\n\n`;
+        case "alert": {
+            const prefix = ctx.announceAlerts ? `${node.kind}: ` : "";
+            return `${prefix}${renderBlockChildren(node.children, ctx).trim()}\n\n`;
+        }
+        case "list": {
+            const items = node.children
+                .filter((child) => child.type === "listItem")
+                .map((child, index) => {
+                const text = renderBlock(child, ctx).trim();
+                return node.ordered ? `${getOrderedListPrefix(index)}${text}` : text;
+            });
+            return `${items.join(node.ordered ? " " : getUnorderedListSeparator(items.length))}\n\n`;
+        }
+        case "listItem": {
+            const text = renderBlockChildren(node.children, ctx).trim();
+            if (node.checked === true) {
+                return `done: ${text}`;
+            }
+            if (node.checked === false) {
+                return `to do: ${text}`;
+            }
+            return text;
+        }
+        case "table": {
+            const [headerRow, ...bodyRows] = node.children.filter((child) => child.type === "tableRow");
+            if (!headerRow) {
+                return "\n\n";
+            }
+            const headers = headerRow.children.map((cell) => cell.type === "tableCell" ? renderChildren(cell.children, ctx).trim() : "");
+            const sentences = bodyRows.flatMap((row) => row.children.flatMap((cell, index) => {
+                if (cell.type !== "tableCell") {
+                    return [];
+                }
+                const header = headers[index]?.trim() ?? "";
+                const value = renderChildren(cell.children, ctx).trim();
+                return value === "" ? [] : `${header} is ${value}.`;
+            }));
+            return `${sentences.join(" ")}\n\n`;
+        }
+        case "tableRow":
+        case "tableCell":
+            return "";
+        case "code": {
+            const prefix = ctx.announceCode ? "Code: " : "";
+            const value = node.value.length === 0 && ctx.announceCode ? "Code:" : `${prefix}${node.value}`;
+            return `${value}\n\n`;
+        }
+        case "frontmatter": {
+            if (!ctx.includeFrontmatter) {
+                return "";
+            }
+            return `${Object.entries(node.data)
+                .map(([key, value]) => `${key}: ${String(value)}.`)
+                .join(" ")}\n\n`;
+        }
+        case "footnoteDefinition":
+            return "";
+        default:
+            return "";
+    }
+}
+function renderBlockChildren(nodes, ctx) {
+    return nodes
+        .map((node) => (isBlockNode(node) ? renderBlock(node, ctx) : renderInline(node, ctx)))
+        .join("");
+}
+function isBlockNode(node) {
+    switch (node.type) {
+        case "root":
+        case "paragraph":
+        case "thematicBreak":
+        case "heading":
+        case "blockquote":
+        case "alert":
+        case "list":
+        case "listItem":
+        case "table":
+        case "tableRow":
+        case "tableCell":
+        case "code":
+        case "frontmatter":
+        case "footnoteDefinition":
+            return true;
+        default:
+            return false;
+    }
+}
+function collectFootnoteDefinitions(nodes, ctx) {
+    for (const node of nodes) {
+        if (node.type === "footnoteDefinition") {
+            ctx.footnoteDefinitions.set(node.label, renderBlockChildren(node.children, createFootnoteDefinitionContext(ctx)).trim());
+            continue;
+        }
+        if ("children" in node) {
+            collectFootnoteDefinitions(node.children, ctx);
+        }
+    }
+}
+function createFootnoteDefinitionContext(ctx) {
+    return {
+        announceHeadings: ctx.announceHeadings,
+        announceCode: ctx.announceCode,
+        announceAlerts: ctx.announceAlerts,
+        showLinks: ctx.showLinks,
+        expandLinks: ctx.expandLinks,
+        includeFrontmatter: ctx.includeFrontmatter,
+        footnoteDefinitions: new Map(),
+        footnoteOrder: []
+    };
+}
+function renderReferencedFootnotes(ctx) {
+    return ctx.footnoteOrder
+        .map((label, index) => {
+        const definitionText = ctx.footnoteDefinitions.get(label);
+        return definitionText === undefined ? "" : `Note ${index + 1}: ${definitionText}.`;
+    })
+        .filter((value) => value.length > 0)
+        .join(" ");
+}
+function getOrderedListPrefix(index) {
+    switch (index) {
+        case 0:
+            return "First, ";
+        case 1:
+            return "Second, ";
+        case 2:
+            return "Third, ";
+        default:
+            return "Next, ";
+    }
+}
+function getUnorderedListSeparator(itemCount) {
+    return itemCount <= 3 ? ", " : "; ";
+}
+function trimBlockSeparators(value) {
+    let start = 0;
+    let end = value.length;
+    while (start < end && value[start] === "\n") {
+        start += 1;
+    }
+    while (end > start && value[end - 1] === "\n") {
+        end -= 1;
+    }
+    return value.slice(start, end);
+}
+export function renderPlaintext(ast, options) {
+    return renderBlock(ast, {
+        announceHeadings: options?.announceHeadings ?? true,
+        announceCode: options?.announceCode ?? true,
+        announceAlerts: options?.announceAlerts ?? true,
+        showLinks: options?.showLinks ?? false,
+        expandLinks: options?.expandLinks ?? false,
+        includeFrontmatter: options?.includeFrontmatter ?? false,
+        footnoteDefinitions: new Map(),
+        footnoteOrder: []
+    });
+}
+export function renderMarkdownPlaintext(markdown, options) {
+    const { ast } = parse(markdown);
+    return renderPlaintext(ast, options);
+}

package/node_modules/toolcraft-design/package.json

@@ -29,6 +29,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./render-markdown-plaintext": {
+      "types": "./dist/render-markdown-plaintext.d.ts",
+      "import": "./dist/render-markdown-plaintext.js"
+    },
     "./*": {
       "types": "./dist/*.d.ts",
       "import": "./dist/*.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft",
-  "version": "0.0.84",
+  "version": "0.0.86",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,6 +17,10 @@
       "types": "./dist/design.d.ts",
       "import": "./dist/design.js"
     },
+    "./design/render-markdown-plaintext": {
+      "types": "./dist/design/render-markdown-plaintext.d.ts",
+      "import": "./dist/design/render-markdown-plaintext.js"
+    },
     "./design/*": {
       "types": "./dist/design/*.d.ts",
       "import": "./dist/design/*.js"
@@ -51,7 +55,7 @@
     "postpack": "node ../../scripts/manage-bundled-workspace-deps.mjs cleanup . toolcraft-design @poe-code/frontmatter @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner tiny-mcp-client mcp-oauth auth-store"
   },
   "dependencies": {
-    "toolcraft-schema": "0.0.84",
+    "toolcraft-schema": "0.0.86",
     "commander": "^13.1.0",
     "fast-string-width": "^3.0.2",
     "fast-wrap-ansi": "^0.2.0",