toolcraft 0.0.78 → 0.0.79

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

@@ -45,7 +45,7 @@ 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 { MdNode, RenderOptions, HtmlRenderOptions } from "./terminal-markdown/index.js";
+export type { CodeToken, CodeTokenKind, HtmlRenderOptions, MdNode, 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/terminal-markdown/ast.d.ts

@@ -2,6 +2,11 @@ export type MdRange = {
     start: number;
     end: number;
 };
+export type CodeTokenKind = "anchor" | "at-rule" | "attribute" | "boolean" | "color" | "command" | "comment" | "decorator" | "directive" | "flag" | "function" | "identifier" | "important" | "invalid" | "key" | "keyword" | "label" | "null" | "number" | "operator" | "parameter" | "plain" | "property" | "punctuation" | "regex" | "selector" | "string" | "tag" | "template" | "type" | "variable";
+export type CodeToken = {
+    kind: CodeTokenKind;
+    value: string;
+};
 type MdNodeWithRange = {
     range?: MdRange;
 };
@@ -23,6 +28,7 @@ export type MdNode = MdNodeWithRange & ({
     lang?: string;
     meta?: string;
     value: string;
+    tokens?: CodeToken[];
 } | {
     type: "list";
     ordered: boolean;

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

@@ -2,5 +2,6 @@ import type { MdNode } from "./ast.js";
 export interface HtmlRenderOptions {
     showFrontmatter?: boolean;
     allowRawHtml?: boolean;
+    syntaxHighlight?: boolean;
 }
 export declare function renderHtml(ast: MdNode, options?: HtmlRenderOptions): string;

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

@@ -1,7 +1,9 @@
+import { highlightCodeBlock } from "./parser/code-highlight.js";
 export function renderHtml(ast, options = {}) {
     const context = {
         showFrontmatter: options.showFrontmatter ?? false,
         allowRawHtml: options.allowRawHtml ?? false,
+        syntaxHighlight: options.syntaxHighlight ?? false,
         footnotes: ast.type === "root" ? createFootnoteState(ast.children) : undefined
     };
     return renderNode(ast, context);
@@ -19,7 +21,7 @@ function renderNode(node, context) {
         case "alert":
             return renderAlert(node, context);
         case "code":
-            return renderCodeBlock(node);
+            return renderCodeBlock(node, context);
         case "list":
             return renderList(node, context);
         case "table":
@@ -79,11 +81,19 @@ function renderAlert(node, context) {
     const content = renderChildren(node.children, context);
     return `<blockquote data-alert="${escapeAttribute(node.kind)}">${content}</blockquote>`;
 }
-function renderCodeBlock(node) {
+function renderCodeBlock(node, context) {
     const classAttribute = node.lang === undefined || node.lang.length === 0
         ? ""
         : ` class="language-${escapeAttribute(node.lang)}"`;
-    return `<pre><code${classAttribute}>${escapeHtml(node.value)}</code></pre>`;
+    const tokens = context.syntaxHighlight ? highlightCodeBlock(node) : undefined;
+    const content = tokens === undefined
+        ? escapeHtml(node.value)
+        : tokens
+            .map((token) => token.kind === "plain"
+            ? escapeHtml(token.value)
+            : `<span class="tc-token-${escapeAttribute(token.kind)}">${escapeHtml(token.value)}</span>`)
+            .join("");
+    return `<pre><code${classAttribute}>${content}</code></pre>`;
 }
 function renderList(node, context) {
     const tag = node.ordered ? "ol" : "ul";

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

@@ -1,6 +1,6 @@
 import { type HtmlRenderOptions } from "./html-renderer.js";
 import { type RenderOptions } from "./renderer.js";
-export type { MdNode } from "./ast.js";
+export type { CodeToken, CodeTokenKind, MdNode } from "./ast.js";
 export { renderHtml } from "./html-renderer.js";
 export type { HtmlRenderOptions } from "./html-renderer.js";
 export { parse } from "./parser.js";

package/node_modules/toolcraft-design/dist/terminal-markdown/parser/code-highlight.d.ts

@@ -0,0 +1,4 @@
+import type { CodeToken, MdNode } from "../ast.js";
+export declare function highlightCodeBlock(node: Pick<Extract<MdNode, {
+    type: "code";
+}>, "lang" | "value" | "tokens">): CodeToken[] | undefined;

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

@@ -0,0 +1,618 @@
+const codeLanguages = [
+    {
+        id: "javascript",
+        aliases: ["js", "javascript", "mjs", "cjs", "es6"],
+        family: "lexical",
+        spec: "javascript"
+    },
+    { id: "javascriptreact", aliases: ["jsx"], family: "lexical", spec: "javascript" },
+    {
+        id: "typescript",
+        aliases: ["ts", "typescript", "mts", "cts"],
+        family: "lexical",
+        spec: "typescript"
+    },
+    { id: "typescriptreact", aliases: ["tsx"], family: "lexical", spec: "typescript" },
+    { id: "json", aliases: ["json"], family: "data", spec: "json" },
+    { id: "jsonc", aliases: ["jsonc"], family: "data", spec: "jsonc" },
+    { id: "jsonl", aliases: ["jsonl"], family: "data", spec: "json" },
+    { id: "yaml", aliases: ["yaml", "yml"], family: "data", spec: "yaml" },
+    { id: "css", aliases: ["css"], family: "style", spec: "css" },
+    { id: "scss", aliases: ["scss"] },
+    { id: "sass", aliases: ["sass"] },
+    { id: "less", aliases: ["less"] },
+    { id: "postcss", aliases: ["postcss"] },
+    { id: "shellscript", aliases: ["sh", "bash", "shell", "shellscript", "zsh", "fish"] },
+    { id: "python", aliases: ["py", "python"] },
+    { id: "sql", aliases: ["sql", "ddl", "dml"] },
+    { id: "html", aliases: ["html"] },
+    { id: "xml", aliases: ["xml", "svg"] },
+    { id: "markdown", aliases: ["md", "markdown"] },
+    { id: "diff", aliases: ["diff", "patch"] },
+    { id: "dockerfile", aliases: ["dockerfile", "docker"] },
+    { id: "ini", aliases: ["ini", "properties"] },
+    { id: "toml", aliases: ["toml"] },
+    { id: "plaintext", aliases: ["text", "txt", "plain", "plaintext"], plain: true },
+    { id: "ruby", aliases: ["rb", "ruby"] },
+    { id: "go", aliases: ["go", "golang"] },
+    { id: "java", aliases: ["java"] },
+    { id: "c", aliases: ["c"] },
+    { id: "cpp", aliases: ["cpp", "c++", "cc", "cxx"] },
+    { id: "csharp", aliases: ["cs", "csharp", "c#"] },
+    { id: "rust", aliases: ["rs", "rust"] },
+    { id: "php", aliases: ["php"] }
+];
+const languageByAlias = new Map();
+for (const language of codeLanguages) {
+    languageByAlias.set(language.id.toLowerCase(), language);
+    for (const alias of language.aliases) {
+        languageByAlias.set(alias.toLowerCase(), language);
+    }
+}
+const jsKeywords = new Set([
+    "as",
+    "async",
+    "await",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "export",
+    "extends",
+    "finally",
+    "for",
+    "from",
+    "function",
+    "get",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "let",
+    "new",
+    "of",
+    "return",
+    "set",
+    "static",
+    "super",
+    "switch",
+    "throw",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield"
+]);
+const tsKeywords = new Set([
+    ...jsKeywords,
+    "abstract",
+    "declare",
+    "enum",
+    "implements",
+    "interface",
+    "keyof",
+    "namespace",
+    "private",
+    "protected",
+    "public",
+    "readonly",
+    "satisfies",
+    "type"
+]);
+const tsTypes = new Set([
+    "any",
+    "bigint",
+    "boolean",
+    "never",
+    "number",
+    "object",
+    "string",
+    "symbol",
+    "unknown",
+    "void"
+]);
+const jsConstants = new Set(["true", "false", "null", "undefined", "NaN", "Infinity"]);
+const lexicalSpecs = {
+    javascript: {
+        keywords: jsKeywords,
+        constants: jsConstants,
+        lineComments: ["//"],
+        blockComments: true,
+        stringQuotes: ['"', "'"],
+        templateQuotes: true,
+        decorators: true
+    },
+    typescript: {
+        keywords: tsKeywords,
+        types: tsTypes,
+        constants: jsConstants,
+        lineComments: ["//"],
+        blockComments: true,
+        stringQuotes: ['"', "'"],
+        templateQuotes: true,
+        decorators: true
+    }
+};
+const tokenizers = {
+    lexical: tokenizeLexical,
+    data: tokenizeData,
+    style: tokenizeStyle,
+    line: tokenizeLine
+};
+export function highlightCodeBlock(node) {
+    if (node.tokens !== undefined) {
+        return node.tokens;
+    }
+    const language = resolveCodeLanguage(node.lang);
+    if (language === undefined ||
+        language.plain === true ||
+        language.family === undefined ||
+        node.value.length === 0) {
+        return undefined;
+    }
+    const tokenize = tokenizers[language.family];
+    const tokens = tokenize(node.value, language);
+    return tokens.some((token) => token.kind !== "plain") ? tokens : undefined;
+}
+function resolveCodeLanguage(lang) {
+    if (lang === undefined || lang.length === 0) {
+        return undefined;
+    }
+    return languageByAlias.get(lang.toLowerCase());
+}
+function tokenizeLexical(source, language) {
+    const spec = lexicalSpecs[language.spec ?? ""];
+    if (spec === undefined) {
+        return [{ kind: "plain", value: source }];
+    }
+    const emitter = createEmitter(source);
+    let index = 0;
+    while (index < source.length) {
+        const start = index;
+        const char = source[index];
+        index = readWhitespace(source, index);
+        if (index > start) {
+            emitter.pushPlain(start, index);
+            continue;
+        }
+        const lineCommentEnd = readAnyLineComment(source, index, spec.lineComments ?? []);
+        if (lineCommentEnd > index) {
+            emitter.push("comment", index, lineCommentEnd);
+            index = lineCommentEnd;
+            continue;
+        }
+        const blockCommentEnd = spec.blockComments === true ? readBlockComment(source, index) : index;
+        if (blockCommentEnd > index) {
+            emitter.push("comment", index, blockCommentEnd);
+            index = blockCommentEnd;
+            continue;
+        }
+        if (spec.decorators === true && char === "@" && isIdentifierStart(source[index + 1] ?? "")) {
+            index = readIdentifier(source, index + 1);
+            emitter.push("decorator", start, index);
+            continue;
+        }
+        if ((spec.stringQuotes ?? []).includes(char)) {
+            index = readQuotedString(source, index, char);
+            emitter.push("string", start, index);
+            continue;
+        }
+        if (spec.templateQuotes === true && char === "`") {
+            index = readQuotedString(source, index, "`");
+            emitter.push("template", start, index);
+            continue;
+        }
+        index = readNumber(source, index);
+        if (index > start) {
+            emitter.push("number", start, index);
+            continue;
+        }
+        index = readIdentifier(source, index);
+        if (index > start) {
+            emitter.push(classifyLexicalWord(source.slice(start, index), spec), start, index);
+            continue;
+        }
+        emitter.pushPlain(start, start + 1);
+        index = start + 1;
+    }
+    return emitter.tokens;
+}
+function tokenizeData(source, language) {
+    return language.spec === "yaml" ? tokenizeYaml(source) : tokenizeJsonLike(source, language.spec === "jsonc");
+}
+function tokenizeJsonLike(source, allowComments) {
+    const emitter = createEmitter(source);
+    let index = 0;
+    while (index < source.length) {
+        const start = index;
+        index = readWhitespace(source, index);
+        if (index > start) {
+            emitter.pushPlain(start, index);
+            continue;
+        }
+        if (allowComments) {
+            const lineCommentEnd = readAnyLineComment(source, index, ["//"]);
+            if (lineCommentEnd > index) {
+                emitter.push("comment", index, lineCommentEnd);
+                index = lineCommentEnd;
+                continue;
+            }
+            const blockCommentEnd = readBlockComment(source, index);
+            if (blockCommentEnd > index) {
+                emitter.push("comment", index, blockCommentEnd);
+                index = blockCommentEnd;
+                continue;
+            }
+        }
+        if (source[index] === '"') {
+            index = readQuotedString(source, index, '"');
+            emitter.push(isJsonKey(source, index) ? "key" : "string", start, index);
+            continue;
+        }
+        index = readNumber(source, index);
+        if (index > start) {
+            emitter.push("number", start, index);
+            continue;
+        }
+        index = readIdentifier(source, index);
+        if (index > start) {
+            emitter.push(classifyDataWord(source.slice(start, index)), start, index);
+            continue;
+        }
+        emitter.pushPlain(start, start + 1);
+        index = start + 1;
+    }
+    return emitter.tokens;
+}
+function tokenizeYaml(source) {
+    const emitter = createEmitter(source);
+    let index = 0;
+    let atLineStart = true;
+    while (index < source.length) {
+        const start = index;
+        if (source[index] === "\n") {
+            emitter.pushPlain(index, index + 1);
+            index += 1;
+            atLineStart = true;
+            continue;
+        }
+        const whitespaceEnd = readSpacesAndTabs(source, index);
+        if (whitespaceEnd > index) {
+            emitter.pushPlain(index, whitespaceEnd);
+            index = whitespaceEnd;
+            continue;
+        }
+        if (source[index] === "#") {
+            index = readUntilLineEnd(source, index);
+            emitter.push("comment", start, index);
+            atLineStart = false;
+            continue;
+        }
+        if (source[index] === '"' || source[index] === "'") {
+            const quote = source[index];
+            index = readQuotedString(source, index, quote);
+            emitter.push("string", start, index);
+            atLineStart = false;
+            continue;
+        }
+        if (atLineStart) {
+            const keyEnd = readYamlKey(source, index);
+            if (keyEnd > index) {
+                emitter.push("key", index, keyEnd);
+                index = keyEnd;
+                atLineStart = false;
+                continue;
+            }
+        }
+        index = readNumber(source, index);
+        if (index > start) {
+            emitter.push("number", start, index);
+            atLineStart = false;
+            continue;
+        }
+        index = readIdentifier(source, index);
+        if (index > start) {
+            emitter.push(classifyDataWord(source.slice(start, index)), start, index);
+            atLineStart = false;
+            continue;
+        }
+        emitter.pushPlain(start, start + 1);
+        index = start + 1;
+        atLineStart = false;
+    }
+    return emitter.tokens;
+}
+function tokenizeStyle(source) {
+    const emitter = createEmitter(source);
+    let index = 0;
+    while (index < source.length) {
+        const start = index;
+        index = readWhitespace(source, index);
+        if (index > start) {
+            emitter.pushPlain(start, index);
+            continue;
+        }
+        const blockCommentEnd = readBlockComment(source, index);
+        if (blockCommentEnd > index) {
+            emitter.push("comment", index, blockCommentEnd);
+            index = blockCommentEnd;
+            continue;
+        }
+        if (source[index] === "@") {
+            index = readCssName(source, index + 1);
+            if (index > start + 1) {
+                emitter.push("at-rule", start, index);
+                continue;
+            }
+        }
+        if (source[index] === "#" && isHex(source[index + 1] ?? "")) {
+            index = readCssColor(source, index + 1);
+            emitter.push("color", start, index);
+            continue;
+        }
+        if (source.startsWith("!important", index)) {
+            index += "!important".length;
+            emitter.push("important", start, index);
+            continue;
+        }
+        if (source[index] === '"' || source[index] === "'") {
+            const quote = source[index];
+            index = readQuotedString(source, index, quote);
+            emitter.push("string", start, index);
+            continue;
+        }
+        index = readNumber(source, index);
+        if (index > start) {
+            emitter.push("number", start, index);
+            continue;
+        }
+        index = readCssName(source, index);
+        if (index > start) {
+            emitter.push(isCssProperty(source, index) ? "property" : "selector", start, index);
+            continue;
+        }
+        emitter.pushPlain(start, start + 1);
+        index = start + 1;
+    }
+    return emitter.tokens;
+}
+function tokenizeLine(source) {
+    return [{ kind: "plain", value: source }];
+}
+function createEmitter(source) {
+    const tokens = [];
+    return {
+        tokens,
+        push(kind, start, end) {
+            pushToken(tokens, source, kind, start, end);
+        },
+        pushPlain(start, end) {
+            pushToken(tokens, source, "plain", start, end);
+        }
+    };
+}
+function pushToken(tokens, source, kind, start, end) {
+    if (end <= start) {
+        return;
+    }
+    const value = source.slice(start, end);
+    const previous = tokens[tokens.length - 1];
+    if (previous?.kind === kind) {
+        previous.value += value;
+        return;
+    }
+    tokens.push({ kind, value });
+}
+function classifyLexicalWord(word, spec) {
+    if (word === "true" || word === "false") {
+        return "boolean";
+    }
+    if (word === "null") {
+        return "null";
+    }
+    if (spec.keywords?.has(word) === true) {
+        return "keyword";
+    }
+    if (spec.types?.has(word) === true) {
+        return "type";
+    }
+    if (spec.constants?.has(word) === true) {
+        return "number";
+    }
+    return "plain";
+}
+function classifyDataWord(word) {
+    switch (word) {
+        case "true":
+        case "false":
+            return "boolean";
+        case "null":
+        case "Null":
+        case "NULL":
+        case "~":
+            return "null";
+        default:
+            return "plain";
+    }
+}
+function readWhitespace(source, index) {
+    while (index < source.length && isWhitespace(source[index])) {
+        index += 1;
+    }
+    return index;
+}
+function readSpacesAndTabs(source, index) {
+    while (index < source.length && (source[index] === " " || source[index] === "\t")) {
+        index += 1;
+    }
+    return index;
+}
+function readIdentifier(source, index) {
+    if (!isIdentifierStart(source[index] ?? "")) {
+        return index;
+    }
+    index += 1;
+    while (index < source.length && isIdentifierPart(source[index])) {
+        index += 1;
+    }
+    return index;
+}
+function readCssName(source, index) {
+    if (!isCssNameStart(source[index] ?? "")) {
+        return index;
+    }
+    index += 1;
+    while (index < source.length && isCssNamePart(source[index])) {
+        index += 1;
+    }
+    return index;
+}
+function readNumber(source, index) {
+    const start = index;
+    if (source[index] === "-") {
+        index += 1;
+    }
+    let hasDigit = false;
+    while (index < source.length && isDigit(source[index])) {
+        index += 1;
+        hasDigit = true;
+    }
+    if (source[index] === "." && isDigit(source[index + 1] ?? "")) {
+        index += 1;
+        while (index < source.length && isDigit(source[index])) {
+            index += 1;
+            hasDigit = true;
+        }
+    }
+    if (!hasDigit) {
+        return start;
+    }
+    if ((source[index] === "e" || source[index] === "E") && isExponentStart(source[index + 1] ?? "")) {
+        const exponentStart = index;
+        index += 1;
+        if (source[index] === "+" || source[index] === "-") {
+            index += 1;
+        }
+        const digitsStart = index;
+        while (index < source.length && isDigit(source[index])) {
+            index += 1;
+        }
+        if (index === digitsStart) {
+            return exponentStart;
+        }
+    }
+    return index;
+}
+function readQuotedString(source, index, quote) {
+    index += 1;
+    while (index < source.length) {
+        const char = source[index];
+        index += 1;
+        if (char === "\\") {
+            index = Math.min(source.length, index + 1);
+            continue;
+        }
+        if (char === quote) {
+            return index;
+        }
+    }
+    return index;
+}
+function readAnyLineComment(source, index, markers) {
+    for (const marker of markers) {
+        if (source.startsWith(marker, index)) {
+            return readUntilLineEnd(source, index);
+        }
+    }
+    return index;
+}
+function readBlockComment(source, index) {
+    if (!source.startsWith("/*", index)) {
+        return index;
+    }
+    index += 2;
+    while (index < source.length) {
+        if (source.startsWith("*/", index)) {
+            return index + 2;
+        }
+        index += 1;
+    }
+    return source.length;
+}
+function readUntilLineEnd(source, index) {
+    while (index < source.length && source[index] !== "\n") {
+        index += 1;
+    }
+    return index;
+}
+function readYamlKey(source, index) {
+    const start = index;
+    while (index < source.length) {
+        const char = source[index];
+        if (char === ":") {
+            return index > start ? index : start;
+        }
+        if (char === "\n" || char === "#" || char === "{" || char === "}" || char === "[" || char === "]") {
+            return start;
+        }
+        index += 1;
+    }
+    return start;
+}
+function readCssColor(source, index) {
+    let count = 0;
+    while (index < source.length && isHex(source[index]) && count < 8) {
+        index += 1;
+        count += 1;
+    }
+    return index;
+}
+function isJsonKey(source, index) {
+    index = readWhitespace(source, index);
+    return source[index] === ":";
+}
+function isCssProperty(source, index) {
+    index = readWhitespace(source, index);
+    return source[index] === ":";
+}
+function isWhitespace(char) {
+    return char === " " || char === "\n" || char === "\r" || char === "\t";
+}
+function isIdentifierStart(char) {
+    return isAlpha(char) || char === "_" || char === "$";
+}
+function isIdentifierPart(char) {
+    return isIdentifierStart(char) || isDigit(char);
+}
+function isCssNameStart(char) {
+    return isAlpha(char) || char === "_" || char === "-" || char === ".";
+}
+function isCssNamePart(char) {
+    return isCssNameStart(char) || isDigit(char);
+}
+function isExponentStart(char) {
+    return isDigit(char) || char === "+" || char === "-";
+}
+function isAlpha(char) {
+    const code = char.charCodeAt(0);
+    return (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
+}
+function isDigit(char) {
+    const code = char.charCodeAt(0);
+    return code >= 48 && code <= 57;
+}
+function isHex(char) {
+    const code = char.charCodeAt(0);
+    return ((code >= 48 && code <= 57) ||
+        (code >= 65 && code <= 70) ||
+        (code >= 97 && code <= 102));
+}

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

@@ -2,5 +2,6 @@ import type { MdNode } from "./ast.js";
 export interface RenderOptions {
     width?: number;
     showFrontmatter?: boolean;
+    syntaxHighlight?: boolean;
 }
 export declare function render(ast: MdNode, options?: RenderOptions): string;

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

@@ -5,6 +5,7 @@ import { stripAnsi } from "../internal/strip-ansi.js";
 import { spacing } from "../tokens/spacing.js";
 import { typography } from "../tokens/typography.js";
 import { widths } from "../tokens/widths.js";
+import { highlightCodeBlock } from "./parser/code-highlight.js";
 const lineChar = "─";
 export function render(ast, options = {}) {
     const requestedWidth = options.width ?? process.stdout.columns ?? widths.maxLine;
@@ -15,6 +16,7 @@ export function render(ast, options = {}) {
     const context = {
         width,
         showFrontmatter: options.showFrontmatter ?? false,
+        syntaxHighlight: options.syntaxHighlight ?? false,
         theme: getTheme(),
         footnotes: ast.type === "root" ? createFootnoteState(ast.children) : undefined
     };
@@ -113,12 +115,72 @@ function renderAlert(node, context) {
 function renderCodeBlock(node, context) {
     const indent = " ".repeat(spacing.sm);
     const lines = node.value.split("\n").map((line) => stripAnsi(line));
+    const strippedSource = lines.join("\n");
     const longestLine = lines.reduce((max, line) => Math.max(max, visibleWidth(line)), 0);
     const borderWidth = Math.max(3, Math.min(context.width - indent.length, longestLine));
     const border = context.theme.muted(`${indent}${lineChar.repeat(borderWidth)}`);
-    const content = lines.map((line) => `${indent}${line}`).join("\n");
+    const highlightedLines = context.syntaxHighlight === true
+        ? renderCodeTokens(highlightCodeBlock({ lang: node.lang, value: strippedSource }), context)?.split("\n")
+        : undefined;
+    const content = (highlightedLines ?? lines).map((line) => `${indent}${line}`).join("\n");
     return `${border}\n${content}\n${border}\n\n`;
 }
+function renderCodeTokens(tokens, context) {
+    if (tokens === undefined) {
+        return undefined;
+    }
+    return tokens.map((token) => styleCodeToken(token, context)).join("");
+}
+function styleCodeToken(token, context) {
+    if (token.kind === "plain") {
+        return token.value;
+    }
+    return getCodeTokenFormatter(token.kind, context)(token.value);
+}
+function getCodeTokenFormatter(kind, context) {
+    switch (kind) {
+        case "keyword":
+        case "type":
+        case "tag":
+        case "command":
+        case "decorator":
+        case "directive":
+        case "at-rule":
+            return (value) => context.theme.accent(typography.bold(value));
+        case "string":
+        case "template":
+            return context.theme.success;
+        case "number":
+        case "boolean":
+        case "null":
+        case "parameter":
+            return context.theme.number;
+        case "comment":
+            return context.theme.muted;
+        case "property":
+        case "key":
+        case "attribute":
+        case "variable":
+        case "function":
+        case "anchor":
+        case "label":
+            return context.theme.info;
+        case "regex":
+        case "color":
+        case "important":
+        case "flag":
+            return context.theme.warning;
+        case "invalid":
+            return context.theme.error;
+        case "operator":
+        case "punctuation":
+        case "selector":
+            return context.theme.muted;
+        case "identifier":
+        case "plain":
+            return (value) => value;
+    }
+}
 function renderList(node, context) {
     const items = node.children
         .map((child, index) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft",
-  "version": "0.0.78",
+  "version": "0.0.79",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -51,7 +51,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.78",
+    "toolcraft-schema": "0.0.79",
     "commander": "^13.1.0",
     "fast-string-width": "^3.0.2",
     "fast-wrap-ansi": "^0.2.0",