Merge branch 'master'

Author: dmitryro

daemon/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2024"
 [dependencies]
 config = "0.15.8"
 daemonize = "0.5.0"
+serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140" # Aligned with models and lib
 uuid = { version = "1.3.1", features = ["serde", "v4", "v1", "rng"] } # Aligned with models and security
 prost = "0.13.0" # Latest stable based on crates.io search on 2025-07-01
@@ -23,6 +24,9 @@ prctl = "1.0.0"
 proctitle = "0.1.1"
 users = "0.11.0"
 bytemuck = "1.21.0"
+thiserror = "2.0.12" # Consistent
+lazy_static = "1.5.0"
+regex = "1.11.1"
 
 [lib]
 name = "daemon"

daemon_api/Cargo.toml

@@ -12,4 +12,11 @@ daemonize = "0.5.0" # Consistent
 daemon = { path = "../daemon" }
 config = "0.15.8" # Consistent
 lazy_static = "1.5.0" # Aligned with lib
+clap = { version = "4.5.29", features = ["derive"] } # Added clap
+anyhow = "1.0.98" # Added anyhow for FromStr error type
+reqwest = { version = "0.12.22", features = ["json"] } # Added with json feature
+thiserror = "2.0.12" # Consistent
 tokio = { version = "1.44.2", features = ["net", "time"] } # Updated to latest stable, retaining specific features
+lib = { path = "../lib" }
+
+

daemon_api/src/cli_schema.rs

@@ -0,0 +1,233 @@
+// daemon_api/src/cli_schema.rs
+
+use clap::{Parser, Subcommand, Args};
+use std::path::PathBuf;
+use lib::storage_engine::config::StorageEngineType;
+
+#[derive(Parser, Debug)]
+#[clap(author, version, about = "GraphDB CLI for managing graph data and daemons", long_about = None)]
+pub struct CliArgs {
+    #[clap(long)]
+    pub cli: bool,
+    #[clap(long, conflicts_with = "cli")]
+    pub query: Option<String>,
+    #[clap(subcommand)]
+    pub command: Option<GraphDbCommands>,
+}
+
+#[derive(Subcommand, Debug)]
+pub enum GraphDbCommands {
+    Start(StartArgs),
+    Stop(StopArgs),
+    Status(StatusArgs),
+    Daemon(DaemonCommandWrapper),
+    Rest(RestCommandWrapper),
+    Storage(StorageActionWrapper),
+    #[clap(arg_required_else_help = true)]
+    ViewGraph {
+        #[clap(long)]
+        graph_id: Option<String>,
+    },
+    #[clap(arg_required_else_help = true)]
+    ViewGraphHistory {
+        #[clap(long)]
+        graph_id: Option<String>,
+        #[clap(long)]
+        start_date: Option<String>,
+        #[clap(long)]
+        end_date: Option<String>,
+    },
+    #[clap(arg_required_else_help = true)]
+    IndexNode {
+        #[clap(long)]
+        node_id: Option<String>,
+    },
+    #[clap(arg_required_else_help = true)]
+    CacheNodeState {
+        #[clap(long)]
+        node_id: Option<String>,
+    },
+    Help(HelpArgs),
+}
+
+#[derive(Args, Debug)]
+pub struct StartArgs {
+    #[clap(long, conflicts_with = "cluster")]
+    pub port: Option<u16>,
+    #[clap(long)]
+    pub cluster: Option<String>,
+    #[clap(long)]
+    pub listen_port: Option<u16>,
+    #[clap(long)]
+    pub storage_port: Option<u16>,
+    #[clap(long)]
+    pub storage_config_file: Option<PathBuf>,
+    #[clap(subcommand)]
+    pub component: Option<StartComponent>,
+}
+
+#[derive(Subcommand, Debug)]
+pub enum StartComponent {
+    Rest(StartRestArgs),
+    Storage(StartStorageArgs),
+}
+
+#[derive(Args, Debug)]
+pub struct StartRestArgs {
+    #[clap(long)]
+    pub port: Option<u16>,
+}
+
+#[derive(Args, Debug)]
+pub struct StartStorageArgs {
+    #[clap(long)]
+    pub port: Option<u16>,
+    #[clap(long)]
+    pub config_file: Option<PathBuf>,
+    #[clap(long, value_enum)]
+    pub engine_type: Option<StorageEngineType>,
+}
+
+#[derive(Args, Debug)]
+pub struct StopArgs {
+    #[clap(subcommand)]
+    pub action: Option<StopAction>,
+}
+
+#[derive(Subcommand, Debug)]
+pub enum StopAction {
+    Rest,
+    Daemon {
+        #[clap(long)]
+        port: Option<u16>,
+    },
+    Storage {
+        #[clap(long)]
+        port: Option<u16>,
+    },
+}
+
+#[derive(Args, Debug)]
+pub struct StatusArgs {
+    #[clap(subcommand)]
+    pub action: Option<StatusAction>,
+}
+
+#[derive(Subcommand, Debug)]
+pub enum StatusAction {
+    Rest,
+    Daemon {
+        #[clap(long)]
+        port: Option<u16>,
+    },
+    Storage {
+        #[clap(long)]
+        port: Option<u16>,
+    },
+}
+
+#[derive(Args, Debug)]
+pub struct DaemonCommandWrapper {
+    #[clap(subcommand)]
+    pub command: DaemonCliCommand,
+}
+
+#[derive(Subcommand, Debug)]
+pub enum DaemonCliCommand {
+    Start {
+        #[clap(long)]
+        port: Option<u16>,
+        #[clap(long)]
+        cluster: Option<String>,
+    },
+    Stop {
+        #[clap(long)]
+        port: Option<u16>,
+    },
+    Status {
+        #[clap(long)]
+        port: Option<u16>,
+    },
+    List,
+    ClearAll,
+}
+
+#[derive(Args, Debug)]
+pub struct RestCommandWrapper {
+    #[clap(subcommand)]
+    pub command: RestCliCommand,
+}
+
+#[derive(Subcommand, Debug)]
+pub enum RestCliCommand {
+    Start {
+        #[clap(long)]
+        port: Option<u16>,
+    },
+    Stop,
+    Status,
+    Health,
+    Version,
+    RegisterUser {
+        #[clap(long)]
+        username: String,
+        #[clap(long)]
+        password: String,
+    },
+    Authenticate {
+        #[clap(long)]
+        username: String,
+        #[clap(long)]
+        password: String,
+    },
+    GraphQuery {
+        query_string: String,
+        #[clap(long)]
+        persist: Option<bool>,
+    },
+    StorageQuery,
+}
+
+#[derive(Args, Debug)]
+pub struct StorageActionWrapper {
+    #[clap(subcommand)]
+    pub action: StorageAction,
+}
+
+#[derive(Subcommand, Debug)]
+pub enum StorageAction {
+    Start {
+        #[clap(long)]
+        port: Option<u16>,
+        #[clap(long)]
+        config_file: Option<PathBuf>,
+        #[clap(long, value_enum)]
+        engine_type: Option<StorageEngineType>,
+    },
+    Stop {
+        #[clap(long)]
+        port: Option<u16>,
+    },
+    Status {
+        #[clap(long)]
+        port: Option<u16>,
+    },
+}
+
+#[derive(Args, Debug)]
+pub struct HelpArgs {
+    pub command_path: Vec<String>,
+}
+
+#[derive(Debug)]
+pub struct KVPair {
+    pub key: String,
+    pub value: String,
+}
+
+#[derive(Debug)]
+pub struct PidStore {
+    pub pid: u32,
+    pub port: u16,
+    pub component: String,
+}

daemon_api/src/help_generator.rs

@@ -0,0 +1,131 @@
+// daemon_api/src/help_generator.rs
+
+// This module provides functions for generating CLI help messages programmatically,
+// leveraging clap's capabilities.
+
+use clap::CommandFactory;
+use crate::cli_schema::CliArgs;
+
+/// Generates the full, auto-generated help message for the CLI.
+pub fn generate_full_help() -> String {
+    let mut cmd = CliArgs::command(); // FIX: Use CliArgs::command() directly
+    let mut buffer = Vec::new();
+    cmd.write_help(&mut buffer).expect("Failed to write help to buffer");
+    String::from_utf8(buffer).expect("Failed to convert help to UTF-8")
+}
+
+/// Generates a filtered help message based on a command path.
+///
+/// This function attempts to get the help for a specific subcommand path.
+/// If the path is empty, it returns the full help.
+/// If the path is invalid or no specific help is found, it activates the error case.
+pub fn generate_help_for_path(command_path: &[String]) -> String {
+    if command_path.is_empty() {
+        return generate_full_help();
+    }
+
+    let mut cmd = CliArgs::command(); // FIX: Use CliArgs::command() directly
+    let mut current_subcommand = Some(&mut cmd);
+    let mut full_path_str = String::new();
+
+    // Traverse the command structure to find the specific subcommand
+    for (i, segment) in command_path.iter().enumerate() {
+        if i > 0 {
+            full_path_str.push(' ');
+        }
+        full_path_str.push_str(segment);
+
+        if let Some(sub) = current_subcommand.take().and_then(|c| c.find_subcommand_mut(segment)) {
+            current_subcommand = Some(sub);
+        } else {
+            // If a segment is not found as a subcommand, return an error message
+            return format!(
+                "Error: Command path '{}' not found. Displaying general help.\n\n{}",
+                full_path_str,
+                generate_full_help()
+            );
+        }
+    }
+
+    if let Some(final_cmd) = current_subcommand {
+        let mut buffer = Vec::new();
+        final_cmd.write_help(&mut buffer).expect("Failed to write filtered help to buffer");
+        String::from_utf8(buffer).expect("Failed to convert filtered help to UTF-8")
+    } else {
+        // This case should ideally not be reached if the loop logic is correct,
+        // but it's a fallback.
+        format!(
+            "Error: Could not retrieve help for '{}'. Displaying general help.\n\n{}",
+            full_path_str,
+            generate_full_help()
+        )
+    }
+}
+
+/// Generates status information for a given command path.
+/// This is a mock/placeholder for now, as actual status checks involve network calls.
+/// In a real scenario, this would likely interact with daemon_api or other health endpoints.
+pub async fn generate_status_for_path(command_path: &[String]) -> String {
+    let mut response_lines = vec![];
+    response_lines.push(format!("--- Status for: {} ---", command_path.join(" ")));
+
+    // Corrected matching on &[String] directly
+    match command_path {
+        [] => {
+            // Full status summary
+            response_lines.push("Comprehensive system status:".to_string());
+            response_lines.push("  GraphDB Daemon: Checking...".to_string());
+            response_lines.push("  REST API: Checking...".to_string());
+            response_lines.push("  Storage Daemon: Checking...".to_string());
+            response_lines.push("\nNote: For detailed status, use CLI 'status <component>' or REST '/api/v1/status/<component>'".to_string());
+        }
+        // FIX: Removed 'ref' binding modifier
+        [rest_str] if rest_str == "rest" => {
+            response_lines.push("Checking REST API status...".to_string());
+            // In a real implementation, make an HTTP call to the REST API's /health endpoint
+            // For now, a placeholder:
+            response_lines.push("  REST API: Mock Status - Running".to_string());
+        }
+        // FIX: Removed 'ref' binding modifier
+        [daemon_str] if daemon_str == "daemon" => {
+            response_lines.push("Checking GraphDB Daemon status (all common ports)...".to_string());
+            // Placeholder for checking multiple daemon ports
+            response_lines.push("  Daemon (8080): Mock Status - Running".to_string());
+            response_lines.push("  Daemon (9001): Mock Status - Down".to_string());
+        }
+        // FIX: Removed 'ref' binding modifier
+        [daemon_str, port_str] if daemon_str == "daemon" => {
+            if let Ok(port) = port_str.parse::<u16>() {
+                response_lines.push(format!("Checking GraphDB Daemon status on port {}...", port));
+                // Placeholder for checking a specific daemon port
+                response_lines.push(format!("  Daemon ({}): Mock Status - Running", port));
+            } else {
+                response_lines.push(format!("Invalid port specified: {}", port_str));
+            }
+        }
+        // FIX: Removed 'ref' binding modifier
+        [storage_str] if storage_str == "storage" => {
+            response_lines.push("Checking Storage Daemon status...".to_string());
+            // Placeholder for checking storage daemon status
+            response_lines.push("  Storage Daemon: Mock Status - Running (Sled)".to_string());
+        }
+        // FIX: Removed 'ref' binding modifier
+        [storage_str, port_str] if storage_str == "storage" => {
+            if let Ok(port) = port_str.parse::<u16>() {
+                response_lines.push(format!("Checking Storage Daemon status on port {}...", port));
+                // Placeholder for checking a specific storage daemon port
+                response_lines.push(format!("  Storage Daemon ({}): Mock Status - Running (RocksDB)", port));
+            } else {
+                response_lines.push(format!("Invalid port specified: {}", port_str));
+            }
+        }
+        _ => {
+            response_lines.push(format!("Unknown status request: {:?}. Displaying general status summary.", command_path));
+            response_lines.push("  GraphDB Daemon: Checking...".to_string());
+            response_lines.push("  REST API: Checking...".to_string());
+            response_lines.push("  Storage Daemon: Checking...".to_string());
+        }
+    }
+    response_lines.join("\n")
+}
+