? tech

Cargo.toml

@@ -11,10 +11,9 @@ chrono = { version = "0.4.31", features = ["serde"] }
 clap = { version = "4.4.2", features = ["derive"] }
 flate2 = "1.0.28"
 futures = "0.3.30"
-gix = "0.57.1"
+git2 = "0.18.1"
 lazy-regex = "3.1.0"
 pollster = "0.3.0"
-rayon = "1.8.0"
 rbx_binary = "0.7.1"
 rbx_dom_weak = "2.5.0"
 rbx_reflection_database = "0.2.7"

src/main.rs

@@ -6,18 +6,14 @@ use rbx_dom_weak::types::Ref;
 
 type AssetID=u64;
 type AssetIDFileMap=Vec<(AssetID,std::path::PathBuf)>;
-const CONCURRENT_DECODE:usize=8;
 const CONCURRENT_REQUESTS:usize=32;
 
 #[derive(Parser)]
 #[command(author,version,about,long_about=None)]
 #[command(propagate_version = true)]
 struct Cli{
-	//asset options
 	#[arg(short,long)]
 	group:Option<u64>,
-	#[arg(long)]
-	asset_id:Option<AssetID>,
 	//idk how to do this better
 	#[arg(long)]
 	cookie_literal:Option<String>,
@@ -25,24 +21,16 @@ struct Cli{
 	cookie_env:Option<String>,
 	#[arg(long)]
 	cookie_file:Option<std::path::PathBuf>,
-	#[arg(long)]
-	start_version:Option<u64>,
 
-	//decompile options
 	#[arg(long)]
 	no_models:Option<bool>,
 	#[arg(long)]
 	no_scripts:Option<bool>,
 	#[arg(long)]
 	no_template:Option<bool>,
-	#[arg(long)]
-	style:Option<String>,
 
-	//git options
 	#[arg(long)]
-	git_committer_name:Option<String>,
-	#[arg(long)]
-	git_committer_email:Option<String>,
+	asset_id:Option<AssetID>,
 
 	#[arg(short,long)]
 	input:Option<std::path::PathBuf>,
@@ -62,14 +50,6 @@ enum Commands{
 	Compile,
 	Decompile,
 	DecompileHistoryIntoGit,
-	DownloadAndDecompileHistoryIntoGit,
-}
-
-#[derive(Clone,Copy)]
-enum DecompileStyle{
-	Rox,
-	Rojo,
-	RoxRojo,
 }
 
 #[derive(Args)]
@@ -78,14 +58,12 @@ struct PathBufList{
 }
 
 #[derive(serde::Deserialize)]
-#[allow(nonstandard_style,dead_code)]
 struct VersionPage{
 	previousPageCursor:Option<String>,
 	nextPageCursor:Option<String>,
 	data:Vec<AssetVersion>,
 }
 #[derive(serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
 struct AssetVersion{
 	Id:u64,
 	assetId:AssetID,
@@ -119,24 +97,8 @@ async fn main()->AResult<()>{
 		None=>None,
 	};
 
-	let decompile_style=match cli.style.as_deref(){
-		Some("rox")
-		|Some("Rox")=>Some(DecompileStyle::Rox),
-		Some("rojo")
-		|Some("Rojo")=>Some(DecompileStyle::Rojo),
-		Some("rox-rojo")
-		|Some("rojo-rox")
-		|Some("roxrojo")
-		|Some("rojorox")
-		|Some("RoxRojo")
-		|Some("RojoRox")=>Some(DecompileStyle::RoxRojo),
-		None=>None,
-		_=>return Err(anyhow::Error::msg("Invalid style")),
-	};
-
 	match cli.command{
 		Commands::DownloadHistory=>download_history(DownloadHistoryConfig{
-			start_version:cli.start_version.unwrap_or(0),
 			output_folder:cli.output.unwrap(),
 			cookie:cookie.unwrap(),
 			asset_id:cli.asset_id.unwrap(),
@@ -145,30 +107,16 @@ async fn main()->AResult<()>{
 		Commands::Upload=>upload_list(cookie.unwrap(),cli.group,vec![(cli.asset_id.unwrap(),cli.output.unwrap())]).await,
 		Commands::Compile=>compile(cli.input.unwrap(),cli.output.unwrap()),
 		Commands::Decompile=>decompile(DecompileConfig{
-			style:decompile_style.unwrap(),
 			input_file:cli.input.unwrap(),
 			output_folder:cli.output.unwrap(),
 			write_template:!cli.no_template.unwrap_or(false),
 			write_models:!cli.no_models.unwrap_or(false),
 			write_scripts:!cli.no_scripts.unwrap_or(false),
-		}).await,
+		}),
 		Commands::DecompileHistoryIntoGit=>decompile_history_into_git(DecompileHistoryConfig{
-			git_committer_name:cli.git_committer_name.unwrap(),
-			git_committer_email:cli.git_committer_email.unwrap(),
-			input_folder:cli.input.unwrap(),
-			output_folder:cli.output.unwrap(),
-			style:decompile_style.unwrap(),
-			write_template:!cli.no_template.unwrap_or(false),
-			write_models:!cli.no_models.unwrap_or(false),
-			write_scripts:!cli.no_scripts.unwrap_or(false),
-		 }).await,
-		Commands::DownloadAndDecompileHistoryIntoGit=>download_and_decompile_history_into_git(DownloadAndDecompileHistoryConfig{
-			git_committer_name:cli.git_committer_name.unwrap(),
-			git_committer_email:cli.git_committer_email.unwrap(),
 			cookie:cookie.unwrap(),
 			asset_id:cli.asset_id.unwrap(),
 			output_folder:cli.output.unwrap(),
-			style:decompile_style.unwrap(),
 			write_template:!cli.no_template.unwrap_or(false),
 			write_models:!cli.no_models.unwrap_or(false),
 			write_scripts:!cli.no_scripts.unwrap_or(false),
@@ -198,7 +146,7 @@ fn maybe_gzip_decode<R:Read>(input:R)->AResult<ReaderType<R>>{
 
 async fn upload_list(cookie:String,group:Option<u64>,asset_id_file_map:AssetIDFileMap)->AResult<()>{
 	let client=reqwest::Client::new();
-	futures::stream::iter(asset_id_file_map.into_iter()
+	futures::stream::iter(asset_id_file_map)
 	.map(|(asset_id,file)|{
 		let client=&client;
 		let cookie=cookie.as_str();
@@ -236,7 +184,7 @@ async fn upload_list(cookie:String,group:Option<u64>,asset_id_file_map:AssetIDFi
 
 			Ok((asset_id,resp.bytes().await?))
 		}
-	}))
+	})
 	.buffer_unordered(CONCURRENT_REQUESTS)
 	.for_each(|b:AResult<_>|async{
 			match b{
@@ -257,7 +205,7 @@ fn read_readable(mut readable:impl Read)->AResult<Vec<u8>>{
 
 async fn download_list(cookie:String,asset_id_file_map:AssetIDFileMap)->AResult<()>{
 	let client=reqwest::Client::new();
-	futures::stream::iter(asset_id_file_map.into_iter()
+	futures::stream::iter(asset_id_file_map)
 	.map(|(asset_id,file)|{
 		let client=&client;
 		let cookie=cookie.as_str();
@@ -267,7 +215,7 @@ async fn download_list(cookie:String,asset_id_file_map:AssetIDFileMap)->AResult<
 			.send().await?;
 			Ok((file,resp.bytes().await?))
 		}
-	}))
+	})
 	.buffer_unordered(CONCURRENT_REQUESTS)
 	.for_each(|b:AResult<_>|async{
 			match b{
@@ -291,36 +239,36 @@ async fn download_list(cookie:String,asset_id_file_map:AssetIDFileMap)->AResult<
 	Ok(())
 }
 
-async fn download_page(client:&reqwest::Client,cookie:&str,asset_id:AssetID,cursor:Option<String>)->AResult<VersionPage>{
-	let mut url=reqwest::Url::parse(format!("https://develop.roblox.com/v1/assets/{}/saved-versions",asset_id).as_str())?;
-	//url borrow scope
-	{
-		let mut query=url.query_pairs_mut();//borrow here
-		//query.append_pair("sortOrder","Asc");
-		//query.append_pair("limit","100");
-		//query.append_pair("count","100");
-		match cursor.as_deref(){
-			Some(next_page)=>{query.append_pair("cursor",next_page);}
-			None=>(),
-		}
-	}
-	println!("page url={}",url);
-	let resp=client.get(url)
-	.header("Cookie",cookie)
-	.send().await?;
-	Ok(resp.json::<VersionPage>().await?)
-}
-
 async fn get_version_history(client:&reqwest::Client,cookie:&str,asset_id:AssetID)->AResult<Vec<AssetVersion>>{
 	let mut cursor:Option<String>=None;
 	let mut asset_list=Vec::new();
 	loop{
-		let mut page=download_page(client,cookie,asset_id,cursor).await?;
-		asset_list.append(&mut page.data);
-		if page.nextPageCursor.is_none(){
-			break;
+		let mut url=reqwest::Url::parse(format!("https://develop.roblox.com/v1/assets/{}/saved-versions",asset_id).as_str())?;
+		//url borrow scope
+		{
+			let mut query=url.query_pairs_mut();//borrow here
+			//query.append_pair("sortOrder","Asc");
+			//query.append_pair("limit","100");
+			//query.append_pair("count","100");
+			match &cursor{
+				Some(next_page)=>{query.append_pair("cursor",next_page);}
+				None=>(),
+			}
+		}
+		println!("page url={}",url);
+		let resp=client.get(url)
+		.header("Cookie",cookie)
+		.send().await?;
+		match resp.json::<VersionPage>().await{
+			Ok(mut page)=>{
+				asset_list.append(&mut page.data);
+				if page.nextPageCursor.is_none(){
+					break;
+				}
+				cursor=page.nextPageCursor;
+			},
+			Err(e)=>panic!("error: {}",e),
 		}
-		cursor=page.nextPageCursor;
 	}
 	asset_list.sort_by(|a,b|a.assetVersionNumber.cmp(&b.assetVersionNumber));
 	Ok(asset_list)
@@ -351,7 +299,6 @@ async fn download_asset_version(client:&reqwest::Client,cookie:&str,asset_id_str
 }
 
 struct DownloadHistoryConfig{
-	start_version:u64,
 	output_folder:std::path::PathBuf,
 	cookie:String,
 	asset_id:AssetID,
@@ -360,68 +307,45 @@ struct DownloadHistoryConfig{
 async fn download_history(config:DownloadHistoryConfig)->AResult<()>{
 	let client=reqwest::Client::new();
 
-	let asset_id_string=config.asset_id.to_string();
-
-	//limit concurrent downloads
-	let mut join_set=tokio::task::JoinSet::new();
-
 	//poll paged list of all asset versions
-	let mut cursor:Option<String>=None;
-	let mut asset_list=Vec::new();
-	loop{
-		let mut page=download_page(&client,config.cookie.as_str(),config.asset_id,cursor).await?;
-		let mut cancel_paging=false;
-		for asset_version in &page.data{
-			let version_number=asset_version.assetVersionNumber;
-			if version_number<config.start_version{
-				cancel_paging=true;
-				continue;//don't trust roblox returned order
-			}
-			while CONCURRENT_REQUESTS<=join_set.len(){
-				join_set.join_next().await.unwrap()??;
-			}
-			let client=client.clone();
-			let cookie=config.cookie.clone();
-			let asset_id_str=asset_id_string.clone();
-			let output_folder=config.output_folder.clone();
-			join_set.spawn(async move{
-				let resp=download_asset_version(&client,cookie.as_str(),asset_id_str.as_str(),version_number.to_string().as_str()).await?;
-				let contents=match maybe_gzip_decode(std::io::Cursor::new(resp.bytes().await?))?{
-					ReaderType::GZip(readable)=>read_readable(readable)?,
-					ReaderType::Raw(readable)=>read_readable(readable)?,
-				};
-
-				let mut path=output_folder;
-				path.set_file_name(format!("{}_v{}.rbxl",config.asset_id,version_number));
-
-				tokio::fs::write(path,contents).await?;
-
-				Ok::<_,anyhow::Error>(())
-			});
-		}
-		if page.nextPageCursor.is_none()||cancel_paging{
-			for asset_version in page.data.into_iter(){
-				if config.start_version<=asset_version.assetVersionNumber{
-					asset_list.push(asset_version);
-				}
-			}
-			break;
-		}else{
-			asset_list.append(&mut page.data);
-		}
-		cursor=page.nextPageCursor;
-	}
-
-	asset_list.sort_by(|a,b|a.assetVersionNumber.cmp(&b.assetVersionNumber));
-
+	let asset_list=get_version_history(&client,&config.cookie.as_str(),config.asset_id).await?;
 	let mut path=config.output_folder.clone();
 	path.set_file_name("versions.json");
 	tokio::fs::write(path,serde_json::to_string(&asset_list)?).await?;
 
-	while let Some(result)=join_set.join_next().await{
-		result??;
-	}
+	//download all versions
+	let asset_id_string=config.asset_id.to_string();
+	futures::stream::iter(asset_list)
+	.map(|asset_version|{
+		let client=&client;
+		let cookie=config.cookie.as_str();
+		let asset_id_str=asset_id_string.as_str();
+		let output_folder=config.output_folder.clone();
+		async move{
+			let resp=download_asset_version(client,cookie,asset_id_str,asset_version.assetVersionNumber.to_string().as_str()).await?;
+			let contents=match maybe_gzip_decode(std::io::Cursor::new(resp.bytes().await?))?{
+				ReaderType::GZip(readable)=>read_readable(readable)?,
+				ReaderType::Raw(readable)=>read_readable(readable)?,
+			};
 
+			let mut path=output_folder;
+			path.set_file_name(format!("{}_v{}.rbxl",config.asset_id,asset_version.assetVersionNumber));
+
+			Ok((path,contents))
+		}
+	})
+	.buffer_unordered(CONCURRENT_REQUESTS)
+	.for_each(|b:AResult<_>|async{
+			match b{
+				Ok((dest,data))=>{
+					match tokio::fs::write(dest,data).await{
+						Err(e)=>eprintln!("fs error: {}",e),
+						_=>(),
+					}
+				},
+				Err(e)=>eprintln!("dl error: {}",e),
+			}
+		}).await;
 	Ok(())
 }
 
@@ -481,77 +405,36 @@ enum WriteStackInstruction<'a>{
 	Destroy(Ref),
 }
 
-#[derive(Default)]
+#[derive(Default,serde::Deserialize,serde::Serialize)]
 struct PropertiesOverride{
-	name:Option<String>,
-	class_name:Option<String>,
+	//Name:Option<String>,
+	ClassName:Option<String>,
 }
 impl PropertiesOverride{
 	fn is_some(&self)->bool{
-		self.name.is_some()
-		||self.class_name.is_some()
+		self.ClassName.is_some()
 	}
 }
-impl std::fmt::Display for PropertiesOverride{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		if let Some(name)=self.name.as_deref(){
-			writeln!(f,"--! Properties.Name=\"{}\"",name)?;
-		}
-		if let Some(class_name)=self.class_name.as_deref(){
-			writeln!(f,"--! Properties.ClassName=\"{}\"",class_name)?;
-		}
-		Ok(())
-    }
-}
 
 fn sanitize<'a>(s:&'a str)->std::borrow::Cow<'a,str>{
 	lazy_regex::regex!(r"[^a-zA-Z0-9._-]").replace_all(s,"_")
 }
 
-fn write_item(dom:&rbx_dom_weak::WeakDom,mut file:std::path::PathBuf,node:&TreeNode,node_name_override:String,mut properties:PropertiesOverride,style:DecompileStyle,write_models:bool,write_scripts:bool)->AResult<()>{
-	file.push(sanitize(node_name_override.as_str()).as_ref());
+fn write_item(dom:&rbx_dom_weak::WeakDom,mut file:std::path::PathBuf,node:&TreeNode,node_name_override:&str,write_models:bool,write_scripts:bool)->AResult<()>{
+	file.push(sanitize(node_name_override).as_ref());
 	match node.class{
 		Class::Folder=>(),
 		Class::ModuleScript|Class::LocalScript|Class::Script=>{
 			if !write_scripts{
 				return Ok(())
 			}
-
-			//set extension
-			match style{
-				DecompileStyle::Rox=>assert!(file.set_extension("lua"),"could not set extension"),
-				DecompileStyle::RoxRojo|DecompileStyle::Rojo=>{
-					match properties.class_name.as_deref(){
-						Some("LocalScript")=>{
-							file.set_extension("client.lua");
-							properties.class_name=None;
-						},
-						Some("Script")=>{
-							file.set_extension("server.lua");
-							properties.class_name=None;
-						},
-						// Some("ModuleScript")=>{
-						// 	file.set_extension("module");
-						// 	properties.class_name=None;
-						// },
-						None=>assert!(file.set_extension("lua"),"could not set extension"),
-						Some(other)=>return Err(anyhow::Error::msg(format!("Attempt to write a {} as a script",other))),
-					}
-				}
-			}
-
-			if let Some(item)=dom.get_by_ref(node.referent){
+			assert!(file.set_extension("lua"),"could not set extension");
+			assert!(dom.get_by_ref(node.referent).is_some_and(|item|{
 				//TODO: delete disabled scripts
 				if let Some(rbx_dom_weak::types::Variant::String(source))=item.properties.get("Source"){
-					if properties.is_some(){
-						//rox style
-						let source=properties.to_string()+source.as_str();
-						std::fs::write(file,source)?;
-					}else{
-						std::fs::write(file,source)?;
-					}
-				}
-			}
+					std::fs::write(file,source).is_ok()
+				}else{false}
+			}),"no string property or file failed to write");
 		},
 		Class::Model=>{
 			if !write_models{
@@ -668,17 +551,13 @@ fn generate_decompiled_context<R:Read>(input:R)->AResult<DecompiledContext>{
 }
 
 struct WriteConfig{
-	style:DecompileStyle,
 	output_folder:std::path::PathBuf,
 	write_template:bool,
 	write_models:bool,
 	write_scripts:bool,
 }
 
-async fn write_files(config:WriteConfig,mut context:DecompiledContext)->AResult<()>{
-	let mut write_queue=Vec::new();
-	let mut destroy_queue=Vec::new();
-
+fn write_files(config:WriteConfig,mut context:DecompiledContext)->AResult<()>{
 	let mut name_tally=std::collections::HashMap::<String,u32>::new();
 	let mut folder=config.output_folder.clone();
 	let mut stack=vec![WriteStackInstruction::Node(context.tree_refs.get(&context.dom.root_ref()).unwrap(),0)];
@@ -686,43 +565,46 @@ async fn write_files(config:WriteConfig,mut context:DecompiledContext)->AResult<
 		match instruction{
 			WriteStackInstruction::PushFolder(component)=>folder.push(component),
 			WriteStackInstruction::PopFolder=>assert!(folder.pop(),"weirdness"),
-			WriteStackInstruction::Destroy(referent)=>destroy_queue.push(referent),
+			WriteStackInstruction::Destroy(referent)=>context.dom.destroy(referent),
 			WriteStackInstruction::Node(node,name_count)=>{
-				//track properties that must be overriden to compile folder structure back into a place file
+				//properties.json to override class or other simple properties
 				let mut properties=PropertiesOverride::default();
 				let has_children=node.children.len()!=0;
 				match node.class{
 					Class::Folder=>(),
-					Class::ModuleScript=>(),//.lua files are ModuleScript by default
-					Class::LocalScript=>properties.class_name=Some("LocalScript".to_string()),
-					Class::Script=>properties.class_name=Some("Script".to_string()),
+					Class::ModuleScript=>{
+						//.lua files are ModuleScript by default
+						if has_children{
+							properties.ClassName=Some("ModuleScript".to_string())
+						}
+					},
+					Class::LocalScript=>properties.ClassName=Some("LocalScript".to_string()),
+					Class::Script=>properties.ClassName=Some("Script".to_string()),
 					Class::Model=>(),
 				}
 				let name_override=if 0<name_count{
-					properties.name=Some(node.name.clone());
 					format!("{}_{}",node.name,name_count)
 				}else{
 					node.name.clone()
 				};
-
-				if has_children{
+				if has_children||properties.is_some(){
 					//push temp subfolder
 					let mut subfolder=folder.clone();
 					subfolder.push(sanitize(name_override.as_str()).as_ref());
 					//make folder
-					tokio::fs::create_dir(subfolder.clone()).await?;
-
-					let name_final=match config.style{
-						DecompileStyle::Rox
-						|DecompileStyle::RoxRojo=>name_override.clone(),
-						DecompileStyle::Rojo=>"init".to_owned(),
-					};
-
+					std::fs::create_dir(subfolder.clone())?;
+					//write properties
+					if properties.is_some(){
+						let mut file=subfolder.clone();
+						file.push("properties");
+						assert!(file.set_extension("json"),"could not set extension");
+						std::fs::write(file,serde_json::to_string(&properties)?)?
+					}
 					//write item in subfolder
-					write_queue.push((subfolder,node,name_final,properties,config.style));
+					write_item(&context.dom,subfolder,node,name_override.as_str(),config.write_models,config.write_scripts)?;
 				}else{
 					//write item
-					write_queue.push((folder.clone(),node,name_override.clone(),properties,config.style));
+					write_item(&context.dom,folder.clone(),node,name_override.as_str(),config.write_models,config.write_scripts)?;
 				}
 				//queue item to be deleted from dom after child objects are handled (stack is popped from the back)
 				match node.class{
@@ -744,24 +626,6 @@ async fn write_files(config:WriteConfig,mut context:DecompiledContext)->AResult<
 		}
 	}
 
-	//run the async
-	{
-		let dom=&context.dom;
-		let write_models=config.write_models;
-		let write_scripts=config.write_scripts;
-		let results:Vec<AResult<()>>=rayon::iter::ParallelIterator::collect(rayon::iter::ParallelIterator::map(rayon::iter::IntoParallelIterator::into_par_iter(write_queue),|(write_path,node,node_name_override,properties,style)|{
-			write_item(&dom,write_path,node,node_name_override,properties,style,write_models,write_scripts)
-		}));
-		for result in results{
-			result?;
-		}
-	}
-
-	//run the destroy
-	for destroy_ref in destroy_queue{
-		context.dom.destroy(destroy_ref);
-	}
-
 	//write what remains in template.rbxlx
 	if config.write_template{
 		let mut file=config.output_folder.clone();
@@ -775,7 +639,6 @@ async fn write_files(config:WriteConfig,mut context:DecompiledContext)->AResult<
 }
 
 struct DecompileConfig{
-	style:DecompileStyle,
 	input_file:std::path::PathBuf,
 	output_folder:std::path::PathBuf,
 	write_template:bool,
@@ -783,7 +646,7 @@ struct DecompileConfig{
 	write_scripts:bool,
 }
 
-async fn decompile(config:DecompileConfig)->AResult<()>{
+fn decompile(config:DecompileConfig)->AResult<()>{
 	//rules:
 	//Class Script|LocalScript|ModuleScript->$Name.lua
 	//Class Model->$Name.rbxmx
@@ -796,40 +659,33 @@ async fn decompile(config:DecompileConfig)->AResult<()>{
 	//generate folders, models, and scripts
 	//delete models and scripts from dom
 	write_files(WriteConfig{
-		style:config.style,
 		output_folder:config.output_folder,
 		write_template:config.write_template,
 		write_models:config.write_models,
 		write_scripts:config.write_scripts,
-	},context).await?;
+	},context)?;
 
 	Ok(())
 }
 
 struct WriteCommitConfig{
-	git_committer_name:String,
-	git_committer_email:String,
 	output_folder:std::path::PathBuf,
-	style:DecompileStyle,
 	write_template:bool,
 	write_models:bool,
 	write_scripts:bool,
 }
 
-async fn write_commit(config:WriteCommitConfig,b:Result<AResult<(AssetVersion,DecompiledContext)>,tokio::task::JoinError>,repo:&gix::Repository)->AResult<()>{
-	let (asset_version,context)=b??;
-	println!("writing files for version {}",asset_version.assetVersionNumber);
+fn write_commit(config:WriteCommitConfig,b:AResult<(AssetVersion,DecompiledContext)>,repo:&git2::Repository)->AResult<()>{
+	let (asset_version,context)=b?;
 
 	//clean output dir
-	if config.write_models||config.write_scripts{
+	{
 		let mut src=config.output_folder.clone();
 		src.push("src");
 		match std::fs::remove_dir_all(src){
 			Ok(())=>(),
 			Err(e)=>println!("remove_dir_all src failed {}",e),
 		}
-	}
-	if config.write_template{
 		let mut template=config.output_folder.clone();
 		template.push("template.rbxlx");
 		match std::fs::remove_file(template){
@@ -840,72 +696,48 @@ async fn write_commit(config:WriteCommitConfig,b:Result<AResult<(AssetVersion,De
 
 	//write files
 	write_files(WriteConfig{
-		style:config.style,
 		output_folder:config.output_folder.clone(),
 		write_template:config.write_template,
 		write_models:config.write_models,
 		write_scripts:config.write_scripts,
-	},context).await?;
+	},context)?;
 
-	let sig=gix::actor::Signature{
-		name:config.git_committer_name.into(),
-		email:config.git_committer_email.into(),
-		time:gix::date::Time::new(asset_version.created.timestamp(),0),
-	};
+
+	let date=asset_version.created;
+	let sig=git2::Signature::new("roblox-git-history","git_history@strafes.net",&git2::Time::new(date.timestamp(),0)).unwrap();
 	let tree_id={
-		let mut tree = repo.index()?;
-		tree.index()?.
-		tree.peel_to_entry(path);
-		tree_index.add_all([config.output_folder.as_path()].iter(),gix::IndexAddOption::DEFAULT,None)?;
-		if tree_index.len()==0{
-			println!("tree_index.len()==0");
-			return Ok(());
-		}else{
-			tree_index.update_all([config.output_folder.as_path()].iter(),None)?;
-		}
-		tree_index.write()?;
+		let mut tree_index = repo.index()?;
+		tree_index.add_all([config.output_folder].iter(),git2::IndexAddOption::DEFAULT,None)?;
 		tree_index.write_tree()?
 	};
-	let tree=repo.tree(tree_id)?;
+	let tree=repo.find_tree(tree_id)?;
 
-	let mut parents=Vec::new();
-
-	match repo.head_commit(){
-		Ok(commit)=>{
-			//test tree against commit tree to see if there is any changes
-			let commit_tree=commit.tree()?;
-			let diff=repo.diff_resource_cache(Some(&commit_tree),Some(&tree),None)?;
-			if diff.deltas().count()==0{
-				println!("no changes");
-				return Ok(());
-			}
-
-			parents.push(commit.id());
-		},
-		//If the repo head is not found, great, continue and make the first commit
-		Err(gix::reference::head_commit::Error::Head(gix::reference::find::existing::Error::NotFound))=>(),
-		//for other errors
-		Err(e)=>Err(e)?,
+	match repo.head(){
+		Ok(reference)=>repo.commit(
+			Some("HEAD"),//update_ref
+			&sig,//author
+			&sig,//commiter
+			&format!("v{}", asset_version.assetVersionNumber),//message
+			&tree,//tree (basically files)
+			&[&reference.peel_to_commit()?],//parents
+		)?,
+		Err(_)=>repo.commit(
+			Some("HEAD"),//update_ref
+			&sig,//author
+			&sig,//commiter
+			&format!("v{}", asset_version.assetVersionNumber),//message
+			&tree,//tree (basically files)
+			&[],//parents
+		)?,
 	};
 
-	repo.commit_as(
-		&sig,//commiter
-		&sig,//author
-		"HEAD",
-		&format!("v{}",asset_version.assetVersionNumber),//message
-		&tree,//tree (basically files)
-		parents,//parents
-	)?;
-
 	//commit
 	Ok(())
 }
 
 struct DecompileHistoryConfig{
-	git_committer_name:String,
-	git_committer_email:String,
-	input_folder:std::path::PathBuf,
-	style:DecompileStyle,
+	cookie:String,
+	asset_id:AssetID,
 	output_folder:std::path::PathBuf,
 	write_template:bool,
 	write_models:bool,
@@ -913,103 +745,38 @@ struct DecompileHistoryConfig{
 }
 
 async fn decompile_history_into_git(config:DecompileHistoryConfig)->AResult<()>{
-	//poll paged list of all asset versions
-	let mut versions_path=config.input_folder.clone();
-	versions_path.push("versions.json");
-	let asset_list:Vec<AssetVersion>=serde_json::from_reader(std::fs::File::open(versions_path)?)?;
-
-	let repo=gix::discover(gix::create::into(
-		config.output_folder.as_path(),
-		gix::create::Kind::Bare,
-		gix::create::Options{
-			destination_must_be_empty:true,
-			fs_capabilities:None
-		}
-	)?)?;
-
-	//decompile all versions
-	futures::stream::iter(asset_list.into_iter()
-	.map(|asset_version|{
-		let mut file_path=config.input_folder.clone();
-		tokio::task::spawn_blocking(move||{
-			file_path.push(format!("{}_v{}.rbxl",asset_version.assetId,asset_version.assetVersionNumber));
-			let file=std::fs::File::open(file_path)?;
-			let contents=generate_decompiled_context(file)?;
-			Ok::<_,anyhow::Error>((asset_version,contents))
-		})
-	}))
-	.buffered(CONCURRENT_DECODE)
-	.for_each(|join_handle_result|async{
-		match write_commit(WriteCommitConfig{
-			git_committer_name:config.git_committer_name.clone(),
-			git_committer_email:config.git_committer_email.clone(),
-			style:config.style,
-			output_folder:config.output_folder.clone(),
-			write_template:config.write_template,
-			write_models:config.write_models,
-			write_scripts:config.write_scripts,
-		},join_handle_result,&repo).await{
-			Ok(())=>(),
-			Err(e)=>println!("download/unzip/decompile/write/commit error: {}",e),
-		}
-	}).await;
-	Ok(())
-}
-
-struct DownloadAndDecompileHistoryConfig{
-	cookie:String,
-	asset_id:AssetID,
-	git_committer_name:String,
-	git_committer_email:String,
-	style:DecompileStyle,
-	output_folder:std::path::PathBuf,
-	write_template:bool,
-	write_models:bool,
-	write_scripts:bool,
-}
-
-async fn download_and_decompile_history_into_git(config:DownloadAndDecompileHistoryConfig)->AResult<()>{
 	let client=reqwest::Client::new();
 
 	//poll paged list of all asset versions
 	let asset_list=get_version_history(&client,&config.cookie.as_str(),config.asset_id).await?;
 
-	let repo=gix::discover(gix::create::into(
-		config.output_folder.as_path(),
-		gix::create::Kind::Bare,
-		gix::create::Options{
-			destination_must_be_empty:true,
-			fs_capabilities:None
-		}
-	)?)?;
+	let repo=git2::Repository::init(config.output_folder.clone())?;
 
 	//download all versions
 	let asset_id_string=config.asset_id.to_string();
-	futures::stream::iter(asset_list.into_iter()
+	futures::stream::iter(asset_list)
 	.map(|asset_version|{
-		let client=client.clone();
-		let cookie=config.cookie.clone();
-		let asset_id_str=asset_id_string.clone();
-		tokio::task::spawn(async move{
-			let resp=download_asset_version(&client,cookie.as_str(),asset_id_str.as_str(),asset_version.assetVersionNumber.to_string().as_str()).await?;
+		let client=&client;
+		let cookie=config.cookie.as_str();
+		let asset_id_str=asset_id_string.as_str();
+		async move{
+			let resp=download_asset_version(client,cookie,asset_id_str,asset_version.assetVersionNumber.to_string().as_str()).await?;
 			let contents=match maybe_gzip_decode(std::io::Cursor::new(resp.bytes().await?))?{
 				ReaderType::GZip(readable)=>generate_decompiled_context(readable)?,
 				ReaderType::Raw(readable)=>generate_decompiled_context(readable)?,
 			};
-			Ok::<_,anyhow::Error>((asset_version,contents))
-		})
-	}))
-	.buffered(CONCURRENT_DECODE)
-	.for_each(|join_handle_result|async{
+
+			Ok((asset_version,contents))
+		}
+	})
+	.buffered(CONCURRENT_REQUESTS)
+	.for_each(|b:AResult<_>|async{
 		match write_commit(WriteCommitConfig{
-			style:config.style,
-			git_committer_name:config.git_committer_name.clone(),
-			git_committer_email:config.git_committer_email.clone(),
 			output_folder:config.output_folder.clone(),
 			write_template:config.write_template,
 			write_models:config.write_models,
 			write_scripts:config.write_scripts,
-		},join_handle_result,&repo).await{
+		},b,&repo){
 			Ok(())=>(),
 			Err(e)=>println!("download/unzip/decompile/write/commit error: {}",e),
 		}