feat: rename projects to point to github/kjuulh/dagger-sdk

crates/dagger-bootstrap/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "dagger-bootstrap"
+version = "0.2.10"
+edition = "2021"
+readme = "README.md"
+license-file = "LICENSE.MIT"
+description = "A dagger sdk for rust, written in rust"
+repository = "https://github.com/kjuulh/dagger-sdk"
+publish = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+dagger-core = { workspace = true }
+dagger-codegen = { workspace = true }
+
+eyre = { workspace = true }
+color-eyre = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+tokio = { workspace = true }
+
+clap = "4.1.6"
+dirs = "4.0.0"
+flate2 = { version = "1.0.25", features = ["zlib"] }
+graphql-introspection-query = "0.2.0"
+graphql_client = { version = "0.12.0", features = ["reqwest"] }
+hex = "0.4.3"
+hex-literal = "0.3.4"
+platform-info = "1.0.2"
+reqwest = { version = "0.11.14", features = ["stream", "deflate"] }
+sha2 = "0.10.6"
+tar = "0.4.38"
+tempfile = "3.3.0"

crates/dagger-bootstrap/src/cli.rs

@@ -0,0 +1,26 @@
+use crate::cli_generate;
+
+pub struct Cli {
+    cmd: clap::Command,
+}
+
+impl Cli {
+    pub fn new() -> eyre::Result<Self> {
+        Ok(Self {
+            cmd: clap::Command::new("dagger-rust")
+                .subcommand_required(true)
+                .subcommand(cli_generate::GenerateCommand::new_cmd()),
+        })
+    }
+
+    pub async fn execute(self, args: &[&str]) -> eyre::Result<()> {
+        let matches = self.cmd.get_matches_from(args);
+
+        match matches.subcommand() {
+            Some(("generate", args)) => cli_generate::GenerateCommand::exec(args).await?,
+            _ => eyre::bail!("command missing"),
+        }
+
+        Ok(())
+    }
+}

crates/dagger-bootstrap/src/cli_generate.rs

@@ -0,0 +1,40 @@
+use std::io::Write;
+use std::sync::Arc;
+
+use clap::{Arg, ArgMatches};
+use dagger_codegen::generate;
+use dagger_codegen::rust::RustGenerator;
+use dagger_core::config::Config;
+use dagger_core::engine::Engine;
+use dagger_core::session::Session;
+
+#[allow(dead_code)]
+pub struct GenerateCommand;
+
+#[allow(dead_code)]
+impl GenerateCommand {
+    pub fn new_cmd() -> clap::Command {
+        clap::Command::new("generate").arg(Arg::new("output").long("output"))
+    }
+
+    pub async fn exec(arg_matches: &ArgMatches) -> eyre::Result<()> {
+        let cfg = Config::default();
+        let (conn, _proc) = Engine::new().start(&cfg).await?;
+        let session = Session::new();
+        let req = session.start(&cfg, &conn)?;
+        let schema = session.schema(req).await?;
+        let code = generate(
+            schema.into_schema().schema.unwrap(),
+            Arc::new(RustGenerator {}),
+        )?;
+
+        if let Some(output) = arg_matches.get_one::<String>("output") {
+            let mut file = std::fs::File::create(output)?;
+            file.write(code.as_bytes())?;
+        } else {
+            println!("{}", code);
+        }
+
+        Ok(())
+    }
+}

crates/dagger-bootstrap/src/main.rs

@@ -0,0 +1,17 @@
+use cli::Cli;
+
+pub mod cli;
+mod cli_generate;
+
+#[tokio::main]
+async fn main() -> eyre::Result<()> {
+    color_eyre::install().unwrap();
+
+    let args = std::env::args();
+    let args = args.collect::<Vec<String>>();
+    let args = args.iter().map(|s| s.as_str()).collect::<Vec<&str>>();
+
+    Cli::new()?.execute(args.as_slice()).await?;
+
+    Ok(())
+}