browser-debugger-cli 0.7.1 → 0.8.0

package/dist/ui/formatters/console/json.js

@@ -0,0 +1,53 @@
+/**
+ * JSON output for console command. Includes summary statistics and
+ * deduplicated errors/warnings; full message list is included only when
+ * --list is set.
+ */
+import { analyzeMessages, } from './shared.js';
+function toJsonError(dedup, includeStackTrace) {
+    const source = dedup.message.stackTrace?.[0];
+    return {
+        count: dedup.count,
+        level: dedup.message.type,
+        text: dedup.message.text,
+        ...(dedup.message.index !== undefined && { index: dedup.message.index }),
+        ...(source && {
+            source: {
+                url: source.url,
+                ...(source.lineNumber >= 0 && {
+                    line: source.lineNumber + 1,
+                    column: source.columnNumber + 1,
+                }),
+            },
+        }),
+        ...(includeStackTrace && dedup.message.stackTrace && { stackTrace: dedup.message.stackTrace }),
+    };
+}
+/**
+ * Build the rich JSON output shape (summary + deduped errors/warnings, plus
+ * the full message list when --list is requested).
+ *
+ * Returns a plain object so callers (e.g. runCommand's JSON envelope) can
+ * embed it without re-parsing a stringified payload.
+ */
+export function buildConsoleJsonOutput(messages, options) {
+    const { grouped, summary } = analyzeMessages(messages);
+    const output = {
+        summary,
+        errors: grouped.errors.map((d) => toJsonError(d, true)),
+        warnings: grouped.warnings.map((d) => toJsonError(d, false)),
+    };
+    if (options.list) {
+        const displayMessages = options.last && options.last > 0 ? messages.slice(-options.last) : messages;
+        output.messages = displayMessages;
+    }
+    return output;
+}
+/**
+ * Format console output as a JSON string. Thin wrapper around
+ * buildConsoleJsonOutput for callers that want a serialized payload.
+ */
+export function formatConsoleJson(messages, options) {
+    return JSON.stringify(buildConsoleJsonOutput(messages, options), null, 2);
+}
+//# sourceMappingURL=json.js.map

package/dist/ui/formatters/console/shared.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Shared types, constants, and helpers used by every console formatter.
+ */
+import type { ConsoleLevel, ConsoleMessage, StackFrame } from '../../../types.js';
+export type { ConsoleLevel } from '../../../types.js';
+/**
+ * Internal console level including 'other' for classification.
+ */
+export type ConsoleInternalLevel = ConsoleLevel | 'other';
+/**
+ * Deduplicated console message with occurrence count.
+ */
+export interface DeduplicatedMessage {
+    /** First occurrence of the message */
+    message: ConsoleMessage;
+    /** Number of times this message appeared */
+    count: number;
+}
+/**
+ * Summary statistics for console messages.
+ */
+export interface ConsoleSummary {
+    /** Total number of messages */
+    total: number;
+    /** Error statistics */
+    errors: {
+        total: number;
+        unique: number;
+    };
+    /** Warning statistics */
+    warnings: {
+        total: number;
+        unique: number;
+    };
+    /** Info message count */
+    info: number;
+    /** Debug message count */
+    debug: number;
+    /** Other message type count */
+    other: number;
+}
+/**
+ * Options for console formatting.
+ */
+export interface ConsoleFormatOptions {
+    /** Output as JSON */
+    json?: boolean | undefined;
+    /** List all messages chronologically (--list flag) */
+    list?: boolean | undefined;
+    /** Follow mode (live streaming) */
+    follow?: boolean | undefined;
+    /** Limit to last N messages */
+    last?: number | undefined;
+    /** Show messages from all navigations (default: current only) */
+    history?: boolean | undefined;
+    /** Filter by level (error, warning, info, debug) */
+    level?: ConsoleLevel | undefined;
+}
+/**
+ * JSON error/warning entry structure.
+ */
+export interface JsonErrorEntry {
+    count: number;
+    level: string;
+    text: string;
+    /** Position in the session's message list (what `details console <n>` takes) */
+    index?: number;
+    /** Where it came from; no line/column for a resource URL (e.g. a failed load) */
+    source?: {
+        url: string;
+        line?: number;
+        column?: number;
+    };
+    stackTrace?: StackFrame[];
+}
+/**
+ * JSON output structure for console command.
+ */
+export interface ConsoleJsonOutput {
+    summary: ConsoleSummary;
+    errors: JsonErrorEntry[];
+    warnings: Omit<JsonErrorEntry, 'stackTrace'>[];
+    messages?: ConsoleMessage[];
+}
+/**
+ * Messages grouped by level with deduplication applied.
+ */
+export interface GroupedMessages {
+    errors: DeduplicatedMessage[];
+    warnings: DeduplicatedMessage[];
+    counts: Record<ConsoleInternalLevel, number>;
+}
+/**
+ * Result from message analysis.
+ */
+export interface AnalysisResult {
+    grouped: GroupedMessages;
+    summary: ConsoleSummary;
+}
+/**
+ * Mapping from console message types to level categories.
+ * Exported for use by console command filtering.
+ */
+export declare const LEVEL_MAP: Record<ConsoleMessage['type'], ConsoleInternalLevel>;
+/**
+ * Format timestamp with milliseconds precision.
+ */
+export declare function formatTimestamp(timestamp: number): string;
+/**
+ * Analyze console messages: group, deduplicate, and summarize.
+ */
+export declare function analyzeMessages(messages: ConsoleMessage[]): AnalysisResult;
+/**
+ * Format source location as "file:line:col".
+ *
+ * A frame without a position (lineNumber -1, e.g. the URL of a failed load)
+ * is shown as its full URL.
+ */
+export declare function formatSourceLocation(stackTrace?: StackFrame[]): string | undefined;
+/**
+ * Format count prefix for deduplicated messages.
+ */
+export declare function formatCountPrefix(count: number): string;
+/**
+ * Format section header with unique/total counts.
+ */
+export declare function formatSectionHeader(label: string, unique: number, total: number): string;
+/**
+ * A stack frame as "url:line:column" (1-based), or just the URL for a frame
+ * without a position (lineNumber -1, e.g. a failed resource load).
+ *
+ * @param frame - Stack frame
+ * @returns Location text
+ */
+export declare function formatFramePosition(frame: StackFrame): string;
+//# sourceMappingURL=shared.d.ts.map

package/dist/ui/formatters/console/shared.js

@@ -0,0 +1,158 @@
+/**
+ * Shared types, constants, and helpers used by every console formatter.
+ */
+/**
+ * Mapping from console message types to level categories.
+ * Exported for use by console command filtering.
+ */
+export const LEVEL_MAP = {
+    error: 'error',
+    warning: 'warning',
+    info: 'info',
+    log: 'info',
+    debug: 'debug',
+    trace: 'debug',
+    dir: 'other',
+    dirxml: 'other',
+    table: 'other',
+    clear: 'other',
+    startGroup: 'other',
+    startGroupCollapsed: 'other',
+    endGroup: 'other',
+    assert: 'error',
+    profile: 'other',
+    profileEnd: 'other',
+    count: 'other',
+    timeEnd: 'other',
+};
+function classifyLevel(type) {
+    return LEVEL_MAP[type];
+}
+/**
+ * Format timestamp with milliseconds precision.
+ */
+export function formatTimestamp(timestamp) {
+    const date = new Date(timestamp);
+    const hours = date.getHours().toString().padStart(2, '0');
+    const minutes = date.getMinutes().toString().padStart(2, '0');
+    const seconds = date.getSeconds().toString().padStart(2, '0');
+    const ms = date.getMilliseconds().toString().padStart(3, '0');
+    return `${hours}:${minutes}:${seconds}.${ms}`;
+}
+function getDeduplicationKey(message) {
+    const source = message.stackTrace?.[0];
+    if (source) {
+        return `${message.text}|${source.url}|${source.lineNumber}|${source.columnNumber}`;
+    }
+    return message.text;
+}
+function deduplicate(messages) {
+    const groups = new Map();
+    for (const message of messages) {
+        const key = getDeduplicationKey(message);
+        const existing = groups.get(key);
+        if (existing) {
+            existing.count++;
+        }
+        else {
+            groups.set(key, { message, count: 1 });
+        }
+    }
+    return Array.from(groups.values());
+}
+function groupByLevel(messages) {
+    const byLevel = {
+        error: [],
+        warning: [],
+        info: [],
+        debug: [],
+        other: [],
+    };
+    for (const msg of messages) {
+        byLevel[classifyLevel(msg.type)].push(msg);
+    }
+    return {
+        errors: deduplicate(byLevel.error),
+        warnings: deduplicate(byLevel.warning),
+        counts: {
+            error: byLevel.error.length,
+            warning: byLevel.warning.length,
+            info: byLevel.info.length,
+            debug: byLevel.debug.length,
+            other: byLevel.other.length,
+        },
+    };
+}
+function buildSummary(total, grouped) {
+    const sumCounts = (items) => items.reduce((sum, d) => sum + d.count, 0);
+    return {
+        total,
+        errors: { total: sumCounts(grouped.errors), unique: grouped.errors.length },
+        warnings: { total: sumCounts(grouped.warnings), unique: grouped.warnings.length },
+        info: grouped.counts.info,
+        debug: grouped.counts.debug,
+        other: grouped.counts.other,
+    };
+}
+/**
+ * Analyze console messages: group, deduplicate, and summarize.
+ */
+export function analyzeMessages(messages) {
+    const grouped = groupByLevel(messages);
+    const summary = buildSummary(messages.length, grouped);
+    return { grouped, summary };
+}
+function getFilenameFromUrl(url, functionName) {
+    if (!url || url === '') {
+        return functionName ? `<${functionName}>` : '<inline>';
+    }
+    if (url.startsWith('eval')) {
+        return '<eval>';
+    }
+    if (url.includes('/')) {
+        return url.split('/').pop() ?? url;
+    }
+    return url;
+}
+/**
+ * Format source location as "file:line:col".
+ *
+ * A frame without a position (lineNumber -1, e.g. the URL of a failed load)
+ * is shown as its full URL.
+ */
+export function formatSourceLocation(stackTrace) {
+    const frame = stackTrace?.[0];
+    if (!frame)
+        return undefined;
+    if (frame.lineNumber < 0)
+        return frame.url;
+    const filename = getFilenameFromUrl(frame.url, frame.functionName);
+    const line = frame.lineNumber + 1;
+    const col = frame.columnNumber + 1;
+    return `${filename}:${line}:${col}`;
+}
+/**
+ * Format count prefix for deduplicated messages.
+ */
+export function formatCountPrefix(count) {
+    return count > 1 ? `[${count}x] ` : '';
+}
+/**
+ * Format section header with unique/total counts.
+ */
+export function formatSectionHeader(label, unique, total) {
+    return unique === total ? `${label} (${total})` : `${label} (${unique} unique, ${total} total)`;
+}
+/**
+ * A stack frame as "url:line:column" (1-based), or just the URL for a frame
+ * without a position (lineNumber -1, e.g. a failed resource load).
+ *
+ * @param frame - Stack frame
+ * @returns Location text
+ */
+export function formatFramePosition(frame) {
+    return frame.lineNumber < 0
+        ? frame.url
+        : `${frame.url}:${frame.lineNumber + 1}:${frame.columnNumber + 1}`;
+}
+//# sourceMappingURL=shared.js.map

package/dist/ui/formatters/console/summarize.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Smart summary view: prioritises errors and warnings with deduplication
+ * and shows info/debug/other as count-only footer entries.
+ */
+import type { ConsoleMessage } from '../../../types.js';
+/**
+ * Format console output as smart summary (default mode).
+ */
+export declare function formatConsoleSummary(messages: ConsoleMessage[]): string;
+//# sourceMappingURL=summarize.d.ts.map

package/dist/ui/formatters/console/summarize.js

@@ -0,0 +1,63 @@
+/**
+ * Smart summary view: prioritises errors and warnings with deduplication
+ * and shows info/debug/other as count-only footer entries.
+ */
+import { OutputFormatter, pluralize } from '../../formatting.js';
+import { analyzeMessages, formatCountPrefix, formatSectionHeader, formatSourceLocation, } from './shared.js';
+function renderErrorSection(fmt, errors, total) {
+    if (errors.length === 0)
+        return;
+    fmt.text(formatSectionHeader('Errors', errors.length, total));
+    fmt.separator('─', 30);
+    for (const { message, count } of errors) {
+        fmt.text(`${formatCountPrefix(count)}${message.text}`);
+        const source = formatSourceLocation(message.stackTrace);
+        if (source) {
+            fmt.text(`     → ${source}`);
+        }
+        fmt.blank();
+    }
+}
+function renderWarningSection(fmt, warnings, total) {
+    if (warnings.length === 0)
+        return;
+    fmt.text(formatSectionHeader('Warnings', warnings.length, total));
+    fmt.separator('─', 30);
+    for (const { message, count } of warnings) {
+        fmt.text(`• ${formatCountPrefix(count)}${message.text}`);
+        const source = formatSourceLocation(message.stackTrace);
+        if (source)
+            fmt.text(`     → ${source}`);
+    }
+    fmt.blank();
+}
+function renderOtherSummary(fmt, summary) {
+    const parts = [
+        summary.info > 0 && pluralize(summary.info, 'info message'),
+        summary.debug > 0 && pluralize(summary.debug, 'debug message'),
+        summary.other > 0 && pluralize(summary.other, 'other message'),
+    ].filter(Boolean);
+    if (parts.length > 0) {
+        fmt.separator('─', 30);
+        fmt.text(`${parts.join(' · ')} (use --list to see)`);
+    }
+}
+/**
+ * Format console output as smart summary (default mode).
+ */
+export function formatConsoleSummary(messages) {
+    const fmt = new OutputFormatter();
+    const { grouped, summary } = analyzeMessages(messages);
+    fmt.text('Console Summary');
+    fmt.separator('━', 60);
+    fmt.blank();
+    renderErrorSection(fmt, grouped.errors, summary.errors.total);
+    renderWarningSection(fmt, grouped.warnings, summary.warnings.total);
+    if (grouped.errors.length === 0 && grouped.warnings.length === 0) {
+        fmt.text('No errors or warnings found');
+        fmt.blank();
+    }
+    renderOtherSummary(fmt, summary);
+    return fmt.build();
+}
+//# sourceMappingURL=summarize.js.map

package/dist/ui/formatters/console.d.ts

@@ -1,143 +1,22 @@
 /**
  * Console command formatters.
  *
- * Provides formatting functions for the `bdg console` command output including
- * smart summary view with deduplication, chronological view, and JSON output.
- */
-import type { ConsoleLevel, ConsoleMessage, StackFrame } from '../../types.js';
-export type { ConsoleLevel } from '../../types.js';
-/**
- * Internal console level including 'other' for classification.
- * Used internally by formatter for message grouping.
- */
-type ConsoleInternalLevel = ConsoleLevel | 'other';
-/**
- * Deduplicated console message with occurrence count.
- */
-export interface DeduplicatedMessage {
-    /** First occurrence of the message */
-    message: ConsoleMessage;
-    /** Number of times this message appeared */
-    count: number;
-}
-/**
- * Summary statistics for console messages.
- */
-export interface ConsoleSummary {
-    /** Total number of messages */
-    total: number;
-    /** Error statistics */
-    errors: {
-        total: number;
-        unique: number;
-    };
-    /** Warning statistics */
-    warnings: {
-        total: number;
-        unique: number;
-    };
-    /** Info message count */
-    info: number;
-    /** Debug message count */
-    debug: number;
-    /** Other message type count */
-    other: number;
-}
-/**
- * Options for console formatting.
- */
-export interface ConsoleFormatOptions {
-    /** Output as JSON */
-    json?: boolean | undefined;
-    /** List all messages chronologically (--list flag) */
-    list?: boolean | undefined;
-    /** Follow mode (live streaming) */
-    follow?: boolean | undefined;
-    /** Limit to last N messages */
-    last?: number | undefined;
-    /** Show messages from all navigations (default: current only) */
-    history?: boolean | undefined;
-    /** Filter by level (error, warning, info, debug) */
-    level?: ConsoleLevel | undefined;
-}
-/**
- * JSON error/warning entry structure.
- */
-interface JsonErrorEntry {
-    count: number;
-    level: string;
-    text: string;
-    source?: {
-        url: string;
-        line: number;
-        column: number;
-    };
-    stackTrace?: StackFrame[];
-}
-/**
- * JSON output structure for console command.
- */
-export interface ConsoleJsonOutput {
-    success: boolean;
-    summary: ConsoleSummary;
-    errors: JsonErrorEntry[];
-    warnings: Omit<JsonErrorEntry, 'stackTrace'>[];
-    messages?: ConsoleMessage[];
-}
-/**
- * Mapping from console message types to level categories.
- * Exported for use by console command filtering.
- */
-export declare const LEVEL_MAP: Record<ConsoleMessage['type'], ConsoleInternalLevel>;
-/**
- * Format console output as smart summary (default mode).
- *
- * Prioritizes errors and warnings with deduplication and counts.
- * Shows info/debug as summary counts only.
- *
- * @param messages - All console messages
- * @returns Formatted summary string
- */
-export declare function formatConsoleSummary(messages: ConsoleMessage[]): string;
-/**
- * Format console output as chronological list (--list mode).
- *
- * Shows all messages in order with timestamps and levels.
- * Includes navigation markers when page reloads are detected.
- *
- * @param messages - All console messages
- * @param options - Format options
- * @returns Formatted chronological list string
- */
-export declare function formatConsoleChronological(messages: ConsoleMessage[], options: ConsoleFormatOptions): string;
-/**
- * Format console output for follow mode streaming.
- *
- * Compact format optimized for live updates.
- *
- * @param messages - Recent console messages to display
- * @returns Formatted streaming output string
- */
-export declare function formatConsoleFollow(messages: ConsoleMessage[]): string;
-/**
- * Format console output as JSON.
- *
- * Structured output with summary statistics and deduplicated errors/warnings.
- *
- * @param messages - All console messages
- * @param options - Format options
- * @returns JSON string
- */
-export declare function formatConsoleJson(messages: ConsoleMessage[], options: ConsoleFormatOptions): string;
-/**
- * Format console output based on options.
- *
- * Main entry point for console formatting. Routes to appropriate formatter
- * based on options (json, list, follow).
- *
- * @param messages - All console messages
- * @param options - Format options
- * @returns Formatted output string
+ * Public entry point that re-exports the per-mode formatters and provides
+ * the `formatConsole` dispatcher. The per-mode implementations live in
+ * `./console/`.
+ */
+import type { ConsoleMessage } from '../../types.js';
+import { type ConsoleFormatOptions } from './console/shared.js';
+export type { ConsoleFormatOptions, ConsoleJsonOutput, ConsoleLevel, ConsoleSummary, DeduplicatedMessage, } from './console/shared.js';
+export { LEVEL_MAP } from './console/shared.js';
+export { formatConsoleChronological } from './console/chronological.js';
+export { formatConsoleFollowLines } from './console/follow.js';
+export { buildConsoleJsonOutput, formatConsoleJson } from './console/json.js';
+export { formatConsoleSummary } from './console/summarize.js';
+/**
+ * Format console output based on options. Routes to the per-mode formatter:
+ * a `--level` filter lists the matching messages (the summary only shows
+ * errors and warnings, so it would hide e.g. `--level info`).
  */
 export declare function formatConsole(messages: ConsoleMessage[], options: ConsoleFormatOptions): string;
 //# sourceMappingURL=console.d.ts.map