feat: project views

apps/server/src/handlers/task/index.ts

@@ -9,6 +9,7 @@ export * from "./task.delete.handler";  // NEW delete handler
 export * from "./task.context.handler"; // NEW context generation
 export * from "./task.decompose.handler"; // NEW decompose handler
 export * from "./task.create_project.handler"; // NEW project creation
+export * from "./task.get_project.handler"; // NEW get project with hierarchy
 
 // Task attachment handlers - key-value store for tasks
 export * from "./task.create_attachment.handler";

apps/server/src/handlers/task/task.create_project.handler.ts

@@ -248,7 +248,7 @@ export class TaskCreateProjectHandler {
 
 				// Map subtask dependencies to real task IDs
 				const realDependencies = subtask.dependencies
-					.map(depId => subtaskMapping[depId])
+					.map((depId: string) => subtaskMapping[depId])
 					.filter(Boolean); // Remove any unmapped dependencies
 
 				if (realDependencies.length > 0) {
@@ -285,7 +285,7 @@ export class TaskCreateProjectHandler {
 				const subtaskTaskId = subtaskMapping[subtask.id];
 				if (subtaskTaskId) {
 					dependencyMapping[subtaskTaskId] = subtask.dependencies
-						.map(depId => subtaskMapping[depId])
+						.map((depId: string) => subtaskMapping[depId])
 						.filter(Boolean);
 				}
 			}

apps/server/src/handlers/task/task.get_project.handler.ts

@@ -0,0 +1,207 @@
+import { EventHandler, Instrumented, Resilient } from "@/core/decorator";
+import type { EventContext } from "@/core/context";
+import { taskGetProjectInput, taskGetProjectOutput } from "@/schemas/task.schema";
+import type { TaskGetProjectInput, TaskGetProjectOutput } from "@/schemas/task.schema";
+import { getRedis } from "@/core/redis";
+import { registry } from "@/core/registry";
+
+@EventHandler({
+	event: "task.get_project",
+	inputSchema: taskGetProjectInput,
+	outputSchema: taskGetProjectOutput,
+	persist: false,
+	rateLimit: 30,
+	description: "Fetch project-structured tasks with hierarchy and attachments"
+})
+export class TaskGetProjectHandler {
+	@Instrumented(3600) // Cache for 1 hour
+	@Resilient({
+		rateLimit: { limit: 30, windowMs: 60000 },
+		timeout: 10000,
+		circuitBreaker: { threshold: 5, timeout: 30000 }
+	})
+	async handle(input: TaskGetProjectInput, ctx: EventContext): Promise<TaskGetProjectOutput> {
+		const redis = getRedis();
+		let projectId = input.projectId;
+		let parentTaskId = input.taskId;
+
+		// If only taskId provided, get projectId from task metadata
+		if (!projectId && parentTaskId) {
+			const taskData = await ctx.prisma.task.findUnique({
+				where: { id: parentTaskId }
+			});
+			if (!taskData?.metadata) {
+				throw new Error(`Task ${parentTaskId} not found or has no metadata`);
+			}
+			const metadata = taskData.metadata as any;
+			projectId = metadata.projectId;
+			if (!projectId) {
+				throw new Error(`Task ${parentTaskId} is not a project task`);
+			}
+		}
+
+		// If only projectId provided, get parentTaskId from Redis
+		if (projectId && !parentTaskId) {
+			const projectKey = `cb:project:${projectId}`;
+			const redisTaskId = await redis.pub.hget(projectKey, "parentTaskId");
+			if (redisTaskId) {
+				parentTaskId = redisTaskId;
+			}
+			if (!parentTaskId) {
+				// Fallback to PostgreSQL
+				const projectTask = await ctx.prisma.task.findFirst({
+					where: {
+						metadata: {
+							path: ["projectId"],
+							equals: projectId
+						}
+					}
+				});
+				if (!projectTask) {
+					throw new Error(`Project ${projectId} not found`);
+				}
+				parentTaskId = projectTask.id;
+			}
+		}
+
+		// Fetch parent task with attachments
+		const parentTask = await ctx.prisma.task.findUnique({
+			where: { id: parentTaskId },
+			include: {
+				attachments: {
+					orderBy: { createdAt: "desc" }
+				}
+			}
+		});
+
+		if (!parentTask) {
+			throw new Error(`Parent task ${parentTaskId} not found`);
+		}
+
+		// Fetch all subtasks for this project
+		const subtasks = await ctx.prisma.task.findMany({
+			where: {
+				metadata: {
+					path: ["projectId"],
+					equals: projectId
+				}
+			},
+			include: {
+				attachments: {
+					where: {
+						key: {
+							startsWith: "subtask_context"
+						}
+					},
+					orderBy: { createdAt: "desc" }
+				}
+			},
+			orderBy: { createdAt: "asc" }
+		});
+
+		// Filter out the parent task from subtasks
+		const actualSubtasks = subtasks.filter(t => t.id !== parentTaskId);
+
+		// Get project metadata from Redis cache or attachments
+		const projectKey = `cb:project:${projectId}`;
+		let projectMetadata: any = {};
+
+		const redisData = await redis.pub.hgetall(projectKey);
+		if (redisData && Object.keys(redisData).length > 0) {
+			projectMetadata = {
+				description: redisData.description || "",
+				status: redisData.status || "unknown",
+				constraints: redisData.constraints ? JSON.parse(redisData.constraints) : [],
+				requirements: redisData.requirements ? JSON.parse(redisData.requirements) : [],
+				estimatedMinutes: redisData.estimatedMinutes ? parseInt(redisData.estimatedMinutes) : undefined,
+				createdAt: redisData.createdAt || new Date().toISOString(),
+				createdBy: redisData.createdBy || ctx.instanceId
+			};
+		} else {
+			// Fallback to attachments
+			const projectAttachment = parentTask.attachments.find(a => 
+				a.key.startsWith("project_") && a.type === "json"
+			);
+			if (projectAttachment?.value) {
+				const attachmentData = projectAttachment.value as any;
+				projectMetadata = {
+					description: attachmentData.description || "",
+					status: attachmentData.status || "unknown",
+					constraints: attachmentData.constraints || [],
+					requirements: attachmentData.requirements || [],
+					estimatedMinutes: attachmentData.estimatedMinutes,
+					createdAt: attachmentData.createdAt || parentTask.createdAt.toISOString(),
+					createdBy: attachmentData.createdBy || ctx.instanceId
+				};
+			}
+		}
+
+		// Get decomposition data for strategy and complexity
+		const decompositionAttachment = parentTask.attachments.find(a =>
+			a.key.startsWith("decomposition_") && a.type === "json"
+		);
+		if (decompositionAttachment?.value) {
+			const decomposition = decompositionAttachment.value as any;
+			projectMetadata.strategy = decomposition.strategy;
+			projectMetadata.totalComplexity = decomposition.totalComplexity;
+		}
+
+		// Calculate stats
+		const stats = {
+			totalTasks: actualSubtasks.length + 1, // Include parent
+			pendingTasks: actualSubtasks.filter(t => t.status === "pending").length,
+			inProgressTasks: actualSubtasks.filter(t => t.status === "in_progress").length,
+			completedTasks: actualSubtasks.filter(t => t.status === "completed").length,
+			failedTasks: actualSubtasks.filter(t => t.status === "failed").length
+		};
+
+		// Add parent task status to stats
+		if (parentTask.status === "pending") stats.pendingTasks++;
+		else if (parentTask.status === "in_progress") stats.inProgressTasks++;
+		else if (parentTask.status === "completed") stats.completedTasks++;
+		else if (parentTask.status === "failed") stats.failedTasks++;
+
+		// Format response
+		return {
+			projectId: projectId!,
+			parentTask: {
+				id: parentTask.id,
+				text: parentTask.text,
+				status: parentTask.status as any,
+				priority: parentTask.priority,
+				createdAt: parentTask.createdAt.toISOString(),
+				updatedAt: parentTask.updatedAt.toISOString(),
+				metadata: parentTask.metadata as any,
+				attachments: parentTask.attachments.map(a => ({
+					key: a.key,
+					type: a.type as any,
+					value: a.value,
+					createdAt: a.createdAt.toISOString()
+				}))
+			},
+			subtasks: actualSubtasks.map(task => {
+				const metadata = task.metadata as any || {};
+				return {
+					id: task.id,
+					text: task.text,
+					status: task.status as any,
+					priority: task.priority,
+					specialist: metadata.specialist,
+					complexity: metadata.complexity,
+					estimatedMinutes: metadata.estimatedMinutes,
+					dependencies: metadata.dependencies || [],
+					createdAt: task.createdAt.toISOString(),
+					updatedAt: task.updatedAt.toISOString(),
+					attachments: task.attachments.map(a => ({
+						key: a.key,
+						type: a.type as any,
+						value: a.value,
+						createdAt: a.createdAt.toISOString()
+					}))
+				};
+			}),
+			projectMetadata,
+			stats
+		};
+	}
+}

apps/server/src/schemas/task.schema.ts

@@ -362,4 +362,71 @@ export const taskCreateProjectOutput = z.object({
 });
 
 export type TaskCreateProjectInput = z.infer<typeof taskCreateProjectInput>;
-export type TaskCreateProjectOutput = z.infer<typeof taskCreateProjectOutput>;
+export type TaskCreateProjectOutput = z.infer<typeof taskCreateProjectOutput>;
+
+// task.get_project
+export const taskGetProjectInput = z.object({
+	projectId: z.string().min(1).optional(),
+	taskId: z.string().min(1).optional(),
+}).refine(data => data.projectId || data.taskId, {
+	message: "Either 'projectId' or 'taskId' must be provided",
+	path: ["projectId"],
+});
+
+export const taskGetProjectOutput = z.object({
+	projectId: z.string(),
+	parentTask: z.object({
+		id: z.string(),
+		text: z.string(),
+		status: TaskStatus,
+		priority: z.number(),
+		createdAt: z.string().datetime(),
+		updatedAt: z.string().datetime(),
+		metadata: z.record(z.string(), z.unknown()).nullable(),
+		attachments: z.array(z.object({
+			key: z.string(),
+			type: AttachmentType,
+			value: z.unknown().optional(),
+			createdAt: z.string()
+		})).optional(),
+	}),
+	subtasks: z.array(z.object({
+		id: z.string(),
+		text: z.string(),
+		status: TaskStatus,
+		priority: z.number(),
+		specialist: z.string().optional(),
+		complexity: z.number().optional(),
+		estimatedMinutes: z.number().optional(),
+		dependencies: z.array(z.string()).optional(),
+		createdAt: z.string().datetime(),
+		updatedAt: z.string().datetime(),
+		attachments: z.array(z.object({
+			key: z.string(),
+			type: AttachmentType,
+			value: z.unknown().optional(),
+			createdAt: z.string()
+		})).optional(),
+	})),
+	projectMetadata: z.object({
+		description: z.string(),
+		status: z.string(),
+		constraints: z.array(z.string()).optional(),
+		requirements: z.array(z.string()).optional(),
+		estimatedMinutes: z.number().optional(),
+		strategy: z.enum(["parallel", "sequential", "mixed"]).optional(),
+		totalComplexity: z.number().optional(),
+		createdAt: z.string().datetime(),
+		createdBy: z.string().optional(),
+	}),
+	stats: z.object({
+		totalTasks: z.number(),
+		pendingTasks: z.number(),
+		inProgressTasks: z.number(),
+		completedTasks: z.number(),
+		failedTasks: z.number(),
+	})
+});
+
+export type TaskGetProjectInput = z.infer<typeof taskGetProjectInput>;
+export type TaskGetProjectOutput = z.infer<typeof taskGetProjectOutput>;

apps/web/src/components/ClaudeBenchLayout.tsx

@@ -11,6 +11,7 @@ import {
   IconRobot,
   IconBroadcast,
   IconBook,
+  IconFolders,
 } from "@tabler/icons-react";
 import { cn } from "@/lib/utils";
 import { ModeToggle } from "@/components/mode-toggle";
@@ -38,6 +39,13 @@ export function ClaudeBenchLayout({ children }: ClaudeBenchLayoutProps) {
         <IconListDetails className="text-neutral-700 dark:text-neutral-200 h-5 w-5 shrink-0" />
       ),
     },
+    {
+      label: "Projects",
+      href: "/projects",
+      icon: (
+        <IconFolders className="text-neutral-700 dark:text-neutral-200 h-5 w-5 shrink-0" />
+      ),
+    },
     {
       label: "Events",
       href: "/events",