sidekick-shared 0.27.6 → 0.28.0

package/dist/esm/parsers/debugLogParser.js

@@ -0,0 +1,126 @@
+/**
+ * Debug log parser for Claude Code debug logs.
+ *
+ * Claude Code writes debug logs to ~/.claude/debug/. This module parses
+ * them into structured entries with level filtering and duplicate collapsing.
+ *
+ * @module parsers/debugLogParser
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { getLiveClaudeHome } from '../claudePaths';
+// ── Constants ──
+const LOG_LINE_PATTERN = /^(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}[.\d]*Z?)\s+(DEBUG|INFO|WARN|ERROR)\s+(.*)$/;
+const LEVEL_ORDER = {
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3,
+};
+// ── Public API ──
+/**
+ * Parses debug log content into structured entries.
+ *
+ * Handles multi-line entries (continuation lines without timestamps).
+ *
+ * @param content - Raw log file content
+ * @returns Array of parsed log entries
+ */
+export function parseDebugLog(content) {
+    const lines = content.split('\n');
+    const entries = [];
+    let current = null;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const match = line.match(LOG_LINE_PATTERN);
+        if (match) {
+            // Save previous entry
+            if (current)
+                entries.push(current);
+            current = {
+                timestamp: match[1],
+                level: match[2],
+                message: match[3],
+                fullContent: line,
+                lineNumber: i + 1,
+            };
+        }
+        else if (current && line.trim()) {
+            // Continuation line
+            current.fullContent += '\n' + line;
+        }
+    }
+    // Don't forget the last entry
+    if (current)
+        entries.push(current);
+    return entries;
+}
+/**
+ * Filters log entries by minimum level.
+ *
+ * @param entries - Array of log entries
+ * @param minLevel - Minimum level to include
+ * @returns Filtered entries at or above the minimum level
+ */
+export function filterByLevel(entries, minLevel) {
+    const minOrder = LEVEL_ORDER[minLevel];
+    return entries.filter((e) => LEVEL_ORDER[e.level] >= minOrder);
+}
+/**
+ * Collapses consecutive identical log messages into single entries with counts.
+ *
+ * @param entries - Array of log entries
+ * @returns Collapsed entries with duplicateCount set on collapsed items
+ */
+export function collapseDuplicates(entries) {
+    if (entries.length === 0)
+        return [];
+    const result = [];
+    let current = { ...entries[0], duplicateCount: 1 };
+    for (let i = 1; i < entries.length; i++) {
+        if (entries[i].message === current.message && entries[i].level === current.level) {
+            current.duplicateCount = (current.duplicateCount || 1) + 1;
+        }
+        else {
+            result.push(current);
+            current = { ...entries[i], duplicateCount: 1 };
+        }
+    }
+    result.push(current);
+    return result;
+}
+/**
+ * Discovers available debug log files.
+ *
+ * @returns Array of debug log file info, sorted by mtime (most recent first)
+ */
+export function discoverDebugLogs() {
+    const debugDir = path.join(getLiveClaudeHome(), 'debug');
+    try {
+        if (!fs.existsSync(debugDir))
+            return [];
+        return fs
+            .readdirSync(debugDir)
+            .filter((f) => f.endsWith('.log') || f.endsWith('.txt'))
+            .map((name) => {
+            const fullPath = path.join(debugDir, name);
+            try {
+                const stat = fs.statSync(fullPath);
+                return {
+                    path: fullPath,
+                    name,
+                    mtime: stat.mtime,
+                    size: stat.size,
+                };
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((f) => f !== null)
+            .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    }
+    catch {
+        return [];
+    }
+}

package/dist/esm/parsers/jsonl.js

@@ -0,0 +1,66 @@
+/**
+ * Line-buffered JSONL parser with optional Zod schema validation.
+ * Ported from sidekick-vscode/src/services/JsonlParser.ts
+ */
+export class JsonlParser {
+    buffer = '';
+    onEvent;
+    onError;
+    schema;
+    constructor(callbacks, options) {
+        this.onEvent = callbacks.onEvent;
+        this.onError = callbacks.onError;
+        this.schema = options?.schema;
+    }
+    processChunk(chunk) {
+        this.buffer += chunk;
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() || '';
+        for (const line of lines) {
+            this.parseLine(line);
+        }
+    }
+    flush() {
+        if (this.buffer.trim().length > 0) {
+            this.parseLine(this.buffer);
+            this.buffer = '';
+        }
+    }
+    reset() {
+        this.buffer = '';
+    }
+    parseLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.startsWith('{'))
+            return;
+        try {
+            const raw = JSON.parse(trimmed);
+            if (this.schema) {
+                const result = this.schema.safeParse(raw);
+                if (result.success) {
+                    this.onEvent(result.data);
+                }
+                else if (this.onError) {
+                    this.onError(new Error(`Schema validation failed: ${result.error.message}`), line);
+                }
+            }
+            else {
+                this.onEvent(raw);
+            }
+        }
+        catch (error) {
+            if (this.onError) {
+                this.onError(error instanceof Error ? error : new Error(String(error)), line);
+            }
+        }
+    }
+}
+/** Truncation patterns from SessionMonitor. */
+export const TRUNCATION_PATTERNS = [
+    { regex: /\[Response truncated/, name: 'Response truncated' },
+    { regex: /\[WARNING: Tool output was truncated/, name: 'Tool output truncated' },
+    { regex: /content_too_long/, name: 'Content too long' },
+    { regex: /<response clipped>/, name: 'Response clipped' },
+    { regex: /\[Content truncated/, name: 'Content truncated' },
+    { regex: /\[\.\.\.truncated/, name: 'Truncated' },
+];

package/dist/esm/parsers/mcpToolName.js

@@ -0,0 +1,28 @@
+/**
+ * Claude Code exposes MCP tools under composite identifiers of the form
+ * `mcp__<server>__<tool>`. Splitting them correctly is subtle enough that
+ * consumers keep re-implementing it by hand (usually with a plain
+ * `split('__')`, which mangles server names containing single underscores).
+ * This module is the canonical splitter. Browser-safe: no Node imports.
+ *
+ * @module mcpToolName
+ */
+const MCP_TOOL_NAME_PATTERN = /^mcp__([^_]+(?:_[^_]+)*)__(.+)$/;
+/**
+ * Splits a Claude Code MCP tool identifier `mcp__<server>__<tool>` into parts.
+ *
+ * The server name ends at the first double underscore after the prefix, so
+ * single underscores stay inside it (`mcp__plugin_context7_context7__query-docs`
+ * → server `plugin_context7_context7`) and the tool keeps any further double
+ * underscores (`mcp__a__b__c` → tool `b__c`).
+ *
+ * Returns `null` for anything that is not a well-formed MCP tool id: a
+ * non-`mcp__` name, a missing or empty server or tool part, or a
+ * case-mismatched prefix. No trimming is applied.
+ */
+export function parseMcpToolName(name) {
+    const match = MCP_TOOL_NAME_PATTERN.exec(name);
+    if (!match)
+        return null;
+    return { serverName: match[1], toolName: match[2] };
+}