@portel/cli 1.0.0

package/dist/cli-formatter.d.ts

@@ -0,0 +1,65 @@
+/**
+ * CLI Output Formatter
+ *
+ * Shared formatting utilities for beautiful CLI output.
+ * Used by photon CLI, lumina, ncp, and other projects.
+ *
+ * Structural formats:
+ * - primitive: Single values (string, number, boolean)
+ * - table: Flat objects or arrays of flat objects (bordered tables)
+ * - tree: Nested/hierarchical structures (indented)
+ * - list: Arrays of primitives (bullet points)
+ * - none: No data to display
+ *
+ * Content formats:
+ * - json: Pretty-printed JSON
+ * - markdown: Rendered markdown
+ * - yaml: YAML content
+ * - code / code:<lang>: Syntax highlighted code
+ */
+import type { OutputFormat } from './types.js';
+/**
+ * Format and output data with optional format hint
+ */
+export declare function formatOutput(data: any, hint?: OutputFormat): void;
+/**
+ * Detect format type from data structure
+ */
+export declare function detectFormat(data: any): OutputFormat;
+export declare function renderPrimitive(value: any): void;
+export declare function renderList(data: any[]): void;
+export declare function renderTable(data: any): void;
+export declare function renderTree(data: any, indent?: string): void;
+/**
+ * Render data as a bordered card
+ * Great for single objects with mixed content types
+ */
+export declare function renderCard(data: any): void;
+/**
+ * Render data as tabbed sections
+ * Each top-level key becomes a tab
+ */
+export declare function renderTabs(data: any): void;
+/**
+ * Render data as collapsible accordion sections
+ * Similar to tabs but with visual collapse indicators
+ */
+export declare function renderAccordion(data: any): void;
+export declare function renderNone(): void;
+export declare function formatKey(key: string): string;
+export declare function formatValue(value: any): string | number | boolean;
+export declare const STATUS: {
+    readonly OK: "ok";
+    readonly UPDATE: "update";
+    readonly WARN: "warn";
+    readonly ERROR: "!";
+    readonly OFF: "off";
+    readonly UNKNOWN: "?";
+};
+export declare function formatToMimeType(format: OutputFormat): string | undefined;
+export declare function printSuccess(message: string): void;
+export declare function printError(message: string): void;
+export declare function printInfo(message: string): void;
+export declare function printWarning(message: string): void;
+export declare function printHeader(title: string): void;
+//# sourceMappingURL=cli-formatter.d.ts.map

package/dist/cli-formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-formatter.d.ts","sourceRoot":"","sources":["../src/cli-formatter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,YAAY,GAAG,IAAI,CASjE;AAyJD;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,YAAY,CAuBpD;AAUD,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,GAAG,IAAI,CAMhD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAgB5C;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI,CA2E3C;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,GAAE,MAAW,GAAG,IAAI,CAwC/D;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI,CAU1C;AA8ED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI,CAuC1C;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI,CAsD/C;AAED,wBAAgB,UAAU,IAAI,IAAI,CAEjC;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAO7C;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAIjE;AAED,eAAO,MAAM,MAAM;;;;;;;CAOT,CAAC;AAEX,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,GAAG,SAAS,CAazE;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAElD;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAEhD;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE/C;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAElD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAG/C"}

package/dist/cli-formatter.js

@@ -0,0 +1,585 @@
+/**
+ * CLI Output Formatter
+ *
+ * Shared formatting utilities for beautiful CLI output.
+ * Used by photon CLI, lumina, ncp, and other projects.
+ *
+ * Structural formats:
+ * - primitive: Single values (string, number, boolean)
+ * - table: Flat objects or arrays of flat objects (bordered tables)
+ * - tree: Nested/hierarchical structures (indented)
+ * - list: Arrays of primitives (bullet points)
+ * - none: No data to display
+ *
+ * Content formats:
+ * - json: Pretty-printed JSON
+ * - markdown: Rendered markdown
+ * - yaml: YAML content
+ * - code / code:<lang>: Syntax highlighted code
+ */
+import { highlight } from 'cli-highlight';
+import chalk from 'chalk';
+/**
+ * Format and output data with optional format hint
+ */
+export function formatOutput(data, hint) {
+    const format = hint || detectFormat(data);
+    if (typeof data === 'string' && isContentFormat(format)) {
+        renderContent(data, format);
+        return;
+    }
+    formatDataWithHint(data, format);
+}
+function isContentFormat(format) {
+    return ['json', 'markdown', 'yaml', 'xml', 'html'].includes(format) ||
+        format === 'code' ||
+        format.startsWith('code:');
+}
+function renderContent(content, format) {
+    switch (format) {
+        case 'json':
+            renderJson(content);
+            break;
+        case 'markdown':
+            renderMarkdown(content);
+            break;
+        case 'yaml':
+            renderYaml(content);
+            break;
+        case 'xml':
+        case 'html':
+            renderXml(content);
+            break;
+        default:
+            if (format === 'code' || format.startsWith('code:')) {
+                const lang = format === 'code' ? undefined : format.split(':')[1];
+                renderCode(content, lang);
+            }
+            else {
+                console.log(content);
+            }
+    }
+}
+function renderJson(content) {
+    try {
+        const parsed = typeof content === 'string' ? JSON.parse(content) : content;
+        const formatted = JSON.stringify(parsed, null, 2);
+        console.log(highlight(formatted, { language: 'json', ignoreIllegals: true }));
+    }
+    catch {
+        console.log(content);
+    }
+}
+/**
+ * Render markdown with colored terminal output
+ */
+function renderMarkdown(content) {
+    let rendered = content;
+    // Code blocks
+    rendered = rendered.replace(/```(\w*)\n([\s\S]*?)```/g, (_match, lang, code) => {
+        const trimmedCode = code.trim();
+        if (lang && lang !== '') {
+            try {
+                return '\n' + highlight(trimmedCode, { language: lang, ignoreIllegals: true }) + '\n';
+            }
+            catch {
+                return '\n' + chalk.gray(trimmedCode) + '\n';
+            }
+        }
+        return '\n' + chalk.gray(trimmedCode) + '\n';
+    });
+    // Links
+    rendered = rendered.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, text, url) => chalk.blue.underline(text) + chalk.dim(` (${url})`));
+    // Headers
+    rendered = rendered
+        .replace(/^### (.+)$/gm, (_m, h) => '\n' + chalk.cyan('   ' + h) + '\n   ' + chalk.dim('-'.repeat(20)))
+        .replace(/^## (.+)$/gm, (_m, h) => '\n' + chalk.yellow.bold('  ' + h) + '\n  ' + chalk.dim('='.repeat(30)))
+        .replace(/^# (.+)$/gm, (_m, h) => '\n' + chalk.magenta.bold(h) + '\n' + chalk.dim('='.repeat(40)));
+    // Blockquotes
+    rendered = rendered.replace(/^> (.+)$/gm, (_m, quote) => chalk.dim('│ ') + chalk.italic(quote));
+    // Horizontal rules
+    rendered = rendered.replace(/^---+$/gm, chalk.dim('─'.repeat(40)));
+    // Lists
+    rendered = rendered.replace(/^- /gm, chalk.dim('  • '));
+    rendered = rendered.replace(/^(\d+)\. /gm, (_m, num) => chalk.dim(`  ${num}. `));
+    // Bold and italic
+    rendered = rendered.replace(/\*\*(.+?)\*\*/g, (_m, text) => chalk.bold(text));
+    rendered = rendered.replace(/\*(.+?)\*/g, (_m, text) => chalk.italic(text));
+    rendered = rendered.replace(/_(.+?)_/g, (_m, text) => chalk.italic(text));
+    // Inline code
+    rendered = rendered.replace(/`([^`]+)`/g, (_m, code) => chalk.cyan(code));
+    console.log(rendered);
+}
+function renderYaml(content) {
+    try {
+        console.log(highlight(content, { language: 'yaml', ignoreIllegals: true }));
+    }
+    catch {
+        console.log(content);
+    }
+}
+function renderXml(content) {
+    try {
+        console.log(highlight(content, { language: 'xml', ignoreIllegals: true }));
+    }
+    catch {
+        console.log(content);
+    }
+}
+function renderCode(content, lang) {
+    try {
+        if (lang) {
+            console.log(highlight(content, { language: lang, ignoreIllegals: true }));
+        }
+        else {
+            console.log(highlight(content, { ignoreIllegals: true }));
+        }
+    }
+    catch {
+        console.log(content);
+    }
+}
+function formatDataWithHint(data, format) {
+    switch (format) {
+        case 'primitive':
+            renderPrimitive(data);
+            break;
+        case 'list':
+            renderList(Array.isArray(data) ? data : [data]);
+            break;
+        case 'table':
+            renderTable(data);
+            break;
+        case 'tree':
+            renderTree(data);
+            break;
+        case 'card':
+            renderCard(data);
+            break;
+        case 'tabs':
+            renderTabs(data);
+            break;
+        case 'accordion':
+            renderAccordion(data);
+            break;
+        case 'none':
+            renderNone();
+            break;
+    }
+}
+/**
+ * Detect format type from data structure
+ */
+export function detectFormat(data) {
+    if (data === null || data === undefined) {
+        return 'none';
+    }
+    if (typeof data === 'string' || typeof data === 'number' || typeof data === 'boolean') {
+        return 'primitive';
+    }
+    if (Array.isArray(data)) {
+        if (data.length === 0)
+            return 'list';
+        const firstItem = data[0];
+        if (typeof firstItem !== 'object' || firstItem === null)
+            return 'list';
+        if (isFlatObject(firstItem))
+            return 'table';
+        return 'tree';
+    }
+    if (typeof data === 'object') {
+        if (isFlatObject(data))
+            return 'table';
+        return 'tree';
+    }
+    return 'none';
+}
+function isFlatObject(obj) {
+    if (typeof obj !== 'object' || obj === null)
+        return false;
+    for (const value of Object.values(obj)) {
+        if (typeof value === 'object' && value !== null)
+            return false;
+    }
+    return true;
+}
+export function renderPrimitive(value) {
+    if (typeof value === 'boolean') {
+        console.log(value ? 'yes' : 'no');
+    }
+    else {
+        console.log(value);
+    }
+}
+export function renderList(data) {
+    if (data.length === 0) {
+        console.log('(empty)');
+        return;
+    }
+    // Check if items are objects - if so, render as table instead
+    const firstItem = data[0];
+    if (typeof firstItem === 'object' && firstItem !== null && !Array.isArray(firstItem)) {
+        // For arrays of objects, delegate to table rendering for better display
+        renderTable(data);
+        return;
+    }
+    // Simple list for primitives
+    data.forEach(item => console.log(`  * ${item}`));
+}
+export function renderTable(data) {
+    if (!Array.isArray(data)) {
+        const entries = Object.entries(data).filter(([key, value]) => !(key === 'returnValue' && value === true));
+        if (entries.length === 0) {
+            console.log('(empty)');
+            return;
+        }
+        const maxKeyLength = Math.max(...entries.map(([k]) => formatKey(k).length));
+        const maxValueLength = Math.max(...entries.map(([_, v]) => String(formatValue(v)).length));
+        console.log(`┌─${'─'.repeat(maxKeyLength)}─┬─${'─'.repeat(maxValueLength)}─┐`);
+        for (let i = 0; i < entries.length; i++) {
+            const [key, value] = entries[i];
+            const formattedKey = formatKey(key);
+            const formattedValue = String(formatValue(value));
+            const keyPadding = ' '.repeat(maxKeyLength - formattedKey.length);
+            const valuePadding = ' '.repeat(maxValueLength - formattedValue.length);
+            console.log(`| ${formattedKey}${keyPadding} | ${formattedValue}${valuePadding} |`);
+            if (i < entries.length - 1) {
+                console.log(`├─${'─'.repeat(maxKeyLength)}─┼─${'─'.repeat(maxValueLength)}─┤`);
+            }
+        }
+        console.log(`└─${'─'.repeat(maxKeyLength)}─┴─${'─'.repeat(maxValueLength)}─┘`);
+        return;
+    }
+    if (data.length === 0) {
+        console.log('(empty)');
+        return;
+    }
+    const allKeys = Array.from(new Set(data.flatMap(obj => Object.keys(obj)))).filter(k => k !== 'returnValue');
+    if (allKeys.length === 0) {
+        console.log('(no data)');
+        return;
+    }
+    const columnWidths = new Map();
+    for (const key of allKeys) {
+        const headerWidth = formatKey(key).length;
+        const maxValueWidth = Math.max(...data.map(obj => String(formatValue(obj[key] ?? '')).length));
+        columnWidths.set(key, Math.max(headerWidth, maxValueWidth));
+    }
+    const topBorderParts = allKeys.map(key => '─'.repeat(columnWidths.get(key) + 2));
+    console.log('┌' + topBorderParts.join('┬') + '┐');
+    const headerParts = allKeys.map(key => {
+        const formattedKey = formatKey(key);
+        const width = columnWidths.get(key);
+        return ' ' + formattedKey.padEnd(width) + ' ';
+    });
+    console.log('│' + headerParts.join('│') + '│');
+    const separatorParts = allKeys.map(key => '─'.repeat(columnWidths.get(key) + 2));
+    console.log('├' + separatorParts.join('┼') + '┤');
+    for (const row of data) {
+        const rowParts = allKeys.map(key => {
+            const value = formatValue(row[key] ?? '');
+            const width = columnWidths.get(key);
+            return ' ' + String(value).padEnd(width) + ' ';
+        });
+        console.log('│' + rowParts.join('│') + '│');
+    }
+    const bottomBorderParts = allKeys.map(key => '─'.repeat(columnWidths.get(key) + 2));
+    console.log('└' + bottomBorderParts.join('┴') + '┘');
+}
+export function renderTree(data, indent = '') {
+    if (Array.isArray(data)) {
+        if (data.length === 0) {
+            console.log(`${indent}(empty)`);
+            return;
+        }
+        data.forEach((item, index) => {
+            if (typeof item === 'object' && item !== null) {
+                console.log(`${indent}[${index}]`);
+                renderTree(item, indent + '  ');
+            }
+            else {
+                console.log(`${indent}* ${item}`);
+            }
+        });
+        return;
+    }
+    if (typeof data === 'object' && data !== null) {
+        const entries = Object.entries(data).filter(([key, value]) => !(key === 'returnValue' && value === true));
+        for (const [key, value] of entries) {
+            const formattedKey = formatKey(key);
+            if (value === null || value === undefined) {
+                console.log(`${indent}${formattedKey}: (none)`);
+            }
+            else if (Array.isArray(value)) {
+                console.log(`${indent}${formattedKey}:`);
+                renderTree(value, indent + '  ');
+            }
+            else if (typeof value === 'object') {
+                console.log(`${indent}${formattedKey}:`);
+                renderTree(value, indent + '  ');
+            }
+            else {
+                console.log(`${indent}${formattedKey}: ${formatValue(value)}`);
+            }
+        }
+        return;
+    }
+    console.log(`${indent}${formatValue(data)}`);
+}
+/**
+ * Render data as a bordered card
+ * Great for single objects with mixed content types
+ */
+export function renderCard(data) {
+    if (Array.isArray(data)) {
+        // Multiple cards
+        data.forEach((item, index) => {
+            if (index > 0)
+                console.log('');
+            renderSingleCard(item);
+        });
+    }
+    else {
+        renderSingleCard(data);
+    }
+}
+function renderSingleCard(data) {
+    if (typeof data !== 'object' || data === null) {
+        console.log(data);
+        return;
+    }
+    const entries = Object.entries(data).filter(([key]) => key !== 'returnValue');
+    if (entries.length === 0) {
+        console.log('(empty)');
+        return;
+    }
+    // Calculate width based on content
+    const maxKeyLength = Math.max(...entries.map(([k]) => formatKey(k).length));
+    const width = Math.min(Math.max(maxKeyLength + 40, 50), 80);
+    // Card top border
+    console.log(chalk.dim('┌' + '─'.repeat(width - 2) + '┐'));
+    // Card content
+    for (const [key, value] of entries) {
+        const formattedKey = chalk.bold(formatKey(key));
+        if (Array.isArray(value)) {
+            // Render arrays inline or as bullets
+            console.log(chalk.dim('│') + ` ${formattedKey}:`);
+            if (value.length === 0) {
+                console.log(chalk.dim('│') + '   (empty)');
+            }
+            else if (typeof value[0] === 'object') {
+                // Array of objects - render as mini-table
+                value.forEach((item, idx) => {
+                    const summary = typeof item === 'object'
+                        ? Object.entries(item).slice(0, 2).map(([k, v]) => `${formatKey(k)}: ${formatValue(v)}`).join(', ')
+                        : String(item);
+                    console.log(chalk.dim('│') + `   ${chalk.cyan(`[${idx}]`)} ${summary}`);
+                });
+            }
+            else {
+                // Array of primitives - render as bullets
+                value.forEach(item => {
+                    console.log(chalk.dim('│') + `   • ${formatValue(item)}`);
+                });
+            }
+        }
+        else if (typeof value === 'object' && value !== null) {
+            // Nested object - render inline
+            console.log(chalk.dim('│') + ` ${formattedKey}:`);
+            for (const [subKey, subVal] of Object.entries(value)) {
+                console.log(chalk.dim('│') + `   ${formatKey(subKey)}: ${formatValue(subVal)}`);
+            }
+        }
+        else {
+            // Simple value
+            const formattedValue = formatCardValue(value);
+            console.log(chalk.dim('│') + ` ${formattedKey}: ${formattedValue}`);
+        }
+    }
+    // Card bottom border
+    console.log(chalk.dim('└' + '─'.repeat(width - 2) + '┘'));
+}
+function formatCardValue(value) {
+    if (value === null || value === undefined)
+        return chalk.dim('-');
+    if (typeof value === 'boolean')
+        return value ? chalk.green('yes') : chalk.red('no');
+    if (typeof value === 'number')
+        return chalk.yellow(String(value));
+    if (typeof value === 'string') {
+        // Check for URLs
+        if (value.startsWith('http://') || value.startsWith('https://')) {
+            return chalk.blue.underline(value);
+        }
+        // Check for dates
+        if (/^\d{4}-\d{2}-\d{2}/.test(value)) {
+            return chalk.cyan(value);
+        }
+    }
+    return String(value);
+}
+/**
+ * Render data as tabbed sections
+ * Each top-level key becomes a tab
+ */
+export function renderTabs(data) {
+    if (typeof data !== 'object' || data === null || Array.isArray(data)) {
+        console.log('Tabs format requires an object with sections');
+        renderTree(data);
+        return;
+    }
+    const sections = Object.entries(data).filter(([key]) => key !== 'returnValue');
+    sections.forEach(([title, content], index) => {
+        // Tab separator
+        if (index > 0) {
+            console.log('\n' + chalk.dim('─'.repeat(60)));
+        }
+        // Tab header
+        console.log(chalk.bold.cyan(`\n▸ ${formatKey(title)}`));
+        console.log('');
+        // Tab content
+        if (content === null || content === undefined) {
+            console.log('  (empty)');
+        }
+        else if (Array.isArray(content)) {
+            if (content.length === 0) {
+                console.log('  (empty)');
+            }
+            else if (typeof content[0] === 'object') {
+                // Array of objects - render as table
+                renderTable(content);
+            }
+            else {
+                // Array of primitives - render as list
+                content.forEach(item => console.log(`  • ${formatValue(item)}`));
+            }
+        }
+        else if (typeof content === 'object') {
+            // Nested object - render as indented tree
+            renderTree(content, '  ');
+        }
+        else {
+            console.log(`  ${formatValue(content)}`);
+        }
+    });
+}
+/**
+ * Render data as collapsible accordion sections
+ * Similar to tabs but with visual collapse indicators
+ */
+export function renderAccordion(data) {
+    if (Array.isArray(data)) {
+        // Array of items - each becomes an accordion section
+        data.forEach((item, index) => {
+            if (index > 0)
+                console.log('');
+            if (typeof item === 'object' && item !== null) {
+                // Use title/name/label field as header, or index
+                const title = item.title || item.name || item.label || `Item ${index + 1}`;
+                const content = item.content || item.data || item;
+                console.log(chalk.bold(`▼ ${title}`));
+                if (typeof content === 'object') {
+                    // Filter out the title field from display
+                    const filtered = Object.fromEntries(Object.entries(content).filter(([k]) => !['title', 'name', 'label'].includes(k)));
+                    renderTree(filtered, '  ');
+                }
+                else {
+                    console.log(`  ${formatValue(content)}`);
+                }
+            }
+            else {
+                console.log(`▼ ${formatValue(item)}`);
+            }
+        });
+    }
+    else if (typeof data === 'object' && data !== null) {
+        // Object - each key becomes an accordion section
+        const entries = Object.entries(data).filter(([key]) => key !== 'returnValue');
+        entries.forEach(([key, value], index) => {
+            if (index > 0)
+                console.log('');
+            console.log(chalk.bold(`▼ ${formatKey(key)}`));
+            if (value === null || value === undefined) {
+                console.log('  (empty)');
+            }
+            else if (Array.isArray(value)) {
+                value.forEach(item => {
+                    if (typeof item === 'object') {
+                        renderTree(item, '  ');
+                    }
+                    else {
+                        console.log(`  • ${formatValue(item)}`);
+                    }
+                });
+            }
+            else if (typeof value === 'object') {
+                renderTree(value, '  ');
+            }
+            else {
+                console.log(`  ${formatValue(value)}`);
+            }
+        });
+    }
+    else {
+        console.log(formatValue(data));
+    }
+}
+export function renderNone() {
+    console.log('Done');
+}
+export function formatKey(key) {
+    return key
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/_/g, ' ')
+        .replace(/^./, str => str.toUpperCase())
+        .trim();
+}
+export function formatValue(value) {
+    if (value === null || value === undefined)
+        return '-';
+    if (typeof value === 'boolean')
+        return value ? 'yes' : 'no';
+    return value;
+}
+export const STATUS = {
+    OK: 'ok',
+    UPDATE: 'update',
+    WARN: 'warn',
+    ERROR: '!',
+    OFF: 'off',
+    UNKNOWN: '?',
+};
+export function formatToMimeType(format) {
+    const mimeTypes = {
+        json: 'application/json',
+        markdown: 'text/markdown',
+        yaml: 'text/yaml',
+        xml: 'application/xml',
+        html: 'text/html',
+    };
+    if (mimeTypes[format])
+        return mimeTypes[format];
+    if (format === 'code')
+        return 'text/plain';
+    if (format.startsWith('code:'))
+        return `text/x-${format.split(':')[1]}`;
+    return undefined;
+}
+export function printSuccess(message) {
+    console.error(`✓ ${message}`);
+}
+export function printError(message) {
+    console.error(`✗ ${message}`);
+}
+export function printInfo(message) {
+    console.error(`${message}`);
+}
+export function printWarning(message) {
+    console.error(`! ${message}`);
+}
+export function printHeader(title) {
+    console.error(`\n${title}`);
+    console.error('─'.repeat(title.length));
+}
+//# sourceMappingURL=cli-formatter.js.map