idea-manager 0.9.7 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "idea-manager",
-  "version": "0.9.7",
+  "version": "1.0.0",
   "description": "Turn free-form brainstorming into structured task trees with AI-generated prompts. Built-in MCP Server for autonomous AI agent execution. Local-first with SQLite, cross-PC sync via Git.",
   "keywords": [
     "brainstorm",

package/src/app/api/projects/[id]/sub-projects/[subId]/tasks/[taskId]/chat/route.ts

@@ -4,7 +4,7 @@ import { getTask } from '@/lib/db/queries/tasks';
 import { getTaskPrompt } from '@/lib/db/queries/task-prompts';
 import { getBrainstorm } from '@/lib/db/queries/brainstorms';
 import { getProject } from '@/lib/db/queries/projects';
-import { runClaude } from '@/lib/ai/client';
+import { runAgent } from '@/lib/ai/client';
 
 export async function GET(
   _request: NextRequest,
@@ -55,7 +55,8 @@ ${brainstorm?.content ? `\nBrainstorming context:\n${brainstorm.content.slice(0,
     .join('\n');
 
   try {
-    const aiResponse = await runClaude(`${systemPrompt}\n\nConversation:\n${conversationText}`);
+    const agentType = project?.agent_type || 'claude';
+    const aiResponse = await runAgent(agentType, `${systemPrompt}\n\nConversation:\n${conversationText}`);
     const trimmed = aiResponse.trim();
     if (!trimmed) {
       const fallbackMsg = addTaskConversation(taskId, 'assistant', '(AI 응답을 생성하지 못했습니다. 다시 시도해주세요.)');

package/src/cli.ts

@@ -22,7 +22,7 @@ try {
 }
 
 async function openAsApp(url: string) {
-  const { execFile: execFileCb } = await import('child_process');
+  const { spawn: spawnChild } = await import('child_process');
   const fs = await import('fs');
   const platform = process.platform;
 
@@ -47,23 +47,18 @@ async function openAsApp(url: string) {
         ];
 
   for (const browser of browsers) {
-    // On macOS, check binary exists before trying
     if (platform === 'darwin' && !fs.existsSync(browser.bin)) continue;
 
     try {
-      await new Promise<void>((resolve, reject) => {
-        const child = execFileCb(browser.bin, browser.args, {
-          shell: platform === 'win32',
-          detached: true,
-          stdio: 'ignore',
-        }, (err) => { if (err) reject(err); });
-        child.unref();
-        // Browser launched — resolve after brief delay
-        setTimeout(resolve, 500);
+      const child = spawnChild(browser.bin, browser.args, {
+        detached: true,
+        stdio: 'ignore',
+        shell: platform === 'win32',
       });
+      child.unref();
       return; // success
     } catch {
-      continue; // try next browser
+      continue;
     }
   }
 

package/src/components/workspace/WorkspacePanel.tsx

@@ -19,6 +19,7 @@ interface IProject {
   project_path: string | null;
   ai_context: string;
   watch_enabled: boolean;
+  agent_type: string;
 }
 
 export default function WorkspacePanel({
@@ -397,6 +398,23 @@ export default function WorkspacePanel({
           )}
         </div>
         <div className="flex items-center gap-2">
+          <select
+            value={project.agent_type || 'claude'}
+            onChange={async (e) => {
+              const res = await fetch(`/api/projects/${id}`, {
+                method: 'PUT',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ agent_type: e.target.value }),
+              });
+              if (res.ok) setProject(await res.json());
+            }}
+            className="px-2 py-1.5 text-xs bg-muted border border-border rounded-md text-foreground cursor-pointer hover:bg-card-hover transition-colors"
+            title="AI Agent"
+          >
+            <option value="claude">Claude</option>
+            <option value="gemini">Gemini</option>
+            <option value="codex">Codex</option>
+          </select>
           <button onClick={handleToggleWatch}
             className={`px-3 py-1.5 text-xs border rounded-md transition-colors flex items-center gap-1.5 ${
               project.watch_enabled

package/src/lib/ai/agents.ts

@@ -0,0 +1,102 @@
+import type { AgentType } from '../../types';
+
+export interface AgentConfig {
+  name: string;
+  binary: string;
+  buildArgs: (opts: { streaming: boolean }) => string[];
+  buildEnv: () => NodeJS.ProcessEnv;
+  parseStreamEvent: (parsed: Record<string, unknown>) => { text?: string; final?: string } | null;
+  cleanOutput?: (text: string) => string;
+}
+
+const claudeConfig: AgentConfig = {
+  name: 'Claude',
+  binary: 'claude',
+  buildArgs: ({ streaming }) => [
+    '--dangerously-skip-permissions',
+    '--model', 'sonnet',
+    ...(streaming
+      ? ['--output-format', 'stream-json', '--verbose']
+      : ['--output-format', 'text']),
+    '--max-turns', '80',
+    '-p', '-',
+  ],
+  buildEnv: () => {
+    const env = { ...process.env };
+    delete env.CLAUDECODE;
+    delete env.CLAUDE_CODE_ENTRYPOINT;
+    delete env.CLAUDE_CODE_MAX_OUTPUT_TOKENS;
+    for (const key of Object.keys(env)) {
+      if (key.startsWith('CLAUDE_CODE_') || key === 'ANTHROPIC_PARENT_SESSION') {
+        delete env[key];
+      }
+    }
+    return { ...env, FORCE_COLOR: '0' };
+  },
+  parseStreamEvent: (parsed) => {
+    if (parsed.type === 'content_block_delta' && (parsed.delta as Record<string, unknown>)?.text) {
+      return { text: (parsed.delta as Record<string, unknown>).text as string };
+    }
+    if (parsed.type === 'assistant' && (parsed.message as Record<string, unknown>)?.content) {
+      let t = '';
+      for (const b of (parsed.message as Record<string, unknown>).content as { type: string; text?: string }[]) {
+        if (b.type === 'text') t += b.text;
+      }
+      return { final: t };
+    }
+    if (parsed.type === 'result' && parsed.result) {
+      return { final: parsed.result as string };
+    }
+    return null;
+  },
+  cleanOutput: (text) => text.replace(/Error: Reached max turns \(\d+\)\s*/g, '').trim(),
+};
+
+const geminiConfig: AgentConfig = {
+  name: 'Gemini',
+  binary: 'gemini',
+  buildArgs: ({ streaming }) => [
+    '--yolo',
+    ...(streaming
+      ? ['--output-format', 'stream-json']
+      : ['--output-format', 'json']),
+    '-p', '-',
+  ],
+  buildEnv: () => ({ ...process.env, FORCE_COLOR: '0' }),
+  parseStreamEvent: (parsed) => {
+    if (parsed.type === 'content_block_delta' && (parsed.delta as Record<string, unknown>)?.text) {
+      return { text: (parsed.delta as Record<string, unknown>).text as string };
+    }
+    if (parsed.type === 'result') {
+      return { final: (parsed.response || parsed.text || parsed.result) as string };
+    }
+    return null;
+  },
+};
+
+const codexConfig: AgentConfig = {
+  name: 'Codex',
+  binary: 'codex',
+  buildArgs: ({ streaming }) => [
+    'exec',
+    '--full-auto',
+    ...(streaming ? ['--json'] : []),
+    '-',
+  ],
+  buildEnv: () => ({ ...process.env, FORCE_COLOR: '0' }),
+  parseStreamEvent: (parsed) => {
+    if (parsed.type === 'item.completed' && (parsed.item as Record<string, unknown>)?.type === 'agent_message') {
+      return { final: (parsed.item as Record<string, unknown>).text as string };
+    }
+    if (parsed.type === 'item.updated' && (parsed.item as Record<string, unknown>)?.type === 'agent_message') {
+      return { text: (parsed.item as Record<string, unknown>).text as string };
+    }
+    return null;
+  },
+};
+
+export const AGENTS: Record<AgentType, AgentConfig> = {
+  claude: claudeConfig,
+  gemini: geminiConfig,
+  codex: codexConfig,
+};

package/src/lib/ai/client.ts

@@ -1,48 +1,41 @@
 import { spawn } from 'node:child_process';
-
-const CLI_PATH = 'claude';
-const DEFAULT_ARGS = ['--dangerously-skip-permissions'];
-const MODEL = 'sonnet';
-const MAX_TURNS = 80;
+import { AGENTS } from './agents';
+import type { AgentType } from '../../types';
 
 export type OnTextChunk = (text: string) => void;
 export type OnRawEvent = (event: Record<string, unknown>) => void;
 
-export interface RunClaudeOptions {
+export interface RunAgentOptions {
   cwd?: string;
   timeoutMs?: number;
 }
 
 /**
- * Spawn Claude Code CLI and collect the result text.
+ * Spawn an AI CLI agent and collect the result text.
  * Optional onText callback receives streaming text chunks as they arrive.
  */
-export function runClaude(prompt: string, onText?: OnTextChunk, onRawEvent?: OnRawEvent, options?: RunClaudeOptions): Promise<string> {
+export function runAgent(
+  agentType: AgentType,
+  prompt: string,
+  onText?: OnTextChunk,
+  onRawEvent?: OnRawEvent,
+  options?: RunAgentOptions,
+): Promise<string> {
+  const config = AGENTS[agentType];
+  if (!config) {
+    return Promise.reject(new Error(`Unknown agent type: ${agentType}`));
+  }
+
   return new Promise((resolve, reject) => {
     const useStreamJson = !!(onText || onRawEvent);
-    const args = [
-      ...DEFAULT_ARGS,
-      '--model', MODEL,
-      ...(useStreamJson ? ['--output-format', 'stream-json', '--verbose'] : ['--output-format', 'text']),
-      '--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 args = config.buildArgs({ streaming: useStreamJson });
+    const env = config.buildEnv();
 
-    const proc = spawn(CLI_PATH, args, {
+    const proc = spawn(config.binary, args, {
       cwd: options?.cwd || process.cwd(),
       stdio: ['pipe', 'pipe', 'pipe'],
-      env: { ...cleanEnv, FORCE_COLOR: '0' },
+      shell: process.platform === 'win32',
+      env,
     });
 
     // Timeout handling
@@ -62,6 +55,7 @@ export function runClaude(prompt: string, onText?: OnTextChunk, onRawEvent?: OnR
     let buffer = '';
     let resultText = '';
     let stderrText = '';
+    let lastEmittedLength = 0;
 
     if (useStreamJson) {
       // stream-json mode: parse NDJSON events
@@ -77,23 +71,21 @@ export function runClaude(prompt: string, onText?: OnTextChunk, onRawEvent?: OnR
             const parsed = JSON.parse(trimmed);
             onRawEvent?.(parsed);
 
-            if (parsed.type === 'content_block_delta' && parsed.delta?.text) {
-              resultText += parsed.delta.text;
-              onText?.(parsed.delta.text);
-            } else if (parsed.type === 'assistant' && parsed.message?.content) {
-              let fullText = '';
-              for (const block of parsed.message.content) {
-                if (block.type === 'text') fullText += block.text;
+            const event = config.parseStreamEvent(parsed);
+            if (event) {
+              if (event.final) {
+                // Some agents emit cumulative text, emit only new portion
+                if (event.final.length > lastEmittedLength) {
+                  const newPart = event.final.slice(lastEmittedLength);
+                  onText?.(newPart);
+                  lastEmittedLength = event.final.length;
+                }
+                resultText = event.final;
+              } else if (event.text) {
+                resultText += event.text;
+                lastEmittedLength = resultText.length;
+                onText?.(event.text);
               }
-              if (fullText.length > resultText.length) {
-                onText?.(fullText.slice(resultText.length));
-              }
-              resultText = fullText;
-            } else if (parsed.type === 'result' && parsed.result) {
-              if (parsed.result.length > resultText.length) {
-                onText?.(parsed.result.slice(resultText.length));
-              }
-              resultText = parsed.result;
             }
           } catch { /* ignore non-JSON */ }
         }
@@ -110,25 +102,29 @@ export function runClaude(prompt: string, onText?: OnTextChunk, onRawEvent?: OnR
     });
 
     proc.on('error', (err) => {
-      reject(new Error(`Claude CLI error: ${err.message}`));
+      reject(new Error(`${config.name} CLI error: ${err.message}`));
     });
 
     proc.on('exit', (code, signal) => {
       if (timeoutTimer) clearTimeout(timeoutTimer);
-      // Clean up known CLI noise from text output
-      if (!useStreamJson) {
-        resultText = resultText.replace(/Error: Reached max turns \(\d+\)\s*/g, '').trim();
+      if (!useStreamJson && config.cleanOutput) {
+        resultText = config.cleanOutput(resultText);
       }
       if (timedOut) {
-        reject(new Error(`Claude CLI timed out after ${Math.round((options?.timeoutMs || 0) / 1000)}s`));
+        reject(new Error(`${config.name} CLI timed out after ${Math.round((options?.timeoutMs || 0) / 1000)}s`));
         return;
       }
       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}`));
+        reject(new Error(`${config.name} CLI exited with code ${code}: ${detail}`));
         return;
       }
       resolve(resultText);
     });
   });
 }
+
+// Backward compatibility
+export function runClaude(prompt: string, onText?: OnTextChunk, onRawEvent?: OnRawEvent, options?: RunAgentOptions): Promise<string> {
+  return runAgent('claude', prompt, onText, onRawEvent, options);
+}

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

@@ -1,6 +1,6 @@
 import { getDb } from '../index';
 import { generateId } from '../../utils/id';
-import type { IProject } from '../../../types';
+import type { IProject, AgentType } from '../../../types';
 
 interface ProjectRow {
   id: string;
@@ -9,12 +9,13 @@ interface ProjectRow {
   project_path: string | null;
   ai_context: string;
   watch_enabled: number;
+  agent_type: string;
   created_at: string;
   updated_at: string;
 }
 
 function rowToProject(row: ProjectRow): IProject {
-  return { ...row, watch_enabled: row.watch_enabled === 1 };
+  return { ...row, watch_enabled: row.watch_enabled === 1, agent_type: (row.agent_type || 'claude') as AgentType };
 }
 
 export function listProjects(): IProject[] {
@@ -47,7 +48,7 @@ export function createProject(name: string, description: string = '', projectPat
   return getProject(id)!;
 }
 
-export function updateProject(id: string, data: { name?: string; description?: string; project_path?: string | null; ai_context?: string; watch_enabled?: boolean }): IProject | undefined {
+export function updateProject(id: string, data: { name?: string; description?: string; project_path?: string | null; ai_context?: string; watch_enabled?: boolean; agent_type?: AgentType }): IProject | undefined {
   const db = getDb();
   const project = getProject(id);
   if (!project) return undefined;
@@ -55,13 +56,14 @@ export function updateProject(id: string, data: { name?: string; description?: s
   const now = new Date().toISOString();
 
   db.prepare(
-    'UPDATE projects SET name = ?, description = ?, project_path = ?, ai_context = ?, watch_enabled = ?, updated_at = ? WHERE id = ?'
+    'UPDATE projects SET name = ?, description = ?, project_path = ?, ai_context = ?, watch_enabled = ?, agent_type = ?, updated_at = ? WHERE id = ?'
   ).run(
     data.name ?? project.name,
     data.description ?? project.description,
     data.project_path !== undefined ? data.project_path : project.project_path,
     data.ai_context !== undefined ? data.ai_context : (project.ai_context ?? ''),
     data.watch_enabled !== undefined ? (data.watch_enabled ? 1 : 0) : (project.watch_enabled ? 1 : 0),
+    data.agent_type ?? project.agent_type ?? 'claude',
     now,
     id,
   );

package/src/lib/db/schema.ts

@@ -33,6 +33,9 @@ export function initSchema(db: Database.Database): void {
   if (!projCols.some(c => c.name === 'watch_enabled')) {
     db.exec("ALTER TABLE projects ADD COLUMN watch_enabled INTEGER NOT NULL DEFAULT 0");
   }
+  if (!projCols.some(c => c.name === 'agent_type')) {
+    db.exec("ALTER TABLE projects ADD COLUMN agent_type TEXT NOT NULL DEFAULT 'claude'");
+  }
 
   // v2 tables
   db.exec(`

package/src/lib/watcher.ts

@@ -1,5 +1,5 @@
 import fs from 'fs';
-import { runClaude } from './ai/client';
+import { runAgent } from './ai/client';
 import { listProjects, getProject } from './db/queries/projects';
 import { getSubProject } from './db/queries/sub-projects';
 import { getTasksByProject, getTask, updateTask } from './db/queries/tasks';
@@ -121,7 +121,7 @@ async function executeTask(task: ITask, project: IProject, options: WatcherOptio
       }
     };
 
-    const result = await runClaude(fullPrompt, onText, undefined, {
+    const result = await runAgent(project.agent_type || 'claude', fullPrompt, onText, undefined, {
       cwd,
       timeoutMs: options.timeoutMs,
     });

package/src/types/index.ts

@@ -1,3 +1,5 @@
+export type AgentType = 'claude' | 'gemini' | 'codex';
+
 export interface IProject {
   id: string;
   name: string;
@@ -5,6 +7,7 @@ export interface IProject {
   project_path: string | null;
   ai_context: string;
   watch_enabled: boolean;
+  agent_type: AgentType;
   created_at: string;
   updated_at: string;
 }