alvin-bot 4.26.0 → 5.1.0

package/dist/services/trends.js

@@ -0,0 +1,309 @@
+/**
+ * Predictive Maintenance via Trends (Self-Preservation Phase 2, 3J).
+ *
+ * Mechanism:
+ *   1. Once every 24 h: snapshot lightweight health metrics and append
+ *      one JSON line to ~/.alvin-bot/state/trends.jsonl
+ *   2. After the file has ≥ 7 days of data: also run a daily AI
+ *      "anomaly detection" pass over the last 30 days of snapshots
+ *   3. If the AI flags a concerning trend → DM operator via 1D
+ *
+ * Why daily and not continuous: trends are about slow degradation
+ * (memory growth, error-rate increase, crash-frequency drift). A
+ * 24-hour sampling cadence is right for these timescales and keeps
+ * the storage + AI-call cost near zero.
+ *
+ * Storage format — JSONL, one line per day:
+ *
+ *   {"ts": "2026-05-13T04:00:00Z", "uptime_s": 86400, "rss_mb": 105,
+ *    "crashes_24h": 0, "diag_24h": 0, "errors_24h": 3,
+ *    "provider": "claude-sdk", "version": "5.0.0"}
+ *
+ * The JSONL design is deliberate: easy to inspect with tail/head/awk,
+ * easy to truncate to last N days, no parsing pitfalls. The AI gets
+ * the whole tail as plain text — works with small-context models.
+ *
+ * Provider-agnostic — same engine.query() pipeline as 3I.
+ *
+ * Opt-out:
+ *   ALVIN_DISABLE_TRENDS=true              → skip 3J entirely
+ *   ALVIN_DISABLE_SELF_PRESERVATION=true   → skip all Phase-1/2
+ *
+ * Tunable for testing:
+ *   ALVIN_TRENDS_INTERVAL_HOURS=24         → snapshot cadence
+ *   ALVIN_TRENDS_AI_AFTER_DAYS=7           → days of data before AI analysis kicks in
+ */
+import { appendFileSync, existsSync, readFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { BOT_VERSION } from "../version.js";
+import { emitCritical } from "./critical-notify.js";
+const TRENDS_PATH = join(homedir(), ".alvin-bot", "state", "trends.jsonl");
+const DEFAULT_INTERVAL_HOURS = 24;
+const DEFAULT_AI_THRESHOLD_DAYS = 7;
+const MAX_RETAIN_DAYS = 90;
+let trendsTimer = null;
+function isDisabled() {
+    return (process.env.ALVIN_DISABLE_TRENDS === "true" ||
+        process.env.ALVIN_DISABLE_SELF_PRESERVATION === "true");
+}
+function countLogLinesLast24h(filename, pattern) {
+    const path = join(homedir(), ".alvin-bot", "logs", filename);
+    if (!existsSync(path))
+        return 0;
+    try {
+        const content = readFileSync(path, "utf-8");
+        const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+        let count = 0;
+        for (const line of content.split("\n")) {
+            const tsMatch = line.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+Z)/);
+            if (!tsMatch)
+                continue;
+            const lineTs = new Date(tsMatch[1]).getTime();
+            if (Number.isFinite(lineTs) && lineTs >= cutoff) {
+                if (!pattern || pattern.test(line))
+                    count++;
+            }
+        }
+        return count;
+    }
+    catch {
+        return 0;
+    }
+}
+function readWatchdogCrashes24h() {
+    try {
+        const path = join(homedir(), ".alvin-bot", "state", "watchdog.json");
+        if (!existsSync(path))
+            return 0;
+        const data = JSON.parse(readFileSync(path, "utf-8"));
+        return data.dailyCrashCount ?? 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function countDiagnosticBundlesLast24h() {
+    try {
+        const dir = join(homedir(), ".alvin-bot", "diagnostics");
+        if (!existsSync(dir))
+            return 0;
+        const { readdirSync, statSync } = require("fs");
+        const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+        return readdirSync(dir)
+            .filter((f) => f.endsWith(".md") && !f.endsWith(".analysis.md"))
+            .filter((f) => {
+            try {
+                return statSync(join(dir, f)).mtimeMs >= cutoff;
+            }
+            catch {
+                return false;
+            }
+        }).length;
+    }
+    catch {
+        return 0;
+    }
+}
+function takeSnapshot(activeProvider) {
+    const mem = process.memoryUsage();
+    return {
+        ts: new Date().toISOString(),
+        uptime_s: Math.round(process.uptime()),
+        rss_mb: Math.round(mem.rss / 1024 / 1024),
+        heap_mb: Math.round(mem.heapUsed / 1024 / 1024),
+        crashes_24h: readWatchdogCrashes24h(),
+        diag_24h: countDiagnosticBundlesLast24h(),
+        errors_24h: countLogLinesLast24h("alvin-bot.err.log"),
+        provider: activeProvider,
+        version: BOT_VERSION,
+    };
+}
+function appendSnapshot(snap) {
+    try {
+        mkdirSync(dirname(TRENDS_PATH), { recursive: true });
+        appendFileSync(TRENDS_PATH, JSON.stringify(snap) + "\n");
+    }
+    catch {
+        // Disk full / permissions — non-fatal
+    }
+}
+function readSnapshots(lastN = 30) {
+    if (!existsSync(TRENDS_PATH))
+        return [];
+    try {
+        const content = readFileSync(TRENDS_PATH, "utf-8");
+        const lines = content.split("\n").filter((l) => l.trim());
+        const recent = lines.slice(-lastN);
+        return recent
+            .map((l) => {
+            try {
+                return JSON.parse(l);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((s) => s !== null);
+    }
+    catch {
+        return [];
+    }
+}
+const TREND_PROMPT_TEMPLATE = `You are an SRE monitoring an Alvin Bot instance over the last days.
+Below is one JSON line per day with the bot's daily health metrics.
+
+Detect any CONCERNING trend that suggests slow degradation — like:
+  - Memory (rss_mb / heap_mb) growing day over day
+  - Error rate (errors_24h) climbing
+  - Crashes (crashes_24h) above 0 for multiple days
+  - Diagnostic bundles (diag_24h) > 0 repeatedly
+
+If there is NO concerning trend, respond with EXACTLY this one line:
+ANOMALY: NONE
+
+If there IS a concerning trend, respond in this 3-line format — nothing else:
+
+ANOMALY: <one short sentence — what trend you noticed>
+SEVERITY: <warn | critical>
+SUGGESTION: <one shell command OR observation for the operator>
+
+--- LAST {N} DAYS OF SNAPSHOTS ---
+{SNAPSHOTS}
+--- END ---`;
+function parseTrendResponse(text) {
+    if (/^ANOMALY:\s*NONE/im.test(text)) {
+        return {
+            anomalyDetected: false,
+            description: "no concerning trend detected",
+            severity: "none",
+            suggestion: "",
+            raw: text,
+        };
+    }
+    const get = (key) => {
+        const m = text.match(new RegExp(`^${key}:\\s*(.+?)$`, "m"));
+        return m ? m[1].trim() : "";
+    };
+    const sevRaw = get("SEVERITY").toLowerCase();
+    const sev = sevRaw === "critical" ? "critical" : "warn";
+    return {
+        anomalyDetected: true,
+        description: get("ANOMALY") || "(no description)",
+        severity: sev,
+        suggestion: get("SUGGESTION") || "(no suggestion)",
+        raw: text,
+    };
+}
+export async function analyzeTrends(registry) {
+    if (isDisabled())
+        return null;
+    if (!registry)
+        return null;
+    const snaps = readSnapshots(30);
+    const threshold = parseInt(process.env.ALVIN_TRENDS_AI_AFTER_DAYS || "", 10) || DEFAULT_AI_THRESHOLD_DAYS;
+    if (snaps.length < threshold)
+        return null;
+    let provider;
+    try {
+        provider = registry.getActive();
+    }
+    catch {
+        return null;
+    }
+    if (!provider)
+        return null;
+    const snapsBlock = snaps.map((s) => JSON.stringify(s)).join("\n");
+    const prompt = TREND_PROMPT_TEMPLATE.replace("{N}", String(snaps.length)).replace("{SNAPSHOTS}", snapsBlock);
+    const abortController = new AbortController();
+    const timer = setTimeout(() => abortController.abort(), 60_000);
+    let fullText = "";
+    try {
+        for await (const chunk of provider.query({
+            prompt,
+            systemPrompt: "You are a precise SRE assistant. Reply ONLY in the requested format.",
+            abortSignal: abortController.signal,
+        })) {
+            if (chunk.type === "text") {
+                if (chunk.delta)
+                    fullText += chunk.delta;
+                else if (chunk.text)
+                    fullText = chunk.text;
+            }
+            else if (chunk.type === "error") {
+                clearTimeout(timer);
+                return null;
+            }
+            else if (chunk.type === "done") {
+                if (chunk.text)
+                    fullText = chunk.text;
+                break;
+            }
+        }
+    }
+    catch {
+        clearTimeout(timer);
+        return null;
+    }
+    clearTimeout(timer);
+    if (!fullText.trim())
+        return null;
+    return parseTrendResponse(fullText);
+}
+async function dailyTask(registry) {
+    try {
+        // Snapshot first — always, regardless of AI being available
+        const activeProviderKey = (() => {
+            try {
+                return registry?.getActiveKey() || "none";
+            }
+            catch {
+                return "none";
+            }
+        })();
+        const snap = takeSnapshot(activeProviderKey);
+        appendSnapshot(snap);
+        console.log(`📊 Trends snapshot taken: rss=${snap.rss_mb}MB errors=${snap.errors_24h} crashes=${snap.crashes_24h}`);
+        // Then attempt AI analysis if we have enough history
+        const result = await analyzeTrends(registry);
+        if (!result)
+            return;
+        if (!result.anomalyDetected) {
+            console.log(`📊 Trends AI: no anomaly detected`);
+            return;
+        }
+        console.log(`📊 Trends AI: ANOMALY (${result.severity}) — ${result.description}`);
+        emitCritical({
+            category: "custom",
+            severity: result.severity === "critical" ? "critical" : "warn",
+            title: `Trend anomaly detected: ${result.description}`,
+            detail: `30-day trend analysis flagged a concerning pattern.\n\n` +
+                `Suggestion: ${result.suggestion}\n\n` +
+                `Trend data: ${TRENDS_PATH}`,
+            suggestedAction: result.suggestion,
+        });
+    }
+    catch (err) {
+        console.warn(`📊 Trends daily task threw: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+export function startTrendsCollector(registry) {
+    if (isDisabled())
+        return;
+    const intervalH = parseInt(process.env.ALVIN_TRENDS_INTERVAL_HOURS || "", 10) || DEFAULT_INTERVAL_HOURS;
+    const intervalMs = intervalH * 60 * 60 * 1000;
+    // Initial: take a first snapshot after 60 s to avoid measuring the
+    // startup transient. Subsequent snapshots every intervalMs.
+    setTimeout(() => {
+        void dailyTask(registry);
+        trendsTimer = setInterval(() => void dailyTask(registry), intervalMs);
+        if (trendsTimer.unref)
+            trendsTimer.unref();
+    }, 60_000);
+}
+export function stopTrendsCollector() {
+    if (trendsTimer) {
+        clearInterval(trendsTimer);
+        trendsTimer = null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alvin-bot",
-  "version": "4.26.0",
+  "version": "5.1.0",
   "description": "Alvin Bot — Your personal AI agent on Telegram, WhatsApp, Discord, Signal, and Web.",
   "type": "module",
   "main": "dist/index.js",
@@ -16,6 +16,8 @@
     "test:watch": "vitest",
     "test:ui": "vitest --ui",
     "privacy-check": "bash scripts/privacy-check.sh",
+    "audit": "npm audit --audit-level=high",
+    "audit:full": "npm audit",
     "prepublishOnly": "bash scripts/privacy-check.sh",
     "electron:compile": "tsc -p electron/tsconfig.json",
     "electron:dev": "npm run electron:compile && electron .",