@kamilio/wire 0.1.0

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/terminal-markdown/demo-content.js

@@ -0,0 +1,139 @@
+export function getMarkdownDemo(name = "default") {
+    switch (name) {
+        case "minimal":
+            return [
+                "# Markdown Minimal",
+                "",
+                "Quick validation paragraph.",
+                "",
+                "```ts",
+                'console.log("demo");',
+                "```"
+            ].join("\n");
+        case "code-blocks":
+            return [
+                "# Code Blocks",
+                "",
+                "```ts",
+                'const sample = "**still literal**";',
+                "",
+                "function increment(value: number): number {",
+                "  return value + 1;",
+                "}",
+                "",
+                'console.log("``` also literal inside code");',
+                "```"
+            ].join("\n");
+        case "blockquotes":
+            return [
+                "# Blockquotes",
+                "",
+                "> Outer quote",
+                "> with a second line for spacing.",
+                ">",
+                "> > Nested quote",
+                "> > keeps its own bar prefix.",
+                "> >",
+                "> > > Deep quote",
+                "> > > stays indented."
+            ].join("\n");
+        case "lists":
+            return [
+                "# Lists",
+                "",
+                "- unordered item",
+                "  - nested item",
+                "  - another nested item",
+                "- another unordered item",
+                "",
+                "1. ordered item",
+                "2. ordered item",
+                "   1. nested ordered item",
+                "   2. another nested ordered item",
+                "",
+                "- [x] completed task",
+                "- [ ] pending task",
+                "  - [x] nested done task",
+                "  - [ ] nested pending task"
+            ].join("\n");
+        case "tables":
+            return [
+                "# Tables",
+                "",
+                "| Column | Left | Center | Right |",
+                "| :----- | :--- | :----: | ----: |",
+                "| Alignment | alpha | beta | 42 |",
+                "| Separators | left | mid | 9000 |",
+                "| Header | visible | x | 7 |"
+            ].join("\n");
+        case "alerts":
+            return [
+                "# Alerts",
+                "",
+                "> [!NOTE]",
+                "> Note labels use info styling.",
+                ">",
+                "> Wrapped content stays aligned beneath the bar.",
+                "",
+                "> [!TIP]",
+                "> Tip labels use success styling.",
+                ">",
+                "> Multi-line content keeps its indentation.",
+                "",
+                "> [!IMPORTANT]",
+                "> Important labels reuse the info color.",
+                ">",
+                "> The follow-up line stays under the same prefix.",
+                "",
+                "> [!WARNING]",
+                "> Warning labels use warning styling.",
+                ">",
+                "> Additional detail remains aligned.",
+                "",
+                "> [!CAUTION]",
+                "> Caution labels use error styling.",
+                ">",
+                "> The final alert confirms the red variant."
+            ].join("\n");
+        case "default":
+            return [
+                "# Design System Markdown",
+                "",
+                "## Overview",
+                "",
+                "### Renderer Features",
+                "",
+                "Paragraph with **bold**, *italic*, ~~strikethrough~~, `code span`, a [docs link](https://example.com/docs), an image ![System diagram](https://example.com/system.png), and a footnote reference[^demo].",
+                "",
+                "```ts",
+                'const agent = "poe-code";',
+                "console.log(agent);",
+                "```",
+                "",
+                "> Outer quote",
+                ">",
+                "> > Nested quote",
+                "",
+                "- unordered item",
+                "- another unordered item",
+                "",
+                "1. ordered item",
+                "2. another ordered item",
+                "",
+                "- [x] completed task",
+                "- [ ] pending task",
+                "",
+                "| Feature | Alignment | Status |",
+                "| :------ | :-------: | -----: |",
+                "| Headings | center | Ready |",
+                "| Tables | aligned | 100% |",
+                "",
+                "> [!NOTE]",
+                "> Alerts are rendered as styled notes.",
+                "",
+                "---",
+                "",
+                "[^demo]: Footnote definition for the markdown demo."
+            ].join("\n");
+    }
+}

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

@@ -0,0 +1,7 @@
+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/node_modules/toolcraft-design/dist/terminal-markdown/html-renderer.js

@@ -0,0 +1,366 @@
+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);
+}
+function renderNode(node, context) {
+    switch (node.type) {
+        case "root":
+            return renderRoot(node, context);
+        case "heading":
+            return renderHeading(node, context);
+        case "paragraph":
+            return renderParagraph(node, context);
+        case "blockquote":
+            return renderBlockquote(node, context);
+        case "alert":
+            return renderAlert(node, context);
+        case "code":
+            return renderCodeBlock(node, context);
+        case "list":
+            return renderList(node, context);
+        case "table":
+            return renderTable(node, context);
+        case "html":
+            return context.allowRawHtml ? node.value : escapeHtml(node.value);
+        case "thematicBreak":
+            return "<hr>";
+        case "frontmatter":
+            return context.showFrontmatter ? renderFrontmatter(node.data) : "";
+        case "footnoteDefinition":
+            return "";
+        case "text":
+        case "strong":
+        case "emphasis":
+        case "strikethrough":
+        case "inlineCode":
+        case "link":
+        case "image":
+        case "break":
+        case "footnoteReference":
+            return renderInline(node, context);
+        default:
+            return "children" in node ? renderChildren(node.children, context) : "";
+    }
+}
+function renderRoot(node, context) {
+    const blocks = node.children
+        .filter((child) => child.type !== "footnoteDefinition")
+        .map((child) => renderNode(child, context))
+        .filter((value) => value.length > 0);
+    const footnotes = renderReferencedFootnotes(context);
+    if (footnotes.length > 0) {
+        blocks.push(footnotes);
+    }
+    return blocks.join("\n");
+}
+function renderChildren(children, context) {
+    return children
+        .map((child) => renderNode(child, context))
+        .filter((value) => value.length > 0)
+        .join("\n");
+}
+function renderHeading(node, context) {
+    const content = renderInlineChildren(node.children, context);
+    return content.length === 0 ? "" : `<h${node.depth}>${content}</h${node.depth}>`;
+}
+function renderParagraph(node, context) {
+    const content = renderInlineChildren(node.children, context);
+    return content.length === 0 ? "" : `<p>${content}</p>`;
+}
+function renderBlockquote(node, context) {
+    const content = renderChildren(node.children, context);
+    return `<blockquote>${content}</blockquote>`;
+}
+function renderAlert(node, context) {
+    const content = renderChildren(node.children, context);
+    return `<blockquote data-alert="${escapeAttribute(node.kind)}">${content}</blockquote>`;
+}
+function renderCodeBlock(node, context) {
+    const classAttribute = node.lang === undefined || node.lang.length === 0
+        ? ""
+        : ` class="language-${escapeAttribute(node.lang)}"`;
+    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";
+    const startAttribute = node.ordered && node.start !== undefined && node.start !== 1
+        ? ` start="${escapeAttribute(String(node.start))}"`
+        : "";
+    const items = node.children
+        .map((child) => (child.type === "listItem" ? renderListItem(child, context) : renderNode(child, context)))
+        .filter((value) => value.length > 0)
+        .join("");
+    return items.length === 0 ? "" : `<${tag}${startAttribute}>${items}</${tag}>`;
+}
+function renderListItem(node, context) {
+    const renderedChildren = node.children
+        .map((child, index) => {
+        if (index === 0 && child.type === "paragraph") {
+            return renderInlineChildren(child.children, context);
+        }
+        return renderNode(child, context);
+    })
+        .filter((value) => value.length > 0);
+    const checkbox = renderTaskCheckbox(node);
+    return `<li>${checkbox}${renderedChildren.join("")}</li>`;
+}
+function renderTaskCheckbox(node) {
+    if (node.checked === true) {
+        return '<input type="checkbox" disabled checked> ';
+    }
+    if (node.checked === false) {
+        return '<input type="checkbox" disabled> ';
+    }
+    return "";
+}
+function renderTable(node, context) {
+    const rows = node.children.filter((child) => child.type === "tableRow");
+    const headerRow = rows[0];
+    if (headerRow === undefined) {
+        return "";
+    }
+    const header = `<thead>${renderTableRow(headerRow, node.align, "th", context)}</thead>`;
+    const bodyRows = rows
+        .slice(1)
+        .map((row) => renderTableRow(row, node.align, "td", context))
+        .join("");
+    const body = `<tbody>${bodyRows}</tbody>`;
+    return ["<table>", header, body, "</table>"].join("\n");
+}
+function renderTableRow(node, alignments, cellTag, context) {
+    const cells = node.children
+        .map((cell, index) => {
+        if (cell.type !== "tableCell") {
+            return "";
+        }
+        const style = renderTableAlignment(alignments[index] ?? null);
+        return `<${cellTag}${style}>${renderInlineChildren(cell.children, context)}</${cellTag}>`;
+    })
+        .join("");
+    return `<tr>${cells}</tr>`;
+}
+function renderTableAlignment(alignment) {
+    if (alignment === null) {
+        return "";
+    }
+    return ` style="text-align: ${alignment}"`;
+}
+function renderFrontmatter(data) {
+    const lines = Object.entries(data).map(([key, value]) => `${key}: ${formatFrontmatterValue(value)}`);
+    if (lines.length === 0) {
+        return "";
+    }
+    return `<pre><code class="language-yaml">${escapeHtml(lines.join("\n"))}</code></pre>`;
+}
+function formatFrontmatterValue(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    const ancestors = [];
+    return JSON.stringify(value, function (_key, nestedValue) {
+        if (typeof nestedValue !== "object" || nestedValue === null) {
+            return nestedValue;
+        }
+        while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) {
+            ancestors.pop();
+        }
+        if (ancestors.includes(nestedValue)) {
+            return "[Circular]";
+        }
+        ancestors.push(nestedValue);
+        return nestedValue;
+    });
+}
+function renderInlineChildren(children, context) {
+    return children.map((child) => renderInline(child, context)).join("");
+}
+function renderInline(node, context) {
+    switch (node.type) {
+        case "text":
+            return escapeHtml(node.value);
+        case "strong":
+            return `<strong>${renderInlineChildren(node.children, context)}</strong>`;
+        case "emphasis":
+            return `<em>${renderInlineChildren(node.children, context)}</em>`;
+        case "strikethrough":
+            return `<del>${renderInlineChildren(node.children, context)}</del>`;
+        case "inlineCode":
+            return `<code>${escapeHtml(node.value)}</code>`;
+        case "link":
+            return renderLink(node, context);
+        case "image":
+            return renderImage(node);
+        case "break":
+            return "<br>";
+        case "footnoteReference":
+            return renderFootnoteReference(node, context);
+        case "html":
+            return context.allowRawHtml ? node.value : escapeHtml(node.value);
+        default:
+            return "children" in node ? renderInlineChildren(node.children, context) : renderNode(node, context);
+    }
+}
+function renderLink(node, context) {
+    const href = sanitizeUrl(node.url);
+    const attributes = [
+        href === null ? "" : ` href="${escapeAttribute(href)}"`,
+        node.title === undefined ? "" : ` title="${escapeAttribute(node.title)}"`
+    ].join("");
+    return `<a${attributes}>${renderInlineChildren(node.children, context)}</a>`;
+}
+function renderImage(node) {
+    const src = sanitizeUrl(node.url);
+    const attributes = [
+        src === null ? "" : ` src="${escapeAttribute(src)}"`,
+        ` alt="${escapeAttribute(node.alt)}"`,
+        node.title === undefined ? "" : ` title="${escapeAttribute(node.title)}"`
+    ].join("");
+    return `<img${attributes}>`;
+}
+function renderFootnoteReference(node, context) {
+    const footnotes = context.footnotes;
+    if (footnotes === undefined || !footnotes.definitions.has(node.label)) {
+        return "";
+    }
+    let number = footnotes.numbers.get(node.label);
+    if (number === undefined) {
+        footnotes.labelsInOrder.push(node.label);
+        number = footnotes.labelsInOrder.length;
+        footnotes.numbers.set(node.label, number);
+    }
+    const id = escapeAttribute(createFootnoteId(node.label));
+    return `<sup id="fnref-${id}"><a href="#fn-${id}">${number}</a></sup>`;
+}
+function renderReferencedFootnotes(context) {
+    const footnotes = context.footnotes;
+    if (footnotes === undefined || footnotes.labelsInOrder.length === 0) {
+        return "";
+    }
+    const items = footnotes.labelsInOrder
+        .map((label) => {
+        const definition = footnotes.definitions.get(label);
+        if (definition === undefined) {
+            return "";
+        }
+        const id = escapeAttribute(createFootnoteId(label));
+        const content = renderChildren(definition.children, context);
+        return `<li id="fn-${id}">${content} <a href="#fnref-${id}" aria-label="Back to content">Back</a></li>`;
+    })
+        .filter((value) => value.length > 0)
+        .join("");
+    return items.length === 0 ? "" : `<section class="footnotes"><ol>${items}</ol></section>`;
+}
+function createFootnoteState(children) {
+    const definitions = new Map();
+    for (const child of children) {
+        collectFootnoteDefinitions(child, definitions);
+    }
+    return {
+        definitions,
+        labelsInOrder: [],
+        numbers: new Map()
+    };
+}
+function collectFootnoteDefinitions(node, definitions) {
+    if (node.type === "footnoteDefinition") {
+        definitions.set(node.label, node);
+        return;
+    }
+    if ("children" in node) {
+        for (const child of node.children) {
+            collectFootnoteDefinitions(child, definitions);
+        }
+    }
+}
+function createFootnoteId(label) {
+    return encodeURIComponent(label);
+}
+function sanitizeUrl(url) {
+    const trimmed = url.trim();
+    if (trimmed.startsWith("//")) {
+        return null;
+    }
+    const scheme = readScheme(trimmed);
+    if (scheme === null) {
+        return trimmed;
+    }
+    switch (scheme.toLowerCase()) {
+        case "http":
+        case "https":
+        case "mailto":
+        case "tel":
+            return trimmed;
+        default:
+            return null;
+    }
+}
+function readScheme(url) {
+    let value = "";
+    for (let index = 0; index < url.length; index += 1) {
+        const char = url[index];
+        if (char === "/" || char === "?" || char === "#") {
+            return null;
+        }
+        if (char === ":") {
+            return value.length === 0 ? null : value;
+        }
+        if (!isSchemeChar(char, index)) {
+            return null;
+        }
+        value += char;
+    }
+    return null;
+}
+function isSchemeChar(char, index) {
+    const code = char.charCodeAt(0);
+    const isAlpha = (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
+    if (index === 0) {
+        return isAlpha;
+    }
+    return isAlpha || (code >= 48 && code <= 57) || char === "+" || char === "-" || char === ".";
+}
+function escapeHtml(value) {
+    let output = "";
+    for (const char of value) {
+        switch (char) {
+            case "&":
+                output += "&amp;";
+                break;
+            case "<":
+                output += "&lt;";
+                break;
+            case ">":
+                output += "&gt;";
+                break;
+            case '"':
+                output += "&quot;";
+                break;
+            default:
+                output += char;
+        }
+    }
+    return output;
+}
+function escapeAttribute(value) {
+    return escapeHtml(value);
+}

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

@@ -0,0 +1,10 @@
+import { type HtmlRenderOptions } from "./html-renderer.js";
+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 { parse } from "./parser.js";
+export { render } from "./renderer.js";
+export type { RenderOptions } from "./renderer.js";
+export declare function renderMarkdown(markdown: string, options?: RenderOptions): string;
+export declare function renderMarkdownHtml(markdown: string, options?: HtmlRenderOptions): string;

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

@@ -0,0 +1,14 @@
+import { parse } from "./parser.js";
+import { renderHtml } from "./html-renderer.js";
+import { render } from "./renderer.js";
+export { renderHtml } from "./html-renderer.js";
+export { parse } from "./parser.js";
+export { render } from "./renderer.js";
+export function renderMarkdown(markdown, options) {
+    const { ast } = parse(markdown);
+    return render(ast, options);
+}
+export function renderMarkdownHtml(markdown, options) {
+    const { ast } = parse(markdown);
+    return renderHtml(ast, options);
+}

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

@@ -0,0 +1,7 @@
+import type { MdNode, MdRange } from "../ast.js";
+export declare function parseBlocks(input: string): MdNode[];
+export declare function parseBlockDocument(input: string): {
+    frontmatter?: Record<string, unknown>;
+    frontmatterRange?: MdRange;
+    children: MdNode[];
+};