@hncode/hncode 0.5.5 → 0.6.0

package/src/llm.js

@@ -256,7 +256,12 @@ function buildBody(cfg, messages, streaming = true, opts = {}) {
     const { system, messages: am } = toAnthropic(messages);
     const body = {
       model: cfg.innerModel, system, messages: am,
-      tools: opts.noTools ? undefined : anthropicToolDefs(opts.tools || llmToolsList),
+      // `tool_choice: none` is the protocol-level refusal. Omitting the tool definitions entirely, which
+      // is what `noTools` used to do, leaves the model free to EMIT the syntax from memory — a summariser
+      // that answers with `<|tool_call|>{…}` instead of a summary. Declaring the tools and forbidding their
+      // use is the only form both providers accept.
+      tools: opts.toolChoice === 'none' ? anthropicToolDefs(opts.tools || llmToolsList) : (opts.noTools ? undefined : anthropicToolDefs(opts.tools || llmToolsList)),
+      tool_choice: opts.toolChoice === 'none' ? { type: 'none' } : undefined,
       ...common, ...wire,
     };
     if (!body.tools || !body.tools.length) delete body.tools;
@@ -296,9 +301,19 @@ function buildBody(cfg, messages, streaming = true, opts = {}) {
     model: cfg.innerModel, messages: toOpenAi(messages),
     ...common, ...wire,
   };
-  // Only attach a NON-EMPTY tools array: `tools: []` is rejected by some strict
-  // gateways, and an instance that registered no list means "no tools here".
-  if (!opts.noTools && defs.length) body.tools = defs;
+  // `tool_choice: 'none'` NEEDS THE TOOLS DECLARED alongside it. OpenAI rejects the field without them, so
+  // the list is sent and the choice forbids use — the same shape as the Anthropic branch, and the only form
+  // that actually stops a model answering with a tool call instead of a summary.
+  if (opts.toolChoice === 'none') {
+    if (defs.length) {
+      body.tools = defs;
+      body.tool_choice = 'none';
+    }
+  } else if (!opts.noTools && defs.length) {
+    // Only attach a NON-EMPTY tools array: `tools: []` is rejected by some strict
+    // gateways, and an instance that registered no list means "no tools here".
+    body.tools = defs;
+  }
   return JSON.stringify(applyPromptCache('openai', body, {
     enabled: cfg.promptCache !== false,
     sessionKey: cfg.sessionId,

package/src/mermaid/ansi.js

@@ -0,0 +1,55 @@
+import { contrastOn, resolveClassStyle } from './class-style.js';
+const ESC = String.fromCharCode(27);
+const OSC8 = `${ESC}]8;;`;
+const ST = `${ESC}\\`;
+/** Dim frame, plain labels, cyan connectors. Readable on light and dark. */
+export const DEFAULT_THEME = {
+    border: '2',
+    edge: '36',
+    edgeLabel: '2;36',
+    title: '1',
+};
+const rgb = (hex, sgr) => `${sgr};2;${[1, 3, 5].map((i) => Number.parseInt(hex.slice(i, i + 2), 16)).join(';')}`;
+/**
+ * The truecolor SGR a class style gives a span of the given role, or
+ * undefined when the style says nothing about it (fall back to the theme).
+ * `stroke` colors borders, `color` text; `fill` backs every painted cell,
+ * with a black/white foreground picked for contrast when none was declared.
+ * A style that colors nothing for this role keeps `fallback` (the theme's
+ * SGR), so a bold-only class bolds the themed look instead of replacing it.
+ */
+export function classSgr(st, role, fallback) {
+    const p = [];
+    const fg = role === 'border' ? (st.stroke ?? st.color) : role === 'edge' ? undefined : st.color;
+    const backed = fg ?? (st.fill === undefined ? undefined : contrastOn(st.fill));
+    if (backed !== undefined)
+        p.push(rgb(backed, 38));
+    if (st.fill !== undefined)
+        p.push(rgb(st.fill, 48));
+    if (p.length === 0 && fallback !== undefined)
+        p.push(fallback);
+    if (st.bold === true)
+        p.unshift('1');
+    return p.length > 0 ? p.join(';') : undefined;
+}
+/**
+ * Render art to ANSI-coloured lines. Spans that carry author classes are
+ * styled from `art.classDefs` (best effort — see `resolveClassStyle`),
+ * overriding the role theme; everything else follows `theme`.
+ *
+ * A convenience over mapping `art.styled` yourself — reach for that directly
+ * when your TUI has its own styling model.
+ */
+export function toAnsi(art, theme = DEFAULT_THEME) {
+    return art.styled.map((row) => row
+        .map((span) => {
+        const cls = resolveClassStyle(span.classes, art.classDefs);
+        const sgr = cls !== null ? classSgr(cls, span.role, theme[span.role]) : theme[span.role];
+        const text = sgr === undefined ? span.text : `${ESC}[${sgr}m${span.text}${ESC}[0m`;
+        // OSC 8 hyperlink around the whole run; terminals without support
+        // ignore the sequences and print the text unchanged.
+        return span.href === undefined ? text : `${OSC8}${span.href}${ST}${text}${OSC8}${ST}`;
+    })
+        .join(''));
+}
+//# sourceMappingURL=ansi.js.map

package/src/mermaid/canvas.js

@@ -0,0 +1,449 @@
+import { measured } from './width.js';
+/**
+ * Sentinel occupying the trailing column of a wide glyph. Never emitted: the
+ * line builder skips it so a CJK character claims two cells of layout but
+ * contributes one character of output.
+ */
+export const CONT = String.fromCharCode(0);
+/** Connection direction bits, combined into a box-drawing glyph by `maskChar`. */
+export const U = 1;
+export const D = 2;
+export const L = 4;
+export const R = 8;
+/** Line styles, tracked per cell so crossing edges keep their own stroke. */
+export const STY_DOT = 1;
+export const STY_THICK = 2;
+export const STY_SOLID = 4;
+/**
+ * A grid of cells. Edges accumulate as direction bits rather than glyphs so
+ * that crossings and junctions resolve correctly whatever order they are drawn
+ * in; `finalizeMask` turns the accumulated bits into characters at the end.
+ *
+ * `occupied` marks cells claimed by a box, which edge bits must not overwrite.
+ */
+export class Canvas {
+    w;
+    h;
+    ch;
+    role;
+    /** Space-joined author classes per cell, or undefined; see `Span.classes`. */
+    tag;
+    /** Link target per cell, or undefined; see `Span.href`. */
+    href;
+    mask;
+    style;
+    occupied;
+    curStyle = STY_SOLID;
+    /** Author classes stamped on cells painted while set, like `curStyle`. */
+    curTag;
+    /** Link target stamped on cells painted while set, like `curTag`. */
+    curHref;
+    constructor(w, h) {
+        const n = w * h;
+        this.w = w;
+        this.h = h;
+        this.ch = new Array(n).fill(' ');
+        this.role = new Array(n).fill('none');
+        this.tag = new Array(n).fill(undefined);
+        this.href = new Array(n).fill(undefined);
+        this.mask = new Uint8Array(n);
+        this.style = new Uint8Array(n);
+        this.occupied = new Uint8Array(n);
+    }
+    idx(x, y) {
+        return y * this.w + x;
+    }
+    set(x, y, c, role) {
+        if (x >= this.w || y >= this.h)
+            return;
+        const i = this.idx(x, y);
+        // A literal tab measures one cell here but jumps to the terminal's tab
+        // stop there, desyncing every column after it (the source box expands
+        // tabs for the same reason). Same width, safe glyph.
+        this.ch[i] = c === '\t' ? ' ' : c;
+        this.role[i] = role;
+        if (this.curTag !== undefined)
+            this.tag[i] = this.curTag;
+        if (this.curHref !== undefined)
+            this.href[i] = this.curHref;
+    }
+    /**
+     * Accumulate direction bits on a free cell.
+     *
+     * `role` is the role to claim the cell for; `border` cells are never
+     * reclassified, so a connector meeting a box keeps the box's styling.
+     */
+    addBits(x, y, bits, role = 'edge') {
+        if (x >= this.w || y >= this.h)
+            return;
+        const i = this.idx(x, y);
+        if (this.occupied[i])
+            return;
+        this.mask[i] |= bits;
+        this.style[i] |= this.curStyle;
+        if (this.role[i] !== 'border')
+            this.role[i] = role;
+        if (this.curTag !== undefined)
+            this.tag[i] = this.curTag;
+        if (this.curHref !== undefined)
+            this.href[i] = this.curHref;
+    }
+    /** Stamp a finished sub-canvas (a subgraph frame's contents) at an offset. */
+    blit(sub, ox, oy) {
+        for (let sy = 0; sy < sub.h; sy++) {
+            for (let sx = 0; sx < sub.w; sx++) {
+                const x = ox + sx;
+                const y = oy + sy;
+                if (x >= this.w || y >= this.h)
+                    continue;
+                const si = sub.idx(sx, sy);
+                const di = this.idx(x, y);
+                this.ch[di] = sub.ch[si];
+                this.role[di] = sub.role[si];
+                this.tag[di] = sub.tag[si];
+                this.href[di] = sub.href[si];
+                this.style[di] = sub.style[si];
+                this.occupied[di] = 1;
+            }
+        }
+    }
+    /** Add direction bits even to an occupied cell, so an edge can meet a border. */
+    junction(x, y, bits) {
+        if (x >= this.w || y >= this.h)
+            return;
+        const i = this.idx(x, y);
+        this.mask[i] |= bits;
+        if (this.role[i] !== 'border')
+            this.role[i] = 'edge';
+    }
+    segV(x, y0, y1) {
+        const a = Math.min(y0, y1);
+        const b = Math.max(y0, y1);
+        for (let y = a; y <= b; y++) {
+            let bits = 0;
+            if (y > a)
+                bits |= U;
+            if (y < b)
+                bits |= D;
+            this.addBits(x, y, bits);
+        }
+    }
+    segH(y, x0, x1) {
+        const a = Math.min(x0, x1);
+        const b = Math.max(x0, x1);
+        for (let x = a; x <= b; x++) {
+            let bits = 0;
+            if (x > a)
+                bits |= L;
+            if (x < b)
+                bits |= R;
+            this.addBits(x, y, bits);
+        }
+    }
+    /** Resolve accumulated direction bits into glyphs, honouring line style. */
+    finalizeMask() {
+        for (let i = 0; i < this.ch.length; i++) {
+            if (this.mask[i] === 0)
+                continue;
+            if (this.ch[i] === ' ') {
+                const c = maskChar(this.mask[i]);
+                this.ch[i] =
+                    this.style[i] === STY_DOT ? dottedChar(c) : this.style[i] === STY_THICK ? thickChar(c) : c;
+            }
+            else if (this.ch[i] === '═' || this.ch[i] === '║') {
+                this.ch[i] = doubleTee(this.ch[i], this.mask[i]);
+            }
+        }
+    }
+    /**
+     * Mirror top-to-bottom for `BT`. Rows reorder but within-row text does not,
+     * so labels stay readable; box-drawing glyphs flip to match.
+     */
+    flipVertical() {
+        for (let y = 0; y < Math.floor(this.h / 2); y++) {
+            const y2 = this.h - 1 - y;
+            for (let x = 0; x < this.w; x++) {
+                const i = this.idx(x, y);
+                const j = this.idx(x, y2);
+                [this.ch[i], this.ch[j]] = [this.ch[j], this.ch[i]];
+                [this.role[i], this.role[j]] = [this.role[j], this.role[i]];
+                [this.tag[i], this.tag[j]] = [this.tag[j], this.tag[i]];
+                [this.href[i], this.href[j]] = [this.href[j], this.href[i]];
+            }
+        }
+        for (let i = 0; i < this.ch.length; i++) {
+            if (!textRole(this.role[i]))
+                this.ch[i] = flipGlyphV(this.ch[i]);
+        }
+    }
+    /**
+     * Mirror left-to-right for `RL`. Mirroring reverses each row, so after
+     * flipping glyphs each text/label run is reversed back to reading order.
+     */
+    flipHorizontal() {
+        for (let y = 0; y < this.h; y++) {
+            for (let x = 0; x < Math.floor(this.w / 2); x++) {
+                const x2 = this.w - 1 - x;
+                const i = this.idx(x, y);
+                const j = this.idx(x2, y);
+                [this.ch[i], this.ch[j]] = [this.ch[j], this.ch[i]];
+                [this.role[i], this.role[j]] = [this.role[j], this.role[i]];
+                [this.tag[i], this.tag[j]] = [this.tag[j], this.tag[i]];
+                [this.href[i], this.href[j]] = [this.href[j], this.href[i]];
+            }
+        }
+        for (let i = 0; i < this.ch.length; i++) {
+            if (!textRole(this.role[i]))
+                this.ch[i] = flipGlyphH(this.ch[i]);
+        }
+        for (let y = 0; y < this.h; y++) {
+            let x = 0;
+            while (x < this.w) {
+                const role = this.role[this.idx(x, y)];
+                if (role === 'text' || role === 'edgeLabel') {
+                    const start = this.idx(x, y);
+                    while (x < this.w && this.role[this.idx(x, y)] === role)
+                        x++;
+                    const end = this.idx(x, y);
+                    reverseSlice(this.ch, start, end);
+                }
+                else {
+                    x++;
+                }
+            }
+        }
+    }
+    /** Group each row into runs of one role and tag, dropping continuations. */
+    toLines() {
+        const plain = [];
+        const styled = [];
+        let width = 0;
+        for (let y = 0; y < this.h; y++) {
+            // A trailing CONT counts as painted: it is the second cell of a wide
+            // glyph, so the row really does reach that column.
+            let last = 0;
+            for (let x = this.w - 1; x >= 0; x--) {
+                if (this.ch[this.idx(x, y)] !== ' ') {
+                    last = x + 1;
+                    break;
+                }
+            }
+            width = Math.max(width, last);
+            const spans = [];
+            const push = (text, role, tag, href) => {
+                if (text === '')
+                    return;
+                const span = { text, role };
+                if (tag !== undefined)
+                    span.classes = tag.split(' ');
+                if (href !== undefined)
+                    span.href = href;
+                spans.push(span);
+            };
+            let plainRow = '';
+            let run = '';
+            let runRole = 'none';
+            let runTag;
+            let runHref;
+            for (let x = 0; x < last; x++) {
+                const i = this.idx(x, y);
+                const c = this.ch[i];
+                if (c === CONT)
+                    continue;
+                plainRow += c;
+                if ((this.role[i] !== runRole || this.tag[i] !== runTag || this.href[i] !== runHref) &&
+                    run !== '') {
+                    push(run, runRole, runTag, runHref);
+                    run = '';
+                }
+                runRole = this.role[i];
+                runTag = this.tag[i];
+                runHref = this.href[i];
+                run += c;
+            }
+            push(run, runRole, runTag, runHref);
+            styled.push(spans);
+            // Only ASCII spaces, which is all a blank cell ever holds. Trimming `\s`
+            // would eat a trailing NBSP that `styled` keeps, desyncing the two.
+            plain.push(plainRow.replace(/ +$/, ''));
+        }
+        let first = 0;
+        while (first < plain.length && plain[first] === '')
+            first++;
+        let end = plain.length;
+        while (end > first && plain[end - 1] === '')
+            end--;
+        return { plain: plain.slice(first, end), styled: styled.slice(first, end), width };
+    }
+}
+function reverseSlice(arr, start, end) {
+    for (let i = start, j = end - 1; i < j; i++, j--) {
+        ;
+        [arr[i], arr[j]] = [arr[j], arr[i]];
+    }
+}
+/**
+ * Paint `text` at `x, y`, one grapheme cluster per cell.
+ *
+ * A wide cluster claims a second cell, marked with `CONT` so the line builder
+ * emits one character for it rather than a stray space.
+ */
+export function drawText(canvas, text, x, y, role) {
+    let cur = x;
+    for (const [cluster, cw] of measured(text)) {
+        if (cw === 0)
+            continue;
+        canvas.set(cur, y, cluster, role);
+        for (let k = 1; k < cw; k++)
+            canvas.set(cur + k, y, CONT, role);
+        cur += cw;
+    }
+}
+/**
+ * Paint `text` at `x, y`, clearing any edge bits underneath first.
+ *
+ * Used where text sits on top of a drawn line (sequence messages, dividers,
+ * compartment rows) and must win over it.
+ */
+export function drawTextOverEdges(canvas, text, x, y, role) {
+    let cur = x;
+    for (const [cluster, cw] of measured(text)) {
+        if (cw === 0)
+            continue;
+        for (let k = 0; k < cw; k++) {
+            if (cur + k < canvas.w && y < canvas.h)
+                canvas.mask[canvas.idx(cur + k, y)] = 0;
+            canvas.set(cur + k, y, k === 0 ? cluster : CONT, role);
+        }
+        cur += cw;
+    }
+}
+export function maskChar(mask) {
+    switch (mask) {
+        case 0:
+            return ' ';
+        case U:
+        case D:
+        case U | D:
+            return '│';
+        case L:
+        case R:
+        case L | R:
+            return '─';
+        case D | R:
+            return '┌';
+        case D | L:
+            return '┐';
+        case U | R:
+            return '└';
+        case U | L:
+            return '┘';
+        case U | D | R:
+            return '├';
+        case U | D | L:
+            return '┤';
+        case D | L | R:
+            return '┬';
+        case U | L | R:
+            return '┴';
+        default:
+            return '┼';
+    }
+}
+/** An edge teeing into a double-line border: the mixed single/double glyphs. */
+function doubleTee(c, mask) {
+    if (c === '═') {
+        if (mask & U && mask & D)
+            return '╪';
+        if (mask & D)
+            return '╤';
+        if (mask & U)
+            return '╧';
+    }
+    else {
+        if (mask & L && mask & R)
+            return '╫';
+        if (mask & R)
+            return '╟';
+        if (mask & L)
+            return '╢';
+    }
+    return c;
+}
+const DOTTED = { '─': '╌', '│': '╎' };
+const THICK = {
+    '─': '━',
+    '│': '┃',
+    '┌': '┏',
+    '┐': '┓',
+    '└': '┗',
+    '┘': '┛',
+    '├': '┣',
+    '┤': '┫',
+    '┬': '┳',
+    '┴': '┻',
+    '┼': '╋',
+};
+const FLIP_V = {
+    '╔': '╚',
+    '╚': '╔',
+    '╗': '╝',
+    '╝': '╗',
+    '╤': '╧',
+    '╧': '╤',
+    '┌': '└',
+    '└': '┌',
+    '┐': '┘',
+    '┘': '┐',
+    '┏': '┗',
+    '┗': '┏',
+    '┓': '┛',
+    '┛': '┓',
+    '╭': '╰',
+    '╰': '╭',
+    '╮': '╯',
+    '╯': '╮',
+    '┬': '┴',
+    '┴': '┬',
+    '┳': '┻',
+    '┻': '┳',
+    '▼': '▲',
+    '▲': '▼',
+    '▽': '△',
+    '△': '▽',
+};
+const FLIP_H = {
+    '╔': '╗',
+    '╗': '╔',
+    '╚': '╝',
+    '╝': '╚',
+    '╟': '╢',
+    '╢': '╟',
+    '┌': '┐',
+    '┐': '┌',
+    '└': '┘',
+    '┘': '└',
+    '┏': '┓',
+    '┓': '┏',
+    '┗': '┛',
+    '┛': '┗',
+    '╭': '╮',
+    '╮': '╭',
+    '╰': '╯',
+    '╯': '╰',
+    '├': '┤',
+    '┤': '├',
+    '┣': '┫',
+    '┫': '┣',
+    '▶': '◄',
+    '◄': '▶',
+    '▷': '◁',
+    '◁': '▷',
+};
+const dottedChar = (c) => DOTTED[c] ?? c;
+const thickChar = (c) => THICK[c] ?? c;
+const flipGlyphV = (c) => FLIP_V[c] ?? c;
+const flipGlyphH = (c) => FLIP_H[c] ?? c;
+/** User-authored cells: flips reorder them but must not remap their glyphs. */
+const textRole = (r) => r === 'text' || r === 'edgeLabel' || r === 'title';
+//# sourceMappingURL=canvas.js.map

package/src/mermaid/class-style.js

@@ -0,0 +1,57 @@
+/**
+ * Best-effort interpretation of `classDef` styles for a cell grid.
+ *
+ * A terminal cell can express a foreground, a background and boldness —
+ * nothing else. `fill` is the node background, `stroke` its border,
+ * `color` its text; every other property is silently ignored.
+ */
+import { NAMED_COLORS } from './css-colors.js';
+/** `#rgb`, `#rrggbb`, `rgb(r,g,b)` or a CSS color name → `#rrggbb`; else null. */
+function normalizeColor(v) {
+    const s = v.trim().toLowerCase();
+    if (/^#[0-9a-f]{6}$/.test(s))
+        return s;
+    if (/^#[0-9a-f]{3}$/.test(s))
+        return `#${s[1]}${s[1]}${s[2]}${s[2]}${s[3]}${s[3]}`;
+    const rgb = s.match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
+    if (rgb !== null) {
+        const hex = (n) => Math.min(255, Number(n)).toString(16).padStart(2, '0');
+        return `#${hex(rgb[1])}${hex(rgb[2])}${hex(rgb[3])}`;
+    }
+    return NAMED_COLORS[s] ?? null;
+}
+/**
+ * The merged style of a span's classes (later classes win), or null when
+ * nothing terminal-expressible was declared.
+ */
+export function resolveClassStyle(classes, classDefs) {
+    if (classes === undefined)
+        return null;
+    const out = {};
+    for (const name of classes) {
+        const props = classDefs[name];
+        if (props === undefined)
+            continue;
+        for (const [k, v] of Object.entries(props)) {
+            if (k === 'fill' || k === 'stroke' || k === 'color') {
+                const c = normalizeColor(v);
+                if (c !== null)
+                    out[k] = c;
+            }
+            else if (k === 'font-weight') {
+                out.bold = v.trim() === 'bold' || v.trim() === 'bolder';
+            }
+        }
+    }
+    return Object.keys(out).length > 0 ? out : null;
+}
+/**
+ * Black or white, whichever reads on the given `#rrggbb` background — the
+ * guard that keeps `fill:#eee` legible on a dark terminal theme.
+ */
+export function contrastOn(fill) {
+    const ch = (i) => Number.parseInt(fill.slice(i, i + 2), 16);
+    const yiq = (ch(1) * 299 + ch(3) * 587 + ch(5) * 114) / 1000;
+    return yiq >= 128 ? '#000000' : '#ffffff';
+}
+//# sourceMappingURL=class-style.js.map