makecc 0.2.13 → 0.2.15

package/dist/server/services/claudeCliService.js

@@ -0,0 +1,210 @@
+import { spawn } from 'child_process';
+import { join, basename } from 'path';
+import { existsSync } from 'fs';
+import { mkdir, copyFile, readdir, stat } from 'fs/promises';
+/**
+ * claude -c 명령어를 백그라운드로 실행하고 결과를 캡처합니다.
+ */
+export async function executeClaudeCli(options) {
+    const { prompt, workingDirectory, outputDirectory, timeoutMs = 300000 } = options; // 기본 5분 타임아웃
+    // 출력 디렉토리 생성
+    if (!existsSync(outputDirectory)) {
+        await mkdir(outputDirectory, { recursive: true });
+    }
+    // 실행 전 working directory 파일 목록 스냅샷
+    const beforeFiles = await getDirectorySnapshot(workingDirectory);
+    return new Promise((resolve) => {
+        // claude -c --print 옵션으로 결과만 출력 (인터랙티브 모드 없이)
+        const proc = spawn('claude', ['-c', '--print', prompt], {
+            cwd: workingDirectory,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                // TERM 설정으로 색상 코드 방지
+                TERM: 'dumb',
+                NO_COLOR: '1',
+            },
+        });
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        // 타임아웃 설정
+        const timer = setTimeout(() => {
+            timedOut = true;
+            proc.kill('SIGTERM');
+        }, timeoutMs);
+        proc.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', async (code) => {
+            clearTimeout(timer);
+            // 실행 후 새로 생성된 파일 찾기
+            const afterFiles = await getDirectorySnapshot(workingDirectory);
+            const newFiles = findNewFiles(beforeFiles, afterFiles);
+            // 새 파일들을 output 디렉토리로 복사
+            const generatedFiles = [];
+            for (const filePath of newFiles) {
+                const fileName = basename(filePath);
+                const destPath = join(outputDirectory, fileName);
+                const fileType = getFileType(fileName);
+                try {
+                    await copyFile(filePath, destPath);
+                    generatedFiles.push({ name: fileName, path: destPath, type: fileType });
+                    console.log(`Copied generated file: ${filePath} -> ${destPath}`);
+                }
+                catch (err) {
+                    console.error(`Failed to copy file ${filePath}:`, err);
+                }
+            }
+            // stdout 결과도 파일로 저장 (결과가 있으면)
+            if (stdout.trim()) {
+                const { writeFile } = await import('fs/promises');
+                const resultPath = join(outputDirectory, 'claude-output.md');
+                await writeFile(resultPath, stdout, 'utf-8');
+                generatedFiles.push({ name: 'claude-output.md', path: resultPath, type: 'markdown' });
+            }
+            resolve({
+                success: code === 0 && !timedOut,
+                stdout: timedOut ? stdout + '\n[Execution timed out]' : stdout,
+                stderr,
+                exitCode: code,
+                generatedFiles,
+            });
+        });
+        proc.on('error', (err) => {
+            clearTimeout(timer);
+            resolve({
+                success: false,
+                stdout: '',
+                stderr: err.message,
+                exitCode: null,
+                generatedFiles: [],
+            });
+        });
+    });
+}
+/**
+ * 디렉토리의 파일 스냅샷 (재귀적으로 1단계까지만)
+ */
+async function getDirectorySnapshot(dir) {
+    const snapshot = new Map();
+    if (!existsSync(dir)) {
+        return snapshot;
+    }
+    try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            // 숨김 파일 및 특정 폴더 제외
+            if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === '__pycache__') {
+                continue;
+            }
+            const fullPath = join(dir, entry.name);
+            if (entry.isFile()) {
+                const stats = await stat(fullPath);
+                snapshot.set(fullPath, stats.mtimeMs);
+            }
+        }
+    }
+    catch (err) {
+        console.error('Error reading directory:', err);
+    }
+    return snapshot;
+}
+/**
+ * 파일 확장자로 타입 결정
+ */
+function getFileType(fileName) {
+    const ext = fileName.split('.').pop()?.toLowerCase() || '';
+    const typeMap = {
+        md: 'markdown',
+        txt: 'text',
+        json: 'json',
+        js: 'javascript',
+        ts: 'typescript',
+        py: 'python',
+        html: 'html',
+        css: 'css',
+        png: 'image',
+        jpg: 'image',
+        jpeg: 'image',
+        gif: 'image',
+        svg: 'image',
+        pdf: 'pdf',
+        xlsx: 'excel',
+        xls: 'excel',
+        pptx: 'powerpoint',
+        ppt: 'powerpoint',
+        docx: 'word',
+        doc: 'word',
+    };
+    return typeMap[ext] || 'file';
+}
+/**
+ * 새로 생성되거나 수정된 파일 찾기
+ */
+function findNewFiles(before, after) {
+    const newFiles = [];
+    for (const [path, mtime] of after) {
+        const beforeMtime = before.get(path);
+        // 새 파일이거나 수정된 파일
+        if (beforeMtime === undefined || mtime > beforeMtime) {
+            newFiles.push(path);
+        }
+    }
+    return newFiles;
+}
+/**
+ * 노드별 프롬프트 생성
+ */
+export function buildNodePrompt(nodeType, nodeData, previousResults) {
+    const lines = [];
+    if (nodeType === 'subagent') {
+        const role = nodeData.role || 'assistant';
+        const description = nodeData.description || '';
+        const systemPrompt = nodeData.systemPrompt || '';
+        lines.push(`You are a ${role}.`);
+        if (systemPrompt) {
+            lines.push(systemPrompt);
+        }
+        lines.push('');
+        lines.push('## Task');
+        lines.push(description || 'Complete the following task based on the input.');
+        lines.push('');
+        if (previousResults) {
+            lines.push('## Input from previous steps');
+            lines.push(previousResults);
+            lines.push('');
+        }
+        lines.push('Please complete this task and provide the result.');
+    }
+    else if (nodeType === 'skill') {
+        const skillId = nodeData.skillId || '';
+        const description = nodeData.description || '';
+        if (skillId) {
+            lines.push(`Execute the skill: /${skillId}`);
+        }
+        lines.push('');
+        lines.push('## Task');
+        lines.push(description || 'Execute this skill with the provided input.');
+        lines.push('');
+        if (previousResults) {
+            lines.push('## Input');
+            lines.push(previousResults);
+            lines.push('');
+        }
+    }
+    else {
+        // Generic
+        lines.push('## Task');
+        lines.push(nodeData.description || 'Process the following input.');
+        lines.push('');
+        if (previousResults) {
+            lines.push('## Input');
+            lines.push(previousResults);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/server/services/nodeSyncService.js

@@ -67,6 +67,8 @@ export class NodeSyncService {
     }
     /**
      * 엣지 연결 시 관계 업데이트
+     * - source의 downstream에 target 추가
+     * - target의 upstream에 source 추가
      */
     async syncEdge(edge, nodes) {
         try {
@@ -75,25 +77,68 @@ export class NodeSyncService {
             if (!sourceNode || !targetNode) {
                 return { success: false, error: 'Source or target node not found' };
             }
-            // 서브에이전트 → 스킬 연결: 서브에이전트의 skills 필드 업데이트
+            const sourceId = this.getNodeIdentifier(sourceNode);
+            const targetId = this.getNodeIdentifier(targetNode);
+            // 서브에이전트 → 스킬 연결
             if (sourceNode.type === 'subagent' && targetNode.type === 'skill') {
+                // 에이전트의 skills 필드 업데이트
                 const skills = sourceNode.skills || [];
-                const skillId = targetNode.skillId || this.toKebabCase(targetNode.label);
-                if (!skills.includes(skillId)) {
-                    skills.push(skillId);
+                if (!skills.includes(targetId)) {
+                    skills.push(targetId);
                     sourceNode.skills = skills;
                     await this.syncSubagentNode(sourceNode);
                 }
+                // 스킬의 upstream 필드 업데이트
+                const upstream = targetNode.upstream || [];
+                if (!upstream.includes(sourceId)) {
+                    upstream.push(sourceId);
+                    targetNode.upstream = upstream;
+                    await this.syncSkillNode(targetNode);
+                }
+            }
+            // 스킬 → 스킬 연결
+            if (sourceNode.type === 'skill' && targetNode.type === 'skill') {
+                // source의 downstream 업데이트
+                const downstream = sourceNode.downstream || [];
+                if (!downstream.includes(targetId)) {
+                    downstream.push(targetId);
+                    sourceNode.downstream = downstream;
+                    await this.syncSkillNode(sourceNode);
+                }
+                // target의 upstream 업데이트
+                const upstream = targetNode.upstream || [];
+                if (!upstream.includes(sourceId)) {
+                    upstream.push(sourceId);
+                    targetNode.upstream = upstream;
+                    await this.syncSkillNode(targetNode);
+                }
             }
-            // 스킬 → 서브에이전트 연결: 서브에이전트의 skills 필드 업데이트
+            // 스킬 → 서브에이전트 연결
             if (sourceNode.type === 'skill' && targetNode.type === 'subagent') {
+                // 에이전트의 upstream skills 필드 업데이트
                 const skills = targetNode.skills || [];
-                const skillId = sourceNode.skillId || this.toKebabCase(sourceNode.label);
-                if (!skills.includes(skillId)) {
-                    skills.push(skillId);
+                if (!skills.includes(sourceId)) {
+                    skills.push(sourceId);
                     targetNode.skills = skills;
                     await this.syncSubagentNode(targetNode);
                 }
+                // 스킬의 downstream 필드 업데이트
+                const downstream = sourceNode.downstream || [];
+                if (!downstream.includes(targetId)) {
+                    downstream.push(targetId);
+                    sourceNode.downstream = downstream;
+                    await this.syncSkillNode(sourceNode);
+                }
+            }
+            // 서브에이전트 → 서브에이전트 연결
+            if (sourceNode.type === 'subagent' && targetNode.type === 'subagent') {
+                // source의 downstream agents
+                const sourceDownstream = sourceNode.skills || [];
+                if (!sourceDownstream.includes(targetId)) {
+                    sourceDownstream.push(targetId);
+                    sourceNode.skills = sourceDownstream;
+                    await this.syncSubagentNode(sourceNode);
+                }
             }
             return { success: true };
         }
@@ -102,6 +147,15 @@ export class NodeSyncService {
             return { success: false, error: errorMessage };
         }
     }
+    /**
+     * 노드의 식별자 반환 (skillId 또는 kebab-case label)
+     */
+    getNodeIdentifier(node) {
+        if (node.type === 'skill') {
+            return node.skillId || this.toKebabCase(node.label);
+        }
+        return this.toKebabCase(node.label);
+    }
     /**
      * 엣지 삭제 시 관계 업데이트
      */
@@ -112,16 +166,35 @@ export class NodeSyncService {
             if (!sourceNode || !targetNode) {
                 return { success: true }; // 노드가 없으면 무시
             }
-            // 서브에이전트에서 스킬 제거
+            const sourceId = this.getNodeIdentifier(sourceNode);
+            const targetId = this.getNodeIdentifier(targetNode);
+            // 서브에이전트 → 스킬 연결 해제
             if (sourceNode.type === 'subagent' && targetNode.type === 'skill') {
-                const skillId = targetNode.skillId || this.toKebabCase(targetNode.label);
-                sourceNode.skills = (sourceNode.skills || []).filter(s => s !== skillId);
+                // 에이전트에서 스킬 제거
+                sourceNode.skills = (sourceNode.skills || []).filter(s => s !== targetId);
                 await this.syncSubagentNode(sourceNode);
+                // 스킬에서 upstream 제거
+                targetNode.upstream = (targetNode.upstream || []).filter(s => s !== sourceId);
+                await this.syncSkillNode(targetNode);
+            }
+            // 스킬 → 스킬 연결 해제
+            if (sourceNode.type === 'skill' && targetNode.type === 'skill') {
+                sourceNode.downstream = (sourceNode.downstream || []).filter(s => s !== targetId);
+                await this.syncSkillNode(sourceNode);
+                targetNode.upstream = (targetNode.upstream || []).filter(s => s !== sourceId);
+                await this.syncSkillNode(targetNode);
             }
+            // 스킬 → 서브에이전트 연결 해제
             if (sourceNode.type === 'skill' && targetNode.type === 'subagent') {
-                const skillId = sourceNode.skillId || this.toKebabCase(sourceNode.label);
-                targetNode.skills = (targetNode.skills || []).filter(s => s !== skillId);
+                targetNode.skills = (targetNode.skills || []).filter(s => s !== sourceId);
                 await this.syncSubagentNode(targetNode);
+                sourceNode.downstream = (sourceNode.downstream || []).filter(s => s !== targetId);
+                await this.syncSkillNode(sourceNode);
+            }
+            // 서브에이전트 → 서브에이전트 연결 해제
+            if (sourceNode.type === 'subagent' && targetNode.type === 'subagent') {
+                sourceNode.skills = (sourceNode.skills || []).filter(s => s !== targetId);
+                await this.syncSubagentNode(sourceNode);
             }
             return { success: true };
         }
@@ -136,21 +209,35 @@ export class NodeSyncService {
         const skillPath = path.join(this.projectRoot, '.claude', 'skills', skillId);
         const skillMdPath = path.join(skillPath, 'SKILL.md');
         await fs.mkdir(skillPath, { recursive: true });
+        // Frontmatter 구성
+        const frontmatter = {
+            name: skillId,
+            description: node.description || node.label,
+        };
+        // upstream 연결 추가
+        if (node.upstream && node.upstream.length > 0) {
+            frontmatter.upstream = node.upstream.join(', ');
+        }
+        // downstream 연결 추가
+        if (node.downstream && node.downstream.length > 0) {
+            frontmatter.downstream = node.downstream.join(', ');
+        }
         // 기존 파일이 있으면 읽어서 업데이트, 없으면 새로 생성
         let content = '';
         try {
             content = await fs.readFile(skillMdPath, 'utf-8');
             // frontmatter 업데이트
-            content = this.updateFrontmatter(content, {
-                name: skillId,
-                description: node.description || node.label,
-            });
+            for (const [key, value] of Object.entries(frontmatter)) {
+                content = this.updateFrontmatter(content, { [key]: value });
+            }
         }
         catch {
             // 새로 생성
+            const frontmatterStr = Object.entries(frontmatter)
+                .map(([key, value]) => `${key}: ${value}`)
+                .join('\n');
             content = `---
-name: ${skillId}
-description: ${node.description || node.label}
+${frontmatterStr}
 ---
 
 # ${node.label}

package/dist/server/services/workflowExecutionService.js

@@ -1,19 +1,16 @@
-import Anthropic from '@anthropic-ai/sdk';
 import { writeFile, mkdir } from 'fs/promises';
 import { join } from 'path';
 import { existsSync } from 'fs';
-import { skillExecutionService } from './skillExecutionService';
+import { executeClaudeCli, buildNodePrompt } from './claudeCliService';
 /**
- * Anthropic API를 사용한 워크플로우 실행 서비스
+ * Claude CLI를 사용한 워크플로우 실행 서비스
  */
 export class WorkflowExecutionService {
-    client;
     results = new Map();
     outputDir = '';
+    projectRoot = '';
     constructor() {
-        this.client = new Anthropic({
-            apiKey: process.env.ANTHROPIC_API_KEY,
-        });
+        this.projectRoot = process.env.MAKECC_PROJECT_PATH || process.cwd();
     }
     /**
      * 워크플로우 전체 실행
@@ -85,55 +82,41 @@ export class WorkflowExecutionService {
         };
     }
     /**
-     * Subagent 노드 실행 - Claude API로 작업 수행
+     * Subagent 노드 실행 - Claude CLI로 작업 수행
      */
     async executeSubagentNode(node, previousResults, onProgress, onLog) {
         const data = node.data;
         onProgress?.({ nodeId: node.id, status: 'running', progress: 20 });
-        // 역할별 시스템 프롬프트
-        const rolePrompts = {
-            researcher: `당신은 전문 리서처입니다. 주어진 주제에 대해 깊이 있는 조사를 수행하고, 핵심 정보를 정리하여 제공합니다.`,
-            writer: `당신은 전문 작가입니다. 명확하고 매력적인 콘텐츠를 작성합니다. 사용자의 요구에 맞는 톤과 스타일로 글을 작성합니다.`,
-            analyst: `당신은 데이터 분석가입니다. 정보를 분석하고 패턴을 파악하여 인사이트를 도출합니다.`,
-            coder: `당신은 전문 개발자입니다. 깔끔하고 효율적인 코드를 작성하며, 모범 사례를 따릅니다.`,
-            designer: `당신은 디자인 전문가입니다. 상세페이지, 배너, UI 등을 위한 디자인 가이드와 컨셉을 제안합니다.`,
-            custom: `당신은 AI 어시스턴트입니다. 주어진 작업을 최선을 다해 수행합니다.`,
-        };
-        const systemPrompt = data.systemPrompt || rolePrompts[data.role] || rolePrompts.custom;
-        const userMessage = `## 작업 설명
-${data.description || '주어진 작업을 수행해주세요.'}
-
-## 이전 단계 결과
-${previousResults || '(없음)'}
-
-위 내용을 바탕으로 작업을 수행하고 결과를 제공해주세요.`;
-        onLog?.('debug', `Subagent "${data.label}" (${data.role}) 호출 중...`);
+        onLog?.('info', `claude -c 실행 중: ${data.label} (${data.role})`);
+        // 프롬프트 생성
+        const prompt = buildNodePrompt('subagent', data, previousResults);
         try {
             onProgress?.({ nodeId: node.id, status: 'running', progress: 40 });
-            const modelId = this.getModelId(data.model);
-            const response = await this.client.messages.create({
-                model: modelId,
-                max_tokens: 4096,
-                system: systemPrompt,
-                messages: [
-                    { role: 'user', content: userMessage }
-                ],
+            const result = await executeClaudeCli({
+                prompt,
+                workingDirectory: this.projectRoot,
+                outputDirectory: this.outputDir,
+                timeoutMs: 300000, // 5분
             });
-            onProgress?.({ nodeId: node.id, status: 'running', progress: 80 });
-            // 응답 텍스트 추출
-            const resultText = response.content
-                .filter((block) => block.type === 'text')
-                .map((block) => block.text)
-                .join('\n');
             onProgress?.({ nodeId: node.id, status: 'running', progress: 100 });
-            return {
-                nodeId: node.id,
-                success: true,
-                result: resultText,
-            };
+            if (result.success) {
+                return {
+                    nodeId: node.id,
+                    success: true,
+                    result: result.stdout,
+                    files: result.generatedFiles,
+                };
+            }
+            else {
+                return {
+                    nodeId: node.id,
+                    success: false,
+                    error: result.stderr || 'Claude CLI 실행 실패',
+                };
+            }
         }
         catch (error) {
-            const errorMsg = error instanceof Error ? error.message : 'Claude API 호출 실패';
+            const errorMsg = error instanceof Error ? error.message : 'Claude CLI 호출 실패';
             onLog?.('error', `Subagent 오류: ${errorMsg}`);
             return {
                 nodeId: node.id,
@@ -143,23 +126,38 @@ ${previousResults || '(없음)'}
         }
     }
     /**
-     * Skill 노드 실행 - skillExecutionService 사용
+     * Skill 노드 실행 - Claude CLI로 스킬 실행
      */
     async executeSkillNode(node, previousResults, onProgress, onLog) {
         const data = node.data;
         const skillId = data.skillId || 'generic';
         onProgress?.({ nodeId: node.id, status: 'running', progress: 10 });
+        onLog?.('info', `claude -c 실행 중: /${skillId}`);
+        // 프롬프트 생성 - 스킬 호출 형태
+        const prompt = buildNodePrompt('skill', data, previousResults);
         try {
-            // skillExecutionService를 사용하여 실제 파일 생성
-            const result = await skillExecutionService.execute(skillId, previousResults, this.outputDir, onLog);
+            const result = await executeClaudeCli({
+                prompt,
+                workingDirectory: this.projectRoot,
+                outputDirectory: this.outputDir,
+                timeoutMs: 300000,
+            });
             onProgress?.({ nodeId: node.id, status: 'running', progress: 100 });
-            return {
-                nodeId: node.id,
-                success: result.success,
-                result: result.result,
-                files: result.files,
-                error: result.error,
-            };
+            if (result.success) {
+                return {
+                    nodeId: node.id,
+                    success: true,
+                    result: result.stdout,
+                    files: result.generatedFiles,
+                };
+            }
+            else {
+                return {
+                    nodeId: node.id,
+                    success: false,
+                    error: result.stderr || '스킬 실행 실패',
+                };
+            }
         }
         catch (error) {
             const errorMsg = error instanceof Error ? error.message : '스킬 실행 실패';
@@ -172,50 +170,47 @@ ${previousResults || '(없음)'}
         }
     }
     /**
-     * MCP 노드 실행 - 외부 도구/서비스 연결
+     * MCP 노드 실행 - Claude CLI로 MCP 서버 연동
      */
     async executeMcpNode(node, previousResults, onProgress, onLog) {
         const data = node.data;
         onProgress?.({ nodeId: node.id, status: 'running', progress: 10 });
-        onLog?.('info', `MCP 서버 "${data.serverName}" 연결 중...`);
-        // MCP 서버 타입별 처리
-        const mcpPrompt = `당신은 MCP (Model Context Protocol) 서버와 상호작용하는 전문가입니다.
+        onLog?.('info', `claude -c 실행 중: MCP 서버 "${data.serverName}"`);
+        const prompt = `MCP 서버를 사용하여 작업을 수행해주세요.
 
 ## MCP 서버 정보
 - 서버 이름: ${data.serverName}
 - 서버 타입: ${data.serverType}
-- 설정: ${JSON.stringify(data.serverConfig, null, 2)}
 
 ## 이전 단계 결과
-${previousResults}
+${previousResults || '(없음)'}
 
 ## 작업
-위 MCP 서버를 사용하여 이전 단계의 결과를 처리하세요.
-
-다음 MCP 서버 유형에 따라 적절한 작업을 수행하세요:
-- PostgreSQL/데이터베이스: 데이터 조회 또는 저장
-- Notion/Google Drive: 문서 생성 또는 업데이트
-- Slack/Discord: 메시지 전송 시뮬레이션
-- GitHub/Jira: 이슈 또는 PR 관련 작업 시뮬레이션
-
-작업 결과를 상세히 설명해주세요.`;
+위 MCP 서버를 사용하여 이전 단계의 결과를 처리하세요.`;
         try {
             onProgress?.({ nodeId: node.id, status: 'running', progress: 50 });
-            const response = await this.client.messages.create({
-                model: 'claude-sonnet-4-20250514',
-                max_tokens: 4096,
-                messages: [{ role: 'user', content: mcpPrompt }],
+            const result = await executeClaudeCli({
+                prompt,
+                workingDirectory: this.projectRoot,
+                outputDirectory: this.outputDir,
+                timeoutMs: 300000,
             });
-            const result = response.content
-                .filter((block) => block.type === 'text')
-                .map((block) => block.text)
-                .join('\n');
             onProgress?.({ nodeId: node.id, status: 'running', progress: 100 });
-            return {
-                nodeId: node.id,
-                success: true,
-                result,
-            };
+            if (result.success) {
+                return {
+                    nodeId: node.id,
+                    success: true,
+                    result: result.stdout,
+                    files: result.generatedFiles,
+                };
+            }
+            else {
+                return {
+                    nodeId: node.id,
+                    success: false,
+                    error: result.stderr || 'MCP 노드 실행 실패',
+                };
+            }
         }
         catch (error) {
             return {
@@ -273,19 +268,6 @@ ${allFiles.map((f) => `- **${f.name}**: \`${f.path}\``).join('\n') || '없음'}
             };
         }
     }
-    /**
-     * 모델 ID 변환
-     */
-    getModelId(model) {
-        switch (model) {
-            case 'opus':
-                return 'claude-opus-4-20250514';
-            case 'haiku':
-                return 'claude-3-5-haiku-20241022';
-            default:
-                return 'claude-sonnet-4-20250514';
-        }
-    }
     /**
      * 이전 노드 결과 수집
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "makecc",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "type": "module",
   "description": "Visual workflow builder for Claude Code agents and skills",
   "keywords": [