gitoxide not ready yet

Cargo.toml

@@ -11,8 +11,10 @@ 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"
 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

@@ -1,4 +1,4 @@
-use std::io::{Read,Seek};
+use std::io::Read;
 use clap::{Args,Parser,Subcommand};
 use anyhow::Result as AResult;
 use futures::StreamExt;
@@ -6,14 +6,18 @@ 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>,
@@ -21,16 +25,24 @@ 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)]
-	asset_id:Option<AssetID>,
+	style:Option<String>,
+
+	//git options
+	#[arg(long)]
+	git_committer_name:Option<String>,
+	#[arg(long)]
+	git_committer_email:Option<String>,
 
 	#[arg(short,long)]
 	input:Option<std::path::PathBuf>,
@@ -49,6 +61,15 @@ enum Commands{
 	Upload,
 	Compile,
 	Decompile,
+	DecompileHistoryIntoGit,
+	DownloadAndDecompileHistoryIntoGit,
+}
+
+#[derive(Clone,Copy)]
+enum DecompileStyle{
+	Rox,
+	Rojo,
+	RoxRojo,
 }
 
 #[derive(Args)]
@@ -57,12 +78,14 @@ 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,
@@ -96,8 +119,24 @@ 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(),
@@ -106,12 +145,34 @@ 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),
+		 }).await,
 	}
 }
 
@@ -121,26 +182,23 @@ enum Cookie{
 	File(std::path::PathBuf),
 }
 
-enum ReaderType<'a,R:Read+Seek>{
-	GZip(flate2::read::GzDecoder<&'a mut R>),
-	Raw(&'a mut R),
+enum ReaderType<R:Read>{
+	GZip(flate2::read::GzDecoder<std::io::BufReader<R>>),
+	Raw(std::io::BufReader<R>),
 }
 
-fn maybe_gzip_decode<R:Read+Seek>(input:&mut R)->AResult<ReaderType<R>>{
-	let mut first_2=[0u8;2];
-	if let (Ok(()),Ok(()))=(std::io::Read::read_exact(input,&mut first_2),std::io::Seek::rewind(input)){
-		match &first_2{
-			b"\x1f\x8b"=>Ok(ReaderType::GZip(flate2::read::GzDecoder::new(input))),
-			_=>Ok(ReaderType::Raw(input)),
-		}
-	}else{
-		Err(anyhow::Error::msg("failed to peek"))
+fn maybe_gzip_decode<R:Read>(input:R)->AResult<ReaderType<R>>{
+	let mut buf=std::io::BufReader::new(input);
+	let peek=std::io::BufRead::fill_buf(&mut buf)?;
+	match &peek[0..2]{
+		b"\x1f\x8b"=>Ok(ReaderType::GZip(flate2::read::GzDecoder::new(buf))),
+		_=>Ok(ReaderType::Raw(buf)),
 	}
 }
 
 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)
+	futures::stream::iter(asset_id_file_map.into_iter()
 	.map(|(asset_id,file)|{
 		let client=&client;
 		let cookie=cookie.as_str();
@@ -178,7 +236,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{
@@ -199,7 +257,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)
+	futures::stream::iter(asset_id_file_map.into_iter()
 	.map(|(asset_id,file)|{
 		let client=&client;
 		let cookie=cookie.as_str();
@@ -209,7 +267,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{
@@ -233,7 +291,67 @@ 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;
+		}
+		cursor=page.nextPageCursor;
+	}
+	asset_list.sort_by(|a,b|a.assetVersionNumber.cmp(&b.assetVersionNumber));
+	Ok(asset_list)
+}
+
+async fn download_asset_version(client:&reqwest::Client,cookie:&str,asset_id_str:&str,asset_version_str:&str)->AResult<reqwest::Response>{
+	let mut url=reqwest::Url::parse("https://assetdelivery.roblox.com/v1/asset/")?;
+	//url borrow scope
+	{
+		let mut query=url.query_pairs_mut();//borrow here
+		query.append_pair("ID",asset_id_str);
+		query.append_pair("version",asset_version_str);
+	}
+	println!("download url={}",url);
+	for i in 0..8{
+		let resp=client.get(url.clone())
+		.header("Cookie",cookie)
+		.send().await?;
+
+		if !resp.status().is_success(){
+			println!("request {} failed",i);
+			continue;
+		}
+
+		return Ok(resp);
+	}
+	Err(anyhow::Error::msg("all requests failed"))
+}
+
 struct DownloadHistoryConfig{
+	start_version:u64,
 	output_folder:std::path::PathBuf,
 	cookie:String,
 	asset_id:AssetID,
@@ -241,117 +359,84 @@ 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 url=reqwest::Url::parse(format!("https://develop.roblox.com/v1/assets/{}/saved-versions",config.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=>(),
+		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>(())
+			});
 		}
-		println!("page url={}",url);
-		let resp=client.get(url)
-		.header("Cookie",config.cookie.clone())
-		.send().await?;
-		match resp.json::<VersionPage>().await{
-			Ok(mut page)=>{
-				asset_list.append(&mut page.data);
-				if page.nextPageCursor.is_none(){
-					break;
+		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);
 				}
-				cursor=page.nextPageCursor;
-			},
-			Err(e)=>panic!("error: {}",e),
+			}
+			break;
+		}else{
+			asset_list.append(&mut page.data);
 		}
+		cursor=page.nextPageCursor;
 	}
+
 	asset_list.sort_by(|a,b|a.assetVersionNumber.cmp(&b.assetVersionNumber));
+
 	let mut path=config.output_folder.clone();
 	path.set_file_name("versions.json");
 	tokio::fs::write(path,serde_json::to_string(&asset_list)?).await?;
 
-	//download all versions
-	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 mut url=reqwest::Url::parse("https://assetdelivery.roblox.com/v1/asset/")?;
-			//url borrow scope
-			{
-				let mut query=url.query_pairs_mut();//borrow here
-				query.append_pair("ID",asset_id_str);
-				query.append_pair("version",asset_version.assetVersionNumber.to_string().as_str());
-			}
-			println!("download url={}",url);
-			let mut result=Err(anyhow::Error::msg("all requests failed"));
-			for i in 1..=8{
-				let resp=client.get(url.clone())
-				.header("Cookie",cookie)
-				.send().await?;
+	while let Some(result)=join_set.join_next().await{
+		result??;
+	}
 
-				if !resp.status().is_success(){
-					println!("request {} failed",i);
-					continue;
-				}
-
-				let mut path=output_folder;
-				path.set_file_name(format!("{}_v{}.rbxl",config.asset_id,asset_version.assetVersionNumber));
-				result=Ok((path,resp.bytes().await?));
-				break;
-			}
-			result
-		}
-	})
-	.buffer_unordered(CONCURRENT_REQUESTS)
-	.for_each(|b:AResult<_>|async{
-			match b{
-				Ok((dest,body))=>{
-					let contents=match maybe_gzip_decode(&mut std::io::Cursor::new(body)){
-						Ok(ReaderType::GZip(readable))=>read_readable(readable),
-						Ok(ReaderType::Raw(readable))=>read_readable(readable),
-						Err(e)=>Err(e),
-					};
-					match contents{
-						Ok(data)=>match tokio::fs::write(dest,data).await{
-							Err(e)=>eprintln!("fs error: {}",e),
-							_=>(),
-						},
-						Err(e)=>eprintln!("gzip error: {}",e),
-					};
-				},
-				Err(e)=>eprintln!("dl error: {}",e),
-			}
-		}).await;
 	Ok(())
 }
 
-fn load_dom<R:Read+Seek>(input:&mut R)->AResult<rbx_dom_weak::WeakDom>{
-	let mut first_8=[0u8;8];
-	if let (Ok(()),Ok(()))=(std::io::Read::read_exact(input, &mut first_8),std::io::Seek::rewind(input)){
-		match &first_8[0..4]{
-			b"<rob"=>{
-				match &first_8[4..8]{
-					b"lox!"=>return rbx_binary::from_reader(input).map_err(anyhow::Error::msg),
-					b"lox "=>return rbx_xml::from_reader(input,rbx_xml::DecodeOptions::default()).map_err(anyhow::Error::msg),
-					other=>Err(anyhow::Error::msg(format!("Unknown Roblox file type {:?}",other))),
-				}
-			},
-			_=>Err(anyhow::Error::msg("unsupported file type")),
-		}
-	}else{
-		Err(anyhow::Error::msg("peek failed"))
+fn load_dom<R:Read>(input:R)->AResult<rbx_dom_weak::WeakDom>{
+	let mut buf=std::io::BufReader::new(input);
+	let peek=std::io::BufRead::fill_buf(&mut buf)?;
+	match &peek[0..4]{
+		b"<rob"=>{
+			match &peek[4..8]{
+				b"lox!"=>return rbx_binary::from_reader(buf).map_err(anyhow::Error::msg),
+				b"lox "=>return rbx_xml::from_reader_default(buf).map_err(anyhow::Error::msg),
+				other=>Err(anyhow::Error::msg(format!("Unknown Roblox file type {:?}",other))),
+			}
+		},
+		_=>Err(anyhow::Error::msg("unsupported file type")),
 	}
 }
 
@@ -396,36 +481,77 @@ enum WriteStackInstruction<'a>{
 	Destroy(Ref),
 }
 
-#[derive(Default,serde::Deserialize,serde::Serialize)]
+#[derive(Default)]
 struct PropertiesOverride{
-	//Name:Option<String>,
-	ClassName:Option<String>,
+	name:Option<String>,
+	class_name:Option<String>,
 }
 impl PropertiesOverride{
 	fn is_some(&self)->bool{
-		self.ClassName.is_some()
+		self.name.is_some()
+		||self.class_name.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:&str,write_models:bool,write_scripts:bool)->AResult<()>{
-	file.push(sanitize(node_name_override).as_ref());
+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());
 	match node.class{
 		Class::Folder=>(),
 		Class::ModuleScript|Class::LocalScript|Class::Script=>{
 			if !write_scripts{
 				return Ok(())
 			}
-			assert!(file.set_extension("lua"),"could not set extension");
-			assert!(dom.get_by_ref(node.referent).is_some_and(|item|{
+
+			//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){
 				//TODO: delete disabled scripts
 				if let Some(rbx_dom_weak::types::Variant::String(source))=item.properties.get("Source"){
-					std::fs::write(file,source).is_ok()
-				}else{false}
-			}),"no string property or file failed to write");
+					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)?;
+					}
+				}
+			}
 		},
 		Class::Model=>{
 			if !write_models{
@@ -439,24 +565,13 @@ fn write_item(dom:&rbx_dom_weak::WeakDom,mut file:std::path::PathBuf,node:&TreeN
 	Ok(())
 }
 
-struct DecompileConfig{
-	input_file:std::path::PathBuf,
-	output_folder:std::path::PathBuf,
-	write_template:bool,
-	write_models:bool,
-	write_scripts:bool,
+struct DecompiledContext{
+	dom:rbx_dom_weak::WeakDom,
+	tree_refs:std::collections::HashMap<rbx_dom_weak::types::Ref,TreeNode>,
 }
 
-fn decompile(config:DecompileConfig)->AResult<()>{
-	//rules:
-	//Class Script|LocalScript|ModuleScript->$Name.lua
-	//Class Model->$Name.rbxmx
-	//overrides.json per-folder [Override{name,class}]
-	//Everything else goes into template.rbxlx
-
-	//read file
-	let mut input=std::io::BufReader::new(std::fs::File::open(config.input_file)?);
-	let mut dom=load_dom(&mut input)?;
+fn generate_decompiled_context<R:Read>(input:R)->AResult<DecompiledContext>{
+	let dom=load_dom(input)?;
 
 	let mut tree_refs=std::collections::HashMap::new();
 	tree_refs.insert(dom.root_ref(),TreeNode::new(
@@ -546,56 +661,68 @@ fn decompile(config:DecompileConfig)->AResult<()>{
 		}
 	}
 
-	//generate folders, models, and scripts
-	//delete models and scripts from dom
+	Ok(DecompiledContext{
+		dom,
+		tree_refs,
+	})
+}
+
+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();
 
 	let mut name_tally=std::collections::HashMap::<String,u32>::new();
 	let mut folder=config.output_folder.clone();
-	let mut stack=vec![WriteStackInstruction::Node(tree_refs.get(&dom.root_ref()).unwrap(),0)];
+	let mut stack=vec![WriteStackInstruction::Node(context.tree_refs.get(&context.dom.root_ref()).unwrap(),0)];
 	while let Some(instruction)=stack.pop(){
 		match instruction{
 			WriteStackInstruction::PushFolder(component)=>folder.push(component),
 			WriteStackInstruction::PopFolder=>assert!(folder.pop(),"weirdness"),
-			WriteStackInstruction::Destroy(referent)=>dom.destroy(referent),
+			WriteStackInstruction::Destroy(referent)=>destroy_queue.push(referent),
 			WriteStackInstruction::Node(node,name_count)=>{
-				//properties.json to override class or other simple properties
+				//track properties that must be overriden to compile folder structure back into a place file
 				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
-						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::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::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||properties.is_some(){
+
+				if has_children{
 					//push temp subfolder
 					let mut subfolder=folder.clone();
 					subfolder.push(sanitize(name_override.as_str()).as_ref());
 					//make folder
-					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)?)?
-					}
+					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(),
+					};
+
 					//write item in subfolder
-					write_item(&dom,subfolder,node,name_override.as_str(),config.write_models,config.write_scripts)?;
+					write_queue.push((subfolder,node,name_final,properties,config.style));
 				}else{
 					//write item
-					write_item(&dom,folder.clone(),node,name_override.as_str(),config.write_models,config.write_scripts)?;
+					write_queue.push((folder.clone(),node,name_override.clone(),properties,config.style));
 				}
 				//queue item to be deleted from dom after child objects are handled (stack is popped from the back)
 				match node.class{
@@ -606,7 +733,7 @@ fn decompile(config:DecompileConfig)->AResult<()>{
 					stack.push(WriteStackInstruction::PopFolder);
 					name_tally.clear();
 					for referent in &node.children{
-						if let Some(c)=tree_refs.get(referent){
+						if let Some(c)=context.tree_refs.get(referent){
 							let v=name_tally.entry(c.name.clone()).and_modify(|v|*v+=1).or_default();
 							stack.push(WriteStackInstruction::Node(c,*v));
 						}
@@ -617,18 +744,279 @@ fn decompile(config:DecompileConfig)->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();
 		file.push("template");
 		assert!(file.set_extension("rbxlx"));
 		let output=std::io::BufWriter::new(std::fs::File::create(file)?);
-		rbx_xml::to_writer_default(output,&dom,&[dom.root_ref()])?;
+		rbx_xml::to_writer_default(output,&context.dom,&[context.dom.root_ref()])?;
 	}
 
 	Ok(())
 }
 
+struct DecompileConfig{
+	style:DecompileStyle,
+	input_file:std::path::PathBuf,
+	output_folder:std::path::PathBuf,
+	write_template:bool,
+	write_models:bool,
+	write_scripts:bool,
+}
+
+async fn decompile(config:DecompileConfig)->AResult<()>{
+	//rules:
+	//Class Script|LocalScript|ModuleScript->$Name.lua
+	//Class Model->$Name.rbxmx
+	//overrides.json per-folder [Override{name,class}]
+	//Everything else goes into template.rbxlx
+
+	//read file
+	let context=generate_decompiled_context(std::io::BufReader::new(std::fs::File::open(config.input_file)?))?;
+
+	//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?;
+
+	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);
+
+	//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){
+			Ok(())=>(),
+			Err(e)=>println!("remove_file template.rbxlx failed {}",e),
+		}
+	}
+
+	//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?;
+
+	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 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()?;
+		tree_index.write_tree()?
+	};
+	let tree=repo.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)?,
+	};
+
+	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,
+	output_folder:std::path::PathBuf,
+	write_template:bool,
+	write_models:bool,
+	write_scripts:bool,
+}
+
+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
+		}
+	)?)?;
+
+	//download all versions
+	let asset_id_string=config.asset_id.to_string();
+	futures::stream::iter(asset_list.into_iter()
+	.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 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{
+		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{
+			Ok(())=>(),
+			Err(e)=>println!("download/unzip/decompile/write/commit error: {}",e),
+		}
+	}).await;
+	Ok(())
+}
+
 fn compile(_folder:std::path::PathBuf,_file:std::path::PathBuf)->AResult<()>{
 	Ok(())
 }