feat(cli): fix three commands that failed smoke test

skills list
- Add List variant to SkillCommands as an alias for status

databases show <id>
- Add Show subcommand to DatabasesCommands; dispatches to databases::get()
- Bare positional (hotdata databases <id>) preserved for backward compat

databases tables <db_id>
- Make Tables subcommand optional; bare positional db_id triggers tables_list
- hotdata databases tables <id> now lists tables without requiring `list` subcommand
- hotdata databases tables list --database <id> still works (backward compat)
- hotdata databases tables with no args prints help

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: eddietejeda

src/command.rs

@@ -547,6 +547,16 @@ pub enum DatabasesCommands {
         output: String,
     },
 
+    /// Show details for a specific managed database
+    Show {
+        /// Database name or ID
+        name_or_id: String,
+
+        /// Output format
+        #[arg(long = "output", short = 'o', default_value = "table", value_parser = ["table", "json", "yaml"])]
+        output: String,
+    },
+
     /// Create a new managed database
     Create {
         /// Optional display label (not unique, not an identifier — databases are addressed by id)
@@ -604,8 +614,11 @@ pub enum DatabasesCommands {
 
     /// Manage tables inside a managed database
     Tables {
+        /// Database id or description — shorthand for `tables list` when no subcommand is given
+        database: Option<String>,
+
         #[command(subcommand)]
-        command: DatabaseTablesCommands,
+        command: Option<DatabaseTablesCommands>,
     },
 }
 
@@ -738,6 +751,8 @@ pub enum SkillCommands {
     },
     /// Show the installation status of the hotdata skill
     Status,
+    /// List installed skills and their versions (alias for status)
+    List,
 }
 
 #[derive(Subcommand)]

src/main.rs

@@ -390,6 +390,9 @@ fn main() {
                         Some(DatabasesCommands::List { output }) => {
                             databases::list(&workspace_id, &output)
                         }
+                        Some(DatabasesCommands::Show { name_or_id, output }) => {
+                            databases::get(&workspace_id, &name_or_id, &output)
+                        }
                         Some(DatabasesCommands::Create {
                             description,
                             schema,
@@ -427,43 +430,63 @@ fn main() {
                                 upload_id.as_deref(),
                             )
                         }
-                        Some(DatabasesCommands::Tables { command }) => match command {
-                            DatabaseTablesCommands::List {
-                                database,
+                        Some(DatabasesCommands::Tables { database, command }) => match command {
+                            Some(DatabaseTablesCommands::List {
+                                database: db_flag,
                                 schema,
                                 output,
-                            } => databases::tables_list(
+                            }) => databases::tables_list(
                                 &workspace_id,
-                                database.as_deref(),
+                                db_flag.as_deref().or(database.as_deref()),
                                 schema.as_deref(),
                                 &output,
                             ),
-                            DatabaseTablesCommands::Load {
-                                database,
+                            Some(DatabaseTablesCommands::Load {
+                                database: db_flag,
                                 table,
                                 schema,
                                 file,
                                 url,
                                 upload_id,
-                            } => databases::tables_load(
+                            }) => databases::tables_load(
                                 &workspace_id,
-                                database.as_deref(),
+                                db_flag.as_deref().or(database.as_deref()),
                                 &table,
                                 Some(schema.as_str()),
                                 file.as_deref(),
                                 url.as_deref(),
                                 upload_id.as_deref(),
                             ),
-                            DatabaseTablesCommands::Delete {
-                                database,
+                            Some(DatabaseTablesCommands::Delete {
+                                database: db_flag,
                                 table,
                                 schema,
-                            } => databases::tables_delete(
+                            }) => databases::tables_delete(
                                 &workspace_id,
-                                database.as_deref(),
+                                db_flag.as_deref().or(database.as_deref()),
                                 &table,
                                 Some(schema.as_str()),
                             ),
+                            None => {
+                                if let Some(ref db) = database {
+                                    databases::tables_list(
+                                        &workspace_id,
+                                        Some(db.as_str()),
+                                        None,
+                                        "table",
+                                    )
+                                } else {
+                                    use clap::CommandFactory;
+                                    let mut cmd = Cli::command();
+                                    cmd.build();
+                                    cmd.find_subcommand_mut("databases")
+                                        .unwrap()
+                                        .find_subcommand_mut("tables")
+                                        .unwrap()
+                                        .print_help()
+                                        .unwrap();
+                                }
+                            }
                         },
                         None => {
                             use clap::CommandFactory;
@@ -507,7 +530,7 @@ fn main() {
                         skill::install()
                     }
                 }
-                SkillCommands::Status => skill::status(),
+                SkillCommands::Status | SkillCommands::List => skill::status(),
             },
             Commands::Results {
                 result_id,