talon-agent 1.0.0 → 1.2.0

package/src/__tests__/telegram-formatting.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect } from "vitest";
+import {
+  markdownToTelegramHtml,
+  splitMessage,
+  escapeHtml,
+} from "../frontend/telegram/formatting.js";
+
+describe("markdownToTelegramHtml", () => {
+  it("converts bold markdown to HTML", () => {
+    expect(markdownToTelegramHtml("**hello**")).toContain("<b>hello</b>");
+  });
+
+  it("converts italic markdown to HTML", () => {
+    expect(markdownToTelegramHtml("_italic_")).toContain("<i>italic</i>");
+  });
+
+  it("converts safe https links to anchor tags", () => {
+    const result = markdownToTelegramHtml("[click](https://example.com)");
+    expect(result).toContain('<a href="https://example.com">click</a>');
+  });
+
+  it("strips unsafe non-https links (covers false branch of line 85)", () => {
+    // javascript: URL is not safe — should output just the text, not an anchor tag
+    const result = markdownToTelegramHtml("[click](javascript:alert('xss'))");
+    expect(result).not.toContain("<a href");
+    expect(result).toContain("click");
+  });
+
+  it("strips unsafe file:// links", () => {
+    const result = markdownToTelegramHtml("[file](file:///etc/passwd)");
+    expect(result).not.toContain("<a href");
+    expect(result).toContain("file");
+  });
+
+  it("converts inline code to <code>", () => {
+    expect(markdownToTelegramHtml("`code`")).toContain("<code>code</code>");
+  });
+
+  it("converts fenced code blocks to pre/code", () => {
+    const result = markdownToTelegramHtml("```\nconsole.log('hi')\n```");
+    expect(result).toContain("<pre><code>");
+    expect(result).toContain("console.log");
+  });
+
+  it("converts strikethrough to <s>", () => {
+    expect(markdownToTelegramHtml("~~deleted~~")).toContain("<s>deleted</s>");
+  });
+
+  it("escapes HTML special chars in text", () => {
+    const result = markdownToTelegramHtml("a & b < c > d");
+    expect(result).toContain("&amp;");
+    expect(result).toContain("&lt;");
+    expect(result).toContain("&gt;");
+  });
+});
+
+describe("splitMessage", () => {
+  it("returns single chunk for short messages", () => {
+    const chunks = splitMessage("Hello", 100);
+    expect(chunks).toHaveLength(1);
+    expect(chunks[0]).toBe("Hello");
+  });
+
+  it("splits long messages at word boundaries", () => {
+    const long = "word ".repeat(200);
+    const chunks = splitMessage(long, 100);
+    expect(chunks.length).toBeGreaterThan(1);
+    for (const chunk of chunks) {
+      expect(chunk.length).toBeLessThanOrEqual(100);
+    }
+  });
+});
+
+describe("escapeHtml", () => {
+  it("escapes angle brackets and ampersand", () => {
+    expect(escapeHtml("<>&")).toBe("&lt;&gt;&amp;");
+  });
+
+  it("passes through plain text unchanged", () => {
+    expect(escapeHtml("hello world")).toBe("hello world");
+  });
+});

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

@@ -77,8 +77,17 @@ vi.mock("../storage/sessions.js", () => ({
   getAllSessions: () => mockGetAllSessions(),
 }));
 
+const mockGetLoadedPlugins = vi.fn(
+  () =>
+    [] as Array<{
+      plugin: Record<string, unknown>;
+      config: Record<string, unknown>;
+      envVars: Record<string, string>;
+      path: string;
+    }>,
+);
 vi.mock("../core/plugin.js", () => ({
-  getLoadedPlugins: () => [],
+  getLoadedPlugins: () => mockGetLoadedPlugins(),
 }));
 
 import {
@@ -363,5 +372,203 @@ describe("built-in commands", () => {
       expect(ctx.initNewChat).not.toHaveBeenCalled();
       expect(ctx.renderer.writeSystem).toHaveBeenCalledWith("Cancelled.");
     });
+
+    it("shows turn count when session has no name (false ternary branch)", async () => {
+      // Selected session has no sessionName → shows "(N turns)" instead of '"name"'
+      mockGetAllSessions.mockReturnValueOnce([
+        {
+          chatId: "t_unnamed_session",
+          info: { turns: 3, lastActive: Date.now(), sessionName: undefined },
+        },
+      ]);
+      const ctx = makeMockContext({
+        waitForInput: vi.fn().mockResolvedValue("1"),
+      });
+      await tryRunCommand("/resume", ctx);
+      expect(ctx.initNewChat).toHaveBeenCalledWith("t_unnamed_session");
+      expect(ctx.renderer.writeSystem).toHaveBeenCalledWith(
+        expect.stringContaining("3 turns"),
+      );
+    });
+  });
+
+  describe("/model — ?? fallback to config.model", () => {
+    it("shows config model when getChatSettings has no model set", async () => {
+      // Default mockGetChatSettings returns {} (no model) → triggers ?? ctx.config.model
+      mockGetChatSettings.mockReturnValueOnce({});
+      const ctx = makeMockContext();
+      await tryRunCommand("/model", ctx);
+      expect(ctx.renderer.writeSystem).toHaveBeenCalledWith(
+        expect.stringContaining("claude-sonnet-4-6"),
+      );
+    });
+  });
+});
+
+describe("/status command", () => {
+  beforeEach(() => {
+    clearCommands();
+    registerBuiltinCommands();
+  });
+
+  it("displays session stats without plugins", async () => {
+    mockGetSessionInfo.mockReturnValueOnce({
+      turns: 5,
+      sessionName: undefined,
+      usage: {
+        totalInputTokens: 1000,
+        totalOutputTokens: 500,
+        totalCacheRead: 200,
+        totalCacheWrite: 0,
+        lastPromptTokens: 100,
+        estimatedCostUsd: 0.01,
+        totalResponseMs: 5000,
+        lastResponseMs: 1000,
+        fastestResponseMs: 500,
+      },
+    });
+    const ctx = makeMockContext();
+    await tryRunCommand("/status", ctx);
+    expect(ctx.renderer.writeln).toHaveBeenCalled();
+    expect(ctx.reprompt).toHaveBeenCalled();
+  });
+
+  it("displays session name when set", async () => {
+    mockGetSessionInfo.mockReturnValueOnce({
+      turns: 3,
+      sessionName: "My Work Session",
+      usage: {
+        totalInputTokens: 500,
+        totalOutputTokens: 200,
+        totalCacheRead: 100,
+        totalCacheWrite: 0,
+        lastPromptTokens: 50,
+        estimatedCostUsd: 0.005,
+        totalResponseMs: 2000,
+        lastResponseMs: 500,
+        fastestResponseMs: 300,
+      },
+    });
+    const ctx = makeMockContext();
+    await tryRunCommand("/status", ctx);
+    // Should mention the session name
+    const calls = (
+      ctx.renderer.writeln as ReturnType<typeof vi.fn>
+    ).mock.calls.flat();
+    const output = calls.join(" ");
+    expect(output).toContain("My Work Session");
+  });
+
+  it("/status shows plugins section when plugins are loaded", async () => {
+    mockGetLoadedPlugins.mockReturnValueOnce([
+      {
+        plugin: {
+          name: "my-plugin",
+          version: "1.0",
+          description: "A test plugin",
+          mcpServerPath: "/path/tools.ts",
+        },
+        config: {},
+        envVars: {},
+        path: "/fake/my-plugin",
+      },
+    ]);
+    const ctx = makeMockContext();
+    await tryRunCommand("/status", ctx);
+    const calls = (
+      ctx.renderer.writeln as ReturnType<typeof vi.fn>
+    ).mock.calls.flat();
+    const out = calls.join(" ");
+    expect(out).toContain("my-plugin");
+    expect(out).toContain("Plugins");
+    expect(ctx.reprompt).toHaveBeenCalled();
+  });
+
+  it("/status shows 'actions only' for plugin without mcpServerPath", async () => {
+    mockGetLoadedPlugins.mockReturnValueOnce([
+      {
+        plugin: { name: "actions-only-plugin" },
+        config: {},
+        envVars: {},
+        path: "/fake/ao-plugin",
+      },
+    ]);
+    const ctx = makeMockContext();
+    await tryRunCommand("/status", ctx);
+    const calls = (
+      ctx.renderer.writeln as ReturnType<typeof vi.fn>
+    ).mock.calls.flat();
+    expect(calls.join(" ")).toContain("actions only");
+  });
+});
+
+describe("/effort command", () => {
+  beforeEach(() => {
+    clearCommands();
+    registerBuiltinCommands();
+    vi.clearAllMocks();
+  });
+
+  it("shows current effort when no arg given", async () => {
+    mockGetChatSettings.mockReturnValueOnce({ effort: "high" });
+    const ctx = makeMockContext();
+    await tryRunCommand("/effort", ctx);
+    expect(ctx.renderer.writeSystem).toHaveBeenCalledWith(
+      expect.stringContaining("high"),
+    );
+    expect(ctx.reprompt).toHaveBeenCalled();
+  });
+
+  it("shows adaptive when effort is not set", async () => {
+    mockGetChatSettings.mockReturnValueOnce({});
+    const ctx = makeMockContext();
+    await tryRunCommand("/effort", ctx);
+    expect(ctx.renderer.writeSystem).toHaveBeenCalledWith(
+      expect.stringContaining("adaptive"),
+    );
+    expect(ctx.reprompt).toHaveBeenCalled();
+  });
+
+  it("sets effort and reprompts when arg given", async () => {
+    const ctx = makeMockContext();
+    await tryRunCommand("/effort max", ctx);
+    expect(mockSetChatEffort).toHaveBeenCalledWith("t_test_123", "max");
+    expect(ctx.renderer.writeSystem).toHaveBeenCalledWith("Effort → max");
+    expect(ctx.reprompt).toHaveBeenCalled();
+  });
+
+  it("sets effort to undefined for 'adaptive' arg", async () => {
+    const ctx = makeMockContext();
+    await tryRunCommand("/effort adaptive", ctx);
+    expect(mockSetChatEffort).toHaveBeenCalledWith("t_test_123", undefined);
+    expect(ctx.reprompt).toHaveBeenCalled();
+  });
+});
+
+describe("/resume sort order", () => {
+  beforeEach(() => {
+    clearCommands();
+    registerBuiltinCommands();
+    vi.clearAllMocks();
+  });
+
+  it("sorts sessions by lastActive descending", async () => {
+    const now = Date.now();
+    mockGetAllSessions.mockReturnValueOnce([
+      {
+        chatId: "t_older",
+        info: { turns: 2, lastActive: now - 7200_000, sessionName: "older" },
+      },
+      {
+        chatId: "t_newer",
+        info: { turns: 3, lastActive: now - 3600_000, sessionName: "newer" },
+      },
+    ]);
+    const ctx = makeMockContext({
+      waitForInput: vi.fn().mockResolvedValue("1"),
+    });
+    await tryRunCommand("/resume", ctx);
+    // Selection "1" should pick the first listed session (most recent = t_newer)
+    expect(ctx.initNewChat).toHaveBeenCalledWith("t_newer");
   });
 });

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

@@ -45,6 +45,14 @@ describe("wrap", () => {
   it("returns text as-is if width too narrow", () => {
     expect(wrap("test", 70, 80)).toBe("test");
   });
+
+  it("skips final cur push when cur is empty (line 66 FALSE branch)", () => {
+    // A line of all spaces: length > width, but all split words are empty strings
+    // → cur never accumulates → `if (cur)` at end is false → no trailing push
+    const result = wrap(" ".repeat(26), 0, 25);
+    // Should produce an empty string (no content words to push)
+    expect(result).toBe("");
+  });
 });
 
 // ── formatTimeAgo ────────────────────────────────────────────────────────────
@@ -128,9 +136,66 @@ describe("extractToolDetail", () => {
     expect(extractToolDetail({ _chatId: "1", foo: "bar" }, 80)).toBe("foo=bar");
   });
 
+  it("truncates string values longer than 30 chars in fallback (line 112 TRUE branch)", () => {
+    // v.length > 30 → `v.slice(0, 30) + "..."` branch
+    const longVal = "a".repeat(35);
+    const result = extractToolDetail({ custom: longVal }, 80);
+    expect(result).toBe(`custom=${"a".repeat(30)}...`);
+  });
+
   it("returns empty string for empty input", () => {
     expect(extractToolDetail({}, 80)).toBe("");
   });
+
+  it("extracts package_url", () => {
+    expect(
+      extractToolDetail({ package_url: "https://pkg.example.com/lib" }, 80),
+    ).toBe("https://pkg.example.com/lib");
+  });
+
+  it("extracts packages array", () => {
+    expect(extractToolDetail({ packages: ["lodash", "express"] }, 80)).toBe(
+      "lodash, express",
+    );
+  });
+
+  it("skips empty string values in fallback", () => {
+    // Empty string value (v.length === 0) is skipped by the `v.length > 0` check
+    expect(extractToolDetail({ empty: "", valid: "value" }, 80)).toBe(
+      "valid=value",
+    );
+  });
+
+  it("skips object/null values in fallback (neither string nor number/boolean)", () => {
+    // Object values don't match either string or number/boolean conditions → skipped
+    expect(extractToolDetail({ obj: { nested: "val" }, num: 42 }, 80)).toBe(
+      "num=42",
+    );
+  });
+
+  it("extracts query field", () => {
+    expect(extractToolDetail({ query: "search term" }, 80)).toBe("search term");
+  });
+
+  it("extracts url field", () => {
+    expect(extractToolDetail({ url: "https://example.com" }, 80)).toBe(
+      "https://example.com",
+    );
+  });
+
+  it("extracts type field", () => {
+    expect(extractToolDetail({ type: "message" }, 80)).toBe("message");
+  });
+
+  it("extracts name field", () => {
+    expect(extractToolDetail({ name: "my-tool" }, 80)).toBe("my-tool");
+  });
+
+  it("extracts model field", () => {
+    expect(extractToolDetail({ model: "claude-sonnet-4-6" }, 80)).toBe(
+      "claude-sonnet-4-6",
+    );
+  });
 });
 
 // ── cleanToolName ────────────────────────────────────────────────────────────
@@ -272,6 +337,164 @@ describe("createRenderer", () => {
     const r = createRenderer(40);
     expect(r.cols).toBe(40);
   });
+
+  it("formats million-range token counts with M suffix", () => {
+    const r = createRenderer(80);
+    output = [];
+    r.renderStatusLine(5000, 1, {
+      model: "Sonnet",
+      turns: 1,
+      inputTokens: 1_500_000,
+      outputTokens: 500_000,
+      cacheHitPct: 0,
+      costUsd: 0,
+    });
+    // 2,000,000 tokens → 2.0M
+    expect(output.join("")).toContain("2.0M tok");
+  });
+
+  it("formats thousand-range token counts with k suffix", () => {
+    const r = createRenderer(80);
+    output = [];
+    r.renderStatusLine(2000, 1, {
+      model: "Sonnet",
+      turns: 1,
+      inputTokens: 5_000,
+      outputTokens: 3_500,
+      cacheHitPct: 0,
+      costUsd: 0,
+    });
+    // 8,500 tokens → 8.5k
+    expect(output.join("")).toContain("8.5k tok");
+  });
+
+  it("startSpinner writes to stdout on each tick", () => {
+    vi.useFakeTimers();
+    const r = createRenderer(80);
+    output = [];
+    r.startSpinner("loading");
+    vi.advanceTimersByTime(100);
+    // At least one frame written
+    expect(output.join("")).toContain("\r");
+    r.stopSpinner();
+    vi.useRealTimers();
+  });
+
+  it("stopSpinner clears the line", () => {
+    vi.useFakeTimers();
+    const r = createRenderer(80);
+    output = [];
+    r.startSpinner("working");
+    r.stopSpinner();
+    expect(output.join("")).toContain("\x1b[2K\r");
+    vi.useRealTimers();
+  });
+
+  it("stopSpinner is safe to call when not running", () => {
+    const r = createRenderer(80);
+    output = [];
+    expect(() => r.stopSpinner()).not.toThrow();
+  });
+
+  it("updateSpinnerLabel changes the displayed label", () => {
+    vi.useFakeTimers();
+    const r = createRenderer(80);
+    output = [];
+    r.startSpinner("initial");
+    r.updateSpinnerLabel("updated");
+    vi.advanceTimersByTime(100);
+    expect(output.join("")).toContain("updated");
+    r.stopSpinner();
+    vi.useRealTimers();
+  });
+
+  it("startSpinner stops any previous spinner before starting", () => {
+    vi.useFakeTimers();
+    const r = createRenderer(80);
+    r.startSpinner("first");
+    output = [];
+    r.startSpinner("second"); // should stop first and start new one
+    vi.advanceTimersByTime(100);
+    expect(output.join("")).toContain("second");
+    r.stopSpinner();
+    vi.useRealTimers();
+  });
+
+  it("renderStatusLine includes session name when provided", () => {
+    const r = createRenderer(80);
+    output = [];
+    r.renderStatusLine(1000, 0, {
+      model: "Sonnet",
+      turns: 1,
+      inputTokens: 10,
+      outputTokens: 5,
+      cacheHitPct: 0,
+      costUsd: 0,
+      sessionName: "My Work",
+    });
+    expect(output.join("")).toContain("My Work");
+  });
+
+  it("renderToolCall called twice — hasToolOutput flag suppresses second blank line", () => {
+    const r = createRenderer(80);
+    output = [];
+    r.renderToolCall("Bash", { command: "ls" });
+    const firstCallLen = output.join("").length;
+    r.renderToolCall("Read", { file_path: "/tmp/x.txt" });
+    const secondCallLen = output.join("").length;
+    // Both calls should add output (second call doesn't add extra blank line)
+    expect(secondCallLen).toBeGreaterThan(firstCallLen);
+    expect(output.join("")).toContain("Read");
+  });
+
+  it("creates renderer with auto column width when no cols given", () => {
+    // Covers the `cols ?? Math.min(...)` right branch
+    const r = createRenderer(); // no cols argument
+    expect(r.cols).toBeGreaterThan(0);
+  });
+
+  it("renderToolCall with numeric/boolean input values", () => {
+    const r = createRenderer(80);
+    output = [];
+    r.renderToolCall("Bash", { timeout: 30, verbose: true });
+    const text = output.join("");
+    // numeric and boolean values should appear
+    expect(text).toContain("Bash");
+  });
+
+  it("renderToolCall with long string value (>30 chars) shows detail", () => {
+    const r = createRenderer(80);
+    output = [];
+    // A value > 30 chars covers the v.length > 30 branch in extractToolDetail
+    r.renderToolCall("Bash", { command: "A".repeat(40) });
+    const text = output.join("");
+    expect(text).toContain("Bash");
+    expect(text).toContain("A"); // detail was extracted
+  });
+
+  it("renderToolCall with empty input produces no detail", () => {
+    // input has only _chatId (skipped) → detail="" → `detail ? ... : ""` returns ""
+    const r = createRenderer(80);
+    output = [];
+    r.renderToolCall("SomeToolName", { _chatId: "ignored" });
+    const text = output.join("");
+    expect(text).toContain("SomeToolName");
+  });
+
+  it("spinner pads shorter label to match previous line length", () => {
+    vi.useFakeTimers();
+    const r = createRenderer(80);
+    output = [];
+    r.startSpinner("a very long spinner label here");
+    vi.advanceTimersByTime(90); // first tick
+    r.updateSpinnerLabel("short"); // shorter label
+    vi.advanceTimersByTime(90); // second tick — padding should be added
+    const text = output.join("");
+    // Should include a carriage return (spinner output)
+    expect(text).toContain("\r");
+    r.stopSpinner();
+    vi.useRealTimers();
+  });
 });
 
 // Need to import afterEach for cleanup

package/src/__tests__/time.test.ts

@@ -0,0 +1,107 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import {
+  setTimezone,
+  getTimezone,
+  formatSmartTimestamp,
+  formatFullDatetime,
+  formatRelativeAge,
+} from "../util/time.js";
+
+describe("time utilities", () => {
+  describe("setTimezone / getTimezone", () => {
+    afterEach(() => setTimezone(undefined));
+
+    it("returns system timezone when none configured", () => {
+      setTimezone(undefined);
+      expect(getTimezone()).toBeTruthy();
+      expect(typeof getTimezone()).toBe("string");
+    });
+
+    it("returns configured timezone", () => {
+      setTimezone("America/New_York");
+      expect(getTimezone()).toBe("America/New_York");
+    });
+
+    it("resets to system timezone when set to undefined", () => {
+      setTimezone("Europe/Warsaw");
+      setTimezone(undefined);
+      expect(getTimezone()).not.toBe("Europe/Warsaw");
+    });
+  });
+
+  describe("formatSmartTimestamp", () => {
+    afterEach(() => setTimezone(undefined));
+
+    it("returns HH:MM for today", () => {
+      const now = Date.now();
+      const result = formatSmartTimestamp(now);
+      expect(result).toMatch(/^\d{2}:\d{2}$/);
+    });
+
+    it("returns 'Yesterday HH:MM' for yesterday", () => {
+      const yesterday = Date.now() - 86_400_000;
+      const result = formatSmartTimestamp(yesterday);
+      expect(result).toMatch(/^Yesterday \d{2}:\d{2}$/);
+    });
+
+    it("returns 'Month Day HH:MM' for a date earlier this year", () => {
+      // Use a date 60 days ago (safe to assume still same year in most cases)
+      const sixtyDaysAgo = Date.now() - 60 * 86_400_000;
+      const date = new Date(sixtyDaysAgo);
+      const currentYear = new Date().getFullYear();
+      // Only test if still in same year
+      if (date.getFullYear() === currentYear) {
+        const result = formatSmartTimestamp(sixtyDaysAgo);
+        // Format: "Apr 2 14:32"
+        expect(result).toMatch(/^[A-Z][a-z]{2} \d{1,2} \d{2}:\d{2}$/);
+      }
+    });
+
+    it("returns 'YYYY-MM-DD HH:MM' for a date in a different year", () => {
+      // A timestamp from 2020 — safely in a past year
+      const oldDate = new Date("2020-06-15T12:00:00Z").getTime();
+      const result = formatSmartTimestamp(oldDate);
+      expect(result).toMatch(/^2020-\d{2}-\d{2} \d{2}:\d{2}$/);
+    });
+  });
+
+  describe("formatFullDatetime", () => {
+    afterEach(() => setTimezone(undefined));
+
+    it("returns a non-empty string", () => {
+      expect(formatFullDatetime().length).toBeGreaterThan(10);
+    });
+
+    it("includes timezone name", () => {
+      setTimezone("UTC");
+      expect(formatFullDatetime()).toContain("UTC");
+    });
+
+    it("includes a weekday abbreviation", () => {
+      const result = formatFullDatetime();
+      expect(result).toMatch(/Mon|Tue|Wed|Thu|Fri|Sat|Sun/);
+    });
+  });
+
+  describe("formatRelativeAge", () => {
+    it("returns 'just now' for timestamps within the last minute", () => {
+      expect(formatRelativeAge(Date.now() - 30_000)).toBe("just now");
+      expect(formatRelativeAge(Date.now())).toBe("just now");
+    });
+
+    it("returns minutes ago for timestamps within the last hour", () => {
+      expect(formatRelativeAge(Date.now() - 5 * 60_000)).toBe("5m ago");
+      expect(formatRelativeAge(Date.now() - 59 * 60_000)).toBe("59m ago");
+    });
+
+    it("returns hours ago for timestamps within the last day", () => {
+      expect(formatRelativeAge(Date.now() - 3 * 3_600_000)).toBe("3h ago");
+      expect(formatRelativeAge(Date.now() - 23 * 3_600_000)).toBe("23h ago");
+    });
+
+    it("returns days ago for old timestamps", () => {
+      expect(formatRelativeAge(Date.now() - 2 * 86_400_000)).toBe("2d ago");
+      expect(formatRelativeAge(Date.now() - 30 * 86_400_000)).toBe("30d ago");
+    });
+  });
+});