@silbaram/artifact-driven-agent 0.1.6 → 0.1.9

package/src/commands/run.js

@@ -2,6 +2,7 @@ import fs from 'fs-extra';
 import path from 'path';
 import { spawn } from 'child_process';
 import chalk from 'chalk';
+import inquirer from 'inquirer';
 import {
   getWorkspaceDir,
   getSessionsDir,
@@ -15,33 +16,31 @@ import {
 import {
   registerSession,
   unregisterSession,
-  updateSessionStatus,
+  updateSessionDetails,
   getActiveSessions,
   getPendingQuestions
 } from '../utils/sessionState.js';
-
-export async function run(role, tool) {
-  if (!isWorkspaceSetup()) {
-    console.log(chalk.red('❌ 먼저 setup을 실행하세요.'));
-    console.log(chalk.gray('  ada setup'));
-    process.exit(1);
-  }
-
+import { getToolForRole } from '../utils/config.js';
+
+/**
+ * [API] AI 에이전트 세션 실행 (핵심 로직)
+ * @param {string} role - 실행할 역할 (예: 'developer')
+ * @param {string} tool - 사용할 도구 (예: 'claude')
+ * @param {object} options - 추가 옵션
+ * @returns {Promise<object>} 세션 결과 정보
+ */
+export async function executeAgentSession(role, tool, options = {}) {
   const roles = getAvailableRoles();
   const tools = ['claude', 'codex', 'gemini', 'copilot'];
 
   // 역할 검증
   if (!roles.includes(role)) {
-    console.log(chalk.red(`❌ 알 수 없는 역할: ${role}`));
-    console.log(chalk.gray(`사용 가능: ${roles.join(', ')}`));
-    process.exit(1);
+    throw new Error(`알 수 없는 역할입니다: ${role} (사용 가능: ${roles.join(', ')})`);
   }
 
   // 도구 검증
   if (!tools.includes(tool)) {
-    console.log(chalk.red(`❌ 알 수 없는 도구: ${tool}`));
-    console.log(chalk.gray(`사용 가능: ${tools.join(', ')}`));
-    process.exit(1);
+    throw new Error(`알 수 없는 도구입니다: ${tool} (사용 가능: ${tools.join(', ')})`);
   }
 
   const workspace = getWorkspaceDir();
@@ -55,7 +54,7 @@ export async function run(role, tool) {
   fs.ensureDirSync(sessionDir);
   fs.ensureDirSync(logsDir);
 
-  // 세션 정보 저장
+  // 세션 정보 객체
   const sessionInfo = {
     session_id: sessionId,
     role: role,
@@ -64,38 +63,199 @@ export async function run(role, tool) {
     started_at: getTimestamp(),
     status: 'active'
   };
-  fs.writeFileSync(path.join(sessionDir, 'session.json'), JSON.stringify(sessionInfo, null, 2));
+  const sessionFile = path.join(sessionDir, 'session.json');
+  fs.writeFileSync(sessionFile, JSON.stringify(sessionInfo, null, 2));
 
-  // 로그 파일 초기화
+  // 로그 헬퍼
   const logFile = path.join(logsDir, `${sessionId}.log`);
   const logMessage = (level, msg) => {
     const line = `[${getTimestamp()}] [${level}] ${msg}\n`;
     fs.appendFileSync(logFile, line);
+    // 옵션에 따라 콘솔 출력 제어 가능 (현재는 항상 출력)
   };
 
-  logMessage('INFO', `세션 시작: role=${role}, tool=${tool}, template=${template}`);
+  // 세션 정리 함수 (시그널 핸들러 및 정상 종료에서 공통 사용)
+  let isCleanedUp = false;
+  const cleanupSession = (status, reason = null) => {
+    if (isCleanedUp) return;
+    isCleanedUp = true;
+
+    sessionInfo.status = status;
+    sessionInfo.ended_at = getTimestamp();
+    if (reason) {
+      sessionInfo.termination_reason = reason;
+    }
+
+    try {
+      fs.writeFileSync(sessionFile, JSON.stringify(sessionInfo, null, 2));
+      logMessage('INFO', `세션 종료 (${status}): ${reason || '정상 종료'}`);
+      unregisterSession(sessionId);
+    } catch (err) {
+      // 정리 중 에러는 무시 (이미 종료 중)
+    }
+  };
 
-  // 멀티 세션: 상태 파일에 세션 등록
-  registerSession(sessionId, role, tool);
-  logMessage('INFO', `세션 등록: ${sessionId}`);
+  // 시그널 핸들러 (Ctrl+C 등 강제 종료 시 세션 정리)
+  const handleSignal = (signal) => {
+    logMessage('INFO', `시그널 수신: ${signal}`);
+    cleanupSession('completed', `사용자 종료 (${signal})`);
 
-  // 역할 파일 경로
-  const roleFile = path.join(workspace, 'roles', `${role}.md`);
-  const roleContent = fs.readFileSync(roleFile, 'utf-8');
+    // 핸들러 제거
+    process.removeListener('SIGINT', handleSignal);
+    process.removeListener('SIGTERM', handleSignal);
 
-  // 시스템 프롬프트 생성
-  const systemPrompt = buildSystemPrompt(workspace, role, roleContent);
+    // exitOnSignal 옵션이 false가 아니면 프로세스 종료 (기본값: true)
+    if (options.exitOnSignal !== false) {
+      setTimeout(() => {
+        process.exit(0);
+      }, 100);
+    }
+  };
+
+  // 시그널 핸들러 등록
+  process.on('SIGINT', handleSignal);
+  process.on('SIGTERM', handleSignal);
+
+  try {
+    logMessage('INFO', `세션 시작: role=${role}, tool=${tool}, template=${template}`);
+
+    // 멀티 세션 등록
+    registerSession(sessionId, role, tool);
+    logMessage('INFO', `세션 등록: ${sessionId}`);
+
+    // 역할 파일 로드 (옵션으로 오버라이드 가능)
+    let systemPrompt;
+    if (options.systemPromptOverride) {
+      systemPrompt = options.systemPromptOverride;
+      logMessage('INFO', '시스템 프롬프트 오버라이드 사용됨');
+    } else {
+      const roleFile = path.join(workspace, 'roles', `${role}.md`);
+      if (!fs.existsSync(roleFile)) {
+        throw new Error(`역할 파일이 존재하지 않습니다: ${roleFile}`);
+      }
+      const roleContent = fs.readFileSync(roleFile, 'utf-8');
+      systemPrompt = buildSystemPrompt(workspace, role, roleContent);
+    }
+
+    // 프롬프트 파일 저장
+    const promptFile = path.join(sessionDir, 'system-prompt.md');
+    fs.writeFileSync(promptFile, systemPrompt, 'utf-8');
+    logMessage('INFO', `시스템 프롬프트 저장: ${promptFile}`);
+
+    // 터미널 UI 출력 (Headless 모드가 아닐 때만)
+    if (!options.headless) {
+      printSessionBanner(role, tool, sessionId, template);
+    }
+
+    // AI 도구 프로세스 실행
+    const handleSpawn = (child) => {
+      sessionInfo.pid = child.pid;
+      fs.writeFileSync(sessionFile, JSON.stringify(sessionInfo, null, 2));
+      updateSessionDetails(sessionId, { pid: child.pid });
+    };
+
+    const output = await launchTool(tool, systemPrompt, promptFile, logMessage, {
+      ...options,
+      onSpawn: handleSpawn
+    });
 
-  // 시스템 프롬프트를 파일로 저장 (AI 도구가 읽을 수 있도록)
-  const promptFile = path.join(sessionDir, 'system-prompt.md');
-  fs.writeFileSync(promptFile, systemPrompt, 'utf-8');
-  logMessage('INFO', `시스템 프롬프트 저장: ${promptFile}`);
+    // 시그널 핸들러 제거
+    process.removeListener('SIGINT', handleSignal);
+    process.removeListener('SIGTERM', handleSignal);
 
-  // 다른 활성 세션 확인
+    // 정상 종료 처리
+    if (output) {
+      sessionInfo.output = output;
+    }
+    cleanupSession('completed');
+
+    // 캡처된 출력 반환
+    return { ...sessionInfo, output };
+
+  } catch (error) {
+    // 시그널 핸들러 제거
+    process.removeListener('SIGINT', handleSignal);
+    process.removeListener('SIGTERM', handleSignal);
+
+    // 에러가 사용자 종료(exit code 비정상)인 경우 completed로 처리
+    const isUserTermination = error.message && (
+      error.message.includes('exited with code 130') ||  // SIGINT
+      error.message.includes('exited with code 143') ||  // SIGTERM
+      error.message.includes('exited with code 1')       // 일반 종료
+    );
+
+    if (isUserTermination) {
+      cleanupSession('completed', '사용자 종료');
+      return { ...sessionInfo };
+    }
+
+    // 실제 에러 처리
+    sessionInfo.error = error.message;
+    cleanupSession('error', error.message);
+    logMessage('ERROR', error.message);
+
+    throw error;
+  }
+}
+
+/**
+ * [CLI] 실행 명령어 핸들러
+ * 사용자 입력을 처리하고 executeAgentSession을 호출
+ */
+export async function runCommand(role, tool) {
+  if (!isWorkspaceSetup()) {
+    console.log(chalk.red('❌ 먼저 setup을 실행하세요.'));
+    console.log(chalk.gray('  ada setup'));
+    process.exit(1);
+  }
+
+  try {
+    // 1. 역할 선택 (입력 없으면 질문)
+    if (!role) {
+      const roles = getAvailableRoles();
+      const answer = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'role',
+          message: '실행할 역할을 선택하세요:',
+          choices: roles
+        }
+      ]);
+      role = answer.role;
+    }
+
+    // 2. 도구 자동 선택 (입력 없으면 설정 파일 참조)
+    if (!tool) {
+      tool = getToolForRole(role);
+      console.log(chalk.gray(`ℹ️  설정된 기본 도구를 사용합니다: ${tool}`));
+    }
+
+    // 3. 세션 실행
+    await executeAgentSession(role, tool);
+
+  } catch (error) {
+    console.error(chalk.red('\n❌ 실행 중 오류가 발생했습니다:'));
+    console.error(chalk.white(error.message));
+    process.exit(1);
+  }
+}
+
+// 기존 CLI 호환성을 위해 run이라는 이름으로 export
+export { runCommand as run };
+// 시스템 프롬프트 생성 로직도 외부에서 쓸 수 있게 export
+export { buildSystemPrompt };
+
+
+// ============================================================================ 
+// 내부 헬퍼 함수들
+// ============================================================================ 
+
+function printSessionBanner(role, tool, sessionId, template) {
+  // 다른 활성 세션 정보
   const activeSessions = getActiveSessions().filter(s => s.sessionId !== sessionId);
   const pendingQuestions = getPendingQuestions();
 
-  // 터미널 타이틀 설정
+  // 터미널 타이틀
   const terminalTitle = `ADA: ${role} (${tool})`;
   process.stdout.write(`\x1b]0;${terminalTitle}\x07`);
 
@@ -105,16 +265,15 @@ export async function run(role, tool) {
   console.log(chalk.cyan('━'.repeat(60)));
   console.log('');
 
-  // 역할 강조 표시
   const roleEmojis = {
     'analyzer': '🔍',
     'planner': '📋',
+    'improver': '🔧',
     'architect': '🏛️',
     'developer': '💻',
     'backend': '⚙️',
     'frontend': '🎨',
     'reviewer': '👀',
-    'qa': '🧪',
     'manager': '👔',
     'library-developer': '📚',
     'game-logic': '🎮',
@@ -130,10 +289,9 @@ export async function run(role, tool) {
   console.log(chalk.white(`  템플릿:   ${chalk.green(template)}`));
   console.log(chalk.white(`  도구:     ${chalk.green(tool)}`));
   console.log(chalk.white(`  작업공간: ${chalk.gray('ai-dev-team/')}`));
-  console.log(chalk.white(`  로그:     ${chalk.gray(`.sessions/logs/${sessionId}.log`)}`));
+  console.log(chalk.white(`  로그:     ${chalk.gray('.sessions/logs/' + sessionId + '.log')}`));
   console.log('');
 
-  // 멀티 세션 정보 표시
   if (activeSessions.length > 0) {
     console.log(chalk.white(`  🔗 활성 세션: ${chalk.yellow(activeSessions.length)}개`));
     activeSessions.forEach(s => {
@@ -149,32 +307,6 @@ export async function run(role, tool) {
 
   console.log(chalk.cyan('━'.repeat(60)));
   console.log('');
-
-  // 도구별 실행
-  try {
-    await launchTool(tool, systemPrompt, promptFile, logMessage);
-
-    // 세션 완료 처리
-    sessionInfo.status = 'completed';
-    sessionInfo.ended_at = getTimestamp();
-    fs.writeFileSync(path.join(sessionDir, 'session.json'), JSON.stringify(sessionInfo, null, 2));
-    logMessage('INFO', '세션 종료');
-
-    // 멀티 세션: 상태 파일에서 세션 제거
-    unregisterSession(sessionId);
-    logMessage('INFO', `세션 해제: ${sessionId}`);
-  } catch (error) {
-    sessionInfo.status = 'error';
-    sessionInfo.error = error.message;
-    fs.writeFileSync(path.join(sessionDir, 'session.json'), JSON.stringify(sessionInfo, null, 2));
-    logMessage('ERROR', error.message);
-
-    // 멀티 세션: 에러 시에도 세션 제거
-    unregisterSession(sessionId);
-    logMessage('INFO', `세션 해제 (에러): ${sessionId}`);
-
-    throw error;
-  }
 }
 
 function buildSystemPrompt(workspace, role, roleContent) {
@@ -185,21 +317,40 @@ function buildSystemPrompt(workspace, role, roleContent) {
   prompt += roleContent;
   prompt += '\n\n---\n\n';
 
-  // 1. 규칙 문서 전체 포함 (규칙은 반드시 알아야 함)
+  // 1. 규칙 문서 - 역할별 필수 규칙만 포함
+  const roleRules = {
+    planner: ['iteration.md', 'escalation.md', 'document-priority.md'],
+    improver: ['iteration.md', 'escalation.md', 'document-priority.md', 'rfc.md'],
+    developer: ['iteration.md', 'escalation.md', 'rollback.md', 'document-priority.md', 'rfc.md'],
+    reviewer: ['iteration.md', 'rollback.md', 'escalation.md', 'document-priority.md'],
+    documenter: ['escalation.md', 'document-priority.md'],
+    analyzer: ['escalation.md', 'document-priority.md'],
+    manager: ['escalation.md', 'document-priority.md', 'rfc.md']  // Manager는 모든 규칙 참고
+  };
+
+  const requiredRules = roleRules[role] || [];
+
   prompt += '# 규칙 (Rules)\n\n';
-  if (fs.existsSync(rulesDir)) {
-    const rules = fs.readdirSync(rulesDir).filter(f => f.endsWith('.md'));
-    rules.forEach(ruleFile => {
+  prompt += `이 역할에 적용되는 필수 규칙: ${requiredRules.join(', ')}\n\n`;
+
+  if (fs.existsSync(rulesDir) && requiredRules.length > 0) {
+    requiredRules.forEach(ruleFile => {
       const rulePath = path.join(rulesDir, ruleFile);
-      try {
-        const content = fs.readFileSync(rulePath, 'utf-8');
-        prompt += `## ${ruleFile}\n\n`;
-        prompt += content;
-        prompt += '\n\n---\n\n';
-      } catch (err) {
-        prompt += `## ${ruleFile} (읽기 실패)\n\n`;
+      if (fs.existsSync(rulePath)) {
+        try {
+          const content = fs.readFileSync(rulePath, 'utf-8');
+          prompt += `## ${ruleFile}\n\n`;
+          prompt += content;
+          prompt += '\n\n---\n\n';
+        } catch (err) {
+          prompt += `## ${ruleFile} (읽기 실패)\n\n`;
+        }
+      } else {
+        prompt += `## ${ruleFile} (파일 없음)\n\n`;
       }
     });
+  } else if (requiredRules.length === 0) {
+    prompt += '(이 역할에 필수 규칙이 지정되지 않았습니다)\n\n';
   }
 
   // 2. 핵심 산출물 전체 포함 (우선순위 높은 문서)
@@ -228,6 +379,8 @@ function buildSystemPrompt(workspace, role, roleContent) {
   });
 
   // 2.1 현재 활성 스프린트 포함
+  prompt += '# 현재 스프린트 정보\n\n';
+
   const sprintsDir = path.join(artifactsDir, 'sprints');
   if (fs.existsSync(sprintsDir)) {
     const sprints = fs.readdirSync(sprintsDir, { withFileTypes: true })
@@ -256,22 +409,65 @@ function buildSystemPrompt(workspace, role, roleContent) {
         }
       }
 
-      // 스프린트의 Task 파일 목록
+      // 스프린트의 Task 파일 전체 포함
       const sprintTasksDir = path.join(sprintsDir, activeSprint, 'tasks');
       if (fs.existsSync(sprintTasksDir)) {
         const taskFiles = fs.readdirSync(sprintTasksDir)
           .filter(f => f.endsWith('.md') && !f.includes('template'));
 
         if (taskFiles.length > 0) {
-          prompt += `## 현재 스프린트 Task 파일 목록\n\n`;
-          prompt += `다음 Task 파일들을 필요 시 읽어서 확인하세요:\n`;
+          prompt += `## 현재 스프린트 Task 파일들\n\n`;
+
+          // 각 Task 파일 내용 포함
           taskFiles.forEach(f => {
-            prompt += `- sprints/${activeSprint}/tasks/${f}\n`;
+            const taskPath = path.join(sprintTasksDir, f);
+            try {
+              const taskContent = fs.readFileSync(taskPath, 'utf-8');
+              prompt += `### ${f}\n\n`;
+              prompt += taskContent;
+              prompt += '\n\n---\n\n';
+            } catch (err) {
+              prompt += `### ${f} (읽기 실패)\n\n`;
+            }
           });
-          prompt += '\n---\n\n';
+        } else {
+          // Task 파일이 없는 경우
+          prompt += `## ⚠️ 스프린트에 Task 없음\n\n`;
+          prompt += `현재 스프린트(${activeSprint})에 할당된 Task가 없습니다.\n\n`;
+          prompt += '**다음 단계:**\n';
+          prompt += '1. `ada sprint add task-001 task-002` 명령으로 Task 할당\n';
+          prompt += '2. Developer 세션 재시작\n\n';
+          prompt += '---\n\n';
         }
+      } else {
+        // tasks 디렉토리가 없는 경우
+        prompt += `## ⚠️ tasks 디렉토리 없음\n\n`;
+        prompt += `현재 스프린트(${activeSprint})에 tasks 디렉토리가 없습니다.\n\n`;
+        prompt += '스프린트 구조가 올바르지 않습니다. `ada sprint create` 명령으로 재생성하세요.\n\n';
+        prompt += '---\n\n';
       }
+    } else {
+      // 스프린트가 없는 경우
+      prompt += '## ⚠️ 현재 활성 스프린트 없음\n\n';
+      prompt += '스프린트가 아직 생성되지 않았습니다.\n\n';
+      prompt += '**다음 단계:**\n';
+      prompt += '1. Planner가 plan.md와 backlog/ Task를 작성했는지 확인\n';
+      prompt += '2. `ada sprint create` 명령으로 스프린트 생성\n';
+      prompt += '3. `ada sprint add task-001 task-002` 명령으로 Task 할당\n';
+      prompt += '4. Developer 세션 재시작\n\n';
+      prompt += '**참고:** Developer는 스프린트가 있어야 작업할 수 있습니다.\n';
+      prompt += '스프린트 없이는 어떤 Task를 해야 할지 알 수 없습니다.\n\n';
+      prompt += '---\n\n';
     }
+  } else {
+    // sprints 디렉토리 자체가 없는 경우
+    prompt += '## ⚠️ sprints 디렉토리 없음\n\n';
+    prompt += 'sprints 디렉토리가 존재하지 않습니다.\n\n';
+    prompt += '**다음 단계:**\n';
+    prompt += '1. `ada sprint create` 명령으로 첫 스프린트 생성\n';
+    prompt += '2. Task를 스프린트에 추가\n';
+    prompt += '3. Developer 세션 재시작\n\n';
+    prompt += '---\n\n';
   }
 
   // 2.2 Backlog Task 목록
@@ -386,7 +582,7 @@ function buildSystemPrompt(workspace, role, roleContent) {
   return prompt;
 }
 
-async function launchTool(tool, systemPrompt, promptFile, logMessage) {
+async function launchTool(tool, systemPrompt, promptFile, logMessage, options = {}) {
   // 프롬프트 파일의 상대 경로 (작업 디렉토리 기준)
   const relativePromptPath = path.relative(process.cwd(), promptFile);
 
@@ -420,76 +616,118 @@ async function launchTool(tool, systemPrompt, promptFile, logMessage) {
   };
 
   const config = commands[tool];
-  const { cmd, args } = config;
+  let { cmd, args } = config;
+  let usePromptStdin = false;
+  let promptInput = null;
+
+  if (options.captureOutput) {
+    // captureOutput 모드일 때 Claude는 --print 옵션 필요
+    if (tool === 'claude') {
+      args = ['--print', '-p', '위 시스템 프롬프트의 지시에 따라 JSON으로 응답하세요.', '--system-prompt-file', promptFile];
+    }
 
-  // 도구 존재 확인
-  const which = spawn('which', [cmd], { shell: true });
+    // codex exec는 프롬프트를 stdin으로 받는다
+    if (tool === 'codex') {
+      args = ['exec', '-'];
+      usePromptStdin = true;
+      promptInput = systemPrompt;
+    }
+
+    // gemini는 Stdin으로 프롬프트 전달 (에러 해결: No input provided via stdin)
+    if (tool === 'gemini') {
+      const userPrompt = '위 시스템 프롬프트의 지시에 따라 JSON으로 응답하세요.';
+      args = ['-o', 'text'];
+      usePromptStdin = true;
+      promptInput = userPrompt;
+    }
+  }
+
+  // 도구 존재 확인 (Windows: where, Unix: which)
+  const whichCmd = process.platform === 'win32' ? 'where' : 'which';
+  const which = spawn(whichCmd, [cmd], { shell: true });
 
   return new Promise((resolve, reject) => {
     which.on('close', (code) => {
       if (code !== 0) {
         console.log(chalk.yellow(`⚠️  ${tool} CLI가 설치되어 있지 않습니다.`));
-        console.log('');
-        console.log(chalk.white('시스템 프롬프트가 다음 파일에 저장되었습니다:'));
-        console.log(chalk.cyan(`  ${relativePromptPath}`));
-        console.log('');
-        console.log(chalk.gray('─'.repeat(60)));
-        console.log(systemPrompt);
-        console.log(chalk.gray('─'.repeat(60)));
-        console.log('');
-        console.log(chalk.gray('위 내용을 복사하여 AI 도구에 붙여넣거나, 파일을 읽도록 하세요.'));
         logMessage('WARN', `${tool} CLI not found, prompt displayed`);
-        resolve();
+        resolve(null);
         return;
       }
 
-      // 도구별 안내 메시지
-      console.log('');
-      if (config.automation === 'perfect') {
-        // 완전 자동화: 간단한 성공 메시지
-        console.log(chalk.green('━'.repeat(60)));
-        console.log(chalk.green.bold('✓ 역할이 자동으로 설정됩니다'));
-        console.log(chalk.green('━'.repeat(60)));
-        console.log('');
-        console.log(chalk.gray(`시스템 프롬프트: ${relativePromptPath}`));
+      if (!options.captureOutput) {
         console.log('');
-      } else {
-        // 수동 입력 필요: 명확한 안내
-        console.log(chalk.yellow('━'.repeat(60)));
-        console.log(chalk.yellow.bold('⚠️  중요: AI 도구 시작 후 다음을 입력하세요'));
-        console.log(chalk.yellow('━'.repeat(60)));
-        console.log('');
-        console.log(chalk.cyan.bold(`  ${config.instruction}`));
-        console.log('');
-        console.log(chalk.gray('그 다음 Enter를 눌러 역할을 수행하도록 하세요.'));
-        console.log('');
-        console.log(chalk.yellow('━'.repeat(60)));
+        if (config.automation === 'perfect') {
+          console.log(chalk.green('━'.repeat(60)));
+          console.log(chalk.green.bold('✓ 역할이 자동으로 설정됩니다'));
+          console.log(chalk.green('━'.repeat(60)));
+          console.log('');
+          console.log(chalk.gray(`시스템 프롬프트: ${relativePromptPath}`));
+          console.log('');
+        } else if (config.automation === 'manual') {
+          console.log(chalk.yellow('━'.repeat(60)));
+          console.log(chalk.yellow.bold('⚠️  수동 설정이 필요합니다'));
+          console.log(chalk.yellow('━'.repeat(60)));
+          console.log('');
+          console.log('CLI가 실행되면 아래 명령어를 복사해서 입력하세요:');
+          console.log('');
+          console.log(chalk.bgWhite.black.bold(` ${config.instruction} `));
+          console.log('');
+        }
+        console.log(chalk.green(`✓ ${tool} 실행 중...`));
         console.log('');
       }
 
-      // CLI 실행
-      console.log(chalk.green(`✓ ${tool} 실행 중...`));
-      console.log('');
-      logMessage('INFO', `${tool} CLI 실행 (automation: ${config.automation})`);
+      logMessage('INFO', `${tool} CLI 실행 (automation: ${config.automation}, captureOutput: ${!!options.captureOutput})`);
 
-      // 환경 변수 병합 (도구별 커스텀 환경 변수 포함)
+      // 환경 변수 병합
       const envVars = {
         ...process.env,
         ADA_SYSTEM_PROMPT: systemPrompt,
-        ...(config.env || {})  // 도구별 환경 변수 추가
+        ...(config.env || {})
       };
 
+      // 캡처 모드에 따라 stdio 설정 변경
+      const stdioConfig = options.captureOutput
+        ? (usePromptStdin ? ['pipe', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe'])
+        : 'inherit';
+
       const child = spawn(cmd, args, {
-        stdio: 'inherit',
+        stdio: stdioConfig,
         shell: true,
         env: envVars
       });
 
+      if (typeof options.onSpawn === 'function') {
+        options.onSpawn(child);
+      }
+
+      let capturedOutput = '';
+      let capturedError = '';
+
+      if (options.captureOutput) {
+        child.stdout.on('data', (data) => {
+          capturedOutput += data.toString();
+        });
+        child.stderr.on('data', (data) => {
+          capturedError += data.toString();
+        });
+      }
+
+      if (options.captureOutput && usePromptStdin && child.stdin) {
+        const input = promptInput || systemPrompt;
+        child.stdin.write(input);
+        child.stdin.end();
+      }
+
       child.on('close', (code) => {
         if (code === 0) {
-          resolve();
+          resolve(options.captureOutput ? capturedOutput : null);
         } else {
-          reject(new Error(`${tool} exited with code ${code}`));
+          const errorMsg = options.captureOutput
+            ? `${tool} exited with code ${code}. Stderr: ${capturedError}`
+            : `${tool} exited with code ${code}`;
+          reject(new Error(errorMsg));
         }
       });