freelang-editor 11.7.4

package/self-evolve/v11-speed-benchmark.fl

@@ -0,0 +1,106 @@
+;; v11-speed-benchmark.fl: 속도 측정 (warmup 제외, 통계 포함)
+
+(defn make-range [n]
+  (if (= n 0)
+    []
+    (append (make-range (- n 1)) (- n 1))))
+
+(defn bench-parse-once [file]
+  (let [[start (now_ms)]]
+    (let [[src (file_read file)]]
+      (let [[tokens (lex src)]]
+        (let [[ast (parse tokens)]]
+          (- (now_ms) start))))))
+
+(defn bench-parse-repeated [file runs]
+  ;; runs회 반복, 각 시간 기록
+  (map (fn [_] (bench-parse-once file)) (make-range runs)))
+
+(defn calc-avg [arr]
+  (let [[sum (reduce (fn [a b] (+ a b)) 0 arr)]]
+    (if (= (length arr) 0)
+      0
+      (/ sum (length arr)))))
+
+(defn calc-min [arr]
+  (reduce (fn [a b] (if (< b a) b a)) 999999 arr))
+
+(defn calc-max [arr]
+  (reduce (fn [a b] (if (> b a) b a)) 0 arr))
+
+(defn bench-file [file-path]
+  (do
+    (println (str "⏱️  벤치마크: " file-path))
+    (println "  20회 반복 (warmup 5회 제외, 실측 15회)\n")
+
+    (let [[times (bench-parse-repeated file-path 20)]]
+      (let [[warmup (slice times 0 5)]]
+        (let [[measured (slice times 5 20)]]
+          (let [[avg (calc-avg measured)]]
+            (let [[min (calc-min measured)]]
+              (let [[max (calc-max measured)]]
+                (do
+                  (println (str "  Warmup (5회): " (calc-avg warmup) "ms"))
+                  (println (str "  평균: " avg "ms"))
+                  (println (str "  범위: " min "ms ~ " max "ms"))
+                  (println (str "  편차: ±" (- max min) "ms\n"))
+                  {:file file-path
+                   :total-runs 20
+                   :measured-runs 15
+                   :warmup-avg (calc-avg warmup)
+                   :avg-ms avg
+                   :min-ms min
+                   :max-ms max
+                   :range-ms (- max min)}))))))))
+
+(defn compare-results [orig optimized]
+  ;; 원본 vs 최적화본 비교
+  (let [[orig-avg (get orig "avg-ms")]]
+    (let [[opt-avg (get optimized "avg-ms")]]
+      (let [[delta (- orig-avg opt-avg)]]
+        (let [[pct (if (= orig-avg 0) 0 (/ (* 100 delta) orig-avg))]]
+          (do
+            (println "📊 비교 결과:")
+            (println (str "  원본: " orig-avg "ms (범위: " (get orig "min-ms") "~" (get orig "max-ms") ")"))
+            (println (str "  최적: " opt-avg "ms (범위: " (get optimized "min-ms") "~" (get optimized "max-ms") ")"))
+            (println (str "  개선: " delta "ms (" pct "%)"))
+            (if (>= (- orig-avg opt-avg) 2.5)
+              (println "  ✅ 유의미한 개선 (≥2.5ms, 10%이상)")
+              (println "  ⚠️  개선 미미 (<2.5ms 또는 <10%)"))
+            (println "")
+            {:baseline-avg orig-avg
+             :optimized-avg opt-avg
+             :delta-ms delta
+             :delta-pct pct
+             :significant (>= (- orig-avg opt-avg) 2.5)}))))))
+
+(do
+  (println "================================================")
+  (println "  속도 벤치마크 (통계 포함)")
+  (println "================================================\n")
+
+  (file_write "self-evolve/logs/speed-delta.log"
+    (str "속도 벤치마크 " (now_iso) "\n\n"))
+
+  ;; 원본 벤치마크
+  (let [[orig (bench-file "self/all.fl")]]
+    (do
+      ;; 최적화본 벤치마크
+      (let [[opt (bench-file "self-evolve/logs/speed-gen-0.fl")]]
+        (do
+          ;; 비교
+          (let [[comparison (compare-results orig opt)]]
+            (do
+              (file_append "self-evolve/logs/speed-delta.log"
+                (str "## 벤치마크 결과\n\n"
+                     "원본 (self/all.fl):\n"
+                     "- 평균: " (get orig "avg-ms") "ms\n"
+                     "- 범위: " (get orig "min-ms") "~" (get orig "max-ms") "ms\n"
+                     "- 편차: " (get orig "range-ms") "ms\n\n"
+                     "최적화 (speed-gen-0.fl):\n"
+                     "- 평균: " (get opt "avg-ms") "ms\n"
+                     "- 범위: " (get opt "min-ms") "~" (get opt "max-ms") "ms\n"
+                     "- 편차: " (get opt "range-ms") "ms\n\n"
+                     "개선: " (get comparison "delta-ms") "ms (" (get comparison "delta-pct") "%)\n"
+                     "유의미: " (if (get comparison "significant") "YES" "NO") "\n\n"))
+              (println "✅ 벤치마크 완료")))))))

package/self-evolve/v11-speed-optimizer.fl

@@ -0,0 +1,79 @@
+;; v11-speed-optimizer.fl: 안정화된 코드 변환기
+;; 핵심: 변환 후 반드시 파싱 검증 (깨진 코드 방지)
+
+(defn optimize-pass-1 [src]
+  ;; Pass 1: whitespace 정규화 (다중 공백 → 단일)
+  (let [[p1 (str_replace src "  " " ")]]
+    (let [[p2 (str_replace p1 "\n\n" "\n")]]
+      p2)))
+
+(defn optimize-pass-2 [src]
+  ;; Pass 2: str 최적화 (str (str a b) c) → (str a b c)
+  ;; ⚠️ 위험: 구조를 모르고 치환 → 나중에 AST 기반으로 전환 필수
+  (str_replace src "(str (str" "(str"))
+
+(defn count-ast-nodes [src]
+  ;; AST 노드 수 = parse 결과 배열 길이
+  (let [[tokens (lex src)]]
+    (let [[ast (parse tokens)]]
+      (length ast))))
+
+(defn is-valid-code [src]
+  ;; 코드가 유효한가? → parse 성공 = 유효
+  (let [[tokens (lex src)]]
+    (let [[ast (parse tokens)]]
+      (> (length ast) 0))))
+
+(defn optimize-all [src]
+  ;; 모든 pass 적용
+  (let [[p1 (optimize-pass-1 src)]]
+    (let [[p2 (optimize-pass-2 p1)]]
+      {:original src
+       :optimized p2
+       :orig-size (length src)
+       :new-size (length p2)
+       :size-delta (- (length src) (length p2))
+       :orig-ast (count-ast-nodes src)
+       :new-ast (count-ast-nodes p2)
+       :ast-delta (- (count-ast-nodes src) (count-ast-nodes p2))
+       :valid (is-valid-code p2)})))
+
+(do
+  (println "================================================")
+  (println "  속도 최적화기 v1 (검증 포함)")
+  (println "================================================\n")
+
+  ;; self/all.fl 읽기
+  (let [[src (file_read "self/all.fl")]]
+    (do
+      (println (str "원본 크기: " (length src) "B"))
+      (println (str "원본 AST: " (count-ast-nodes src) " 노드\n"))
+
+      ;; 최적화 실행
+      (let [[result (optimize-all src)]]
+        (do
+          ;; 결과 출력
+          (println (str "최적화 후:"))
+          (println (str "  크기: " (get result "new-size") "B (감소: " (get result "size-delta") "B)"))
+          (println (str "  AST: " (get result "new-ast") " 노드 (감소: " (get result "ast-delta") ")\n"))
+
+          ;; ⚠️ 검증 단계: 코드가 유효한가?
+          (if (get result "valid")
+            (do
+              (println "✅ 코드 유효성 검증 PASS")
+              ;; 최적화본 저장
+              (file_write "self-evolve/logs/speed-gen-0.fl" (get result "optimized"))
+
+              ;; 로그 기록
+              (file_write "self-evolve/logs/speed-delta.log"
+                (str "속도 최적화 " (now_iso) "\n\n"
+                     "## Gen 0\n"
+                     "- 크기: " (get result "orig-size") "B → " (get result "new-size") "B (-" (get result "size-delta") "B)\n"
+                     "- AST: " (get result "orig-ast") " → " (get result "new-ast") " (-" (get result "ast-delta") ")\n"
+                     "- 상태: VALID ✅\n\n"))
+
+              (println "\n✅ 최적화 완료 (안전함)"))
+            (do
+              (println "❌ 코드 유효성 검증 FAIL")
+              (println "   변환된 코드가 깨졌습니다. 저장하지 않음.")
+              (println "   → AST 기반 변환으로 전환 필요"))))))))

package/src/AGENT-DSL.md

@@ -0,0 +1,527 @@
+# FreeLang v11 Agent DSL — 완전 가이드
+
+> AI 에이전트가 **안정적으로 작업을 정의하고 실행**하는 프레임워크
+
+---
+
+## 📚 목차
+
+1. [개요](#개요)
+2. [핵심 개념](#핵심-개념)
+3. [Task 정의](#task-정의)
+4. [State 관리](#state-관리)
+5. [Logging & 검증](#logging--검증)
+6. [Storage](#storage)
+7. [실제 예제](#실제-예제)
+8. [API 레퍼런스](#api-레퍼런스)
+
+---
+
+## 개요
+
+### FreeLang Agent DSL은 무엇인가?
+
+AI 에이전트가 작업을 **결정론적으로 정의하고 실행**하는 프레임워크입니다.
+
+```lisp
+(load "src/agent-dsl.fl")
+
+; Task 정의
+(let [$task (make-task "fetch-data" fetch-action)])
+
+; 실행
+(agent-run [$task])
+```
+
+### 3가지 특징
+
+| 특징 | 설명 |
+|------|------|
+| **Deterministic** | 같은 입력 = 같은 출력 (SHA256 보증) |
+| **Reproducible** | 실행 기록 → 재현 가능한 로그 |
+| **Traceable** | 모든 단계를 추적하고 검증 |
+
+---
+
+## 핵심 개념
+
+### 1. Task (작업)
+
+**정의**: 하나의 원자적 작업 단위
+
+```lisp
+{
+  :name "fetch-users"      ; 작업 이름
+  :action action-fn        ; 실행 함수
+  :depends []              ; 의존 작업
+  :retry 3                 ; 재시도 횟수
+  :timeout 30000           ; 타임아웃 (ms)
+  :on-error nil            ; 에러 핸들러
+  :on-success nil          ; 성공 콜백
+  :status "pending"        ; 상태
+  :result nil              ; 실행 결과
+  :error nil               ; 에러 정보
+}
+```
+
+### 2. State (상태)
+
+**정의**: Agent의 전역 상태 (불변)
+
+```lisp
+{
+  :id "agent_1234567890"      ; 세션 ID
+  :created-at 1234567890      ; 생성 시간
+  :steps { :counter 0 }       ; 단계별 데이터
+  :logs [...]                 ; 실행 기록
+}
+```
+
+### 3. Workflow (워크플로우)
+
+**정의**: 여러 Task를 의존성과 함께 실행
+
+```
+Task A (독립)
+  ↓
+Task B (A 완료 후)
+  ↓
+Task C (B 완료 후)
+```
+
+---
+
+## Task 정의
+
+### 기본 Task 만들기
+
+```lisp
+(let [$action (fn [$ctx] (println "작업 실행중..."))]
+  (let [$task (make-task "hello" $action)]
+    (println $task)))
+```
+
+**출력**:
+```
+{
+  :name "hello"
+  :action <function>
+  :depends []
+  :retry 3
+  :timeout 30000
+  ...
+}
+```
+
+### Task 커스터마이징
+
+```lisp
+; 재시도 횟수 변경
+(assoc $task :retry 5)
+
+; 의존성 추가
+(assoc $task :depends ["fetch-data"])
+
+; 에러 핸들러 추가
+(assoc $task :on-error (fn [err]
+  (println (str "Error: " err))
+))
+
+; 성공 콜백 추가
+(assoc $task :on-success (fn [result]
+  (println (str "Success: " result))
+))
+```
+
+### Task 액션 함수 작성
+
+```lisp
+; 간단한 액션
+[FUNC fetch-action :params [$ctx]
+  :body { :data [1 2 3] }
+]
+
+; 컨텍스트 사용
+[FUNC process-action :params [$ctx]
+  :body (let [
+    [$input (get $ctx :input)]
+  ] (map (fn [x] (* x 2)) $input))
+]
+
+; HTTP 요청
+[FUNC api-action :params [$ctx]
+  :body (let [
+    [$response (http-get "https://api.example.com/data")]
+  ] (json-parse $response))
+]
+```
+
+---
+
+## State 관리
+
+### State 초기화
+
+```lisp
+(let [$state (agent-state)]
+  (println $state))
+```
+
+**출력**:
+```
+{
+  :id "agent_1234567890"
+  :created-at 1234567890
+  :steps {}
+  :logs []
+}
+```
+
+### State 값 설정 및 조회
+
+```lisp
+; 값 설정
+(let [$state (agent-state-set $state "counter" 0)]
+  (println (agent-state-get $state "counter")))  ; 0
+
+; 여러 값 설정
+(let [$state (agent-state-set $state "total" 100)]
+  (let [$state (agent-state-set $state "processed" 0)]
+    (println (agent-state-get $state "total"))))  ; 100
+```
+
+### State 변화 추적
+
+```lisp
+(let [$state (agent-state)]
+  (let [$state (agent-state-set $state "step1" "done")]
+    (let [$state (agent-state-set $state "step2" "running")]
+      (println (get $state :steps)))))
+
+; 출력:
+; { :step1 "done" :step2 "running" }
+```
+
+---
+
+## Logging & 검증
+
+### 기본 로깅
+
+```lisp
+(load "src/logging-deterministic.fl")
+
+(let [$entry (log-entry 1 "fetch-data" 
+  { :url "..." }
+  { :result [...] }
+)]
+  (println $entry))
+```
+
+**출력**:
+```
+{
+  :step 1
+  :task-name "fetch-data"
+  :timestamp 1234567890
+  :input { :url "..." }
+  :output { :result [...] }
+  :input-hash "sha256-abc123..."
+  :output-hash "sha256-def456..."
+}
+```
+
+### 로그 검증 (결정론 보증)
+
+```lisp
+(let [$entry (log-entry 1 "task" 
+  { :data 42 }
+  { :result 84 }
+)]
+  (let [$verification (log-verify $entry)]
+    (println (get $verification :valid))))  ; true
+```
+
+### 배치 검증
+
+```lisp
+(let [$log (execution-log)]
+  (let [$log (log-append $log $entry1)]
+    (let [$log (log-append $log $entry2)]
+      (let [$results (log-verify-all $log)]
+        (println (get $results :all-valid))))))  ; true
+```
+
+### 재현 (Replay)
+
+```lisp
+(let [$replay-results (log-replay $log)]
+  (println (get $replay-results :total-steps)))
+```
+
+---
+
+## Storage
+
+### 초기화
+
+```lisp
+(load "src/storage-unified.fl")
+
+; SQLite
+(let [$storage (storage-init { :type "sqlite" :path "./agent.db" })]
+  (println $storage))
+
+; MariaDB
+(let [$storage (storage-init {
+  :type "mariadb"
+  :host "localhost"
+  :user "root"
+  :password "..."
+})]
+  (println $storage))
+
+; JSON (파일 기반)
+(let [$storage (storage-init { :type "json" :path "./data" })]
+  (println $storage))
+```
+
+### 데이터 저장
+
+```lisp
+; 상태 저장
+(storage-save $storage "agent-state" "session-123" {
+  :counter 42
+  :status "running"
+})
+
+; 작업 결과 저장
+(storage-save $storage "task-results" "task-1" {
+  :status "done"
+  :output { :count 100 }
+})
+```
+
+### 데이터 로드
+
+```lisp
+(let [$data (storage-load $storage "agent-state" "session-123")]
+  (println $data))
+
+; 출력:
+; { :counter 42 :status "running" }
+```
+
+### 쿼리 실행
+
+```lisp
+; SQLite
+(let [$results (storage-query $storage 
+  "SELECT * FROM tasks WHERE status = 'done'")]
+  (println $results))
+
+; MariaDB
+(let [$results (storage-query $storage
+  "SELECT * FROM tasks WHERE created_at > ?")]
+  (println $results))
+```
+
+---
+
+## 실제 예제
+
+### 예제 1: 순차 작업 (데이터 수집 → 처리 → 저장)
+
+```lisp
+(load "src/agent-dsl.fl")
+(load "src/logging-deterministic.fl")
+(load "src/storage-unified.fl")
+
+(let [$state (agent-state)]
+
+  ; Task 1: 데이터 수집
+  (let [$fetch-task (make-task "fetch" (fn [$ctx]
+    (let [$data [
+      { :id 1 :value 100 }
+      { :id 2 :value 200 }
+    ]]
+      (do
+        (set! $state (agent-log $state 1 "Fetched 2 items" {}))
+        $data
+      )
+    )
+  ))]
+
+    ; Task 2: 처리
+    (let [$process-task (make-task "process" (fn [$ctx]
+      (let [$processed (map (fn [item]
+        (assoc item :doubled (* (get item :value) 2))
+      ) [...])]
+        (do
+          (set! $state (agent-log $state 2 "Processed items" {}))
+          $processed
+        )
+      )
+    ))]
+      (assoc $process-task :depends ["fetch"])
+
+      ; Task 3: 저장
+      (let [$save-task (make-task "save" (fn [$ctx]
+        (let [$storage (storage-init { :type "sqlite" })]
+          (do
+            (storage-save $storage "results" "batch-1" [...])
+            (set! $state (agent-log $state 3 "Saved results" {}))
+            { :saved true }
+          )
+        )
+      ))]
+        (assoc $save-task :depends ["process"])
+
+        ; 실행
+        (let [$result (agent-run [
+          $fetch-task
+          $process-task
+          $save-task
+        ])]
+          (println "완료!")
+          (println (str "총 단계: " (get $result :total-steps)))
+        )
+      )
+    )
+  )
+)
+```
+
+### 예제 2: 에러 처리 및 재시도
+
+```lisp
+(let [$api-task (make-task "call-api" (fn [$ctx]
+  (http-get "https://api.example.com/data")
+))]
+
+  ; 재시도 설정
+  (set! $api-task (assoc $api-task :retry 3))
+  (set! $api-task (assoc $api-task :timeout 5000))
+
+  ; 에러 핸들러
+  (set! $api-task (assoc $api-task :on-error (fn [err]
+    (println (str "API 호출 실패: " err))
+  )))
+
+  ; 성공 핸들러
+  (set! $api-task (assoc $api-task :on-success (fn [result]
+    (println "API 호출 성공!")
+  )))
+
+  (agent-run [$api-task])
+)
+```
+
+### 예제 3: 상태 추적 및 감시
+
+```lisp
+(let [$state (agent-state)]
+  (let [$state (agent-state-set $state "processed" 0)]
+    (let [$state (agent-state-set $state "total" 1000)]
+
+      ; 진행 상황 추적
+      (let [$loop-task (make-task "loop" (fn [$ctx]
+        (let [$processed (agent-state-get $state "processed")]
+          (do
+            (set! $state (agent-state-set $state "processed" (+ $processed 100)))
+            (let [$log-entry (log-entry 1 "loop"
+              { :processed $processed }
+              { :processed (+ $processed 100) }
+            )]
+              (set! $state (log-append $state $log-entry))
+            )
+          )
+        )
+      ))]
+
+        (agent-run [$loop-task])
+
+        ; 최종 상태 확인
+        (println (str "처리됨: " (agent-state-get $state "processed")))
+        (println (str "로그 수: " (length (get $state :logs))))
+      )
+    )
+  )
+)
+```
+
+---
+
+## API 레퍼런스
+
+### Task
+
+| 함수 | 설명 |
+|------|------|
+| `(make-task name action)` | Task 생성 |
+| `(task-execute task context)` | Task 실행 |
+| `(agent-run task-list)` | 여러 Task 실행 |
+
+### State
+
+| 함수 | 설명 |
+|------|------|
+| `(agent-state)` | State 초기화 |
+| `(agent-state-set state key value)` | 값 설정 |
+| `(agent-state-get state key)` | 값 조회 |
+| `(agent-log state step message data)` | 로그 추가 |
+
+### Logging
+
+| 함수 | 설명 |
+|------|------|
+| `(log-entry step task-name input output)` | 로그 엔트리 생성 |
+| `(sha256-deterministic data)` | 결정론 해싱 |
+| `(log-verify entry)` | 로그 검증 |
+| `(log-verify-all log)` | 배치 검증 |
+| `(log-replay log)` | 재현 |
+
+### Storage
+
+| 함수 | 설명 |
+|------|------|
+| `(storage-init config)` | 저장소 초기화 |
+| `(storage-save storage table key value)` | 데이터 저장 |
+| `(storage-load storage table key)` | 데이터 로드 |
+| `(storage-query storage sql)` | 쿼리 실행 |
+| `(storage-migrate storage migrations)` | 마이그레이션 |
+
+---
+
+## 핵심 원칙
+
+### 1. **결정론성**
+```lisp
+(fib 30)  ; → 항상 832040
+(sha256-deterministic {:a 1})  ; → 항상 같은 해시
+```
+
+### 2. **재현성**
+```lisp
+; 실행 기록을 저장하면, 같은 입력으로 같은 결과를 얻을 수 있다
+(log-verify entry)  ; SHA256 검증
+```
+
+### 3. **추적성**
+```lisp
+; 모든 단계를 로그와 저장소에 기록
+(agent-log state step message data)
+(storage-save storage table key value)
+```
+
+---
+
+## 다음 단계
+
+- [Deterministic Logging Guide](./LOGGING-GUIDE.md) — 로깅 심화
+- [Storage Guide](./STORAGE-GUIDE.md) — 저장소 심화
+- [Express.fl Demo](./echo-server-demo.fl) — HTTP 서버 예제
+
+---
+
+**🤖 AI 에이전트를 FreeLang으로 안전하게 실행하세요!**