tower-studio 0.1.3 → 0.1.5

package/src/actions/__tests__/cli-profile-actions.test.ts

@@ -1,243 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-vi.mock("@/lib/db", () => ({
-  db: {
-    cliProfile: {
-      findFirst: vi.fn(),
-      update: vi.fn(),
-    },
-  },
-}));
-
-vi.mock("next/cache", () => ({ revalidatePath: vi.fn() }));
-
-import { db } from "@/lib/db";
-import { revalidatePath } from "next/cache";
-import {
-  getDefaultCliProfile,
-  updateCliProfile,
-} from "@/actions/cli-profile-actions";
-
-const mockDb = db as {
-  cliProfile: {
-    findFirst: ReturnType<typeof vi.fn>;
-    update: ReturnType<typeof vi.fn>;
-  };
-};
-
-const mockRevalidatePath = revalidatePath as ReturnType<typeof vi.fn>;
-
-const mockProfile = {
-  id: "profile1",
-  name: "Default",
-  command: "claude",
-  baseArgs: '["--model","claude-3-5-sonnet"]',
-  envVars: '{"MY_VAR":"value"}',
-  isDefault: true,
-};
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-describe("getDefaultCliProfile", () => {
-  it("returns shaped profile when found", async () => {
-    mockDb.cliProfile.findFirst.mockResolvedValue(mockProfile);
-
-    const result = await getDefaultCliProfile();
-
-    expect(mockDb.cliProfile.findFirst).toHaveBeenCalledWith({
-      where: { isDefault: true },
-    });
-    expect(result).toEqual({
-      id: "profile1",
-      name: "Default",
-      command: "claude",
-      baseArgs: '["--model","claude-3-5-sonnet"]',
-      envVars: '{"MY_VAR":"value"}',
-    });
-  });
-
-  it("returns null when no default profile exists", async () => {
-    mockDb.cliProfile.findFirst.mockResolvedValue(null);
-
-    const result = await getDefaultCliProfile();
-
-    expect(result).toBeNull();
-  });
-});
-
-describe("updateCliProfile — command validation", () => {
-  it("happy path: valid command 'claude' passes and calls update", async () => {
-    mockDb.cliProfile.update.mockResolvedValue(mockProfile);
-
-    await updateCliProfile("profile1", {
-      command: "claude",
-      baseArgs: '["--model","opus"]',
-      envVars: '{"FOO":"bar"}',
-    });
-
-    expect(mockDb.cliProfile.update).toHaveBeenCalledWith({
-      where: { id: "profile1" },
-      data: expect.objectContaining({ command: "claude" }),
-    });
-    expect(mockRevalidatePath).toHaveBeenCalledWith("/settings");
-  });
-
-  it("valid command 'claude-code' passes", async () => {
-    mockDb.cliProfile.update.mockResolvedValue({ ...mockProfile, command: "claude-code" });
-
-    await expect(
-      updateCliProfile("profile1", { command: "claude-code" })
-    ).resolves.not.toThrow();
-    expect(mockDb.cliProfile.update).toHaveBeenCalled();
-  });
-
-  it("command with path prefix: '/usr/bin/claude' basename is 'claude' — passes allowlist", async () => {
-    mockDb.cliProfile.update.mockResolvedValue(mockProfile);
-
-    await expect(
-      updateCliProfile("profile1", { command: "/usr/bin/claude" })
-    ).resolves.not.toThrow();
-    expect(mockDb.cliProfile.update).toHaveBeenCalled();
-  });
-
-  it("command 'bash' is not in allowlist — throws error", async () => {
-    await expect(
-      updateCliProfile("profile1", { command: "bash" })
-    ).rejects.toThrow(/claude.*claude-code|claude-code.*claude/);
-    expect(mockDb.cliProfile.update).not.toHaveBeenCalled();
-  });
-
-  it("command 'sh' is not in allowlist — throws error", async () => {
-    await expect(
-      updateCliProfile("profile1", { command: "sh" })
-    ).rejects.toThrow();
-    expect(mockDb.cliProfile.update).not.toHaveBeenCalled();
-  });
-});
-
-describe("updateCliProfile — baseArgs validation", () => {
-  it("valid baseArgs JSON array of strings passes", async () => {
-    mockDb.cliProfile.update.mockResolvedValue(mockProfile);
-
-    await expect(
-      updateCliProfile("profile1", { baseArgs: '["--model","opus"]' })
-    ).resolves.not.toThrow();
-    expect(mockDb.cliProfile.update).toHaveBeenCalled();
-  });
-
-  it("invalid JSON string throws about JSON array", async () => {
-    await expect(
-      updateCliProfile("profile1", { baseArgs: "not json" })
-    ).rejects.toThrow(/JSON 数组|JSON array/);
-    expect(mockDb.cliProfile.update).not.toHaveBeenCalled();
-  });
-
-  it("non-array JSON (string) throws about JSON array", async () => {
-    await expect(
-      updateCliProfile("profile1", { baseArgs: '"string"' })
-    ).rejects.toThrow(/JSON 数组|JSON array/);
-    expect(mockDb.cliProfile.update).not.toHaveBeenCalled();
-  });
-
-  it("baseArgs with shell metacharacter ';' throws about disallowed characters", async () => {
-    await expect(
-      updateCliProfile("profile1", { baseArgs: '["--flag;rm -rf"]' })
-    ).rejects.toThrow(/不允许的字符|disallowed/);
-    expect(mockDb.cliProfile.update).not.toHaveBeenCalled();
-  });
-
-  it("baseArgs with metacharacter '|' throws", async () => {
-    await expect(
-      updateCliProfile("profile1", { baseArgs: '["--flag|evil"]' })
-    ).rejects.toThrow();
-    expect(mockDb.cliProfile.update).not.toHaveBeenCalled();
-  });
-
-  it("baseArgs with metacharacter '`' throws", async () => {
-    await expect(
-      updateCliProfile("profile1", { baseArgs: '["--flag`cmd`"]' })
-    ).rejects.toThrow();
-    expect(mockDb.cliProfile.update).not.toHaveBeenCalled();
-  });
-
-  it("non-string element in baseArgs array throws", async () => {
-    await expect(
-      updateCliProfile("profile1", { baseArgs: "[123]" })
-    ).rejects.toThrow(/字符串|string/);
-    expect(mockDb.cliProfile.update).not.toHaveBeenCalled();
-  });
-});
-
-describe("updateCliProfile — envVars validation", () => {
-  it("valid envVars JSON object passes", async () => {
-    mockDb.cliProfile.update.mockResolvedValue(mockProfile);
-
-    await expect(
-      updateCliProfile("profile1", { envVars: '{"MY_VAR":"hello"}' })
-    ).resolves.not.toThrow();
-    expect(mockDb.cliProfile.update).toHaveBeenCalled();
-  });
-
-  it("invalid JSON throws about JSON object", async () => {
-    await expect(
-      updateCliProfile("profile1", { envVars: "not json" })
-    ).rejects.toThrow(/JSON 对象|JSON object/);
-    expect(mockDb.cliProfile.update).not.toHaveBeenCalled();
-  });
-
-  it("JSON array throws about JSON object", async () => {
-    await expect(
-      updateCliProfile("profile1", { envVars: "[]" })
-    ).rejects.toThrow(/JSON 对象|JSON object/);
-    expect(mockDb.cliProfile.update).not.toHaveBeenCalled();
-  });
-
-  it("blocked key PATH (uppercase) throws about system critical variable", async () => {
-    await expect(
-      updateCliProfile("profile1", { envVars: '{"PATH":"/evil"}' })
-    ).rejects.toThrow(/系统关键变量|PATH/);
-    expect(mockDb.cliProfile.update).not.toHaveBeenCalled();
-  });
-
-  it("blocked key NODE_OPTIONS throws", async () => {
-    await expect(
-      updateCliProfile("profile1", { envVars: '{"NODE_OPTIONS":"--inspect"}' })
-    ).rejects.toThrow(/系统关键变量|NODE_OPTIONS/);
-    expect(mockDb.cliProfile.update).not.toHaveBeenCalled();
-  });
-
-  it("blocked key LD_PRELOAD throws", async () => {
-    await expect(
-      updateCliProfile("profile1", { envVars: '{"LD_PRELOAD":"/evil.so"}' })
-    ).rejects.toThrow();
-    expect(mockDb.cliProfile.update).not.toHaveBeenCalled();
-  });
-
-  it("blocked key lowercase 'path' also throws (toUpperCase normalization)", async () => {
-    await expect(
-      updateCliProfile("profile1", { envVars: '{"path":"/evil"}' })
-    ).rejects.toThrow(/系统关键变量|path/);
-    expect(mockDb.cliProfile.update).not.toHaveBeenCalled();
-  });
-});
-
-describe("updateCliProfile — P2025 error handling", () => {
-  it("P2025 Prisma error returns user-friendly message '不存在'", async () => {
-    mockDb.cliProfile.update.mockRejectedValue({ code: "P2025" });
-
-    await expect(
-      updateCliProfile("profile1", { command: "claude" })
-    ).rejects.toThrow(/CLI Profile 不存在/);
-  });
-
-  it("non-P2025 errors are re-thrown as-is", async () => {
-    const originalError = new Error("Database connection failed");
-    mockDb.cliProfile.update.mockRejectedValue(originalError);
-
-    await expect(
-      updateCliProfile("profile1", { command: "claude" })
-    ).rejects.toThrow("Database connection failed");
-  });
-});

package/src/actions/__tests__/label-actions.test.ts

@@ -1,187 +0,0 @@
-import { vi, describe, it, expect, beforeEach } from "vitest";
-
-// Mock db before any imports
-vi.mock("@/lib/db", () => ({
-  db: {
-    label: {
-      findMany: vi.fn(),
-      findUnique: vi.fn(),
-      create: vi.fn(),
-      delete: vi.fn(),
-    },
-    taskLabel: {
-      findMany: vi.fn(),
-      deleteMany: vi.fn(),
-      createMany: vi.fn(),
-    },
-    $transaction: vi.fn(),
-  },
-}));
-
-vi.mock("next/cache", () => ({ revalidatePath: vi.fn() }));
-
-import { db } from "@/lib/db";
-import { revalidatePath } from "next/cache";
-import {
-  getLabelsForWorkspace,
-  createLabel,
-  deleteLabel,
-  setTaskLabels,
-  getTaskLabels,
-} from "@/actions/label-actions";
-
-const mockDb = db as {
-  label: {
-    findMany: ReturnType<typeof vi.fn>;
-    findUnique: ReturnType<typeof vi.fn>;
-    create: ReturnType<typeof vi.fn>;
-    delete: ReturnType<typeof vi.fn>;
-  };
-  taskLabel: {
-    findMany: ReturnType<typeof vi.fn>;
-    deleteMany: ReturnType<typeof vi.fn>;
-    createMany: ReturnType<typeof vi.fn>;
-  };
-  $transaction: ReturnType<typeof vi.fn>;
-};
-
-describe("label-actions", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe("getLabelsForWorkspace", () => {
-    it("queries with OR including builtin and workspace-specific labels", async () => {
-      const mockLabels = [
-        { id: "l1", name: "Bug", color: "#ff0000", isBuiltin: true },
-        { id: "l2", name: "Custom", color: "#00ff00", isBuiltin: false, workspaceId: "ws1" },
-      ];
-      mockDb.label.findMany.mockResolvedValue(mockLabels);
-
-      const result = await getLabelsForWorkspace("ws1");
-
-      expect(result).toEqual(mockLabels);
-      const callArgs = mockDb.label.findMany.mock.calls[0][0];
-      expect(callArgs.where.OR).toEqual(
-        expect.arrayContaining([
-          { isBuiltin: true },
-          { workspaceId: "ws1" },
-        ])
-      );
-    });
-  });
-
-  describe("createLabel", () => {
-    it("creates label with valid data and calls revalidatePath", async () => {
-      const mockLabel = { id: "l1", name: "Feature", color: "#0000ff", workspaceId: "ws1" };
-      mockDb.label.create.mockResolvedValue(mockLabel);
-
-      const result = await createLabel({ name: "Feature", color: "#0000ff", workspaceId: "ws1" });
-
-      expect(result).toEqual(mockLabel);
-      expect(mockDb.label.create).toHaveBeenCalledOnce();
-      expect(revalidatePath).toHaveBeenCalledWith("/workspaces");
-    });
-
-    it("throws Zod validation error for invalid hex color", async () => {
-      await expect(
-        createLabel({ name: "Label", color: "red", workspaceId: "ws1" })
-      ).rejects.toThrow();
-      expect(mockDb.label.create).not.toHaveBeenCalled();
-    });
-
-    it("throws Zod validation error for empty name", async () => {
-      await expect(
-        createLabel({ name: "", color: "#ffffff", workspaceId: "ws1" })
-      ).rejects.toThrow();
-      expect(mockDb.label.create).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("deleteLabel", () => {
-    it("deletes non-builtin label and calls revalidatePath", async () => {
-      const mockLabel = { id: "l1", name: "Custom", isBuiltin: false };
-      mockDb.label.findUnique.mockResolvedValue(mockLabel);
-      mockDb.label.delete.mockResolvedValue(mockLabel);
-
-      await deleteLabel("l1");
-
-      expect(mockDb.label.delete).toHaveBeenCalledWith({ where: { id: "l1" } });
-      expect(revalidatePath).toHaveBeenCalledWith("/workspaces");
-    });
-
-    it("throws 'Cannot delete builtin labels' when label is builtin", async () => {
-      const mockLabel = { id: "l1", name: "Bug", isBuiltin: true };
-      mockDb.label.findUnique.mockResolvedValue(mockLabel);
-
-      await expect(deleteLabel("l1")).rejects.toThrow("Cannot delete builtin labels");
-      expect(mockDb.label.delete).not.toHaveBeenCalled();
-    });
-
-    it("throws 'Label not found' when label does not exist", async () => {
-      mockDb.label.findUnique.mockResolvedValue(null);
-
-      await expect(deleteLabel("nonexistent")).rejects.toThrow("Label not found");
-      expect(mockDb.label.delete).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("setTaskLabels", () => {
-    it("calls deleteMany then createMany in transaction for non-empty label array", async () => {
-      const mockTx = {
-        taskLabel: {
-          deleteMany: vi.fn().mockResolvedValue({}),
-          createMany: vi.fn().mockResolvedValue({}),
-        },
-      };
-      mockDb.$transaction.mockImplementation(async (fn: (tx: typeof mockTx) => Promise<void>) => fn(mockTx));
-
-      await setTaskLabels("task1", ["l1", "l2"]);
-
-      expect(mockTx.taskLabel.deleteMany).toHaveBeenCalledWith({ where: { taskId: "task1" } });
-      expect(mockTx.taskLabel.createMany).toHaveBeenCalledWith({
-        data: [
-          { taskId: "task1", labelId: "l1" },
-          { taskId: "task1", labelId: "l2" },
-        ],
-      });
-      expect(revalidatePath).toHaveBeenCalledWith("/workspaces");
-    });
-
-    it("calls deleteMany but NOT createMany when labelIds is empty array", async () => {
-      const mockTx = {
-        taskLabel: {
-          deleteMany: vi.fn().mockResolvedValue({}),
-          createMany: vi.fn().mockResolvedValue({}),
-        },
-      };
-      mockDb.$transaction.mockImplementation(async (fn: (tx: typeof mockTx) => Promise<void>) => fn(mockTx));
-
-      await setTaskLabels("task1", []);
-
-      expect(mockTx.taskLabel.deleteMany).toHaveBeenCalledWith({ where: { taskId: "task1" } });
-      expect(mockTx.taskLabel.createMany).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("getTaskLabels", () => {
-    it("maps taskLabel results to label objects", async () => {
-      const mockTaskLabels = [
-        { taskId: "t1", labelId: "l1", label: { id: "l1", name: "Bug", color: "#ff0000", isBuiltin: true } },
-        { taskId: "t1", labelId: "l2", label: { id: "l2", name: "Custom", color: "#00ff00", isBuiltin: false } },
-      ];
-      mockDb.taskLabel.findMany.mockResolvedValue(mockTaskLabels);
-
-      const result = await getTaskLabels("t1");
-
-      expect(result).toEqual([
-        { id: "l1", name: "Bug", color: "#ff0000", isBuiltin: true },
-        { id: "l2", name: "Custom", color: "#00ff00", isBuiltin: false },
-      ]);
-      expect(mockDb.taskLabel.findMany).toHaveBeenCalledWith({
-        where: { taskId: "t1" },
-        include: { label: true },
-      });
-    });
-  });
-});

package/src/actions/__tests__/note-actions.test.ts

@@ -1,237 +0,0 @@
-import { vi, describe, it, expect, beforeEach } from "vitest";
-
-// Mock db before any imports
-vi.mock("@/lib/db", () => ({
-  db: {
-    projectNote: {
-      create: vi.fn(),
-      update: vi.fn(),
-      delete: vi.fn(),
-      findUnique: vi.fn(),
-      findMany: vi.fn(),
-    },
-  },
-}));
-
-vi.mock("next/cache", () => ({ revalidatePath: vi.fn() }));
-
-vi.mock("@/lib/fts", () => ({
-  syncNoteToFts: vi.fn(),
-  deleteNoteFromFts: vi.fn(),
-}));
-
-import { db } from "@/lib/db";
-import { revalidatePath } from "next/cache";
-import { syncNoteToFts, deleteNoteFromFts } from "@/lib/fts";
-import {
-  createNote,
-  updateNote,
-  deleteNote,
-  getNoteById,
-  getProjectNotes,
-  getTaskNotes,
-} from "@/actions/note-actions";
-
-const mockDb = db as {
-  projectNote: {
-    create: ReturnType<typeof vi.fn>;
-    update: ReturnType<typeof vi.fn>;
-    delete: ReturnType<typeof vi.fn>;
-    findUnique: ReturnType<typeof vi.fn>;
-    findMany: ReturnType<typeof vi.fn>;
-  };
-};
-
-const mockSyncNoteToFts = syncNoteToFts as ReturnType<typeof vi.fn>;
-const mockDeleteNoteFromFts = deleteNoteFromFts as ReturnType<typeof vi.fn>;
-
-describe("note-actions", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe("createNote", () => {
-    it("creates note with correct data and calls syncNoteToFts after create", async () => {
-      const mockNote = {
-        id: "note1",
-        title: "My Note",
-        content: "Content",
-        category: "备忘",
-        projectId: "proj1",
-        taskId: null,
-      };
-      mockDb.projectNote.create.mockResolvedValue(mockNote);
-      mockSyncNoteToFts.mockResolvedValue(undefined);
-
-      const result = await createNote({ title: "My Note", content: "Content", projectId: "proj1" });
-
-      expect(result).toEqual(mockNote);
-      expect(mockDb.projectNote.create).toHaveBeenCalledOnce();
-      expect(mockSyncNoteToFts).toHaveBeenCalledWith(db, {
-        id: mockNote.id,
-        title: mockNote.title,
-        content: mockNote.content,
-      });
-      expect(revalidatePath).toHaveBeenCalledWith("/workspace");
-    });
-
-    it("uses default category '备忘' when category not provided", async () => {
-      const mockNote = { id: "note1", title: "Test", content: "", category: "备忘", projectId: "p1", taskId: null };
-      mockDb.projectNote.create.mockResolvedValue(mockNote);
-      mockSyncNoteToFts.mockResolvedValue(undefined);
-
-      await createNote({ title: "Test", content: "", projectId: "p1" });
-
-      const callArgs = mockDb.projectNote.create.mock.calls[0][0];
-      expect(callArgs.data.category).toBe("备忘");
-    });
-
-    it("uses provided category when given", async () => {
-      const mockNote = { id: "note1", title: "Test", content: "", category: "账号", projectId: "p1", taskId: null };
-      mockDb.projectNote.create.mockResolvedValue(mockNote);
-      mockSyncNoteToFts.mockResolvedValue(undefined);
-
-      await createNote({ title: "Test", content: "", projectId: "p1", category: "账号" });
-
-      const callArgs = mockDb.projectNote.create.mock.calls[0][0];
-      expect(callArgs.data.category).toBe("账号");
-    });
-
-    it("throws Zod validation error when title is empty", async () => {
-      await expect(
-        createNote({ title: "", content: "Content", projectId: "p1" })
-      ).rejects.toThrow();
-      expect(mockDb.projectNote.create).not.toHaveBeenCalled();
-    });
-
-    it("throws Zod validation error when title exceeds 200 characters", async () => {
-      const longTitle = "a".repeat(201);
-      await expect(
-        createNote({ title: longTitle, content: "Content", projectId: "p1" })
-      ).rejects.toThrow();
-      expect(mockDb.projectNote.create).not.toHaveBeenCalled();
-    });
-
-    it("calls syncNoteToFts with correct shape { id, title, content }", async () => {
-      const mockNote = { id: "note-abc", title: "Note Title", content: "Note content", category: "备忘", projectId: "p1", taskId: null };
-      mockDb.projectNote.create.mockResolvedValue(mockNote);
-      mockSyncNoteToFts.mockResolvedValue(undefined);
-
-      await createNote({ title: "Note Title", content: "Note content", projectId: "p1" });
-
-      expect(mockSyncNoteToFts).toHaveBeenCalledWith(
-        db,
-        { id: "note-abc", title: "Note Title", content: "Note content" }
-      );
-    });
-  });
-
-  describe("updateNote", () => {
-    it("updates note and calls syncNoteToFts with updated data", async () => {
-      const mockNote = { id: "note1", title: "Updated Title", content: "Updated Content", category: "备忘", projectId: "p1", taskId: null };
-      mockDb.projectNote.update.mockResolvedValue(mockNote);
-      mockSyncNoteToFts.mockResolvedValue(undefined);
-
-      const result = await updateNote("note1", { title: "Updated Title", content: "Updated Content" });
-
-      expect(result).toEqual(mockNote);
-      expect(mockDb.projectNote.update).toHaveBeenCalledWith({
-        where: { id: "note1" },
-        data: expect.objectContaining({ title: "Updated Title", content: "Updated Content" }),
-      });
-      expect(mockSyncNoteToFts).toHaveBeenCalledWith(db, {
-        id: mockNote.id,
-        title: mockNote.title,
-        content: mockNote.content,
-      });
-      expect(revalidatePath).toHaveBeenCalledWith("/workspace");
-    });
-  });
-
-  describe("deleteNote", () => {
-    it("calls deleteNoteFromFts BEFORE db.projectNote.delete", async () => {
-      const callOrder: string[] = [];
-      mockDeleteNoteFromFts.mockImplementation(async () => { callOrder.push("deleteNoteFromFts"); });
-      mockDb.projectNote.delete.mockImplementation(async () => { callOrder.push("db.delete"); });
-
-      await deleteNote("note1");
-
-      expect(callOrder).toEqual(["deleteNoteFromFts", "db.delete"]);
-      expect(mockDeleteNoteFromFts).toHaveBeenCalledWith(db, "note1");
-      expect(mockDb.projectNote.delete).toHaveBeenCalledWith({ where: { id: "note1" } });
-    });
-
-    it("calls revalidatePath after deletion", async () => {
-      mockDeleteNoteFromFts.mockResolvedValue(undefined);
-      mockDb.projectNote.delete.mockResolvedValue({});
-
-      await deleteNote("note1");
-
-      expect(revalidatePath).toHaveBeenCalledWith("/workspace");
-    });
-  });
-
-  describe("getNoteById", () => {
-    it("calls findUnique with correct id", async () => {
-      const mockNote = { id: "note1", title: "Note", content: "", category: "备忘", projectId: "p1", taskId: null };
-      mockDb.projectNote.findUnique.mockResolvedValue(mockNote);
-
-      const result = await getNoteById("note1");
-
-      expect(result).toEqual(mockNote);
-      expect(mockDb.projectNote.findUnique).toHaveBeenCalledWith({ where: { id: "note1" } });
-    });
-
-    it("returns null when note not found", async () => {
-      mockDb.projectNote.findUnique.mockResolvedValue(null);
-
-      const result = await getNoteById("nonexistent");
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("getProjectNotes", () => {
-    it("queries with projectId filter and taskId: null", async () => {
-      const mockNotes = [{ id: "n1", title: "Note 1", projectId: "p1", taskId: null }];
-      mockDb.projectNote.findMany.mockResolvedValue(mockNotes);
-
-      const result = await getProjectNotes("p1");
-
-      expect(result).toEqual(mockNotes);
-      const callArgs = mockDb.projectNote.findMany.mock.calls[0][0];
-      expect(callArgs.where.projectId).toBe("p1");
-      expect(callArgs.where.taskId).toBeNull();
-    });
-
-    it("includes category filter when category option is provided", async () => {
-      mockDb.projectNote.findMany.mockResolvedValue([]);
-
-      await getProjectNotes("p1", { category: "账号" });
-
-      const callArgs = mockDb.projectNote.findMany.mock.calls[0][0];
-      expect(callArgs.where.category).toBe("账号");
-    });
-
-    it("does NOT include category in where clause when category is not provided", async () => {
-      mockDb.projectNote.findMany.mockResolvedValue([]);
-
-      await getProjectNotes("p1");
-
-      const callArgs = mockDb.projectNote.findMany.mock.calls[0][0];
-      expect(callArgs.where.category).toBeUndefined();
-    });
-  });
-
-  describe("getTaskNotes", () => {
-    it("queries with taskId filter", async () => {
-      const mockNotes = [{ id: "n1", title: "Task Note", projectId: "p1", taskId: "t1" }];
-      mockDb.projectNote.findMany.mockResolvedValue(mockNotes);
-
-      const result = await getTaskNotes("t1");
-
-      expect(result).toEqual(mockNotes);
-      const callArgs = mockDb.projectNote.findMany.mock.calls[0][0];
-      expect(callArgs.where.taskId).toBe("t1");
-    });
-  });
-});