chore: Config Updates ( TOML / JSON / YAML ) (#205)

* chore: Moving config from JSON to YAML

Signed-off-by: Lucas Fontes <lucas@cosmonic.com>

* Config cleanup

Signed-off-by: Lucas Fontes <lucas@cosmonic.com>

* tests

Signed-off-by: Lucas Fontes <lucas@cosmonic.com>

* lint

Signed-off-by: Lucas Fontes <lucas@cosmonic.com>

* fixing test

Signed-off-by: Lucas Fontes <lucas@cosmonic.com>

* moves project directory to -C

Signed-off-by: Lucas Fontes <lucas@cosmonic.com>

---------

Signed-off-by: Lucas Fontes <lucas@cosmonic.com>

Author: lxfontes

.wash/config.json

@@ -0,0 +1 @@
+version: 2.0.0-rc.5

.wash/config.yaml

@@ -41,7 +41,7 @@ clap-markdown = { workspace = true }
 ctrlc = { workspace = true }
 dialoguer = { workspace = true, features = ["editor", "password", "zeroize", "fuzzy-select", "fuzzy-matcher"] }
 etcetera = { workspace = true }
-figment = { workspace = true, features = ["json", "env"] }
+figment = { workspace = true, features = ["json", "env", "yaml", "toml"] }
 flate2 = { workspace = true, features = ["rust_backend"] }
 humantime = { workspace = true }
 indicatif = { workspace = true }
@@ -50,6 +50,7 @@ reqwest = { workspace = true, features = ["json", "rustls-tls"] }
 semver = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true, features = ["std"] }
+serde_yaml_ng = { workspace = true }
 tar = { workspace = true }
 tempfile = { workspace = true }
 tokio = { workspace = true, features = ["full"] }
@@ -119,6 +120,7 @@ names = { version = "0.14", default-features = false }
 semver = { version = "1.0.26", default-features = false }
 serde = { version = "1.0.219", default-features = false }
 serde_json = { version = "1.0.140", default-features = false }
+serde_yaml_ng = { version = "0.9", default-features = false }
 sha2 = { version = "0.10.8", default-features = false }
 sysinfo = { version = "0.32", default-features = false, features = ["system"] }
 tar = { version = "0.4", default-features = false }

Cargo.lock

@@ -14,26 +14,18 @@ use std::io::IsTerminal;
 use tokio::{fs, process::Command};
 use tracing::{debug, error, info, instrument, trace, warn};
 
-use crate::component_build::ProjectType;
 use crate::plugin::bindings::wasmcloud::wash::types::HookType;
 use crate::wit::WitConfig;
 use crate::{
     cli::{CliCommand, CliContext, CommandOutput},
-    config::{Config, generate_project_config, load_config, save_config},
+    config::{Config, generate_project_config, save_config},
     wit::{CommonPackageArgs, WkgFetcher, load_lock_file},
 };
+use crate::{component_build::ProjectType, config::local_config_path};
 
 /// CLI command for building components
 #[derive(Debug, Clone, Args, Serialize)]
 pub struct ComponentBuildCommand {
-    /// Path to the project directory
-    #[clap(name = "project-path", default_value = ".")]
-    project_path: PathBuf,
-
-    /// Path to a configuration file in a location other than PROJECT_DIR/.wash/config.json
-    #[clap(name = "config", long = "config")]
-    build_config: Option<PathBuf>,
-
     /// The expected path to the built Wasm component artifact
     #[clap(long = "component-path")]
     component_path: Option<PathBuf>,
@@ -57,7 +49,7 @@ impl CliCommand for ComponentBuildCommand {
     #[instrument(level = "debug", skip(self, ctx), name = "component_build")]
     async fn handle(&self, ctx: &CliContext) -> anyhow::Result<CommandOutput> {
         // Load configuration with CLI arguments override
-        let mut config = load_config(&ctx.config_path(), Some(&self.project_path), None::<Config>)?;
+        let mut config = ctx.load_config(None::<Config>)?;
         // Ensure the CLI argument takes precedence
         if let Some(wit) = config.wit.as_mut() {
             wit.skip_fetch = self.skip_fetch;
@@ -67,7 +59,7 @@ impl CliCommand for ComponentBuildCommand {
                 ..Default::default()
             })
         }
-        let result = build_component(&self.project_path, ctx, &config, Some(&self.args)).await?;
+        let result = build_component(ctx.project_dir(), ctx, &config, Some(&self.args)).await?;
 
         Ok(CommandOutput::ok(
             format!(
@@ -77,7 +69,7 @@ impl CliCommand for ComponentBuildCommand {
             Some(serde_json::json!({
                 "component_path": result.component_path,
                 "project_type": result.project_type,
-                "project_path": self.project_path,
+                "project_path": result.project_path,
             })),
         ))
     }
@@ -744,7 +736,7 @@ impl ComponentBuilder {
 
             // Add WIT world - this is required for TinyGo builds when WIT is present
             let Some(wit_world) = &tinygo_config.wit_world else {
-                // Generate project config to ensure .wash/config.json exists with placeholder
+                // Generate project config to ensure .wash/config.yaml exists with placeholder
                 let mut config_with_placeholder = config.clone();
                 let component_path_relative = PathBuf::from("build/output.wasm");
 
@@ -764,11 +756,7 @@ impl ComponentBuilder {
                 }
 
                 // Write config with placeholder
-                let config_dir = self.project_path.join(".wash");
-                let config_path = config_dir.join("config.json");
-                tokio::fs::create_dir_all(&config_dir)
-                    .await
-                    .context("failed to create .wash directory")?;
+                let config_path = local_config_path(&self.project_path);
                 save_config(&config_with_placeholder, &config_path).await?;
 
                 bail!(

Cargo.toml

@@ -4,7 +4,7 @@ use tracing::instrument;
 
 use crate::{
     cli::{CliCommand, CliContext, CommandOutput},
-    config::{generate_default_config, local_config_path},
+    config::{Config, generate_default_config, load_config, local_config_path},
 };
 
 /// Create a new component project from a template, git repository, or local path
@@ -33,11 +33,9 @@ impl CliCommand for ConfigCommand {
         match self {
             ConfigCommand::Init { force, global } => {
                 let config_path = if *global {
-                    ctx.config_path()
+                    ctx.user_config_path()
                 } else {
-                    local_config_path(
-                        &std::env::current_dir().context("failed to get current dir")?,
-                    )
+                    local_config_path(ctx.project_dir())
                 };
 
                 generate_default_config(&config_path, *force)
@@ -48,6 +46,7 @@ impl CliCommand for ConfigCommand {
                     "Configuration initialized successfully.".to_string(),
                     Some(serde_json::json!({
                         "message": "Configuration initialized successfully.",
+                        "config_path": config_path.display().to_string(),
                         "success": true,
                     })),
                 ))
@@ -56,29 +55,41 @@ impl CliCommand for ConfigCommand {
                 let version = env!("CARGO_PKG_VERSION");
                 let data_dir = ctx.data_dir().display().to_string();
                 let cache_dir = ctx.cache_dir().display().to_string();
-                let config_dir = ctx.config_dir().display().to_string();
-                let config_path = ctx.config_path().display().to_string();
+                let user_config_dir = ctx.config_dir().display().to_string();
+                let user_config_path = ctx.user_config_path().display().to_string();
+                let project_path = ctx.project_dir();
+                let project_config_path = ctx.project_config_path().display().to_string();
 
                 Ok(CommandOutput::ok(
                     format!(
-                        "wash version: {version}\nData directory: {data_dir}\nCache directory: {cache_dir}\nConfig directory: {config_dir}\nConfig path: {config_path}"
+                        r"
+wash version: {version}
+Data directory: {data_dir}
+Cache directory: {cache_dir}
+User Config directory: {user_config_dir}
+User Config path: {user_config_path}
+Project Config path: {project_config_path}
+                        "
                     ),
                     Some(serde_json::json!({
                         "version": version,
                         "data_dir": data_dir,
                         "cache_dir": cache_dir,
-                        "config_dir": config_dir,
-                        "config_path": config_path,
+                        "user_config_dir": user_config_dir,
+                        "user_config_path": user_config_path,
+                        "project_path": project_path,
+                        "project_config_path": project_config_path,
                     })),
                 ))
             }
             ConfigCommand::Show {} => {
-                let config = ctx
-                    .ensure_config(None)
-                    .await
-                    .context("failed to load config")?;
+                let config = load_config(
+                    &ctx.user_config_path(),
+                    Some(ctx.project_dir()),
+                    None::<Config>,
+                )?;
                 Ok(CommandOutput::ok(
-                    serde_json::to_string_pretty(&config).context("failed to serialize config")?,
+                    serde_yaml_ng::to_string(&config).context("failed to serialize config")?,
                     Some(serde_json::to_value(&config).context("failed to serialize config")?),
                 ))
             }

crates/wash/src/cli/component_build.rs

@@ -43,10 +43,6 @@ use crate::{
 
 #[derive(Debug, Clone, Args)]
 pub struct DevCommand {
-    /// The path to the project directory
-    #[clap(name = "project-dir", default_value = ".")]
-    pub project_dir: PathBuf,
-
     /// The path to the built Wasm file to be used in development
     #[clap(long = "component-path")]
     pub component_path: Option<PathBuf>,
@@ -84,11 +80,12 @@ pub struct DevCommand {
 
 impl CliCommand for DevCommand {
     async fn handle(&self, ctx: &CliContext) -> anyhow::Result<CommandOutput> {
-        info!(path = ?self.project_dir, "starting development session for project");
+        let project_dir = ctx.project_dir();
+        info!(path = ?project_dir, "starting development session for project");
 
         let config = load_config(
-            &ctx.config_path(),
-            Some(self.project_dir.as_path()),
+            &ctx.user_config_path(),
+            Some(project_dir),
             // Override the component path with the one provided in the command line
             Some(Config {
                 build: Some(BuildConfig {
@@ -100,20 +97,8 @@ impl CliCommand for DevCommand {
         )
         .context("failed to load config for development")?;
 
-        // Validate project directory
-        ensure!(
-            self.project_dir.exists(),
-            "Project directory does not exist: {}",
-            self.project_dir.display()
-        );
-        ensure!(
-            self.project_dir.is_dir(),
-            "Project path is not a directory: {}",
-            self.project_dir.display()
-        );
-
         // Check for required tools (e.g., wasmCloud, WIT)
-        let project_context = detect_project_context(&self.project_dir)
+        let project_context = detect_project_context(project_dir)
             .await
             .context("failed to detect project context")?;
         let (issues, recommendations) = check_project_specific_tools(&project_context)
@@ -137,7 +122,7 @@ impl CliCommand for DevCommand {
             debug!("no recommendations found for project tools");
         }
 
-        let component_path = match build_component(&self.project_dir, ctx, &config, None).await {
+        let component_path = match build_component(project_dir, ctx, &config, None).await {
             // Edge case where the build was successful, but the component path in the config is different
             // than the one returned by the build process.
             Ok(build_result)
@@ -282,14 +267,15 @@ impl CliCommand for DevCommand {
         let mut last_build_time = SystemTime::now();
 
         // Canonicalize project root once to ensure consistent path comparisons
-        let canonical_project_root = self.project_dir.canonicalize().with_context(|| {
+        // It should be already canonicalized, but just in case
+        let canonical_project_root = project_dir.canonicalize().with_context(|| {
             format!(
                 "failed to canonicalize project directory: {}",
-                self.project_dir.display()
+                project_dir.display()
             )
         })?;
         debug!(
-            original = ?self.project_dir.display(),
+            original = ?project_dir.display(),
             canonical = ?canonical_project_root.display(),
             "canonicalized project root for file watching"
         );
@@ -312,7 +298,7 @@ impl CliCommand for DevCommand {
         let ignore_paths_notify = ignore_paths.clone();
 
         let canonical_project_root_notify = canonical_project_root.clone();
-        debug!(path = ?self.project_dir.display(), "setting up watcher");
+        debug!(path = ?project_dir.display(), "setting up watcher");
 
         // Watch for changes and rebuild/deploy as needed
         let mut watcher = notify::recommended_watcher(move |res: _| match res {
@@ -386,7 +372,7 @@ impl CliCommand for DevCommand {
                     info!("rebuilding component after file changed ...");
 
                     // Check if WIT-related files have changed since the last build
-                    let wit_changed = wit_files_changed(&self.project_dir, last_build_time);
+                    let wit_changed = wit_files_changed(project_dir, last_build_time);
 
                     // Create a modified config with skip_fetch set based on WIT file changes
                     let mut rebuild_config = config.clone();
@@ -405,7 +391,7 @@ impl CliCommand for DevCommand {
                     }
 
                     let rebuild_result = build_component(
-                        &self.project_dir,
+                        project_dir,
                         ctx,
                         &rebuild_config,
                         None,