tokenmaw 0.3.0

package/dist/markdown.js

@@ -0,0 +1,274 @@
+/**
+ * markdown.ts — Lightweight terminal markdown renderer.
+ *
+ * Exported so it can be unit-tested independently of the TUI.
+ * No external dependencies — pure string transformation.
+ */
+import chalk from 'chalk';
+const MARKDOWN_THEME = {
+    text: '#d7e0ea',
+    muted: '#7f92a6',
+    accent: '#6fb1d6',
+    accentStrong: '#8ac3e6',
+    codeBg: '#16212d',
+    codeText: '#c7d7e6',
+    codeFence: '#5f7388',
+    codeGreen: '#8ebd93',
+    codeRed: '#c97c7c',
+};
+function isDiffLanguage(lang) {
+    return lang.toLowerCase() === 'diff' || lang.toLowerCase() === 'patch';
+}
+export function diffKind(line) {
+    if (/^(diff --git|index |--- |\+\+\+ )/.test(line))
+        return 'file';
+    if (line.startsWith('@@'))
+        return 'hunk';
+    if (line.startsWith('+') && !line.startsWith('+++'))
+        return 'add';
+    if (line.startsWith('-') && !line.startsWith('---'))
+        return 'del';
+    return 'context';
+}
+export function renderDiffLine(line) {
+    switch (diffKind(line)) {
+        case 'add':
+            return chalk.hex(MARKDOWN_THEME.codeGreen)(line);
+        case 'del':
+            return chalk.hex(MARKDOWN_THEME.codeRed)(line);
+        case 'hunk':
+            return chalk.hex(MARKDOWN_THEME.accent)(line);
+        case 'file':
+            return chalk.bold.hex(MARKDOWN_THEME.text)(line);
+        case 'context':
+        default:
+            return chalk.hex(MARKDOWN_THEME.muted)(line);
+    }
+}
+function renderCodeLine(lang, line) {
+    return isDiffLanguage(lang) ? renderDiffLine(line) : chalk.hex(MARKDOWN_THEME.codeText)(line);
+}
+const ANSI_PATTERN = /\x1b\[[0-9;]*[A-Za-z]/g;
+/** Display width ignoring ANSI escapes, counting East-Asian wide chars as 2 columns. */
+export function displayWidth(text) {
+    const clean = text.replace(ANSI_PATTERN, '');
+    let width = 0;
+    for (const ch of clean) {
+        const code = ch.codePointAt(0);
+        const wide = (code >= 0x1100 && code <= 0x115F)
+            || (code >= 0x2E80 && code <= 0x303E)
+            || (code >= 0x3130 && code <= 0x4DBF)
+            || (code >= 0x4E00 && code <= 0x9FFF)
+            || (code >= 0xA000 && code <= 0xA4CF)
+            || (code >= 0xAC00 && code <= 0xD7A3)
+            || (code >= 0xF900 && code <= 0xFAFF)
+            || (code >= 0xFE30 && code <= 0xFE4F)
+            || (code >= 0xFF00 && code <= 0xFF60)
+            || (code >= 0xFFE0 && code <= 0xFFE6)
+            || (code >= 0x1F300 && code <= 0x1FAFF)
+            || (code >= 0x20000 && code <= 0x3FFFD);
+        width += wide ? 2 : 1;
+    }
+    return width;
+}
+function splitCells(line) {
+    let trimmed = line.trim();
+    if (trimmed.startsWith('|'))
+        trimmed = trimmed.slice(1);
+    if (trimmed.endsWith('|') && !trimmed.endsWith('\\|'))
+        trimmed = trimmed.slice(0, -1);
+    return trimmed
+        .split(/(?<!\\)\|/)
+        .map((cell) => cell.trim().replace(/\\\|/g, '|'));
+}
+function delimiterCells(line) {
+    const trimmed = line.trim();
+    if (!trimmed.includes('|'))
+        return null;
+    const cells = splitCells(trimmed);
+    if (!cells.length || !cells.every((cell) => /^:?-+:?$/.test(cell)))
+        return null;
+    return cells;
+}
+/** Match a GFM pipe table starting at lines[start]. Returns null when absent. */
+export function matchGfmTable(lines, start) {
+    const headerLine = lines[start];
+    const delimiterLine = lines[start + 1];
+    if (!headerLine || !delimiterLine)
+        return null;
+    if (!headerLine.includes('|'))
+        return null;
+    const alignCells = delimiterCells(delimiterLine);
+    if (!alignCells)
+        return null;
+    const header = splitCells(headerLine);
+    if (header.length !== alignCells.length)
+        return null;
+    const aligns = alignCells.map((cell) => (cell.startsWith(':') && cell.endsWith(':') ? 'center' : cell.endsWith(':') ? 'right' : 'left'));
+    const rows = [];
+    let end = start + 2;
+    while (end < lines.length) {
+        const line = lines[end];
+        if (!line.includes('|') || !line.trim() || /^```/.test(line) || /^#{1,6} /.test(line))
+            break;
+        const cells = splitCells(line);
+        while (cells.length < header.length)
+            cells.push('');
+        rows.push(cells.slice(0, header.length));
+        end += 1;
+    }
+    return { table: { header, aligns, rows }, end };
+}
+function truncateToWidth(text, maxWidth) {
+    if (displayWidth(text) <= maxWidth)
+        return text;
+    let out = '';
+    let width = 0;
+    for (const ch of text) {
+        const w = displayWidth(ch);
+        if (width + w > maxWidth - 1)
+            break;
+        out += ch;
+        width += w;
+    }
+    return `${out}…`;
+}
+/** Render a parsed table as aligned monospace lines that fit within maxWidth columns. */
+export function renderGfmTable(table, maxWidth) {
+    const columns = table.header.length;
+    const gap = ' │ ';
+    const gapWidth = displayWidth(gap);
+    const minWidth = 4;
+    const widths = table.header.map((cell, index) => Math.max(displayWidth(cell), ...table.rows.map((row) => displayWidth(row[index] ?? '')), minWidth));
+    const totalWidth = () => widths.reduce((sum, width) => sum + width, 0) + gapWidth * (columns - 1);
+    if (totalWidth() > maxWidth) {
+        const shrinkable = widths.map((_, index) => index).filter((index) => widths[index] > minWidth);
+        shrinkable.sort((a, b) => widths[b] - widths[a]);
+        let overflow = totalWidth() - maxWidth;
+        for (const index of shrinkable) {
+            if (overflow <= 0)
+                break;
+            const reduce = Math.min(overflow, widths[index] - minWidth);
+            widths[index] = widths[index] - reduce;
+            overflow -= reduce;
+        }
+    }
+    const padCell = (rendered, width, align) => {
+        const padding = Math.max(0, width - displayWidth(rendered));
+        if (align === 'right')
+            return ' '.repeat(padding) + rendered;
+        if (align === 'center') {
+            const left = Math.floor(padding / 2);
+            return ' '.repeat(left) + rendered + ' '.repeat(padding - left);
+        }
+        return rendered + ' '.repeat(padding);
+    };
+    const renderRow = (cells, style) => cells
+        .map((cell, index) => {
+        const width = widths[index];
+        const plain = displayWidth(cell) > width ? truncateToWidth(cell, width) : cell;
+        return padCell(style(plain), width, table.aligns[index]);
+    })
+        .join(chalk.hex(MARKDOWN_THEME.muted)(gap));
+    const header = renderRow(table.header, (cell) => chalk.bold.hex(MARKDOWN_THEME.accent)(inlineMarkdown(cell)));
+    // One uniform border color for every structural character (│, ─, ┼).
+    const separator = chalk.hex(MARKDOWN_THEME.muted)(widths.map((width) => '─'.repeat(width)).join('─┼─'));
+    const body = table.rows.map((row) => renderRow(row, (cell) => inlineMarkdown(cell)));
+    return [header, chalk.hex(MARKDOWN_THEME.muted)(separator), ...body];
+}
+export function inlineMarkdown(text) {
+    return text
+        .replace(/\*\*\*(.+?)\*\*\*/g, (_m, t) => chalk.bold.italic(t))
+        .replace(/\*\*(.+?)\*\*/g, (_m, t) => chalk.bold(t))
+        .replace(/__(.+?)__/g, (_m, t) => chalk.bold(t))
+        .replace(/\*(.+?)\*/g, (_m, t) => chalk.italic(t))
+        .replace(/_(.+?)_/g, (_m, t) => chalk.italic(t))
+        .replace(/`([^`]+)`/g, (_m, t) => chalk.bgHex(MARKDOWN_THEME.codeBg).hex(MARKDOWN_THEME.codeText)(` ${t} `))
+        .replace(/~~(.+?)~~/g, (_m, t) => chalk.strikethrough(t));
+}
+export function renderMarkdown(text, cols = 80) {
+    const lines = text.split('\n');
+    const out = [];
+    let inCodeBlock = false;
+    let codeLang = '';
+    let codeLines = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const raw = lines[index];
+        const fenceMatch = raw.match(/^```(\w*)$/);
+        if (fenceMatch) {
+            if (!inCodeBlock) {
+                inCodeBlock = true;
+                codeLang = fenceMatch[1] ?? '';
+                codeLines = [];
+            }
+            else {
+                inCodeBlock = false;
+                const langLabel = codeLang ? chalk.hex(MARKDOWN_THEME.muted).italic(` ${codeLang}`) : '';
+                out.push(chalk.hex(MARKDOWN_THEME.codeFence)('┌' + '─'.repeat(Math.max(2, cols - 2))) + langLabel);
+                for (const cl of codeLines) {
+                    out.push(chalk.hex(MARKDOWN_THEME.codeFence)('│ ') + renderCodeLine(codeLang, cl));
+                }
+                out.push(chalk.hex(MARKDOWN_THEME.codeFence)('└' + '─'.repeat(Math.max(2, cols - 2))));
+                codeLang = '';
+                codeLines = [];
+            }
+            continue;
+        }
+        if (inCodeBlock) {
+            codeLines.push(raw);
+            continue;
+        }
+        const h1 = raw.match(/^# (.+)/);
+        const h2 = raw.match(/^## (.+)/);
+        const h3 = raw.match(/^### (.+)/);
+        if (h1) {
+            out.push('\n' + chalk.bold.hex(MARKDOWN_THEME.accentStrong)(h1[1]));
+            continue;
+        }
+        if (h2) {
+            out.push('\n' + chalk.bold.hex(MARKDOWN_THEME.text)(h2[1]));
+            continue;
+        }
+        if (h3) {
+            out.push(chalk.bold(h3[1]));
+            continue;
+        }
+        if (/^---+$/.test(raw) || /^\*\*\*+$/.test(raw)) {
+            out.push(chalk.hex(MARKDOWN_THEME.muted)('─'.repeat(cols)));
+            continue;
+        }
+        const tableMatch = matchGfmTable(lines, index);
+        if (tableMatch) {
+            out.push(...renderGfmTable(tableMatch.table, cols));
+            index = tableMatch.end - 1;
+            continue;
+        }
+        const bullet = raw.match(/^(\s*)[*\-+] (.+)/);
+        if (bullet) {
+            out.push((bullet[1] ?? '') + chalk.hex(MARKDOWN_THEME.accent)('•') + ' ' + inlineMarkdown(bullet[2] ?? ''));
+            continue;
+        }
+        const numbered = raw.match(/^(\s*)(\d+)\. (.+)/);
+        if (numbered) {
+            out.push((numbered[1] ?? '') +
+                chalk.hex(MARKDOWN_THEME.accent)(numbered[2] + '.') +
+                ' ' +
+                inlineMarkdown(numbered[3] ?? ''));
+            continue;
+        }
+        const bq = raw.match(/^> (.+)/);
+        if (bq) {
+            out.push(chalk.hex(MARKDOWN_THEME.muted)('│ ') + chalk.italic.hex(MARKDOWN_THEME.muted)(bq[1]));
+            continue;
+        }
+        out.push(inlineMarkdown(raw));
+    }
+    if (inCodeBlock && codeLines.length > 0) {
+        out.push(chalk.hex(MARKDOWN_THEME.codeFence)('┌─'));
+        for (const cl of codeLines) {
+            out.push(chalk.hex(MARKDOWN_THEME.codeFence)('│ ') + renderCodeLine(codeLang, cl));
+        }
+        out.push(chalk.hex(MARKDOWN_THEME.codeFence)('└─'));
+    }
+    return out.join('\n');
+}

package/dist/model-config.js

@@ -0,0 +1,48 @@
+import { detectBackend } from './backend.js';
+export function defaultBaseUrlForBackend(backend) {
+    if (backend === 'anthropic')
+        return 'https://api.anthropic.com';
+    if (backend === 'openai')
+        return 'https://api.openai.com';
+    return 'http://localhost:11434';
+}
+export function resolveModelConfig(fileConfig, requestedModel) {
+    const defaultModel = requestedModel ?? process.env.AGENT_MODEL ?? fileConfig.model;
+    if (!defaultModel) {
+        return {
+            name: '(unconfigured)',
+            config: {
+                type: 'ollama',
+                baseUrl: 'http://localhost:11434',
+                model: '',
+            },
+        };
+    }
+    const aliasConfig = fileConfig.models?.[defaultModel];
+    const modelConfig = aliasConfig ?? { model: defaultModel };
+    const requestedBackend = (process.env.LLM_BACKEND
+        ?? modelConfig.backend
+        ?? fileConfig.backend);
+    const baseUrl = process.env.LLM_BASE_URL
+        ?? process.env.OLLAMA_BASE_URL
+        ?? modelConfig.baseUrl
+        ?? fileConfig.baseUrl
+        ?? (requestedBackend ? defaultBaseUrlForBackend(requestedBackend) : undefined);
+    if (!baseUrl) {
+        throw new Error('No base URL specified. Set "baseUrl" in .agentrc or set LLM_BASE_URL env var.');
+    }
+    const backend = (requestedBackend ?? detectBackend(baseUrl));
+    const apiKey = process.env.LLM_API_KEY ?? modelConfig.apiKey ?? fileConfig.apiKey;
+    return {
+        name: aliasConfig ? defaultModel : modelConfig.model,
+        config: {
+            type: backend,
+            baseUrl,
+            model: modelConfig.model,
+            ...(modelConfig.wireApi ? { wireApi: modelConfig.wireApi } : {}),
+            ...(apiKey ? { apiKey } : {}),
+            ...(modelConfig.requestOptions ? { requestOptions: modelConfig.requestOptions } : {}),
+            ...(modelConfig.contextWindow ? { contextWindow: modelConfig.contextWindow } : {}),
+        },
+    };
+}

package/dist/policy.js

@@ -0,0 +1,80 @@
+import { resolve, isAbsolute, relative } from 'node:path';
+export function clonePolicy(policy) {
+    return {
+        level: policy.level,
+        workspaceRoot: policy.workspaceRoot,
+        allowedReadRoots: [...policy.allowedReadRoots],
+        allowedWriteRoots: [...policy.allowedWriteRoots],
+        bashAllowlist: [...policy.bashAllowlist],
+        bashDenylist: [...policy.bashDenylist],
+    };
+}
+export function defaultPolicy(level = 'off', workspaceRoot = process.cwd()) {
+    return {
+        level,
+        workspaceRoot,
+        allowedReadRoots: [workspaceRoot],
+        allowedWriteRoots: [workspaceRoot],
+        bashAllowlist: ['npm test', 'npm run typecheck', 'npm run build', 'node --version', 'echo '],
+        bashDenylist: [
+            'rm -rf /', 'curl | sh', 'wget | sh', 'mkfs', ':(){:|:&};:',
+            'Remove-Item -Recurse C:\\', 'format C:', 'diskpart',
+        ],
+    };
+}
+export function readOnlyPolicy(base) {
+    const policy = clonePolicy(base);
+    policy.allowedWriteRoots = [];
+    return policy;
+}
+function withinRoots(target, roots) {
+    const norm = resolve(target);
+    return roots.some((r) => {
+        const root = resolve(r);
+        if (norm === root)
+            return true;
+        // Use path.relative for cross-platform safety: on Windows, resolve()
+        // returns backslash-separated paths, so a naive `startsWith(root + '/')`
+        // check fails and wrongly rejects in-workspace files.
+        const rel = relative(root, norm);
+        return rel !== '' && !rel.startsWith('..') && !isAbsolute(rel);
+    });
+}
+export function authorizeToolCall(policy, name, args) {
+    if (policy.level === 'off')
+        return { ok: true };
+    const readPathTools = new Set([
+        'read_file', 'read_files', 'file_info', 'list_dir', 'search_text', 'search_files',
+        'repo_map', 'git_diff', 'git_log',
+    ]);
+    const writePathTools = new Set(['write_file', 'edit_file']);
+    if (readPathTools.has(name) || writePathTools.has(name)) {
+        const key = name === 'repo_map' ? 'root' : 'path';
+        const path = typeof args[key] === 'string' ? args[key] : '.';
+        const target = isAbsolute(path) ? path : resolve(policy.workspaceRoot, path);
+        const roots = writePathTools.has(name) ? policy.allowedWriteRoots : policy.allowedReadRoots;
+        if (!withinRoots(target, roots)) {
+            return { ok: false, ruleId: 'path_outside_workspace', reason: `Path not allowed: ${path}` };
+        }
+    }
+    if (name === 'bash') {
+        const cmd = typeof args['command'] === 'string' ? args['command'] : '';
+        if (!cmd)
+            return { ok: false, ruleId: 'missing_command', reason: 'bash command is required' };
+        if (policy.bashDenylist.some((bad) => cmd.includes(bad))) {
+            return { ok: false, ruleId: 'bash_denylist', reason: `Command blocked by denylist: ${cmd}` };
+        }
+        const cwdArg = typeof args['cwd'] === 'string' ? args['cwd'] : policy.workspaceRoot;
+        const cwd = isAbsolute(cwdArg) ? cwdArg : resolve(policy.workspaceRoot, cwdArg);
+        if (!withinRoots(cwd, policy.allowedReadRoots)) {
+            return { ok: false, ruleId: 'cwd_outside_workspace', reason: `Working directory not allowed: ${cwdArg}` };
+        }
+        if (policy.level === 'strict' && !policy.bashAllowlist.some((ok) => cmd.startsWith(ok))) {
+            return { ok: false, ruleId: 'bash_not_allowlisted', reason: `Command not allowlisted: ${cmd}` };
+        }
+    }
+    return { ok: true };
+}
+export function formatPolicyError(name, decision) {
+    return `PolicyError: tool=${name}; rule=${decision.ruleId ?? 'unknown'}; reason=${decision.reason ?? 'blocked'}`;
+}

package/dist/responses.js

@@ -0,0 +1,81 @@
+import { transportHeaders } from './backend.js';
+import { resilientFetch, FetchError } from './fetch.js';
+export async function* responsesStream(config, instructions, messages, tools, signal) {
+    const input = [];
+    for (const message of messages) {
+        if (message.responseItems)
+            input.push(...message.responseItems);
+        if (message.role === 'tool')
+            input.push({ type: 'function_call_output', call_id: message.tool_use_id, output: message.content ?? '' });
+        else {
+            if (message.content)
+                input.push({ role: message.role, content: message.content });
+            for (const call of message.tool_calls ?? []) {
+                input.push({ type: 'function_call', call_id: call.id, name: call.function.name, arguments: JSON.stringify(call.function.arguments) });
+            }
+        }
+    }
+    const options = config.requestOptions;
+    const body = {
+        ...(options?.temperature !== undefined ? { temperature: options.temperature } : {}),
+        ...(options?.topP !== undefined ? { top_p: options.topP } : {}),
+        ...(options?.maxTokens !== undefined ? { max_output_tokens: options.maxTokens } : {}),
+        ...options?.extraBody,
+        model: config.model, instructions, input, stream: true, store: false,
+        include: ['reasoning.encrypted_content'],
+        ...(tools?.length ? { tools: tools.map(({ function: fn }) => ({ type: 'function', name: fn.name, description: fn.description, parameters: fn.parameters, strict: false })) } : {}),
+    };
+    const base = config.baseUrl.replace(/\/+$/, '').replace(/\/v1$/, '');
+    const response = await resilientFetch(`${base}/v1/responses`, {
+        method: 'POST', headers: { 'content-type': 'application/json', ...(config.apiKey ? { authorization: `Bearer ${config.apiKey}` } : {}), ...transportHeaders(config) },
+        body: JSON.stringify(body), signal, timeout: 120_000, retries: 2,
+    });
+    if (!response.ok)
+        throw new FetchError(`Responses HTTP ${response.status}: ${await response.text()}`, response.status, false);
+    if (!response.body)
+        throw new Error('Responses returned no stream');
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+        while (true) {
+            const { value, done } = await reader.read();
+            buffer += done ? decoder.decode() + '\n\n' : decoder.decode(value, { stream: true });
+            buffer = buffer.replace(/\r\n/g, '\n');
+            const frames = buffer.split('\n\n');
+            buffer = frames.pop() ?? '';
+            for (const frame of frames) {
+                const data = frame.split('\n').filter((line) => line.startsWith('data:')).map((line) => line.slice(5).trimStart()).join('\n');
+                if (!data || data === '[DONE]')
+                    continue;
+                const event = JSON.parse(data);
+                if (event.type === 'response.output_text.delta' && event.delta)
+                    yield { content: event.delta, done: false };
+                if (event.type === 'response.reasoning_summary_text.delta' && event.delta)
+                    yield { content: null, thinking: event.delta, done: false };
+                if (event.type === 'response.output_item.done' && event.item?.type === 'reasoning') {
+                    yield { content: null, responseItems: [event.item], done: false };
+                }
+                if (event.type === 'response.output_item.done' && event.item?.type === 'function_call') {
+                    const item = event.item;
+                    if (!item.call_id || !item.name)
+                        throw new Error('Responses returned an incomplete tool call');
+                    yield { content: null, toolCalls: [{ id: item.call_id, function: { name: item.name, arguments: JSON.parse(item.arguments ?? '{}') } }], done: false };
+                }
+                if (['error', 'response.failed', 'response.incomplete'].includes(event.type)) {
+                    throw new Error(event.response?.error?.message ?? event.message ?? event.response?.incomplete_details?.reason ?? `Responses: ${event.type}`);
+                }
+                if (event.type === 'response.completed') {
+                    yield { content: null, done: true };
+                    return;
+                }
+            }
+            if (done)
+                throw new Error('Responses stream ended before completion');
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+}

package/dist/runtime/agent-registry.js

@@ -0,0 +1,139 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { relative, resolve, sep } from 'node:path';
+function unquote(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function parseInlineList(value) {
+    const trimmed = value.trim();
+    if (trimmed === '[]')
+        return [];
+    if (!trimmed.startsWith('[') || !trimmed.endsWith(']'))
+        return [unquote(trimmed)].filter(Boolean);
+    return trimmed.slice(1, -1).split(',').map((item) => unquote(item)).filter(Boolean);
+}
+function parseDocument(raw, source, id, scope) {
+    const normalized = raw.replace(/^\uFEFF/, '').replace(/\r\n/g, '\n');
+    if (!normalized.startsWith('---\n'))
+        throw new Error(`Agent spec ${source} must start with YAML frontmatter`);
+    const end = normalized.indexOf('\n---\n', 4);
+    if (end < 0)
+        throw new Error(`Agent spec ${source} has no closing frontmatter delimiter`);
+    const header = normalized.slice(4, end);
+    const instructions = normalized.slice(end + 5).trim();
+    const data = {};
+    let activeList;
+    for (const rawLine of header.split('\n')) {
+        const line = rawLine.replace(/\s+#.*$/, '');
+        const listItem = line.match(/^\s+-\s+(.+)$/);
+        if (listItem && activeList) {
+            const values = Array.isArray(data[activeList]) ? data[activeList] : [];
+            values.push(unquote(listItem[1]));
+            data[activeList] = values;
+            continue;
+        }
+        const field = line.match(/^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/);
+        if (!field) {
+            if (line.trim())
+                throw new Error(`Invalid frontmatter line in ${source}: ${rawLine}`);
+            continue;
+        }
+        const [, key, value] = field;
+        if (value) {
+            data[key] = (value.startsWith('[') && value.endsWith(']')) ? parseInlineList(value) : unquote(value);
+            activeList = undefined;
+        }
+        else {
+            data[key] = [];
+            activeList = key;
+        }
+    }
+    const description = typeof data.description === 'string' ? data.description.trim() : '';
+    if (!description)
+        throw new Error(`Agent spec ${source} requires a description`);
+    if (!instructions)
+        throw new Error(`Agent spec ${source} requires instructions`);
+    const tools = Array.isArray(data.tools) ? data.tools : data.tools ? [String(data.tools)] : [];
+    const agents = Array.isArray(data.agents) ? data.agents : data.agents ? [String(data.agents)] : [];
+    const model = typeof data.model === 'string' && data.model !== 'inherit' ? data.model : undefined;
+    return { id, description, model, tools, agents, instructions, source, scope };
+}
+async function markdownFiles(root) {
+    const files = [];
+    const visit = async (dir) => {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const path = resolve(dir, entry.name);
+            if (entry.isDirectory())
+                await visit(path);
+            else if (entry.isFile() && entry.name.toLowerCase().endsWith('.md'))
+                files.push(path);
+        }
+    };
+    await visit(root);
+    return files.sort();
+}
+function specId(root, file) {
+    return relative(root, file).split(sep).join('/').replace(/\.md$/i, '');
+}
+function matchesSelector(id, selector) {
+    if (selector === '*')
+        return true;
+    if (selector.endsWith('/*'))
+        return id.startsWith(selector.slice(0, -1));
+    return id === selector;
+}
+export class AgentRegistry {
+    specs = new Map();
+    roots;
+    constructor(options = {}) {
+        const workspaceRoot = resolve(options.workspaceRoot ?? process.cwd());
+        const builtinDir = resolve(options.builtinDir ?? resolve(import.meta.dirname, '..', '..', 'agents'));
+        this.roots = [
+            { path: builtinDir, scope: 'builtin' },
+            { path: resolve(options.userDir ?? resolve(homedir(), '.coder', 'agents')), scope: 'user' },
+            { path: resolve(options.projectDir ?? resolve(workspaceRoot, '.coder', 'agents')), scope: 'project' },
+        ];
+    }
+    async load() {
+        this.specs.clear();
+        for (const root of this.roots) {
+            for (const file of await markdownFiles(root.path)) {
+                const id = specId(root.path, file);
+                if (!/^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(id) || id.includes('..')) {
+                    throw new Error(`Invalid agent id derived from ${file}`);
+                }
+                this.specs.set(id, parseDocument(await readFile(file, 'utf8'), file, id, root.scope));
+            }
+        }
+        if (!this.specs.has('main'))
+            throw new Error('No main agent spec found');
+    }
+    get(id) {
+        const spec = this.specs.get(id);
+        return spec ? { ...spec, tools: [...spec.tools], agents: [...spec.agents] } : undefined;
+    }
+    list() {
+        return [...this.specs.values()].sort((a, b) => a.id.localeCompare(b.id)).map((spec) => this.get(spec.id));
+    }
+    allowedAgents(specOrId) {
+        const spec = typeof specOrId === 'string' ? this.specs.get(specOrId) : specOrId;
+        if (!spec)
+            return [];
+        return this.list().filter((candidate) => (candidate.id !== spec.id && spec.agents.some((selector) => matchesSelector(candidate.id, selector))));
+    }
+    canCall(from, targetId) {
+        return this.allowedAgents(from).some((candidate) => candidate.id === targetId);
+    }
+}
+export { matchesSelector as matchesAgentSelector, parseDocument as parseAgentSpec };