freelang-editor 11.7.4

package/src/critique.ts

@@ -0,0 +1,77 @@
+// FreeLang v9 Critique — 자기 출력 비판 에이전트
+// Phase 118: [CRITIQUE :output $x :find-weaknesses fn :find-counterexamples fn :severity fn]
+
+export type Severity = 'critical' | 'major' | 'minor' | 'suggestion';
+
+export interface CritiquePoint {
+  type: 'weakness' | 'counterexample' | 'assumption' | 'missing';
+  description: string;
+  severity: Severity;
+  suggestion?: string;
+}
+
+export interface CritiqueResult {
+  output: any;
+  points: CritiquePoint[];
+  overallRisk: number;      // 0~1, 높을수록 위험
+  approved: boolean;        // critical/major가 없으면 true
+  summary: string;
+}
+
+export interface CritiqueConfig {
+  finders: Array<(output: any) => CritiquePoint[]>;  // 문제 찾는 함수들
+  riskThreshold?: number;  // 이 이상이면 approved=false (default: 0.5)
+}
+
+export function severityWeight(s: Severity): number {
+  return { critical: 1.0, major: 0.7, minor: 0.3, suggestion: 0.1 }[s];
+}
+
+export class CritiqueAgent {
+  run(output: any, config: CritiqueConfig): CritiqueResult {
+    const { finders, riskThreshold = 0.5 } = config;
+    const points: CritiquePoint[] = finders.flatMap(f => {
+      try { return f(output); } catch { return []; }
+    });
+
+    const totalRisk = points.length === 0 ? 0
+      : points.reduce((s, p) => s + severityWeight(p.severity), 0) / (points.length * 1.0);
+    const overallRisk = Math.min(1, totalRisk);
+    const approved = overallRisk < riskThreshold && !points.some(p => p.severity === 'critical');
+
+    const criticals = points.filter(p => p.severity === 'critical').length;
+    const majors = points.filter(p => p.severity === 'major').length;
+    const summary = points.length === 0
+      ? '비판할 점 없음 — 통과'
+      : `${points.length}개 문제 발견 (critical: ${criticals}, major: ${majors}), 위험도: ${(overallRisk*100).toFixed(0)}%`;
+
+    return { output, points, overallRisk, approved, summary };
+  }
+}
+
+// 기본 비판 파인더들
+export const defaultFinders: Array<(output: any) => CritiquePoint[]> = [
+  // 빈 출력
+  (output: any): CritiquePoint[] => {
+    if (output === null || output === undefined || output === '') {
+      return [{ type: 'missing', description: '출력이 비어있음', severity: 'critical' }];
+    }
+    return [];
+  },
+  // 너무 짧은 출력
+  (output: any): CritiquePoint[] => {
+    if (typeof output === 'string' && output.length > 0 && output.length < 5) {
+      return [{ type: 'weakness', description: '출력이 너무 짧음', severity: 'minor', suggestion: '더 구체적으로 서술' }];
+    }
+    return [];
+  },
+  // 에러 객체
+  (output: any): CritiquePoint[] => {
+    if (output instanceof Error || (typeof output === 'object' && output !== null && output?._tag === 'Err')) {
+      return [{ type: 'weakness', description: '에러 값이 출력됨', severity: 'major' }];
+    }
+    return [];
+  },
+];
+
+export const globalCritique = new CritiqueAgent();

package/src/crossover.ts

@@ -0,0 +1,218 @@
+// FreeLang v9 Crossover — 두 해법 교배
+// Phase 133: [CROSSOVER] 유전 알고리즘 기반 교배 연산자
+
+export type CrossoverType = 'single-point' | 'two-point' | 'uniform' | 'blend' | 'arithmetic';
+
+export interface CrossoverConfig {
+  type: CrossoverType;
+  rate: number;       // 교배율 (기본 0.7)
+  blendAlpha?: number; // blend 교배 시 알파값 (기본 0.5)
+}
+
+export interface CrossoverResult<T> {
+  parent1: T;
+  parent2: T;
+  child1: T;
+  child2: T;
+  crossoverPoint?: number;   // single-point 시
+  crossoverPoints?: [number, number]; // two-point 시
+  type: CrossoverType;
+}
+
+export class Crossover<T> {
+  private config: CrossoverConfig;
+
+  constructor(config?: Partial<CrossoverConfig>) {
+    this.config = {
+      type: config?.type ?? 'single-point',
+      rate: config?.rate ?? 0.7,
+      blendAlpha: config?.blendAlpha ?? 0.5,
+    };
+  }
+
+  // 단일점 교배 (배열)
+  singlePoint<U>(a: U[], b: U[]): CrossoverResult<U[]> {
+    const len = Math.min(a.length, b.length);
+    const point = len <= 1 ? 0 : Math.floor(Math.random() * (len - 1)) + 1;
+
+    const child1 = [...a.slice(0, point), ...b.slice(point)];
+    const child2 = [...b.slice(0, point), ...a.slice(point)];
+
+    // 길이 맞추기
+    while (child1.length < a.length) child1.push(a[child1.length]);
+    while (child2.length < b.length) child2.push(b[child2.length]);
+
+    return {
+      parent1: [...a] as U[],
+      parent2: [...b] as U[],
+      child1: child1.slice(0, a.length),
+      child2: child2.slice(0, b.length),
+      crossoverPoint: point,
+      type: 'single-point',
+    };
+  }
+
+  // 두 점 교배 (배열)
+  twoPoint<U>(a: U[], b: U[]): CrossoverResult<U[]> {
+    const len = Math.min(a.length, b.length);
+    let p1 = len <= 2 ? 0 : Math.floor(Math.random() * (len - 1));
+    let p2 = len <= 2 ? len : Math.floor(Math.random() * (len - p1 - 1)) + p1 + 1;
+    if (p1 >= p2) { p2 = Math.min(p1 + 1, len); }
+
+    const child1 = [
+      ...a.slice(0, p1),
+      ...b.slice(p1, p2),
+      ...a.slice(p2),
+    ];
+    const child2 = [
+      ...b.slice(0, p1),
+      ...a.slice(p1, p2),
+      ...b.slice(p2),
+    ];
+
+    return {
+      parent1: [...a] as U[],
+      parent2: [...b] as U[],
+      child1: child1.slice(0, a.length),
+      child2: child2.slice(0, b.length),
+      crossoverPoints: [p1, p2],
+      type: 'two-point',
+    };
+  }
+
+  // 균등 교배 (각 요소를 50% 확률로 선택)
+  uniform<U>(a: U[], b: U[]): CrossoverResult<U[]> {
+    const len = Math.max(a.length, b.length);
+    const child1: U[] = [];
+    const child2: U[] = [];
+
+    for (let i = 0; i < len; i++) {
+      const ai = i < a.length ? a[i] : b[i];
+      const bi = i < b.length ? b[i] : a[i];
+      if (Math.random() < 0.5) {
+        child1.push(ai);
+        child2.push(bi);
+      } else {
+        child1.push(bi);
+        child2.push(ai);
+      }
+    }
+
+    return {
+      parent1: [...a] as U[],
+      parent2: [...b] as U[],
+      child1: child1.slice(0, a.length),
+      child2: child2.slice(0, b.length),
+      type: 'uniform',
+    };
+  }
+
+  // 산술 교배 (숫자 배열: alpha*a + (1-alpha)*b)
+  arithmetic(a: number[], b: number[], alpha?: number): CrossoverResult<number[]> {
+    const al = alpha ?? this.config.blendAlpha ?? 0.5;
+    const child1 = a.map((v, i) => al * v + (1 - al) * (b[i] ?? 0));
+    const child2 = a.map((v, i) => (1 - al) * v + al * (b[i] ?? 0));
+
+    return {
+      parent1: [...a],
+      parent2: [...b],
+      child1,
+      child2,
+      type: 'arithmetic',
+    };
+  }
+
+  // 문자열 교배 (단일점)
+  crossoverStrings(a: string, b: string): CrossoverResult<string> {
+    const aArr = a.split('');
+    const bArr = b.split('');
+    const result = this.singlePoint(aArr, bArr);
+
+    return {
+      parent1: a,
+      parent2: b,
+      child1: result.child1.join(''),
+      child2: result.child2.join(''),
+      crossoverPoint: result.crossoverPoint,
+      type: 'single-point',
+    };
+  }
+
+  // 객체 교배 (키 기반)
+  crossoverObjects(
+    a: Record<string, unknown>,
+    b: Record<string, unknown>
+  ): CrossoverResult<Record<string, unknown>> {
+    const allKeys = Array.from(new Set([...Object.keys(a), ...Object.keys(b)]));
+    const child1: Record<string, unknown> = {};
+    const child2: Record<string, unknown> = {};
+
+    for (const key of allKeys) {
+      if (Math.random() < 0.5) {
+        child1[key] = key in a ? a[key] : b[key];
+        child2[key] = key in b ? b[key] : a[key];
+      } else {
+        child1[key] = key in b ? b[key] : a[key];
+        child2[key] = key in a ? a[key] : b[key];
+      }
+    }
+
+    return {
+      parent1: { ...a },
+      parent2: { ...b },
+      child1,
+      child2,
+      type: 'uniform',
+    };
+  }
+
+  // 자동 교배 (타입 감지)
+  cross(a: T, b: T): CrossoverResult<T> {
+    if (Array.isArray(a) && Array.isArray(b)) {
+      const isNumeric = a.every((v: any) => typeof v === 'number');
+      if (isNumeric) {
+        return this.arithmetic(a as number[], b as number[]) as unknown as CrossoverResult<T>;
+      }
+      const result = this.singlePoint(a, b);
+      return result as unknown as CrossoverResult<T>;
+    }
+    if (typeof a === 'string' && typeof b === 'string') {
+      return this.crossoverStrings(a, b) as unknown as CrossoverResult<T>;
+    }
+    if (typeof a === 'object' && a !== null && typeof b === 'object' && b !== null) {
+      return this.crossoverObjects(
+        a as Record<string, unknown>,
+        b as Record<string, unknown>
+      ) as unknown as CrossoverResult<T>;
+    }
+    // 기본: arithmetic for numbers
+    if (typeof a === 'number' && typeof b === 'number') {
+      const alpha = this.config.blendAlpha ?? 0.5;
+      return {
+        parent1: a,
+        parent2: b,
+        child1: (alpha * (a as unknown as number) + (1 - alpha) * (b as unknown as number)) as unknown as T,
+        child2: ((1 - alpha) * (a as unknown as number) + alpha * (b as unknown as number)) as unknown as T,
+        type: 'arithmetic',
+      };
+    }
+    // fallback
+    return {
+      parent1: a,
+      parent2: b,
+      child1: a,
+      child2: b,
+      type: this.config.type,
+    };
+  }
+}
+
+export const globalCrossover: Crossover<unknown> = new Crossover();
+
+export function crossoverNumbers(a: number[], b: number[]): CrossoverResult<number[]> {
+  return globalCrossover.arithmetic(a, b);
+}
+
+export function crossoverStrings(a: string, b: string): CrossoverResult<string> {
+  return globalCrossover.crossoverStrings(a, b);
+}

package/src/curiosity.ts

@@ -0,0 +1,305 @@
+// curiosity.ts — FreeLang v9 Phase 148: [CURIOSITY]
+// AI가 호기심을 가지고 미지의 영역을 탐색하는 시스템
+// 정보 이득을 최대화하는 방향으로 탐색 (UCB1 알고리즘)
+
+export interface KnowledgeGap {
+  topic: string;
+  unknownAspects: string[];
+  priority: number;       // 0~1 (얼마나 중요한 공백인가)
+  explorationCost: number; // 탐색 비용
+  expectedGain: number;   // 예상 정보 이득
+}
+
+export interface CuriosityState {
+  explored: Set<string>;      // 탐색 완료 항목
+  frontier: string[];         // 탐색 대기 항목
+  knowledgeGaps: KnowledgeGap[];
+  curiosityScore: number;     // 현재 호기심 수준 0~1
+  explorationHistory: Array<{ topic: string; gain: number; timestamp: Date }>;
+}
+
+export interface ExplorationResult {
+  topic: string;
+  discovered: string[];       // 발견된 새 정보
+  newQuestions: string[];     // 생성된 새 질문
+  informationGain: number;    // 정보 이득량
+  surpriseLevel: number;      // 0~1 (예상치 못한 발견)
+  relatedTopics: string[];    // 연관 탐색 후보
+}
+
+// UCB1 관련 내부 상태
+interface UCB1Stats {
+  visits: number;
+  totalGain: number;
+}
+
+/**
+ * CuriosityEngine — 호기심 기반 탐색 엔진
+ *
+ * 핵심 아이디어:
+ *   - 정보가 적을수록 → curiosity 높음
+ *   - UCB1으로 exploration/exploitation 균형
+ *   - 탐색 시 새 질문(frontier) 자동 생성
+ */
+export class CuriosityEngine {
+  private state: CuriosityState;
+  private ucb1Stats: Map<string, UCB1Stats>;
+  private totalVisits: number;
+
+  constructor(initialTopics?: string[]) {
+    this.state = {
+      explored: new Set<string>(),
+      frontier: initialTopics ? [...initialTopics] : [],
+      knowledgeGaps: [],
+      curiosityScore: 0.5,
+      explorationHistory: [],
+    };
+    this.ucb1Stats = new Map();
+    this.totalVisits = 0;
+
+    // 초기 주제 UCB1 초기화
+    for (const t of this.state.frontier) {
+      this.ucb1Stats.set(t, { visits: 0, totalGain: 0 });
+    }
+  }
+
+  /**
+   * 호기심 점수 계산
+   * - knownFacts가 많을수록 낮음 (이미 알고 있으니 덜 궁금)
+   * - knownFacts가 없을수록 높음 (아무것도 모르니 궁금)
+   */
+  computeCuriosity(topic: string, knownFacts: string[]): number {
+    // 기본 호기심: 알려진 사실이 없으면 최대
+    const baseCuriosity = knownFacts.length === 0 ? 1.0 : Math.max(0, 1.0 - knownFacts.length * 0.15);
+
+    // 이미 탐색된 주제는 호기심 감소
+    const explorationPenalty = this.state.explored.has(topic) ? 0.3 : 0;
+
+    // 호기심 점수 계산 (0~1 클램프)
+    const raw = baseCuriosity - explorationPenalty;
+    return Math.max(0, Math.min(1, raw));
+  }
+
+  /**
+   * 다음 탐색 대상 선택 (UCB1 기반)
+   * UCB1 = avgGain + C * sqrt(ln(N) / n_i)
+   * C = 탐색 계수 (1.41 = sqrt(2))
+   */
+  selectNextTopic(): string | null {
+    if (this.state.frontier.length === 0) return null;
+
+    const C = Math.SQRT2;
+    const N = Math.max(1, this.totalVisits);
+
+    let bestTopic: string | null = null;
+    let bestScore = -Infinity;
+
+    for (const topic of this.state.frontier) {
+      const stats = this.ucb1Stats.get(topic) ?? { visits: 0, totalGain: 0 };
+      const avgGain = stats.visits > 0 ? stats.totalGain / stats.visits : 0;
+      const exploration = C * Math.sqrt(Math.log(N + 1) / (stats.visits + 1));
+      const ucb1Score = avgGain + exploration;
+
+      if (ucb1Score > bestScore) {
+        bestScore = ucb1Score;
+        bestTopic = topic;
+      }
+    }
+
+    return bestTopic;
+  }
+
+  /**
+   * 탐색 수행
+   * explorerFunc: (topic) => { facts, questions }
+   */
+  explore(
+    topic: string,
+    explorerFunc: (topic: string) => { facts: string[]; questions: string[] }
+  ): ExplorationResult {
+    const { facts, questions } = explorerFunc(topic);
+
+    // 새로운 발견 = 아직 모르는 사실들
+    const discovered = facts.filter(f => !this.state.explored.has(f));
+
+    // 정보 이득 계산
+    const informationGain = discovered.length > 0
+      ? Math.min(1, discovered.length * 0.2)
+      : 0.05; // 최소한의 이득
+
+    // surpriseLevel: 예상치 못한 발견 비율
+    const surpriseLevel = facts.length > 0
+      ? Math.min(1, discovered.length / facts.length)
+      : 0;
+
+    // 연관 주제: 새 질문에서 추출
+    const relatedTopics = questions
+      .map(q => q.split(/[?!.,]/)[0].trim())
+      .filter(t => t.length > 0 && !this.state.explored.has(t));
+
+    // 상태 업데이트
+    this.state.explored.add(topic);
+    this.state.frontier = this.state.frontier.filter(t => t !== topic);
+
+    // 새 frontier 추가 (중복 제거)
+    for (const rt of relatedTopics) {
+      if (!this.state.frontier.includes(rt) && !this.state.explored.has(rt)) {
+        this.state.frontier.push(rt);
+        if (!this.ucb1Stats.has(rt)) {
+          this.ucb1Stats.set(rt, { visits: 0, totalGain: 0 });
+        }
+      }
+    }
+
+    // UCB1 통계 업데이트
+    const stats = this.ucb1Stats.get(topic) ?? { visits: 0, totalGain: 0 };
+    stats.visits += 1;
+    stats.totalGain += informationGain;
+    this.ucb1Stats.set(topic, stats);
+    this.totalVisits += 1;
+
+    // 탐색 이력 기록
+    this.state.explorationHistory.push({
+      topic,
+      gain: informationGain,
+      timestamp: new Date(),
+    });
+
+    // 호기심 점수 업데이트 (탐색할수록 감소, 새 발견이 많으면 유지)
+    this.state.curiosityScore = Math.max(
+      0.1,
+      this.state.curiosityScore - 0.05 + surpriseLevel * 0.1
+    );
+
+    return {
+      topic,
+      discovered,
+      newQuestions: questions,
+      informationGain,
+      surpriseLevel,
+      relatedTopics,
+    };
+  }
+
+  /**
+   * 지식 공백 식별
+   * allTopics에는 있지만 knownTopics에 없는 것 = 공백
+   */
+  identifyGaps(knownTopics: string[], allTopics: string[]): KnowledgeGap[] {
+    const knownSet = new Set(knownTopics);
+    const gaps: KnowledgeGap[] = [];
+
+    for (const topic of allTopics) {
+      if (!knownSet.has(topic)) {
+        const unknownAspects = [
+          `${topic}의 정의`,
+          `${topic}의 원리`,
+          `${topic}의 응용`,
+        ];
+        const priority = this.state.explored.has(topic) ? 0.3 : 0.7;
+        const explorationCost = 0.5;
+        const expectedGain = priority * (1 - explorationCost);
+
+        gaps.push({
+          topic,
+          unknownAspects,
+          priority,
+          explorationCost,
+          expectedGain,
+        });
+      }
+    }
+
+    // priority 내림차순 정렬
+    gaps.sort((a, b) => b.priority - a.priority);
+    this.state.knowledgeGaps = gaps;
+
+    return gaps;
+  }
+
+  /**
+   * 호기심 기반 질문 생성
+   * topic + context를 바탕으로 탐색 질문 생성
+   */
+  generateQuestions(topic: string, context: string[]): string[] {
+    const questions: string[] = [
+      `${topic}란 무엇인가?`,
+      `${topic}은 어떻게 동작하는가?`,
+      `${topic}의 한계는 무엇인가?`,
+      `${topic}은 무엇과 연관되어 있는가?`,
+    ];
+
+    // context 기반 추가 질문
+    for (const ctx of context.slice(0, 3)) {
+      questions.push(`${ctx}와 ${topic}의 관계는?`);
+    }
+
+    return questions;
+  }
+
+  /**
+   * 탐색 우선순위 결정 (UCB1)
+   * topics 목록에서 UCB1 점수 기준 내림차순 정렬
+   */
+  prioritize(topics: string[]): string[] {
+    const C = Math.SQRT2;
+    const N = Math.max(1, this.totalVisits);
+
+    return [...topics].sort((a, b) => {
+      const sA = this.ucb1Stats.get(a) ?? { visits: 0, totalGain: 0 };
+      const sB = this.ucb1Stats.get(b) ?? { visits: 0, totalGain: 0 };
+
+      const scoreA = (sA.visits > 0 ? sA.totalGain / sA.visits : 0)
+        + C * Math.sqrt(Math.log(N + 1) / (sA.visits + 1));
+      const scoreB = (sB.visits > 0 ? sB.totalGain / sB.visits : 0)
+        + C * Math.sqrt(Math.log(N + 1) / (sB.visits + 1));
+
+      return scoreB - scoreA; // 내림차순
+    });
+  }
+
+  /**
+   * 탐색 이력 분석
+   */
+  analyzeExplorationHistory(): {
+    totalExplored: number;
+    avgInfoGain: number;
+    mostSurprising: string;
+    recommendations: string[];
+  } {
+    const history = this.state.explorationHistory;
+    const totalExplored = history.length;
+    const avgInfoGain = totalExplored > 0
+      ? history.reduce((s, h) => s + h.gain, 0) / totalExplored
+      : 0;
+
+    // 가장 높은 gain을 가진 탐색
+    const mostSurprising = history.length > 0
+      ? history.reduce((best, h) => h.gain > best.gain ? h : best, history[0]).topic
+      : "없음";
+
+    // 추천: frontier에서 UCB1 상위 3개
+    const topFrontier = this.prioritize(this.state.frontier).slice(0, 3);
+    const recommendations = topFrontier.length > 0
+      ? topFrontier.map(t => `${t} 탐색 권장`)
+      : ["탐색 대상 추가 필요"];
+
+    return { totalExplored, avgInfoGain, mostSurprising, recommendations };
+  }
+
+  /**
+   * 현재 상태 반환
+   */
+  getState(): CuriosityState {
+    return {
+      explored: new Set(this.state.explored),
+      frontier: [...this.state.frontier],
+      knowledgeGaps: [...this.state.knowledgeGaps],
+      curiosityScore: this.state.curiosityScore,
+      explorationHistory: [...this.state.explorationHistory],
+    };
+  }
+}
+
+// 전역 CuriosityEngine 인스턴스
+export const globalCuriosity = new CuriosityEngine();

package/src/debate.ts

@@ -0,0 +1,64 @@
+// FreeLang v9 Debate — 내부 찬반 에이전트 토론
+// Phase 113: [DEBATE :proposition "..." :pro fn :con fn :rounds 3 :judge fn]
+
+export interface Argument {
+  side: 'pro' | 'con';
+  point: string;
+  strength: number;   // 0.0~1.0
+}
+
+export interface DebateRound {
+  round: number;
+  proArgument: Argument;
+  conArgument: Argument;
+}
+
+export interface DebateResult {
+  proposition: string;
+  winner: 'pro' | 'con' | 'tie';
+  proScore: number;
+  conScore: number;
+  rounds: DebateRound[];
+  conclusion: string;
+}
+
+export interface DebateConfig {
+  proposition: string;
+  pro: (round: number, conArgs: Argument[]) => Argument;   // 찬성 에이전트
+  con: (round: number, proArgs: Argument[]) => Argument;   // 반대 에이전트
+  rounds?: number;                                          // 토론 라운드 수 (default: 3)
+  judge?: (proScore: number, conScore: number) => 'pro' | 'con' | 'tie'; // 판정
+}
+
+export class Debater {
+  debate(config: DebateConfig): DebateResult {
+    const { proposition, pro, con, rounds = 3 } = config;
+    const judge = config.judge ?? ((p, c) => p > c ? 'pro' : c > p ? 'con' : 'tie');
+
+    const debateRounds: DebateRound[] = [];
+    const proArgs: Argument[] = [];
+    const conArgs: Argument[] = [];
+
+    for (let r = 1; r <= rounds; r++) {
+      const proArg = pro(r, conArgs);
+      proArgs.push(proArg);
+
+      const conArg = con(r, proArgs);
+      conArgs.push(conArg);
+
+      debateRounds.push({ round: r, proArgument: proArg, conArgument: conArg });
+    }
+
+    const proScore = proArgs.reduce((s, a) => s + a.strength, 0) / proArgs.length;
+    const conScore = conArgs.reduce((s, a) => s + a.strength, 0) / conArgs.length;
+    const winner = judge(proScore, conScore);
+
+    const conclusion = winner === 'tie'
+      ? `"${proposition}" — 팽팽한 논쟁 (pro: ${proScore.toFixed(2)}, con: ${conScore.toFixed(2)})`
+      : `"${proposition}" — ${winner === 'pro' ? '채택' : '기각'} (승자: ${winner})`;
+
+    return { proposition, winner, proScore, conScore, rounds: debateRounds, conclusion };
+  }
+}
+
+export const globalDebater = new Debater();