tower-studio 0.1.1 → 0.1.2

package/.next/standalone/tower/tests/unit/actions/search-actions.test.ts

@@ -0,0 +1,358 @@
+// @vitest-environment node
+import { describe, it, expect, beforeAll, afterAll, afterEach } from "vitest";
+import { PrismaClient } from "@prisma/client";
+import { syncNoteToFts } from "@/lib/fts";
+import type { SearchCategory, SearchResult } from "@/lib/search";
+
+const testDb = new PrismaClient({
+  datasources: {
+    db: { url: process.env.DATABASE_URL ?? "file:./prisma/dev.db" },
+  },
+});
+
+let testWorkspaceId: string;
+let testProjectId: string;
+
+let globalSearchFn: (query: string, category?: SearchCategory) => Promise<SearchResult[]>;
+
+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 Actions Test WS" },
+  });
+  testWorkspaceId = workspace.id;
+
+  const project = await testDb.project.create({
+    data: {
+      name: "Search Actions Test Proj",
+      workspaceId: testWorkspaceId,
+    },
+  });
+  testProjectId = project.id;
+
+  // Dynamic import: search-actions.ts uses "use server" directive
+  const mod = await import("@/actions/search-actions");
+  globalSearchFn = mod.globalSearch;
+});
+
+afterAll(async () => {
+  // Delete test workspace (cascade to projects and notes)
+  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("globalSearch - note category", () => {
+  it("returns empty array for empty query", async () => {
+    const results = await globalSearchFn("", "note");
+    expect(results).toEqual([]);
+  });
+
+  it("returns notes with matching title via FTS5", async () => {
+    const note = await testDb.projectNote.create({
+      data: {
+        title: "API Configuration Guide",
+        content: "This note covers API setup details",
+        projectId: testProjectId,
+      },
+    });
+    await syncNoteToFts(testDb, { id: note.id, title: note.title, content: note.content });
+
+    const results = await globalSearchFn("API", "note");
+    expect(results.length).toBeGreaterThan(0);
+    const found = results.find((r) => r.id === note.id);
+    expect(found).toBeDefined();
+    expect(found?.type).toBe("note");
+  });
+
+  it("returns notes with matching content via FTS5", async () => {
+    const note = await testDb.projectNote.create({
+      data: {
+        title: "General Notes",
+        content: "Contains important config settings",
+        projectId: testProjectId,
+      },
+    });
+    await syncNoteToFts(testDb, { id: note.id, title: note.title, content: note.content });
+
+    const results = await globalSearchFn("config", "note");
+    expect(results.length).toBeGreaterThan(0);
+    const found = results.find((r) => r.id === note.id);
+    expect(found).toBeDefined();
+  });
+
+  it("uses LIKE fallback for short query (< 3 chars)", async () => {
+    const note = await testDb.projectNote.create({
+      data: {
+        title: "AB Test Note",
+        content: "some content",
+        projectId: testProjectId,
+      },
+    });
+    // Note NOT synced to FTS — LIKE fallback queries the ProjectNote table directly
+
+    const results = await globalSearchFn("ab", "note");
+    expect(results.length).toBeGreaterThan(0);
+    const found = results.find((r) => r.id === note.id);
+    expect(found).toBeDefined();
+  });
+
+  it("does not throw on malformed FTS5 query (unmatched quote) — falls back to LIKE", async () => {
+    const note = await testDb.projectNote.create({
+      data: {
+        title: "unmatched quote test note",
+        content: "this has unmatched content",
+        projectId: testProjectId,
+      },
+    });
+    // Note NOT synced to FTS — LIKE fallback should still find it
+
+    // '"unmatched' has an unmatched double quote — would crash FTS5 MATCH
+    await expect(globalSearchFn('"unmatched', "note")).resolves.not.toThrow();
+    const results = await globalSearchFn('"unmatched', "note");
+    // LIKE fallback should find the note with "unmatched" in title/content
+    expect(Array.isArray(results)).toBe(true);
+  });
+
+  it("note search result has navigateTo matching /workspaces/{wsId}?projectId={pId}", async () => {
+    const note = await testDb.projectNote.create({
+      data: {
+        title: "Navigation Test Note",
+        content: "navigation content",
+        projectId: testProjectId,
+      },
+    });
+    await syncNoteToFts(testDb, { id: note.id, title: note.title, content: note.content });
+
+    const results = await globalSearchFn("Navigation", "note");
+    expect(results.length).toBeGreaterThan(0);
+    const found = results.find((r) => r.id === note.id);
+    expect(found?.navigateTo).toMatch(
+      new RegExp(`/workspaces/${testWorkspaceId}/notes\\?projectId=${testProjectId}`)
+    );
+  });
+});
+
+describe("globalSearch - note category - snippet", () => {
+  it("note result has snippet with first 80 chars of content", async () => {
+    const longContent = "A".repeat(120);
+    const note = await testDb.projectNote.create({
+      data: {
+        title: "Snippet Test Note",
+        content: longContent,
+        projectId: testProjectId,
+      },
+    });
+    await syncNoteToFts(testDb, { id: note.id, title: note.title, content: note.content });
+
+    const results = await globalSearchFn("Snippet Test", "note");
+    const found = results.find((r) => r.id === note.id);
+    expect(found).toBeDefined();
+    expect(found?.snippet).toBe("A".repeat(80));
+  });
+
+  it("note result with empty content has undefined snippet", async () => {
+    const note = await testDb.projectNote.create({
+      data: {
+        title: "Empty Content Snippet Note",
+        content: "",
+        projectId: testProjectId,
+      },
+    });
+    // Sync to FTS so the note is found by title match
+    await syncNoteToFts(testDb, { id: note.id, title: note.title, content: note.content });
+    const results = await globalSearchFn("Empty Content Snippet", "note");
+    const found = results.find((r) => r.id === note.id);
+    expect(found).toBeDefined();
+    expect(found?.snippet).toBeUndefined();
+  });
+});
+
+describe("globalSearch - asset category - snippet", () => {
+  it("asset result has snippet equal to description", async () => {
+    await testDb.projectAsset.create({
+      data: {
+        filename: "snippet-test.pdf",
+        path: "/data/assets/snippet-test.pdf",
+        size: 4096,
+        mimeType: "application/pdf",
+        description: "This is a detailed description of the test PDF file",
+        projectId: testProjectId,
+      },
+    });
+
+    const results = await globalSearchFn("snippet-test", "asset");
+    const found = results.find((r) => r.title === "snippet-test.pdf");
+    expect(found).toBeDefined();
+    expect(found?.snippet).toBe("This is a detailed description of the test PDF file");
+  });
+
+  it("asset result with empty description has undefined snippet", async () => {
+    await testDb.projectAsset.create({
+      data: {
+        filename: "no-desc-asset.txt",
+        path: "/data/assets/no-desc-asset.txt",
+        size: 128,
+        mimeType: "text/plain",
+        description: "",
+        projectId: testProjectId,
+      },
+    });
+
+    const results = await globalSearchFn("no-desc-asset", "asset");
+    const found = results.find((r) => r.title === "no-desc-asset.txt");
+    expect(found).toBeDefined();
+    expect(found?.snippet).toBeUndefined();
+  });
+});
+
+describe("globalSearch - asset category", () => {
+  it("returns assets with matching filename", async () => {
+    await testDb.projectAsset.create({
+      data: {
+        filename: "readme.md",
+        path: "/data/assets/readme.md",
+        size: 1024,
+        mimeType: "text/markdown",
+        description: "project documentation",
+        projectId: testProjectId,
+      },
+    });
+
+    const results = await globalSearchFn("readme", "asset");
+    expect(results.length).toBeGreaterThan(0);
+    const found = results.find((r) => r.title === "readme.md");
+    expect(found).toBeDefined();
+    expect(found?.type).toBe("asset");
+  });
+
+  it("returns assets with matching description", async () => {
+    await testDb.projectAsset.create({
+      data: {
+        filename: "config.yaml",
+        path: "/data/assets/config.yaml",
+        size: 512,
+        mimeType: "text/yaml",
+        description: "deployment configuration file",
+        projectId: testProjectId,
+      },
+    });
+
+    const results = await globalSearchFn("deployment", "asset");
+    expect(results.length).toBeGreaterThan(0);
+    const found = results.find((r) => r.title === "config.yaml");
+    expect(found).toBeDefined();
+  });
+
+  it("asset search result has navigateTo matching /workspaces/{wsId}?projectId={pId}", async () => {
+    await testDb.projectAsset.create({
+      data: {
+        filename: "nav-asset.png",
+        path: "/data/assets/nav-asset.png",
+        size: 2048,
+        mimeType: "image/png",
+        description: "navigation test asset",
+        projectId: testProjectId,
+      },
+    });
+
+    const results = await globalSearchFn("nav-asset", "asset");
+    expect(results.length).toBeGreaterThan(0);
+    const found = results.find((r) => r.title === "nav-asset.png");
+    expect(found?.navigateTo).toMatch(
+      new RegExp(`/workspaces/${testWorkspaceId}/assets\\?projectId=${testProjectId}`)
+    );
+  });
+});
+
+describe("globalSearch - all category", () => {
+  it("returns results from multiple types", async () => {
+    // Create a task with "testall" in title
+    await testDb.task.create({
+      data: {
+        title: "testall task item",
+        projectId: testProjectId,
+      },
+    });
+
+    // Create a note with "testall" in title and sync to FTS
+    const note = await testDb.projectNote.create({
+      data: {
+        title: "testall note item",
+        content: "testall content",
+        projectId: testProjectId,
+      },
+    });
+    await syncNoteToFts(testDb, { id: note.id, title: note.title, content: note.content });
+
+    // Create an asset with "testall" in filename
+    await testDb.projectAsset.create({
+      data: {
+        filename: "testall-file.txt",
+        path: "/data/assets/testall-file.txt",
+        size: 256,
+        mimeType: "text/plain",
+        description: "",
+        projectId: testProjectId,
+      },
+    });
+
+    const results = await globalSearchFn("testall", "all");
+    expect(results.length).toBeGreaterThan(0);
+
+    // Should have results from multiple types
+    const types = new Set(results.map((r) => r.type));
+    expect(types.size).toBeGreaterThan(1);
+  });
+
+  it("each result has type discriminant in valid set", async () => {
+    const note = await testDb.projectNote.create({
+      data: {
+        title: "multitype-search-note",
+        content: "multitype content",
+        projectId: testProjectId,
+      },
+    });
+    await syncNoteToFts(testDb, { id: note.id, title: note.title, content: note.content });
+
+    const results = await globalSearchFn("multitype", "all");
+    const validTypes = new Set(["task", "project", "repository", "note", "asset"]);
+    for (const r of results) {
+      expect(validTypes.has(r.type)).toBe(true);
+    }
+  });
+
+  it("returns empty array when nothing matches (not an error)", async () => {
+    const results = await globalSearchFn("xxx_no_match_zzz_12345", "all");
+    expect(results).toEqual([]);
+  });
+});

package/.next/standalone/tower/tests/unit/actions/task-actions.test.ts

@@ -0,0 +1,173 @@
+// @vitest-environment node
+import { describe, it, expect, beforeAll, afterAll, afterEach, vi } from "vitest";
+import { PrismaClient } from "@prisma/client";
+import { removeWorktree } from "@/lib/worktree";
+
+// Mock next/cache to avoid "static generation store missing" error in test environment
+vi.mock("next/cache", () => ({
+  revalidatePath: vi.fn(),
+  revalidateTag: vi.fn(),
+}));
+
+// Mock worktree module to avoid real git operations in tests
+vi.mock("@/lib/worktree", () => ({
+  removeWorktree: vi.fn(),
+  createWorktree: vi.fn(),
+}));
+
+const testDb = new PrismaClient({
+  datasources: {
+    db: { url: process.env.DATABASE_URL ?? "file:./prisma/dev.db" },
+  },
+});
+
+let createTaskFn: (data: {
+  title: string;
+  description?: string;
+  projectId: string;
+  priority?: string;
+  status?: string;
+  labelIds?: string[];
+  baseBranch?: string;
+}) => Promise<any>;
+let updateTaskFn: (
+  taskId: string,
+  data: { title?: string; description?: string; priority?: string; labelIds?: string[]; baseBranch?: string }
+) => Promise<any>;
+let updateTaskStatusFn: (taskId: string, status: string) => Promise<any>;
+
+const mockedRemoveWorktree = vi.mocked(removeWorktree);
+
+let workspaceId: string;
+let projectId: string;
+
+beforeAll(async () => {
+  await testDb.$connect();
+
+  // Dynamic import: task-actions.ts uses "use server" directive
+  const mod = await import("@/actions/task-actions");
+  createTaskFn = mod.createTask as any;
+  updateTaskFn = mod.updateTask as any;
+  updateTaskStatusFn = mod.updateTaskStatus as any;
+
+  // Create workspace and project for tests
+  const workspace = await testDb.workspace.create({
+    data: { name: "Test Workspace for task-actions" },
+  });
+  workspaceId = workspace.id;
+
+  const project = await testDb.project.create({
+    data: { name: "Test Project for task-actions", workspaceId },
+  });
+  projectId = project.id;
+});
+
+afterAll(async () => {
+  // Clean up test workspace (cascades to projects and tasks)
+  await testDb.workspace.deleteMany({
+    where: { name: "Test Workspace for task-actions" },
+  });
+  await testDb.$disconnect();
+});
+
+afterEach(async () => {
+  // Clean up tasks after each test
+  await testDb.task.deleteMany({ where: { projectId } });
+});
+
+describe("createTask with baseBranch", () => {
+  it("persists baseBranch when provided", async () => {
+    const task = await createTaskFn({
+      title: "Test task with base branch",
+      projectId,
+      baseBranch: "main",
+    });
+
+    const found = await testDb.task.findUnique({ where: { id: task.id } });
+    expect(found).not.toBeNull();
+    expect(found!.baseBranch).toBe("main");
+  });
+
+  it("results in null baseBranch when not provided", async () => {
+    const task = await createTaskFn({
+      title: "Test task without base branch",
+      projectId,
+    });
+
+    const found = await testDb.task.findUnique({ where: { id: task.id } });
+    expect(found).not.toBeNull();
+    expect(found!.baseBranch).toBeNull();
+  });
+});
+
+describe("updateTask with baseBranch", () => {
+  it("updates baseBranch field when provided", async () => {
+    const task = await createTaskFn({
+      title: "Task to update baseBranch",
+      projectId,
+    });
+
+    await updateTaskFn(task.id, { baseBranch: "develop" });
+
+    const found = await testDb.task.findUnique({ where: { id: task.id } });
+    expect(found).not.toBeNull();
+    expect(found!.baseBranch).toBe("develop");
+  });
+});
+
+describe("updateTaskStatus CANCELLED cleanup", () => {
+  afterEach(() => {
+    mockedRemoveWorktree.mockReset();
+  });
+
+  it("calls removeWorktree when cancelling a task in a GIT project with localPath", async () => {
+    // Create a GIT project with localPath
+    const gitProject = await testDb.project.create({
+      data: {
+        name: "Git Project for cancel test",
+        workspaceId,
+        localPath: "/tmp/test-repo",
+        gitUrl: "https://github.com/test/repo",
+      },
+    });
+    const task = await createTaskFn({ title: "Task to cancel", projectId: gitProject.id });
+
+    await updateTaskStatusFn(task.id, "CANCELLED");
+
+    expect(mockedRemoveWorktree).toHaveBeenCalledWith("/tmp/test-repo", task.id);
+
+    // Cleanup
+    await testDb.task.deleteMany({ where: { projectId: gitProject.id } });
+    await testDb.project.delete({ where: { id: gitProject.id } });
+  });
+
+  it("does not call removeWorktree when cancelling a task in a NORMAL project", async () => {
+    // projectId is a NORMAL project (no localPath)
+    const task = await createTaskFn({ title: "Normal project task", projectId });
+
+    mockedRemoveWorktree.mockClear();
+    await updateTaskStatusFn(task.id, "CANCELLED");
+
+    expect(mockedRemoveWorktree).not.toHaveBeenCalled();
+  });
+
+  it("does not throw when removeWorktree fails", async () => {
+    const gitProject = await testDb.project.create({
+      data: {
+        name: "Git Project for cleanup fail test",
+        workspaceId,
+        localPath: "/tmp/test-repo-2",
+        gitUrl: "https://github.com/test/repo2",
+      },
+    });
+    const task = await createTaskFn({ title: "Task cleanup fail", projectId: gitProject.id });
+    mockedRemoveWorktree.mockRejectedValueOnce(new Error("git error"));
+
+    // Should not throw (D-05)
+    await expect(updateTaskStatusFn(task.id, "CANCELLED")).resolves.toBeDefined();
+
+    // Cleanup
+    await testDb.task.deleteMany({ where: { projectId: gitProject.id } });
+    await testDb.project.delete({ where: { id: gitProject.id } });
+  });
+});

package/.next/standalone/tower/tests/unit/api/diff-route.test.ts

@@ -0,0 +1,9 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+describe("GET /api/tasks/[taskId]/diff", () => {
+  it.todo("returns 404 when task does not exist");
+  it.todo("returns 400 when task has no baseBranch");
+  it.todo("returns 400 when project has no localPath");
+  it.todo("returns diff response with files, totalAdded, totalRemoved, hasConflicts, commitCount");
+  it.todo("validates taskId with Zod");
+});

package/.next/standalone/tower/tests/unit/api/file-serving.test.ts

@@ -0,0 +1,88 @@
+// @vitest-environment node
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import * as os from "node:os";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { vi } from "vitest";
+
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "file-serving-test-"));
+
+// Mock process.cwd() before importing file-serve so DATA_ROOT resolves to tmpDir
+vi.spyOn(process, "cwd").mockReturnValue(tmpDir);
+
+// Import after mocking cwd
+import { resolveAssetPath, MIME_MAP } from "@/lib/file-serve";
+
+afterAll(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+  vi.restoreAllMocks();
+});
+
+describe("resolveAssetPath", () => {
+  it("returns resolved path for valid projectId and filename", () => {
+    const result = resolveAssetPath("proj1", "image.png");
+    expect(result.error).toBeNull();
+    expect(result.resolved).not.toBeNull();
+    expect(result.resolved).toContain(path.join("data", "assets", "proj1", "image.png"));
+  });
+
+  it("rejects path traversal in projectId: ../../etc/passwd", () => {
+    const result = resolveAssetPath("../../etc", "passwd");
+    expect(result.resolved).toBeNull();
+    expect(result.error).toBe("Invalid path");
+  });
+
+  it("rejects path traversal in filename: ../../../etc/passwd", () => {
+    const result = resolveAssetPath("proj1", "../../../etc/passwd");
+    expect(result.resolved).toBeNull();
+    expect(result.error).toBe("Invalid path");
+  });
+
+  it("returns path under data/assets/ for normal inputs", () => {
+    const result = resolveAssetPath("myproject", "report.pdf");
+    expect(result.error).toBeNull();
+    expect(result.resolved).toMatch(/data[/\\]assets[/\\]myproject[/\\]report\.pdf$/);
+  });
+});
+
+describe("MIME_MAP", () => {
+  it("maps .png to image/png", () => {
+    expect(MIME_MAP[".png"]).toBe("image/png");
+  });
+
+  it("maps .jpg to image/jpeg", () => {
+    expect(MIME_MAP[".jpg"]).toBe("image/jpeg");
+  });
+
+  it("maps .jpeg to image/jpeg", () => {
+    expect(MIME_MAP[".jpeg"]).toBe("image/jpeg");
+  });
+
+  it("maps .gif to image/gif", () => {
+    expect(MIME_MAP[".gif"]).toBe("image/gif");
+  });
+
+  it("maps .webp to image/webp", () => {
+    expect(MIME_MAP[".webp"]).toBe("image/webp");
+  });
+
+  it("maps .svg to image/svg+xml", () => {
+    expect(MIME_MAP[".svg"]).toBe("image/svg+xml");
+  });
+
+  it("maps .pdf to application/pdf", () => {
+    expect(MIME_MAP[".pdf"]).toBe("application/pdf");
+  });
+
+  it("maps .txt to text/plain", () => {
+    expect(MIME_MAP[".txt"]).toBe("text/plain");
+  });
+
+  it("maps .md to text/markdown", () => {
+    expect(MIME_MAP[".md"]).toBe("text/markdown");
+  });
+
+  it("maps .json to application/json", () => {
+    expect(MIME_MAP[".json"]).toBe("application/json");
+  });
+});

package/.next/standalone/tower/tests/unit/api/merge-route.test.ts

@@ -0,0 +1,9 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+describe("POST /api/tasks/[taskId]/merge", () => {
+  it.todo("returns 400 when task is not IN_REVIEW");
+  it.todo("returns 409 when conflicts detected");
+  it.todo("performs squash merge and sets task status to DONE on success");
+  it.todo("returns 400 when baseBranch is not set");
+  it.todo("validates taskId with Zod");
+});

package/.next/standalone/tower/tests/unit/api/stream-persist-result.test.ts

@@ -0,0 +1,7 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+describe("stream route - persistResult IN_REVIEW transition", () => {
+  it.todo("sets task status to IN_REVIEW when exitCode is 0");
+  it.todo("does NOT set IN_REVIEW when exitCode is non-zero");
+  it.todo("emits status_changed SSE event after IN_REVIEW transition");
+});

package/.next/standalone/tower/tests/unit/api/stream-send-back.test.ts

@@ -0,0 +1,7 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+describe("stream route - send-back flow", () => {
+  it.todo("transitions IN_REVIEW task to IN_PROGRESS before creating execution");
+  it.todo("does NOT transition task if status is not IN_REVIEW");
+  it.todo("creates a new TaskExecution record for send-back");
+});