fenrir-runtime 0.0.1 → 0.3.0

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' };
+    }
+  }
+}

package/src/cli/index.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+import path from 'path';
+import { runFile, watchFile, formatFile, lintFile, bundleFile } from '../runtime/runner.js';
+import { PackageManager } from './packageManager.js';
+import { ArchiveSystem } from './archiveSystem.js';
+import { TestRunner } from './testRunner.js';
+import { Scaffolder } from './scaffolder.js';
+import { Doctor } from './doctor.js';
+import { startRepl } from './repl.js';
+
+const [,,cmd,...argv] = process.argv;
+const pm = new PackageManager();
+const arc = new ArchiveSystem();
+const tester = new TestRunner();
+const scaffolder = new Scaffolder();
+const doctor = new Doctor();
+
+const B='\x1b[1m', C='\x1b[36m', G='\x1b[90m', R='\x1b[0m';
+
+function help() {
+  console.log(`
+${B}Fenrir${R}  ${G}v0.3.0${R}
+
+${B}Run${R}
+  ${C}fenrir${R} <file.fnr>              Run a file
+  ${C}fenrir${R} <file.fnr> --sandbox    Run in sandbox (no fs write / exec)
+  ${C}fenrir${R} watch <file.fnr>        Watch & re-run on change
+  ${C}fenrir${R} repl                    Interactive REPL
+
+${B}Code${R}
+  ${C}fenrir${R} fmt <file.fnr>          Format file
+  ${C}fenrir${R} lint <file.fnr>         Lint file
+  ${C}fenrir${R} bundle <entry> [out]    Bundle to single file
+  ${C}fenrir${R} test [pattern]          Run test files
+
+${B}Project${R}
+  ${C}fenrir${R} new <name> [template]   Scaffold project (script|server|cli)
+  ${C}fenrir${R} install [pkg]           Install package
+  ${C}fenrir${R} remove <pkg>            Remove package
+  ${C}fenrir${R} doctor                  Check environment
+
+${B}Archives${R}
+  ${C}fenrir${R} archive [msg]           Save snapshot
+  ${C}fenrir${R} archives                List snapshots
+  ${C}fenrir${R} rollback [id]           Restore snapshot
+  ${C}fenrir${R} diff [id1] [id2]        Diff two snapshots
+  ${C}fenrir${R} clean [n]               Keep n snapshots
+
+  ${C}fenrir${R} help                    Show this
+`);
+}
+
+async function main() {
+  if (!cmd || cmd === 'help') { help(); return; }
+  if (cmd === '--version' || cmd === '-v') { console.log('0.3.0'); return; }
+
+  const debug = argv.includes('--debug') || process.env.FENRIR_DEBUG === '1';
+  const sandbox = argv.includes('--sandbox');
+  const cleanArgs = argv.filter(a => a !== '--debug' && a !== '--sandbox');
+
+  switch (cmd) {
+    case 'repl':    await startRepl(); break;
+    case 'watch':
+      if (!cleanArgs[0]) { console.error('Usage: fenrir watch <file>'); process.exit(1); }
+      await watchFile(path.resolve(process.cwd(), cleanArgs[0]), debug); break;
+    case 'fmt':
+    case 'format':
+      if (!cleanArgs[0]) { console.error('Usage: fenrir fmt <file>'); process.exit(1); }
+      formatFile(path.resolve(process.cwd(), cleanArgs[0])); break;
+    case 'lint':
+      if (!cleanArgs[0]) { console.error('Usage: fenrir lint <file>'); process.exit(1); }
+      lintFile(path.resolve(process.cwd(), cleanArgs[0])); break;
+    case 'bundle':
+      if (!cleanArgs[0]) { console.error('Usage: fenrir bundle <entry> [out]'); process.exit(1); }
+      bundleFile(path.resolve(process.cwd(), cleanArgs[0]), cleanArgs[1] ? path.resolve(process.cwd(), cleanArgs[1]) : undefined); break;
+    case 'test':    await tester.run(cleanArgs[0]); break;
+    case 'new':     await scaffolder.create(cleanArgs[0], cleanArgs[1]); break;
+    case 'install': await pm.install(cleanArgs[0]); break;
+    case 'remove':
+      if (!cleanArgs[0]) { console.error('Usage: fenrir remove <pkg>'); process.exit(1); }
+      await pm.remove(cleanArgs[0]); break;
+    case 'doctor':  await doctor.run(); break;
+    case 'archive': await arc.create(cleanArgs.join(' ') || undefined); break;
+    case 'archives': await arc.list(); break;
+    case 'rollback': await arc.rollback(cleanArgs[0]); break;
+    case 'diff':    await arc.diff(cleanArgs[0], cleanArgs[1]); break;
+    case 'clean':   await arc.clean(cleanArgs[0] ? parseInt(cleanArgs[0]) : 10); break;
+    default:
+      if (cmd.endsWith('.fnr') || cmd.endsWith('.js') || cmd.endsWith('.mjs')) {
+        await runFile(path.resolve(process.cwd(), cmd), debug, sandbox);
+      } else {
+        console.error(`\x1b[31m✘ Unknown command: ${cmd}\x1b[0m`);
+        console.log(`Run \x1b[36mfenrir help\x1b[0m for usage.`);
+        process.exit(1);
+      }
+  }
+}
+
+main().catch(e => { console.error('\x1b[31m✘ Fatal:\x1b[0m', e?.message||e); process.exit(1); });

package/src/cli/packageManager.js

@@ -0,0 +1,52 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+export class PackageManager {
+  constructor(root = process.cwd()) {
+    this.root = root;
+    this.pkgPath = path.join(root, 'package.json');
+    this.fenrirPath = path.join(root, 'fenrir.json');
+  }
+
+  async install(name) {
+    if (!fs.existsSync(this.fenrirPath)) await this.init();
+    if (name) {
+      process.stdout.write(`\x1b[36m⬇  Installing ${name}...\x1b[0m\n`);
+      execSync(`npm install ${name}`, { cwd: this.root, stdio: 'pipe' });
+      await this.sync(name, 'add');
+      process.stdout.write(`\x1b[32m✓  ${name} installed.\x1b[0m\n`);
+    } else {
+      process.stdout.write('\x1b[36m⬇  Installing dependencies...\x1b[0m\n');
+      execSync('npm install', { cwd: this.root, stdio: 'inherit' });
+      process.stdout.write('\x1b[32m✓  Done.\x1b[0m\n');
+    }
+  }
+
+  async remove(name) {
+    process.stdout.write(`\x1b[36m✗  Removing ${name}...\x1b[0m\n`);
+    execSync(`npm uninstall ${name}`, { cwd: this.root, stdio: 'pipe' });
+    await this.sync(name, 'remove');
+    process.stdout.write(`\x1b[32m✓  ${name} removed.\x1b[0m\n`);
+  }
+
+  async init() {
+    const name = path.basename(this.root);
+    await fs.promises.writeFile(this.fenrirPath, JSON.stringify({ name, version:'0.1.0', description:'A Fenrir project', dependencies:{}, fenrirVersion:'0.3.0' }, null, 2));
+    if (!fs.existsSync(this.pkgPath)) {
+      await fs.promises.writeFile(this.pkgPath, JSON.stringify({ name:name.toLowerCase().replace(/[^a-z0-9-]/g,'-'), version:'0.1.0', type:'module', dependencies:{} }, null, 2));
+    }
+    process.stdout.write('\x1b[32m✓  Fenrir project initialized.\x1b[0m\n');
+  }
+
+  async sync(name, action) {
+    if (!fs.existsSync(this.fenrirPath)) return;
+    const j = JSON.parse(await fs.promises.readFile(this.fenrirPath, 'utf8'));
+    if (!j.dependencies) j.dependencies = {};
+    if (action === 'add') {
+      const pkg = fs.existsSync(this.pkgPath) ? JSON.parse(await fs.promises.readFile(this.pkgPath,'utf8')) : {};
+      j.dependencies[name] = pkg.dependencies?.[name] ?? 'latest';
+    } else { delete j.dependencies[name]; }
+    await fs.promises.writeFile(this.fenrirPath, JSON.stringify(j, null, 2));
+  }
+}

package/src/cli/repl.js

@@ -0,0 +1,108 @@
+import { createInterface } from 'readline';
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function startRepl() {
+  const { runFile } = await import('../runtime/runner.js');
+  const historyFile = path.join(os.homedir(), '.fenrir_history');
+  const history = fs.existsSync(historyFile)
+    ? fs.readFileSync(historyFile, 'utf8').split('\n').filter(Boolean).slice(-200)
+    : [];
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: '\x1b[36mfenrir\x1b[0m \x1b[90m›\x1b[0m ',
+    history,
+    historySize: 200,
+  });
+
+  console.log('\x1b[1mFenrir REPL\x1b[0m \x1b[90mv0.3.0 — Ctrl+C to exit, .help for commands\x1b[0m\n');
+  rl.prompt();
+
+  let multiline = '';
+  let inMulti = false;
+
+  rl.on('line', async raw => {
+    const line = raw.trim();
+
+    if (!line) { rl.prompt(); return; }
+
+    if (line === '.exit' || line === '.quit') { saveHistory(historyFile, history); process.exit(0); }
+    if (line === '.help') {
+      console.log('\x1b[90m  .help      Show this\n  .clear     Clear screen\n  .exit      Exit REPL\n  .history   Show history\x1b[0m');
+      rl.prompt(); return;
+    }
+    if (line === '.clear') { process.stdout.write('\x1b[2J\x1b[0f'); rl.prompt(); return; }
+    if (line === '.history') { history.slice(-20).forEach(h => console.log(`  \x1b[90m${h}\x1b[0m`)); rl.prompt(); return; }
+
+    if (line.endsWith('{') || line.endsWith('(') || line.endsWith('[')) {
+      multiline += raw + '\n';
+      inMulti = true;
+      process.stdout.write('\x1b[90m... \x1b[0m');
+      return;
+    }
+
+    if (inMulti) {
+      multiline += raw + '\n';
+      if (line === '}' || line === ')' || line === ']') {
+        inMulti = false;
+        await evalLine(multiline.trim(), historyFile, history);
+        multiline = '';
+      } else {
+        process.stdout.write('\x1b[90m... \x1b[0m');
+        return;
+      }
+    } else {
+      await evalLine(line, historyFile, history);
+    }
+
+    rl.prompt();
+  });
+
+  rl.on('close', () => { saveHistory(historyFile, history); process.exit(0); });
+}
+
+async function evalLine(code, historyFile, history) {
+  const { default: transform } = await import('../runtime/runner.js').then(m => ({ default: m.runFile }));
+  history.push(code);
+  if (history.length > 200) history.shift();
+  saveHistory(historyFile, history);
+
+  const tempDir = path.join(os.tmpdir(), `fenrir_repl_${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+  const tempFile = path.join(tempDir, 'repl.mjs');
+
+  const stdlibPath = path.join(__dirname, '..', 'stdlib', 'index.js');
+  const inject = `import { injectGlobals } from "file://${stdlibPath}";\ninjectGlobals();\n`;
+
+  const wrapped = `${inject}
+;(async () => {
+  try {
+    const __result = (${code});
+    if (__result !== undefined) process.stdout.write('\\x1b[32m→ ' + JSON.stringify(__result, null, 2) + '\\x1b[0m\\n');
+  } catch(e) {
+    try {
+      ${code};
+    } catch(e2) {
+      process.stderr.write('\\x1b[31m✘ ' + (e2.message || e2) + '\\x1b[0m\\n');
+    }
+  }
+})();`;
+
+  fs.writeFileSync(tempFile, wrapped);
+  try {
+    execSync(`node ${tempFile}`, { stdio: 'inherit', cwd: process.cwd() });
+  } catch {}
+  try { fs.rmSync(tempDir, { recursive: true, force: true }); } catch {}
+}
+
+function saveHistory(file, history) {
+  try { fs.writeFileSync(file, history.join('\n'), 'utf8'); } catch {}
+}

package/src/cli/scaffolder.js

@@ -0,0 +1,68 @@
+import fs from 'fs';
+import path from 'path';
+
+const templates = {
+  script: {
+    'main.fnr': `print("Hello from Fenrir!")
+
+const name = await prompt("What is your name? ")
+print(f"Hello, {name}!")
+`,
+    'fenrir.json': (name) => JSON.stringify({ name, version: '0.1.0', description: 'A Fenrir script', dependencies: {}, fenrirVersion: '0.3.0' }, null, 2),
+  },
+
+  server: {
+    'main.fnr': `const app = serve(3000, async req => {
+  if (req.url === "/") return { body: { message: "Hello from Fenrir!" } }
+  if (req.url === "/ping") return "pong"
+  return response({ error: "Not found" }, 404)
+})
+`,
+    'fenrir.json': (name) => JSON.stringify({ name, version: '0.1.0', description: 'A Fenrir HTTP server', dependencies: {}, fenrirVersion: '0.3.0' }, null, 2),
+  },
+
+  cli: {
+    'main.fnr': `const argv = args()
+
+if (argv[0] === "--help" || !argv[0]) {
+  print("Usage: fenrir main.fnr <command>")
+  print("Commands: hello, version")
+  exit(0)
+}
+
+match argv[0] {
+  "hello"   => print("Hello, world!")
+  "version" => print("v0.1.0")
+  _         => { err(f"Unknown command: {argv[0]}"); exit(1) }
+}
+`,
+    'fenrir.json': (name) => JSON.stringify({ name, version: '0.1.0', description: 'A Fenrir CLI tool', dependencies: {}, fenrirVersion: '0.3.0' }, null, 2),
+  },
+};
+
+export class Scaffolder {
+  async create(name, template = 'script') {
+    if (!name) { console.error('Usage: fenrir new <name> [script|server|cli]'); process.exit(1); }
+    const dest = path.join(process.cwd(), name);
+    if (fs.existsSync(dest)) { console.error(`\x1b[31m✘ Directory already exists: ${name}\x1b[0m`); process.exit(1); }
+
+    const tpl = templates[template];
+    if (!tpl) {
+      console.error(`\x1b[31m✘ Unknown template: ${template}. Choose: script, server, cli\x1b[0m`);
+      process.exit(1);
+    }
+
+    fs.mkdirSync(dest, { recursive: true });
+
+    for (const [filename, content] of Object.entries(tpl)) {
+      const fileContent = typeof content === 'function' ? content(name) : content;
+      fs.writeFileSync(path.join(dest, filename), fileContent, 'utf8');
+    }
+
+    fs.writeFileSync(path.join(dest, '.gitignore'), 'node_modules/\n.fenrir/\n.env\n', 'utf8');
+
+    console.log(`\x1b[32m✓  Created ${template} project: ${name}\x1b[0m`);
+    console.log(`\n  \x1b[90mcd ${name}\x1b[0m`);
+    console.log(`  \x1b[90mfenrir main.fnr\x1b[0m\n`);
+  }
+}

package/src/cli/testRunner.js

@@ -0,0 +1,99 @@
+import fs from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+import os from 'os';
+import crypto from 'crypto';
+import { glob } from 'glob';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export class TestRunner {
+  constructor(root = process.cwd()) {
+    this.root = root;
+  }
+
+  async run(pattern) {
+    const files = pattern
+      ? await glob(pattern, { cwd: this.root })
+      : await glob('**/*.test.{fnr,js,mjs}', { cwd: this.root, ignore: ['node_modules/**', '.fenrir/**'] });
+
+    if (!files.length) {
+      console.log('\x1b[33m⚠  No test files found.\x1b[0m');
+      return;
+    }
+
+    console.log(`\x1b[1m\nRunning ${files.length} test file(s)...\x1b[0m\n`);
+
+    let passed = 0, failed = 0;
+
+    for (const file of files) {
+      const abs = path.join(this.root, file);
+      const result = await this.runFile(abs);
+      if (result.success) {
+        console.log(`  \x1b[32m✓\x1b[0m  ${file}`);
+        passed++;
+      } else {
+        console.log(`  \x1b[31m✘\x1b[0m  ${file}`);
+        if (result.output) {
+          result.output.split('\n').forEach(l => console.log(`     \x1b[90m${l}\x1b[0m`));
+        }
+        failed++;
+      }
+    }
+
+    console.log(`\n\x1b[1m${passed + failed} tests: \x1b[32m${passed} passed\x1b[0m, \x1b[31m${failed} failed\x1b[0m\n`);
+    if (failed > 0) process.exit(1);
+  }
+
+  runFile(filePath) {
+    return new Promise(async resolve => {
+      const { runFile: execFile } = await import('../runtime/runner.js');
+      const source = fs.readFileSync(filePath, 'utf8');
+      const wrapped = this.wrapTestSource(source);
+      const tempDir = path.join(os.tmpdir(), `fenrir_test_${crypto.randomBytes(4).toString('hex')}`);
+      fs.mkdirSync(tempDir, { recursive: true });
+      const tempFile = path.join(tempDir, 'test.mjs');
+      const stdlibPath = path.join(__dirname, '..', 'stdlib', 'index.js');
+      const inject = `import { injectGlobals } from "file://${stdlibPath}";\ninjectGlobals();\n`;
+      fs.writeFileSync(tempFile, inject + '\n' + wrapped);
+      const root = process.cwd();
+      const cwdMods = path.join(root, 'node_modules');
+      const env = { ...process.env, NODE_PATH: cwdMods };
+      let output = '';
+      const child = spawn('node', [tempFile], { env, cwd: root });
+      child.stdout.on('data', d => output += d);
+      child.stderr.on('data', d => output += d);
+      child.on('close', code => {
+        try { fs.rmSync(tempDir, { recursive: true, force: true }); } catch {}
+        resolve({ success: code === 0, output: code !== 0 ? output.trim() : '' });
+      });
+    });
+  }
+
+  wrapTestSource(source) {
+    return `
+const __tests = [];
+const __results = { passed: 0, failed: 0 };
+
+globalThis.test = (name, fn) => __tests.push({ name, fn });
+globalThis.describe = (label, fn) => { fn(); };
+
+${source}
+
+;(async () => {
+  for (const { name, fn } of __tests) {
+    try {
+      await fn();
+      __results.passed++;
+    } catch(e) {
+      __results.failed++;
+      process.stderr.write('FAIL: ' + name + '\\n' + (e.message || e) + '\\n');
+    }
+  }
+  if (__results.failed > 0) process.exit(1);
+})();
+`;
+  }
+}