로컬에서 AI 멀티 에이전트 만들기 (2) — 에이전트 구현

// src/event-bus.ts
export class EventBus {
  private pub: Redis;
  private sub: Redis;
  private handlers: Map<string, ((event: AgentEvent) => void)[]> = new Map();
 
  constructor(redisUrl: string) {
    this.pub = new Redis(redisUrl);
    this.sub = new Redis(redisUrl);  // Redis pub/sub는 연결 2개 필요
  }
 
  async publish(type: string, payload: Record<string, unknown>) {
    const event = {
      id: crypto.randomUUID(),
      type,
      payload,
      timestamp: new Date().toISOString(),
    };
    await this.pub.publish("agent-events", JSON.stringify(event));
    return event;
  }
 
  async subscribe(type: string, handler: (event: AgentEvent) => void) {
    if (!this.handlers.has(type)) {
      this.handlers.set(type, []);
    }
    this.handlers.get(type)!.push(handler);
 
    if (this.handlers.size === 1) {  // 첫 구독시에만 Redis subscribe
      await this.sub.subscribe("agent-events");
      this.sub.on("message", (_channel, message) => {
        const event = JSON.parse(message);
        const handlers = this.handlers.get(event.type) || [];
        handlers.forEach((h) => h(event));
      });
    }
  }
}

this.sub.on("message", (_channel, message) => {
  try {
    const event = JSON.parse(message);
    const handlers = this.handlers.get(event.type) || [];
    handlers.forEach((h) => h(event));
  } catch (e) {
    console.error("EventBus: invalid message", e);
  }
});

// src/orchestrator.ts
export class Orchestrator {
  async start() {
    // task.created → planner-queue
    await this.eventBus.subscribe("task.created", async (event) => {
      await this.plannerQueue.add("plan", event.payload);
    });
 
    // plan.completed → coder-queue
    await this.eventBus.subscribe("plan.completed", async (event) => {
      await this.coderQueue.add("code", event.payload);
    });
 
    // code.completed → reviewer-queue
    await this.eventBus.subscribe("code.completed", async (event) => {
      await this.reviewerQueue.add("review", event.payload);
    });
  }
}

// src/agents/planner-agent.ts
const SYSTEM_PROMPT = `You are a software planning agent.
Given a user's request, produce a JSON implementation plan.
 
Your response must be a valid JSON object with this exact structure:
{
  "title": "Short project title",
  "steps": ["Step 1: ...", "Step 2: ...", ...],
  "files": ["file1.ts", "file2.ts", ...],
  "techStack": ["React", "TypeScript", ...]
}
 
Respond ONLY with JSON, no markdown fences or explanation`;

private parsePlan(output: string): Plan {
  const cleaned = output
    .replace(/```json\s*/g, "")
    .replace(/```\s*/g, "")
    .trim();
 
  const start = cleaned.indexOf("{");
  const end = cleaned.lastIndexOf("}");
  return JSON.parse(cleaned.slice(start, end + 1));
}

// src/agents/coder-agent.ts
private buildPrompt(plan: Plan): string {
  return `You are a coding agent. Implement the following plan.
 
## Project: ${plan.title}
 
## Tech Stack
${plan.techStack.map((t) => `- ${t}`).join("\n")}
 
## Files to Create
${plan.files.map((f) => `- ${f}`).join("\n")}
 
## Implementation Steps
${plan.steps.map((s, i) => `${i + 1}. ${s}`).join("\n")}
 
Rules:
- Create all listed files with complete, working code
- Make the code immediately runnable
- Do NOT explain — just write the code`;
}

// src/agents/reviewer-agent.ts
const SYSTEM_PROMPT = `You are a code review agent.
Review the code and provide feedback.
 
Your response must end with a VERDICT block:
 
VERDICT: approve OR suggest
SCORE: 1-10
FEEDBACK: One paragraph summary`;

private parseVerdict(output: string) {
  const verdictMatch = output.match(/VERDICT:\s*(approve|suggest)/i);
  const scoreMatch = output.match(/SCORE:\s*(\d+)/i);
  const feedbackMatch = output.match(/FEEDBACK:\s*(.+)/is);
 
  return {
    verdict: verdictMatch?.[1]?.toLowerCase() || "suggest",
    score: scoreMatch ? parseInt(scoreMatch[1], 10) : 5,
    feedback: feedbackMatch?.[1]?.trim() || output.slice(-500),
  };
}

// src/workers/planner-worker.ts
export function createPlannerWorker(eventBus: EventBus): Worker {
  const agent = new PlannerAgent(plannerConfig.engine);
 
  return new Worker("planner-queue", async (job) => {
    const { task, cwd } = job.data;
    const { plan, raw } = await agent.run(task, cwd);
 
    // 결과를 이벤트로 발행 → Orchestrator가 다음 큐로 라우팅
    await eventBus.publish("plan.completed", { task, plan, cwd });
    return { plan };
  }, { connection: { url: redisUrl } });
}

// src/start.ts
const eventBus = new EventBus(redisUrl);
const orchestrator = new Orchestrator(eventBus);
await orchestrator.start();
 
const plannerWorker = createPlannerWorker(eventBus);
const coderWorker = createCoderWorker(eventBus);
const reviewerWorker = createReviewerWorker(eventBus);