@jungjaehoon/mama-os 0.1.1

package/templates/workspace/skill-forge/orchestrator.ts

@@ -0,0 +1,495 @@
+/**
+ * Skill Forge - Orchestrator
+ *
+ * 멀티 에이전트 조율: Architect → Developer → QA
+ * 각 단계 사이 5초 카운트다운으로 유저 검토 기회 제공
+ */
+
+import {
+  SessionState,
+  SessionPhase,
+  SkillRequest,
+  OrchestratorEvent,
+  DiscordAction,
+  SkillForgeConfig,
+  DEFAULT_CONFIG,
+  ArchitectOutput,
+  DeveloperOutput,
+  QAOutput,
+} from './types';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+import { randomUUID } from 'crypto';
+import { createArchitectAgent } from './agents/architect';
+import { createDeveloperAgent } from './agents/developer';
+import { createQAAgent } from './agents/qa';
+import { ErrorHandler, createError, SkillForgeError, rollbackStrategy } from './error-handler';
+import { createMockMAMAIntegration, MAMAIntegration } from './mama-integration';
+
+export class Orchestrator {
+  private state: SessionState | null = null;
+  private config: SkillForgeConfig;
+  private eventHandlers: ((event: OrchestratorEvent) => void)[] = [];
+  private countdownTimer: NodeJS.Timeout | null = null;
+  private errorHandler: ErrorHandler;
+  private mama: MAMAIntegration;
+
+  constructor(config: Partial<SkillForgeConfig> = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.errorHandler = new ErrorHandler({
+      maxRetries: 3,
+      retryDelayMs: 1000,
+      onError: (err) => this.emit({ type: 'ERROR', error: err.userMessage }),
+    });
+    this.mama = createMockMAMAIntegration();
+  }
+
+  // ===== Event System =====
+
+  onEvent(handler: (event: OrchestratorEvent) => void): void {
+    this.eventHandlers.push(handler);
+  }
+
+  private emit(event: OrchestratorEvent): void {
+    for (const handler of this.eventHandlers) {
+      try {
+        handler(event);
+      } catch (error) {
+        console.error('[Orchestrator] Event handler error:', error);
+      }
+    }
+  }
+
+  // ===== Session Management =====
+
+  async startSession(request: SkillRequest): Promise<SessionState> {
+    this.state = {
+      id: randomUUID(),
+      phase: 'idle',
+      request,
+      artifacts: {},
+      countdown: null,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+
+    this.emit({ type: 'REQUEST_RECEIVED', request });
+    this.saveState();
+
+    await this.transitionTo('architect');
+    return this.state;
+  }
+
+  getState(): SessionState | null {
+    return this.state;
+  }
+
+  // ===== Phase Transitions =====
+
+  private async transitionTo(phase: SessionPhase): Promise<void> {
+    if (!this.state) {
+      throw new Error('No active session');
+    }
+
+    this.state.phase = phase;
+    this.state.updatedAt = new Date().toISOString();
+    this.saveState();
+
+    switch (phase) {
+      case 'architect':
+        await this.runArchitect();
+        break;
+      case 'architect_review':
+        this.startCountdown('architect_review');
+        break;
+      case 'developer':
+        await this.runDeveloper();
+        break;
+      case 'developer_review':
+        this.startCountdown('developer_review');
+        break;
+      case 'qa':
+        await this.runQA();
+        break;
+      case 'qa_review':
+        this.startCountdown('qa_review');
+        break;
+      case 'completed':
+        this.emit({ type: 'SESSION_COMPLETE', success: true });
+        await this.saveGeneratedFiles();
+        // MAMA 연동: decision 저장
+        await this.saveToMAMA();
+        break;
+      case 'cancelled':
+        this.emit({ type: 'SESSION_COMPLETE', success: false });
+        break;
+    }
+  }
+
+  // ===== Agent Execution =====
+
+  private async runArchitect(): Promise<void> {
+    this.emit({ type: 'AGENT_START', agent: 'architect' });
+
+    try {
+      const output = await this.errorHandler.handle(
+        'architect',
+        async () => {
+          const architect = createArchitectAgent();
+          return architect.design(this.state!.request);
+        },
+        { phase: 'architect' }
+      );
+
+      this.state!.artifacts.architectOutput = output;
+      this.emit({ type: 'AGENT_COMPLETE', agent: 'architect', output });
+
+      await this.transitionTo('architect_review');
+    } catch (error) {
+      await this.handleAgentError(error as SkillForgeError, 'architect');
+    }
+  }
+
+  private async runDeveloper(): Promise<void> {
+    this.emit({ type: 'AGENT_START', agent: 'developer' });
+
+    try {
+      const architectOutput = this.state!.artifacts.architectOutput;
+      if (!architectOutput) {
+        throw createError('STATE_ERROR', 'Architect output not found', { phase: 'developer' });
+      }
+
+      const output = await this.errorHandler.handle(
+        'developer',
+        async () => {
+          const developer = createDeveloperAgent();
+          return developer.develop(architectOutput, this.state!.request);
+        },
+        { phase: 'developer' }
+      );
+
+      this.state!.artifacts.developerOutput = output;
+      this.emit({ type: 'AGENT_COMPLETE', agent: 'developer', output });
+
+      await this.transitionTo('developer_review');
+    } catch (error) {
+      await this.handleAgentError(error as SkillForgeError, 'developer');
+    }
+  }
+
+  private async runQA(): Promise<void> {
+    this.emit({ type: 'AGENT_START', agent: 'qa' });
+
+    try {
+      const architectOutput = this.state!.artifacts.architectOutput;
+      const developerOutput = this.state!.artifacts.developerOutput;
+
+      if (!architectOutput || !developerOutput) {
+        throw createError('STATE_ERROR', 'Previous outputs not found', { phase: 'qa' });
+      }
+
+      const output = await this.errorHandler.handle(
+        'qa',
+        async () => {
+          const qa = createQAAgent();
+          return qa.verify(developerOutput, architectOutput);
+        },
+        { phase: 'qa' }
+      );
+
+      this.state!.artifacts.qaOutput = output;
+      this.emit({ type: 'AGENT_COMPLETE', agent: 'qa', output });
+
+      await this.transitionTo('qa_review');
+    } catch (error) {
+      await this.handleAgentError(error as SkillForgeError, 'qa');
+    }
+  }
+
+  // ===== Error Recovery =====
+
+  private async handleAgentError(error: SkillForgeError, agent: string): Promise<void> {
+    console.error(`[Orchestrator] ${agent} failed:`, error.message);
+
+    // Try recovery
+    if (rollbackStrategy.canRecover(error, this.state!)) {
+      this.state = rollbackStrategy.recover(error, this.state!);
+      this.saveState();
+      this.emit({ type: 'ERROR', error: `${error.userMessage} (롤백됨)` });
+    } else {
+      // Cannot recover - cancel session
+      await this.transitionTo('cancelled');
+    }
+  }
+
+  // ===== MAMA Integration =====
+
+  private async saveToMAMA(): Promise<void> {
+    if (!this.state) return;
+
+    try {
+      await this.mama.saveDecision(this.state);
+      console.log('[Orchestrator] Saved decision to MAMA');
+    } catch (error) {
+      console.error('[Orchestrator] Failed to save to MAMA:', error);
+      // Non-critical - don't fail the session
+    }
+  }
+
+  // ===== File Generation =====
+
+  private async saveGeneratedFiles(): Promise<void> {
+    const developerOutput = this.state?.artifacts.developerOutput;
+    if (!developerOutput || !developerOutput.files) return;
+
+    const outputDir = this.config.outputDir.replace('~', process.env.HOME || '');
+
+    for (const file of developerOutput.files) {
+      const fullPath = `${outputDir}/${file.path}`;
+      const dir = dirname(fullPath);
+
+      // 디렉토리 생성
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+
+      writeFileSync(fullPath, file.content);
+      console.log(`[Orchestrator] Saved: ${fullPath}`);
+    }
+  }
+
+  // ===== Countdown System =====
+
+  private startCountdown(phase: SessionPhase): void {
+    this.emit({ type: 'COUNTDOWN_START', phase });
+
+    this.state!.countdown = {
+      startedAt: new Date().toISOString(),
+      durationMs: this.config.countdownMs,
+    };
+    this.saveState();
+
+    this.countdownTimer = setTimeout(() => {
+      this.onCountdownExpire();
+    }, this.config.countdownMs);
+  }
+
+  private stopCountdown(): void {
+    if (this.countdownTimer) {
+      clearTimeout(this.countdownTimer);
+      this.countdownTimer = null;
+    }
+    if (this.state) {
+      this.state.countdown = null;
+    }
+  }
+
+  private async onCountdownExpire(): Promise<void> {
+    this.emit({ type: 'COUNTDOWN_EXPIRE' });
+    this.stopCountdown();
+
+    const nextPhase = this.getNextPhase();
+    if (nextPhase) {
+      await this.transitionTo(nextPhase);
+    }
+  }
+
+  private getNextPhase(): SessionPhase | null {
+    if (!this.state) return null;
+
+    const transitions: Partial<Record<SessionPhase, SessionPhase>> = {
+      architect_review: 'developer',
+      developer_review: 'qa',
+      qa_review: 'completed',
+    };
+
+    return transitions[this.state.phase] || null;
+  }
+
+  // ===== User Actions =====
+
+  async handleUserAction(action: DiscordAction): Promise<void> {
+    if (!this.state) {
+      throw new Error('No active session');
+    }
+
+    this.emit({ type: 'USER_ACTION', action });
+    this.stopCountdown();
+
+    switch (action.type) {
+      case 'approve':
+        const nextPhase = this.getNextPhase();
+        if (nextPhase) {
+          await this.transitionTo(nextPhase);
+        }
+        break;
+
+      case 'revise':
+        await this.retryCurrentPhase();
+        break;
+
+      case 'cancel':
+        await this.transitionTo('cancelled');
+        break;
+
+      case 'extend':
+        this.startCountdown(this.state.phase);
+        break;
+    }
+  }
+
+  private async retryCurrentPhase(): Promise<void> {
+    if (!this.state) return;
+
+    const retryMap: Partial<Record<SessionPhase, SessionPhase>> = {
+      architect_review: 'architect',
+      developer_review: 'developer',
+      qa_review: 'qa',
+    };
+
+    const retryPhase = retryMap[this.state.phase];
+    if (retryPhase) {
+      await this.transitionTo(retryPhase);
+    }
+  }
+
+  // ===== State Persistence =====
+
+  private saveState(): void {
+    if (!this.state) return;
+
+    const statePath = this.config.stateFile.replace('~', process.env.HOME || '');
+    const dir = dirname(statePath);
+
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+
+    writeFileSync(statePath, JSON.stringify(this.state, null, 2));
+  }
+
+  loadState(): SessionState | null {
+    const statePath = this.config.stateFile.replace('~', process.env.HOME || '');
+
+    if (!existsSync(statePath)) {
+      return null;
+    }
+
+    try {
+      const data = readFileSync(statePath, 'utf-8');
+      this.state = JSON.parse(data);
+      return this.state;
+    } catch {
+      return null;
+    }
+  }
+
+  // ===== Debug / Info =====
+
+  getPhaseDescription(phase: SessionPhase): string {
+    const descriptions: Record<SessionPhase, string> = {
+      idle: '⏸️ 대기 중',
+      architect: '🏗️ Architect가 구조를 설계 중...',
+      architect_review: '👀 구조 검토 중 (5초 카운트다운)',
+      developer: '💻 Developer가 코드 작성 중...',
+      developer_review: '👀 코드 검토 중 (5초 카운트다운)',
+      qa: '🔍 QA가 검증 중...',
+      qa_review: '👀 검증 결과 검토 중 (5초 카운트다운)',
+      completed: '✅ 완료!',
+      cancelled: '❌ 취소됨',
+    };
+    return descriptions[phase];
+  }
+
+  // ===== Summary =====
+
+  getSummary(): string {
+    if (!this.state) return '세션 없음';
+
+    const arch = this.state.artifacts.architectOutput;
+    const dev = this.state.artifacts.developerOutput;
+    const qa = this.state.artifacts.qaOutput;
+
+    let summary = `## Skill Forge 결과\n\n`;
+    summary += `**스킬명:** ${this.state.request.name}\n`;
+    summary += `**상태:** ${this.getPhaseDescription(this.state.phase)}\n\n`;
+
+    if (arch) {
+      summary += `### 🏗️ Architect\n`;
+      summary += `- 목적: ${arch.purpose}\n`;
+      summary += `- 복잡도: ${arch.estimatedComplexity}\n`;
+      summary += `- 워크플로우: ${arch.workflow.length}단계\n\n`;
+    }
+
+    if (dev) {
+      summary += `### 💻 Developer\n`;
+      summary += `- 생성 파일: ${dev.files.length}개\n`;
+      dev.files.forEach((f) => {
+        summary += `  - ${f.path}\n`;
+      });
+      summary += `\n`;
+    }
+
+    if (qa) {
+      summary += `### 🔍 QA\n`;
+      summary += `- 통과: ${qa.passed ? '✅' : '❌'}\n`;
+      summary += `- 권고: ${qa.recommendation}\n`;
+      summary += `- 체크리스트: ${qa.checklist.filter((c) => c.passed).length}/${qa.checklist.length}\n`;
+    }
+
+    return summary;
+  }
+}
+
+// ===== Factory =====
+
+export function createOrchestrator(config?: Partial<SkillForgeConfig>): Orchestrator {
+  return new Orchestrator(config);
+}
+
+// ===== Test CLI =====
+
+async function runTest() {
+  console.log('🔥 Skill Forge - Full Pipeline Test\n');
+
+  const orchestrator = createOrchestrator({
+    countdownMs: 2000, // 테스트용 2초
+  });
+
+  // 이벤트 로깅
+  orchestrator.onEvent((event) => {
+    const emoji: Record<string, string> = {
+      REQUEST_RECEIVED: '📥',
+      AGENT_START: '🚀',
+      AGENT_COMPLETE: '✅',
+      COUNTDOWN_START: '⏱️',
+      COUNTDOWN_EXPIRE: '⏰',
+      SESSION_COMPLETE: '🎉',
+      ERROR: '❌',
+    };
+    console.log(`${emoji[event.type] || '•'} ${event.type}`);
+  });
+
+  try {
+    await orchestrator.startSession({
+      name: 'hello-world',
+      description: '간단한 인사 스킬',
+      triggers: ['/hello', '안녕'],
+      capabilities: ['인사하기', '이름 받기'],
+      rawInput: '/forge hello-world - 간단한 인사 스킬',
+    });
+
+    // 전체 파이프라인 완료 대기
+    await new Promise((resolve) => setTimeout(resolve, 10000));
+
+    console.log('\n' + '='.repeat(50));
+    console.log(orchestrator.getSummary());
+  } catch (err) {
+    console.error('❌ Error:', err);
+  }
+}
+
+const isMainModule = import.meta.url === `file://${process.argv[1]}`;
+if (isMainModule) {
+  runTest();
+}

package/templates/workspace/skill-forge/output/generated-skills/skills/hello-world/README.md

@@ -0,0 +1,24 @@
+# hello-world
+
+> 간단한 인사 스킬
+
+## 트리거
+
+- `/hello`
+- `안녕`
+
+## 워크플로우
+
+1. **parse**: 사용자 입력 파싱
+2. **validate**: 입력 검증
+3. **execute**: 핵심 로직 실행
+4. **format**: 결과 포맷팅
+5. **respond**: 응답 반환
+
+## 필요한 도구
+
+- discord_send
+
+---
+
+Generated by Skill Forge 🔥

package/templates/workspace/skill-forge/output/generated-skills/skills/hello-world/index.ts

@@ -0,0 +1,79 @@
+/**
+ * hello-world - 간단한 인사 스킬
+ *
+ * @triggers /hello, 안녕
+ * @complexity simple
+ */
+
+import { SkillContext, SkillResult } from './types';
+
+// ===== Skill Definition =====
+
+export const skill = {
+  name: 'hello-world',
+  description: '간단한 인사 스킬',
+  triggers: ['/hello', '안녕'],
+
+  async execute(context: SkillContext): Promise<SkillResult> {
+    try {
+      console.log('[hello-world] 시작:', context.input);
+
+      // Workflow Steps
+      // Step 1: parse - 사용자 입력 파싱
+      const step1 = await parse(context.input);
+      // Step 2: validate - 입력 검증
+      const step2 = await validate(step1);
+      // Step 3: execute - 핵심 로직 실행
+      const step3 = await execute(step2);
+      // Step 4: format - 결과 포맷팅
+      const step4 = await format(step3);
+      // Step 5: respond - 응답 반환
+      const step5 = await respond(step4);
+
+      return {
+        success: true,
+        message: String(step5),
+      };
+    } catch (error) {
+      console.error('[hello-world] 에러:', error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : '알 수 없는 에러',
+      };
+    }
+  },
+};
+
+// ===== Helper Functions =====
+
+async function parse(input: unknown): Promise<unknown> {
+  // 사용자 입력 파싱
+  console.log('[parse]', input);
+  return input;
+}
+
+async function validate(input: unknown): Promise<unknown> {
+  // 입력 검증
+  console.log('[validate]', input);
+  return input;
+}
+
+async function execute(input: unknown): Promise<unknown> {
+  // 핵심 로직 실행
+  console.log('[execute]', input);
+  return input;
+}
+
+async function format(input: unknown): Promise<unknown> {
+  // 결과 포맷팅
+  console.log('[format]', input);
+  return input;
+}
+
+async function respond(input: unknown): Promise<unknown> {
+  // 응답 반환
+  console.log('[respond]', input);
+  return input;
+}
+
+export default skill;

package/templates/workspace/skill-forge/output/generated-skills/skills/hello-world/types.ts

@@ -0,0 +1,17 @@
+/**
+ * hello-world - Type Definitions
+ */
+
+export interface SkillContext {
+  input: string;
+  channelId?: string;
+  userId?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface SkillResult {
+  success: boolean;
+  message?: string;
+  error?: string;
+  data?: unknown;
+}

package/templates/workspace/skill-forge/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "skill-forge",
+  "version": "0.1.0",
+  "description": "Multi-Agent Skill Generator for OpenClaw",
+  "type": "module",
+  "main": "dist/orchestrator.js",
+  "scripts": {
+    "build": "tsc",
+    "test": "npx tsx orchestrator.ts",
+    "dev": "npx tsx --watch orchestrator.ts"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^5.3.0",
+    "@types/node": "^20.10.0",
+    "tsx": "^4.7.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}