noctrace 0.7.4 → 0.8.0

package/dist/server/shared/reliability.js

@@ -0,0 +1,186 @@
+/** Collect all rows (including nested children) into a flat list. */
+function flattenRows(rows) {
+    const result = [];
+    const walk = (list) => {
+        for (const row of list) {
+            result.push(row);
+            if (row.children.length > 0)
+                walk(row.children);
+        }
+    };
+    walk(rows);
+    return result;
+}
+/**
+ * Extract the first plausible file path from a label string.
+ * Matches Unix-style absolute paths or relative paths containing a `/`.
+ * Returns null when no path-like token is found.
+ */
+function extractFilePath(label) {
+    // Match tokens that look like file paths:
+    // - absolute: /foo/bar.ts
+    // - relative with directory: src/foo.ts
+    // We split on spaces/colons/parens and look for tokens containing '/'
+    const tokens = label.split(/[\s:()[\],"']+/);
+    for (const token of tokens) {
+        if (token.length === 0)
+            continue;
+        // Must contain a slash and at least one dot (heuristic for real paths)
+        if (token.includes('/') && token.includes('.')) {
+            return token;
+        }
+        // Also accept absolute paths without a dot (e.g. /usr/local/bin/node)
+        if (token.startsWith('/') && token.includes('/')) {
+            return token;
+        }
+    }
+    return null;
+}
+/**
+ * Compute per-tool and session-level reliability statistics.
+ *
+ * Rows with status 'running' are excluded from all counts — they have not
+ * yet completed and would skew success/error ratios.
+ *
+ * @param rows - Top-level WaterfallRow array from the session parser.
+ * @returns {@link SessionReliability} with per-tool and aggregate metrics.
+ */
+export function computeReliability(rows) {
+    const flat = flattenRows(rows);
+    // Only consider completed rows (skip running)
+    const completed = flat.filter((r) => r.status !== 'running');
+    if (completed.length === 0) {
+        return {
+            totalCalls: 0,
+            successCount: 0,
+            errorCount: 0,
+            failureCount: 0,
+            overallReliability: 100,
+            errorDensity: 0,
+            recoveryAttempts: 0,
+            recoverySuccesses: 0,
+            recoveryRate: 0,
+            avgErrorsBeforeFix: 0,
+            toolReliability: [],
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Overall counts
+    // -------------------------------------------------------------------------
+    let successCount = 0;
+    let errorCount = 0;
+    let failureCount = 0;
+    for (const row of completed) {
+        if (row.isFailure) {
+            failureCount++;
+        }
+        else if (row.status === 'error') {
+            errorCount++;
+        }
+        else {
+            successCount++;
+        }
+    }
+    const totalCalls = completed.length;
+    const overallReliability = (successCount / totalCalls) * 100;
+    // -------------------------------------------------------------------------
+    // Error density: errors per 10 calls
+    // -------------------------------------------------------------------------
+    const errorDensity = totalCalls > 0 ? (errorCount / totalCalls) * 10 : 0;
+    // -------------------------------------------------------------------------
+    // Recovery rate: error→same-tool-success sequences
+    // -------------------------------------------------------------------------
+    // Build a map from toolName (lowercased) to the ordered list of completed rows
+    const toolSequences = new Map();
+    for (const row of completed) {
+        const key = row.toolName.toLowerCase();
+        if (!toolSequences.has(key))
+            toolSequences.set(key, []);
+        toolSequences.get(key).push(row);
+    }
+    let recoveryAttempts = 0;
+    let recoverySuccesses = 0;
+    for (const [, sequence] of toolSequences) {
+        for (let i = 0; i < sequence.length - 1; i++) {
+            if (sequence[i].status === 'error') {
+                // Look for the immediately next row in the same-tool sequence
+                recoveryAttempts++;
+                if (sequence[i + 1].status === 'success') {
+                    recoverySuccesses++;
+                }
+            }
+        }
+    }
+    const recoveryRate = recoveryAttempts > 0 ? (recoverySuccesses / recoveryAttempts) * 100 : 0;
+    // -------------------------------------------------------------------------
+    // Error-to-fix ratio: avg errors before first success, per file
+    // -------------------------------------------------------------------------
+    // Group rows by extracted file path
+    const fileRows = new Map();
+    for (const row of completed) {
+        const filePath = extractFilePath(row.label);
+        if (filePath === null)
+            continue;
+        if (!fileRows.has(filePath))
+            fileRows.set(filePath, []);
+        fileRows.get(filePath).push(row);
+    }
+    const errorsBeforeFixCounts = [];
+    for (const [, fileSeq] of fileRows) {
+        // Find the index of the first success
+        const firstSuccessIdx = fileSeq.findIndex((r) => r.status === 'success');
+        if (firstSuccessIdx <= 0)
+            continue; // no success, or success was first — skip
+        // Count errors before the first success
+        const errorsBeforeSuccess = fileSeq
+            .slice(0, firstSuccessIdx)
+            .filter((r) => r.status === 'error').length;
+        if (errorsBeforeSuccess === 0)
+            continue; // no errors before success — skip
+        errorsBeforeFixCounts.push(errorsBeforeSuccess);
+    }
+    const avgErrorsBeforeFix = errorsBeforeFixCounts.length > 0
+        ? errorsBeforeFixCounts.reduce((a, b) => a + b, 0) / errorsBeforeFixCounts.length
+        : 0;
+    // -------------------------------------------------------------------------
+    // Per-tool reliability
+    // -------------------------------------------------------------------------
+    const toolGroups = new Map();
+    for (const row of completed) {
+        const key = row.toolName.toLowerCase();
+        if (!toolGroups.has(key)) {
+            toolGroups.set(key, { originalName: row.toolName, success: 0, errors: 0, failures: 0 });
+        }
+        const entry = toolGroups.get(key);
+        if (row.isFailure) {
+            entry.failures++;
+        }
+        else if (row.status === 'error') {
+            entry.errors++;
+        }
+        else {
+            entry.success++;
+        }
+    }
+    const toolReliability = [];
+    for (const [, { originalName, success, errors, failures }] of toolGroups) {
+        const total = success + errors + failures;
+        const reliability = total > 0 ? (success / total) * 100 : 100;
+        toolReliability.push({ toolName: originalName, total, success, errors, failures, reliability });
+    }
+    // Sort ascending by reliability — worst tools first
+    toolReliability.sort((a, b) => a.reliability - b.reliability);
+    return {
+        totalCalls,
+        successCount,
+        errorCount,
+        failureCount,
+        overallReliability,
+        errorDensity,
+        recoveryAttempts,
+        recoverySuccesses,
+        recoveryRate,
+        avgErrorsBeforeFix,
+        toolReliability,
+    };
+}

package/dist/server/shared/session-metadata.js

@@ -0,0 +1,161 @@
+function isObj(val) {
+    return typeof val === 'object' && val !== null && !Array.isArray(val);
+}
+/**
+ * Extract compaction boundaries with optional metadata from JSONL content.
+ * Returns CompactionBoundary[] with trigger type and pre-compaction token count.
+ */
+export function parseCompactionBoundaries(content) {
+    const lines = content.split('\n');
+    const out = [];
+    for (const line of lines) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(t);
+        }
+        catch {
+            continue;
+        }
+        if (!isObj(parsed))
+            continue;
+        if (parsed['type'] !== 'system')
+            continue;
+        if (parsed['subtype'] !== 'compact_boundary')
+            continue;
+        const timestamp = typeof parsed['timestamp'] === 'string'
+            ? new Date(parsed['timestamp']).getTime() : Date.now();
+        // Extract compact_metadata if present
+        const meta = isObj(parsed['compact_metadata']) ? parsed['compact_metadata'] : null;
+        const trigger = meta && (meta['trigger'] === 'manual' || meta['trigger'] === 'auto')
+            ? meta['trigger'] : null;
+        const preTokens = meta && typeof meta['pre_tokens'] === 'number' ? meta['pre_tokens'] : null;
+        out.push({ timestamp, trigger, preTokens });
+    }
+    return out;
+}
+/**
+ * Parse the terminal result record from JSONL content.
+ * Extracts duration_api_ms, modelUsage, stop_reason, permission_denials.
+ */
+export function parseSessionResultMetrics(content) {
+    const defaults = {
+        durationApiMs: null,
+        modelUsage: [],
+        stopReason: null,
+        permissionDenialCount: 0,
+    };
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(t);
+        }
+        catch {
+            continue;
+        }
+        if (!isObj(parsed))
+            continue;
+        if (parsed['type'] !== 'result')
+            continue;
+        // duration_api_ms
+        if (typeof parsed['duration_api_ms'] === 'number') {
+            defaults.durationApiMs = parsed['duration_api_ms'];
+        }
+        // stop_reason
+        const sr = parsed['stop_reason'];
+        if (sr === 'end_turn' || sr === 'max_tokens' || sr === 'refusal') {
+            defaults.stopReason = sr;
+        }
+        // permission_denials
+        if (Array.isArray(parsed['permission_denials'])) {
+            defaults.permissionDenialCount = parsed['permission_denials'].length;
+        }
+        // modelUsage — { [modelName]: { input_tokens, output_tokens, cache_read_input_tokens?, cache_creation_input_tokens? } }
+        const mu = parsed['modelUsage'];
+        if (isObj(mu)) {
+            const entries = [];
+            for (const [model, usage] of Object.entries(mu)) {
+                if (!isObj(usage))
+                    continue;
+                entries.push({
+                    model,
+                    inputTokens: typeof usage['input_tokens'] === 'number' ? usage['input_tokens'] : 0,
+                    outputTokens: typeof usage['output_tokens'] === 'number' ? usage['output_tokens'] : 0,
+                    cacheReadTokens: typeof usage['cache_read_input_tokens'] === 'number' ? usage['cache_read_input_tokens'] : 0,
+                    cacheCreateTokens: typeof usage['cache_creation_input_tokens'] === 'number' ? usage['cache_creation_input_tokens'] : 0,
+                });
+            }
+            defaults.modelUsage = entries;
+        }
+        // Only one result record per session — stop scanning
+        break;
+    }
+    return defaults;
+}
+/**
+ * Parse session init context (agents, skills, plugins, effort) from JSONL content.
+ * Reads the first system init record.
+ */
+export function parseInitContext(content) {
+    const defaults = { agents: [], skills: [], plugins: [], effort: null };
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(t);
+        }
+        catch {
+            continue;
+        }
+        if (!isObj(parsed))
+            continue;
+        if (parsed['type'] !== 'system')
+            continue;
+        // Match init records — subtype may be 'init' or absent on the first system record
+        const subtype = parsed['subtype'];
+        if (subtype !== undefined && subtype !== 'init')
+            continue;
+        // agents
+        if (Array.isArray(parsed['agents'])) {
+            defaults.agents = parsed['agents'].filter((a) => typeof a === 'string');
+        }
+        // skills
+        if (Array.isArray(parsed['skills'])) {
+            defaults.skills = parsed['skills'].filter((s) => typeof s === 'string');
+        }
+        // plugins
+        if (Array.isArray(parsed['plugins'])) {
+            for (const p of parsed['plugins']) {
+                if (isObj(p) && typeof p['name'] === 'string') {
+                    defaults.plugins.push({
+                        name: p['name'],
+                        path: typeof p['path'] === 'string' ? p['path'] : '',
+                    });
+                }
+            }
+        }
+        // effort level
+        if (typeof parsed['effort'] === 'string') {
+            defaults.effort = parsed['effort'];
+        }
+        // Also check nested config field where effort might appear
+        if (defaults.effort === null && isObj(parsed['config'])) {
+            const config = parsed['config'];
+            if (typeof config['effort'] === 'string') {
+                defaults.effort = config['effort'];
+            }
+        }
+        // Only read the first init record
+        break;
+    }
+    return defaults;
+}

package/hooks/hooks.json

@@ -64,5 +64,38 @@
         }
       ]
     }
+  ],
+  "SessionStart": [
+    {
+      "hooks": [
+        {
+          "type": "command",
+          "command": "curl -s -X POST http://localhost:4117/api/hooks -H 'Content-Type: application/json' --data-raw \"$(cat)\"",
+          "async": true
+        }
+      ]
+    }
+  ],
+  "SessionEnd": [
+    {
+      "hooks": [
+        {
+          "type": "command",
+          "command": "curl -s -X POST http://localhost:4117/api/hooks -H 'Content-Type: application/json' --data-raw \"$(cat)\"",
+          "async": true
+        }
+      ]
+    }
+  ],
+  "PostToolUseFailure": [
+    {
+      "hooks": [
+        {
+          "type": "command",
+          "command": "curl -s -X POST http://localhost:4117/api/hooks -H 'Content-Type: application/json' --data-raw \"$(cat)\"",
+          "async": true
+        }
+      ]
+    }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "noctrace",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "description": "Chrome DevTools Network-tab-style waterfall visualizer for Claude Code agent workflows",
   "type": "module",
   "license": "MIT",
@@ -17,17 +17,26 @@
     "node": ">=20"
   },
   "keywords": [
-    "claude",
+    "noctrace",
     "claude-code",
+    "claude",
     "anthropic",
+    "observability",
     "devtools",
     "waterfall",
-    "observability",
-    "agent",
-    "ai",
+    "ai-agent",
     "llm",
     "timeline",
-    "visualizer"
+    "visualizer",
+    "claude-code-hooks",
+    "token-usage",
+    "context-window",
+    "agent-monitoring",
+    "ai-observability",
+    "claude-code-devtools",
+    "session-viewer",
+    "tool-calls",
+    "sub-agents"
   ],
   "bin": {
     "noctrace": "bin/noctrace.js"