feat(cli): setup skeleton for quartz tool

Cargo.toml

@@ -3,6 +3,7 @@ resolver = "2"
 members = [
     "apps/mtcs/enclave",
     "apps/transfers/enclave",
+    "cli",
     "core/light-client-proofs/*",
     "core/quartz",
     "cosmwasm/packages/*",

cli/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "quartz"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+keywords = ["blockchain", "cosmos", "tendermint", "cycles", "quartz"]
+readme = "README.md"
+
+[dependencies]
+clap.workspace = true
+color-eyre.workspace = true
+displaydoc.workspace = true
+serde.workspace = true
+thiserror.workspace = true
+tracing.workspace = true
+tracing-subscriber = { workspace = true, features = ["env-filter"] }

cli/README.md

@@ -0,0 +1,77 @@
+# quartz CLI
+
+A CLI tool to manage Quartz applications. The `quartz` CLI tool is designed to streamline the development and deployment
+process of Quartz applications.
+
+It provides helpful information about each command and its options. To get a list of all available subcommands and their
+descriptions, use the `--help` flag:
+
+```shell
+$ quartz --help
+
+Quartz 0.1.0
+A CLI tool to manage Quartz applications
+
+USAGE:
+    quartz [SUBCOMMAND]
+
+OPTIONS:
+    -h, --help       Print help information
+    -V, --version    Print version information
+
+SUBCOMMANDS:
+    init        Create base Quartz app directory from template
+    build       Build the contract and enclave binaries
+    start       Configure Gramine, sign, and start the enclave binary
+    deploy      Deploy the WASM binary to the blockchain and call instantiate
+    run         Run the enclave handler, and expose a public query server for users
+    handshake   Run the handshake between the contract and enclave
+```
+
+## Installation
+
+To install Quartz, ensure you have Rust and Cargo installed. Then run:
+
+```shell
+cargo install quartz
+```
+
+## Usage of subcommands
+
+### Init
+
+Initialize a new Quartz app directory structure with optional name and path arguments.
+
+#### Usage
+
+```shell
+$ quartz init --help
+quartz-init 
+Create base Quartz app directory from template
+
+USAGE:
+    quartz init [OPTIONS]
+
+OPTIONS:
+    -n, --name <NAME>    Set the name of the Quartz app [default: <name of parent directory>]
+    -p, --path <PATH>    Set the path where the Quartz app will be created [default: .]
+    -h, --help           Print help information
+```
+
+#### Example
+
+```shell
+quartz init --name <app_name> --path <path>
+```
+
+This command will create the following directory structure at the specified path (or the current directory if no path is
+provided):
+
+```shell
+$ tree /<path>/<app-name> -L 1
+apps/transfers/
+├── contracts/
+├── enclave/
+├── frontend/
+└── README.md
+```

cli/src/cli.rs

@@ -0,0 +1,42 @@
+use std::path::PathBuf;
+
+use clap::{Parser, Subcommand};
+use tracing::metadata::LevelFilter;
+
+#[derive(clap::Args, Debug, Clone)]
+pub struct Verbosity {
+    /// Increase verbosity, can be repeated up to 2 times
+    #[arg(long, short, action = clap::ArgAction::Count)]
+    pub verbose: u8,
+}
+
+impl Verbosity {
+    pub fn to_level_filter(&self) -> LevelFilter {
+        match self.verbose {
+            0 => LevelFilter::INFO,
+            1 => LevelFilter::DEBUG,
+            _ => LevelFilter::TRACE,
+        }
+    }
+}
+
+#[derive(Debug, Parser)]
+#[command(version, long_about = None)]
+pub struct Cli {
+    /// Increase log verbosity
+    #[clap(flatten)]
+    pub verbose: Verbosity,
+
+    /// Main command
+    #[command(subcommand)]
+    pub command: Command,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum Command {
+    Init {
+        /// path to create & init a quartz app, defaults to current path if unspecified
+        #[clap(long)]
+        path: Option<PathBuf>,
+    },
+}

cli/src/error.rs

@@ -0,0 +1,8 @@
+use displaydoc::Display;
+use thiserror::Error;
+
+#[derive(Debug, Display, Error)]
+pub enum Error {
+    /// specified path `{0}` is not a directory
+    PathNotDir(String),
+}

cli/src/handler.rs

@@ -0,0 +1,22 @@
+use crate::{cli::Verbosity, error::Error, request::Request, response::Response};
+
+pub mod init;
+
+pub trait Handler {
+    type Error;
+    type Response;
+
+    fn handle(self, verbosity: Verbosity) -> Result<Self::Response, Self::Error>;
+}
+
+impl Handler for Request {
+    type Error = Error;
+    type Response = Response;
+
+    fn handle(self, verbosity: Verbosity) -> Result<Self::Response, Self::Error> {
+        match self {
+            Request::Init(request) => request.handle(verbosity),
+        }
+        .map(Into::into)
+    }
+}

cli/src/handler/init.rs

@@ -0,0 +1,16 @@
+use tracing::trace;
+
+use crate::{
+    cli::Verbosity, error::Error, handler::Handler, request::init::InitRequest,
+    response::init::InitResponse,
+};
+
+impl Handler for InitRequest {
+    type Error = Error;
+    type Response = InitResponse;
+
+    fn handle(self, _verbosity: Verbosity) -> Result<Self::Response, Self::Error> {
+        trace!("initializing directory structure...");
+        todo!()
+    }
+}

cli/src/main.rs

@@ -0,0 +1,48 @@
+#![doc = include_str!("../README.md")]
+#![forbid(unsafe_code)]
+#![warn(
+    clippy::checked_conversions,
+    clippy::panic,
+    clippy::panic_in_result_fn,
+    clippy::unwrap_used,
+    trivial_casts,
+    trivial_numeric_casts,
+    rust_2018_idioms,
+    unused_lifetimes,
+    unused_import_braces,
+    unused_qualifications
+)]
+
+pub mod cli;
+pub mod error;
+pub mod handler;
+pub mod request;
+pub mod response;
+
+use clap::Parser;
+use color_eyre::eyre::Result;
+use tracing_subscriber::{util::SubscriberInitExt, EnvFilter};
+
+use crate::{cli::Cli, handler::Handler, request::Request};
+
+fn main() -> Result<()> {
+    color_eyre::install()?;
+
+    let args = Cli::parse();
+
+    let env_filter = EnvFilter::builder()
+        .with_default_directive(args.verbose.to_level_filter().into())
+        .from_env_lossy();
+
+    tracing_subscriber::fmt()
+        .with_target(false)
+        .with_writer(std::io::stderr)
+        .with_env_filter(env_filter)
+        .finish()
+        .init();
+
+    let request = Request::try_from(args.command)?;
+    request.handle(args.verbose)?;
+
+    Ok(())
+}

cli/src/request.rs

@@ -0,0 +1,19 @@
+use crate::{cli::Command, error::Error, request::init::InitRequest};
+
+pub mod init;
+
+#[derive(Clone, Debug)]
+pub enum Request {
+    Init(InitRequest),
+}
+
+impl TryFrom<Command> for Request {
+    type Error = Error;
+
+    fn try_from(cmd: Command) -> Result<Self, Self::Error> {
+        match cmd {
+            Command::Init { path } => InitRequest::try_from(path),
+        }
+        .map(Into::into)
+    }
+}

cli/src/request/init.rs

@@ -0,0 +1,30 @@
+use std::path::PathBuf;
+
+use crate::{error::Error, request::Request};
+
+#[derive(Clone, Debug)]
+pub struct InitRequest {
+    // TODO(hu55a1n1): remove `allow(unused)` here once init handler is implemented
+    #[allow(unused)]
+    directory: PathBuf,
+}
+
+impl TryFrom<Option<PathBuf>> for InitRequest {
+    type Error = Error;
+
+    fn try_from(path: Option<PathBuf>) -> Result<Self, Self::Error> {
+        if let Some(path) = path {
+            if !path.is_dir() {
+                return Err(Error::PathNotDir(format!("{}", path.display())));
+            }
+        }
+
+        todo!()
+    }
+}
+
+impl From<InitRequest> for Request {
+    fn from(request: InitRequest) -> Self {
+        Self::Init(request)
+    }
+}

cli/src/response.rs

@@ -0,0 +1,10 @@
+use serde::Serialize;
+
+use crate::response::init::InitResponse;
+
+pub mod init;
+
+#[derive(Clone, Debug, Serialize)]
+pub enum Response {
+    Init(InitResponse),
+}

cli/src/response/init.rs

@@ -0,0 +1,12 @@
+use serde::Serialize;
+
+use crate::response::Response;
+
+#[derive(Clone, Debug, Serialize)]
+pub struct InitResponse;
+
+impl From<InitResponse> for Response {
+    fn from(response: InitResponse) -> Self {
+        Self::Init(response)
+    }
+}