spindb 0.5.4 → 0.6.0

package/cli/commands/config.ts

@@ -1,17 +1,44 @@
 import { Command } from 'commander'
 import chalk from 'chalk'
 import { existsSync } from 'fs'
-import { configManager } from '../../core/config-manager'
-import { error, success, header } from '../ui/theme'
+import {
+  configManager,
+  POSTGRESQL_TOOLS,
+  MYSQL_TOOLS,
+  ENHANCED_SHELLS,
+  ALL_TOOLS,
+} from '../../core/config-manager'
+import { updateManager } from '../../core/update-manager'
+import { error, success, header, info } from '../ui/theme'
 import { createSpinner } from '../ui/spinner'
 import type { BinaryTool } from '../../types'
 
-const VALID_TOOLS: BinaryTool[] = [
-  'psql',
-  'pg_dump',
-  'pg_restore',
-  'pg_basebackup',
-]
+/**
+ * Helper to display a tool's config
+ */
+function displayToolConfig(
+  tool: BinaryTool,
+  binaryConfig: { path: string; version?: string; source: string } | undefined,
+): void {
+  if (binaryConfig) {
+    const sourceLabel =
+      binaryConfig.source === 'system'
+        ? chalk.blue('system')
+        : binaryConfig.source === 'custom'
+          ? chalk.yellow('custom')
+          : chalk.green('bundled')
+    const versionLabel = binaryConfig.version
+      ? chalk.gray(` (v${binaryConfig.version})`)
+      : ''
+    console.log(
+      `    ${chalk.cyan(tool.padEnd(15))} ${binaryConfig.path}${versionLabel} [${sourceLabel}]`,
+    )
+  } else {
+    console.log(
+      `    ${chalk.cyan(tool.padEnd(15))} ${chalk.gray('not detected')}`,
+    )
+  }
+}
 
 export const configCommand = new Command('config')
   .description('Manage spindb configuration')
@@ -26,37 +53,38 @@ export const configCommand = new Command('config')
           console.log(header('SpinDB Configuration'))
           console.log()
 
-          console.log(chalk.bold('  Binary Paths:'))
-          console.log(chalk.gray('  ' + '─'.repeat(50)))
-
-          for (const tool of VALID_TOOLS) {
-            const binaryConfig = config.binaries[tool]
-            if (binaryConfig) {
-              const sourceLabel =
-                binaryConfig.source === 'system'
-                  ? chalk.blue('system')
-                  : binaryConfig.source === 'custom'
-                    ? chalk.yellow('custom')
-                    : chalk.green('bundled')
-              const versionLabel = binaryConfig.version
-                ? chalk.gray(` (v${binaryConfig.version})`)
-                : ''
-              console.log(
-                `  ${chalk.cyan(tool.padEnd(15))} ${binaryConfig.path}${versionLabel} [${sourceLabel}]`,
-              )
-            } else {
-              console.log(
-                `  ${chalk.cyan(tool.padEnd(15))} ${chalk.gray('not configured')}`,
-              )
-            }
+          // PostgreSQL tools
+          console.log(chalk.bold('  🐘 PostgreSQL Tools:'))
+          console.log(chalk.gray('  ' + '─'.repeat(60)))
+          for (const tool of POSTGRESQL_TOOLS) {
+            displayToolConfig(tool, config.binaries[tool])
           }
+          console.log()
 
+          // MySQL tools
+          console.log(chalk.bold('  🐬 MySQL Tools:'))
+          console.log(chalk.gray('  ' + '─'.repeat(60)))
+          for (const tool of MYSQL_TOOLS) {
+            displayToolConfig(tool, config.binaries[tool])
+          }
+          console.log()
+
+          // Enhanced shells
+          console.log(chalk.bold('  ✨ Enhanced Shells (optional):'))
+          console.log(chalk.gray('  ' + '─'.repeat(60)))
+          for (const tool of ENHANCED_SHELLS) {
+            displayToolConfig(tool, config.binaries[tool])
+          }
           console.log()
 
           if (config.updatedAt) {
+            const isStale = await configManager.isStale()
+            const staleWarning = isStale
+              ? chalk.yellow(' (stale - run config detect to refresh)')
+              : ''
             console.log(
               chalk.gray(
-                `  Last updated: ${new Date(config.updatedAt).toLocaleString()}`,
+                `  Last updated: ${new Date(config.updatedAt).toLocaleString()}${staleWarning}`,
               ),
             )
             console.log()
@@ -70,55 +98,108 @@ export const configCommand = new Command('config')
   )
   .addCommand(
     new Command('detect')
-      .description('Auto-detect PostgreSQL client tools on your system')
+      .description('Auto-detect all database tools on your system')
       .action(async () => {
         try {
           console.log()
-          console.log(header('Detecting PostgreSQL Tools'))
+          console.log(header('Detecting Database Tools'))
           console.log()
 
-          const spinner = createSpinner(
-            'Searching for PostgreSQL client tools...',
-          )
+          const spinner = createSpinner('Searching for database tools...')
           spinner.start()
 
           // Clear existing configs to force re-detection
           await configManager.clearAllBinaries()
 
-          const { found, missing } = await configManager.initialize()
+          const result = await configManager.initialize()
 
           spinner.succeed('Detection complete')
           console.log()
 
-          if (found.length > 0) {
-            console.log(chalk.bold('  Found:'))
-            for (const tool of found) {
-              const config = await configManager.getBinaryConfig(tool)
-              if (config) {
-                const versionLabel = config.version
-                  ? chalk.gray(` (v${config.version})`)
-                  : ''
+          // Helper to display category results
+          async function displayCategory(
+            title: string,
+            icon: string,
+            found: BinaryTool[],
+            missing: BinaryTool[],
+          ): Promise<void> {
+            console.log(chalk.bold(`  ${icon} ${title}:`))
+
+            if (found.length > 0) {
+              for (const tool of found) {
+                const config = await configManager.getBinaryConfig(tool)
+                if (config) {
+                  const versionLabel = config.version
+                    ? chalk.gray(` (v${config.version})`)
+                    : ''
+                  console.log(
+                    `    ${chalk.green('✓')} ${chalk.cyan(tool.padEnd(15))} ${config.path}${versionLabel}`,
+                  )
+                }
+              }
+            }
+
+            if (missing.length > 0) {
+              for (const tool of missing) {
                 console.log(
-                  `  ${chalk.green('✓')} ${chalk.cyan(tool.padEnd(15))} ${config.path}${versionLabel}`,
+                  `    ${chalk.gray('○')} ${chalk.gray(tool.padEnd(15))} not found`,
                 )
               }
             }
+
             console.log()
           }
 
-          if (missing.length > 0) {
-            console.log(chalk.bold('  Not found:'))
-            for (const tool of missing) {
-              console.log(`  ${chalk.red('✗')} ${chalk.cyan(tool)}`)
+          await displayCategory(
+            'PostgreSQL Tools',
+            '🐘',
+            result.postgresql.found,
+            result.postgresql.missing,
+          )
+          await displayCategory(
+            'MySQL Tools',
+            '🐬',
+            result.mysql.found,
+            result.mysql.missing,
+          )
+          await displayCategory(
+            'Enhanced Shells (optional)',
+            '✨',
+            result.enhanced.found,
+            result.enhanced.missing,
+          )
+
+          // Show install hints for missing required tools
+          if (
+            result.postgresql.missing.length > 0 ||
+            result.mysql.missing.length > 0
+          ) {
+            console.log(chalk.gray('  Install missing tools:'))
+            if (result.postgresql.missing.length > 0) {
+              console.log(
+                chalk.gray('    PostgreSQL: brew install postgresql@17'),
+              )
+            }
+            if (result.mysql.missing.length > 0) {
+              console.log(chalk.gray('    MySQL:      brew install mysql'))
             }
             console.log()
-            console.log(chalk.gray('  Install missing tools:'))
-            console.log(
-              chalk.gray(
-                '    macOS:  brew install libpq && brew link --force libpq',
-              ),
-            )
-            console.log(chalk.gray('    Ubuntu: apt install postgresql-client'))
+          }
+
+          // Show enhanced shell hints
+          if (result.enhanced.missing.length > 0) {
+            console.log(chalk.gray('  Optional enhanced shells:'))
+            if (result.enhanced.missing.includes('pgcli')) {
+              console.log(chalk.gray('    pgcli: brew install pgcli'))
+            }
+            if (result.enhanced.missing.includes('mycli')) {
+              console.log(chalk.gray('    mycli: brew install mycli'))
+            }
+            if (result.enhanced.missing.includes('usql')) {
+              console.log(
+                chalk.gray('    usql:  brew tap xo/xo && brew install usql'),
+              )
+            }
             console.log()
           }
         } catch (err) {
@@ -131,14 +212,14 @@ export const configCommand = new Command('config')
   .addCommand(
     new Command('set')
       .description('Set a custom binary path')
-      .argument('<tool>', `Tool name (${VALID_TOOLS.join(', ')})`)
+      .argument('<tool>', 'Tool name (psql, mysql, pgcli, etc.)')
       .argument('<path>', 'Path to the binary')
       .action(async (tool: string, path: string) => {
         try {
           // Validate tool name
-          if (!VALID_TOOLS.includes(tool as BinaryTool)) {
+          if (!ALL_TOOLS.includes(tool as BinaryTool)) {
             console.error(error(`Invalid tool: ${tool}`))
-            console.log(chalk.gray(`  Valid tools: ${VALID_TOOLS.join(', ')}`))
+            console.log(chalk.gray(`  Valid tools: ${ALL_TOOLS.join(', ')}`))
             process.exit(1)
           }
 
@@ -164,13 +245,13 @@ export const configCommand = new Command('config')
   .addCommand(
     new Command('unset')
       .description('Remove a custom binary path')
-      .argument('<tool>', `Tool name (${VALID_TOOLS.join(', ')})`)
+      .argument('<tool>', 'Tool name (psql, mysql, pgcli, etc.)')
       .action(async (tool: string) => {
         try {
           // Validate tool name
-          if (!VALID_TOOLS.includes(tool as BinaryTool)) {
+          if (!ALL_TOOLS.includes(tool as BinaryTool)) {
             console.error(error(`Invalid tool: ${tool}`))
-            console.log(chalk.gray(`  Valid tools: ${VALID_TOOLS.join(', ')}`))
+            console.log(chalk.gray(`  Valid tools: ${ALL_TOOLS.join(', ')}`))
             process.exit(1)
           }
 
@@ -186,13 +267,13 @@ export const configCommand = new Command('config')
   .addCommand(
     new Command('path')
       .description('Show the path for a specific tool')
-      .argument('<tool>', `Tool name (${VALID_TOOLS.join(', ')})`)
+      .argument('<tool>', 'Tool name (psql, mysql, pgcli, etc.)')
       .action(async (tool: string) => {
         try {
           // Validate tool name
-          if (!VALID_TOOLS.includes(tool as BinaryTool)) {
+          if (!ALL_TOOLS.includes(tool as BinaryTool)) {
             console.error(error(`Invalid tool: ${tool}`))
-            console.log(chalk.gray(`  Valid tools: ${VALID_TOOLS.join(', ')}`))
+            console.log(chalk.gray(`  Valid tools: ${ALL_TOOLS.join(', ')}`))
             process.exit(1)
           }
 
@@ -213,3 +294,55 @@ export const configCommand = new Command('config')
         }
       }),
   )
+  .addCommand(
+    new Command('update-check')
+      .description('Enable or disable automatic update checks on startup')
+      .argument('[state]', 'on or off (omit to show current status)')
+      .action(async (state?: string) => {
+        try {
+          const cached = await updateManager.getCachedUpdateInfo()
+
+          if (!state) {
+            // Show current status
+            const status = cached.autoCheckEnabled
+              ? chalk.green('enabled')
+              : chalk.yellow('disabled')
+            console.log()
+            console.log(`  Update checks on startup: ${status}`)
+            console.log()
+            console.log(chalk.gray('  Usage:'))
+            console.log(
+              chalk.gray('    spindb config update-check on   # Enable'),
+            )
+            console.log(
+              chalk.gray('    spindb config update-check off  # Disable'),
+            )
+            console.log()
+            return
+          }
+
+          if (state !== 'on' && state !== 'off') {
+            console.error(error('Invalid state. Use "on" or "off"'))
+            process.exit(1)
+          }
+
+          const enabled = state === 'on'
+          await updateManager.setAutoCheckEnabled(enabled)
+
+          if (enabled) {
+            console.log(success('Update checks enabled on startup'))
+          } else {
+            console.log(info('Update checks disabled on startup'))
+            console.log(
+              chalk.gray(
+                '  You can still manually check with: spindb version --check',
+              ),
+            )
+          }
+        } catch (err) {
+          const e = err as Error
+          console.error(error(e.message))
+          process.exit(1)
+        }
+      }),
+  )

package/cli/commands/connect.ts

@@ -26,9 +26,15 @@ export const connectCommand = new Command('connect')
   .option('-d, --database <name>', 'Database name')
   .option('--tui', 'Use usql for enhanced shell experience')
   .option('--install-tui', 'Install usql if not present, then connect')
-  .option('--pgcli', 'Use pgcli for enhanced PostgreSQL shell (dropdown auto-completion)')
+  .option(
+    '--pgcli',
+    'Use pgcli for enhanced PostgreSQL shell (dropdown auto-completion)',
+  )
   .option('--install-pgcli', 'Install pgcli if not present, then connect')
-  .option('--mycli', 'Use mycli for enhanced MySQL shell (dropdown auto-completion)')
+  .option(
+    '--mycli',
+    'Use mycli for enhanced MySQL shell (dropdown auto-completion)',
+  )
   .option('--install-mycli', 'Install mycli if not present, then connect')
   .action(
     async (
@@ -164,7 +170,9 @@ export const connectCommand = new Command('connect')
         const usePgcli = options.pgcli || options.installPgcli
         if (usePgcli) {
           if (engineName !== 'postgresql') {
-            console.error(error('pgcli is only available for PostgreSQL containers'))
+            console.error(
+              error('pgcli is only available for PostgreSQL containers'),
+            )
             console.log(chalk.gray('For MySQL, use: spindb connect --mycli'))
             process.exit(1)
           }
@@ -173,7 +181,9 @@ export const connectCommand = new Command('connect')
 
           if (!pgcliInstalled) {
             if (options.installPgcli) {
-              console.log(info('Installing pgcli for enhanced PostgreSQL shell...'))
+              console.log(
+                info('Installing pgcli for enhanced PostgreSQL shell...'),
+              )
               const pm = await detectPackageManager()
               if (pm) {
                 const result = await installPgcli(pm)
@@ -181,7 +191,9 @@ export const connectCommand = new Command('connect')
                   console.log(success('pgcli installed successfully!'))
                   console.log()
                 } else {
-                  console.error(error(`Failed to install pgcli: ${result.error}`))
+                  console.error(
+                    error(`Failed to install pgcli: ${result.error}`),
+                  )
                   console.log()
                   console.log(chalk.gray('Manual installation:'))
                   for (const instruction of getPgcliManualInstructions()) {
@@ -201,7 +213,9 @@ export const connectCommand = new Command('connect')
             } else {
               console.error(error('pgcli is not installed'))
               console.log()
-              console.log(chalk.gray('Install pgcli for enhanced PostgreSQL shell:'))
+              console.log(
+                chalk.gray('Install pgcli for enhanced PostgreSQL shell:'),
+              )
               console.log(chalk.cyan('  spindb connect --install-pgcli'))
               console.log()
               console.log(chalk.gray('Or install manually:'))
@@ -218,7 +232,9 @@ export const connectCommand = new Command('connect')
         if (useMycli) {
           if (engineName !== 'mysql') {
             console.error(error('mycli is only available for MySQL containers'))
-            console.log(chalk.gray('For PostgreSQL, use: spindb connect --pgcli'))
+            console.log(
+              chalk.gray('For PostgreSQL, use: spindb connect --pgcli'),
+            )
             process.exit(1)
           }
 
@@ -234,7 +250,9 @@ export const connectCommand = new Command('connect')
                   console.log(success('mycli installed successfully!'))
                   console.log()
                 } else {
-                  console.error(error(`Failed to install mycli: ${result.error}`))
+                  console.error(
+                    error(`Failed to install mycli: ${result.error}`),
+                  )
                   console.log()
                   console.log(chalk.gray('Manual installation:'))
                   for (const instruction of getMycliManualInstructions()) {
@@ -327,7 +345,9 @@ export const connectCommand = new Command('connect')
 
             if (clientCmd === 'usql') {
               console.log(chalk.gray('  Install usql:'))
-              console.log(chalk.cyan('  brew tap xo/xo && brew install xo/xo/usql'))
+              console.log(
+                chalk.cyan('  brew tap xo/xo && brew install xo/xo/usql'),
+              )
             } else if (clientCmd === 'pgcli') {
               console.log(chalk.gray('  Install pgcli:'))
               console.log(chalk.cyan('  brew install pgcli'))

package/cli/commands/engines.ts

@@ -10,7 +10,7 @@ import { paths } from '../../config/paths'
 import { containerManager } from '../../core/container-manager'
 import { promptConfirm } from '../ui/prompts'
 import { createSpinner } from '../ui/spinner'
-import { error, warning, info } from '../ui/theme'
+import { error, warning, info, formatBytes } from '../ui/theme'
 import {
   getMysqldPath,
   getMysqlVersion,
@@ -185,14 +185,6 @@ function compareVersions(a: string, b: string): number {
   return 0
 }
 
-function formatBytes(bytes: number): string {
-  if (bytes === 0) return '0 B'
-  const k = 1024
-  const sizes = ['B', 'KB', 'MB', 'GB']
-  const i = Math.floor(Math.log(bytes) / Math.log(k))
-  return `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`
-}
-
 /**
  * Engine icons
  */

package/cli/commands/list.ts

@@ -1,7 +1,9 @@
 import { Command } from 'commander'
 import chalk from 'chalk'
 import { containerManager } from '../../core/container-manager'
-import { info, error } from '../ui/theme'
+import { getEngine } from '../../engines'
+import { info, error, formatBytes } from '../ui/theme'
+import type { ContainerConfig } from '../../types'
 
 /**
  * Engine icons for display
@@ -11,6 +13,23 @@ const engineIcons: Record<string, string> = {
   mysql: '🐬',
 }
 
+/**
+ * Get database size for a container (only if running)
+ */
+async function getContainerSize(
+  container: ContainerConfig,
+): Promise<number | null> {
+  if (container.status !== 'running') {
+    return null
+  }
+  try {
+    const engine = getEngine(container.engine)
+    return await engine.getDatabaseSize(container)
+  } catch {
+    return null
+  }
+}
+
 export const listCommand = new Command('list')
   .alias('ls')
   .description('List all containers')
@@ -20,7 +39,14 @@ export const listCommand = new Command('list')
       const containers = await containerManager.list()
 
       if (options.json) {
-        console.log(JSON.stringify(containers, null, 2))
+        // Include sizes in JSON output
+        const containersWithSize = await Promise.all(
+          containers.map(async (container) => ({
+            ...container,
+            sizeBytes: await getContainerSize(container),
+          })),
+        )
+        console.log(JSON.stringify(containersWithSize, null, 2))
         return
       }
 
@@ -29,6 +55,9 @@ export const listCommand = new Command('list')
         return
       }
 
+      // Fetch sizes for running containers in parallel
+      const sizes = await Promise.all(containers.map(getContainerSize))
+
       // Table header
       console.log()
       console.log(
@@ -37,12 +66,16 @@ export const listCommand = new Command('list')
           chalk.bold.white('ENGINE'.padEnd(15)) +
           chalk.bold.white('VERSION'.padEnd(10)) +
           chalk.bold.white('PORT'.padEnd(8)) +
+          chalk.bold.white('SIZE'.padEnd(10)) +
           chalk.bold.white('STATUS'),
       )
-      console.log(chalk.gray('  ' + '─'.repeat(63)))
+      console.log(chalk.gray('  ' + '─'.repeat(73)))
 
       // Table rows
-      for (const container of containers) {
+      for (let i = 0; i < containers.length; i++) {
+        const container = containers[i]
+        const size = sizes[i]
+
         const statusDisplay =
           container.status === 'running'
             ? chalk.green('● running')
@@ -51,12 +84,16 @@ export const listCommand = new Command('list')
         const engineIcon = engineIcons[container.engine] || '▣'
         const engineDisplay = `${engineIcon} ${container.engine}`
 
+        // Format size: show value if running, dash if stopped
+        const sizeDisplay = size !== null ? formatBytes(size) : chalk.gray('—')
+
         console.log(
           chalk.gray('  ') +
             chalk.cyan(container.name.padEnd(20)) +
             chalk.white(engineDisplay.padEnd(14)) +
             chalk.yellow(container.version.padEnd(10)) +
             chalk.green(String(container.port).padEnd(8)) +
+            chalk.magenta(sizeDisplay.padEnd(10)) +
             statusDisplay,
         )
       }