talon-agent 1.0.0

package/src/__tests__/terminal-renderer.test.ts

@@ -0,0 +1,278 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Mock picocolors to return raw strings (no ANSI)
+vi.mock("picocolors", () => ({
+  default: {
+    cyan: (s: string) => s,
+    green: (s: string) => s,
+    dim: (s: string) => s,
+    red: (s: string) => s,
+    bold: (s: string) => s,
+    yellow: (s: string) => s,
+    underline: (s: string) => s,
+  },
+}));
+
+import {
+  wrap,
+  formatTimeAgo,
+  extractToolDetail,
+  cleanToolName,
+  createRenderer,
+} from "../frontend/terminal/renderer.js";
+
+// ── wrap ─────────────────────────────────────────────────────────────────────
+
+describe("wrap", () => {
+  it("preserves short lines", () => {
+    expect(wrap("hello world", 2, 80)).toBe("  hello world");
+  });
+
+  it("wraps long lines", () => {
+    const text = "the quick brown fox jumps over the lazy dog";
+    const result = wrap(text, 2, 30);
+    // Every line should be ≤ 30 chars
+    for (const line of result.split("\n")) {
+      expect(line.length).toBeLessThanOrEqual(30);
+    }
+  });
+
+  it("preserves existing newlines", () => {
+    const result = wrap("line1\nline2", 2, 80);
+    expect(result).toBe("  line1\n  line2");
+  });
+
+  it("returns text as-is if width too narrow", () => {
+    expect(wrap("test", 70, 80)).toBe("test");
+  });
+});
+
+// ── formatTimeAgo ────────────────────────────────────────────────────────────
+
+describe("formatTimeAgo", () => {
+  it('returns "just now" for recent timestamps', () => {
+    expect(formatTimeAgo(Date.now())).toBe("just now");
+    expect(formatTimeAgo(Date.now() - 30_000)).toBe("just now");
+  });
+
+  it("returns minutes for < 1 hour", () => {
+    expect(formatTimeAgo(Date.now() - 5 * 60_000)).toBe("5m ago");
+    expect(formatTimeAgo(Date.now() - 59 * 60_000)).toBe("59m ago");
+  });
+
+  it("returns hours for < 1 day", () => {
+    expect(formatTimeAgo(Date.now() - 2 * 3_600_000)).toBe("2h ago");
+    expect(formatTimeAgo(Date.now() - 23 * 3_600_000)).toBe("23h ago");
+  });
+
+  it("returns days for >= 1 day", () => {
+    expect(formatTimeAgo(Date.now() - 86_400_000)).toBe("1d ago");
+    expect(formatTimeAgo(Date.now() - 7 * 86_400_000)).toBe("7d ago");
+  });
+});
+
+// ── extractToolDetail ────────────────────────────────────────────────────────
+
+describe("extractToolDetail", () => {
+  it("prefers description over command", () => {
+    const detail = extractToolDetail(
+      { command: "git status --long", description: "Show git status" },
+      80,
+    );
+    expect(detail).toBe("Show git status");
+  });
+
+  it("falls back to command when no description", () => {
+    const detail = extractToolDetail({ command: "ls -la" }, 80);
+    expect(detail).toBe("ls -la");
+  });
+
+  it("truncates long commands with ellipsis", () => {
+    const longCmd = "a".repeat(100);
+    const detail = extractToolDetail({ command: longCmd }, 50);
+    expect(detail.length).toBeLessThanOrEqual(50);
+    expect(detail).toMatch(/\.\.\.$/);
+  });
+
+  it("extracts file_path", () => {
+    expect(extractToolDetail({ file_path: "/src/index.ts" }, 80)).toBe(
+      "/src/index.ts",
+    );
+  });
+
+  it("extracts pattern + path", () => {
+    expect(extractToolDetail({ pattern: "*.ts", path: "/src" }, 80)).toBe(
+      "*.ts in /src",
+    );
+  });
+
+  it("extracts pattern alone", () => {
+    expect(extractToolDetail({ pattern: "*.ts" }, 80)).toBe("*.ts");
+  });
+
+  it("extracts action", () => {
+    expect(extractToolDetail({ action: "deploy" }, 80)).toBe("deploy");
+  });
+
+  it("extracts build_number with hash", () => {
+    expect(extractToolDetail({ build_number: 42 }, 80)).toBe("#42");
+  });
+
+  it("falls back to key=value pairs", () => {
+    expect(extractToolDetail({ foo: "bar", num: 5 }, 80)).toBe(
+      "foo=bar, num=5",
+    );
+  });
+
+  it("skips _chatId in fallback", () => {
+    expect(extractToolDetail({ _chatId: "1", foo: "bar" }, 80)).toBe("foo=bar");
+  });
+
+  it("returns empty string for empty input", () => {
+    expect(extractToolDetail({}, 80)).toBe("");
+  });
+});
+
+// ── cleanToolName ────────────────────────────────────────────────────────────
+
+describe("cleanToolName", () => {
+  it("strips MCP server prefix", () => {
+    expect(cleanToolName("mcp__npuw-tools__jenkins_list_builds")).toBe(
+      "jenkins_list_builds",
+    );
+  });
+
+  it("handles trailing double-underscore by returning original (empty last segment)", () => {
+    // When last segment is empty, || fallback returns original name
+    expect(cleanToolName("mcp__server__")).toBe("mcp__server__");
+  });
+
+  it("preserves non-MCP names", () => {
+    expect(cleanToolName("Bash")).toBe("Bash");
+    expect(cleanToolName("Read")).toBe("Read");
+  });
+
+  it("handles single-segment MCP name", () => {
+    expect(cleanToolName("mcp__tool")).toBe("tool");
+  });
+});
+
+// ── createRenderer (output capture) ──────────────────────────────────────────
+
+describe("createRenderer", () => {
+  let output: string[];
+  let originalWrite: typeof process.stdout.write;
+
+  beforeEach(() => {
+    output = [];
+    originalWrite = process.stdout.write;
+    process.stdout.write = vi.fn((chunk: unknown) => {
+      output.push(String(chunk));
+      return true;
+    }) as typeof process.stdout.write;
+  });
+
+  afterEach(() => {
+    process.stdout.write = originalWrite;
+  });
+
+  it("writeln outputs text with newline", () => {
+    const r = createRenderer(80);
+    r.writeln("hello");
+    expect(output.join("")).toContain("hello\n");
+  });
+
+  it("writeSystem wraps in dim", () => {
+    const r = createRenderer(80);
+    r.writeSystem("test message");
+    expect(output.join("")).toContain("test message");
+  });
+
+  it("writeError includes error marker", () => {
+    const r = createRenderer(80);
+    r.writeError("something failed");
+    const text = output.join("");
+    expect(text).toContain("something failed");
+  });
+
+  it("renderAssistantMessage includes Talon header", () => {
+    const r = createRenderer(80);
+    r.renderAssistantMessage("Hello world");
+    const text = output.join("");
+    expect(text).toContain("Talon");
+    expect(text).toContain("Hello world");
+  });
+
+  it("renderToolCall shows tool name and detail", () => {
+    const r = createRenderer(80);
+    r.renderToolCall("Bash", {
+      command: "git status",
+      description: "Show git status",
+    });
+    const text = output.join("");
+    expect(text).toContain("Bash");
+    expect(text).toContain("Show git status");
+  });
+
+  it("renderToolCall hides TodoRead/TodoWrite", () => {
+    const r = createRenderer(80);
+    r.renderToolCall("TodoRead", { _chatId: "1" });
+    r.renderToolCall("TodoWrite", { _chatId: "1" });
+    const text = output.join("");
+    expect(text).not.toContain("TodoRead");
+    expect(text).not.toContain("TodoWrite");
+  });
+
+  it("renderToolCall strips MCP prefix in display", () => {
+    const r = createRenderer(80);
+    r.renderToolCall("mcp__server__my_tool", { action: "test" });
+    const text = output.join("");
+    expect(text).toContain("my tool"); // underscores → spaces
+    expect(text).not.toContain("mcp__");
+  });
+
+  it("renderStatusLine shows duration, model, turns, tokens, cache, and tools", () => {
+    const r = createRenderer(80);
+    r.renderStatusLine(1500, 3, {
+      model: "Sonnet 4.6",
+      turns: 2,
+      inputTokens: 100,
+      outputTokens: 50,
+      cacheHitPct: 44,
+      costUsd: 0,
+    });
+    const text = output.join("");
+    expect(text).toContain("1.5s");
+    expect(text).toContain("Sonnet 4.6");
+    expect(text).toContain("2 turns");
+    expect(text).toContain("150 tok");
+    expect(text).toContain("44% cache");
+    expect(text).toContain("3 tools");
+  });
+
+  it("renderStatusLine pluralizes tool count correctly", () => {
+    const r = createRenderer(80);
+
+    output = [];
+    r.renderStatusLine(1000, 1, {
+      model: "Sonnet 4.6",
+      turns: 1,
+      inputTokens: 10,
+      outputTokens: 5,
+      cacheHitPct: 0,
+      costUsd: 0,
+    });
+    expect(output.join("")).toContain("1 tool");
+    expect(output.join("")).not.toContain("1 tools");
+    expect(output.join("")).toContain("1 turn");
+    expect(output.join("")).not.toContain("1 turns");
+  });
+
+  it("uses the provided column width", () => {
+    const r = createRenderer(40);
+    expect(r.cols).toBe(40);
+  });
+});
+
+// Need to import afterEach for cleanup
+import { afterEach } from "vitest";

package/src/__tests__/watchdog.test.ts

@@ -0,0 +1,287 @@
+import { describe, it, expect, vi, afterEach, beforeEach } from "vitest";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+// Mock the log module
+vi.mock("../util/log.js", () => ({
+  log: vi.fn(),
+  logError: vi.fn(),
+  logWarn: vi.fn(),
+}));
+
+const {
+  recordMessageProcessed,
+  getTotalMessagesProcessed,
+  recordError,
+  getRecentErrors,
+  getHealthStatus,
+  getUptimeMs,
+  startWatchdog,
+  stopWatchdog,
+} = await import("../util/watchdog.js");
+
+const WATCHDOG_TEST_DIR = join(tmpdir(), `talon-watchdog-test-${Date.now()}`);
+
+describe("watchdog", () => {
+  afterEach(() => {
+    stopWatchdog();
+  });
+
+  describe("recordMessageProcessed", () => {
+    it("increments counter", () => {
+      const before = getTotalMessagesProcessed();
+      recordMessageProcessed();
+      recordMessageProcessed();
+      recordMessageProcessed();
+      expect(getTotalMessagesProcessed()).toBe(before + 3);
+    });
+
+    it("updates lastProcessedAt timestamp", () => {
+      const beforeStatus = getHealthStatus();
+      const beforeMs = beforeStatus.msSinceLastMessage;
+      recordMessageProcessed();
+      const afterStatus = getHealthStatus();
+      // After recording, msSinceLastMessage should be very small (near 0)
+      expect(afterStatus.msSinceLastMessage).toBeLessThanOrEqual(50);
+    });
+  });
+
+  describe("recordError", () => {
+    it("stores error with timestamp", () => {
+      const beforeCount = getRecentErrors(100).length;
+      recordError("something went wrong");
+      const errors = getRecentErrors(100);
+      expect(errors.length).toBe(beforeCount + 1);
+
+      const lastError = errors[errors.length - 1];
+      expect(lastError.message).toBe("something went wrong");
+      expect(lastError.timestamp).toBeGreaterThan(0);
+      expect(lastError.timestamp).toBeLessThanOrEqual(Date.now());
+    });
+
+    it("stores multiple errors in order", () => {
+      const before = getRecentErrors(100).length;
+      recordError("first-error");
+      recordError("second-error");
+      recordError("third-error");
+      const errors = getRecentErrors(100);
+      const newErrors = errors.slice(before);
+      expect(newErrors[0].message).toBe("first-error");
+      expect(newErrors[1].message).toBe("second-error");
+      expect(newErrors[2].message).toBe("third-error");
+    });
+  });
+
+  describe("getRecentErrors", () => {
+    it("returns last N errors", () => {
+      // Record several errors
+      for (let i = 0; i < 5; i++) {
+        recordError(`error-batch-${i}`);
+      }
+      const last2 = getRecentErrors(2);
+      expect(last2).toHaveLength(2);
+      // Should be the most recent 2
+      expect(last2[1].message).toBe("error-batch-4");
+      expect(last2[0].message).toBe("error-batch-3");
+    });
+
+    it("defaults to 5 errors when no limit specified", () => {
+      // Fill with enough errors
+      for (let i = 0; i < 10; i++) {
+        recordError(`default-limit-${i}`);
+      }
+      const errors = getRecentErrors();
+      expect(errors).toHaveLength(5);
+    });
+
+    it("returns fewer than limit when not enough errors exist", () => {
+      // The array already has errors from prior tests, but requesting a huge limit
+      // should return at most what's available (capped at 20)
+      const all = getRecentErrors(200);
+      expect(all.length).toBeLessThanOrEqual(20);
+    });
+  });
+
+  describe("error cap", () => {
+    it("does not grow infinitely (capped at MAX_ERRORS)", () => {
+      // Push more than 20 errors (MAX_ERRORS = 20)
+      for (let i = 0; i < 30; i++) {
+        recordError(`overflow-error-${i}`);
+      }
+      const all = getRecentErrors(100);
+      expect(all.length).toBeLessThanOrEqual(20);
+    });
+
+    it("keeps the most recent errors after cap", () => {
+      // Push enough to guarantee we hit the cap
+      for (let i = 0; i < 25; i++) {
+        recordError(`cap-test-${i}`);
+      }
+      const all = getRecentErrors(100);
+      // The last error should be the most recent one
+      expect(all[all.length - 1].message).toBe("cap-test-24");
+    });
+  });
+
+  describe("getHealthStatus", () => {
+    it("returns correct structure", () => {
+      const status = getHealthStatus();
+      expect(status).toHaveProperty("healthy");
+      expect(status).toHaveProperty("uptimeMs");
+      expect(status).toHaveProperty("totalMessagesProcessed");
+      expect(status).toHaveProperty("lastProcessedAt");
+      expect(status).toHaveProperty("msSinceLastMessage");
+      expect(status).toHaveProperty("recentErrorCount");
+
+      expect(status.healthy).toBe(true);
+      expect(status.uptimeMs).toBeGreaterThanOrEqual(0);
+      expect(status.totalMessagesProcessed).toBeGreaterThanOrEqual(0);
+      expect(status.lastProcessedAt).toBeGreaterThan(0);
+      expect(status.msSinceLastMessage).toBeGreaterThanOrEqual(0);
+      expect(typeof status.recentErrorCount).toBe("number");
+    });
+
+    it("reflects message count from recordMessageProcessed", () => {
+      const before = getHealthStatus().totalMessagesProcessed;
+      recordMessageProcessed();
+      const after = getHealthStatus().totalMessagesProcessed;
+      expect(after).toBe(before + 1);
+    });
+
+    it("reflects error count from recordError", () => {
+      const before = getHealthStatus().recentErrorCount;
+      recordError("health-check-error");
+      const after = getHealthStatus().recentErrorCount;
+      // If already at cap (MAX_ERRORS=20), count stays at 20
+      if (before < 20) {
+        expect(after).toBe(before + 1);
+      } else {
+        expect(after).toBe(20);
+      }
+    });
+
+    it("reports healthy when no messages have been processed yet (fresh start scenario)", () => {
+      // When totalMessagesProcessed > 0 and recent, should be healthy
+      recordMessageProcessed();
+      const status = getHealthStatus();
+      expect(status.healthy).toBe(true);
+    });
+
+    it("uptimeMs increases over time", async () => {
+      const first = getUptimeMs();
+      await new Promise((r) => setTimeout(r, 5));
+      const second = getUptimeMs();
+      expect(second).toBeGreaterThanOrEqual(first);
+    });
+
+    it("msSinceLastMessage updates after recordMessageProcessed", () => {
+      recordMessageProcessed();
+      const status = getHealthStatus();
+      // Just processed a message, so msSinceLastMessage should be small
+      expect(status.msSinceLastMessage).toBeLessThan(1000);
+    });
+  });
+
+  describe("getUptimeMs", () => {
+    it("returns a positive number", () => {
+      expect(getUptimeMs()).toBeGreaterThanOrEqual(0);
+    });
+
+    it("returns a number (type check)", () => {
+      expect(typeof getUptimeMs()).toBe("number");
+    });
+  });
+
+  describe("startWatchdog / stopWatchdog", () => {
+    afterEach(() => {
+      stopWatchdog();
+      if (existsSync(WATCHDOG_TEST_DIR)) {
+        rmSync(WATCHDOG_TEST_DIR, { recursive: true });
+      }
+    });
+
+    it("startWatchdog does not throw", () => {
+      expect(() => startWatchdog()).not.toThrow();
+    });
+
+    it("stopWatchdog does not throw when not started", () => {
+      expect(() => stopWatchdog()).not.toThrow();
+    });
+
+    it("startWatchdog is idempotent (calling twice is safe)", () => {
+      startWatchdog();
+      expect(() => startWatchdog()).not.toThrow();
+      stopWatchdog();
+    });
+
+    it("stopWatchdog clears the timer", () => {
+      startWatchdog();
+      stopWatchdog();
+      // Calling stopWatchdog again should be a no-op
+      expect(() => stopWatchdog()).not.toThrow();
+    });
+
+    it("can restart after stopping", () => {
+      startWatchdog();
+      stopWatchdog();
+      expect(() => startWatchdog()).not.toThrow();
+      stopWatchdog();
+    });
+
+    it("accepts a workspace directory argument", () => {
+      mkdirSync(WATCHDOG_TEST_DIR, { recursive: true });
+      expect(() => startWatchdog(WATCHDOG_TEST_DIR)).not.toThrow();
+      stopWatchdog();
+    });
+
+    it("watchdog interval callback checks workspace existence", () => {
+      // Use fake timers to trigger the interval
+      vi.useFakeTimers();
+      try {
+        mkdirSync(WATCHDOG_TEST_DIR, { recursive: true });
+        startWatchdog(WATCHDOG_TEST_DIR);
+
+        // Remove the workspace dir to trigger the recreate path
+        rmSync(WATCHDOG_TEST_DIR, { recursive: true });
+        expect(existsSync(WATCHDOG_TEST_DIR)).toBe(false);
+
+        // Advance timer to trigger interval callback (60 seconds)
+        vi.advanceTimersByTime(60_000);
+
+        // Watchdog should have recreated the directory
+        expect(existsSync(WATCHDOG_TEST_DIR)).toBe(true);
+
+        stopWatchdog();
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
+    it("watchdog interval logs warning on inactivity", async () => {
+      const logModule = await import("../util/log.js");
+      const { logWarn } = vi.mocked(logModule);
+      vi.useFakeTimers();
+      try {
+        // Record a message first so totalMessagesProcessed > 0
+        recordMessageProcessed();
+
+        startWatchdog();
+
+        // Advance past the inactivity threshold (10 minutes = 600_000ms)
+        // Need to advance enough for both: setting lastProcessedAt to be old + triggering the interval
+        vi.advanceTimersByTime(11 * 60_000);
+
+        // logWarn should have been called with an inactivity message
+        expect(logWarn).toHaveBeenCalledWith(
+          "watchdog",
+          expect.stringContaining("No messages processed"),
+        );
+
+        stopWatchdog();
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+  });
+});