freelang-editor 11.7.4

package/src/peer-review.ts

@@ -0,0 +1,53 @@
+// peer-review.ts — FreeLang v9 Phase 127: PEER-REVIEW
+// 에이전트 간 피어 리뷰 시스템
+
+export interface ReviewComment {
+  reviewerId: string;
+  aspect: string;
+  score: number;      // 0~1
+  comment: string;
+  suggestion?: string;
+}
+
+export interface ReviewResult {
+  targetId: string;
+  output: any;
+  comments: ReviewComment[];
+  averageScore: number;
+  approved: boolean;
+  summary: string;
+}
+
+export interface Reviewer {
+  id: string;
+  review: (output: any, context?: any) => ReviewComment;
+}
+
+export class PeerReviewSystem {
+  private reviewers: Map<string, Reviewer> = new Map();
+
+  addReviewer(reviewer: Reviewer): void { this.reviewers.set(reviewer.id, reviewer); }
+
+  review(targetId: string, output: any, reviewerIds?: string[], approvalThreshold = 0.7): ReviewResult {
+    const selected = reviewerIds
+      ? reviewerIds.map(id => this.reviewers.get(id)).filter(Boolean) as Reviewer[]
+      : [...this.reviewers.values()];
+
+    const comments = selected.map(r => r.review(output));
+    const averageScore = comments.length > 0
+      ? comments.reduce((s, c) => s + c.score, 0) / comments.length
+      : 0;
+    const approved = averageScore >= approvalThreshold;
+    const issues = comments.filter(c => c.score < approvalThreshold);
+    const summary = approved
+      ? `승인 (평균 점수: ${averageScore.toFixed(2)})`
+      : `반려 — ${issues.length}개 문제: ${issues.map(c => c.aspect).join(', ')}`;
+
+    return { targetId, output, comments, averageScore, approved, summary };
+  }
+
+  list(): string[] { return [...this.reviewers.keys()]; }
+  size(): number { return this.reviewers.size; }
+}
+
+export const globalPeerReview = new PeerReviewSystem();

package/src/predict.ts

@@ -0,0 +1,365 @@
+// predict.ts — Phase 144: [PREDICT] 예측 + 신뢰구간
+// AI가 미래를 예측하고 신뢰구간을 계산하는 시스템
+
+export interface Prediction {
+  value: number;       // 예측값
+  lower: number;       // 하한 (예: 95% CI)
+  upper: number;       // 상한
+  confidence: number;  // 신뢰 수준 (0~1, 예: 0.95)
+  method: string;      // 예측 방법
+  horizon?: number;    // 예측 시점 (스텝)
+}
+
+export interface TimeSeriesPrediction {
+  predictions: Prediction[];
+  trend: 'up' | 'down' | 'flat' | 'volatile';
+  seasonality?: number;  // 주기 (있으면)
+  accuracy?: number;     // 회고 정확도 (테스트 시)
+}
+
+export interface ClassificationPrediction {
+  classes: Array<{
+    label: string;
+    probability: number;
+  }>;
+  predicted: string;    // 최고 확률 클래스
+  confidence: number;
+}
+
+// 통계 유틸리티
+function mean(data: number[]): number {
+  if (data.length === 0) return 0;
+  return data.reduce((a, b) => a + b, 0) / data.length;
+}
+
+function variance(data: number[]): number {
+  if (data.length < 2) return 0;
+  const m = mean(data);
+  return data.reduce((sum, x) => sum + (x - m) ** 2, 0) / (data.length - 1);
+}
+
+function stddev(data: number[]): number {
+  return Math.sqrt(variance(data));
+}
+
+// 선형 회귀 계수 계산 (OLS)
+function linearFit(data: number[]): { slope: number; intercept: number } {
+  const n = data.length;
+  if (n === 0) return { slope: 0, intercept: 0 };
+  if (n === 1) return { slope: 0, intercept: data[0] };
+
+  const xs = Array.from({ length: n }, (_, i) => i);
+  const mx = mean(xs);
+  const my = mean(data);
+
+  let num = 0;
+  let den = 0;
+  for (let i = 0; i < n; i++) {
+    num += (xs[i] - mx) * (data[i] - my);
+    den += (xs[i] - mx) ** 2;
+  }
+
+  const slope = den === 0 ? 0 : num / den;
+  const intercept = my - slope * mx;
+  return { slope, intercept };
+}
+
+// 잔차 표준 오차 계산
+function residualStdError(data: number[], slope: number, intercept: number): number {
+  const n = data.length;
+  if (n < 3) return stddev(data) * 0.5;
+  const residuals = data.map((y, i) => y - (intercept + slope * i));
+  const sse = residuals.reduce((sum, r) => sum + r ** 2, 0);
+  return Math.sqrt(sse / (n - 2));
+}
+
+// z-score for confidence intervals
+function zScore(confidence: number): number {
+  // 근사치: 0.90→1.645, 0.95→1.96, 0.99→2.576
+  if (confidence >= 0.99) return 2.576;
+  if (confidence >= 0.975) return 2.24;
+  if (confidence >= 0.95) return 1.96;
+  if (confidence >= 0.90) return 1.645;
+  if (confidence >= 0.80) return 1.282;
+  return 1.0;
+}
+
+export class Predictor {
+  // 선형 회귀 예측
+  linearRegression(data: number[], horizon: number = 1): Prediction {
+    const { slope, intercept } = linearFit(data);
+    const nextIdx = data.length - 1 + horizon;
+    const value = intercept + slope * nextIdx;
+    const se = residualStdError(data, slope, intercept);
+    const z = zScore(0.95);
+    // 최소 margin: 데이터 범위의 5% 또는 se 기반 margin 중 큰 값
+    const minMargin = (Math.max(...data) - Math.min(...data)) * 0.05 + 1e-6;
+    const margin = Math.max(minMargin, z * se * Math.sqrt(1 + (1 / data.length)));
+
+    return {
+      value,
+      lower: value - margin,
+      upper: value + margin,
+      confidence: 0.95,
+      method: "linear-regression",
+      horizon,
+    };
+  }
+
+  // 이동 평균 예측
+  movingAverage(data: number[], window: number = 3, horizon: number = 1): Prediction {
+    const w = Math.min(window, data.length);
+    const slice = data.slice(data.length - w);
+    const value = mean(slice);
+    const sd = stddev(slice.length < 2 ? data : slice);
+    const z = zScore(0.95);
+    const margin = z * sd / Math.sqrt(w);
+
+    return {
+      value,
+      lower: value - margin,
+      upper: value + margin,
+      confidence: 0.95,
+      method: "moving-average",
+      horizon,
+    };
+  }
+
+  // 지수 평활 예측 (Exponential Smoothing)
+  exponentialSmoothing(data: number[], alpha: number = 0.3, horizon: number = 1): Prediction {
+    if (data.length === 0) {
+      return { value: 0, lower: 0, upper: 0, confidence: 0.95, method: "exponential-smoothing", horizon };
+    }
+
+    let smoothed = data[0];
+    for (let i = 1; i < data.length; i++) {
+      smoothed = alpha * data[i] + (1 - alpha) * smoothed;
+    }
+
+    const errors = [];
+    let s = data[0];
+    for (let i = 1; i < data.length; i++) {
+      const prev = s;
+      s = alpha * data[i] + (1 - alpha) * prev;
+      errors.push(data[i] - prev);
+    }
+
+    const se = errors.length > 0 ? stddev(errors) : stddev(data) * 0.5;
+    const z = zScore(0.95);
+    const margin = z * se;
+
+    return {
+      value: smoothed,
+      lower: smoothed - margin,
+      upper: smoothed + margin,
+      confidence: 0.95,
+      method: "exponential-smoothing",
+      horizon,
+    };
+  }
+
+  // 시계열 다중 예측
+  forecastTimeSeries(data: number[], steps: number = 3): TimeSeriesPrediction {
+    const trend = this.detectTrend(data);
+    const predictions: Prediction[] = [];
+
+    for (let h = 1; h <= steps; h++) {
+      predictions.push(this.linearRegression(data, h));
+    }
+
+    // 계절성 감지: 자기상관 이용
+    let seasonality: number | undefined = undefined;
+    if (data.length >= 8) {
+      const bestPeriod = this._detectSeasonality(data);
+      if (bestPeriod > 1) seasonality = bestPeriod;
+    }
+
+    // 회고 정확도: 마지막 20% 데이터로 검증
+    let accuracy: number | undefined = undefined;
+    if (data.length >= 5) {
+      const splitIdx = Math.floor(data.length * 0.8);
+      const trainData = data.slice(0, splitIdx);
+      const testData = data.slice(splitIdx);
+      const testPreds = testData.map((_, i) => {
+        const { slope, intercept } = linearFit(trainData);
+        return intercept + slope * (trainData.length + i);
+      });
+      const mae = mean(testData.map((actual, i) => Math.abs(actual - testPreds[i])));
+      const range = Math.max(...data) - Math.min(...data);
+      accuracy = range > 0 ? Math.max(0, 1 - mae / range) : 0.5;
+    }
+
+    return { predictions, trend, seasonality, accuracy };
+  }
+
+  // 신뢰구간 계산 (부트스트랩)
+  confidenceInterval(samples: number[], confidence: number = 0.95): { lower: number; upper: number } {
+    if (samples.length === 0) return { lower: 0, upper: 0 };
+
+    const sorted = [...samples].sort((a, b) => a - b);
+    const n = sorted.length;
+    const alpha = 1 - confidence;
+    const lowerIdx = Math.floor((alpha / 2) * n);
+    const upperIdx = Math.ceil((1 - alpha / 2) * n) - 1;
+
+    // 데이터가 적을 때는 정규 근사
+    if (n < 30) {
+      const m = mean(samples);
+      const sd = stddev(samples);
+      const z = zScore(confidence);
+      const margin = z * sd / Math.sqrt(n);
+      return { lower: m - margin, upper: m + margin };
+    }
+
+    return {
+      lower: sorted[Math.max(0, lowerIdx)],
+      upper: sorted[Math.min(n - 1, upperIdx)],
+    };
+  }
+
+  // 분류 예측 (K-NN 스타일 + 나이브 베이즈 유사)
+  classify(
+    features: Record<string, number>,
+    trainingData: Array<{ features: Record<string, number>; label: string }>
+  ): ClassificationPrediction {
+    if (trainingData.length === 0) {
+      return {
+        classes: [{ label: "unknown", probability: 1.0 }],
+        predicted: "unknown",
+        confidence: 0,
+      };
+    }
+
+    // 유클리드 거리 기반 KNN
+    const distances = trainingData.map(item => {
+      const keys = Object.keys(features);
+      let dist = 0;
+      for (const k of keys) {
+        const fv = features[k] ?? 0;
+        const tv = item.features[k] ?? 0;
+        dist += (fv - tv) ** 2;
+      }
+      return { label: item.label, dist: Math.sqrt(dist) };
+    });
+
+    distances.sort((a, b) => a.dist - b.dist);
+    const k = Math.min(5, distances.length);
+    const neighbors = distances.slice(0, k);
+
+    // 가중치: 거리 역수
+    const labelWeights: Record<string, number> = {};
+    let totalWeight = 0;
+    for (const n of neighbors) {
+      const w = n.dist === 0 ? 1e6 : 1 / (n.dist + 1e-10);
+      labelWeights[n.label] = (labelWeights[n.label] ?? 0) + w;
+      totalWeight += w;
+    }
+
+    const classes = Object.entries(labelWeights)
+      .map(([label, w]) => ({ label, probability: w / totalWeight }))
+      .sort((a, b) => b.probability - a.probability);
+
+    const predicted = classes[0]?.label ?? "unknown";
+    const confidence = classes[0]?.probability ?? 0;
+
+    return { classes, predicted, confidence };
+  }
+
+  // 예측 정확도 평가
+  evaluate(predictions: number[], actuals: number[]): {
+    mae: number;
+    rmse: number;
+    mape: number;
+  } {
+    const n = Math.min(predictions.length, actuals.length);
+    if (n === 0) return { mae: 0, rmse: 0, mape: 0 };
+
+    let sumAE = 0;
+    let sumSE = 0;
+    let sumAPE = 0;
+    let mapeCount = 0;
+
+    for (let i = 0; i < n; i++) {
+      const err = predictions[i] - actuals[i];
+      sumAE += Math.abs(err);
+      sumSE += err ** 2;
+      if (actuals[i] !== 0) {
+        sumAPE += Math.abs(err / actuals[i]) * 100;
+        mapeCount++;
+      }
+    }
+
+    return {
+      mae: sumAE / n,
+      rmse: Math.sqrt(sumSE / n),
+      mape: mapeCount > 0 ? sumAPE / mapeCount : 0,
+    };
+  }
+
+  // 트렌드 감지
+  detectTrend(data: number[]): 'up' | 'down' | 'flat' | 'volatile' {
+    if (data.length < 2) return 'flat';
+
+    const { slope, intercept } = linearFit(data);
+    const n = data.length;
+
+    // R-squared 계산으로 선형성 측정
+    const yMean = mean(data);
+    const ssTot = data.reduce((sum, y) => sum + (y - yMean) ** 2, 0);
+    const ssRes = data.reduce((sum, y, i) => sum + (y - (intercept + slope * i)) ** 2, 0);
+    const rSquared = ssTot > 0 ? 1 - ssRes / ssTot : 1;
+
+    // R-squared가 높으면 선형 트렌드 (up/down/flat)
+    if (rSquared >= 0.7) {
+      const range = Math.max(...data) - Math.min(...data);
+      const normalizedSlope = range > 0 ? slope / range : slope;
+      if (Math.abs(normalizedSlope) < 0.05) return 'flat';
+      if (normalizedSlope > 0) return 'up';
+      return 'down';
+    }
+
+    // 선형성이 낮을 때 CV로 판단
+    const sd = stddev(data);
+    const m = Math.abs(yMean);
+    const cv = m > 0 ? sd / m : sd;
+
+    if (cv > 0.3) return 'volatile';
+
+    const range = Math.max(...data) - Math.min(...data);
+    const normalizedSlope = range > 0 ? slope / range : slope;
+    if (Math.abs(normalizedSlope) < 0.05) return 'flat';
+    if (normalizedSlope > 0) return 'up';
+    return 'down';
+  }
+
+  // 계절성 감지 (자기상관 기반)
+  private _detectSeasonality(data: number[]): number {
+    const n = data.length;
+    const m = mean(data);
+    let bestPeriod = 0;
+    let bestCorr = 0;
+
+    const maxLag = Math.floor(n / 2);
+    for (let lag = 2; lag <= maxLag; lag++) {
+      let num = 0;
+      let den1 = 0;
+      let den2 = 0;
+      for (let i = lag; i < n; i++) {
+        const a = data[i] - m;
+        const b = data[i - lag] - m;
+        num += a * b;
+        den1 += a ** 2;
+        den2 += b ** 2;
+      }
+      const corr = (den1 * den2 > 0) ? num / Math.sqrt(den1 * den2) : 0;
+      if (corr > bestCorr) {
+        bestCorr = corr;
+        bestPeriod = lag;
+      }
+    }
+
+    return bestCorr > 0.5 ? bestPeriod : 0;
+  }
+}
+
+export const globalPredictor = new Predictor();

package/src/profiler.ts

@@ -0,0 +1,150 @@
+// FreeLang v9: Performance Profiler
+// Phase 82: 함수별 호출 횟수, 실행 시간, selfMs 측정
+
+export interface ProfileEntry {
+  name: string;
+  callCount: number;
+  totalMs: number;
+  selfMs: number;       // 자식 호출 제외한 자신의 시간
+  avgMs: number;
+  maxMs: number;
+  minMs: number;
+}
+
+interface ActiveCall {
+  name: string;
+  startMs: number;
+  childMs: number;  // 자식 호출에 쓴 시간
+}
+
+export class Profiler {
+  enabled: boolean = false;
+
+  private entries: Map<string, {
+    callCount: number;
+    totalMs: number;
+    selfMs: number;
+    maxMs: number;
+    minMs: number;
+  }> = new Map();
+
+  // 호출 스택: selfMs(자식 제외 시간) 계산용
+  private callStack: ActiveCall[] = [];
+
+  /**
+   * enter(name) → exit 함수 반환
+   * exit 호출 시 경과 시간 기록
+   */
+  enter(name: string): () => void {
+    if (!this.enabled) return () => {};
+
+    const startMs = performance.now();
+    const stackEntry: ActiveCall = { name, startMs, childMs: 0 };
+    this.callStack.push(stackEntry);
+
+    return () => {
+      const endMs = performance.now();
+      const durationMs = endMs - startMs;
+      const selfMs = durationMs - stackEntry.childMs;
+
+      // 스택에서 제거
+      const idx = this.callStack.lastIndexOf(stackEntry);
+      if (idx !== -1) this.callStack.splice(idx, 1);
+
+      // 부모에게 자식 시간 누산
+      if (this.callStack.length > 0) {
+        this.callStack[this.callStack.length - 1].childMs += durationMs;
+      }
+
+      this._addEntry(name, durationMs, selfMs);
+    };
+  }
+
+  /**
+   * record(name, ms): 직접 기록 (selfMs = ms로 가정)
+   */
+  record(name: string, ms: number): void {
+    if (!this.enabled) return;
+    this._addEntry(name, ms, ms);
+  }
+
+  private _addEntry(name: string, totalMs: number, selfMs: number): void {
+    const existing = this.entries.get(name);
+    if (existing) {
+      existing.callCount++;
+      existing.totalMs += totalMs;
+      existing.selfMs += selfMs;
+      if (totalMs > existing.maxMs) existing.maxMs = totalMs;
+      if (totalMs < existing.minMs) existing.minMs = totalMs;
+    } else {
+      this.entries.set(name, {
+        callCount: 1,
+        totalMs,
+        selfMs,
+        maxMs: totalMs,
+        minMs: totalMs,
+      });
+    }
+  }
+
+  /**
+   * getReport(): callCount 내림차순 정렬된 ProfileEntry 배열
+   */
+  getReport(): ProfileEntry[] {
+    const result: ProfileEntry[] = [];
+    for (const [name, data] of this.entries) {
+      result.push({
+        name,
+        callCount: data.callCount,
+        totalMs: data.totalMs,
+        selfMs: data.selfMs,
+        avgMs: data.totalMs / data.callCount,
+        maxMs: data.maxMs,
+        minMs: data.minMs,
+      });
+    }
+    result.sort((a, b) => b.callCount - a.callCount);
+    return result;
+  }
+
+  /**
+   * getTop(n): 상위 N개 반환
+   */
+  getTop(n: number): ProfileEntry[] {
+    return this.getReport().slice(0, n);
+  }
+
+  /**
+   * reset(): 모든 데이터 초기화
+   */
+  reset(): void {
+    this.entries.clear();
+    this.callStack = [];
+  }
+
+  /**
+   * toMarkdown(): Markdown 테이블 출력
+   */
+  toMarkdown(): string {
+    const report = this.getReport();
+    if (report.length === 0) {
+      return "| name | calls | totalMs | selfMs | avgMs | maxMs | minMs |\n|------|-------|---------|--------|-------|-------|-------|\n";
+    }
+    const header = "| name | calls | totalMs | selfMs | avgMs | maxMs | minMs |";
+    const divider = "|------|-------|---------|--------|-------|-------|-------|";
+    const rows = report.map(e =>
+      `| ${e.name} | ${e.callCount} | ${e.totalMs.toFixed(3)} | ${e.selfMs.toFixed(3)} | ${e.avgMs.toFixed(3)} | ${e.maxMs.toFixed(3)} | ${e.minMs.toFixed(3)} |`
+    );
+    return [header, divider, ...rows].join("\n");
+  }
+
+  /**
+   * toJSON(): ProfileEntry 배열을 JSON 객체로
+   */
+  toJSON(): object {
+    return this.getReport();
+  }
+}
+
+// 싱글턴 인스턴스
+export const globalProfiler = new Profiler();

package/src/prompt-compiler.ts

@@ -0,0 +1,123 @@
+// FreeLang v9 Prompt Compiler
+// Phase 109: FL 코드 → LLM 프롬프트 문자열 컴파일
+
+export type PromptTarget = 'claude' | 'gpt' | 'generic';
+
+export interface CompileResult {
+  prompt: string;
+  target: PromptTarget;
+  tokens: number;        // 추정 토큰 수
+  sections: string[];    // 사용된 섹션들
+}
+
+export interface PromptSection {
+  name: string;
+  content: string;
+  priority: number;      // 1=필수, 0.5=권장, 0=선택
+}
+
+// FL 블록 타입 → 프롬프트 섹션 매핑
+const BLOCK_TEMPLATES: Record<string, (args: Record<string, any>) => PromptSection> = {
+  COT: (args) => ({
+    name: 'chain-of-thought',
+    priority: 1,
+    content: `Think step by step:\n${
+      (args.steps ?? []).map((s: string, i: number) => `${i+1}. ${s}`).join('\n')
+    }\nThen provide your conclusion.`
+  }),
+  TOT: (args) => ({
+    name: 'tree-of-thought',
+    priority: 1,
+    content: `Explore multiple approaches:\n${
+      (args.branches ?? []).map((b: string) => `- ${b}`).join('\n')
+    }\nEvaluate each and select the best.`
+  }),
+  REFLECT: (args) => ({
+    name: 'self-reflection',
+    priority: 0.5,
+    content: `After responding, reflect on:\n${
+      (args.criteria ?? ['accuracy', 'completeness']).map((c: string) => `- ${c}`).join('\n')
+    }\nScore each criterion (0-10) and revise if below ${(args.threshold ?? 0.7) * 10}.`
+  }),
+  AGENT: (args) => ({
+    name: 'agent-loop',
+    priority: 1,
+    content: `Goal: ${args.goal ?? 'Complete the task'}\nMax steps: ${args.maxSteps ?? 5}\nFor each step: observe → think → act → verify.`
+  }),
+  CONTEXT: (args) => ({
+    name: 'context',
+    priority: 1,
+    content: `Context window: ${args.maxTokens ?? 4096} tokens. Strategy: ${args.strategy ?? 'sliding'}.`
+  }),
+  'SELF-IMPROVE': (args) => ({
+    name: 'self-improvement',
+    priority: 0.5,
+    content: `Iterations: ${args.iterations ?? 3}. After each response, evaluate and improve until satisfied.`
+  }),
+};
+
+export class PromptCompiler {
+  private target: PromptTarget;
+
+  constructor(target: PromptTarget = 'claude') {
+    this.target = target;
+  }
+
+  // FL 블록 정보 → 프롬프트 섹션
+  compileBlock(blockType: string, args: Record<string, any> = {}): PromptSection | null {
+    const template = BLOCK_TEMPLATES[blockType];
+    if (!template) return null;
+    return template(args);
+  }
+
+  // 여러 섹션 → 최종 프롬프트
+  compile(sections: PromptSection[], userInstruction: string): CompileResult {
+    // 우선순위 정렬
+    const sorted = [...sections].sort((a, b) => b.priority - a.priority);
+    const parts: string[] = [];
+
+    if (this.target === 'claude') {
+      parts.push('Human: ' + userInstruction);
+      parts.push('\n[Instructions]');
+      sorted.forEach(s => { if (s.content) parts.push(s.content); });
+      parts.push('\nAssistant:');
+    } else if (this.target === 'gpt') {
+      parts.push('[System]');
+      sorted.forEach(s => { if (s.content) parts.push(s.content); });
+      parts.push('\n[User]: ' + userInstruction);
+    } else {
+      sorted.forEach(s => { if (s.content) parts.push(s.content); });
+      parts.push('\n' + userInstruction);
+    }
+
+    const prompt = parts.join('\n');
+    return {
+      prompt,
+      target: this.target,
+      tokens: Math.ceil(prompt.length / 4),
+      sections: sorted.map(s => s.name)
+    };
+  }
+
+  // FL 코드 문자열에서 블록 감지 후 컴파일
+  compileFromCode(flCode: string, instruction: string): CompileResult {
+    const sections: PromptSection[] = [];
+    const blockRegex = /\[(COT|TOT|REFLECT|AGENT|CONTEXT|SELF-IMPROVE)[^\]]*\]/g;
+    let match;
+    while ((match = blockRegex.exec(flCode)) !== null) {
+      const blockType = match[1];
+      const section = this.compileBlock(blockType, {});
+      if (section) sections.push(section);
+    }
+    if (sections.length === 0) {
+      sections.push({ name: 'default', content: '', priority: 0.5 });
+    }
+    return this.compile(sections, instruction);
+  }
+
+  setTarget(target: PromptTarget): void { this.target = target; }
+
+  getTarget(): PromptTarget { return this.target; }
+}
+
+export const globalCompiler = new PromptCompiler('claude');