makecc 0.2.17 → 0.2.19

package/server/services/projectService.ts

@@ -0,0 +1,424 @@
+import { promises as fs, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { nanoid } from 'nanoid';
+
+export interface Project {
+  id: string;
+  name: string;
+  description: string;
+  thumbnail?: string;
+  skillCount: number;
+  agentCount: number;
+  path: string;
+  lastModified: string;
+  createdAt: string;
+}
+
+export interface GalleryItem {
+  id: string;
+  name: string;
+  description: string;
+  thumbnail: string;
+  author: string;
+  downloads: number;
+  tags: string[];
+}
+
+// Default makecc home directory
+const MAKECC_HOME = process.env.MAKECC_HOME || join(homedir(), 'makecc');
+
+// Gallery items (static for now, could be fetched from a registry later)
+const GALLERY_ITEMS: GalleryItem[] = [
+  {
+    id: 'gmail-assistant',
+    name: 'Gmail Assistant',
+    description: 'Read, write and organize emails using Claude',
+    thumbnail: '/gallery/gmail.png',
+    author: 'makecc',
+    downloads: 1234,
+    tags: ['email', 'productivity'],
+  },
+  {
+    id: 'web-scraper',
+    name: 'Web Scraper',
+    description: 'Extract data from websites automatically',
+    thumbnail: '/gallery/scraper.png',
+    author: 'makecc',
+    downloads: 892,
+    tags: ['data', 'automation'],
+  },
+  {
+    id: 'document-analyzer',
+    name: 'Document Analyzer',
+    description: 'Analyze and summarize PDF documents',
+    thumbnail: '/gallery/docs.png',
+    author: 'makecc',
+    downloads: 567,
+    tags: ['pdf', 'analysis'],
+  },
+];
+
+class ProjectService {
+  private makeccHome: string;
+
+  constructor() {
+    this.makeccHome = MAKECC_HOME;
+  }
+
+  getMakeccHome(): string {
+    return this.makeccHome;
+  }
+
+  async ensureMakeccHome(): Promise<void> {
+    if (!existsSync(this.makeccHome)) {
+      await fs.mkdir(this.makeccHome, { recursive: true });
+      console.log(`Created makecc home directory: ${this.makeccHome}`);
+    }
+  }
+
+  async listProjects(): Promise<Project[]> {
+    await this.ensureMakeccHome();
+
+    const entries = await fs.readdir(this.makeccHome, { withFileTypes: true });
+    const projects: Project[] = [];
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith('.')) continue;
+
+      const projectPath = join(this.makeccHome, entry.name);
+      const project = await this.loadProjectInfo(projectPath, entry.name);
+      if (project) {
+        projects.push(project);
+      }
+    }
+
+    // Sort by lastModified (most recent first)
+    projects.sort((a, b) =>
+      new Date(b.lastModified).getTime() - new Date(a.lastModified).getTime()
+    );
+
+    return projects;
+  }
+
+  private async loadProjectInfo(projectPath: string, name: string): Promise<Project | null> {
+    try {
+      const stat = await fs.stat(projectPath);
+
+      // Read project.json if exists
+      const configPath = join(projectPath, 'project.json');
+      let config: { description?: string; id?: string; createdAt?: string } = {};
+
+      if (existsSync(configPath)) {
+        const content = await fs.readFile(configPath, 'utf-8');
+        config = JSON.parse(content);
+      }
+
+      // Count skills and agents
+      const claudePath = join(projectPath, '.claude');
+      let skillCount = 0;
+      let agentCount = 0;
+
+      if (existsSync(claudePath)) {
+        const skillsPath = join(claudePath, 'skills');
+        const agentsPath = join(claudePath, 'agents');
+
+        if (existsSync(skillsPath)) {
+          const skills = await fs.readdir(skillsPath, { withFileTypes: true });
+          skillCount = skills.filter(s => s.isDirectory()).length;
+        }
+
+        if (existsSync(agentsPath)) {
+          const agents = await fs.readdir(agentsPath);
+          agentCount = agents.filter(a => a.endsWith('.md')).length;
+        }
+      }
+
+      return {
+        id: config.id || name,
+        name,
+        description: config.description || '',
+        skillCount,
+        agentCount,
+        path: projectPath,
+        lastModified: stat.mtime.toISOString(),
+        createdAt: config.createdAt || stat.birthtime.toISOString(),
+      };
+    } catch (error) {
+      console.error(`Failed to load project info for ${name}:`, error);
+      return null;
+    }
+  }
+
+  async createProject(name: string, description: string): Promise<Project> {
+    await this.ensureMakeccHome();
+
+    // Sanitize project name
+    const sanitizedName = name
+      .toLowerCase()
+      .replace(/[^a-z0-9-]/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-|-$/g, '');
+
+    const projectPath = join(this.makeccHome, sanitizedName);
+
+    if (existsSync(projectPath)) {
+      throw new Error(`Project "${sanitizedName}" already exists`);
+    }
+
+    // Create project directory structure
+    await fs.mkdir(projectPath, { recursive: true });
+    await fs.mkdir(join(projectPath, '.claude', 'skills'), { recursive: true });
+    await fs.mkdir(join(projectPath, '.claude', 'agents'), { recursive: true });
+
+    // Create project.json
+    const projectId = nanoid(10);
+    const now = new Date().toISOString();
+    const config = {
+      id: projectId,
+      name: sanitizedName,
+      description,
+      createdAt: now,
+    };
+
+    await fs.writeFile(
+      join(projectPath, 'project.json'),
+      JSON.stringify(config, null, 2)
+    );
+
+    // Create CLAUDE.md
+    const claudeMd = `# ${name}
+
+${description}
+
+## Project Structure
+
+\`\`\`
+${sanitizedName}/
+├── .claude/
+│   ├── skills/      # Claude Code skills
+│   └── agents/      # Claude Code agents
+└── project.json     # Project configuration
+\`\`\`
+
+## Getting Started
+
+1. Open this project in makecc
+2. Create skills using natural language
+3. Build workflows to automate tasks
+`;
+
+    await fs.writeFile(join(projectPath, 'CLAUDE.md'), claudeMd);
+
+    return {
+      id: projectId,
+      name: sanitizedName,
+      description,
+      skillCount: 0,
+      agentCount: 0,
+      path: projectPath,
+      lastModified: now,
+      createdAt: now,
+    };
+  }
+
+  async deleteProject(projectId: string): Promise<void> {
+    const projects = await this.listProjects();
+    const project = projects.find(p => p.id === projectId || p.name === projectId);
+
+    if (!project) {
+      throw new Error(`Project "${projectId}" not found`);
+    }
+
+    // Move to trash instead of permanent delete
+    const trashPath = join(this.makeccHome, '.trash');
+    await fs.mkdir(trashPath, { recursive: true });
+
+    const trashName = `${project.name}_${Date.now()}`;
+    await fs.rename(project.path, join(trashPath, trashName));
+  }
+
+  async getProject(projectId: string): Promise<Project | null> {
+    const projects = await this.listProjects();
+    return projects.find(p => p.id === projectId || p.name === projectId) || null;
+  }
+
+  getGalleryItems(): GalleryItem[] {
+    return GALLERY_ITEMS;
+  }
+
+  async createSampleProjects(): Promise<void> {
+    await this.ensureMakeccHome();
+
+    // Check if samples already exist
+    const projects = await this.listProjects();
+    const hasGmail = projects.some(p => p.name === 'gmail-assistant');
+    const hasScraper = projects.some(p => p.name === 'web-scraper');
+
+    if (!hasGmail) {
+      await this.createGmailSampleProject();
+    }
+
+    if (!hasScraper) {
+      await this.createScraperSampleProject();
+    }
+  }
+
+  private async createGmailSampleProject(): Promise<void> {
+    const projectPath = join(this.makeccHome, 'gmail-assistant');
+    await fs.mkdir(projectPath, { recursive: true });
+    await fs.mkdir(join(projectPath, '.claude', 'skills', 'gmail'), { recursive: true });
+    await fs.mkdir(join(projectPath, '.claude', 'agents'), { recursive: true });
+
+    // project.json
+    await fs.writeFile(
+      join(projectPath, 'project.json'),
+      JSON.stringify({
+        id: 'gmail-sample',
+        name: 'gmail-assistant',
+        description: 'Read, write and organize emails using Claude',
+        createdAt: new Date().toISOString(),
+      }, null, 2)
+    );
+
+    // Sample skill: SKILL.md
+    const skillMd = `---
+name: gmail
+description: Gmail 읽기/쓰기 스킬
+---
+
+# Gmail Skill
+
+이 스킬은 Gmail API를 사용하여 이메일을 읽고 쓸 수 있게 합니다.
+
+## 사용법
+
+\`\`\`bash
+python scripts/main.py read --count 10
+python scripts/main.py send --to "user@example.com" --subject "Hello" --body "Hi there!"
+\`\`\`
+
+## 기능
+
+- 받은편지함 읽기
+- 이메일 검색
+- 이메일 작성 및 전송
+- 라벨 관리
+`;
+
+    await fs.writeFile(
+      join(projectPath, '.claude', 'skills', 'gmail', 'SKILL.md'),
+      skillMd
+    );
+
+    // Sample Python script
+    const mainPy = `#!/usr/bin/env python3
+"""Gmail skill for reading and writing emails."""
+
+import argparse
+import json
+
+def read_emails(count: int = 10):
+    """Read recent emails from inbox."""
+    print(json.dumps({
+        "status": "success",
+        "message": f"Would read {count} emails from Gmail",
+        "note": "This is a sample - configure Gmail API credentials to use"
+    }))
+
+def send_email(to: str, subject: str, body: str):
+    """Send an email."""
+    print(json.dumps({
+        "status": "success",
+        "message": f"Would send email to {to}",
+        "subject": subject,
+        "note": "This is a sample - configure Gmail API credentials to use"
+    }))
+
+def main():
+    parser = argparse.ArgumentParser(description='Gmail Skill')
+    subparsers = parser.add_subparsers(dest='command', help='Commands')
+
+    # Read command
+    read_parser = subparsers.add_parser('read', help='Read emails')
+    read_parser.add_argument('--count', type=int, default=10, help='Number of emails')
+
+    # Send command
+    send_parser = subparsers.add_parser('send', help='Send email')
+    send_parser.add_argument('--to', required=True, help='Recipient')
+    send_parser.add_argument('--subject', required=True, help='Subject')
+    send_parser.add_argument('--body', required=True, help='Body')
+
+    args = parser.parse_args()
+
+    if args.command == 'read':
+        read_emails(args.count)
+    elif args.command == 'send':
+        send_email(args.to, args.subject, args.body)
+    else:
+        parser.print_help()
+
+if __name__ == '__main__':
+    main()
+`;
+
+    await fs.mkdir(join(projectPath, '.claude', 'skills', 'gmail', 'scripts'), { recursive: true });
+    await fs.writeFile(
+      join(projectPath, '.claude', 'skills', 'gmail', 'scripts', 'main.py'),
+      mainPy
+    );
+
+    console.log('Created sample project: gmail-assistant');
+  }
+
+  private async createScraperSampleProject(): Promise<void> {
+    const projectPath = join(this.makeccHome, 'web-scraper');
+    await fs.mkdir(projectPath, { recursive: true });
+    await fs.mkdir(join(projectPath, '.claude', 'agents'), { recursive: true });
+
+    // project.json
+    await fs.writeFile(
+      join(projectPath, 'project.json'),
+      JSON.stringify({
+        id: 'scraper-sample',
+        name: 'web-scraper',
+        description: 'Extract data from websites automatically',
+        createdAt: new Date().toISOString(),
+      }, null, 2)
+    );
+
+    // Sample agent
+    const agentMd = `---
+name: web-scraper
+description: 웹 페이지에서 데이터를 추출하는 에이전트
+tools: WebFetch, Read, Write
+model: sonnet
+---
+
+# Web Scraper Agent
+
+이 에이전트는 웹 페이지에서 데이터를 추출하고 구조화합니다.
+
+## 워크플로우
+
+1. URL을 입력받습니다
+2. WebFetch로 페이지 내용을 가져옵니다
+3. 원하는 데이터를 추출합니다
+4. JSON 또는 CSV로 결과를 저장합니다
+
+## 사용 예시
+
+"https://example.com에서 모든 제품 이름과 가격을 추출해줘"
+`;
+
+    await fs.writeFile(
+      join(projectPath, '.claude', 'agents', 'web-scraper.md'),
+      agentMd
+    );
+
+    console.log('Created sample project: web-scraper');
+  }
+}
+
+export const projectService = new ProjectService();

package/server/services/skillGeneratorService.ts

@@ -42,23 +42,25 @@ export interface SkillProgressEvent {
 
 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.
+const SYSTEM_PROMPT = `You are an expert Claude Code skill generator. Generate production-quality skills with complete, working code.
 
-Your response must follow this exact JSON schema:
+RESPOND WITH ONLY A VALID JSON OBJECT - NO MARKDOWN, NO CODE BLOCKS, NO EXPLANATIONS.
+
+## JSON Schema
 
 {
-  "skillName": "Human readable skill name",
+  "skillName": "Human Readable Skill Name",
   "skillId": "skill-id-in-kebab-case",
-  "description": "Brief description of what this skill does",
+  "description": "Comprehensive description including what it does AND when to use it. Include trigger phrases in Korean. Example: 'PDF 문서에서 텍스트 추출 및 분석. \"PDF 읽어줘\", \"PDF 분석해줘\", \"PDF에서 텍스트 추출\" 등의 요청 시 사용.'",
   "files": [
     {
       "path": "SKILL.md",
-      "content": "Full SKILL.md content here",
+      "content": "Full SKILL.md content (see format below)",
       "language": "markdown"
     },
     {
       "path": "scripts/main.py",
-      "content": "Full Python script content here",
+      "content": "Full Python script (150-300 lines, production quality)",
       "language": "python"
     },
     {
@@ -69,36 +71,155 @@ Your response must follow this exact JSON schema:
   ]
 }
 
-SKILL.md must follow this format:
+## SKILL.md Format (MUST follow exactly)
+
 ---
 name: skill-id
-description: One line description
+description: Detailed description with trigger phrases. Include what it does AND specific Korean trigger phrases like "~해줘", "~만들어줘". This is the PRIMARY mechanism for skill activation.
 ---
 
 # Skill Name
 
-## When to use
-- Use case 1
-- Use case 2
+Brief description of what this skill does.
+
+## 실행 전 요구사항 (필수)
+
+List any prerequisites:
+- API keys needed (with instructions to check/request)
+- Environment setup
+- Dependencies
+
+## 빠른 시작
+
+\\\`\\\`\\\`bash
+.venv/bin/python .claude/skills/skill-id/scripts/main.py \\\\
+  --required-arg "value" \\\\
+  --output output.ext
+\\\`\\\`\\\`
+
+## 스크립트 옵션
+
+| 옵션 | 설명 | 기본값 |
+|------|------|--------|
+| \\\`--arg1\\\`, \\\`-a\\\` | Description | default |
+| \\\`--output\\\`, \\\`-o\\\` | 출력 경로 (필수) | - |
 
-## Usage
-\`\`\`bash
-.venv/bin/python .claude/skills/skill-id/scripts/main.py [args]
-\`\`\`
+## 사용 예시
 
-## Parameters
-- \`--param1\`: Description
+### 예시 1: Basic Usage
+\\\`\\\`\\\`bash
+.venv/bin/python .claude/skills/skill-id/scripts/main.py \\\\
+  --arg "value" --output result.ext
+\\\`\\\`\\\`
 
-## Example
-[Usage example]
+### 예시 2: Advanced Usage
+\\\`\\\`\\\`bash
+.venv/bin/python .claude/skills/skill-id/scripts/main.py \\\\
+  --arg "value" --advanced-option
+\\\`\\\`\\\`
 
-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 .venv/bin/python (project local virtual environment)
-5. List all required packages in requirements.txt
-6. RESPOND WITH JSON ONLY - NO OTHER TEXT`;
+## 제한사항
+
+- List any limitations or constraints
+
+## Python Script Requirements (scripts/main.py)
+
+The script MUST:
+1. Be 150-300 lines of COMPLETE, WORKING code
+2. Use argparse with --help support
+3. Include comprehensive error handling (try-except)
+4. Print Korean status messages with emoji (✅ 완료, ❌ 오류, ⏳ 처리 중)
+5. Check dependencies at startup with helpful install instructions
+6. Support common use cases with sensible defaults
+7. Include docstring with usage examples
+
+## Script Template Structure
+
+\\\`\\\`\\\`python
+#!/usr/bin/env python3
+"""
+Skill Name - Brief description
+
+Usage:
+    python main.py --arg "value" --output output.ext
+
+Examples:
+    python main.py --input data.txt --output result.txt
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+def check_dependencies():
+    """Check required packages"""
+    try:
+        import required_package
+        return True
+    except ImportError:
+        print("❌ required_package가 설치되어 있지 않습니다.")
+        print("   설치: uv pip install --python .venv/bin/python required_package")
+        return False
+
+def main_function(arg1, arg2, output_path):
+    """Main processing logic with error handling"""
+    print(f"⏳ 처리 중...")
+
+    try:
+        # Processing logic here
+        result = process(arg1, arg2)
+
+        # Save output
+        output_file = Path(output_path)
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(output_file, 'w') as f:
+            f.write(result)
+
+        print(f"✅ 완료!")
+        print(f"   파일: {output_file}")
+        return str(output_file)
+
+    except Exception as e:
+        print(f"❌ 오류 발생: {e}")
+        sys.exit(1)
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Skill description",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=\"\"\"
+예시:
+  python main.py --input data.txt --output result.txt
+  python main.py --input data.txt --output result.txt --option
+        \"\"\"
+    )
+
+    parser.add_argument("--input", "-i", required=True, help="입력 파일")
+    parser.add_argument("--output", "-o", required=True, help="출력 경로")
+    parser.add_argument("--option", action="store_true", help="옵션 설명")
+
+    args = parser.parse_args()
+
+    if not check_dependencies():
+        sys.exit(1)
+
+    main_function(args.input, args.option, args.output)
+
+if __name__ == "__main__":
+    main()
+\\\`\\\`\\\`
+
+## Critical Rules
+
+1. GENERATE COMPLETE, WORKING CODE - NO PLACEHOLDERS, NO "# TODO", NO "pass"
+2. Scripts must be 150-300 lines with real implementation
+3. Include ALL necessary imports and helper functions
+4. Use Korean for user-facing messages, English for code/logs
+5. description field MUST include Korean trigger phrases
+6. SKILL.md MUST have complete usage examples with actual commands
+7. Always include requirements.txt with specific packages needed
+8. RESPOND WITH JSON ONLY - NO OTHER TEXT`;
 
 export class SkillGeneratorService {
   private projectRoot: string;