sidekick-shared 0.27.6 → 0.28.1

package/dist/esm/formatters/eventHighlighter.js

@@ -0,0 +1,332 @@
+/**
+ * Keyword-based semantic syntax highlighting for session event text.
+ *
+ * Applies cascading word-by-word colorization based on keyword categories:
+ * errors=red, success=green, warnings=yellow, actions=cyan, numbers=blue,
+ * URLs/paths=magenta, HTTP status codes and methods colored by semantics.
+ *
+ * Supports blessed (CLI), ANSI (terminal), and HTML (VS Code webview) output formats.
+ *
+ * @module formatters/eventHighlighter
+ */
+const BLESSED_COLORS = {
+    red: ['{red-fg}', '{/red-fg}'],
+    green: ['{green-fg}', '{/green-fg}'],
+    yellow: ['{yellow-fg}', '{/yellow-fg}'],
+    cyan: ['{cyan-fg}', '{/cyan-fg}'],
+    blue: ['{blue-fg}', '{/blue-fg}'],
+    magenta: ['{magenta-fg}', '{/magenta-fg}'],
+    grey: ['{grey-fg}', '{/grey-fg}'],
+    white: ['{white-fg}', '{/white-fg}'],
+};
+const ANSI_COLORS = {
+    red: ['\x1b[31m', '\x1b[0m'],
+    green: ['\x1b[32m', '\x1b[0m'],
+    yellow: ['\x1b[33m', '\x1b[0m'],
+    cyan: ['\x1b[36m', '\x1b[0m'],
+    blue: ['\x1b[34m', '\x1b[0m'],
+    magenta: ['\x1b[35m', '\x1b[0m'],
+    grey: ['\x1b[90m', '\x1b[0m'],
+    white: ['\x1b[37m', '\x1b[0m'],
+};
+const HTML_COLORS = {
+    red: ['<span class="sk-hl-error">', '</span>'],
+    green: ['<span class="sk-hl-success">', '</span>'],
+    yellow: ['<span class="sk-hl-warning">', '</span>'],
+    cyan: ['<span class="sk-hl-action">', '</span>'],
+    blue: ['<span class="sk-hl-number">', '</span>'],
+    magenta: ['<span class="sk-hl-path">', '</span>'],
+    grey: ['<span class="sk-hl-muted">', '</span>'],
+    white: ['<span class="sk-hl-default">', '</span>'],
+};
+function getColors(format) {
+    switch (format) {
+        case 'blessed':
+            return BLESSED_COLORS;
+        case 'ansi':
+            return ANSI_COLORS;
+        case 'html':
+            return HTML_COLORS;
+    }
+}
+const ERROR_KEYWORDS = new Set([
+    'error',
+    'errors',
+    'err',
+    'fail',
+    'failed',
+    'failure',
+    'failures',
+    'fatal',
+    'panic',
+    'crash',
+    'crashed',
+    'exception',
+    'exceptions',
+    'critical',
+    'alert',
+    'abort',
+    'aborted',
+    'denied',
+    'forbidden',
+    'rejected',
+    'invalid',
+    'illegal',
+    'corrupt',
+    'corrupted',
+    'broken',
+    'bug',
+    'segfault',
+    'timeout',
+    'timedout',
+    'timed-out',
+    'deadlock',
+    'overflow',
+    'underflow',
+    'null',
+    'undefined',
+    'nan',
+    'unhandled',
+    'uncaught',
+    'unreachable',
+    'missing',
+    'notfound',
+    'not-found',
+    'unavailable',
+    'disconnected',
+    'dropped',
+]);
+const SUCCESS_KEYWORDS = new Set([
+    'success',
+    'successful',
+    'succeeded',
+    'ok',
+    'done',
+    'complete',
+    'completed',
+    'passed',
+    'pass',
+    'resolved',
+    'fixed',
+    'ready',
+    'active',
+    'running',
+    'started',
+    'created',
+    'connected',
+    'established',
+    'accepted',
+    'approved',
+    'merged',
+    'deployed',
+    'installed',
+    'loaded',
+    'enabled',
+    'healthy',
+    'valid',
+    'verified',
+]);
+const WARNING_KEYWORDS = new Set([
+    'warn',
+    'warning',
+    'warnings',
+    'caution',
+    'deprecated',
+    'slow',
+    'retry',
+    'retrying',
+    'retries',
+    'pending',
+    'waiting',
+    'queued',
+    'stale',
+    'expired',
+    'expiring',
+    'limited',
+    'throttled',
+    'throttling',
+    'degraded',
+    'unstable',
+    'flaky',
+    'skipped',
+    'skip',
+    'ignored',
+    'unknown',
+    'unrecognized',
+]);
+const ACTION_KEYWORDS = new Set([
+    'read',
+    'write',
+    'edit',
+    'delete',
+    'create',
+    'update',
+    'insert',
+    'remove',
+    'add',
+    'modify',
+    'patch',
+    'merge',
+    'push',
+    'pull',
+    'fetch',
+    'send',
+    'receive',
+    'request',
+    'response',
+    'query',
+    'search',
+    'find',
+    'list',
+    'get',
+    'set',
+    'put',
+    'post',
+    'build',
+    'compile',
+    'test',
+    'deploy',
+    'install',
+    'run',
+    'execute',
+    'start',
+    'stop',
+    'restart',
+    'init',
+    'initialize',
+    'configure',
+    'spawn',
+    'call',
+    'invoke',
+]);
+const HTTP_METHODS = new Map([
+    ['GET', 'green'],
+    ['HEAD', 'green'],
+    ['OPTIONS', 'green'],
+    ['POST', 'yellow'],
+    ['PUT', 'yellow'],
+    ['PATCH', 'yellow'],
+    ['DELETE', 'red'],
+]);
+// ── Patterns ──
+const NUMBER_PATTERN = /^-?\d+(\.\d+)?(%|ms|s|m|h|d|k|K|M|G|T|B)?$/;
+const PATH_PATTERN = /^[.~]?\/[\w./-]+|^[\w-]+\/[\w./-]+|^[\w-]+\.[\w.]+$/;
+const URL_PATTERN = /^https?:\/\//;
+/**
+ * Classify an HTTP status code by color.
+ * Returns null if the word is not a status code.
+ */
+function httpStatusColor(word) {
+    if (!/^\d{3}$/.test(word))
+        return null;
+    const code = parseInt(word, 10);
+    if (code >= 200 && code < 300)
+        return 'green';
+    if (code >= 300 && code < 400)
+        return 'yellow';
+    if (code >= 400)
+        return 'red';
+    return null;
+}
+/**
+ * Determine the color for a single word based on keyword categories.
+ * Priority: errors > warnings > success > HTTP > actions > paths > numbers
+ */
+function classifyWord(word) {
+    const lower = word.toLowerCase();
+    // Strip common punctuation for keyword matching
+    const stripped = lower.replace(/[.,;:!?()[\]{}'"]+$/g, '').replace(/^['"([\]{}]+/, '');
+    if (ERROR_KEYWORDS.has(stripped))
+        return 'red';
+    if (WARNING_KEYWORDS.has(stripped))
+        return 'yellow';
+    if (SUCCESS_KEYWORDS.has(stripped))
+        return 'green';
+    // HTTP methods
+    const httpMethod = HTTP_METHODS.get(word.toUpperCase());
+    if (httpMethod)
+        return httpMethod;
+    // HTTP status codes
+    const statusColor = httpStatusColor(stripped);
+    if (statusColor)
+        return statusColor;
+    if (ACTION_KEYWORDS.has(stripped))
+        return 'cyan';
+    // Paths and URLs
+    if (URL_PATTERN.test(word) || PATH_PATTERN.test(word))
+        return 'magenta';
+    // Numbers
+    if (NUMBER_PATTERN.test(stripped))
+        return 'blue';
+    return null;
+}
+// ── LRU cache for highlighted results ──
+const CACHE_MAX = 500;
+const highlightCache = new Map();
+function cacheKey(text, format) {
+    return `${format}:${text}`;
+}
+/**
+ * Apply keyword-based semantic highlighting to text.
+ *
+ * Splits text on whitespace and colors each word based on keyword category.
+ * Words not matching any category pass through uncolored.
+ *
+ * @param text - The text to highlight.
+ * @param format - Output format: 'blessed' (CLI), 'ansi' (terminal), or 'html' (webview).
+ * @returns The highlighted text with format-appropriate tags.
+ */
+export function highlight(text, format) {
+    if (!text)
+        return text;
+    const key = cacheKey(text, format);
+    const cached = highlightCache.get(key);
+    if (cached !== undefined)
+        return cached;
+    const colors = getColors(format);
+    const words = text.split(/(\s+)/); // Split preserving whitespace
+    const parts = [];
+    for (const segment of words) {
+        // Preserve whitespace segments as-is
+        if (/^\s+$/.test(segment)) {
+            parts.push(segment);
+            continue;
+        }
+        const color = classifyWord(segment);
+        if (color) {
+            const [open, close] = colors[color];
+            parts.push(`${open}${segment}${close}`);
+        }
+        else {
+            parts.push(segment);
+        }
+    }
+    const result = parts.join('');
+    // LRU cache: evict oldest if full
+    if (highlightCache.size >= CACHE_MAX) {
+        const first = highlightCache.keys().next().value;
+        if (first !== undefined)
+            highlightCache.delete(first);
+    }
+    highlightCache.set(key, result);
+    return result;
+}
+/**
+ * CSS class definitions for HTML highlight format.
+ * Include this in webview stylesheets.
+ */
+export const HIGHLIGHT_CSS = `
+.sk-hl-error { color: var(--vscode-charts-red, #f44747); }
+.sk-hl-success { color: var(--vscode-charts-green, #89d185); }
+.sk-hl-warning { color: var(--vscode-charts-yellow, #cca700); }
+.sk-hl-action { color: var(--vscode-charts-blue, #4fc1ff); }
+.sk-hl-number { color: var(--vscode-charts-purple, #b180d7); }
+.sk-hl-path { color: var(--vscode-charts-orange, #cca700); }
+.sk-hl-muted { opacity: 0.6; }
+.sk-hl-default { }
+.sk-search-match { background-color: var(--vscode-editor-findMatchHighlightBackground, rgba(234, 92, 0, 0.33)); }
+`;
+/** Clear the highlight cache (for testing or memory pressure). */
+export function clearHighlightCache() {
+    highlightCache.clear();
+}

package/dist/esm/formatters/noiseClassifier.js

@@ -0,0 +1,209 @@
+/**
+ * Noise classification pipeline for session events.
+ *
+ * Multi-layer classification system that filters system noise, sidechains,
+ * synthetic messages, and soft noise (system-reminder tags, empty outputs).
+ * Inspired by tail-claude's noise filtering.
+ *
+ * @module formatters/noiseClassifier
+ */
+// ── Hard Noise Detection ──
+/** Hard noise types that should be dropped entirely from display. */
+const HARD_NOISE_EVENT_TYPES = new Set(['file-history-snapshot', 'queue-operation', 'progress']);
+const SYNTHETIC_MODEL_PREFIX = '<synthetic>';
+/**
+ * Determines if an event is "hard noise" and should be dropped entirely.
+ *
+ * Hard noise includes:
+ * - System-type events (non-content)
+ * - Specific infrastructure event types (file-history-snapshot, queue-operation, progress)
+ * - Sidechain/subagent events (when filtering to main conversation)
+ * - Synthetic model entries (model starts with `<synthetic>`)
+ */
+export function isHardNoise(event) {
+    // Sidechain events are noise for the main timeline
+    if (event.isSidechain)
+        return true;
+    // Check for known noise event types in raw data
+    const rawType = event.type;
+    if (HARD_NOISE_EVENT_TYPES.has(rawType))
+        return true;
+    // Synthetic model entries
+    if (event.message?.model?.startsWith(SYNTHETIC_MODEL_PREFIX))
+        return true;
+    return false;
+}
+/**
+ * FollowEvent variant of hard noise detection.
+ */
+export function isHardNoiseFollowEvent(event) {
+    // System events that are just infrastructure
+    if (event.type === 'system') {
+        const summary = event.summary?.toLowerCase() ?? '';
+        // Keep "Session ended" type system events
+        if (summary.includes('session ended') || summary.includes('session started')) {
+            return false;
+        }
+        // Token count events from Codex are noise for timeline display
+        if (summary.startsWith('tokens:') || summary.startsWith('model:')) {
+            return true;
+        }
+    }
+    return false;
+}
+// ── Soft Noise Detection ──
+const SYSTEM_REMINDER_PATTERN = /<system-reminder>[\s\S]*?<\/system-reminder>/;
+const COMMAND_CAVEAT_PATTERNS = [
+    /IMPORTANT:.*?(?:never|always|must|should)/i,
+    /Note:.*?(?:do not|don't|avoid)/i,
+];
+const INTERRUPTION_MARKERS = ['interrupted by user', 'operation cancelled', 'aborted'];
+/**
+ * Checks for soft noise that can be hidden but not dropped.
+ *
+ * Soft noise includes:
+ * - system-reminder XML tags in content
+ * - Command caveats (IMPORTANT/Note instructions)
+ * - Empty tool outputs
+ * - User interruption markers
+ *
+ * @returns A reason string if soft noise is detected, null otherwise.
+ */
+export function getSoftNoiseReason(event) {
+    const content = extractContent(event);
+    if (content && SYSTEM_REMINDER_PATTERN.test(content)) {
+        return 'system-reminder';
+    }
+    for (const pattern of COMMAND_CAVEAT_PATTERNS) {
+        if (content && pattern.test(content)) {
+            return 'command-caveat';
+        }
+    }
+    // Empty tool results
+    if (event.type === 'tool_result') {
+        const output = event.result?.output;
+        if (output === '' || output === undefined || output === null) {
+            return 'empty-tool-output';
+        }
+    }
+    // Interruption markers
+    if (content) {
+        for (const marker of INTERRUPTION_MARKERS) {
+            if (content.toLowerCase().includes(marker)) {
+                return 'interruption';
+            }
+        }
+    }
+    return null;
+}
+// ── Message Classification ──
+/**
+ * Classifies a SessionEvent into semantic message categories.
+ *
+ * Categories:
+ * - `user` — human prompts
+ * - `ai` — assistant responses (text or tool calls)
+ * - `system` — tool results, compaction, infrastructure
+ * - `teammate` — teammate/subagent messages (from `<teammate-message>` blocks)
+ * - `compact` — compaction/summary events
+ */
+export function classifyMessage(event) {
+    switch (event.type) {
+        case 'user': {
+            const content = extractContent(event);
+            // Check for teammate messages
+            if (content && content.includes('<teammate-message>')) {
+                return 'teammate';
+            }
+            return 'user';
+        }
+        case 'assistant':
+            return 'ai';
+        case 'summary':
+            return 'compact';
+        case 'tool_use':
+            return 'ai';
+        case 'tool_result':
+            return 'system';
+        default:
+            return 'system';
+    }
+}
+/**
+ * FollowEvent variant of message classification.
+ */
+export function classifyFollowEvent(event) {
+    switch (event.type) {
+        case 'user':
+            return 'user';
+        case 'assistant':
+            return 'ai';
+        case 'tool_use':
+            return 'ai';
+        case 'tool_result':
+            return 'system';
+        case 'summary':
+            return 'compact';
+        case 'system':
+            return 'system';
+        default:
+            return 'system';
+    }
+}
+// ── Merge Detection ──
+/**
+ * Determines if the current event should be merged with the previous one.
+ *
+ * Consecutive assistant text messages (without tool calls between them)
+ * can be merged into a single display entry.
+ */
+export function shouldMergeWithPrevious(current, previous) {
+    if (!previous)
+        return false;
+    // Merge consecutive assistant text messages
+    if (current.type === 'assistant' && previous.type === 'assistant') {
+        // Don't merge if either has tool_use content blocks
+        const currentContent = current.message?.content;
+        const previousContent = previous.message?.content;
+        if (hasToolUseBlocks(currentContent) || hasToolUseBlocks(previousContent)) {
+            return false;
+        }
+        return true;
+    }
+    return false;
+}
+// ── Full Classification ──
+/**
+ * Performs full noise classification on a SessionEvent.
+ * Combines hard noise detection, soft noise detection, and message classification.
+ */
+export function classifyNoise(event) {
+    return {
+        isHardNoise: isHardNoise(event),
+        softNoiseReason: getSoftNoiseReason(event),
+        messageClassification: classifyMessage(event),
+    };
+}
+// ── Helpers ──
+function extractContent(event) {
+    const content = event.message?.content;
+    if (!content)
+        return null;
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        const texts = [];
+        for (const block of content) {
+            if (block.type === 'text' && typeof block.text === 'string') {
+                texts.push(block.text);
+            }
+        }
+        return texts.length > 0 ? texts.join('\n') : null;
+    }
+    return null;
+}
+function hasToolUseBlocks(content) {
+    if (!Array.isArray(content))
+        return false;
+    return content.some((b) => b.type === 'tool_use');
+}