@open-agent-toolkit/cli 0.3.36 → 0.3.38

package/dist/providers/codex/codec/config-toml-edit.js

@@ -0,0 +1,718 @@
+import { CliError } from '../../../errors/index.js';
+const BARE_KEY_PATTERN = /^[A-Za-z0-9_-]+$/;
+const BARE_VALUE_TERMINATORS = new Set([
+    ' ',
+    '\t',
+    ',',
+    ']',
+    '}',
+    '#',
+    '\r',
+    '\n',
+]);
+const SIMPLE_ESCAPES = {
+    b: '\b',
+    t: '\t',
+    n: '\n',
+    f: '\f',
+    r: '\r',
+    '"': '"',
+    '\\': '\\',
+};
+const MAX_EDIT_PASSES = 10_000;
+function unsupported(detail) {
+    return new CliError(`Cannot edit .codex/config.toml without rewriting user content: ${detail}. Edit the file by hand and rerun sync.`);
+}
+function findLast(items, predicate) {
+    for (let index = items.length - 1; index >= 0; index--) {
+        if (predicate(items[index])) {
+            return items[index];
+        }
+    }
+    return undefined;
+}
+function pathsEqual(left, right) {
+    return (left.length === right.length &&
+        left.every((segment, index) => segment === right[index]));
+}
+function startsWithPath(path, prefix) {
+    return (path.length >= prefix.length &&
+        prefix.every((segment, index) => segment === path[index]));
+}
+function isStrictPrefix(prefix, path) {
+    return prefix.length < path.length && startsWithPath(path, prefix);
+}
+class TomlLexer {
+    text;
+    pos = 0;
+    sections = [];
+    entries = [];
+    comments = [];
+    constructor(text) {
+        this.text = text;
+    }
+    lex() {
+        let section = {
+            header: null,
+            path: [],
+            isArray: false,
+            lastEnd: 0,
+        };
+        this.sections.push(section);
+        while (this.pos < this.text.length) {
+            const lineStart = this.pos;
+            this.skipInlineWhitespace();
+            if (this.pos >= this.text.length) {
+                break;
+            }
+            if (this.atNewline()) {
+                this.skipNewline();
+                continue;
+            }
+            if (this.peek() === '#') {
+                const start = this.pos;
+                this.skipComment();
+                this.comments.push({ lineStart, start, end: this.pos });
+                continue;
+            }
+            if (this.peek() === '[') {
+                const isArray = this.text.startsWith('[[', this.pos);
+                this.pos += isArray ? 2 : 1;
+                const path = this.lexKey();
+                this.expect(isArray ? ']]' : ']');
+                const end = this.finishLine();
+                section = {
+                    header: { path, isArray, lineStart, end },
+                    path,
+                    isArray,
+                    lastEnd: end,
+                };
+                this.sections.push(section);
+                continue;
+            }
+            const entry = this.lexKeyValue(section, null, section.path, lineStart);
+            entry.end = this.finishLine();
+            section.lastEnd = entry.end;
+        }
+        return {
+            sections: this.sections,
+            entries: this.entries,
+            blocks: findMarkerBlocks(this.text, this.comments),
+        };
+    }
+    peek(offset = 0) {
+        return this.text[this.pos + offset];
+    }
+    fail(detail) {
+        throw unsupported(`${detail} at offset ${this.pos}`);
+    }
+    atNewline() {
+        return (this.peek() === '\n' || (this.peek() === '\r' && this.peek(1) === '\n'));
+    }
+    skipNewline() {
+        this.pos += this.peek() === '\r' ? 2 : 1;
+    }
+    skipInlineWhitespace() {
+        while (this.peek() === ' ' || this.peek() === '\t') {
+            this.pos += 1;
+        }
+    }
+    skipComment() {
+        while (this.pos < this.text.length && !this.atNewline()) {
+            this.pos += 1;
+        }
+    }
+    skipArrayWhitespace() {
+        for (;;) {
+            this.skipInlineWhitespace();
+            if (this.atNewline()) {
+                this.skipNewline();
+            }
+            else if (this.peek() === '#') {
+                this.skipComment();
+            }
+            else {
+                return;
+            }
+        }
+    }
+    expect(token) {
+        this.skipInlineWhitespace();
+        if (!this.text.startsWith(token, this.pos)) {
+            this.fail(`expected "${token}"`);
+        }
+        this.pos += token.length;
+    }
+    finishLine() {
+        this.skipInlineWhitespace();
+        if (this.peek() === '#') {
+            this.skipComment();
+        }
+        if (this.pos < this.text.length && !this.atNewline()) {
+            this.fail('expected end of line');
+        }
+        return this.pos;
+    }
+    lexKey() {
+        const segments = [];
+        for (;;) {
+            this.skipInlineWhitespace();
+            const char = this.peek();
+            if (char === '"') {
+                segments.push(this.lexBasicKey());
+            }
+            else if (char === "'") {
+                const close = this.text.indexOf("'", this.pos + 1);
+                if (close < 0) {
+                    this.fail('unterminated literal key');
+                }
+                segments.push(this.text.slice(this.pos + 1, close));
+                this.pos = close + 1;
+            }
+            else {
+                const start = this.pos;
+                while (/[A-Za-z0-9_-]/.test(this.peek() ?? '')) {
+                    this.pos += 1;
+                }
+                if (start === this.pos) {
+                    this.fail('expected a key');
+                }
+                segments.push(this.text.slice(start, this.pos));
+            }
+            this.skipInlineWhitespace();
+            if (this.peek() !== '.') {
+                return segments;
+            }
+            this.pos += 1;
+        }
+    }
+    lexBasicKey() {
+        let value = '';
+        this.pos += 1;
+        for (;;) {
+            const char = this.peek();
+            if (char === undefined || char === '\n' || char === '\r') {
+                this.fail('unterminated quoted key');
+            }
+            this.pos += 1;
+            if (char === '"') {
+                return value;
+            }
+            if (char !== '\\') {
+                value += char;
+                continue;
+            }
+            const escape = this.peek() ?? '';
+            this.pos += 1;
+            if (escape in SIMPLE_ESCAPES) {
+                value += SIMPLE_ESCAPES[escape];
+                continue;
+            }
+            const width = escape === 'u' ? 4 : escape === 'U' ? 8 : 0;
+            const hex = this.text.slice(this.pos, this.pos + width);
+            if (width === 0 || !/^[0-9A-Fa-f]+$/.test(hex) || hex.length !== width) {
+                this.fail('invalid escape in quoted key');
+            }
+            value += String.fromCodePoint(Number.parseInt(hex, 16));
+            this.pos += width;
+        }
+    }
+    lexKeyValue(section, inline, containerPath, lineStart) {
+        this.skipInlineWhitespace();
+        const start = this.pos;
+        const keyPath = this.lexKey();
+        this.expect('=');
+        this.skipInlineWhitespace();
+        const entry = {
+            path: [...containerPath, ...keyPath],
+            keyPath,
+            containerPath,
+            section,
+            inline,
+            start,
+            lineStart,
+            valueStart: this.pos,
+            valueEnd: this.pos,
+            end: this.pos,
+            table: null,
+        };
+        if (!section.isArray) {
+            this.entries.push(entry);
+        }
+        entry.table = this.lexValue(entry.path, section);
+        entry.valueEnd = this.pos;
+        entry.end = this.pos;
+        return entry;
+    }
+    lexValue(path, section) {
+        const char = this.peek();
+        if (this.text.startsWith('"""', this.pos)) {
+            this.lexMultilineString('"""', true);
+        }
+        else if (this.text.startsWith("'''", this.pos)) {
+            this.lexMultilineString("'''", false);
+        }
+        else if (char === '"') {
+            this.lexSingleLineString('"', true);
+        }
+        else if (char === "'") {
+            this.lexSingleLineString("'", false);
+        }
+        else if (char === '[') {
+            this.lexArray(section);
+        }
+        else if (char === '{') {
+            return this.lexInlineTable(path, section);
+        }
+        else {
+            this.lexBareValue();
+        }
+        return null;
+    }
+    lexMultilineString(delimiter, escapes) {
+        this.pos += 3;
+        for (;;) {
+            if (this.pos >= this.text.length) {
+                this.fail('unterminated multiline string');
+            }
+            if (escapes && this.peek() === '\\') {
+                this.pos += 2;
+                continue;
+            }
+            if (this.text.startsWith(delimiter, this.pos)) {
+                this.pos += 3;
+                for (let extra = 0; extra < 2 && this.peek() === delimiter[0]; extra++) {
+                    this.pos += 1;
+                }
+                return;
+            }
+            this.pos += 1;
+        }
+    }
+    lexSingleLineString(delimiter, escapes) {
+        this.pos += 1;
+        for (;;) {
+            const char = this.peek();
+            if (char === undefined || char === '\n' || char === '\r') {
+                this.fail('unterminated string');
+            }
+            if (escapes && char === '\\') {
+                this.pos += 2;
+                continue;
+            }
+            this.pos += 1;
+            if (char === delimiter) {
+                return;
+            }
+        }
+    }
+    lexArray(section) {
+        this.pos += 1;
+        for (;;) {
+            this.skipArrayWhitespace();
+            if (this.peek() === ']') {
+                this.pos += 1;
+                return;
+            }
+            if (this.pos >= this.text.length) {
+                this.fail('unterminated array');
+            }
+            this.lexValue(null, section);
+            this.skipArrayWhitespace();
+            if (this.peek() === ',') {
+                this.pos += 1;
+            }
+            else if (this.peek() !== ']') {
+                this.fail('expected "," or "]" in array');
+            }
+        }
+    }
+    lexInlineTable(path, section) {
+        const table = {
+            path: path ?? [],
+            open: this.pos,
+            close: this.pos,
+            entries: [],
+        };
+        this.pos += 1;
+        this.skipInlineWhitespace();
+        if (this.peek() !== '}') {
+            for (;;) {
+                if (path === null) {
+                    this.lexValueOnlyInlineEntry(section);
+                }
+                else {
+                    table.entries.push(this.lexKeyValue(section, table, path, table.open));
+                }
+                this.skipInlineWhitespace();
+                if (this.peek() === ',') {
+                    this.pos += 1;
+                    continue;
+                }
+                if (this.peek() !== '}') {
+                    this.fail('expected "," or "}" in inline table');
+                }
+                break;
+            }
+        }
+        table.close = this.pos;
+        this.pos += 1;
+        return path === null ? null : table;
+    }
+    /** Inline tables inside arrays are array elements, never table definitions. */
+    lexValueOnlyInlineEntry(section) {
+        this.skipInlineWhitespace();
+        this.lexKey();
+        this.expect('=');
+        this.skipInlineWhitespace();
+        this.lexValue(null, section);
+    }
+    lexBareValue() {
+        const start = this.pos;
+        while (this.pos < this.text.length &&
+            !BARE_VALUE_TERMINATORS.has(this.peek())) {
+            this.pos += 1;
+        }
+        if (start === this.pos) {
+            this.fail('expected a value');
+        }
+        if (/^\d{4}-\d{2}-\d{2}$/.test(this.text.slice(start, this.pos)) &&
+            /^ \d{2}:/.test(this.text.slice(this.pos, this.pos + 4))) {
+            this.pos += 1;
+            this.lexBareValue();
+        }
+    }
+}
+function lexToml(text) {
+    return new TomlLexer(text).lex();
+}
+/** Renders a TOML basic string; JSON escaping is not TOML-safe for all input. */
+export function renderTomlString(value) {
+    let rendered = '"';
+    for (const char of value) {
+        const code = char.codePointAt(0);
+        if (char === '"' || char === '\\') {
+            rendered += `\\${char}`;
+        }
+        else if (char === '\b') {
+            rendered += '\\b';
+        }
+        else if (char === '\t') {
+            rendered += '\\t';
+        }
+        else if (char === '\n') {
+            rendered += '\\n';
+        }
+        else if (char === '\f') {
+            rendered += '\\f';
+        }
+        else if (char === '\r') {
+            rendered += '\\r';
+        }
+        else if (code < 0x20 || code === 0x7f) {
+            rendered += `\\u${code.toString(16).padStart(4, '0')}`;
+        }
+        else if (code >= 0xd800 && code <= 0xdfff) {
+            throw unsupported('a value contains an unpaired surrogate');
+        }
+        else {
+            rendered += char;
+        }
+    }
+    return `${rendered}"`;
+}
+function renderKey(segment) {
+    return BARE_KEY_PATTERN.test(segment) ? segment : renderTomlString(segment);
+}
+function renderKeyPath(path) {
+    return path.map(renderKey).join('.');
+}
+function detectEol(text) {
+    const newline = text.indexOf('\n');
+    return newline > 0 && text[newline - 1] === '\r' ? '\r\n' : '\n';
+}
+function splice(text, start, end, replacement) {
+    return `${text.slice(0, start)}${replacement}${text.slice(end)}`;
+}
+function lineIndentAt(text, lineStart) {
+    return /^[ \t]*/.exec(text.slice(lineStart))[0];
+}
+function previousLineStart(text, lineStart) {
+    if (lineStart === 0) {
+        return null;
+    }
+    return text.lastIndexOf('\n', lineStart - 2) + 1;
+}
+function lineEndIncludingNewline(text, contentEnd) {
+    if (text.startsWith('\r\n', contentEnd)) {
+        return contentEnd + 2;
+    }
+    return text[contentEnd] === '\n' ? contentEnd + 1 : contentEnd;
+}
+function findDefinition(document, tablePath) {
+    if (tablePath.length === 0) {
+        return { kind: 'root' };
+    }
+    const section = document.sections.find((candidate) => candidate.header !== null &&
+        !candidate.isArray &&
+        pathsEqual(candidate.path, tablePath));
+    if (section) {
+        return { kind: 'header', section };
+    }
+    const inline = document.entries.find((entry) => pathsEqual(entry.path, tablePath));
+    if (inline) {
+        if (!inline.table) {
+            throw unsupported(`${renderKeyPath(tablePath)} is not a table`);
+        }
+        return { kind: 'inline', table: inline.table };
+    }
+    const dotted = document.entries.filter((entry) => isStrictPrefix(tablePath, entry.path) &&
+        isStrictPrefix(entry.containerPath, tablePath));
+    if (dotted.length > 0) {
+        return { kind: 'dotted', anchor: dotted.at(-1) };
+    }
+    return document.sections.some((candidate) => candidate.header !== null && isStrictPrefix(tablePath, candidate.path))
+        ? { kind: 'implicit' }
+        : null;
+}
+function insertIntoInlineTable(text, document, table, path, member) {
+    const block = markerBlockAt(document, table.close);
+    if (block) {
+        throw insideMarkerBlock(path, block);
+    }
+    const last = table.entries.at(-1);
+    if (!last) {
+        return splice(text, table.open + 1, table.close, ` ${member} `);
+    }
+    return splice(text, last.valueEnd, last.valueEnd, `, ${member}`);
+}
+function insertAfterStatement(text, lineStart, contentEnd, line) {
+    return splice(text, contentEnd, contentEnd, `${detectEol(text)}${lineIndentAt(text, lineStart)}${line}`);
+}
+/*
+ * Other tools own `# BEGIN <label>` ... `# END <label>` blocks and delete every
+ * line between the pair, so nothing OAT writes may be inserted inside one.
+ * Only standalone comment lines count; text inside strings is not a marker.
+ */
+const MARKER_PATTERN = /^#[ \t]*(BEGIN|END)[ \t]+(\S(?:.*\S)?)[ \t]*$/;
+function findMarkerBlocks(text, comments) {
+    const markers = comments.map((comment) => ({
+        comment,
+        match: MARKER_PATTERN.exec(text.slice(comment.start, comment.end)),
+    }));
+    const blocks = [];
+    markers.forEach(({ comment, match }, index) => {
+        if (match?.[1] !== 'BEGIN') {
+            return;
+        }
+        const label = match[2];
+        const end = markers
+            .slice(index + 1)
+            .find((candidate) => candidate.match?.[1] === 'END' && candidate.match[2] === label);
+        if (end) {
+            blocks.push({
+                label,
+                beginLineStart: comment.lineStart,
+                beginEnd: comment.end,
+                endLineStart: end.comment.lineStart,
+            });
+        }
+    });
+    return blocks;
+}
+function markerBlockAt(document, offset) {
+    return document.blocks.find((block) => block.beginEnd <= offset && offset <= block.endLineStart);
+}
+function outsideMarkerBlocks(document, offset) {
+    return offset !== null && markerBlockAt(document, offset) ? null : offset;
+}
+function insideMarkerBlock(path, block) {
+    return unsupported(`${renderKeyPath(path)} would be written inside the "# BEGIN ${block.label}" block`);
+}
+/** Appends after `anchor`, or after the last statement before a marker block. */
+function insertIntoSection(text, document, section, anchor, path, line) {
+    let { lineStart, end } = anchor;
+    for (;;) {
+        const block = markerBlockAt(document, end);
+        if (!block) {
+            return insertAfterStatement(text, lineStart, end, line);
+        }
+        const previous = findLast(document.entries, (entry) => entry.section === section &&
+            entry.inline === null &&
+            entry.end <= block.beginLineStart);
+        const header = section.header;
+        if (previous) {
+            ({ lineStart, end } = previous);
+        }
+        else if (header && header.end <= block.beginLineStart) {
+            ({ lineStart, end } = header);
+        }
+        else {
+            throw insideMarkerBlock(path, block);
+        }
+    }
+}
+function isCommentLine(line) {
+    return /^[ \t]*#/.test(line);
+}
+function isBlankLine(line) {
+    return /^[ \t]*(?:\r?\n)?$/.test(line);
+}
+/*
+ * Other tools wrap tables in marker comments. A comment run with content
+ * directly on both sides may be the `# END` of the block above or the
+ * `# BEGIN` of the block below, so the two helpers below return null rather
+ * than guess, and the caller appends at the end of the file instead.
+ */
+function leadingCommentStart(text, lineStart) {
+    let start = lineStart;
+    for (;;) {
+        const previous = previousLineStart(text, start);
+        if (previous === null) {
+            return start;
+        }
+        const line = text.slice(previous, start);
+        if (!isCommentLine(line)) {
+            return isBlankLine(line) || start === lineStart ? start : null;
+        }
+        start = previous;
+    }
+}
+function trailingCommentEnd(text, contentEnd) {
+    let end = contentEnd;
+    let cursor = lineEndIncludingNewline(text, contentEnd);
+    while (cursor < text.length) {
+        const newline = text.indexOf('\n', cursor);
+        const next = newline < 0 ? text.length : newline + 1;
+        const line = text.slice(cursor, next);
+        if (!isCommentLine(line)) {
+            return isBlankLine(line) || end === contentEnd ? end : null;
+        }
+        end = cursor + line.replace(/\r?\n$/, '').length;
+        cursor = next;
+    }
+    return end;
+}
+function insertSection(text, document, tablePath, lines) {
+    const eol = detectEol(text);
+    const block = [`[${renderKeyPath(tablePath)}]`, ...lines].join(eol);
+    const headers = document.sections.filter((section) => section.header !== null);
+    const firstSubTable = headers.find((section) => isStrictPrefix(tablePath, section.path));
+    const start = firstSubTable
+        ? outsideMarkerBlocks(document, leadingCommentStart(text, firstSubTable.header.lineStart))
+        : null;
+    if (start !== null) {
+        return splice(text, start, start, `${block}${eol}${eol}`);
+    }
+    const familyDepth = firstSubTable ? 0 : tablePath.length - 1;
+    for (let depth = familyDepth; depth >= 1; depth--) {
+        const family = tablePath.slice(0, depth);
+        const lastInFamily = findLast(headers, (section) => startsWithPath(section.path, family));
+        if (lastInFamily) {
+            const end = outsideMarkerBlocks(document, trailingCommentEnd(text, lastInFamily.lastEnd));
+            if (end !== null) {
+                return splice(text, end, end, `${eol}${eol}${block}`);
+            }
+            break;
+        }
+    }
+    const contentEnd = text.length - /(?:\r?\n[ \t]*)*$/.exec(text)[0].length;
+    if (contentEnd === 0) {
+        return splice(text, 0, 0, `${block}${eol}`);
+    }
+    return splice(text, contentEnd, contentEnd, `${eol}${eol}${block}`);
+}
+/** `renderedValue` must already be a valid TOML value literal. */
+export function setTomlValue(text, path, renderedValue) {
+    const document = lexToml(text);
+    const existing = document.entries.find((entry) => pathsEqual(entry.path, path));
+    if (existing) {
+        return splice(text, existing.valueStart, existing.valueEnd, renderedValue);
+    }
+    const tablePath = path.slice(0, -1);
+    let depth = tablePath.length;
+    let definition = findDefinition(document, tablePath);
+    while (definition === null) {
+        depth -= 1;
+        definition = findDefinition(document, tablePath.slice(0, depth));
+    }
+    const rest = path.slice(depth);
+    switch (definition.kind) {
+        case 'header':
+            if (rest.length === 1) {
+                const { section } = definition;
+                const lastEntry = findLast(document.entries, (entry) => entry.section === section && entry.inline === null);
+                return insertIntoSection(text, document, section, {
+                    lineStart: lastEntry?.lineStart ?? section.header.lineStart,
+                    end: section.lastEnd,
+                }, path, `${renderKey(rest[0])} = ${renderedValue}`);
+            }
+            break;
+        case 'inline': {
+            const member = rest
+                .slice(0, -1)
+                .reduceRight((inner, segment) => `${renderKey(segment)} = { ${inner} }`, `${renderKey(rest.at(-1))} = ${renderedValue}`);
+            return insertIntoInlineTable(text, document, definition.table, path, member);
+        }
+        case 'dotted': {
+            const { anchor } = definition;
+            const member = `${renderKeyPath(path.slice(anchor.containerPath.length))} = ${renderedValue}`;
+            if (anchor.inline) {
+                return insertIntoInlineTable(text, document, anchor.inline, path, member);
+            }
+            return insertIntoSection(text, document, anchor.section, anchor, path, member);
+        }
+        case 'root':
+        case 'implicit':
+            break;
+    }
+    if (tablePath.length === 0) {
+        throw unsupported(`top-level key ${renderKeyPath(path)} is not editable`);
+    }
+    return insertSection(text, document, tablePath, [
+        `${renderKey(path.at(-1))} = ${renderedValue}`,
+    ]);
+}
+function removeLines(text, start, contentEnd) {
+    let removeStart = start;
+    const removeEnd = lineEndIncludingNewline(text, contentEnd);
+    const previous = previousLineStart(text, start);
+    const following = text.slice(removeEnd);
+    if (previous !== null &&
+        /^[ \t]*\r?\n$/.test(text.slice(previous, start)) &&
+        /^[ \t]*(?:\r?\n|$)/.test(following)) {
+        removeStart = previous;
+    }
+    return splice(text, removeStart, removeEnd, '');
+}
+function removeInlineEntry(text, entry) {
+    const table = entry.inline;
+    const index = table.entries.indexOf(entry);
+    if (table.entries.length === 1) {
+        return splice(text, table.open + 1, table.close, '');
+    }
+    const next = table.entries[index + 1];
+    if (next) {
+        return splice(text, entry.start, next.start, '');
+    }
+    return splice(text, table.entries[index - 1].valueEnd, entry.valueEnd, '');
+}
+export function removeTomlTable(text, path) {
+    let current = text;
+    for (let pass = 0; pass < MAX_EDIT_PASSES; pass++) {
+        const document = lexToml(current);
+        const section = document.sections.find((candidate) => candidate.header !== null && startsWithPath(candidate.path, path));
+        if (section) {
+            current = removeLines(current, section.header.lineStart, section.lastEnd);
+            continue;
+        }
+        const entry = document.entries.find((candidate) => startsWithPath(candidate.path, path));
+        if (!entry) {
+            return current;
+        }
+        current = entry.inline
+            ? removeInlineEntry(current, entry)
+            : removeLines(current, entry.lineStart, entry.end);
+    }
+    throw unsupported(`${renderKeyPath(path)} could not be removed`);
+}