idea-manager 0.2.0 → 0.3.0

package/src/lib/ai/client.ts

@@ -1,4 +1,4 @@
-import { query } from '@anthropic-ai/claude-agent-sdk';
+import { spawn } from 'node:child_process';
 import type { IStructureWithQuestions } from '@/types';
 
 export interface IStructuredItem {
@@ -6,10 +6,147 @@ export interface IStructuredItem {
   description: string;
   item_type: 'feature' | 'task' | 'bug' | 'idea' | 'note';
   priority: 'high' | 'medium' | 'low';
+  status?: 'pending' | 'in_progress' | 'done';
   children?: IStructuredItem[];
 }
 
-export async function runStructure(brainstormContent: string): Promise<IStructuredItem[]> {
+const CLI_PATH = 'claude';
+const DEFAULT_ARGS = ['--dangerously-skip-permissions'];
+const MODEL = 'sonnet';
+const MAX_TURNS = 1;
+
+export type OnTextChunk = (text: string) => void;
+export type OnRawEvent = (event: Record<string, unknown>) => void;
+
+/**
+ * Spawn Claude Code CLI and collect the result text.
+ * Optional onText callback receives streaming text chunks as they arrive.
+ */
+export function runClaude(prompt: string, onText?: OnTextChunk, onRawEvent?: OnRawEvent): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const args = [
+      ...DEFAULT_ARGS,
+      '--model', MODEL,
+      '--output-format', 'stream-json',
+      '--max-turns', String(MAX_TURNS),
+      '-p', '-',  // read prompt from stdin
+    ];
+
+    // Strip Claude Code session env vars to avoid nested session detection
+    const cleanEnv = { ...process.env };
+    delete cleanEnv.CLAUDECODE;
+    delete cleanEnv.CLAUDE_CODE_ENTRYPOINT;
+    delete cleanEnv.CLAUDE_CODE_MAX_OUTPUT_TOKENS;
+    for (const key of Object.keys(cleanEnv)) {
+      if (key.startsWith('CLAUDE_CODE_') || key === 'ANTHROPIC_PARENT_SESSION') {
+        delete cleanEnv[key];
+      }
+    }
+
+    const proc = spawn(CLI_PATH, args, {
+      cwd: process.cwd(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...cleanEnv, FORCE_COLOR: '0' },
+    });
+
+    // Write prompt to stdin and close it
+    proc.stdin?.write(prompt);
+    proc.stdin?.end();
+
+    let buffer = '';
+    let resultText = '';
+    let stderrText = '';
+
+    proc.stdout?.on('data', (chunk: Buffer) => {
+      buffer += chunk.toString();
+      const lines = buffer.split('\n');
+      buffer = lines.pop() ?? '';
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const parsed = JSON.parse(trimmed);
+
+          // Emit raw event for live streaming to frontend
+          onRawEvent?.(parsed);
+
+          // content_block_delta — real-time streaming tokens (API-style)
+          if (parsed.type === 'content_block_delta' && parsed.delta?.text) {
+            resultText += parsed.delta.text;
+            onText?.(parsed.delta.text);
+          }
+
+          // assistant — complete or incremental message
+          else if (parsed.type === 'assistant' && parsed.message?.content) {
+            let fullText = '';
+            for (const block of parsed.message.content) {
+              if (block.type === 'text') {
+                fullText += block.text;
+              }
+            }
+            // Only emit the NEW part (handles incremental assistant messages)
+            if (fullText.length > resultText.length) {
+              const newPart = fullText.slice(resultText.length);
+              onText?.(newPart);
+            }
+            resultText = fullText;
+          }
+
+          // result — final output
+          else if (parsed.type === 'result' && parsed.result) {
+            // Emit any remaining new text from result
+            if (parsed.result.length > resultText.length) {
+              const newPart = parsed.result.slice(resultText.length);
+              onText?.(newPart);
+            }
+            resultText = parsed.result;
+          }
+        } catch {
+          // ignore non-JSON lines
+        }
+      }
+    });
+
+    proc.stderr?.on('data', (chunk: Buffer) => {
+      stderrText += chunk.toString();
+    });
+
+    proc.on('error', (err) => {
+      reject(new Error(`Claude CLI error: ${err.message}`));
+    });
+
+    proc.on('exit', (code, signal) => {
+      if (code !== 0 && !resultText) {
+        const detail = stderrText.slice(0, 500) || (signal ? `killed by signal ${signal}` : 'no output');
+        reject(new Error(`Claude CLI exited with code ${code}: ${detail}`));
+        return;
+      }
+      resolve(resultText);
+    });
+  });
+}
+
+/**
+ * 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.
 
@@ -17,46 +154,35 @@ 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", "children": [same schema] }
+{ "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`;
-
-  const prompt = `Analyze this brainstorming content and structure it into a JSON tree:\n\n${brainstormContent}`;
-
-  let resultText = '';
-
-  for await (const message of query({
-    prompt: `${systemPrompt}\n\n${prompt}`,
-    options: {
-      allowedTools: [],
-      maxTurns: 1,
-    },
-  })) {
-    if (message.type === 'result') {
-      resultText = (message as { type: string; result: string }).result || '';
-    }
-  }
-
-  // Strip markdown fences if present
-  resultText = resultText.replace(/```(?:json)?\s*/g, '').replace(/```\s*/g, '').trim();
-
-  // Extract JSON from the response
-  const jsonMatch = resultText.match(/\[[\s\S]*\]/);
-  if (!jsonMatch) {
-    throw new Error('AI did not return valid JSON');
-  }
-
-  return JSON.parse(jsonMatch[0]) as IStructuredItem[];
+- 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.
@@ -65,10 +191,11 @@ 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", "children": [same] }],
+  "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 }]
 }
 
@@ -77,11 +204,20 @@ Rules:
 - 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`;
+- 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) {
@@ -90,32 +226,13 @@ Rules:
       .join('\n');
   }
 
-  const prompt = `다음 브레인스토밍 내용을 분석하고 구조화하세요:\n\n${brainstormContent}${historyContext}`;
-
-  let resultText = '';
-
-  for await (const message of query({
-    prompt: `${systemPrompt}\n\n${prompt}`,
-    options: {
-      allowedTools: [],
-      maxTurns: 1,
-    },
-  })) {
-    if (message.type === 'result') {
-      resultText = (message as { type: string; result: string }).result || '';
-    }
-  }
-
-  // Strip markdown fences if present
-  resultText = resultText.replace(/```(?:json)?\s*/g, '').replace(/```\s*/g, '').trim();
-
-  // Extract JSON object from the response
-  const jsonMatch = resultText.match(/\{[\s\S]*\}/);
-  if (!jsonMatch) {
-    throw new Error('AI did not return valid JSON');
-  }
+  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 parsed = JSON.parse(jsonMatch[0]);
+  const resultText = await runClaude(prompt, onText, onRawEvent);
+  const json = extractJson(resultText, 'object');
+  const parsed = JSON.parse(json);
 
   return {
     items: parsed.items || [],

package/src/lib/ai/prompter.ts

@@ -1,14 +1,14 @@
-import { query } from '@anthropic-ai/claude-agent-sdk';
+import { runClaude } from './client';
 import { getPrompt, createPrompt } from '../db/queries/prompts';
 import { getBrainstorm } from '../db/queries/brainstorms';
 import { getRecentConversations } from '../db/queries/conversations';
+import { getProjectContextSummary } from '../db/queries/context';
 import type { IPrompt, IItem } from '@/types';
 
 export async function generatePrompt(
   item: IItem,
-  projectContext?: { brainstormContent?: string; conversationHistory?: string },
+  projectContext?: { brainstormContent?: string; conversationHistory?: string; projectDocs?: string },
 ): Promise<IPrompt> {
-  // Check for existing manual prompt — don't overwrite
   const existing = getPrompt(item.id);
   if (existing?.prompt_type === 'manual') {
     return existing;
@@ -21,46 +21,39 @@ Rules:
 - Write in Korean
 - Be specific and actionable
 - Include conditions, constraints, and requirements
-- Include relevant context from the brainstorming and conversation
+- Include relevant context from the brainstorming, conversation, and project documentation
 - The prompt should be ready to paste into a coding tool
 - Keep it concise but complete (under 500 chars)
 - Do NOT include markdown fences or extra formatting`;
 
+  const CONTEXT_LIMIT = 30_000; // 30KB max for prompt generation context
   let context = '';
   if (projectContext?.brainstormContent) {
-    context += `\n\n브레인스토밍 원문:\n${projectContext.brainstormContent}`;
+    context += `\n\n브레인스토밍 원문:\n${projectContext.brainstormContent.slice(0, 3000)}`;
   }
   if (projectContext?.conversationHistory) {
-    context += `\n\nAI 대화 이력:\n${projectContext.conversationHistory}`;
+    context += `\n\nAI 대화 이력:\n${projectContext.conversationHistory.slice(0, 5000)}`;
+  }
+  if (projectContext?.projectDocs) {
+    const remaining = CONTEXT_LIMIT - context.length;
+    if (remaining > 1000) {
+      context += `\n\n프로젝트 문서:\n${projectContext.projectDocs.slice(0, remaining)}`;
+    }
   }
 
-  const prompt = `다음 항목에 대한 실행 프롬프트를 생성하세요:
+  const prompt = `${systemPrompt}\n\n다음 항목에 대한 실행 프롬프트를 생성하세요:
 
 제목: ${item.title}
 설명: ${item.description}
 유형: ${item.item_type}
 우선순위: ${item.priority}${context}`;
 
-  let resultText = '';
-
-  for await (const message of query({
-    prompt: `${systemPrompt}\n\n${prompt}`,
-    options: {
-      allowedTools: [],
-      maxTurns: 1,
-    },
-  })) {
-    if (message.type === 'result') {
-      resultText = (message as { type: string; result: string }).result || '';
-    }
-  }
-
-  resultText = resultText.trim();
+  const resultText = await runClaude(prompt);
 
   return createPrompt({
     project_id: item.project_id,
     item_id: item.id,
-    content: resultText,
+    content: resultText.trim(),
     prompt_type: 'auto',
   });
 }
@@ -68,7 +61,6 @@ Rules:
 export async function generatePromptForItem(
   item: IItem,
 ): Promise<IPrompt> {
-  // Load project context
   const brainstorm = getBrainstorm(item.project_id);
   const conversations = getRecentConversations(item.project_id, 20);
 
@@ -76,8 +68,11 @@ export async function generatePromptForItem(
     ? conversations.map(c => `${c.role === 'user' ? '사용자' : 'AI'}: ${c.content}`).join('\n')
     : undefined;
 
+  const projectDocs = getProjectContextSummary(item.project_id) || undefined;
+
   return generatePrompt(item, {
     brainstormContent: brainstorm?.content,
     conversationHistory,
+    projectDocs,
   });
 }

package/src/lib/ai/refiner.ts

@@ -0,0 +1,128 @@
+import { runClaude } from './client';
+import { updateItem, addChildItems, getItemTree, deleteItem } from '../db/queries/items';
+import { getBrainstorm } from '../db/queries/brainstorms';
+import { getDb } from '../db/index';
+import type { IItem, IItemTree } from '@/types';
+
+interface RefineChild {
+  title: string;
+  description: string;
+  item_type: 'feature' | 'task' | 'bug' | 'idea' | 'note';
+  priority: 'high' | 'medium' | 'low';
+  children?: RefineChild[];
+}
+
+interface RefineResult {
+  title: string;
+  description: string;
+  children?: RefineChild[];
+  remove_children?: boolean;
+}
+
+export async function refineItem(
+  item: IItem,
+  userMessage: string,
+): Promise<{ title: string; description: string; tree: IItemTree[] }> {
+  const brainstorm = getBrainstorm(item.project_id);
+
+  // Get existing children info
+  const db = getDb();
+  const existingChildren = db.prepare(
+    'SELECT id, title, description, item_type, priority FROM items WHERE parent_id = ?'
+  ).all(item.id) as Pick<IItem, 'id' | 'title' | 'description' | 'item_type' | 'priority'>[];
+
+  const childrenInfo = existingChildren.length > 0
+    ? `\n\n현재 하위 항목 (${existingChildren.length}개):\n${existingChildren.map((c, i) => `${i + 1}. [${c.item_type}] ${c.title}: ${c.description}`).join('\n')}`
+    : '\n\n현재 하위 항목: 없음';
+
+  const systemPrompt = `You are a task refinement assistant. The user wants to modify a task item and potentially its sub-items.
+You ALWAYS output ONLY a raw JSON object, nothing else.
+
+Output schema:
+{
+  "title": string,
+  "description": string,
+  "children": [{ "title": string, "description": string, "item_type": "feature"|"task"|"bug"|"idea"|"note", "priority": "high"|"medium"|"low", "children": [...] }],
+  "remove_children": boolean
+}
+
+Rules:
+- Output MUST be a JSON object
+- No markdown fences, no explanation, no text before or after the JSON
+- Keep titles concise (under 50 chars)
+- Write in Korean
+- description should be detailed and actionable
+- "children" is OPTIONAL: include it only if the user asks to add/restructure sub-items
+- "remove_children" is OPTIONAL: set true only if the user explicitly asks to remove existing children before adding new ones
+- If the user just wants to modify the title/description, omit "children"
+- If the user asks to break down, detail, or expand the item, provide "children" array with sub-items`;
+
+  const context = brainstorm?.content ? `\n\n브레인스토밍 원문:\n${brainstorm.content}` : '';
+
+  const prompt = `${systemPrompt}\n\n현재 항목:
+제목: ${item.title}
+설명: ${item.description}
+유형: ${item.item_type}
+우선순위: ${item.priority}${childrenInfo}${context}
+
+사용자 요청: ${userMessage}`;
+
+  const resultText = await runClaude(prompt);
+
+  const cleaned = resultText.replace(/```(?:json)?\s*/g, '').replace(/```\s*/g, '').trim();
+  const jsonMatch = cleaned.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error('AI did not return valid JSON');
+  }
+
+  const parsed = JSON.parse(jsonMatch[0]) as RefineResult;
+
+  // Update the item itself
+  updateItem(item.id, {
+    title: parsed.title,
+    description: parsed.description,
+  });
+
+  // Handle children changes
+  if (parsed.children && parsed.children.length > 0) {
+    // If remove_children is set, delete existing children first
+    if (parsed.remove_children && existingChildren.length > 0) {
+      for (const child of existingChildren) {
+        deleteItem(child.id);
+      }
+    }
+
+    // Add new children
+    addChildItems(item.project_id, item.id, parsed.children.map(c => ({
+      parent_id: item.id,
+      title: c.title,
+      description: c.description,
+      item_type: c.item_type,
+      priority: c.priority,
+      children: c.children?.map(mapChild) ?? undefined,
+    })));
+  }
+
+  // Return updated tree
+  const tree = getItemTree(item.project_id);
+
+  return { title: parsed.title, description: parsed.description, tree };
+}
+
+function mapChild(c: RefineChild): {
+  parent_id: null;
+  title: string;
+  description: string;
+  item_type: RefineChild['item_type'];
+  priority: RefineChild['priority'];
+  children?: ReturnType<typeof mapChild>[];
+} {
+  return {
+    parent_id: null,
+    title: c.title,
+    description: c.description,
+    item_type: c.item_type,
+    priority: c.priority,
+    children: c.children?.map(mapChild),
+  };
+}