idea-manager 0.2.0 → 0.3.0

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.0",
   "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';

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',
+    },
+  });
+}