fenrir-runtime 0.0.1 → 0.2.0

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.2.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/runtime/runner.js

@@ -0,0 +1,139 @@
+import { spawn } 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);
+
+function transform(source, filePath) {
+  const lines = source.split('\n');
+  const out = [];
+  let i = 0;
+
+  while (i < lines.length) {
+    const raw = lines[i];
+    const line = raw.trim();
+    i++;
+
+    if (!line) { out.push(''); continue; }
+    if (line.startsWith('//') || line.startsWith('/*') || line.startsWith('*')) { out.push(raw); continue; }
+
+    if (line.startsWith('use ') && line.includes(' from ')) {
+      const m = line.match(/^use\s+(.*?)\s+from\s+(['"])(.*?)\2\s*;?$/);
+      if (m) {
+        const [, spec,, mod] = m;
+        const isLocal = /^\.\.?\//.test(mod) || mod.startsWith('/');
+        out.push(isLocal
+          ? `import ${spec} from "file://${path.resolve(path.dirname(filePath), mod)}";`
+          : `import ${spec} from "${mod}";`
+        );
+      } else { out.push(raw); }
+      continue;
+    }
+
+    if (line.startsWith('async fn ') || line.startsWith('fn ')) {
+      out.push(sh(raw).replace(/\basync fn\s+/, 'async function ').replace(/\bfn\s+/, 'function '));
+      continue;
+    }
+
+    if (line.startsWith('type ') && line.includes('=')) continue;
+    if (isJs(line)) { out.push(sh(raw)); continue; }
+
+    if (!bal(line)) {
+      let full = raw;
+      while (i < lines.length && !bal(full)) { full += '\n' + lines[i]; i++; }
+      const s = sh(full);
+      out.push(s + (semi(s.trim()) ? ';' : ''));
+      continue;
+    }
+
+    const s = sh(raw);
+    out.push(s.trim() + (semi(s.trim()) ? ';' : ''));
+  }
+
+  return out.join('\n');
+}
+
+const sh = c => c
+  .replace(/\blog\(/g, 'console.log(')
+  .replace(/\berr\(/g, 'console.error(')
+  .replace(/\bwarn\(/g, 'console.warn(')
+  .replace(/\binfo\(/g, 'console.info(')
+  .replace(/\basync fn\b/g, 'async function')
+  .replace(/\bfn\b/g, 'function');
+
+function ch(s, c) { let n=0,inS=false,sC=''; for(let j=0;j<s.length;j++){const x=s[j];if(inS){if(x==='\\'){j++;continue}if(x===sC)inS=false;continue}if(x==='"'||x==="'"){inS=true;sC=x;continue}if(x===c)n++}return n; }
+const bal = s => ch(s,'(')=== ch(s,')')&& ch(s,'[')=== ch(s,']')&& ch(s,'{')=== ch(s,'}');
+
+function isJs(l) {
+  return l.startsWith('import ')||l.startsWith('export ')||l.startsWith('class ')||
+    l.startsWith('function ')||l.startsWith('async function ')||
+    l.startsWith('if ')||l.startsWith('if(')||l.startsWith('else')||l.startsWith('} else')||
+    l.startsWith('for ')||l.startsWith('for(')||l.startsWith('while ')||l.startsWith('while(')||
+    l.startsWith('switch ')||l.startsWith('switch(')||l.startsWith('try')||
+    l.startsWith('catch')||l.startsWith('finally')||l.startsWith('return')||
+    l.startsWith('throw ')||l.startsWith('case ')||l.startsWith('default:')||
+    /^}\s*(else|catch|finally)/.test(l)||l==='break'||l==='continue';
+}
+
+function semi(l) {
+  if(!l) return false;
+  if(l.endsWith(';')||l.endsWith('{')||l.endsWith('}')||l.endsWith(',')||l.endsWith('[')||l.endsWith('(')) return false;
+  if(isJs(l)) return false;
+  if(l.endsWith(')')&&!(l.includes('=')||l.includes('console.')||/^[a-zA-Z_$][\w$.]*\s*\(/.test(l)||/^(await|return)\s/.test(l))) return false;
+  return l.includes('=')||l.includes('console.')||
+    l.startsWith('const ')||l.startsWith('let ')||l.startsWith('var ')||
+    l.startsWith('throw ')||l.startsWith('return')||l.startsWith('import ')||
+    /^[a-zA-Z_$][\w$.]*\s*[\(`[]/.test(l)||/^(await|yield)\s/.test(l)||
+    /^\w+\s*(\+\+|--)/.test(l)||/^\w+\s*[+\-*/&|^]=/.test(l);
+}
+
+export async function runFile(filePath, debug=false) {
+  if (!fs.existsSync(filePath)) { console.error(`\x1b[31m✘ File not found: ${filePath}\x1b[0m`); process.exit(1); }
+
+  const source = fs.readFileSync(filePath, 'utf8');
+  if (!source.trim()) { console.error('\x1b[31m✘ File is empty.\x1b[0m'); process.exit(1); }
+
+  const userCode = transform(source, filePath);
+  const stdlibPath = path.join(__dirname, '..', 'stdlib', 'index.js');
+  const inject = fs.existsSync(stdlibPath)
+    ? `import { injectGlobals } from "file://${stdlibPath}";\ninjectGlobals();\n`
+    : '';
+
+  const final = `${inject}\n// === USER CODE ===\n${userCode}`;
+  if (debug) console.log('\x1b[90m[debug]\x1b[0m\n' + final);
+
+  const tempDir = path.join(os.tmpdir(), `fenrir_${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+  const tempFile = path.join(tempDir, 'run.mjs');
+  fs.writeFileSync(tempFile, final);
+
+  const root = process.cwd();
+  const cwdMods = path.join(root, 'node_modules');
+  const tempMods = path.join(tempDir, 'node_modules');
+  if (fs.existsSync(cwdMods)) try { cpDir(cwdMods, tempMods); } catch {}
+  const pkg = path.join(root, 'package.json');
+  if (fs.existsSync(pkg)) try { fs.copyFileSync(pkg, path.join(tempDir,'package.json')); } catch {}
+
+  const env = { ...process.env,
+    NODE_PATH: [tempMods, cwdMods, process.env.NODE_PATH].filter(Boolean).join(path.delimiter) };
+
+  const child = spawn('node', [tempFile], { stdio:'inherit', env, cwd:root });
+  child.on('close', code => { del(tempDir); process.exit(code??0); });
+  child.on('error', e => { console.error(`\x1b[31m✘ ${e.message}\x1b[0m`); del(tempDir); process.exit(1); });
+  process.on('SIGINT', () => { del(tempDir); process.exit(130); });
+}
+
+const del = dir => { try { fs.rmSync(dir,{recursive:true,force:true}); } catch {} };
+
+function cpDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const e of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, e.name), d = path.join(dest, e.name);
+    if (e.isSymbolicLink()) try { cpDir(fs.realpathSync(s),d); } catch {}
+    else if (e.isDirectory()) cpDir(s,d);
+    else try { fs.copyFileSync(s,d); } catch {}
+  }
+}

package/src/stdlib/index.js

@@ -0,0 +1,101 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync, spawn as nodeSpawn } from 'child_process';
+import { createInterface } from 'readline';
+
+const fmt = v => v===null?'null':v===undefined?'undefined':typeof v==='object'?JSON.stringify(v,null,2):String(v);
+
+export const print = (...a) => { process.stdout.write(a.map(fmt).join(' ')+'\n'); };
+export const log   = print;
+export const err   = (...a) => { process.stderr.write(a.map(fmt).join(' ')+'\n'); };
+export const warn  = (...a) => { process.stderr.write('\x1b[33m'+a.map(fmt).join(' ')+'\x1b[0m\n'); };
+export const info  = (...a) => { process.stdout.write('\x1b[36m'+a.map(fmt).join(' ')+'\x1b[0m\n'); };
+
+export const prompt = q => new Promise(r => {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  rl.question(q, a => { rl.close(); r(a); });
+});
+
+export const readFile   = p => fs.readFileSync(path.resolve(p), 'utf8');
+export const writeFile  = (p,c) => { fs.writeFileSync(path.resolve(p), c, 'utf8'); };
+export const appendFile = (p,c) => { fs.appendFileSync(path.resolve(p), c, 'utf8'); };
+export const fileExists = p => fs.existsSync(path.resolve(p));
+export const readDir    = p => fs.readdirSync(path.resolve(p));
+export const readJSON   = p => JSON.parse(readFile(p));
+export const writeJSON  = (p,d) => writeFile(p, JSON.stringify(d,null,2));
+export const mkdir      = p => { fs.mkdirSync(path.resolve(p), { recursive: true }); };
+export const rm         = p => { fs.rmSync(path.resolve(p), { recursive: true, force: true }); };
+
+export const get  = async (url, headers) => { const r=await fetch(url,{headers}); const t=await r.text(); try{return JSON.parse(t)}catch{return t}};
+export const post = async (url, body, headers) => { const r=await fetch(url,{method:'POST',headers:{'Content-Type':'application/json',...headers},body:JSON.stringify(body)}); const t=await r.text(); try{return JSON.parse(t)}catch{return t}};
+
+export const exec  = cmd => execSync(cmd, { encoding:'utf8', stdio:['pipe','pipe','pipe'] }).trim();
+export const run   = cmd => { execSync(cmd, { stdio:'inherit' }); };
+export const spawn = (cmd, args=[]) => new Promise((res,rej) => {
+  const c = nodeSpawn(cmd, args, { stdio:'inherit' });
+  c.on('close', res); c.on('error', rej);
+});
+
+export const env   = (k, fb='') => process.env[k] ?? fb;
+export const args  = () => process.argv.slice(2);
+export const exit  = (c=0) => process.exit(c);
+export const cwd   = () => process.cwd();
+
+export const now  = () => Date.now();
+export const time = () => new Date().toISOString();
+export const sleep = ms => new Promise(r => setTimeout(r, ms));
+export const bench = async (label, fn) => { const s=performance.now(); await fn(); info(`[bench] ${label}: ${(performance.now()-s).toFixed(2)}ms`); };
+
+export const range = (start, end, step=1) => { if(end===undefined){end=start;start=0;} const r=[];for(let i=start;i<end;i+=step)r.push(i);return r; };
+export const rand    = (min=0,max=1) => Math.random()*(max-min)+min;
+export const randInt = (min,max) => Math.floor(rand(min,max+1));
+export const pick    = arr => arr[randInt(0,arr.length-1)];
+export const shuffle = arr => { const a=[...arr]; for(let i=a.length-1;i>0;i--){const j=randInt(0,i);[a[i],a[j]]=[a[j],a[i]];} return a; };
+export const chunk   = (arr,n) => { const r=[];for(let i=0;i<arr.length;i+=n)r.push(arr.slice(i,i+n));return r; };
+export const unique  = arr => [...new Set(arr)];
+export const flatten = arr => arr.flat(Infinity);
+export const sum     = arr => arr.reduce((a,b)=>a+b,0);
+export const avg     = arr => sum(arr)/arr.length;
+export const min     = (...a) => Math.min(...(Array.isArray(a[0])?a[0]:a));
+export const max     = (...a) => Math.max(...(Array.isArray(a[0])?a[0]:a));
+export const clamp   = (n,lo,hi) => Math.max(lo,Math.min(hi,n));
+
+export const capitalize = s => s.charAt(0).toUpperCase()+s.slice(1);
+export const truncate   = (s,n,suf='...') => s.length>n?s.slice(0,n)+suf:s;
+export const pad        = (s,n,c=' ') => String(s).padStart(n,c);
+export const repeat     = (s,n) => s.repeat(n);
+
+export const keys    = o => Object.keys(o);
+export const values  = o => Object.values(o);
+export const entries = o => Object.entries(o);
+export const merge   = (...os) => Object.assign({},...os);
+export const clone   = v => JSON.parse(JSON.stringify(v));
+
+export const all   = ps => Promise.all(ps);
+export const race  = ps => Promise.race(ps);
+export const retry = async (fn,times=3,delay=500) => { for(let i=0;i<times;i++){try{return await fn()}catch(e){if(i===times-1)throw e;await sleep(delay);}} };
+
+export const isString = v => typeof v==='string';
+export const isNumber = v => typeof v==='number';
+export const isBool   = v => typeof v==='boolean';
+export const isArray  = v => Array.isArray(v);
+export const isObject = v => v!==null&&typeof v==='object'&&!Array.isArray(v);
+export const isNull   = v => v===null;
+export const isDefined= v => v!==undefined&&v!==null;
+
+export const { abs,ceil,floor,round,sqrt,pow,PI,E,log2,log10,sin,cos,tan } = Math;
+
+export function injectGlobals() {
+  Object.assign(globalThis, {
+    print,log,err,warn,info,prompt,
+    readFile,writeFile,appendFile,fileExists,readDir,readJSON,writeJSON,mkdir,rm,
+    get,post,exec,run,spawn,env,args,exit,cwd,
+    now,time,sleep,bench,
+    range,rand,randInt,pick,shuffle,chunk,unique,flatten,sum,avg,min,max,clamp,
+    capitalize,truncate,pad,repeat,
+    keys,values,entries,merge,clone,
+    all,race,retry,
+    isString,isNumber,isBool,isArray,isObject,isNull,isDefined,
+    abs,ceil,floor,round,sqrt,pow,PI,E,log2,log10,sin,cos,tan,
+  });
+}

package/App/App.axaml

@@ -1,8 +0,0 @@
-<Application xmlns="https://github.com/avaloniaui"
-             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             x:Class="FenrirLinux.App"
-             RequestedThemeVariant="Dark">
-    <Application.Styles>
-        <FluentTheme />
-    </Application.Styles>
-</Application>

package/App/App.axaml.cs

@@ -1,23 +0,0 @@
-using Avalonia;
-using Avalonia.Controls.ApplicationLifetimes;
-using Avalonia.Markup.Xaml;
-
-namespace FenrirLinux;
-
-public partial class App : Application
-{
-    public override void Initialize()
-    {
-        AvaloniaXamlLoader.Load(this);
-    }
-
-    public override void OnFrameworkInitializationCompleted()
-    {
-        if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
-        {
-            desktop.MainWindow = new MainWindow();
-        }
-
-        base.OnFrameworkInitializationCompleted();
-    }
-}

package/App/FenrirLinux.csproj

@@ -1,27 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>WinExe</OutputType>
-    <TargetFramework>net9.0</TargetFramework>
-    <Nullable>enable</Nullable>
-    <BuiltInComInteropSupport>true</BuiltInComInteropSupport>
-    <ApplicationManifest>app.manifest</ApplicationManifest>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <AvaloniaResource Include="Assets\**" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <TrimmerRootDescriptor Include="Roots.xml" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Avalonia" Version="11.0.6" />
-    <PackageReference Include="Avalonia.Desktop" Version="11.0.6" />
-    <PackageReference Include="Avalonia.Themes.Fluent" Version="11.0.6" />
-    <PackageReference Include="Avalonia.Fonts.Inter" Version="11.0.6" />
-    <PackageReference Include="Avalonia.ReactiveUI" Version="11.0.6" />
-    <PackageReference Condition="'$(Configuration)' == 'Debug'" Include="Avalonia.Diagnostics" Version="11.0.6" />
-  </ItemGroup>
-</Project>