npm - noctrace - Versions diffs - 0.5.0 → 0.6.0 - Mend

noctrace 0.5.0 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/README.md +9 -3
package/dist/client/assets/index-C4vi082v.css +2 -0
package/dist/client/assets/index-DqY0cF0g.js +30 -0
package/dist/client/index.html +2 -2
package/dist/server/shared/filter.js +172 -0
package/dist/server/shared/latency-stats.js +76 -0
package/dist/server/shared/session-compare.js +89 -0
package/dist/server/shared/tips.js +36 -7
package/package.json +1 -1
package/dist/client/assets/index-CfD3iTQS.js +0 -30
package/dist/client/assets/index-nE1IMGzA.css +0 -2

package/dist/client/index.html CHANGED Viewed

@@ -7,8 +7,8 @@
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;600;700&display=swap" rel="stylesheet" />
-    <script type="module" crossorigin src="/assets/index-CfD3iTQS.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-nE1IMGzA.css">
+    <script type="module" crossorigin src="/assets/index-DqY0cF0g.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-C4vi082v.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/shared/filter.js ADDED Viewed

@@ -0,0 +1,172 @@
+/** Special keywords that map directly to status or type filters */
+const STATUS_KEYWORDS = new Set(['error', 'running', 'success']);
+/**
+ * Parses a raw filter string into structured filter components.
+ * Tokens are space-separated. Unrecognised tokens become textTokens.
+ */
+export function parseFilterString(filter) {
+    const result = {
+        textTokens: [],
+        typeFilters: [],
+        minDuration: null,
+        maxDuration: null,
+        statusFilters: [],
+        minTokens: null,
+        maxTokens: null,
+    };
+    if (!filter.trim())
+        return result;
+    const tokens = filter.trim().split(/\s+/);
+    for (const token of tokens) {
+        const lower = token.toLowerCase();
+        // type:xxx
+        if (lower.startsWith('type:')) {
+            const typeName = lower.slice(5);
+            if (typeName)
+                result.typeFilters.push(typeName);
+            continue;
+        }
+        // tokens:>NNN or tokens:<NNN
+        if (lower.startsWith('tokens:')) {
+            const rest = lower.slice(7);
+            if (rest.startsWith('>')) {
+                const n = parseTokenCount(rest.slice(1));
+                if (n !== null)
+                    result.minTokens = n;
+            }
+            else if (rest.startsWith('<')) {
+                const n = parseTokenCount(rest.slice(1));
+                if (n !== null)
+                    result.maxTokens = n;
+            }
+            continue;
+        }
+        // >NNNms or >NNNs or >NNN (seconds default)
+        if (lower.startsWith('>')) {
+            const ms = parseDuration(lower.slice(1));
+            if (ms !== null) {
+                result.minDuration = ms;
+                continue;
+            }
+        }
+        // <NNNms or <NNNs or <NNN (seconds default)
+        if (lower.startsWith('<')) {
+            const ms = parseDuration(lower.slice(1));
+            if (ms !== null) {
+                result.maxDuration = ms;
+                continue;
+            }
+        }
+        // Special status keywords (backward compat)
+        if (STATUS_KEYWORDS.has(lower)) {
+            result.statusFilters.push(lower);
+            continue;
+        }
+        // 'agent' keyword: treated as type filter for backward compat
+        if (lower === 'agent') {
+            result.typeFilters.push('agent');
+            continue;
+        }
+        // Everything else is free text
+        result.textTokens.push(lower);
+    }
+    return result;
+}
+/**
+ * Parses a duration string like "5s", "100ms", or "5" (default seconds).
+ * Returns milliseconds, or null if the string is not a valid duration.
+ */
+function parseDuration(s) {
+    if (s.endsWith('ms')) {
+        const n = Number(s.slice(0, -2));
+        return isNaN(n) ? null : n;
+    }
+    if (s.endsWith('s')) {
+        const n = Number(s.slice(0, -1));
+        return isNaN(n) ? null : n * 1000;
+    }
+    // No unit — treat as seconds
+    const n = Number(s);
+    return isNaN(n) ? null : n * 1000;
+}
+/**
+ * Parses a token count string. Supports plain integers and k/m suffixes (e.g., "1k", "1.5m").
+ * Returns null if the string is not parseable.
+ */
+function parseTokenCount(s) {
+    const lower = s.toLowerCase();
+    if (lower.endsWith('k')) {
+        const n = Number(lower.slice(0, -1));
+        return isNaN(n) ? null : Math.round(n * 1000);
+    }
+    if (lower.endsWith('m')) {
+        const n = Number(lower.slice(0, -1));
+        return isNaN(n) ? null : Math.round(n * 1_000_000);
+    }
+    const n = Number(lower);
+    return isNaN(n) ? null : n;
+}
+/**
+ * Tests whether a row matches a pre-parsed filter.
+ * All active filter fields are AND-ed; multiple typeFilters are OR-ed.
+ * Agent rows also match when any of their children match.
+ */
+export function rowMatchesFilter(row, parsed) {
+    // Empty filter — everything matches
+    const hasAnyFilter = parsed.textTokens.length > 0 ||
+        parsed.typeFilters.length > 0 ||
+        parsed.minDuration !== null ||
+        parsed.maxDuration !== null ||
+        parsed.statusFilters.length > 0 ||
+        parsed.minTokens !== null ||
+        parsed.maxTokens !== null;
+    if (!hasAnyFilter)
+        return true;
+    // For agent rows, also return true if any child matches
+    if (row.type === 'agent' && row.children.length > 0) {
+        if (row.children.some((child) => rowMatchesFilter(child, parsed)))
+            return true;
+    }
+    return rowMatchesDirect(row, parsed);
+}
+/** Tests a single row (no child traversal) against the parsed filter. */
+function rowMatchesDirect(row, parsed) {
+    // Status filter
+    if (parsed.statusFilters.length > 0) {
+        if (!parsed.statusFilters.includes(row.status))
+            return false;
+    }
+    // Type filter (OR among typeFilters)
+    if (parsed.typeFilters.length > 0) {
+        const rowTypeLower = row.toolName.toLowerCase();
+        const rowKind = row.type; // 'agent' | 'tool'
+        const matched = parsed.typeFilters.some((tf) => rowTypeLower === tf || rowTypeLower.includes(tf) || rowKind === tf);
+        if (!matched)
+            return false;
+    }
+    // Duration filter
+    if (parsed.minDuration !== null) {
+        if (row.duration === null || row.duration < parsed.minDuration)
+            return false;
+    }
+    if (parsed.maxDuration !== null) {
+        if (row.duration === null || row.duration > parsed.maxDuration)
+            return false;
+    }
+    // Token delta filter
+    if (parsed.minTokens !== null) {
+        if (row.tokenDelta < parsed.minTokens)
+            return false;
+    }
+    if (parsed.maxTokens !== null) {
+        if (row.tokenDelta > parsed.maxTokens)
+            return false;
+    }
+    // Free-text filter
+    if (parsed.textTokens.length > 0) {
+        const haystack = (row.toolName + ' ' + row.label).toLowerCase();
+        if (!parsed.textTokens.every((t) => haystack.includes(t)))
+            return false;
+    }
+    return true;
+}

package/dist/server/shared/latency-stats.js ADDED Viewed

@@ -0,0 +1,76 @@
+/** 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;
+}
+/**
+ * Compute a percentile value from a sorted array of numbers.
+ *
+ * Uses the nearest-rank method: index = Math.floor((n - 1) * p).
+ * The array must be sorted in ascending order.
+ */
+function percentile(sorted, p) {
+    if (sorted.length === 0)
+        return 0;
+    const idx = Math.floor((sorted.length - 1) * p);
+    return sorted[idx];
+}
+/**
+ * Compute per-tool latency statistics for a session.
+ *
+ * Flattens all rows (including nested children), skips rows without a
+ * completed duration, groups by normalized tool name (lowercased), and
+ * computes P50, P95, max, and total for each group. Also collects row IDs
+ * that exceed the provided slow threshold.
+ *
+ * @param rows - Top-level WaterfallRow array from the session parser.
+ * @param slowThresholdMs - Duration threshold in milliseconds above which a
+ *   row is considered slow and included in `slowCallIds`.
+ * @returns {@link SessionLatencyStats} with tool breakdowns and slow call IDs.
+ */
+export function computeLatencyStats(rows, slowThresholdMs) {
+    const flat = flattenRows(rows);
+    // Group durations and collect slow call IDs in one pass.
+    const groups = new Map();
+    const slowCallIds = [];
+    for (const row of flat) {
+        if (row.duration === null)
+            continue;
+        const key = row.toolName.toLowerCase();
+        if (!groups.has(key)) {
+            groups.set(key, { durations: [], originalName: row.toolName });
+        }
+        // Non-null assertion is safe: we just set it above if missing.
+        groups.get(key).durations.push(row.duration);
+        if (row.duration > slowThresholdMs) {
+            slowCallIds.push(row.id);
+        }
+    }
+    // Build per-tool stats.
+    const toolStats = [];
+    for (const [, { durations, originalName }] of groups) {
+        durations.sort((a, b) => a - b);
+        const total = durations.reduce((sum, d) => sum + d, 0);
+        toolStats.push({
+            toolName: originalName,
+            count: durations.length,
+            p50: percentile(durations, 0.5),
+            p95: percentile(durations, 0.95),
+            max: durations[durations.length - 1],
+            total,
+        });
+    }
+    // Sort by total duration descending.
+    toolStats.sort((a, b) => b.total - a.total);
+    const totalCalls = toolStats.reduce((sum, s) => sum + s.count, 0);
+    const totalDuration = toolStats.reduce((sum, s) => sum + s.total, 0);
+    return { toolStats, totalCalls, totalDuration, slowCallIds };
+}

package/dist/server/shared/session-compare.js ADDED Viewed

@@ -0,0 +1,89 @@
+/** 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;
+}
+/**
+ * Compute aggregated metrics for a session's waterfall rows.
+ *
+ * Accepts the top-level WaterfallRow array and the session's ContextHealth
+ * (may be null for sessions that haven't been scored yet). Returns a
+ * {@link SessionMetrics} object suitable for display and delta computation.
+ */
+export function computeSessionMetrics(rows, health) {
+    if (rows.length === 0) {
+        return {
+            totalDuration: 0,
+            totalTokens: 0,
+            totalCalls: 0,
+            errorCount: 0,
+            errorRate: 0,
+            toolMix: {},
+            healthGrade: health?.grade ?? 'A',
+            healthScore: health?.score ?? 100,
+            contextFillTimeline: [],
+        };
+    }
+    const flat = flattenRows(rows);
+    let totalTokens = 0;
+    let errorCount = 0;
+    let minStart = Infinity;
+    let maxEnd = -Infinity;
+    const toolMix = {};
+    const contextFillTimeline = [];
+    for (const row of flat) {
+        totalTokens += row.inputTokens + row.outputTokens;
+        if (row.status === 'error')
+            errorCount++;
+        if (row.startTime < minStart)
+            minStart = row.startTime;
+        const end = row.endTime ?? row.startTime;
+        if (end > maxEnd)
+            maxEnd = end;
+        // Count tool mix (use original toolName casing)
+        const name = row.toolName;
+        toolMix[name] = (toolMix[name] ?? 0) + 1;
+        // Collect context fill trajectory — skip zero/unset values
+        if (row.contextFillPercent > 0) {
+            contextFillTimeline.push(row.contextFillPercent);
+        }
+    }
+    const totalCalls = flat.length;
+    const errorRate = totalCalls > 0 ? errorCount / totalCalls : 0;
+    const totalDuration = maxEnd > minStart ? maxEnd - minStart : 0;
+    return {
+        totalDuration,
+        totalTokens,
+        totalCalls,
+        errorCount,
+        errorRate,
+        toolMix,
+        healthGrade: health?.grade ?? 'A',
+        healthScore: health?.score ?? 100,
+        contextFillTimeline,
+    };
+}
+/**
+ * Compute the numeric deltas between two sessions (right minus left).
+ *
+ * A negative durationDelta means the right session completed faster.
+ * A negative errorRateDelta means the right session had fewer errors.
+ * These semantics let the UI consistently color negative as green (better)
+ * and positive as red (worse) for duration, tokens, calls, and error rate.
+ */
+export function compareSessionMetrics(left, right) {
+    return {
+        durationDelta: right.totalDuration - left.totalDuration,
+        tokenDelta: right.totalTokens - left.totalTokens,
+        callDelta: right.totalCalls - left.totalCalls,
+        errorRateDelta: right.errorRate - left.errorRate,
+    };
+}

package/dist/server/shared/tips.js CHANGED Viewed

@@ -35,15 +35,16 @@ function flattenRows(rows) {
  * Analyze rows and attach efficiency tips to wasteful ones. Mutates rows in place.
  *
  * Detection rules:
- * 1. Re-read           — row.isReread is true
- * 2. Search fan-out    — 5+ consecutive search/read tools with no write between them
- * 3. Correction loop   — 3+ edits to the same file_path
- * 4. Repeated Bash     — same command string run 2+ times
- * 5. Large token spike — row.tokenDelta > 10 000
- * 6. High context fill — first row where contextFillPercent >= 80
- * 7. No delegation     — 50+ total tool rows with zero agent rows
+ * 1. Re-read              — row.isReread is true
+ * 2. Search fan-out       — 5+ consecutive search/read tools with no write between them
+ * 3. Correction loop      — 3+ edits to the same file_path
+ * 4. Repeated Bash        — same command string run 2+ times
+ * 5. Large token spike    — row.tokenDelta > 10 000
+ * 6. High context fill    — first row where contextFillPercent >= 80
+ * 7. No delegation        — 50+ total tool rows with zero agent rows
  * 8. Post-compaction re-read — isReread after a compaction boundary
  * 9. Compaction thrash    — 3+ compaction boundaries (thrash loop)
+ * 10. Identical tool loop — 3+ consecutive calls with the same toolName + input key
  *
  * A row may accumulate multiple tips. Duplicate tip ids on the same row are silently skipped.
  *
@@ -71,6 +72,12 @@ export function attachEfficiencyTips(rows, compactionBoundaries) {
     const bashCounts = new Map();
     /** Whether we have already attached the high-fill tip. */
     let highFillAttached = false;
+    /**
+     * State for Rule 10: Identical tool loop.
+     * Tracks the key of the last tool call and the consecutive run length.
+     */
+    let lastToolKey = null;
+    let identicalToolStreak = 0;
     /** Total tool rows (type === 'tool') across the session. */
     let toolRowCount = 0;
     /** Whether any agent row exists in the session. */
@@ -194,6 +201,28 @@ export function attachEfficiencyTips(rows, compactionBoundaries) {
                 severity: 'critical',
             });
         }
+        // ------------------------------------------------------------------
+        // Rule 10: Identical tool loop
+        // Track 3+ consecutive tool calls with the same toolName + input key.
+        // Use first 200 chars of stringified input to avoid perf issues on
+        // large inputs while still catching the common stuck-loop pattern.
+        // ------------------------------------------------------------------
+        const inputKey = row.toolName + ':' + JSON.stringify(row.input).slice(0, 200);
+        if (inputKey === lastToolKey) {
+            identicalToolStreak++;
+            if (identicalToolStreak >= 3) {
+                addTip(row, {
+                    id: 'identical-loop',
+                    title: 'Identical tool loop',
+                    message: 'Same tool called with identical input 3 times consecutively — the agent may be stuck in a loop.',
+                    severity: 'warning',
+                });
+            }
+        }
+        else {
+            lastToolKey = inputKey;
+            identicalToolStreak = 1;
+        }
     }
     // -------------------------------------------------------------------------
     // Rule 7: No delegation (post-scan)

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "noctrace",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Chrome DevTools Network-tab-style waterfall visualizer for Claude Code agent workflows",
   "type": "module",
   "license": "MIT",