tower-studio 0.1.2 → 0.1.3

package/src/lib/__tests__/assistant-sessions.test.ts

@@ -0,0 +1,253 @@
+// @vitest-environment jsdom
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  getSessions,
+  addSession,
+  updateSession,
+  deleteSession,
+  getActiveSessionId,
+  setActiveSessionId,
+  buildSessionTitle,
+  type AssistantSession,
+} from "../assistant-sessions";
+
+function makeSession(id: string, title = "Test Session"): AssistantSession {
+  return {
+    id,
+    title,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+const STORAGE_KEY = "tower-assistant-sessions";
+const ACTIVE_KEY = "tower-assistant-active-session";
+
+describe("getSessions", () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it("returns [] when localStorage is empty", () => {
+    expect(getSessions()).toEqual([]);
+  });
+
+  it("returns parsed array when localStorage has valid JSON", () => {
+    const sessions = [makeSession("s1"), makeSession("s2")];
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(sessions));
+    expect(getSessions()).toHaveLength(2);
+    expect(getSessions()[0].id).toBe("s1");
+  });
+
+  it("returns [] when localStorage has invalid JSON", () => {
+    localStorage.setItem(STORAGE_KEY, "not-valid-json{{{");
+    expect(getSessions()).toEqual([]);
+  });
+
+  it("returns [] when localStorage has non-array JSON (object)", () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify({ id: "s1" }));
+    expect(getSessions()).toEqual([]);
+  });
+
+  it("returns [] when localStorage has non-array JSON (string)", () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify("just a string"));
+    expect(getSessions()).toEqual([]);
+  });
+});
+
+describe("addSession", () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it("adds a session when list is empty", () => {
+    addSession(makeSession("s1"));
+    expect(getSessions()).toHaveLength(1);
+    expect(getSessions()[0].id).toBe("s1");
+  });
+
+  it("prepends new session before existing ones", () => {
+    addSession(makeSession("s1"));
+    addSession(makeSession("s2"));
+    const sessions = getSessions();
+    expect(sessions[0].id).toBe("s2");
+    expect(sessions[1].id).toBe("s1");
+  });
+
+  it("deduplicates by id (re-adding same id moves it to front)", () => {
+    addSession(makeSession("s1"));
+    addSession(makeSession("s2"));
+    addSession(makeSession("s1")); // s1 should be at front, no duplicate
+    const sessions = getSessions();
+    expect(sessions).toHaveLength(2);
+    expect(sessions[0].id).toBe("s1");
+    expect(sessions[1].id).toBe("s2");
+  });
+
+  it("caps at MAX_SESSIONS (10) — oldest is dropped when 11th session added", () => {
+    for (let i = 1; i <= 10; i++) {
+      addSession(makeSession(`s${i}`));
+    }
+    expect(getSessions()).toHaveLength(10);
+
+    addSession(makeSession("s11"));
+    const sessions = getSessions();
+    expect(sessions).toHaveLength(10);
+    expect(sessions[0].id).toBe("s11");
+    const ids = sessions.map((s) => s.id);
+    expect(ids).not.toContain("s1");
+  });
+
+  it("respects MAX_SESSIONS cap even when deduplication occurs", () => {
+    for (let i = 1; i <= 10; i++) {
+      addSession(makeSession(`s${i}`));
+    }
+    addSession(makeSession("s5"));
+    expect(getSessions()).toHaveLength(10);
+    expect(getSessions()[0].id).toBe("s5");
+  });
+});
+
+describe("updateSession", () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it("merges updates into the target session", () => {
+    addSession(makeSession("s1", "Original Title"));
+    updateSession("s1", { title: "Updated Title" });
+    const sessions = getSessions();
+    expect(sessions[0].title).toBe("Updated Title");
+  });
+
+  it("sets updatedAt to a new ISO timestamp", async () => {
+    const before = new Date().toISOString();
+    addSession(makeSession("s1"));
+    // Small delay to ensure timestamp changes
+    await new Promise((r) => setTimeout(r, 5));
+    updateSession("s1", { title: "New" });
+    const updated = getSessions()[0].updatedAt;
+    expect(updated >= before).toBe(true);
+  });
+
+  it("does not affect other sessions", () => {
+    addSession(makeSession("s1", "Title 1"));
+    addSession(makeSession("s2", "Title 2"));
+    updateSession("s2", { title: "Changed" });
+    const sessions = getSessions();
+    const s1 = sessions.find((s) => s.id === "s1")!;
+    expect(s1.title).toBe("Title 1");
+  });
+
+  it("is a no-op when session id does not exist", () => {
+    addSession(makeSession("s1"));
+    updateSession("nonexistent", { title: "Ghost" });
+    expect(getSessions()).toHaveLength(1);
+    expect(getSessions()[0].title).toBe("Test Session");
+  });
+});
+
+describe("deleteSession", () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it("removes the session with the matching id", () => {
+    addSession(makeSession("s1"));
+    addSession(makeSession("s2"));
+    deleteSession("s1");
+    const sessions = getSessions();
+    expect(sessions).toHaveLength(1);
+    expect(sessions[0].id).toBe("s2");
+  });
+
+  it("is a no-op when session id does not exist", () => {
+    addSession(makeSession("s1"));
+    deleteSession("nonexistent");
+    expect(getSessions()).toHaveLength(1);
+  });
+
+  it("clears the active session id if the deleted session was active", () => {
+    addSession(makeSession("s1"));
+    setActiveSessionId("s1");
+    expect(getActiveSessionId()).toBe("s1");
+    deleteSession("s1");
+    expect(getActiveSessionId()).toBeNull();
+  });
+
+  it("does not clear active session when a different session is deleted", () => {
+    addSession(makeSession("s1"));
+    addSession(makeSession("s2"));
+    setActiveSessionId("s2");
+    deleteSession("s1");
+    expect(getActiveSessionId()).toBe("s2");
+  });
+});
+
+describe("getActiveSessionId / setActiveSessionId", () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it("returns null when no active session is set", () => {
+    expect(getActiveSessionId()).toBeNull();
+  });
+
+  it("stores and retrieves the active session id", () => {
+    setActiveSessionId("s42");
+    expect(getActiveSessionId()).toBe("s42");
+  });
+
+  it("removes the active session key when null is passed", () => {
+    setActiveSessionId("s42");
+    setActiveSessionId(null);
+    expect(getActiveSessionId()).toBeNull();
+    // Confirm the key is fully removed (not set to string "null")
+    expect(localStorage.getItem(ACTIVE_KEY)).toBeNull();
+  });
+
+  it("overwrites previous active session id", () => {
+    setActiveSessionId("s1");
+    setActiveSessionId("s2");
+    expect(getActiveSessionId()).toBe("s2");
+  });
+});
+
+describe("buildSessionTitle", () => {
+  it("returns the message as-is when it is <=30 chars", () => {
+    expect(buildSessionTitle("Hello world")).toBe("Hello world");
+  });
+
+  it("truncates to exactly 30 characters when input exceeds 30 chars", () => {
+    const long = "A".repeat(40);
+    const result = buildSessionTitle(long);
+    expect(result).toHaveLength(30);
+    expect(result).toBe("A".repeat(30));
+  });
+
+  it("returns 'New Session' for empty string", () => {
+    expect(buildSessionTitle("")).toBe("New Session");
+  });
+
+  it("returns 'New Session' for whitespace-only string", () => {
+    expect(buildSessionTitle("   ")).toBe("New Session");
+    expect(buildSessionTitle("\t\n")).toBe("New Session");
+  });
+
+  it("trims leading/trailing whitespace before checking length", () => {
+    // " Hello " → trimmed to "Hello" (5 chars) — should not truncate
+    expect(buildSessionTitle("  Hello  ")).toBe("Hello");
+  });
+
+  it("truncates based on trimmed length, not raw length", () => {
+    // 30 x chars padded: trimmed is exactly 30 — no truncation
+    const exactly30 = "x".repeat(30);
+    expect(buildSessionTitle(`  ${exactly30}  `)).toBe(exactly30);
+  });
+
+  it("returns 'New Session' when string has exactly 30 chars after trim (not empty)", () => {
+    // Edge: exactly 30 chars after trim should NOT be treated as empty
+    const exactly30 = "x".repeat(30);
+    expect(buildSessionTitle(exactly30)).toBe(exactly30);
+  });
+});

package/src/lib/__tests__/build-multimodal-prompt.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Mock fs before importing the module under test
+vi.mock("node:fs", () => ({
+  existsSync: vi.fn(),
+}));
+
+import * as fs from "node:fs";
+import { buildMultimodalPrompt } from "../build-multimodal-prompt";
+
+const CACHE_DIR = "/abs/cache/assistant";
+
+// Valid sub-path format filenames for testing
+const SUBPATH1 = "2026-04/images/design-a1b2c3d4.png";
+const SUBPATH2 = "2026-04/images/photo-b2c3d4e5.jpg";
+const SUBPATH3 = "2025-12/images/test-c3d4e5f6.webp";
+const SUBPATH_EXISTS = "2026-04/images/exists-d4e5f6a7.png";
+const SUBPATH_MISSING = "2026-04/images/missing-e5f6a7b8.jpg";
+
+beforeEach(() => {
+  vi.resetAllMocks();
+});
+
+describe("buildMultimodalPrompt", () => {
+  it("returns prompt unchanged when imageFilenames is empty", () => {
+    const result = buildMultimodalPrompt("/tower hello", [], CACHE_DIR);
+    expect(result).toBe("/tower hello");
+  });
+
+  it("appends image path section for a single existing image", () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+
+    const result = buildMultimodalPrompt(
+      "/tower describe this",
+      [SUBPATH1],
+      CACHE_DIR
+    );
+
+    expect(result).toContain(`/abs/cache/assistant/${SUBPATH1}`);
+    expect(result).toContain("Read tool");
+    expect(result).toContain("---");
+  });
+
+  it("appends all image paths when multiple images exist", () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+
+    const result = buildMultimodalPrompt(
+      "/tower compare",
+      [SUBPATH1, SUBPATH2],
+      CACHE_DIR
+    );
+
+    expect(result).toContain(`/abs/cache/assistant/${SUBPATH1}`);
+    expect(result).toContain(`/abs/cache/assistant/${SUBPATH2}`);
+  });
+
+  it("skips files that do not exist on disk", () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    const result = buildMultimodalPrompt(
+      "/tower hi",
+      [SUBPATH1],
+      CACHE_DIR
+    );
+
+    // No valid paths → returns prompt unchanged
+    expect(result).toBe("/tower hi");
+  });
+
+  it("returns prompt unchanged when all files are missing", () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    const result = buildMultimodalPrompt(
+      "/tower test",
+      [SUBPATH1, SUBPATH2, SUBPATH3],
+      CACHE_DIR
+    );
+
+    expect(result).toBe("/tower test");
+    expect(result).not.toContain("---");
+  });
+
+  it("includes only existing files when some are missing", () => {
+    vi.mocked(fs.existsSync).mockImplementation((p) => {
+      return (p as string).includes("exists-d4e5f6a7");
+    });
+
+    const result = buildMultimodalPrompt(
+      "/tower mixed",
+      [SUBPATH_EXISTS, SUBPATH_MISSING],
+      CACHE_DIR
+    );
+
+    expect(result).toContain(`/abs/cache/assistant/${SUBPATH_EXISTS}`);
+    expect(result).not.toContain("missing-e5f6a7b8");
+  });
+
+  it("caps at 10 images — excess silently dropped", () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+
+    const manyImages = Array.from(
+      { length: 15 },
+      (_, i) => `2026-04/images/img-${String(i).padStart(8, "0")}.png`
+    );
+    const result = buildMultimodalPrompt("/tower many", manyImages, CACHE_DIR);
+
+    // Only first 10 should appear
+    for (let i = 0; i < 10; i++) {
+      expect(result).toContain(manyImages[i]);
+    }
+    // Images 10–14 should not appear
+    for (let i = 10; i < 15; i++) {
+      expect(result).not.toContain(manyImages[i]);
+    }
+  });
+
+  it("uses a clear delimiter section so Claude knows where image references start", () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+
+    const result = buildMultimodalPrompt(
+      "/tower check",
+      [SUBPATH1],
+      CACHE_DIR
+    );
+
+    // Should have the delimiter and the instruction text
+    expect(result).toContain("\n\n---\n");
+    expect(result).toMatch(/attached.*image/i);
+  });
+
+  it("rejects filenames with path traversal sequences", () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+
+    const result = buildMultimodalPrompt(
+      "/tower safe",
+      ["../../etc/passwd", "../.env", SUBPATH1],
+      CACHE_DIR
+    );
+
+    // Only the valid sub-path filename should appear
+    expect(result).toContain(SUBPATH1);
+    expect(result).not.toContain("passwd");
+    expect(result).not.toContain(".env");
+  });
+
+  it("rejects filenames that don't match sub-path format", () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+
+    const result = buildMultimodalPrompt(
+      "/tower strict",
+      ["not-valid.png", "abc.jpg", SUBPATH1],
+      CACHE_DIR
+    );
+
+    expect(result).toContain(SUBPATH1);
+    expect(result).not.toContain("not-valid");
+    expect(result).not.toContain("abc.jpg");
+  });
+
+  it("accepts sub-paths with Chinese characters", () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+
+    const chineseSubPath = "2026-04/images/\u8bbe\u8ba1\u7a3f-a1b2c3d4.png";
+    const result = buildMultimodalPrompt(
+      "/tower check chinese",
+      [chineseSubPath],
+      CACHE_DIR
+    );
+
+    expect(result).toContain(chineseSubPath);
+    expect(result).toContain("Read tool");
+  });
+});

package/src/lib/__tests__/config-reader.test.ts

@@ -0,0 +1,75 @@
+// @vitest-environment node
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// Use vi.hoisted to define mock before vi.mock hoisting runs
+const mockFindUnique = vi.hoisted(() => vi.fn());
+
+vi.mock("@/lib/db", () => ({
+  db: {
+    systemConfig: {
+      findUnique: mockFindUnique,
+    },
+  },
+}));
+
+import { readConfigValue } from "../config-reader";
+
+describe("readConfigValue", () => {
+  beforeEach(() => {
+    mockFindUnique.mockReset();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("returns default value when key is missing from DB (findUnique returns null)", async () => {
+    mockFindUnique.mockResolvedValue(null);
+    const result = await readConfigValue("missing-key", 42);
+    expect(result).toBe(42);
+    expect(mockFindUnique).toHaveBeenCalledWith({ where: { key: "missing-key" } });
+  });
+
+  it("returns parsed number when findUnique returns valid JSON string '100'", async () => {
+    mockFindUnique.mockResolvedValue({ value: "100" });
+    const result = await readConfigValue<number>("number-key", 0);
+    expect(result).toBe(100);
+  });
+
+  it("returns parsed string when findUnique returns valid JSON string '\"hello\"'", async () => {
+    mockFindUnique.mockResolvedValue({ value: '"hello"' });
+    const result = await readConfigValue<string>("string-key", "default");
+    expect(result).toBe("hello");
+  });
+
+  it("returns parsed boolean true when findUnique returns value 'true'", async () => {
+    mockFindUnique.mockResolvedValue({ value: "true" });
+    const result = await readConfigValue<boolean>("bool-key", false);
+    expect(result).toBe(true);
+  });
+
+  it("returns default value when stored JSON is invalid (fallback on parse error)", async () => {
+    mockFindUnique.mockResolvedValue({ value: "not-json{" });
+    const result = await readConfigValue<string>("bad-json", "fallback");
+    expect(result).toBe("fallback");
+  });
+
+  it("returns parsed object when findUnique returns valid JSON object string", async () => {
+    mockFindUnique.mockResolvedValue({ value: '{"a":1}' });
+    const result = await readConfigValue<{ a: number }>("object-key", {});
+    expect(result).toEqual({ a: 1 });
+  });
+
+  it("returns default object when findUnique returns null (complex default)", async () => {
+    mockFindUnique.mockResolvedValue(null);
+    const defaultVal = { nested: { x: 99 } };
+    const result = await readConfigValue("missing-complex", defaultVal);
+    expect(result).toEqual(defaultVal);
+  });
+
+  it("returns parsed boolean false when findUnique returns value 'false'", async () => {
+    mockFindUnique.mockResolvedValue({ value: "false" });
+    const result = await readConfigValue<boolean>("bool-false-key", true);
+    expect(result).toBe(false);
+  });
+});