tower-studio 0.1.2 → 0.1.3

package/.next/standalone/tower/tests/unit/mcp/identify-project.test.ts

@@ -1,217 +0,0 @@
-// @vitest-environment node
-import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import { PrismaClient } from "@prisma/client";
-import { scoreProject, knowledgeTools } from "@/mcp/tools/knowledge-tools";
-
-const testDb = new PrismaClient({
-  datasources: {
-    db: { url: process.env.DATABASE_URL ?? "file:./prisma/dev.db" },
-  },
-});
-
-let workspace1Id: string;
-let workspace2Id: string;
-let alphaProjectId: string;
-let betaProjectId: string;
-let gammaProjectId: string;
-
-beforeAll(async () => {
-  await testDb.$connect();
-
-  // Create 2 test workspaces
-  const workspace1 = await testDb.workspace.create({
-    data: { name: "Knowledge Test Workspace 1" },
-  });
-  workspace1Id = workspace1.id;
-
-  const workspace2 = await testDb.workspace.create({
-    data: { name: "Knowledge Test Workspace 2" },
-  });
-  workspace2Id = workspace2.id;
-
-  // Create projects: Alpha (alias "alp", description "first project") in workspace 1
-  const alpha = await testDb.project.create({
-    data: {
-      name: "Alpha",
-      alias: "alp",
-      description: "first project",
-      workspaceId: workspace1Id,
-    },
-  });
-  alphaProjectId = alpha.id;
-
-  // Beta (alias "bet", description "second alpha project") in workspace 1
-  const beta = await testDb.project.create({
-    data: {
-      name: "Beta",
-      alias: "bet",
-      description: "second alpha project",
-      workspaceId: workspace1Id,
-    },
-  });
-  betaProjectId = beta.id;
-
-  // Gamma (no alias, description "third project") in workspace 2
-  const gamma = await testDb.project.create({
-    data: {
-      name: "Gamma",
-      alias: null,
-      description: "third project",
-      workspaceId: workspace2Id,
-    },
-  });
-  gammaProjectId = gamma.id;
-});
-
-afterAll(async () => {
-  // Cascade delete via workspace
-  await testDb.workspace.delete({ where: { id: workspace1Id } });
-  await testDb.workspace.delete({ where: { id: workspace2Id } });
-  await testDb.$disconnect();
-});
-
-// --- scoreProject unit tests ---
-
-describe("scoreProject", () => {
-  it("returns 1.0 for exact name match (case-insensitive)", () => {
-    const score = scoreProject({ name: "MyProject", alias: null, description: null }, "myproject");
-    expect(score).toBe(1.0);
-  });
-
-  it("returns 0.9 for name starts-with match", () => {
-    const score = scoreProject({ name: "MyProject", alias: null, description: null }, "my");
-    expect(score).toBe(0.9);
-  });
-
-  it("returns 0.75 for name contains match", () => {
-    const score = scoreProject({ name: "MyProject", alias: null, description: null }, "proj");
-    expect(score).toBe(0.75);
-  });
-
-  it("returns 0.85 for exact alias match", () => {
-    const score = scoreProject({ name: "SomeProject", alias: "mp", description: null }, "mp");
-    expect(score).toBe(0.85);
-  });
-
-  it("returns 0.75 for alias starts-with match", () => {
-    const score = scoreProject({ name: "SomeProject", alias: "mp", description: null }, "m");
-    expect(score).toBe(0.75);
-  });
-
-  it("returns 0.6 for alias contains match", () => {
-    const score = scoreProject({ name: "SomeProject", alias: "myp", description: null }, "yp");
-    expect(score).toBe(0.6);
-  });
-
-  it("returns 0.4 for description contains match", () => {
-    const score = scoreProject({ name: "SomeProject", alias: null, description: "a cool project" }, "cool");
-    expect(score).toBe(0.4);
-  });
-
-  it("returns 0.0 for no match", () => {
-    const score = scoreProject({ name: "X", alias: null, description: null }, "zzz");
-    expect(score).toBe(0.0);
-  });
-
-  it("name match (0.75) ranks higher than alias match (0.6) for same query", () => {
-    // Name contains "yp" (0.75) vs alias contains "yp" (0.6)
-    const nameContainsScore = scoreProject({ name: "MyProject", alias: "xyz", description: null }, "yp");
-    const aliasContainsScore = scoreProject({ name: "SomeProject", alias: "myp", description: null }, "yp");
-    // nameContains = 0.75, aliasContains = 0.6
-    expect(nameContainsScore).toBeGreaterThan(aliasContainsScore);
-  });
-});
-
-// --- identify_project handler integration tests ---
-
-describe("identify_project handler", () => {
-  it("query 'alpha' returns Alpha first (name match) and Beta second (description match)", async () => {
-    const handler = knowledgeTools.identify_project.handler;
-    const results = await handler({ query: "alpha" });
-
-    expect(results.length).toBeGreaterThanOrEqual(2);
-    // Alpha should be first (name match = higher confidence)
-    const alphaResult = results.find((r) => r.projectId === alphaProjectId);
-    const betaResult = results.find((r) => r.projectId === betaProjectId);
-    expect(alphaResult).toBeDefined();
-    expect(betaResult).toBeDefined();
-    expect(alphaResult!.confidence).toBeGreaterThan(betaResult!.confidence);
-    // Alpha should come before Beta in sorted results
-    const alphaIndex = results.indexOf(alphaResult!);
-    const betaIndex = results.indexOf(betaResult!);
-    expect(alphaIndex).toBeLessThan(betaIndex);
-  });
-
-  it("query 'alp' returns Alpha (alias exact or name starts-with, whichever is higher)", async () => {
-    const handler = knowledgeTools.identify_project.handler;
-    const results = await handler({ query: "alp" });
-
-    expect(results.length).toBeGreaterThan(0);
-    expect(results[0].projectId).toBe(alphaProjectId);
-    // Alpha: name starts-with = 0.9, alias exact = 0.85 → max = 0.9
-    expect(results[0].confidence).toBe(0.9);
-  });
-
-  it("query 'zzzzz' returns empty array (below confidence threshold)", async () => {
-    const handler = knowledgeTools.identify_project.handler;
-    const results = await handler({ query: "zzzzz" });
-    expect(results).toEqual([]);
-  });
-
-  it("with workspaceId for workspace2, query 'project' returns only Gamma", async () => {
-    const handler = knowledgeTools.identify_project.handler;
-    const results = await handler({ query: "project", workspaceId: workspace2Id });
-
-    expect(results.length).toBeGreaterThan(0);
-    const ids = results.map((r) => r.projectId);
-    expect(ids).toContain(gammaProjectId);
-    expect(ids).not.toContain(alphaProjectId);
-    expect(ids).not.toContain(betaProjectId);
-  });
-
-  it("with no workspaceId searches all workspaces", async () => {
-    const handler = knowledgeTools.identify_project.handler;
-    // "project" matches descriptions of Alpha, Beta, Gamma
-    const results = await handler({ query: "project" });
-
-    const ids = results.map((r) => r.projectId);
-    expect(ids).toContain(gammaProjectId);
-    // Beta also has "project" in desc: "second alpha project"
-    expect(ids).toContain(betaProjectId);
-  });
-
-  it("results contain required fields", async () => {
-    const handler = knowledgeTools.identify_project.handler;
-    const results = await handler({ query: "alpha" });
-
-    expect(results.length).toBeGreaterThan(0);
-    const result = results[0];
-    expect(result).toHaveProperty("projectId");
-    expect(result).toHaveProperty("name");
-    expect(result).toHaveProperty("alias");
-    expect(result).toHaveProperty("workspaceId");
-    expect(result).toHaveProperty("workspaceName");
-    expect(result).toHaveProperty("confidence");
-    expect(typeof result.confidence).toBe("number");
-    expect(result.confidence).toBeGreaterThanOrEqual(0);
-    expect(result.confidence).toBeLessThanOrEqual(1);
-  });
-
-  it("results are sorted by confidence DESC", async () => {
-    const handler = knowledgeTools.identify_project.handler;
-    const results = await handler({ query: "alpha" });
-
-    for (let i = 1; i < results.length; i++) {
-      expect(results[i - 1].confidence).toBeGreaterThanOrEqual(results[i].confidence);
-    }
-  });
-
-  it("filters out results below 0.3 confidence", async () => {
-    const handler = knowledgeTools.identify_project.handler;
-    const results = await handler({ query: "alpha" });
-
-    for (const result of results) {
-      expect(result.confidence).toBeGreaterThanOrEqual(0.3);
-    }
-  });
-});

package/.next/standalone/tower/tests/unit/mcp/manage-assets.test.ts

@@ -1,199 +0,0 @@
-// @vitest-environment node
-import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
-import { PrismaClient } from "@prisma/client";
-
-// Mock node:fs before importing the module under test
-vi.mock("node:fs", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("node:fs")>();
-  return {
-    ...actual,
-    renameSync: vi.fn(),
-    copyFileSync: vi.fn(),
-    unlinkSync: vi.fn(),
-    statSync: vi.fn(() => ({ size: 1234 })),
-    mkdirSync: vi.fn(),
-  };
-});
-
-const testDb = new PrismaClient({
-  datasources: {
-    db: { url: process.env.DATABASE_URL ?? "file:./prisma/dev.db" },
-  },
-});
-
-let testWorkspaceId: string;
-let testProjectId: string;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let manageAssetsHandler: (args: any) => Promise<unknown>;
-
-beforeAll(async () => {
-  await testDb.$connect();
-
-  const workspace = await testDb.workspace.create({
-    data: { name: "Manage Assets MCP Test Workspace" },
-  });
-  testWorkspaceId = workspace.id;
-
-  const project = await testDb.project.create({
-    data: {
-      name: "Manage Assets MCP Test Project",
-      workspaceId: testWorkspaceId,
-    },
-  });
-  testProjectId = project.id;
-
-  const mod = await import("@/mcp/tools/note-asset-tools");
-  manageAssetsHandler = mod.noteAssetTools.manage_assets.handler;
-});
-
-afterAll(async () => {
-  // Clean up test assets from DB
-  await testDb.projectAsset.deleteMany({ where: { projectId: testProjectId } });
-  await testDb.workspace.delete({ where: { id: testWorkspaceId } });
-  await testDb.$disconnect();
-});
-
-describe("manage_assets action=add", () => {
-  it("calls renameSync with correct src/dest and creates DB record", async () => {
-    const { renameSync } = await import("node:fs");
-    vi.mocked(renameSync).mockClear();
-
-    const result = await manageAssetsHandler({
-      action: "add",
-      projectId: testProjectId,
-      sourcePath: "/tmp/myfile.pdf",
-    }) as { id: string; filename: string; path: string; size: number; projectId: string };
-
-    expect(renameSync).toHaveBeenCalledOnce();
-    const [src, dest] = vi.mocked(renameSync).mock.calls[0];
-    expect(src).toBe("/tmp/myfile.pdf");
-    expect(String(dest)).toContain("myfile.pdf");
-    expect(String(dest)).toContain(testProjectId);
-
-    expect(result.filename).toBe("myfile.pdf");
-    expect(result.size).toBe(1234);
-    expect(result.projectId).toBe(testProjectId);
-    expect(result.id).toBeDefined();
-
-    // Cleanup
-    await testDb.projectAsset.delete({ where: { id: result.id } });
-  });
-
-  it("uses custom filename when provided", async () => {
-    const { renameSync } = await import("node:fs");
-    vi.mocked(renameSync).mockClear();
-
-    const result = await manageAssetsHandler({
-      action: "add",
-      projectId: testProjectId,
-      sourcePath: "/tmp/something.txt",
-      filename: "custom-name.txt",
-    }) as { id: string; filename: string; path: string };
-
-    const [, dest] = vi.mocked(renameSync).mock.calls[0];
-    expect(String(dest)).toContain("custom-name.txt");
-    expect(result.filename).toBe("custom-name.txt");
-
-    // Cleanup
-    await testDb.projectAsset.delete({ where: { id: result.id } });
-  });
-
-  it("falls back to copyFileSync + unlinkSync on EXDEV error", async () => {
-    const { renameSync, copyFileSync, unlinkSync } = await import("node:fs");
-    vi.mocked(renameSync).mockImplementationOnce(() => {
-      const err = new Error("EXDEV cross-device link") as NodeJS.ErrnoException;
-      err.code = "EXDEV";
-      throw err;
-    });
-    vi.mocked(copyFileSync).mockClear();
-    vi.mocked(unlinkSync).mockClear();
-
-    const result = await manageAssetsHandler({
-      action: "add",
-      projectId: testProjectId,
-      sourcePath: "/tmp/crossdevice.bin",
-    }) as { id: string; filename: string };
-
-    expect(copyFileSync).toHaveBeenCalledOnce();
-    expect(unlinkSync).toHaveBeenCalledOnce();
-    expect(result.filename).toBe("crossdevice.bin");
-
-    // Cleanup
-    await testDb.projectAsset.delete({ where: { id: result.id } });
-  });
-
-  it("throws when projectId is missing", async () => {
-    await expect(
-      manageAssetsHandler({ action: "add", sourcePath: "/tmp/file.txt" })
-    ).rejects.toThrow("projectId and sourcePath required");
-  });
-
-  it("throws when sourcePath is missing", async () => {
-    await expect(
-      manageAssetsHandler({ action: "add", projectId: testProjectId })
-    ).rejects.toThrow("projectId and sourcePath required");
-  });
-});
-
-describe("manage_assets action=list", () => {
-  it("returns assets for a project ordered by createdAt desc", async () => {
-    // Create two assets with a small delay to ensure distinct createdAt timestamps
-    const a1 = await testDb.projectAsset.create({
-      data: { filename: "first.txt", path: "/data/assets/p/first.txt", size: 100, projectId: testProjectId },
-    });
-    await new Promise((r) => setTimeout(r, 10));
-    const a2 = await testDb.projectAsset.create({
-      data: { filename: "second.txt", path: "/data/assets/p/second.txt", size: 200, projectId: testProjectId },
-    });
-
-    const results = await manageAssetsHandler({
-      action: "list",
-      projectId: testProjectId,
-    }) as Array<{ id: string; filename: string }>;
-
-    expect(results.length).toBeGreaterThanOrEqual(2);
-    // Most recently created should be first
-    expect(results[0].filename).toBe("second.txt");
-
-    // Cleanup
-    await testDb.projectAsset.deleteMany({ where: { id: { in: [a1.id, a2.id] } } });
-  });
-});
-
-describe("manage_assets action=get", () => {
-  it("returns a single asset by ID", async () => {
-    const asset = await testDb.projectAsset.create({
-      data: { filename: "getme.txt", path: "/data/assets/p/getme.txt", size: 42, projectId: testProjectId },
-    });
-
-    const result = await manageAssetsHandler({
-      action: "get",
-      assetId: asset.id,
-    }) as { id: string; filename: string };
-
-    expect(result.id).toBe(asset.id);
-    expect(result.filename).toBe("getme.txt");
-
-    // Cleanup
-    await testDb.projectAsset.delete({ where: { id: asset.id } });
-  });
-});
-
-describe("manage_assets action=delete", () => {
-  it("deletes the DB record", async () => {
-    const asset = await testDb.projectAsset.create({
-      data: { filename: "todelete.txt", path: "/data/assets/p/todelete.txt", size: 10, projectId: testProjectId },
-    });
-
-    const result = await manageAssetsHandler({
-      action: "delete",
-      assetId: asset.id,
-    }) as { deleted: boolean; assetId: string };
-
-    expect(result.deleted).toBe(true);
-    expect(result.assetId).toBe(asset.id);
-
-    const found = await testDb.projectAsset.findUnique({ where: { id: asset.id } });
-    expect(found).toBeNull();
-  });
-});