makecc 0.2.5 → 0.2.8

package/server/services/nodeSyncService.ts

@@ -0,0 +1,384 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+interface NodeData {
+  id: string;
+  type: 'skill' | 'subagent' | 'command' | 'hook' | 'input' | 'output';
+  label: string;
+  description?: string;
+  // Skill specific
+  skillId?: string;
+  skillPath?: string;
+  // Subagent specific
+  tools?: string[];
+  model?: string;
+  skills?: string[];  // Connected skills
+  systemPrompt?: string;
+  // Command specific
+  commandName?: string;
+  commandContent?: string;
+  // Hook specific
+  hookEvent?: string;
+  hookMatcher?: string;
+  hookCommand?: string;
+}
+
+interface EdgeData {
+  source: string;
+  target: string;
+  sourceType: string;
+  targetType: string;
+}
+
+export class NodeSyncService {
+  private projectRoot: string;
+
+  constructor(projectRoot?: string) {
+    this.projectRoot = projectRoot || process.env.MAKECC_PROJECT_PATH || process.cwd();
+  }
+
+  /**
+   * 노드 생성/수정 시 파일 동기화
+   */
+  async syncNode(node: NodeData): Promise<{ success: boolean; path?: string; error?: string }> {
+    try {
+      switch (node.type) {
+        case 'skill':
+          return await this.syncSkillNode(node);
+        case 'subagent':
+          return await this.syncSubagentNode(node);
+        case 'command':
+          return await this.syncCommandNode(node);
+        case 'hook':
+          return await this.syncHookNode(node);
+        case 'input':
+        case 'output':
+          // 입력/출력 노드는 파일 저장 불필요
+          return { success: true };
+        default:
+          return { success: false, error: `Unknown node type: ${node.type}` };
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      return { success: false, error: errorMessage };
+    }
+  }
+
+  /**
+   * 노드 삭제 시 파일 삭제
+   */
+  async deleteNode(node: NodeData): Promise<{ success: boolean; error?: string }> {
+    try {
+      switch (node.type) {
+        case 'skill':
+          if (node.skillId) {
+            const skillPath = path.join(this.projectRoot, '.claude', 'skills', node.skillId);
+            await fs.rm(skillPath, { recursive: true, force: true });
+          }
+          break;
+        case 'subagent':
+          const agentName = this.toKebabCase(node.label);
+          const agentPath = path.join(this.projectRoot, '.claude', 'agents', `${agentName}.md`);
+          await fs.unlink(agentPath).catch(() => {});
+          break;
+        case 'command':
+          const cmdName = node.commandName || this.toKebabCase(node.label);
+          const cmdPath = path.join(this.projectRoot, '.claude', 'commands', `${cmdName}.md`);
+          await fs.unlink(cmdPath).catch(() => {});
+          break;
+        case 'hook':
+          await this.removeHookFromSettings(node);
+          break;
+      }
+      return { success: true };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      return { success: false, error: errorMessage };
+    }
+  }
+
+  /**
+   * 엣지 연결 시 관계 업데이트
+   */
+  async syncEdge(edge: EdgeData, nodes: NodeData[]): Promise<{ success: boolean; error?: string }> {
+    try {
+      const sourceNode = nodes.find(n => n.id === edge.source);
+      const targetNode = nodes.find(n => n.id === edge.target);
+
+      if (!sourceNode || !targetNode) {
+        return { success: false, error: 'Source or target node not found' };
+      }
+
+      // 서브에이전트 → 스킬 연결: 서브에이전트의 skills 필드 업데이트
+      if (sourceNode.type === 'subagent' && targetNode.type === 'skill') {
+        const skills = sourceNode.skills || [];
+        const skillId = targetNode.skillId || this.toKebabCase(targetNode.label);
+        if (!skills.includes(skillId)) {
+          skills.push(skillId);
+          sourceNode.skills = skills;
+          await this.syncSubagentNode(sourceNode);
+        }
+      }
+
+      // 스킬 → 서브에이전트 연결: 서브에이전트의 skills 필드 업데이트
+      if (sourceNode.type === 'skill' && targetNode.type === 'subagent') {
+        const skills = targetNode.skills || [];
+        const skillId = sourceNode.skillId || this.toKebabCase(sourceNode.label);
+        if (!skills.includes(skillId)) {
+          skills.push(skillId);
+          targetNode.skills = skills;
+          await this.syncSubagentNode(targetNode);
+        }
+      }
+
+      return { success: true };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      return { success: false, error: errorMessage };
+    }
+  }
+
+  /**
+   * 엣지 삭제 시 관계 업데이트
+   */
+  async removeEdge(edge: EdgeData, nodes: NodeData[]): Promise<{ success: boolean; error?: string }> {
+    try {
+      const sourceNode = nodes.find(n => n.id === edge.source);
+      const targetNode = nodes.find(n => n.id === edge.target);
+
+      if (!sourceNode || !targetNode) {
+        return { success: true }; // 노드가 없으면 무시
+      }
+
+      // 서브에이전트에서 스킬 제거
+      if (sourceNode.type === 'subagent' && targetNode.type === 'skill') {
+        const skillId = targetNode.skillId || this.toKebabCase(targetNode.label);
+        sourceNode.skills = (sourceNode.skills || []).filter(s => s !== skillId);
+        await this.syncSubagentNode(sourceNode);
+      }
+
+      if (sourceNode.type === 'skill' && targetNode.type === 'subagent') {
+        const skillId = sourceNode.skillId || this.toKebabCase(sourceNode.label);
+        targetNode.skills = (targetNode.skills || []).filter(s => s !== skillId);
+        await this.syncSubagentNode(targetNode);
+      }
+
+      return { success: true };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      return { success: false, error: errorMessage };
+    }
+  }
+
+  // ===== Private Methods =====
+
+  private async syncSkillNode(node: NodeData): Promise<{ success: boolean; path?: string; error?: string }> {
+    const skillId = node.skillId || this.toKebabCase(node.label);
+    const skillPath = path.join(this.projectRoot, '.claude', 'skills', skillId);
+    const skillMdPath = path.join(skillPath, 'SKILL.md');
+
+    await fs.mkdir(skillPath, { recursive: true });
+
+    // 기존 파일이 있으면 읽어서 업데이트, 없으면 새로 생성
+    let content = '';
+    try {
+      content = await fs.readFile(skillMdPath, 'utf-8');
+      // frontmatter 업데이트
+      content = this.updateFrontmatter(content, {
+        name: skillId,
+        description: node.description || node.label,
+      });
+    } catch {
+      // 새로 생성
+      content = `---
+name: ${skillId}
+description: ${node.description || node.label}
+---
+
+# ${node.label}
+
+## 사용 시점
+이 스킬은 다음 상황에서 사용됩니다:
+- ${node.description || '설명을 추가하세요'}
+
+## 사용 방법
+
+\`\`\`bash
+# 스킬 사용 방법을 여기에 작성하세요
+\`\`\`
+`;
+    }
+
+    await fs.writeFile(skillMdPath, content, 'utf-8');
+    return { success: true, path: skillPath };
+  }
+
+  private async syncSubagentNode(node: NodeData): Promise<{ success: boolean; path?: string; error?: string }> {
+    const agentName = this.toKebabCase(node.label);
+    const agentsDir = path.join(this.projectRoot, '.claude', 'agents');
+    const agentPath = path.join(agentsDir, `${agentName}.md`);
+
+    await fs.mkdir(agentsDir, { recursive: true });
+
+    // Frontmatter 구성
+    const frontmatter: Record<string, string> = {
+      name: agentName,
+      description: node.description || node.label,
+    };
+
+    if (node.tools && node.tools.length > 0) {
+      frontmatter.tools = node.tools.join(', ');
+    }
+
+    if (node.model) {
+      frontmatter.model = node.model;
+    }
+
+    if (node.skills && node.skills.length > 0) {
+      frontmatter.skills = node.skills.join(', ');
+    }
+
+    const frontmatterStr = Object.entries(frontmatter)
+      .map(([key, value]) => `${key}: ${value}`)
+      .join('\n');
+
+    const content = `---
+${frontmatterStr}
+---
+
+${node.systemPrompt || `You are ${node.label}.
+
+${node.description || ''}
+`}
+`;
+
+    await fs.writeFile(agentPath, content, 'utf-8');
+    return { success: true, path: agentPath };
+  }
+
+  private async syncCommandNode(node: NodeData): Promise<{ success: boolean; path?: string; error?: string }> {
+    const cmdName = node.commandName || this.toKebabCase(node.label);
+    const commandsDir = path.join(this.projectRoot, '.claude', 'commands');
+    const cmdPath = path.join(commandsDir, `${cmdName}.md`);
+
+    await fs.mkdir(commandsDir, { recursive: true });
+
+    const content = node.commandContent || `---
+description: ${node.description || node.label}
+---
+
+${node.description || '커맨드 내용을 여기에 작성하세요'}
+
+$ARGUMENTS
+`;
+
+    await fs.writeFile(cmdPath, content, 'utf-8');
+    return { success: true, path: cmdPath };
+  }
+
+  private async syncHookNode(node: NodeData): Promise<{ success: boolean; path?: string; error?: string }> {
+    const settingsPath = path.join(this.projectRoot, '.claude', 'settings.json');
+
+    // 기존 settings 읽기
+    let settings: Record<string, unknown> = {};
+    try {
+      const content = await fs.readFile(settingsPath, 'utf-8');
+      settings = JSON.parse(content);
+    } catch {
+      // 파일 없음
+    }
+
+    // hooks 섹션 확인/생성
+    if (!settings.hooks) {
+      settings.hooks = {};
+    }
+
+    const hooks = settings.hooks as Record<string, unknown[]>;
+    const event = node.hookEvent || 'PreToolUse';
+
+    if (!hooks[event]) {
+      hooks[event] = [];
+    }
+
+    // 기존 훅 찾기 (같은 matcher로)
+    const eventHooks = hooks[event] as Array<{ matcher: string; hooks: Array<{ type: string; command: string }> }>;
+    const existingIndex = eventHooks.findIndex(h => h.matcher === (node.hookMatcher || '*'));
+
+    const hookConfig = {
+      matcher: node.hookMatcher || '*',
+      hooks: [
+        {
+          type: 'command',
+          command: node.hookCommand || 'echo "Hook triggered"',
+        },
+      ],
+    };
+
+    if (existingIndex >= 0) {
+      eventHooks[existingIndex] = hookConfig;
+    } else {
+      eventHooks.push(hookConfig);
+    }
+
+    // .claude 디렉토리 생성
+    await fs.mkdir(path.dirname(settingsPath), { recursive: true });
+    await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
+
+    return { success: true, path: settingsPath };
+  }
+
+  private async removeHookFromSettings(node: NodeData): Promise<void> {
+    const settingsPath = path.join(this.projectRoot, '.claude', 'settings.json');
+
+    let settings: Record<string, unknown> = {};
+    try {
+      const content = await fs.readFile(settingsPath, 'utf-8');
+      settings = JSON.parse(content);
+    } catch {
+      return;
+    }
+
+    const hooks = settings.hooks as Record<string, unknown[]> | undefined;
+    if (!hooks) return;
+
+    const event = node.hookEvent || 'PreToolUse';
+    if (!hooks[event]) return;
+
+    const eventHooks = hooks[event] as Array<{ matcher: string }>;
+    hooks[event] = eventHooks.filter(h => h.matcher !== (node.hookMatcher || '*'));
+
+    await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
+  }
+
+  private updateFrontmatter(content: string, updates: Record<string, string>): string {
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) {
+      // frontmatter 없으면 추가
+      const fm = Object.entries(updates)
+        .map(([k, v]) => `${k}: ${v}`)
+        .join('\n');
+      return `---\n${fm}\n---\n\n${content}`;
+    }
+
+    let frontmatter = frontmatterMatch[1];
+    for (const [key, value] of Object.entries(updates)) {
+      const regex = new RegExp(`^${key}:.*$`, 'm');
+      if (regex.test(frontmatter)) {
+        frontmatter = frontmatter.replace(regex, `${key}: ${value}`);
+      } else {
+        frontmatter += `\n${key}: ${value}`;
+      }
+    }
+
+    return content.replace(/^---\n[\s\S]*?\n---/, `---\n${frontmatter}\n---`);
+  }
+
+  private toKebabCase(str: string): string {
+    return str
+      .toLowerCase()
+      .replace(/[^a-z0-9가-힣]+/g, '-')
+      .replace(/^-|-$/g, '');
+  }
+}
+
+export const nodeSyncService = new NodeSyncService();

package/server/services/skillGeneratorService.ts

@@ -1,6 +1,8 @@
 import Anthropic from '@anthropic-ai/sdk';
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import { existsSync } from 'fs';
+import { spawn } from 'child_process';
 import type { ApiSettings } from './workflowAIService';
 
 export interface GeneratedSkill {
@@ -21,6 +23,24 @@ export interface SkillGenerationResult {
   error?: string;
 }
 
+export type SkillProgressStep =
+  | 'started'
+  | 'analyzing'
+  | 'designing'
+  | 'generating'
+  | 'saving'
+  | 'installing'
+  | 'completed'
+  | 'error';
+
+export interface SkillProgressEvent {
+  step: SkillProgressStep;
+  message: string;
+  detail?: string;
+}
+
+export type SkillProgressCallback = (event: SkillProgressEvent) => void;
+
 const SYSTEM_PROMPT = `You are a Claude Code skill generator. You MUST respond with ONLY a valid JSON object. No markdown, no code blocks, no explanations - just pure JSON.
 
 Your response must follow this exact JSON schema:
@@ -106,14 +126,44 @@ export class SkillGeneratorService {
     return new Anthropic({ apiKey: envApiKey });
   }
 
-  async generate(prompt: string, settings?: ApiSettings): Promise<SkillGenerationResult> {
+  async generate(
+    prompt: string,
+    settings?: ApiSettings,
+    onProgress?: SkillProgressCallback
+  ): Promise<SkillGenerationResult> {
+    const progress = onProgress || (() => {});
+
+    progress({
+      step: 'started',
+      message: '✨ 스킬 생성을 시작합니다',
+      detail: `요청: "${prompt.slice(0, 50)}${prompt.length > 50 ? '...' : ''}"`,
+    });
+
     const client = this.getClient(settings);
 
+    progress({
+      step: 'analyzing',
+      message: '🔍 요청을 분석하고 있어요',
+      detail: '어떤 스킬이 필요한지 파악 중...',
+    });
+
     const userPrompt = `Create a skill for: "${prompt}"
 
 Generate complete, working code. Respond with JSON only.`;
 
     try {
+      progress({
+        step: 'designing',
+        message: '📝 스킬 구조를 설계하고 있어요',
+        detail: 'AI가 최적의 스킬 구조를 결정 중...',
+      });
+
+      progress({
+        step: 'generating',
+        message: '⚙️ 코드를 생성하고 있어요',
+        detail: 'Python 스크립트와 설정 파일 작성 중...',
+      });
+
       const response = await client.messages.create({
         model: 'claude-sonnet-4-20250514',
         max_tokens: 8192,
@@ -132,6 +182,10 @@ Generate complete, working code. Respond with JSON only.`;
       }
 
       if (!responseText) {
+        progress({
+          step: 'error',
+          message: '❌ AI 응답을 받지 못했습니다',
+        });
         return { success: false, error: 'AI 응답을 받지 못했습니다.' };
       }
 
@@ -143,13 +197,52 @@ Generate complete, working code. Respond with JSON only.`;
         skill = JSON.parse(fullJson);
       } catch {
         console.error('Failed to parse skill response:', fullJson.slice(0, 500));
+        progress({
+          step: 'error',
+          message: '❌ AI 응답을 파싱할 수 없습니다',
+          detail: '다시 시도해주세요',
+        });
         return { success: false, error: 'AI 응답을 파싱할 수 없습니다. 다시 시도해주세요.' };
       }
 
+      progress({
+        step: 'saving',
+        message: '💾 파일을 저장하고 있어요',
+        detail: `${skill.files.length}개 파일 저장 중...`,
+      });
+
       // 파일 저장
       const skillPath = path.join(this.projectRoot, '.claude', 'skills', skill.skillId);
       await this.saveSkillFiles(skillPath, skill.files);
 
+      // requirements.txt가 있으면 의존성 설치
+      const requirementsPath = path.join(skillPath, 'requirements.txt');
+      if (existsSync(requirementsPath)) {
+        progress({
+          step: 'installing',
+          message: '📦 패키지를 설치하고 있어요',
+          detail: 'pip install 실행 중...',
+        });
+
+        try {
+          await this.installDependencies(requirementsPath, progress);
+        } catch (installError) {
+          // 설치 실패해도 스킬 생성은 성공으로 처리
+          console.error('Dependency installation failed:', installError);
+          progress({
+            step: 'installing',
+            message: '⚠️ 일부 패키지 설치에 실패했어요',
+            detail: '나중에 수동으로 설치해주세요',
+          });
+        }
+      }
+
+      progress({
+        step: 'completed',
+        message: '✅ 스킬이 생성되었습니다!',
+        detail: `${skill.skillName} → ${skillPath}`,
+      });
+
       return {
         success: true,
         skill,
@@ -158,6 +251,11 @@ Generate complete, working code. Respond with JSON only.`;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : 'Unknown error';
       console.error('Skill generation error:', errorMessage);
+      progress({
+        step: 'error',
+        message: '❌ 스킬 생성에 실패했습니다',
+        detail: errorMessage,
+      });
       return { success: false, error: errorMessage };
     }
   }
@@ -181,6 +279,107 @@ Generate complete, working code. Respond with JSON only.`;
       console.log(`Saved: ${filePath}`);
     }
   }
+
+  private async installDependencies(
+    requirementsPath: string,
+    progress: SkillProgressCallback
+  ): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+      const venvPythonPath = path.join(homeDir, '.claude', 'venv', 'bin', 'python');
+
+      let command: string;
+      let args: string[];
+
+      // uv를 우선 사용 (10-100x 빠름)
+      // uv pip install --python <venv-python> -r requirements.txt
+      const useUv = this.checkCommandExists('uv');
+
+      if (useUv && existsSync(venvPythonPath)) {
+        command = 'uv';
+        args = ['pip', 'install', '--python', venvPythonPath, '-r', requirementsPath];
+        progress({
+          step: 'installing',
+          message: '⚡ uv로 패키지 설치 중 (고속)',
+          detail: 'uv pip install 실행 중...',
+        });
+      } else if (existsSync(path.join(homeDir, '.claude', 'venv', 'bin', 'pip'))) {
+        // fallback: 전역 venv pip 사용
+        command = path.join(homeDir, '.claude', 'venv', 'bin', 'pip');
+        args = ['install', '-r', requirementsPath];
+        progress({
+          step: 'installing',
+          message: '📦 pip으로 패키지 설치 중',
+          detail: 'pip install 실행 중...',
+        });
+      } else {
+        // fallback: 시스템 pip 사용
+        command = 'pip3';
+        args = ['install', '-r', requirementsPath];
+        progress({
+          step: 'installing',
+          message: '📦 pip으로 패키지 설치 중',
+          detail: 'pip install 실행 중...',
+        });
+      }
+
+      console.log(`Installing dependencies: ${command} ${args.join(' ')}`);
+
+      const proc = spawn(command, args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+
+      let output = '';
+      let errorOutput = '';
+
+      proc.stdout?.on('data', (data) => {
+        output += data.toString();
+        const lines = data.toString().trim().split('\n');
+        for (const line of lines) {
+          if (line.includes('Successfully installed') || line.includes('Requirement already satisfied') || line.includes('Installed')) {
+            progress({
+              step: 'installing',
+              message: '📦 패키지 설치 중',
+              detail: line.slice(0, 60) + (line.length > 60 ? '...' : ''),
+            });
+          }
+        }
+      });
+
+      proc.stderr?.on('data', (data) => {
+        errorOutput += data.toString();
+      });
+
+      proc.on('close', (code) => {
+        if (code === 0) {
+          progress({
+            step: 'installing',
+            message: '✅ 패키지 설치 완료',
+            detail: '모든 의존성이 설치되었습니다',
+          });
+          resolve();
+        } else {
+          console.error('Package install failed:', errorOutput);
+          reject(new Error(`Package install failed with code ${code}`));
+        }
+      });
+
+      proc.on('error', (err) => {
+        console.error('Failed to start package installer:', err);
+        reject(err);
+      });
+    });
+  }
+
+  private checkCommandExists(cmd: string): boolean {
+    try {
+      const { execSync } = require('child_process');
+      execSync(`which ${cmd}`, { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
 }
 
 export const skillGeneratorService = new SkillGeneratorService();