tower-studio 0.1.2 → 0.1.5

package/.next/standalone/tower/tests/unit/lib/search.test.ts

@@ -1,289 +0,0 @@
-// @vitest-environment node
-import { describe, it, expect, beforeAll, afterAll, afterEach } from "vitest";
-import { PrismaClient } from "@prisma/client";
-import { syncNoteToFts } from "@/lib/fts";
-import type { SearchConfig } from "@/lib/search";
-
-const testDb = new PrismaClient({
-  datasources: {
-    db: { url: process.env.DATABASE_URL ?? "file:./prisma/dev.db" },
-  },
-});
-
-let testWorkspaceId: string;
-let testProjectId: string;
-
-const defaultConfig: SearchConfig = {
-  resultLimit: 20,
-  allModeCap: 5,
-  snippetLength: 80,
-};
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let searchFn: (query: string, category: any, config: SearchConfig) => Promise<unknown[]>;
-
-beforeAll(async () => {
-  await testDb.$connect();
-
-  // Ensure FTS5 table exists
-  await testDb.$executeRawUnsafe(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts
-    USING fts5(
-      note_id UNINDEXED,
-      title,
-      content,
-      tokenize='trigram case_sensitive 0'
-    )
-  `);
-
-  // Create test workspace and project
-  const workspace = await testDb.workspace.create({
-    data: { name: "Search Lib Test WS" },
-  });
-  testWorkspaceId = workspace.id;
-
-  const project = await testDb.project.create({
-    data: {
-      name: "Search Lib Test Proj",
-      workspaceId: testWorkspaceId,
-    },
-  });
-  testProjectId = project.id;
-
-  // Dynamic import: framework-agnostic module
-  const mod = await import("@/lib/search");
-  searchFn = mod.search;
-});
-
-afterAll(async () => {
-  await testDb.workspace.delete({ where: { id: testWorkspaceId } });
-  await testDb.$disconnect();
-});
-
-afterEach(async () => {
-  // Clean up notes + FTS entries
-  const notes = await testDb.projectNote.findMany({
-    where: { projectId: testProjectId },
-  });
-  for (const note of notes) {
-    await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", note.id);
-  }
-  await testDb.projectNote.deleteMany({ where: { projectId: testProjectId } });
-
-  // Clean up assets
-  await testDb.projectAsset.deleteMany({ where: { projectId: testProjectId } });
-
-  // Clean up tasks
-  await testDb.task.deleteMany({ where: { projectId: testProjectId } });
-});
-
-describe("search - empty query", () => {
-  it("Test 1: returns empty array for empty query (task category)", async () => {
-    const results = await searchFn("", "task", defaultConfig);
-    expect(results).toEqual([]);
-  });
-
-  it("returns empty array for whitespace-only query", async () => {
-    const results = await searchFn("   ", "task", defaultConfig);
-    expect(results).toEqual([]);
-  });
-});
-
-describe("search - task category", () => {
-  it("Test 2: returns task results with correct shape (id, type, title, subtitle, navigateTo)", async () => {
-    await testDb.task.create({
-      data: {
-        title: "srchlib-task-shape-test",
-        projectId: testProjectId,
-      },
-    });
-
-    const results = await searchFn("srchlib-task-shape-test", "task", defaultConfig) as Array<{
-      id: string;
-      type: string;
-      title: string;
-      subtitle: string;
-      navigateTo: string;
-    }>;
-
-    expect(results.length).toBeGreaterThan(0);
-    const found = results.find((r) => r.title === "srchlib-task-shape-test");
-    expect(found).toBeDefined();
-    expect(found?.type).toBe("task");
-    expect(found?.id).toBeDefined();
-    expect(found?.subtitle).toBeDefined();
-    expect(found?.navigateTo).toMatch(/\/workspaces\//);
-  });
-});
-
-describe("search - note category with FTS5", () => {
-  it("Test 3: returns note results with snippet field via FTS5 MATCH", async () => {
-    const longContent = "FTS5content".repeat(10);
-    const note = await testDb.projectNote.create({
-      data: {
-        title: "srchlib-fts5-note-title",
-        content: longContent,
-        projectId: testProjectId,
-      },
-    });
-    await syncNoteToFts(testDb, { id: note.id, title: note.title, content: note.content });
-
-    const results = await searchFn("srchlib-fts5-note", "note", defaultConfig) as Array<{
-      id: string;
-      type: string;
-      snippet?: string;
-    }>;
-
-    expect(results.length).toBeGreaterThan(0);
-    const found = results.find((r) => r.id === note.id);
-    expect(found).toBeDefined();
-    expect(found?.type).toBe("note");
-    expect(found?.snippet).toBe(longContent.slice(0, 80));
-  });
-});
-
-describe("search - note category with short query (LIKE fallback)", () => {
-  it("Test 4: uses LIKE fallback for short query (< 3 chars)", async () => {
-    const note = await testDb.projectNote.create({
-      data: {
-        title: "AB Short Query Note",
-        content: "some content here",
-        projectId: testProjectId,
-      },
-    });
-    // NOT synced to FTS — LIKE fallback queries ProjectNote table directly
-
-    const results = await searchFn("ab", "note", defaultConfig) as Array<{ id: string }>;
-    expect(results.length).toBeGreaterThan(0);
-    const found = results.find((r) => r.id === note.id);
-    expect(found).toBeDefined();
-  });
-});
-
-describe("search - all category", () => {
-  it("Test 5: returns results from multiple types, each capped at allModeCap", async () => {
-    // Create task
-    await testDb.task.create({
-      data: {
-        title: "srchlib-all-task",
-        projectId: testProjectId,
-      },
-    });
-
-    // Create note and sync to FTS
-    const note = await testDb.projectNote.create({
-      data: {
-        title: "srchlib-all-note",
-        content: "srchlib all category content",
-        projectId: testProjectId,
-      },
-    });
-    await syncNoteToFts(testDb, { id: note.id, title: note.title, content: note.content });
-
-    // Create asset
-    await testDb.projectAsset.create({
-      data: {
-        filename: "srchlib-all-file.txt",
-        path: "/data/assets/srchlib-all-file.txt",
-        size: 256,
-        mimeType: "text/plain",
-        description: "",
-        projectId: testProjectId,
-      },
-    });
-
-    const capConfig: SearchConfig = { resultLimit: 20, allModeCap: 3, snippetLength: 80 };
-    const results = await searchFn("srchlib-all", "all", capConfig) as Array<{ type: string }>;
-    expect(results.length).toBeGreaterThan(0);
-
-    // Results from multiple types
-    const types = new Set(results.map((r) => r.type));
-    expect(types.size).toBeGreaterThan(1);
-
-    // Each type capped at allModeCap (3)
-    const taskResults = results.filter((r) => r.type === "task");
-    const noteResults = results.filter((r) => r.type === "note");
-    const assetResults = results.filter((r) => r.type === "asset");
-    expect(taskResults.length).toBeLessThanOrEqual(3);
-    expect(noteResults.length).toBeLessThanOrEqual(3);
-    expect(assetResults.length).toBeLessThanOrEqual(3);
-  });
-});
-
-describe("search - resultLimit config", () => {
-  it("Test 6: respects resultLimit — creates 25 tasks, verifies result count <= 10", async () => {
-    // Create 25 tasks matching the query
-    const creations = Array.from({ length: 25 }, (_, i) =>
-      testDb.task.create({
-        data: {
-          title: `srchlib-limit-task-${i.toString().padStart(3, "0")}`,
-          projectId: testProjectId,
-        },
-      })
-    );
-    await Promise.all(creations);
-
-    const limitConfig: SearchConfig = { resultLimit: 10, allModeCap: 5, snippetLength: 80 };
-    const results = await searchFn("srchlib-limit-task", "task", limitConfig);
-    expect(results.length).toBeLessThanOrEqual(10);
-  });
-});
-
-describe("search - asset category", () => {
-  it("Test 7: returns asset results with snippet from description", async () => {
-    await testDb.projectAsset.create({
-      data: {
-        filename: "srchlib-asset-file.pdf",
-        path: "/data/assets/srchlib-asset-file.pdf",
-        size: 4096,
-        mimeType: "application/pdf",
-        description: "This is the asset description for search lib test",
-        projectId: testProjectId,
-      },
-    });
-
-    const results = await searchFn("srchlib-asset-file", "asset", defaultConfig) as Array<{
-      id: string;
-      type: string;
-      title: string;
-      snippet?: string;
-    }>;
-
-    expect(results.length).toBeGreaterThan(0);
-    const found = results.find((r) => r.title === "srchlib-asset-file.pdf");
-    expect(found).toBeDefined();
-    expect(found?.type).toBe("asset");
-    expect(found?.snippet).toBe("This is the asset description for search lib test");
-  });
-
-  it("asset with empty description has undefined snippet", async () => {
-    await testDb.projectAsset.create({
-      data: {
-        filename: "srchlib-no-desc.txt",
-        path: "/data/assets/srchlib-no-desc.txt",
-        size: 128,
-        mimeType: "text/plain",
-        description: "",
-        projectId: testProjectId,
-      },
-    });
-
-    const results = await searchFn("srchlib-no-desc", "asset", defaultConfig) as Array<{
-      title: string;
-      snippet?: string;
-    }>;
-
-    const found = results.find((r) => r.title === "srchlib-no-desc.txt");
-    expect(found).toBeDefined();
-    expect(found?.snippet).toBeUndefined();
-  });
-});
-
-describe("search - module exports", () => {
-  it("search module exports SearchConfig type (compile-time check via usage)", () => {
-    const cfg: SearchConfig = { resultLimit: 20, allModeCap: 5, snippetLength: 80 };
-    expect(cfg.resultLimit).toBe(20);
-    expect(cfg.allModeCap).toBe(5);
-    expect(cfg.snippetLength).toBe(80);
-  });
-});

package/.next/standalone/tower/tests/unit/lib/session-store.test.ts

@@ -1,111 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-// Mock node-pty
-const mockPty = {
-  onData: vi.fn(),
-  onExit: vi.fn(),
-  write: vi.fn(),
-  resize: vi.fn(),
-  kill: vi.fn(),
-};
-
-vi.mock("node-pty", () => ({
-  spawn: vi.fn(() => ({
-    ...mockPty,
-    onData: vi.fn(),
-    onExit: vi.fn(),
-    write: vi.fn(),
-    resize: vi.fn(),
-    kill: vi.fn(),
-  })),
-}));
-
-import {
-  createSession,
-  getSession,
-  destroySession,
-  destroyAllSessions,
-} from "@/lib/pty/session-store";
-
-describe("session-store", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    // Clean up any sessions from previous tests
-    destroyAllSessions();
-  });
-
-  describe("createSession", () => {
-    it("creates a new PtySession and returns it", () => {
-      const session = createSession("task-1", "bash", [], "/tmp", vi.fn(), vi.fn());
-      expect(session).toBeDefined();
-      expect(session.taskId).toBe("task-1");
-    });
-
-    it("stores session retrievable by getSession", () => {
-      const session = createSession("task-2", "bash", [], "/tmp", vi.fn(), vi.fn());
-      const retrieved = getSession("task-2");
-      expect(retrieved).toBe(session);
-    });
-
-    it("destroys existing session before creating new one for same taskId", () => {
-      const session1 = createSession("task-3", "bash", [], "/tmp", vi.fn(), vi.fn());
-      const killSpy = vi.spyOn(session1, "kill");
-
-      createSession("task-3", "bash", [], "/tmp", vi.fn(), vi.fn());
-      expect(killSpy).toHaveBeenCalled();
-    });
-  });
-
-  describe("getSession", () => {
-    it("returns undefined for non-existent taskId", () => {
-      expect(getSession("non-existent")).toBeUndefined();
-    });
-
-    it("returns the session for existing taskId", () => {
-      const session = createSession("task-4", "bash", [], "/tmp", vi.fn(), vi.fn());
-      expect(getSession("task-4")).toBe(session);
-    });
-  });
-
-  describe("destroySession", () => {
-    it("removes session from store", () => {
-      createSession("task-5", "bash", [], "/tmp", vi.fn(), vi.fn());
-      destroySession("task-5");
-      expect(getSession("task-5")).toBeUndefined();
-    });
-
-    it("kills the PTY", () => {
-      const session = createSession("task-6", "bash", [], "/tmp", vi.fn(), vi.fn());
-      const killSpy = vi.spyOn(session, "kill");
-      destroySession("task-6");
-      expect(killSpy).toHaveBeenCalled();
-    });
-
-    it("clears disconnect timer if set", () => {
-      const session = createSession("task-7", "bash", [], "/tmp", vi.fn(), vi.fn());
-      session.disconnectTimer = setTimeout(() => {}, 30000);
-      destroySession("task-7");
-      expect(session.disconnectTimer).toBeNull();
-    });
-
-    it("does nothing for non-existent taskId", () => {
-      expect(() => destroySession("non-existent")).not.toThrow();
-    });
-  });
-
-  describe("destroyAllSessions", () => {
-    it("destroys all sessions", () => {
-      const s1 = createSession("task-a", "bash", [], "/tmp", vi.fn(), vi.fn());
-      const s2 = createSession("task-b", "bash", [], "/tmp", vi.fn(), vi.fn());
-      const kill1 = vi.spyOn(s1, "kill");
-      const kill2 = vi.spyOn(s2, "kill");
-
-      destroyAllSessions();
-
-      expect(kill1).toHaveBeenCalled();
-      expect(kill2).toHaveBeenCalled();
-      expect(getSession("task-a")).toBeUndefined();
-      expect(getSession("task-b")).toBeUndefined();
-    });
-  });
-});

package/.next/standalone/tower/tests/unit/lib/utils.test.ts

@@ -1,33 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { cn, formatRelativeTime } from "@/lib/utils";
-
-describe("cn", () => {
-  it("merges class names", () => {
-    expect(cn("px-2", "py-1")).toBe("px-2 py-1");
-  });
-
-  it("handles conditional classes", () => {
-    expect(cn("px-2", false && "py-1", "text-sm")).toBe("px-2 text-sm");
-  });
-
-  it("resolves tailwind conflicts", () => {
-    expect(cn("px-2", "px-4")).toBe("px-4");
-  });
-});
-
-describe("formatRelativeTime", () => {
-  it("formats recent time as just now", () => {
-    const now = new Date();
-    expect(formatRelativeTime(now)).toBe("刚刚");
-  });
-
-  it("formats minutes ago", () => {
-    const tenMinutesAgo = new Date(Date.now() - 10 * 60 * 1000);
-    expect(formatRelativeTime(tenMinutesAgo)).toBe("10分钟前");
-  });
-
-  it("formats hours ago", () => {
-    const twoHoursAgo = new Date(Date.now() - 2 * 60 * 60 * 1000);
-    expect(formatRelativeTime(twoHoursAgo)).toBe("2小时前");
-  });
-});

package/.next/standalone/tower/tests/unit/lib/worktree.test.ts

@@ -1,190 +0,0 @@
-// @vitest-environment node
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-// Mock child_process before importing worktree
-vi.mock("child_process", () => ({
-  execFileSync: vi.fn(),
-}));
-
-// Mock fs/promises before importing worktree
-vi.mock("fs/promises", () => ({
-  mkdir: vi.fn(),
-}));
-
-// Mock fs before importing worktree
-vi.mock("fs", () => ({
-  existsSync: vi.fn(),
-}));
-
-import { execFileSync } from "child_process";
-import { mkdir } from "fs/promises";
-import { existsSync } from "fs";
-import { createWorktree, removeWorktree } from "@/lib/worktree";
-
-const mockedExecFileSync = vi.mocked(execFileSync);
-const mockedMkdir = vi.mocked(mkdir);
-const mockedExistsSync = vi.mocked(existsSync);
-
-const LOCAL_PATH = "/home/user/myproject";
-const TASK_ID = "clxabc123def";
-const BASE_BRANCH = "main";
-
-const expectedWorktreePath = `${LOCAL_PATH}/.worktrees/task-${TASK_ID}`;
-const expectedBranch = `task/${TASK_ID}`;
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  mockedMkdir.mockResolvedValue(undefined);
-  mockedExecFileSync.mockReturnValue("" as never);
-});
-
-function findCall(args: string[]): boolean {
-  return mockedExecFileSync.mock.calls.some(
-    (call) => {
-      const [cmd, cmdArgs] = call as [string, string[]];
-      return cmd === args[0] && JSON.stringify(cmdArgs) === JSON.stringify(args.slice(1));
-    }
-  );
-}
-
-describe("createWorktree", () => {
-  it("creates a new worktree when branch does not exist", async () => {
-    mockedExecFileSync.mockReturnValue("" as never);
-
-    const result = await createWorktree(LOCAL_PATH, TASK_ID, BASE_BRANCH);
-
-    expect(mockedMkdir).toHaveBeenCalledWith(
-      `${LOCAL_PATH}/.worktrees`,
-      { recursive: true }
-    );
-    expect(mockedExecFileSync).toHaveBeenCalledWith(
-      "git", ["worktree", "list", "--porcelain"],
-      { cwd: LOCAL_PATH, encoding: "utf-8", timeout: 10000 }
-    );
-    expect(mockedExecFileSync).toHaveBeenCalledWith(
-      "git", ["branch", "--list", expectedBranch],
-      { cwd: LOCAL_PATH, encoding: "utf-8", timeout: 5000 }
-    );
-    expect(mockedExecFileSync).toHaveBeenCalledWith(
-      "git", ["worktree", "add", "-b", expectedBranch, expectedWorktreePath, BASE_BRANCH],
-      { cwd: LOCAL_PATH, encoding: "utf-8", timeout: 30000 }
-    );
-    expect(result).toEqual({ worktreePath: expectedWorktreePath, worktreeBranch: expectedBranch });
-  });
-
-  it("reuses existing worktree when git worktree list contains target path", async () => {
-    const porcelainOutput = `worktree /other/path\nHEAD abc123\nbranch refs/heads/main\n\nworktree ${expectedWorktreePath}\nHEAD def456\nbranch refs/heads/${expectedBranch}\n`;
-    mockedExecFileSync.mockReturnValue(porcelainOutput as never);
-
-    const result = await createWorktree(LOCAL_PATH, TASK_ID, BASE_BRANCH);
-
-    expect(mockedExecFileSync).toHaveBeenCalledWith(
-      "git", ["worktree", "list", "--porcelain"],
-      { cwd: LOCAL_PATH, encoding: "utf-8", timeout: 10000 }
-    );
-    // Should NOT call git branch --list or git worktree add (early return)
-    expect(findCall(["git", "branch", "--list", expectedBranch])).toBe(false);
-    expect(result).toEqual({ worktreePath: expectedWorktreePath, worktreeBranch: expectedBranch });
-  });
-
-  it("attaches existing branch without -b flag when branch already exists", async () => {
-    mockedExecFileSync.mockImplementation((cmd: string, args?: readonly string[]) => {
-      const argsArr = args as string[] | undefined;
-      if (argsArr?.[0] === "worktree" && argsArr?.[1] === "list") return "" as never;
-      if (argsArr?.[0] === "branch" && argsArr?.[1] === "--list") return `  task/${TASK_ID}` as never;
-      return "" as never;
-    });
-
-    const result = await createWorktree(LOCAL_PATH, TASK_ID, BASE_BRANCH);
-
-    expect(mockedExecFileSync).toHaveBeenCalledWith(
-      "git", ["worktree", "add", expectedWorktreePath, expectedBranch],
-      { cwd: LOCAL_PATH, encoding: "utf-8", timeout: 30000 }
-    );
-    // Should NOT have been called with -b
-    expect(findCall(["git", "worktree", "add", "-b", expectedBranch, expectedWorktreePath, BASE_BRANCH])).toBe(false);
-    expect(result).toEqual({ worktreePath: expectedWorktreePath, worktreeBranch: expectedBranch });
-  });
-
-  it("throws with descriptive message when git worktree add fails", async () => {
-    mockedExecFileSync.mockImplementation((cmd: string, args?: readonly string[]) => {
-      const argsArr = args as string[] | undefined;
-      if (argsArr?.[0] === "worktree" && argsArr?.[1] === "list") return "" as never;
-      if (argsArr?.[0] === "branch" && argsArr?.[1] === "--list") return "" as never;
-      throw new Error("fatal: 'main' is not a commit and a branch 'task/clxabc123def' cannot be created from it");
-    });
-
-    await expect(createWorktree(LOCAL_PATH, TASK_ID, BASE_BRANCH)).rejects.toThrow(
-      "fatal: 'main' is not a commit"
-    );
-  });
-});
-
-describe("removeWorktree", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockedExecFileSync.mockReturnValue("" as never);
-    mockedExistsSync.mockReturnValue(false);
-  });
-
-  it("removes worktree dir and deletes branch when both exist", async () => {
-    mockedExistsSync.mockReturnValue(true);
-    mockedExecFileSync.mockImplementation((cmd: string, args?: readonly string[]) => {
-      const argsArr = args as string[] | undefined;
-      if (argsArr?.[0] === "branch" && argsArr?.[1] === "--list") return `  task/${TASK_ID}` as never;
-      return "" as never;
-    });
-
-    await removeWorktree(LOCAL_PATH, TASK_ID);
-
-    expect(mockedExecFileSync).toHaveBeenCalledWith(
-      "git", ["worktree", "remove", expectedWorktreePath, "--force"],
-      { cwd: LOCAL_PATH, encoding: "utf-8", timeout: 30000 }
-    );
-    expect(mockedExecFileSync).toHaveBeenCalledWith(
-      "git", ["branch", "-D", expectedBranch],
-      { cwd: LOCAL_PATH, encoding: "utf-8", timeout: 5000 }
-    );
-  });
-
-  it("skips git worktree remove when dir does not exist but still deletes branch", async () => {
-    mockedExistsSync.mockReturnValue(false);
-    mockedExecFileSync.mockImplementation((cmd: string, args?: readonly string[]) => {
-      const argsArr = args as string[] | undefined;
-      if (argsArr?.[0] === "branch" && argsArr?.[1] === "--list") return `  task/${TASK_ID}` as never;
-      return "" as never;
-    });
-
-    await removeWorktree(LOCAL_PATH, TASK_ID);
-
-    expect(findCall(["git", "worktree", "remove", expectedWorktreePath, "--force"])).toBe(false);
-    expect(mockedExecFileSync).toHaveBeenCalledWith(
-      "git", ["branch", "-D", expectedBranch],
-      { cwd: LOCAL_PATH, encoding: "utf-8", timeout: 5000 }
-    );
-  });
-
-  it("skips git branch -D when branch does not exist", async () => {
-    mockedExistsSync.mockReturnValue(true);
-    mockedExecFileSync.mockReturnValue("" as never);
-
-    await removeWorktree(LOCAL_PATH, TASK_ID);
-
-    expect(mockedExecFileSync).toHaveBeenCalledWith(
-      "git", ["worktree", "remove", expectedWorktreePath, "--force"],
-      { cwd: LOCAL_PATH, encoding: "utf-8", timeout: 30000 }
-    );
-    expect(findCall(["git", "branch", "-D", expectedBranch])).toBe(false);
-  });
-
-  it("is a no-op when neither dir nor branch exist", async () => {
-    mockedExistsSync.mockReturnValue(false);
-    mockedExecFileSync.mockReturnValue("" as never);
-
-    await removeWorktree(LOCAL_PATH, TASK_ID);
-
-    expect(findCall(["git", "worktree", "remove", expectedWorktreePath, "--force"])).toBe(false);
-    expect(findCall(["git", "branch", "-D", expectedBranch])).toBe(false);
-    expect(findCall(["git", "branch", "--list", expectedBranch])).toBe(true);
-  });
-});