Refactor build system and implement complete renderer system

- Split monolithic build.rs into modular async generators
- Add renderer override system with type-safe dispatch
- Implement command template macro for consistent command definitions
- Add proc-macro crates for command and renderer systems
- Reorganize directory structure for better separation of concerns
- Update documentation to reflect new architecture

7 files changed, 173 insertions, 199 deletions

diff --git a/src/cmds/cmd/status.rs b/src/cmds/cmd/status.rs
index f34dbb8..52f12d0 100644
--- a/src/cmds/cmd/status.rs
+++ b/src/cmds/cmd/status.rs
@@ -1,159 +1,156 @@
 use std::{collections::HashMap, time::SystemTime};
 
-use just_enough_vcs::vcs::{
-    constants::VAULT_HOST_NAME, data::local::workspace_analyzer::ModifiedRelativePathBuf,
-};
-
 use crate::{
+    cmd_output,
     cmds::{
         arg::status::JVStatusArgument,
         collect::status::JVStatusCollect,
         r#in::status::JVStatusInput,
         out::status::{JVStatusOutput, JVStatusWrongModifyReason},
-        renderer::status::JVStatusRenderer,
     },
     systems::cmd::{
-        cmd_system::{JVCommand, JVCommandContext},
+        cmd_system::JVCommandContext,
         errors::{CmdExecuteError, CmdPrepareError},
         workspace_reader::LocalWorkspaceReader,
     },
 };
+use cmd_system_macros::exec;
+use just_enough_vcs::vcs::{
+    constants::VAULT_HOST_NAME, data::local::workspace_analyzer::ModifiedRelativePathBuf,
+};
 
 pub struct JVStatusCommand;
+type Cmd = JVStatusCommand;
+type Arg = JVStatusArgument;
+type In = JVStatusInput;
+type Collect = JVStatusCollect;
 
-impl JVCommand<JVStatusArgument, JVStatusInput, JVStatusCollect, JVStatusOutput, JVStatusRenderer>
-    for JVStatusCommand
-{
-    async fn prepare(
-        _args: &JVStatusArgument,
-        _ctx: &JVCommandContext,
-    ) -> Result<JVStatusInput, CmdPrepareError> {
-        Ok(JVStatusInput)
-    }
+fn help_str() -> String {
+    "".to_string()
+}
 
-    async fn collect(
-        _args: &JVStatusArgument,
-        _ctx: &JVCommandContext,
-    ) -> Result<JVStatusCollect, CmdPrepareError> {
-        // Initialize a reader for the local workspace and a default result structure
-        let mut reader = LocalWorkspaceReader::default();
-        let mut collect = JVStatusCollect::default();
-
-        // Analyze the current status of the local workspace
-        // (detects changes like created, modified, moved, etc.)
-        let analyzed = reader.analyze_local_status().await?;
-
-        // Retrieve the current account (member) ID
-        let account = reader.current_account().await?;
-
-        // Retrieve the name of the current sheet
-        let sheet_name = reader.sheet_name().await?;
-
-        // Is Host Mode
-        let is_host_mode = reader.is_host_mode().await?;
-
-        let cached_sheet = reader.cached_sheet(&sheet_name).await?;
-        let sheet_holder = cached_sheet.holder().cloned().unwrap_or_default();
-        let is_ref_sheet = sheet_holder == VAULT_HOST_NAME;
-
-        // Get Latest file data
-        let latest_file_data = reader.pop_latest_file_data(&account).await?;
-
-        // Get the timestamp of the last update, defaulting to the current time if not available
-        let update_time = reader
-            .latest_info()
-            .await?
-            .update_instant
-            .unwrap_or(SystemTime::now());
-
-        // Record the current system time
-        let now_time = SystemTime::now();
-
-        // Populate the result structure with the gathered data
-        collect.current_account = account;
-        collect.current_sheet = sheet_name;
-        collect.is_host_mode = is_host_mode;
-        collect.in_ref_sheet = is_ref_sheet;
-        collect.analyzed_result = analyzed;
-        collect.update_time = update_time;
-        collect.now_time = now_time;
-        collect.latest_file_data = latest_file_data;
-        Ok(collect)
-    }
+async fn prepare(_args: &Arg, _ctx: &JVCommandContext) -> Result<In, CmdPrepareError> {
+    Ok(JVStatusInput)
+}
 
-    async fn exec(
-        _input: JVStatusInput,
-        collect: JVStatusCollect,
-    ) -> Result<JVStatusOutput, CmdExecuteError> {
-        let mut wrong_modified_items: HashMap<ModifiedRelativePathBuf, JVStatusWrongModifyReason> =
-            HashMap::new();
+async fn collect(_args: &Arg, _ctx: &JVCommandContext) -> Result<Collect, CmdPrepareError> {
+    // Initialize a reader for the local workspace and a default result structure
+    let mut reader = LocalWorkspaceReader::default();
+    let mut collect = JVStatusCollect::default();
+
+    // Analyze the current status of the local workspace
+    // (detects changes like created, modified, moved, etc.)
+    let analyzed = reader.analyze_local_status().await?;
+
+    // Retrieve the current account (member) ID
+    let account = reader.current_account().await?;
+
+    // Retrieve the name of the current sheet
+    let sheet_name = reader.sheet_name().await?;
+
+    // Is Host Mode
+    let is_host_mode = reader.is_host_mode().await?;
+
+    let cached_sheet = reader.cached_sheet(&sheet_name).await?;
+    let sheet_holder = cached_sheet.holder().cloned().unwrap_or_default();
+    let is_ref_sheet = sheet_holder == VAULT_HOST_NAME;
+
+    // Get Latest file data
+    let latest_file_data = reader.pop_latest_file_data(&account).await?;
+
+    // Get the timestamp of the last update, defaulting to the current time if not available
+    let update_time = reader
+        .latest_info()
+        .await?
+        .update_instant
+        .unwrap_or(SystemTime::now());
+
+    // Record the current system time
+    let now_time = SystemTime::now();
+
+    // Populate the result structure with the gathered data
+    collect.current_account = account;
+    collect.current_sheet = sheet_name;
+    collect.is_host_mode = is_host_mode;
+    collect.in_ref_sheet = is_ref_sheet;
+    collect.analyzed_result = analyzed;
+    collect.update_time = update_time;
+    collect.now_time = now_time;
+    collect.latest_file_data = latest_file_data;
+    Ok(collect)
+}
 
-        let latest_file_data = &collect.latest_file_data;
+#[exec]
+async fn exec(
+    _input: In,
+    collect: Collect,
+) -> Result<(Box<dyn std::any::Any + Send + 'static>, String), CmdExecuteError> {
+    let mut wrong_modified_items: HashMap<ModifiedRelativePathBuf, JVStatusWrongModifyReason> =
+        HashMap::new();
+
+    let latest_file_data = &collect.latest_file_data;
+
+    // Calculate whether modifications are correc
+    let modified = &collect.analyzed_result.modified;
+    for item in modified {
+        // Get mapping
+        let Ok(mapping) = collect.local_sheet_data.mapping_data(&item) else {
+            continue;
+        };
 
-        // Calculate whether modifications are correc
-        let modified = &collect.analyzed_result.modified;
-        for item in modified {
-            // Get mapping
-            let Ok(mapping) = collect.local_sheet_data.mapping_data(&item) else {
+        // Check base version
+        {
+            let base_version = mapping.version_when_updated().clone();
+            let Some(latest_version) = latest_file_data
+                .file_version(mapping.mapping_vfid())
+                .cloned()
+            else {
                 continue;
             };
 
-            // Check base version
-            {
-                let base_version = mapping.version_when_updated().clone();
-                let Some(latest_version) = latest_file_data
-                    .file_version(mapping.mapping_vfid())
-                    .cloned()
-                else {
-                    continue;
-                };
-
-                // Base version dismatch
-                if base_version != latest_version {
-                    wrong_modified_items.insert(
-                        item.clone(),
-                        JVStatusWrongModifyReason::BaseVersionMismatch {
-                            base_version,
-                            latest_version,
-                        },
-                    );
-                    continue;
-                }
-            }
-
-            // Check edit right (only check when current is not HOST)
-            if collect.current_account != VAULT_HOST_NAME {
-                let holder = latest_file_data.file_holder(mapping.mapping_vfid());
-                if holder.is_none() {
-                    wrong_modified_items.insert(item.clone(), JVStatusWrongModifyReason::NoHolder);
-                    continue;
-                }
-
-                let holder = holder.cloned().unwrap();
-                if &collect.current_account != &holder {
-                    wrong_modified_items.insert(
-                        item.clone(),
-                        JVStatusWrongModifyReason::ModifiedButNotHeld { holder: holder },
-                    );
-                }
+            // Base version dismatch
+            if base_version != latest_version {
+                wrong_modified_items.insert(
+                    item.clone(),
+                    JVStatusWrongModifyReason::BaseVersionMismatch {
+                        base_version,
+                        latest_version,
+                    },
+                );
+                continue;
             }
         }
 
-        let output = JVStatusOutput {
-            current_account: collect.current_account,
-            current_sheet: collect.current_sheet,
-            is_host_mode: collect.is_host_mode,
-            in_ref_sheet: collect.in_ref_sheet,
-            analyzed_result: collect.analyzed_result,
-            wrong_modified_items: wrong_modified_items,
-            update_time: collect.update_time,
-            now_time: collect.now_time,
-        };
+        // Check edit right (only check when current is not HOST)
+        if collect.current_account != VAULT_HOST_NAME {
+            let holder = latest_file_data.file_holder(mapping.mapping_vfid());
+            if holder.is_none() {
+                wrong_modified_items.insert(item.clone(), JVStatusWrongModifyReason::NoHolder);
+                continue;
+            }
 
-        Ok(output)
+            let holder = holder.cloned().unwrap();
+            if &collect.current_account != &holder {
+                wrong_modified_items.insert(
+                    item.clone(),
+                    JVStatusWrongModifyReason::ModifiedButNotHeld { holder: holder },
+                );
+            }
+        }
     }
 
-    fn get_help_str() -> String {
-        "".to_string()
-    }
+    let output = JVStatusOutput {
+        current_account: collect.current_account,
+        current_sheet: collect.current_sheet,
+        is_host_mode: collect.is_host_mode,
+        in_ref_sheet: collect.in_ref_sheet,
+        analyzed_result: collect.analyzed_result,
+        wrong_modified_items: wrong_modified_items,
+        update_time: collect.update_time,
+        now_time: collect.now_time,
+    };
+
+    cmd_output!(output, JVStatusOutput)
 }
+
+crate::command_template!();
diff --git a/src/cmds/override.rs b/src/cmds/override.rs
new file mode 100644
index 0000000..8cfd458
--- /dev/null
+++ b/src/cmds/override.rs
@@ -0,0 +1 @@
+pub mod renderer;
diff --git a/src/cmds/override/renderer/json.rs b/src/cmds/override/renderer/json.rs
new file mode 100644
index 0000000..b4e69f1
--- /dev/null
+++ b/src/cmds/override/renderer/json.rs
@@ -0,0 +1,17 @@
+use serde::Serialize;
+use serde_json;
+
+use crate::{
+    r_print,
+    systems::{cmd::errors::CmdRenderError, render::renderer::JVRenderResult},
+};
+
+pub async fn render<T: Serialize + Send>(data: &T) -> Result<JVRenderResult, CmdRenderError> {
+    let mut r = JVRenderResult::default();
+    let json_string =
+        serde_json::to_string(data).map_err(|e| CmdRenderError::SerializeFailed(e.to_string()))?;
+
+    r_print!(r, "{}", json_string);
+
+    Ok(r)
+}
diff --git a/src/cmds/override/renderer/json_pretty.rs b/src/cmds/override/renderer/json_pretty.rs
new file mode 100644
index 0000000..3923117
--- /dev/null
+++ b/src/cmds/override/renderer/json_pretty.rs
@@ -0,0 +1,16 @@
+use serde::Serialize;
+
+use crate::{
+    r_print,
+    systems::{cmd::errors::CmdRenderError, render::renderer::JVRenderResult},
+};
+
+pub async fn render<T: Serialize + Send>(data: &T) -> Result<JVRenderResult, CmdRenderError> {
+    let mut r = JVRenderResult::default();
+    let json_string = serde_json::to_string_pretty(data)
+        .map_err(|e| CmdRenderError::SerializeFailed(e.to_string()))?;
+
+    r_print!(r, "{}", json_string);
+
+    Ok(r)
+}
diff --git a/src/cmds/renderer/json.rs b/src/cmds/renderer/json.rs
deleted file mode 100644
index 9a3105d..0000000
--- a/src/cmds/renderer/json.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use serde::Serialize;
-use serde_json;
-
-use crate::{
-    r_print,
-    systems::cmd::{
-        errors::CmdRenderError,
-        renderer::{JVRenderResult, JVResultRenderer},
-    },
-};
-
-pub struct JVResultJsonRenderer;
-
-impl<T> JVResultRenderer<T> for JVResultJsonRenderer
-where
-    T: Serialize + Sync,
-{
-    async fn render(data: &T) -> Result<JVRenderResult, CmdRenderError> {
-        let mut r = JVRenderResult::default();
-        let json_string = serde_json::to_string(data)
-            .map_err(|e| CmdRenderError::SerializeFailed(e.to_string()))?;
-
-        r_print!(r, "{}", json_string);
-
-        Ok(r)
-    }
-}
diff --git a/src/cmds/renderer/json_pretty.rs b/src/cmds/renderer/json_pretty.rs
deleted file mode 100644
index a4a3ba5..0000000
--- a/src/cmds/renderer/json_pretty.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-use serde::Serialize;
-
-use crate::{
-    r_print,
-    systems::cmd::{
-        errors::CmdRenderError,
-        renderer::{JVRenderResult, JVResultRenderer},
-    },
-};
-
-pub struct JVResultPrettyJsonRenderer;
-
-impl<T> JVResultRenderer<T> for JVResultPrettyJsonRenderer
-where
-    T: Serialize + Sync,
-{
-    async fn render(data: &T) -> Result<JVRenderResult, CmdRenderError> {
-        let mut r = JVRenderResult::default();
-        let json_string = serde_json::to_string_pretty(data)
-            .map_err(|e| CmdRenderError::SerializeFailed(e.to_string()))?;
-
-        r_print!(r, "{}", json_string);
-
-        Ok(r)
-    }
-}
diff --git a/src/cmds/renderer/status.rs b/src/cmds/renderer/status.rs
index 965ff87..573e74e 100644
--- a/src/cmds/renderer/status.rs
+++ b/src/cmds/renderer/status.rs
@@ -2,40 +2,36 @@ use cli_utils::{
     display::{SimpleTable, md},
     env::auto_update_outdate,
 };
+use render_system_macros::result_renderer;
 use rust_i18n::t;
 
+use crate::cmds::out::status::JVStatusWrongModifyReason;
 use crate::{
-    cmds::out::status::{JVStatusOutput, JVStatusWrongModifyReason},
+    cmds::out::status::JVStatusOutput,
     r_println,
-    systems::cmd::{
-        errors::CmdRenderError,
-        renderer::{JVRenderResult, JVResultRenderer},
-    },
+    systems::{cmd::errors::CmdRenderError, render::renderer::JVRenderResult},
 };
 
-pub struct JVStatusRenderer;
-
 enum Mode {
     StructuralChangesMode,
     ContentChangesMode,
     Clean,
 }
 
-impl JVResultRenderer<JVStatusOutput> for JVStatusRenderer {
-    async fn render(data: &JVStatusOutput) -> Result<JVRenderResult, CmdRenderError> {
-        let mut r = JVRenderResult::default();
+#[result_renderer(JVStatusRenderer)]
+pub async fn render(data: &JVStatusOutput) -> Result<JVRenderResult, CmdRenderError> {
+    let mut r = JVRenderResult::default();
 
-        // Render Header
-        render_header(&mut r, data);
+    // Render Header
+    render_header(&mut r, data);
 
-        // Render Info and Mode
-        render_info_and_mode(&mut r, data);
+    // Render Info and Mode
+    render_info_and_mode(&mut r, data);
 
-        // Render Hint
-        render_hint(&mut r, data);
+    // Render Hint
+    render_hint(&mut r, data);
 
-        Ok(r)
-    }
+    Ok(r)
 }
 
 fn render_header(r: &mut JVRenderResult, data: &JVStatusOutput) {