@bububuger/spanory 0.1.15 → 0.1.18

package/dist/alert/evaluate.js

@@ -1,10 +1,12 @@
 // @ts-nocheck
 import { readFile } from 'node:fs/promises';
 import { summarizeAgents, summarizeCache, summarizeCommands, summarizeMcp, summarizeSessions, summarizeTurnDiff, } from '../report/aggregate.js';
+const DEFAULT_CONTEXT_WINDOW_TOKENS = 200000;
 function getMetricFromSessionRow(row, metric, refs = {}) {
     const cacheRow = refs.cacheBySessionId?.get(row.sessionId);
     const agentRow = refs.agentBySessionId?.get(row.sessionId);
     const turnDiffRows = refs.turnDiffBySessionId?.get(row.sessionId) ?? [];
+    const contextRow = refs.contextBySessionId?.get(row.sessionId);
     switch (metric) {
         case 'events':
             return row.events ?? 0;
@@ -26,10 +28,154 @@ function getMetricFromSessionRow(row, metric, refs = {}) {
             return agentRow?.agentTasks ?? 0;
         case 'diff.char_delta.max':
             return turnDiffRows.reduce((max, rowItem) => Math.max(max, Math.abs(Number(rowItem.charDelta ?? 0))), 0);
+        case 'context.unknown_delta_share.window5':
+            return contextRow?.unknownDeltaShareWindow5 ?? 0;
+        case 'context.unknown_top_streak':
+            return contextRow?.unknownTopStreak ?? 0;
+        case 'context.high_pollution_source_streak':
+            return contextRow?.highPollutionSourceStreak ?? 0;
+        case 'context.fill_ratio.max':
+            return contextRow?.maxFillRatio ?? 0;
+        case 'context.delta_ratio.max':
+            return contextRow?.maxDeltaRatio ?? 0;
+        case 'context.compact.count':
+            return contextRow?.compactCount ?? 0;
         default:
             return 0;
     }
 }
+function parseJsonObject(value) {
+    if (typeof value !== 'string' || !value.trim())
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+            return parsed;
+    }
+    catch {
+        // ignore parse errors
+    }
+    return null;
+}
+function parseJsonArray(value) {
+    if (typeof value !== 'string' || !value.trim())
+        return [];
+    try {
+        const parsed = JSON.parse(value);
+        if (Array.isArray(parsed))
+            return parsed;
+    }
+    catch {
+        // ignore parse errors
+    }
+    return [];
+}
+function summarizeContextForSession(events) {
+    const snapshots = events.filter((event) => event?.attributes?.['agentic.context.event_type'] === 'context_snapshot');
+    const attributions = events.filter((event) => event?.attributes?.['agentic.context.event_type'] === 'context_source_attribution');
+    const last5 = snapshots.slice(-5);
+    let unknownTokens = 0;
+    let totalTokens = 0;
+    for (const snapshot of last5) {
+        const composition = parseJsonObject(snapshot?.attributes?.['agentic.context.composition']);
+        if (!composition)
+            continue;
+        for (const [kind, raw] of Object.entries(composition)) {
+            const value = Number(raw);
+            if (!Number.isFinite(value) || value <= 0)
+                continue;
+            totalTokens += value;
+            if (kind === 'unknown')
+                unknownTokens += value;
+        }
+    }
+    const unknownDeltaShareWindow5 = totalTokens > 0 ? unknownTokens / totalTokens : 0;
+    let unknownTopStreak = 0;
+    let runningUnknown = 0;
+    for (const snapshot of snapshots) {
+        const topSources = parseJsonArray(snapshot?.attributes?.['agentic.context.top_sources']);
+        const top = String(topSources[0] ?? '').trim();
+        if (top === 'unknown') {
+            runningUnknown += 1;
+            if (runningUnknown > unknownTopStreak)
+                unknownTopStreak = runningUnknown;
+        }
+        else {
+            runningUnknown = 0;
+        }
+    }
+    const turnOrder = [];
+    const highByTurn = new Map();
+    for (const event of attributions) {
+        const attrs = event?.attributes ?? {};
+        const turnId = String(event?.turnId ?? '');
+        if (!turnId)
+            continue;
+        if (!highByTurn.has(turnId)) {
+            highByTurn.set(turnId, []);
+            turnOrder.push(turnId);
+        }
+        const sourceKind = String(attrs['agentic.context.source_kind'] ?? '').trim();
+        const score = Number(attrs['agentic.context.pollution_score']);
+        if (!sourceKind || !Number.isFinite(score))
+            continue;
+        if (score < 80)
+            continue;
+        highByTurn.get(turnId).push({ sourceKind, score });
+    }
+    let highPollutionSourceStreak = 0;
+    let runningSource = '';
+    let runningCount = 0;
+    for (const turnId of turnOrder) {
+        const items = highByTurn.get(turnId) ?? [];
+        if (!items.length) {
+            runningSource = '';
+            runningCount = 0;
+            continue;
+        }
+        items.sort((a, b) => b.score - a.score);
+        const topSource = items[0].sourceKind;
+        if (topSource === runningSource) {
+            runningCount += 1;
+        }
+        else {
+            runningSource = topSource;
+            runningCount = 1;
+        }
+        if (runningCount > highPollutionSourceStreak) {
+            highPollutionSourceStreak = runningCount;
+        }
+    }
+    let maxFillRatio = 0;
+    let maxDeltaRatio = 0;
+    let compactCount = 0;
+    for (const event of events) {
+        const attrs = event?.attributes ?? {};
+        if (String(attrs['agentic.context.event_type'] ?? '') === 'context_snapshot') {
+            const fillRatio = Number(attrs['agentic.context.fill_ratio']);
+            if (Number.isFinite(fillRatio) && fillRatio > maxFillRatio)
+                maxFillRatio = fillRatio;
+            const deltaTokens = Number(attrs['agentic.context.delta_tokens']);
+            if (Number.isFinite(deltaTokens) && deltaTokens > 0) {
+                const ratio = deltaTokens / DEFAULT_CONTEXT_WINDOW_TOKENS;
+                if (ratio > maxDeltaRatio)
+                    maxDeltaRatio = ratio;
+            }
+        }
+        if (String(attrs['agentic.context.event_type'] ?? '') === 'context_boundary'
+            && String(attrs['agentic.context.boundary_kind'] ?? '') === 'compact_after') {
+            compactCount += 1;
+        }
+    }
+    return {
+        unknownDeltaShareWindow5,
+        unknownTopStreak,
+        highPollutionSourceStreak,
+        maxFillRatio,
+        maxDeltaRatio,
+        compactCount,
+    };
+}
 function getMetricFromAgentRow(row, metric) {
     switch (metric) {
         case 'agentTasks':
@@ -68,12 +214,17 @@ function evaluateSessionRule(rule, sessions) {
         list.push(row);
         turnDiffBySessionId.set(key, list);
     }
+    const contextBySessionId = new Map(sessions.map((session) => [
+        session.context?.sessionId ?? session.events?.[0]?.sessionId,
+        summarizeContextForSession(session.events ?? []),
+    ]));
     const matched = rows
         .map((row) => {
         const value = getMetricFromSessionRow(row, rule.metric, {
             cacheBySessionId,
             agentBySessionId,
             turnDiffBySessionId,
+            contextBySessionId,
         });
         return { row, value };
     })

package/dist/env.d.ts

@@ -1,2 +1,6 @@
+export declare function resolveUserHome(): string;
+export declare function resolveSpanoryHome(): string;
+export declare function resolveSpanoryEnvPath(): string;
+export declare function resolveLegacyUserEnvPath(): string;
 export declare function parseSimpleDotEnv(raw: any): {};
 export declare function loadUserEnv(): Promise<void>;

package/dist/env.js

@@ -1,9 +1,23 @@
 // @ts-nocheck
 import path from 'node:path';
-import { readFile } from 'node:fs/promises';
-function resolveUserHome() {
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+export function resolveUserHome() {
     return process.env.HOME || process.env.USERPROFILE || '';
 }
+export function resolveSpanoryHome() {
+    if (process.env.SPANORY_HOME)
+        return process.env.SPANORY_HOME;
+    const home = resolveUserHome();
+    return home ? path.join(home, '.spanory') : '';
+}
+export function resolveSpanoryEnvPath() {
+    const root = resolveSpanoryHome();
+    return root ? path.join(root, '.env') : '';
+}
+export function resolveLegacyUserEnvPath() {
+    const home = resolveUserHome();
+    return home ? path.join(home, '.env') : '';
+}
 export function parseSimpleDotEnv(raw) {
     const out = {};
     for (const line of String(raw).split('\n')) {
@@ -36,19 +50,33 @@ export function parseSimpleDotEnv(raw) {
     return out;
 }
 export async function loadUserEnv() {
-    const home = resolveUserHome();
-    if (!home)
+    const spanoryHome = resolveSpanoryHome();
+    const envPath = resolveSpanoryEnvPath();
+    const legacyEnvPath = resolveLegacyUserEnvPath();
+    if (!spanoryHome || !envPath)
         return;
-    const envPath = path.join(home, '.env');
     try {
-        const raw = await readFile(envPath, 'utf-8');
-        const parsed = parseSimpleDotEnv(raw);
-        for (const [k, v] of Object.entries(parsed)) {
-            if (process.env[k] === undefined)
-                process.env[k] = v;
-        }
+        await mkdir(spanoryHome, { recursive: true });
+        await writeFile(envPath, '', { flag: 'a' });
     }
     catch {
-        // ignore missing ~/.env
+        // best effort only
+    }
+    const candidates = [envPath, legacyEnvPath].filter(Boolean);
+    for (const candidate of candidates) {
+        try {
+            const raw = await readFile(candidate, 'utf-8');
+            const parsed = parseSimpleDotEnv(raw);
+            if (Object.keys(parsed).length === 0)
+                continue;
+            for (const [k, v] of Object.entries(parsed)) {
+                if (process.env[k] === undefined)
+                    process.env[k] = v;
+            }
+            return;
+        }
+        catch {
+            // try next candidate
+        }
     }
 }