tower-studio 0.1.3 → 0.1.5

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

@@ -1,253 +0,0 @@
-// @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

@@ -1,173 +0,0 @@
-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

@@ -1,75 +0,0 @@
-// @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);
-  });
-});