📡 동적 통신 프로토콜
├── 실시간 데이터 접근
├── 양방향 통신
├── 외부 시스템 연결
└── API/데이터베이스 통합

📚 정적 지식 저장소
├── 작업별 베스트 프랙티스
├── 도메인 특화 지침
├── 템플릿과 가이드라인
└── 품질 향상 방법론

graph TD
    A[사용자 요청] --> B[Claude]
    B --> C[Skill Layer]
    B --> D[MCP Layer]
    C --> E[처리 방법론]
    D --> F[데이터 접근]
    E --> G[고품질 결과물]
    F --> G

// 개별 API 작업들
tool("github_create_issue")
tool("github_add_label")
tool("github_assign_user")
// 사용자가 3번 승인해야 함

// 통합 워크플로우
tool("github_create_issue_complete", {
    title, body, labels, assignees
})
// 한 번의 승인으로 전체 작업 완료

MCP 보안 (기술적)        Skill 보안 (콘텐츠)
├── OAuth 2.1            ├── 데이터 마스킹 규칙
├── 클라이언트 검증      ├── 개인정보 처리 가이드
├── 세션 관리            ├── 규정 준수 템플릿
└── 암호화 통신          └── 민감정보 처리 방법

my-skill/
├── SKILL.md          # 필수: 메인 지침과 메타데이터
├── REFERENCE.md      # 선택: 추가 참조 정보
├── scripts/          # 선택: 실행 가능한 코드
│   └── process.py
└── templates/        # 선택: 템플릿 파일들
    └── report.html

---
name: Project Debug Assistant
description: Enhanced debugging for TypeScript projects with common error patterns
version: 1.0.0
---

# Project Debug Assistant

## Overview
이 Skill은 TypeScript 프로젝트의 일반적인 디버깅 패턴을 지원합니다.

## 디버깅 전략
1. 타입 에러 우선 확인
2. 비동기 처리 검증
3. 의존성 충돌 검사

## 프로젝트별 가이드라인
- src/api/: REST API 엔드포인트
- src/utils/: 유틸리티 함수
- tests/: 테스트 파일

Settings > Capabilities > Skills > Upload skill
→ ZIP 파일 업로드
→ Code execution 활성화 확인
→ Skill 토글 ON

from anthropic import Anthropic
from anthropic.lib import files_from_dir

client = Anthropic(api_key="your-key")

# Skill 생성
skill = client.beta.skills.create(
    display_title="Debug Assistant",
    files=files_from_dir("/path/to/skill"),
    betas=["skills-2025-10-02"]
)

# 사용
response = client.beta.messages.create(
    model="claude-opus-4-1-20250805",
    container={
        "skills": [
            {"type": "custom", "skill_id": skill.id, "version": "latest"}
        ]
    },
    messages=[{"role": "user", "content": "Debug my code"}],
    tools=[{"type": "code_execution_20250825"}]
)

# Marketplace에서 설치
/plugin marketplace add anthropics/skills

# 로컬 디렉토리에서 설치
/plugin add /path/to/skill-directory

# Git 저장소에서 설치
/plugin add https://github.com/user/skill-repo

// VSCode Extension → Skill 자동 생성
export async function activate(context: vscode.ExtensionContext) {
    // MCP 서버 초기화
    initializeMCPServer();

    // Skill 자동 생성
    await generateDebugSkill(context);

    // API 통합 (선택적)
    await integrateWithClaudeAPI(context);
}

async function generateDebugSkill(context: ExtensionContext) {
    const skillsDir = path.join(os.homedir(), '.claude-skills', 'debug');

    // SKILL.md 생성
    const content = generateSkillContent();
    await fs.writeFile(path.join(skillsDir, 'SKILL.md'), content);

    // 사용자 알림
    vscode.window.showInformationMessage(
        `Skill 생성 완료: ${skillsDir}`
    );
}

class DynamicSkillProvider {
    generateContextualSkill(): string {
        const activeBreakpoints = this.getActiveBreakpoints();
        const recentErrors = this.getRecentErrors();

        return `---
name: Dynamic Debug Context
description: Real-time debugging context
---

# 현재 디버깅 상태

## 활성 Breakpoints
${activeBreakpoints.map(formatBreakpoint).join('\n')}

## 최근 에러 패턴
${recentErrors.map(formatError).join('\n')}
`;
    }
}

class ClaudeIntegration {
    async setupAutoSkill(apiKey: string) {
        const client = new AnthropicClient({ apiKey });

        // Skill 자동 등록
        const skill = await client.beta.skills.create({
            display_title: "VSCode Debug Tools",
            files: this.prepareSkillFiles(),
            betas: ["skills-2025-10-02"]
        });

        return skill.id;
    }
}

class SkillVersionManager {
    async syncVersion(context: ExtensionContext) {
        const extensionVersion = context.extension.packageJSON.version;
        const skillVersion = context.globalState.get('skillVersion');

        if (extensionVersion !== skillVersion) {
            await this.updateSkill(extensionVersion);
            await context.globalState.update('skillVersion', extensionVersion);
        }
    }
}

class DebugPatternCollector {
    private patterns = new Map<string, PatternStats>();

    collectEvent(event: DebugEvent) {
        // 1. 이벤트 데이터 수집
        const data = {
            timestamp: Date.now(),
            errorType: this.classifyError(event),
            fileType: this.extractFileType(event),
            stackDepth: event.stackFrames?.length,
            resolution: event.resolution
        };

        // 2. 패턴 빈도 업데이트
        this.updatePatternFrequency(data);

        // 3. 임계값 도달시 Skill 업데이트
        if (this.shouldUpdateSkill()) {
            this.triggerSkillUpdate();
        }
    }
}

class PatternAnalyzer {
    analyzePatterns(events: DebugEvent[]): PatternInsights {
        return {
            // 통계적 분석
            mostFrequentErrors: this.getTopErrors(events, 5),
            averageResolutionTime: this.calculateAvgTime(events),
            problemFiles: this.identifyProblematicFiles(events),

            // 상관관계 분석
            correlations: {
                fileTypeToError: this.correlateFileTypeErrors(events),
                timeToError: this.correlateTimePatterns(events),
                stackDepthToComplexity: this.analyzeStackPatterns(events)
            }
        };
    }
}

class SkillEvolution {
    generateEvolvedSkill(patterns: PatternInsights): string {
        return `---
name: Project Intelligence
description: Auto-learned from ${patterns.totalSessions} debug sessions
---

# 프로젝트 디버깅 인텔리전스

## 통계 기반 인사이트
- 가장 빈번한 에러: ${patterns.mostFrequentErrors[0].type} (${patterns.mostFrequentErrors[0].count}회)
- 평균 해결 시간: ${patterns.averageResolutionTime}분
- 문제 다발 파일: ${patterns.problemFiles.join(', ')}

## 패턴 기반 전략
${this.generateStrategies(patterns)}

## 프로젝트별 특성
${this.generateProjectSpecificGuide(patterns)}
`;
    }
}

class FeedbackSystem {
    // Claude의 제안 효과성 추적
    trackEffectiveness(suggestion: Suggestion, outcome: Outcome) {
        const score = this.calculateScore(outcome);

        if (score > 0.7) {
            // 효과적인 패턴 강화
            this.reinforcePattern(suggestion.pattern);
        } else if (score < 0.3) {
            // 비효과적 패턴 수정
            this.revisePattern(suggestion.pattern);
        }

        // Skill 실시간 업데이트
        this.updateSkillWithFeedback();
    }
}

class SkillAutoUpdater {
    constructor(private context: vscode.ExtensionContext) {
        // 주기적 업데이트 (24시간)
        setInterval(() => this.updateSkill(), 24 * 60 * 60 * 1000);

        // 중요 이벤트시 즉시 업데이트
        vscode.debug.onDidTerminateDebugSession(() => {
            if (this.hasSignificantChange()) {
                this.updateSkill();
            }
        });
    }

    async updateSkill() {
        const patterns = await this.collectPatterns();
        const newSkill = this.generateSkill(patterns);
        await this.saveSkill(newSkill);

        vscode.window.showInformationMessage(
            'Debug Skill이 최신 패턴으로 업데이트되었습니다'
        );
    }
}

VSCode Extension (HTTP Server:8890)
    ↓
CLI Tool (MCP Client/Server)
    ↓
AI Tools (Cursor, Claude)

VSCode Extension
├── MCP Server (디버깅 기능)
├── Pattern Collector (패턴 수집)
└── Skill Generator (자동 생성)
    ↓
Claude (Skill 사용)
├── 정적 지침 (Skill)
└── 동적 작업 (MCP)

// extension.ts
export class MCPDebugToolsWithSkills {
    private mpcServer: MCPServer;
    private patternCollector: PatternCollector;
    private skillGenerator: SkillGenerator;

    async activate(context: vscode.ExtensionContext) {
        // 1. MCP 서버 시작
        this.mpcServer = new MCPServer(8890);
        await this.mpcServer.start();

        // 2. 패턴 수집 시작
        this.patternCollector = new PatternCollector();
        this.patternCollector.startCollecting();

        // 3. 초기 Skill 생성
        const initialSkill = await this.generateInitialSkill();
        await this.deploySkill(initialSkill);

        // 4. 자동 업데이트 설정
        this.setupAutoUpdate(context);
    }

    private async generateInitialSkill(): Promise<Skill> {
        return {
            name: "VSCode Debug Assistant",
            description: "MCP Debug Tools 통합 디버깅 어시스턴트",
            content: `
# VSCode 디버깅 어시스턴트

## MCP Debug Tools 연동
- add-breakpoint: 중단점 추가
- inspect-variable: 변수 검사
- step-into/over/out: 단계별 실행

## 디버깅 전략
1. 이진 탐색으로 문제 영역 좁히기
2. 의심 함수 시작/끝에 중단점 설정
3. 변수 값 변화 추적

## 프로젝트별 패턴
(자동으로 업데이트됨)
`
        };
    }
}