freelang-editor 11.7.4

package/src/test-typeclass-parsing.ts

@@ -0,0 +1,264 @@
+// Phase 5 Week 2 Day 1: TypeClass Parsing Tests
+// TYPECLASS와 INSTANCE 블록 파싱 검증
+
+import { lex } from "./lexer";
+import { parse } from "./parser";
+import { TypeClass, TypeClassInstance } from "./ast";
+
+console.log("🚀 Phase 5 Week 2 Day 1: TypeClass Parsing Tests\n");
+
+// Helper: Parse code and extract AST nodes
+function parseCode(code: string): any[] {
+  const tokens = lex(code);
+  const ast = parse(tokens);
+  return ast;
+}
+
+// TEST 1: TYPECLASS 기본 파싱
+console.log("=".repeat(60));
+console.log("TEST 1: TYPECLASS 기본 파싱");
+console.log("=".repeat(60));
+
+try {
+  const code1 = `
+[TYPECLASS Monad
+  :typeParams [M]
+  :methods [
+    [:pure (fn [$a] (M $a))]
+    [:bind (fn [$m $f] (M))]
+    [:map (fn [$m $f] (M))]
+  ]
+]
+`;
+
+  const ast = parseCode(code1);
+  const typeClass = ast[0] as TypeClass;
+
+  console.log(`Input: [TYPECLASS Monad :typeParams [M] :methods [...]]`);
+  console.log(`Kind: ${typeClass.kind}`);
+  console.log(`Name: ${typeClass.name}`);
+  console.log(`TypeParams: [${typeClass.typeParams.join(", ")}]`);
+  console.log(`Methods: [${Array.from(typeClass.methods.keys()).join(", ")}]`);
+  console.log(`✅ ${typeClass.kind === "type-class" && typeClass.name === "Monad" ? "PASS" : "FAIL"}\n`);
+} catch (e: any) {
+  console.log(`❌ Error: ${e.message}\n`);
+}
+
+// TEST 2: TYPECLASS 복수 타입 파라미터
+console.log("=".repeat(60));
+console.log("TEST 2: TYPECLASS 복수 타입 파라미터");
+console.log("=".repeat(60));
+
+try {
+  const code2 = `
+[TYPECLASS Bifunctor
+  :typeParams [F]
+  :methods [
+    [:bimap (fn [$f $g $ab] (F))]
+  ]
+]
+`;
+
+  const ast = parseCode(code2);
+  const typeClass = ast[0] as TypeClass;
+
+  console.log(`Input: [TYPECLASS Bifunctor :typeParams [F] ...]`);
+  console.log(`Name: ${typeClass.name}`);
+  console.log(`TypeParams: [${typeClass.typeParams.join(", ")}]`);
+  console.log(`✅ ${typeClass.name === "Bifunctor" ? "PASS" : "FAIL"}\n`);
+} catch (e: any) {
+  console.log(`❌ Error: ${e.message}\n`);
+}
+
+// TEST 3: INSTANCE 기본 파싱
+console.log("=".repeat(60));
+console.log("TEST 3: INSTANCE 기본 파싱");
+console.log("=".repeat(60));
+
+try {
+  const code3 = `
+[INSTANCE Result
+  :typeclass Monad
+  :pure (fn [$x] (ok $x))
+  :bind (fn [$m $f] $m)
+  :map (fn [$m $f] $m)
+]
+`;
+
+  const ast = parseCode(code3);
+  const instance = ast[0] as TypeClassInstance;
+
+  console.log(`Input: [INSTANCE Result :typeclass Monad :pure ... :bind ... :map ...]`);
+  console.log(`Kind: ${instance.kind}`);
+  console.log(`ClassName: ${instance.className}`);
+  console.log(`ConcreteType: ${instance.concreteType}`);
+  console.log(`Implementations: [${Array.from(instance.implementations.keys()).join(", ")}]`);
+  console.log(
+    `✅ ${
+      instance.kind === "type-class-instance" &&
+      instance.className === "Monad" &&
+      instance.concreteType === "Result"
+        ? "PASS"
+        : "FAIL"
+    }\n`
+  );
+} catch (e: any) {
+  console.log(`❌ Error: ${e.message}\n`);
+}
+
+// TEST 4: INSTANCE for Option
+console.log("=".repeat(60));
+console.log("TEST 4: INSTANCE for Option");
+console.log("=".repeat(60));
+
+try {
+  const code4 = `
+[INSTANCE Option
+  :typeclass Functor
+  :fmap (fn [$opt $f] $opt)
+]
+`;
+
+  const ast = parseCode(code4);
+  const instance = ast[0] as TypeClassInstance;
+
+  console.log(`Input: [INSTANCE Option :typeclass Functor :fmap ...]`);
+  console.log(`ClassName: ${instance.className}`);
+  console.log(`ConcreteType: ${instance.concreteType}`);
+  console.log(`Methods: [${Array.from(instance.implementations.keys()).join(", ")}]`);
+  console.log(`✅ ${instance.className === "Functor" && instance.concreteType === "Option" ? "PASS" : "FAIL"}\n`);
+} catch (e: any) {
+  console.log(`❌ Error: ${e.message}\n`);
+}
+
+// TEST 5: TYPECLASS Functor
+console.log("=".repeat(60));
+console.log("TEST 5: TYPECLASS Functor");
+console.log("=".repeat(60));
+
+try {
+  const code5 = `
+[TYPECLASS Functor
+  :typeParams [F]
+  :methods [
+    [:fmap (fn [$f $a] (F))]
+  ]
+]
+`;
+
+  const ast = parseCode(code5);
+  const typeClass = ast[0] as TypeClass;
+
+  console.log(`Input: [TYPECLASS Functor :typeParams [F] :methods [...]]`);
+  console.log(`Name: ${typeClass.name}`);
+  console.log(`Methods: [${Array.from(typeClass.methods.keys()).join(", ")}]`);
+
+  // Check method structure
+  const fmapMethod = typeClass.methods.get("fmap");
+  console.log(`Method 'fmap' exists: ${fmapMethod ? "yes" : "no"}`);
+  console.log(
+    `✅ ${typeClass.name === "Functor" && typeClass.methods.has("fmap") ? "PASS" : "FAIL"}\n`
+  );
+} catch (e: any) {
+  console.log(`❌ Error: ${e.message}\n`);
+}
+
+// TEST 6: 여러 TYPECLASS 연속 정의
+console.log("=".repeat(60));
+console.log("TEST 6: 여러 TYPECLASS 연속 정의");
+console.log("=".repeat(60));
+
+try {
+  const code6 = `
+[TYPECLASS Functor
+  :typeParams [F]
+  :methods [[:fmap (fn [$f] (F))]]
+]
+[TYPECLASS Monad
+  :typeParams [M]
+  :methods [
+    [:pure (fn [$a] (M))]
+    [:bind (fn [$m $f] (M))]
+  ]
+]
+`;
+
+  const ast = parseCode(code6);
+
+  console.log(`Input: 2 TYPECLASS definitions`);
+  console.log(`AST count: ${ast.length}`);
+  console.log(`First TypeClass: ${ast[0].kind === "type-class" ? ast[0].name : "NOT A TYPECLASS"}`);
+  console.log(`Second TypeClass: ${ast[1].kind === "type-class" ? ast[1].name : "NOT A TYPECLASS"}`);
+  console.log(
+    `✅ ${
+      ast.length === 2 &&
+      (ast[0] as TypeClass).name === "Functor" &&
+      (ast[1] as TypeClass).name === "Monad"
+        ? "PASS"
+        : "FAIL"
+    }\n`
+  );
+} catch (e: any) {
+  console.log(`❌ Error: ${e.message}\n`);
+}
+
+// TEST 7: Mixed TYPECLASS and INSTANCE
+console.log("=".repeat(60));
+console.log("TEST 7: Mixed TYPECLASS and INSTANCE");
+console.log("=".repeat(60));
+
+try {
+  const code7 = `
+[TYPECLASS Monad
+  :typeParams [M]
+]
+[INSTANCE Option
+  :typeclass Monad
+  :pure (fn [$x] (some $x))
+  :bind (fn [$m $f] $m)
+]
+`;
+
+  const ast = parseCode(code7);
+
+  console.log(`Input: 1 TYPECLASS + 1 INSTANCE`);
+  console.log(`AST count: ${ast.length}`);
+
+  const typeClass = ast[0] as TypeClass;
+  const instance = ast[1] as TypeClassInstance;
+
+  console.log(`First: ${typeClass.kind} (${typeClass.name})`);
+  console.log(`Second: ${instance.kind} (${instance.className} ${instance.concreteType})`);
+  console.log(
+    `✅ ${
+      typeClass.kind === "type-class" &&
+      instance.kind === "type-class-instance" &&
+      typeClass.name === "Monad"
+        ? "PASS"
+        : "FAIL"
+    }\n`
+  );
+} catch (e: any) {
+  console.log(`❌ Error: ${e.message}\n`);
+}
+
+// SUMMARY
+console.log("=".repeat(60));
+console.log("📋 PHASE 5 WEEK 2 DAY 1: PARSING SUMMARY");
+console.log("=".repeat(60));
+console.log("\n✅ Features Tested:");
+console.log("   1. TYPECLASS block parsing");
+console.log("   2. Type parameter extraction");
+console.log("   3. Method signature extraction");
+console.log("   4. INSTANCE block parsing");
+console.log("   5. Class name and concrete type extraction");
+console.log("   6. Method implementation extraction");
+console.log("   7. Mixed TYPECLASS + INSTANCE definitions\n");
+
+console.log("📝 Parsing Strategy:");
+console.log("   • parseBlock() 반환 타입 확장 (TypeClass, TypeClassInstance 추가)");
+console.log("   • convertBlockToTypeClass() 메서드 구현");
+console.log("   • convertBlockToInstance() 메서드 구현");
+console.log("   • :typeParams, :methods 필드 추출\n");
+
+console.log("✅ Phase 5 Week 2 Day 1 Parsing Complete!\n");

package/src/todo-server-30116.ts

@@ -0,0 +1,53 @@
+// Phase 55: 인메모리 TODO 서버 — 포트 30116
+// test-phase55-http-client.ts가 별도 프로세스로 실행
+
+import * as http from "http";
+
+interface Todo { id: number; title: string; done: boolean; }
+let todos: Todo[] = [];
+let nextId = 1;
+
+function readBody(req: http.IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    req.on("data", (c) => (data += c));
+    req.on("end", () => resolve(data));
+    req.on("error", reject);
+  });
+}
+
+const server = http.createServer(async (req, res) => {
+  const url = req.url ?? "/";
+  const method = req.method ?? "GET";
+  res.setHeader("Content-Type", "application/json");
+
+  if (method === "GET" && url === "/todos") {
+    res.writeHead(200);
+    res.end(JSON.stringify(todos));
+  } else if (method === "POST" && url === "/todos") {
+    const body = await readBody(req);
+    let title = "untitled";
+    try { title = JSON.parse(body).title ?? "untitled"; } catch {}
+    const todo: Todo = { id: nextId++, title, done: false };
+    todos.push(todo);
+    res.writeHead(201);
+    res.end(JSON.stringify(todo));
+  } else if (method === "DELETE" && url.startsWith("/todos/")) {
+    const id = parseInt(url.split("/").pop() ?? "0", 10);
+    todos = todos.filter((t) => t.id !== id);
+    res.writeHead(200);
+    res.end(JSON.stringify({ ok: true }));
+  } else if (method === "POST" && url === "/_reset") {
+    todos = [];
+    nextId = 1;
+    res.writeHead(200);
+    res.end(JSON.stringify({ ok: true }));
+  } else {
+    res.writeHead(404);
+    res.end(JSON.stringify({ error: "not found" }));
+  }
+});
+
+server.listen(30116, "127.0.0.1", () => {
+  process.stdout.write("READY\n");
+});

package/src/token.ts

@@ -0,0 +1,130 @@
+// FreeLang v9: Token types
+
+export enum TokenType {
+  // Literals
+  Number = "Number",
+  String = "String",
+  Symbol = "Symbol",
+  Keyword = "Keyword",
+  Variable = "Variable", // $varname
+
+  // Delimiters
+  LBracket = "LBracket",   // [
+  RBracket = "RBracket",   // ]
+  LParen = "LParen",       // (
+  RParen = "RParen",       // )
+  LBrace = "LBrace",       // {
+  RBrace = "RBrace",       // }
+
+  // Phase 6 Keywords
+  Module = "Module",       // MODULE
+  TypeClass = "TypeClass", // TYPECLASS
+  Instance = "Instance",   // INSTANCE
+  Import = "Import",       // import
+  Open = "Open",           // open
+
+  // Phase 9a Keywords (Search)
+  Search = "Search",       // search
+  Fetch = "Fetch",         // fetch
+  Browse = "Browse",       // browse
+  Cache = "Cache",         // cache
+
+  // Phase 9b Keywords (Learning)
+  Learn = "Learn",         // learn
+  Recall = "Recall",       // recall
+  Remember = "Remember",   // remember
+  Forget = "Forget",       // forget
+
+  // Phase 9c Keywords (Reasoning)
+  Observe = "Observe",     // observe
+  Analyze = "Analyze",     // analyze
+  Decide = "Decide",       // decide
+  Act = "Act",             // act
+  Verify = "Verify",       // verify
+
+  // Phase 9c Keywords (Conditional)
+  If = "If",               // if
+  When = "When",           // when
+  Then = "Then",           // then
+  Else = "Else",           // else
+
+  // Phase 9c Keywords (Loop Control)
+  Repeat = "Repeat",       // repeat
+  Until = "Until",         // until
+  While = "While",         // while
+
+  // Phase 11 Keywords (Web DSL)
+  Page = "Page",           // PAGE
+  Api = "Api",             // API
+  Route = "Route",         // ROUTE
+  Component = "Component", // COMPONENT
+  Form = "Form",           // FORM
+  State = "State",         // STATE
+  Computed = "Computed",   // COMPUTED
+  Watch = "Watch",         // WATCH
+  Method = "Method",       // METHOD
+  Render = "Render",       // RENDER
+  Handler = "Handler",     // HANDLER
+  Validation = "Validation", // VALIDATION
+  Layout = "Layout",       // LAYOUT
+  Middleware = "Middleware", // MIDDLEWARE
+  Suspense = "Suspense",   // SUSPENSE
+  Slot = "Slot",           // SLOT
+  Metadata = "Metadata",   // METADATA
+
+  // Phase 11 Keywords (Enterprise Backend)
+  Service = "Service",     // SERVICE
+  Controller = "Controller", // CONTROLLER
+  Guard = "Guard",         // GUARD
+  Pipe = "Pipe",           // PIPE
+
+  // Phase 11 Keywords (Database ORM)
+  Model = "Model",         // MODEL
+  Query = "Query",         // QUERY
+  Migration = "Migration", // MIGRATION
+  Repository = "Repository", // REPOSITORY
+  Database = "Database",   // DATABASE
+
+  // Phase 11 Keywords (Cache & Messaging)
+  Cached = "Cached",       // CACHED
+  Kafka = "Kafka",         // KAFKA
+  Producer = "Producer",   // PRODUCER
+  Consumer = "Consumer",   // CONSUMER
+  Queue = "Queue",         // QUEUE
+  RabbitMQ = "RabbitMQ",   // RABBITMQ
+
+  // Phase 11 Keywords (Authentication)
+  JWT = "JWT",             // JWT
+  OAuth = "OAuth",         // OAUTH
+
+  // Phase 11 Keywords (Deployment)
+  Dockerfile = "Dockerfile",           // DOCKERFILE
+  DockerCompose = "DockerCompose",     // DOCKER-COMPOSE
+  K8sDeployment = "K8sDeployment",     // K8S-DEPLOYMENT
+  K8sService = "K8sService",           // K8S-SERVICE
+  K8sIngress = "K8sIngress",           // K8S-INGRESS
+
+  // Phase 11 Keywords (Cloud)
+  AWS = "AWS",                         // AWS
+  AwsS3 = "AwsS3",                     // AWS-S3
+  AwsLambda = "AwsLambda",             // AWS-LAMBDA
+  AwsRds = "AwsRds",                   // AWS-RDS
+  AwsSqs = "AwsSqs",                   // AWS-SQS
+  GCP = "GCP",                         // GCP
+  GcpCloudRun = "GcpCloudRun",         // GCP-CLOUD-RUN
+  GcpBigquery = "GcpBigquery",         // GCP-BIGQUERY
+  Azure = "Azure",                     // AZURE
+  AzureFunction = "AzureFunction",     // AZURE-FUNCTION
+  AzureCosmos = "AzureCosmos",         // AZURE-COSMOS
+
+  // Special
+  Colon = "Colon",         // :
+  EOF = "EOF",
+}
+
+export interface Token {
+  type: TokenType;
+  value: string;
+  line: number;
+  col: number;
+}

package/src/tool-registry.ts

@@ -0,0 +1,195 @@
+// FreeLang v9: Phase 97 — Tool Registry
+// AI 도구 사용 DSL: USE-TOOL, TOOL 블록, use-tool, list-tools
+
+export interface ToolDefinition {
+  name: string;
+  description: string;
+  inputSchema: Record<string, 'string' | 'number' | 'boolean' | 'array' | 'any'>;
+  outputSchema?: 'string' | 'number' | 'boolean' | 'array' | 'object' | 'any';
+  execute: (args: Record<string, any>) => Promise<any> | any;
+  timeout?: number; // ms, 기본 5000
+}
+
+export interface ToolResult {
+  tool: string;
+  input: Record<string, any>;
+  output: any;
+  durationMs: number;
+  success: boolean;
+  error?: string;
+}
+
+export class ToolRegistry {
+  private tools: Map<string, ToolDefinition> = new Map();
+
+  /** 도구 등록 (chainable) */
+  register(tool: ToolDefinition): this {
+    this.tools.set(tool.name, tool);
+    return this;
+  }
+
+  /** 도구 조회 */
+  get(name: string): ToolDefinition | undefined {
+    return this.tools.get(name);
+  }
+
+  /** 모든 도구 목록 */
+  listAll(): ToolDefinition[] {
+    return Array.from(this.tools.values());
+  }
+
+  /** 비동기 도구 실행 */
+  async execute(name: string, args: Record<string, any>): Promise<ToolResult> {
+    const start = Date.now();
+    const tool = this.tools.get(name);
+
+    if (!tool) {
+      return {
+        tool: name,
+        input: args,
+        output: null,
+        durationMs: Date.now() - start,
+        success: false,
+        error: `Tool not found: ${name}`,
+      };
+    }
+
+    const timeout = tool.timeout ?? 5000;
+
+    try {
+      const resultPromise = Promise.resolve(tool.execute(args));
+      const timeoutPromise = new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error(`Tool timeout: ${name} (${timeout}ms)`)), timeout)
+      );
+      const output = await Promise.race([resultPromise, timeoutPromise]);
+      return {
+        tool: name,
+        input: args,
+        output,
+        durationMs: Date.now() - start,
+        success: true,
+      };
+    } catch (e: any) {
+      return {
+        tool: name,
+        input: args,
+        output: null,
+        durationMs: Date.now() - start,
+        success: false,
+        error: String(e?.message ?? e),
+      };
+    }
+  }
+
+  /** 동기 도구 실행 (비동기 도구는 await 없이 실행) */
+  executeSync(name: string, args: Record<string, any>): ToolResult {
+    const start = Date.now();
+    const tool = this.tools.get(name);
+
+    if (!tool) {
+      return {
+        tool: name,
+        input: args,
+        output: null,
+        durationMs: Date.now() - start,
+        success: false,
+        error: `Tool not found: ${name}`,
+      };
+    }
+
+    try {
+      const output = tool.execute(args);
+      // Promise인 경우 그대로 반환 (동기 결과로 처리)
+      return {
+        tool: name,
+        input: args,
+        output,
+        durationMs: Date.now() - start,
+        success: true,
+      };
+    } catch (e: any) {
+      return {
+        tool: name,
+        input: args,
+        output: null,
+        durationMs: Date.now() - start,
+        success: false,
+        error: String(e?.message ?? e),
+      };
+    }
+  }
+}
+
+// ── 기본 내장 도구 등록 ──────────────────────────────────────────────────────
+
+function makeSafeMathEval(expr: string): number {
+  // 안전한 수학 표현식만 허용 (숫자, 연산자, 괄호, 공백, 소수점)
+  const safe = expr.replace(/[^0-9+\-*/.() ]/g, '');
+  // eslint-disable-next-line no-new-func
+  return Function(`"use strict"; return (${safe})`)() as number;
+}
+
+export const globalToolRegistry = new ToolRegistry();
+
+// math — 수학 계산
+globalToolRegistry.register({
+  name: 'math',
+  description: '수학 표현식을 계산합니다. 예: {expr: "2 + 3 * 4"}',
+  inputSchema: { expr: 'string' },
+  outputSchema: 'number',
+  execute: ({ expr }) => makeSafeMathEval(String(expr)),
+});
+
+// str-upper — 대문자 변환
+globalToolRegistry.register({
+  name: 'str-upper',
+  description: '문자열을 대문자로 변환합니다.',
+  inputSchema: { s: 'string' },
+  outputSchema: 'string',
+  execute: ({ s }) => String(s).toUpperCase(),
+});
+
+// str-lower — 소문자 변환
+globalToolRegistry.register({
+  name: 'str-lower',
+  description: '문자열을 소문자로 변환합니다.',
+  inputSchema: { s: 'string' },
+  outputSchema: 'string',
+  execute: ({ s }) => String(s).toLowerCase(),
+});
+
+// str-len — 문자열 길이
+globalToolRegistry.register({
+  name: 'str-len',
+  description: '문자열 길이를 반환합니다.',
+  inputSchema: { s: 'string' },
+  outputSchema: 'number',
+  execute: ({ s }) => String(s).length,
+});
+
+// json-parse — JSON 파싱
+globalToolRegistry.register({
+  name: 'json-parse',
+  description: 'JSON 문자열을 객체로 파싱합니다.',
+  inputSchema: { s: 'string' },
+  outputSchema: 'any',
+  execute: ({ s }) => JSON.parse(String(s)),
+});
+
+// json-stringify — JSON 직렬화
+globalToolRegistry.register({
+  name: 'json-stringify',
+  description: '값을 JSON 문자열로 변환합니다.',
+  inputSchema: { v: 'any' },
+  outputSchema: 'string',
+  execute: ({ v }) => JSON.stringify(v),
+});
+
+// type-of — 타입 확인
+globalToolRegistry.register({
+  name: 'type-of',
+  description: '값의 타입을 반환합니다.',
+  inputSchema: { v: 'any' },
+  outputSchema: 'string',
+  execute: ({ v }) => typeof v,
+});