sidekick-shared 0.13.2

package/dist/parsers/subagentTraceParser.js

@@ -0,0 +1,346 @@
+"use strict";
+/**
+ * Subagent execution trace parser.
+ *
+ * Extends the existing subagent scanner to preserve full conversation events
+ * (not just stats) for drill-down trace visualization. Applies noise classification
+ * and tool summary formatting from the formatters module.
+ *
+ * Three-phase parent-child linking:
+ * 1. Result-based: match toolUseResult.agentId → parent tool_use_id
+ * 2. Team summary: parse <teammate-message> XML blocks
+ * 3. Positional fallback: timestamp ordering + proximity
+ *
+ * @module parsers/subagentTraceParser
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanSubagentTraces = scanSubagentTraces;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const toolSummary_1 = require("../formatters/toolSummary");
+const noiseClassifier_1 = require("../formatters/noiseClassifier");
+// ── Constants ──
+const AGENT_FILE_PATTERN = /^agent-(.+)\.jsonl$/;
+// ── Public API ──
+/**
+ * Scans and parses subagent traces with full conversation events.
+ *
+ * Unlike `scanSubagentDir()` which only returns stats, this returns
+ * the full conversation trace for each subagent, formatted with tool
+ * summaries and noise classification.
+ *
+ * @param sessionDir - Directory containing the session file
+ * @param sessionId - Session ID (filename without .jsonl extension)
+ * @returns Array of SubagentTrace objects forming a tree
+ */
+function scanSubagentTraces(sessionDir, sessionId) {
+    const subagentsDir = path.join(sessionDir, sessionId, 'subagents');
+    try {
+        if (!fs.existsSync(subagentsDir))
+            return [];
+        const files = fs.readdirSync(subagentsDir);
+        const traces = [];
+        for (const file of files) {
+            const match = file.match(AGENT_FILE_PATTERN);
+            if (!match)
+                continue;
+            const agentId = match[1];
+            const filePath = path.join(subagentsDir, file);
+            const trace = parseAgentTrace(filePath, agentId);
+            if (trace)
+                traces.push(trace);
+        }
+        // Link parent-child relationships
+        linkTraces(traces);
+        // Return only top-level traces (those without parents)
+        return traces.filter(t => !t.parentToolUseId);
+    }
+    catch {
+        return [];
+    }
+}
+// ── Parsing ──
+function parseAgentTrace(filePath, agentId) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n').filter(l => l.trim());
+        const events = [];
+        const toolCalls = [];
+        let agentType;
+        let description;
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let startTime;
+        let endTime;
+        for (const line of lines) {
+            try {
+                const raw = JSON.parse(line);
+                const timestamp = new Date(raw.timestamp || Date.now());
+                if (!startTime)
+                    startTime = timestamp;
+                endTime = timestamp;
+                // Build SessionEvent from raw JSONL
+                const sessionEvent = rawToSessionEvent(raw);
+                if (!sessionEvent)
+                    continue;
+                // Classify and format
+                const hardNoise = (0, noiseClassifier_1.isHardNoise)(sessionEvent);
+                const messageClass = (0, noiseClassifier_1.classifyMessage)(sessionEvent);
+                const softNoise = (0, noiseClassifier_1.getSoftNoiseReason)(sessionEvent);
+                // Compute noise level
+                let noiseLevel = 'system';
+                switch (sessionEvent.type) {
+                    case 'user':
+                        noiseLevel = 'user';
+                        break;
+                    case 'assistant':
+                        noiseLevel = 'ai';
+                        break;
+                    case 'tool_use':
+                        noiseLevel = 'system';
+                        break;
+                    case 'tool_result':
+                        noiseLevel = 'noise';
+                        break;
+                    case 'summary':
+                        noiseLevel = 'system';
+                        break;
+                }
+                // Format tool summary
+                let toolSummary;
+                if (sessionEvent.type === 'tool_use' && sessionEvent.tool) {
+                    toolSummary = (0, toolSummary_1.formatToolSummary)(sessionEvent.tool.name, sessionEvent.tool.input);
+                }
+                events.push({
+                    event: sessionEvent,
+                    toolSummary,
+                    noiseLevel,
+                    messageClassification: messageClass,
+                    softNoiseReason: softNoise ?? undefined,
+                    isHardNoise: hardNoise,
+                });
+                // Extract token usage
+                if (raw.type === 'assistant' && raw.message?.usage) {
+                    const usage = raw.message.usage;
+                    inputTokens += (usage.input_tokens || 0) + (usage.cache_creation_input_tokens || 0) + (usage.cache_read_input_tokens || 0);
+                    outputTokens += usage.output_tokens || 0;
+                }
+                // Extract tool calls
+                if (raw.type === 'assistant' && Array.isArray(raw.message?.content)) {
+                    for (const block of raw.message.content) {
+                        if (block?.type === 'tool_use') {
+                            toolCalls.push({
+                                name: block.name,
+                                input: block.input || {},
+                                timestamp,
+                            });
+                            // Extract agent info from Task tool
+                            if (block.name === 'Task' && block.input) {
+                                if (block.input.subagent_type && !agentType) {
+                                    agentType = String(block.input.subagent_type);
+                                }
+                                if (block.input.description && !description) {
+                                    description = String(block.input.description);
+                                }
+                            }
+                        }
+                    }
+                }
+                // Extract agent type from system messages
+                if (raw.type === 'system' && raw.message?.content) {
+                    const contentStr = typeof raw.message.content === 'string'
+                        ? raw.message.content
+                        : JSON.stringify(raw.message.content);
+                    const typeMatch = contentStr.match(/subagent_type['":\s]+(\w+)/i);
+                    if (typeMatch && !agentType) {
+                        agentType = typeMatch[1];
+                    }
+                }
+            }
+            catch {
+                // Skip malformed lines
+            }
+        }
+        if (events.length === 0 && !agentType && !description && inputTokens === 0) {
+            return null;
+        }
+        const durationMs = startTime && endTime ? endTime.getTime() - startTime.getTime() : undefined;
+        return {
+            agentId,
+            agentType,
+            description,
+            events,
+            children: [],
+            stats: {
+                agentId,
+                agentType,
+                description,
+                toolCalls,
+                inputTokens,
+                outputTokens,
+                startTime,
+                endTime,
+                durationMs,
+            },
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// ── Parent-Child Linking ──
+function linkTraces(traces) {
+    const traceById = new Map();
+    for (const trace of traces) {
+        traceById.set(trace.agentId, trace);
+    }
+    // Phase 1: Result-based linking
+    // Look for tool_result events that contain agentId references
+    for (const trace of traces) {
+        for (const traceEvent of trace.events) {
+            const evt = traceEvent.event;
+            if (evt.type === 'tool_use' && evt.tool?.name === 'Task') {
+                // The tool_use_id from this call should appear as a result in the parent
+                // but we can link via timestamp proximity to child traces
+            }
+        }
+    }
+    // Phase 2: Team summary linking
+    for (const trace of traces) {
+        for (const traceEvent of trace.events) {
+            const content = traceEvent.event.message?.content;
+            if (typeof content === 'string' && content.includes('<teammate-message>')) {
+                // Parse teammate agent IDs from XML blocks
+                const matches = content.matchAll(/agent[_-]id['":\s]+([a-f0-9]+)/gi);
+                for (const match of matches) {
+                    const childId = match[1];
+                    const child = traceById.get(childId);
+                    if (child && child !== trace) {
+                        child.parentToolUseId = trace.agentId;
+                        trace.children.push(child);
+                    }
+                }
+            }
+        }
+    }
+    // Phase 3: Positional fallback — timestamp proximity
+    // Traces without parents that fall within another trace's time window
+    const parentless = traces.filter(t => !t.parentToolUseId);
+    for (const child of parentless) {
+        if (!child.stats.startTime)
+            continue;
+        const childStart = child.stats.startTime.getTime();
+        // Find a trace that was active (Task tool call) right before this child started
+        for (const potential of traces) {
+            if (potential === child)
+                continue;
+            if (potential.parentToolUseId)
+                continue; // Already linked
+            for (const traceEvent of potential.events) {
+                const evt = traceEvent.event;
+                if (evt.type === 'tool_use' && evt.tool?.name === 'Task') {
+                    const taskTime = new Date(evt.timestamp).getTime();
+                    // Within 2 seconds before child start
+                    if (taskTime <= childStart && childStart - taskTime < 2000) {
+                        child.parentToolUseId = potential.agentId;
+                        potential.children.push(child);
+                        break;
+                    }
+                }
+            }
+            if (child.parentToolUseId)
+                break;
+        }
+    }
+}
+// ── Helpers ──
+function rawToSessionEvent(raw) {
+    const type = raw.type;
+    if (!type)
+        return null;
+    // Map raw JSONL types to SessionEvent types
+    const typeMap = {
+        user: 'user',
+        assistant: 'assistant',
+        tool_use: 'tool_use',
+        tool_result: 'tool_result',
+        summary: 'summary',
+    };
+    const mappedType = typeMap[type];
+    if (!mappedType)
+        return null;
+    const message = raw.message;
+    const timestamp = raw.timestamp || new Date().toISOString();
+    // Extract tool info for tool_use events from content blocks
+    let tool;
+    let result;
+    if (mappedType === 'assistant' && message?.content && Array.isArray(message.content)) {
+        // Look for inline tool_use blocks
+        for (const block of message.content) {
+            if (block.type === 'tool_use') {
+                tool = {
+                    name: block.name,
+                    input: block.input || {},
+                };
+                break;
+            }
+        }
+    }
+    if (mappedType === 'tool_result') {
+        const msg = raw.message;
+        if (msg?.content && Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+                if (block.type === 'tool_result') {
+                    result = {
+                        tool_use_id: block.tool_use_id,
+                        output: block.content,
+                        is_error: block.is_error,
+                    };
+                    break;
+                }
+            }
+        }
+    }
+    return {
+        type: mappedType,
+        message: message || { role: 'unknown' },
+        timestamp,
+        isSidechain: raw.isSidechain,
+        permissionMode: raw.permissionMode,
+        tool,
+        result,
+    };
+}

package/dist/paths.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Config path resolution and workspace encoding.
+ * Mirrors patterns from sidekick-vscode/src/services/SessionPathResolver.ts
+ * and TaskPersistenceService.ts
+ */
+/**
+ * Gets the Sidekick config directory.
+ * ~/.config/sidekick on Unix, %APPDATA%/sidekick on Windows.
+ */
+export declare function getConfigDir(): string;
+/**
+ * Gets the path to a project-specific data file.
+ * e.g., ~/.config/sidekick/tasks/my-project.json
+ */
+export declare function getProjectDataPath(slug: string, subdomain: string): string;
+/**
+ * Gets the path to a global data file.
+ * e.g., ~/.config/sidekick/historical-data.json
+ */
+export declare function getGlobalDataPath(filename: string): string;
+/**
+ * Encodes a workspace path to Claude Code's directory naming scheme.
+ * Replaces path separators, colons, and underscores with hyphens.
+ *
+ * From: sidekick-vscode/src/services/SessionPathResolver.ts:35-43
+ */
+export declare function encodeWorkspacePath(workspacePath: string): string;
+/**
+ * Derives a project slug from a workspace path.
+ * Resolves symlinks, then encodes for use as a filename.
+ */
+export declare function getProjectSlug(cwd?: string): string;
+/**
+ * Derives a project slug WITHOUT resolving symlinks.
+ * Matches the VS Code extension's behavior (encodeWorkspacePath on raw path).
+ * Use this when reading data written by the extension.
+ */
+export declare function getProjectSlugRaw(cwd?: string): string;

package/dist/paths.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * Config path resolution and workspace encoding.
+ * Mirrors patterns from sidekick-vscode/src/services/SessionPathResolver.ts
+ * and TaskPersistenceService.ts
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigDir = getConfigDir;
+exports.getProjectDataPath = getProjectDataPath;
+exports.getGlobalDataPath = getGlobalDataPath;
+exports.encodeWorkspacePath = encodeWorkspacePath;
+exports.getProjectSlug = getProjectSlug;
+exports.getProjectSlugRaw = getProjectSlugRaw;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+/**
+ * Gets the Sidekick config directory.
+ * ~/.config/sidekick on Unix, %APPDATA%/sidekick on Windows.
+ */
+function getConfigDir() {
+    if (process.platform === 'win32') {
+        return path.join(process.env.APPDATA || os.homedir(), 'sidekick');
+    }
+    return path.join(os.homedir(), '.config', 'sidekick');
+}
+/**
+ * Gets the path to a project-specific data file.
+ * e.g., ~/.config/sidekick/tasks/my-project.json
+ */
+function getProjectDataPath(slug, subdomain) {
+    return path.join(getConfigDir(), subdomain, `${slug}.json`);
+}
+/**
+ * Gets the path to a global data file.
+ * e.g., ~/.config/sidekick/historical-data.json
+ */
+function getGlobalDataPath(filename) {
+    return path.join(getConfigDir(), filename);
+}
+/**
+ * Encodes a workspace path to Claude Code's directory naming scheme.
+ * Replaces path separators, colons, and underscores with hyphens.
+ *
+ * From: sidekick-vscode/src/services/SessionPathResolver.ts:35-43
+ */
+function encodeWorkspacePath(workspacePath) {
+    const normalized = workspacePath.replace(/\\/g, '/');
+    return normalized.replace(/[:/_]/g, '-');
+}
+/**
+ * Derives a project slug from a workspace path.
+ * Resolves symlinks, then encodes for use as a filename.
+ */
+function getProjectSlug(cwd) {
+    const dir = cwd || process.cwd();
+    let resolved;
+    try {
+        resolved = fs.realpathSync(dir);
+    }
+    catch {
+        resolved = path.resolve(dir);
+    }
+    return encodeWorkspacePath(resolved);
+}
+/**
+ * Derives a project slug WITHOUT resolving symlinks.
+ * Matches the VS Code extension's behavior (encodeWorkspacePath on raw path).
+ * Use this when reading data written by the extension.
+ */
+function getProjectSlugRaw(cwd) {
+    const dir = cwd || process.cwd();
+    return encodeWorkspacePath(path.resolve(dir));
+}

package/dist/phrases.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Randomized boot-up phrases that give Sidekick some personality.
+ * Phrases are organized into thematic categories and picked at random on each launch.
+ *
+ * This is the canonical source — both the VS Code extension and CLI import from here.
+ */
+export declare const SIDEKICK_ENERGY: string[];
+export declare const AI_COMMENTARY: string[];
+export declare const DEV_RELATABLE: string[];
+export declare const DRAMATIC: string[];
+export declare const PUNCHY: string[];
+/** Session monitoring / dashboard-specific humor. */
+export declare const META_MONITORING: string[];
+/** Meta-commentary on this feature and shameless self-promotion. */
+export declare const FOURTH_WALL: string[];
+/** The tangled web between programmers, AI, customers, codebases, and society. */
+export declare const THE_ECOSYSTEM: string[];
+/** Jokes about the AI companies whose models and tools we monitor. */
+export declare const AI_INDUSTRY: string[];
+/** The agent as your personal hype man, life coach, and motivational speaker. */
+export declare const MOTIVATION: string[];
+/** LLMs being sycophantic yes-men optimized for engagement over truth. */
+export declare const SYCOPHANCY: string[];
+/** Existential dread about AI replacing your job and eventually everything else. */
+export declare const OBSOLESCENCE: string[];
+/** Roasting the "just prompt and approve" lifestyle. */
+export declare const VIBE_CODING: string[];
+/** Late night deploys, 3 AM debugging, on-call horror, and weekend engineering. */
+export declare const AFTER_HOURS: string[];
+/** Video game loading screen tips, but for programming. */
+export declare const LOADING_TIPS: string[];
+/** Fake error messages, status codes, and stack traces. */
+export declare const ERROR_MESSAGES: string[];
+/** "Overheard in Slack" and "Overheard in standup" format. */
+export declare const OVERHEARD: string[];
+/** Roasting the worst commit messages humanity has produced. */
+export declare const COMMIT_SINS: string[];
+/** Fake profound wisdom that sounds deep but is just about code. */
+export declare const FORTUNE_COOKIE: string[];
+/** The absurdity of tech hiring, leetcode, and whiteboard interviews. */
+export declare const INTERVIEW_HELL: string[];
+/** Tongue twisters for developers, AI agents, and sidekick enthusiasts. */
+export declare const TONGUE_TWISTERS: string[];
+/** AI rubber duck debugger humor — talking through problems with a bot that listens too well. */
+export declare const RUBBER_DUCK: string[];
+/** Package management pain — dependency hell, version conflicts, and lockfile nightmares. */
+export declare const DEPENDENCY_HELL: string[];
+/** Searching, copying, and the graveyard of duplicate questions. */
+export declare const STACK_OVERFLOW: string[];
+export declare const ALL_PHRASES: string[];
+/** Pick a random phrase from all categories. */
+export declare function getRandomPhrase(): string;