talon-agent 1.0.0 → 1.2.0

package/src/__tests__/history-persistence.test.ts

@@ -23,12 +23,8 @@ vi.mock("write-file-atomic", () => ({
   default: { sync: (...args: unknown[]) => writeFileSyncMock(...args) },
 }));
 
-const {
-  loadHistory,
-  flushHistory,
-  pushMessage,
-  getRecentHistory,
-} = await import("../storage/history.js");
+const { loadHistory, flushHistory, pushMessage, getRecentHistory } =
+  await import("../storage/history.js");
 
 describe("history persistence", () => {
   beforeEach(() => {
@@ -37,10 +33,31 @@ describe("history persistence", () => {
 
   describe("loadHistory", () => {
     it("loads history from a JSON file when it exists", () => {
-      const data: Record<string, Array<{ msgId: number; senderId: number; senderName: string; text: string; timestamp: number }>> = {
+      const data: Record<
+        string,
+        Array<{
+          msgId: number;
+          senderId: number;
+          senderName: string;
+          text: string;
+          timestamp: number;
+        }>
+      > = {
         "chat-1": [
-          { msgId: 1, senderId: 100, senderName: "Alice", text: "hello", timestamp: 1000 },
-          { msgId: 2, senderId: 200, senderName: "Bob", text: "hi", timestamp: 2000 },
+          {
+            msgId: 1,
+            senderId: 100,
+            senderName: "Alice",
+            text: "hello",
+            timestamp: 1000,
+          },
+          {
+            msgId: 2,
+            senderId: 200,
+            senderName: "Bob",
+            text: "hi",
+            timestamp: 2000,
+          },
         ],
       };
       existsSyncMock.mockReturnValue(true);
@@ -89,9 +106,15 @@ describe("history persistence", () => {
 
     it("loads multiple chats", () => {
       const data = {
-        "chat-a": [{ msgId: 1, senderId: 1, senderName: "A", text: "a", timestamp: 1 }],
-        "chat-b": [{ msgId: 2, senderId: 2, senderName: "B", text: "b", timestamp: 2 }],
-        "chat-c": [{ msgId: 3, senderId: 3, senderName: "C", text: "c", timestamp: 3 }],
+        "chat-a": [
+          { msgId: 1, senderId: 1, senderName: "A", text: "a", timestamp: 1 },
+        ],
+        "chat-b": [
+          { msgId: 2, senderId: 2, senderName: "B", text: "b", timestamp: 2 },
+        ],
+        "chat-c": [
+          { msgId: 3, senderId: 3, senderName: "C", text: "c", timestamp: 3 },
+        ],
       };
       existsSyncMock.mockReturnValue(true);
       readFileSyncMock.mockReturnValue(JSON.stringify(data));
@@ -122,7 +145,8 @@ describe("history persistence", () => {
 
       expect(writeFileSyncMock).toHaveBeenCalled();
       // Last write call is the actual data (earlier calls may be .bak backups)
-      const lastCall = writeFileSyncMock.mock.calls[writeFileSyncMock.mock.calls.length - 1];
+      const lastCall =
+        writeFileSyncMock.mock.calls[writeFileSyncMock.mock.calls.length - 1];
       const writtenData = lastCall[1] as string;
       const parsed = JSON.parse(writtenData.trim());
       expect(parsed[id]).toBeDefined();
@@ -144,13 +168,12 @@ describe("history persistence", () => {
 
       flushHistory();
 
-      expect(mkdirSyncMock).toHaveBeenCalledWith(
-        expect.any(String),
-        { recursive: true },
-      );
+      expect(mkdirSyncMock).toHaveBeenCalledWith(expect.any(String), {
+        recursive: true,
+      });
     });
 
-    it("handles write errors gracefully", () => {
+    it("handles write errors gracefully (line 96 TRUE branch: Error thrown on data write)", () => {
       const id = `flush-err-${Date.now()}`;
       pushMessage(id, {
         msgId: 1,
@@ -160,7 +183,8 @@ describe("history persistence", () => {
         timestamp: Date.now(),
       });
 
-      existsSyncMock.mockReturnValue(true);
+      // existsSync=false skips the .bak write so the Error is thrown on the actual data write
+      existsSyncMock.mockReturnValue(false);
       writeFileSyncMock.mockImplementationOnce(() => {
         throw new Error("disk full");
       });
@@ -170,3 +194,34 @@ describe("history persistence", () => {
     });
   });
 });
+
+describe("history — non-Error throw coverage", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("saveHistory covers String(err) when writeFileAtomic throws a non-Error", async () => {
+    const { logError } = await import("../util/log.js");
+    vi.mocked(logError).mockClear();
+
+    const id = `flush-non-error-${Date.now()}`;
+    pushMessage(id, {
+      msgId: 1,
+      senderId: 1,
+      senderName: "TestUser",
+      text: "test non-error throw",
+      timestamp: Date.now(),
+    });
+
+    existsSyncMock.mockReturnValue(false); // no backup attempt
+    // Throw a plain string (non-Error) to cover `err instanceof Error ? ... : err`
+    writeFileSyncMock.mockImplementation(() => {
+      throw "disk quota string";
+    }); // eslint-disable-line @typescript-eslint/no-throw-literal
+
+    expect(() => flushHistory()).not.toThrow();
+    expect(vi.mocked(logError)).toHaveBeenCalled();
+
+    writeFileSyncMock.mockReset();
+  });
+});

package/src/__tests__/history.test.ts

@@ -64,15 +64,18 @@ describe("history", () => {
 
     it("preserves all optional fields on the message", () => {
       const id = chatId();
-      pushMessage(id, makeMsg({
-        msgId: 1,
-        senderName: "Alice",
-        text: "photo msg",
-        replyToMsgId: 99,
-        mediaType: "photo",
-        stickerFileId: "stk123",
-        filePath: "/tmp/photo.jpg",
-      }));
+      pushMessage(
+        id,
+        makeMsg({
+          msgId: 1,
+          senderName: "Alice",
+          text: "photo msg",
+          replyToMsgId: 99,
+          mediaType: "photo",
+          stickerFileId: "stk123",
+          filePath: "/tmp/photo.jpg",
+        }),
+      );
       const history = getRecentHistory(id);
       expect(history[0].replyToMsgId).toBe(99);
       expect(history[0].mediaType).toBe("photo");
@@ -119,7 +122,9 @@ describe("history", () => {
 
     it("is a no-op for nonexistent chat", () => {
       // Should not throw
-      expect(() => setMessageFilePath("no-such-chat", 1, "/tmp/x.jpg")).not.toThrow();
+      expect(() =>
+        setMessageFilePath("no-such-chat", 1, "/tmp/x.jpg"),
+      ).not.toThrow();
     });
 
     it("is a no-op for nonexistent message", () => {
@@ -218,7 +223,10 @@ describe("history", () => {
     it("respects the limit parameter", () => {
       const id = chatId();
       for (let i = 0; i < 10; i++) {
-        pushMessage(id, makeMsg({ msgId: i, senderName: "Alice", text: `msg ${i}` }));
+        pushMessage(
+          id,
+          makeMsg({ msgId: i, senderName: "Alice", text: `msg ${i}` }),
+        );
       }
       const result = getMessagesByUser(id, "Alice", 3);
       const lines = result.split("\n");
@@ -306,66 +314,84 @@ describe("history", () => {
 
     it("shows time ago for users seen minutes ago", () => {
       const id = chatId();
-      pushMessage(id, makeMsg({
-        msgId: 1,
-        senderId: 100,
-        senderName: "Alice",
-        timestamp: Date.now() - 5 * 60_000, // 5 minutes ago
-      }));
+      pushMessage(
+        id,
+        makeMsg({
+          msgId: 1,
+          senderId: 100,
+          senderName: "Alice",
+          timestamp: Date.now() - 5 * 60_000, // 5 minutes ago
+        }),
+      );
       const result = getKnownUsers(id);
       expect(result).toContain("5m ago");
     });
 
     it("shows time ago for users seen hours ago", () => {
       const id = chatId();
-      pushMessage(id, makeMsg({
-        msgId: 1,
-        senderId: 100,
-        senderName: "Alice",
-        timestamp: Date.now() - 3 * 3_600_000, // 3 hours ago
-      }));
+      pushMessage(
+        id,
+        makeMsg({
+          msgId: 1,
+          senderId: 100,
+          senderName: "Alice",
+          timestamp: Date.now() - 3 * 3_600_000, // 3 hours ago
+        }),
+      );
       const result = getKnownUsers(id);
       expect(result).toContain("3h ago");
     });
 
     it("shows time ago for users seen days ago", () => {
       const id = chatId();
-      pushMessage(id, makeMsg({
-        msgId: 1,
-        senderId: 100,
-        senderName: "Alice",
-        timestamp: Date.now() - 2 * 86_400_000, // 2 days ago
-      }));
+      pushMessage(
+        id,
+        makeMsg({
+          msgId: 1,
+          senderId: 100,
+          senderName: "Alice",
+          timestamp: Date.now() - 2 * 86_400_000, // 2 days ago
+        }),
+      );
       const result = getKnownUsers(id);
       expect(result).toContain("2d ago");
     });
 
     it("shows 'just now' for users seen less than a minute ago", () => {
       const id = chatId();
-      pushMessage(id, makeMsg({
-        msgId: 1,
-        senderId: 100,
-        senderName: "Alice",
-        timestamp: Date.now() - 10_000, // 10 seconds ago
-      }));
+      pushMessage(
+        id,
+        makeMsg({
+          msgId: 1,
+          senderId: 100,
+          senderName: "Alice",
+          timestamp: Date.now() - 10_000, // 10 seconds ago
+        }),
+      );
       const result = getKnownUsers(id);
       expect(result).toContain("just now");
     });
 
     it("sorts users by last seen (most recent first)", () => {
       const id = chatId();
-      pushMessage(id, makeMsg({
-        msgId: 1,
-        senderId: 100,
-        senderName: "OldUser",
-        timestamp: Date.now() - 86_400_000,
-      }));
-      pushMessage(id, makeMsg({
-        msgId: 2,
-        senderId: 200,
-        senderName: "NewUser",
-        timestamp: Date.now() - 60_000,
-      }));
+      pushMessage(
+        id,
+        makeMsg({
+          msgId: 1,
+          senderId: 100,
+          senderName: "OldUser",
+          timestamp: Date.now() - 86_400_000,
+        }),
+      );
+      pushMessage(
+        id,
+        makeMsg({
+          msgId: 2,
+          senderId: 200,
+          senderName: "NewUser",
+          timestamp: Date.now() - 60_000,
+        }),
+      );
       const result = getKnownUsers(id);
       const newIdx = result.indexOf("NewUser");
       const oldIdx = result.indexOf("OldUser");
@@ -374,18 +400,24 @@ describe("history", () => {
 
     it("updates user name to the latest seen name", () => {
       const id = chatId();
-      pushMessage(id, makeMsg({
-        msgId: 1,
-        senderId: 100,
-        senderName: "OldName",
-        timestamp: Date.now() - 60_000,
-      }));
-      pushMessage(id, makeMsg({
-        msgId: 2,
-        senderId: 100,
-        senderName: "NewName",
-        timestamp: Date.now(),
-      }));
+      pushMessage(
+        id,
+        makeMsg({
+          msgId: 1,
+          senderId: 100,
+          senderName: "OldName",
+          timestamp: Date.now() - 60_000,
+        }),
+      );
+      pushMessage(
+        id,
+        makeMsg({
+          msgId: 2,
+          senderId: 100,
+          senderName: "NewName",
+          timestamp: Date.now(),
+        }),
+      );
       const result = getKnownUsers(id);
       expect(result).toContain("NewName");
       expect(result).not.toContain("OldName");
@@ -399,18 +431,12 @@ describe("history", () => {
         id,
         makeMsg({ msgId: 1, senderId: 100, senderName: "Alice" }),
       );
-      pushMessage(
-        id,
-        makeMsg({ msgId: 2, senderId: 200, senderName: "Bob" }),
-      );
+      pushMessage(id, makeMsg({ msgId: 2, senderId: 200, senderName: "Bob" }));
       pushMessage(
         id,
         makeMsg({ msgId: 3, senderId: 100, senderName: "Alice" }),
       );
-      pushMessage(
-        id,
-        makeMsg({ msgId: 4, senderId: 200, senderName: "Bob" }),
-      );
+      pushMessage(id, makeMsg({ msgId: 4, senderId: 200, senderName: "Bob" }));
 
       const result = getRecentBySenderId(id, 100);
       expect(result).toHaveLength(2);
@@ -556,8 +582,14 @@ describe("history", () => {
 
     it("formats multiple messages joined by newlines", () => {
       const id = chatId();
-      pushMessage(id, makeMsg({ msgId: 1, text: "first", timestamp: 1000000000000 }));
-      pushMessage(id, makeMsg({ msgId: 2, text: "second", timestamp: 1000000060000 }));
+      pushMessage(
+        id,
+        makeMsg({ msgId: 1, text: "first", timestamp: 1000000000000 }),
+      );
+      pushMessage(
+        id,
+        makeMsg({ msgId: 2, text: "second", timestamp: 1000000060000 }),
+      );
       const result = getRecentFormatted(id, 5);
       const lines = result.split("\n");
       expect(lines).toHaveLength(2);
@@ -567,9 +599,17 @@ describe("history", () => {
 
     it("includes all media type variants in tags", () => {
       const id = chatId();
-      const types: Array<HistoryMessage["mediaType"]> = ["document", "voice", "video", "animation"];
+      const types: Array<HistoryMessage["mediaType"]> = [
+        "document",
+        "voice",
+        "video",
+        "animation",
+      ];
       types.forEach((type, i) => {
-        pushMessage(id, makeMsg({ msgId: i + 1, text: `media ${type}`, mediaType: type }));
+        pushMessage(
+          id,
+          makeMsg({ msgId: i + 1, text: `media ${type}`, mediaType: type }),
+        );
       });
       const result = getRecentFormatted(id, 10);
       expect(result).toContain("[document]");
@@ -612,14 +652,8 @@ describe("history", () => {
       const id = chatId();
       const ts1 = Date.now() - 10000;
       const ts2 = Date.now() - 5000;
-      pushMessage(
-        id,
-        makeMsg({ msgId: 1, senderId: 100, timestamp: ts1 }),
-      );
-      pushMessage(
-        id,
-        makeMsg({ msgId: 2, senderId: 200, timestamp: ts2 }),
-      );
+      pushMessage(id, makeMsg({ msgId: 1, senderId: 100, timestamp: ts1 }));
+      pushMessage(id, makeMsg({ msgId: 2, senderId: 200, timestamp: ts2 }));
 
       const stats = getHistoryStats(id);
       expect(stats.totalMessages).toBe(2);

package/src/__tests__/integration.test.ts

@@ -8,7 +8,9 @@ import { initDispatcher, execute } from "../core/dispatcher.js";
 import type { QueryBackend, ContextManager } from "../core/types.js";
 import { TalonError } from "../core/errors.js";
 
-function setup(overrides: { queryResult?: Record<string, unknown>; queryError?: Error } = {}) {
+function setup(
+  overrides: { queryResult?: Record<string, unknown>; queryError?: Error } = {},
+) {
   const acquired: number[] = [];
   const released: number[] = [];
   const typingCalls: number[] = [];
@@ -38,16 +40,28 @@ function setup(overrides: { queryResult?: Record<string, unknown>; queryError?:
   initDispatcher({
     backend,
     context,
-    sendTyping: vi.fn(async (id: number) => { typingCalls.push(id); }),
-    onActivity: vi.fn(() => { activityCount++; }),
+    sendTyping: vi.fn(async (id: number) => {
+      typingCalls.push(id);
+    }),
+    onActivity: vi.fn(() => {
+      activityCount++;
+    }),
   });
 
-  return { backend, context, acquired, released, typingCalls, getActivityCount: () => activityCount };
+  return {
+    backend,
+    context,
+    acquired,
+    released,
+    typingCalls,
+    getActivityCount: () => activityCount,
+  };
 }
 
 describe("integration: dispatcher lifecycle", () => {
   it("full happy path: acquire → type → query → activity → release", async () => {
-    const { backend, acquired, released, typingCalls, getActivityCount } = setup();
+    const { backend, acquired, released, typingCalls, getActivityCount } =
+      setup();
 
     const result = await execute({
       chatId: "123",
@@ -136,7 +150,14 @@ describe("integration: dispatcher lifecycle", () => {
         order.push(`start:${params.chatId}`);
         await new Promise((r) => setTimeout(r, 20));
         order.push(`end:${params.chatId}`);
-        return { text: "", durationMs: 20, inputTokens: 0, outputTokens: 0, cacheRead: 0, cacheWrite: 0 };
+        return {
+          text: "",
+          durationMs: 20,
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheRead: 0,
+          cacheWrite: 0,
+        };
       }),
     };
 
@@ -153,8 +174,22 @@ describe("integration: dispatcher lifecycle", () => {
 
     // Fire two queries simultaneously
     await Promise.all([
-      execute({ chatId: "A", numericChatId: 1, prompt: "a", senderName: "U", isGroup: false, source: "message" }),
-      execute({ chatId: "B", numericChatId: 2, prompt: "b", senderName: "U", isGroup: false, source: "message" }),
+      execute({
+        chatId: "A",
+        numericChatId: 1,
+        prompt: "a",
+        senderName: "U",
+        isGroup: false,
+        source: "message",
+      }),
+      execute({
+        chatId: "B",
+        numericChatId: 2,
+        prompt: "b",
+        senderName: "U",
+        isGroup: false,
+        source: "message",
+      }),
     ]);
 
     // True concurrency — both start before either ends

package/src/__tests__/log-init.test.ts

@@ -0,0 +1,129 @@
+/**
+ * Tests for log.ts module-level initialization code.
+ * Uses vi.resetModules() + vi.doMock() to control the file system state
+ * during module load so we can cover the initialization branches.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+describe("log.ts — module-level initialization branches", () => {
+  const mockMkdirSync = vi.fn();
+  const mockRenameSync = vi.fn();
+  const mockUnlinkSync = vi.fn();
+  const mockLogFn = vi.fn();
+
+  beforeEach(() => {
+    vi.resetModules();
+    mockMkdirSync.mockClear();
+    mockRenameSync.mockClear();
+    mockUnlinkSync.mockClear();
+    mockLogFn.mockClear();
+    delete process.env.TALON_QUIET;
+  });
+
+  afterEach(() => {
+    delete process.env.TALON_QUIET;
+  });
+
+  it("creates .talon dir when it does not exist (line 39 TRUE branch)", async () => {
+    vi.doMock("../util/paths.js", () => ({
+      dirs: { root: "/fake/.talon" },
+      files: {
+        log: "/fake/.talon/talon.log",
+        config: "/fake/.talon/config.json",
+      },
+    }));
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => false), // root dir doesn't exist
+      mkdirSync: mockMkdirSync,
+      statSync: vi.fn(() => ({ size: 0 })),
+      renameSync: mockRenameSync,
+      unlinkSync: mockUnlinkSync,
+      readFileSync: vi.fn(() => "{}"),
+    }));
+    vi.doMock("pino", () => ({
+      default: () => ({
+        info: mockLogFn,
+        error: mockLogFn,
+        warn: mockLogFn,
+        debug: mockLogFn,
+      }),
+    }));
+
+    await import("../util/log.js");
+
+    // mkdirSync should have been called to create the missing root dir
+    expect(mockMkdirSync).toHaveBeenCalledWith("/fake/.talon", {
+      recursive: true,
+    });
+  });
+
+  it("rotates log file when it exceeds 10MB (line 46 TRUE branch)", async () => {
+    vi.doMock("../util/paths.js", () => ({
+      dirs: { root: "/fake/.talon" },
+      files: {
+        log: "/fake/.talon/talon.log",
+        config: "/fake/.talon/config.json",
+      },
+    }));
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => true), // both root dir and log file exist
+      mkdirSync: mockMkdirSync,
+      statSync: vi.fn(() => ({ size: 11 * 1024 * 1024 })), // > 10MB → triggers rotation
+      renameSync: mockRenameSync,
+      unlinkSync: mockUnlinkSync,
+      readFileSync: vi.fn(() => "{}"),
+    }));
+    vi.doMock("pino", () => ({
+      default: () => ({
+        info: mockLogFn,
+        error: mockLogFn,
+        warn: mockLogFn,
+        debug: mockLogFn,
+      }),
+    }));
+
+    await import("../util/log.js");
+
+    // renameSync should have been called to rotate the oversized log file
+    expect(mockRenameSync).toHaveBeenCalledWith(
+      "/fake/.talon/talon.log",
+      "/fake/.talon/talon.log.old",
+    );
+  });
+
+  it("skips config read when TALON_QUIET=1 (line 59 FALSE branch: if(!quiet) not entered)", async () => {
+    process.env.TALON_QUIET = "1";
+    vi.doMock("../util/paths.js", () => ({
+      dirs: { root: "/fake/.talon" },
+      files: {
+        log: "/fake/.talon/talon.log",
+        config: "/fake/.talon/config.json",
+      },
+    }));
+    const readFileSyncMock = vi.fn(() => "{}");
+    vi.doMock("node:fs", () => ({
+      existsSync: vi.fn(() => true),
+      mkdirSync: mockMkdirSync,
+      statSync: vi.fn(() => ({ size: 0 })),
+      renameSync: mockRenameSync,
+      unlinkSync: mockUnlinkSync,
+      readFileSync: readFileSyncMock,
+    }));
+    vi.doMock("pino", () => ({
+      default: () => ({
+        info: mockLogFn,
+        error: mockLogFn,
+        warn: mockLogFn,
+        debug: mockLogFn,
+      }),
+    }));
+
+    await import("../util/log.js");
+
+    // When TALON_QUIET=1, quiet=true before `if (!quiet)` — readFileSync for config never called
+    const configCalls = readFileSyncMock.mock.calls.filter((c: unknown[]) =>
+      String(c[0]).includes("config"),
+    );
+    expect(configCalls).toHaveLength(0);
+  });
+});

package/src/__tests__/log.test.ts

@@ -29,14 +29,29 @@ describe("log", () => {
     it("calls pino.info with component and message", () => {
       log("bot", "started successfully");
       expect(mockInfo).toHaveBeenCalledOnce();
-      expect(mockInfo).toHaveBeenCalledWith({ component: "bot" }, "started successfully");
+      expect(mockInfo).toHaveBeenCalledWith(
+        { component: "bot" },
+        "started successfully",
+      );
     });
 
     it("works with all valid component types", () => {
       const components = [
-        "bot", "bridge", "agent", "pulse", "userbot", "users",
-        "watchdog", "workspace", "shutdown", "file", "sessions",
-        "settings", "commands", "cron", "dispatcher",
+        "bot",
+        "bridge",
+        "agent",
+        "pulse",
+        "userbot",
+        "users",
+        "watchdog",
+        "workspace",
+        "shutdown",
+        "file",
+        "sessions",
+        "settings",
+        "commands",
+        "cron",
+        "dispatcher",
       ] as const;
       for (const component of components) {
         mockInfo.mockClear();
@@ -50,7 +65,10 @@ describe("log", () => {
     it("calls pino.error with component and message", () => {
       logError("bot", "failed to start");
       expect(mockError).toHaveBeenCalledOnce();
-      expect(mockError).toHaveBeenCalledWith({ component: "bot" }, "failed to start");
+      expect(mockError).toHaveBeenCalledWith(
+        { component: "bot" },
+        "failed to start",
+      );
     });
 
     it("includes Error message in context", () => {