makecc 0.2.10 → 0.2.12

package/server/services/claudeMdService.ts

@@ -0,0 +1,270 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { existsSync } from 'fs';
+import { execSync, spawn } from 'child_process';
+
+const MAKECC_SECTION_MARKER = '<!-- makecc-managed-section -->';
+const MAKECC_SECTION_END = '<!-- /makecc-managed-section -->';
+
+/**
+ * makecc가 로컬 프로젝트에 추가할 CLAUDE.md 기본 템플릿
+ */
+const MAKECC_CLAUDE_MD_TEMPLATE = `${MAKECC_SECTION_MARKER}
+## makecc 스킬/워크플로우 규칙
+
+이 섹션은 makecc에 의해 자동 생성되었습니다.
+
+### Python 가상환경
+
+**모든 스킬은 프로젝트 로컬 가상환경을 사용합니다:**
+
+\`\`\`
+.venv/
+\`\`\`
+
+**사용 패턴:**
+
+\`\`\`bash
+# 로컬 venv Python 직접 실행 (권장)
+.venv/bin/python script.py
+
+# 또는 활성화 후 실행
+source .venv/bin/activate && python script.py
+\`\`\`
+
+### 패키지 관리
+
+**uv를 우선 사용합니다 (pip보다 10-100x 빠름):**
+
+\`\`\`bash
+# uv로 패키지 설치 (권장)
+uv pip install --python .venv/bin/python package_name
+
+# requirements.txt 설치
+uv pip install --python .venv/bin/python -r requirements.txt
+
+# uv가 없으면 pip 폴백
+.venv/bin/pip install package_name
+\`\`\`
+
+### 스킬 저장 경로
+
+| 항목 | 경로 |
+|------|------|
+| 스킬 | \`.claude/skills/[skill-name]/\` |
+| 에이전트 | \`.claude/agents/[agent-name].md\` |
+| 워크플로우 | \`.claude/agents/[workflow-name].md\` |
+
+### 스킬 구조
+
+\`\`\`
+.claude/skills/[skill-name]/
+├── SKILL.md          # 스킬 정의 (필수)
+├── scripts/
+│   └── main.py       # 메인 스크립트
+└── requirements.txt  # 의존성 목록
+\`\`\`
+
+### 스킬 실행 규칙
+
+1. **가상환경 사용**: 항상 \`.venv/bin/python\` 사용
+2. **의존성 설치**: \`uv pip install\` 우선, 실패 시 \`pip\` 폴백
+3. **경로 참조**: 상대 경로 대신 절대 경로 사용 권장
+4. **한글 지원**: 사용자 메시지는 한글로 출력
+
+${MAKECC_SECTION_END}
+`;
+
+export class ClaudeMdService {
+  private projectRoot: string;
+
+  constructor(projectRoot?: string) {
+    this.projectRoot = projectRoot || process.env.MAKECC_PROJECT_PATH || process.cwd();
+  }
+
+  /**
+   * CLAUDE.md 파일 경로
+   */
+  private getClaudeMdPath(): string {
+    return path.join(this.projectRoot, 'CLAUDE.md');
+  }
+
+  /**
+   * CLAUDE.md 내용 읽기
+   */
+  async read(): Promise<string | null> {
+    const claudeMdPath = this.getClaudeMdPath();
+    if (!existsSync(claudeMdPath)) {
+      return null;
+    }
+    return fs.readFile(claudeMdPath, 'utf-8');
+  }
+
+  /**
+   * makecc 섹션이 있는지 확인
+   */
+  hasMakeccSection(content: string): boolean {
+    return content.includes(MAKECC_SECTION_MARKER);
+  }
+
+  /**
+   * CLAUDE.md 초기화 - 없으면 생성, 있으면 섹션 추가
+   */
+  async initialize(): Promise<{ created: boolean; updated: boolean; path: string }> {
+    const claudeMdPath = this.getClaudeMdPath();
+    const result = { created: false, updated: false, path: claudeMdPath };
+
+    const existingContent = await this.read();
+
+    if (existingContent === null) {
+      // 파일이 없으면 새로 생성
+      const newContent = `# CLAUDE.md
+
+이 파일은 Claude Code가 이 프로젝트의 코드를 다룰 때 참고하는 가이드입니다.
+
+${MAKECC_CLAUDE_MD_TEMPLATE}
+`;
+      await fs.writeFile(claudeMdPath, newContent, 'utf-8');
+      result.created = true;
+      console.log(`Created CLAUDE.md at ${claudeMdPath}`);
+    } else if (!this.hasMakeccSection(existingContent)) {
+      // 파일은 있지만 makecc 섹션이 없으면 추가
+      const updatedContent = existingContent.trimEnd() + '\n\n' + MAKECC_CLAUDE_MD_TEMPLATE;
+      await fs.writeFile(claudeMdPath, updatedContent, 'utf-8');
+      result.updated = true;
+      console.log(`Added makecc section to CLAUDE.md at ${claudeMdPath}`);
+    } else {
+      console.log(`CLAUDE.md already has makecc section at ${claudeMdPath}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * 프로젝트 로컬 .venv 초기화
+   */
+  async initializeVenv(): Promise<{ created: boolean; path: string }> {
+    const venvPath = path.join(this.projectRoot, '.venv');
+    const result = { created: false, path: venvPath };
+
+    if (existsSync(venvPath)) {
+      console.log(`Virtual environment already exists at ${venvPath}`);
+      return result;
+    }
+
+    console.log(`Creating virtual environment at ${venvPath}...`);
+
+    try {
+      // uv가 있으면 uv venv 사용 (더 빠름)
+      if (this.checkCommandExists('uv')) {
+        execSync(`uv venv "${venvPath}"`, { cwd: this.projectRoot, stdio: 'inherit' });
+      } else {
+        // python -m venv 사용
+        execSync(`python3 -m venv "${venvPath}"`, { cwd: this.projectRoot, stdio: 'inherit' });
+      }
+      result.created = true;
+      console.log(`Created virtual environment at ${venvPath}`);
+    } catch (error) {
+      console.error('Failed to create virtual environment:', error);
+      throw error;
+    }
+
+    return result;
+  }
+
+  /**
+   * uv 설치 확인 및 자동 설치
+   */
+  async ensureUvInstalled(): Promise<{ installed: boolean; alreadyExists: boolean }> {
+    const result = { installed: false, alreadyExists: false };
+
+    if (this.checkCommandExists('uv')) {
+      result.alreadyExists = true;
+      console.log('uv is already installed');
+      return result;
+    }
+
+    console.log('uv not found, attempting to install...');
+
+    try {
+      // curl 스크립트로 설치
+      await this.runCommand('curl', ['-LsSf', 'https://astral.sh/uv/install.sh', '-o', '/tmp/uv-install.sh']);
+      await this.runCommand('sh', ['/tmp/uv-install.sh']);
+
+      // PATH에 추가된 uv 확인
+      const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+      const uvPath = path.join(homeDir, '.local', 'bin', 'uv');
+
+      if (existsSync(uvPath)) {
+        // PATH에 추가
+        process.env.PATH = `${path.dirname(uvPath)}:${process.env.PATH}`;
+        result.installed = true;
+        console.log('uv installed successfully');
+      } else {
+        console.warn('uv installation may have failed, falling back to pip');
+      }
+    } catch (error) {
+      console.error('Failed to install uv:', error);
+      console.log('Will fall back to pip for package management');
+    }
+
+    return result;
+  }
+
+  /**
+   * 전체 초기화 실행
+   */
+  async setup(): Promise<{
+    claudeMd: { created: boolean; updated: boolean; path: string };
+    venv: { created: boolean; path: string };
+    uv: { installed: boolean; alreadyExists: boolean };
+  }> {
+    console.log('\n=== makecc Project Setup ===\n');
+    console.log(`Project root: ${this.projectRoot}\n`);
+
+    // 1. uv 설치 확인
+    const uvResult = await this.ensureUvInstalled();
+
+    // 2. CLAUDE.md 초기화
+    const claudeMdResult = await this.initialize();
+
+    // 3. .venv 초기화
+    const venvResult = await this.initializeVenv();
+
+    console.log('\n=== Setup Complete ===\n');
+
+    return {
+      claudeMd: claudeMdResult,
+      venv: venvResult,
+      uv: uvResult,
+    };
+  }
+
+  /**
+   * 명령어 존재 확인
+   */
+  private checkCommandExists(cmd: string): boolean {
+    try {
+      execSync(`which ${cmd}`, { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * 명령어 실행 (Promise)
+   */
+  private runCommand(command: string, args: string[]): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const proc = spawn(command, args, { stdio: 'inherit' });
+      proc.on('close', (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`Command failed with code ${code}`));
+      });
+      proc.on('error', reject);
+    });
+  }
+}
+
+export const claudeMdService = new ClaudeMdService();

package/server/services/skillGeneratorService.ts

@@ -2,8 +2,9 @@ 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 { spawn, execSync } from 'child_process';
 import type { ApiSettings } from './workflowAIService';
+import { claudeMdService } from './claudeMdService';
 
 export interface GeneratedSkill {
   skillName: string;
@@ -82,7 +83,7 @@ description: One line description
 
 ## Usage
 \`\`\`bash
-~/.claude/venv/bin/python ~/.claude/skills/skill-id/scripts/main.py [args]
+.venv/bin/python .claude/skills/skill-id/scripts/main.py [args]
 \`\`\`
 
 ## Parameters
@@ -95,7 +96,7 @@ 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
+4. Scripts run with .venv/bin/python (project local virtual environment)
 5. List all required packages in requirements.txt
 6. RESPOND WITH JSON ONLY - NO OTHER TEXT`;
 
@@ -107,23 +108,39 @@ export class SkillGeneratorService {
   }
 
   private getClient(settings?: ApiSettings): Anthropic {
-    if (settings?.apiMode === 'direct' && settings.apiKey) {
-      return new Anthropic({ apiKey: settings.apiKey });
-    }
+    const DEFAULT_ANTHROPIC_URL = 'https://api.anthropic.com';
 
-    if (settings?.apiMode === 'proxy' && settings.proxyUrl) {
+    // 1. 프록시 우선: proxyUrl이 설정되어 있고, 기본 Anthropic URL이 아닌 경우
+    //    프록시 서버가 API 키를 관리하므로 클라이언트는 키 불필요
+    if (settings?.proxyUrl && settings.proxyUrl !== DEFAULT_ANTHROPIC_URL) {
+      console.log(`Using proxy server: ${settings.proxyUrl}`);
       return new Anthropic({
         baseURL: settings.proxyUrl,
-        apiKey: process.env.ANTHROPIC_API_KEY || 'proxy-mode',
+        apiKey: 'proxy-mode', // 프록시 서버가 실제 키를 관리
       });
     }
 
+    // 2. 환경변수에 API 키가 있으면 직접 호출
     const envApiKey = process.env.ANTHROPIC_API_KEY;
-    if (!envApiKey) {
-      throw new Error('API 키가 설정되지 않았습니다. 설정에서 API 키를 입력하세요.');
+    if (envApiKey) {
+      console.log('Using API key from environment variable');
+      return new Anthropic({ apiKey: envApiKey });
+    }
+
+    // 3. UI에서 direct 모드로 API 키를 직접 입력한 경우
+    if (settings?.apiMode === 'direct' && settings.apiKey) {
+      console.log('Using API key from UI settings');
+      return new Anthropic({ apiKey: settings.apiKey });
     }
 
-    return new Anthropic({ apiKey: envApiKey });
+    // 4. 아무것도 없으면 에러
+    throw new Error(
+      'API 키가 설정되지 않았습니다.\n' +
+      '해결 방법:\n' +
+      '1. 프록시 서버 URL을 설정하거나\n' +
+      '2. 프로젝트 .env 파일에 ANTHROPIC_API_KEY를 추가하거나\n' +
+      '3. 설정에서 Direct 모드로 API 키를 직접 입력하세요.'
+    );
   }
 
   async generate(
@@ -147,9 +164,21 @@ export class SkillGeneratorService {
       detail: '어떤 스킬이 필요한지 파악 중...',
     });
 
+    // CLAUDE.md 내용 읽기
+    let claudeMdContext = '';
+    const claudeMdContent = await claudeMdService.read();
+    if (claudeMdContent) {
+      claudeMdContext = `\n\n<project_context>
+The following is the project's CLAUDE.md file. Follow these guidelines when generating the skill:
+
+${claudeMdContent}
+</project_context>`;
+      console.log('Including CLAUDE.md in API context');
+    }
+
     const userPrompt = `Create a skill for: "${prompt}"
 
-Generate complete, working code. Respond with JSON only.`;
+Generate complete, working code. Respond with JSON only.${claudeMdContext}`;
 
     try {
       progress({
@@ -285,41 +314,42 @@ Generate complete, working code. Respond with JSON only.`;
     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');
+      // 로컬 프로젝트의 .venv 사용
+      const localVenvPythonPath = path.join(this.projectRoot, '.venv', 'bin', 'python');
+      const localVenvPipPath = path.join(this.projectRoot, '.venv', 'bin', 'pip');
 
       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)) {
+      if (useUv && existsSync(localVenvPythonPath)) {
         command = 'uv';
-        args = ['pip', 'install', '--python', venvPythonPath, '-r', requirementsPath];
+        args = ['pip', 'install', '--python', localVenvPythonPath, '-r', requirementsPath];
         progress({
           step: 'installing',
           message: '⚡ uv로 패키지 설치 중 (고속)',
-          detail: 'uv pip install 실행 중...',
+          detail: 'uv pip install → .venv/',
         });
-      } else if (existsSync(path.join(homeDir, '.claude', 'venv', 'bin', 'pip'))) {
-        // fallback: 전역 venv pip 사용
-        command = path.join(homeDir, '.claude', 'venv', 'bin', 'pip');
+      } else if (existsSync(localVenvPipPath)) {
+        // fallback: 로컬 venv pip 사용
+        command = localVenvPipPath;
         args = ['install', '-r', requirementsPath];
         progress({
           step: 'installing',
           message: '📦 pip으로 패키지 설치 중',
-          detail: 'pip install 실행 중...',
+          detail: 'pip install → .venv/',
         });
       } else {
-        // fallback: 시스템 pip 사용
+        // fallback: 시스템 pip 사용 (경고)
+        console.warn('Warning: .venv not found, using system pip');
         command = 'pip3';
         args = ['install', '-r', requirementsPath];
         progress({
           step: 'installing',
-          message: '📦 pip으로 패키지 설치 중',
-          detail: 'pip install 실행 중...',
+          message: '⚠️ 시스템 pip 사용 중',
+          detail: '.venv가 없어 시스템 pip 사용',
         });
       }
 

package/server/services/workflowAIService.ts

@@ -165,31 +165,39 @@ ${AVAILABLE_TOOLS.join(', ')}
 
 export class WorkflowAIService {
   private getClient(settings?: ApiSettings): Anthropic {
-    // 1. Direct mode with user-provided API key
-    if (settings?.apiMode === 'direct' && settings.apiKey) {
-      return new Anthropic({
-        apiKey: settings.apiKey,
-      });
-    }
+    const DEFAULT_ANTHROPIC_URL = 'https://api.anthropic.com';
 
-    // 2. Proxy mode with custom base URL
-    if (settings?.apiMode === 'proxy' && settings.proxyUrl) {
+    // 1. 프록시 우선: proxyUrl이 설정되어 있고, 기본 Anthropic URL이 아닌 경우
+    //    프록시 서버가 API 키를 관리하므로 클라이언트는 키 불필요
+    if (settings?.proxyUrl && settings.proxyUrl !== DEFAULT_ANTHROPIC_URL) {
+      console.log(`Using proxy server: ${settings.proxyUrl}`);
       return new Anthropic({
         baseURL: settings.proxyUrl,
-        // Proxy server handles the API key
-        apiKey: process.env.ANTHROPIC_API_KEY || 'proxy-mode',
+        apiKey: 'proxy-mode', // 프록시 서버가 실제 키를 관리
       });
     }
 
-    // 3. Default: use environment variable
+    // 2. 환경변수에 API 키가 있으면 직접 호출
     const envApiKey = process.env.ANTHROPIC_API_KEY;
-    if (!envApiKey) {
-      throw new Error('API 키가 설정되지 않았습니다. 설정에서 API 키를 입력하거나 프록시 서버를 설정하세요.');
+    if (envApiKey) {
+      console.log('Using API key from environment variable');
+      return new Anthropic({ apiKey: envApiKey });
     }
 
-    return new Anthropic({
-      apiKey: envApiKey,
-    });
+    // 3. UI에서 direct 모드로 API 키를 직접 입력한 경우
+    if (settings?.apiMode === 'direct' && settings.apiKey) {
+      console.log('Using API key from UI settings');
+      return new Anthropic({ apiKey: settings.apiKey });
+    }
+
+    // 4. 아무것도 없으면 에러
+    throw new Error(
+      'API 키가 설정되지 않았습니다.\n' +
+      '해결 방법:\n' +
+      '1. 프록시 서버 URL을 설정하거나\n' +
+      '2. 프로젝트 .env 파일에 ANTHROPIC_API_KEY를 추가하거나\n' +
+      '3. 설정에서 Direct 모드로 API 키를 직접 입력하세요.'
+    );
   }
 
   async generate(prompt: string, settings?: ApiSettings): Promise<AIWorkflowResult> {