freelang-editor 11.7.4

package/src/repl.ts

@@ -0,0 +1,323 @@
+// FreeLang v9: REPL 2.0
+// Phase 75: 히스토리, :cmd 명령어, 기본 자동완성
+
+import * as readline from "readline";
+import * as fs from "fs";
+import * as path from "path";
+import { Interpreter } from "./interpreter";
+import { lex } from "./lexer";
+import { parse } from "./parser";
+
+// REPL 전용 평가 결과 타입
+export interface ReplResult {
+  value: any;
+  error?: string;
+}
+
+// 단위 테스트용: readline 없이 동작하는 핵심 로직
+export class FreeLangReplCore {
+  public interp: Interpreter;
+  public history: string[] = [];
+
+  constructor(interp?: Interpreter) {
+    this.interp = interp ?? new Interpreter();
+  }
+
+  /**
+   * 소스 라인 평가 (eval 핵심)
+   */
+  evalLine(src: string): ReplResult {
+    try {
+      const ctx = this.interp.interpret(parse(lex(src)));
+      return { value: ctx.lastValue };
+    } catch (e: any) {
+      return { value: undefined, error: e.message };
+    }
+  }
+
+  /**
+   * :cmd 명령어 처리
+   * 반환값: 출력할 문자열 (undefined = 출력 없음)
+   */
+  handleCmd(cmd: string): string | undefined {
+    const parts = cmd.slice(1).trim().split(/\s+/);
+    const name = parts[0];
+    const args = parts.slice(1);
+
+    switch (name) {
+      case "help":
+        return [
+          "FreeLang v9 REPL 명령어:",
+          "  :help          — 이 도움말",
+          "  :ls            — 정의된 함수 목록",
+          "  :src <이름>    — 함수 소스(파라미터) 보기",
+          "  :inspect <변수> — 변수 현재 값",
+          "  :time <표현식> — 실행 시간 측정",
+          "  :clear         — 인터프리터 상태 초기화",
+          "  :load <파일>   — .fl 파일 로드",
+          "  :hist          — 히스토리 출력",
+          "  :quit / :exit  — 종료",
+          "",
+          "디버거 (S2, 2026-05-01):",
+          "  :break <fn>    — 함수에 break point 설정",
+          "  :step          — step 모드 toggle (모든 줄에서 break)",
+          "  :continue      — break 해제 + 계속 실행",
+          "  :stack         — 현재 callStack 출력",
+          "  :locals        — 현재 변수 dump",
+          "  :debug         — debugger enabled toggle",
+          "  :watch <var>   — 변수 감시 추가",
+          "  :unwatch <var> — 변수 감시 제거",
+          "  :watches       — 감시 중인 변수 출력",
+        ].join("\n");
+
+      case "ls": {
+        const fns = [...this.interp.context.functions.keys()];
+        if (fns.length === 0) return "(함수 없음)";
+        return fns.join("  ");
+      }
+
+      case "src": {
+        const fnName = args[0];
+        if (!fnName) return "사용법: :src <함수명>";
+        const fn = this.interp.context.functions.get(fnName);
+        if (!fn) return `함수 '${fnName}' 없음`;
+        const params = fn.params.join(" ");
+        return `(defn ${fn.name} [${params}] ...)`;
+      }
+
+      case "inspect": {
+        const varName = args[0];
+        if (!varName) return "사용법: :inspect <변수명>";
+        // variables는 $-prefix로 저장됨 (define x 42 → $x)
+        const key = varName.startsWith("$") ? varName : "$" + varName;
+        const val = this.interp.context.variables.get(key);
+        if (val === undefined && !this.interp.context.variables.has(key)) {
+          return `변수 '${varName}' 없음`;
+        }
+        return `${varName} = ${JSON.stringify(val)}`;
+      }
+
+      case "time": {
+        const expr = args.join(" ");
+        if (!expr) return "사용법: :time <표현식>";
+        const start = Date.now();
+        const result = this.evalLine(expr);
+        const elapsed = Date.now() - start;
+        if (result.error) return `오류: ${result.error} (${elapsed}ms)`;
+        return `→ ${JSON.stringify(result.value)} (${elapsed}ms)`;
+      }
+
+      case "clear": {
+        this.interp = new Interpreter();
+        return "상태 초기화 완료";
+      }
+
+      case "load": {
+        const filePath = args[0];
+        if (!filePath) return "사용법: :load <파일경로>";
+        const absPath = path.resolve(filePath);
+        if (!fs.existsSync(absPath)) return `파일 없음: ${absPath}`;
+        try {
+          const src = fs.readFileSync(absPath, "utf-8");
+          const result = this.evalLine(src);
+          if (result.error) return `로드 오류: ${result.error}`;
+          return `로드 완료: ${absPath}`;
+        } catch (e: any) {
+          return `로드 오류: ${e.message}`;
+        }
+      }
+
+      case "hist": {
+        if (this.history.length === 0) return "(히스토리 없음)";
+        return this.history
+          .map((h, i) => `  ${String(i + 1).padStart(3)}: ${h}`)
+          .join("\n");
+      }
+
+      case "quit":
+      case "exit":
+        process.exit(0);
+
+      // ── S1 (2026-04-25): 디버거 명령 ──────────────────
+      case "break": {
+        const fnName = args[0];
+        if (!fnName) return "사용법: :break <함수명> 또는 :break <파일:라인>";
+        const { getGlobalDebugSession } = require("./debugger");
+        const sess = getGlobalDebugSession();
+        sess.enabled = true;
+        // 함수명만 주면 그 함수 정의의 line에 break
+        if (!fnName.includes(":")) {
+          const fn = this.interp.context.functions.get(fnName);
+          if (!fn) return `함수 '${fnName}' 없음`;
+          const line = (fn as any).line ?? 0;
+          sess.addBreakpoint("<repl>", line);
+          return `break point 설정: ${fnName} (line ${line})`;
+        }
+        // file:line 형식
+        const [file, lineStr] = fnName.split(":");
+        sess.addBreakpoint(file, Number(lineStr));
+        return `break point 설정: ${file}:${lineStr}`;
+      }
+      case "step": {
+        const { getGlobalDebugSession } = require("./debugger");
+        const sess = getGlobalDebugSession();
+        sess.enabled = true;
+        sess.stepMode = !sess.stepMode;
+        return `step 모드: ${sess.stepMode ? "ON" : "OFF"}`;
+      }
+      case "continue": {
+        const { getGlobalDebugSession } = require("./debugger");
+        const sess = getGlobalDebugSession();
+        sess.stepMode = false;
+        return "step 모드 해제 (continue)";
+      }
+      case "stack": {
+        const stack: Array<{fn: string; line: number}> = (this.interp as any).callStack ?? [];
+        if (stack.length === 0) return "(callStack 비어있음)";
+        return stack.slice(-20).map((s, i) =>
+          `  #${stack.length - 20 + i}: ${s.fn} (line ${s.line})`
+        ).join("\n");
+      }
+      case "locals": {
+        // 현재 scope의 모든 변수 dump
+        const vars: Map<string, any> = (this.interp.context.variables as any).snapshot?.()
+          ?? new Map();
+        if (vars.size === 0) return "(변수 없음)";
+        const out: string[] = [];
+        let count = 0;
+        for (const [k, v] of vars) {
+          if (count++ >= 30) { out.push(`  ... (${vars.size - 30}개 더)`); break; }
+          const valStr = typeof v === "function" ? "<function>"
+            : v?.kind === "function-value" ? "<fn-value>"
+            : JSON.stringify(v)?.slice(0, 60);
+          out.push(`  ${k} = ${valStr}`);
+        }
+        return out.join("\n");
+      }
+      case "debug": {
+        const { getGlobalDebugSession } = require("./debugger");
+        const sess = getGlobalDebugSession();
+        sess.enabled = !sess.enabled;
+        return `debugger: ${sess.enabled ? "ON" : "OFF"}`;
+      }
+
+      case "watch": {
+        const varName = args[0];
+        if (!varName) return "사용법: :watch <변수명>";
+        const { getGlobalDebugSession } = require("./debugger");
+        const sess = getGlobalDebugSession();
+        sess.addWatch(varName);
+        return `👁 watching: ${varName}`;
+      }
+
+      case "unwatch": {
+        const varName = args[0];
+        if (!varName) return "사용법: :unwatch <변수명>";
+        const { getGlobalDebugSession } = require("./debugger");
+        const sess = getGlobalDebugSession();
+        sess.removeWatch(varName);
+        return `✓ removed: ${varName}`;
+      }
+
+      case "watches": {
+        const { getGlobalDebugSession } = require("./debugger");
+        const sess = getGlobalDebugSession();
+        const watched = sess.getWatchValues(this.interp.context.variables as any);
+        if (Object.keys(watched).length === 0) {
+          return "(감시 중인 변수 없음)";
+        }
+        const out: string[] = [];
+        for (const [k, v] of Object.entries(watched)) {
+          const valStr = typeof v === "function" ? "<function>"
+            : v?.kind === "function-value" ? "<fn-value>"
+            : JSON.stringify(v)?.slice(0, 80);
+          out.push(`  ${k} = ${valStr}`);
+        }
+        return out.join("\n");
+      }
+
+      default:
+        return `알 수 없는 명령어: :${name} (:help 참조)`;
+    }
+  }
+
+  /**
+   * 한 줄 처리 (히스토리 누적 + :cmd 분기)
+   * 반환: { output, isError }
+   */
+  processLine(line: string): { output: string | null; isError: boolean } {
+    const trimmed = line.trim();
+    if (!trimmed) return { output: null, isError: false };
+
+    this.history.push(trimmed);
+
+    if (trimmed.startsWith(":")) {
+      const out = this.handleCmd(trimmed);
+      return { output: out ?? null, isError: false };
+    }
+
+    const result = this.evalLine(trimmed);
+    if (result.error) {
+      return { output: `오류: ${result.error}`, isError: true };
+    }
+    if (result.value !== null && result.value !== undefined) {
+      return { output: `→ ${JSON.stringify(result.value)}`, isError: false };
+    }
+    return { output: null, isError: false };
+  }
+}
+
+/**
+ * 인터랙티브 REPL (readline 사용)
+ */
+export class FreeLangRepl {
+  private core: FreeLangReplCore;
+  private rl!: readline.Interface;
+
+  constructor() {
+    this.core = new FreeLangReplCore();
+  }
+
+  start(): void {
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true,
+      completer: (line: string) => this.completer(line),
+    });
+
+    console.log("FreeLang v9 REPL — :help 로 명령어 확인");
+    this.prompt();
+  }
+
+  private completer(line: string): [string[], string] {
+    // :cmd 자동완성 (15개 명령어)
+    const cmds = [
+      ":help", ":ls", ":src", ":inspect", ":time", ":clear", ":load", ":hist", ":quit", ":exit",
+      ":break", ":step", ":continue", ":stack", ":locals", ":debug",
+      ":watch", ":unwatch", ":watches",
+    ];
+    if (line.startsWith(":")) {
+      const hits = cmds.filter((c) => c.startsWith(line));
+      return [hits.length ? hits : cmds, line];
+    }
+    // 함수명 자동완성
+    const fns = [...this.core.interp.context.functions.keys()];
+    const hits = fns.filter((f) => f.startsWith(line));
+    return [hits, line];
+  }
+
+  private prompt(): void {
+    this.rl.question("fl> ", (line) => {
+      const { output, isError } = this.core.processLine(line);
+      if (output !== null) {
+        if (isError) {
+          console.error(output);
+        } else {
+          console.log(output);
+        }
+      }
+      this.prompt();
+    });
+  }
+}

package/src/result-type.ts

@@ -0,0 +1,126 @@
+// FreeLang v9: Result 타입 — Phase 96 AI 에러 처리 시스템
+// 에러는 프로그램 종료가 아니다. AI가 학습하고 복구하는 정보다.
+
+// ── ErrorCategory ────────────────────────────────────────────────────────
+export enum ErrorCategory {
+  TYPE_ERROR    = 'type-error',
+  RUNTIME_ERROR = 'runtime-error',
+  NOT_FOUND     = 'not-found',
+  ARITY         = 'arity-error',
+  IO            = 'io-error',
+  AI            = 'ai-error',
+  USER          = 'user-error',
+  TIMEOUT       = 'timeout',
+}
+
+// ── Ok<T> ─────────────────────────────────────────────────────────────────
+export interface Ok<T> {
+  readonly _tag: 'Ok';
+  readonly value: T;
+}
+
+// ── Err ──────────────────────────────────────────────────────────────────
+export interface Err {
+  readonly _tag: 'Err';
+  readonly code: string;
+  readonly message: string;
+  readonly category: ErrorCategory;
+  readonly context?: Record<string, any>;
+  readonly hint?: string;
+  readonly recoverable: boolean;
+}
+
+// ── Result<T> ─────────────────────────────────────────────────────────────
+export type Result<T> = Ok<T> | Err;
+
+// ── 생성 함수 ─────────────────────────────────────────────────────────────
+export function ok<T>(value: T): Ok<T> {
+  return { _tag: 'Ok', value };
+}
+
+export function err(
+  code: string,
+  message: string,
+  opts?: {
+    category?: ErrorCategory;
+    context?: Record<string, any>;
+    hint?: string;
+    recoverable?: boolean;
+  }
+): Err {
+  return {
+    _tag: 'Err',
+    code,
+    message,
+    category: opts?.category ?? ErrorCategory.RUNTIME_ERROR,
+    context: opts?.context,
+    hint: opts?.hint,
+    recoverable: opts?.recoverable ?? false,
+  };
+}
+
+// ── 판별 함수 ─────────────────────────────────────────────────────────────
+export function isOk<T>(r: Result<T>): r is Ok<T> {
+  return r._tag === 'Ok';
+}
+
+export function isErr<T>(r: Result<T>): r is Err {
+  return r._tag === 'Err';
+}
+
+// ── 값 추출 ───────────────────────────────────────────────────────────────
+export function unwrap<T>(r: Result<T>): T {
+  if (isOk(r)) return r.value;
+  throw new Error(`[FreeLang Result] unwrap failed: [${r.code}] ${r.message}`);
+}
+
+export function unwrapOr<T>(r: Result<T>, defaultValue: T): T {
+  if (isOk(r)) return r.value;
+  return defaultValue;
+}
+
+// ── 변환 함수 ─────────────────────────────────────────────────────────────
+export function mapOk<T, U>(r: Result<T>, fn: (v: T) => U): Result<U> {
+  if (isOk(r)) return ok(fn(r.value));
+  return r as unknown as Err;
+}
+
+export function mapErr<T>(r: Result<T>, fn: (e: Err) => Err): Result<T> {
+  if (isErr(r)) return fn(r);
+  return r;
+}
+
+export function flatMap<T, U>(r: Result<T>, fn: (v: T) => Result<U>): Result<U> {
+  if (isOk(r)) return fn(r.value);
+  return r as unknown as Err;
+}
+
+export function recover<T>(r: Result<T>, fn: (e: Err) => T): T {
+  if (isOk(r)) return r.value;
+  return fn(r);
+}
+
+// ── 기존 Error → Result 변환 ──────────────────────────────────────────────
+export function fromThrown(e: unknown, code = 'UNKNOWN'): Err {
+  if (typeof e === 'string') {
+    return err(code, e);
+  }
+  if (e instanceof Error) {
+    // 에러 메시지에서 카테고리 추론
+    const msg = e.message.toLowerCase();
+    let category = ErrorCategory.RUNTIME_ERROR;
+    if (msg.includes('not found') || msg.includes('undefined') || msg.includes('cannot find')) {
+      category = ErrorCategory.NOT_FOUND;
+    } else if (msg.includes('type') || msg.includes('is not a')) {
+      category = ErrorCategory.TYPE_ERROR;
+    } else if (msg.includes('arity') || msg.includes('argument')) {
+      category = ErrorCategory.ARITY;
+    } else if (msg.includes('timeout')) {
+      category = ErrorCategory.TIMEOUT;
+    } else if (msg.includes('enoent') || msg.includes('eacces') || msg.includes('file')) {
+      category = ErrorCategory.IO;
+    }
+    return err(code, e.message, { category, recoverable: false });
+  }
+  return err(code, String(e));
+}

package/src/return-signal.ts

@@ -0,0 +1,10 @@
+// FreeLang: ReturnSignal — (return val) early exit from fn body
+// try/catch 블록을 통과해 함수 호출 경계까지 전파됨
+
+export class ReturnSignal {
+  constructor(public readonly value: any) {}
+}
+
+export function isReturnSignal(e: unknown): e is ReturnSignal {
+  return e instanceof ReturnSignal;
+}

package/src/runtime-entry.ts

@@ -0,0 +1,8 @@
+// src/runtime-entry.ts — Y4-3 풀 이관 단계A 진입점
+//
+// self/runtime/interpreter.js 를 esbuild 로 번들할 때의 단일 entry.
+// REPL/dynamic eval 산출물에서 require 가능한 표면.
+
+export { Interpreter, interpret } from "./interpreter";
+export { lex } from "./lexer";
+export { parse } from "./parser";