freelang-editor 11.7.4

package/src/__tests__/p1-3-distributed.test.ts

@@ -0,0 +1,160 @@
+// P1-3: Distributed Execution Tests
+// Tests for large-scale parallel workload management
+
+import { DistributedExecutor, DistributedTask } from "../stdlib-distributed";
+
+describe("P1-3: Distributed Execution", () => {
+  describe("Test 1: Basic distributed execution with 100 items and 4 workers", () => {
+    it("should process all items correctly across workers", async () => {
+      const items = Array.from({ length: 100 }, (_, i) => ({ id: i, value: i * 2 }));
+
+      const task: DistributedTask = {
+        items,
+        worker_count: 4,
+        batch_size: 25,
+        sync_interval_ms: 100,
+        task: async (ctx: any) => ({
+          input_id: ctx.item.id,
+          computed: ctx.item.value * 10,
+          worker: ctx.worker_id,
+        }),
+      };
+
+      const executor = new DistributedExecutor();
+      const result = await executor.execute(task);
+
+      expect(result.status).toBe("success");
+      expect(result.total_items).toBe(100);
+      expect(result.processed_items).toBe(100);
+      expect(result.failed_items).toBe(0);
+      expect(result.workers_used).toBe(4);
+      expect(result.results.length).toBe(100);
+      expect(result.sync_count).toBeGreaterThan(0);
+    });
+  });
+
+  describe("Test 2: Partial failure handling", () => {
+    it("should track failed items but continue processing", async () => {
+      const items = Array.from({ length: 50 }, (_, i) => ({ id: i }));
+
+      const task: DistributedTask = {
+        items,
+        worker_count: 2,
+        batch_size: 10,
+        sync_interval_ms: 100,
+        task: async (ctx: any) => {
+          // Fail on every 5th item
+          if (ctx.item.id % 5 === 0) {
+            throw new Error(`Failed on item ${ctx.item.id}`);
+          }
+          return { processed: ctx.item.id };
+        },
+      };
+
+      const executor = new DistributedExecutor();
+      const result = await executor.execute(task);
+
+      expect(result.status).toBe("partial");
+      expect(result.processed_items).toBeGreaterThan(0);
+      expect(result.failed_items).toBeGreaterThan(0);
+      expect(result.processed_items + result.failed_items).toBe(50);
+      expect(result.errors.length).toBe(result.failed_items);
+    });
+  });
+
+  describe("Test 3: Large batch processing (1000 items)", () => {
+    it("should handle large workload efficiently", async () => {
+      const items = Array.from({ length: 1000 }, (_, i) => i);
+
+      const task: DistributedTask = {
+        items,
+        worker_count: 8,
+        batch_size: 100,
+        sync_interval_ms: 500,
+        task: async (ctx: any) => ({
+          squared: ctx.item * ctx.item,
+          worker: ctx.worker_id,
+        }),
+      };
+
+      const executor = new DistributedExecutor();
+      const startMs = Date.now();
+      const result = await executor.execute(task);
+      const elapsedMs = Date.now() - startMs;
+
+      expect(result.status).toBe("success");
+      expect(result.processed_items).toBe(1000);
+      expect(result.failed_items).toBe(0);
+      expect(result.results.length).toBe(1000);
+
+      // Verify parallel processing (should be faster than sequential)
+      // 1000 items * 10ms per item = 10 seconds sequential
+      // With 8 workers should be ~1.25 seconds
+      console.log(`[Test 3] Processed 1000 items in ${elapsedMs}ms using 8 workers`);
+    });
+  });
+
+  describe("Test 4: Worker state synchronization", () => {
+    it("should synchronize state at intervals", async () => {
+      const items = Array.from({ length: 200 }, (_, i) => i);
+      let sync_count = 0;
+
+      const task: DistributedTask = {
+        items,
+        worker_count: 4,
+        batch_size: 50,
+        sync_interval_ms: 100,
+        task: async (ctx: any) => ({
+          value: ctx.item + 1,
+        }),
+      };
+
+      const executor = new DistributedExecutor();
+      const result = await executor.execute(task);
+
+      expect(result.status).toBe("success");
+      expect(result.sync_count).toBeGreaterThan(0);
+      expect(result.sync_errors).toBe(0);
+
+      // Verify sync happened multiple times
+      expect(result.sync_count).toBeGreaterThanOrEqual(4);  // At least once per worker
+    });
+  });
+
+  describe("Test 5: Distributed with context preservation", () => {
+    it("should preserve and pass context correctly across workers", async () => {
+      const items = Array.from({ length: 100 }, (_, i) => ({ id: i, name: `item-${i}` }));
+
+      const task: DistributedTask = {
+        items,
+        worker_count: 4,
+        batch_size: 25,
+        sync_interval_ms: 100,
+        task: async (ctx: any) => ({
+          original_id: ctx.item.id,
+          original_name: ctx.item.name,
+          processed_by: ctx.worker_id,
+          batch: ctx.batch_index,
+          timestamp: Date.now(),
+        }),
+      };
+
+      const executor = new DistributedExecutor();
+      const result = await executor.execute(task);
+
+      expect(result.status).toBe("success");
+      expect(result.processed_items).toBe(100);
+
+      // Verify context preservation
+      const firstResult = result.results[0];
+      expect(firstResult).toHaveProperty("original_id");
+      expect(firstResult).toHaveProperty("original_name");
+      expect(firstResult).toHaveProperty("processed_by");
+      expect(firstResult).toHaveProperty("batch");
+
+      // Verify distributed execution (multiple workers used)
+      const workers = new Set(result.results.map((r: any) => r.processed_by));
+      expect(workers.size).toBeGreaterThan(1);  // At least 2 different workers
+    });
+  });
+});

package/src/__tests__/p1-4-observability.test.ts

@@ -0,0 +1,161 @@
+// P1-4: Observability Tests
+// Tests for structured logging, metrics collection, and distributed tracing
+
+import { createWorkflowModule } from "../stdlib-workflow";
+
+describe("P1-4: Observability", () => {
+  const WF = createWorkflowModule();
+
+  describe("Test 1: Trace ID propagation and structured logging", () => {
+    it("should include trace_id in all log entries", async () => {
+      const workflow = WF.workflow_create("trace-test", [
+        WF.workflow_step("step1", (ctx: any) => ({ v1: 1 })),
+        WF.workflow_step("step2", (ctx: any) => ({ v2: 2 })),
+        WF.workflow_step("step3", (ctx: any) => ({ v3: 3 })),
+      ]);
+
+      const result = await WF.workflow_run_async(workflow, {});
+
+      expect(result.status).toBe("success");
+      expect(result.log.length).toBe(3);
+
+      // Verify trace_id in all entries
+      result.log.forEach((entry, index) => {
+        expect(entry.trace_id).toBeDefined();
+        expect(entry.trace_id).toBeTruthy();  // Must be non-empty string
+        expect(entry.step).toBe(`step${index + 1}`);
+        expect(entry.status).toBe("ok");
+      });
+
+      // Verify all trace_ids are the same (from same workflow run)
+      const traceIds = new Set(result.log.map(e => e.trace_id));
+      expect(traceIds.size).toBe(1);  // All same trace_id
+    });
+  });
+
+  describe("Test 2: Metrics collection (wall_time_ms)", () => {
+    it("should collect accurate timing metrics for each step", async () => {
+      const workflow = WF.workflow_create("metrics-test", [
+        WF.workflow_step("fast-step", (ctx: any) => {
+          // Fast operation
+          return { done: true };
+        }),
+        WF.workflow_step("slow-step", (ctx: any) => {
+          // Slightly slower operation
+          const end = Date.now() + 10;
+          while (Date.now() < end) { /* busy wait */ }
+          return { done: true };
+        }),
+      ]);
+
+      const result = await WF.workflow_run_async(workflow, {});
+
+      expect(result.status).toBe("success");
+      expect(result.log.length).toBe(2);
+
+      // Verify metrics exist
+      result.log.forEach(entry => {
+        expect(entry.metrics).toBeDefined();
+        expect(entry.metrics?.wall_time_ms).toBeGreaterThanOrEqual(0);
+      });
+
+      // Slow step should take longer
+      const fastMs = result.log[0].metrics?.wall_time_ms ?? 0;
+      const slowMs = result.log[1].metrics?.wall_time_ms ?? 0;
+      expect(slowMs).toBeGreaterThanOrEqual(fastMs);
+    });
+  });
+
+  describe("Test 3: Parallel task metrics", () => {
+    it("should track parallel_tasks count in metrics", async () => {
+      const workflow = WF.workflow_create("parallel-metrics", [
+        WF.workflow_step("sequential", (ctx: any) => ({ done: true })),
+        WF.workflow_step("with-parallel", (ctx: any) => ({ done: true }), {
+          parallel_tasks: [
+            WF.workflow_step("task1", (ctx: any) => ({ t1: 1 })),
+            WF.workflow_step("task2", (ctx: any) => ({ t2: 2 })),
+            WF.workflow_step("task3", (ctx: any) => ({ t3: 3 })),
+          ],
+          merge_strategy: "all-success",
+        }),
+      ]);
+
+      const result = await WF.workflow_run_async(workflow, {});
+
+      expect(result.status).toBe("success");
+      expect(result.log.length).toBe(2);
+
+      // First step has no parallel tasks
+      expect(result.log[0].metrics?.parallel_tasks).toBeUndefined();
+
+      // Second step (with parallel) might have parallel_tasks metric
+      // This depends on implementation details
+      // At minimum, it should have wall_time_ms
+      expect(result.log[1].metrics?.wall_time_ms).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe("Test 4: Error handling preserves trace_id", () => {
+    it("should include trace_id even on errors", async () => {
+      const workflow = WF.workflow_create("error-trace", [
+        WF.workflow_step("good-step", (ctx: any) => ({ ok: true })),
+        WF.workflow_step("bad-step", (ctx: any) => {
+          throw new Error("Intentional failure");
+        }, {
+          fallback: { recovered: true },
+        }),
+      ]);
+
+      const result = await WF.workflow_run_async(workflow, {});
+
+      expect(result.status).toBe("success");  // Fallback used
+      expect(result.log.length).toBe(2);
+
+      // Both entries should have trace_id
+      result.log.forEach(entry => {
+        expect(entry.trace_id).toBeDefined();
+      });
+
+      // Error entry should include error info
+      expect(result.log[1].error).toContain("Intentional failure");
+    });
+  });
+
+  describe("Test 5: Workflow-level metrics summary", () => {
+    it("should calculate overall metrics (parallel_ratio, error_ratio)", async () => {
+      const workflow = WF.workflow_create("metrics-summary", [
+        WF.workflow_step("step1", (ctx: any) => ({ v: 1 }), {
+          parallel_tasks: [
+            WF.workflow_step("p1", (ctx: any) => ({})),
+            WF.workflow_step("p2", (ctx: any) => ({})),
+          ],
+          merge_strategy: "all-success",
+        }),
+        WF.workflow_step("step2", (ctx: any) => ({ v: 2 })),
+        WF.workflow_step("step3", (ctx: any) => ({ v: 3 })),
+      ]);
+
+      const result = await WF.workflow_run_async(workflow, {});
+
+      expect(result.status).toBe("success");
+      expect(result.steps_ok).toBe(3);
+      expect(result.steps_failed).toBe(0);
+
+      // Verify log has trace_id
+      expect(result.log.length).toBeGreaterThan(0);
+      result.log.forEach(entry => {
+        expect(entry.trace_id).toBeTruthy();
+      });
+
+      // Metrics at workflow level
+      expect(result.metrics).toBeDefined();
+      if (result.metrics) {
+        expect(result.metrics.total_ms).toBeGreaterThanOrEqual(0);
+        expect(result.metrics.parallel_ratio).toBeGreaterThanOrEqual(0);
+        expect(result.metrics.parallel_ratio).toBeLessThanOrEqual(1);
+        expect(result.metrics.error_ratio).toBe(0);  // All successful
+        expect(result.metrics.compensation_ratio).toBe(0);  // No compensations
+      }
+    });
+  });
+});

package/src/__tests__/parser.test.ts

@@ -0,0 +1,142 @@
+// FreeLang v9 파서 테스트
+// Token[] → ASTNode[] 검증
+
+import { lex } from '../lexer';
+import { Parser } from '../parser';
+
+function parse(source: string) {
+  const tokens = lex(source);
+  return new Parser(tokens).parse();
+}
+
+describe('Parser - 기본 S-Expression 파싱', () => {
+  test('단순 심볼 — 최상위 레벨 심볼은 파서 에러', () => {
+    // FreeLang v9는 최상위에 블록이나 S-expression만 허용
+    expect(() => parse('hello')).toThrow();
+  });
+
+  test('숫자 리터럴 S-expression', () => {
+    const ast = parse('(+ 1 2)');
+    expect(ast).toBeDefined();
+    expect(ast.length).toBeGreaterThan(0);
+  });
+
+  test('중첩 S-expression', () => {
+    const ast = parse('(+ (* 2 3) 4)');
+    expect(ast).toBeDefined();
+    expect(ast.length).toBe(1);
+  });
+
+  test('문자열 인자 S-expression', () => {
+    const ast = parse('(print "hello world")');
+    expect(ast).toBeDefined();
+  });
+
+  test('$변수 인자', () => {
+    const ast = parse('(+ $a $b)');
+    expect(ast).toBeDefined();
+  });
+
+  test('null? 함수 호출', () => {
+    const ast = parse('(null? $x)');
+    expect(ast).toBeDefined();
+  });
+
+  test('if S-expression', () => {
+    const ast = parse('(if (null? $x) 0 $x)');
+    expect(ast).toBeDefined();
+  });
+
+  test('let 바인딩', () => {
+    const ast = parse('(let [[$x 10] [$y 20]] (+ $x $y))');
+    expect(ast).toBeDefined();
+  });
+
+  test('중첩 괄호 3겹', () => {
+    const ast = parse('(+ (+ 1 2) (+ 3 4))');
+    expect(ast).toBeDefined();
+    expect(ast.length).toBe(1);
+  });
+
+  test('불리언 리터럴', () => {
+    const ast = parse('(if true 1 0)');
+    expect(ast).toBeDefined();
+  });
+});
+
+describe('Parser - [FUNC] 블록', () => {
+  test('[FUNC] 기본 파싱', () => {
+    const ast = parse('[FUNC add :params [$a $b] :body (+ $a $b)]');
+    expect(ast).toBeDefined();
+    expect(ast.length).toBe(1);
+  });
+
+  test('[FUNC] 단일 파라미터', () => {
+    const ast = parse('[FUNC double :params [$x] :body (* $x 2)]');
+    expect(ast).toBeDefined();
+  });
+
+  test('[FUNC] 빈 파라미터', () => {
+    const ast = parse('[FUNC greet :params [] :body "hello"]');
+    expect(ast).toBeDefined();
+  });
+
+  test('[FUNC] 중첩 body', () => {
+    const ast = parse('[FUNC max :params [$a $b] :body (if (> $a $b) $a $b)]');
+    expect(ast).toBeDefined();
+  });
+
+  test('[FUNC] 여러 개 연속', () => {
+    const ast = parse('[FUNC f1 :params [$x] :body $x][FUNC f2 :params [$x] :body (* $x 2)]');
+    expect(ast.length).toBe(2);
+  });
+});
+
+describe('Parser - [ROUTE] 블록', () => {
+  test('[ROUTE] GET 파싱', () => {
+    const ast = parse('[ROUTE health :method "GET" :path "/health" :handler (respond 200 "ok")]');
+    expect(ast).toBeDefined();
+  });
+
+  test('[ROUTE] POST 파싱', () => {
+    const ast = parse('[ROUTE create :method "POST" :path "/api/items" :handler (respond 201 "created")]');
+    expect(ast).toBeDefined();
+  });
+});
+
+describe('Parser - AST 노드 구조', () => {
+  test('S-expression 노드 kind', () => {
+    const ast = parse('(+ 1 2)');
+    expect((ast[0] as any).kind).toBe('sexpr');
+  });
+
+  test('[FUNC] 노드 kind 검증', () => {
+    const ast = parse('[FUNC f :params [$x] :body $x]');
+    expect((ast[0] as any).kind).toBe('block');
+  });
+
+  test('복수 노드 파싱', () => {
+    const ast = parse('(+ 1 2)(* 3 4)');
+    expect(ast.length).toBe(2);
+  });
+
+  test('빈 입력 → 빈 배열', () => {
+    const ast = parse('');
+    expect(Array.isArray(ast)).toBe(true);
+    expect(ast.length).toBe(0);
+  });
+});
+
+describe('Parser - 에러 처리', () => {
+  test('괄호 불일치 — 에러 발생', () => {
+    expect(() => parse('(+ 1 2')).toThrow();
+  });
+
+  test('최상위 심볼 — 에러 발생', () => {
+    expect(() => parse('hello world')).toThrow();
+  });
+
+  test('미완성 [FUNC] — 에러 발생', () => {
+    expect(() => parse('[FUNC')).toThrow();
+  });
+});

package/src/__tests__/phase151-self-evolve.test.ts

@@ -0,0 +1,161 @@
+// Phase 151: v9 자기진화 — v9가 자신의 코드를 진화시킨다
+
+import { EvolutionEngine } from "../evolve";
+
+beforeAll(() => {
+  jest.spyOn(console, "log").mockImplementation(() => {});
+});
+afterAll(() => {
+  jest.restoreAllMocks();
+});
+
+describe("Phase 151: v9 자기진화 [EVOLVE]", () => {
+  const sortAlgorithms = [
+    {
+      name: "bubble_sort_v1",
+      code: "(fn [arr] (reduce arr [result []] (cons result $item)))",
+      complexity: 2,
+    },
+    {
+      name: "selection_sort_v1",
+      code: "(fn [arr] (map arr (fn [$x] (+ $x 1))))",
+      complexity: 1,
+    },
+    {
+      name: "insertion_sort_v1",
+      code: "(fn [arr] (filter (fn [$x] (> $x 0)) arr))",
+      complexity: 1,
+    },
+    {
+      name: "merge_sort_v1",
+      code: "(fn [arr] (reverse arr))",
+      complexity: 1,
+    },
+  ];
+
+  const evaluateAlgorithm = (genome) => {
+    const lengthScore = 100 / (genome.code.length + 1);
+    const complexityScore = 100 / (genome.complexity + 1);
+    return lengthScore + complexityScore;
+  };
+
+  const mutateAlgorithm = (genome, rate) => {
+    if (Math.random() < rate) {
+      const code = genome.code;
+      const mutated = code.length > 20
+        ? code.slice(0, code.length - 5) + ")"
+        : code;
+
+      return {
+        ...genome,
+        code: mutated,
+        complexity: Math.max(1, genome.complexity - 1),
+        name: `${genome.name}_mut`,
+      };
+    }
+    return genome;
+  };
+
+  const crossoverAlgorithm = (a, b) => {
+    const midpoint = Math.floor(a.code.length / 2);
+    const newCode = a.code.slice(0, midpoint) + b.code.slice(midpoint);
+
+    return {
+      name: `${a.name}_x_${b.name}`,
+      code: newCode,
+      complexity: Math.round((a.complexity + b.complexity) / 2),
+    };
+  };
+
+  test("1. 정렬 알고리즘 유전자 정의", () => {
+    expect(sortAlgorithms.length).toBe(4);
+  });
+
+  test("2. fitness 함수 계산", () => {
+    const fitness = evaluateAlgorithm(sortAlgorithms[0]);
+    expect(fitness).toBeGreaterThan(0);
+    expect(fitness).toBeLessThan(200);
+  });
+
+  test("3. 변이 함수 작동", () => {
+    const mutated = mutateAlgorithm(sortAlgorithms[0], 1.0);
+    expect(mutated.name).toContain("_mut");
+  });
+
+  test("4. 교배 함수 작동", () => {
+    const child = crossoverAlgorithm(sortAlgorithms[0], sortAlgorithms[1]);
+    expect(child.code.length).toBeGreaterThan(0);
+    expect(child.name).toContain("_x_");
+  });
+
+  test("5. EvolutionEngine으로 8세대 진화", () => {
+    const engine = new EvolutionEngine({
+      populationSize: 8,
+      maxGenerations: 8,
+      mutationRate: 0.2,
+      eliteRatio: 0.25,
+      fitnessFunc: evaluateAlgorithm,
+      mutateFunc: (g, r) => mutateAlgorithm(g, r),
+      crossoverFunc: (a, b) => crossoverAlgorithm(a, b),
+      initFunc: () => sortAlgorithms[Math.floor(Math.random() * sortAlgorithms.length)],
+    });
+
+    engine.initialize();
+
+    for (let i = 0; i < 8; i++) {
+      engine.step();
+    }
+
+    const pop = engine.getPopulation();
+    expect(pop.length).toBe(8);
+    expect(pop[0].fitness).toBeGreaterThan(0);
+  });
+
+  test("6. 20세대 자기진화 — fitness 향상", () => {
+    const engine = new EvolutionEngine({
+      populationSize: 10,
+      maxGenerations: 20,
+      mutationRate: 0.15,
+      eliteRatio: 0.2,
+      fitnessFunc: evaluateAlgorithm,
+      mutateFunc: (g, r) => mutateAlgorithm(g, r),
+      crossoverFunc: (a, b) => crossoverAlgorithm(a, b),
+      initFunc: () => sortAlgorithms[Math.floor(Math.random() * sortAlgorithms.length)],
+    });
+
+    engine.initialize();
+
+    let firstBestFitness = 0;
+    let lastBestFitness = 0;
+
+    for (let i = 0; i < 20; i++) {
+      const { bestFitness } = engine.step();
+      if (i === 0) firstBestFitness = bestFitness;
+      lastBestFitness = bestFitness;
+    }
+
+    expect(lastBestFitness).toBeGreaterThanOrEqual(firstBestFitness);
+  });
+
+  test("7. 최고 개체 분석 및 코드 생성", () => {
+    const engine = new EvolutionEngine({
+      populationSize: 10,
+      maxGenerations: 15,
+      mutationRate: 0.15,
+      eliteRatio: 0.2,
+      fitnessFunc: evaluateAlgorithm,
+      mutateFunc: (g, r) => mutateAlgorithm(g, r),
+      crossoverFunc: (a, b) => crossoverAlgorithm(a, b),
+      initFunc: () => sortAlgorithms[Math.floor(Math.random() * sortAlgorithms.length)],
+    });
+
+    const result = engine.run();
+    const best = engine.getBest();
+
+    expect(best).not.toBeNull();
+    if (best) {
+      expect(best.fitness).toBeGreaterThan(0);
+      expect(best.genome.code.length).toBeGreaterThan(0);
+    }
+  });
+});