tokenmaw 0.3.0 → 0.4.0

package/dist/markdown.js

@@ -1,21 +1,49 @@
 /**
  * markdown.ts — Lightweight terminal markdown renderer.
  *
- * Exported so it can be unit-tested independently of the TUI.
- * No external dependencies — pure string transformation.
+ * Emits Blessed style tags (not raw ANSI) so the TUI renders every highlight
+ * with theme-driven colors, and exports the theme shape so unit tests and the
+ * TUI share one definition. No external dependencies — pure string transform.
  */
-import chalk from 'chalk';
-const MARKDOWN_THEME = {
+/** Blessed tags quantize hex colors to the terminal palette; chalk's
+ * truecolor SGR sequences are dropped by Blessed's attribute parser, which is
+ * why highlights previously rendered as plain white. */
+export const DEFAULT_MARKDOWN_THEME = {
     text: '#d7e0ea',
     muted: '#7f92a6',
     accent: '#6fb1d6',
-    accentStrong: '#8ac3e6',
+    heading: '#8ac3e6',
+    headingStrong: '#d7e0ea',
     codeBg: '#16212d',
     codeText: '#c7d7e6',
     codeFence: '#5f7388',
-    codeGreen: '#8ebd93',
-    codeRed: '#c97c7c',
+    diffAddBg: '#10281a',
+    diffAddText: '#9fd0a6',
+    diffDelBg: '#2b1215',
+    diffDelText: '#d99f9f',
 };
+let currentTheme = DEFAULT_MARKDOWN_THEME;
+export function setMarkdownTheme(theme) {
+    currentTheme = theme;
+}
+export function getMarkdownTheme() {
+    return currentTheme;
+}
+/** Blessed reserves braces for style tags; escape literal ones. */
+export function escapeTags(text) {
+    return text.replace(/{/g, '{open}').replace(/}/g, '{close}');
+}
+function fg(color, text) {
+    return `{${color}-fg}${text}{/${color}-fg}`;
+}
+/** Italic and strikethrough are not Blessed flags; raw SGR is honored by the
+ * content parser and excluded from width measurement. */
+function italic(text) {
+    return `\x1b[3m${text}\x1b[23m`;
+}
+function strike(text) {
+    return `\x1b[9m${text}\x1b[29m`;
+}
 function isDiffLanguage(lang) {
     return lang.toLowerCase() === 'diff' || lang.toLowerCase() === 'patch';
 }
@@ -31,27 +59,30 @@ export function diffKind(line) {
     return 'context';
 }
 export function renderDiffLine(line) {
+    const theme = getMarkdownTheme();
     switch (diffKind(line)) {
         case 'add':
-            return chalk.hex(MARKDOWN_THEME.codeGreen)(line);
+            return fg(theme.diffAddText, escapeTags(line));
         case 'del':
-            return chalk.hex(MARKDOWN_THEME.codeRed)(line);
+            return fg(theme.diffDelText, escapeTags(line));
         case 'hunk':
-            return chalk.hex(MARKDOWN_THEME.accent)(line);
+            return fg(theme.accent, escapeTags(line));
         case 'file':
-            return chalk.bold.hex(MARKDOWN_THEME.text)(line);
+            return fg(theme.text, escapeTags(line));
         case 'context':
         default:
-            return chalk.hex(MARKDOWN_THEME.muted)(line);
+            return fg(theme.muted, escapeTags(line));
     }
 }
 function renderCodeLine(lang, line) {
-    return isDiffLanguage(lang) ? renderDiffLine(line) : chalk.hex(MARKDOWN_THEME.codeText)(line);
+    return isDiffLanguage(lang) ? renderDiffLine(line) : fg(getMarkdownTheme().codeText, escapeTags(line));
 }
 const ANSI_PATTERN = /\x1b\[[0-9;]*[A-Za-z]/g;
-/** Display width ignoring ANSI escapes, counting East-Asian wide chars as 2 columns. */
+const TAG_PATTERN = /\{[^{}]*\}/g;
+/** Display width ignoring ANSI escapes and style tags, counting East-Asian
+ * wide chars as 2 columns. */
 export function displayWidth(text) {
-    const clean = text.replace(ANSI_PATTERN, '');
+    const clean = text.replace(ANSI_PATTERN, '').replace(TAG_PATTERN, '');
     let width = 0;
     for (const ch of clean) {
         const code = ch.codePointAt(0);
@@ -135,6 +166,7 @@ function truncateToWidth(text, maxWidth) {
 }
 /** Render a parsed table as aligned monospace lines that fit within maxWidth columns. */
 export function renderGfmTable(table, maxWidth) {
+    const theme = getMarkdownTheme();
     const columns = table.header.length;
     const gap = ' │ ';
     const gapWidth = displayWidth(gap);
@@ -153,40 +185,43 @@ export function renderGfmTable(table, maxWidth) {
             overflow -= reduce;
         }
     }
-    const padCell = (rendered, width, align) => {
-        const padding = Math.max(0, width - displayWidth(rendered));
+    const padCell = (plain, width, align) => {
+        const padding = Math.max(0, width - displayWidth(plain));
         if (align === 'right')
-            return ' '.repeat(padding) + rendered;
+            return ' '.repeat(padding) + plain;
         if (align === 'center') {
             const left = Math.floor(padding / 2);
-            return ' '.repeat(left) + rendered + ' '.repeat(padding - left);
+            return ' '.repeat(left) + plain + ' '.repeat(padding - left);
         }
-        return rendered + ' '.repeat(padding);
+        return plain + ' '.repeat(padding);
     };
+    // Pad the plain cell first, then style — so padding never measures tags.
     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]);
+        return style(padCell(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)));
+        .join(fg(theme.muted, gap));
+    const header = renderRow(table.header, (plain) => fg(theme.accent, `{bold}${inlineMarkdown(plain)}{/bold}`));
     // 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];
+    const separator = fg(theme.muted, widths.map((width) => '─'.repeat(width)).join('─┼─'));
+    const body = table.rows.map((row) => renderRow(row, (plain) => inlineMarkdown(plain)));
+    return [header, 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));
+    const theme = getMarkdownTheme();
+    return escapeTags(text)
+        .replace(/\*\*\*(.+?)\*\*\*/g, (_m, t) => `{bold}${italic(t)}{/bold}`)
+        .replace(/\*\*(.+?)\*\*/g, (_m, t) => `{bold}${t}{/bold}`)
+        .replace(/__(.+?)__/g, (_m, t) => `{bold}${t}{/bold}`)
+        .replace(/\*(.+?)\*/g, (_m, t) => italic(t))
+        .replace(/_(.+?)_/g, (_m, t) => italic(t))
+        .replace(/`([^`]+)`/g, (_m, t) => `{${theme.codeBg}-bg}{${theme.codeText}-fg} ${t} {/${theme.codeText}-fg}{/${theme.codeBg}-bg}`)
+        .replace(/~~(.+?)~~/g, (_m, t) => strike(t));
 }
 export function renderMarkdown(text, cols = 80) {
+    const theme = getMarkdownTheme();
     const lines = text.split('\n');
     const out = [];
     let inCodeBlock = false;
@@ -203,12 +238,12 @@ export function renderMarkdown(text, cols = 80) {
             }
             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);
+                const langLabel = codeLang ? fg(theme.muted, italic(` ${escapeTags(codeLang)}`)) : '';
+                out.push(fg(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(fg(theme.codeFence, '│ ') + renderCodeLine(codeLang, cl));
                 }
-                out.push(chalk.hex(MARKDOWN_THEME.codeFence)('└' + '─'.repeat(Math.max(2, cols - 2))));
+                out.push(fg(theme.codeFence, '└' + '─'.repeat(Math.max(2, cols - 2))));
                 codeLang = '';
                 codeLines = [];
             }
@@ -222,19 +257,19 @@ export function renderMarkdown(text, cols = 80) {
         const h2 = raw.match(/^## (.+)/);
         const h3 = raw.match(/^### (.+)/);
         if (h1) {
-            out.push('\n' + chalk.bold.hex(MARKDOWN_THEME.accentStrong)(h1[1]));
+            out.push('\n' + fg(theme.heading, `{bold}${escapeTags(h1[1])}{/bold}`));
             continue;
         }
         if (h2) {
-            out.push('\n' + chalk.bold.hex(MARKDOWN_THEME.text)(h2[1]));
+            out.push('\n' + fg(theme.headingStrong, `{bold}${escapeTags(h2[1])}{/bold}`));
             continue;
         }
         if (h3) {
-            out.push(chalk.bold(h3[1]));
+            out.push(`{bold}${escapeTags(h3[1])}{/bold}`);
             continue;
         }
         if (/^---+$/.test(raw) || /^\*\*\*+$/.test(raw)) {
-            out.push(chalk.hex(MARKDOWN_THEME.muted)('─'.repeat(cols)));
+            out.push(fg(theme.muted, '─'.repeat(cols)));
             continue;
         }
         const tableMatch = matchGfmTable(lines, index);
@@ -245,30 +280,30 @@ export function renderMarkdown(text, cols = 80) {
         }
         const bullet = raw.match(/^(\s*)[*\-+] (.+)/);
         if (bullet) {
-            out.push((bullet[1] ?? '') + chalk.hex(MARKDOWN_THEME.accent)('•') + ' ' + inlineMarkdown(bullet[2] ?? ''));
+            out.push((bullet[1] ?? '') + fg(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] + '.') +
+                fg(theme.accent, escapeTags(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]));
+            out.push(fg(theme.muted, '│ ') + fg(theme.muted, italic(escapeTags(bq[1]))));
             continue;
         }
         out.push(inlineMarkdown(raw));
     }
     if (inCodeBlock && codeLines.length > 0) {
-        out.push(chalk.hex(MARKDOWN_THEME.codeFence)('┌─'));
+        out.push(fg(theme.codeFence, '┌─'));
         for (const cl of codeLines) {
-            out.push(chalk.hex(MARKDOWN_THEME.codeFence)('│ ') + renderCodeLine(codeLang, cl));
+            out.push(fg(theme.codeFence, '│ ') + renderCodeLine(codeLang, cl));
         }
-        out.push(chalk.hex(MARKDOWN_THEME.codeFence)('└─'));
+        out.push(fg(theme.codeFence, '└─'));
     }
     return out.join('\n');
 }

package/dist/responses.js

@@ -66,7 +66,13 @@ export async function* responsesStream(config, instructions, messages, tools, si
                     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 };
+                    const usage = event.response?.usage;
+                    yield { content: null, done: true, usage: usage ? {
+                            inputTokens: usage.input_tokens,
+                            outputTokens: usage.output_tokens,
+                            cachedInputTokens: usage.input_tokens_details?.cached_tokens,
+                            reasoningTokens: usage.output_tokens_details?.reasoning_tokens,
+                        } : undefined };
                     return;
                 }
             }

package/dist/runtime/agent-registry.js

@@ -1,6 +1,6 @@
 import { readdir, readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { relative, resolve, sep } from 'node:path';
+import { join, relative, resolve, sep } from 'node:path';
 function unquote(value) {
     const trimmed = value.trim();
     if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
@@ -86,6 +86,25 @@ async function markdownFiles(root) {
 function specId(root, file) {
     return relative(root, file).split(sep).join('/').replace(/\.md$/i, '');
 }
+/** Names checked in order when loading project context. The lowercase form
+ * covers case-insensitive filesystems; the capitalized forms follow the
+ * agents.md convention used by other coding agents. */
+const WORKSPACE_CONTEXT_FILENAMES = ['AGENTS.md', 'AGENT.md', 'agents.md'];
+/** Loads an optional AGENTS.md-style project context document from the
+ * workspace root. Plain Markdown with no frontmatter; a missing, empty, or
+ * unreadable file is not an error — the convention is opt-in per workspace. */
+export async function loadWorkspaceContext(root) {
+    for (const name of WORKSPACE_CONTEXT_FILENAMES) {
+        try {
+            const content = (await readFile(join(root, name), 'utf8')).replace(/^\uFEFF/, '').trim();
+            if (content)
+                return content;
+            // An empty file counts as absent; keep looking at the remaining names.
+        }
+        catch { /* try the next candidate name */ }
+    }
+    return undefined;
+}
 function matchesSelector(id, selector) {
     if (selector === '*')
         return true;
@@ -96,15 +115,26 @@ function matchesSelector(id, selector) {
 export class AgentRegistry {
     specs = new Map();
     roots;
+    builtinDir;
+    userDir;
+    projectDir;
     constructor(options = {}) {
         const workspaceRoot = resolve(options.workspaceRoot ?? process.cwd());
-        const builtinDir = resolve(options.builtinDir ?? resolve(import.meta.dirname, '..', '..', 'agents'));
+        this.builtinDir = resolve(options.builtinDir ?? resolve(import.meta.dirname, '..', '..', 'agents'));
+        this.userDir = resolve(options.userDir ?? resolve(homedir(), '.coder', 'agents'));
+        this.projectDir = options.projectDir ? resolve(options.projectDir) : undefined;
         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' },
+            { path: this.builtinDir, scope: 'builtin' },
+            { path: this.userDir, scope: 'user' },
+            { path: this.projectDir ?? resolve(workspaceRoot, '.coder', 'agents'), scope: 'project' },
         ];
     }
+    /** Point the project-scope spec root at another workspace (<root>/.coder/agents).
+     * Takes effect on the next load(); used by /cd when switching workspaces. */
+    setProjectDir(workspaceRoot) {
+        this.projectDir = resolve(workspaceRoot, '.coder', 'agents');
+        this.roots[this.roots.length - 1] = { path: this.projectDir, scope: 'project' };
+    }
     async load() {
         this.specs.clear();
         for (const root of this.roots) {