freelang-editor 11.7.4

package/src/protocol.ts

@@ -0,0 +1,114 @@
+// protocol.ts — FreeLang v9 Phase 64: Protocol/Interface System
+// defprotocol + impl 다형성 지원
+
+export interface ProtocolMethod {
+  name: string;
+  params: string[];
+  returnType?: string;
+}
+
+export interface Protocol {
+  name: string;
+  methods: ProtocolMethod[];
+}
+
+export interface ProtocolImpl {
+  protocolName: string;
+  typeName: string;
+  methods: Map<string, { params: string[]; body: any }>;
+}
+
+export class ProtocolRegistry {
+  // protocolName → Protocol
+  private protocols = new Map<string, Protocol>();
+  // "ProtocolName:TypeName" → ProtocolImpl
+  private impls = new Map<string, ProtocolImpl>();
+  // methodName → Set<protocolName> (역인덱스: 어떤 프로토콜에 속하는지)
+  private methodIndex = new Map<string, Set<string>>();
+
+  defineProtocol(proto: Protocol): void {
+    this.protocols.set(proto.name, proto);
+    for (const method of proto.methods) {
+      if (!this.methodIndex.has(method.name)) {
+        this.methodIndex.set(method.name, new Set());
+      }
+      this.methodIndex.get(method.name)!.add(proto.name);
+    }
+  }
+
+  defineImpl(impl: ProtocolImpl): void {
+    const key = `${impl.protocolName}:${impl.typeName}`;
+    this.impls.set(key, impl);
+  }
+
+  /**
+   * (serialize p) 호출 시:
+   * 1. methodName("serialize")이 어떤 프로토콜에 속하는지 역인덱스로 탐색
+   * 2. value.__type ("Point") 확인
+   * 3. "Serializable:Point" impl 찾아 반환
+   */
+  resolveMethod(methodName: string, value: any): ProtocolImpl | null {
+    const typeName = this.extractTypeName(value);
+    if (!typeName) return null;
+
+    const protoNames = this.methodIndex.get(methodName);
+    if (!protoNames) return null;
+
+    for (const protoName of protoNames) {
+      const key = `${protoName}:${typeName}`;
+      const impl = this.impls.get(key);
+      if (impl && impl.methods.has(methodName)) {
+        return impl;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * 특정 타입이 프로토콜의 특정 메서드를 구현하고 있는지 확인
+   */
+  resolveMethodForType(methodName: string, typeName: string): ProtocolImpl | null {
+    const protoNames = this.methodIndex.get(methodName);
+    if (!protoNames) return null;
+
+    for (const protoName of protoNames) {
+      const key = `${protoName}:${typeName}`;
+      const impl = this.impls.get(key);
+      if (impl && impl.methods.has(methodName)) {
+        return impl;
+      }
+    }
+    return null;
+  }
+
+  hasMethod(methodName: string): boolean {
+    return this.methodIndex.has(methodName);
+  }
+
+  getProtocol(name: string): Protocol | undefined {
+    return this.protocols.get(name);
+  }
+
+  getImpl(protocolName: string, typeName: string): ProtocolImpl | undefined {
+    return this.impls.get(`${protocolName}:${typeName}`);
+  }
+
+  /**
+   * 값에서 타입명 추출:
+   * - value.__type: "Point" → "Point"
+   * - Array → "List"
+   * - string → "String"
+   * - number → "Number"
+   */
+  extractTypeName(value: any): string | null {
+    if (value === null || value === undefined) return null;
+    if (typeof value === "object" && !Array.isArray(value)) {
+      if (value.__type) return String(value.__type);
+    }
+    if (Array.isArray(value)) return "List";
+    if (typeof value === "string") return "String";
+    if (typeof value === "number") return "Number";
+    if (typeof value === "boolean") return "Boolean";
+    return null;
+  }
+}

package/src/prune.ts

@@ -0,0 +1,195 @@
+// FreeLang v9 Prune — 쓸모없는 것 자동 제거
+// Phase 136: [PRUNE] AI가 저품질/불필요한 항목을 자동 제거한다
+
+export type PruneStrategy = 'threshold' | 'top-k' | 'top-percent' | 'pareto' | 'diversity';
+
+export interface PruneConfig {
+  strategy: PruneStrategy;
+  threshold?: number;     // threshold 전략: 이 값 미만 제거
+  k?: number;             // top-k 전략: 상위 k개만 유지
+  percent?: number;       // top-percent 전략: 상위 N% 유지
+  minDiversity?: number;  // diversity 전략: 최소 다양성
+}
+
+export interface PruneResult<T> {
+  kept: T[];              // 유지된 항목
+  removed: T[];           // 제거된 항목
+  keptRatio: number;      // 유지 비율
+  strategy: PruneStrategy;
+  stats: {
+    originalCount: number;
+    keptCount: number;
+    removedCount: number;
+    avgFitnessKept: number;
+    avgFitnessRemoved: number;
+  };
+}
+
+function average(nums: number[]): number {
+  if (nums.length === 0) return 0;
+  return nums.reduce((a, b) => a + b, 0) / nums.length;
+}
+
+function buildResult<T>(
+  kept: T[],
+  removed: T[],
+  scorer: (item: T) => number | null,
+  strategy: PruneStrategy,
+  originalCount: number
+): PruneResult<T> {
+  const keptFitness = scorer ? kept.map(scorer).filter((n): n is number => n !== null) : [];
+  const removedFitness = scorer ? removed.map(scorer).filter((n): n is number => n !== null) : [];
+  const total = kept.length + removed.length;
+  return {
+    kept,
+    removed,
+    keptRatio: total === 0 ? 1 : kept.length / total,
+    strategy,
+    stats: {
+      originalCount,
+      keptCount: kept.length,
+      removedCount: removed.length,
+      avgFitnessKept: average(keptFitness),
+      avgFitnessRemoved: average(removedFitness),
+    },
+  };
+}
+
+export class Pruner<T> {
+  private config: Partial<PruneConfig>;
+
+  constructor(config?: Partial<PruneConfig>) {
+    this.config = config ?? {};
+  }
+
+  // 임계값 기반 제거: score < threshold 이면 제거
+  pruneByThreshold(items: T[], scorer: (item: T) => number, threshold: number): PruneResult<T> {
+    const original = [...items];
+    const kept: T[] = [];
+    const removed: T[] = [];
+    for (const item of original) {
+      if (scorer(item) >= threshold) kept.push(item);
+      else removed.push(item);
+    }
+    return buildResult(kept, removed, scorer, 'threshold', original.length);
+  }
+
+  // 상위 K개만 유지
+  pruneToTopK(items: T[], scorer: (item: T) => number, k: number): PruneResult<T> {
+    const original = [...items];
+    const sorted = [...original].sort((a, b) => scorer(b) - scorer(a));
+    const effectiveK = Math.min(k, original.length);
+    const kept = sorted.slice(0, effectiveK);
+    const keptSet = new Set(kept);
+    const removed = original.filter(item => !keptSet.has(item));
+    return buildResult(kept, removed, scorer, 'top-k', original.length);
+  }
+
+  // 상위 N% 유지 (최소 1개)
+  pruneToTopPercent(items: T[], scorer: (item: T) => number, percent: number): PruneResult<T> {
+    const original = [...items];
+    const k = Math.max(1, Math.ceil(original.length * percent));
+    return this.pruneToTopK(original, scorer, k);
+  }
+
+  // 다양성 기반 제거 (너무 유사한 것 제거)
+  pruneForDiversity(
+    items: T[],
+    scorer: (item: T) => number,
+    similarity: (a: T, b: T) => number,
+    minDiversity: number
+  ): PruneResult<T> {
+    const original = [...items];
+    if (original.length === 0) {
+      return buildResult([], [], scorer, 'diversity', 0);
+    }
+
+    // 점수 내림차순 정렬
+    const sorted = [...original].sort((a, b) => scorer(b) - scorer(a));
+    const kept: T[] = [];
+
+    for (const candidate of sorted) {
+      // 이미 kept에 있는 항목들과 너무 유사하면 제거
+      const tooSimilar = kept.some(existing => similarity(candidate, existing) > (1 - minDiversity));
+      if (!tooSimilar) {
+        kept.push(candidate);
+      }
+    }
+
+    const keptSet = new Set(kept);
+    const removed = original.filter(item => !keptSet.has(item));
+    return buildResult(kept, removed, scorer, 'diversity', original.length);
+  }
+
+  // 중복 제거 (정확히 같은 것)
+  dedup(items: T[], key?: (item: T) => string): PruneResult<T> {
+    const original = [...items];
+    const seen = new Set<string>();
+    const kept: T[] = [];
+    const removed: T[] = [];
+
+    for (const item of original) {
+      const k = key ? key(item) : JSON.stringify(item);
+      if (!seen.has(k)) {
+        seen.add(k);
+        kept.push(item);
+      } else {
+        removed.push(item);
+      }
+    }
+
+    // dedup은 scorer가 없으므로 null scorer 사용
+    return buildResult(kept, removed, () => 0, 'threshold', original.length);
+  }
+
+  // 약한 개체 제거 (평균 이하)
+  pruneWeak(items: T[], scorer: (item: T) => number): PruneResult<T> {
+    const original = [...items];
+    if (original.length === 0) {
+      return buildResult([], [], scorer, 'threshold', 0);
+    }
+    const scores = original.map(scorer);
+    const avg = average(scores);
+    const kept: T[] = [];
+    const removed: T[] = [];
+    for (let i = 0; i < original.length; i++) {
+      if (scores[i] >= avg) kept.push(original[i]);
+      else removed.push(original[i]);
+    }
+    return buildResult(kept, removed, scorer, 'threshold', original.length);
+  }
+
+  // 자동 전략 적용 (설정된 전략 사용, 기본값 top-k with k=10)
+  prune(items: T[], scorer: (item: T) => number): PruneResult<T> {
+    const strategy = this.config.strategy ?? 'top-k';
+    switch (strategy) {
+      case 'threshold':
+        return this.pruneByThreshold(items, scorer, this.config.threshold ?? 0.5);
+      case 'top-k':
+        return this.pruneToTopK(items, scorer, this.config.k ?? 10);
+      case 'top-percent':
+        return this.pruneToTopPercent(items, scorer, this.config.percent ?? 0.5);
+      case 'diversity':
+        return this.pruneForDiversity(
+          items, scorer,
+          (a, b) => (a === b ? 1 : 0),
+          this.config.minDiversity ?? 0.2
+        );
+      default:
+        return this.pruneWeak(items, scorer);
+    }
+  }
+}
+
+export const globalPruner: Pruner<unknown> = new Pruner<unknown>();
+
+export function keepBest<T>(items: T[], scorer: (item: T) => number, k: number): T[] {
+  const sorted = [...items].sort((a, b) => scorer(b) - scorer(a));
+  return sorted.slice(0, Math.min(k, items.length));
+}
+
+export function removeWeak<T>(items: T[], scorer: (item: T) => number): T[] {
+  const scores = items.map(scorer);
+  const avg = average(scores);
+  return items.filter((_, i) => scores[i] >= avg);
+}

package/src/quality-loop.ts

@@ -0,0 +1,105 @@
+// FreeLang v9 Quality Evaluation Loop
+// Phase 106: 자동 품질 평가 루프
+// (quality-check output criteria-list) → QualityResult
+// (quality-loop :generate fn :evaluate fn :threshold 0.8 :max-rounds 3)
+
+export interface QualityCriterion {
+  name: string;
+  weight: number;           // 0.0~1.0
+  evaluate: (output: any) => number; // 0.0~1.0
+}
+
+export interface QualityResult {
+  score: number;            // 가중 평균
+  passed: boolean;
+  breakdown: Record<string, number>;  // 기준별 점수
+  feedback: string[];
+}
+
+export interface QualityLoopResult<T> {
+  output: T;
+  rounds: number;
+  finalScore: number;
+  passed: boolean;
+  history: Array<{ round: number; output: T; score: number }>;
+}
+
+// 품질 평가
+export function evaluateQuality(output: any, criteria: QualityCriterion[], threshold = 0.7): QualityResult {
+  let totalWeight = 0;
+  let weightedScore = 0;
+  const breakdown: Record<string, number> = {};
+  const feedback: string[] = [];
+
+  for (const c of criteria) {
+    const score = Math.max(0, Math.min(1, c.evaluate(output)));
+    breakdown[c.name] = score;
+    weightedScore += score * c.weight;
+    totalWeight += c.weight;
+    if (score < threshold) {
+      feedback.push(`${c.name}: ${(score * 100).toFixed(0)}% (기준 미달)`);
+    }
+  }
+
+  const finalScore = totalWeight > 0 ? weightedScore / totalWeight : 0;
+  return {
+    score: finalScore,
+    passed: finalScore >= threshold,
+    breakdown,
+    feedback
+  };
+}
+
+// 품질 루프: 기준 충족할 때까지 재생성
+export async function qualityLoop<T>(config: {
+  generate: (round: number, prevOutput?: T, prevResult?: QualityResult) => T | Promise<T>;
+  criteria: QualityCriterion[];
+  threshold?: number;
+  maxRounds?: number;
+}): Promise<QualityLoopResult<T>> {
+  const { generate, criteria, threshold = 0.7, maxRounds = 3 } = config;
+  const history: QualityLoopResult<T>['history'] = [];
+  let output!: T;
+  let finalScore = 0;
+  let passed = false;
+  let prevOutput: T | undefined;
+  let prevResult: QualityResult | undefined;
+
+  for (let round = 1; round <= maxRounds; round++) {
+    output = await Promise.resolve(generate(round, prevOutput, prevResult));
+    const result = evaluateQuality(output, criteria, threshold);
+    finalScore = result.score;
+    passed = result.passed;
+    history.push({ round, output, score: finalScore });
+
+    if (passed) break;
+    prevOutput = output;
+    prevResult = result;
+  }
+
+  return { output, rounds: history.length, finalScore, passed, history };
+}
+
+// 기본 품질 기준들
+export const defaultCriteria: QualityCriterion[] = [
+  {
+    name: 'length',
+    weight: 0.3,
+    evaluate: (v) => {
+      const s = String(v);
+      if (s.length < 10) return 0.3;
+      if (s.length < 50) return 0.7;
+      return 1.0;
+    }
+  },
+  {
+    name: 'non-empty',
+    weight: 0.4,
+    evaluate: (v) => (v !== null && v !== undefined && v !== '') ? 1.0 : 0.0
+  },
+  {
+    name: 'no-error',
+    weight: 0.3,
+    evaluate: (v) => (v instanceof Error || (typeof v === 'object' && v?._tag === 'Err')) ? 0.0 : 1.0
+  }
+];

package/src/rag.ts

@@ -0,0 +1,81 @@
+// FreeLang v9 RAG — Retrieval-Augmented Generation
+// Phase 102: [RAG :query "..." :docs [...] :top 3 :augment fn]
+
+export interface RAGDocument {
+  id: string;
+  content: string;
+  metadata?: Record<string, any>;
+  score?: number;
+}
+
+export interface RAGResult {
+  query: string;
+  retrieved: RAGDocument[];
+  augmented: string;
+}
+
+// TF-IDF 기반 유사도 (외부 라이브러리 불필요)
+export function tokenize(text: string): string[] {
+  return text.toLowerCase().replace(/[^a-z0-9가-힣\s]/g, '').split(/\s+/).filter(Boolean);
+}
+
+export function tfidf(query: string[], doc: string[]): number {
+  const docSet = new Set(doc);
+  const overlap = query.filter(t => docSet.has(t)).length;
+  if (overlap === 0) return 0;
+  return overlap / (Math.sqrt(query.length) * Math.sqrt(doc.length));
+}
+
+export class RAGStore {
+  private docs: RAGDocument[] = [];
+
+  // 문서 추가
+  add(doc: RAGDocument): void {
+    this.docs.push(doc);
+  }
+
+  addMany(docs: RAGDocument[]): void {
+    docs.forEach(d => this.add(d));
+  }
+
+  // 검색
+  retrieve(query: string, topK: number = 3): RAGDocument[] {
+    const queryTokens = tokenize(query);
+    return this.docs
+      .map(doc => ({
+        ...doc,
+        score: tfidf(queryTokens, tokenize(doc.content))
+      }))
+      .filter(d => (d.score ?? 0) > 0)
+      .sort((a, b) => (b.score ?? 0) - (a.score ?? 0))
+      .slice(0, topK);
+  }
+
+  // RAG 실행: 검색 + augment 함수로 최종 응답 생성
+  query(queryStr: string, options: {
+    topK?: number;
+    augment?: (query: string, docs: RAGDocument[]) => string;
+  } = {}): RAGResult {
+    const retrieved = this.retrieve(queryStr, options.topK ?? 3);
+    const augmented = options.augment
+      ? options.augment(queryStr, retrieved)
+      : `Query: ${queryStr}\n\nContext:\n${retrieved.map(d => d.content).join('\n---\n')}`;
+    return { query: queryStr, retrieved, augmented };
+  }
+
+  // 문서 삭제
+  remove(id: string): boolean {
+    const idx = this.docs.findIndex(d => d.id === id);
+    if (idx === -1) return false;
+    this.docs.splice(idx, 1);
+    return true;
+  }
+
+  size(): number { return this.docs.length; }
+  all(): RAGDocument[] { return [...this.docs]; }
+
+  // 초기화
+  clear(): void { this.docs = []; }
+}
+
+export const globalRAG = new RAGStore();

package/src/reasoning-debugger.ts

@@ -0,0 +1,122 @@
+// FreeLang v9 Reasoning Debugger
+// Phase 108: AI 추론 과정 추적 + 시각화
+
+export type TraceNodeType = 'thought' | 'action' | 'observation' | 'decision' | 'error' | 'result';
+
+export interface TraceNode {
+  id: string;
+  type: TraceNodeType;
+  label: string;
+  value?: any;
+  children: TraceNode[];
+  depth: number;
+  timestamp: number;
+  duration?: number;  // ms
+}
+
+export class ReasoningTrace {
+  private root: TraceNode;
+  private current: TraceNode;
+  private stack: TraceNode[] = [];
+  private nodeCounter = 0;
+
+  constructor(label: string) {
+    this.root = this.makeNode('thought', label);
+    this.current = this.root;
+  }
+
+  private makeNode(type: TraceNodeType, label: string, value?: any): TraceNode {
+    return {
+      id: `node-${++this.nodeCounter}`,
+      type,
+      label,
+      value,
+      children: [],
+      depth: this.stack.length,
+      timestamp: Date.now()
+    };
+  }
+
+  // 새 단계 추가 (현재 노드의 자식)
+  add(type: TraceNodeType, label: string, value?: any): TraceNode {
+    const node = this.makeNode(type, label, value);
+    this.current.children.push(node);
+    return node;
+  }
+
+  // 들어가기 (자식으로 포커스 이동)
+  enter(type: TraceNodeType, label: string, value?: any): TraceNode {
+    const node = this.makeNode(type, label, value);
+    this.current.children.push(node);
+    this.stack.push(this.current);
+    this.current = node;
+    return node;
+  }
+
+  // 나오기 (부모로 복귀)
+  exit(result?: any): void {
+    if (this.stack.length > 0) {
+      if (result !== undefined) this.current.value = result;
+      this.current.duration = Date.now() - this.current.timestamp;
+      this.current = this.stack.pop()!;
+    }
+  }
+
+  // 마크다운으로 렌더링
+  toMarkdown(): string {
+    const lines: string[] = ['## Reasoning Trace', ''];
+    function render(node: TraceNode, depth: number) {
+      const indent = '  '.repeat(depth);
+      const icon = { thought: '💭', action: '⚡', observation: '👁', decision: '🎯', error: '❌', result: '✅' }[node.type];
+      const dur = node.duration ? ` (${node.duration}ms)` : '';
+      const val = node.value !== undefined ? ` → \`${JSON.stringify(node.value)}\`` : '';
+      lines.push(`${indent}${icon} **${node.label}**${val}${dur}`);
+      node.children.forEach(c => render(c, depth + 1));
+    }
+    render(this.root, 0);
+    return lines.join('\n');
+  }
+
+  // 텍스트 트리
+  toTree(): string {
+    const lines: string[] = [];
+    function render(node: TraceNode, prefix: string, isLast: boolean) {
+      const connector = isLast ? '└── ' : '├── ';
+      const val = node.value !== undefined ? `: ${JSON.stringify(node.value)}` : '';
+      lines.push(`${prefix}${connector}[${node.type}] ${node.label}${val}`);
+      const childPrefix = prefix + (isLast ? '    ' : '│   ');
+      node.children.forEach((c, i) => render(c, childPrefix, i === node.children.length - 1));
+    }
+    lines.push(`[root] ${this.root.label}`);
+    this.root.children.forEach((c, i) => render(c, '', i === this.root.children.length - 1));
+    return lines.join('\n');
+  }
+
+  getRoot(): TraceNode { return this.root; }
+  getCurrent(): TraceNode { return this.current; }
+  depth(): number { return this.stack.length; }
+  nodeCount(): number { return this.nodeCounter; }
+}
+
+// 글로벌 트레이스 레지스트리
+const traceRegistry = new Map<string, ReasoningTrace>();
+let traceCounter = 0;
+
+export function createTrace(label: string): { id: string; trace: ReasoningTrace } {
+  const id = `trace-${++traceCounter}`;
+  const trace = new ReasoningTrace(label);
+  traceRegistry.set(id, trace);
+  return { id, trace };
+}
+
+export function getTrace(id: string): ReasoningTrace | null {
+  return traceRegistry.get(id) ?? null;
+}
+
+export function deleteTrace(id: string): boolean {
+  return traceRegistry.delete(id);
+}
+
+export function listTraces(): string[] {
+  return Array.from(traceRegistry.keys());
+}