spindb 0.1.0

package/src/cli/commands/restore.ts

@@ -0,0 +1,161 @@
+import { Command } from 'commander'
+import { existsSync } from 'fs'
+import chalk from 'chalk'
+import { containerManager } from '@/core/container-manager'
+import { processManager } from '@/core/process-manager'
+import { getEngine } from '@/engines'
+import { promptContainerSelect, promptDatabaseName } from '@/cli/ui/prompts'
+import { createSpinner } from '@/cli/ui/spinner'
+import { success, error, warning } from '@/cli/ui/theme'
+
+export const restoreCommand = new Command('restore')
+  .description('Restore a backup to a container')
+  .argument('[name]', 'Container name')
+  .argument('[backup]', 'Path to backup file')
+  .option('-d, --database <name>', 'Target database name')
+  .action(
+    async (
+      name: string | undefined,
+      backup: string | undefined,
+      options: { database?: string },
+    ) => {
+      try {
+        let containerName = name
+        const backupPath = backup
+
+        // Interactive selection if no name provided
+        if (!containerName) {
+          const containers = await containerManager.list()
+          const running = containers.filter((c) => c.status === 'running')
+
+          if (running.length === 0) {
+            if (containers.length === 0) {
+              console.log(
+                warning('No containers found. Create one with: spindb create'),
+              )
+            } else {
+              console.log(
+                warning(
+                  'No running containers. Start one first with: spindb start',
+                ),
+              )
+            }
+            return
+          }
+
+          const selected = await promptContainerSelect(
+            running,
+            'Select container to restore to:',
+          )
+          if (!selected) return
+          containerName = selected
+        }
+
+        // Get container config
+        const config = await containerManager.getConfig(containerName)
+        if (!config) {
+          console.error(error(`Container "${containerName}" not found`))
+          process.exit(1)
+        }
+
+        // Check if running
+        const running = await processManager.isRunning(containerName)
+        if (!running) {
+          console.error(
+            error(
+              `Container "${containerName}" is not running. Start it first.`,
+            ),
+          )
+          process.exit(1)
+        }
+
+        // Check backup file
+        if (!backupPath) {
+          console.error(error('Backup file path is required'))
+          console.log(
+            chalk.gray('  Usage: spindb restore <container> <backup-file>'),
+          )
+          process.exit(1)
+        }
+
+        if (!existsSync(backupPath)) {
+          console.error(error(`Backup file not found: ${backupPath}`))
+          process.exit(1)
+        }
+
+        // Get database name
+        let databaseName = options.database
+        if (!databaseName) {
+          databaseName = await promptDatabaseName(containerName)
+        }
+
+        // Get engine
+        const engine = getEngine(config.engine)
+
+        // Detect backup format
+        const detectSpinner = createSpinner('Detecting backup format...')
+        detectSpinner.start()
+
+        const format = await engine.detectBackupFormat(backupPath)
+        detectSpinner.succeed(`Detected: ${format.description}`)
+
+        // Create database
+        const dbSpinner = createSpinner(
+          `Creating database "${databaseName}"...`,
+        )
+        dbSpinner.start()
+
+        await engine.createDatabase(config, databaseName)
+        dbSpinner.succeed(`Database "${databaseName}" ready`)
+
+        // Restore backup
+        const restoreSpinner = createSpinner('Restoring backup...')
+        restoreSpinner.start()
+
+        const result = await engine.restore(config, backupPath, {
+          database: databaseName,
+          createDatabase: false, // Already created
+        })
+
+        if (result.code === 0 || !result.stderr) {
+          restoreSpinner.succeed('Backup restored successfully')
+        } else {
+          // pg_restore often returns warnings even on success
+          restoreSpinner.warn('Restore completed with warnings')
+          if (result.stderr) {
+            console.log(chalk.yellow('\n  Warnings:'))
+            const lines = result.stderr.split('\n').slice(0, 5)
+            lines.forEach((line) => {
+              if (line.trim()) {
+                console.log(chalk.gray(`    ${line}`))
+              }
+            })
+            if (result.stderr.split('\n').length > 5) {
+              console.log(chalk.gray('    ...'))
+            }
+          }
+        }
+
+        // Show connection info
+        const connectionString = engine.getConnectionString(
+          config,
+          databaseName,
+        )
+        console.log()
+        console.log(success(`Database "${databaseName}" restored`))
+        console.log()
+        console.log(chalk.gray('  Connection string:'))
+        console.log(chalk.cyan(`  ${connectionString}`))
+        console.log()
+        console.log(chalk.gray('  Connect with:'))
+        console.log(
+          chalk.cyan(`  spindb connect ${containerName} -d ${databaseName}`),
+        )
+        console.log()
+      } catch (err) {
+        const e = err as Error
+        console.error(error(e.message))
+        process.exit(1)
+      }
+    },
+  )

package/src/cli/commands/start.ts

@@ -0,0 +1,95 @@
+import { Command } from 'commander'
+import chalk from 'chalk'
+import { containerManager } from '@/core/container-manager'
+import { portManager } from '@/core/port-manager'
+import { processManager } from '@/core/process-manager'
+import { getEngine } from '@/engines'
+import { promptContainerSelect } from '@/cli/ui/prompts'
+import { createSpinner } from '@/cli/ui/spinner'
+import { error, warning } from '@/cli/ui/theme'
+
+export const startCommand = new Command('start')
+  .description('Start a container')
+  .argument('[name]', 'Container name')
+  .action(async (name: string | undefined) => {
+    try {
+      let containerName = name
+
+      // Interactive selection if no name provided
+      if (!containerName) {
+        const containers = await containerManager.list()
+        const stopped = containers.filter((c) => c.status !== 'running')
+
+        if (stopped.length === 0) {
+          if (containers.length === 0) {
+            console.log(
+              warning('No containers found. Create one with: spindb create'),
+            )
+          } else {
+            console.log(warning('All containers are already running'))
+          }
+          return
+        }
+
+        const selected = await promptContainerSelect(
+          stopped,
+          'Select container to start:',
+        )
+        if (!selected) return
+        containerName = selected
+      }
+
+      // Get container config
+      const config = await containerManager.getConfig(containerName)
+      if (!config) {
+        console.error(error(`Container "${containerName}" not found`))
+        process.exit(1)
+      }
+
+      // Check if already running
+      const running = await processManager.isRunning(containerName)
+      if (running) {
+        console.log(warning(`Container "${containerName}" is already running`))
+        return
+      }
+
+      // Check port availability
+      const portAvailable = await portManager.isPortAvailable(config.port)
+      if (!portAvailable) {
+        // Try to find a new port
+        const { port: newPort } = await portManager.findAvailablePort()
+        console.log(
+          warning(
+            `Port ${config.port} is in use, switching to port ${newPort}`,
+          ),
+        )
+        config.port = newPort
+        await containerManager.updateConfig(containerName, { port: newPort })
+      }
+
+      // Get engine and start
+      const engine = getEngine(config.engine)
+
+      const spinner = createSpinner(`Starting ${containerName}...`)
+      spinner.start()
+
+      await engine.start(config)
+      await containerManager.updateConfig(containerName, { status: 'running' })
+
+      spinner.succeed(`Container "${containerName}" started`)
+
+      // Show connection info
+      const connectionString = engine.getConnectionString(config)
+      console.log()
+      console.log(chalk.gray('  Connection string:'))
+      console.log(chalk.cyan(`  ${connectionString}`))
+      console.log()
+      console.log(chalk.gray('  Connect with:'))
+      console.log(chalk.cyan(`  spindb connect ${containerName}`))
+      console.log()
+    } catch (err) {
+      const e = err as Error
+      console.error(error(e.message))
+      process.exit(1)
+    }
+  })

package/src/cli/commands/stop.ts

@@ -0,0 +1,91 @@
+import { Command } from 'commander'
+import { containerManager } from '@/core/container-manager'
+import { processManager } from '@/core/process-manager'
+import { getEngine } from '@/engines'
+import { promptContainerSelect } from '@/cli/ui/prompts'
+import { createSpinner } from '@/cli/ui/spinner'
+import { success, error, warning } from '@/cli/ui/theme'
+
+export const stopCommand = new Command('stop')
+  .description('Stop a container')
+  .argument('[name]', 'Container name')
+  .option('-a, --all', 'Stop all running containers')
+  .action(async (name: string | undefined, options: { all?: boolean }) => {
+    try {
+      if (options.all) {
+        // Stop all running containers
+        const containers = await containerManager.list()
+        const running = containers.filter((c) => c.status === 'running')
+
+        if (running.length === 0) {
+          console.log(warning('No running containers found'))
+          return
+        }
+
+        for (const container of running) {
+          const spinner = createSpinner(`Stopping ${container.name}...`)
+          spinner.start()
+
+          const engine = getEngine(container.engine)
+          await engine.stop(container)
+          await containerManager.updateConfig(container.name, {
+            status: 'stopped',
+          })
+
+          spinner.succeed(`Stopped "${container.name}"`)
+        }
+
+        console.log(success(`Stopped ${running.length} container(s)`))
+        return
+      }
+
+      let containerName = name
+
+      // Interactive selection if no name provided
+      if (!containerName) {
+        const containers = await containerManager.list()
+        const running = containers.filter((c) => c.status === 'running')
+
+        if (running.length === 0) {
+          console.log(warning('No running containers found'))
+          return
+        }
+
+        const selected = await promptContainerSelect(
+          running,
+          'Select container to stop:',
+        )
+        if (!selected) return
+        containerName = selected
+      }
+
+      // Get container config
+      const config = await containerManager.getConfig(containerName)
+      if (!config) {
+        console.error(error(`Container "${containerName}" not found`))
+        process.exit(1)
+      }
+
+      // Check if running
+      const running = await processManager.isRunning(containerName)
+      if (!running) {
+        console.log(warning(`Container "${containerName}" is not running`))
+        return
+      }
+
+      // Get engine and stop
+      const engine = getEngine(config.engine)
+
+      const spinner = createSpinner(`Stopping ${containerName}...`)
+      spinner.start()
+
+      await engine.stop(config)
+      await containerManager.updateConfig(containerName, { status: 'stopped' })
+
+      spinner.succeed(`Container "${containerName}" stopped`)
+    } catch (err) {
+      const e = err as Error
+      console.error(error(e.message))
+      process.exit(1)
+    }
+  })

package/src/cli/index.ts

@@ -0,0 +1,38 @@
+import { program } from 'commander'
+import { createCommand } from '@/cli/commands/create'
+import { listCommand } from '@/cli/commands/list'
+import { startCommand } from '@/cli/commands/start'
+import { stopCommand } from '@/cli/commands/stop'
+import { deleteCommand } from '@/cli/commands/delete'
+import { restoreCommand } from '@/cli/commands/restore'
+import { connectCommand } from '@/cli/commands/connect'
+import { cloneCommand } from '@/cli/commands/clone'
+import { menuCommand } from '@/cli/commands/menu'
+import { configCommand } from '@/cli/commands/config'
+
+export async function run(): Promise<void> {
+  program
+    .name('spindb')
+    .description('Spin up local database containers without Docker')
+    .version('0.1.0')
+
+  program.addCommand(createCommand)
+  program.addCommand(listCommand)
+  program.addCommand(startCommand)
+  program.addCommand(stopCommand)
+  program.addCommand(deleteCommand)
+  program.addCommand(restoreCommand)
+  program.addCommand(connectCommand)
+  program.addCommand(cloneCommand)
+  program.addCommand(menuCommand)
+  program.addCommand(configCommand)
+
+  // If no arguments provided, show interactive menu
+  if (process.argv.length <= 2) {
+    const { menuCommand: menu } = await import('@/cli/commands/menu')
+    await menu.parseAsync([])
+    return
+  }
+
+  program.parse()
+}

package/src/cli/ui/prompts.ts

@@ -0,0 +1,197 @@
+import inquirer from 'inquirer'
+import chalk from 'chalk'
+import { listEngines } from '@/engines'
+import { defaults } from '@/config/defaults'
+import type { ContainerConfig } from '@/types'
+
+/**
+ * Prompt for container name
+ */
+export async function promptContainerName(
+  defaultName?: string,
+): Promise<string> {
+  const { name } = await inquirer.prompt<{ name: string }>([
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Container name:',
+      default: defaultName,
+      validate: (input: string) => {
+        if (!input) return 'Name is required'
+        if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(input)) {
+          return 'Name must start with a letter and contain only letters, numbers, hyphens, and underscores'
+        }
+        return true
+      },
+    },
+  ])
+  return name
+}
+
+/**
+ * Prompt for database engine selection
+ */
+export async function promptEngine(): Promise<string> {
+  const engines = listEngines()
+
+  const { engine } = await inquirer.prompt<{ engine: string }>([
+    {
+      type: 'list',
+      name: 'engine',
+      message: 'Select database engine:',
+      choices: engines.map((e) => ({
+        name: `${e.displayName} ${chalk.gray(`(versions: ${e.supportedVersions.join(', ')})`)}`,
+        value: e.name,
+        short: e.displayName,
+      })),
+    },
+  ])
+
+  return engine
+}
+
+/**
+ * Prompt for PostgreSQL version
+ */
+export async function promptVersion(engine: string): Promise<string> {
+  const engines = listEngines()
+  const selectedEngine = engines.find((e) => e.name === engine)
+  const versions =
+    selectedEngine?.supportedVersions || defaults.supportedPostgresVersions
+
+  const { version } = await inquirer.prompt<{ version: string }>([
+    {
+      type: 'list',
+      name: 'version',
+      message: 'Select version:',
+      choices: versions.map((v, i) => ({
+        name: i === versions.length - 1 ? `${v} ${chalk.green('(latest)')}` : v,
+        value: v,
+      })),
+      default: versions[versions.length - 1], // Default to latest
+    },
+  ])
+
+  return version
+}
+
+/**
+ * Prompt for port
+ */
+export async function promptPort(
+  defaultPort: number = defaults.port,
+): Promise<number> {
+  const { port } = await inquirer.prompt<{ port: number }>([
+    {
+      type: 'input',
+      name: 'port',
+      message: 'Port:',
+      default: String(defaultPort),
+      validate: (input: string) => {
+        const num = parseInt(input, 10)
+        if (isNaN(num) || num < 1 || num > 65535) {
+          return 'Port must be a number between 1 and 65535'
+        }
+        return true
+      },
+      filter: (input: string) => parseInt(input, 10),
+    },
+  ])
+
+  return port
+}
+
+/**
+ * Prompt for confirmation using arrow-key selection
+ */
+export async function promptConfirm(
+  message: string,
+  defaultValue: boolean = true,
+): Promise<boolean> {
+  const { confirmed } = await inquirer.prompt<{ confirmed: string }>([
+    {
+      type: 'list',
+      name: 'confirmed',
+      message,
+      choices: [
+        { name: 'Yes', value: 'yes' },
+        { name: 'No', value: 'no' },
+      ],
+      default: defaultValue ? 'yes' : 'no',
+    },
+  ])
+
+  return confirmed === 'yes'
+}
+
+/**
+ * Prompt for container selection from a list
+ */
+export async function promptContainerSelect(
+  containers: ContainerConfig[],
+  message: string = 'Select container:',
+): Promise<string | null> {
+  if (containers.length === 0) {
+    return null
+  }
+
+  const { container } = await inquirer.prompt<{ container: string }>([
+    {
+      type: 'list',
+      name: 'container',
+      message,
+      choices: containers.map((c) => ({
+        name: `${c.name} ${chalk.gray(`(${c.engine} ${c.version}, port ${c.port})`)} ${
+          c.status === 'running'
+            ? chalk.green('● running')
+            : chalk.gray('○ stopped')
+        }`,
+        value: c.name,
+        short: c.name,
+      })),
+    },
+  ])
+
+  return container
+}
+
+/**
+ * Prompt for database name
+ */
+export async function promptDatabaseName(
+  defaultName?: string,
+): Promise<string> {
+  const { database } = await inquirer.prompt<{ database: string }>([
+    {
+      type: 'input',
+      name: 'database',
+      message: 'Database name:',
+      default: defaultName,
+      validate: (input: string) => {
+        if (!input) return 'Database name is required'
+        return true
+      },
+    },
+  ])
+
+  return database
+}
+
+export interface CreateOptions {
+  name: string
+  engine: string
+  version: string
+}
+
+/**
+ * Full interactive create flow
+ */
+export async function promptCreateOptions(): Promise<CreateOptions> {
+  console.log(chalk.cyan('\n  🗄️  Create New Database Container\n'))
+
+  const name = await promptContainerName()
+  const engine = await promptEngine()
+  const version = await promptVersion(engine)
+
+  return { name, engine, version }
+}

package/src/cli/ui/spinner.ts

@@ -0,0 +1,94 @@
+import ora, { type Ora } from 'ora'
+
+/**
+ * Create a spinner with consistent styling
+ */
+export function createSpinner(text: string): Ora {
+  return ora({
+    text,
+    color: 'cyan',
+    spinner: 'dots',
+  })
+}
+
+/**
+ * Run an async operation with a spinner
+ */
+export async function withSpinner<T>(
+  text: string,
+  operation: (updateText: (message: string) => void) => Promise<T>,
+): Promise<T> {
+  const spinner = createSpinner(text)
+  spinner.start()
+
+  try {
+    const result = await operation((message: string) => {
+      spinner.text = message
+    })
+    spinner.succeed()
+    return result
+  } catch (err) {
+    const error = err as Error
+    spinner.fail(error.message)
+    throw error
+  }
+}
+
+/**
+ * Progress tracker for multi-step operations
+ */
+export class ProgressTracker {
+  private steps: string[]
+  private currentStep: number
+  private spinner: Ora | null
+
+  constructor(steps: string[]) {
+    this.steps = steps
+    this.currentStep = 0
+    this.spinner = null
+  }
+
+  start(): void {
+    if (this.steps.length > 0) {
+      this.spinner = createSpinner(this.steps[0])
+      this.spinner.start()
+    }
+  }
+
+  nextStep(): void {
+    if (this.spinner) {
+      this.spinner.succeed()
+    }
+
+    this.currentStep++
+
+    if (this.currentStep < this.steps.length) {
+      this.spinner = createSpinner(this.steps[this.currentStep])
+      this.spinner.start()
+    }
+  }
+
+  updateText(text: string): void {
+    if (this.spinner) {
+      this.spinner.text = text
+    }
+  }
+
+  succeed(text?: string): void {
+    if (this.spinner) {
+      this.spinner.succeed(text)
+    }
+  }
+
+  fail(text?: string): void {
+    if (this.spinner) {
+      this.spinner.fail(text)
+    }
+  }
+
+  warn(text?: string): void {
+    if (this.spinner) {
+      this.spinner.warn(text)
+    }
+  }
+}