makecc 0.2.5 → 0.2.8

package/dist/server/services/nodeSyncService.js

@@ -0,0 +1,313 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export class NodeSyncService {
+    projectRoot;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot || process.env.MAKECC_PROJECT_PATH || process.cwd();
+    }
+    /**
+     * 노드 생성/수정 시 파일 동기화
+     */
+    async syncNode(node) {
+        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) {
+        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, nodes) {
+        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, nodes) {
+        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 =====
+    async syncSkillNode(node) {
+        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 };
+    }
+    async syncSubagentNode(node) {
+        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 = {
+            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 };
+    }
+    async syncCommandNode(node) {
+        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 };
+    }
+    async syncHookNode(node) {
+        const settingsPath = path.join(this.projectRoot, '.claude', 'settings.json');
+        // 기존 settings 읽기
+        let settings = {};
+        try {
+            const content = await fs.readFile(settingsPath, 'utf-8');
+            settings = JSON.parse(content);
+        }
+        catch {
+            // 파일 없음
+        }
+        // hooks 섹션 확인/생성
+        if (!settings.hooks) {
+            settings.hooks = {};
+        }
+        const hooks = settings.hooks;
+        const event = node.hookEvent || 'PreToolUse';
+        if (!hooks[event]) {
+            hooks[event] = [];
+        }
+        // 기존 훅 찾기 (같은 matcher로)
+        const eventHooks = hooks[event];
+        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 };
+    }
+    async removeHookFromSettings(node) {
+        const settingsPath = path.join(this.projectRoot, '.claude', 'settings.json');
+        let settings = {};
+        try {
+            const content = await fs.readFile(settingsPath, 'utf-8');
+            settings = JSON.parse(content);
+        }
+        catch {
+            return;
+        }
+        const hooks = settings.hooks;
+        if (!hooks)
+            return;
+        const event = node.hookEvent || 'PreToolUse';
+        if (!hooks[event])
+            return;
+        const eventHooks = hooks[event];
+        hooks[event] = eventHooks.filter(h => h.matcher !== (node.hookMatcher || '*'));
+        await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
+    }
+    updateFrontmatter(content, updates) {
+        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---`);
+    }
+    toKebabCase(str) {
+        return str
+            .toLowerCase()
+            .replace(/[^a-z0-9가-힣]+/g, '-')
+            .replace(/^-|-$/g, '');
+    }
+}
+export const nodeSyncService = new NodeSyncService();

package/dist/server/services/skillGeneratorService.js

@@ -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';
 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:
@@ -79,12 +81,33 @@ export class SkillGeneratorService {
         }
         return new Anthropic({ apiKey: envApiKey });
     }
-    async generate(prompt, settings) {
+    async generate(prompt, settings, onProgress) {
+        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,
@@ -101,6 +124,10 @@ Generate complete, working code. Respond with JSON only.`;
                 }
             }
             if (!responseText) {
+                progress({
+                    step: 'error',
+                    message: '❌ AI 응답을 받지 못했습니다',
+                });
                 return { success: false, error: 'AI 응답을 받지 못했습니다.' };
             }
             // Prefill로 '{'를 보냈으니 응답 앞에 '{'를 붙임
@@ -111,11 +138,47 @@ Generate complete, working code. Respond with JSON only.`;
             }
             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,
@@ -125,6 +188,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 };
         }
     }
@@ -141,5 +209,95 @@ Generate complete, working code. Respond with JSON only.`;
             console.log(`Saved: ${filePath}`);
         }
     }
+    async installDependencies(requirementsPath, progress) {
+        return new Promise((resolve, reject) => {
+            const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+            const venvPythonPath = path.join(homeDir, '.claude', 'venv', 'bin', 'python');
+            let command;
+            let args;
+            // 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);
+            });
+        });
+    }
+    checkCommandExists(cmd) {
+        try {
+            const { execSync } = require('child_process');
+            execSync(`which ${cmd}`, { stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
 }
 export const skillGeneratorService = new SkillGeneratorService();

package/package.json

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