add embedded fs for embedding files, move dysnomia stuff out of source

Cargo.lock

···
 ]
 
 [[package]]
+name = "bstr"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab"
+dependencies = [
+ "memchr",
+ "serde",
+]
+
+[[package]]
 name = "btree-range-map"
 version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "nu-protocol",
  "rapidhash",
  "reqwest",
+ "rust-embed",
  "scc",
  "serde",
  "serde_ipld_dagcbor",
···
 checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
 
 [[package]]
+name = "globset"
+version = "0.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52dfc19153a48bde0cbd630453615c8151bce3a5adfac7a0aebfbf0a1e1f57e3"
+dependencies = [
+ "aho-corasick",
+ "bstr",
+ "log",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
 name = "gloo-storage"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "60b161f275cb337fe0a44d924a5f4df0ed69c2c39519858f931ce61c779d3475"
 dependencies = [
+ "globset",
  "sha2",
  "walkdir",
 ]
···
 [[package]]
 name = "vfs"
 version = "0.12.1"
-source = "git+https://github.com/landaire/rust-vfs?branch=fix%2Fwasm#c4341e8e7c16a019c1a1415fc8a413bf883a08d5"
+source = "git+https://github.com/90-008/rust-vfs?branch=fix%2Fwasm#547b30641d8f329614fb29e44c1c7360ef57ded9"
 dependencies = [
  "filetime",
+ "rust-embed",
 ]
 
 [[package]]

Cargo.toml

···
 wasm-bindgen-futures = "0.4"
 getrandom = { version = "0.3", features = ["wasm_js"] }
 web-sys = { version = "0.3", features = ["console", "Window"] }
-vfs = { version = "0.12" }
+vfs = { version = "0.12", features = ["embedded-fs"] }
 nu-command = { git = "https://github.com/90-008/nushell", default-features = false }
 nu-engine = { git = "https://github.com/90-008/nushell", default-features = false }
 nu-parser = { git = "https://github.com/90-008/nushell", default-features = false }
···
 rapidhash = { version = "4", features = ["unsafe"] }
 async-lock = "3.4.1"
 compile-time = "0.2.0"
+rust-embed = { version = "8.9.0", features = ["debug-embed", "include-exclude"] }
 
 [patch.crates-io]
-vfs = { git = "https://github.com/landaire/rust-vfs", branch = "fix/wasm" }
+vfs = { git = "https://github.com/90-008/rust-vfs", branch = "fix/wasm" }
 
 [profile.release]
 opt-level = 3

src/cmd/ls.rs

···
     Category, ListStream, PipelineData, Record, ShellError, Signature, SyntaxShape, Type, Value,
     engine::{Command, EngineState, Stack},
 };
+use wasm_bindgen::JsValue;
 
 #[derive(Clone)]
 pub struct Ls;
···
         let full_paths = call.has_flag(engine_state, stack, "full-paths")?;
 
         let pwd = get_pwd();
+        // web_sys::console::log_1(&JsValue::from_str(&format!("{pwd:?}")));
+        // web_sys::console::log_1(&JsValue::from_str(&format!(
+        //     "{:?}",
+        //     pwd.read_dir().map(|a| a.collect::<Vec<_>>())
+        // )));
         let mut target_dir = pwd.clone();
         if let Some(path) = path_arg {
             target_dir = Arc::new(

src/cmd/mod.rs

···
 pub mod save;
 pub mod source;
 pub mod sys;
-pub mod version;
 
 pub use cd::Cd;
 pub use fetch::Fetch;
···
 pub use save::Save;
 pub use source::Source;
 pub use sys::Sys;
-pub use version::Version;

src/cmd/sys.rs

···
             );
         }
 
+        let date = compile_time::unix!();
+        let rustc = compile_time::rustc_version_str!();
+
+        rec.push("build_time", Value::int(date, head));
+        rec.push("rustc_version", Value::string(rustc, head));
+
         Ok(Value::record(rec, head).into_pipeline_data())
     }
 }

src/cmd/version.rs

···
-use nu_protocol::Type;
-use nu_protocol::engine::Call;
-use nu_protocol::{
-    Category, IntoPipelineData, PipelineData, ShellError, Signature, Value,
-    engine::{Command, EngineState, Stack},
-};
-
-#[derive(Clone)]
-pub struct Version;
-
-impl Command for Version {
-    fn name(&self) -> &str {
-        "version"
-    }
-
-    fn signature(&self) -> Signature {
-        Signature::build(self.name())
-            .input_output_type(Type::Nothing, Type::String)
-            .category(Category::System)
-    }
-
-    fn description(&self) -> &str {
-        "print the version of dysnomia."
-    }
-
-    fn run(
-        &self,
-        _engine_state: &EngineState,
-        _stack: &mut Stack,
-        call: &Call,
-        _input: PipelineData,
-    ) -> Result<PipelineData, ShellError> {
-        let date = compile_time::unix!();
-        let rustc = compile_time::rustc_version_str!();
-        Ok(
-            Value::string(format!("dysnomia.v099.t{date} (rustc {rustc})"), call.head)
-                .into_pipeline_data(),
-        )
-    }
-}

src/completion/suggestions.rs

···
 pub fn generate_command_argument_suggestions(
     input: &str,
     engine_guard: &EngineState,
-    working_set: &StateWorkingSet,
     prefix: String,
     span: Span,
     command_name: String,
···
         // Get positional arguments from signature
         // Check if argument is in required or optional positional
         let required_count = signature.required_positional.len();
-        let is_optional = arg_index >= required_count;
 
         // Find the argument at the given index
         let arg = if arg_index < signature.required_positional.len() {
···
             } => generate_command_argument_suggestions(
                 input,
                 engine_guard,
-                working_set,
                 prefix,
                 span,
                 command_name,

src/globals.rs

···
     ShellError, Signal, Span,
     engine::{EngineState, StateDelta},
 };
+use rust_embed::RustEmbed;
 use std::{
     collections::HashMap,
     sync::{
···
     },
     time::{Duration, SystemTime, UNIX_EPOCH},
 };
-use vfs::{VfsError, VfsPath, error::VfsErrorKind};
+use vfs::{EmbeddedFS, OverlayFS, VfsError, VfsPath, error::VfsErrorKind};
 use wasm_bindgen::prelude::*;
 
 use crate::memory_fs::MemoryFS;
 
 static ROOT: OnceLock<Arc<VfsPath>> = OnceLock::new();
 
+fn init_vfs() -> Arc<VfsPath> {
+    let memory_fs = VfsPath::new(MemoryFS::new());
+    let embedded_fs = VfsPath::new(EmbeddedFS::<EmbeddedFiles>::new());
+    let overlaid_fs = VfsPath::new(OverlayFS::new(&[memory_fs, embedded_fs]));
+    Arc::new(overlaid_fs)
+}
+
 pub fn get_vfs() -> Arc<VfsPath> {
-    ROOT.get_or_init(|| Arc::new(VfsPath::new(MemoryFS::new())))
-        .clone()
+    ROOT.get_or_init(init_vfs).clone()
 }
+
+#[derive(RustEmbed, Debug)]
+#[folder = "embedded/"]
+#[exclude = ".gitkeep"]
+pub struct EmbeddedFiles;
 
 static PWD: OnceLock<RwLock<Arc<VfsPath>>> = OnceLock::new();
 

src/lib.rs

···
 use crate::{
     cmd::{
         Cd, Fetch, Job, JobKill, JobList, Ls, Mkdir, Mv, Open, Pwd, Random, Rm, Save, Source, Sys,
-        Version,
     },
     default_context::add_shell_command_context,
     error::format_error,
···
     engine_state = add_shell_command_context(engine_state);
     engine_state = add_extra_command_context(engine_state);
 
-    let write_file = |name: &str, contents: &str| {
-        get_vfs()
-            .join(name)
-            .and_then(|p| p.create_file())
-            .and_then(|mut f| f.write_all(contents.as_bytes()).map_err(VfsError::from))
-            .map_err(|e| miette::miette!(e.to_string()))
-    };
-
-    let access_log = format!(
-        r#"/dysnomia.v000 /user: 90008/ /ip: [REDACTED]/ /time: [REDACTED]//
-/dysnomia.v002 /user: 90008/ /ip: [REDACTED]/ /time: [REDACTED]//
-/dysnomia.v011 /user: 90008/ /ip: [REDACTED]/ /time: [REDACTED]//
-[...ENTRIES TRUNCATED...]
-/dysnomia.v099 /user: anonymous/ /ip: [REDACTED]/ /time: {time}//"#,
-        time = current_time()
-            .and_then(|t| t.duration_since(UNIX_EPOCH).ok())
-            .map_or_else(
-                || "unknown".to_string(),
-                |time| chrono::DateTime::from_timestamp_nanos(time.as_nanos() as i64)
-                    .format("%Y-%m-%dT%H:%M:%SZ")
-                    .to_string()
-            )
-    );
-    write_file(".access.log", &access_log)?;
-
-    let welcome_txt = r#"welcome  anonymous !
-
-
-you are interfacing with dysnomia.v099
-using the nu shell.
-
-
-a few commands you can try:
-
-"hello, user!" | save message.txt
-fetch at://ptr.pet
-ls --help"#;
-    write_file("welcome.txt", &welcome_txt)?;
-
     let mut working_set = StateWorkingSet::new(&engine_state);
-    let decls: [Box<dyn Command>; 16] = [
+    let decls: [Box<dyn Command>; 15] = [
         Box::new(Ls),
         Box::new(Open),
         Box::new(Save),
···
         Box::new(JobKill),
         Box::new(Sys),
         Box::new(Random),
-        Box::new(Version),
     ];
     for decl in decls {
         working_set.add_decl(decl);
···
     config.use_ansi_coloring = true.into();
     config.show_banner = nu_protocol::BannerKind::Full;
     config.hooks.display_output = Some("table".into_value(Span::unknown()));
+    config.table.show_empty = false;
     engine_state.config = Arc::new(config);
 
     engine_state.set_signals(Signals::new(Arc::new(InterruptBool)));

www/index.html

···
 <!doctype html>
 <html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>dysnomia</title>
-  </head>
-  <body>
-    <div id="app"></div>
-    <script type="module" src="/src/main.ts"></script>
-  </body>
+    <head>
+        <meta charset="UTF-8" />
+        <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>faunu</title>
+    </head>
+    <body>
+        <div id="app"></div>
+        <script type="module" src="/src/main.ts"></script>
+    </body>
 </html>

www/package.json

···
 {
-  "name": "dysnomia",
+  "name": "faunu",
   "private": true,
   "version": "0.0.0",
   "type": "module",