micro-models-agent 0.7.10 → 0.8.0

package/dist/tools/search-history.js

@@ -0,0 +1,64 @@
+import * as fs from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { t } from '../i18n/index';
+function searchFile(filePath, query, maxResults, results) {
+    if (!fs.existsSync(filePath))
+        return;
+    const content = fs.readFileSync(filePath, 'utf-8');
+    for (const line of content.split('\n').filter(Boolean)) {
+        if (line.toLowerCase().includes(query)) {
+            try {
+                const entry = JSON.parse(line);
+                results.push(`[${filePath}] ${JSON.stringify(entry).slice(0, 200)}`);
+            }
+            catch { /* skip */ }
+        }
+        if (results.length >= maxResults)
+            break;
+    }
+}
+export const searchHistoryTool = {
+    name: 'search_history',
+    description: 'Search through session history for past interactions across all sessions.',
+    tags: ['research'],
+    parameters: {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Search query' },
+            maxResults: { type: 'number', description: 'Maximum results (default 5)' },
+            sessionId: { type: 'string', description: 'Optional: limit search to a specific session' },
+        },
+        required: ['query'],
+    },
+    handler: async (_ctx, args) => {
+        const query = String(args.query || '').toLowerCase();
+        const maxResults = Number(args.maxResults) || 5;
+        const sessionId = args.sessionId ? String(args.sessionId) : null;
+        const sessionDir = join(homedir(), '.mma', 'sessions');
+        const results = [];
+        try {
+            if (!fs.existsSync(sessionDir)) {
+                return { success: true, output: t('tool.no_sessions_dir', { dir: sessionDir }) };
+            }
+            const entries = fs.readdirSync(sessionDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                if (sessionId && entry.name !== sessionId)
+                    continue;
+                const historyFile = join(sessionDir, entry.name, 'history.jsonl');
+                searchFile(historyFile, query, maxResults, results);
+                if (results.length >= maxResults)
+                    break;
+            }
+            if (results.length === 0) {
+                return { success: true, output: t('tool.no_history', { query }) };
+            }
+            return { success: true, output: t('tool.history_results', { query, results: results.join('\n') }) };
+        }
+        catch (err) {
+            return { success: true, output: t('tool.history_error', { error: String(err) }) };
+        }
+    },
+};

package/dist/tools/subagent.js

@@ -0,0 +1,130 @@
+import { t } from "../i18n/index";
+import { Agent } from "../core/agent";
+import { ContextManager } from "../modules/context/manager";
+import { HallucinationDetector } from "../modules/hallucination/detector";
+import { PluginManager } from "../modules/plugins/manager";
+import { logSecurityBlock } from "../modules/security/audit-log";
+import { getSessionSecurityConfig } from "../modules/security/session-isolation";
+export const subagentTool = {
+    name: "subagent",
+    description: "Spawn an isolated sub-agent to work on a task independently. The sub-agent has its own context and executes autonomously. Use for parallel work or complex sub-tasks.",
+    tags: ["code"],
+    parameters: {
+        type: "object",
+        properties: {
+            task: {
+                type: "string",
+                description: "Task description for the sub-agent",
+            },
+            context: {
+                type: "string",
+                description: "Optional context or constraints",
+            },
+            expert_tag: {
+                type: "string",
+                description: "Expert tag for tool filtering and model selection",
+            },
+            allowed_files: {
+                type: "array",
+                items: { type: "string" },
+                description: "Files/directories the sub-agent can read and write",
+            },
+            read_only_files: {
+                type: "array",
+                items: { type: "string" },
+                description: "Files/directories the sub-agent can read but not write",
+            },
+            shared_context: {
+                type: "string",
+                description: "Shared context/rules passed to the sub-agent",
+            },
+            max_tokens: {
+                type: "number",
+                description: "Maximum tokens for the sub-agent response",
+            },
+            tool_tags: {
+                type: "array",
+                items: { type: "string" },
+                description: "Tool tags to expose to the sub-agent",
+            },
+        },
+        required: ["task"],
+    },
+    handler: async (ctx, args) => {
+        const task = String(args.task || "");
+        const context = String(args.context || "");
+        if (!task) {
+            return { success: false, output: t("tool.name_or_task") };
+        }
+        // Get session-specific security config
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext)
+            : ctx.config.security;
+        // Security check: limit recursion depth
+        const maxDepth = securityConfig?.maxRecursionDepth ?? 3;
+        const currentDepth = ctx.recursionDepth ?? 0;
+        if (currentDepth >= maxDepth) {
+            logSecurityBlock(ctx.sessionId, "bash_command", `Maximum recursion depth (${maxDepth}) exceeded`, task);
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] Maximum sub-agent recursion depth (${maxDepth}) exceeded`,
+            };
+        }
+        const scope = args.allowed_files || args.read_only_files
+            ? {
+                allowed_files: args.allowed_files || [],
+                read_only_files: args.read_only_files || [],
+            }
+            : ctx.scope;
+        const toolTags = args.tool_tags ? args.tool_tags : undefined;
+        if (!ctx.llmProvider || !ctx.toolExecutor) {
+            return {
+                success: false,
+                output: "Sub-agent cannot run: missing llmProvider or toolExecutor in context",
+            };
+        }
+        try {
+            const subContextManager = new ContextManager(ctx.config.contextWindow, ctx.config.contextBudget);
+            const subPluginManager = new PluginManager();
+            const hallucinationDetector = new HallucinationDetector();
+            const systemPrompt = {
+                content: `You are a sub-agent working on a specific task. ${context ? `Context: ${context}` : ""}`,
+                priority: "critical",
+                essential: true,
+                estimatedTokens: 100,
+            };
+            const subDeps = {
+                config: ctx.config,
+                llmProvider: ctx.llmProvider,
+                toolExecutor: ctx.toolExecutor,
+                pluginManager: subPluginManager,
+                contextManager: subContextManager,
+                hallucinationDetector,
+                logger: ctx.logger,
+                baseDir: ctx.baseDir,
+                scope,
+                toolTags,
+                promptBlocks: [systemPrompt],
+                recursionDepth: currentDepth + 1, // Increment recursion depth for sub-agent
+            };
+            const subAgent = new Agent(subDeps);
+            const fullTask = context ? `${task}\n\nContext: ${context}` : task;
+            const result = await subAgent.run(fullTask);
+            if (result.success) {
+                return {
+                    success: true,
+                    output: `Sub-agent completed:\n${result.text}\n\nIterations: ${result.iterationCount}`,
+                };
+            }
+            else {
+                return {
+                    success: false,
+                    output: `Sub-agent failed: ${result.error}\nPartial output: ${result.text}`,
+                };
+            }
+        }
+        catch (e) {
+            return { success: false, output: `Sub-agent error: ${e.message}` };
+        }
+    },
+};

package/dist/tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tools/user-input.js

@@ -0,0 +1,123 @@
+import * as readline from "readline";
+import { t } from "../i18n/index";
+/** Index returned by askChoice when the user picks the "custom answer" entry. */
+export const CUSTOM_INDEX = -1;
+/**
+ * Parse user input like "1" or "1,3" into 0-based option indexes.
+ * Returns null on invalid input (empty, non-numeric, out of range,
+ * duplicates, or multiple values when multiple is false).
+ */
+export function parseSelection(input, optionCount, multiple) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return null;
+    const parts = trimmed.split(",").map((p) => p.trim());
+    if (!multiple && parts.length > 1)
+        return null;
+    const indexes = [];
+    for (const part of parts) {
+        if (!/^\d+$/.test(part))
+            return null;
+        const idx = Number(part) - 1;
+        if (idx < 0 || idx >= optionCount)
+            return null;
+        if (indexes.includes(idx))
+            return null;
+        indexes.push(idx);
+    }
+    return indexes.length ? indexes : null;
+}
+/** Render question + numbered option list as a single string. */
+export function formatMenu(question, options, opts = {}) {
+    const lines = [question];
+    options.forEach((opt, i) => {
+        lines.push(`  [${i + 1}] ${opt.label} — ${opt.description}`);
+    });
+    if (opts.allowCustom) {
+        lines.push(`  [${options.length + 1}] ${t("tool.user_input.custom_option")}`);
+    }
+    return lines.join("\n");
+}
+/** Prompt text for the choice input. */
+export function choicePrompt(optionCount, multiple) {
+    return multiple
+        ? t("tool.user_input.choice_multiple")
+        : t("tool.user_input.choice_single", { max: optionCount });
+}
+function createRl() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+function promptLine(rl, prompt) {
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => resolve(answer));
+    });
+}
+/** Free-text question. Returns trimmed answer (may be empty). */
+export async function askText(question) {
+    const rl = createRl();
+    try {
+        const answer = await promptLine(rl, `${question} `);
+        return answer.trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * Choice question: shows a numbered menu and waits for a valid selection.
+ * Returns selected 0-based indexes; CUSTOM_INDEX marks the custom entry.
+ * Re-asks until the input is valid.
+ */
+export async function askChoice(question, options, opts = {}) {
+    const multiple = opts.multiple ?? false;
+    const entryCount = options.length + (opts.allowCustom ? 1 : 0);
+    const customEntry = options.length; // index of the custom entry, if enabled
+    const rl = createRl();
+    try {
+        console.log(formatMenu(question, options, opts));
+        for (;;) {
+            const answer = await promptLine(rl, choicePrompt(entryCount, multiple));
+            const parsed = parseSelection(answer, entryCount, multiple);
+            if (parsed) {
+                return parsed.map((i) => opts.allowCustom && i === customEntry ? CUSTOM_INDEX : i);
+            }
+            console.log(t("tool.user_input.invalid"));
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * High-level helper used by the question tool.
+ * - No options: free-text input, returns [text] or [] when empty.
+ * - With options: returns selected labels; custom entry resolves to typed text.
+ */
+export async function askUser(question, opts = {}) {
+    const header = [opts.progress, opts.header].filter(Boolean).join(" — ");
+    const text = header ? `${header}\n${question}` : question;
+    if (!opts.options || opts.options.length === 0) {
+        const answer = await askText(text);
+        return answer ? [answer] : [];
+    }
+    const allowCustom = opts.custom ?? true;
+    const indexes = await askChoice(text, opts.options, {
+        multiple: opts.multiple,
+        allowCustom,
+    });
+    const labels = [];
+    for (const idx of indexes) {
+        if (idx === CUSTOM_INDEX) {
+            const custom = await askText(t("tool.user_input.custom_prompt"));
+            if (custom)
+                labels.push(custom);
+        }
+        else {
+            labels.push(opts.options[idx].label);
+        }
+    }
+    return labels;
+}

package/dist/tools/web-browse.js

@@ -0,0 +1,51 @@
+import { t } from '../i18n/index';
+import { isUrlAllowed, sanitizeUrl } from '../modules/security/network-validator';
+import { logNetworkRequest, logSecurityBlock } from '../modules/security/audit-log';
+import { getSessionSecurityConfig } from '../modules/security/session-isolation';
+export const webBrowseTool = {
+    name: 'web_browse',
+    description: 'Fetch and read a web page. Returns the page content as plain text.',
+    tags: ['research'],
+    parameters: {
+        type: 'object',
+        properties: {
+            url: { type: 'string', description: 'URL to fetch' },
+        },
+        required: ['url'],
+    },
+    handler: async (ctx, args) => {
+        const url = String(args.url || '');
+        // Get session-specific security config
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext).network
+            : ctx.config.security?.network;
+        const validation = isUrlAllowed(url, securityConfig);
+        if (!validation.allowed) {
+            logSecurityBlock(ctx.sessionId, "network_request", validation.reason || "URL blocked by security policy", sanitizeUrl(url));
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] URL is not allowed: ${validation.reason}`,
+            };
+        }
+        try {
+            const response = await fetch(url, { signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000) });
+            const text = await response.text();
+            const stripped = text
+                .replace(/<script[\s\S]*?<\/script>/gi, '')
+                .replace(/<style[\s\S]*?<\/style>/gi, '')
+                .replace(/<[^>]+>/g, '')
+                .replace(/&[^;]+;/g, ' ')
+                .replace(/\s+/g, ' ')
+                .trim();
+            // Log successful network request
+            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Status: ${response.status}`);
+            const maxLen = securityConfig?.maxResponseSize || 8000;
+            const content = stripped.length > maxLen ? stripped.slice(0, maxLen) + t('file.truncated') : stripped;
+            return { success: true, output: content || t('file.empty_page') };
+        }
+        catch (err) {
+            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Error: ${err.message}`);
+            return { success: false, output: t('error.fetch_url_failed', { url: sanitizeUrl(url), message: err.message }) };
+        }
+    },
+};

package/dist/tools/web-fetch.js

@@ -0,0 +1,62 @@
+import { t } from '../i18n/index';
+import { isUrlAllowed, sanitizeUrl } from '../modules/security/network-validator';
+import { logNetworkRequest, logSecurityBlock } from '../modules/security/audit-log';
+import { getSessionSecurityConfig } from '../modules/security/session-isolation';
+import { DEFAULT_SECURITY_CONFIG } from '../config/security';
+const MAX_CHARS = 15000;
+function stripHtml(html) {
+    return html
+        .replace(/<script[\s\S]*?<\/script>/gi, '')
+        .replace(/<style[\s\S]*?<\/style>/gi, '')
+        .replace(/<[^>]+>/g, '')
+        .replace(/&[^;]+;/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+export const webFetchTool = {
+    name: 'web_fetch',
+    description: 'Fetch a URL and convert its content to markdown. Use for reading documentation, APIs, web pages.',
+    tags: ['research'],
+    parameters: {
+        type: 'object',
+        properties: {
+            url: { type: 'string', description: 'URL to fetch' },
+        },
+        required: ['url'],
+    },
+    handler: async (ctx, args) => {
+        const url = String(args.url);
+        // Get session-specific security config
+        const config = ctx.config || {};
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(config, ctx.sessionContext).network
+            : config.security?.network || DEFAULT_SECURITY_CONFIG.network;
+        const validation = isUrlAllowed(url, securityConfig);
+        if (!validation.allowed) {
+            logSecurityBlock(ctx.sessionId, "network_request", validation.reason || "URL blocked by security policy", sanitizeUrl(url));
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] URL is not allowed: ${validation.reason}`,
+            };
+        }
+        try {
+            const response = await fetch(url, { signal: AbortSignal.timeout(securityConfig?.requestTimeout || 15000) });
+            if (!response.ok) {
+                return { success: false, output: t('error.http', { status: response.status, statusText: response.statusText }) };
+            }
+            const contentType = response.headers.get('content-type') || '';
+            const text = await response.text();
+            const cleaned = contentType.includes('html') ? stripHtml(text) : text;
+            // Log successful network request
+            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Status: ${response.status}`);
+            if (cleaned.length > (securityConfig?.maxResponseSize || MAX_CHARS)) {
+                return { success: true, output: cleaned.slice(0, securityConfig?.maxResponseSize || MAX_CHARS) + t('file.truncated') };
+            }
+            return { success: true, output: cleaned || t('file.empty_page') };
+        }
+        catch (e) {
+            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Error: ${e.message}`);
+            return { success: false, output: t('error.fetch_failed', { message: e.message }) };
+        }
+    },
+};

package/dist/tools/web-search.js

@@ -0,0 +1,59 @@
+import { t } from '../i18n/index';
+import { isUrlAllowed, sanitizeUrl } from '../modules/security/network-validator';
+import { logNetworkRequest, logSecurityBlock } from '../modules/security/audit-log';
+import { getSessionSecurityConfig } from '../modules/security/session-isolation';
+export const webSearchTool = {
+    name: 'web_search',
+    description: 'Search the web for information. Returns search results with titles and snippets.',
+    tags: ['research'],
+    parameters: {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Search query' },
+            numResults: { type: 'number', description: 'Number of results (default 5)' },
+        },
+        required: ['query'],
+    },
+    handler: async (ctx, args) => {
+        const query = String(args.query || '');
+        const numResults = Number(args.numResults) || 5;
+        // Build search URL
+        const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+        // Get session-specific security config
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext).network
+            : ctx.config.security?.network;
+        const validation = isUrlAllowed(url, securityConfig);
+        if (!validation.allowed) {
+            logSecurityBlock(ctx.sessionId, "network_request", validation.reason || "URL blocked by security policy", sanitizeUrl(url));
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] Search URL is not allowed: ${validation.reason}`,
+            };
+        }
+        try {
+            const response = await fetch(url, { signal: AbortSignal.timeout(securityConfig?.requestTimeout || 10000) });
+            const html = await response.text();
+            const results = [];
+            const snippetRegex = /<a[^>]+class="result__a"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
+            let match;
+            let count = 0;
+            while ((match = snippetRegex.exec(html)) !== null && count < numResults) {
+                const title = match[1].replace(/<[^>]+>/g, '').trim();
+                const snippet = match[2].replace(/<[^>]+>/g, '').trim();
+                results.push(`${title}: ${snippet}`);
+                count++;
+            }
+            // Log successful network request
+            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Results: ${results.length}`);
+            if (results.length === 0) {
+                return { success: true, output: t('tool.no_results', { query }) };
+            }
+            return { success: true, output: t('tool.search_results', { query, results: results.join('\n') }) };
+        }
+        catch (err) {
+            logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Error: ${err.message}`);
+            return { success: false, output: t('error.search_failed', { message: err.message }) };
+        }
+    },
+};

package/dist/tools/write-file.js

@@ -0,0 +1,80 @@
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from "fs";
+import { resolve, normalize, dirname } from "path";
+import { t } from "../i18n/index";
+import { isPathWritable } from "../modules/security/path-validator";
+import { scanContent } from "../modules/security/content-scanner";
+import { logFileWrite, logSecurityBlock } from "../modules/security/audit-log";
+import { getSessionSecurityConfig } from "../modules/security/session-isolation";
+import { generateDiff, generateNewFileDiff } from "../ui/diff";
+export const writeFileTool = {
+    name: "write_file",
+    description: "Create or overwrite a file with given content. Creates intermediate directories if needed.",
+    tags: ["file", "code"],
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "File path" },
+            content: { type: "string", description: "File content" },
+        },
+        required: ["path", "content"],
+    },
+    handler: async (ctx, args) => {
+        const path = String(args.path);
+        const baseDir = resolve(ctx.baseDir);
+        const resolved = resolve(baseDir, normalize(path));
+        // Check path permissions
+        const scopeCheck = isPathWritable(ctx.baseDir, path, ctx.scope, ctx.config.security?.paths);
+        if (!scopeCheck.allowed) {
+            logSecurityBlock(ctx.sessionId, "file_write", scopeCheck.reason || "Path not allowed", path);
+            return {
+                success: false,
+                output: t("file.path_not_allowed", {
+                    path: `${path} — ${scopeCheck.reason}`,
+                }),
+            };
+        }
+        // Get session-specific security config
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext)
+            : ctx.config.security;
+        // Check file operations limit
+        const maxFileOps = securityConfig?.maxFileOperations ?? 100;
+        const currentCount = ctx.fileOperationsCount ?? 0;
+        if (currentCount >= maxFileOps) {
+            logSecurityBlock(ctx.sessionId, "file_write", `Maximum file operations (${maxFileOps}) exceeded`, path);
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] Maximum file operations (${maxFileOps}) exceeded`,
+            };
+        }
+        // Check content for dangerous patterns
+        const content = String(args.content);
+        const scanResult = scanContent(content, path, ctx.config.security?.contentScan);
+        if (!scanResult.allowed) {
+            logSecurityBlock(ctx.sessionId, "file_write", scanResult.reason || "Content contains dangerous patterns", path);
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] ${scanResult.reason}`,
+            };
+        }
+        const dir = dirname(resolved);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        const fileExists = existsSync(resolved);
+        let oldContent = "";
+        if (fileExists) {
+            oldContent = readFileSync(resolved, "utf-8");
+        }
+        writeFileSync(resolved, content, "utf-8");
+        const diff = fileExists
+            ? generateDiff(oldContent, content)
+            : generateNewFileDiff(content);
+        // Increment file operations counter
+        ctx.fileOperationsCount = currentCount + 1;
+        // Log successful file write
+        logFileWrite(ctx.sessionId, path, true, `File ${fileExists ? 'updated' : 'created'}`);
+        ctx.trackCreatedPath?.(path);
+        return { success: true, output: t("file.written", { path }), diff };
+    },
+};

package/dist/ui/box.js

@@ -0,0 +1,81 @@
+import stringWidth from "string-width";
+import { pc } from "./colors";
+import { getTerminalWidth } from "./table";
+/** Wrap a string to `width` columns, keeping ANSI codes intact. */
+export function wrapText(text, width) {
+    if (width < 1)
+        return text ? [text] : [];
+    const lines = [];
+    let current = "";
+    const push = (token) => {
+        const candidate = current ? `${current} ${token}` : token;
+        if (stringWidth(candidate) <= width) {
+            current = candidate;
+            return;
+        }
+        if (current) {
+            lines.push(current);
+            current = "";
+        }
+        if (stringWidth(token) <= width) {
+            current = token;
+            return;
+        }
+        let acc = "";
+        for (const ch of token) {
+            if (stringWidth(acc + ch) <= width) {
+                acc += ch;
+            }
+            else {
+                lines.push(acc);
+                acc = ch;
+            }
+        }
+        current = acc;
+    };
+    for (const token of text.split(/\s+/)) {
+        if (token)
+            push(token);
+    }
+    if (current)
+        lines.push(current);
+    return lines.length ? lines : [""];
+}
+function padTo(text, width) {
+    const gap = Math.max(0, width - stringWidth(text));
+    return text + " ".repeat(gap);
+}
+/** Render a box with an optional title embedded in the top border. */
+export function box(lines, opts = {}) {
+    const pad = opts.padding ?? 1;
+    const width = Math.max(20, Math.min(opts.width ?? getTerminalWidth(), 120));
+    const inner = Math.max(1, width - 2 - pad * 2);
+    const wrapped = [];
+    for (const line of lines) {
+        for (const part of wrapText(line, inner))
+            wrapped.push(part);
+    }
+    const out = [];
+    const title = opts.title ?? "";
+    if (title) {
+        const head = `─ ${title} `;
+        out.push(pc.dim(`┌${head}${"─".repeat(Math.max(0, width - 2 - stringWidth(head)))}┐`));
+    }
+    else {
+        out.push(pc.dim(`┌${"─".repeat(width - 2)}┐`));
+    }
+    for (const line of wrapped) {
+        out.push(pc.dim("│") +
+            " ".repeat(pad) +
+            padTo(line, inner) +
+            " ".repeat(pad) +
+            pc.dim("│"));
+    }
+    out.push(pc.dim(`└${"─".repeat(width - 2)}┘`));
+    return out;
+}
+/** A horizontal rule that respects the terminal width (max 60 cols). */
+export function divider(width) {
+    const w = Math.min(width ?? getTerminalWidth(), 60);
+    return pc.dim("─".repeat(w));
+}

package/dist/ui/colors.js

@@ -0,0 +1,4 @@
+import { createColors } from "picocolors";
+const isTty = () => process.stdout.isTTY === true;
+const enabled = isTty() && !process.env.CI && !process.env.NO_COLOR;
+export const pc = createColors(enabled);