freelang-v4 4.3.0

package/src/main.ts

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+// FreeLang v4 — CLI Entry Point
+
+import * as fs from "fs";
+import { Lexer } from "./lexer";
+import { Parser } from "./parser";
+import { TypeChecker } from "./checker";
+import { Compiler } from "./compiler";
+import { VM } from "./vm";
+import { IRGen } from "./ir-gen";
+import { REPL } from "./repl";
+import { SQLiteDB, MigrationManager } from "./db";
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  // 버전 확인
+  if (args[0] === "--version" || args[0] === "-v") {
+    console.log("FreeLang 4.1.0");
+    process.exit(0);
+  }
+
+  // REPL 모드
+  if (args[0] === "--repl" || args[0] === "-i") {
+    const repl = new REPL();
+    await repl.start();
+    return;
+  }
+
+  // 마이그레이션 CLI
+  if (args[0] === "migrate") {
+    const cmd = args[1];
+    const dbPath = args[2] || "./app.db";
+    const migrationsDir = args[3] || "./migrations";
+
+    const db = new SQLiteDB(dbPath);
+    const manager = new MigrationManager(db, migrationsDir);
+
+    try {
+      if (cmd === "up") {
+        await db.init();
+        await manager.up();
+        await db.close();
+      } else if (cmd === "down") {
+        await db.init();
+        await manager.down();
+        await db.close();
+      } else if (cmd === "status") {
+        await db.init();
+        const rows = await manager.status();
+        if (rows.length === 0) {
+          console.log("적용된 마이그레이션이 없습니다.");
+        } else {
+          console.log("적용된 마이그레이션:");
+          for (const row of rows) {
+            console.log(`  - ${row.name} (${row.applied_at})`);
+          }
+        }
+        await db.close();
+      } else {
+        console.error(`unknown migrate command: ${cmd}`);
+        console.log("Usage:");
+        console.log("  freelang migrate up [db_path] [migrations_dir]");
+        console.log("  freelang migrate down [db_path] [migrations_dir]");
+        console.log("  freelang migrate status [db_path] [migrations_dir]");
+        process.exit(1);
+      }
+    } catch (e: any) {
+      console.error(`migrate error: ${e.message}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  // 패키지 매니저 CLI
+  if (args[0] === "init") {
+    const { initProject } = await import("./pkg/init");
+    await initProject(args[1] || "my-app");
+    return;
+  }
+
+  if (args[0] === "install") {
+    const { installPackage } = await import("./pkg/install");
+    await installPackage(args[1], process.cwd());
+    return;
+  }
+
+  if (args[0] === "run") {
+    const { runScript } = await import("./pkg/run");
+    await runScript(args[1], process.cwd());
+    return;
+  }
+
+  if (args[0] === "list-packages") {
+    const { listPackages } = await import("./pkg/registry");
+    listPackages();
+    return;
+  }
+
+  if (args[0] === "search-packages") {
+    const { searchPackages } = await import("./pkg/registry");
+    searchPackages(args[1] || "");
+    return;
+  }
+
+  // 웹 REPL
+  if (args[0] === "--web-repl") {
+    const portIdx = args.indexOf("--port");
+    const port = portIdx >= 0 ? parseInt(args[portIdx + 1]) : 3000;
+    const { startWebRepl } = await import("./web-repl/server");
+    await startWebRepl(port);
+    return;
+  }
+
+  // 도움말
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    console.log("🦁 FreeLang v4.3 — AI-First Programming Language");
+    console.log("");
+    console.log("Usage:");
+    console.log("  freelang <file.fl> [options]      파일 실행");
+    console.log("  freelang --repl                    대화형 쉘 시작");
+    console.log("  freelang --web-repl [--port PORT]  웹 REPL 시작");
+    console.log("");
+    console.log("Project Management:");
+    console.log("  freelang init [name]               새 프로젝트 생성");
+    console.log("  freelang install <pkg>             패키지 설치");
+    console.log("  freelang run <script>              freelang.toml 스크립트 실행");
+    console.log("  freelang list-packages             전체 패키지 목록");
+    console.log("  freelang search-packages <query>   패키지 검색");
+    console.log("");
+    console.log("Database:");
+    console.log("  freelang migrate <cmd> [args]      마이그레이션 관리");
+    console.log("");
+    console.log("Options:");
+    console.log("  --no-check   타입 체크 건너뛰기");
+    console.log("  --dump-bc    바이트코드 덤프");
+    console.log("  --dump-ir    IR(중간 표현) 덤프");
+    console.log("  --use-ir     IR 경로로 컴파일");
+    console.log("  --help, -h   도움말 표시");
+    console.log("  --version    버전 표시");
+    process.exit(0);
+  }
+
+  const file = args[0];
+  const noCheck = args.includes("--no-check");
+  const dumpBc = args.includes("--dump-bc");
+  const dumpIr = args.includes("--dump-ir");
+  const useIr = args.includes("--use-ir") || dumpIr;
+
+  // 파일 읽기
+  let source: string;
+  try {
+    source = fs.readFileSync(file, "utf-8");
+  } catch {
+    console.error(`error: cannot read file '${file}'`);
+    process.exit(1);
+  }
+
+  // 1. Lexer
+  const { tokens, errors: lexErrors } = new Lexer(source).tokenize();
+  if (lexErrors.length > 0) {
+    for (const e of lexErrors) {
+      console.error(`${file}:${e.line}: lex error: ${e.message}`);
+    }
+    process.exit(1);
+  }
+
+  // 2. Parser
+  const { program, errors: parseErrors } = new Parser(tokens).parse();
+  if (parseErrors.length > 0) {
+    for (const e of parseErrors) {
+      console.error(`${file}:${e.line}: parse error: ${e.message}`);
+    }
+    process.exit(1);
+  }
+
+  // 3. TypeChecker (optional)
+  if (!noCheck) {
+    const checkErrors = new TypeChecker().check(program);
+    if (checkErrors.length > 0) {
+      for (const e of checkErrors) {
+        console.error(`${file}:${e.line}: type error: ${e.message}`);
+      }
+      process.exit(1);
+    }
+  }
+
+  // 4. Compiler (IR 경로 vs 기존 경로)
+  let chunk;
+  if (useIr) {
+    const irProg = new IRGen().generate(program);  // AST → IR
+    if (dumpIr) {
+      console.log(JSON.stringify(irProg, null, 2));
+      process.exit(0);
+    }
+    chunk = new Compiler().compileIR(irProg);      // IR → Chunk
+  } else {
+    chunk = new Compiler().compile(program);       // 기존 경로 유지
+  }
+
+  if (dumpBc) {
+    console.log(`--- bytecode (${chunk.code.length} bytes, ${chunk.functions.length} functions) ---`);
+    console.log(`constants: ${JSON.stringify(chunk.constants)}`);
+    for (const fn of chunk.functions) {
+      console.log(`fn ${fn.name}(arity=${fn.arity}) @ offset ${fn.offset}`);
+    }
+    process.exit(0);
+  }
+
+  // 5. VM 실행
+  const { output, error } = await new VM().run(chunk);
+
+  for (const line of output) {
+    console.log(line);
+  }
+
+  if (error) {
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+main().catch(console.error);

package/src/models.fl

@@ -0,0 +1,162 @@
+// FreeLang v4.2 — gogs-cli API 응답 모델
+// Gogs API에서 반환하는 데이터 구조
+
+// ==================== Repo Model ====================
+
+struct Repo {
+    id: i32
+    owner: Owner
+    name: str
+    full_name: str
+    description: str
+    private: bool
+    fork: bool
+    html_url: str
+    ssh_url: str
+    clone_url: str
+    default_branch: str
+    created_at: str
+    updated_at: str
+}
+
+struct Owner {
+    id: i32
+    login: str
+    avatar_url: str
+}
+
+struct CreateRepoRequest {
+    name: str
+    description: str
+    private: bool
+}
+
+// ==================== User Model ====================
+
+struct User {
+    id: i32
+    login: str
+    full_name: str
+    email: str
+    is_admin: bool
+    avatar_url: str
+    created_at: str
+    updated_at: str
+}
+
+struct CreateUserRequest {
+    username: str
+    email: str
+    password: str
+    send_notify: bool
+    is_admin: bool
+}
+
+// ==================== Organization Model ====================
+
+struct Organization {
+    id: i32
+    username: str
+    full_name: str
+    email: str
+    website: str
+    location: str
+    bio: str
+    avatar_url: str
+    created_at: str
+    updated_at: str
+}
+
+struct CreateOrgRequest {
+    username: str
+    full_name: str
+    email: str
+    website: str
+    location: str
+    bio: str
+}
+
+// ==================== Team Model ====================
+
+struct Team {
+    id: i32
+    name: str
+    description: str
+    permission: str
+}
+
+struct CreateTeamRequest {
+    name: str
+    description: str
+    permission: str
+}
+
+// ==================== Issue Model ====================
+
+struct Issue {
+    id: i32
+    number: i32
+    title: str
+    description: str
+    state: str  // "open", "closed"
+    user: User
+    created_at: str
+    updated_at: str
+}
+
+struct CreateIssueRequest {
+    title: str
+    body: str
+}
+
+// ==================== Webhook Model ====================
+
+struct Webhook {
+    id: i32
+    url: str
+    content_type: str
+    events: [str]
+    active: bool
+    created_at: str
+    updated_at: str
+}
+
+struct CreateWebhookRequest {
+    url: str
+    content_type: str
+    events: [str]
+    active: bool
+}
+
+// ==================== Deploy Key Model ====================
+
+struct DeployKey {
+    id: i32
+    key_id: i32
+    title: str
+    key: str
+    url: str
+    read_only: bool
+    created_at: str
+}
+
+struct CreateDeployKeyRequest {
+    title: str
+    key: str
+    read_only: bool
+}
+
+// ==================== Analysis Model ====================
+
+struct RepositoryStats {
+    total: i32
+    public: i32
+    private: i32
+    recently_updated_7days: i32
+    by_updated: [Repo]
+}
+
+struct AnalysisResult {
+    timestamp: str
+    repository_stats: RepositoryStats
+}

package/src/module-jest.test.ts

@@ -0,0 +1,145 @@
+// FreeLang v4 Module System Tests
+// 기본 import/export 파싱 및 검증 테스트
+
+import { Lexer } from "./lexer";
+import { Parser } from "./parser";
+import { TypeChecker } from "./checker";
+import { Program, Stmt, ImportDecl, ExportDecl } from "./ast";
+
+describe("Module System", () => {
+  // 헬퍼: 코드를 AST로 파싱
+  function parseCode(code: string): Program {
+    const lexer = new Lexer(code);
+    const { tokens, errors: lexErrors } = lexer.tokenize();
+    if (lexErrors.length > 0) {
+      throw new Error(`Lex errors: ${lexErrors.map(e => e.message).join(", ")}`);
+    }
+
+    const parser = new Parser(tokens);
+    const { program, errors: parseErrors } = parser.parse();
+    if (parseErrors.length > 0) {
+      throw new Error(`Parse errors: ${parseErrors.map(e => e.message).join(", ")}`);
+    }
+
+    return program;
+  }
+
+  // Test 1: 기본 import 파싱
+  it("should parse basic import statement", () => {
+    const code = `import { add } from "./math";`;
+    const program = parseCode(code);
+
+    expect(program.stmts.length).toBe(1);
+    const stmt = program.stmts[0] as ImportDecl;
+    expect(stmt.kind).toBe("import_decl");
+    expect(stmt.source).toBe("./math");
+    expect(stmt.items.length).toBe(1);
+    expect(stmt.items[0].name).toBe("add");
+    expect(stmt.items[0].alias).toBeUndefined();
+  });
+
+  // Test 2: 다중 항목 import
+  it("should parse multiple import items", () => {
+    const code = `import { add, subtract, multiply } from "./math";`;
+    const program = parseCode(code);
+
+    const stmt = program.stmts[0] as ImportDecl;
+    expect(stmt.items.length).toBe(3);
+    expect(stmt.items[0].name).toBe("add");
+    expect(stmt.items[1].name).toBe("subtract");
+    expect(stmt.items[2].name).toBe("multiply");
+  });
+
+  // Test 3: Import alias
+  it("should parse import with alias", () => {
+    const code = `import { add as sum } from "./math";`;
+    const program = parseCode(code);
+
+    const stmt = program.stmts[0] as ImportDecl;
+    expect(stmt.items[0].name).toBe("add");
+    expect(stmt.items[0].alias).toBe("sum");
+  });
+
+  // Test 4: Default import
+  it("should parse default import", () => {
+    const code = `import math from "./math";`;
+    const program = parseCode(code);
+
+    const stmt = program.stmts[0] as ImportDecl;
+    expect(stmt.default).toBe(true);
+    expect(stmt.items[0].name).toBe("math");
+  });
+
+  // Test 5: Export with function
+  it("should parse export function", () => {
+    const code = `export fn add(a: i32, b: i32) -> i32 { a + b }`;
+    const program = parseCode(code);
+
+    const stmt = program.stmts[0] as ExportDecl;
+    expect(stmt.kind).toBe("export_decl");
+    expect(typeof stmt.target).not.toBe("string");
+  });
+
+  // Test 6: Export with struct
+  it("should parse export struct", () => {
+    const code = `export struct Point { x: i32, y: i32 }`;
+    const program = parseCode(code);
+
+    const stmt = program.stmts[0] as ExportDecl;
+    expect(stmt.kind).toBe("export_decl");
+  });
+
+  // Test 7: Export list
+  it("should parse export list", () => {
+    const code = `export { add, multiply, PI };`;
+    const program = parseCode(code);
+
+    const stmt = program.stmts[0] as ExportDecl;
+    expect(typeof stmt.target).toBe("object");
+    const names = stmt.target as string[];
+    expect(names.length).toBe(3);
+    expect(names[0]).toBe("add");
+    expect(names[1]).toBe("multiply");
+    expect(names[2]).toBe("PI");
+  });
+
+  // Test 8: Type checking with imports
+  it("should check imported names in scope", () => {
+    const code = `
+      import { add } from "./math";
+      var result: i32 = add(2, 3);
+    `;
+    const program = parseCode(code);
+    const checker = new TypeChecker();
+    const errors = checker.check(program);
+
+    // import 문이 성공적으로 처리되어야 함
+    expect(errors.length).toBeLessThan(3); // 약간의 에러는 있을 수 있음 (모듈 미로드)
+  });
+
+  // Test 9: Multiple imports
+  it("should parse multiple import statements", () => {
+    const code = `
+      import { add } from "./math";
+      import { map, filter } from "./array";
+      fn main() -> void { }
+    `;
+    const program = parseCode(code);
+
+    expect(program.stmts[0].kind).toBe("import_decl");
+    expect(program.stmts[1].kind).toBe("import_decl");
+    expect(program.stmts[2].kind).toBe("fn_decl");
+  });
+
+  // Test 10: Import and Export together
+  it("should parse import and export together", () => {
+    const code = `
+      import { double } from "./utils";
+      export fn quad(x: i32) -> i32 { double(double(x)) }
+    `;
+    const program = parseCode(code);
+
+    expect(program.stmts[0].kind).toBe("import_decl");
+    expect(program.stmts[1].kind).toBe("export_decl");
+  });
+});