@ikarmic/forge-core 5.2.0 → 5.4.0

package/dist/tools/glob-filter.js

@@ -0,0 +1,12 @@
+import { globToRegex } from './policy.js';
+/**
+ * A file-name filter for tools that take a glob from the model (`search_files` include, `list_files` pattern).
+ * A slash-less glob such as "*.ts" names files at any depth, as in ripgrep -g; a glob with a slash is matched
+ * against the path relative to the searched directory. Do not use `globToRegex` directly for this: it anchors a
+ * slash-less pattern to the top level on purpose, for permission rules (RB-64).
+ */
+export function fileGlobMatcher(glob) {
+    const re = globToRegex(glob);
+    const byPath = glob.includes('/');
+    return (rel, name) => re.test(byPath ? rel : name);
+}

package/dist/tools/html-to-markdown.d.ts

@@ -0,0 +1,13 @@
+/**
+ * HTML to Markdown for `fetch_url` (G19). The old converter replaced every tag with a space, so a page became one long line:
+ * no headings, no link targets, no list or code structure. This keeps what a model needs to read documentation.
+ *
+ * It is one linear scan with no parser dependency and no regex that can backtrack over the page: the input is text a stranger
+ * wrote and it runs on the host's only thread (RB-22). Output is read by a model, so it is conservative about what a page can
+ * make appear in it (RB-81): only http, https and mailto link targets, images as their description only, hidden elements dropped, and a code
+ * fence longer than any backtick run inside it, so page text cannot close the fence early.
+ */
+/** Decode HTML entities in one pass, so `&amp;lt;` stays `&lt;` instead of becoming `<`. */
+export declare function decodeEntities(s: string): string;
+/** Convert a page. Only the main content is kept when the page marks one and it holds real text; otherwise the whole page. */
+export declare function htmlToMarkdown(html: string, baseUrl?: string): string;

package/dist/tools/html-to-markdown.js

@@ -0,0 +1,507 @@
+/**
+ * HTML to Markdown for `fetch_url` (G19). The old converter replaced every tag with a space, so a page became one long line:
+ * no headings, no link targets, no list or code structure. This keeps what a model needs to read documentation.
+ *
+ * It is one linear scan with no parser dependency and no regex that can backtrack over the page: the input is text a stranger
+ * wrote and it runs on the host's only thread (RB-22). Output is read by a model, so it is conservative about what a page can
+ * make appear in it (RB-81): only http, https and mailto link targets, images as their description only, hidden elements dropped, and a code
+ * fence longer than any backtick run inside it, so page text cannot close the fence early.
+ */
+const NAMED = {
+    amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ', hellip: '…', mdash: '—', ndash: '–', lsquo: '‘', rsquo: '’',
+    ldquo: '“', rdquo: '”', copy: '©', reg: '®', trade: '™', middot: '·', bull: '•', laquo: '«', raquo: '»', times: '×',
+    larr: '←', rarr: '→', euro: '€', pound: '£', deg: '°',
+};
+/** Decode HTML entities in one pass, so `&amp;lt;` stays `&lt;` instead of becoming `<`. */
+export function decodeEntities(s) {
+    if (!s.includes('&'))
+        return s;
+    return s.replace(/&(#[xX][0-9a-fA-F]{1,6}|#[0-9]{1,7}|[a-zA-Z]{2,8});/g, (whole, e) => {
+        if (e.charAt(0) === '#') {
+            const cp = e.charAt(1).toLowerCase() === 'x' ? parseInt(e.slice(2), 16) : parseInt(e.slice(1), 10);
+            const ok = cp === 9 || cp === 10 || cp === 13 || (cp >= 0x20 && cp <= 0x10ffff && !(cp >= 0x7f && cp <= 0x9f) && !(cp >= 0xd800 && cp <= 0xdfff));
+            return ok ? String.fromCodePoint(cp) : ' ';
+        }
+        return NAMED[e.toLowerCase()] ?? whole;
+    });
+}
+const BLOCK = new Set([
+    'p', 'div', 'section', 'article', 'header', 'main', 'aside', 'figure', 'figcaption', 'form', 'fieldset',
+    'address', 'details', 'summary', 'dl', 'dt', 'dd', 'center', 'hgroup', 'body', 'html', 'table', 'caption',
+]);
+const SKIPPED = new Set(['head', 'title', 'noscript', 'svg', 'template', 'iframe', 'canvas', 'object', 'nav', 'footer']);
+const VOID = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
+const EMPHASIS = { b: '**', strong: '**', i: '*', em: '*', del: '~~', s: '~~', strike: '~~' };
+const CODE = new Set(['code', 'kbd', 'samp', 'tt']);
+/** Value of an attribute in the text of one tag, or undefined. */
+function attr(tag, name) {
+    if (!tag.toLowerCase().includes(name))
+        return undefined;
+    const m = new RegExp(`(?:^|\\s)${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'>]+))`, 'i').exec(tag);
+    if (!m)
+        return undefined;
+    return decodeEntities(m[1] ?? m[2] ?? m[3] ?? '');
+}
+function isHidden(tag) {
+    const lower = tag.toLowerCase();
+    if (lower.includes('role') && /^(?:navigation|contentinfo)$/.test(attr(tag, 'role')?.trim().toLowerCase() ?? ''))
+        return true;
+    if (!lower.includes('hidden') && !lower.includes('display'))
+        return false;
+    if (/(?:^|\s)hidden(?=[\s=/]|$)/.test(lower))
+        return true;
+    if (attr(tag, 'aria-hidden')?.trim().toLowerCase() === 'true')
+        return true;
+    const style = attr(tag, 'style')?.toLowerCase() ?? '';
+    return /display\s*:\s*none|visibility\s*:\s*hidden/.test(style);
+}
+/** Length of the longest run of backticks in `s` (a loop, not a spread: a page can hold hundreds of thousands of runs). */
+function longestBacktickRun(s) {
+    let longest = 0;
+    let run = 0;
+    for (let k = 0; k < s.length; k++) {
+        run = s.charAt(k) === '`' ? run + 1 : 0;
+        if (run > longest)
+            longest = run;
+    }
+    return longest;
+}
+const MAX_OPEN_MARKS = 64;
+const MAX_LIST_INDENT = 8;
+function escapeTarget(s) {
+    return s.replace(/ /g, '%20').replace(/\(/g, '%28').replace(/\)/g, '%29').replace(/</g, '%3C').replace(/>/g, '%3E');
+}
+/** A link target worth showing, or undefined: only http, https and mailto; never script or data. */
+function safeTarget(raw, base) {
+    const value = raw?.trim();
+    if (!value || value.startsWith('#'))
+        return undefined;
+    let url;
+    try {
+        url = base ? new URL(value, base) : new URL(value);
+    }
+    catch {
+        // A relative address with nothing to resolve it against stays as written; anything with a scheme we cannot read is dropped.
+        return /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(value) ? undefined : escapeTarget(value);
+    }
+    const ok = url.protocol === 'http:' || url.protocol === 'https:' || url.protocol === 'mailto:';
+    return ok ? escapeTarget(url.href) : undefined;
+}
+/** The index of the `>` that ends the tag starting after `from`, honouring quoted attribute values; -1 if there is none. */
+function findTagEnd(html, from) {
+    let prevSignificant = '';
+    for (let j = from; j < html.length; j++) {
+        const c = html.charAt(j);
+        if (c === '>')
+            return j;
+        if ((c === '"' || c === "'") && prevSignificant === '=') {
+            const close = html.indexOf(c, j + 1);
+            if (close === -1)
+                return -1;
+            j = close;
+            prevSignificant = c;
+            continue;
+        }
+        if (c !== ' ' && c !== '\t' && c !== '\n' && c !== '\r')
+            prevSignificant = c;
+    }
+    return -1;
+}
+const MIN_MAIN_CHARS = 200;
+/** The page's main content (`<main>`, else `<article>`), or undefined: the menus and footers around it are not wanted. */
+function contentRegion(html) {
+    const lower = html.toLowerCase();
+    for (const tag of ['main', 'article']) {
+        let start = lower.indexOf(`<${tag}`);
+        while (start !== -1 && !/[\s>/]/.test(lower.charAt(start + tag.length + 1)))
+            start = lower.indexOf(`<${tag}`, start + 1);
+        if (start === -1)
+            continue;
+        const close = lower.lastIndexOf(`</${tag}`);
+        const stop = close > start ? html.indexOf('>', close) + 1 : 0;
+        return html.slice(start, stop > 0 ? stop : html.length);
+    }
+    return undefined;
+}
+/** Convert a page. Only the main content is kept when the page marks one and it holds real text; otherwise the whole page. */
+export function htmlToMarkdown(html, baseUrl) {
+    const region = contentRegion(html);
+    if (region) {
+        const inner = convert(region, baseUrl);
+        if (inner.length >= MIN_MAIN_CHARS)
+            return inner;
+    }
+    return convert(html, baseUrl);
+}
+function convert(html, baseUrl) {
+    const lower = html.toLowerCase();
+    const parts = [];
+    let trailingNl = 0;
+    let spaceOk = false; // may a separating space go before the next word
+    let pending = false; // whitespace was seen since the last word
+    const stack = [];
+    const lists = [];
+    let skipTag = '';
+    let skipDepth = 0;
+    let pre;
+    let tableDepth = 0;
+    let rowCells;
+    let rowsDone = 0;
+    let cell;
+    const note = (s) => {
+        let k = s.length;
+        while (k > 0 && s.charAt(k - 1) === '\n')
+            k--;
+        trailingNl = k === 0 ? trailingNl + s.length : s.length - k;
+        spaceOk = !/\s$/.test(s.slice(-1));
+    };
+    const put = (s) => {
+        if (!s)
+            return;
+        parts.push(s);
+        note(s);
+        pending = false;
+    };
+    const mark = (tag, extra = {}) => ({ tag, at: parts.length, nl: trailingNl, ok: spaceOk, ...extra });
+    /** Take back everything written since `m` and write `replacement` in its place, keeping the pending-space state. */
+    const replaceFrom = (m, replacement) => {
+        const inner = parts.splice(m.at).join('');
+        trailingNl = m.nl;
+        spaceOk = m.ok;
+        if (replacement) {
+            parts.push(replacement);
+            note(replacement);
+        }
+        return inner;
+    };
+    const block = () => {
+        if (parts.length === 0)
+            return;
+        pending = false;
+        if (trailingNl < 2)
+            put('\n'.repeat(2 - trailingNl));
+    };
+    const newline = () => {
+        if (parts.length === 0)
+            return;
+        pending = false;
+        if (trailingNl < 1)
+            put('\n');
+    };
+    const text = (raw) => {
+        if (skipDepth > 0 || !raw)
+            return;
+        if (pre) {
+            put(decodeEntities(raw).replace(/\r\n?/g, '\n').replace(/ /g, ' '));
+            return;
+        }
+        const t = decodeEntities(raw).replace(/\s+/g, ' ');
+        if (t === ' ') {
+            if (spaceOk)
+                pending = true;
+            return;
+        }
+        const core = t.trim();
+        if ((t.startsWith(' ') || pending) && spaceOk)
+            put(' ');
+        put(core);
+        pending = t.endsWith(' ');
+    };
+    const wrap = (inner, marker) => {
+        const core = inner.trim();
+        if (!core)
+            return inner;
+        const lead = inner.slice(0, inner.length - inner.trimStart().length);
+        const trail = inner.slice(inner.trimEnd().length);
+        return lead + marker + core + marker + trail;
+    };
+    const closeCell = () => {
+        if (!cell || !rowCells)
+            return;
+        const raw = replaceFrom(cell, '');
+        rowCells.push(raw.replace(/\s+/g, ' ').trim().replace(/\|/g, '\\|'));
+        cell = undefined;
+    };
+    const closeRow = () => {
+        closeCell();
+        if (rowCells && rowCells.length > 0) {
+            put(`| ${rowCells.join(' | ')} |\n`);
+            if (rowsDone === 0)
+                put(`| ${rowCells.map(() => '---').join(' | ')} |\n`);
+            rowsDone++;
+        }
+        rowCells = undefined;
+    };
+    const closeInline = (tag) => {
+        let idx = -1;
+        for (let k = stack.length - 1; k >= 0; k--) {
+            if (stack[k].tag === tag) {
+                idx = k;
+                break;
+            }
+        }
+        if (idx === -1)
+            return;
+        const m = stack[idx];
+        stack.length = idx;
+        finishMark(m);
+    };
+    const finishMark = (m) => {
+        if (m.tag === 'blockquote') {
+            const inner = replaceFrom(m, '').trim();
+            if (inner)
+                put(inner.split('\n').map((l) => (l ? `> ${l}` : '>')).join('\n'));
+            block();
+        }
+        else if (m.tag === 'a') {
+            const inner = replaceFrom(m, '');
+            const label = inner.replace(/\s+/g, ' ');
+            if (m.drop || !label.trim())
+                return;
+            parts.push(m.href ? wrapLink(label, m.href) : label);
+            note(m.href ? wrapLink(label, m.href) : label);
+        }
+        else if (m.tag === 'code') {
+            const inner = replaceFrom(m, '').replace(/\s+/g, ' ');
+            if (!inner.trim())
+                return;
+            const fence = '`'.repeat(longestBacktickRun(inner) + 1);
+            const body = inner.trim();
+            const padded = body.startsWith('`') || body.endsWith('`') ? ` ${body} ` : body;
+            const out = fence + padded + fence;
+            const wrapped = (inner.startsWith(' ') ? ' ' : '') + out + (inner.endsWith(' ') ? ' ' : '');
+            parts.push(wrapped);
+            note(wrapped);
+        }
+        else {
+            const marker = EMPHASIS[m.tag];
+            const inner = replaceFrom(m, '');
+            if (!inner)
+                return;
+            const out = marker ? wrap(inner.replace(/\s+/g, ' '), marker) : inner;
+            parts.push(out);
+            note(out);
+        }
+    };
+    const wrapLink = (label, href) => {
+        const core = label.trim();
+        const lead = label.startsWith(' ') ? ' ' : '';
+        const trail = label.endsWith(' ') ? ' ' : '';
+        return `${lead}[${core}](${href})${trail}`;
+    };
+    const endPre = () => {
+        if (!pre)
+            return;
+        const raw = parts.splice(pre.at).join('');
+        const lang = pre.lang;
+        trailingNl = pre.nl;
+        spaceOk = false;
+        pre = undefined;
+        const code = raw.replace(/^\n+/, '').replace(/\s+$/, '');
+        const fence = '`'.repeat(Math.max(2, longestBacktickRun(code)) + 1);
+        block();
+        put(`${fence}${lang}\n${code}\n${fence}`);
+        block();
+    };
+    let i = 0;
+    const n = html.length;
+    while (i < n) {
+        const lt = html.indexOf('<', i);
+        if (lt === -1) {
+            text(html.slice(i));
+            break;
+        }
+        if (lt > i)
+            text(html.slice(i, lt));
+        if (html.startsWith('<!--', lt)) {
+            const e = html.indexOf('-->', lt + 4);
+            i = e === -1 ? n : e + 3;
+            continue;
+        }
+        const first = html.charAt(lt + 1);
+        if (first === '!' || first === '?') {
+            const e = html.indexOf('>', lt);
+            i = e === -1 ? n : e + 1;
+            continue;
+        }
+        if (!/[a-zA-Z/]/.test(first) || (first === '/' && !/[a-zA-Z]/.test(html.charAt(lt + 2)))) {
+            text('<');
+            i = lt + 1;
+            continue;
+        }
+        const end = findTagEnd(html, lt + 1);
+        if (end === -1)
+            break; // a tag cut off by the end of the page: drop it rather than show its attributes
+        const rawTag = html.slice(lt + 1, end);
+        i = end + 1;
+        const closing = rawTag.charAt(0) === '/';
+        const nameMatch = /^\/?([a-zA-Z][a-zA-Z0-9:-]*)/.exec(rawTag);
+        if (!nameMatch)
+            continue;
+        const name = nameMatch[1].toLowerCase();
+        const selfClosing = rawTag.endsWith('/') || VOID.has(name);
+        // The inside of a script or style is not markup, so jump to its end tag before anything else.
+        if (!closing && (name === 'script' || name === 'style')) {
+            const e = lower.indexOf(`</${name}`, end + 1);
+            const gt = e === -1 ? -1 : html.indexOf('>', e);
+            i = gt === -1 ? n : gt + 1;
+            continue;
+        }
+        if (skipDepth > 0) {
+            if (name === skipTag && !selfClosing)
+                skipDepth += closing ? -1 : 1;
+            if (skipDepth === 0)
+                skipTag = '';
+            continue;
+        }
+        if (!closing && !selfClosing && (SKIPPED.has(name) || isHidden(rawTag))) {
+            skipTag = name;
+            skipDepth = 1;
+            continue;
+        }
+        if (!closing && selfClosing && isHidden(rawTag))
+            continue;
+        if (pre && name !== 'pre') {
+            if (name === 'br')
+                put('\n');
+            else if (name === 'code' && !closing && !pre.lang)
+                pre.lang = /language-([\w+#.-]+)/.exec(attr(rawTag, 'class') ?? '')?.[1] ?? '';
+            continue;
+        }
+        if (closing) {
+            if (name === 'pre')
+                endPre();
+            else if (/^h[1-6]$/.test(name) || BLOCK.has(name))
+                block();
+            else if (name === 'ul' || name === 'ol') {
+                lists.pop();
+                if (lists.length === 0)
+                    block();
+                else
+                    newline();
+            }
+            else if (name === 'li')
+                newline();
+            else if (name === 'blockquote')
+                closeInline('blockquote');
+            else if (name === 'a')
+                closeInline('a');
+            else if (CODE.has(name))
+                closeInline('code');
+            else if (EMPHASIS[name])
+                closeInline(name);
+            else if (name === 'td' || name === 'th') {
+                if (tableDepth === 1)
+                    closeCell();
+                else
+                    put(' ');
+            }
+            else if (name === 'tr') {
+                if (tableDepth === 1)
+                    closeRow();
+            }
+            else if (name === 'table') {
+                if (tableDepth === 1)
+                    closeRow();
+                tableDepth = Math.max(0, tableDepth - 1);
+                if (tableDepth === 0) {
+                    rowsDone = 0;
+                    block();
+                }
+            }
+            continue;
+        }
+        // Opening (or void) tags.
+        if (/^h[1-6]$/.test(name)) {
+            block();
+            put(`${'#'.repeat(Number(name.charAt(1)))} `);
+        }
+        else if (name === 'pre') {
+            block();
+            pre = { at: parts.length, nl: trailingNl, lang: /language-([\w+#.-]+)/.exec(attr(rawTag, 'class') ?? '')?.[1] ?? '' };
+        }
+        else if (name === 'br') {
+            if (parts.length > 0)
+                put('\n');
+        }
+        else if (name === 'hr') {
+            block();
+            put('---');
+            block();
+        }
+        else if (name === 'ul' || name === 'ol') {
+            if (lists.length === 0)
+                block();
+            else
+                newline();
+            const start = parseInt(attr(rawTag, 'start') ?? '1', 10);
+            lists.push({ ordered: name === 'ol', n: Number.isFinite(start) ? start : 1 });
+        }
+        else if (name === 'li') {
+            newline();
+            const top = lists[lists.length - 1];
+            const marker = top?.ordered ? `${top.n++}. ` : '- ';
+            put('  '.repeat(Math.min(MAX_LIST_INDENT, Math.max(0, lists.length - 1))) + marker);
+        }
+        else if (name === 'blockquote') {
+            block();
+            if (stack.length < MAX_OPEN_MARKS)
+                stack.push(mark('blockquote'));
+        }
+        else if (name === 'a') {
+            // A link with both hreflang and lang is a language switcher (Wikipedia lists hundreds): page furniture, not content.
+            const drop = attr(rawTag, 'hreflang') !== undefined && attr(rawTag, 'lang') !== undefined;
+            if (stack.length < MAX_OPEN_MARKS)
+                stack.push(mark('a', { href: safeTarget(attr(rawTag, 'href'), baseUrl), drop }));
+        }
+        else if (CODE.has(name)) {
+            if (stack.length < MAX_OPEN_MARKS)
+                stack.push(mark('code'));
+        }
+        else if (EMPHASIS[name]) {
+            if (stack.length < MAX_OPEN_MARKS)
+                stack.push(mark(name));
+        }
+        else if (name === 'img') {
+            const alt = (attr(rawTag, 'alt') ?? '').replace(/\s+/g, ' ').trim();
+            if (alt)
+                text(` ${alt} `);
+        }
+        else if (name === 'table') {
+            if (tableDepth === 0)
+                block();
+            tableDepth++;
+        }
+        else if (name === 'tr') {
+            if (tableDepth === 1) {
+                closeRow();
+                rowCells = [];
+            }
+        }
+        else if (name === 'td' || name === 'th') {
+            if (tableDepth === 1) {
+                if (!rowCells)
+                    rowCells = [];
+                closeCell();
+                cell = mark('cell');
+            }
+            else
+                put(' ');
+        }
+        else if (BLOCK.has(name)) {
+            block();
+        }
+    }
+    // The page ended with things open: close them so their text is not lost or left half-marked.
+    endPre();
+    if (tableDepth > 0)
+        closeRow();
+    while (stack.length > 0)
+        finishMark(stack.pop());
+    return parts
+        .join('')
+        .replace(/^[ \t]*(?:-|\d+\.)[ \t]*$/gm, '') // a list item that ended up empty
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}

package/dist/tools/index.d.ts

@@ -1,9 +1,11 @@
 import { applyPatchTool } from './apply-patch.js';
+import { bgReadTool, bgStartTool, bgStopTool } from './background-process.js';
 import { editFileTool } from './edit-file.js';
 import { fetchUrlTool } from './fetch-url.js';
 import { findReferencesTool } from './find-references.js';
 import { findSymbolTool } from './find-symbol.js';
 import { dependencyAuditTool } from './dependency-audit.js';
+import { getDiagnosticsTool } from './get-diagnostics.js';
 import { gitDiffTool } from './git-diff.js';
 import { listFilesTool } from './list-files.js';
 import { listSymbolsTool } from './list-symbols.js';
@@ -11,10 +13,12 @@ import { memoryForgetTool, memoryReadTool, memoryWriteTool } from './memory.js';
 import { editNotebookTool } from './notebook.js';
 import { readFileTool } from './read-file.js';
 import { readImageTool } from './read-image.js';
+import { repoCloneTool } from './repo-clone.js';
 import { runCommandTool } from './run-command.js';
 import { searchFilesTool } from './search-files.js';
 import { askUserTool } from './ask-user.js';
 import { subAgentTool } from './sub-agent.js';
+import { suggestPlanTool } from './suggest-plan.js';
 import { subAgentWaitTool } from './sub-agent-wait.js';
 import { todoReadTool, todoWriteTool } from './todo.js';
 import { writeFileTool } from './write-file.js';
@@ -32,7 +36,7 @@ type AnyToolDefinition = ToolDefinition<any, any>;
  * intentional: the model sees this order in its tool list.
  */
 export declare const BUILTIN_TOOLS: readonly AnyToolDefinition[];
-export { applyPatchTool, askUserTool, dependencyAuditTool, editFileTool, editNotebookTool, fetchUrlTool, findReferencesTool, findSymbolTool, gitDiffTool, listFilesTool, listSymbolsTool, memoryForgetTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, runCommandTool, searchFilesTool, subAgentTool, subAgentWaitTool, todoReadTool, todoWriteTool, writeFileTool, };
+export { applyPatchTool, askUserTool, bgReadTool, bgStartTool, bgStopTool, dependencyAuditTool, editFileTool, editNotebookTool, fetchUrlTool, findReferencesTool, findSymbolTool, getDiagnosticsTool, gitDiffTool, listFilesTool, listSymbolsTool, memoryForgetTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, repoCloneTool, runCommandTool, searchFilesTool, subAgentTool, subAgentWaitTool, suggestPlanTool, todoReadTool, todoWriteTool, writeFileTool, };
 export type { ToolContext, ToolDefinition, ToolPolicy, ToolSandbox } from '../types.js';
 export { checkPolicyViolation, globToRegex, mergeToolSandbox, normalizePathPattern, pathMatchesAny } from './policy.js';
 export { redact, countRedactions, buildRules } from './redact.js';

package/dist/tools/index.js

@@ -1,9 +1,11 @@
 import { applyPatchTool } from './apply-patch.js';
+import { bgReadTool, bgStartTool, bgStopTool } from './background-process.js';
 import { editFileTool } from './edit-file.js';
 import { fetchUrlTool } from './fetch-url.js';
 import { findReferencesTool } from './find-references.js';
 import { findSymbolTool } from './find-symbol.js';
 import { dependencyAuditTool } from './dependency-audit.js';
+import { getDiagnosticsTool } from './get-diagnostics.js';
 import { gitDiffTool } from './git-diff.js';
 import { listFilesTool } from './list-files.js';
 import { listSymbolsTool } from './list-symbols.js';
@@ -11,10 +13,12 @@ import { memoryForgetTool, memoryReadTool, memoryWriteTool } from './memory.js';
 import { editNotebookTool } from './notebook.js';
 import { readFileTool } from './read-file.js';
 import { readImageTool } from './read-image.js';
+import { repoCloneTool } from './repo-clone.js';
 import { runCommandTool } from './run-command.js';
 import { searchFilesTool } from './search-files.js';
 import { askUserTool } from './ask-user.js';
 import { subAgentTool } from './sub-agent.js';
+import { suggestPlanTool } from './suggest-plan.js';
 import { subAgentWaitTool } from './sub-agent-wait.js';
 import { todoReadTool, todoWriteTool } from './todo.js';
 import { writeFileTool } from './write-file.js';
@@ -34,12 +38,17 @@ export const BUILTIN_TOOLS = [
     findReferencesTool,
     gitDiffTool,
     dependencyAuditTool,
+    getDiagnosticsTool,
     writeFileTool,
     editFileTool,
     applyPatchTool,
     editNotebookTool,
     runCommandTool,
+    bgStartTool,
+    bgReadTool,
+    bgStopTool,
     fetchUrlTool,
+    repoCloneTool,
     memoryReadTool,
     memoryWriteTool,
     memoryForgetTool,
@@ -48,8 +57,9 @@ export const BUILTIN_TOOLS = [
     todoWriteTool,
     todoReadTool,
     askUserTool,
+    suggestPlanTool,
 ];
-export { applyPatchTool, askUserTool, dependencyAuditTool, editFileTool, editNotebookTool, fetchUrlTool, findReferencesTool, findSymbolTool, gitDiffTool, listFilesTool, listSymbolsTool, memoryForgetTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, runCommandTool, searchFilesTool, subAgentTool, subAgentWaitTool, todoReadTool, todoWriteTool, writeFileTool, };
+export { applyPatchTool, askUserTool, bgReadTool, bgStartTool, bgStopTool, dependencyAuditTool, editFileTool, editNotebookTool, fetchUrlTool, findReferencesTool, findSymbolTool, getDiagnosticsTool, gitDiffTool, listFilesTool, listSymbolsTool, memoryForgetTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, repoCloneTool, runCommandTool, searchFilesTool, subAgentTool, subAgentWaitTool, suggestPlanTool, todoReadTool, todoWriteTool, writeFileTool, };
 export { checkPolicyViolation, globToRegex, mergeToolSandbox, normalizePathPattern, pathMatchesAny } from './policy.js';
 export { redact, countRedactions, buildRules } from './redact.js';
 export { ToolResultCache, buildCacheKey, cachedExecute } from './result-cache.js';

package/dist/tools/list-files.d.ts

@@ -5,6 +5,7 @@ declare const params: z.ZodObject<{
     max_entries: z.ZodOptional<z.ZodNumber>;
     include_hidden: z.ZodOptional<z.ZodBoolean>;
     include_ignored: z.ZodOptional<z.ZodBoolean>;
+    pattern: z.ZodOptional<z.ZodString>;
     recursive: z.ZodOptional<z.ZodBoolean>;
     max_depth: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;