@vascend/talos 0.1.0

package/dist/tui/logo.js

@@ -0,0 +1,305 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const DEFAULT_LOGO = {
+    columns: 28,
+    rows: 14,
+    samples: 4,
+    ansi: true,
+};
+const cachedLogos = new Map();
+export function renderVascendTerminalLogo(options = {}) {
+    const cfg = { ...DEFAULT_LOGO, ...options };
+    const key = `${cfg.columns}:${cfg.rows}:${cfg.samples}:${cfg.ansi ? 1 : 0}`;
+    const cached = cachedLogos.get(key);
+    if (cached)
+        return cached;
+    const rendered = renderBlockLogo(readVascendTerminalSvg(), cfg);
+    cachedLogos.set(key, rendered);
+    return rendered;
+}
+export function renderBlockLogo(svg, options = {}) {
+    const paths = extractPaths(svg);
+    const transform = extractTransform(svg);
+    const polygons = paths.flatMap((path) => parsePath(path, transform));
+    const box = extractViewBox(svg) ?? bounds(polygons);
+    if (!box)
+        return [];
+    return renderPolygons(polygons, box, {
+        columns: options.columns ?? 28,
+        rows: options.rows ?? 14,
+        samples: options.samples ?? 4,
+        ansi: options.ansi ?? false,
+    });
+}
+function readVascendTerminalSvg() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        join(here, "..", "..", "..", "vascend-terminal", "assets", "logo.svg"),
+        join(process.cwd(), "..", "vascend-terminal", "assets", "logo.svg"),
+        join(process.cwd(), "vascend-terminal", "assets", "logo.svg"),
+    ];
+    const path = candidates.find((candidate) => existsSync(candidate));
+    if (!path)
+        return "";
+    return readFileSync(path, "utf8");
+}
+function extractPaths(svg) {
+    return [...svg.matchAll(/<path\b[^>]*\bd="([^"]+)"/g)]
+        .map((match) => match[1]?.replace(/\s+/g, " ").trim() ?? "")
+        .filter(Boolean);
+}
+// I gruppi possono essere ANNIDATI (il logo Vascend Terminal ha un <g> esterno
+// translate+scale e uno interno con scale(0.1,-0.1)): considerare solo il primo
+// lasciava i poligoni fuori dal viewBox e il logo usciva VUOTO. Le trasformazioni
+// affini translate+scale si compongono in ordine di documento:
+// p' = t1 + s1 * (t2 + s2 * p) = (t1 + s1*t2) + (s1*s2) * p.
+function extractTransform(svg) {
+    const groups = [...svg.matchAll(/<g\b[^>]*\btransform="([^"]+)"/g)].map((match) => match[1] ?? "");
+    return groups.reduce((outer, raw) => {
+        const translate = /translate\(([-+0-9.eE]+)[,\s]+([-+0-9.eE]+)\)/.exec(raw);
+        const scale = /scale\(([-+0-9.eE]+)(?:[,\s]+([-+0-9.eE]+))?\)/.exec(raw);
+        const inner = {
+            tx: Number(translate?.[1] ?? 0),
+            ty: Number(translate?.[2] ?? 0),
+            sx: Number(scale?.[1] ?? 1),
+            sy: Number(scale?.[2] ?? scale?.[1] ?? 1),
+        };
+        return {
+            tx: outer.tx + outer.sx * inner.tx,
+            ty: outer.ty + outer.sy * inner.ty,
+            sx: outer.sx * inner.sx,
+            sy: outer.sy * inner.sy,
+        };
+    }, { tx: 0, ty: 0, sx: 1, sy: 1 });
+}
+function extractViewBox(svg) {
+    const match = /\bviewBox="([-+0-9.eE]+)\s+([-+0-9.eE]+)\s+([-+0-9.eE]+)\s+([-+0-9.eE]+)"/.exec(svg);
+    if (!match)
+        return null;
+    const minX = Number(match[1]);
+    const minY = Number(match[2]);
+    const width = Number(match[3]);
+    const height = Number(match[4]);
+    if (![minX, minY, width, height].every(Number.isFinite) || width <= 0 || height <= 0)
+        return null;
+    return { minX, minY, maxX: minX + width, maxY: minY + height };
+}
+function parsePath(path, transform) {
+    const tokens = path.match(/[a-zA-Z]|[-+]?(?:\d*\.\d+|\d+)(?:e[-+]?\d+)?/g) ?? [];
+    const polygons = [];
+    let polygon = [];
+    let index = 0;
+    let command = "";
+    let current = { x: 0, y: 0 };
+    let start = current;
+    const add = (point) => {
+        polygon.push(applyTransform(point, transform));
+    };
+    const close = () => {
+        if (polygon.length > 0)
+            polygons.push(polygon);
+        polygon = [];
+    };
+    const nextNumber = () => {
+        const token = tokens[index];
+        if (token === undefined || isCommand(token))
+            throw new Error(`path SVG non valido vicino a ${index}`);
+        index += 1;
+        return Number(token);
+    };
+    while (index < tokens.length) {
+        const token = tokens[index];
+        if (token === undefined)
+            break;
+        if (isCommand(token)) {
+            command = token;
+            index += 1;
+        }
+        switch (command) {
+            case "M":
+            case "m": {
+                const relative = command === "m";
+                current = point(nextNumber(), nextNumber(), relative ? current : undefined);
+                start = current;
+                add(current);
+                command = relative ? "l" : "L";
+                break;
+            }
+            case "L":
+            case "l": {
+                const relative = command === "l";
+                while (hasNumber(tokens, index)) {
+                    current = point(nextNumber(), nextNumber(), relative ? current : undefined);
+                    add(current);
+                }
+                break;
+            }
+            case "C":
+            case "c": {
+                const relative = command === "c";
+                while (hasNumber(tokens, index)) {
+                    const p0 = current;
+                    const p1 = point(nextNumber(), nextNumber(), relative ? current : undefined);
+                    const p2 = point(nextNumber(), nextNumber(), relative ? current : undefined);
+                    const p3 = point(nextNumber(), nextNumber(), relative ? current : undefined);
+                    for (let step = 1; step <= 24; step += 1) {
+                        add(cubic(p0, p1, p2, p3, step / 24));
+                    }
+                    current = p3;
+                }
+                break;
+            }
+            case "Z":
+            case "z":
+                current = start;
+                close();
+                break;
+            default:
+                throw new Error(`comando SVG non supportato: ${command}`);
+        }
+    }
+    close();
+    return polygons;
+}
+function isCommand(token) {
+    return /^[a-zA-Z]$/.test(token);
+}
+function hasNumber(tokens, index) {
+    const token = tokens[index];
+    return token !== undefined && !isCommand(token);
+}
+function point(x, y, relativeTo) {
+    return relativeTo ? { x: relativeTo.x + x, y: relativeTo.y + y } : { x, y };
+}
+function applyTransform(point, transform) {
+    return {
+        x: transform.tx + point.x * transform.sx,
+        y: transform.ty + point.y * transform.sy,
+    };
+}
+function cubic(p0, p1, p2, p3, t) {
+    const mt = 1 - t;
+    return {
+        x: mt ** 3 * p0.x + 3 * mt ** 2 * t * p1.x + 3 * mt * t ** 2 * p2.x + t ** 3 * p3.x,
+        y: mt ** 3 * p0.y + 3 * mt ** 2 * t * p1.y + 3 * mt * t ** 2 * p2.y + t ** 3 * p3.y,
+    };
+}
+function bounds(polygons) {
+    const first = polygons[0]?.[0];
+    if (!first)
+        return null;
+    return polygons.reduce((box, polygon) => {
+        return polygon.reduce((acc, p) => ({
+            minX: Math.min(acc.minX, p.x),
+            minY: Math.min(acc.minY, p.y),
+            maxX: Math.max(acc.maxX, p.x),
+            maxY: Math.max(acc.maxY, p.y),
+        }), box);
+    }, { minX: first.x, minY: first.y, maxX: first.x, maxY: first.y });
+}
+function renderPolygons(polygons, box, options) {
+    const minX = box.minX;
+    const maxX = box.maxX;
+    const minY = box.minY;
+    const maxY = box.maxY;
+    const lines = [];
+    for (let row = 0; row < options.rows; row += 1) {
+        const cells = [];
+        let lastActive = -1;
+        for (let col = 0; col < options.columns; col += 1) {
+            const x0 = minX + (col / options.columns) * (maxX - minX);
+            const x1 = minX + ((col + 1) / options.columns) * (maxX - minX);
+            const y0 = minY + (row / options.rows) * (maxY - minY);
+            const yMid = minY + ((row + 0.5) / options.rows) * (maxY - minY);
+            const y1 = minY + ((row + 1) / options.rows) * (maxY - minY);
+            const top = coverage(polygons, x0, x1, y0, yMid, options.samples);
+            const bottom = coverage(polygons, x0, x1, yMid, y1, options.samples);
+            const cell = block(top, bottom, options.ansi);
+            cells.push(cell.text);
+            if (cell.active)
+                lastActive = col;
+        }
+        lines.push(cells.slice(0, lastActive + 1).join(""));
+    }
+    return trimEmpty(lines);
+}
+function coverage(polygons, x0, x1, y0, y1, samples) {
+    let hits = 0;
+    const total = samples * samples;
+    for (let y = 0; y < samples; y += 1) {
+        for (let x = 0; x < samples; x += 1) {
+            const px = x0 + ((x + 0.5) / samples) * (x1 - x0);
+            const py = y0 + ((y + 0.5) / samples) * (y1 - y0);
+            if (insideAny(polygons, px, py))
+                hits += 1;
+        }
+    }
+    return hits / total;
+}
+function block(topCoverage, bottomCoverage, ansi) {
+    const top = shade(topCoverage);
+    const bottom = shade(bottomCoverage);
+    if (top === 0 && bottom === 0)
+        return { text: " ", active: false };
+    if (!ansi)
+        return { text: plainBlock(top, bottom), active: true };
+    if (top > 0 && bottom > 0) {
+        return {
+            text: `\x1b[38;2;${top};${top};${top};48;2;${bottom};${bottom};${bottom}m▀\x1b[0m`,
+            active: true,
+        };
+    }
+    if (top > 0)
+        return { text: `${fg(top)}▀\x1b[0m`, active: true };
+    return { text: `${fg(bottom)}▄\x1b[0m`, active: true };
+}
+function plainBlock(top, bottom) {
+    if (top > 0 && bottom > 0)
+        return "█";
+    if (top > 0)
+        return "▀";
+    return "▄";
+}
+function shade(coverageValue) {
+    if (coverageValue < 0.18)
+        return 0;
+    if (coverageValue < 0.35)
+        return 96;
+    if (coverageValue < 0.58)
+        return 160;
+    if (coverageValue < 0.82)
+        return 220;
+    return 255;
+}
+function fg(value) {
+    return `\x1b[38;2;${value};${value};${value}m`;
+}
+function insideAny(polygons, x, y) {
+    return polygons.some((polygon) => insidePolygon(polygon, x, y));
+}
+function insidePolygon(polygon, x, y) {
+    let inside = false;
+    let previousIndex = polygon.length - 1;
+    for (let currentIndex = 0; currentIndex < polygon.length; currentIndex += 1) {
+        const current = polygon[currentIndex];
+        const previous = polygon[previousIndex];
+        if (current && previous) {
+            const crosses = current.y > y !== previous.y > y;
+            const atX = ((previous.x - current.x) * (y - current.y)) / (previous.y - current.y) + current.x;
+            if (crosses && x < atX)
+                inside = !inside;
+        }
+        previousIndex = currentIndex;
+    }
+    return inside;
+}
+function trimEmpty(lines) {
+    let start = 0;
+    let end = lines.length;
+    while (start < end && !lines[start]?.trim())
+        start += 1;
+    while (end > start && !lines[end - 1]?.trim())
+        end -= 1;
+    return lines.slice(start, end);
+}

package/dist/tui/markdown-inline.d.ts

@@ -0,0 +1,3 @@
+import type { TuiTheme } from "./branding.js";
+export declare function inlineText(text: string): string;
+export declare function wrapInline(text: string, width: number, theme: TuiTheme, hangingIndent?: number, textStyle?: (s: string) => string): readonly string[];

package/dist/tui/markdown-inline.js

@@ -0,0 +1,99 @@
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { plainText, terminalWidth } from "./terminal-text.js";
+const token = /\\([\\`*_{}\[\]()#+\-.!|>~])|(`+)([\s\S]*?)\2|\*\*(.+?)\*\*|__(.+?)__|\[([^\]]+)\]\((<[^>]+>|(?:[^\s()]|\([^()]*\))+)\)|\*([^*]+)\*|_([^_]+)_|~~(.+?)~~/g;
+function linkTarget(value) {
+    const target = value.replace(/^<|>$/g, "");
+    if (/^(https?:|mailto:)/i.test(target))
+        return target;
+    if (/^[a-z][a-z0-9+.-]*:/i.test(target) && !/^[a-z]:[\\/]/i.test(target))
+        return undefined;
+    return pathToFileURL(resolve(target)).href;
+}
+function spans(text, style = {}) {
+    const out = [];
+    let offset = 0;
+    // Each recursive call owns its regex cursor.
+    for (const match of text.matchAll(new RegExp(token))) {
+        if (match.index > offset)
+            out.push({ ...style, text: text.slice(offset, match.index) });
+        if (match[1])
+            out.push({ ...style, text: match[1] });
+        else if (match[2])
+            out.push({ ...style, text: match[3], code: true });
+        else if (match[4] || match[5])
+            out.push(...spans(match[4] ?? match[5], { ...style, bold: true }));
+        else if (match[6])
+            out.push(...spans(match[6], { ...style, href: linkTarget(match[7]) }));
+        else if (match[8] || match[9])
+            out.push(...spans(match[8] ?? match[9], { ...style, italic: true }));
+        else
+            out.push(...spans(match[10], { ...style, strike: true }));
+        offset = match.index + match[0].length;
+    }
+    if (offset < text.length)
+        out.push({ ...style, text: text.slice(offset) });
+    return out;
+}
+function paint(span, text, theme, textStyle) {
+    let out = span.href ? (theme.markdownLink ?? theme.accent)(text)
+        : span.code ? (theme.markdownCode ?? theme.accent)(text) : textStyle(text);
+    if (span.bold)
+        out = theme.bold(out);
+    if (span.italic)
+        out = `\x1b[3m${out}\x1b[23m`;
+    if (span.strike)
+        out = `\x1b[9m${out}\x1b[29m`;
+    if (span.href)
+        out = `\x1b]8;;${span.href}\x1b\\${out}\x1b]8;;\x1b\\`;
+    return out;
+}
+export function inlineText(text) { return spans(plainText(text)).map(span => span.text).join(""); }
+// Wrap rendered text, not Markdown delimiters. Every line closes its styles
+// and links, including when a long bold phrase or a link spans several rows.
+export function wrapInline(text, width, theme, hangingIndent = 0, textStyle = theme.silver) {
+    const parts = spans(plainText(text));
+    const content = parts.map(span => span.text).join("");
+    if (!content)
+        return [""];
+    const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+    const out = [];
+    let start = 0;
+    while (start < content.length) {
+        const indent = out.length ? Math.min(hangingIndent, Math.max(0, width - 2)) : 0;
+        const available = Math.max(2, width - indent);
+        let end = start;
+        let cells = 0;
+        let space = -1;
+        for (const { segment } of graphemes.segment(content.slice(start))) {
+            const size = terminalWidth(segment);
+            if (cells + size > available)
+                break;
+            if (/\s/.test(segment))
+                space = end;
+            cells += size;
+            end += segment.length;
+        }
+        if (end < content.length && space > start)
+            end = space;
+        if (end === start)
+            end = start + 1;
+        const limit = start + content.slice(start, end).trimEnd().length;
+        let cursor = 0;
+        let row = " ".repeat(indent);
+        for (const part of parts) {
+            const a = Math.max(0, start - cursor);
+            const b = Math.min(part.text.length, limit - cursor);
+            if (b > a)
+                row += paint(part, part.text.slice(a, b), theme, textStyle);
+            cursor += part.text.length;
+            if (cursor >= limit)
+                break;
+        }
+        out.push(row);
+        start = end;
+        while (content[start] === " ")
+            start++;
+    }
+    return out;
+}

package/dist/tui/markdown-table.d.ts

@@ -0,0 +1,4 @@
+import type { TuiTheme } from "./branding.js";
+export declare function tableCells(line: string): string[];
+export declare function isTableSeparator(line: string): boolean;
+export declare function renderTable(header: readonly string[], separator: readonly string[], rows: readonly string[][], width: number, theme: TuiTheme): readonly string[];

package/dist/tui/markdown-table.js

@@ -0,0 +1,63 @@
+import { inlineText, wrapInline } from "./markdown-inline.js";
+import { terminalWidth } from "./terminal-text.js";
+export function tableCells(line) {
+    const source = line.trim().replace(/^\|/, "").replace(/(?<!\\)\|$/, "");
+    const cells = [];
+    let cell = "";
+    let codeFence = "";
+    for (let i = 0; i < source.length; i++) {
+        const ch = source[i];
+        if (ch === "\\" && i + 1 < source.length) {
+            cell += ch + source[++i];
+            continue;
+        }
+        if (ch === "`") {
+            const run = /^`+/.exec(source.slice(i))[0];
+            codeFence = codeFence === run ? "" : codeFence || run;
+            cell += run;
+            i += run.length - 1;
+            continue;
+        }
+        if (ch === "|" && !codeFence) {
+            cells.push(cell.trim());
+            cell = "";
+        }
+        else
+            cell += ch;
+    }
+    cells.push(cell.trim());
+    return cells;
+}
+export function isTableSeparator(line) {
+    return line.includes("|") && tableCells(line).every(cell => /^:?-{3,}:?$/.test(cell));
+}
+export function renderTable(header, separator, rows, width, theme) {
+    const count = header.length;
+    const gap = 3;
+    if (width < count * 6 + (count - 1) * gap) {
+        return rows.flatMap((row, index) => [
+            ...(index ? [""] : []),
+            ...header.flatMap((label, col) => wrapInline(`**${label}**: ${row[col] ?? ""}`, width, theme)),
+        ]);
+    }
+    const widths = header.map((label, col) => Math.max(3, terminalWidth(inlineText(label)), ...rows.map(row => terminalWidth(inlineText(row[col] ?? "")))));
+    const budget = width - (count - 1) * gap;
+    while (widths.reduce((sum, size) => sum + size, 0) > budget) {
+        const largest = widths.indexOf(Math.max(...widths));
+        widths[largest]--;
+    }
+    const rule = widths.map(size => theme.dark("─".repeat(size))).join(" ".repeat(gap));
+    const renderRow = (row, heading = false) => {
+        const cells = widths.map((size, col) => wrapInline(row[col] ?? "", size, theme, 0, heading ? s => theme.bold((theme.markdownHeading ?? theme.silver)(s)) : theme.silver));
+        return Array.from({ length: Math.max(1, ...cells.map(cell => cell.length)) }, (_, line) => widths.map((size, col) => {
+            const value = cells[col][line] ?? "";
+            const padding = Math.max(0, size - terminalWidth(value));
+            const align = separator[col] ?? "";
+            const left = !heading && align.endsWith(":") ? (align.startsWith(":") ? Math.floor(padding / 2) : padding) : 0;
+            return " ".repeat(left) + value + " ".repeat(padding - left);
+        }).join(" ".repeat(gap)));
+    };
+    return [...renderRow(header, true), rule, ...rows.flatMap((row, index) => [
+            ...(index ? [rule] : []), ...renderRow(row),
+        ])];
+}

package/dist/tui/markdown.d.ts

@@ -0,0 +1,11 @@
+import type { TuiTheme } from "./branding.js";
+export interface MarkdownRenderOptions {
+    readonly width: number;
+    readonly theme: TuiTheme;
+    readonly imageCtx?: {
+        readonly cwd: string;
+        readonly env: NodeJS.ProcessEnv;
+    };
+}
+export declare function renderMarkdown(text: string, opts: MarkdownRenderOptions): readonly string[];
+export declare function wrapPlain(text: string, width: number): readonly string[];