idea-manager 0.2.0 → 0.3.1

package/src/app/api/projects/[id]/structure/stream/route.ts

@@ -0,0 +1,157 @@
+import { NextRequest } from 'next/server';
+import { getProject } from '@/lib/db/queries/projects';
+import { getBrainstorm } from '@/lib/db/queries/brainstorms';
+import { getProjectContextSummary } from '@/lib/db/queries/context';
+import { structureWithChatDirect } from '@/lib/ai/structurer';
+import {
+  getTask, startTask, addTaskEvent, finishTask, failTask,
+  addTaskListener, cleanupTasks,
+} from '@/lib/task-store';
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const { id } = await params;
+  const project = getProject(id);
+  if (!project) {
+    return new Response('Project not found', { status: 404 });
+  }
+
+  cleanupTasks();
+
+  const existingTask = getTask(id);
+
+  // If there's an active task, attach to it (reconnect scenario)
+  if (existingTask && existingTask.status === 'running') {
+    return createReconnectStream(id, existingTask);
+  }
+
+  // If recently finished task exists, replay final result
+  if (existingTask && existingTask.status === 'done' && existingTask.result) {
+    return createReplayStream(existingTask);
+  }
+
+  // Start new task
+  const brainstorm = getBrainstorm(id);
+  if (!brainstorm) {
+    return new Response('Project not initialized', { status: 400 });
+  }
+
+  const hasContent = brainstorm.content.trim();
+  const hasContext = !!getProjectContextSummary(id);
+
+  if (!hasContent && !hasContext) {
+    return new Response('No content to structure', { status: 400 });
+  }
+
+  // User-provided project description from scan panel
+  const userDescription = request.nextUrl.searchParams.get('desc') || '';
+
+  let content = hasContent
+    ? brainstorm.content
+    : '프로젝트 스캔 결과를 분석하여 현재 프로젝트의 구조, 진행 상황, TODO 항목을 파악해주세요.';
+
+  if (userDescription) {
+    content = `[사용자가 제공한 프로젝트 설명]\n${userDescription}\n\n${content}`;
+  }
+
+  const brainstormId = brainstorm.id;
+
+  // Start background task
+  startTask(id);
+
+  const send = async (event: string, data: unknown) => {
+    addTaskEvent(id, event, data);
+    if (event === 'done') {
+      finishTask(id, data);
+    }
+  };
+
+  // Run structuring in background (detached from stream)
+  (async () => {
+    try {
+      await structureWithChatDirect(id, brainstormId, content, send);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : 'Structure failed';
+      addTaskEvent(id, 'error', { error: msg });
+      failTask(id, msg);
+    }
+  })();
+
+  // Stream events to this client
+  return createReconnectStream(id, getTask(id)!);
+}
+
+function createReconnectStream(projectId: string, task: ReturnType<typeof getTask>) {
+  const encoder = new TextEncoder();
+  let unsubscribe: (() => void) | null = null;
+
+  const stream = new ReadableStream({
+    start(controller) {
+      const send = (event: string, data: unknown) => {
+        try {
+          controller.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
+        } catch {
+          // controller may be closed
+        }
+      };
+
+      // Replay past events
+      if (task) {
+        for (const ev of task.events) {
+          send(ev.event, ev.data);
+        }
+
+        // If already finished, close immediately
+        if (task.status !== 'running') {
+          controller.close();
+          return;
+        }
+      }
+
+      // Listen for new events
+      unsubscribe = addTaskListener(projectId, (event, data) => {
+        send(event, data);
+        if (event === 'done' || event === 'error') {
+          try { controller.close(); } catch { /* already closed */ }
+          unsubscribe?.();
+        }
+      });
+    },
+    cancel() {
+      unsubscribe?.();
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+      'X-Accel-Buffering': 'no',
+    },
+  });
+}
+
+function createReplayStream(task: NonNullable<ReturnType<typeof getTask>>) {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    start(controller) {
+      for (const ev of task.events) {
+        try {
+          controller.enqueue(encoder.encode(`event: ${ev.event}\ndata: ${JSON.stringify(ev.data)}\n\n`));
+        } catch { break; }
+      }
+      controller.close();
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+    },
+  });
+}

package/src/app/api/projects/[id]/sub-projects/[subId]/route.ts

@@ -0,0 +1,39 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getSubProject, updateSubProject, deleteSubProject } from '@/lib/db/queries/sub-projects';
+
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string; subId: string }> },
+) {
+  const { subId } = await params;
+  const sp = getSubProject(subId);
+  if (!sp) {
+    return NextResponse.json({ error: 'Sub-project not found' }, { status: 404 });
+  }
+  return NextResponse.json(sp);
+}
+
+export async function PUT(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string; subId: string }> },
+) {
+  const { subId } = await params;
+  const body = await request.json();
+  const sp = updateSubProject(subId, body);
+  if (!sp) {
+    return NextResponse.json({ error: 'Sub-project not found' }, { status: 404 });
+  }
+  return NextResponse.json(sp);
+}
+
+export async function DELETE(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string; subId: string }> },
+) {
+  const { subId } = await params;
+  const deleted = deleteSubProject(subId);
+  if (!deleted) {
+    return NextResponse.json({ error: 'Sub-project not found' }, { status: 404 });
+  }
+  return NextResponse.json({ success: true });
+}

package/src/app/api/projects/[id]/sub-projects/[subId]/tasks/[taskId]/chat/route.ts

@@ -0,0 +1,60 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getTaskConversations, addTaskConversation } from '@/lib/db/queries/task-conversations';
+import { getTask } from '@/lib/db/queries/tasks';
+import { getTaskPrompt } from '@/lib/db/queries/task-prompts';
+import { getBrainstorm } from '@/lib/db/queries/brainstorms';
+import { runClaude } from '@/lib/ai/client';
+
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string; subId: string; taskId: string }> },
+) {
+  const { taskId } = await params;
+  const conversations = getTaskConversations(taskId);
+  return NextResponse.json(conversations);
+}
+
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string; subId: string; taskId: string }> },
+) {
+  const { id: projectId, taskId } = await params;
+  const body = await request.json();
+
+  if (!body.message || typeof body.message !== 'string') {
+    return NextResponse.json({ error: 'message is required' }, { status: 400 });
+  }
+
+  const task = getTask(taskId);
+  if (!task) {
+    return NextResponse.json({ error: 'Task not found' }, { status: 404 });
+  }
+
+  // Save user message
+  const userMsg = addTaskConversation(taskId, 'user', body.message);
+
+  // Build context for AI
+  const history = getTaskConversations(taskId);
+  const prompt = getTaskPrompt(taskId);
+  const brainstorm = getBrainstorm(projectId);
+
+  const systemPrompt = `You are a helpful assistant helping refine a development task. Respond in Korean. Be concise.
+
+Task: ${task.title}
+Description: ${task.description}
+Status: ${task.status}
+${prompt?.content ? `Current prompt:\n${prompt.content}` : ''}
+${brainstorm?.content ? `\nBrainstorming context:\n${brainstorm.content.slice(0, 3000)}` : ''}`;
+
+  const conversationText = history
+    .map(m => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}`)
+    .join('\n');
+
+  try {
+    const aiResponse = await runClaude(`${systemPrompt}\n\nConversation:\n${conversationText}`);
+    const aiMsg = addTaskConversation(taskId, 'assistant', aiResponse.trim());
+    return NextResponse.json({ userMessage: userMsg, aiMessage: aiMsg });
+  } catch {
+    return NextResponse.json({ error: 'AI response failed' }, { status: 500 });
+  }
+}

package/src/app/api/projects/[id]/sub-projects/[subId]/tasks/[taskId]/prompt/route.ts

@@ -0,0 +1,26 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getTaskPrompt, upsertTaskPrompt } from '@/lib/db/queries/task-prompts';
+
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string; subId: string; taskId: string }> },
+) {
+  const { taskId } = await params;
+  const prompt = getTaskPrompt(taskId);
+  return NextResponse.json(prompt ?? { content: '', prompt_type: 'manual' });
+}
+
+export async function PUT(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string; subId: string; taskId: string }> },
+) {
+  const { taskId } = await params;
+  const body = await request.json();
+
+  if (typeof body.content !== 'string') {
+    return NextResponse.json({ error: 'content is required' }, { status: 400 });
+  }
+
+  const prompt = upsertTaskPrompt(taskId, body.content, body.prompt_type);
+  return NextResponse.json(prompt);
+}

package/src/app/api/projects/[id]/sub-projects/[subId]/tasks/[taskId]/route.ts

@@ -0,0 +1,39 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getTask, updateTask, deleteTask } from '@/lib/db/queries/tasks';
+
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string; subId: string; taskId: string }> },
+) {
+  const { taskId } = await params;
+  const task = getTask(taskId);
+  if (!task) {
+    return NextResponse.json({ error: 'Task not found' }, { status: 404 });
+  }
+  return NextResponse.json(task);
+}
+
+export async function PUT(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string; subId: string; taskId: string }> },
+) {
+  const { taskId } = await params;
+  const body = await request.json();
+  const task = updateTask(taskId, body);
+  if (!task) {
+    return NextResponse.json({ error: 'Task not found' }, { status: 404 });
+  }
+  return NextResponse.json(task);
+}
+
+export async function DELETE(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string; subId: string; taskId: string }> },
+) {
+  const { taskId } = await params;
+  const deleted = deleteTask(taskId);
+  if (!deleted) {
+    return NextResponse.json({ error: 'Task not found' }, { status: 404 });
+  }
+  return NextResponse.json({ success: true });
+}

package/src/app/api/projects/[id]/sub-projects/[subId]/tasks/route.ts

@@ -0,0 +1,33 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getTasks, createTask } from '@/lib/db/queries/tasks';
+
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string; subId: string }> },
+) {
+  const { subId } = await params;
+  const tasks = getTasks(subId);
+  return NextResponse.json(tasks);
+}
+
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string; subId: string }> },
+) {
+  const { id, subId } = await params;
+  const body = await request.json();
+
+  if (!body.title || typeof body.title !== 'string') {
+    return NextResponse.json({ error: 'title is required' }, { status: 400 });
+  }
+
+  const task = createTask({
+    project_id: id,
+    sub_project_id: subId,
+    title: body.title,
+    description: body.description,
+    status: body.status,
+    priority: body.priority,
+  });
+  return NextResponse.json(task, { status: 201 });
+}

package/src/app/api/projects/[id]/sub-projects/route.ts

@@ -0,0 +1,31 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getSubProjectsWithStats, createSubProject } from '@/lib/db/queries/sub-projects';
+
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const { id } = await params;
+  const subProjects = getSubProjectsWithStats(id);
+  return NextResponse.json(subProjects);
+}
+
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const { id } = await params;
+  const body = await request.json();
+
+  if (!body.name || typeof body.name !== 'string') {
+    return NextResponse.json({ error: 'name is required' }, { status: 400 });
+  }
+
+  const sp = createSubProject({
+    project_id: id,
+    name: body.name,
+    description: body.description,
+    folder_path: body.folder_path,
+  });
+  return NextResponse.json(sp, { status: 201 });
+}

package/src/app/api/projects/route.ts

@@ -14,6 +14,6 @@ export async function POST(request: NextRequest) {
     return NextResponse.json({ error: 'name is required' }, { status: 400 });
   }
 
-  const project = createProject(name, description || '');
+  const project = createProject(name, description || '', body.project_path || undefined);
   return NextResponse.json(project, { status: 201 });
 }