tower-studio 0.1.1 → 0.1.3

package/src/app/workspaces/[workspaceId]/board-page-client.tsx

@@ -0,0 +1,257 @@
+"use client";
+
+import { useState, useCallback, useTransition, useEffect } from "react";
+import { useRouter } from "next/navigation";
+import { BoardStats } from "@/components/board/board-stats";
+import { BoardFilters } from "@/components/board/board-filters";
+import { KanbanBoard } from "@/components/board/kanban-board";
+import { CreateTaskDialog } from "@/components/board/create-task-dialog";
+import { RepoSidebar } from "@/components/repository/repo-sidebar";
+import { TaskDetailPanel } from "@/components/task/task-detail-panel";
+import { createTask, updateTaskStatus, updateTask, deleteTask, toggleTaskPinned } from "@/actions/task-actions";
+import { startPtyExecution } from "@/actions/agent-actions";
+import { ProjectTabs } from "@/components/board/project-tabs";
+import type { TaskStatus, Priority } from "@prisma/client";
+import { TOWER_LABEL_NAME } from "@/lib/constants";
+import type { TaskWithLabels } from "@/types";
+import { toast } from "sonner";
+
+
+interface LabelOption {
+  id: string;
+  name: string;
+  color: string;
+  isBuiltin: boolean;
+}
+
+interface ProjectInfo {
+  id: string;
+  name: string;
+  alias: string | null;
+  description: string | null;
+  type: string;
+  gitUrl: string | null;
+  localPath: string | null;
+}
+
+interface BoardPageClientProps {
+  workspaceId: string;
+  projectId: string;
+  project: ProjectInfo;
+  projects: Array<{ id: string; name: string; alias: string | null }>;
+  initialTasks: TaskWithLabels[];
+  labels: LabelOption[];
+  openTaskId?: string;
+}
+
+export function BoardPageClient({
+  workspaceId,
+  projectId,
+  project,
+  projects,
+  initialTasks,
+  labels,
+  openTaskId,
+}: BoardPageClientProps) {
+  const router = useRouter();
+  const [, startTransition] = useTransition();
+  const [searchQuery, setSearchQuery] = useState("");
+  const [showCreateDialog, setShowCreateDialog] = useState(false);
+  const [createDefaultStatus, setCreateDefaultStatus] = useState<TaskStatus>("TODO");
+  const [selectedTask, setSelectedTask] = useState<TaskWithLabels | null>(
+    openTaskId ? initialTasks.find((t) => t.id === openTaskId) ?? null : null
+  );
+  const [editingTask, setEditingTask] = useState<TaskWithLabels | null>(null);
+
+  const refreshData = useCallback(() => {
+    startTransition(() => {
+      router.refresh();
+    });
+  }, [router]);
+
+  // Auto-poll for external changes (MCP task creation, etc.)
+  // Pause polling while create/edit dialog is open to prevent form reset
+  useEffect(() => {
+    if (showCreateDialog) return;
+    const timer = setInterval(() => {
+      startTransition(() => {
+        router.refresh();
+      });
+    }, 5000);
+    return () => clearInterval(timer);
+  }, [router, showCreateDialog]);
+
+  const handleSearchChange = useCallback((query: string) => {
+    setSearchQuery(query);
+  }, []);
+
+  const handleTaskMove = useCallback(async (taskId: string, newStatus: TaskStatus) => {
+    await updateTaskStatus(taskId, newStatus);
+    if (selectedTask?.id === taskId) {
+      setSelectedTask({ ...selectedTask, status: newStatus });
+    }
+    refreshData();
+  }, [refreshData, selectedTask]);
+
+  const handleCreateTask = useCallback(
+    async (data: { title: string; description: string; priority: Priority; status: TaskStatus; labelIds: string[]; baseBranch?: string; subPath?: string }) => {
+      await createTask({
+        title: data.title,
+        description: data.description,
+        projectId,
+        priority: data.priority,
+        status: data.status,
+        labelIds: data.labelIds,
+        baseBranch: data.baseBranch,
+        subPath: data.subPath,
+      });
+      refreshData();
+    },
+    [projectId, refreshData]
+  );
+
+  const handleUpdateTask = useCallback(async (taskId: string, data: { title: string; description: string; priority: Priority; labelIds: string[]; subPath?: string }) => {
+    await updateTask(taskId, { ...data, labelIds: data.labelIds });
+    setEditingTask(null);
+    refreshData();
+  }, [refreshData]);
+
+  const handleDeleteTask = useCallback(async (taskId: string) => {
+    await deleteTask(taskId);
+    if (selectedTask?.id === taskId) {
+      setSelectedTask(null);
+    }
+    refreshData();
+  }, [refreshData, selectedTask]);
+
+  const handleTogglePin = useCallback(async (taskId: string) => {
+    await toggleTaskPinned(taskId);
+    refreshData();
+  }, [refreshData]);
+
+  const handleLaunchTask = useCallback(async (taskId: string) => {
+    try {
+      await startPtyExecution(taskId, "");
+    } catch (err) {
+      toast.error(err instanceof Error ? err.message : String(err));
+    }
+    router.push(`/workspaces/${workspaceId}/tasks/${taskId}`);
+  }, [router, workspaceId]);
+
+  const handleContextMenuStatusChange = useCallback(async (taskId: string, status: TaskStatus) => {
+    await updateTaskStatus(taskId, status);
+    if (selectedTask?.id === taskId) {
+      setSelectedTask({ ...selectedTask, status });
+    }
+    refreshData();
+  }, [refreshData, selectedTask]);
+
+  const handleAddTaskToColumn = useCallback((status: TaskStatus) => {
+    setCreateDefaultStatus(status);
+    setEditingTask(null);
+    setShowCreateDialog(true);
+  }, []);
+
+  const handleEditTask = useCallback((task: TaskWithLabels) => {
+    setEditingTask(task);
+    setShowCreateDialog(true);
+  }, []);
+
+  // Exclude Tower-labeled tasks from kanban (system workbench tasks)
+  const boardTasks = initialTasks.filter(
+    (t) => !t.labels?.some((tl) => tl.label.name === TOWER_LABEL_NAME && tl.label.isBuiltin)
+  );
+
+  const filteredTasks = searchQuery.trim()
+    ? boardTasks.filter((t) => {
+        const q = searchQuery.toLowerCase();
+        return t.title.toLowerCase().includes(q) ||
+          (t.description?.toLowerCase().includes(q) ?? false);
+      })
+    : boardTasks;
+
+  return (
+    <div className="flex h-full">
+      <div className="flex flex-1 flex-col overflow-hidden">
+        {/* Project Tabs — always show, single project also shown */}
+        <div className="px-6 pt-3 pb-1">
+          <ProjectTabs
+            projects={projects}
+            activeProjectId={projectId}
+            onSelect={(id) => router.push(`/workspaces/${workspaceId}?projectId=${id}`, { scroll: false })}
+          />
+        </div>
+
+        {/* Stats */}
+        <BoardStats
+          totalTasks={boardTasks.length}
+          runningTasks={boardTasks.filter((t) => t.status === "IN_PROGRESS").length}
+        />
+
+        {/* Filters */}
+        <BoardFilters
+          searchQuery={searchQuery}
+          onSearchChange={handleSearchChange}
+          onCreateTask={() => {
+            setEditingTask(null);
+            setShowCreateDialog(true);
+          }}
+        />
+
+        {/* Kanban Board */}
+        <div className="flex-1 min-h-0 overflow-hidden p-4">
+          <KanbanBoard
+            initialTasks={filteredTasks}
+            onTaskMove={handleTaskMove}
+            onTaskClick={(task) => {
+              {
+                setSelectedTask(task);
+              }
+            }}
+            onEditTask={handleEditTask}
+            onAddTask={handleAddTaskToColumn}
+            onDeleteTask={handleDeleteTask}
+            onTogglePin={handleTogglePin}
+            workspaceId={workspaceId}
+            onContextMenuStatusChange={handleContextMenuStatusChange}
+            onContextMenuLaunch={handleLaunchTask}
+          />
+        </div>
+
+        {/* Create/Edit Task Dialog */}
+        <CreateTaskDialog
+          open={showCreateDialog}
+          onOpenChange={(open) => {
+            setShowCreateDialog(open);
+            if (!open) setEditingTask(null);
+          }}
+          onSubmit={handleCreateTask}
+          onUpdate={handleUpdateTask}
+          defaultStatus={createDefaultStatus}
+          editTask={editingTask}
+          editTaskLabelIds={
+            editingTask?.labels
+              ? editingTask.labels.map((tl) => tl.labelId)
+              : []
+          }
+          labels={labels.filter((l) => !(l.name === TOWER_LABEL_NAME && l.isBuiltin))}
+          projectType={project.type}
+          projectLocalPath={project.localPath}
+        />
+      </div>
+
+      {/* Right: Task Detail Panel or Repo Sidebar */}
+      {selectedTask ? (
+        <TaskDetailPanel
+          task={selectedTask}
+          workspaceId={workspaceId}
+          projectLocalPath={project.localPath}
+          onClose={() => setSelectedTask(null)}
+        />
+      ) : (
+        <RepoSidebar project={project} workspaceId={workspaceId} />
+      )}
+
+    </div>
+  );
+}

package/src/app/workspaces/[workspaceId]/notes/notes-page-client.tsx

@@ -0,0 +1,337 @@
+"use client";
+
+import { useState, useTransition, useCallback } from "react";
+import { Plus, Loader2 } from "lucide-react";
+import { SubPageNav } from "@/components/layout/sub-page-nav";
+import type { ProjectNote } from "@prisma/client";
+import { useI18n } from "@/lib/i18n";
+import { NOTE_CATEGORIES_PRESET } from "@/lib/constants";
+import { createNote, updateNote, deleteNote, getProjectNotes } from "@/actions/note-actions";
+import { CategoryFilter } from "@/components/notes/category-filter";
+import { Button } from "@/components/ui/button";
+import { Select, SelectContent, SelectItem, SelectTrigger } from "@/components/ui/select";
+import { NoteList } from "@/components/notes/note-list";
+import { NoteEditor } from "@/components/notes/note-editor";
+import type { NoteItem } from "@/components/notes/note-card";
+
+interface SimpleProject {
+  id: string;
+  name: string;
+  alias: string | null;
+}
+
+interface SimpleWorkspace {
+  id: string;
+  name: string;
+  projects: SimpleProject[];
+}
+
+interface NotesPageClientProps {
+  allWorkspaces: SimpleWorkspace[];
+  initialWorkspaceId: string;
+  initialProjectId: string | null;
+  initialNotes: ProjectNote[];
+}
+
+export function NotesPageClient({
+  allWorkspaces,
+  initialWorkspaceId,
+  initialProjectId,
+  initialNotes,
+}: NotesPageClientProps) {
+  const { t } = useI18n();
+  const [isPending, startTransition] = useTransition();
+
+  // List view selection state (for browsing)
+  const [listWsId, setListWsId] = useState(initialWorkspaceId);
+  const [listProjectId, setListProjectId] = useState<string | null>(initialProjectId);
+
+  // Data state
+  const [notes, setNotes] = useState<ProjectNote[]>(initialNotes);
+  const [activeCategory, setActiveCategory] = useState("all");
+
+  // Form state (independent from list view)
+  const [editingNote, setEditingNote] = useState<NoteItem | null>(null);
+  const [isCreating, setIsCreating] = useState(false);
+  const [formTitle, setFormTitle] = useState("");
+  const [formContent, setFormContent] = useState("");
+  const [formCategory, setFormCategory] = useState<string>(NOTE_CATEGORIES_PRESET[3]);
+  const [formWsId, setFormWsId] = useState(initialWorkspaceId);
+  const [formProjectId, setFormProjectId] = useState<string | null>(initialProjectId);
+
+  // Derived
+  const listWs = allWorkspaces.find((ws) => ws.id === listWsId);
+  const listProjects = listWs?.projects ?? [];
+  const formWs = allWorkspaces.find((ws) => ws.id === formWsId);
+  const formProjects = formWs?.projects ?? [];
+
+  // Reload notes for the list view
+  const reloadNotes = useCallback(
+    (projectId: string | null) => {
+      if (!projectId) {
+        setNotes([]);
+        return;
+      }
+      startTransition(async () => {
+        const freshNotes = await getProjectNotes(projectId);
+        setNotes(freshNotes);
+      });
+    },
+    [startTransition]
+  );
+
+  // List view handlers
+  const handleListWsChange = (wsId: string) => {
+    if (wsId === listWsId) return;
+    setListWsId(wsId);
+    const ws = allWorkspaces.find((w) => w.id === wsId);
+    const firstProject = ws?.projects[0] ?? null;
+    setListProjectId(firstProject?.id ?? null);
+    setActiveCategory("all");
+    reloadNotes(firstProject?.id ?? null);
+  };
+
+  const handleListProjectChange = (projectId: string) => {
+    if (projectId === listProjectId) return;
+    setListProjectId(projectId);
+    setActiveCategory("all");
+    reloadNotes(projectId);
+  };
+
+  // Form workspace/project handlers (don't affect list view)
+  const handleFormWsChange = (wsId: string) => {
+    if (wsId === formWsId) return;
+    setFormWsId(wsId);
+    const ws = allWorkspaces.find((w) => w.id === wsId);
+    const firstProject = ws?.projects[0] ?? null;
+    setFormProjectId(firstProject?.id ?? null);
+  };
+
+  // CRUD handlers
+  const handleNewNote = () => {
+    setFormTitle("");
+    setFormContent("");
+    setFormCategory(NOTE_CATEGORIES_PRESET[3]);
+    // Default form selectors to current list view selection
+    setFormWsId(listWsId);
+    setFormProjectId(listProjectId);
+    setEditingNote(null);
+    setIsCreating(true);
+  };
+
+  const handleEditNote = (note: NoteItem) => {
+    setFormTitle(note.title);
+    setFormContent(note.content);
+    setFormCategory(note.category);
+    setEditingNote(note);
+    setIsCreating(false);
+  };
+
+  const handleCancel = () => {
+    setIsCreating(false);
+    setEditingNote(null);
+  };
+
+  const handleCreate = async () => {
+    if (!formProjectId || !formTitle.trim()) return;
+    await createNote({
+      title: formTitle.trim(),
+      content: formContent,
+      category: formCategory,
+      projectId: formProjectId,
+    });
+    setIsCreating(false);
+    // If we created in the same project as list view, reload
+    if (formProjectId === listProjectId) {
+      reloadNotes(listProjectId);
+    }
+  };
+
+  const handleUpdate = async () => {
+    if (!editingNote || !formTitle.trim()) return;
+    await updateNote(editingNote.id, {
+      title: formTitle.trim(),
+      content: formContent,
+      category: formCategory,
+    });
+    setEditingNote(null);
+    reloadNotes(listProjectId);
+  };
+
+  const handleDelete = async (noteId: string) => {
+    const noteToDelete = notes.find((n) => n.id === noteId);
+    if (!noteToDelete) return;
+    if (!confirm(t("notes.deleteConfirm", { title: noteToDelete.title }))) return;
+    await deleteNote(noteId);
+    reloadNotes(listProjectId);
+  };
+
+  // Filtered notes
+  const filteredNotes: NoteItem[] =
+    activeCategory === "all"
+      ? notes.map((n) => ({ ...n, updatedAt: new Date(n.updatedAt) }))
+      : notes
+          .filter((n) => n.category === activeCategory)
+          .map((n) => ({ ...n, updatedAt: new Date(n.updatedAt) }));
+
+  const showForm = isCreating || editingNote !== null;
+
+  return (
+    <div className="flex h-full flex-col overflow-hidden">
+      <SubPageNav workspaceId={listWsId} />
+
+      {/* Action bar */}
+      <div className="header-sm flex items-center gap-3 px-6 py-2">
+        <Select value={listWsId} onValueChange={(v) => v && handleListWsChange(v)}>
+          <SelectTrigger className="h-8 w-auto min-w-[120px]">
+            <span className="truncate">{allWorkspaces.find((ws) => ws.id === listWsId)?.name ?? listWsId}</span>
+          </SelectTrigger>
+          <SelectContent>
+            {allWorkspaces.map((ws) => (
+              <SelectItem key={ws.id} value={ws.id}>{ws.name}</SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+        {listProjects.length > 0 && (
+          <Select value={listProjectId ?? ""} onValueChange={(v) => v && handleListProjectChange(v)}>
+            <SelectTrigger className="h-8 w-auto min-w-[140px]">
+              <span className="truncate">
+                {(() => { const p = listProjects.find((x) => x.id === listProjectId); return p ? (p.alias ? `${p.name} (${p.alias})` : p.name) : ""; })()}
+              </span>
+            </SelectTrigger>
+            <SelectContent>
+              {listProjects.map((p) => (
+                <SelectItem key={p.id} value={p.id}>
+                  {p.name}{p.alias ? ` (${p.alias})` : ""}
+                </SelectItem>
+              ))}
+            </SelectContent>
+          </Select>
+        )}
+        {!showForm && (
+          <Button
+            onClick={handleNewNote}
+            className="ml-auto bg-primary/10 text-primary ring-1 ring-primary/20 hover:bg-primary/15"
+          >
+            <Plus className="h-3.5 w-3.5" />
+            <span>{t("notes.newNote")}</span>
+          </Button>
+        )}
+      </div>
+
+      {/* Content */}
+      <div className="flex-1 overflow-hidden px-6 py-4 flex flex-col">
+        {showForm ? (
+          /* ── Create / Edit form with its own workspace+project selectors ── */
+          <div className="flex flex-col gap-4 flex-1 min-h-0">
+            {/* Form selectors row */}
+            <div className="flex items-center gap-3 flex-wrap">
+              {/* Workspace selector (only for create, not edit) */}
+              {!editingNote && (
+                <div className="flex items-center gap-2">
+                  <label className="text-xs text-muted-foreground whitespace-nowrap">{t("notes.workspace")}</label>
+                  <Select value={formWsId} onValueChange={(v) => v && handleFormWsChange(v)}>
+                    <SelectTrigger className="min-w-[140px] text-xs">
+                      <span className="truncate">{allWorkspaces.find((ws) => ws.id === formWsId)?.name ?? formWsId}</span>
+                    </SelectTrigger>
+                    <SelectContent>
+                      {allWorkspaces.map((ws) => (
+                        <SelectItem key={ws.id} value={ws.id}>{ws.name}</SelectItem>
+                      ))}
+                    </SelectContent>
+                  </Select>
+                </div>
+              )}
+              {/* Project selector (only for create, not edit) */}
+              {!editingNote && formProjects.length > 0 && (
+                <div className="flex items-center gap-2">
+                  <label className="text-xs text-muted-foreground whitespace-nowrap">{t("notes.project")}</label>
+                  <Select value={formProjectId ?? ""} onValueChange={(v) => v && setFormProjectId(v)}>
+                    <SelectTrigger className="min-w-[160px] text-xs">
+                      <span className="truncate">
+                        {(() => { const p = formProjects.find((x) => x.id === formProjectId); return p ? (p.alias ? `${p.name} (${p.alias})` : p.name) : ""; })()}
+                      </span>
+                    </SelectTrigger>
+                    <SelectContent>
+                      {formProjects.map((p) => (
+                        <SelectItem key={p.id} value={p.id}>
+                          {p.name}{p.alias ? ` (${p.alias})` : ""}
+                        </SelectItem>
+                      ))}
+                    </SelectContent>
+                  </Select>
+                </div>
+              )}
+              {/* Category selector */}
+              <div className="flex items-center gap-2">
+                <label className="text-xs text-muted-foreground whitespace-nowrap">{t("notes.categoryLabel")}</label>
+                <Select value={formCategory} onValueChange={(v) => v && setFormCategory(v)}>
+                  <SelectTrigger className="min-w-[120px] text-xs">
+                    <span className="truncate">{formCategory}</span>
+                  </SelectTrigger>
+                  <SelectContent>
+                    {NOTE_CATEGORIES_PRESET.map((cat) => (
+                      <SelectItem key={cat} value={cat}>{cat}</SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+              </div>
+            </div>
+
+            {/* Title input */}
+            <input
+              type="text"
+              value={formTitle}
+              onChange={(e) => setFormTitle(e.target.value)}
+              placeholder={t("notes.titlePlaceholder")}
+              className="w-full rounded-md border border-border bg-background px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground focus:outline-none focus:ring-1 focus:ring-ring"
+            />
+
+            <NoteEditor value={formContent} onChange={setFormContent} />
+
+            <div className="flex items-center gap-2 justify-end">
+              <Button
+                variant="outline"
+                onClick={handleCancel}
+              >
+                {t("notes.cancel")}
+              </Button>
+              <Button
+                onClick={editingNote ? handleUpdate : handleCreate}
+                disabled={!formTitle.trim() || (!editingNote && !formProjectId)}
+                className="bg-primary/10 text-primary ring-1 ring-primary/20 hover:bg-primary/15"
+              >
+                {t("notes.save")}
+              </Button>
+            </div>
+          </div>
+        ) : (
+          /* ── List view ── */
+          <div className="space-y-4">
+            <CategoryFilter active={activeCategory} onSelect={setActiveCategory} />
+
+            <div className={`relative ${isPending ? "opacity-40 pointer-events-none" : ""} transition-opacity`}>
+              {isPending && (
+                <div className="absolute inset-0 z-10 flex items-center justify-center">
+                  <Loader2 className="size-5 animate-spin text-muted-foreground" />
+                </div>
+              )}
+              {listProjects.length === 0 ? (
+                <div className="flex flex-col items-center justify-center gap-2 py-16 text-center">
+                  <p className="text-sm font-medium text-muted-foreground">{t("notes.noProject")}</p>
+                  <p className="text-xs text-muted-foreground/60">{t("notes.noProjectHint")}</p>
+                </div>
+              ) : (
+                <NoteList
+                  notes={filteredNotes}
+                  onEdit={handleEditNote}
+                  onDelete={handleDelete}
+                />
+              )}
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}

package/src/app/workspaces/[workspaceId]/notes/page.tsx

@@ -0,0 +1,39 @@
+import { notFound } from "next/navigation";
+import { db } from "@/lib/db";
+import { getProjectNotes } from "@/actions/note-actions";
+import { getWorkspacesWithProjects } from "@/actions/workspace-actions";
+import { NotesPageClient } from "./notes-page-client";
+
+interface Props {
+  params: Promise<{ workspaceId: string }>;
+}
+
+export default async function NotesPage({ params }: Props) {
+  const { workspaceId } = await params;
+
+  // Verify current workspace exists
+  const workspace = await db.workspace.findUnique({
+    where: { id: workspaceId },
+    select: { id: true },
+  });
+  if (!workspace) notFound();
+
+  // All workspaces with their projects (lightweight) for the selector
+  const allWorkspaces = await getWorkspacesWithProjects();
+
+  // Find current workspace's projects for initial data
+  const currentWs = allWorkspaces.find((ws) => ws.id === workspaceId);
+  const initialProject = currentWs?.projects[0];
+  const initialNotes = initialProject
+    ? await getProjectNotes(initialProject.id)
+    : [];
+
+  return (
+    <NotesPageClient
+      allWorkspaces={allWorkspaces}
+      initialWorkspaceId={workspaceId}
+      initialProjectId={initialProject?.id ?? null}
+      initialNotes={initialNotes}
+    />
+  );
+}