@jungjaehoon/mama-os 0.1.1

package/templates/workspace/skill-forge/agents/qa.ts

@@ -0,0 +1,313 @@
+/**
+ * Skill Forge - QA Agent
+ *
+ * 역할: 생성된 스킬 검증
+ * 모델: Haiku (빠른 체크리스트 검증)
+ *
+ * 입력: DeveloperOutput + ArchitectOutput
+ * 출력: QAOutput (체크리스트, 이슈, 권고)
+ */
+
+import { ArchitectOutput, DeveloperOutput, QAOutput, ChecklistItem, QAIssue } from '../types';
+
+// ===== QA System Prompt =====
+
+const QA_SYSTEM_PROMPT = `당신은 Skill Forge의 **QA 에이전트**입니다.
+
+## 역할
+Developer가 생성한 코드를 검증하고 품질을 보장합니다.
+
+## 체크리스트
+
+### 1. 구조 검증
+- [ ] 모든 필수 파일이 생성되었는가
+- [ ] 파일 구조가 설계와 일치하는가
+- [ ] export가 올바르게 되어있는가
+
+### 2. 코드 품질
+- [ ] TypeScript 타입이 명시되어있는가
+- [ ] 에러 핸들링이 있는가 (try-catch)
+- [ ] 적절한 주석이 있는가
+
+### 3. 기능 검증
+- [ ] 트리거가 올바르게 정의되었는가
+- [ ] 워크플로우 단계가 구현되었는가
+- [ ] 필요한 도구를 사용하는가
+
+### 4. 보안/안전
+- [ ] 하드코딩된 비밀이 없는가
+- [ ] 입력 검증이 있는가
+- [ ] 에러 메시지가 안전한가
+
+## 출력 형식 (JSON)
+{
+  "passed": true/false,
+  "checklist": [
+    {"item": "검사 항목", "passed": true/false, "note": "선택적 설명"}
+  ],
+  "issues": [
+    {"severity": "critical|warning|suggestion", "description": "설명", "location": "파일:라인"}
+  ],
+  "recommendation": "approve|revise|reject"
+}
+
+JSON만 출력하세요.`;
+
+// ===== QA Agent Class =====
+
+export class QAAgent {
+  private systemPrompt: string;
+
+  constructor() {
+    this.systemPrompt = QA_SYSTEM_PROMPT;
+  }
+
+  /**
+   * Developer 출력을 검증합니다
+   */
+  async verify(
+    developerOutput: DeveloperOutput,
+    architectOutput: ArchitectOutput
+  ): Promise<QAOutput> {
+    const userPrompt = this.buildUserPrompt(developerOutput, architectOutput);
+    const response = await this.callClaude(userPrompt);
+    return this.parseResponse(response);
+  }
+
+  private buildUserPrompt(dev: DeveloperOutput, arch: ArchitectOutput): string {
+    return `## Architect 설계
+
+\`\`\`json
+${JSON.stringify(arch, null, 2)}
+\`\`\`
+
+## Developer 출력
+
+### 생성된 파일들
+${dev.files
+  .map(
+    (f) => `#### ${f.path}
+\`\`\`${f.language}
+${f.content}
+\`\`\``
+  )
+  .join('\n\n')}
+
+### 설치 지침
+${dev.installInstructions.join('\n') || '없음'}
+
+### 테스트 명령
+${dev.testCommands.join('\n') || '없음'}
+
+---
+
+위 코드를 체크리스트에 따라 검증하세요.`;
+  }
+
+  private async callClaude(userPrompt: string): Promise<string> {
+    // TODO: 실제 Claude API 호출 (Phase 3)
+    const output = this.runChecklist(userPrompt);
+    return JSON.stringify(output);
+  }
+
+  private parseResponse(response: string): QAOutput {
+    try {
+      let jsonStr = response;
+      const jsonMatch = response.match(/\`\`\`(?:json)?\s*([\s\S]*?)\`\`\`/);
+      if (jsonMatch) {
+        jsonStr = jsonMatch[1];
+      }
+      const parsed = JSON.parse(jsonStr.trim());
+      return {
+        passed: parsed.passed ?? false,
+        checklist: parsed.checklist || [],
+        issues: parsed.issues || [],
+        recommendation: parsed.recommendation || 'revise',
+      };
+    } catch (error) {
+      console.error('[QAAgent] JSON parse error:', error);
+      throw new Error(`QA 응답 파싱 실패: ${error}`);
+    }
+  }
+
+  // ===== Checklist Runner (Local) =====
+
+  private runChecklist(userPrompt: string): QAOutput {
+    const checklist: ChecklistItem[] = [];
+    const issues: QAIssue[] = [];
+
+    // 파일 추출
+    const fileMatches = userPrompt.matchAll(/#### ([\w\-\/\.]+)\n\`\`\`(\w+)\n([\s\S]*?)\`\`\`/g);
+    const files: Array<{ path: string; lang: string; content: string }> = [];
+
+    for (const match of fileMatches) {
+      files.push({ path: match[1], lang: match[2], content: match[3] });
+    }
+
+    // 1. 구조 검증
+    checklist.push({
+      item: '필수 파일 생성됨',
+      passed: files.length >= 2,
+      note: `${files.length}개 파일`,
+    });
+
+    const hasIndex = files.some((f) => f.path.includes('index.ts'));
+    checklist.push({
+      item: 'index.ts 존재',
+      passed: hasIndex,
+    });
+
+    const hasTypes = files.some((f) => f.path.includes('types.ts'));
+    checklist.push({
+      item: 'types.ts 존재',
+      passed: hasTypes,
+    });
+
+    // 2. 코드 품질
+    const indexFile = files.find((f) => f.path.includes('index.ts'));
+    if (indexFile) {
+      const hasExport = indexFile.content.includes('export');
+      checklist.push({
+        item: 'export 문 존재',
+        passed: hasExport,
+      });
+
+      const hasTryCatch = indexFile.content.includes('try') && indexFile.content.includes('catch');
+      checklist.push({
+        item: '에러 핸들링 (try-catch)',
+        passed: hasTryCatch,
+      });
+
+      const hasTypeAnnotation = indexFile.content.includes(': ') || indexFile.content.includes('<');
+      checklist.push({
+        item: '타입 어노테이션',
+        passed: hasTypeAnnotation,
+      });
+
+      // 보안 체크
+      const hasHardcodedSecrets = /api[_-]?key|password|secret/i.test(indexFile.content);
+      if (hasHardcodedSecrets) {
+        issues.push({
+          severity: 'warning',
+          description: '하드코딩된 비밀 키워드 발견',
+          location: indexFile.path,
+        });
+      }
+      checklist.push({
+        item: '하드코딩 비밀 없음',
+        passed: !hasHardcodedSecrets,
+      });
+    }
+
+    // 3. 트리거 검증
+    const hasTriggers = files.some((f) => f.content.includes('triggers'));
+    checklist.push({
+      item: '트리거 정의됨',
+      passed: hasTriggers,
+    });
+
+    // 4. README 체크
+    const hasReadme = files.some((f) => f.path.includes('README'));
+    checklist.push({
+      item: 'README 존재',
+      passed: hasReadme,
+    });
+
+    // 결과 계산
+    const passedCount = checklist.filter((c) => c.passed).length;
+    const totalCount = checklist.length;
+    const passRate = passedCount / totalCount;
+
+    const criticalIssues = issues.filter((i) => i.severity === 'critical').length;
+
+    let recommendation: 'approve' | 'revise' | 'reject';
+    if (criticalIssues > 0) {
+      recommendation = 'reject';
+    } else if (passRate >= 0.8) {
+      recommendation = 'approve';
+    } else {
+      recommendation = 'revise';
+    }
+
+    return {
+      passed: passRate >= 0.8 && criticalIssues === 0,
+      checklist,
+      issues,
+      recommendation,
+    };
+  }
+}
+
+// ===== Factory =====
+
+export function createQAAgent(): QAAgent {
+  return new QAAgent();
+}
+
+// ===== Test =====
+
+async function runTest() {
+  console.log('🔍 QA Agent Test\n');
+
+  const agent = createQAAgent();
+
+  const devOutput: DeveloperOutput = {
+    files: [
+      {
+        path: 'skills/code-review/index.ts',
+        language: 'typescript',
+        content: `export const skill = {
+  name: 'code-review',
+  triggers: ['/review'],
+  async execute(ctx: any) {
+    try {
+      return { success: true };
+    } catch (e) {
+      return { success: false };
+    }
+  }
+};`,
+      },
+      {
+        path: 'skills/code-review/types.ts',
+        language: 'typescript',
+        content: `export interface SkillContext { input: string; }`,
+      },
+      {
+        path: 'skills/code-review/README.md',
+        language: 'markdown',
+        content: `# code-review\n\nCode review skill.`,
+      },
+    ],
+    installInstructions: [],
+    testCommands: ['npx tsx skills/code-review/index.ts'],
+  };
+
+  const archOutput: ArchitectOutput = {
+    skillName: 'code-review',
+    purpose: '코드 리뷰',
+    triggers: ['/review'],
+    workflow: [{ step: 1, action: 'analyze', description: '분석' }],
+    fileStructure: [],
+    toolsRequired: [],
+    estimatedComplexity: 'simple',
+  };
+
+  const output = await agent.verify(devOutput, archOutput);
+  console.log('✅ QA Result:\n');
+  console.log(`Passed: ${output.passed}`);
+  console.log(`Recommendation: ${output.recommendation}`);
+  console.log(`\nChecklist:`);
+  output.checklist.forEach((c) => {
+    console.log(`  ${c.passed ? '✅' : '❌'} ${c.item}${c.note ? ` (${c.note})` : ''}`);
+  });
+  if (output.issues.length > 0) {
+    console.log(`\nIssues:`);
+    output.issues.forEach((i) => console.log(`  ⚠️ [${i.severity}] ${i.description}`));
+  }
+}
+
+const isMainModule = import.meta.url === `file://${process.argv[1]}`;
+if (isMainModule) {
+  runTest();
+}

package/templates/workspace/skill-forge/claude-api.ts

@@ -0,0 +1,353 @@
+/**
+ * Skill Forge - Claude API Integration
+ *
+ * 실제 Claude API 연동으로 각 에이전트 실행
+ * 환경변수: ANTHROPIC_API_KEY
+ */
+
+import { AgentModel, ArchitectOutput, DeveloperOutput, QAOutput, SkillRequest } from './types';
+
+// ===== API Types =====
+
+export interface ClaudeMessage {
+  role: 'user' | 'assistant';
+  content: string;
+}
+
+export interface ClaudeRequest {
+  model: string;
+  max_tokens: number;
+  system?: string;
+  messages: ClaudeMessage[];
+}
+
+export interface ClaudeResponse {
+  id: string;
+  type: 'message';
+  role: 'assistant';
+  content: Array<{
+    type: 'text';
+    text: string;
+  }>;
+  model: string;
+  stop_reason: string;
+  usage: {
+    input_tokens: number;
+    output_tokens: number;
+  };
+}
+
+// ===== Model Mapping =====
+
+const MODEL_MAP: Record<AgentModel, string> = {
+  sonnet: 'claude-sonnet-4-20250514',
+  opus: 'claude-sonnet-4-20250514', // Opus 미출시로 Sonnet 사용
+  haiku: 'claude-3-5-haiku-20241022',
+};
+
+// ===== API Client =====
+
+export class ClaudeAPIClient {
+  private apiKey: string;
+  private baseUrl = 'https://api.anthropic.com/v1/messages';
+
+  constructor(apiKey?: string) {
+    this.apiKey = apiKey || process.env.ANTHROPIC_API_KEY || '';
+    if (!this.apiKey) {
+      console.warn('[ClaudeAPI] No API key found - using mock mode');
+    }
+  }
+
+  async call(
+    model: AgentModel,
+    systemPrompt: string,
+    userMessage: string,
+    maxTokens: number = 4096
+  ): Promise<string> {
+    // Mock mode for testing without API key
+    if (!this.apiKey) {
+      return this.mockResponse(model, userMessage);
+    }
+
+    const request: ClaudeRequest = {
+      model: MODEL_MAP[model],
+      max_tokens: maxTokens,
+      system: systemPrompt,
+      messages: [{ role: 'user', content: userMessage }],
+    };
+
+    try {
+      const response = await fetch(this.baseUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.apiKey,
+          'anthropic-version': '2023-06-01',
+        },
+        body: JSON.stringify(request),
+      });
+
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`API error ${response.status}: ${error}`);
+      }
+
+      const data = (await response.json()) as ClaudeResponse;
+      return data.content[0]?.text || '';
+    } catch (error) {
+      console.error('[ClaudeAPI] Error:', error);
+      throw error;
+    }
+  }
+
+  private mockResponse(model: AgentModel, userMessage: string): string {
+    console.log(`[ClaudeAPI] Mock mode - ${model}`);
+    return `Mock response for ${model}`;
+  }
+}
+
+// ===== System Prompts =====
+
+export const ARCHITECT_SYSTEM_PROMPT = `You are the Architect agent in Skill Forge.
+Your role is to design the structure of a skill based on user requirements.
+
+You MUST respond with valid JSON in this exact format:
+{
+  "skillName": "skill-name-here",
+  "purpose": "One line description",
+  "triggers": ["/command", "keyword"],
+  "workflow": [
+    {"step": 1, "action": "action-name", "description": "What this step does"}
+  ],
+  "fileStructure": [
+    {"path": "skills/name/index.ts", "purpose": "Main entry point"}
+  ],
+  "toolsRequired": ["Read", "Write"],
+  "estimatedComplexity": "simple|medium|complex"
+}
+
+Be concise. Focus on practical implementation.`;
+
+export const DEVELOPER_SYSTEM_PROMPT = `You are the Developer agent in Skill Forge.
+Your role is to implement code based on the Architect's design.
+
+You MUST respond with valid JSON in this exact format:
+{
+  "files": [
+    {
+      "path": "skills/name/index.ts",
+      "content": "// Full TypeScript code here",
+      "language": "typescript"
+    }
+  ],
+  "installInstructions": ["npm install"],
+  "testCommands": ["npm test"]
+}
+
+Write clean, typed TypeScript code. Include proper error handling.`;
+
+export const QA_SYSTEM_PROMPT = `You are the QA agent in Skill Forge.
+Your role is to verify the quality of generated code.
+
+You MUST respond with valid JSON in this exact format:
+{
+  "passed": true|false,
+  "checklist": [
+    {"item": "Check description", "passed": true|false, "note": "Optional note"}
+  ],
+  "issues": [
+    {"severity": "critical|warning|suggestion", "description": "Issue description", "location": "file.ts:10"}
+  ],
+  "recommendation": "approve|revise|reject"
+}
+
+Be thorough but practical. Focus on actual issues.`;
+
+// ===== Agent API Wrappers =====
+
+export async function callArchitect(
+  client: ClaudeAPIClient,
+  request: SkillRequest
+): Promise<ArchitectOutput> {
+  const userMessage = `Design a skill with these requirements:
+
+Name: ${request.name}
+Description: ${request.description}
+Triggers: ${request.triggers.join(', ')}
+Capabilities: ${request.capabilities.join(', ')}
+
+Original request: ${request.rawInput}
+
+Respond with JSON only.`;
+
+  const response = await client.call('sonnet', ARCHITECT_SYSTEM_PROMPT, userMessage);
+  return parseJSON<ArchitectOutput>(response, 'Architect');
+}
+
+export async function callDeveloper(
+  client: ClaudeAPIClient,
+  architectOutput: ArchitectOutput,
+  request: SkillRequest
+): Promise<DeveloperOutput> {
+  const userMessage = `Implement this skill design:
+
+${JSON.stringify(architectOutput, null, 2)}
+
+Original request: ${request.rawInput}
+
+Create all files specified in fileStructure. Respond with JSON only.`;
+
+  const response = await client.call('sonnet', DEVELOPER_SYSTEM_PROMPT, userMessage, 8192);
+  return parseJSON<DeveloperOutput>(response, 'Developer');
+}
+
+export async function callQA(
+  client: ClaudeAPIClient,
+  developerOutput: DeveloperOutput,
+  architectOutput: ArchitectOutput
+): Promise<QAOutput> {
+  const userMessage = `Verify this implementation:
+
+## Architect Design
+${JSON.stringify(architectOutput, null, 2)}
+
+## Developer Output
+${JSON.stringify(developerOutput, null, 2)}
+
+Check for:
+1. All files from design are implemented
+2. Code is valid TypeScript
+3. Error handling exists
+4. Workflow is followed
+5. Types are properly defined
+
+Respond with JSON only.`;
+
+  const response = await client.call('haiku', QA_SYSTEM_PROMPT, userMessage);
+  return parseJSON<QAOutput>(response, 'QA');
+}
+
+// ===== JSON Parser =====
+
+function parseJSON<T>(response: string, agentName: string): T {
+  // Extract JSON from response (handle markdown code blocks)
+  let jsonStr = response;
+
+  // Remove markdown code block if present
+  const jsonMatch = response.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  if (jsonMatch) {
+    jsonStr = jsonMatch[1];
+  }
+
+  // Try to find JSON object
+  const objectMatch = jsonStr.match(/\{[\s\S]*\}/);
+  if (objectMatch) {
+    jsonStr = objectMatch[0];
+  }
+
+  try {
+    return JSON.parse(jsonStr) as T;
+  } catch (error) {
+    console.error(`[${agentName}] Failed to parse JSON:`, jsonStr.slice(0, 200));
+    throw new Error(`${agentName} returned invalid JSON`);
+  }
+}
+
+// ===== Integration with Agents =====
+
+export function createAPIArchitectAgent(client: ClaudeAPIClient) {
+  return {
+    async design(request: SkillRequest): Promise<ArchitectOutput> {
+      console.log('[Architect] Calling Claude API...');
+      const output = await callArchitect(client, request);
+      console.log('[Architect] Design complete:', output.skillName);
+      return output;
+    },
+  };
+}
+
+export function createAPIDeveloperAgent(client: ClaudeAPIClient) {
+  return {
+    async develop(
+      architectOutput: ArchitectOutput,
+      request: SkillRequest
+    ): Promise<DeveloperOutput> {
+      console.log('[Developer] Calling Claude API...');
+      const output = await callDeveloper(client, architectOutput, request);
+      console.log('[Developer] Generated', output.files.length, 'files');
+      return output;
+    },
+  };
+}
+
+export function createAPIQAAgent(client: ClaudeAPIClient) {
+  return {
+    async verify(
+      developerOutput: DeveloperOutput,
+      architectOutput: ArchitectOutput
+    ): Promise<QAOutput> {
+      console.log('[QA] Calling Claude API...');
+      const output = await callQA(client, developerOutput, architectOutput);
+      console.log('[QA] Result:', output.passed ? 'PASSED' : 'FAILED');
+      return output;
+    },
+  };
+}
+
+// ===== Test =====
+
+async function runTest() {
+  console.log('🔌 Claude API Integration Test\n');
+
+  const client = new ClaudeAPIClient();
+
+  const testRequest: SkillRequest = {
+    name: 'weather-check',
+    description: '날씨 정보를 조회하는 스킬',
+    triggers: ['/weather', '날씨'],
+    capabilities: ['현재 날씨 조회', '지역별 날씨'],
+    rawInput: '/forge weather-check - 날씨 정보 조회',
+  };
+
+  if (!process.env.ANTHROPIC_API_KEY) {
+    console.log('⚠️  ANTHROPIC_API_KEY not set - using mock mode\n');
+
+    // Mock test
+    const architect = createAPIArchitectAgent(client);
+    console.log('Testing mock architect...');
+
+    // In mock mode, this will fail with invalid JSON
+    // That's expected behavior
+    console.log('Mock mode active - API calls will return placeholder text');
+    console.log('\n✅ Test setup complete (set ANTHROPIC_API_KEY for real API test)');
+    return;
+  }
+
+  console.log('🔑 API key found - running real API test\n');
+
+  try {
+    // Test Architect
+    console.log('=== Architect ===');
+    const architectOutput = await callArchitect(client, testRequest);
+    console.log(JSON.stringify(architectOutput, null, 2));
+
+    // Test Developer
+    console.log('\n=== Developer ===');
+    const developerOutput = await callDeveloper(client, architectOutput, testRequest);
+    console.log(`Generated ${developerOutput.files.length} files`);
+
+    // Test QA
+    console.log('\n=== QA ===');
+    const qaOutput = await callQA(client, developerOutput, architectOutput);
+    console.log(JSON.stringify(qaOutput, null, 2));
+
+    console.log('\n✅ All API tests passed');
+  } catch (error) {
+    console.error('\n❌ Test failed:', error);
+  }
+}
+
+const isMainModule = import.meta.url === `file://${process.argv[1]}`;
+if (isMainModule) {
+  runTest();
+}