pi-deadman 1.0.0

package/__tests__/logging.test.ts

@@ -0,0 +1,128 @@
+// __tests__/logging.test.ts
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { Logger } from "../extensions/logging";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+describe("Logger", () => {
+  let tmpDir: string;
+  let logger: Logger;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "deadman-log-test-"));
+    logger = new Logger(tmpDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  // --- system.jsonl ---
+  it("appends system poll to system.jsonl", () => {
+    logger.logSystem({ ts: Date.now(), zone: "GREEN", canary_ms: 8.0 });
+    const lines = fs.readFileSync(path.join(tmpDir, "system.jsonl"), "utf-8").trim().split("\n");
+    expect(lines).toHaveLength(1);
+    const entry = JSON.parse(lines[0]);
+    expect(entry.zone).toBe("GREEN");
+  });
+
+  it("appends multiple system entries", () => {
+    logger.logSystem({ ts: 1, zone: "GREEN" });
+    logger.logSystem({ ts: 2, zone: "YELLOW" });
+    logger.logSystem({ ts: 3, zone: "ORANGE" });
+    const lines = fs.readFileSync(path.join(tmpDir, "system.jsonl"), "utf-8").trim().split("\n");
+    expect(lines).toHaveLength(3);
+  });
+
+  // --- processes.jsonl ---
+  it("appends process snapshot to processes.jsonl", () => {
+    logger.logProcesses({ ts: Date.now(), processes: [{ pid: 1, name: "test", footprint_mb: 100 }] });
+    const lines = fs.readFileSync(path.join(tmpDir, "processes.jsonl"), "utf-8").trim().split("\n");
+    expect(lines).toHaveLength(1);
+  });
+
+  // --- tool_impact.jsonl ---
+  it("appends tool impact to tool_impact.jsonl", () => {
+    logger.logToolImpact({
+      ts: Date.now(),
+      command: "npm install",
+      tier: 3,
+      memory_before_mb: 500,
+      memory_after_mb: 700,
+      delta_mb: 200,
+      duration_ms: 30000,
+    });
+    const lines = fs.readFileSync(path.join(tmpDir, "tool_impact.jsonl"), "utf-8").trim().split("\n");
+    expect(lines).toHaveLength(1);
+    const entry = JSON.parse(lines[0]);
+    expect(entry.command).toBe("npm install");
+    expect(entry.delta_mb).toBe(200);
+  });
+
+  // --- decisions.jsonl ---
+  it("appends decision to decisions.jsonl", () => {
+    logger.logDecision({
+      ts: Date.now(),
+      command: "docker build .",
+      tier: 3,
+      zone: "ORANGE",
+      action: "block",
+      reason: "System in ORANGE, tier 3 command blocked",
+    });
+    const lines = fs.readFileSync(path.join(tmpDir, "decisions.jsonl"), "utf-8").trim().split("\n");
+    expect(lines).toHaveLength(1);
+    const entry = JSON.parse(lines[0]);
+    expect(entry.action).toBe("block");
+  });
+
+  it("logs pass decisions too", () => {
+    logger.logDecision({
+      ts: Date.now(),
+      command: "cat file.txt",
+      tier: 1,
+      zone: "GREEN",
+      action: "pass",
+    });
+    const lines = fs.readFileSync(path.join(tmpDir, "decisions.jsonl"), "utf-8").trim().split("\n");
+    const entry = JSON.parse(lines[0]);
+    expect(entry.action).toBe("pass");
+  });
+
+  // --- GC ---
+  it("gc removes entries older than retention days", () => {
+    const oldTs = Date.now() / 1000 - 86400 * 15; // 15 days ago
+    const newTs = Date.now() / 1000; // now
+    logger.logSystem({ ts: oldTs, zone: "GREEN" });
+    logger.logSystem({ ts: newTs, zone: "YELLOW" });
+    logger.gc(10); // 10-day retention
+    const lines = fs.readFileSync(path.join(tmpDir, "system.jsonl"), "utf-8").trim().split("\n");
+    expect(lines).toHaveLength(1);
+    expect(JSON.parse(lines[0]).zone).toBe("YELLOW");
+  });
+
+  it("gc runs across all 4 files", () => {
+    const oldTs = Date.now() / 1000 - 86400 * 15;
+    logger.logSystem({ ts: oldTs, zone: "OLD" });
+    logger.logProcesses({ ts: oldTs, processes: [] });
+    logger.logToolImpact({ ts: oldTs, command: "old" });
+    logger.logDecision({ ts: oldTs, command: "old", action: "pass" });
+    logger.gc(10);
+    for (const file of ["system.jsonl", "processes.jsonl", "tool_impact.jsonl", "decisions.jsonl"]) {
+      const content = fs.readFileSync(path.join(tmpDir, file), "utf-8").trim();
+      expect(content).toBe("");
+    }
+  });
+
+  // --- Resilience ---
+  it("handles corrupted lines during read", () => {
+    fs.writeFileSync(path.join(tmpDir, "system.jsonl"), '{"ts":1}\nnot json\n{"ts":2}\n');
+    expect(() => logger.gc(10)).not.toThrow();
+  });
+
+  it("creates log files on first write", () => {
+    expect(fs.existsSync(path.join(tmpDir, "system.jsonl"))).toBe(false);
+    logger.logSystem({ ts: 1 });
+    expect(fs.existsSync(path.join(tmpDir, "system.jsonl"))).toBe(true);
+  });
+});

package/__tests__/monitor.test.ts

@@ -0,0 +1,115 @@
+// __tests__/monitor.test.ts
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { Monitor } from "../extensions/monitor";
+import { Zone } from "../extensions/zones";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+describe("Monitor", () => {
+  let tmpDir: string;
+  let baselinePath: string;
+  let logDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "deadman-monitor-test-"));
+    baselinePath = path.join(tmpDir, "baseline.json");
+    logDir = path.join(tmpDir, "logs");
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("starts in GREEN with default zone", () => {
+    const monitor = new Monitor({ baselinePath, logDir });
+    expect(monitor.currentZone).toBe(Zone.GREEN);
+  });
+
+  it("reports not calibrated before calibration", () => {
+    const monitor = new Monitor({ baselinePath, logDir });
+    expect(monitor.isCalibrated).toBe(false);
+  });
+
+  it("loads persisted baseline on construction", () => {
+    fs.mkdirSync(path.dirname(baselinePath), { recursive: true });
+    fs.writeFileSync(baselinePath, JSON.stringify({
+      canary_ms: 7.5,
+      calibrated_at: "2026-02-28T10:00:00.000Z",
+      source: "calibrated",
+    }));
+    const monitor = new Monitor({ baselinePath, logDir });
+    expect(monitor.isCalibrated).toBe(true);
+    expect(monitor.baseline?.canary_ms).toBe(7.5);
+  });
+
+  it("getSnapshot returns current state", () => {
+    const monitor = new Monitor({ baselinePath, logDir });
+    const snap = monitor.getSnapshot();
+    expect(snap).toHaveProperty("zone");
+    expect(snap).toHaveProperty("trend");
+    expect(snap).toHaveProperty("confirmed");
+    expect(snap).toHaveProperty("isCalibrated");
+    expect(snap).toHaveProperty("baseline");
+  });
+
+  it("start and stop control the polling loop", async () => {
+    fs.mkdirSync(path.dirname(baselinePath), { recursive: true });
+    fs.writeFileSync(baselinePath, JSON.stringify({
+      canary_ms: 8.0,
+      calibrated_at: "2026-02-28T10:00:00.000Z",
+      source: "calibrated",
+    }));
+
+    const monitor = new Monitor({ baselinePath, logDir });
+    monitor.start();
+
+    // Wait for at least one poll
+    await new Promise(r => setTimeout(r, 1500));
+    expect(monitor.pollCount).toBeGreaterThanOrEqual(1);
+
+    monitor.stop();
+    const countAfterStop = monitor.pollCount;
+
+    // Wait and confirm no more polls
+    await new Promise(r => setTimeout(r, 1500));
+    expect(monitor.pollCount).toBe(countAfterStop);
+  });
+
+  it("creates log directory on start", () => {
+    const monitor = new Monitor({ baselinePath, logDir });
+    monitor.start();
+    expect(fs.existsSync(logDir)).toBe(true);
+    monitor.stop();
+  });
+
+  // --- New tests for watchdog integration ---
+
+  it("exposes worker for external use", () => {
+    const monitor = new Monitor({ baselinePath, logDir });
+    // Worker should be accessible (may not be started yet)
+    expect(monitor.getWorker()).toBeDefined();
+  });
+
+  it("has watchdog state with defaults", () => {
+    const monitor = new Monitor({ baselinePath, logDir });
+    const state = monitor.getWatchdogState();
+    expect(state).toHaveProperty("snapshotHistory");
+    expect(state).toHaveProperty("lastNonRedTimestamp");
+    expect(state).toHaveProperty("consecutiveNonRedPolls");
+    expect(state).toHaveProperty("lastKillTime");
+    expect(state).toHaveProperty("cooldownMs");
+    expect(state.lastKillTime).toBe(0);
+    expect(state.consecutiveNonRedPolls).toBe(0);
+  });
+
+  it("exposes onAutoKill callback setter", () => {
+    const monitor = new Monitor({ baselinePath, logDir });
+    const kills: any[] = [];
+    monitor.onAutoKill((decision) => {
+      kills.push(decision);
+    });
+    // Just verifying the API exists, no kill will fire in GREEN
+    expect(kills).toHaveLength(0);
+  });
+});

package/__tests__/processes.test.ts

@@ -0,0 +1,74 @@
+// __tests__/processes.test.ts
+import { describe, it, expect } from "vitest";
+import { getTopProcesses, formatProcessList, type ProcessInfo } from "../extensions/processes";
+
+describe("getTopProcesses", () => {
+  it("returns an array of ProcessInfo objects", async () => {
+    const procs = await getTopProcesses();
+    expect(Array.isArray(procs)).toBe(true);
+    expect(procs.length).toBeGreaterThan(0);
+  });
+
+  it("each process has pid, name, footprint_mb, rss_mb", async () => {
+    const procs = await getTopProcesses();
+    const first = procs[0];
+    expect(first).toHaveProperty("pid");
+    expect(first).toHaveProperty("name");
+    expect(first).toHaveProperty("footprint_mb");
+    expect(first).toHaveProperty("rss_mb");
+    expect(typeof first.pid).toBe("number");
+    expect(typeof first.name).toBe("string");
+    expect(typeof first.footprint_mb).toBe("number");
+    expect(typeof first.rss_mb).toBe("number");
+  });
+
+  it("is sorted by footprint_mb descending", async () => {
+    const procs = await getTopProcesses();
+    for (let i = 1; i < procs.length; i++) {
+      expect(procs[i - 1].footprint_mb).toBeGreaterThanOrEqual(procs[i].footprint_mb);
+    }
+  });
+
+  it("footprint_mb is larger than or equal to rss_mb for most processes", async () => {
+    const procs = await getTopProcesses();
+    expect(procs[0].footprint_mb).toBeGreaterThanOrEqual(procs[0].rss_mb);
+  });
+
+  it("completes in under 200ms", async () => {
+    const start = performance.now();
+    await getTopProcesses();
+    const elapsed = performance.now() - start;
+    expect(elapsed).toBeLessThan(200);
+  });
+
+  it("returns at most 20 processes", async () => {
+    const procs = await getTopProcesses();
+    expect(procs.length).toBeLessThanOrEqual(20);
+  });
+});
+
+describe("formatProcessList", () => {
+  const mockProcesses: ProcessInfo[] = [
+    { pid: 100, name: "firefox", footprint_mb: 800, rss_mb: 266 },
+    { pid: 200, name: "claude", footprint_mb: 400, rss_mb: 150 },
+    { pid: 300, name: "node", footprint_mb: 200, rss_mb: 80 },
+  ];
+
+  it("formats processes as selectable strings", () => {
+    const formatted = formatProcessList(mockProcesses, 3);
+    expect(formatted).toHaveLength(3);
+    expect(formatted[0]).toContain("firefox");
+    expect(formatted[0]).toContain("800");
+    expect(formatted[1]).toContain("claude");
+    expect(formatted[2]).toContain("node");
+  });
+
+  it("limits to requested count", () => {
+    const formatted = formatProcessList(mockProcesses, 2);
+    expect(formatted).toHaveLength(2);
+  });
+
+  it("handles empty array", () => {
+    expect(formatProcessList([], 5)).toEqual([]);
+  });
+});

package/__tests__/signals.test.ts

@@ -0,0 +1,59 @@
+// __tests__/signals.test.ts
+import { describe, it, expect } from "vitest";
+import { collectSignals, type SystemSignals } from "../extensions/signals";
+
+describe("collectSignals", () => {
+  it("returns a SystemSignals object with all fields", async () => {
+    const s = await collectSignals();
+    expect(s).toHaveProperty("swapout_rate");
+    expect(s).toHaveProperty("swapin_rate");
+    expect(s).toHaveProperty("decomp_rate");
+    expect(s).toHaveProperty("pressure_level");
+    expect(s).toHaveProperty("memorystatus_level");
+    expect(s).toHaveProperty("swap_used_mb");
+    expect(s).toHaveProperty("swap_free_mb");
+    expect(s).toHaveProperty("compression_ratio");
+  });
+
+  it("all numeric fields are non-negative", async () => {
+    const s = await collectSignals();
+    expect(s.swapout_rate).toBeGreaterThanOrEqual(0);
+    expect(s.swapin_rate).toBeGreaterThanOrEqual(0);
+    expect(s.decomp_rate).toBeGreaterThanOrEqual(0);
+    expect(s.pressure_level).toBeGreaterThanOrEqual(1);
+    expect(s.memorystatus_level).toBeGreaterThanOrEqual(0);
+    expect(s.swap_used_mb).toBeGreaterThanOrEqual(0);
+    expect(s.swap_free_mb).toBeGreaterThanOrEqual(0);
+    expect(s.compression_ratio).toBeGreaterThanOrEqual(1.0);
+  });
+
+  it("pressure_level is 1, 2, or 4", async () => {
+    const s = await collectSignals();
+    expect([1, 2, 4]).toContain(s.pressure_level);
+  });
+
+  it("memorystatus_level is between 0 and 100", async () => {
+    const s = await collectSignals();
+    expect(s.memorystatus_level).toBeGreaterThanOrEqual(0);
+    expect(s.memorystatus_level).toBeLessThanOrEqual(100);
+  });
+
+  it("swap_used_mb and swap_free_mb are reasonable (< 50GB)", async () => {
+    const s = await collectSignals();
+    expect(s.swap_used_mb).toBeLessThan(50000);
+    expect(s.swap_free_mb).toBeLessThan(50000);
+  });
+
+  it("compression_ratio is at least 1.0", async () => {
+    const s = await collectSignals();
+    expect(s.compression_ratio).toBeGreaterThanOrEqual(1.0);
+  });
+
+  it("consecutive calls compute delta-based rates", async () => {
+    const s1 = await collectSignals();
+    await new Promise(r => setTimeout(r, 100));
+    const s2 = await collectSignals();
+    expect(typeof s2.swapout_rate).toBe("number");
+    expect(typeof s2.decomp_rate).toBe("number");
+  });
+});