gigarag-copilot 0.1.0

package/cli/clients/toml.js

@@ -0,0 +1,169 @@
+/**
+ * Just enough TOML to add, replace and remove one table without touching the rest
+ * of the file. It does not parse values. It finds table headers and the keys that
+ * could define our table another way, which is all a safe edit needs, and leaves
+ * every other byte exactly as it was.
+ *
+ * It refuses, and says why, when our table is written in a form it cannot edit:
+ * an inline table (`gigarag = { ... }`), a dotted key (`mcp_servers.gigarag.command
+ * = ...`), or a parent written as an inline table. Adding a `[header]` beside any of
+ * those would define the same key twice, which is invalid TOML, and the client would
+ * then fail to load its whole config.
+ */
+/** The dotted parts of a key such as `a."b c".d`, respecting quotes. Undefined if it does not parse. */
+export function splitDotted(src) {
+    const parts = [];
+    let i = 0;
+    while (i < src.length) {
+        while (src[i] === ' ' || src[i] === '\t')
+            i++;
+        if (i >= src.length)
+            break;
+        if (src[i] === '"' || src[i] === "'") {
+            const quote = src[i];
+            const end = src.indexOf(quote, i + 1);
+            if (end < 0)
+                return undefined;
+            parts.push(src.slice(i + 1, end));
+            i = end + 1;
+        }
+        else {
+            const start = i;
+            while (i < src.length && src[i] !== '.' && src[i] !== ' ' && src[i] !== '\t')
+                i++;
+            parts.push(src.slice(start, i));
+        }
+        while (src[i] === ' ' || src[i] === '\t')
+            i++;
+        if (src[i] === '.')
+            i++;
+        else if (i < src.length)
+            return undefined;
+    }
+    return parts;
+}
+/** The dotted key parts of a `[header]` line, or undefined if the line is not one. */
+export function headerParts(line) {
+    const m = /^\s*\[([^\[\]]+)\]\s*(?:#.*)?$/.exec(line);
+    return m ? splitDotted(m[1]) : undefined;
+}
+const isHeaderLine = (line) => /^\s*\[/.test(line);
+const isBlankOrComment = (line) => /^\s*(#.*)?$/.test(line);
+const startsWith = (parts, prefix) => parts.length >= prefix.length && prefix.every((p, i) => parts[i] === p);
+const same = (a, b) => a.length === b.length && a.every((p, i) => p === b[i]);
+function eolOf(text) {
+    return text.includes('\r\n') ? '\r\n' : '\n';
+}
+function render(value) {
+    if (Array.isArray(value))
+        return `[${value.map(v => JSON.stringify(v)).join(', ')}]`;
+    return typeof value === 'string' ? JSON.stringify(value) : String(value);
+}
+/** A reason our table cannot be edited safely, or undefined when it can. */
+export function unsafeForm(lines, path) {
+    let current = [];
+    for (const line of lines) {
+        if (isHeaderLine(line)) {
+            const parts = headerParts(line);
+            // An array-of-tables header, or one we could not read, is somebody else's structure.
+            current = parts ?? ['\u0000'];
+            continue;
+        }
+        if (isBlankOrComment(line))
+            continue;
+        const m = /^\s*([^=#]+?)\s*=\s*(.*)$/.exec(line);
+        if (!m)
+            continue;
+        const key = splitDotted(m[1].trim());
+        if (!key)
+            continue;
+        // Only keys in a table above ours can define ours by another route. Inside our own header they are just its keys.
+        const above = current.length < path.length && startsWith(path, current);
+        if (!above)
+            continue;
+        const full = [...current, ...key];
+        if (startsWith(full, path))
+            return `${path.join('.')} is already defined as an inline table or a dotted key`;
+        if (full.length < path.length && startsWith(path, full) && /^\{/.test(m[2].trim())) {
+            return `${full.join('.')} is written as an inline table`;
+        }
+    }
+    return undefined;
+}
+/**
+ * Where our table lives: its own block and any `[path.sub]` blocks, as line ranges. A block ends at
+ * its last line of content, so a comment or blank line before the next header stays with what follows.
+ */
+function ranges(lines, path) {
+    const found = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (!isHeaderLine(lines[i]))
+            continue;
+        const parts = headerParts(lines[i]);
+        if (!parts || !startsWith(parts, path))
+            continue;
+        let end = i + 1;
+        while (end < lines.length && !isHeaderLine(lines[end]))
+            end++;
+        while (end > i + 1 && isBlankOrComment(lines[end - 1]))
+            end--;
+        found.push({ start: i, end });
+        i = end - 1;
+    }
+    return found;
+}
+function block(path, values) {
+    const header = `[${path.map(p => (/^[A-Za-z0-9_-]+$/.test(p) ? p : JSON.stringify(p))).join('.')}]`;
+    return [header, ...Object.entries(values).map(([k, v]) => `${k} = ${render(v)}`)];
+}
+function withoutRanges(lines, rs) {
+    const drop = new Set();
+    for (const r of rs)
+        for (let i = r.start; i < r.end; i++)
+            drop.add(i);
+    return lines.filter((_, i) => !drop.has(i));
+}
+/** Drops `[path]` and every `[path.sub]` block. */
+export function removeTable(text, path) {
+    const eol = eolOf(text);
+    const lines = text.split(/\r?\n/);
+    const bad = unsafeForm(lines, path);
+    if (bad)
+        return { ok: false, reason: bad };
+    const rs = ranges(lines, path);
+    if (rs.length === 0)
+        return { ok: true, text, existed: false, changed: false };
+    const kept = withoutRanges(lines, rs);
+    // Removing a block can leave two blank lines where one block used to be. Keep one.
+    for (let i = kept.length - 1; i > 0; i--)
+        if (kept[i] === '' && kept[i - 1] === '' && i < kept.length - 1)
+            kept.splice(i, 1);
+    while (kept.length > 1 && kept[kept.length - 1] === '' && kept[kept.length - 2] === '')
+        kept.pop();
+    return { ok: true, text: kept.join(eol), existed: true, changed: true };
+}
+/**
+ * Replaces `[path]` where it is, or appends it. Replacing in place means running it twice changes
+ * nothing, and an entry in the middle of a file does not migrate to the end on every run.
+ */
+export function setTable(text, path, values) {
+    const eol = eolOf(text);
+    const lines = text.split(/\r?\n/);
+    const bad = unsafeForm(lines, path);
+    if (bad)
+        return { ok: false, reason: bad };
+    const fresh = block(path, values);
+    const rs = ranges(lines, path);
+    if (rs.length === 0) {
+        const trimmed = text.replace(/\s+$/, '');
+        const next = trimmed === '' ? `${fresh.join(eol)}${eol}` : `${trimmed}${eol}${eol}${fresh.join(eol)}${eol}`;
+        return { ok: true, text: next, existed: false, changed: next !== text };
+    }
+    const first = rs[0];
+    const out = [...lines.slice(0, first.start), ...fresh, ...lines.slice(first.end)];
+    // Any later `[path.sub]` block belonged to the entry being replaced.
+    const shift = fresh.length - (first.end - first.start);
+    const rest = rs.slice(1).map(r => ({ start: r.start + shift, end: r.end + shift }));
+    const next = withoutRanges(out, rest).join(eol);
+    return { ok: true, text: next, existed: true, changed: next !== text };
+}

package/cli/clients/tomlarray.js

@@ -0,0 +1,121 @@
+import { headerParts, splitDotted } from './toml.js';
+/**
+ * Editing one entry of a TOML array of tables, such as Mistral Vibe's
+ *
+ *   [[mcp_servers]]
+ *   name = "gigarag"
+ *   transport = "stdio"
+ *
+ * The entry is found by its `name` line, so the other `[[mcp_servers]]` blocks belong to somebody
+ * else and stay exactly as they are. A `[mcp_servers.env]` table after our block is a sub-table of
+ * that entry and travels with it. The comment or blank line before the next block does not.
+ */
+const ARRAY_HEADER = /^\s*\[\[\s*([^\[\]]+?)\s*\]\]\s*(?:#.*)?$/;
+const isHeader = (line) => /^\s*\[/.test(line);
+const isBlankOrComment = (line) => /^\s*(#.*)?$/.test(line);
+const same = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
+const startsWith = (a, p) => a.length >= p.length && p.every((x, i) => a[i] === x);
+function eolOf(text) {
+    return text.includes('\r\n') ? '\r\n' : '\n';
+}
+function render(value) {
+    if (Array.isArray(value))
+        return `[${value.map(v => JSON.stringify(v)).join(', ')}]`;
+    return typeof value === 'string' ? JSON.stringify(value) : String(value);
+}
+/** Every `[[path]]` element as a line range, sub-tables included, and whether it carries our name. */
+function elements(lines, path, name) {
+    const out = [];
+    const nameLine = new RegExp(`^\\s*name\\s*=\\s*["']${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}["']\\s*(#.*)?$`);
+    for (let i = 0; i < lines.length; i++) {
+        const m = ARRAY_HEADER.exec(lines[i]);
+        const parts = m ? splitDotted(m[1]) : undefined;
+        if (!parts || !same(parts, path))
+            continue;
+        let end = i + 1;
+        while (end < lines.length) {
+            const line = lines[end];
+            if (!isHeader(line)) {
+                end++;
+                continue;
+            }
+            // A sub-table of this element continues it. Anything else starts something new.
+            const sub = headerParts(line);
+            if (sub && sub.length > path.length && startsWith(sub, path))
+                end++;
+            else
+                break;
+        }
+        while (end > i + 1 && isBlankOrComment(lines[end - 1]))
+            end--;
+        out.push({ start: i, end, ours: lines.slice(i + 1, end).some(l => nameLine.test(l)) });
+        i = end - 1;
+    }
+    return out;
+}
+/** A reason this file cannot be edited safely, or undefined. */
+function unsafe(lines, path) {
+    const first = path[0].replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    if (lines.some(l => new RegExp(`^\\s*${first}\\s*=`).test(l)))
+        return `${path.join('.')} is written as an inline array`;
+    return undefined;
+}
+export function removeArrayEntry(text, path, name) {
+    const eol = eolOf(text);
+    const lines = text.split(/\r?\n/);
+    const bad = unsafe(lines, path);
+    if (bad)
+        return { ok: false, reason: bad };
+    const mine = elements(lines, path, name).filter(e => e.ours);
+    if (mine.length === 0)
+        return { ok: true, text, existed: false, changed: false };
+    const drop = new Set();
+    for (const e of mine) {
+        for (let i = e.start; i < e.end; i++)
+            drop.add(i);
+        // The blank line that separated this element from the one before it goes with it.
+        if (e.start > 0 && lines[e.start - 1].trim() === '')
+            drop.add(e.start - 1);
+    }
+    const kept = lines.filter((_, i) => !drop.has(i));
+    while (kept.length > 1 && kept[kept.length - 1] === '' && kept[kept.length - 2] === '')
+        kept.pop();
+    return { ok: true, text: kept.join(eol), existed: true, changed: true };
+}
+export function setArrayEntry(text, path, name, values) {
+    const eol = eolOf(text);
+    const lines = text.split(/\r?\n/);
+    const bad = unsafe(lines, path);
+    if (bad)
+        return { ok: false, reason: bad };
+    const fresh = [`[[${path.join('.')}]]`, ...Object.entries({ name, ...values }).map(([k, v]) => `${k} = ${render(v)}`)];
+    const mine = elements(lines, path, name).filter(e => e.ours);
+    if (mine.length === 0) {
+        const trimmed = text.replace(/\s+$/, '');
+        const next = trimmed === '' ? `${fresh.join(eol)}${eol}` : `${trimmed}${eol}${eol}${fresh.join(eol)}${eol}`;
+        return { ok: true, text: next, existed: false, changed: next !== text };
+    }
+    // Replace the first copy where it stands, and drop any duplicates.
+    const first = mine[0];
+    const out = [...lines.slice(0, first.start), ...fresh, ...lines.slice(first.end)];
+    const shift = fresh.length - (first.end - first.start);
+    const drop = new Set();
+    for (const e of mine.slice(1))
+        for (let i = e.start + shift; i < e.end + shift; i++)
+            drop.add(i);
+    const next = out.filter((_, i) => !drop.has(i)).join(eol);
+    return { ok: true, text: next, existed: true, changed: next !== text };
+}
+/** The command of our entry, or undefined. Used by `status` to spot a launcher that has moved. */
+export function arrayEntryCommand(text, path, name) {
+    const lines = text.split(/\r?\n/);
+    const e = elements(lines, path, name).find(x => x.ours);
+    if (!e)
+        return undefined;
+    for (const l of lines.slice(e.start + 1, e.end)) {
+        const m = /^\s*command\s*=\s*("(?:[^"\\]|\\.)*")/.exec(l);
+        if (m)
+            return JSON.parse(m[1]);
+    }
+    return undefined;
+}

package/cli/clients/yaml.js

@@ -0,0 +1,146 @@
+/**
+ * Just enough YAML to add, replace and remove one entry under a top-level mapping,
+ * such as Goose's `extensions:`, without touching any other byte of the file. Like
+ * the TOML helper it finds structure by indentation and never parses values, so
+ * comments and anchors elsewhere survive.
+ *
+ * It refuses, and says why, what it cannot edit safely: tabs, a mapping written in
+ * flow style (`extensions: {}`), a sequence written at the same indent as its key,
+ * and an entry of ours that is already written inline (`gigarag: {cmd: x}`).
+ */
+const indentOf = (line) => /^ */.exec(line)[0].length;
+const isBlankOrComment = (line) => /^\s*(#.*)?$/.test(line);
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+function eolOf(text) {
+    return text.includes('\r\n') ? '\r\n' : '\n';
+}
+function scalar(v) {
+    return typeof v === 'string' ? JSON.stringify(v) : String(v);
+}
+function flow(v) {
+    if (Array.isArray(v))
+        return `[${v.map(flow).join(', ')}]`;
+    if (typeof v === 'object') {
+        const entries = Object.entries(v);
+        return entries.length === 0 ? '{}' : `{ ${entries.map(([k, x]) => `${k}: ${flow(x)}`).join(', ')} }`;
+    }
+    return scalar(v);
+}
+/** The lines of `name:` and its mapping, indented `indent` spaces, with `step` spaces per level. */
+export function renderEntry(name, entry, indent, step = 2) {
+    const pad = ' '.repeat(indent);
+    const lines = [`${pad}${name}:`];
+    for (const [k, v] of Object.entries(entry)) {
+        // Arrays and empty maps stay on one line, which is how these files are written by hand.
+        if (typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length > 0) {
+            lines.push(...renderEntry(k, v, indent + step, step));
+        }
+        else {
+            lines.push(`${' '.repeat(indent + step)}${k}: ${flow(v)}`);
+        }
+    }
+    return lines;
+}
+/** A byte order mark would hide the first key from every pattern below, so it is set aside and put back. */
+function splitBom(text) {
+    return text.charCodeAt(0) === 0xfeff ? { bom: String.fromCharCode(0xfeff), body: text.slice(1) } : { bom: '', body: text };
+}
+function locate(lines, key) {
+    const re = new RegExp(`^${escape(key)}:\\s*(.*?)\\s*$`);
+    const keyLine = lines.findIndex(l => re.test(l));
+    if (keyLine < 0)
+        return undefined;
+    const rest = re.exec(lines[keyLine])[1];
+    if (rest !== '' && !rest.startsWith('#'))
+        return 'flow';
+    let end = keyLine + 1;
+    let childIndent = 0;
+    for (let i = keyLine + 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (isBlankOrComment(line))
+            continue;
+        // A sequence may sit at the same indent as its key, which is not a mapping we can add an entry to.
+        if (indentOf(line) === 0) {
+            if (/^-(\s|$)/.test(line) && childIndent === 0)
+                return 'sequence';
+            break;
+        }
+        if (childIndent === 0)
+            childIndent = indentOf(line);
+        end = i + 1;
+    }
+    return { keyLine, end, childIndent: childIndent || 2 };
+}
+const unsafeText = (body) => (/^\s*\t/m.test(body) ? 'it is indented with tabs, which YAML does not allow, so it is not safe to edit' : undefined);
+/** Finds our entry's line range inside the mapping, or a reason it is written in a way we will not edit. */
+function findEntry(lines, where, name) {
+    const n = escape(name);
+    const block = new RegExp(`^ {${where.childIndent}}${n}:\\s*(#.*)?$`);
+    const inline = new RegExp(`^ {${where.childIndent}}${n}:\\s*\\S`);
+    for (let i = where.keyLine + 1; i < where.end; i++) {
+        if (inline.test(lines[i]) && !block.test(lines[i]))
+            return { reason: `${name} is already written inline, which gigarag will not edit` };
+    }
+    const start = lines.findIndex((l, i) => i > where.keyLine && i < where.end && block.test(l));
+    if (start < 0)
+        return undefined;
+    let stop = start + 1;
+    while (stop < where.end && (isBlankOrComment(lines[stop]) || indentOf(lines[stop]) > where.childIndent))
+        stop++;
+    // Trailing blank or comment lines belong to whatever comes next, not to this entry.
+    while (stop > start + 1 && isBlankOrComment(lines[stop - 1]))
+        stop--;
+    return { start, stop };
+}
+/** Removes `name` from under `key`. */
+export function removeYamlEntry(text, key, name) {
+    const { bom, body } = splitBom(text);
+    const tabs = unsafeText(body);
+    if (tabs)
+        return { ok: false, reason: tabs };
+    const eol = eolOf(body);
+    const lines = body.split(/\r?\n/);
+    const where = locate(lines, key);
+    if (where === undefined)
+        return { ok: true, text, existed: false, changed: false };
+    if (where === 'flow')
+        return { ok: false, reason: `"${key}" is written in flow style, which gigarag will not edit` };
+    if (where === 'sequence')
+        return { ok: false, reason: `"${key}" is a sequence, not a mapping` };
+    const found = findEntry(lines, where, name);
+    if (!found)
+        return { ok: true, text, existed: false, changed: false };
+    if ('reason' in found)
+        return { ok: false, reason: found.reason };
+    return { ok: true, text: bom + [...lines.slice(0, found.start), ...lines.slice(found.stop)].join(eol), existed: true, changed: true };
+}
+/** Replaces `name` under `key` where it stands, or adds it at the end of the mapping. */
+export function setYamlEntry(text, key, name, entry) {
+    const { bom, body } = splitBom(text);
+    const tabs = unsafeText(body);
+    if (tabs)
+        return { ok: false, reason: tabs };
+    const eol = eolOf(body);
+    const lines = body.split(/\r?\n/);
+    const where = locate(lines, key);
+    if (where === undefined) {
+        const trimmed = body.replace(/\s+$/, '');
+        const fresh = [`${key}:`, ...renderEntry(name, entry, 2)];
+        const out = trimmed === '' ? [...fresh, ''] : [...trimmed.split(/\r?\n/), '', ...fresh, ''];
+        const next = bom + out.join(eol);
+        return { ok: true, text: next, existed: false, changed: next !== text };
+    }
+    if (where === 'flow')
+        return { ok: false, reason: `"${key}" is written in flow style, which gigarag will not edit` };
+    if (where === 'sequence')
+        return { ok: false, reason: `"${key}" is a sequence, not a mapping` };
+    const found = findEntry(lines, where, name);
+    if (found && 'reason' in found)
+        return { ok: false, reason: found.reason };
+    const fresh = renderEntry(name, entry, where.childIndent);
+    const out = found
+        ? [...lines.slice(0, found.start), ...fresh, ...lines.slice(found.stop)]
+        : [...lines.slice(0, where.end), ...fresh, ...lines.slice(where.end)];
+    const next = bom + out.join(eol);
+    return { ok: true, text: next, existed: found !== undefined, changed: next !== text };
+}