makecc 0.2.17 → 0.2.19

package/dist/server/services/projectService.js

@@ -0,0 +1,332 @@
+import { promises as fs, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { nanoid } from 'nanoid';
+// 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 = [
+    {
+        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 {
+    makeccHome;
+    constructor() {
+        this.makeccHome = MAKECC_HOME;
+    }
+    getMakeccHome() {
+        return this.makeccHome;
+    }
+    async ensureMakeccHome() {
+        if (!existsSync(this.makeccHome)) {
+            await fs.mkdir(this.makeccHome, { recursive: true });
+            console.log(`Created makecc home directory: ${this.makeccHome}`);
+        }
+    }
+    async listProjects() {
+        await this.ensureMakeccHome();
+        const entries = await fs.readdir(this.makeccHome, { withFileTypes: true });
+        const projects = [];
+        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;
+    }
+    async loadProjectInfo(projectPath, name) {
+        try {
+            const stat = await fs.stat(projectPath);
+            // Read project.json if exists
+            const configPath = join(projectPath, 'project.json');
+            let config = {};
+            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, description) {
+        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) {
+        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) {
+        const projects = await this.listProjects();
+        return projects.find(p => p.id === projectId || p.name === projectId) || null;
+    }
+    getGalleryItems() {
+        return GALLERY_ITEMS;
+    }
+    async createSampleProjects() {
+        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();
+        }
+    }
+    async createGmailSampleProject() {
+        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');
+    }
+    async createScraperSampleProject() {
+        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/dist/server/services/skillGeneratorService.js

@@ -4,23 +4,25 @@ import * as path from 'path';
 import { existsSync } from 'fs';
 import { spawn } from 'child_process';
 import { claudeMdService } from './claudeMdService';
-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"
     },
     {
@@ -31,36 +33,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\\\` | 출력 경로 (필수) | - |
+
+## 사용 예시
+
+### 예시 1: Basic Usage
+\\\`\\\`\\\`bash
+.venv/bin/python .claude/skills/skill-id/scripts/main.py \\\\
+  --arg "value" --output result.ext
+\\\`\\\`\\\`
+
+### 예시 2: Advanced Usage
+\\\`\\\`\\\`bash
+.venv/bin/python .claude/skills/skill-id/scripts/main.py \\\\
+  --arg "value" --advanced-option
+\\\`\\\`\\\`
+
+## 제한사항
+
+- 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)
 
-## Usage
-\`\`\`bash
-.venv/bin/python .claude/skills/skill-id/scripts/main.py [args]
-\`\`\`
+    main_function(args.input, args.option, args.output)
 
-## Parameters
-- \`--param1\`: Description
+if __name__ == "__main__":
+    main()
+\\\`\\\`\\\`
 
-## Example
-[Usage example]
+## Critical Rules
 
-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`;
+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 {
     projectRoot;
     constructor(projectRoot) {