@m6d/cortex-cli 0.14.0 → 0.16.0

package/src/contracts/markdown/index.ts

@@ -1,47 +0,0 @@
-/*
- * CommonMark fence tracking shared by the prompt rich-text pipeline, the
- * widget's streamed-message segmenter, and Cortex's report stand-ins.
- */
-
-/** A fence delimiter of three or more backticks or tildes, indented at most three spaces, and the rest of its line. */
-const FENCE_LINE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
-
-/**
- * Line-by-line fence state, following CommonMark's fence rules: a fence line
- * is indented at most three spaces; an opening backtick fence's info string
- * may not contain backticks; and a fence closes only on the same marker
- * character, with at least the opening run's length, followed by nothing but
- * whitespace — so a `~~~` line, a shorter same-marker run, or a ```` ```js ````
- * info line inside a backtick fence all stay code content.
- */
-export function fenceTracker() {
-    let fence: { marker: string; length: number } | null = null;
-    return (line: string) => {
-        const match = FENCE_LINE.exec(line);
-        const delimiter = match?.[1];
-        const rest = match?.[2] ?? "";
-        if (delimiter) {
-            const marker = delimiter.charAt(0);
-            if (fence) {
-                if (
-                    marker === fence.marker &&
-                    delimiter.length >= fence.length &&
-                    rest.trim() === ""
-                ) {
-                    fence = null;
-                    return "close";
-                }
-                return "inside";
-            }
-            if (marker === "`" && rest.includes("`")) return "outside";
-            fence = { marker, length: delimiter.length };
-            return "open";
-        }
-        return fence ? "inside" : "outside";
-    };
-}
-
-/** An opening fence line's language: the info string's first word, "" when there is none. */
-export function fenceLanguage(line: string) {
-    return FENCE_LINE.exec(line)?.[2]?.trim().split(/\s+/)[0] ?? "";
-}

package/src/contracts/pattern/index.ts

@@ -1,276 +0,0 @@
-// cspell:ignore fefe fff
-import { RE2JS } from "re2js";
-
-/*
- * A tool input schema's `pattern`: a regular expression JavaScript reads with
- * no flags, which Cortex matches on RE2 so a value is checked in time linear
- * in its length. A pattern RE2 cannot match as JavaScript reads it is refused
- * by Cortex and left out of what the TypeScript SDK exports.
- *
- * RE2 matches code points where JavaScript matches UTF-16 units, so the
- * pattern and every input lift each surrogate unit into a private-use plane,
- * where it is one code point: RE2 then reads the units JavaScript reads.
- * Nothing collides there, since a real character in that plane is astral,
- * arrives as two surrogate units and is lifted in turn.
- */
-
-/**
- * What one escape or character in a class stands for, spelled as the inside
- * of an RE2 class: a single character carries its UTF-16 unit, and an
- * unescaped `-` is marked as one that may make a range.
- */
-type Atom = { body: string; char?: number; dash?: boolean };
-
-/** JavaScript's `\s`, its WhiteSpace and LineTerminator characters, as the inside of an RE2 class. */
-const SPACE =
-    "\\x{9}-\\x{d}\\x{20}\\x{a0}\\x{1680}\\x{2000}-\\x{200a}\\x{2028}\\x{2029}\\x{202f}\\x{205f}\\x{3000}\\x{feff}";
-/** Every character `SPACE` leaves out: JavaScript's `\S`. */
-const NON_SPACE =
-    "\\x{0}-\\x{8}\\x{e}-\\x{1f}\\x{21}-\\x{9f}\\x{a1}-\\x{167f}\\x{1681}-\\x{1fff}\\x{200b}-\\x{2027}" +
-    "\\x{202a}-\\x{202e}\\x{2030}-\\x{205e}\\x{2060}-\\x{2fff}\\x{3001}-\\x{fefe}\\x{ff00}-\\x{10ffff}";
-/** The set escapes as JavaScript reads them; RE2's own `\d` and `\w` match, its `\s` holds only ASCII. */
-const SET_ESCAPES = new Map([
-    ["d", "\\d"],
-    ["D", "\\D"],
-    ["w", "\\w"],
-    ["W", "\\W"],
-    ["s", SPACE],
-    ["S", NON_SPACE],
-]);
-/** JavaScript's `.`: every character but a line terminator, where RE2's leaves out only `\n`. */
-const DOT = "[^\\x{a}\\x{d}\\x{2028}\\x{2029}]";
-const CONTROL_ESCAPES = new Map([
-    ["f", 0x0c],
-    ["n", 0x0a],
-    ["r", 0x0d],
-    ["t", 0x09],
-    ["v", 0x0b],
-]);
-const QUANTIFIER = /\{\d+(?:,\d*)?\}/y;
-const SURROGATE = /[\uD800-\uDFFF]/g;
-/** Where surrogate unit `0xd800 + n` is lifted: code point `0xf0000 + n`. */
-const LIFTED_SURROGATES = 0xf0000;
-const HEX = /[0-9A-Fa-f]+/y;
-/** What JavaScript's `[^]` and `[]` hold: every character, and none. */
-const ANY = "[\\x{0}-\\x{10ffff}]";
-const NONE = "[^\\x{0}-\\x{10ffff}]";
-
-/** A thrown error: the pattern holds what RE2 cannot match as JavaScript reads it. */
-function unsupported(what: string): never {
-    throw new Error(`a pattern with ${what}`);
-}
-
-/** A UTF-16 unit as the one code point RE2 reads: a surrogate lifted, any other unit itself. */
-function lifted(unit: number) {
-    return unit >= 0xd800 && unit <= 0xdfff ? LIFTED_SURROGATES + unit - 0xd800 : unit;
-}
-
-/** `input` with every surrogate unit lifted, one code point per UTF-16 unit. */
-function liftedText(input: string) {
-    return input.replace(SURROGATE, (unit) => String.fromCodePoint(lifted(unit.charCodeAt(0))));
-}
-
-/** One UTF-16 unit as RE2 reads it literally, inside a class or out. */
-function literal(unit: number) {
-    const char = lifted(unit);
-    const spelled = String.fromCodePoint(char);
-    return /^[A-Za-z0-9]$/.test(spelled) ? spelled : `\\x{${char.toString(16)}}`;
-}
-
-/**
- * The units from `from` to `to` as the inside of an RE2 class: the part
- * among the surrogates, lifted, apart from the parts below and above it.
- */
-function unitRange(from: number, to: number) {
-    return (
-        [
-            [from, Math.min(to, 0xd7ff)],
-            [Math.max(from, 0xd800), Math.min(to, 0xdfff)],
-            [Math.max(from, 0xe000), to],
-        ] satisfies Array<[number, number]>
-    )
-        .filter(([low, high]) => low <= high)
-        .map(([low, high]) => `${literal(low)}-${literal(high)}`)
-        .join("");
-}
-
-function character(char: number, dash = false) {
-    return { body: literal(char), char, dash };
-}
-
-/**
- * A class's atoms as the inside of an RE2 class: an unescaped dash between
- * two characters makes a range, and beside a set escape it is a character,
- * as JavaScript reads them.
- */
-function classBody(atoms: Atom[]) {
-    let body = "";
-    for (let index = 0; index < atoms.length; index += 1) {
-        const [from, dash, to] = atoms.slice(index, index + 3);
-        if (!from) break;
-        if (!dash?.dash || !to) {
-            body += from.body;
-            continue;
-        }
-        body +=
-            from.char !== undefined && to.char !== undefined
-                ? unitRange(from.char, to.char)
-                : `${from.body}${dash.body}${to.body}`;
-        index += 2;
-    }
-    return body;
-}
-
-/**
- * A pattern read left to right as JavaScript reads it with no flags (Annex B
- * included), written in RE2's syntax; throws on a lookaround, a
- * backreference, a legacy octal escape, a group modifier or a `\c` without
- * its letter. It reads UTF-16 units, as JavaScript does. Groups do not
- * capture: nothing reads them.
- */
-class Translation {
-    private at = 0;
-
-    public constructor(private readonly pattern: string) {}
-
-    public spell() {
-        let re2 = "";
-        while (this.at < this.pattern.length) re2 += this.term();
-        return re2;
-    }
-
-    private term() {
-        const char = this.pattern[this.at] ?? "";
-        if (char === "\\") return this.escapeOutsideClass();
-        if (char === "[") return this.characterClass();
-        if (char === "(") return this.group();
-        if (char === "{") return this.brace();
-        if (!"|)^$*+?.".includes(char)) return literal(this.unit());
-        this.at += 1;
-        return char === "." ? DOT : char;
-    }
-
-    private escapeOutsideClass() {
-        this.at += 1;
-        const assertion = this.pattern[this.at];
-        if (assertion === "b" || assertion === "B") {
-            this.at += 1;
-            return `\\${assertion}`;
-        }
-        const atom = this.escape(false);
-        return "char" in atom ? atom.body : `[${atom.body}]`;
-    }
-
-    /** The escape after a backslash, which `at` is past; in a class `\b` is a backspace. */
-    private escape(insideClass: boolean) {
-        const next = this.pattern[this.at] ?? unsupported("a trailing backslash");
-        this.at += 1;
-        const set = SET_ESCAPES.get(next);
-        if (set) return { body: set };
-        const control = insideClass && next === "b" ? 0x08 : CONTROL_ESCAPES.get(next);
-        if (control !== undefined) return character(control);
-        if (next === "c") return character(this.controlLetter(insideClass));
-        if (next === "x" || next === "u") {
-            return character(this.hex(next === "x" ? 2 : 4) ?? next.charCodeAt(0));
-        }
-        if (next === "0" && !/^\d$/.test(this.pattern[this.at] ?? "")) return character(0);
-        if (/^[\dk]$/.test(next)) unsupported("a backreference or an octal escape");
-        this.at -= 1;
-        return character(this.unit());
-    }
-
-    /** The control character a `\c` names: a letter, or in a class also a digit or `_`. */
-    private controlLetter(insideClass: boolean) {
-        const letter = this.pattern[this.at] ?? "";
-        if (!(insideClass ? /^\w$/ : /^[A-Za-z]$/).test(letter)) {
-            unsupported("a \\c without its letter");
-        }
-        this.at += 1;
-        return letter.charCodeAt(0) % 32;
-    }
-
-    /** `length` hex digits at `at` as a UTF-16 unit, consumed; undefined when fewer follow. */
-    private hex(length: number) {
-        HEX.lastIndex = this.at;
-        const digits = HEX.exec(this.pattern)?.[0] ?? "";
-        if (digits.length < length) return undefined;
-        this.at += length;
-        return Number.parseInt(digits.slice(0, length), 16);
-    }
-
-    private unit() {
-        const unit = this.pattern.charCodeAt(this.at);
-        if (Number.isNaN(unit)) unsupported("a pattern cut short");
-        this.at += 1;
-        return unit;
-    }
-
-    /**
-     * A class, `at` on its `[`. In JavaScript a `]` always closes one, so
-     * `[]` holds nothing and `[^]` everything.
-     */
-    private characterClass() {
-        this.at += 1;
-        const negated = this.pattern[this.at] === "^";
-        if (negated) this.at += 1;
-        const atoms: Atom[] = [];
-        while (this.pattern[this.at] !== "]") {
-            if (this.at >= this.pattern.length) unsupported("an unclosed class");
-            atoms.push(this.classAtom());
-        }
-        this.at += 1;
-        const body = classBody(atoms);
-        if (!body) return negated ? ANY : NONE;
-        return `[${negated ? "^" : ""}${body}]`;
-    }
-
-    private classAtom() {
-        const char = this.pattern[this.at];
-        this.at += 1;
-        if (char === "\\") return this.escape(true);
-        if (char === "-") return character(0x2d, true);
-        this.at -= 1;
-        return character(this.unit());
-    }
-
-    /** A group's opening as RE2 reads it: every group, named or not, without a capture. */
-    private group() {
-        const opening = this.pattern.slice(this.at, this.at + 4);
-        if (/^\(\?<[^=!]/.test(opening)) {
-            const name = this.pattern.indexOf(">", this.at);
-            if (name < 0) unsupported("an unclosed group name");
-            this.at = name + 1;
-        } else if (opening.startsWith("(?")) {
-            if (!opening.startsWith("(?:")) unsupported("a lookaround or a group modifier");
-            this.at += 3;
-        } else {
-            this.at += 1;
-        }
-        return "(?:";
-    }
-
-    /** A quantifier, or a brace JavaScript reads as a character because it opens none. */
-    private brace() {
-        QUANTIFIER.lastIndex = this.at;
-        const quantifier = QUANTIFIER.exec(this.pattern)?.[0];
-        this.at += quantifier?.length ?? 1;
-        return quantifier ?? literal(0x7b);
-    }
-}
-
-/**
- * A matcher for a pattern JavaScript compiles, meaning what the pattern
- * means to JavaScript with no flags, UTF-16 unit for unit; undefined when
- * RE2 cannot match it so, as for a lookaround, a backreference or a
- * repetition past 1000. Its `test` runs on RE2, in time linear in the input.
- * It never calls `new RegExp`, so it works while a caller has replaced that
- * global.
- */
-export function linearPattern(pattern: string) {
-    try {
-        const re2 = RE2JS.compile(new Translation(pattern).spell());
-        return { test: (input: string) => re2.test(liftedText(input)) };
-    } catch {
-        return undefined;
-    }
-}

package/src/contracts/server/reserved-names.fixtures.json

@@ -1,18 +0,0 @@
-{
-    "tools": [
-        "describeDataset",
-        "executeCode",
-        "fetchImage",
-        "loadSkill",
-        "queryDataset",
-        "readAttachment",
-        "readReport",
-        "searchKnowledge",
-        "searchServices",
-        "searchThreadHistory",
-        "searchTools",
-        "requestLocation",
-        "submitAnswer"
-    ],
-    "variables": ["utcTime", "locale", "timezone"]
-}