makecc 0.2.16 → 0.2.18

package/server/index.ts

@@ -242,8 +242,7 @@ app.get('/api/load/claude-config', async (req, res) => {
   try {
     const config = await configLoaderService.loadAll();
     console.log(
-      `Loaded config: ${config.skills.length} skills, ${config.subagents.length} agents, ` +
-      `${config.commands.length} commands, ${config.hooks.length} hooks`
+      `Loaded config: ${config.skills.length} skills, ${config.agents.length} agents, ${config.hooks.length} hooks`
     );
     res.json(config);
   } catch (error) {
@@ -256,7 +255,7 @@ app.get('/api/load/claude-config', async (req, res) => {
 // Generate workflow using AI
 app.post('/api/generate/workflow', async (req, res) => {
   try {
-    const { prompt } = req.body as { prompt: string };
+    const { prompt, expand = true } = req.body as { prompt: string; expand?: boolean };
 
     if (!prompt || typeof prompt !== 'string') {
       return res.status(400).json({ message: 'Prompt is required' });
@@ -267,13 +266,21 @@ app.post('/api/generate/workflow', async (req, res) => {
     const apiKey = req.headers['x-api-key'] as string;
     const proxyUrl = req.headers['x-proxy-url'] as string;
 
-    console.log('Generating workflow for prompt:', prompt, 'mode:', apiMode);
+    console.log('Generating workflow for prompt:', prompt, 'mode:', apiMode, 'expand:', expand);
 
-    const result = await workflowAIService.generate(prompt, {
+    const settings = {
       apiMode: apiMode as 'proxy' | 'direct',
       apiKey,
       proxyUrl,
-    });
+    };
+
+    // expand=true (기본값)이면 재귀적으로 스킬/에이전트 상세 생성
+    const result = expand
+      ? await workflowAIService.generateWithExpansion(prompt, settings, (event) => {
+          console.log(`[Workflow] ${event.step}: ${event.message}`);
+        })
+      : await workflowAIService.generate(prompt, settings);
+
     console.log('Workflow generated:', result.workflowName);
 
     res.json(result);

package/server/services/claudeCliService.ts

@@ -208,7 +208,7 @@ export function buildNodePrompt(
 ): string {
   const lines: string[] = [];
 
-  if (nodeType === 'subagent') {
+  if (nodeType === 'agent') {
     const role = nodeData.role as string || 'assistant';
     const description = nodeData.description as string || '';
     const systemPrompt = nodeData.systemPrompt as string || '';

package/server/services/claudeService.ts

@@ -40,7 +40,7 @@ export class ClaudeService {
       case 'input':
         return this.executeInputNode(node.id, node.data as InputNodeData);
 
-      case 'subagent':
+      case 'agent':
         return this.executeSubagentNode(
           node.id,
           node.data as SubagentNodeData,

package/server/services/configLoaderService.ts

@@ -12,7 +12,7 @@ interface LoadedSkill {
 
 interface LoadedSubagent {
   id: string;
-  type: 'subagent';
+  type: 'agent';
   label: string;
   description: string;
   tools: string[];
@@ -21,15 +21,6 @@ interface LoadedSubagent {
   systemPrompt: string;
 }
 
-interface LoadedCommand {
-  id: string;
-  type: 'command';
-  label: string;
-  description: string;
-  commandName: string;
-  commandContent: string;
-}
-
 interface LoadedHook {
   id: string;
   type: 'hook';
@@ -40,12 +31,11 @@ interface LoadedHook {
   hookCommand: string;
 }
 
-export type LoadedNode = LoadedSkill | LoadedSubagent | LoadedCommand | LoadedHook;
+export type LoadedNode = LoadedSkill | LoadedSubagent | LoadedHook;
 
 export interface ClaudeConfig {
   skills: LoadedSkill[];
-  subagents: LoadedSubagent[];
-  commands: LoadedCommand[];
+  agents: LoadedSubagent[];
   hooks: LoadedHook[];
 }
 
@@ -60,14 +50,13 @@ export class ConfigLoaderService {
    * .claude/ 디렉토리에서 모든 설정 로드
    */
   async loadAll(): Promise<ClaudeConfig> {
-    const [skills, subagents, commands, hooks] = await Promise.all([
+    const [skills, agents, hooks] = await Promise.all([
       this.loadSkills(),
-      this.loadSubagents(),
-      this.loadCommands(),
+      this.loadAgents(),
       this.loadHooks(),
     ]);
 
-    return { skills, subagents, commands, hooks };
+    return { skills, agents, hooks };
   }
 
   /**
@@ -108,11 +97,11 @@ export class ConfigLoaderService {
   }
 
   /**
-   * .claude/agents/ 에서 서브에이전트 로드
+   * .claude/agents/ 에서 에이전트 로드
    */
-  async loadSubagents(): Promise<LoadedSubagent[]> {
+  async loadAgents(): Promise<LoadedSubagent[]> {
     const agentsDir = path.join(this.projectRoot, '.claude', 'agents');
-    const subagents: LoadedSubagent[] = [];
+    const agents: LoadedSubagent[] = [];
 
     try {
       const entries = await fs.readdir(agentsDir, { withFileTypes: true });
@@ -125,9 +114,9 @@ export class ConfigLoaderService {
             const parsed = this.parseFrontmatter(content);
             const agentName = entry.name.replace('.md', '');
 
-            subagents.push({
-              id: `subagent-${agentName}`,
-              type: 'subagent',
+            agents.push({
+              id: `agent-${agentName}`,
+              type: 'agent',
               label: parsed.frontmatter.name || agentName,
               description: parsed.frontmatter.description || '',
               tools: this.parseList(parsed.frontmatter.tools),
@@ -144,45 +133,7 @@ export class ConfigLoaderService {
       // agents 디렉토리가 없으면 빈 배열 반환
     }
 
-    return subagents;
-  }
-
-  /**
-   * .claude/commands/ 에서 커맨드 로드
-   */
-  async loadCommands(): Promise<LoadedCommand[]> {
-    const commandsDir = path.join(this.projectRoot, '.claude', 'commands');
-    const commands: LoadedCommand[] = [];
-
-    try {
-      const entries = await fs.readdir(commandsDir, { withFileTypes: true });
-
-      for (const entry of entries) {
-        if (entry.isFile() && entry.name.endsWith('.md')) {
-          const cmdPath = path.join(commandsDir, entry.name);
-          try {
-            const content = await fs.readFile(cmdPath, 'utf-8');
-            const parsed = this.parseFrontmatter(content);
-            const cmdName = entry.name.replace('.md', '');
-
-            commands.push({
-              id: `command-${cmdName}`,
-              type: 'command',
-              label: parsed.frontmatter.name || cmdName,
-              description: parsed.frontmatter.description || '',
-              commandName: cmdName,
-              commandContent: content,
-            });
-          } catch {
-            // 읽을 수 없으면 스킵
-          }
-        }
-      }
-    } catch {
-      // commands 디렉토리가 없으면 빈 배열 반환
-    }
-
-    return commands;
+    return agents;
   }
 
   /**

package/server/services/nodeSyncService.ts

@@ -3,7 +3,7 @@ import * as path from 'path';
 
 interface NodeData {
   id: string;
-  type: 'skill' | 'subagent' | 'command' | 'hook' | 'input' | 'output';
+  type: 'skill' | 'agent' | 'hook' | 'input' | 'output';
   label: string;
   description?: string;
   // Skill specific
@@ -11,14 +11,11 @@ interface NodeData {
   skillPath?: string;
   upstream?: string[];   // Connected upstream agents/skills
   downstream?: string[]; // Connected downstream agents/skills
-  // Subagent specific
+  // Agent specific
   tools?: string[];
   model?: string;
   skills?: string[];  // Connected downstream skills
   systemPrompt?: string;
-  // Command specific
-  commandName?: string;
-  commandContent?: string;
   // Hook specific
   hookEvent?: string;
   hookMatcher?: string;
@@ -47,10 +44,8 @@ export class NodeSyncService {
       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 'agent':
+          return await this.syncAgentNode(node);
         case 'hook':
           return await this.syncHookNode(node);
         case 'input':
@@ -86,16 +81,11 @@ export class NodeSyncService {
             await fs.rm(skillPath, { recursive: true, force: true });
           }
           break;
-        case 'subagent':
+        case 'agent':
           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;
@@ -112,11 +102,11 @@ export class NodeSyncService {
    */
   private async removeReferencesToNode(nodeId: string, nodeType: string, allNodes: NodeData[]): Promise<void> {
     for (const relatedNode of allNodes) {
-      if (relatedNode.type === 'subagent') {
+      if (relatedNode.type === 'agent') {
         // 서브에이전트의 skills 배열에서 삭제된 노드 제거
         if (relatedNode.skills?.includes(nodeId)) {
           relatedNode.skills = relatedNode.skills.filter(s => s !== nodeId);
-          await this.syncSubagentNode(relatedNode);
+          await this.syncAgentNode(relatedNode);
         }
       } else if (relatedNode.type === 'skill') {
         let updated = false;
@@ -155,13 +145,13 @@ export class NodeSyncService {
       const targetId = this.getNodeIdentifier(targetNode);
 
       // 서브에이전트 → 스킬 연결
-      if (sourceNode.type === 'subagent' && targetNode.type === 'skill') {
+      if (sourceNode.type === 'agent' && targetNode.type === 'skill') {
         // 에이전트의 skills 필드 업데이트
         const skills = sourceNode.skills || [];
         if (!skills.includes(targetId)) {
           skills.push(targetId);
           sourceNode.skills = skills;
-          await this.syncSubagentNode(sourceNode);
+          await this.syncAgentNode(sourceNode);
         }
 
         // 스킬의 upstream 필드 업데이트
@@ -193,13 +183,13 @@ export class NodeSyncService {
       }
 
       // 스킬 → 서브에이전트 연결
-      if (sourceNode.type === 'skill' && targetNode.type === 'subagent') {
+      if (sourceNode.type === 'skill' && targetNode.type === 'agent') {
         // 에이전트의 upstream skills 필드 업데이트
         const skills = targetNode.skills || [];
         if (!skills.includes(sourceId)) {
           skills.push(sourceId);
           targetNode.skills = skills;
-          await this.syncSubagentNode(targetNode);
+          await this.syncAgentNode(targetNode);
         }
 
         // 스킬의 downstream 필드 업데이트
@@ -212,13 +202,13 @@ export class NodeSyncService {
       }
 
       // 서브에이전트 → 서브에이전트 연결
-      if (sourceNode.type === 'subagent' && targetNode.type === 'subagent') {
+      if (sourceNode.type === 'agent' && targetNode.type === 'agent') {
         // source의 downstream agents
         const sourceDownstream = sourceNode.skills || [];
         if (!sourceDownstream.includes(targetId)) {
           sourceDownstream.push(targetId);
           sourceNode.skills = sourceDownstream;
-          await this.syncSubagentNode(sourceNode);
+          await this.syncAgentNode(sourceNode);
         }
       }
 
@@ -255,10 +245,10 @@ export class NodeSyncService {
       const targetId = this.getNodeIdentifier(targetNode);
 
       // 서브에이전트 → 스킬 연결 해제
-      if (sourceNode.type === 'subagent' && targetNode.type === 'skill') {
+      if (sourceNode.type === 'agent' && targetNode.type === 'skill') {
         // 에이전트에서 스킬 제거
         sourceNode.skills = (sourceNode.skills || []).filter(s => s !== targetId);
-        await this.syncSubagentNode(sourceNode);
+        await this.syncAgentNode(sourceNode);
 
         // 스킬에서 upstream 제거
         targetNode.upstream = (targetNode.upstream || []).filter(s => s !== sourceId);
@@ -275,18 +265,18 @@ export class NodeSyncService {
       }
 
       // 스킬 → 서브에이전트 연결 해제
-      if (sourceNode.type === 'skill' && targetNode.type === 'subagent') {
+      if (sourceNode.type === 'skill' && targetNode.type === 'agent') {
         targetNode.skills = (targetNode.skills || []).filter(s => s !== sourceId);
-        await this.syncSubagentNode(targetNode);
+        await this.syncAgentNode(targetNode);
 
         sourceNode.downstream = (sourceNode.downstream || []).filter(s => s !== targetId);
         await this.syncSkillNode(sourceNode);
       }
 
       // 서브에이전트 → 서브에이전트 연결 해제
-      if (sourceNode.type === 'subagent' && targetNode.type === 'subagent') {
+      if (sourceNode.type === 'agent' && targetNode.type === 'agent') {
         sourceNode.skills = (sourceNode.skills || []).filter(s => s !== targetId);
-        await this.syncSubagentNode(sourceNode);
+        await this.syncAgentNode(sourceNode);
       }
 
       return { success: true };
@@ -357,7 +347,7 @@ ${frontmatterStr}
     return { success: true, path: skillPath };
   }
 
-  private async syncSubagentNode(node: NodeData): Promise<{ success: boolean; path?: string; error?: string }> {
+  private async syncAgentNode(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`);
@@ -446,26 +436,6 @@ ${body}
     return { frontmatter, body };
   }
 
-  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');
 

package/server/services/terminalService.ts

@@ -49,7 +49,7 @@ function generateClaudePrompt(options: TerminalExecutionOptions): string {
   executionOrder.forEach((node) => {
     if (node.type === 'input') return;
 
-    if (node.type === 'subagent') {
+    if (node.type === 'agent') {
       const data = node.data as SubagentNodeData;
       lines.push(`${stepNum}. **${data.label}** (${data.role})`);
       if (data.description) {