freelang-editor 11.7.4

package/src/context-window.ts

@@ -0,0 +1,139 @@
+// context-window.ts — FreeLang v9 Phase 95
+// AI 컨텍스트 윈도우 관리: 무엇을 기억하고, 무엇을 버리고, 어떻게 압축할지
+
+export interface ContextEntry {
+  id: string;
+  content: any;
+  tokens: number;        // 토큰 수 추정
+  priority: number;      // 우선순위 (높을수록 보존, 0.0~1.0)
+  timestamp: number;
+  tags: string[];
+}
+
+export type ContextStrategy = "sliding" | "priority" | "summarize";
+
+export interface ContextWindow {
+  maxTokens: number;
+  entries: ContextEntry[];
+  usedTokens: number;
+  strategy: ContextStrategy;
+}
+
+let _idCounter = 0;
+function genId(): string {
+  return `ctx-${Date.now()}-${++_idCounter}`;
+}
+
+export class ContextManager {
+  private window: ContextWindow;
+
+  constructor(maxTokens: number = 4096, strategy: ContextStrategy = "priority") {
+    this.window = {
+      maxTokens,
+      entries: [],
+      usedTokens: 0,
+      strategy,
+    };
+  }
+
+  // 토큰 추정: JSON.stringify 길이 / 4 (근사값)
+  estimateTokens(content: any): number {
+    try {
+      const str = typeof content === "string" ? content : JSON.stringify(content);
+      return Math.max(1, Math.ceil(str.length / 4));
+    } catch {
+      return 1;
+    }
+  }
+
+  hasRoom(tokens: number): boolean {
+    return this.window.usedTokens + tokens <= this.window.maxTokens;
+  }
+
+  add(
+    content: any,
+    opts?: { priority?: number; tags?: string[]; tokens?: number }
+  ): string {
+    const tokens = opts?.tokens ?? this.estimateTokens(content);
+    const priority = opts?.priority ?? 0.5;
+    const tags = opts?.tags ?? [];
+    const id = genId();
+
+    const entry: ContextEntry = {
+      id,
+      content,
+      tokens,
+      priority,
+      timestamp: Date.now(),
+      tags,
+    };
+
+    this.window.entries.push(entry);
+    this.window.usedTokens += tokens;
+
+    // 용량 초과 시 자동 trim
+    if (this.window.usedTokens > this.window.maxTokens) {
+      this.trim();
+    }
+
+    return id;
+  }
+
+  get(id: string): ContextEntry | undefined {
+    return this.window.entries.find((e) => e.id === id);
+  }
+
+  remove(id: string): void {
+    const idx = this.window.entries.findIndex((e) => e.id === id);
+    if (idx !== -1) {
+      this.window.usedTokens -= this.window.entries[idx].tokens;
+      this.window.entries.splice(idx, 1);
+      if (this.window.usedTokens < 0) this.window.usedTokens = 0;
+    }
+  }
+
+  // 오래된/낮은 우선순위 항목 제거 — 용량이 확보될 때까지
+  trim(): ContextEntry[] {
+    const removed: ContextEntry[] = [];
+
+    if (this.window.usedTokens <= this.window.maxTokens) {
+      return removed;
+    }
+
+    // priority 낮은 순 → 오래된 순으로 정렬하여 제거
+    const sorted = [...this.window.entries].sort((a, b) => {
+      if (a.priority !== b.priority) return a.priority - b.priority;
+      return a.timestamp - b.timestamp;
+    });
+
+    for (const candidate of sorted) {
+      if (this.window.usedTokens <= this.window.maxTokens) break;
+      const idx = this.window.entries.findIndex((e) => e.id === candidate.id);
+      if (idx !== -1) {
+        this.window.usedTokens -= this.window.entries[idx].tokens;
+        removed.push(this.window.entries[idx]);
+        this.window.entries.splice(idx, 1);
+      }
+    }
+
+    if (this.window.usedTokens < 0) this.window.usedTokens = 0;
+    return removed;
+  }
+
+  // 압축: fn이 entries를 받아 새 값 반환
+  compress(fn: (entries: ContextEntry[]) => any): any {
+    return fn(this.window.entries);
+  }
+
+  getAll(tag?: string): ContextEntry[] {
+    if (!tag) return [...this.window.entries];
+    return this.window.entries.filter((e) => e.tags.includes(tag));
+  }
+
+  stats(): { used: number; max: number; percent: number; count: number } {
+    const used = this.window.usedTokens;
+    const max = this.window.maxTokens;
+    const percent = max > 0 ? Math.round((used / max) * 100) : 0;
+    return { used, max, percent, count: this.window.entries.length };
+  }
+}

package/src/cot.ts

@@ -0,0 +1,241 @@
+// cot.ts — FreeLang v9 Phase 92: Chain-of-Thought 런타임
+// AI 단계별 추론을 언어의 기본 블록으로 구현
+
+export interface ThoughtStep {
+  id: string;
+  thought: string;        // 이 단계에서 한 생각
+  result: any;            // 이 단계의 결과값
+  confidence?: number;    // 이 단계의 확신도 (0.0~1.0)
+  durationMs?: number;    // 실행 시간 (ms)
+}
+
+export interface CoTResult {
+  steps: ThoughtStep[];
+  conclusion: any;        // 최종 결론
+  totalSteps: number;
+  confidence?: number;    // 전체 평균 확신도
+}
+
+/**
+ * ChainOfThought — AI 단계별 추론 런타임
+ *
+ * 사용 예:
+ *   const cot = new ChainOfThought();
+ *   cot.step("숫자 더하기", () => 2 + 3);
+ *   cot.step("결과 두 배", () => 10);
+ *   const result = cot.conclude(steps => steps[steps.length - 1].result);
+ */
+export class ChainOfThought {
+  private steps: ThoughtStep[] = [];
+
+  /**
+   * 추론 단계 추가 + 즉시 실행
+   * @param thought 이 단계에서 하는 생각 (설명)
+   * @param fn      실행할 함수. prev는 이전 단계 결과.
+   * @param confidence 선택적 확신도 (0.0~1.0)
+   */
+  step(thought: string, fn: (prev?: any) => any, confidence?: number): this {
+    const id = `step-${this.steps.length + 1}`;
+    const prev = this.steps.length > 0
+      ? this.steps[this.steps.length - 1].result
+      : undefined;
+
+    const startMs = Date.now();
+    let result: any;
+    let error: any;
+    try {
+      result = fn(prev);
+    } catch (e) {
+      error = e;
+      result = { kind: "cot-error", error: e instanceof Error ? e.message : String(e) };
+    }
+    const durationMs = Date.now() - startMs;
+
+    const thoughtStep: ThoughtStep = { id, thought, result, durationMs };
+    if (confidence !== undefined) thoughtStep.confidence = confidence;
+
+    this.steps.push(thoughtStep);
+
+    // 에러가 있으면 다시 throw (TC-19)
+    if (error !== undefined) throw error;
+
+    return this;
+  }
+
+  /**
+   * 결론 도출 — 모든 단계 완료 후 최종 결론 계산
+   * @param fn 모든 steps 배열을 받아 결론 반환
+   */
+  conclude(fn: (steps: ThoughtStep[]) => any): CoTResult {
+    const conclusion = fn(this.steps);
+
+    const confidenceValues = this.steps
+      .filter(s => s.confidence !== undefined)
+      .map(s => s.confidence as number);
+    const avgConfidence = confidenceValues.length > 0
+      ? confidenceValues.reduce((a, b) => a + b, 0) / confidenceValues.length
+      : undefined;
+
+    return {
+      steps: [...this.steps],
+      conclusion,
+      totalSteps: this.steps.length,
+      confidence: avgConfidence,
+    };
+  }
+
+  /** 현재까지 쌓인 단계 배열 반환 */
+  getSteps(): ThoughtStep[] {
+    return [...this.steps];
+  }
+
+  /**
+   * 추론 과정을 마크다운으로 시각화
+   */
+  toMarkdown(): string {
+    const lines: string[] = ["# Chain-of-Thought 추론\n"];
+    for (let i = 0; i < this.steps.length; i++) {
+      const s = this.steps[i];
+      lines.push(`## Step ${i + 1}: ${s.thought}`);
+      lines.push(`- **결과**: ${JSON.stringify(s.result)}`);
+      if (s.confidence !== undefined) {
+        lines.push(`- **확신도**: ${(s.confidence * 100).toFixed(0)}%`);
+      }
+      if (s.durationMs !== undefined) {
+        lines.push(`- **소요시간**: ${s.durationMs}ms`);
+      }
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+
+  /** JSON 직렬화 */
+  toJSON(): object {
+    return {
+      kind: "chain-of-thought",
+      totalSteps: this.steps.length,
+      steps: this.steps.map(s => ({
+        id: s.id,
+        thought: s.thought,
+        result: s.result,
+        confidence: s.confidence,
+        durationMs: s.durationMs,
+      })),
+    };
+  }
+
+  /** 내부 steps 초기화 (재사용용) */
+  reset(): this {
+    this.steps = [];
+    return this;
+  }
+}
+
+/**
+ * FL 인터프리터용 COT 폼 평가기
+ *
+ * FL 문법:
+ *   (COT
+ *     :step "질문 이해" (parse-question $input)
+ *     :step "분석" (analyze $facts)
+ *     :conclude (fn [$steps] (synthesize $steps)))
+ *
+ * - :step "설명" expr — 단계 추가 + 실행
+ * - :conclude fn — 결론 도출 fn (steps 배열 받음)
+ * - 각 step에서 $prev로 이전 단계 결과 참조 가능
+ */
+export function evalCotForm(
+  args: any[],
+  evalFn: (node: any) => any,
+  setVar: (name: string, value: any) => void,
+  getVar: (name: string) => any,
+): CoTResult {
+  const cot = new ChainOfThought();
+  let concludeFn: any = null;
+
+  // FL 파서에서 S-expression 내 :symbol은 두 가지 형태로 올 수 있음:
+  // 1. {kind: "keyword", name: "step"} — T.Keyword 토큰
+  // 2. {kind: "literal", type: "string", value: "step"} — T.Colon + T.Symbol → string literal
+  function isKeyword(node: any, name: string): boolean {
+    if (!node) return false;
+    if (node.kind === "keyword" && node.name === name) return true;
+    if (node.kind === "literal" && node.type === "string" && node.value === name) return true;
+    return false;
+  }
+
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+
+    // :step 키워드
+    if (isKeyword(arg, "step")) {
+      i++;
+      if (i >= args.length) throw new Error("COT :step requires a description string");
+
+      // step 설명 (문자열 리터럴 또는 평가)
+      const descNode = args[i];
+      let desc: string;
+      if (descNode?.kind === "literal" && typeof descNode.value === "string") {
+        desc = descNode.value;
+      } else {
+        desc = String(evalFn(descNode));
+      }
+      i++;
+
+      if (i >= args.length) throw new Error(`COT :step "${desc}" requires an expression`);
+
+      // step 표현식 (평가를 fn으로 감싸서 $prev 주입)
+      const stepExpr = args[i];
+      i++;
+
+      // 확신도 선택적 파싱: :confidence 0.9
+      let confidence: number | undefined;
+      if (i < args.length && isKeyword(args[i], "confidence")) {
+        i++;
+        if (i < args.length) {
+          confidence = Number(evalFn(args[i]));
+          i++;
+        }
+      }
+
+      cot.step(desc, (prev: any) => {
+        // $prev 주입
+        setVar("$prev", prev !== undefined ? prev : null);
+        return evalFn(stepExpr);
+      }, confidence);
+
+      continue;
+    }
+
+    // :conclude 키워드
+    if (isKeyword(arg, "conclude")) {
+      i++;
+      if (i >= args.length) throw new Error("COT :conclude requires a function");
+      concludeFn = evalFn(args[i]);
+      i++;
+      continue;
+    }
+
+    // 나머지는 건너뜀
+    i++;
+  }
+
+  // conclude fn이 없으면 마지막 step 결과를 결론으로
+  const concludeWrapper = (steps: ThoughtStep[]): any => {
+    if (concludeFn === null) {
+      return steps.length > 0 ? steps[steps.length - 1].result : null;
+    }
+    if (typeof concludeFn === "function") {
+      return concludeFn(steps);
+    }
+    if (concludeFn?.kind === "function-value") {
+      // FreeLang function value 호출 — callFunctionValue를 통해 처리
+      // steps 배열을 인자로 전달하기 위해 setVar + 직접 실행
+      setVar("$__cot_steps__", steps);
+      return concludeFn;
+    }
+    return concludeFn;
+  };
+
+  return cot.conclude(concludeWrapper);
+}

package/src/counterfactual.ts

@@ -0,0 +1,268 @@
+// counterfactual.ts — FreeLang v9 Phase 143: [COUNTERFACTUAL]
+// "만약 X가 달랐다면 Y는 어떻게 됐을까?" 반사실 추론 시스템
+
+export interface Scenario {
+  id: string;
+  name: string;
+  variables: Record<string, unknown>;  // 현재 세계 변수들
+  outcome: unknown;                     // 현재 결과
+}
+
+export interface Counterfactual {
+  id: string;
+  baseScenario: Scenario;
+  intervention: Record<string, unknown>; // 변경할 변수들
+  counterfactualOutcome: unknown;         // 반사실 결과
+  delta: Record<string, unknown>;        // 변화량
+  probability: number;                   // 이 반사실이 실현됐을 확률
+  explanation: string;
+}
+
+export interface CounterfactualAnalysis {
+  original: Scenario;
+  counterfactuals: Counterfactual[];
+  mostLikelyAlternative: Counterfactual;
+  keyFactors: string[];   // 결과를 가장 많이 바꾸는 변수들
+  sensitivity: Record<string, number>; // 변수별 민감도
+}
+
+let _cfIdCounter = 0;
+
+function genCfId(): string {
+  return `cf-${++_cfIdCounter}-${Date.now()}`;
+}
+
+/**
+ * 두 값의 변화량 계산
+ */
+function computeDelta(before: unknown, after: unknown): unknown {
+  if (typeof before === 'number' && typeof after === 'number') {
+    return after - before;
+  }
+  if (typeof before === 'boolean' && typeof after === 'boolean') {
+    return before !== after ? `${before} → ${after}` : 'unchanged';
+  }
+  if (before === after) return 'unchanged';
+  return `${String(before)} → ${String(after)}`;
+}
+
+/**
+ * 두 결과 간 차이로 probability 추정
+ * 개입 변수 수가 적을수록, 결과 차이가 적을수록 확률 높음
+ */
+function estimateProbability(
+  interventionCount: number,
+  outcomeChanged: boolean,
+  totalVarCount: number
+): number {
+  const interventionRatio = interventionCount / Math.max(totalVarCount, 1);
+  const base = 1 - interventionRatio * 0.5;
+  const outcomeBonus = outcomeChanged ? 0 : 0.1;
+  return Math.max(0, Math.min(1, base + outcomeBonus));
+}
+
+/**
+ * 반사실 설명 생성
+ */
+function generateExplanation(
+  baseScenario: Scenario,
+  intervention: Record<string, unknown>,
+  originalOutcome: unknown,
+  counterfactualOutcome: unknown
+): string {
+  const changes = Object.entries(intervention)
+    .map(([k, v]) => `${k}=${String(v)}`)
+    .join(', ');
+  const changed = originalOutcome !== counterfactualOutcome;
+  if (changed) {
+    return `만약 ${changes}이었다면, 결과는 "${String(originalOutcome)}" 대신 "${String(counterfactualOutcome)}"이 됐을 것입니다.`;
+  }
+  return `${changes}으로 변경해도 결과 "${String(originalOutcome)}"는 동일합니다.`;
+}
+
+export class CounterfactualReasoner {
+  private scenarios: Map<string, Scenario> = new Map();
+
+  // 시나리오 등록
+  registerScenario(scenario: Scenario): void {
+    this.scenarios.set(scenario.id, scenario);
+  }
+
+  // 단일 반사실 생성
+  createCounterfactual(
+    scenarioId: string,
+    intervention: Record<string, unknown>,
+    outcomeFunc: (vars: Record<string, unknown>) => unknown
+  ): Counterfactual {
+    const base = this.scenarios.get(scenarioId);
+    if (!base) throw new Error(`Scenario "${scenarioId}" not found`);
+
+    const modifiedVars = { ...base.variables, ...intervention };
+    const cfOutcome = outcomeFunc(modifiedVars);
+
+    const delta: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(intervention)) {
+      delta[k] = computeDelta(base.variables[k], v);
+    }
+
+    const prob = estimateProbability(
+      Object.keys(intervention).length,
+      cfOutcome !== base.outcome,
+      Object.keys(base.variables).length
+    );
+
+    return {
+      id: genCfId(),
+      baseScenario: base,
+      intervention,
+      counterfactualOutcome: cfOutcome,
+      delta,
+      probability: prob,
+      explanation: generateExplanation(base, intervention, base.outcome, cfOutcome),
+    };
+  }
+
+  // 여러 반사실 분석
+  analyze(
+    scenarioId: string,
+    interventions: Array<Record<string, unknown>>,
+    outcomeFunc: (vars: Record<string, unknown>) => unknown
+  ): CounterfactualAnalysis {
+    const base = this.scenarios.get(scenarioId);
+    if (!base) throw new Error(`Scenario "${scenarioId}" not found`);
+
+    const counterfactuals = interventions.map(iv =>
+      this.createCounterfactual(scenarioId, iv, outcomeFunc)
+    );
+
+    // mostLikelyAlternative: 가장 높은 probability
+    const mostLikelyAlternative = counterfactuals.reduce(
+      (best, cf) => cf.probability > best.probability ? cf : best,
+      counterfactuals[0]
+    );
+
+    // sensitivity: 각 변수가 결과를 얼마나 바꾸는지
+    const sensitivity = this.sensitivityAnalysis(base.variables, outcomeFunc as (vars: Record<string, unknown>) => number);
+
+    // keyFactors: sensitivity 상위 변수들
+    const keyFactors = Object.entries(sensitivity)
+      .sort((a, b) => b[1] - a[1])
+      .map(([k]) => k);
+
+    return {
+      original: base,
+      counterfactuals,
+      mostLikelyAlternative,
+      keyFactors,
+      sensitivity,
+    };
+  }
+
+  // "만약 X가 N이었다면?" 단순 질문
+  whatIf(
+    variables: Record<string, unknown>,
+    change: Record<string, unknown>,
+    outcomeFunc: (vars: Record<string, unknown>) => unknown
+  ): Counterfactual {
+    const tempId = `__temp_${Date.now()}`;
+    const originalOutcome = outcomeFunc(variables);
+    const tempScenario: Scenario = {
+      id: tempId,
+      name: 'temporary',
+      variables,
+      outcome: originalOutcome,
+    };
+    this.scenarios.set(tempId, tempScenario);
+    const cf = this.createCounterfactual(tempId, change, outcomeFunc);
+    this.scenarios.delete(tempId);
+    return cf;
+  }
+
+  // 최소 변경으로 원하는 결과 달성
+  findMinimalIntervention(
+    scenarioId: string,
+    targetOutcome: unknown,
+    outcomeFunc: (vars: Record<string, unknown>) => unknown
+  ): Record<string, unknown> | null {
+    const base = this.scenarios.get(scenarioId);
+    if (!base) throw new Error(`Scenario "${scenarioId}" not found`);
+
+    const vars = base.variables;
+    const keys = Object.keys(vars);
+
+    // 단일 변수 변경 시도 (boolean flip, number ±10~50%)
+    for (const key of keys) {
+      const val = vars[key];
+      const candidates: unknown[] = [];
+
+      if (typeof val === 'boolean') {
+        candidates.push(!val);
+      } else if (typeof val === 'number') {
+        candidates.push(val * 0.5, val * 1.5, val * 0, val * 2);
+      } else if (typeof val === 'string') {
+        candidates.push('');
+      }
+
+      for (const candidate of candidates) {
+        const modified = { ...vars, [key]: candidate };
+        const result = outcomeFunc(modified);
+        if (result === targetOutcome) {
+          return { [key]: candidate };
+        }
+      }
+    }
+
+    // 두 변수 조합 시도
+    for (let i = 0; i < keys.length; i++) {
+      for (let j = i + 1; j < keys.length; j++) {
+        const ki = keys[i];
+        const kj = keys[j];
+        const vi = vars[ki];
+        const vj = vars[kj];
+
+        const ci: unknown[] = typeof vi === 'boolean' ? [!vi] : typeof vi === 'number' ? [vi * 0.5] : [''];
+        const cj: unknown[] = typeof vj === 'boolean' ? [!vj] : typeof vj === 'number' ? [vj * 0.5] : [''];
+
+        for (const candidateI of ci) {
+          for (const candidateJ of cj) {
+            const modified = { ...vars, [ki]: candidateI, [kj]: candidateJ };
+            const result = outcomeFunc(modified);
+            if (result === targetOutcome) {
+              return { [ki]: candidateI, [kj]: candidateJ };
+            }
+          }
+        }
+      }
+    }
+
+    return null;
+  }
+
+  // 민감도 분석: 각 수치 변수를 ±10% 변경했을 때 결과 변화
+  sensitivityAnalysis(
+    variables: Record<string, unknown>,
+    outcomeFunc: (vars: Record<string, unknown>) => number
+  ): Record<string, number> {
+    const baseOutcome = outcomeFunc(variables);
+    const sensitivity: Record<string, number> = {};
+
+    for (const [key, val] of Object.entries(variables)) {
+      if (typeof val === 'number') {
+        const delta = val * 0.1 || 1; // 0이면 1 사용
+        const plusOutcome = outcomeFunc({ ...variables, [key]: val + delta });
+        const minusOutcome = outcomeFunc({ ...variables, [key]: val - delta });
+        const avgChange = (Math.abs(plusOutcome - baseOutcome) + Math.abs(minusOutcome - baseOutcome)) / 2;
+        sensitivity[key] = avgChange;
+      } else if (typeof val === 'boolean') {
+        const flipped = outcomeFunc({ ...variables, [key]: !val });
+        sensitivity[key] = Math.abs(flipped - baseOutcome);
+      } else {
+        sensitivity[key] = 0;
+      }
+    }
+
+    return sensitivity;
+  }
+}
+
+export const globalCounterfactual = new CounterfactualReasoner();