sessioncast-cli 1.0.0

package/dist/project/executor.js

@@ -0,0 +1,893 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowExecutor = void 0;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const events_1 = require("events");
+const relay_client_1 = require("./relay-client");
+const POLL_INTERVAL_MS = 2000;
+const MAX_RETRIES = 3;
+const CLAUDE_START_DELAY_MS = 1000;
+const CLAUDE_ANALYSIS_TIMEOUT_MS = 55000; // 55 seconds (less than server's 60s timeout)
+class WorkflowExecutor extends events_1.EventEmitter {
+    constructor(manager, options = {}) {
+        super();
+        this.workflow = null;
+        this.running = false;
+        this.pollTimer = null;
+        this.relayClient = null;
+        this.manager = manager;
+        this.options = {
+            autoLaunchClaude: options.autoLaunchClaude ?? true,
+            claudeCommand: options.claudeCommand ?? 'claude',
+            relayUrl: options.relayUrl,
+            relayToken: options.relayToken,
+            machineId: options.machineId ?? os.hostname()
+        };
+    }
+    /**
+     * Start workflow execution
+     */
+    async start() {
+        this.workflow = this.manager.loadWorkflow();
+        if (!this.workflow) {
+            throw new Error('No workflow found. Run project init first.');
+        }
+        this.running = true;
+        console.log(`Starting workflow: ${this.workflow.name}`);
+        // Connect to relay server if configured
+        if (this.options.relayUrl && this.options.relayToken) {
+            await this.connectToRelay();
+        }
+        // Initialize status
+        const status = {
+            workflow: this.workflow.name,
+            startedAt: new Date().toISOString(),
+            status: 'running',
+            agents: {}
+        };
+        for (const agent of this.workflow.agents) {
+            status.agents[agent.id] = { status: 'pending' };
+        }
+        this.manager.saveStatus(status);
+        // Start PM Agent first
+        await this.startPMAgent();
+        // Then start the workflow execution loop
+        this.runExecutionLoop();
+    }
+    /**
+     * Start PM Agent tmux session
+     */
+    async startPMAgent() {
+        const sessionName = this.manager.getTmuxSessionName('pm');
+        const pmAgentPath = path.join(this.manager.getProjectPath(), 'tools', 'pm-agent');
+        console.log(`Starting PM Agent: ${sessionName}`);
+        try {
+            // Check if session already exists
+            try {
+                (0, child_process_1.execSync)(`tmux has-session -t "${sessionName}" 2>/dev/null`);
+                console.log(`PM Agent session already exists: ${sessionName}`);
+                // Update status to running even if session already exists
+                this.manager.updateAgentStatus('pm', {
+                    status: 'running',
+                    startedAt: new Date().toISOString()
+                });
+                this.updateRelayStatus();
+                return;
+            }
+            catch {
+                // Session doesn't exist, create it
+            }
+            // Create new tmux session
+            (0, child_process_1.execSync)(`tmux new-session -d -s "${sessionName}" -c "${pmAgentPath}"`, { stdio: 'pipe' });
+            console.log(`Created PM Agent session: ${sessionName}`);
+            // Auto-launch Claude Code CLI
+            if (this.options.autoLaunchClaude) {
+                await this.launchClaudeInSession(sessionName, 'pm');
+            }
+            // Update status
+            this.manager.updateAgentStatus('pm', {
+                status: 'running',
+                startedAt: new Date().toISOString()
+            });
+            this.updateRelayStatus();
+            this.emit('agent-started', { agentId: 'pm', sessionName });
+        }
+        catch (error) {
+            console.error('Failed to start PM Agent:', error);
+            throw error;
+        }
+    }
+    /**
+     * Start a work agent
+     */
+    async startAgent(agent) {
+        const sessionName = this.manager.getTmuxSessionName(agent.id);
+        const agentPath = path.join(this.manager.getProjectPath(), agent.workDir);
+        console.log(`Starting agent: ${agent.id} (${agent.name})`);
+        try {
+            // Check if session already exists
+            try {
+                (0, child_process_1.execSync)(`tmux has-session -t "${sessionName}" 2>/dev/null`);
+                console.log(`Agent session already exists: ${sessionName}`);
+                // Update status to running even if session already exists
+                this.manager.updateAgentStatus(agent.id, {
+                    status: 'running',
+                    startedAt: new Date().toISOString(),
+                    currentTask: agent.tasks[0] || 'Resuming...'
+                });
+                this.updateRelayStatus();
+                return;
+            }
+            catch {
+                // Session doesn't exist, create it
+            }
+            // Ensure work folder exists with CLAUDE.md
+            this.manager.createWorkAgent(agent.id, agent.name, agent.tasks);
+            // Create new tmux session
+            (0, child_process_1.execSync)(`tmux new-session -d -s "${sessionName}" -c "${agentPath}"`, { stdio: 'pipe' });
+            console.log(`Created agent session: ${sessionName}`);
+            // Auto-launch Claude Code CLI with task prompt
+            if (this.options.autoLaunchClaude) {
+                const taskPrompt = this.buildTaskPrompt(agent);
+                await this.launchClaudeInSession(sessionName, agent.id, taskPrompt);
+            }
+            // Update status
+            this.manager.updateAgentStatus(agent.id, {
+                status: 'running',
+                startedAt: new Date().toISOString(),
+                currentTask: agent.tasks[0] || 'Starting...'
+            });
+            this.updateRelayStatus();
+            this.emit('agent-started', { agentId: agent.id, sessionName });
+        }
+        catch (error) {
+            console.error(`Failed to start agent ${agent.id}:`, error);
+            this.manager.updateAgentStatus(agent.id, {
+                status: 'failed',
+                error: String(error)
+            });
+            this.updateRelayStatus();
+        }
+    }
+    /**
+     * Build task prompt for agent
+     */
+    buildTaskPrompt(agent) {
+        const tasks = agent.tasks.map((t, i) => `${i + 1}. ${t}`).join('\n');
+        return `다음 태스크를 수행해주세요:\n${tasks}\n\n완료 후 반드시:\n1. output.md에 결과 기록\n2. touch DONE 실행`;
+    }
+    /**
+     * Launch Claude Code CLI in a tmux session
+     */
+    async launchClaudeInSession(sessionName, agentId, initialPrompt) {
+        // Wait for shell to be ready
+        await this.sleep(CLAUDE_START_DELAY_MS);
+        try {
+            // Send claude command
+            (0, child_process_1.execSync)(`tmux send-keys -t "${sessionName}" "${this.options.claudeCommand}" Enter`, {
+                stdio: 'pipe'
+            });
+            console.log(`Launched Claude Code in ${agentId}`);
+            // If there's an initial prompt, send it after claude starts
+            if (initialPrompt) {
+                // Wait for claude to initialize
+                await this.sleep(3000);
+                // Send the initial prompt
+                const escapedPrompt = initialPrompt.replace(/"/g, '\\"').replace(/\n/g, '\\n');
+                (0, child_process_1.execSync)(`tmux send-keys -t "${sessionName}" "${escapedPrompt}" Enter`, {
+                    stdio: 'pipe'
+                });
+                console.log(`Sent initial prompt to ${agentId}`);
+            }
+        }
+        catch (error) {
+            console.error(`Failed to launch Claude in ${agentId}:`, error);
+        }
+    }
+    /**
+     * Sleep helper
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Main execution loop
+     */
+    runExecutionLoop() {
+        const check = () => {
+            if (!this.running || !this.workflow) {
+                return;
+            }
+            const status = this.manager.loadStatus();
+            if (!status)
+                return;
+            // Check each agent
+            for (const agent of this.workflow.agents) {
+                const agentStatus = status.agents[agent.id];
+                // Skip completed or failed agents
+                if (agentStatus?.status === 'completed' || agentStatus?.status === 'failed') {
+                    continue;
+                }
+                // Check if dependencies are met
+                const dependenciesMet = agent.dependsOn.every(depId => {
+                    return status.agents[depId]?.status === 'completed';
+                });
+                if (!dependenciesMet) {
+                    continue;
+                }
+                // Check if agent is pending (not started yet)
+                if (agentStatus?.status === 'pending') {
+                    this.startAgent(agent);
+                    continue;
+                }
+                // Check if running agent is completed
+                if (agentStatus?.status === 'running') {
+                    if (this.manager.isAgentCompleted(agent.id)) {
+                        const output = this.manager.getAgentOutput(agent.id);
+                        this.manager.updateAgentStatus(agent.id, {
+                            status: 'completed',
+                            completedAt: new Date().toISOString(),
+                            output: output || undefined
+                        });
+                        // Append output to shared context
+                        if (output) {
+                            this.manager.appendToContext(`\n## ${agent.name} Output\n${output}\n`);
+                        }
+                        console.log(`Agent completed: ${agent.id}`);
+                        this.updateRelayStatus();
+                        this.emit('agent-completed', { agentId: agent.id, output });
+                    }
+                }
+            }
+            // Check if workflow is complete
+            const updatedStatus = this.manager.loadStatus();
+            if (updatedStatus) {
+                const allCompleted = this.workflow.agents.every(a => updatedStatus.agents[a.id]?.status === 'completed');
+                if (allCompleted) {
+                    console.log('Workflow completed!');
+                    updatedStatus.status = 'completed';
+                    this.manager.saveStatus(updatedStatus);
+                    this.updateRelayStatus();
+                    this.emit('workflow-completed', updatedStatus);
+                    this.stop();
+                    return;
+                }
+                const anyFailed = this.workflow.agents.some(a => updatedStatus.agents[a.id]?.status === 'failed');
+                if (anyFailed) {
+                    console.log('Workflow failed!');
+                    updatedStatus.status = 'failed';
+                    this.manager.saveStatus(updatedStatus);
+                    this.updateRelayStatus();
+                    this.emit('workflow-failed', updatedStatus);
+                    this.stop();
+                    return;
+                }
+            }
+            // Continue polling
+            this.pollTimer = setTimeout(check, POLL_INTERVAL_MS);
+        };
+        check();
+    }
+    /**
+     * Connect to relay server
+     */
+    async connectToRelay() {
+        if (!this.options.relayUrl || !this.options.relayToken || !this.workflow) {
+            return;
+        }
+        try {
+            this.relayClient = new relay_client_1.ProjectRelayClient({
+                url: this.options.relayUrl,
+                token: this.options.relayToken,
+                machineId: this.options.machineId || os.hostname(),
+                projectId: this.manager.getProjectId(),
+                projectName: this.workflow.name,
+                mission: this.workflow.mission,
+                sources: this.manager.getSources(),
+            });
+            await this.relayClient.connect();
+            console.log('Connected to relay server');
+            this.relayClient.on('error', (error) => {
+                console.error('Relay connection error:', error.message);
+            });
+            this.relayClient.on('disconnected', () => {
+                console.log('Disconnected from relay server');
+            });
+            // Handle incoming messages from server
+            this.relayClient.on('message', (message) => {
+                this.handleRelayMessage(message);
+            });
+        }
+        catch (error) {
+            console.error('Failed to connect to relay server:', error);
+            // Don't throw - relay is optional
+        }
+    }
+    /**
+     * Handle incoming messages from relay server
+     */
+    handleRelayMessage(message) {
+        switch (message.type) {
+            case 'analyzeMission':
+                this.handleAnalyzeMission(message);
+                break;
+            case 'addSource':
+                this.handleAddSource(message);
+                break;
+            default:
+                // Ignore other message types
+                break;
+        }
+    }
+    /**
+     * Handle mission analysis request - calls Claude Code to analyze
+     */
+    async handleAnalyzeMission(message) {
+        const requestId = message.requestId;
+        const meta = message.meta || {};
+        const mission = meta.mission || '';
+        const contextPaths = meta.contextPaths ? meta.contextPaths.split(',').filter(Boolean) : [];
+        if (!requestId) {
+            console.error('analyzeMission: missing requestId');
+            return;
+        }
+        console.log(`Analyzing mission: ${mission.substring(0, 50)}...`);
+        if (contextPaths.length > 0) {
+            console.log(`With context paths: ${contextPaths.join(', ')}`);
+        }
+        try {
+            const result = await this.callClaudeForAnalysis(mission, contextPaths);
+            this.relayClient?.sendAnalysisResponse(requestId, result.steps, result.decisions);
+            console.log(`Mission analysis completed: ${result.steps.length} steps, ${result.decisions.length} decisions`);
+        }
+        catch (error) {
+            console.error('Mission analysis failed:', error);
+            this.relayClient?.sendAnalysisError(requestId, String(error));
+        }
+    }
+    /**
+     * Handle addSource request - clone/copy source into work folder
+     */
+    async handleAddSource(message) {
+        const requestId = message.requestId;
+        const meta = message.meta || {};
+        const sourceType = meta.sourceType || 'git';
+        const sourceUrl = meta.sourceUrl || '';
+        const targetFolder = meta.targetFolder || '';
+        if (!requestId || !sourceUrl) {
+            console.error('addSource: missing requestId or sourceUrl');
+            return;
+        }
+        console.log(`Adding source: ${sourceType} ${sourceUrl} -> work/${targetFolder || 'auto'}`);
+        try {
+            const result = await this.executeAddSource(sourceType, sourceUrl, targetFolder);
+            this.relayClient?.sendAddSourceResult(requestId, result);
+            console.log(`Source added successfully: ${result.folder}`);
+            // Update sources list on server
+            const sources = this.manager.getSources();
+            this.relayClient?.updateSources(sources);
+        }
+        catch (error) {
+            console.error('Add source failed:', error);
+            this.relayClient?.sendAddSourceError(requestId, String(error));
+        }
+    }
+    /**
+     * Execute the source addition command
+     */
+    executeAddSource(sourceType, sourceUrl, targetFolder) {
+        // For 'prompt' type, use Claude to generate and execute the command
+        if (sourceType === 'prompt') {
+            return this.executeAddSourceWithAI(sourceUrl, targetFolder);
+        }
+        return new Promise((resolve, reject) => {
+            const workPath = path.join(this.manager.getProjectPath(), 'work');
+            // Determine target folder name
+            let folder = targetFolder;
+            if (!folder) {
+                // Auto-generate from URL
+                if (sourceType === 'git' || sourceType === 'gh') {
+                    // Extract repo name from URL
+                    const match = sourceUrl.match(/\/([^\/]+?)(\.git)?$/);
+                    folder = match ? match[1] : 'source';
+                }
+                else {
+                    // For cp, use the last part of the path
+                    folder = path.basename(sourceUrl);
+                }
+            }
+            const targetPath = path.join(workPath, folder);
+            let command;
+            switch (sourceType) {
+                case 'git':
+                    command = `git clone "${sourceUrl}" "${targetPath}"`;
+                    break;
+                case 'gh':
+                    command = `gh repo clone "${sourceUrl}" "${targetPath}"`;
+                    break;
+                case 'cp':
+                    command = `cp -r "${sourceUrl}" "${targetPath}"`;
+                    break;
+                default:
+                    reject(new Error(`Unknown source type: ${sourceType}`));
+                    return;
+            }
+            (0, child_process_1.exec)(command, { cwd: this.manager.getProjectPath(), maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+                if (error) {
+                    reject(new Error(`Command failed: ${error.message}\n${stderr}`));
+                    return;
+                }
+                // List files in the added folder
+                try {
+                    const files = (0, child_process_1.execSync)(`ls -la "${targetPath}" | head -20`, { encoding: 'utf-8' }).split('\n').filter(Boolean);
+                    resolve({ folder, files });
+                }
+                catch {
+                    resolve({ folder, files: [] });
+                }
+            });
+        });
+    }
+    /**
+     * Use Claude to interpret a natural language prompt and add source
+     */
+    executeAddSourceWithAI(prompt, targetFolder) {
+        return new Promise((resolve, reject) => {
+            const workPath = path.join(this.manager.getProjectPath(), 'work');
+            const projectPath = this.manager.getProjectPath();
+            const aiPrompt = `당신은 소스 코드를 work 폴더에 추가하는 작업을 수행합니다.
+
+사용자 요청: ${prompt}
+${targetFolder ? `대상 폴더: work/${targetFolder}` : '대상 폴더: 자동 결정'}
+Work 경로: ${workPath}
+
+다음 중 적절한 명령어를 생성하고 실행하세요:
+- git clone <url> <target_path>
+- gh repo clone <repo> <target_path>
+- cp -r <source> <target_path>
+
+반드시 아래 JSON 형식으로만 응답하세요 (다른 텍스트 없이):
+{
+  "command": "실행할 명령어",
+  "folder": "생성될 폴더명 (work/ 제외)"
+}
+
+예시:
+- "React 보일러플레이트" → {"command": "npx create-react-app ${workPath}/react-app", "folder": "react-app"}
+- "anthropics/claude-code 클론" → {"command": "gh repo clone anthropics/claude-code ${workPath}/claude-code", "folder": "claude-code"}`;
+            // Use echo | claude -p pattern to handle long prompts
+            const escapedPrompt = aiPrompt.replace(/'/g, "'\\''");
+            const claudeCmd = `echo '${escapedPrompt}' | env -u ANTHROPIC_API_KEY ${this.options.claudeCommand || 'claude'} -p`;
+            (0, child_process_1.exec)(claudeCmd, { cwd: projectPath, maxBuffer: 1024 * 1024, timeout: 60000, shell: '/bin/bash' }, (error, stdout, stderr) => {
+                if (error) {
+                    console.error('Claude stderr:', stderr);
+                    reject(new Error(`Claude analysis failed: ${error.message}\nstderr: ${stderr}`));
+                    return;
+                }
+                try {
+                    // Parse Claude's response
+                    const jsonMatch = stdout.match(/\{[\s\S]*\}/);
+                    if (!jsonMatch) {
+                        reject(new Error('Claude did not return valid JSON'));
+                        return;
+                    }
+                    const result = JSON.parse(jsonMatch[0]);
+                    const command = result.command;
+                    const folder = result.folder || 'source';
+                    console.log(`AI generated command: ${command}`);
+                    // Execute the generated command
+                    (0, child_process_1.exec)(command, { cwd: projectPath, maxBuffer: 10 * 1024 * 1024 }, (execError, execStdout, execStderr) => {
+                        if (execError) {
+                            reject(new Error(`Command failed: ${execError.message}\n${execStderr}`));
+                            return;
+                        }
+                        // List files in the added folder
+                        const targetPath = path.join(workPath, folder);
+                        try {
+                            const files = (0, child_process_1.execSync)(`ls -la "${targetPath}" | head -20`, { encoding: 'utf-8' }).split('\n').filter(Boolean);
+                            resolve({ folder, files });
+                        }
+                        catch {
+                            resolve({ folder, files: [] });
+                        }
+                    });
+                }
+                catch (parseError) {
+                    reject(new Error(`Failed to parse Claude response: ${parseError}`));
+                }
+            });
+        });
+    }
+    /**
+     * Call Claude Code CLI to analyze mission and return steps and decisions
+     */
+    callClaudeForAnalysis(mission, contextPaths = []) {
+        return new Promise((resolve, reject) => {
+            // Get project structure automatically from work folder
+            const projectStructure = this.manager.getProjectStructure();
+            // Read source file contents if contextPaths provided
+            const sourceContext = this.readSourceContext(contextPaths);
+            const prompt = this.buildAnalysisPrompt(mission, projectStructure, sourceContext);
+            const projectPath = this.manager.getProjectPath();
+            // Use echo | claude -p pattern to handle long prompts with source context
+            const escapedPrompt = prompt.replace(/'/g, "'\\''");
+            const claudeCmd = `echo '${escapedPrompt}' | env -u ANTHROPIC_API_KEY ${this.options.claudeCommand || 'claude'} -p`;
+            const timeout = setTimeout(() => {
+                reject(new Error('Analysis timeout'));
+            }, CLAUDE_ANALYSIS_TIMEOUT_MS);
+            (0, child_process_1.exec)(claudeCmd, { cwd: projectPath, maxBuffer: 1024 * 1024, shell: '/bin/bash' }, (error, stdout, stderr) => {
+                clearTimeout(timeout);
+                if (error) {
+                    reject(new Error(`Claude CLI error: ${error.message}`));
+                    return;
+                }
+                try {
+                    // Parse Claude's response to extract steps and decisions
+                    const result = this.parseAnalysisResponse(stdout);
+                    resolve(result);
+                }
+                catch (parseError) {
+                    reject(new Error(`Failed to parse analysis: ${parseError}`));
+                }
+            });
+        });
+    }
+    /**
+     * Read source file contents from context paths for Claude analysis
+     */
+    readSourceContext(contextPaths) {
+        if (contextPaths.length === 0)
+            return '';
+        const projectPath = this.manager.getProjectPath();
+        const contents = [];
+        for (const ctxPath of contextPaths) {
+            const fullPath = path.join(projectPath, ctxPath);
+            try {
+                // Check if path exists
+                const stats = require('fs').statSync(fullPath);
+                if (stats.isDirectory()) {
+                    // Get key files from directory (README, package.json, main source files)
+                    const keyFiles = this.getKeyFilesFromDirectory(fullPath);
+                    if (keyFiles.length > 0) {
+                        contents.push(`\n## 소스: ${ctxPath}\n`);
+                        for (const file of keyFiles) {
+                            contents.push(`### ${file.name}\n\`\`\`\n${file.content}\n\`\`\`\n`);
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                console.warn(`Failed to read context path: ${ctxPath}`, e);
+            }
+        }
+        return contents.join('\n');
+    }
+    /**
+     * Get key files from a source directory for context
+     */
+    getKeyFilesFromDirectory(dirPath) {
+        const fs = require('fs');
+        const keyFiles = [];
+        const keyFileNames = ['README.md', 'package.json', 'setup.py', 'Cargo.toml', 'go.mod', 'pom.xml', 'build.gradle'];
+        const maxFileSize = 5000; // Limit file content to prevent huge prompts
+        try {
+            const files = fs.readdirSync(dirPath);
+            // First, add key config/readme files
+            for (const fileName of keyFileNames) {
+                if (files.includes(fileName)) {
+                    const filePath = path.join(dirPath, fileName);
+                    try {
+                        let content = fs.readFileSync(filePath, 'utf-8');
+                        if (content.length > maxFileSize) {
+                            content = content.substring(0, maxFileSize) + '\n... (truncated)';
+                        }
+                        keyFiles.push({ name: fileName, content });
+                    }
+                    catch {
+                        // Skip unreadable files
+                    }
+                }
+            }
+            // Then, add a few source files (limited)
+            const sourceExtensions = ['.ts', '.js', '.py', '.java', '.go', '.rs'];
+            let sourceFileCount = 0;
+            const maxSourceFiles = 3;
+            for (const fileName of files) {
+                if (sourceFileCount >= maxSourceFiles)
+                    break;
+                const ext = path.extname(fileName).toLowerCase();
+                if (sourceExtensions.includes(ext)) {
+                    const filePath = path.join(dirPath, fileName);
+                    try {
+                        const stats = fs.statSync(filePath);
+                        if (stats.isFile() && stats.size < maxFileSize) {
+                            let content = fs.readFileSync(filePath, 'utf-8');
+                            if (content.length > maxFileSize) {
+                                content = content.substring(0, maxFileSize) + '\n... (truncated)';
+                            }
+                            keyFiles.push({ name: fileName, content });
+                            sourceFileCount++;
+                        }
+                    }
+                    catch {
+                        // Skip unreadable files
+                    }
+                }
+            }
+        }
+        catch (e) {
+            console.warn(`Failed to read directory: ${dirPath}`, e);
+        }
+        return keyFiles;
+    }
+    /**
+     * Build the prompt for Claude Code to analyze the mission
+     */
+    buildAnalysisPrompt(mission, projectStructure, sourceContext = '') {
+        let prompt = `당신은 프로젝트 관리자입니다. 다음 미션을 분석하고 작업 스텝으로 분해해주세요.
+
+미션: ${mission}
+
+프로젝트 구조:
+${projectStructure}`;
+        if (sourceContext) {
+            prompt += `
+
+=== 소스 컨텍스트 (참고용) ===
+${sourceContext}
+=== 소스 컨텍스트 끝 ===
+
+위 소스 코드를 분석하여 미션에 맞는 구체적인 작업 스텝을 생성하세요.
+소스 코드의 구조와 내용을 고려하여 실제로 수행해야 할 작업을 상세하게 설명하세요.`;
+        }
+        prompt += `
+
+반드시 아래 JSON 형식으로만 응답하세요 (다른 텍스트 없이):
+{
+  "steps": [
+    {
+      "id": "step-1",
+      "title": "스텝 제목",
+      "description": "상세 설명",
+      "agent": "pm 또는 dev",
+      "dependsOn": []
+    }
+  ],
+  "decisions": [
+    {
+      "id": "decision-1",
+      "question": "사용자에게 물어볼 질문",
+      "options": ["선택지1", "선택지2", "선택지3"],
+      "required": true
+    }
+  ]
+}
+
+규칙:
+- PM agent: 분석, 설계, 계획, 검토 작업 (tools/pm-agent에서 실행)
+- DEV agent: 실제 코드 구현 작업 (work/dev에서 실행)
+- dependsOn: 이 스텝이 의존하는 이전 스텝 ID 목록
+- 첫 번째 스텝은 항상 PM의 요구사항 분석
+- 마지막 스텝은 PM의 검토 및 완료
+- 각 에이전트는 work/ 폴더 하위에 자신의 폴더에서 작업
+- decisions: 작업 진행 전 사용자의 결정이 필요한 항목들
+- 기술 선택, 구현 방식 등 여러 가지 선택지가 있을 때 decisions에 추가
+- 명확한 작업만 있고 결정이 필요없으면 decisions는 빈 배열 []`;
+        return prompt;
+    }
+    /**
+     * Parse Claude's response to extract steps and decisions
+     */
+    parseAnalysisResponse(response) {
+        // Try to find JSON object in the response (new format with steps and decisions)
+        const jsonObjectMatch = response.match(/\{[\s\S]*\}/);
+        if (jsonObjectMatch) {
+            try {
+                const parsed = JSON.parse(jsonObjectMatch[0]);
+                if (parsed.steps && Array.isArray(parsed.steps)) {
+                    const steps = parsed.steps.map((step, index) => ({
+                        id: step.id || `step-${index + 1}`,
+                        title: step.title || `Step ${index + 1}`,
+                        description: step.description || '',
+                        agent: step.agent === 'dev' ? 'dev' : 'pm',
+                        estimatedTime: step.estimatedTime,
+                        dependsOn: Array.isArray(step.dependsOn) ? step.dependsOn : []
+                    }));
+                    const decisions = (parsed.decisions || []).map((decision, index) => ({
+                        id: decision.id || `decision-${index + 1}`,
+                        question: decision.question || '',
+                        options: Array.isArray(decision.options) ? decision.options : [],
+                        required: decision.required !== false
+                    }));
+                    return { steps, decisions };
+                }
+            }
+            catch (e) {
+                // Fall through to try array format
+            }
+        }
+        // Try to find JSON array in the response (legacy format)
+        const jsonArrayMatch = response.match(/\[[\s\S]*\]/);
+        if (jsonArrayMatch) {
+            try {
+                const steps = JSON.parse(jsonArrayMatch[0]);
+                // Validate and fix steps
+                return {
+                    steps: steps.map((step, index) => ({
+                        id: step.id || `step-${index + 1}`,
+                        title: step.title || `Step ${index + 1}`,
+                        description: step.description || '',
+                        agent: step.agent === 'dev' ? 'dev' : 'pm',
+                        estimatedTime: step.estimatedTime,
+                        dependsOn: Array.isArray(step.dependsOn) ? step.dependsOn : []
+                    })),
+                    decisions: []
+                };
+            }
+            catch (e) {
+                console.warn('Failed to parse JSON, using default steps:', e);
+            }
+        }
+        // If no JSON found, create default steps
+        console.warn('No JSON found in Claude response, using default steps');
+        return { steps: this.getDefaultSteps(), decisions: [] };
+    }
+    /**
+     * Get default steps when analysis fails
+     */
+    getDefaultSteps() {
+        return [
+            { id: 'step-1', title: '요구사항 분석', description: '미션을 분석하고 구체적인 요구사항 도출', agent: 'pm', dependsOn: [] },
+            { id: 'step-2', title: '구현 계획', description: '구체적인 구현 방안 수립', agent: 'pm', dependsOn: ['step-1'] },
+            { id: 'step-3', title: '개발', description: '기능 구현', agent: 'dev', dependsOn: ['step-2'] },
+            { id: 'step-4', title: '검토 및 완료', description: '결과물 검토 및 마무리', agent: 'pm', dependsOn: ['step-3'] }
+        ];
+    }
+    /**
+     * Update relay with current status
+     */
+    updateRelayStatus() {
+        if (!this.relayClient || !this.workflow)
+            return;
+        const status = this.manager.loadStatus();
+        if (!status)
+            return;
+        const agents = {};
+        for (const agent of this.workflow.agents) {
+            const agentStatus = status.agents[agent.id];
+            if (agentStatus) {
+                agents[agent.id] = {
+                    status: agentStatus.status,
+                    currentTask: agentStatus.currentTask
+                };
+            }
+        }
+        this.relayClient.updateStatus(status.status, agents);
+    }
+    /**
+     * Stop workflow execution
+     */
+    stop() {
+        this.running = false;
+        if (this.pollTimer) {
+            clearTimeout(this.pollTimer);
+            this.pollTimer = null;
+        }
+        // Disconnect from relay
+        if (this.relayClient) {
+            this.relayClient.destroy();
+            this.relayClient = null;
+        }
+    }
+    /**
+     * Kill all project tmux sessions
+     */
+    killAllSessions() {
+        const projectId = this.manager.getProjectId().replace(/[^a-zA-Z0-9_-]/g, '_');
+        const prefix = `proj_${projectId}_`;
+        try {
+            const sessions = (0, child_process_1.execSync)(`tmux ls -F "#{session_name}" 2>/dev/null || true`, {
+                encoding: 'utf-8'
+            });
+            for (const session of sessions.split('\n')) {
+                if (session.startsWith(prefix)) {
+                    try {
+                        (0, child_process_1.execSync)(`tmux kill-session -t "${session}"`, { stdio: 'pipe' });
+                        console.log(`Killed session: ${session}`);
+                    }
+                    catch {
+                        // Ignore errors
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    /**
+     * Send keys to an agent session
+     */
+    sendToAgent(agentId, keys) {
+        const sessionName = this.manager.getTmuxSessionName(agentId);
+        try {
+            (0, child_process_1.execSync)(`tmux send-keys -t "${sessionName}" "${keys.replace(/"/g, '\\"')}" Enter`, {
+                stdio: 'pipe'
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Capture agent terminal output
+     */
+    captureAgent(agentId) {
+        const sessionName = this.manager.getTmuxSessionName(agentId);
+        try {
+            return (0, child_process_1.execSync)(`tmux capture-pane -t "${sessionName}" -p -e`, {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * List all agent sessions for this project
+     */
+    listSessions() {
+        const projectId = this.manager.getProjectId().replace(/[^a-zA-Z0-9_-]/g, '_');
+        const prefix = `proj_${projectId}_`;
+        try {
+            const sessions = (0, child_process_1.execSync)(`tmux ls -F "#{session_name}" 2>/dev/null || true`, {
+                encoding: 'utf-8'
+            });
+            return sessions
+                .split('\n')
+                .filter(s => s.startsWith(prefix))
+                .map(s => s.substring(prefix.length));
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.WorkflowExecutor = WorkflowExecutor;