fenrir-runtime 0.2.0 → 0.3.0

package/README.md

@@ -0,0 +1,155 @@
+<div align="center">
+
+# Fenrir
+
+**A Lightweight Runtime**
+
+[![npm](https://img.shields.io/npm/v/fenrir-runtime?style=flat-square&color=000&labelColor=000)](https://www.npmjs.com/package/fenrir-runtime)
+
+<br/>
+
+🌐 &nbsp;[Türkçe](/READMEs/turkish.md)
+
+</div>
+
+---
+
+<br/>
+
+Fenrir is a minimal scripting runtime that runs `.fnr` files using a clean, expressive syntax on top of Node.js. It ships with a built-in standard library, package management, and a snapshot/rollback archive system.
+
+<br/>
+
+## Features
+
+```
+  Clean syntax      fn, use, log — no verbose JS boilerplate
+  Built-in stdlib   File I/O, HTTP, math, arrays — globally available, no imports
+  Package manager   Install and remove npm packages via fenrir install
+  Archive system    Snapshot your project and roll back at any time
+```
+
+<br/>
+
+## Installation
+
+**Via npm**
+
+```bash
+npm install -g fenrir-runtime
+```
+
+**Via GitHub**
+
+```bash
+git clone https://github.com/yourusername/fenrir.git
+cd fenrir
+npm install
+npm link
+```
+
+<br/>
+
+## Usage
+
+```bash
+fenrir main.fnr              # Run a file
+fenrir install <pkg>         # Install a package
+fenrir remove  <pkg>         # Remove a package
+fenrir archive "message"     # Save a snapshot
+fenrir archives              # List snapshots
+fenrir rollback              # Restore latest snapshot
+fenrir rollback <id>         # Restore specific snapshot
+fenrir clean   <n>           # Keep last n snapshots
+fenrir help                  # Show help
+```
+
+<br/>
+
+## Syntax
+
+`.fnr` files are mostly JavaScript with a cleaner surface:
+
+```js
+use express from 'express'
+
+const app = express()
+const PORT = env('PORT', '3000')
+
+fn greet(name) {
+  log(`Hello, ${name}!`)
+}
+
+app.get('/', fn(req, res) {
+  res.json({ message: 'Hello from Fenrir' })
+})
+
+app.listen(PORT, fn() {
+  log(`🐺 Server running on http://localhost:${PORT}`)
+})
+```
+
+| Fenrir | JavaScript |
+|--------|------------|
+| `fn name() {}` | `function name() {}` |
+| `fn(args) {}` | `function(args) {}` |
+| `use X from 'mod'` | `import X from 'mod'` |
+| `log()` | `console.log()` |
+| `err()` | `console.error()` |
+| `warn()` | `console.warn()` |
+| `info()` | `console.info()` |
+
+<br/>
+
+## Standard Library
+
+All functions are globally available — no imports needed.
+
+| Category | Functions |
+|----------|-----------|
+| **I/O** | `readFile` `writeFile` `appendFile` `fileExists` `readDir` `readJSON` `writeJSON` `mkdir` `rm` |
+| **HTTP** | `get` `post` |
+| **System** | `exec` `run` `spawn` `env` `args` `exit` `cwd` |
+| **Time** | `now` `time` `sleep` `bench` |
+| **Array** | `range` `pick` `shuffle` `chunk` `unique` `flatten` `sum` `avg` `min` `max` `clamp` |
+| **String** | `capitalize` `truncate` `pad` `repeat` |
+| **Object** | `keys` `values` `entries` `merge` `clone` |
+| **Async** | `all` `race` `retry` |
+| **Types** | `isString` `isNumber` `isBool` `isArray` `isObject` `isNull` `isDefined` |
+| **Math** | `rand` `randInt` `abs` `ceil` `floor` `round` `sqrt` `pow` `PI` `E` |
+
+<br/>
+
+## Archive System
+
+```bash
+fenrir archive "before refactor"       # Save snapshot
+fenrir archives                        # List all snapshots
+fenrir rollback                        # Restore latest
+fenrir rollback 2024-01-15_14-30-00    # Restore specific
+fenrir clean 10                        # Keep last 10, delete rest
+```
+
+<br/>
+
+## Debug Mode
+
+```bash
+FENRIR_DEBUG=1 fenrir main.fnr
+```
+
+Prints the transformed JavaScript before execution.
+
+<br/>
+
+## Requirements
+
+- Node.js **v18** or higher
+
+<br/>
+
+---
+
+<div align="center">
+<sub>BSD-3-Clause License</sub>
+</div>

package/READMEs/turkish.md

@@ -0,0 +1,156 @@
+<div align="center">
+
+# Fenrir
+
+**Hafif bir Runtime**
+
+[![npm](https://img.shields.io/npm/v/fenrir-runtime?style=flat-square&color=000&labelColor=000)](https://www.npmjs.com/package/fenrir-runtime)
+
+
+<br/>
+
+🌐 &nbsp;[English](README.md)
+
+</div>
+
+---
+
+<br/>
+
+Fenrir, `.fnr` uzantılı dosyaları Node.js üzerinde temiz ve ifade edici bir söz dizimiyle çalıştıran minimal bir scripting runtime'ıdır. Dahili standart kütüphane, paket yönetimi ve anlık görüntü/geri alma arşiv sistemiyle birlikte gelir.
+
+<br/>
+
+## Özellikler
+
+```
+  Temiz söz dizimi   fn, use, log — uzun JS kalıpları yok
+  Dahili stdlib      Dosya I/O, HTTP, matematik — import olmadan global erişim
+  Paket yönetimi     fenrir install ile npm paket kur/kaldır
+  Arşiv sistemi      Anlık görüntü al, istediğin zaman geri dön
+```
+
+<br/>
+
+## Kurulum
+
+**npm ile**
+
+```bash
+npm install -g fenrir-runtime
+```
+
+**GitHub'dan**
+
+```bash
+git clone https://github.com/yourusername/fenrir.git
+cd fenrir
+npm install
+npm link
+```
+
+<br/>
+
+## Kullanım
+
+```bash
+fenrir main.fnr              # Dosya çalıştır
+fenrir install <paket>       # Paket kur
+fenrir remove  <paket>       # Paket kaldır
+fenrir archive "mesaj"       # Anlık görüntü kaydet
+fenrir archives              # Görüntüleri listele
+fenrir rollback              # Son görüntüye geri dön
+fenrir rollback <id>         # Belirli görüntüye geri dön
+fenrir clean   <n>           # Son n görüntüyü tut, kalanı sil
+fenrir help                  # Yardım göster
+```
+
+<br/>
+
+## Söz Dizimi
+
+`.fnr` dosyaları büyük ölçüde JavaScript'tir, birkaç daha temiz alternatifle:
+
+```js
+use express from 'express'
+
+const app = express()
+const PORT = env('PORT', '3000')
+
+fn selamla(isim) {
+  log(`Merhaba, ${isim}!`)
+}
+
+app.get('/', fn(req, res) {
+  res.json({ mesaj: 'Fenrir ile merhaba' })
+})
+
+app.listen(PORT, fn() {
+  log(`🐺 Sunucu http://localhost:${PORT} adresinde çalışıyor`)
+})
+```
+
+| Fenrir | JavaScript |
+|--------|------------|
+| `fn isim() {}` | `function isim() {}` |
+| `fn(args) {}` | `function(args) {}` |
+| `use X from 'mod'` | `import X from 'mod'` |
+| `log()` | `console.log()` |
+| `err()` | `console.error()` |
+| `warn()` | `console.warn()` |
+| `info()` | `console.info()` |
+
+<br/>
+
+## Standart Kütüphane
+
+Tüm fonksiyonlar global olarak kullanılabilir — import gerekmez.
+
+| Kategori | Fonksiyonlar |
+|----------|--------------|
+| **I/O** | `readFile` `writeFile` `appendFile` `fileExists` `readDir` `readJSON` `writeJSON` `mkdir` `rm` |
+| **HTTP** | `get` `post` |
+| **Sistem** | `exec` `run` `spawn` `env` `args` `exit` `cwd` |
+| **Zaman** | `now` `time` `sleep` `bench` |
+| **Dizi** | `range` `pick` `shuffle` `chunk` `unique` `flatten` `sum` `avg` `min` `max` `clamp` |
+| **String** | `capitalize` `truncate` `pad` `repeat` |
+| **Nesne** | `keys` `values` `entries` `merge` `clone` |
+| **Async** | `all` `race` `retry` |
+| **Tip** | `isString` `isNumber` `isBool` `isArray` `isObject` `isNull` `isDefined` |
+| **Math** | `rand` `randInt` `abs` `ceil` `floor` `round` `sqrt` `pow` `PI` `E` |
+
+<br/>
+
+## Arşiv Sistemi
+
+```bash
+fenrir archive "refactor öncesi"       # Anlık görüntü kaydet
+fenrir archives                        # Tüm görüntüleri listele
+fenrir rollback                        # En son görüntüye geri dön
+fenrir rollback 2024-01-15_14-30-00    # Belirli görüntüye geri dön
+fenrir clean 10                        # Son 10'u tut, kalanı sil
+```
+
+<br/>
+
+## Debug Modu
+
+```bash
+FENRIR_DEBUG=1 fenrir main.fnr
+```
+
+Çalıştırmadan önce dönüştürülmüş JavaScript kodunu ekrana basar.
+
+<br/>
+
+## Gereksinimler
+
+- Node.js **v18** veya üzeri
+
+<br/>
+
+---
+
+<div align="center">
+<sub>BSD-3-Clause License</sub>
+</div>

package/example/main.fnr

@@ -1,67 +1,103 @@
-use express from 'express'
+const PORT = 3000
 
-const app = express()
-const PORT = env('PORT', '3000')
+const routes = {}
 
-app.use(express.json())
+fn route(method, path, handler) {
+  routes[`${method}:${path}`] = handler
+}
 
-const users = [
-  { id: 1, name: 'Alice', role: 'admin' },
-  { id: 2, name: 'Bob',   role: 'user'  },
-]
+fn notFound() {
+  return response({ error: "Not found" }, 404)
+}
 
-fn logger(req, res, next) {
-  log(`[${time()}] ${req.method} ${req.url}`)
-  next()
+fn methodNotAllowed() {
+  return response({ error: "Method not allowed" }, 405)
 }
 
-fn notFound(req, res) {
-  res.status(404).json({ error: 'not found' })
+const db = {
+  users: [
+    { id: 1, name: "Alice", email: "alice@example.com" },
+    { id: 2, name: "Bob",   email: "bob@example.com" },
+  ],
+  nextId: 3
 }
 
-app.use(logger)
+route("GET", "/", req => ({
+  body: {
+    name: "Fenrir API",
+    version: "1.0.0",
+    endpoints: ["GET /", "GET /users", "GET /users/:id", "POST /users", "DELETE /users/:id"]
+  }
+}))
 
-app.get('/', fn(req, res) {
-  res.json({
-    name: 'Fenrir API',
-    version: '0.2.0',
-    uptime: process.uptime(),
-  })
-})
+route("GET", "/users", req => ({
+  body: { users: db.users, total: db.users.length }
+}))
 
-app.get('/users', fn(req, res) {
-  res.json({ users, count: users.length })
+route("POST", "/users", req => {
+  const { name, email } = req.body || {}
+  if (!name || !email) {
+    return response({ error: "name and email required" }, 400)
+  }
+  const user = { id: db.nextId++, name, email }
+  db.users.push(user)
+  return response({ created: user }, 201)
 })
 
-app.get('/users/:id', fn(req, res) {
-  const id = parseInt(req.params.id)
-  const user = users.find(u => u.id === id)
-  if (!user) return res.status(404).json({ error: 'user not found' })
-  res.json(user)
-})
+const server = serve(PORT, async req => {
+  const method = req.method
+  const url    = req.url.split("?")[0]
 
-app.post('/users', fn(req, res) {
-  const { name, role } = req.body
-  if (!name) return res.status(400).json({ error: 'name is required' })
-  const user = { id: users.length + 1, name, role: role || 'user' }
-  users.push(user)
-  res.status(201).json(user)
-})
+  info(f"[${method}] ${url}")
+
+  const exact = routes[`${method}:${url}`]
+  if (exact) return exact(req)
 
-app.delete('/users/:id', fn(req, res) {
-  const id = parseInt(req.params.id)
-  const idx = users.findIndex(u => u.id === id)
-  if (idx === -1) return res.status(404).json({ error: 'user not found' })
-  const removed = users.splice(idx, 1)[0]
-  res.json({ deleted: removed })
+  const dynamicKey = Object.keys(routes).find(k => {
+    const [km, kp] = k.split(":")
+    if (km !== method) return false
+    const kParts = kp.split("/")
+    const uParts = url.split("/")
+    if (kParts.length !== uParts.length) return false
+    return kParts.every((seg, i) => seg.startsWith(":") || seg === uParts[i])
+  })
+
+  if (dynamicKey) {
+    const [, pattern] = dynamicKey.split(":")
+    const patParts = pattern.split("/")
+    const urlParts = url.split("/")
+    req.params = {}
+    patParts.forEach((seg, i) => {
+      if (seg.startsWith(":")) req.params[seg.slice(1)] = urlParts[i]
+    })
+    return routes[dynamicKey](req)
+  }
+
+  const anyMethod = Object.keys(routes).find(k => k.split(":")[1] === url)
+  if (anyMethod) return methodNotAllowed()
+
+  return notFound()
 })
 
-app.use(notFound)
+route("GET", "/users/:id", req => {
+  const id   = parseInt(req.params.id)
+  const user = db.users.find(u => u.id === id)
+  if (!user) return response({ error: f"User ${id} not found" }, 404)
+  return { body: { user } }
+})
 
-app.listen(PORT, fn() {
-  log(`🐺 Server running on http://localhost:${PORT}`)
-  log(`   GET    /users`)
-  log(`   GET    /users/:id`)
-  log(`   POST   /users`)
-  log(`   DELETE /users/:id`)
+route("DELETE", "/users/:id", req => {
+  const id  = parseInt(req.params.id)
+  const idx = db.users.findIndex(u => u.id === id)
+  if (idx === -1) return response({ error: f"User ${id} not found" }, 404)
+  const [removed] = db.users.splice(idx, 1)
+  return { body: { deleted: removed } }
 })
+
+print(f"Server running → http://localhost:${PORT}")
+print("Routes:")
+print("  GET    /")
+print("  GET    /users")
+print("  POST   /users        body: { name, email }")
+print("  GET    /users/:id")
+print("  DELETE /users/:id")

package/package.json

@@ -1,16 +1,20 @@
 {
-    "name": "fenrir-runtime",
-    "version": "0.2.0",
-    "description": "Fenrir — a modern JavaScript-based runtime",
-    "main": "src/cli/index.js",
-    "bin": {
-      "fenrir": "./src/cli/index.js"
-    },
-    "type": "module",
-    "scripts": {
-      "link": "npm link"
-    },
-    "dependencies": {
-      "glob": "^11.0.0"
-    }
-  }
+  "name": "fenrir-runtime",
+  "version": "0.3.0",
+  "description": "Fenrir — a modern JavaScript-based runtime",
+  "main": "src/cli/index.js",
+  "bin": {
+    "fenrir": "./src/cli/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "link": "npm link"
+  },
+  "dependencies": {
+    "glob": "^11.0.0",
+    "sql.js": "^1.12.0",
+    "js-yaml": "^4.1.0",
+    "toml": "^3.0.0",
+    "chokidar": "^3.6.0"
+  }
+}

package/src/cli/archiveSystem.js

@@ -21,9 +21,13 @@ export class ArchiveSystem {
       fs.mkdirSync(path.dirname(out), { recursive: true });
       fs.copyFileSync(path.join(this.root, f), out);
     }
-    const meta = { timestamp: now.toISOString(), message: message||'Snapshot', files: files.length,
+    const meta = {
+      timestamp: now.toISOString(),
+      message: message || 'Snapshot',
+      files: files.length,
       hash: crypto.createHash('md5').update(files.join('|')).digest('hex').slice(0,8),
-      gitHash: (() => { try { return execSync('git rev-parse HEAD',{cwd:this.root,encoding:'utf8'}).trim(); } catch { return null; } })() };
+      gitHash: (() => { try { return execSync('git rev-parse HEAD',{cwd:this.root,encoding:'utf8'}).trim(); } catch { return null; } })()
+    };
     fs.writeFileSync(path.join(dest,'.metadata.json'), JSON.stringify(meta,null,2));
     console.log(`\x1b[32m✓  Archive: ${id} (${files.length} files)\x1b[0m`);
     return id;
@@ -53,7 +57,6 @@ export class ArchiveSystem {
     if (!fs.existsSync(ap)) { console.error(`Not found: ${target}`); return; }
     console.log('Saving current state...');
     await this.create(`Pre-rollback — ${new Date().toISOString()}`);
-    const meta = JSON.parse(fs.readFileSync(path.join(ap,'.metadata.json'),'utf8'));
     console.log(`Rolling back to \x1b[36m${target}\x1b[0m`);
     for (const f of await this.collect()) { const fp=path.join(this.root,f); if(fs.existsSync(fp)) fs.rmSync(fp,{force:true}); }
     const af = await glob('**/*',{cwd:ap,nodir:true,ignore:['.metadata.json']});
@@ -70,6 +73,42 @@ export class ArchiveSystem {
     console.log(`\x1b[32m✓  Removed ${del.length}, kept ${keep}.\x1b[0m`);
   }
 
+  async diff(idA, idB) {
+    if (!fs.existsSync(this.dir)) { console.error('No archives.'); return; }
+    const all = fs.readdirSync(this.dir).sort().reverse();
+
+    const resolveId = (id, fallbackIdx) => id ?? all[fallbackIdx];
+    const a = resolveId(idA, 1);
+    const b = resolveId(idB, 0);
+
+    if (!a || !b) { console.error('Not enough archives to diff.'); return; }
+    const pathA = path.join(this.dir, a);
+    const pathB = path.join(this.dir, b);
+    if (!fs.existsSync(pathA)) { console.error(`Not found: ${a}`); return; }
+    if (!fs.existsSync(pathB)) { console.error(`Not found: ${b}`); return; }
+
+    const filesA = new Set(await glob('**/*', { cwd: pathA, nodir: true, ignore: ['.metadata.json'] }));
+    const filesB = new Set(await glob('**/*', { cwd: pathB, nodir: true, ignore: ['.metadata.json'] }));
+
+    const added   = [...filesB].filter(f => !filesA.has(f));
+    const removed = [...filesA].filter(f => !filesB.has(f));
+    const changed = [...filesA].filter(f => {
+      if (!filesB.has(f)) return false;
+      const ha = crypto.createHash('md5').update(fs.readFileSync(path.join(pathA, f))).digest('hex');
+      const hb = crypto.createHash('md5').update(fs.readFileSync(path.join(pathB, f))).digest('hex');
+      return ha !== hb;
+    });
+
+    console.log(`\x1b[1mDiff: \x1b[36m${a}\x1b[0m\x1b[1m → \x1b[36m${b}\x1b[0m\n`);
+    if (!added.length && !removed.length && !changed.length) {
+      console.log('  \x1b[90mNo differences.\x1b[0m'); return;
+    }
+    for (const f of added)   console.log(`  \x1b[32m+ ${f}\x1b[0m`);
+    for (const f of removed) console.log(`  \x1b[31m- ${f}\x1b[0m`);
+    for (const f of changed) console.log(`  \x1b[33m~ ${f}\x1b[0m`);
+    console.log(`\n  \x1b[90m${added.length} added, ${removed.length} removed, ${changed.length} changed\x1b[0m`);
+  }
+
   async collect() {
     const patterns = ['**/*.{py,java,cpp,c,h,cs,rb,php,swift,go,rs}','**/*.{js,ts,jsx,tsx,mjs,cjs}','**/*.{css,scss,sass,less}','**/*.{html,htm,json,xml,yml,yaml}','**/*.{md,txt,sh,bash,lock,fnr}'];
     const ignore = ['.fenrir/**','node_modules/**','.git/**','*.log','.env*','dist/**','build/**'];

package/src/cli/doctor.js

@@ -0,0 +1,87 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+export class Doctor {
+  async run() {
+    console.log('\x1b[1m\nFenrir Doctor\x1b[0m\n');
+    const checks = [
+      this.checkNode(),
+      this.checkNpm(),
+      this.checkFenrirJson(),
+      this.checkPackageJson(),
+      this.checkNodeModules(),
+      this.checkGit(),
+    ];
+
+    let allOk = true;
+    for (const { ok, label, detail } of checks) {
+      const icon = ok ? '\x1b[32m✓\x1b[0m' : '\x1b[31m✘\x1b[0m';
+      console.log(`  ${icon}  ${label}${detail ? '  \x1b[90m' + detail + '\x1b[0m' : ''}`);
+      if (!ok) allOk = false;
+    }
+
+    console.log(allOk
+      ? '\n\x1b[32m  All checks passed.\x1b[0m\n'
+      : '\n\x1b[33m  Some checks failed. Review above.\x1b[0m\n'
+    );
+  }
+
+  checkNode() {
+    try {
+      const v = execSync('node --version', { encoding: 'utf8' }).trim();
+      const major = parseInt(v.slice(1));
+      return { ok: major >= 18, label: `Node.js ${v}`, detail: major < 18 ? 'Requires Node 18+' : '' };
+    } catch {
+      return { ok: false, label: 'Node.js not found' };
+    }
+  }
+
+  checkNpm() {
+    try {
+      const v = execSync('npm --version', { encoding: 'utf8' }).trim();
+      return { ok: true, label: `npm v${v}` };
+    } catch {
+      return { ok: false, label: 'npm not found' };
+    }
+  }
+
+  checkFenrirJson() {
+    const p = path.join(process.cwd(), 'fenrir.json');
+    if (!fs.existsSync(p)) return { ok: false, label: 'fenrir.json', detail: 'Not found (run: fenrir install)' };
+    try {
+      const j = JSON.parse(fs.readFileSync(p, 'utf8'));
+      return { ok: true, label: 'fenrir.json', detail: `v${j.version}` };
+    } catch {
+      return { ok: false, label: 'fenrir.json', detail: 'Invalid JSON' };
+    }
+  }
+
+  checkPackageJson() {
+    const p = path.join(process.cwd(), 'package.json');
+    if (!fs.existsSync(p)) return { ok: false, label: 'package.json', detail: 'Not found' };
+    try {
+      const j = JSON.parse(fs.readFileSync(p, 'utf8'));
+      const hasModule = j.type === 'module';
+      return { ok: hasModule, label: 'package.json', detail: hasModule ? '' : 'Missing "type": "module"' };
+    } catch {
+      return { ok: false, label: 'package.json', detail: 'Invalid JSON' };
+    }
+  }
+
+  checkNodeModules() {
+    const p = path.join(process.cwd(), 'node_modules');
+    const exists = fs.existsSync(p);
+    return { ok: exists, label: 'node_modules', detail: exists ? '' : 'Not found (run: fenrir install)' };
+  }
+
+  checkGit() {
+    try {
+      execSync('git rev-parse --git-dir', { cwd: process.cwd(), encoding: 'utf8', stdio: 'pipe' });
+      const branch = execSync('git branch --show-current', { encoding: 'utf8', stdio: 'pipe' }).trim();
+      return { ok: true, label: 'Git repository', detail: `branch: ${branch}` };
+    } catch {
+      return { ok: false, label: 'Git repository', detail: 'Not a git repo' };
+    }
+  }
+}