idea-manager 0.4.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "idea-manager",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "AI 기반 브레인스토밍 → 구조화 → 프롬프트 생성 도구. MCP Server 내장.",
   "keywords": [
     "brainstorm",

package/src/app/projects/[id]/page.tsx

@@ -334,10 +334,6 @@ function WorkspaceInner({ id }: { id: string }) {
             <div style={{ width: leftWidth }} className="border-r border-border flex flex-col flex-shrink-0">
               <Editor
                 projectId={id}
-                onContentChange={() => {}}
-                onSendMessage={() => {}}
-                memos={[]}
-                chatLoading={false}
                 onCollapse={() => setShowBrainstorm(false)}
               />
             </div>

package/src/components/brainstorm/Editor.tsx

@@ -1,39 +1,18 @@
 'use client';
 
 import { useState, useEffect, useRef, useCallback } from 'react';
-import MemoPin from './MemoPin';
-
-interface Memo {
-  id: string;
-  anchor_text: string;
-  question: string;
-  is_resolved: boolean;
-}
 
 interface EditorProps {
   projectId: string;
-  onContentChange: (content: string) => void;
-  onSendMessage: (message: string) => void;
-  memos?: Memo[];
-  chatLoading?: boolean;
   onCollapse?: () => void;
 }
 
-interface PinPosition {
-  memo: Memo;
-  top: number;
-  left: number;
-}
-
-export default function Editor({ projectId, onContentChange, onSendMessage, memos = [], chatLoading, onCollapse }: EditorProps) {
+export default function Editor({ projectId, onCollapse }: EditorProps) {
   const [content, setContent] = useState('');
   const [saving, setSaving] = useState(false);
   const [loaded, setLoaded] = useState(false);
-  const [pinPositions, setPinPositions] = useState<PinPosition[]>([]);
   const saveTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-  const structureTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const textareaRef = useRef<HTMLTextAreaElement>(null);
-  const overlayRef = useRef<HTMLDivElement>(null);
 
   // Load brainstorm content
   useEffect(() => {
@@ -46,37 +25,6 @@ export default function Editor({ projectId, onContentChange, onSendMessage, memo
     load();
   }, [projectId]);
 
-  // Calculate pin positions when memos or content change
-  useEffect(() => {
-    if (!textareaRef.current || !content) {
-      setPinPositions([]);
-      return;
-    }
-
-    const textarea = textareaRef.current;
-    const unresolvedMemos = memos.filter(m => !m.is_resolved);
-    const positions: PinPosition[] = [];
-
-    for (const memo of unresolvedMemos) {
-      const idx = content.indexOf(memo.anchor_text);
-      if (idx === -1) continue;
-
-      // Calculate approximate position based on character index
-      const textBefore = content.substring(0, idx);
-      const lines = textBefore.split('\n');
-      const lineNumber = lines.length - 1;
-      const lineHeight = parseFloat(getComputedStyle(textarea).lineHeight) || 22;
-      const paddingTop = parseFloat(getComputedStyle(textarea).paddingTop) || 16;
-
-      const top = paddingTop + lineNumber * lineHeight;
-      const left = textarea.clientWidth - 28;
-
-      positions.push({ memo, top, left });
-    }
-
-    setPinPositions(positions);
-  }, [memos, content]);
-
   const saveContent = useCallback(async (text: string) => {
     setSaving(true);
     await fetch(`/api/projects/${projectId}/brainstorm`, {
@@ -96,21 +44,6 @@ export default function Editor({ projectId, onContentChange, onSendMessage, memo
     saveTimerRef.current = setTimeout(() => {
       saveContent(newContent);
     }, 1000);
-
-    // Trigger AI structuring with 3s debounce
-    if (structureTimerRef.current) clearTimeout(structureTimerRef.current);
-    if (newContent.trim()) {
-      structureTimerRef.current = setTimeout(() => {
-        onContentChange(newContent);
-      }, 3000);
-    }
-  };
-
-  // Sync scroll between textarea and overlay
-  const handleScroll = () => {
-    if (textareaRef.current && overlayRef.current) {
-      overlayRef.current.scrollTop = textareaRef.current.scrollTop;
-    }
   };
 
   if (!loaded) {
@@ -145,7 +78,6 @@ export default function Editor({ projectId, onContentChange, onSendMessage, memo
           ref={textareaRef}
           value={content}
           onChange={handleChange}
-          onScroll={handleScroll}
           placeholder={`자유롭게 아이디어를 적어보세요...
 
 예시:
@@ -158,21 +90,6 @@ export default function Editor({ projectId, onContentChange, onSendMessage, memo
                      placeholder:text-muted-foreground/40 font-mono text-sm leading-relaxed"
           spellCheck={false}
         />
-        {pinPositions.length > 0 && (
-          <div ref={overlayRef} className="memo-overlay">
-            {pinPositions.map((pin) => (
-              <MemoPin
-                key={pin.memo.id}
-                question={pin.memo.question}
-                anchorText={pin.memo.anchor_text}
-                top={pin.top}
-                left={pin.left}
-                loading={chatLoading}
-                onSendMessage={onSendMessage}
-              />
-            ))}
-          </div>
-        )}
       </div>
     </div>
   );

package/src/lib/ai/client.ts

@@ -1,14 +1,4 @@
 import { spawn } from 'node:child_process';
-import type { IStructureWithQuestions } from '@/types';
-
-export interface IStructuredItem {
-  title: string;
-  description: string;
-  item_type: 'feature' | 'task' | 'bug' | 'idea' | 'note';
-  priority: 'high' | 'medium' | 'low';
-  status?: 'pending' | 'in_progress' | 'done';
-  children?: IStructuredItem[];
-}
 
 const CLI_PATH = 'claude';
 const DEFAULT_ARGS = ['--dangerously-skip-permissions'];
@@ -122,116 +112,3 @@ export function runClaude(prompt: string, onText?: OnTextChunk, onRawEvent?: OnR
     });
   });
 }
-
-/**
- * Run Claude for free-form markdown analysis (not JSON).
- * Used for building the hub document in multi-agent analysis.
- */
-export function runAnalysis(prompt: string, onText?: OnTextChunk, onRawEvent?: OnRawEvent): Promise<string> {
-  return runClaude(prompt, onText, onRawEvent);
-}
-
-export function extractJson(text: string, type: 'array' | 'object'): string {
-  // Strip markdown fences
-  text = text.replace(/```(?:json)?\s*/g, '').replace(/```\s*/g, '').trim();
-  const pattern = type === 'array' ? /\[[\s\S]*\]/ : /\{[\s\S]*\}/;
-  const match = text.match(pattern);
-  if (!match) {
-    throw new Error(`AI did not return valid JSON ${type}`);
-  }
-  return match[0];
-}
-
-export async function runStructure(brainstormContent: string, projectContext?: string, onText?: OnTextChunk, onRawEvent?: OnRawEvent): Promise<IStructuredItem[]> {
-  const systemPrompt = `You are a JSON-only structuring machine. You NEVER respond with text, explanations, or conversation.
-You ALWAYS output ONLY a raw JSON array, nothing else.
-
-Your job: convert ANY input text into a structured JSON array of items.
-Even if the input seems like a greeting or conversation, extract the implicit intent and structure it.
-
-Schema per item:
-{ "title": string, "description": string, "item_type": "feature"|"task"|"bug"|"idea"|"note", "priority": "high"|"medium"|"low", "status": "pending"|"in_progress"|"done", "children": [same schema] }
-
-Rules:
-- Output MUST start with [ and end with ]
-- No markdown fences, no explanation, no text before or after the JSON
-- Keep titles concise (under 50 chars)
-- Group related ideas under parent items
-- If input is vague, interpret it as best you can and create at least 1 item
-- IMPORTANT: When project source code context is provided, judge the status based on the actual code:
-  - "done": feature/task is fully implemented in the source code
-  - "in_progress": partially implemented or has TODOs
-  - "pending": not yet started or only planned
-- If no source code context is provided, default status to "pending"`;
-
-  const ctxBlock = projectContext ? `\n\n프로젝트 문서 컨텍스트:\n${projectContext}` : '';
-  const prompt = `${systemPrompt}\n\nAnalyze this brainstorming content and structure it into a JSON tree:\n\n${brainstormContent}${ctxBlock}`;
-
-  const resultText = await runClaude(prompt, onText, onRawEvent);
-  const json = extractJson(resultText, 'array');
-  return JSON.parse(json) as IStructuredItem[];
-}
-
-export async function runStructureWithQuestions(
-  brainstormContent: string,
-  conversationHistory: { role: 'assistant' | 'user'; content: string }[],
-  projectContext?: string,
-  onText?: OnTextChunk,
-  onRawEvent?: OnRawEvent,
-  existingStructure?: string,
-): Promise<IStructureWithQuestions> {
-  const systemPrompt = `You are an AI assistant that structures brainstorming content AND identifies ambiguous areas.
-You ALWAYS output ONLY a raw JSON object (not an array), nothing else.
-
-Your job:
-1. Convert the brainstorming text into a structured JSON tree of items
-2. Identify 0-5 areas where the brainstorming is ambiguous or could benefit from clarification
-3. Consider the conversation history to avoid repeating questions already answered
-4. If existing structured items are provided, UPDATE them rather than creating duplicates
-
-Output schema:
-{
-  "items": [{ "title": string, "description": string, "item_type": "feature"|"task"|"bug"|"idea"|"note", "priority": "high"|"medium"|"low", "status": "pending"|"in_progress"|"done", "children": [same] }],
-  "questions": [{ "anchor_text": string, "question": string }]
-}
-
-Rules:
-- Output MUST be a JSON object with "items" and "questions" keys
-- No markdown fences, no explanation, no text before or after the JSON
-- Keep titles concise (under 50 chars)
-- Group related ideas under parent items
-- NEVER create duplicate items. If the existing structure already has an item for a concept, update it instead of adding a new one
-- Merge similar items together. The output should be a clean, deduplicated structure
-- Preserve the status of existing items unless the brainstorming text explicitly changes them
-- questions[].anchor_text MUST be an exact substring from the brainstorming content (5-20 chars)
-- questions[].question should be a helpful Korean question asking for clarification
-- Generate 0-5 questions. Skip questions already answered in conversation history.
-- If the brainstorming is clear enough, return an empty questions array
-- All questions MUST be in Korean
-- If project documentation context is provided, use it to make more informed structuring decisions (e.g., matching tech stack, conventions, existing patterns)
-- IMPORTANT: When project source code context is provided, judge the status based on the actual code:
-  - "done": feature/task is fully implemented in the source code
-  - "in_progress": partially implemented or has TODOs
-  - "pending": not yet started or only planned
-- If no source code context is provided, default status to "pending"`;
-
-  let historyContext = '';
-  if (conversationHistory.length > 0) {
-    historyContext = '\n\n이전 대화:\n' + conversationHistory
-      .map(m => `${m.role === 'user' ? '사용자' : 'AI'}: ${m.content}`)
-      .join('\n');
-  }
-
-  const ctxBlock = projectContext ? `\n\n프로젝트 문서 컨텍스트:\n${projectContext}` : '';
-  const existingBlock = existingStructure ? `\n\n현재 구조화된 항목 (중복 생성하지 말고 업데이트하세요):\n${existingStructure}` : '';
-  const prompt = `${systemPrompt}\n\n다음 브레인스토밍 내용을 분석하고 구조화하세요:\n\n${brainstormContent}${historyContext}${existingBlock}${ctxBlock}`;
-
-  const resultText = await runClaude(prompt, onText, onRawEvent);
-  const json = extractJson(resultText, 'object');
-  const parsed = JSON.parse(json);
-
-  return {
-    items: parsed.items || [],
-    questions: parsed.questions || [],
-  } as IStructureWithQuestions;
-}

package/src/lib/db/schema.ts

@@ -21,78 +21,8 @@ export function initSchema(db: Database.Database): void {
       FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
     );
 
-    CREATE TABLE IF NOT EXISTS items (
-      id TEXT PRIMARY KEY,
-      project_id TEXT NOT NULL,
-      brainstorm_id TEXT,
-      parent_id TEXT,
-      title TEXT NOT NULL,
-      description TEXT NOT NULL DEFAULT '',
-      item_type TEXT NOT NULL DEFAULT 'feature',
-      priority TEXT NOT NULL DEFAULT 'medium',
-      status TEXT NOT NULL DEFAULT 'pending',
-      is_locked INTEGER NOT NULL DEFAULT 1,
-      is_pinned INTEGER NOT NULL DEFAULT 1,
-      sort_order INTEGER NOT NULL DEFAULT 0,
-      metadata TEXT,
-      created_at TEXT NOT NULL DEFAULT (datetime('now')),
-      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
-      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
-      FOREIGN KEY (brainstorm_id) REFERENCES brainstorms(id),
-      FOREIGN KEY (parent_id) REFERENCES items(id)
-    );
-
-    CREATE TABLE IF NOT EXISTS conversations (
-      id TEXT PRIMARY KEY,
-      project_id TEXT NOT NULL,
-      role TEXT NOT NULL CHECK(role IN ('assistant', 'user')),
-      content TEXT NOT NULL,
-      metadata TEXT,
-      created_at TEXT NOT NULL DEFAULT (datetime('now')),
-      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
-    );
-
-    CREATE TABLE IF NOT EXISTS memos (
-      id TEXT PRIMARY KEY,
-      project_id TEXT NOT NULL,
-      conversation_id TEXT,
-      anchor_text TEXT NOT NULL,
-      question TEXT NOT NULL,
-      is_resolved INTEGER NOT NULL DEFAULT 0,
-      created_at TEXT NOT NULL DEFAULT (datetime('now')),
-      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
-      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
-      FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE SET NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS prompts (
-      id TEXT PRIMARY KEY,
-      project_id TEXT NOT NULL,
-      item_id TEXT NOT NULL,
-      content TEXT NOT NULL,
-      prompt_type TEXT NOT NULL DEFAULT 'auto',
-      version INTEGER NOT NULL DEFAULT 1,
-      created_at TEXT NOT NULL DEFAULT (datetime('now')),
-      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
-      FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE CASCADE
-    );
-
-    CREATE TABLE IF NOT EXISTS project_context (
-      id TEXT PRIMARY KEY,
-      project_id TEXT NOT NULL,
-      file_path TEXT NOT NULL,
-      content TEXT NOT NULL,
-      scanned_at TEXT NOT NULL DEFAULT (datetime('now')),
-      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
-    );
   `);
 
-  // Migrations for existing DBs
-  const itemCols = db.prepare("PRAGMA table_info(items)").all() as { name: string }[];
-  if (!itemCols.some(c => c.name === 'is_pinned')) {
-    db.exec("ALTER TABLE items ADD COLUMN is_pinned INTEGER NOT NULL DEFAULT 1");
-  }
-
   const projCols = db.prepare("PRAGMA table_info(projects)").all() as { name: string }[];
   if (!projCols.some(c => c.name === 'project_path')) {
     db.exec("ALTER TABLE projects ADD COLUMN project_path TEXT");

package/src/types/index.ts

@@ -8,14 +8,6 @@ export interface IProject {
   updated_at: string;
 }
 
-export interface IProjectContext {
-  id: string;
-  project_id: string;
-  file_path: string;
-  content: string;
-  scanned_at: string;
-}
-
 export interface IBrainstorm {
   id: string;
   project_id: string;
@@ -25,75 +17,7 @@ export interface IBrainstorm {
   updated_at: string;
 }
 
-export type ItemType = 'feature' | 'task' | 'bug' | 'idea' | 'note';
-export type ItemStatus = 'pending' | 'in_progress' | 'done';
 export type ItemPriority = 'high' | 'medium' | 'low';
-
-export interface IItem {
-  id: string;
-  project_id: string;
-  brainstorm_id: string | null;
-  parent_id: string | null;
-  title: string;
-  description: string;
-  item_type: ItemType;
-  priority: ItemPriority;
-  status: ItemStatus;
-  is_locked: boolean;
-  is_pinned: boolean;
-  sort_order: number;
-  metadata: string | null;
-  created_at: string;
-  updated_at: string;
-}
-
-export interface IItemTree extends IItem {
-  children: IItemTree[];
-}
-
-export interface IStructureResult {
-  items: {
-    id?: string;
-    parent_id: string | null;
-    title: string;
-    description: string;
-    item_type: ItemType;
-    priority: ItemPriority;
-    children?: IStructureResult['items'];
-  }[];
-}
-
-export interface IConversation {
-  id: string;
-  project_id: string;
-  role: 'assistant' | 'user';
-  content: string;
-  metadata: string | null;
-  created_at: string;
-}
-
-export interface IMemo {
-  id: string;
-  project_id: string;
-  conversation_id: string | null;
-  anchor_text: string;
-  question: string;
-  is_resolved: boolean;
-  created_at: string;
-  updated_at: string;
-}
-
-export interface IPrompt {
-  id: string;
-  project_id: string;
-  item_id: string;
-  content: string;
-  prompt_type: 'auto' | 'manual';
-  version: number;
-  created_at: string;
-}
-
-// v2 types
 export type TaskStatus = 'idea' | 'writing' | 'submitted' | 'testing' | 'done' | 'problem';
 
 export interface ISubProject {
@@ -147,17 +71,3 @@ export interface ISubProjectWithStats extends ISubProject {
   last_activity: string | null;
   preview_tasks: { title: string; status: TaskStatus }[];
 }
-
-export interface IStructureWithQuestions {
-  items: {
-    title: string;
-    description: string;
-    item_type: ItemType;
-    priority: ItemPriority;
-    children?: IStructureWithQuestions['items'];
-  }[];
-  questions: {
-    anchor_text: string;
-    question: string;
-  }[];
-}

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

@@ -1,32 +0,0 @@
-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]/conversations/route.ts

@@ -1,50 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-import { getProject } from '@/lib/db/queries/projects';
-import { getConversations } from '@/lib/db/queries/conversations';
-import { getBrainstorm } from '@/lib/db/queries/brainstorms';
-import { handleChatResponse } from '@/lib/ai/chat-responder';
-
-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 conversations = getConversations(id);
-  return NextResponse.json(conversations);
-}
-
-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 brainstorm = getBrainstorm(id);
-  if (!brainstorm) {
-    return NextResponse.json({ error: 'No brainstorm found' }, { status: 400 });
-  }
-
-  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 handleChatResponse(id, brainstorm.id, message.trim());
-    return NextResponse.json(result);
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : 'Chat response failed';
-    return NextResponse.json({ error: msg }, { status: 500 });
-  }
-}

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

@@ -1,51 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-import { getDb } from '@/lib/db/index';
-import { getPrompt, updatePromptContent } from '@/lib/db/queries/prompts';
-import { generatePromptForItem } from '@/lib/ai/prompter';
-import type { IItem } from '@/types';
-
-export async function GET(
-  _request: NextRequest,
-  { params }: { params: Promise<{ id: string; itemId: string }> },
-) {
-  const { itemId } = await params;
-  const prompt = getPrompt(itemId);
-
-  if (!prompt) {
-    return NextResponse.json({ error: 'No prompt found' }, { status: 404 });
-  }
-
-  return NextResponse.json(prompt);
-}
-
-export async function POST(
-  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 });
-  }
-
-  const body = await request.json().catch(() => ({}));
-
-  try {
-    // If manual content provided, save it directly
-    if (body.content && typeof body.content === 'string') {
-      const prompt = updatePromptContent(itemId, body.content);
-      return NextResponse.json(prompt);
-    }
-
-    // Otherwise, generate with AI
-    const prompt = await generatePromptForItem(item);
-    return NextResponse.json(prompt);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Prompt generation failed';
-    return NextResponse.json({ error: message }, { status: 500 });
-  }
-}

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

@@ -1,36 +0,0 @@
-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 });
-  }
-}