@jungjaehoon/mama-os 0.53.0 → 0.57.0

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

@@ -1,495 +0,0 @@
-/**
- * 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

@@ -1,24 +0,0 @@
-# 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

@@ -1,79 +0,0 @@
-/**
- * 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

@@ -1,17 +0,0 @@
-/**
- * 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

@@ -1,21 +0,0 @@
-{
-  "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"
-  }
-}