feat: cli

Cargo.lock

@@ -1019,7 +1019,6 @@ name = "nix-js"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "bumpalo",
  "deno_core",
  "derive_more",
  "hashbrown 0.16.1",

nix-js-macros/src/lib.rs

@@ -1,4 +1,4 @@
-//! This crate provides procedural macros for the nixjit project.
+//! This crate provides procedural macros for the nix-js project.
 use proc_macro::TokenStream;
 
 mod ir;

nix-js/Cargo.toml

@@ -11,7 +11,6 @@ anyhow = "1.0"
 rustyline = "14.0"
 
 regex = "1.11"
-bumpalo = { version = "3.19", features = ["boxed"] }
 hashbrown = "0.16"
 derive_more = { version = "2", features = ["full"] }
 thiserror = "2"

nix-js/src/bin/eval.rs

@@ -0,0 +1,23 @@
+use std::process::exit;
+use anyhow::Result;
+use nix_js::context::Context;
+
+fn main() -> Result<()> {
+    let mut args = std::env::args();
+    if args.len() != 2 {
+        eprintln!("Usage: {} expr", args.next().unwrap());
+        exit(1);
+    }
+    args.next();
+    let expr = args.next().unwrap();
+    match Context::new().eval(&expr) {
+        Ok(value) => {
+            println!("{value}");
+            Ok(())
+        },
+        Err(err) => {
+            eprintln!("Error: {err}");
+            Err(anyhow::anyhow!("{err}"))
+        },
+    }
+}

nix-js/src/bin/repl.rs

@@ -0,0 +1,53 @@
+use anyhow::Result;
+use regex::Regex;
+use rustyline::DefaultEditor;
+use rustyline::error::ReadlineError;
+
+use nix_js::context::Context;
+
+fn main() -> Result<()> {
+    let mut rl = DefaultEditor::new()?;
+    let mut context = Context::new();
+    let re = Regex::new(r"^\s*([a-zA-Z_][a-zA-Z0-9_'-]*)\s*=(.*)$").unwrap();
+    loop {
+        let readline = rl.readline("nix-js-repl> ");
+        match readline {
+            Ok(line) => {
+                if line.trim().is_empty() {
+                    continue;
+                }
+                let _ = rl.add_history_entry(line.as_str());
+                if let Some(_caps) = re.captures(&line) {
+                    eprintln!("Error: binding not implemented yet");
+                    continue;
+                    /* let ident = caps.get(1).unwrap().as_str();
+                    let expr = caps.get(2).unwrap().as_str().trim();
+                    if expr.is_empty() {
+                        eprintln!("Error: missing expression after '='");
+                        continue;
+                    }
+                    if let Err(err) = context.add_binding(ident, expr) {
+                        eprintln!("Error: {}", err);
+                    } */
+                } else {
+                    match context.eval(&line) {
+                        Ok(value) => println!("{value}"),
+                        Err(err) => eprintln!("Error: {err}"),
+                    }
+                }
+            }
+            Err(ReadlineError::Interrupted) => {
+                println!();
+            }
+            Err(ReadlineError::Eof) => {
+                println!("CTRL-D");
+                break;
+            }
+            Err(err) => {
+                eprintln!("Error: {err:?}");
+                break;
+            }
+        }
+    }
+    Ok(())
+}