makecc 0.1.0

package/server/services/workflowExecutionService.ts

@@ -0,0 +1,471 @@
+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 type {
+  ExecutionNode,
+  SubagentNodeData,
+  SkillNodeData,
+  InputNodeData,
+  OutputNodeData,
+  McpNodeData,
+  NodeExecutionUpdate,
+} from '../types';
+
+export interface WorkflowEdge {
+  id: string;
+  source: string;
+  target: string;
+}
+
+export interface ExecutionContext {
+  workflowId: string;
+  workflowName: string;
+  nodes: ExecutionNode[];
+  edges: WorkflowEdge[];
+  inputs?: Record<string, string>;
+  outputDir: string;
+}
+
+export interface ExecutionResult {
+  nodeId: string;
+  success: boolean;
+  result?: string;
+  files?: Array<{ path: string; type: string; name: string }>;
+  error?: string;
+}
+
+type ProgressCallback = (update: NodeExecutionUpdate) => void;
+type LogCallback = (type: 'info' | 'warn' | 'error' | 'debug', message: string) => void;
+
+/**
+ * Anthropic API를 사용한 워크플로우 실행 서비스
+ */
+export class WorkflowExecutionService {
+  private client: Anthropic;
+  private results: Map<string, ExecutionResult> = new Map();
+  private outputDir: string = '';
+
+  constructor() {
+    this.client = new Anthropic({
+      apiKey: process.env.ANTHROPIC_API_KEY,
+    });
+  }
+
+  /**
+   * 워크플로우 전체 실행
+   */
+  async execute(
+    context: ExecutionContext,
+    onProgress?: ProgressCallback,
+    onLog?: LogCallback
+  ): Promise<Map<string, ExecutionResult>> {
+    this.results.clear();
+    this.outputDir = context.outputDir;
+
+    // 출력 디렉토리 생성
+    if (!existsSync(this.outputDir)) {
+      await mkdir(this.outputDir, { recursive: true });
+    }
+
+    const executionOrder = this.topologicalSort(context.nodes, context.edges);
+
+    onLog?.('info', `워크플로우 "${context.workflowName}" 실행 시작 (${executionOrder.length}개 노드)`);
+
+    for (const node of executionOrder) {
+      try {
+        onProgress?.({ nodeId: node.id, status: 'running', progress: 0 });
+        onLog?.('info', `노드 "${node.data.label}" 실행 중...`);
+
+        const result = await this.executeNode(node, context, onProgress, onLog);
+        this.results.set(node.id, result);
+
+        if (result.success) {
+          onProgress?.({ nodeId: node.id, status: 'completed', progress: 100, result: result.result });
+          onLog?.('info', `노드 "${node.data.label}" 완료`);
+        } else {
+          onProgress?.({ nodeId: node.id, status: 'error', error: result.error });
+          onLog?.('error', `노드 "${node.data.label}" 실패: ${result.error}`);
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        this.results.set(node.id, { nodeId: node.id, success: false, error: errorMessage });
+        onProgress?.({ nodeId: node.id, status: 'error', error: errorMessage });
+        onLog?.('error', `노드 "${node.data.label}" 실행 오류: ${errorMessage}`);
+      }
+    }
+
+    return this.results;
+  }
+
+  /**
+   * 개별 노드 실행
+   */
+  private async executeNode(
+    node: ExecutionNode,
+    context: ExecutionContext,
+    onProgress?: ProgressCallback,
+    onLog?: LogCallback
+  ): Promise<ExecutionResult> {
+    // 이전 노드 결과 수집
+    const previousResults = this.collectPreviousResults(node, context.edges);
+
+    switch (node.type) {
+      case 'input':
+        return this.executeInputNode(node, context.inputs);
+
+      case 'subagent':
+        return this.executeSubagentNode(node, previousResults, onProgress, onLog);
+
+      case 'skill':
+        return this.executeSkillNode(node, previousResults, onProgress, onLog);
+
+      case 'mcp':
+        return this.executeMcpNode(node, previousResults, onProgress, onLog);
+
+      case 'output':
+        return this.executeOutputNode(node, previousResults, onLog);
+
+      default:
+        return { nodeId: node.id, success: false, error: `Unknown node type: ${node.type}` };
+    }
+  }
+
+  /**
+   * Input 노드 실행 - 사용자 입력값 반환
+   */
+  private async executeInputNode(
+    node: ExecutionNode,
+    inputs?: Record<string, string>
+  ): Promise<ExecutionResult> {
+    const data = node.data as InputNodeData;
+    const value = inputs?.[node.id] || data.value || '';
+
+    return {
+      nodeId: node.id,
+      success: true,
+      result: value,
+    };
+  }
+
+  /**
+   * Subagent 노드 실행 - Claude API로 작업 수행
+   */
+  private async executeSubagentNode(
+    node: ExecutionNode,
+    previousResults: string,
+    onProgress?: ProgressCallback,
+    onLog?: LogCallback
+  ): Promise<ExecutionResult> {
+    const data = node.data as SubagentNodeData;
+
+    onProgress?.({ nodeId: node.id, status: 'running', progress: 20 });
+
+    // 역할별 시스템 프롬프트
+    const rolePrompts: Record<string, string> = {
+      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}) 호출 중...`);
+
+    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 }
+        ],
+      });
+
+      onProgress?.({ nodeId: node.id, status: 'running', progress: 80 });
+
+      // 응답 텍스트 추출
+      const resultText = response.content
+        .filter((block): block is Anthropic.TextBlock => 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,
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : 'Claude API 호출 실패';
+      onLog?.('error', `Subagent 오류: ${errorMsg}`);
+      return {
+        nodeId: node.id,
+        success: false,
+        error: errorMsg,
+      };
+    }
+  }
+
+  /**
+   * Skill 노드 실행 - skillExecutionService 사용
+   */
+  private async executeSkillNode(
+    node: ExecutionNode,
+    previousResults: string,
+    onProgress?: ProgressCallback,
+    onLog?: LogCallback
+  ): Promise<ExecutionResult> {
+    const data = node.data as SkillNodeData;
+    const skillId = data.skillId || 'generic';
+
+    onProgress?.({ nodeId: node.id, status: 'running', progress: 10 });
+
+    try {
+      // skillExecutionService를 사용하여 실제 파일 생성
+      const result = await skillExecutionService.execute(
+        skillId,
+        previousResults,
+        this.outputDir,
+        onLog
+      );
+
+      onProgress?.({ nodeId: node.id, status: 'running', progress: 100 });
+
+      return {
+        nodeId: node.id,
+        success: result.success,
+        result: result.result,
+        files: result.files,
+        error: result.error,
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : '스킬 실행 실패';
+      onLog?.('error', errorMsg);
+      return {
+        nodeId: node.id,
+        success: false,
+        error: errorMsg,
+      };
+    }
+  }
+
+  /**
+   * MCP 노드 실행 - 외부 도구/서비스 연결
+   */
+  private async executeMcpNode(
+    node: ExecutionNode,
+    previousResults: string,
+    onProgress?: ProgressCallback,
+    onLog?: LogCallback
+  ): Promise<ExecutionResult> {
+    const data = node.data as McpNodeData;
+
+    onProgress?.({ nodeId: node.id, status: 'running', progress: 10 });
+    onLog?.('info', `MCP 서버 "${data.serverName}" 연결 중...`);
+
+    // MCP 서버 타입별 처리
+    const mcpPrompt = `당신은 MCP (Model Context Protocol) 서버와 상호작용하는 전문가입니다.
+
+## MCP 서버 정보
+- 서버 이름: ${data.serverName}
+- 서버 타입: ${data.serverType}
+- 설정: ${JSON.stringify(data.serverConfig, null, 2)}
+
+## 이전 단계 결과
+${previousResults}
+
+## 작업
+위 MCP 서버를 사용하여 이전 단계의 결과를 처리하세요.
+
+다음 MCP 서버 유형에 따라 적절한 작업을 수행하세요:
+- PostgreSQL/데이터베이스: 데이터 조회 또는 저장
+- Notion/Google Drive: 문서 생성 또는 업데이트
+- Slack/Discord: 메시지 전송 시뮬레이션
+- GitHub/Jira: 이슈 또는 PR 관련 작업 시뮬레이션
+
+작업 결과를 상세히 설명해주세요.`;
+
+    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 = response.content
+        .filter((block): block is Anthropic.TextBlock => block.type === 'text')
+        .map((block) => block.text)
+        .join('\n');
+
+      onProgress?.({ nodeId: node.id, status: 'running', progress: 100 });
+
+      return {
+        nodeId: node.id,
+        success: true,
+        result,
+      };
+    } catch (error) {
+      return {
+        nodeId: node.id,
+        success: false,
+        error: error instanceof Error ? error.message : 'MCP 노드 실행 실패',
+      };
+    }
+  }
+
+  /**
+   * Output 노드 실행 - 결과 수집 및 파일 저장
+   */
+  private async executeOutputNode(
+    node: ExecutionNode,
+    previousResults: string,
+    onLog?: LogCallback
+  ): Promise<ExecutionResult> {
+    const data = node.data as OutputNodeData;
+
+    onLog?.('info', '최종 결과 수집 및 저장 중...');
+
+    // 모든 이전 결과와 파일 수집
+    const allFiles: Array<{ path: string; type: string; name: string }> = [];
+
+    for (const [, result] of this.results) {
+      if (result.files) {
+        allFiles.push(...result.files);
+      }
+    }
+
+    // 결과 요약 파일 생성
+    const summaryPath = join(this.outputDir, 'result-summary.md');
+    const summaryContent = `# 워크플로우 실행 결과
+
+## 생성된 컨텐츠
+
+${previousResults}
+
+## 생성된 파일 목록
+${allFiles.map((f) => `- **${f.name}**: \`${f.path}\``).join('\n') || '없음'}
+
+---
+생성 시간: ${new Date().toLocaleString('ko-KR')}
+`;
+
+    try {
+      await writeFile(summaryPath, summaryContent, 'utf-8');
+
+      return {
+        nodeId: node.id,
+        success: true,
+        result: summaryContent,
+        files: [
+          { path: summaryPath, type: 'markdown', name: '결과 요약' },
+          ...allFiles,
+        ],
+      };
+    } catch (error) {
+      return {
+        nodeId: node.id,
+        success: true,
+        result: previousResults,
+        files: allFiles,
+      };
+    }
+  }
+
+  /**
+   * 모델 ID 변환
+   */
+  private getModelId(model?: 'sonnet' | 'opus' | 'haiku'): string {
+    switch (model) {
+      case 'opus':
+        return 'claude-opus-4-20250514';
+      case 'haiku':
+        return 'claude-3-5-haiku-20241022';
+      default:
+        return 'claude-sonnet-4-20250514';
+    }
+  }
+
+  /**
+   * 이전 노드 결과 수집
+   */
+  private collectPreviousResults(node: ExecutionNode, edges: WorkflowEdge[]): string {
+    const incomingEdges = edges.filter((e) => e.target === node.id);
+    const previousResults: string[] = [];
+
+    for (const edge of incomingEdges) {
+      const result = this.results.get(edge.source);
+      if (result?.result) {
+        previousResults.push(result.result);
+      }
+    }
+
+    return previousResults.join('\n\n---\n\n');
+  }
+
+  /**
+   * 위상 정렬 (실행 순서 결정)
+   */
+  private topologicalSort(nodes: ExecutionNode[], edges: WorkflowEdge[]): ExecutionNode[] {
+    const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+    const inDegree = new Map<string, number>();
+    const adjList = new Map<string, string[]>();
+
+    nodes.forEach((node) => {
+      inDegree.set(node.id, 0);
+      adjList.set(node.id, []);
+    });
+
+    edges.forEach((edge) => {
+      adjList.get(edge.source)?.push(edge.target);
+      inDegree.set(edge.target, (inDegree.get(edge.target) || 0) + 1);
+    });
+
+    const queue: string[] = [];
+    inDegree.forEach((degree, nodeId) => {
+      if (degree === 0) {
+        queue.push(nodeId);
+      }
+    });
+
+    const result: ExecutionNode[] = [];
+    while (queue.length > 0) {
+      const nodeId = queue.shift()!;
+      const node = nodeMap.get(nodeId);
+      if (node) {
+        result.push(node);
+      }
+
+      adjList.get(nodeId)?.forEach((neighborId) => {
+        const newDegree = (inDegree.get(neighborId) || 0) - 1;
+        inDegree.set(neighborId, newDegree);
+        if (newDegree === 0) {
+          queue.push(neighborId);
+        }
+      });
+    }
+
+    return result;
+  }
+}
+
+export const workflowExecutionService = new WorkflowExecutionService();

package/server/types.ts

@@ -0,0 +1,110 @@
+// Node status type
+export type NodeStatus = 'idle' | 'pending' | 'running' | 'completed' | 'error';
+
+// Base node data
+export interface BaseNodeData {
+  label: string;
+  description?: string;
+  status: NodeStatus;
+  progress?: number;
+  error?: string;
+  [key: string]: unknown;
+}
+
+// Node types
+export type InputType = 'text' | 'file' | 'select' | 'multi';
+export type AgentRole = 'researcher' | 'writer' | 'analyst' | 'coder' | 'custom';
+export type SkillType = 'official' | 'custom';
+export type McpServerType = 'stdio' | 'sse' | 'http';
+export type OutputType = 'markdown' | 'document' | 'image' | 'webpage' | 'link' | 'auto';
+
+export interface InputNodeData extends BaseNodeData {
+  inputType: InputType;
+  value?: string;
+  placeholder?: string;
+  options?: string[];
+  fileTypes?: string[];
+}
+
+export interface SubagentNodeData extends BaseNodeData {
+  role: AgentRole;
+  tools: string[];
+  mdContent?: string;
+  systemPrompt?: string;
+  model?: 'sonnet' | 'opus' | 'haiku';
+  usedInputs?: string[];
+}
+
+export interface SkillNodeData extends BaseNodeData {
+  skillType: SkillType;
+  skillId?: string;
+  skillCategory?: string;
+  mdContent?: string;
+  skillContent?: string; // AI가 생성한 커스텀 스킬 SKILL.md 내용
+  usedInputs?: string[];
+}
+
+export interface McpNodeData extends BaseNodeData {
+  serverType: McpServerType;
+  serverName: string;
+  serverConfig: {
+    command?: string;
+    args?: string[];
+    url?: string;
+    env?: Record<string, string>;
+  };
+  usedInputs?: string[];
+}
+
+export interface OutputNodeData extends BaseNodeData {
+  outputType: OutputType;
+  layoutType?: 'manual' | 'auto' | 'google-docs' | 'google-slides' | 'google-sheets';
+  result?: string;
+  filePath?: string;
+  usedInputs?: string[];
+}
+
+export type WorkflowNodeData =
+  | InputNodeData
+  | SubagentNodeData
+  | SkillNodeData
+  | McpNodeData
+  | OutputNodeData;
+
+// Node structure for execution
+export interface ExecutionNode {
+  id: string;
+  type: 'input' | 'subagent' | 'skill' | 'mcp' | 'output';
+  data: WorkflowNodeData;
+  position: { x: number; y: number };
+}
+
+// Workflow execution request
+export interface WorkflowExecutionRequest {
+  workflowId: string;
+  workflowName: string;
+  nodes: ExecutionNode[];
+  edges: Array<{
+    id: string;
+    source: string;
+    target: string;
+  }>;
+  inputs?: Record<string, string>;
+}
+
+// Node execution update
+export interface NodeExecutionUpdate {
+  nodeId: string;
+  status: NodeStatus;
+  progress?: number;
+  result?: string;
+  error?: string;
+}
+
+// Console log entry
+export interface ConsoleLogEntry {
+  type: 'info' | 'warn' | 'error' | 'debug';
+  message: string;
+  timestamp: string;
+  nodeId?: string;
+}