freelang-editor 11.7.4

package/src/multi-agent.ts

@@ -0,0 +1,101 @@
+// FreeLang v9 Multi-Agent Communication
+// Phase 103: 멀티 에이전트 통신 시스템
+// (agent-send "agentId" message)
+// (agent-recv "agentId")
+// (agent-broadcast message)
+// (agent-spawn "id" handlerFn)
+
+export interface AgentMessage {
+  from: string;
+  to: string | 'broadcast';
+  content: any;
+  timestamp: number;
+  id: string;
+}
+
+export interface AgentHandle {
+  id: string;
+  handler: (msg: AgentMessage, bus: MessageBus) => any;
+  inbox: AgentMessage[];
+  running: boolean;
+}
+
+export class MessageBus {
+  private agents: Map<string, AgentHandle> = new Map();
+  private log: AgentMessage[] = [];
+  private msgCounter = 0;
+
+  // 에이전트 등록
+  spawn(id: string, handler: (msg: AgentMessage, bus: MessageBus) => any): AgentHandle {
+    const handle: AgentHandle = { id, handler, inbox: [], running: true };
+    this.agents.set(id, handle);
+    return handle;
+  }
+
+  // 단일 메시지 전송
+  send(from: string, to: string, content: any): AgentMessage {
+    const msg: AgentMessage = {
+      from, to, content,
+      timestamp: Date.now(),
+      id: `msg-${++this.msgCounter}`
+    };
+    const target = this.agents.get(to);
+    if (target) {
+      target.inbox.push(msg);
+    }
+    this.log.push(msg);
+    return msg;
+  }
+
+  // 브로드캐스트
+  broadcast(from: string, content: any): AgentMessage[] {
+    return [...this.agents.keys()]
+      .filter(id => id !== from)
+      .map(to => this.send(from, to, content));
+  }
+
+  // 수신 (첫 메시지 꺼내기)
+  recv(agentId: string): AgentMessage | null {
+    const agent = this.agents.get(agentId);
+    if (!agent || agent.inbox.length === 0) return null;
+    return agent.inbox.shift()!;
+  }
+
+  // 수신 대기 + 핸들러 실행
+  process(agentId: string): any[] {
+    const agent = this.agents.get(agentId);
+    if (!agent) return [];
+    const results: any[] = [];
+    while (agent.inbox.length > 0) {
+      const msg = agent.inbox.shift()!;
+      results.push(agent.handler(msg, this));
+    }
+    return results;
+  }
+
+  // 에이전트 중지
+  stop(agentId: string): void {
+    const agent = this.agents.get(agentId);
+    if (agent) agent.running = false;
+  }
+
+  // 전체 메시지 로그
+  history(): AgentMessage[] { return [...this.log]; }
+
+  // 에이전트 목록
+  list(): string[] { return [...this.agents.keys()]; }
+
+  // 인박스 크기
+  inboxSize(agentId: string): number {
+    return this.agents.get(agentId)?.inbox.length ?? 0;
+  }
+
+  size(): number { return this.agents.size; }
+
+  // 에이전트 가져오기
+  get(agentId: string): AgentHandle | undefined {
+    return this.agents.get(agentId);
+  }
+}
+
+export const globalBus = new MessageBus();

package/src/mutate.ts

@@ -0,0 +1,226 @@
+// mutate.ts — FreeLang v9 Phase 132: [MUTATE] 코드 변이 + 선택
+// AI가 해법을 변이시켜 탐색 공간을 확장한다
+
+export type MutationType = 'random' | 'gaussian' | 'swap' | 'flip' | 'insert' | 'delete' | 'replace';
+
+export interface MutationConfig {
+  rate: number;      // 변이율 (0~1)
+  strength: number;  // 변이 강도 (기본 0.1)
+  type: MutationType;
+}
+
+export interface MutationResult<T> {
+  original: T;
+  mutated: T;
+  mutations: number;       // 실제 변이 발생 횟수
+  mutationType: MutationType;
+}
+
+const DEFAULT_CONFIG: MutationConfig = {
+  rate: 0.1,
+  strength: 0.1,
+  type: 'random',
+};
+
+// 문자 집합 (문자열 변이용)
+const CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+
+export class Mutator<T> {
+  private config: MutationConfig;
+
+  constructor(config?: Partial<MutationConfig>) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+
+  getConfig(): MutationConfig {
+    return { ...this.config };
+  }
+
+  // 숫자 배열 변이
+  mutateNumbers(arr: number[]): MutationResult<number[]> {
+    const original = [...arr];
+    const mutated = [...arr];
+    let mutations = 0;
+    const type = this.config.type;
+
+    if (type === 'swap') {
+      return this.swapMutation(arr) as unknown as MutationResult<number[]>;
+    }
+
+    if (type === 'flip') {
+      return this.flipMutation(arr as unknown as number[]) as unknown as MutationResult<number[]>;
+    }
+
+    for (let i = 0; i < mutated.length; i++) {
+      if (Math.random() < this.config.rate) {
+        if (type === 'gaussian') {
+          // Gaussian 변이: Box-Muller 변환
+          const u1 = Math.random();
+          const u2 = Math.random();
+          const gaussian = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+          mutated[i] = mutated[i] + gaussian * this.config.strength * (Math.abs(mutated[i]) || 1);
+        } else {
+          // random 변이: strength 범위 내 랜덤 변화
+          const delta = (Math.random() * 2 - 1) * this.config.strength * (Math.abs(mutated[i]) || 1);
+          mutated[i] = mutated[i] + delta;
+        }
+        mutations++;
+      }
+    }
+
+    return { original, mutated, mutations, mutationType: type };
+  }
+
+  // 문자열 변이
+  mutateString(s: string): MutationResult<string> {
+    const original = s;
+    const type = this.config.type;
+    let mutated = s;
+    let mutations = 0;
+
+    if (type === 'insert') {
+      // 문자 삽입
+      const chars = s.split('');
+      const newChars: string[] = [];
+      for (let i = 0; i < chars.length; i++) {
+        newChars.push(chars[i]);
+        if (Math.random() < this.config.rate) {
+          const randChar = CHARS[Math.floor(Math.random() * CHARS.length)];
+          newChars.push(randChar);
+          mutations++;
+        }
+      }
+      mutated = newChars.join('');
+    } else if (type === 'delete') {
+      // 문자 삭제
+      const chars = s.split('');
+      const kept: string[] = [];
+      for (const ch of chars) {
+        if (Math.random() < this.config.rate) {
+          mutations++;
+          // skip (delete)
+        } else {
+          kept.push(ch);
+        }
+      }
+      mutated = kept.join('');
+    } else if (type === 'swap') {
+      // 인접 문자 교환
+      const chars = s.split('');
+      for (let i = 0; i < chars.length - 1; i++) {
+        if (Math.random() < this.config.rate) {
+          const tmp = chars[i];
+          chars[i] = chars[i + 1];
+          chars[i + 1] = tmp;
+          mutations++;
+          i++; // 교환 후 다음 위치 건너뜀
+        }
+      }
+      mutated = chars.join('');
+    } else {
+      // random/replace: 문자 치환
+      const chars = s.split('');
+      for (let i = 0; i < chars.length; i++) {
+        if (Math.random() < this.config.rate) {
+          chars[i] = CHARS[Math.floor(Math.random() * CHARS.length)];
+          mutations++;
+        }
+      }
+      mutated = chars.join('');
+    }
+
+    return { original, mutated, mutations, mutationType: type };
+  }
+
+  // 제네릭 객체 변이 (JSON-safe)
+  mutateObject(obj: Record<string, unknown>): MutationResult<Record<string, unknown>> {
+    const original: Record<string, unknown> = JSON.parse(JSON.stringify(obj));
+    const mutated: Record<string, unknown> = JSON.parse(JSON.stringify(obj));
+    let mutations = 0;
+    const type = this.config.type;
+
+    for (const key of Object.keys(mutated)) {
+      if (Math.random() < this.config.rate) {
+        const val = mutated[key];
+        if (typeof val === 'number') {
+          const delta = (Math.random() * 2 - 1) * this.config.strength * (Math.abs(val) || 1);
+          mutated[key] = val + delta;
+          mutations++;
+        } else if (typeof val === 'string') {
+          // 문자열 값: 랜덤 문자 하나 치환
+          if (val.length > 0) {
+            const pos = Math.floor(Math.random() * val.length);
+            const newChar = CHARS[Math.floor(Math.random() * CHARS.length)];
+            mutated[key] = val.slice(0, pos) + newChar + val.slice(pos + 1);
+            mutations++;
+          }
+        } else if (typeof val === 'boolean') {
+          mutated[key] = !val;
+          mutations++;
+        }
+      }
+    }
+
+    return { original, mutated, mutations, mutationType: type };
+  }
+
+  // 배열 요소 교환 (swap mutation)
+  swapMutation<U>(arr: U[]): MutationResult<U[]> {
+    const original = [...arr];
+    const mutated = [...arr];
+    let mutations = 0;
+
+    for (let i = 0; i < mutated.length - 1; i++) {
+      if (Math.random() < this.config.rate) {
+        const j = Math.floor(Math.random() * (mutated.length - i - 1)) + i + 1;
+        const tmp = mutated[i];
+        mutated[i] = mutated[j];
+        mutated[j] = tmp;
+        mutations++;
+      }
+    }
+
+    return { original, mutated, mutations, mutationType: 'swap' };
+  }
+
+  // 비트 플립 (0 ↔ 1)
+  flipMutation(bits: number[]): MutationResult<number[]> {
+    const original = [...bits];
+    const mutated = [...bits];
+    let mutations = 0;
+
+    for (let i = 0; i < mutated.length; i++) {
+      if (Math.random() < this.config.rate) {
+        mutated[i] = mutated[i] === 0 ? 1 : 0;
+        mutations++;
+      }
+    }
+
+    return { original, mutated, mutations, mutationType: 'flip' };
+  }
+
+  // 적합도 기반 선택 (높은 적합도 우선)
+  select<U>(candidates: Array<{ value: U; fitness: number }>, n: number): U[] {
+    const sorted = [...candidates].sort((a, b) => b.fitness - a.fitness);
+    return sorted.slice(0, n).map(c => c.value);
+  }
+}
+
+// 전역 싱글톤 변이기
+export const globalMutator: Mutator<unknown> = new Mutator<unknown>();
+
+// 편의 함수
+export function mutateNumbers(arr: number[], rate = 0.1): MutationResult<number[]> {
+  const m = new Mutator<number[]>({ rate });
+  return m.mutateNumbers(arr);
+}
+
+export function mutateString(s: string, rate = 0.1): MutationResult<string> {
+  const m = new Mutator<string>({ rate });
+  return m.mutateString(s);
+}
+
+export function selectBest<T>(items: Array<{ value: T; fitness: number }>, ratio = 0.5): T[] {
+  const n = Math.max(1, Math.round(items.length * ratio));
+  return globalMutator.select(items, n) as T[];
+}

package/src/negotiate.ts

@@ -0,0 +1,55 @@
+// negotiate.ts — FreeLang v9 Phase 124: 에이전트 협상 블록
+// [NEGOTIATE] 블록: 멀티 에이전트 협상 엔진
+
+export interface NegotiationPosition {
+  agentId: string;
+  offer: number;      // 현재 제안값 (0~1 정규화)
+  minAccept: number;  // 최소 수용값
+  maxOffer: number;   // 최대 제안값
+  flexibility: number; // 양보 의지 (0~1)
+}
+
+export interface NegotiationRound {
+  round: number;
+  offers: Record<string, number>;
+  gap: number;
+}
+
+export interface NegotiationResult {
+  agreed: boolean;
+  value?: number;
+  rounds: NegotiationRound[];
+  breakdown: string;
+}
+
+export class Negotiator {
+  negotiate(positions: NegotiationPosition[], maxRounds = 5): NegotiationResult {
+    const rounds: NegotiationRound[] = [];
+    let currentOffers: Record<string, number> = {};
+    positions.forEach(p => { currentOffers[p.agentId] = p.offer; });
+
+    for (let r = 1; r <= maxRounds; r++) {
+      const values = Object.values(currentOffers);
+      const gap = Math.max(...values) - Math.min(...values);
+      rounds.push({ round: r, offers: { ...currentOffers }, gap });
+
+      // 합의 조건: 모든 제안이 서로의 minAccept 범위 안
+      const avgOffer = values.reduce((s, v) => s + v, 0) / values.length;
+      const allAccept = positions.every(p => avgOffer >= p.minAccept && avgOffer <= p.maxOffer);
+      if (allAccept || gap < 0.01) {
+        return { agreed: true, value: avgOffer, rounds, breakdown: `${r}라운드에 합의 (값: ${avgOffer.toFixed(3)})` };
+      }
+
+      // 양보: 각 에이전트가 중간값 방향으로 flexibility만큼 이동
+      positions.forEach(p => {
+        const current = currentOffers[p.agentId];
+        const delta = (avgOffer - current) * p.flexibility * 0.5;
+        currentOffers[p.agentId] = Math.max(p.minAccept, Math.min(p.maxOffer, current + delta));
+      });
+    }
+
+    return { agreed: false, rounds, breakdown: `${maxRounds}라운드 후 협상 결렬` };
+  }
+}
+
+export const globalNegotiator = new Negotiator();

package/src/optimizer.ts

@@ -0,0 +1,277 @@
+// FreeLang v9 Phase 84: 바이트코드 최적화기
+
+import { OpCode, Instruction, Chunk } from "./bytecode";
+
+// ─────────────────────────────────────────────────────────────
+// OptimizationPass 인터페이스
+// ─────────────────────────────────────────────────────────────
+
+export interface OptimizationPass {
+  name: string;
+  run(chunk: Chunk): Chunk;
+}
+
+// ─────────────────────────────────────────────────────────────
+// 헬퍼: Chunk 복사
+// ─────────────────────────────────────────────────────────────
+
+function cloneChunk(chunk: Chunk): Chunk {
+  return {
+    instructions: chunk.instructions.map(i => ({ ...i })),
+    constants: [...chunk.constants],
+    name: chunk.name,
+  };
+}
+
+// ─────────────────────────────────────────────────────────────
+// Pass 1: constant-folding
+// PUSH_CONST a, PUSH_CONST b, <binary op> → PUSH_CONST result
+// ─────────────────────────────────────────────────────────────
+
+const FOLDABLE_BINARY_OPS = new Set([
+  OpCode.ADD, OpCode.SUB, OpCode.MUL, OpCode.DIV, OpCode.MOD,
+  OpCode.EQ, OpCode.NEQ, OpCode.LT, OpCode.GT, OpCode.LE, OpCode.GE,
+  OpCode.AND, OpCode.OR,
+]);
+
+function applyBinaryOp(op: OpCode, a: any, b: any): any {
+  switch (op) {
+    case OpCode.ADD: return a + b;
+    case OpCode.SUB: return a - b;
+    case OpCode.MUL: return a * b;
+    case OpCode.DIV: return b === 0 ? null : a / b;
+    case OpCode.MOD: return a % b;
+    case OpCode.EQ:  return a === b;
+    case OpCode.NEQ: return a !== b;
+    case OpCode.LT:  return a < b;
+    case OpCode.GT:  return a > b;
+    case OpCode.LE:  return a <= b;
+    case OpCode.GE:  return a >= b;
+    case OpCode.AND: return Boolean(a) && Boolean(b);
+    case OpCode.OR:  return Boolean(a) || Boolean(b);
+    default: return null;
+  }
+}
+
+export const constantFoldingPass: OptimizationPass = {
+  name: "constant-folding",
+  run(chunk: Chunk): Chunk {
+    const result = cloneChunk(chunk);
+    let changed = true;
+
+    // 변경이 없을 때까지 반복 (연쇄 폴딩)
+    while (changed) {
+      changed = false;
+      const instrs = result.instructions;
+
+      for (let i = 0; i + 2 < instrs.length; i++) {
+        const a = instrs[i];
+        const b = instrs[i + 1];
+        const op = instrs[i + 2];
+
+        if (
+          a.op === OpCode.PUSH_CONST &&
+          b.op === OpCode.PUSH_CONST &&
+          FOLDABLE_BINARY_OPS.has(op.op)
+        ) {
+          const aVal = result.constants[a.arg as number];
+          const bVal = result.constants[b.arg as number];
+
+          // DIV by zero는 폴딩하지 않음
+          if (op.op === OpCode.DIV && bVal === 0) continue;
+
+          const foldedVal = applyBinaryOp(op.op, aVal, bVal);
+
+          // 새 상수 추가 (중복 체크)
+          let newIdx = result.constants.indexOf(foldedVal);
+          if (newIdx === -1) {
+            newIdx = result.constants.length;
+            result.constants.push(foldedVal);
+          }
+
+          // 3개 명령어를 1개로 교체
+          instrs.splice(i, 3, { op: OpCode.PUSH_CONST, arg: newIdx });
+
+          // JUMP 오프셋 보정 (2개 명령어 제거됨)
+          for (let j = 0; j < instrs.length; j++) {
+            const instr = instrs[j];
+            if (
+              (instr.op === OpCode.JUMP || instr.op === OpCode.JUMP_IF_FALSE) &&
+              typeof instr.arg === "number"
+            ) {
+              if (instr.arg > i + 2) {
+                instr.arg -= 2;
+              } else if (instr.arg > i) {
+                // jump 대상이 제거된 범위 내 → 폴딩된 자리로
+                instr.arg = i;
+              }
+            }
+          }
+
+          changed = true;
+          break; // instrs 길이 변경되었으므로 재시작
+        }
+      }
+    }
+
+    return result;
+  },
+};
+
+// ─────────────────────────────────────────────────────────────
+// Pass 2: dead-code-elimination
+// HALT 이후 명령어 제거
+// ─────────────────────────────────────────────────────────────
+
+export const deadCodeEliminationPass: OptimizationPass = {
+  name: "dead-code-elimination",
+  run(chunk: Chunk): Chunk {
+    const result = cloneChunk(chunk);
+    const instrs = result.instructions;
+
+    const haltIdx = instrs.findIndex(i => i.op === OpCode.HALT);
+    if (haltIdx !== -1 && haltIdx < instrs.length - 1) {
+      // HALT 이후 모두 제거
+      result.instructions = instrs.slice(0, haltIdx + 1);
+    }
+
+    return result;
+  },
+};
+
+// ─────────────────────────────────────────────────────────────
+// Pass 3: push-pop-elimination
+// PUSH_CONST x, POP → 두 명령어 제거
+// ─────────────────────────────────────────────────────────────
+
+export const pushPopEliminationPass: OptimizationPass = {
+  name: "push-pop-elimination",
+  run(chunk: Chunk): Chunk {
+    const result = cloneChunk(chunk);
+    let changed = true;
+
+    while (changed) {
+      changed = false;
+      const instrs = result.instructions;
+
+      for (let i = 0; i + 1 < instrs.length; i++) {
+        const curr = instrs[i];
+        const next = instrs[i + 1];
+
+        // PUSH_CONST 바로 다음 POP → 둘 다 제거
+        if (curr.op === OpCode.PUSH_CONST && next.op === OpCode.POP) {
+          instrs.splice(i, 2);
+
+          // JUMP 오프셋 보정
+          for (let j = 0; j < instrs.length; j++) {
+            const instr = instrs[j];
+            if (
+              (instr.op === OpCode.JUMP || instr.op === OpCode.JUMP_IF_FALSE) &&
+              typeof instr.arg === "number"
+            ) {
+              if (instr.arg > i + 1) {
+                instr.arg -= 2;
+              } else if (instr.arg > i) {
+                instr.arg = i;
+              }
+            }
+          }
+
+          changed = true;
+          break;
+        }
+      }
+    }
+
+    return result;
+  },
+};
+
+// ─────────────────────────────────────────────────────────────
+// Pass 4: jump-optimization
+// JUMP i+1 (다음 줄로 점프) → 제거
+// ─────────────────────────────────────────────────────────────
+
+export const jumpOptimizationPass: OptimizationPass = {
+  name: "jump-optimization",
+  run(chunk: Chunk): Chunk {
+    const result = cloneChunk(chunk);
+    let changed = true;
+
+    while (changed) {
+      changed = false;
+      const instrs = result.instructions;
+
+      for (let i = 0; i < instrs.length; i++) {
+        const instr = instrs[i];
+        // JUMP to next instruction (i+1) → 무의미, 제거
+        if (instr.op === OpCode.JUMP && instr.arg === i + 1) {
+          instrs.splice(i, 1);
+
+          // JUMP 오프셋 보정
+          for (let j = 0; j < instrs.length; j++) {
+            const other = instrs[j];
+            if (
+              (other.op === OpCode.JUMP || other.op === OpCode.JUMP_IF_FALSE) &&
+              typeof other.arg === "number"
+            ) {
+              if (other.arg > i) {
+                other.arg -= 1;
+              }
+            }
+          }
+
+          changed = true;
+          break;
+        }
+      }
+    }
+
+    return result;
+  },
+};
+
+// ─────────────────────────────────────────────────────────────
+// Optimizer 클래스
+// ─────────────────────────────────────────────────────────────
+
+export class Optimizer {
+  private passes: OptimizationPass[] = [];
+  private stats: { passName: string; reduced: number }[] = [];
+
+  addPass(pass: OptimizationPass): this {
+    this.passes.push(pass);
+    return this;
+  }
+
+  optimize(chunk: Chunk): Chunk {
+    this.stats = [];
+    let current = chunk;
+
+    for (const pass of this.passes) {
+      const before = current.instructions.length;
+      const after = pass.run(current);
+      const reduced = before - after.instructions.length;
+      this.stats.push({ passName: pass.name, reduced });
+      current = after;
+    }
+
+    return current;
+  }
+
+  getStats(): { passName: string; reduced: number }[] {
+    return this.stats;
+  }
+}
+
+// ─────────────────────────────────────────────────────────────
+// createDefaultOptimizer — 4개 패스 모두 포함
+// ─────────────────────────────────────────────────────────────
+
+export function createDefaultOptimizer(): Optimizer {
+  return new Optimizer()
+    .addPass(constantFoldingPass)
+    .addPass(deadCodeEliminationPass)
+    .addPass(pushPopEliminationPass)
+    .addPass(jumpOptimizationPass);
+}