@bububuger/spanory 0.1.14

package/dist/alert/evaluate.d.ts

@@ -0,0 +1,3 @@
+export declare function loadAlertRules(path: any): Promise<any>;
+export declare function evaluateRules(rules: any, sessions: any): any[];
+export declare function sendAlertWebhook(url: any, payload: any, headers?: {}): Promise<void>;

package/dist/alert/evaluate.js

@@ -0,0 +1,197 @@
+// @ts-nocheck
+import { readFile } from 'node:fs/promises';
+import { summarizeAgents, summarizeCache, summarizeCommands, summarizeMcp, summarizeSessions, summarizeTurnDiff, } from '../report/aggregate.js';
+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) ?? [];
+    switch (metric) {
+        case 'events':
+            return row.events ?? 0;
+        case 'turns':
+            return row.turns ?? 0;
+        case 'usage.total':
+            return row.usage?.total ?? 0;
+        case 'usage.input':
+            return row.usage?.input ?? 0;
+        case 'usage.output':
+            return row.usage?.output ?? 0;
+        case 'cache.read':
+            return cacheRow?.cacheReadInputTokens ?? 0;
+        case 'cache.creation':
+            return cacheRow?.cacheCreationInputTokens ?? 0;
+        case 'cache.hit_rate':
+            return cacheRow?.cacheHitRate ?? 0;
+        case 'subagent.calls':
+            return agentRow?.agentTasks ?? 0;
+        case 'diff.char_delta.max':
+            return turnDiffRows.reduce((max, rowItem) => Math.max(max, Math.abs(Number(rowItem.charDelta ?? 0))), 0);
+        default:
+            return 0;
+    }
+}
+function getMetricFromAgentRow(row, metric) {
+    switch (metric) {
+        case 'agentTasks':
+            return row.agentTasks ?? 0;
+        case 'shellCommands':
+            return row.shellCommands ?? 0;
+        case 'mcpCalls':
+            return row.mcpCalls ?? 0;
+        case 'usage.total':
+            return row.usage?.total ?? 0;
+        default:
+            return 0;
+    }
+}
+function compare(value, op, threshold) {
+    if (op === 'gt')
+        return value > threshold;
+    if (op === 'gte')
+        return value >= threshold;
+    if (op === 'lt')
+        return value < threshold;
+    if (op === 'lte')
+        return value <= threshold;
+    if (op === 'eq')
+        return value === threshold;
+    throw new Error(`unsupported operator: ${op}`);
+}
+function evaluateSessionRule(rule, sessions) {
+    const rows = summarizeSessions(sessions);
+    const cacheBySessionId = new Map(summarizeCache(sessions).map((row) => [row.sessionId, row]));
+    const agentBySessionId = new Map(summarizeAgents(sessions).map((row) => [row.sessionId, row]));
+    const turnDiffBySessionId = new Map();
+    for (const row of summarizeTurnDiff(sessions)) {
+        const key = row.sessionId;
+        const list = turnDiffBySessionId.get(key) ?? [];
+        list.push(row);
+        turnDiffBySessionId.set(key, list);
+    }
+    const matched = rows
+        .map((row) => {
+        const value = getMetricFromSessionRow(row, rule.metric, {
+            cacheBySessionId,
+            agentBySessionId,
+            turnDiffBySessionId,
+        });
+        return { row, value };
+    })
+        .filter((x) => compare(x.value, rule.op, Number(rule.threshold)));
+    return matched.map((m) => ({
+        ruleId: rule.id,
+        severity: rule.severity ?? 'warning',
+        scope: 'session',
+        metric: rule.metric,
+        op: rule.op,
+        threshold: Number(rule.threshold),
+        value: m.value,
+        context: {
+            sessionId: m.row.sessionId,
+            projectId: m.row.projectId,
+            runtime: m.row.runtime,
+        },
+    }));
+}
+function evaluateAgentRule(rule, sessions) {
+    const rows = summarizeAgents(sessions);
+    const matched = rows
+        .map((row) => {
+        const value = getMetricFromAgentRow(row, rule.metric);
+        return { row, value };
+    })
+        .filter((x) => compare(x.value, rule.op, Number(rule.threshold)));
+    return matched.map((m) => ({
+        ruleId: rule.id,
+        severity: rule.severity ?? 'warning',
+        scope: 'agent',
+        metric: rule.metric,
+        op: rule.op,
+        threshold: Number(rule.threshold),
+        value: m.value,
+        context: {
+            sessionId: m.row.sessionId,
+            projectId: m.row.projectId,
+            runtime: m.row.runtime,
+        },
+    }));
+}
+function evaluateMcpRule(rule, sessions) {
+    const rows = summarizeMcp(sessions);
+    const matched = rows.filter((row) => compare(row.calls ?? 0, rule.op, Number(rule.threshold)));
+    return matched.map((row) => ({
+        ruleId: rule.id,
+        severity: rule.severity ?? 'warning',
+        scope: 'mcp',
+        metric: 'calls',
+        op: rule.op,
+        threshold: Number(rule.threshold),
+        value: row.calls,
+        context: {
+            server: row.server,
+        },
+    }));
+}
+function evaluateCommandRule(rule, sessions) {
+    const rows = summarizeCommands(sessions);
+    const matched = rows.filter((row) => compare(row.calls ?? 0, rule.op, Number(rule.threshold)));
+    return matched.map((row) => ({
+        ruleId: rule.id,
+        severity: rule.severity ?? 'warning',
+        scope: 'command',
+        metric: 'calls',
+        op: rule.op,
+        threshold: Number(rule.threshold),
+        value: row.calls,
+        context: {
+            command: row.command,
+        },
+    }));
+}
+export async function loadAlertRules(path) {
+    const raw = await readFile(path, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.rules)) {
+        throw new Error('rule file must be JSON with {"rules": [...]}');
+    }
+    return parsed.rules;
+}
+export function evaluateRules(rules, sessions) {
+    const alerts = [];
+    for (const rule of rules) {
+        if (!rule.id || !rule.scope || !rule.metric || !rule.op) {
+            throw new Error(`invalid rule: ${JSON.stringify(rule)}`);
+        }
+        if (rule.scope === 'session') {
+            alerts.push(...evaluateSessionRule(rule, sessions));
+            continue;
+        }
+        if (rule.scope === 'agent') {
+            alerts.push(...evaluateAgentRule(rule, sessions));
+            continue;
+        }
+        if (rule.scope === 'mcp') {
+            alerts.push(...evaluateMcpRule(rule, sessions));
+            continue;
+        }
+        if (rule.scope === 'command') {
+            alerts.push(...evaluateCommandRule(rule, sessions));
+            continue;
+        }
+        throw new Error(`unsupported rule scope: ${rule.scope}`);
+    }
+    return alerts;
+}
+export async function sendAlertWebhook(url, payload, headers = {}) {
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            ...headers,
+        },
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        throw new Error(`webhook HTTP ${response.status}`);
+    }
+}

package/dist/env.d.ts

@@ -0,0 +1,2 @@
+export declare function parseSimpleDotEnv(raw: any): {};
+export declare function loadUserEnv(): Promise<void>;

package/dist/env.js

@@ -0,0 +1,54 @@
+// @ts-nocheck
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+function resolveUserHome() {
+    return process.env.HOME || process.env.USERPROFILE || '';
+}
+export function parseSimpleDotEnv(raw) {
+    const out = {};
+    for (const line of String(raw).split('\n')) {
+        let s = line.trim();
+        if (!s || s.startsWith('#'))
+            continue;
+        if (s.startsWith('export ')) {
+            s = s.slice('export '.length).trim();
+        }
+        const idx = s.indexOf('=');
+        if (idx <= 0)
+            continue;
+        const key = s.slice(0, idx).trim();
+        if (!key)
+            continue;
+        let value = s.slice(idx + 1).trim();
+        const quoted = (value.startsWith('"') && value.endsWith('"'))
+            || (value.startsWith("'") && value.endsWith("'"));
+        if (quoted) {
+            value = value.slice(1, -1);
+        }
+        else {
+            const commentIdx = value.indexOf(' #');
+            if (commentIdx >= 0) {
+                value = value.slice(0, commentIdx).trimEnd();
+            }
+        }
+        out[key] = value;
+    }
+    return out;
+}
+export async function loadUserEnv() {
+    const home = resolveUserHome();
+    if (!home)
+        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;
+        }
+    }
+    catch {
+        // ignore missing ~/.env
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};