history now writes to the fs .history properly

Cargo.lock

@@ -10,15 +10,15 @@ checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
 
 [[package]]
 name = "bitflags"
-version = "2.6.0"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+checksum = "1be3f42a67d6d345ecd59f675f3f012d6974981560836e938c22b424b85ce1be"
 
 [[package]]
 name = "bstr"
-version = "1.11.1"
+version = "1.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "786a307d683a5bf92e6fd5fd69a7eb613751668d1d8d67d802846dfe367c62c8"
+checksum = "531a9155a481e2ee699d4f98f43c0ca4ff8ee1bfd55c31e9e98fb29d2b176fe0"
 dependencies = [
  "memchr",
  "serde",
@@ -32,9 +32,9 @@ checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
 
 [[package]]
 name = "cc"
-version = "1.2.6"
+version = "1.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d6dbb628b8f8555f86d0323c2eb39e3ec81901f4b83e091db8a6a76d316a333"
+checksum = "ad0cf6e91fde44c773c6ee7ec6bba798504641a8bc2eb7e37a04ffbf4dfaa55a"
 dependencies = [
  "shlex",
 ]
@@ -73,6 +73,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "126f97965c8ad46d6d9163268ff28432e8f6a1196a55578867832e3049df63dd"
 dependencies = [
  "const_format_proc_macros",
+ "konst",
 ]
 
 [[package]]
@@ -146,6 +147,21 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "konst"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "330f0e13e6483b8c34885f7e6c9f19b1a7bd449c673fbb948a51c99d66ef74f4"
+dependencies = [
+ "konst_macro_rules",
+]
+
+[[package]]
+name = "konst_macro_rules"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4933f3f57a8e9d9da04db23fb153356ecaf00cbd14aee46279c33dc80925c37"
+
 [[package]]
 name = "libc"
 version = "0.2.169"
@@ -178,9 +194,9 @@ dependencies = [
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.4.14"
+version = "0.4.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
+checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
 
 [[package]]
 name = "lock_api"
@@ -198,6 +214,25 @@ version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 
+[[package]]
+name = "lua-src"
+version = "547.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1edaf29e3517b49b8b746701e5648ccb5785cde1c119062cbabbc5d5cd115e42"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "luajit-src"
+version = "210.5.11+97813fb"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3015551c284515db7c30c559fc1080f9cb9ee990d1f6fca315451a107c7540bb"
+dependencies = [
+ "cc",
+ "which",
+]
+
 [[package]]
 name = "luau0-src"
 version = "0.11.2+luau653"
@@ -254,6 +289,8 @@ checksum = "63a11d485edf0f3f04a508615d36c7d50d299cf61a7ee6d3e2530651e0a31771"
 dependencies = [
  "cc",
  "cfg-if",
+ "lua-src",
+ "luajit-src",
  "luau0-src",
  "pkg-config",
 ]
@@ -314,9 +351,9 @@ checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.92"
+version = "1.0.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
+checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99"
 dependencies = [
  "unicode-ident",
 ]
@@ -347,9 +384,9 @@ checksum = "c7fb8039b3032c191086b10f11f319a6e99e1e82889c5cc6046f515c9db1d497"
 
 [[package]]
 name = "rustix"
-version = "0.38.42"
+version = "0.38.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f93dc38ecbab2eb790ff964bb77fa94faf256fd3e73285fd7ba0903b76bedb85"
+checksum = "a78891ee6bf2340288408954ac787aa063d8e8817e9f53abb37c695c6d834ef6"
 dependencies = [
  "bitflags",
  "errno",
@@ -428,9 +465,9 @@ checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 
 [[package]]
 name = "syn"
-version = "2.0.94"
+version = "2.0.96"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "987bc0be1cdea8b10216bd06e2ca407d40b9543468fafd3ddfb02f36e77f71f3"
+checksum = "d5d0adab1ae378d7f53bdebc67a39f1f151407ef230f0ce2883572f5d8985c80"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -439,18 +476,18 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "2.0.9"
+version = "2.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f072643fd0190df67a8bab670c20ef5d8737177d6ac6b2e9a236cb096206b2cc"
+checksum = "d452f284b73e6d76dd36758a0c8684b1d5be31f92b89d07fd5822175732206fc"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.9"
+version = "2.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b50fa271071aae2e6ee85f842e2e28ba8cd2c5fb67f11fcb1fd70b276f9e7d4"
+checksum = "26afc1baea8a989337eeb52b6e72a039780ce45c3edfcc9c5b9d112feeb173c2"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -555,6 +592,18 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "which"
+version = "6.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ee928febd44d98f2f459a4a79bd4d928591333a494a10a868418ac1b39cf1f"
+dependencies = [
+ "either",
+ "home",
+ "rustix",
+ "winsafe",
+]
+
 [[package]]
 name = "whoami"
 version = "1.5.2"
@@ -669,3 +718,9 @@ name = "windows_x86_64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "winsafe"
+version = "0.0.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d135d17ab770252ad95e9a872d365cf3090e3be864a34ab46f48555993efc904"

Cargo.toml

@@ -5,16 +5,10 @@ edition = "2021"
 
 [dependencies]
 color-print = "0.3.7"
-const_format = "0.2.33"
+const_format = { version = "0.2.34", features = ["rust_1_64"] }
 crossterm = "0.28.1"
 home = "0.5.9"
-mlua = { version = "0.10.0", features = ["luau-jit"] }
+mlua = { version = "0.10.0", features = ["luau-jit", "vendored"] }
 thiserror = "2.0.9"
 uzers = "0.12.1"
-whoami = "1.5.2"
-
-[profile.release]
-strip = true
-opt-level = "z"
-lto = true
-codegen-units = 1
+whoami = "1.5.2"

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 rhpidfyre
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

src/commands.rs

@@ -1,25 +1,16 @@
+use std::{io, process, str::SplitWhitespace, path::{Path, PathBuf}};
 use uzers::User;
-use std::{
-	io,
-	process,
-	str::SplitWhitespace,
-	path::{Path, PathBuf},
-};
 
-enum ValidStatus {
-	NoRootFolder,
-	TryExists(io::Error)
-}
-
-fn display_none<T>(e: io::Error) -> Option<T> {
-	println!("{e}");
-	None
-}
+use crate::{history::History, session::MapDisplay, valid_pbuf::IsValid};
 
 trait PathBufIsValid {
-	fn is_valid(&self) -> Result<PathBuf, ValidStatus>;
 	fn is_valid_or_home(&self) -> Option<PathBuf>;
 }
+impl PathBufIsValid for PathBuf {
+	fn is_valid_or_home(&self) -> Option<PathBuf> {
+		self.is_valid_or(self.is_dir(), home::home_dir)
+	}
+}
 
 trait ChangeDirectory {
 	fn change_directory(&self, args: SplitWhitespace) -> Option<PathBuf>;
@@ -29,33 +20,9 @@ trait ChangeDirectory {
 	fn previous_dir(&self) -> Option<PathBuf>;
 	fn home_dir(&self) -> Option<PathBuf>;
 }
-
-impl PathBufIsValid for PathBuf {
-	fn is_valid(&self) -> Result<PathBuf, ValidStatus> {
-		match self.try_exists() {
-			Ok(true) => Ok(self.to_path_buf()),
-			Ok(false) => Err(ValidStatus::NoRootFolder),
-			Err(trye_error) => Err(ValidStatus::TryExists(trye_error))
-		}
-	}
-
-	fn is_valid_or_home(&self) -> Option<PathBuf> {
-		match self.is_valid() {
-			Ok(valid) => Some(valid),
-			Err(valid_status) => {
-				match valid_status {
-					ValidStatus::NoRootFolder => println!("cd: /root: No such file or directory"),
-					ValidStatus::TryExists(error) => println!("cd: {error}"),
-				};
-				None
-			},
-		}
-	}
-}
-
 impl ChangeDirectory for Command {
 	fn set_current_dir(&self, new_path: &Path) -> Option<PathBuf> {
-		std::env::set_current_dir(new_path).map_or_else(display_none, |()| Some(new_path.to_path_buf()))
+		std::env::set_current_dir(new_path).map_or_display_none(|()| Some(new_path.to_path_buf()))
 	}
 
 	fn home_dir(&self) -> Option<PathBuf> {
@@ -122,24 +89,25 @@ impl ChangeDirectory for Command {
 
 pub struct Command(String);
 impl Command {
-	pub fn new(input: String) -> Self {
+	pub const fn new(input: String) -> Self {
 		Self(input)
 	}
 
-	pub fn spawn(&self, command_process: io::Result<process::Child>) {
-		command_process.map_or_else(display_none, |mut child| Some(child.wait()));
+	pub fn spawn_sys_cmd(&mut self, history: &mut History, command_process: io::Result<process::Child>) {
+		if let Ok(mut child) = command_process {
+			history.add(self.0.as_str());
+			child.wait().ok();
+		} else {
+			println!("Unknown command: {}", self.0)
+		}
 	}
 
-	pub fn exec(&self) {
+	pub fn exec(&mut self, history: &mut History) {
 		let mut args = self.0.split_whitespace();
 		if let Some(command) = args.next() {
 			match command {
-				"cd" => {
-					self.change_directory(args);
-				},
-				command => {
-					self.spawn(process::Command::new(command).args(args).spawn());
-				}
+				"cd" => if self.change_directory(args).is_some() { history.add(self.0.as_str()) },
+				command => { self.spawn_sys_cmd(history, process::Command::new(command).args(args).spawn()); }
 			}
 		}
 	}

src/history.rs

@@ -0,0 +1,52 @@
+use std::{fs::{File, OpenOptions}, io::{BufRead, BufReader, Write}, path::PathBuf};
+
+use crate::{rc::{self}, session::{self, MapDisplay}, valid_pbuf::IsValid};
+
+#[derive(Debug, Clone)]
+pub struct History {
+	fs_history: Option<Vec<String>>,
+	history: Vec<String>,
+	file: Option<PathBuf>,
+}
+impl History {
+	pub fn init() -> Self {
+		let file = rc::config_dir().map(|mut config_dir| {
+			config_dir.push(".history");
+			config_dir.is_valid_file_or_create(b"");
+			config_dir
+		});
+		let fs_history = file.as_ref().and_then(|file| {
+			File::open(file).map_or_display_none(|file| {
+				Some(BufReader::new(file).lines().map_while(Result::ok).collect::<Vec<String>>())
+			})
+		});
+		Self {
+			history: Vec::new(),
+			fs_history,
+			file,
+		}
+	}
+
+	pub fn write_to_file_fallible(&mut self) {
+		if self.history.is_empty() { return; }
+
+		if let (Some(history_file), Some(fs_history)) = (&self.file, &self.fs_history) {
+			OpenOptions::new()
+				.append(true)
+				.open(history_file.as_path())
+			.map_or_display(|mut file| {
+				let newline_maybe = if fs_history.is_empty() { "" } else { "\n" };
+				if let Err(write_err) = file.write_all(format!("{newline_maybe}{}", self.history.join("\n")).as_bytes()) {
+					session::shell_error(write_err);
+				};
+			});
+		}
+	}
+
+	pub fn add(&mut self, command: &str) {
+		match self.history.last() {
+		    Some(last_cmd) => if last_cmd != command { self.history.push(command.to_owned()); },
+		    None => self.history.push(command.to_owned()),
+		};
+	}
+}

src/lib.rs

@@ -1,13 +1,10 @@
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 
-pub mod shell;
-mod commands;
-mod ps;
-mod rc;
+pub mod session;
+pub mod commands;
+pub mod history;
+pub mod ps;
+pub mod rc;
+pub mod vm;
 
-#[path = "./luau/vm.rs"]
-mod vm;
-#[path = "./luau/alias.rs"]
-mod alias;
-#[path = "./luau/terminal.rs"]
-mod terminal;
+mod valid_pbuf;

src/luau/terminal.rs

@@ -1,80 +0,0 @@
-use mlua::{Result as lResult, Table};
-use crossterm::style::Stylize;
-use crate::vm::Vm;
-
-macro_rules! foreground_styles_luau {
-	($self:expr, $style_table:expr, $($color:ident)+) => {
-		$(
-			$style_table.set(stringify!($color).to_ascii_uppercase(), $self.0.create_function(|_, text: String| -> lResult<String> {
-            	Ok(text.$color().to_string())
-        	})?)?;
-        )+
-    };
-}
-
-macro_rules! background_styles_luau {
-	($self:expr, $style_table:expr, $($color:ident)+) => {
-		$(
-			match stringify!($color).split_once("_") {
-			    Some((_, color_name)) => $style_table.set(color_name.to_ascii_uppercase(), $self.0.create_function(|_, text: String| -> lResult<String> {
-					Ok(text.$color().to_string())
-        		})?)?,
-			    None => panic!("Luau set error: {:?}. There was nothing to split from delimiter: \"_\"", stringify!($color)),
-			}
-        )+
-    };
-}
-
-pub trait TerminalColors {
-	fn background(&self, style_table: &Table) -> lResult<()>;
-	fn foreground(&self, style_table: &Table) -> lResult<()>;
-	fn styling(&self) -> lResult<Table>;
-	fn terminal(&self) -> lResult<()>;
-}
-impl TerminalColors for Vm {
-	fn background(&self, style_table: &Table) -> lResult<()> {
-		let foreground_table = self.0.create_table()?;
-		foreground_styles_luau!(self, foreground_table,
-			dark_grey   dark_red     dark_green dark_cyan
-			dark_yellow dark_magenta dark_blue
-			red  grey    black green yellow
-		    blue magenta cyan  white
-			underlined
-			underline_dark_grey   underline_dark_red     underline_dark_green underline_dark_cyan
-			underline_dark_yellow underline_dark_magenta underline_dark_blue  underline_red
-			underline_grey        underline_black        underline_green      underline_yellow
-			underline_blue        underline_magenta      underline_cyan       underline_white
-			bold
-		);
-		style_table.set("FOREGROUND", foreground_table)?;
-        Ok(())
-	}
-
-	fn foreground(&self, style_table: &Table) -> lResult<()> {
-		let background_table = self.0.create_table()?;
-		background_styles_luau!(self, background_table,
-			on_dark_grey   on_dark_red     on_dark_green on_dark_cyan
-			on_dark_yellow on_dark_magenta on_dark_blue
-			on_red   on_grey  on_black
-		    on_green on_yellow
-		    on_blue  on_magenta
-		    on_cyan  on_white
-		);
-		style_table.set("BACKGROUND", background_table)?;
-        Ok(())
-	}
-
-	fn styling(&self) -> lResult<Table> {
-		let style_table = self.0.create_table()?;
-		self.foreground(&style_table)?;
-		self.background(&style_table)?;
-		Ok(style_table)
-	}
-
-	fn terminal(&self) -> lResult<()> {
-		let term_table = self.0.create_table()?;
-		term_table.set("OUT", self.styling()?)?;
-		self.0.globals().set("TERMINAL", &term_table)?;
-		Ok(())
-	}
-}

src/luau/vm.rs

@@ -1,84 +0,0 @@
-use mlua::{
-	Lua as Luau,
-	Result as lResult,
-	MultiValue,
-};
-use crate::VERSION;
-use crate::terminal::TerminalColors;
-use core::fmt;
-use color_print::cprintln;
-
-fn display_none<T, E>(err: E) -> Option<T>
-where
-	E: fmt::Display
-{
-	println!("{err}");
-	None
-}
-
-fn luau_error<T>(err: mlua::Error) -> Option<T> {
-	cprintln!("<bold>====</>\n<r><bold>[!]</> {err}</>\n<bold>====</>");
-	None
-}
-
-fn luau_out(luau_args: MultiValue) -> String {
-	let mut print = String::new();
-	luau_args.iter()
-		.map(|arg| arg.to_string().unwrap_or("<SHELL CONVERSION ERROR>".to_owned()))
-		.for_each(|arg| {
-			if !print.is_empty() {
-				print.push('\u{0009}');
-			};
-			print.push_str(&arg);
-		}
-	);
-	print
-}
-
-trait Globals {
-	fn print(&self) -> lResult<()>;
-	fn printraw(&self) -> lResult<()>;
-	fn version(&self) -> lResult<()>;
-}
-impl Globals for Vm {
-	fn print(&self) -> lResult<()> {
-		self.0.globals().set("print", self.0.create_function(|_this, args: MultiValue| -> lResult<()> {
-			println!("{}", luau_out(args));
-			Ok(())
-		})?)
-	}
-	fn printraw(&self) -> lResult<()> {
-		self.0.globals().set("printraw", self.0.create_function(|_this, args: MultiValue| -> lResult<()> {
-			println!("{}", luau_out(args));
-			Ok(())
-		})?)
-	}
-	fn version(&self) -> lResult<()> {
-		let luau_info = self.0.globals().get::<String>("_VERSION")?;
-		self.0.globals().set("_VERSION", format!("{}, liblambdashell {}", luau_info, VERSION))
-	}
-}
-
-pub struct Vm(pub Luau);
-impl Vm {
-	pub fn new() -> Self {
-		Self(Luau::new())
-	}
-
-	fn set_shell_globals(&self) -> mlua::Result<()> {
-		self.print()?;
-		self.printraw()?;
-		self.version()?;
-		self.terminal()?;
-		self.0.globals().set("getfenv", mlua::Nil)?;
-		self.0.globals().set("setfenv", mlua::Nil)?;
-		self.0.sandbox(true)?;
-		Ok(())
-	}
-
-	pub fn exec(&self, source: String) {
-		self.set_shell_globals().map_or_else(display_none, |()| {
-			self.0.load(source).exec().map_or_else(luau_error, |()| Some(()))
-		});
-	}
-}

src/ps.rs

@@ -1,21 +1,28 @@
-use const_format::formatcp;
-use color_print::{cformat, cprint};
+pub const DEFAULT_PS: &str = concat!("lambdashell-", env!("CARGO_PKG_VERSION"), " ");
 
-pub const DEFAULT_PS: &str = formatcp!("lambdashell-{}", env!("CARGO_PKG_VERSION"));
+#[derive(Debug)]
+pub struct Ps(String);
+impl Ps {
+	pub const fn set(prompt: String) -> Self {
+		Self(prompt)
+	}
+	//rustc: `std::string::String::as_str` is not yet stable as a const fn
+	pub fn get(&self) -> &str {
+		self.0.as_str()
+	}
+	pub fn modify(&mut self, prompt: String) {
+		self.0 = prompt
+	}
+	pub fn display(&self) {
+		print!("{}", self.0);
+	}
 
-pub fn working_dir_name() -> String {
-	std::env::current_dir().map_or("?".to_owned(), |path| {
-		path.file_name().map_or("?".to_owned(), |name| {
-			let name_os_string = name.to_os_string();
-			match name_os_string == whoami::username_os() && name_os_string != "root" {
+	pub fn working_dir_name(&self) -> String {
+		std::env::current_dir().map_or("?".to_owned(), |path| path.file_name().map_or("?".to_owned(), |name| {
+			match name.to_os_string() == whoami::username_os() {
 				true => "~".to_owned(),
 				false => name.to_string_lossy().to_string(),
 			}
-		})
-	})
-}
-
-pub fn display(ps1: &String) {
-	let working_dir_name = cformat!(" <bold>{}</> ", working_dir_name());
-	cprint!("{}{}λ ", ps1, working_dir_name);
-}
+		}))
+	}
+}

src/rc.rs

@@ -1,117 +1,29 @@
-use std::{fs::{self, File}, io::{self, Write}, path::PathBuf};
-use thiserror::Error;
+use std::path::PathBuf;
+
+use crate::valid_pbuf::IsValid;
 
 pub const DEFAULT_CONFIG_CONTENT: &str = r#"--!strict
 
-local username = SHELL.SYSTEM.USERNAME
+local cyan = TERMINAL.OUT.FOREGROUND.CYAN
+local red  = TERMINAL.OUT.FOREGROUND.RED
+
 local hostname = SHELL.SYSTEM.HOSTNAME
+local username = SHELL.SYSTEM.USERNAME
+
+username = if username == "root" then red(username) else cyan(username)
 
 SHELL.PROMPT = `{username}@{hostname} λ `"#;
 
-#[derive(Debug, Error)]
-#[allow(dead_code)]
-enum IsValidDirErr {
-	#[error("Failed to see if a file exists: {0}")]
-	TryExists(#[from] io::Error),
-	#[error("Not a valid entry")]
-	NotAnEntry,
-	#[error("Directory missing")]
-	Missing
-}
-
-#[allow(dead_code)]
-enum CreateErr {
-	TryExists(io::Error),
-	Passable
-}
-
-fn display_none<T>(e: io::Error) -> Option<T> {
-	println!("{e}");
-	None
-}
-
-#[allow(dead_code)]
-trait IsValid {
-	fn is_valid(&self, is_dir_or_file: bool) -> Result<PathBuf, IsValidDirErr>;
-	fn is_valid_option(&self, is_dir_or_file: bool) -> Option<PathBuf>;
-	fn is_valid_file_or_create(&self, default_file_bytes: &[u8]) -> Option<PathBuf>;
-	fn is_valid_dir_or_create(&self) -> Option<PathBuf>;
-	fn is_valid_or<F>(&self, is_content: bool, f: F) -> Option<PathBuf>
-	where
-		F: FnOnce() -> Option<PathBuf>;
-}
-impl IsValid for PathBuf {
-	fn is_valid(&self, is_content: bool) -> Result<PathBuf, IsValidDirErr> {
-		match self.try_exists() {
-			Ok(true) => match is_content {
-				true => Ok(self.to_path_buf()),
-				false => Err(IsValidDirErr::NotAnEntry)
-			},
-			Ok(false) => Err(IsValidDirErr::Missing),
-			Err(try_e) => Err(IsValidDirErr::TryExists(try_e))
-		}
-	}
-
-	fn is_valid_or<F>(&self, is_content: bool, f: F) -> Option<PathBuf>
-	where
-		F: FnOnce() -> Option<PathBuf>
-	{
-		let possible_content = self.is_valid(is_content).map_err(|e| match e {
-			IsValidDirErr::TryExists(try_e) => CreateErr::TryExists(try_e),
-			IsValidDirErr::NotAnEntry | IsValidDirErr::Missing => CreateErr::Passable
-		});
-		match possible_content {
-			Ok(p) => Some(p),
-			Err(e) => match e {
-				CreateErr::TryExists(_) => None,
-				CreateErr::Passable => f()
-			},
-		}
-	}
-
-	fn is_valid_dir_or_create(&self) -> Option<PathBuf> {
-		self.is_valid_or(self.is_dir(), || {
-			match fs::create_dir(self) {
-				Ok(()) => Some(self.to_path_buf()),
-				Err(create_e) => display_none(create_e),
-			}
-		})
-	}
-
-	fn is_valid_file_or_create(&self, default_file_bytes: &[u8]) -> Option<PathBuf> {
-		self.is_valid_or(self.is_file(), || {
-			match File::create(self) {
-				Ok(mut file) => match file.write_all(default_file_bytes) {
-					Ok(()) => Some(self.to_path_buf()),
-					Err(write_e) => display_none(write_e),
-				},
-				Err(create_e) => display_none(create_e)
-			}
-		})
-	}
-
-	fn is_valid_option(&self, is_dir_or_file: bool) -> Option<PathBuf> {
-		self.is_valid(is_dir_or_file).ok()
-	}
-}
-
 pub fn config_dir() -> Option<PathBuf> {
 	let mut config = home::home_dir()?;
 	config.push(".config");
-	config.is_valid_option(config.is_dir())?;
+	config.is_valid_dir_or_create()?;
 	config.push("lambdashell");
 	config.is_valid_dir_or_create()
 }
 
 pub fn config_file() -> Option<PathBuf> {
 	let mut config_file = config_dir()?;
-	config_file.push("config.luau");
+	config_file.push("init.luau");
 	config_file.is_valid_file_or_create(DEFAULT_CONFIG_CONTENT.as_bytes())
-}
-
-// TODO: history.rs
-pub fn history_file() -> Option<PathBuf> {
-	let mut config_file = config_dir()?;
-	config_file.push(".history");
-	config_file.is_valid_file_or_create(b"")
 }

src/session.rs

@@ -0,0 +1,94 @@
+use std::{cell::RefCell, fs, io::{self}, rc::Rc};
+use core::fmt;
+use color_print::ceprintln;
+
+use crate::{
+	commands, history::History, ps::{self, Ps}, rc::{self}, vm::{self, LuauVm}
+};
+
+#[inline]
+pub fn shell_error<E: fmt::Display>(err: E) {
+	ceprintln!("<bold,r>[!]:</> {err}")
+}
+
+pub trait MapDisplay<T, E: fmt::Display> {
+	fn map_or_display<F: FnOnce(T)>(self, f: F);
+	fn map_or_display_none<R, F: FnOnce(T) -> Option<R>>(self, f: F) -> Option<R>;
+}
+impl<T, E: fmt::Display> MapDisplay<T, E> for Result<T, E> {
+	///Map but display the error to stdout
+	#[inline]
+	fn map_or_display<F: FnOnce(T)>(self, f: F) {
+		self.map_or_else(|e| shell_error(e), f)
+	}
+	///Map but display the error to stdout and return `None`
+	#[inline]
+	fn map_or_display_none<R, F: FnOnce(T) -> Option<R>>(self, f: F) -> Option<R> {
+		self.map_or_else(|e| { shell_error(e); None }, f)
+	}
+}
+
+#[derive(Debug, Clone)]
+pub struct Config {
+	pub norc: bool
+}
+pub struct LambdaShell {
+	terminate: bool,
+	history: History,
+	config: Config,
+	vm: LuauVm,
+	ps: Rc<RefCell<Ps>>,
+}
+impl LambdaShell {
+	pub fn create(config: Config) -> Self {
+		let ps = Rc::new(RefCell::new(Ps::set(ps::DEFAULT_PS.to_owned())));
+		Self {
+			ps: Rc::clone(&ps),
+			vm: vm::LuauVm::new(ps),
+			history: History::init(),
+			terminate: false,
+			config,
+		}
+	}
+
+	pub fn wait(&mut self) -> Result<(), io::Error> {
+		io::Write::flush(&mut io::stdout()).map(|()| {
+			let mut input = String::new();
+			io::stdin().read_line(&mut input).map_or_display(|_size| match input.trim() {
+				"exit" => {
+					self.terminate = true;
+					self.history.add("exit");
+				},
+				trim => commands::Command::new(trim.to_owned()).exec(&mut self.history)
+			})
+		})
+	}
+
+	pub fn error<E: fmt::Display>(&mut self, err: E) {
+		shell_error(err);
+		self.terminate = true;
+	}
+
+	pub fn start(&mut self) {
+		if !self.config.norc {
+			if let Some(conf_file) = rc::config_file() {
+				fs::read_to_string(conf_file).map_or_display(|luau_conf| self.vm_exec(luau_conf));
+			}
+		}
+		self.ps.borrow().display();
+
+		loop {
+			if self.terminate { break } else {
+				match self.wait() {
+			        Ok(()) => self.ps.borrow().display(),
+			        Err(flush_err) => self.error(flush_err),
+			    }
+			}
+		}
+		self.history.write_to_file_fallible();
+	}
+
+	pub fn vm_exec(&self, source: String) {
+		self.vm.exec(source);
+	}
+}

src/shell.rs

@@ -1,73 +0,0 @@
-use crate::{ps, commands, rc, vm};
-use std::{fs, io::{self}};
-
-pub struct Config {
-	pub norc: bool
-}
-
-trait ShellLuauVm {
-	fn shell_vm_exec(&self, source: String);
-}
-impl ShellLuauVm for LambdaShell {
-	fn shell_vm_exec(&self, source: String) {
-		vm::Vm::new().exec(source);
-	}
-}
-
-pub struct LambdaShell {
-	ps1: String,
-	config: Config,
-	terminating: bool,
-}
-impl LambdaShell {
-	pub fn create(config: Config) -> Self {
-		Self {
-			ps1: ps::DEFAULT_PS.to_owned(),
-			terminating: false,
-			config,
-		}
-	}
-
-	pub fn wait(&mut self) -> Result<(), io::Error> {
-		io::Write::flush(&mut io::stdout()).map(|()| {
-			let mut input = String::new();
-			io::stdin().read_line(&mut input).map_or_else(|read_error| println!("{read_error}"), |_size| {
-				match input.trim() {
-					//special casey
-					"exit" => self.terminating = true,
-					trim => commands::Command::new(trim.to_owned()).exec()
-				};
-			})
-		})
-	}
-
-	fn rc_parse(&self) {
-		if !self.config.norc {
-			if let Some(conf_file) = rc::config_file() {
-				match fs::read_to_string(conf_file) {
-			        Ok(luau_conf) => self.shell_vm_exec(luau_conf),
-			        Err(read_err) => println!("{read_err}"),
-			    }
-			}
-		}
-	}
-
-	pub fn start(&mut self) {
-		self.rc_parse();
-
-		ps::display(&self.ps1);
-
-		loop {
-			match self.terminating {
-				true => break,
-				false => match self.wait() {
-					Ok(()) => ps::display(&self.ps1),
-					Err(flush_error) => {
-						println!("{flush_error}");
-						break;
-					}
-				},
-			}
-		}
-	}
-}

src/valid_pbuf.rs

@@ -0,0 +1,75 @@
+use std::{fs::{self, File}, io::{self, Write}, path::PathBuf};
+use thiserror::Error;
+
+use crate::session::MapDisplay;
+
+#[derive(Debug, Error)]
+#[allow(dead_code)]
+pub enum IsValidDirErr {
+	#[error("Failed to see if a file exists: {0}")]
+	TryExists(#[from] io::Error),
+	#[error("Not a valid entry")]
+	NotAnEntry,
+	#[error("Directory missing")]
+	Missing
+}
+
+#[allow(dead_code)]
+enum CreateErr {
+	TryExists(io::Error),
+	Passable
+}
+
+#[allow(dead_code)]
+pub trait IsValid {
+	fn is_valid(&self, is_dir_or_file: bool) -> Result<PathBuf, IsValidDirErr>;
+	fn is_valid_option(&self, is_dir_or_file: bool) -> Option<PathBuf>;
+	fn is_valid_file_or_create(&self, default_file_bytes: &[u8]) -> Option<PathBuf>;
+	fn is_valid_dir_or_create(&self) -> Option<PathBuf>;
+	fn is_valid_or<F>(&self, is_content: bool, f: F) -> Option<PathBuf>
+	where
+		F: FnOnce() -> Option<PathBuf>;
+}
+impl IsValid for PathBuf {
+	#[inline]
+	fn is_valid(&self, is_content: bool) -> Result<PathBuf, IsValidDirErr> {
+		match self.try_exists() {
+			Ok(true) => if is_content { Ok(self.to_path_buf()) } else { Err(IsValidDirErr::NotAnEntry) },
+			Ok(false) => Err(IsValidDirErr::Missing),
+			Err(try_e) => Err(IsValidDirErr::TryExists(try_e))
+		}
+	}
+
+	#[inline]
+	fn is_valid_or<F>(&self, is_content: bool, f: F) -> Option<PathBuf>
+	where
+		F: FnOnce() -> Option<PathBuf>
+	{
+		self.is_valid(is_content).map_err(|e| match e {
+			IsValidDirErr::TryExists(try_e) => CreateErr::TryExists(try_e),
+			IsValidDirErr::NotAnEntry | IsValidDirErr::Missing => CreateErr::Passable
+		}).map_or_else(|e| match e {
+			CreateErr::TryExists(_) => None,
+			CreateErr::Passable => f()
+		}, Some)
+	}
+
+	#[inline]
+	fn is_valid_dir_or_create(&self) -> Option<PathBuf> {
+		self.is_valid_or(self.is_dir(), || fs::create_dir(self).map_or_display_none(|()| Some(self.to_path_buf())))
+	}
+
+	#[inline]
+	fn is_valid_file_or_create(&self, default_file_bytes: &[u8]) -> Option<PathBuf> {
+		self.is_valid_or(self.is_file(), || {
+			File::create(self).map_or_display_none(|mut file| {
+				file.write_all(default_file_bytes).map_or_display_none(|()| Some(self.to_path_buf()))
+			})
+		})
+	}
+
+	#[inline]
+	fn is_valid_option(&self, is_dir_or_file: bool) -> Option<PathBuf> {
+		self.is_valid(is_dir_or_file).ok()
+	}
+}

src/vm/mod.rs

@@ -0,0 +1,79 @@
+use mlua::{Function, Lua as Luau, MultiValue, Result as lResult, Table, Value};
+use color_print::{cformat, ceprintln};
+use terminal::TerminalGlobal;
+use std::{cell::RefCell, rc::Rc};
+use core::fmt;
+use shell::ShellGlobal;
+
+use crate::{ps::Ps, session::MapDisplay};
+
+mod shell;
+mod terminal;
+mod alias;
+
+trait LuauRuntimeErr<T> {
+	fn map_or_luau_rt_err<R, F: FnOnce(T) -> Option<R>>(self, f: F) -> Option<R>;
+}
+impl<T, E: fmt::Display> LuauRuntimeErr<T> for Result<T, E> {
+	#[inline]
+	fn map_or_luau_rt_err<R, F: FnOnce(T) -> Option<R>>(self, f: F) -> Option<R> {
+		self.map_or_else(|luau_rt_err| {
+			ceprintln!("<bold>====</>\n<r><bold>[!]:</> {luau_rt_err}</>\n<bold>====</>");
+			None
+		}, f)
+	}
+}
+
+trait Globals {
+	const LIB_VERSION: &str;
+	const CONV_ERROR: &str;
+	fn global_warn(&self, luau_globals: &Table) -> lResult<()>;
+	fn global_version(&self, luau_globals: &Table) -> lResult<()>;
+}
+impl Globals for LuauVm {
+	const LIB_VERSION: &str = env!("CARGO_PKG_VERSION");
+	const CONV_ERROR: &str = "<SHELL CONVERSION ERROR>";
+
+	fn global_warn(&self, luau_globals: &Table) -> lResult<()> {
+		let luau_print = luau_globals.get::<Function>("print")?;
+		luau_globals.raw_set("warn", self.vm.create_function(move |this, args: MultiValue| -> lResult<()> {
+			let luau_multi_values = args.into_iter()
+				.map(|value| cformat!("<bold,y>{}</>", value.to_string().unwrap_or(Self::CONV_ERROR.to_owned())))
+				.map(|arg_v| Value::String(this.create_string(arg_v).unwrap()))
+				.collect::<MultiValue>();
+			luau_print.call::<()>(luau_multi_values)?;
+			Ok(())
+		})?)
+	}
+
+	fn global_version(&self, luau_globals: &Table) -> lResult<()> {
+		let luau_info = luau_globals.get::<String>("_VERSION")?;
+		luau_globals.raw_set("_VERSION", format!("{luau_info}, liblambdashell {}", Self::LIB_VERSION))
+	}
+}
+
+pub struct LuauVm {
+	vm: Luau,
+	ps: Rc<RefCell<Ps>>
+}
+impl LuauVm {
+	pub(crate) fn new(ps: Rc<RefCell<Ps>>) -> Self {
+		Self { vm: Luau::new(), ps }
+	}
+
+	fn set_shell_globals(&self) -> lResult<()> {
+		let luau_globals = self.vm.globals();
+		self.global_shell(&luau_globals)?;
+		self.global_terminal(&luau_globals)?;
+		self.global_warn(&luau_globals)?;
+		self.global_version(&luau_globals)?;
+		luau_globals.raw_set("getfenv", mlua::Nil)?;
+		luau_globals.raw_set("setfenv", mlua::Nil)?;
+		self.vm.sandbox(true)?;
+		Ok(())
+	}
+
+	pub fn exec(&self, source: String) {
+		self.set_shell_globals().map_or_display_none(|()| self.vm.load(source).exec().map_or_luau_rt_err(Some));
+	}
+}

src/vm/shell.rs

@@ -0,0 +1,47 @@
+use mlua::{Lua as Luau, MetaMethod, Result as lResult, Table, UserData, UserDataFields, UserDataMethods};
+use std::{cell::RefCell, rc::Rc};
+use whoami::fallible;
+
+use crate::{ps::Ps, vm::LuauVm};
+
+const DEFAULT_HOSTNAME: &str = "hostname";
+
+fn luau_sys_details(luau: &Luau) -> lResult<Table> {
+	let system = luau.create_table()?;
+	system.raw_set("DESKTOP_ENV", whoami::desktop_env().to_string())?;
+	system.raw_set("DEVICENAME", whoami::devicename().to_string())?;
+	system.raw_set("USERNAME", whoami::username().to_string())?;
+	system.raw_set("REALNAME", whoami::realname().to_string())?;
+	system.raw_set("PLATFORM", whoami::platform().to_string())?;
+	system.raw_set("DISTRO", whoami::distro().to_string())?;
+	system.raw_set("ARCH", whoami::arch().to_string())?;
+	system.raw_set("HOSTNAME", fallible::hostname().unwrap_or(DEFAULT_HOSTNAME.to_owned()))?;
+	Ok(system)
+}
+
+struct Shell(Rc<RefCell<Ps>>);
+impl UserData for Shell {
+	fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {
+		fields.add_field_method_get("PROMPT", |_, this| Ok(this.0.borrow().get().to_owned()));
+		fields.add_field_method_get("SYSTEM", |luau, _| luau_sys_details(luau));
+	}
+
+	fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
+		methods.add_meta_method_mut(MetaMethod::NewIndex, |_, this, (tindex, tvalue): (String, String)| -> lResult<()> {
+			if tindex == "PROMPT" {
+				this.0.borrow_mut().modify(tvalue);
+			}
+			Ok(())
+		});
+	}
+}
+
+pub trait ShellGlobal {
+	fn global_shell(&self, luau_globals: &Table) -> lResult<()>;
+}
+impl ShellGlobal for LuauVm {
+	fn global_shell(&self, luau_globals: &Table) -> lResult<()> {
+		luau_globals.set("SHELL", Shell(Rc::clone(&self.ps)))?;
+		Ok(())
+	}
+}

src/vm/terminal.rs

@@ -0,0 +1,93 @@
+use mlua::{UserDataFields, Lua as Luau, Result as lResult, Table, UserData};
+use const_format::str_split;
+use crossterm::style::Stylize;
+
+use crate::vm::LuauVm;
+
+macro_rules! foreground_styles_luau {
+	($luau:expr, $style_table:expr, $($color:ident)+) => {
+		$(
+			$style_table.raw_set(stringify!($color).to_ascii_uppercase(), $luau.create_function(|_, text: String| -> lResult<String> {
+            	Ok(text.$color().to_string())
+        	})?)?;
+        )+
+    };
+}
+macro_rules! background_styles_luau {
+	($luau:expr, $style_table:expr, $($color:ident)+) => {
+		$(
+			$style_table.raw_set(
+				str_split!(stringify!($color), "_")[1..].join("_").to_ascii_uppercase(),
+			$luau.create_function(|_, text: String| -> lResult<String> {
+				Ok(text.$color().to_string())
+        	})?)?;
+        )+
+    };
+}
+
+fn text_styles_funcs(luau: &Luau) -> lResult<(Table, Table)> {
+	let foreground_table = luau.create_table()?;
+	let background_table = luau.create_table()?;
+	foreground_styles_luau!(luau, foreground_table,
+		dark_grey   dark_red     dark_green dark_cyan
+		dark_yellow dark_magenta dark_blue
+		red  grey    black green yellow
+	    blue magenta cyan  white
+		underlined
+		underline_dark_grey   underline_dark_red     underline_dark_green underline_dark_cyan
+		underline_dark_yellow underline_dark_magenta underline_dark_blue  underline_red
+		underline_grey        underline_black        underline_green      underline_yellow
+		underline_blue        underline_magenta      underline_cyan       underline_white
+		bold
+	);
+	background_styles_luau!(luau, background_table,
+		on_dark_grey   on_dark_red     on_dark_green on_dark_cyan
+		on_dark_yellow on_dark_magenta on_dark_blue
+		on_red   on_grey  on_black
+	    on_green on_yellow
+	    on_blue  on_magenta
+	    on_cyan  on_white
+	);
+	Ok((foreground_table, background_table))
+}
+
+fn fields_write_funcs<F: UserDataFields<Terminal>>(fields: &mut F) {
+	fields.add_field_method_get("WRITE", |luau, _| luau.create_function(|_, s: String| -> lResult<()> {
+		print!("{s}");
+		Ok(())
+	}));
+	fields.add_field_method_get("WRITE_ERROR", |luau, _| luau.create_function(|_, s: String| -> lResult<()> {
+		eprint!("{s}");
+		Ok(())
+	}));
+	fields.add_field_method_get("WRITE_ERROR_LN", |luau, _| luau.create_function(|_, s: String| -> lResult<()> {
+		eprintln!("{s}");
+		Ok(())
+	}));
+}
+
+struct Terminal;
+impl UserData for Terminal {
+	fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {
+		fields_write_funcs(fields);
+		fields.add_field_method_get("OUT", |luau, _| {
+			let (foreground, background) = text_styles_funcs(luau)?;
+			let out_table = luau.create_table()?;
+			out_table.raw_set("FOREGROUND", foreground)?;
+			out_table.raw_set("BACKGROUND", background)?;
+			Ok(out_table)
+		});
+	}
+	// fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
+
+	// }
+}
+
+pub trait TerminalGlobal {
+	fn global_terminal(&self, luau_globals: &Table) -> lResult<()>;
+}
+impl TerminalGlobal for LuauVm {
+	fn global_terminal(&self, luau_globals: &Table) -> lResult<()> {
+		luau_globals.raw_set("TERMINAL", Terminal)
+	}
+}