idea-manager 0.2.0 → 0.3.1

package/README.md

@@ -1,42 +1,34 @@
 # IM (Idea Manager)
 
-> 자유롭게 아이디어를 쏟아내면, AI가 구조화해드립니다.
+> 아이디어에서 실행 가능한 프롬프트까지, 멀티 프로젝트 워크플로우 매니저
 
-브레인스토밍 텍스트를 AI가 분석하여 실행 가능한 작업 트리로 변환하고, 각 작업에 대한 프롬프트를 생성하여 MCP Server를 통해 AI 에이전트가 자율적으로 실행할 수 있게 하는 도구입니다.
+여러 프로젝트를 동시에 진행하는 개발자를 위한 태스크 관리 도구입니다. 아이디어를 서브 프로젝트와 태스크로 조직화하고, 각 태스크별 프롬프트를 정제하여 Claude Code 등 AI 에이전트에게 전달할 수 있습니다. MCP Server를 내장하고 있어 AI 에이전트가 자율적으로 태스크를 가져가 실행할 수 있습니다.
 
 ## 핵심 워크플로우
 
 ```
-브레인스토밍 → AI 구조화 → 프롬프트 생성 → MCP 실행
+브레인스토밍 → 서브 프로젝트/태스크 조직화 → 프롬프트 정제 → MCP로 AI 실행
 ```
 
-### 1. 브레인스토밍
-
-자유로운 형태로 아이디어를 작성합니다. 구조나 형식에 구애받지 않고 생각나는 대로 써내려갑니다.
-
-### 2. AI 구조화
-
-AI가 브레인스토밍 텍스트를 분석하여 계층형 작업 트리로 변환합니다.
-모호한 부분이 있으면 AI가 질문을 던지고, 채팅을 통해 답변하면 구조가 점점 정교해집니다.
+### 계층 구조
 
 ```
 프로젝트
-├── 기능 A (feature)
-│   ├── 작업 A-1 (task)
-│   └── 작업 A-2 (task)
-├── 기능 B (feature)
-│   └── 버그 수정 (bug)
-└── 아이디어 메모 (idea)
+├── 서브 프로젝트 A
+│   ├── 태스크 1  →  프롬프트
+│   ├── 태스크 2  →  프롬프트
+│   └── 태스크 3  →  프롬프트
+└── 서브 프로젝트 B
+    ├── 태스크 4  →  프롬프트
+    └── 태스크 5  →  프롬프트
 ```
 
-### 3. 프롬프트 생성
-
-구조화된 각 항목에 대해 AI가 실행 가능한 프롬프트를 자동 생성합니다.
-수동으로 편집하거나 직접 작성할 수도 있습니다.
+### 태스크 상태 흐름
 
-### 4. MCP 실행
-
-내장된 MCP Server를 통해 Claude 등 AI 에이전트가 작업을 조회하고, 상태를 업데이트하며, 순차적으로 실행할 수 있습니다.
+```
+💡 Idea → ✏️ Writing → 🚀 Submitted → 🧪 Testing → ✅ Done
+                                                      🔴 Problem
+```
 
 ## 설치
 
@@ -52,7 +44,7 @@ npm install -g idea-manager
 im start
 ```
 
-자동으로 `http://localhost:3456`에서 웹 UI가 열립니다.
+`http://localhost:3456`에서 웹 UI가 열립니다.
 
 ```bash
 # 포트 변경
@@ -65,8 +57,6 @@ im start -p 4000
 im mcp
 ```
 
-Claude Desktop, Claude Code 등에서 MCP Server로 연결하여 AI 에이전트가 작업을 자율 실행할 수 있습니다.
-
 #### Claude Desktop 설정 (claude_desktop_config.json)
 
 ```json
@@ -91,27 +81,29 @@ claude mcp add idea-manager -- npx -y idea-manager mcp
 | 도구 | 설명 |
 |------|------|
 | `list-projects` | 프로젝트 목록 조회 |
-| `get-project-context` | 프로젝트 전체 구조와 진행 상태 조회 |
-| `get-next-task` | 다음 실행 가능한 작업과 프롬프트 조회 |
-| `get-prompt` | 특정 항목의 프롬프트 조회 |
-| `update-status` | 작업 상태 변경 (pending / in_progress / done) |
-| `report-completion` | 작업 완료 보고 (자동 잠금) |
+| `get-project-context` | 서브 프로젝트 + 태스크 트리 전체 조회 |
+| `get-next-task` | 다음 실행할 태스크와 프롬프트 조회 (status=submitted) |
+| `get-task-prompt` | 특정 태스크의 프롬프트 조회 |
+| `update-status` | 태스크 상태 변경 (idea/writing/submitted/testing/done/problem) |
+| `report-completion` | 태스크 완료 보고 |
 
 ## 주요 기능
 
-- **자유 형식 브레인스토밍** - 구조 없이 아이디어를 쏟아내는 에디터
-- **AI 대화형 구조화** - AI가 질문하고 유저가 답변하며 구조를 정교화
-- **계층형 작업 트리** - feature / task / bug / idea / note 유형 분류
-- **잠금/해제 시스템** - 작업 실행 순서를 제어하는 Lock 메커니즘
-- **프롬프트 자동 생성** - 각 작업에 대한 실행 프롬프트 생성
-- **MCP Server 내장** - AI 에이전트 자율 실행 지원
-- **로컬 우선** - SQLite 기반, 데이터는 `~/.idea-manager/`에 저장
+- **3-패널 워크스페이스** — 브레인스토밍 | 프로젝트 트리 | 태스크 상세, 패널 간 드래그로 크기 조절
+- **트리형 프로젝트 구조** — 서브 프로젝트 아래 태스크가 계층적으로 표시
+- **브레인스토밍 패널** — 자유 형식 메모, 접기/펼치기 가능
+- **프롬프트 에디터** — 태스크별 프롬프트 작성/편집/복사, AI 다듬기
+- **AI 채팅** — 태스크별 AI 대화로 프롬프트 구체화
+- **3탭 대시보드** — 진행 중 / 전체 / 오늘 할 일
+- **키보드 단축키** — 한영 전환 상관없이 동작 (B: 브레인스토밍 토글, N: 서브 프로젝트 추가, T: 태스크 추가, Cmd+1~6: 상태 변경)
+- **MCP Server 내장** — AI 에이전트 자율 실행 지원
+- **로컬 우선** — SQLite 기반, 데이터는 `~/.idea-manager/`에 저장
 
 ## 기술 스택
 
 | 영역 | 기술 |
 |------|------|
-| Frontend | Next.js, React 19, TypeScript, Tailwind CSS 4 |
+| Frontend | Next.js 15, React 19, TypeScript, Tailwind CSS 4 |
 | Backend | Next.js API Routes |
 | Database | SQLite (better-sqlite3) |
 | AI | Anthropic Claude (Agent SDK) |
@@ -121,7 +113,7 @@ claude mcp add idea-manager -- npx -y idea-manager mcp
 ## 환경 변수
 
 ```bash
-ANTHROPIC_API_KEY=sk-ant-...  # Claude API 키 (AI 기능에 필요)
+ANTHROPIC_API_KEY=sk-ant-...  # Claude API 키 (AI 채팅/다듬기에 필요, 없어도 기본 기능은 동작)
 ```
 
 ## 라이선스

package/next.config.ts

@@ -1,7 +1,6 @@
 import type { NextConfig } from "next";
 
 const nextConfig: NextConfig = {
-  output: 'standalone',
   serverExternalPackages: ['better-sqlite3'],
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "idea-manager",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "AI 기반 브레인스토밍 → 구조화 → 프롬프트 생성 도구. MCP Server 내장.",
   "keywords": [
     "brainstorm",
@@ -37,7 +37,7 @@
     "mcp": "tsx src/cli.ts mcp"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.66",
+    "@anthropic-ai/sdk": "^0.78.0",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "better-sqlite3": "^12.6.2",
     "commander": "^14.0.3",

package/{src/app/icon.svg → public/favicon.svg}

@@ -5,6 +5,6 @@
       <stop offset="100%" stop-color="#8b5cf6"/>
     </linearGradient>
   </defs>
-  <rect width="512" height="512" rx="108" fill="url(#bg)"/>
-  <text x="256" y="390" font-family="system-ui, -apple-system, sans-serif" font-size="420" font-weight="900" fill="white" text-anchor="middle">I</text>
+  <rect width="512" height="512" rx="96" fill="url(#bg)"/>
+  <text x="256" y="390" font-family="Georgia, 'Times New Roman', serif" font-size="420" font-weight="700" fill="white" text-anchor="middle">I</text>
 </svg>

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

@@ -0,0 +1,49 @@
+import { NextRequest, NextResponse } from 'next/server';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const IGNORED = new Set([
+  'node_modules', '.git', '.next', 'dist', 'build', '__pycache__',
+  '.cache', '.tmp', '.DS_Store', 'coverage', '.turbo', '.vercel',
+]);
+
+export async function GET(request: NextRequest) {
+  const dirPath = request.nextUrl.searchParams.get('path') || os.homedir();
+
+  try {
+    const resolved = path.resolve(dirPath);
+
+    if (!fs.existsSync(resolved)) {
+      return NextResponse.json({ error: '경로가 존재하지 않습니다' }, { status: 404 });
+    }
+
+    const stat = fs.statSync(resolved);
+    if (!stat.isDirectory()) {
+      return NextResponse.json({ error: '디렉토리가 아닙니다' }, { status: 400 });
+    }
+
+    const entries = fs.readdirSync(resolved, { withFileTypes: true });
+    const dirs = entries
+      .filter(e => e.isDirectory() && !e.name.startsWith('.') && !IGNORED.has(e.name))
+      .map(e => ({
+        name: e.name,
+        path: path.join(resolved, e.name),
+      }))
+      .sort((a, b) => a.name.localeCompare(b.name));
+
+    // Check for project markers
+    const hasPackageJson = fs.existsSync(path.join(resolved, 'package.json'));
+    const hasReadme = fs.existsSync(path.join(resolved, 'README.md'));
+    const hasGit = fs.existsSync(path.join(resolved, '.git'));
+
+    return NextResponse.json({
+      current: resolved,
+      parent: path.dirname(resolved) !== resolved ? path.dirname(resolved) : null,
+      dirs,
+      isProject: hasPackageJson || hasReadme || hasGit,
+    });
+  } catch {
+    return NextResponse.json({ error: '디렉토리를 읽을 수 없습니다' }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,32 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getProject } from '@/lib/db/queries/projects';
+import { getItemTree } from '@/lib/db/queries/items';
+import { getBrainstorm } from '@/lib/db/queries/brainstorms';
+import { cleanupItems } from '@/lib/ai/cleanup';
+
+export async function POST(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const { id } = await params;
+  const project = getProject(id);
+  if (!project) {
+    return NextResponse.json({ error: 'Project not found' }, { status: 404 });
+  }
+
+  const items = getItemTree(id);
+  if (items.length === 0) {
+    return NextResponse.json({ items: [], changed: false });
+  }
+
+  const brainstorm = getBrainstorm(id);
+  const brainstormContent = brainstorm?.content || '';
+
+  try {
+    const result = await cleanupItems(id, brainstorm?.id || '', items, brainstormContent);
+    return NextResponse.json(result);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Cleanup failed';
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

package/src/app/api/projects/[id]/items/[itemId]/refine/route.ts

@@ -0,0 +1,36 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getItem } from '@/lib/db/queries/items';
+import { getProject } from '@/lib/db/queries/projects';
+import { refineItem } from '@/lib/ai/refiner';
+
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string; itemId: string }> },
+) {
+  const { id: projectId, itemId } = await params;
+
+  const project = getProject(projectId);
+  if (!project) {
+    return NextResponse.json({ error: 'Project not found' }, { status: 404 });
+  }
+
+  const item = getItem(itemId);
+  if (!item || item.project_id !== projectId) {
+    return NextResponse.json({ error: 'Item not found' }, { status: 404 });
+  }
+
+  const body = await request.json();
+  const { message } = body;
+
+  if (!message || typeof message !== 'string' || !message.trim()) {
+    return NextResponse.json({ error: 'Message is required' }, { status: 400 });
+  }
+
+  try {
+    const result = await refineItem(item, message.trim());
+    return NextResponse.json(result);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : 'Refine failed';
+    return NextResponse.json({ error: msg }, { status: 500 });
+  }
+}

package/src/app/api/projects/[id]/items/[itemId]/route.ts

@@ -1,6 +1,6 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { getDb } from '@/lib/db/index';
-import { updateItem } from '@/lib/db/queries/items';
+import { updateItem, deleteItem } from '@/lib/db/queries/items';
 import type { IItem, ItemStatus } from '@/types';
 
 export async function GET(
@@ -48,6 +48,10 @@ export async function PUT(
     }
   }
 
+  if (body.is_pinned !== undefined) {
+    updates.is_pinned = Boolean(body.is_pinned);
+  }
+
   if (body.title !== undefined) updates.title = body.title;
   if (body.description !== undefined) updates.description = body.description;
   if (body.priority !== undefined) updates.priority = body.priority;
@@ -61,6 +65,24 @@ export async function PUT(
   return NextResponse.json(updated);
 }
 
+export async function DELETE(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string; itemId: string }> },
+) {
+  const { id: projectId, itemId } = await params;
+  const db = getDb();
+
+  const item = db.prepare('SELECT * FROM items WHERE id = ? AND project_id = ?')
+    .get(itemId, projectId) as IItem | undefined;
+
+  if (!item) {
+    return NextResponse.json({ error: 'Item not found' }, { status: 404 });
+  }
+
+  deleteItem(itemId);
+  return NextResponse.json({ success: true });
+}
+
 function lockChildrenRecursive(db: ReturnType<typeof getDb>, parentId: string, locked: boolean) {
   const now = new Date().toISOString();
   const children = db.prepare('SELECT id FROM items WHERE parent_id = ?').all(parentId) as { id: string }[];

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

@@ -1,6 +1,6 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { getProject } from '@/lib/db/queries/projects';
-import { getItemTree } from '@/lib/db/queries/items';
+import { getItemTree, deleteItem, deleteItemsByProject, bulkUpdateStatus } from '@/lib/db/queries/items';
 
 export async function GET(
   _request: NextRequest,
@@ -15,3 +15,53 @@ export async function GET(
   const tree = getItemTree(id);
   return NextResponse.json(tree);
 }
+
+// Bulk delete: DELETE /api/projects/[id]/items
+// body: { itemIds: string[] } or { all: true }
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const { id } = await params;
+  const project = getProject(id);
+  if (!project) {
+    return NextResponse.json({ error: 'Project not found' }, { status: 404 });
+  }
+
+  const body = await request.json();
+
+  if (body.all) {
+    deleteItemsByProject(id);
+  } else if (Array.isArray(body.itemIds)) {
+    for (const itemId of body.itemIds) {
+      deleteItem(itemId);
+    }
+  } else {
+    return NextResponse.json({ error: 'itemIds or all required' }, { status: 400 });
+  }
+
+  const tree = getItemTree(id);
+  return NextResponse.json(tree);
+}
+
+// Bulk update status: PATCH /api/projects/[id]/items
+// body: { status: 'done' | 'pending' | 'in_progress' }
+export async function PATCH(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const { id } = await params;
+  const project = getProject(id);
+  if (!project) {
+    return NextResponse.json({ error: 'Project not found' }, { status: 404 });
+  }
+
+  const body = await request.json();
+  if (!body.status) {
+    return NextResponse.json({ error: 'status required' }, { status: 400 });
+  }
+
+  bulkUpdateStatus(id, body.status);
+  const tree = getItemTree(id);
+  return NextResponse.json(tree);
+}

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

@@ -0,0 +1,73 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getProject } from '@/lib/db/queries/projects';
+import { getProjectContexts, replaceProjectContexts } from '@/lib/db/queries/context';
+import { scanProjectDirectory } from '@/lib/scanner';
+import { getFileCategory } from '@/lib/scanner';
+
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const { id } = await params;
+  const project = getProject(id);
+  if (!project) {
+    return NextResponse.json({ error: 'Project not found' }, { status: 404 });
+  }
+
+  const contexts = getProjectContexts(id);
+  if (contexts.length === 0) {
+    return NextResponse.json({ exists: false, files: [], total: 0, totalSize: 0, scannedAt: null });
+  }
+
+  const files = contexts.map(c => ({
+    file_path: c.file_path,
+    size: c.content.length,
+    category: getFileCategory(c.file_path),
+    folder: getFolder(c.file_path),
+  }));
+
+  return NextResponse.json({
+    exists: true,
+    files,
+    total: contexts.length,
+    totalSize: contexts.reduce((s, c) => s + c.content.length, 0),
+    scannedAt: contexts[0]?.scanned_at || null,
+  });
+}
+
+function getFolder(filePath: string): string {
+  const parts = filePath.split('/');
+  if (parts.length <= 1 || filePath.startsWith('__')) return '(root)';
+  return parts[0];
+}
+
+export async function POST(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const { id } = await params;
+  const project = getProject(id);
+  if (!project) {
+    return NextResponse.json({ error: 'Project not found' }, { status: 404 });
+  }
+
+  if (!project.project_path) {
+    return NextResponse.json({ error: '프로젝트 경로가 설정되지 않았습니다' }, { status: 400 });
+  }
+
+  try {
+    const scanned = scanProjectDirectory(project.project_path);
+    const contexts = replaceProjectContexts(id, scanned);
+
+    return NextResponse.json({
+      files: contexts.map(c => ({
+        file_path: c.file_path,
+        size: c.content.length,
+      })),
+      total: contexts.length,
+    });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : 'Scan failed';
+    return NextResponse.json({ error: msg }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,112 @@
+import { NextRequest } from 'next/server';
+import { getProject } from '@/lib/db/queries/projects';
+import { replaceProjectContexts } from '@/lib/db/queries/context';
+import { scanProjectDirectoryStream } from '@/lib/scanner';
+import { runAnalysis } from '@/lib/ai/client';
+
+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 });
+  }
+
+  if (!project.project_path) {
+    return new Response('No project path', { status: 400 });
+  }
+
+  const projectPath = project.project_path;
+  const projectId = id;
+
+  const stream = new ReadableStream({
+    async start(controller) {
+      const encoder = new TextEncoder();
+
+      const send = (event: string, data: unknown) => {
+        try {
+          controller.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
+        } catch { /* closed */ }
+      };
+      let directoryTree = '';
+      let readmeContent = '';
+      let packageJsonContent = '';
+
+      try {
+        const generator = scanProjectDirectoryStream(projectPath);
+
+        for (const event of generator) {
+          if (event.type === 'scanning_dir') {
+            send('scanning', { dir: event.dir });
+          } else if (event.type === 'file_found') {
+            send('file', {
+              file_path: event.file!.file_path,
+              size: event.file!.size,
+              category: event.file!.category,
+              folder: event.file!.folder,
+              summarized: event.file!.summarized,
+            });
+          } else if (event.type === 'done') {
+            replaceProjectContexts(projectId, event.results!);
+            directoryTree = event.results?.find(r => r.file_path === '__directory_tree.txt')?.content || '';
+            readmeContent = event.results?.find(r => r.file_path.match(/^README\.md$/i))?.content || '';
+            packageJsonContent = event.results?.find(r => r.file_path === 'package.json')?.content || '';
+            send('scan_complete', {
+              total: event.total,
+              totalSize: event.totalSize,
+            });
+          }
+        }
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : 'Scan failed';
+        send('error', { error: msg });
+        controller.close();
+        return;
+      }
+
+      // Phase 2: Auto-analyze project with AI
+      send('analyzing', { message: '프로젝트를 분석하고 있습니다...' });
+
+      const analysisPrompt = `아래 프로젝트의 디렉토리 구조와 핵심 파일을 보고, 이 프로젝트에 대해 간결하게 설명해주세요.
+
+다음 형식으로 작성해주세요 (마크다운 없이 평문):
+1. 프로젝트 목적 (1줄)
+2. 기술 스택 (1줄)
+3. 주요 서브 프로젝트/모듈 구성 (2-3줄)
+4. 현재 개발 상태 추정 (1줄)
+
+간결하고 핵심만 담아주세요. 한국어로 작성하세요.
+
+=== 디렉토리 구조 ===
+${directoryTree.slice(0, 5000)}
+
+${readmeContent ? `=== README.md ===\n${readmeContent.slice(0, 3000)}` : ''}
+
+${packageJsonContent ? `=== package.json ===\n${packageJsonContent.slice(0, 2000)}` : ''}`;
+
+      try {
+        const analysisResult = await runAnalysis(analysisPrompt, (text) => {
+          send('analysis_text', { text });
+        });
+        send('analysis_done', { description: analysisResult });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : 'Analysis failed';
+        console.error('[scan] Auto-analysis failed:', msg);
+        send('analysis_done', { description: '', error: msg });
+      }
+
+      controller.close();
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+      'X-Accel-Buffering': 'no',
+    },
+  });
+}

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

@@ -1,7 +1,26 @@
 import { NextRequest, NextResponse } 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 { structureWithChat } from '@/lib/ai/structurer';
+import { getTask } from '@/lib/task-store';
+
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const { id } = await params;
+  const task = getTask(id);
+  if (!task) {
+    return NextResponse.json({ active: false });
+  }
+  return NextResponse.json({
+    active: task.status === 'running',
+    status: task.status,
+    startedAt: task.startedAt,
+    eventCount: task.events.length,
+  });
+}
 
 export async function POST(
   _request: NextRequest,
@@ -14,12 +33,24 @@ export async function POST(
   }
 
   const brainstorm = getBrainstorm(id);
-  if (!brainstorm || !brainstorm.content.trim()) {
-    return NextResponse.json({ error: 'No brainstorm content to structure' }, { status: 400 });
+  if (!brainstorm) {
+    return NextResponse.json({ error: 'Project not initialized' }, { status: 400 });
   }
 
+  const hasContent = brainstorm.content.trim();
+  const hasContext = !!getProjectContextSummary(id);
+
+  if (!hasContent && !hasContext) {
+    return NextResponse.json({ error: '브레인스토밍 내용이나 프로젝트 스캔 결과가 필요합니다' }, { status: 400 });
+  }
+
+  // If brainstorm is empty but project context exists, use a placeholder prompt
+  const content = hasContent
+    ? brainstorm.content
+    : '프로젝트 스캔 결과를 분석하여 현재 프로젝트의 구조, 진행 상황, TODO 항목을 파악해주세요.';
+
   try {
-    const result = await structureWithChat(id, brainstorm.id, brainstorm.content);
+    const result = await structureWithChat(id, brainstorm.id, content);
     return NextResponse.json(result);
   } catch (error) {
     const message = error instanceof Error ? error.message : 'AI structuring failed';