freelang-editor 11.7.4

package/src/fitness.ts

@@ -0,0 +1,238 @@
+// FreeLang v9 Fitness — 적합도 함수 모음
+// Phase 134: [FITNESS] AI가 솔루션의 품질을 평가하는 적합도 함수
+
+export interface FitnessResult {
+  score: number;          // 0~1 정규화된 점수
+  rawScore: number;       // 원점수
+  rank?: number;          // 랭킹 (집합에서)
+  percentile?: number;    // 백분위
+  details: Record<string, number>; // 세부 점수
+}
+
+export interface FitnessConfig {
+  weights?: Record<string, number>; // 가중치 맵
+  normalize?: boolean;              // 0~1 정규화 여부 (기본 true)
+  maximize?: boolean;               // true=높을수록 좋음, false=낮을수록 좋음
+}
+
+// 레벤슈타인 거리 계산
+function levenshtein(a: string, b: string): number {
+  const m = a.length;
+  const n = b.length;
+  const dp: number[][] = Array.from({ length: m + 1 }, (_, i) =>
+    Array.from({ length: n + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0))
+  );
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (a[i - 1] === b[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1];
+      } else {
+        dp[i][j] = 1 + Math.min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]);
+      }
+    }
+  }
+  return dp[m][n];
+}
+
+export class FitnessEvaluator {
+  private config: FitnessConfig;
+
+  constructor(config: FitnessConfig = {}) {
+    this.config = {
+      normalize: config.normalize !== false,
+      maximize: config.maximize !== false,
+      weights: config.weights ?? {},
+    };
+  }
+
+  // 숫자 근접도 (목표값에 얼마나 가까운가)
+  proximity(value: number, target: number, tolerance?: number): FitnessResult {
+    const diff = Math.abs(value - target);
+    const tol = tolerance !== undefined ? tolerance : Math.abs(target) || 1;
+
+    let rawScore: number;
+    let score: number;
+
+    if (tol === 0) {
+      rawScore = diff === 0 ? 1 : 0;
+      score = rawScore;
+    } else {
+      rawScore = Math.max(0, 1 - diff / tol);
+      score = this.config.normalize !== false ? rawScore : rawScore;
+    }
+
+    if (this.config.maximize === false) {
+      score = 1 - score;
+    }
+
+    return {
+      score,
+      rawScore,
+      details: {
+        diff,
+        tolerance: tol,
+        proximity: rawScore,
+      },
+    };
+  }
+
+  // 문자열 유사도 (레벤슈타인 거리 기반)
+  stringSimilarity(a: string, b: string): FitnessResult {
+    if (a.length === 0 && b.length === 0) {
+      return { score: 1, rawScore: 1, details: { distance: 0, maxLen: 0 } };
+    }
+    const maxLen = Math.max(a.length, b.length);
+    const dist = levenshtein(a, b);
+    const rawScore = maxLen === 0 ? 1 : 1 - dist / maxLen;
+    const score = this.config.maximize === false ? 1 - rawScore : rawScore;
+
+    return {
+      score,
+      rawScore,
+      details: {
+        distance: dist,
+        maxLen,
+        similarity: rawScore,
+      },
+    };
+  }
+
+  // 배열 일치도
+  arrayMatch<T>(arr: T[], target: T[]): FitnessResult {
+    if (target.length === 0 && arr.length === 0) {
+      return { score: 1, rawScore: 1, details: { matched: 0, total: 0 } };
+    }
+    const maxLen = Math.max(arr.length, target.length);
+    let matched = 0;
+    const minLen = Math.min(arr.length, target.length);
+    for (let i = 0; i < minLen; i++) {
+      if (JSON.stringify(arr[i]) === JSON.stringify(target[i])) matched++;
+    }
+    const rawScore = maxLen === 0 ? 1 : matched / maxLen;
+    const score = this.config.maximize === false ? 1 - rawScore : rawScore;
+
+    return {
+      score,
+      rawScore,
+      details: {
+        matched,
+        total: maxLen,
+        arrLen: arr.length,
+        targetLen: target.length,
+      },
+    };
+  }
+
+  // 다목적 적합도 (여러 기준 가중합)
+  multiObjective(
+    values: Record<string, number>,
+    targets: Record<string, number>,
+    weights?: Record<string, number>
+  ): FitnessResult {
+    const keys = Object.keys(targets);
+    if (keys.length === 0) {
+      return { score: 1, rawScore: 1, details: {} };
+    }
+
+    const w = weights ?? this.config.weights ?? {};
+    const details: Record<string, number> = {};
+    let weightedSum = 0;
+    let totalWeight = 0;
+
+    for (const key of keys) {
+      const val = values[key] ?? 0;
+      const tgt = targets[key] ?? 0;
+      const weight = w[key] ?? 1;
+      const maxVal = Math.max(Math.abs(tgt), Math.abs(val), 1);
+      const proximity = Math.max(0, 1 - Math.abs(val - tgt) / maxVal);
+      details[key] = proximity;
+      weightedSum += proximity * weight;
+      totalWeight += weight;
+    }
+
+    const rawScore = totalWeight > 0 ? weightedSum / totalWeight : 0;
+    const score = this.config.maximize === false ? 1 - rawScore : rawScore;
+
+    return { score, rawScore, details };
+  }
+
+  // 제약 만족도 (모든 제약 충족 시 1.0)
+  constraintSatisfaction(
+    value: unknown,
+    constraints: Array<(v: unknown) => boolean>
+  ): FitnessResult {
+    if (constraints.length === 0) {
+      return { score: 1, rawScore: 1, details: { satisfied: 0, total: 0 } };
+    }
+
+    let satisfied = 0;
+    const details: Record<string, number> = {};
+    for (let i = 0; i < constraints.length; i++) {
+      const result = constraints[i](value) ? 1 : 0;
+      details[`constraint_${i}`] = result;
+      satisfied += result;
+    }
+
+    const rawScore = satisfied / constraints.length;
+    const score = this.config.maximize === false ? 1 - rawScore : rawScore;
+
+    return {
+      score,
+      rawScore,
+      details: { ...details, satisfied, total: constraints.length },
+    };
+  }
+
+  // 집합에서 랭킹
+  rank<T>(items: T[], scorer: (item: T) => number): Array<T & { rank: number; score: number }> {
+    const scored = items.map((item, idx) => ({ item, score: scorer(item), idx }));
+    scored.sort((a, b) => b.score - a.score);
+    return scored.map((s, rankIdx) => ({
+      ...(s.item as any),
+      rank: rankIdx + 1,
+      score: s.score,
+    }));
+  }
+
+  // 파레토 최적 (다목적 최적화)
+  paretoFront<T>(
+    items: T[],
+    objectives: Array<(item: T) => number>
+  ): T[] {
+    if (items.length === 0) return [];
+
+    const dominated = new Set<number>();
+
+    for (let i = 0; i < items.length; i++) {
+      if (dominated.has(i)) continue;
+      for (let j = 0; j < items.length; j++) {
+        if (i === j || dominated.has(j)) continue;
+        // i가 j를 지배하는지 확인: 모든 목표에서 i >= j이고 적어도 하나에서 i > j
+        const scores_i = objectives.map(f => f(items[i]));
+        const scores_j = objectives.map(f => f(items[j]));
+        const allGeq = scores_i.every((s, k) => s >= scores_j[k]);
+        const someGt = scores_i.some((s, k) => s > scores_j[k]);
+        if (allGeq && someGt) {
+          dominated.add(j);
+        }
+      }
+    }
+
+    return items.filter((_, i) => !dominated.has(i));
+  }
+}
+
+export const globalFitness = new FitnessEvaluator();
+
+export function fitnessScore(value: number, target: number): number {
+  return globalFitness.proximity(value, target).score;
+}
+
+export function rankItems<T>(
+  items: T[],
+  scores: number[]
+): Array<{ item: T; rank: number; score: number }> {
+  const paired = items.map((item, i) => ({ item, score: scores[i] ?? 0 }));
+  paired.sort((a, b) => b.score - a.score);
+  return paired.map((p, rankIdx) => ({ item: p.item, rank: rankIdx + 1, score: p.score }));
+}

package/src/fl-app-demo.fl

@@ -0,0 +1,19 @@
+; FreeLang v9 — fl-app-demo.fl
+; Phase 54: import 시스템 실전 데모 — 통계 계산기
+
+(import list :from "./fl-list-utils.fl")
+(import stru :from "./fl-str-utils.fl")
+
+(define data [3.0 1.0 4.0 1.0 5.0 9.0 2.0 6.0])
+
+(println "=== FL 통계 계산기 ===")
+(println (str "데이터: " data))
+(println (str "합계:   " (list:sum data)))
+(println (str "평균:   " (list:mean data)))
+(println (str "최대:   " (list:lst-max data)))
+(println (str "최소:   " (list:lst-min data)))
+(println (str "상위 3: " (list:take data 3)))
+(println (str "하위 5: " (list:drop data 3)))
+(println (str "반복:   " (stru:repeat-str "FL" 3)))
+(println (str "패딩:   " (stru:pad-left "42" 5 "0")))
+(println "=== 완료 ===")

package/src/fl-files/fl-fmt.fl

@@ -0,0 +1,29 @@
+;;; FreeLang Formatter — self-hosted
+;;; Phase 88: 자체 호스팅 2.0
+
+[MODULE fl-fmt]
+
+;;; 들여쓰기 N칸 생성 — repeat로 공백 2칸 반복
+[FUNC indent :params [n]
+  :body (repeat "  " n)
+]
+
+;;; S-expression 포맷: op와 args를 공백으로 연결
+[FUNC fmt-sexpr :params [op args depth]
+  :body (concat "(" op " " (join " " args) ")")
+]
+
+;;; 단일 토큰을 문자열로 포맷
+[FUNC fmt-expr :params [token]
+  :body (str token)
+]
+
+;;; 토큰 목록을 줄바꿈으로 연결해 포맷된 코드 반환
+[FUNC fmt-tokens :params [tokens]
+  :body (join "\n" (map fmt-expr tokens))
+]
+
+;;; 최상위 포매터 — 소스를 줄로 분리해 재결합
+[FUNC format-code :params [src]
+  :body (join "\n" (str-split src "\n"))
+]

package/src/fl-files/fl-lint.fl

@@ -0,0 +1,61 @@
+;;; FreeLang Linter — self-hosted
+;;; Phase 88: 자체 호스팅 2.0
+
+[MODULE fl-lint]
+
+;;; 빈 바디 검사 — node의 body 필드 길이로 판단
+[FUNC check-empty-body :params [node]
+  :body (if (= (length (get node "body")) 0)
+    [{:rule "empty-body" :msg "빈 FUNC 바디"}]
+    [])
+]
+
+;;; 노드 이름 추출
+[FUNC node-name :params [node]
+  :body (get node "name")
+]
+
+;;; 노드 바디 추출
+[FUNC node-body :params [node]
+  :body (get node "body")
+]
+
+;;; 전체 린트 — loop로 각 노드 check-empty-body 적용 후 결과 합산
+[FUNC lint-nodes :params [nodes]
+  :body (
+    (define ln-n (length nodes))
+    (define ln-i 0)
+    (define ln-result [])
+    (loop [[_ 0]]
+      (if (>= ln-i ln-n) ln-result
+        (do
+          (define ln-issues (check-empty-body (get nodes ln-i)))
+          (set! ln-result (append ln-result ln-issues))
+          (set! ln-i (+ ln-i 1))
+          (recur 0)
+        )
+      )
+    )
+  )
+]
+
+;;; 소스 문자열에서 FUNC 블록 수 계산 — loop 방식
+[FUNC count-funcs :params [src]
+  :body (
+    (define cf-lines (str-split src "\n"))
+    (define cf-n (length cf-lines))
+    (define cf-i 0)
+    (define cf-count 0)
+    (loop [[_ 0]]
+      (if (>= cf-i cf-n) cf-count
+        (do
+          (if (contains? (get cf-lines cf-i) "FUNC")
+            (set! cf-count (+ cf-count 1))
+            0)
+          (set! cf-i (+ cf-i 1))
+          (recur 0)
+        )
+      )
+    )
+  )
+]

package/src/fl-files/fl-test.fl

@@ -0,0 +1,52 @@
+;;; FreeLang Test Runner — self-hosted
+;;; Phase 88: 자체 호스팅 2.0
+
+[MODULE fl-test]
+
+(define test-results [])
+
+;;; 테스트 케이스 실행 — fn 호출 결과로 pass/fail 판단
+[FUNC my-test :params [name fn]
+  :body (do
+    (define ok (call fn))
+    (set! test-results (append test-results [{:name name :ok ok}]))
+    ok)
+]
+
+;;; pass 카운트 계산 — loop 방식
+[FUNC count-passed :params [results]
+  :body (
+    (define cp-n (length results))
+    (define cp-i 0)
+    (define cp-count 0)
+    (loop [[_ 0]]
+      (if (>= cp-i cp-n) cp-count
+        (do
+          (if (get (get results cp-i) "ok")
+            (set! cp-count (+ cp-count 1))
+            0)
+          (set! cp-i (+ cp-i 1))
+          (recur 0)
+        )
+      )
+    )
+  )
+]
+
+;;; 결과 리포트 출력
+[FUNC my-report :params []
+  :body (do
+    (define passed (count-passed test-results))
+    (define total (length test-results))
+    (print (concat "결과: " (num-to-str passed) "/" (num-to-str total))))
+]
+
+;;; assertion — expect와 actual이 같은지 검사
+[FUNC assert-eq :params [expected actual]
+  :body (= expected actual)
+]
+
+;;; 빈 배열인지 검사
+[FUNC assert-empty :params [arr]
+  :body (= (length arr) 0)
+]

package/src/fl-http-demo.fl

@@ -0,0 +1,19 @@
+; FreeLang v9 — fl-http-demo.fl
+; Phase 55: FL HTTP 클라이언트 — TODO 서버(포트 30116)와 통신
+
+(define BASE "http://localhost:30116")
+
+; GET /todos — 초기 목록
+(define todos-raw (http_json (str BASE "/todos")))
+(println (str "초기 todos 수: " (length todos-raw)))
+
+; POST /todos — 새 항목 추가
+(define post-body "{\"title\":\"FL에서 추가!\"}")
+(define new-todo-raw (http_post (str BASE "/todos") post-body))
+(println (str "추가 응답: " new-todo-raw))
+
+; GET /todos — 추가 후 목록
+(define todos2-raw (http_json (str BASE "/todos")))
+(println (str "추가 후 todos 수: " (length todos2-raw)))
+
+(println "=== Phase 55 완료 ===")

package/src/fl-list-utils.fl

@@ -0,0 +1,108 @@
+; FreeLang v9 — fl-list-utils.fl
+; Phase 54: FL 리스트 유틸리티 라이브러리 (import 시스템 활용)
+
+; 리스트 합계 — sm-* 접두사
+[FUNC sum :params [arr]
+  :body (
+    (define sm-n (length arr))
+    (define sm-acc 0.0)
+    (define sm-i 0)
+    (loop [[_ 0]]
+      (if (>= sm-i sm-n) sm-acc
+        (
+          (set! sm-acc (+ sm-acc (get arr sm-i)))
+          (set! sm-i (+ sm-i 1))
+          (recur 0)
+        )
+      )
+    )
+  )
+]
+
+; 리스트 평균
+[FUNC mean :params [arr]
+  :body (
+    (define mn-n (length arr))
+    (if (= mn-n 0) 0.0
+      (/ (sum arr) mn-n)
+    )
+  )
+]
+
+; 리스트 최댓값 — lmx-* 접두사
+[FUNC lst-max :params [arr]
+  :body (
+    (define lmx-n (length arr))
+    (define lmx-best (get arr 0))
+    (define lmx-i 1)
+    (loop [[_ 0]]
+      (if (>= lmx-i lmx-n) lmx-best
+        (
+          (if (> (get arr lmx-i) lmx-best)
+            (set! lmx-best (get arr lmx-i))
+            0
+          )
+          (set! lmx-i (+ lmx-i 1))
+          (recur 0)
+        )
+      )
+    )
+  )
+]
+
+; 리스트 최솟값 — lmn-* 접두사
+[FUNC lst-min :params [arr]
+  :body (
+    (define lmn-n (length arr))
+    (define lmn-best (get arr 0))
+    (define lmn-i 1)
+    (loop [[_ 0]]
+      (if (>= lmn-i lmn-n) lmn-best
+        (
+          (if (< (get arr lmn-i) lmn-best)
+            (set! lmn-best (get arr lmn-i))
+            0
+          )
+          (set! lmn-i (+ lmn-i 1))
+          (recur 0)
+        )
+      )
+    )
+  )
+]
+
+; 앞 n개 — tk-* 접두사
+[FUNC take :params [arr n]
+  :body (
+    (define tk-result [])
+    (define tk-i 0)
+    (define tk-limit (if (< n (length arr)) n (length arr)))
+    (loop [[_ 0]]
+      (if (>= tk-i tk-limit) tk-result
+        (
+          (set! tk-result (append tk-result (get arr tk-i)))
+          (set! tk-i (+ tk-i 1))
+          (recur 0)
+        )
+      )
+    )
+  )
+]
+
+; 앞 n개 제거 — dp-* 접두사
+[FUNC drop :params [arr n]
+  :body (
+    (define dp-result [])
+    (define dp-i n)
+    (define dp-len (length arr))
+    (loop [[_ 0]]
+      (if (>= dp-i dp-len) dp-result
+        (
+          (set! dp-result (append dp-result (get arr dp-i)))
+          (set! dp-i (+ dp-i 1))
+          (recur 0)
+        )
+      )
+    )
+  )
+]

package/src/fl-math-lib.fl

@@ -0,0 +1,14 @@
+; FreeLang v9 — fl-math-lib.fl
+; Phase 52 import 시스템 테스트 픽스처
+
+[FUNC square :params [x]
+  :body (* x x)
+]
+
+[FUNC cube :params [x]
+  :body (* x x x)
+]
+
+[FUNC clamp :params [x lo hi]
+  :body (if (< x lo) lo (if (> x hi) hi x))
+]

package/src/fl-sdk.ts

@@ -0,0 +1,154 @@
+// FreeLang v9 External AI SDK
+// Phase 110: 외부 AI가 FL을 쓰는 SDK
+// 외부 AI(Claude API, OpenAI API 등)가 FL 코드를 실행하거나 FL 블록을 생성할 수 있도록 SDK 제공
+
+export interface FLSDKConfig {
+  version: string;
+  features: string[];
+}
+
+export interface FLCodeBlock {
+  type: 'expression' | 'block' | 'program';
+  code: string;
+  description?: string;
+}
+
+export interface FLExecuteResult {
+  success: boolean;
+  output: any;
+  error?: string;
+  executionMs: number;
+}
+
+// FL 코드 생성 헬퍼 (AI가 FL 코드를 쉽게 생성하도록)
+export class FLCodeBuilder {
+  private lines: string[] = [];
+
+  // 기본 폼
+  define(name: string, value: string): FLCodeBuilder {
+    this.lines.push(`(define ${name} ${value})`);
+    return this;
+  }
+
+  defn(name: string, params: string[], body: string): FLCodeBuilder {
+    this.lines.push(`(defn ${name} [${params.map(p => '$' + p).join(' ')}] ${body})`);
+    return this;
+  }
+
+  call(fn: string, ...args: string[]): FLCodeBuilder {
+    this.lines.push(`(${fn} ${args.join(' ')})`);
+    return this;
+  }
+
+  // AI 블록
+  cot(goal: string, steps: string[]): FLCodeBuilder {
+    const stepStr = steps.map(s => `:step "${s}" nil`).join(' ');
+    this.lines.push(`[COT :goal "${goal}" ${stepStr} :conclude identity]`);
+    return this;
+  }
+
+  agent(goal: string, maxSteps: number = 5): FLCodeBuilder {
+    this.lines.push(`[AGENT :goal "${goal}" :max-steps ${maxSteps} :step (fn [$s] $s)]`);
+    return this;
+  }
+
+  maybe(confidence: number, value: string): FLCodeBuilder {
+    this.lines.push(`(maybe ${confidence} ${value})`);
+    return this;
+  }
+
+  result(type: 'ok' | 'err', value: string, errCode?: string): FLCodeBuilder {
+    if (type === 'ok') this.lines.push(`(ok ${value})`);
+    else this.lines.push(`(err "${errCode ?? 'ERROR'}" ${value})`);
+    return this;
+  }
+
+  pipe(...fns: string[]): FLCodeBuilder {
+    this.lines.push(`(-> $data ${fns.join(' ')})`);
+    return this;
+  }
+
+  comment(text: string): FLCodeBuilder {
+    this.lines.push(`; ${text}`);
+    return this;
+  }
+
+  build(): string {
+    return this.lines.join('\n');
+  }
+
+  reset(): FLCodeBuilder {
+    this.lines = [];
+    return this;
+  }
+
+  lineCount(): number { return this.lines.length; }
+}
+
+// FL SDK 메인 클래스
+export class FLSDK {
+  readonly version: string = '9.0.0';
+  readonly features: string[] = [
+    'maybe', 'cot', 'tot', 'reflect', 'context',
+    'result', 'fl-try', 'use-tool', 'agent', 'self-improve',
+    'memory', 'rag', 'multi-agent', 'try-reason',
+    'streaming', 'quality-loop', 'tutor', 'debugger',
+    'prompt-compiler'
+  ];
+
+  // 코드 빌더 생성
+  builder(): FLCodeBuilder {
+    return new FLCodeBuilder();
+  }
+
+  // FL 코드 블록 만들기
+  block(type: FLCodeBlock['type'], code: string, description?: string): FLCodeBlock {
+    return { type, code, description };
+  }
+
+  // 피처 지원 여부
+  supports(feature: string): boolean {
+    return this.features.includes(feature);
+  }
+
+  // FL 코드 검증 (간단한 괄호 밸런스 체크)
+  validate(code: string): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+    let depth = 0;
+    for (const ch of code) {
+      if (ch === '(' || ch === '[') depth++;
+      else if (ch === ')' || ch === ']') {
+        depth--;
+        if (depth < 0) {
+          errors.push('Unexpected closing bracket');
+          break;
+        }
+      }
+    }
+    if (depth > 0) errors.push(`Unclosed brackets: ${depth}`);
+    return { valid: errors.length === 0, errors };
+  }
+
+  // 빠른 스니펫 생성
+  snippet(concept: string): string {
+    const snippets: Record<string, string> = {
+      'maybe': '(maybe 0.8 "result")',
+      'ok': '(ok 42)',
+      'err': '(err "NOT_FOUND" "Item not found")',
+      'cot': '[COT :step "analyze" nil :conclude identity]',
+      'agent': '[AGENT :goal "task" :max-steps 5 :step (fn [$s] $s)]',
+      'reflect': '[REFLECT :output $result :criteria [accuracy] :threshold 0.8]',
+      'pipe': '(-> $data parse transform output)',
+      'memory': '(mem-remember "key" "value")',
+      'rag': '(rag-add "doc1" "content")',
+    };
+    return snippets[concept] ?? `; ${concept} snippet not found`;
+  }
+
+  getConfig(): FLSDKConfig {
+    return { version: this.version, features: [...this.features] };
+  }
+}
+
+export const sdk = new FLSDK();
+export default sdk;