@compilr-dev/cli 0.6.6 → 0.7.1

package/dist/tools/handoff.d.ts

@@ -1,25 +1,17 @@
 /**
  * Handoff Tool - Multi-Agent Task Handoff
  *
- * Allows any agent to hand off the current task to another agent.
- * Available to all agents (specialists and coordinator).
- *
- * Flow:
- * 1. Agent calls handoff(agentId, task, reason?)
- * 2. CLI shows approval prompt (unless auto-approve is enabled)
- * 3. If approved: auto-switch to target agent, inject task
- * 4. If denied: return "User declined" to current agent
+ * Uses SDK's createHandoffTool factory with CLI-specific handler.
+ * Exported as a static tool that lazily resolves dependencies.
+ */
+/**
+ * Handoff tool — delegates to the CLI's handoff handler.
  *
- * One-hop rule: If this agent was itself handed a task, it cannot
- * re-hand it off (except back to the coordinator/default).
+ * The handler (registered by delegation-handlers.ts) manages team validation,
+ * one-hop enforcement, user approval, and agent switching.
  */
-interface HandoffInput {
-    /** Target agent ID (e.g., 'arch', 'dev', 'qa', 'default') */
+export declare const handoffTool: import("@compilr-dev/sdk").Tool<{
     agentId: string;
-    /** Task description for the target agent */
     task: string;
-    /** Optional reason for handoff (shown to user for context) */
     reason?: string;
-}
-export declare const handoffTool: import("@compilr-dev/sdk").Tool<HandoffInput>;
-export {};
+}>;

package/dist/tools/handoff.js

@@ -1,23 +1,17 @@
 /**
  * Handoff Tool - Multi-Agent Task Handoff
  *
- * Allows any agent to hand off the current task to another agent.
- * Available to all agents (specialists and coordinator).
- *
- * Flow:
- * 1. Agent calls handoff(agentId, task, reason?)
- * 2. CLI shows approval prompt (unless auto-approve is enabled)
- * 3. If approved: auto-switch to target agent, inject task
- * 4. If denied: return "User declined" to current agent
- *
- * One-hop rule: If this agent was itself handed a task, it cannot
- * re-hand it off (except back to the coordinator/default).
+ * Uses SDK's createHandoffTool factory with CLI-specific handler.
+ * Exported as a static tool that lazily resolves dependencies.
  */
 import { defineTool } from '@compilr-dev/sdk';
 import { getHandoffHandler } from '../shared-handlers.js';
-// =============================================================================
-// Tool Definition
-// =============================================================================
+/**
+ * Handoff tool — delegates to the CLI's handoff handler.
+ *
+ * The handler (registered by delegation-handlers.ts) manages team validation,
+ * one-hop enforcement, user approval, and agent switching.
+ */
 export const handoffTool = defineTool({
     name: 'handoff',
     description: 'Hand off the current task to another team agent. ' +
@@ -43,50 +37,36 @@ export const handoffTool = defineTool({
         required: ['agentId', 'task'],
     },
     execute: async (input) => {
+        if (!input.agentId || input.agentId.trim().length === 0) {
+            return { success: false, error: 'Agent ID is required' };
+        }
+        if (!input.task || input.task.trim().length === 0) {
+            return { success: false, error: 'Task description is required' };
+        }
+        const handoffHandler = getHandoffHandler();
+        if (!handoffHandler) {
+            return {
+                success: false,
+                error: 'Handoff handler not initialized. This tool requires multi-agent mode with a team.',
+            };
+        }
         try {
-            // Validate input
-            if (!input.agentId || input.agentId.trim().length === 0) {
-                return {
-                    success: false,
-                    error: 'Agent ID is required',
-                };
-            }
-            if (!input.task || input.task.trim().length === 0) {
-                return {
-                    success: false,
-                    error: 'Task description is required',
-                };
-            }
-            // Get the handoff handler from shared-handlers
-            const handoffHandler = getHandoffHandler();
-            if (!handoffHandler) {
-                return {
-                    success: false,
-                    error: 'Handoff handler not initialized. ' +
-                        'This tool requires multi-agent mode with a team.',
-                };
-            }
-            // Execute handoff (shows approval prompt, switches if approved)
             const result = await handoffHandler({
                 agentId: input.agentId.trim(),
                 task: input.task.trim(),
                 reason: input.reason?.trim(),
             });
             if (result.error) {
-                return {
-                    success: false,
-                    error: result.error,
-                };
+                return { success: false, error: result.error };
             }
-            const output = {
-                handedOff: result.success,
-                message: result.declined
-                    ? 'User declined the handoff. Continue handling the task yourself.'
-                    : `Task handed off to $${input.agentId}. They will handle it from here.`,
-            };
             return {
                 success: true,
-                result: output,
+                result: {
+                    handedOff: !result.declined,
+                    message: result.declined
+                        ? 'User declined the handoff. Continue handling the task yourself.'
+                        : `Task handed off to $${input.agentId}. They will handle it from here.`,
+                },
             };
         }
         catch (err) {

package/dist/ui/conversation.js

@@ -7,7 +7,7 @@
  */
 import { Chalk } from 'chalk';
 import { marked } from 'marked';
-import { markedTerminal } from 'marked-terminal';
+import { markedTerminal } from './markdown-renderer.js';
 import { highlight } from 'cli-highlight';
 import { getStyles } from '../themes/index.js';
 import { getThemeColors } from '../themes/index.js';
@@ -153,7 +153,6 @@ export function renderMarkdown(text) {
         const preprocessed = preprocessMarkdown(text);
         // Configure marked with theme-aware options
         const options = getThemedMarkedOptions();
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
         marked.use(markedTerminal(options));
         // Parse
         const rendered = marked.parse(preprocessed, { async: false });

package/dist/ui/markdown-renderer.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Terminal markdown renderer for marked.
+ * Drop-in replacement for `marked-terminal` — returns a marked extension.
+ *
+ * Usage:
+ *   import { markedTerminal } from './markdown-renderer.js';
+ *   marked.use(markedTerminal(options));
+ */
+type ChalkFn = (text: string) => string;
+export interface TerminalRendererOptions {
+    heading?: ChalkFn;
+    firstHeading?: ChalkFn;
+    strong?: ChalkFn;
+    em?: ChalkFn;
+    codespan?: ChalkFn;
+    code?: ChalkFn;
+    blockquote?: ChalkFn;
+    del?: ChalkFn;
+    link?: ChalkFn;
+    href?: ChalkFn;
+    html?: ChalkFn;
+    hr?: ChalkFn;
+    table?: ChalkFn;
+    listitem?: ChalkFn;
+    paragraph?: ChalkFn;
+    text?: ChalkFn;
+    width?: number;
+    tab?: number;
+    reflowText?: boolean;
+    showSectionPrefix?: boolean;
+    unescape?: boolean;
+    emoji?: boolean;
+    tableOptions?: Record<string, unknown>;
+}
+/**
+ * Returns a marked extension that renders markdown to ANSI terminal output.
+ * Drop-in replacement for `markedTerminal` from the `marked-terminal` package.
+ */
+export declare function markedTerminal(options?: TerminalRendererOptions): {
+    renderer: Record<string, unknown>;
+    useNewRenderer: boolean;
+};
+export {};

package/dist/ui/markdown-renderer.js

@@ -0,0 +1,474 @@
+/**
+ * Terminal markdown renderer for marked.
+ * Drop-in replacement for `marked-terminal` — returns a marked extension.
+ *
+ * Usage:
+ *   import { markedTerminal } from './markdown-renderer.js';
+ *   marked.use(markedTerminal(options));
+ */
+import { Chalk } from 'chalk';
+import { highlight as cliHighlight } from 'cli-highlight';
+import Table from 'cli-table3';
+import ansiEscapes from 'ansi-escapes';
+import supportsHyperlinks from 'supports-hyperlinks';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const TABLE_CELL_SPLIT = '^*||*^';
+const TABLE_ROW_WRAP = '*|*|*|*';
+const TABLE_ROW_WRAP_RE = new RegExp(TABLE_ROW_WRAP.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
+const COLON_REPLACER = '*#COLON|*';
+const COLON_REPLACER_RE = new RegExp(COLON_REPLACER.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
+const HARD_RETURN = '\r';
+const HARD_RETURN_RE = new RegExp(HARD_RETURN);
+const HARD_RETURN_GFM_RE = new RegExp(HARD_RETURN + '|<br />');
+const BULLET_POINT = '* ';
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\u001b\[(?:\d{1,3})(?:;\d{1,3})*m/g;
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+const chalk = new Chalk({ level: 3 });
+const defaultOptions = {
+    heading: chalk.green.bold,
+    firstHeading: chalk.magenta.underline.bold,
+    strong: chalk.bold,
+    em: chalk.italic,
+    codespan: chalk.yellow,
+    code: chalk.yellow,
+    blockquote: chalk.gray.italic,
+    del: chalk.dim.gray.strikethrough,
+    link: chalk.blue,
+    href: chalk.blue.underline,
+    html: chalk.gray,
+    hr: chalk.reset,
+    table: chalk.reset,
+    listitem: chalk.reset,
+    paragraph: chalk.reset,
+    text: (s) => s,
+    width: 80,
+    tab: 2,
+    reflowText: true,
+    showSectionPrefix: false,
+    unescape: true,
+    emoji: false,
+    tableOptions: {},
+};
+// ---------------------------------------------------------------------------
+// Utilities
+// ---------------------------------------------------------------------------
+function identity(s) { return s; }
+function textLength(str) {
+    return str.replace(ANSI_RE, '').length;
+}
+function section(text) {
+    return text + '\n\n';
+}
+function indentify(indent, text) {
+    if (!text)
+        return text;
+    return indent + text.split('\n').join('\n' + indent);
+}
+function indentLines(indent, text) {
+    return text.replace(/(^|\n)(.+)/g, '$1' + indent + '$2');
+}
+function unescapeEntities(html) {
+    return html
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'");
+}
+function undoColon(str) {
+    return str.replace(COLON_REPLACER_RE, ':');
+}
+function fixHardReturn(text, reflow) {
+    return reflow ? text.replace(HARD_RETURN_RE, '\n') : text;
+}
+function hr(char, length) {
+    const width = length || process.stdout.columns || 80;
+    return char.repeat(width);
+}
+function highlightCode(code, language, fallbackStyle) {
+    if (chalk.level === 0)
+        return code;
+    try {
+        return cliHighlight(code, { language: language || 'plaintext' });
+    }
+    catch {
+        return fallbackStyle(code);
+    }
+}
+// ---------------------------------------------------------------------------
+// Reflow
+// ---------------------------------------------------------------------------
+function reflowText(text, width, gfm) {
+    const splitRe = gfm ? HARD_RETURN_GFM_RE : HARD_RETURN_RE;
+    const sections = text.split(splitRe);
+    const reflowed = [];
+    for (const sec of sections) {
+        // eslint-disable-next-line no-control-regex
+        const fragments = sec.split(/(\u001b\[(?:\d{1,3})(?:;\d{1,3})*m)/g);
+        let column = 0;
+        let currentLine = '';
+        let lastWasEscape = false;
+        for (const fragment of fragments) {
+            if (fragment === '') {
+                lastWasEscape = false;
+                continue;
+            }
+            if (!textLength(fragment)) {
+                currentLine += fragment;
+                lastWasEscape = true;
+                continue;
+            }
+            const words = fragment.split(/[ \t\n]+/);
+            for (const word of words) {
+                if (!word)
+                    continue;
+                const addSpace = column !== 0 && !lastWasEscape;
+                const neededWidth = word.length + (addSpace ? 1 : 0);
+                if (column + neededWidth > width && word.length <= width) {
+                    reflowed.push(currentLine);
+                    currentLine = word;
+                    column = word.length;
+                }
+                else if (column + neededWidth > width) {
+                    // Word longer than width — split it
+                    let remaining = word;
+                    const space = width - column - (addSpace ? 1 : 0);
+                    if (space > 0) {
+                        if (addSpace)
+                            currentLine += ' ';
+                        currentLine += remaining.substring(0, space);
+                        reflowed.push(currentLine);
+                        remaining = remaining.substring(space);
+                    }
+                    while (remaining.length > width) {
+                        reflowed.push(remaining.substring(0, width));
+                        remaining = remaining.substring(width);
+                    }
+                    currentLine = remaining;
+                    column = remaining.length;
+                }
+                else {
+                    if (addSpace) {
+                        currentLine += ' ';
+                        column++;
+                    }
+                    currentLine += word;
+                    column += word.length;
+                }
+                lastWasEscape = false;
+            }
+        }
+        if (textLength(currentLine))
+            reflowed.push(currentLine);
+    }
+    return reflowed.join('\n');
+}
+// ---------------------------------------------------------------------------
+// List helpers
+// ---------------------------------------------------------------------------
+function isPointedLine(line, indent) {
+    const pointRe = new RegExp('^(?:' + indent.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + ')*(?:\\*|\\d+\\.)');
+    return pointRe.test(line);
+}
+function bulletPointLines(lines, indent) {
+    return lines.split('\n').filter(Boolean).map(line => isPointedLine(line, indent) ? line : ' '.repeat(BULLET_POINT.length) + line).join('\n');
+}
+function numberedLines(lines, indent) {
+    let num = 0;
+    return lines.split('\n').filter(Boolean).map(line => {
+        if (isPointedLine(line, indent)) {
+            num++;
+            return line.replace(BULLET_POINT, `${String(num)}. `);
+        }
+        return ' '.repeat(`${String(num)}. `.length) + line;
+    }).join('\n');
+}
+function fixNestedLists(body, indent) {
+    const pointRe = '(?:\\*|\\d+\\.)';
+    const regex = new RegExp('(\\S(?: |  )?)' +
+        '((?:' + indent.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + ')+)' +
+        '(' + pointRe + '(?:.*)+)$', 'gm');
+    return body.replace(regex, '$1\n' + indent + '$2$3');
+}
+// ---------------------------------------------------------------------------
+// Table helpers
+// ---------------------------------------------------------------------------
+function generateTableRow(text, escape) {
+    if (!text)
+        return [];
+    const esc = escape || identity;
+    const lines = esc(text).split('\n');
+    const data = [];
+    for (const line of lines) {
+        if (!line)
+            continue;
+        const parsed = line.replace(TABLE_ROW_WRAP_RE, '').split(TABLE_CELL_SPLIT);
+        data.push(parsed.slice(0, -1));
+    }
+    return data;
+}
+// ---------------------------------------------------------------------------
+// Renderer
+// ---------------------------------------------------------------------------
+class TerminalMarkdownRenderer {
+    o;
+    tab;
+    tableSettings;
+    transform;
+    // Set by marked extension wrapper before each call
+    parser = { parse: () => '', parseInline: () => '' };
+    options = {};
+    constructor(opts) {
+        this.o = { ...defaultOptions, ...opts };
+        this.tab = typeof this.o.tab === 'number' ? ' '.repeat(this.o.tab) : '  ';
+        this.tableSettings = this.o.tableOptions;
+        const unescape = this.o.unescape ? unescapeEntities : identity;
+        this.transform = (s) => undoColon(unescape(s));
+    }
+    space() { return ''; }
+    text(token) {
+        const t = typeof token === 'object' ? (token.text ?? '') : token;
+        return this.o.text(t);
+    }
+    code(token, lang) {
+        let code;
+        if (typeof token === 'object') {
+            lang = token.lang;
+            code = token.text;
+        }
+        else {
+            code = token;
+        }
+        code = fixHardReturn(code, this.o.reflowText);
+        return section(indentify(this.tab, highlightCode(code, lang, this.o.code)));
+    }
+    blockquote(token) {
+        let quote;
+        if (typeof token === 'object' && token.tokens) {
+            quote = this.parser.parse(token.tokens);
+        }
+        else {
+            quote = typeof token === 'string' ? token : '';
+        }
+        return section(this.o.blockquote(indentify(this.tab, quote.trim())));
+    }
+    html(token) {
+        const t = typeof token === 'object' ? (token.text ?? '') : token;
+        return this.o.html(t);
+    }
+    heading(token, level) {
+        let text;
+        if (typeof token === 'object' && token.tokens) {
+            level = token.depth;
+            text = this.parser.parseInline(token.tokens);
+        }
+        else {
+            text = typeof token === 'string' ? token : '';
+        }
+        text = this.transform(text);
+        const prefix = this.o.showSectionPrefix ? '#'.repeat(level ?? 1) + ' ' : '';
+        text = prefix + text;
+        if (this.o.reflowText)
+            text = reflowText(text, this.o.width, !!this.options.gfm);
+        return section(level === 1 ? this.o.firstHeading(text) : this.o.heading(text));
+    }
+    hr() {
+        return section(this.o.hr(hr('─', this.o.reflowText ? this.o.width : undefined)));
+    }
+    list(token, ordered) {
+        let body;
+        if (typeof token === 'object' && token.items) {
+            ordered = token.ordered;
+            body = '';
+            for (const item of token.items) {
+                body += this.listitem(item);
+            }
+        }
+        else {
+            body = typeof token === 'string' ? token : '';
+        }
+        body = body.trim();
+        body = ordered ? numberedLines(body, this.tab) : bulletPointLines(body, this.tab);
+        return section(fixNestedLists(indentLines(this.tab, body), this.tab));
+    }
+    listitem(token) {
+        let text;
+        if (typeof token === 'object' && token.tokens) {
+            const item = token;
+            text = '';
+            if (item.task) {
+                const cb = item.checked ? '[X] ' : '[ ] ';
+                text += cb;
+            }
+            text += this.parser.parse(item.tokens ?? [], !!item.loose);
+        }
+        else {
+            text = typeof token === 'string' ? token : '';
+        }
+        const transform = (s) => this.o.listitem(this.transform(s));
+        const isNested = text.includes('\n');
+        if (isNested)
+            text = text.trim();
+        return '\n' + BULLET_POINT + transform(text);
+    }
+    checkbox(token) {
+        const checked = typeof token === 'object' ? token.checked : token;
+        return '[' + (checked ? 'X' : ' ') + '] ';
+    }
+    paragraph(token) {
+        let text;
+        if (typeof token === 'object' && token.tokens) {
+            text = this.parser.parseInline(token.tokens);
+        }
+        else {
+            text = typeof token === 'string' ? token : '';
+        }
+        text = this.o.paragraph(this.transform(text));
+        if (this.o.reflowText)
+            text = reflowText(text, this.o.width, !!this.options.gfm);
+        return section(text);
+    }
+    table(token, body) {
+        let header;
+        if (typeof token === 'object' && token.header) {
+            header = '';
+            for (const cell of token.header) {
+                header += this.parser.parseInline(cell.tokens) + TABLE_CELL_SPLIT;
+            }
+            header = TABLE_ROW_WRAP + header + TABLE_ROW_WRAP + '\n';
+            body = '';
+            for (const row of token.rows ?? []) {
+                let rowStr = '';
+                for (const cell of row) {
+                    rowStr += this.parser.parseInline(cell.tokens) + TABLE_CELL_SPLIT;
+                }
+                body += TABLE_ROW_WRAP + rowStr + TABLE_ROW_WRAP + '\n';
+            }
+        }
+        else {
+            header = typeof token === 'string' ? token : '';
+        }
+        const table = new Table({
+            head: generateTableRow(header)[0] ?? [],
+            ...this.tableSettings,
+        });
+        for (const row of generateTableRow(body ?? '', this.transform)) {
+            table.push(row);
+        }
+        return section(this.o.table(table.toString()));
+    }
+    tablerow(token) {
+        const content = typeof token === 'object' ? (token.text ?? '') : token;
+        return TABLE_ROW_WRAP + content + TABLE_ROW_WRAP + '\n';
+    }
+    tablecell(token) {
+        if (typeof token === 'object' && token.tokens) {
+            return this.parser.parseInline(token.tokens) + TABLE_CELL_SPLIT;
+        }
+        return (typeof token === 'string' ? token : '') + TABLE_CELL_SPLIT;
+    }
+    strong(token) {
+        let text;
+        if (typeof token === 'object' && token.tokens) {
+            text = this.parser.parseInline(token.tokens);
+        }
+        else {
+            text = typeof token === 'string' ? token : '';
+        }
+        return this.o.strong(text);
+    }
+    em(token) {
+        let text;
+        if (typeof token === 'object' && token.tokens) {
+            text = this.parser.parseInline(token.tokens);
+        }
+        else {
+            text = typeof token === 'string' ? token : '';
+        }
+        return this.o.em(fixHardReturn(text, this.o.reflowText));
+    }
+    codespan(token) {
+        let text = typeof token === 'object' ? (token.text ?? '') : token;
+        text = fixHardReturn(text, this.o.reflowText);
+        return this.o.codespan(text.replace(/:/g, COLON_REPLACER));
+    }
+    br() {
+        return this.o.reflowText ? HARD_RETURN : '\n';
+    }
+    del(token) {
+        let text;
+        if (typeof token === 'object' && token.tokens) {
+            text = this.parser.parseInline(token.tokens);
+        }
+        else {
+            text = typeof token === 'string' ? token : '';
+        }
+        return this.o.del(text);
+    }
+    link(token, _title, _text) {
+        let href;
+        let text;
+        if (typeof token === 'object' && token.tokens) {
+            href = token.href ?? '';
+            text = this.parser.parseInline(token.tokens);
+        }
+        else {
+            href = typeof token === 'string' ? token : '';
+            text = typeof _text === 'string' ? _text : '';
+        }
+        const hasText = text && text !== href;
+        let out = '';
+        if (supportsHyperlinks.stdout) {
+            const linkText = this.o.href(text || href);
+            out = ansiEscapes.link(linkText, href);
+        }
+        else {
+            if (hasText)
+                out += text + ' (';
+            out += this.o.href(href);
+            if (hasText)
+                out += ')';
+        }
+        return this.o.link(out);
+    }
+    image(token, title, text) {
+        if (typeof token === 'object') {
+            title = token.title;
+            text = token.text;
+            token = token.href ?? '';
+        }
+        let out = '![' + (text || '');
+        if (title)
+            out += ' – ' + title;
+        return out + '](' + token + ')\n';
+    }
+}
+// ---------------------------------------------------------------------------
+// Public API — same interface as `marked-terminal`
+// ---------------------------------------------------------------------------
+/**
+ * Returns a marked extension that renders markdown to ANSI terminal output.
+ * Drop-in replacement for `markedTerminal` from the `marked-terminal` package.
+ */
+export function markedTerminal(options) {
+    const r = new TerminalMarkdownRenderer(options ?? {});
+    const methods = [
+        'space', 'text', 'code', 'blockquote', 'html', 'heading', 'hr',
+        'list', 'listitem', 'checkbox', 'paragraph', 'table', 'tablerow',
+        'tablecell', 'strong', 'em', 'codespan', 'br', 'del', 'link', 'image',
+    ];
+    const renderer = {};
+    for (const method of methods) {
+        renderer[method] = function (...args) {
+            r.options = this.options;
+            r.parser = this.parser;
+            return r[method](...args);
+        };
+    }
+    return { renderer, useNewRenderer: true };
+}

package/dist/ui/overlay/impl/artifact-detail-overlay-v2.js

@@ -10,7 +10,7 @@
  */
 import chalk from 'chalk';
 import { marked } from 'marked';
-import { markedTerminal } from 'marked-terminal';
+import { markedTerminal } from '../../markdown-renderer.js';
 import { BaseOverlayV2 } from '../../base/overlay-base-v2.js';
 import { getCurrentTheme } from '../../../themes/index.js';
 import * as terminal from '../../terminal.js';
@@ -92,7 +92,6 @@ function getThemedMarkedOptions(termWidth) {
 }
 function renderMarkdownSync(content, termWidth) {
     const options = getThemedMarkedOptions(termWidth);
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
     marked.use(markedTerminal(options));
     const rendered = marked.parse(content, { async: false });
     return rendered.split('\n');