@anysphere/file-service 0.0.0-f2b1ba30 → 0.0.0

package/Cargo.toml

@@ -17,9 +17,6 @@ tempfile = "3.8.0"
 anyhow = "1.0.75"
 tonic = "0.9.2"
 prost = "0.11.9"
-tracing = "0.1.37"
-tracing-subscriber = "0.3.17"
-tracing-appender = "0.2.2"
 
 [build-dependencies]
 napi-build = "2.0.1"

package/build.rs

@@ -6,38 +6,38 @@ fn main() -> Result<(), anyhow::Error> {
   napi_build::setup();
 
   // print the relative path.
-  // let workspace_root = "../../../../../";
-  // let path = std::path::Path::new(workspace_root).canonicalize()?;
-  // let include_path = Path::join(&path, "schema");
-
-  // // let relevant_protos = &[
-	// // 	"aiserver/v1/repository.proto",
-	// // 	"aiserver/v1/symbolic_context.proto",
-	// // 	"aiserver/v1/utils.proto"
-	// // ];
-  // // let proto_paths = relevant_protos
-  // //   .iter()
-  // //   .map(|proto| Path::join(&include_path, proto))
-	// // 	.collect::<Vec<_>>();
-	// let proto_glob = Path::join(&include_path, "aiserver/v1/*.proto");
-  // let relevant_protos: Vec<_> = glob::glob(proto_glob.to_str().expect("Failed to convert path to str"))?
-  //   .filter_map(Result::ok)
-  //   .collect();
-
+  let workspace_root = "../../../../../";
+  let path = std::path::Path::new(workspace_root).canonicalize()?;
+  let include_path = Path::join(&path, "schema");
+
+  // let relevant_protos = &[
+	// 	"aiserver/v1/repository.proto",
+	// 	"aiserver/v1/symbolic_context.proto",
+	// 	"aiserver/v1/utils.proto"
+	// ];
   // let proto_paths = relevant_protos
   //   .iter()
-  //   .map(|proto_path| proto_path.to_str().expect("Failed to convert path to str"))
-  //   .collect::<Vec<_>>();
-  // let includes = &[include_path.to_str().unwrap()];
-
-  // // print the path
-  // println!("cargo:rustc-env=INCLUDE_PATH={}", include_path.display());
-
-  // tonic_build::configure()
-  //   .build_server(false)
-	// 	.build_transport(true)
-	// 	.out_dir("src/proto")
-  //   .compile(&proto_paths, includes)?;
+  //   .map(|proto| Path::join(&include_path, proto))
+	// 	.collect::<Vec<_>>();
+	let proto_glob = Path::join(&include_path, "aiserver/v1/*.proto");
+  let relevant_protos: Vec<_> = glob::glob(proto_glob.to_str().expect("Failed to convert path to str"))?
+    .filter_map(Result::ok)
+    .collect();
+
+  let proto_paths = relevant_protos
+    .iter()
+    .map(|proto_path| proto_path.to_str().expect("Failed to convert path to str"))
+    .collect::<Vec<_>>();
+  let includes = &[include_path.to_str().unwrap()];
+
+  // print the path
+  println!("cargo:rustc-env=INCLUDE_PATH={}", include_path.display());
+
+  tonic_build::configure()
+    .build_server(false)
+		.build_transport(true)
+		.out_dir("src/proto")
+    .compile(&proto_paths, includes)?;
 
 
 	Ok(())

package/index.d.ts

@@ -4,17 +4,10 @@
 /* auto-generated by NAPI-RS */
 
 export class MerkleClient {
-  constructor(rootDirectory: string)
   init(): Promise<void>
+  syncWithRemote(): Promise<void>
   computeMerkleTree(): Promise<void>
   updateFile(filePath: string): Promise<void>
   deleteFile(filePath: string): Promise<void>
-  getSubtreeHash(relativePath: string): Promise<string>
-  getNumEmbeddableFiles(): Promise<number>
-  getAllFiles(): Promise<Array<string>>
-  getAllDirFilesToEmbed(absoluteFilePath: string): Promise<Array<string>>
-  getNextFileToEmbed(): Promise<Array<string>>
-  getSpline(absoluteFilePath: string): Promise<Array<string>>
-  getHashesForFiles(files: Array<string>): Promise<Array<string>>
   updateRootDirectory(rootDirectory: string): void
 }

package/package.json

@@ -1,15 +1,13 @@
 {
   "name": "@anysphere/file-service",
-  "version": "0.0.0-f2b1ba30",
+  "version": "0.0.0",
   "main": "index.js",
   "types": "index.d.ts",
   "napi": {
     "name": "file_service",
     "triples": {
       "additional": [
-        "aarch64-apple-darwin",
-        "aarch64-pc-windows-msvc",
-        "universal-apple-darwin"
+        "aarch64-apple-darwin"
       ]
     }
   },
@@ -31,15 +29,12 @@
     "prepublishOnly": "napi prepublish -t npm",
     "test": "ava",
     "universal": "napi universal",
-    "preversion": "git config --global user.name || git config --global user.name 'Your Name'; git config --global user.email || git config --global user.email 'youremail@example.com'",
     "version": "napi version"
   },
   "optionalDependencies": {
-    "@anysphere/file-service-win32-x64-msvc": "0.0.0-f2b1ba30",
-    "@anysphere/file-service-darwin-x64": "0.0.0-f2b1ba30",
-    "@anysphere/file-service-linux-x64-gnu": "0.0.0-f2b1ba30",
-    "@anysphere/file-service-darwin-arm64": "0.0.0-f2b1ba30",
-    "@anysphere/file-service-win32-arm64-msvc": "0.0.0-f2b1ba30",
-    "@anysphere/file-service-darwin-universal": "0.0.0-f2b1ba30"
+    "@anysphere/file-service-win32-x64-msvc": "0.0.0",
+    "@anysphere/file-service-darwin-x64": "0.0.0",
+    "@anysphere/file-service-linux-x64-gnu": "0.0.0",
+    "@anysphere/file-service-darwin-arm64": "0.0.0"
   }
 }

package/src/file_utils.rs

@@ -12,15 +12,15 @@ pub fn is_in_bad_dir(file_path: &Path) -> Result<bool, Error> {
   let item_path = file_path
     .to_str()
     .ok_or(anyhow::anyhow!("Failed to convert path to string"))?;
-  let is_bad_dir =
-    item_path.contains("node_modules") || item_path.contains(".git");
+  let is_bad_dir = (item_path.contains("node_modules") || item_path.contains(".git"))
+    && !(item_path.ends_with(".git") || item_path.ends_with("node_modules"));
   Ok(is_bad_dir)
 }
 
 pub fn is_good_file(file_path: &Path) -> Result<(), Error> {
-  let item_path = file_path
-    .to_str()
-    .ok_or(anyhow::anyhow!("Failed to convert path to string"))?;
+  let item_path = file_path.to_str().ok_or(anyhow::anyhow!(
+		"Failed to convert path to string"
+	))?;
 
   let path = Path::new(item_path);
   let file_name = path
@@ -36,24 +36,20 @@ pub fn is_good_file(file_path: &Path) -> Result<(), Error> {
     .ok_or(anyhow::anyhow!("Failed to convert extension to string"))?;
 
   match file_name {
-    "package-lock.json" | "pnpm-lock.yaml" | "yarn.lock" | "composer.lock"
-    | "Gemfile.lock" | "bun.lockb" => {
+    "package-lock.json" | "pnpm-lock.yaml" | "yarn.lock" | "composer.lock" | "Gemfile.lock" => {
       return Err(anyhow::anyhow!("File is just a lock file"));
     }
     _ => {}
   }
 
   match extension {
-    "lock" | "bak" | "tmp" | "bin" | "exe" | "dll" | "so" | "lockb" => {
+    "lock" | "bak" | "tmp" | "bin" | "exe" | "dll" | "so" => {
       return Err(anyhow::anyhow!("File is just a lock file"));
     }
     _ => {}
   }
 
-  if item_path.contains(".git")
-    || item_path.contains(".svn")
-    || item_path.contains(".hg")
-  {
+  if item_path.contains(".git") || item_path.contains(".svn") || item_path.contains(".hg") {
     return Err(anyhow::anyhow!("File is just a lock file"));
   }
 
@@ -64,39 +60,29 @@ pub fn is_good_file(file_path: &Path) -> Result<(), Error> {
         if bad_extensions.contains(&ext_str) {
           return Err(anyhow::anyhow!("File is not a valid UTF-8 string"));
         }
-      }
-      None => {
-        return Err(anyhow::anyhow!("Failed to convert extension to string"))
-      }
+      },
+      None => return Err(anyhow::anyhow!("Failed to convert extension to string")),
     },
     None => return Err(anyhow::anyhow!("Failed to get extension")),
   }
 
-  // #[cfg(not(test))]
-  // {
   let path = Path::new(item_path);
   for part in path.iter() {
     match part.to_str() {
-      Some(s) if s.starts_with(".") => {
-        return Err(anyhow::anyhow!("File is hidden"))
-      }
+      Some(s) if s.starts_with(".") => return Err(anyhow::anyhow!("File is hidden")),
       _ => {}
     }
   }
-  // }
 
   Ok(())
 }
 
 // implement the buffer above:
-pub async fn is_good_file_runtime_check(
-  file_path: &Path,
-  buffer: &[u8],
-) -> Result<(), Error> {
+pub async fn is_good_file_runtime_check(file_path: &Path, buffer: &[u8]) -> Result<(), Error> {
   match get_file_size(file_path).await {
     Ok(size) if size > 2 * 1024 * 1024 => {
       return Err(anyhow::anyhow!("Buffer is too large"));
-    }
+    },
     Err(e) => return Err(e),
     _ => {}
   }
@@ -111,10 +97,7 @@ pub async fn is_good_file_runtime_check(
   Ok(())
 }
 
-pub fn as_relative_path(
-  base_path: &Path,
-  file_path: &Path,
-) -> Result<String, Error> {
+pub fn as_relative_path(base_path: &Path, file_path: &Path) -> Result<String, Error> {
   let relative_path = file_path.strip_prefix(base_path)?;
   Ok(
     relative_path
@@ -134,7 +117,7 @@ pub async fn get_file_size(file_path: &Path) -> Result<u64, Error> {
 mod tests {
   use super::*;
   use std::path::Path;
-  use tokio::io::AsyncWriteExt;
+	use tokio::io::AsyncWriteExt;
 
   #[test]
   fn test_is_in_bad_dir() {
@@ -167,12 +150,7 @@ mod tests {
     let mut temp_file = fs::File::create(&temp_file_path).await.unwrap();
     temp_file.write_all(b"Hello, world!").await.unwrap();
     let buffer = fs::read(&temp_file_path).await.unwrap();
-    assert_eq!(
-      is_good_file_runtime_check(&temp_file_path, &buffer)
-        .await
-        .is_ok(),
-      true
-    );
+    assert_eq!(is_good_file_runtime_check(&temp_file_path, &buffer).await.is_ok(), true);
     temp_dir.close().unwrap();
 
     let temp_dir = tempfile::tempdir().unwrap();
@@ -180,12 +158,7 @@ mod tests {
     let mut temp_file = fs::File::create(&temp_file_path).await.unwrap();
     temp_file.write_all(&[0, 159, 146, 150]).await.unwrap(); // Invalid UTF-8 sequence
     let buffer = fs::read(&temp_file_path).await.unwrap();
-    assert_eq!(
-      is_good_file_runtime_check(&temp_file_path, &buffer)
-        .await
-        .is_err(),
-      true
-    );
+    assert_eq!(is_good_file_runtime_check(&temp_file_path, &buffer).await.is_err(), true);
     temp_dir.close().unwrap();
   }
 
@@ -209,5 +182,6 @@ mod tests {
     let size = get_file_size(&temp_file_path).await.unwrap();
     assert_eq!(size, 13);
     temp_dir.close().unwrap();
+
   }
 }

package/src/git_utils.rs

@@ -1,10 +1,10 @@
 use std::collections::HashSet;
+use std::path::PathBuf;
 use std::process::Command;
 
 pub fn list_ignored_files(
   workspace_root_path: &str,
-  should_return_absolute_paths: bool,
-) -> Result<HashSet<String>, Box<dyn std::error::Error>> {
+) -> Result<HashSet<PathBuf>, Box<dyn std::error::Error>> {
   let mut gitignored_files = HashSet::new();
 
   let commands = vec![
@@ -15,66 +15,12 @@ pub fn list_ignored_files(
       "--ignored",
       "--exclude-standard",
     ],
-    // FIXME(sualeh): this is super sketchy and might totally break in like a bazillion ways. i dont like it.
-    vec![
-      "sh",
-      "-c",
-      "git submodule foreach --quiet 'git ls-files --others --ignored --exclude-standard | sed \"s|^|$path/|\"'",
-    ],
-  ];
-
-  for command in commands {
-    let output = Command::new(&command[0])
-      .args(&command[1..])
-      .current_dir(workspace_root_path)
-      .output()?;
-
-    if output.status.success() {
-      let files = String::from_utf8(output.stdout)?
-        .lines()
-        .filter(|line| !line.is_empty())
-        .map(|line| {
-          if should_return_absolute_paths {
-            let mut path = std::path::PathBuf::from(workspace_root_path);
-            path.push(line);
-
-            match path.canonicalize() {
-              Ok(canonical_path) => {
-                canonical_path.to_string_lossy().into_owned()
-              }
-              Err(_) => String::from(line),
-            }
-          } else {
-            String::from(line)
-          }
-        })
-        .collect::<HashSet<_>>();
-
-      gitignored_files.extend(files);
-    }
-  }
-
-  Ok(gitignored_files)
-}
-
-pub fn list_ignored_files_with_absolute_paths(
-  workspace_root_path: &str,
-) -> Result<HashSet<String>, Box<dyn std::error::Error>> {
-  let mut gitignored_files = HashSet::new();
-
-  let commands = vec![
     vec![
       "git",
-      "ls-files",
-      "--others",
-      "--ignored",
-      "--exclude-standard",
-    ],
-    // FIXME(sualeh): this is super sketchy and might totally break in like a bazillion ways. i dont like it.
-    vec![
-      "sh",
-      "-c",
-      "git submodule foreach --quiet 'git ls-files --others --ignored --exclude-standard | sed \"s|^|$path/|\"'",
+      "submodule",
+      "foreach",
+      "--quiet",
+      "git ls-files --others --ignored --exclude-standard | sed 's|^|$path/|'",
     ],
   ];
 
@@ -88,7 +34,7 @@ pub fn list_ignored_files_with_absolute_paths(
       let files = String::from_utf8(output.stdout)?
         .lines()
         .filter(|line| !line.is_empty())
-        .map(|line| String::from(line))
+        .map(|line| PathBuf::from(line))
         .collect::<HashSet<_>>();
 
       gitignored_files.extend(files);
@@ -111,18 +57,6 @@ pub async fn is_git_ignored(
   Ok(output.status.success())
 }
 
-pub async fn is_git_directory(
-  workspace_root_path: &str,
-) -> Result<bool, anyhow::Error> {
-  let output = tokio::process::Command::new("git")
-    .args(&["rev-parse", "--is-inside-work-tree"])
-    .current_dir(workspace_root_path)
-    .output()
-    .await?;
-
-  Ok(output.status.success())
-}
-
 #[cfg(test)]
 mod tests {
   use super::*;
@@ -132,8 +66,7 @@ mod tests {
   #[test]
   fn test_no_ignored_files() {
     let dir = tempfile::tempdir().unwrap();
-    let gitignored_files =
-      list_ignored_files(dir.path().to_str().unwrap(), false).unwrap();
+    let gitignored_files = list_ignored_files(dir.path().to_str().unwrap()).unwrap();
     Command::new("git")
       .args(&["init"])
       .current_dir(dir.path())
@@ -159,14 +92,13 @@ mod tests {
       .current_dir(dir.path())
       .output()
       .unwrap();
-    let gitignored_files =
-      list_ignored_files(dir.path().to_str().unwrap(), false).unwrap();
+    let gitignored_files = list_ignored_files(dir.path().to_str().unwrap()).unwrap();
     println!(
       "ignored files for test_one_ignored_file: {:?}",
       gitignored_files
     );
     // assert_eq!(gitignored_files.len(), 1);
-    assert!(gitignored_files.contains(&String::from("ignored.txt")));
+    assert!(gitignored_files.contains(&PathBuf::from("ignored.txt")));
   }
 
   #[test]
@@ -189,83 +121,19 @@ mod tests {
       .current_dir(dir.path())
       .output()
       .unwrap();
-    let gitignored_files =
-      list_ignored_files(dir.path().to_str().unwrap(), false).unwrap();
+    let gitignored_files = list_ignored_files(dir.path().to_str().unwrap()).unwrap();
     println!(
       "ignored files for test_multiple_ignored_files: {:?}",
       gitignored_files
     );
     // assert_eq!(gitignored_files.len(), 2);
-    assert!(gitignored_files.contains(&String::from("ignored1.txt")));
-    assert!(gitignored_files.contains(&String::from("ignored2.txt")));
-  }
-
-  #[test]
-  fn test_git_submodule_ignored_files() {
-    let dir = tempfile::tempdir().unwrap();
-    let submodule_path = dir.path().join("submodule");
-    std::fs::create_dir(&submodule_path).unwrap();
-
-    let o = Command::new("git")
-      .args(&["init"])
-      .current_dir(&submodule_path)
-      .output()
-      .unwrap();
-    println!("git init output: {:?}", o);
-
-    let file_path = submodule_path.join("ignored.txt");
-    let mut file = File::create(&file_path).unwrap();
-    writeln!(file, "This is an ignored file.").unwrap();
-
-    let file2 = submodule_path.join("ignored2.txt");
-    let mut file = File::create(&file2).unwrap();
-    writeln!(file, "This is another ignored file.").unwrap();
-
-    let gitignore_path = submodule_path.join(".gitignore");
-    let mut gitignore = File::create(&gitignore_path).unwrap();
-    writeln!(gitignore, "*.txt").unwrap();
-
-    let o = Command::new("git")
-      .args(&["init"])
-      .current_dir(dir.path())
-      .output()
-      .unwrap();
-    println!("git init output: {:?}", o);
-
-    // make a commit in the submodule
-    let o = Command::new("git")
-      .args(&["add", "."])
-      .current_dir(&submodule_path)
-      .output()
-      .unwrap();
-    println!("git add output: {:?}", o);
-    let o = Command::new("git")
-      .args(&["commit", "-m", "initial commit"])
-      .current_dir(&submodule_path)
-      .output()
-      .unwrap();
-    println!("git commit output: {:?}", o);
-
-    let o = Command::new("git")
-      .args(&["submodule", "add", "./submodule"])
-      .current_dir(dir.path())
-      .output()
-      .unwrap();
-    println!("git submodule add output: {:?}", o);
-
-    let gitignored_files =
-      list_ignored_files(dir.path().to_str().unwrap(), false).unwrap();
-    println!(
-      "ignored files for test_git_submodule_ignored_files: {:?}",
-      gitignored_files
-    );
-    assert!(gitignored_files.contains(&String::from("submodule/ignored.txt")));
-    assert!(gitignored_files.contains(&String::from("submodule/ignored2.txt")));
+    assert!(gitignored_files.contains(&PathBuf::from("ignored1.txt")));
+    assert!(gitignored_files.contains(&PathBuf::from("ignored2.txt")));
   }
 
   #[test]
   fn test_multiple_ignored_files_in_current_dir() {
-    let gitignored_files = list_ignored_files(".", false).unwrap();
+    let gitignored_files = list_ignored_files(".").unwrap();
     assert!(gitignored_files.len() > 1);
 
     // print a sample of the ignored files
@@ -279,6 +147,7 @@ mod tests {
     }
   }
 
+
   #[tokio::test]
   async fn test_file_not_ignored() {
     let dir = tempfile::tempdir().unwrap();
@@ -291,10 +160,7 @@ mod tests {
       .current_dir(dir.path())
       .output()
       .unwrap();
-    let is_ignored =
-      is_git_ignored(dir.path().to_str().unwrap(), "not_ignored.txt")
-        .await
-        .unwrap();
+    let is_ignored = is_git_ignored(dir.path().to_str().unwrap(), "not_ignored.txt").await.unwrap();
     assert_eq!(is_ignored, false);
   }
 
@@ -314,10 +180,7 @@ mod tests {
       .current_dir(dir.path())
       .output()
       .unwrap();
-    let is_ignored =
-      is_git_ignored(dir.path().to_str().unwrap(), "ignored.txt")
-        .await
-        .unwrap();
+    let is_ignored = is_git_ignored(dir.path().to_str().unwrap(), "ignored.txt").await.unwrap();
     assert_eq!(is_ignored, true);
   }
 
@@ -337,10 +200,8 @@ mod tests {
       .current_dir(dir.path())
       .output()
       .unwrap();
-    let is_ignored =
-      is_git_ignored(dir.path().to_str().unwrap(), "ignored.txt")
-        .await
-        .unwrap();
+    let is_ignored = is_git_ignored(dir.path().to_str().unwrap(), "ignored.txt").await.unwrap();
     assert_eq!(is_ignored, true);
   }
+
 }