makecc 0.2.4 → 0.2.7

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

@@ -21,87 +21,63 @@ export interface SkillGenerationResult {
   error?: string;
 }
 
-const SYSTEM_PROMPT = `당신은 Claude Code 스킬 생성 전문가입니다.
+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.
 
-사용자의 요청을 분석하여 완전히 작동하는 Claude Code 스킬을 생성합니다.
-
-## Claude Code 스킬 구조
-
-스킬은 다음 구조로 생성됩니다:
-\`\`\`
-.claude/skills/[skill-name]/
-├── SKILL.md          # 스킬 정의 (필수)
-├── scripts/          # 스크립트 폴더
-│   └── main.py       # 메인 스크립트
-└── requirements.txt  # Python 의존성 (필요시)
-\`\`\`
-
-## SKILL.md 형식
-
-\`\`\`markdown
----
-name: skill-name
-description: 스킬 설명 (한 줄)
----
-
-# 스킬 이름
-
-## 사용 시점
-이 스킬은 다음 상황에서 사용됩니다:
-- 상황 1
-- 상황 2
-
-## 사용 방법
-
-\\\`\\\`\\\`bash
-~/.claude/venv/bin/python ~/.claude/skills/[skill-name]/scripts/main.py [인자들]
-\\\`\\\`\\\`
-
-## 파라미터
-- \`param1\`: 설명
-- \`param2\`: 설명
-
-## 예시
-[사용 예시]
-\`\`\`
-
-## 응답 형식 (JSON)
-
-반드시 아래 형식의 JSON으로 응답하세요:
+Your response must follow this exact JSON schema:
 
 {
-  "skillName": "스킬 이름 (한글 가능)",
-  "skillId": "skill-id-kebab-case",
-  "description": "스킬 설명",
+  "skillName": "Human readable skill name",
+  "skillId": "skill-id-in-kebab-case",
+  "description": "Brief description of what this skill does",
   "files": [
     {
       "path": "SKILL.md",
-      "content": "SKILL.md 전체 내용",
+      "content": "Full SKILL.md content here",
       "language": "markdown"
     },
     {
       "path": "scripts/main.py",
-      "content": "Python 스크립트 전체 내용",
+      "content": "Full Python script content here",
       "language": "python"
     },
     {
       "path": "requirements.txt",
-      "content": "의존성 목록 (필요한 경우)",
+      "content": "package1\\npackage2",
       "language": "text"
     }
   ]
 }
 
-## 중요 규칙
+SKILL.md must follow this format:
+---
+name: skill-id
+description: One line description
+---
+
+# Skill Name
+
+## When to use
+- Use case 1
+- Use case 2
+
+## Usage
+\`\`\`bash
+~/.claude/venv/bin/python ~/.claude/skills/skill-id/scripts/main.py [args]
+\`\`\`
+
+## Parameters
+- \`--param1\`: Description
+
+## Example
+[Usage example]
 
-1. **완전한 코드 생성**: 실제로 동작하는 완전한 코드를 작성하세요
-2. **에러 처리 포함**: try-except로 에러 처리를 포함하세요
-3. **한글 지원**: 출력 메시지는 한글로 작성하세요
-4. **환경 고려**:
-   - Python 스크립트는 \`~/.claude/venv/bin/python\`으로 실행됩니다
-   - 필요한 패키지는 requirements.txt에 명시하세요
-5. **JSON만 반환**: 설명 없이 JSON만 반환하세요
-`;
+RULES:
+1. Generate COMPLETE, WORKING code - no placeholders
+2. Include proper error handling with try-except
+3. Use Korean for user-facing messages
+4. Scripts run with ~/.claude/venv/bin/python
+5. List all required packages in requirements.txt
+6. RESPOND WITH JSON ONLY - NO OTHER TEXT`;
 
 export class SkillGeneratorService {
   private projectRoot: string;
@@ -133,17 +109,19 @@ export class SkillGeneratorService {
   async generate(prompt: string, settings?: ApiSettings): Promise<SkillGenerationResult> {
     const client = this.getClient(settings);
 
-    const userPrompt = `다음 스킬을 생성해주세요: "${prompt}"
+    const userPrompt = `Create a skill for: "${prompt}"
 
-완전히 동작하는 코드를 포함한 스킬을 생성하세요.
-반드시 JSON만 반환하세요.`;
+Generate complete, working code. Respond with JSON only.`;
 
     try {
       const response = await client.messages.create({
         model: 'claude-sonnet-4-20250514',
         max_tokens: 8192,
         system: SYSTEM_PROMPT,
-        messages: [{ role: 'user', content: userPrompt }],
+        messages: [
+          { role: 'user', content: userPrompt },
+          { role: 'assistant', content: '{' }  // Prefill to force JSON
+        ],
       });
 
       let responseText = '';
@@ -157,15 +135,14 @@ export class SkillGeneratorService {
         return { success: false, error: 'AI 응답을 받지 못했습니다.' };
       }
 
-      // JSON 추출
-      const jsonMatch = responseText.match(/```(?:json)?\s*([\s\S]*?)```/);
-      const rawJson = jsonMatch ? jsonMatch[1].trim() : responseText.trim();
+      // Prefill로 '{'를 보냈으니 응답 앞에 '{'를 붙임
+      const fullJson = '{' + responseText;
 
       let skill: GeneratedSkill;
       try {
-        skill = JSON.parse(rawJson);
+        skill = JSON.parse(fullJson);
       } catch {
-        console.error('Failed to parse skill response:', rawJson.slice(0, 500));
+        console.error('Failed to parse skill response:', fullJson.slice(0, 500));
         return { success: false, error: 'AI 응답을 파싱할 수 없습니다. 다시 시도해주세요.' };
       }