idea-manager 0.1.0

package/src/lib/ai/prompter.ts

@@ -0,0 +1,83 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { getPrompt, createPrompt } from '../db/queries/prompts';
+import { getBrainstorm } from '../db/queries/brainstorms';
+import { getRecentConversations } from '../db/queries/conversations';
+import type { IPrompt, IItem } from '@/types';
+
+export async function generatePrompt(
+  item: IItem,
+  projectContext?: { brainstormContent?: string; conversationHistory?: string },
+): Promise<IPrompt> {
+  // Check for existing manual prompt — don't overwrite
+  const existing = getPrompt(item.id);
+  if (existing?.prompt_type === 'manual') {
+    return existing;
+  }
+
+  const systemPrompt = `You are a prompt engineering expert. Generate a clear, actionable prompt for a coding assistant (like Cursor or Claude Code) to implement the given task.
+
+Rules:
+- Output ONLY the prompt text, nothing else
+- Write in Korean
+- Be specific and actionable
+- Include conditions, constraints, and requirements
+- Include relevant context from the brainstorming and conversation
+- 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`;
+
+  let context = '';
+  if (projectContext?.brainstormContent) {
+    context += `\n\n브레인스토밍 원문:\n${projectContext.brainstormContent}`;
+  }
+  if (projectContext?.conversationHistory) {
+    context += `\n\nAI 대화 이력:\n${projectContext.conversationHistory}`;
+  }
+
+  const prompt = `다음 항목에 대한 실행 프롬프트를 생성하세요:
+
+제목: ${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();
+
+  return createPrompt({
+    project_id: item.project_id,
+    item_id: item.id,
+    content: resultText,
+    prompt_type: 'auto',
+  });
+}
+
+export async function generatePromptForItem(
+  item: IItem,
+): Promise<IPrompt> {
+  // Load project context
+  const brainstorm = getBrainstorm(item.project_id);
+  const conversations = getRecentConversations(item.project_id, 20);
+
+  const conversationHistory = conversations.length > 0
+    ? conversations.map(c => `${c.role === 'user' ? '사용자' : 'AI'}: ${c.content}`).join('\n')
+    : undefined;
+
+  return generatePrompt(item, {
+    brainstormContent: brainstorm?.content,
+    conversationHistory,
+  });
+}

package/src/lib/ai/structurer.ts

@@ -0,0 +1,74 @@
+import { runStructure, runStructureWithQuestions, type IStructuredItem } from './client';
+import { replaceItems } from '../db/queries/items';
+import { getRecentConversations, addMessage } from '../db/queries/conversations';
+import { resolveMemos, createMemosFromQuestions } from '../db/queries/memos';
+import type { IItemTree, IMemo, IConversation } from '@/types';
+
+export async function structureBrainstorm(
+  projectId: string,
+  brainstormId: string,
+  content: string,
+): Promise<IItemTree[]> {
+  if (!content.trim()) {
+    return [];
+  }
+
+  const structured = await runStructure(content);
+
+  const dbItems = mapToDbFormat(structured);
+
+  return replaceItems(projectId, brainstormId, dbItems);
+}
+
+export async function structureWithChat(
+  projectId: string,
+  brainstormId: string,
+  content: string,
+): Promise<{ items: IItemTree[]; memos: IMemo[]; message: IConversation | null }> {
+  if (!content.trim()) {
+    return { items: [], memos: [], message: null };
+  }
+
+  // Load recent conversation history
+  const history = getRecentConversations(projectId, 20);
+  const historyForAi = history.map(h => ({
+    role: h.role,
+    content: h.content,
+  }));
+
+  // AI call with questions
+  const result = await runStructureWithQuestions(content, historyForAi);
+
+  // Replace items in DB
+  const dbItems = mapToDbFormat(result.items as IStructuredItem[]);
+  const tree = replaceItems(projectId, brainstormId, dbItems);
+
+  // Resolve old memos
+  resolveMemos(projectId);
+
+  // Build AI message from questions
+  let aiMessage: IConversation | null = null;
+  let memos: IMemo[] = [];
+
+  if (result.questions.length > 0) {
+    const messageContent = result.questions
+      .map((q, i) => `${i + 1}. ${q.question}`)
+      .join('\n');
+
+    aiMessage = addMessage(projectId, 'assistant', messageContent);
+    memos = createMemosFromQuestions(projectId, aiMessage.id, result.questions);
+  }
+
+  return { items: tree, memos, message: aiMessage };
+}
+
+function mapToDbFormat(items: IStructuredItem[]): Parameters<typeof replaceItems>[2] {
+  return items.map((item) => ({
+    parent_id: null,
+    title: item.title,
+    description: item.description,
+    item_type: item.item_type,
+    priority: item.priority,
+    children: item.children ? mapToDbFormat(item.children) : undefined,
+  }));
+}

package/src/lib/db/index.ts

@@ -0,0 +1,16 @@
+import Database from 'better-sqlite3';
+import { getDbPath } from '../utils/paths';
+import { initSchema } from './schema';
+
+let db: Database.Database | null = null;
+
+export function getDb(): Database.Database {
+  if (!db) {
+    const dbPath = getDbPath();
+    db = new Database(dbPath);
+    db.pragma('journal_mode = WAL');
+    db.pragma('foreign_keys = ON');
+    initSchema(db);
+  }
+  return db;
+}

package/src/lib/db/queries/brainstorms.ts

@@ -0,0 +1,26 @@
+import { getDb } from '../index';
+import type { IBrainstorm } from '@/types';
+
+export function getBrainstorm(projectId: string): IBrainstorm | undefined {
+  const db = getDb();
+  return db.prepare(
+    'SELECT * FROM brainstorms WHERE project_id = ? ORDER BY version DESC LIMIT 1'
+  ).get(projectId) as IBrainstorm | undefined;
+}
+
+export function updateBrainstorm(projectId: string, content: string): IBrainstorm | undefined {
+  const db = getDb();
+  const now = new Date().toISOString();
+
+  const existing = getBrainstorm(projectId);
+  if (!existing) return undefined;
+
+  db.prepare(
+    'UPDATE brainstorms SET content = ?, version = version + 1, updated_at = ? WHERE id = ?'
+  ).run(content, now, existing.id);
+
+  // Also update project's updated_at
+  db.prepare('UPDATE projects SET updated_at = ? WHERE id = ?').run(now, projectId);
+
+  return getBrainstorm(projectId);
+}

package/src/lib/db/queries/conversations.ts

@@ -0,0 +1,46 @@
+import { getDb } from '../index';
+import { generateId } from '../../utils/id';
+import type { IConversation } from '@/types';
+
+export function getConversations(projectId: string, limit = 20): IConversation[] {
+  const db = getDb();
+  return db.prepare(
+    `SELECT * FROM conversations WHERE project_id = ?
+     ORDER BY created_at ASC LIMIT ?`
+  ).all(projectId, limit) as IConversation[];
+}
+
+export function getRecentConversations(projectId: string, limit = 20): IConversation[] {
+  const db = getDb();
+  // Get the last N messages ordered chronologically
+  const rows = db.prepare(
+    `SELECT * FROM (
+       SELECT * FROM conversations WHERE project_id = ?
+       ORDER BY created_at DESC LIMIT ?
+     ) sub ORDER BY created_at ASC`
+  ).all(projectId, limit) as IConversation[];
+  return rows;
+}
+
+export function addMessage(
+  projectId: string,
+  role: 'assistant' | 'user',
+  content: string,
+  metadata?: string,
+): IConversation {
+  const db = getDb();
+  const id = generateId();
+  const now = new Date().toISOString();
+
+  db.prepare(
+    `INSERT INTO conversations (id, project_id, role, content, metadata, created_at)
+     VALUES (?, ?, ?, ?, ?, ?)`
+  ).run(id, projectId, role, content, metadata ?? null, now);
+
+  return db.prepare('SELECT * FROM conversations WHERE id = ?').get(id) as IConversation;
+}
+
+export function deleteConversations(projectId: string): void {
+  const db = getDb();
+  db.prepare('DELETE FROM conversations WHERE project_id = ?').run(projectId);
+}

package/src/lib/db/queries/items.ts

@@ -0,0 +1,147 @@
+import { getDb } from '../index';
+import { generateId } from '../../utils/id';
+import type { IItem, IItemTree, ItemType, ItemPriority, ItemStatus } from '@/types';
+
+export function getItems(projectId: string): IItem[] {
+  const db = getDb();
+  return db.prepare(
+    'SELECT * FROM items WHERE project_id = ? ORDER BY sort_order ASC'
+  ).all(projectId) as IItem[];
+}
+
+export function getItemTree(projectId: string): IItemTree[] {
+  const items = getItems(projectId);
+  return buildTree(items);
+}
+
+function buildTree(items: IItem[]): IItemTree[] {
+  const map = new Map<string, IItemTree>();
+  const roots: IItemTree[] = [];
+
+  for (const item of items) {
+    map.set(item.id, { ...item, children: [] });
+  }
+
+  for (const item of items) {
+    const node = map.get(item.id)!;
+    if (item.parent_id && map.has(item.parent_id)) {
+      map.get(item.parent_id)!.children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+
+  return roots;
+}
+
+export function createItem(data: {
+  project_id: string;
+  brainstorm_id?: string;
+  parent_id?: string;
+  title: string;
+  description?: string;
+  item_type?: ItemType;
+  priority?: ItemPriority;
+  sort_order?: number;
+}): IItem {
+  const db = getDb();
+  const id = generateId();
+  const now = new Date().toISOString();
+
+  db.prepare(`
+    INSERT INTO items (id, project_id, brainstorm_id, parent_id, title, description,
+      item_type, priority, status, is_locked, sort_order, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'pending', 1, ?, ?, ?)
+  `).run(
+    id,
+    data.project_id,
+    data.brainstorm_id ?? null,
+    data.parent_id ?? null,
+    data.title,
+    data.description ?? '',
+    data.item_type ?? 'feature',
+    data.priority ?? 'medium',
+    data.sort_order ?? 0,
+    now,
+    now,
+  );
+
+  return db.prepare('SELECT * FROM items WHERE id = ?').get(id) as IItem;
+}
+
+export function updateItem(id: string, data: {
+  title?: string;
+  description?: string;
+  status?: ItemStatus;
+  is_locked?: boolean;
+  priority?: ItemPriority;
+  sort_order?: number;
+}): IItem | undefined {
+  const db = getDb();
+  const item = db.prepare('SELECT * FROM items WHERE id = ?').get(id) as IItem | undefined;
+  if (!item) return undefined;
+
+  const now = new Date().toISOString();
+  db.prepare(`
+    UPDATE items SET
+      title = ?, description = ?, status = ?, is_locked = ?,
+      priority = ?, sort_order = ?, updated_at = ?
+    WHERE id = ?
+  `).run(
+    data.title ?? item.title,
+    data.description ?? item.description,
+    data.status ?? item.status,
+    data.is_locked !== undefined ? (data.is_locked ? 1 : 0) : (item.is_locked ? 1 : 0),
+    data.priority ?? item.priority,
+    data.sort_order ?? item.sort_order,
+    now,
+    id,
+  );
+
+  return db.prepare('SELECT * FROM items WHERE id = ?').get(id) as IItem;
+}
+
+export function deleteItemsByProject(projectId: string): void {
+  const db = getDb();
+  db.prepare('DELETE FROM items WHERE project_id = ?').run(projectId);
+}
+
+export function replaceItems(projectId: string, brainstormId: string, newItems: {
+  parent_id: string | null;
+  title: string;
+  description: string;
+  item_type: ItemType;
+  priority: ItemPriority;
+  children?: typeof newItems;
+}[]): IItemTree[] {
+  const db = getDb();
+
+  const insertItems = db.transaction(() => {
+    // Delete existing items for this project
+    db.prepare('DELETE FROM items WHERE project_id = ?').run(projectId);
+
+    // Insert new items recursively
+    let sortOrder = 0;
+    const insertRecursive = (items: typeof newItems, parentId: string | null) => {
+      for (const item of items) {
+        const id = generateId();
+        const now = new Date().toISOString();
+        db.prepare(`
+          INSERT INTO items (id, project_id, brainstorm_id, parent_id, title, description,
+            item_type, priority, status, is_locked, sort_order, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'pending', 1, ?, ?, ?)
+        `).run(id, projectId, brainstormId, parentId, item.title, item.description,
+          item.item_type, item.priority, sortOrder++, now, now);
+
+        if (item.children?.length) {
+          insertRecursive(item.children, id);
+        }
+      }
+    };
+
+    insertRecursive(newItems, null);
+  });
+
+  insertItems();
+  return getItemTree(projectId);
+}

package/src/lib/db/queries/memos.ts

@@ -0,0 +1,66 @@
+import { getDb } from '../index';
+import { generateId } from '../../utils/id';
+import type { IMemo } from '@/types';
+
+export function getMemos(projectId: string, onlyUnresolved = false): IMemo[] {
+  const db = getDb();
+  const whereClause = onlyUnresolved
+    ? 'WHERE project_id = ? AND is_resolved = 0'
+    : 'WHERE project_id = ?';
+
+  return db.prepare(
+    `SELECT * FROM memos ${whereClause} ORDER BY created_at ASC`
+  ).all(projectId) as IMemo[];
+}
+
+export function createMemo(data: {
+  project_id: string;
+  conversation_id?: string;
+  anchor_text: string;
+  question: string;
+}): IMemo {
+  const db = getDb();
+  const id = generateId();
+  const now = new Date().toISOString();
+
+  db.prepare(
+    `INSERT INTO memos (id, project_id, conversation_id, anchor_text, question, is_resolved, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, 0, ?, ?)`
+  ).run(id, data.project_id, data.conversation_id ?? null, data.anchor_text, data.question, now, now);
+
+  return db.prepare('SELECT * FROM memos WHERE id = ?').get(id) as IMemo;
+}
+
+export function resolveMemos(projectId: string): void {
+  const db = getDb();
+  const now = new Date().toISOString();
+  db.prepare(
+    `UPDATE memos SET is_resolved = 1, updated_at = ? WHERE project_id = ? AND is_resolved = 0`
+  ).run(now, projectId);
+}
+
+export function createMemosFromQuestions(
+  projectId: string,
+  conversationId: string,
+  questions: { anchor_text: string; question: string }[],
+): IMemo[] {
+  const db = getDb();
+  const memos: IMemo[] = [];
+
+  const insertMemo = db.prepare(
+    `INSERT INTO memos (id, project_id, conversation_id, anchor_text, question, is_resolved, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, 0, ?, ?)`
+  );
+
+  const insertAll = db.transaction(() => {
+    for (const q of questions) {
+      const id = generateId();
+      const now = new Date().toISOString();
+      insertMemo.run(id, projectId, conversationId, q.anchor_text, q.question, now, now);
+      memos.push(db.prepare('SELECT * FROM memos WHERE id = ?').get(id) as IMemo);
+    }
+  });
+
+  insertAll();
+  return memos;
+}

package/src/lib/db/queries/projects.ts

@@ -0,0 +1,53 @@
+import { getDb } from '../index';
+import { generateId } from '../../utils/id';
+import type { IProject } from '@/types';
+
+export function listProjects(): IProject[] {
+  const db = getDb();
+  return db.prepare('SELECT * FROM projects ORDER BY updated_at DESC').all() as IProject[];
+}
+
+export function getProject(id: string): IProject | undefined {
+  const db = getDb();
+  return db.prepare('SELECT * FROM projects WHERE id = ?').get(id) as IProject | undefined;
+}
+
+export function createProject(name: string, description: string = ''): IProject {
+  const db = getDb();
+  const id = generateId();
+  const now = new Date().toISOString();
+
+  db.prepare(
+    'INSERT INTO projects (id, name, description, created_at, updated_at) VALUES (?, ?, ?, ?, ?)'
+  ).run(id, name, description, now, now);
+
+  // Also create a default brainstorm
+  const brainstormId = generateId();
+  db.prepare(
+    'INSERT INTO brainstorms (id, project_id, content, version, created_at, updated_at) VALUES (?, ?, ?, 1, ?, ?)'
+  ).run(brainstormId, id, '', now, now);
+
+  return getProject(id)!;
+}
+
+export function updateProject(id: string, data: { name?: string; description?: string }): IProject | undefined {
+  const db = getDb();
+  const project = getProject(id);
+  if (!project) return undefined;
+
+  const name = data.name ?? project.name;
+  const description = data.description ?? project.description;
+  const now = new Date().toISOString();
+
+  db.prepare(
+    'UPDATE projects SET name = ?, description = ?, updated_at = ? WHERE id = ?'
+  ).run(name, description, now, id);
+
+  return getProject(id);
+}
+
+export function deleteProject(id: string): boolean {
+  const db = getDb();
+  const result = db.prepare('DELETE FROM projects WHERE id = ?').run(id);
+  return result.changes > 0;
+}

package/src/lib/db/queries/prompts.ts

@@ -0,0 +1,68 @@
+import { getDb } from '../index';
+import { generateId } from '../../utils/id';
+import type { IPrompt } from '@/types';
+
+export function getPrompt(itemId: string): IPrompt | undefined {
+  const db = getDb();
+  return db.prepare(
+    'SELECT * FROM prompts WHERE item_id = ? ORDER BY version DESC LIMIT 1'
+  ).get(itemId) as IPrompt | undefined;
+}
+
+export function getPromptsByProject(projectId: string): IPrompt[] {
+  const db = getDb();
+  // Get latest version of each item's prompt
+  return db.prepare(
+    `SELECT p.* FROM prompts p
+     INNER JOIN (
+       SELECT item_id, MAX(version) as max_version
+       FROM prompts WHERE project_id = ?
+       GROUP BY item_id
+     ) latest ON p.item_id = latest.item_id AND p.version = latest.max_version
+     WHERE p.project_id = ?`
+  ).all(projectId, projectId) as IPrompt[];
+}
+
+export function createPrompt(data: {
+  project_id: string;
+  item_id: string;
+  content: string;
+  prompt_type?: 'auto' | 'manual';
+}): IPrompt {
+  const db = getDb();
+  const id = generateId();
+  const now = new Date().toISOString();
+
+  // Get next version number
+  const existing = db.prepare(
+    'SELECT MAX(version) as max_ver FROM prompts WHERE item_id = ?'
+  ).get(data.item_id) as { max_ver: number | null } | undefined;
+  const version = (existing?.max_ver ?? 0) + 1;
+
+  db.prepare(
+    `INSERT INTO prompts (id, project_id, item_id, content, prompt_type, version, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`
+  ).run(id, data.project_id, data.item_id, data.content, data.prompt_type ?? 'auto', version, now);
+
+  return db.prepare('SELECT * FROM prompts WHERE id = ?').get(id) as IPrompt;
+}
+
+export function updatePromptContent(itemId: string, content: string): IPrompt {
+  // Create a new manual version
+  const db = getDb();
+  const existing = getPrompt(itemId);
+  if (!existing) {
+    throw new Error('No prompt found for this item');
+  }
+  return createPrompt({
+    project_id: existing.project_id,
+    item_id: itemId,
+    content,
+    prompt_type: 'manual',
+  });
+}
+
+export function deletePromptsByItem(itemId: string): void {
+  const db = getDb();
+  db.prepare('DELETE FROM prompts WHERE item_id = ?').run(itemId);
+}

package/src/lib/db/schema.ts

@@ -0,0 +1,78 @@
+import type Database from 'better-sqlite3';
+
+export function initSchema(db: Database.Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      description TEXT NOT NULL DEFAULT '',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS brainstorms (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      content TEXT NOT NULL DEFAULT '',
+      version INTEGER NOT NULL DEFAULT 1,
+      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
+    );
+
+    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,
+      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
+    );
+  `);
+}