spindb 0.8.1 → 0.9.0

package/README.md

@@ -6,7 +6,7 @@
 
 **Local databases without the Docker baggage.**
 
-Spin up PostgreSQL and MySQL instances for local development. No Docker daemon, no container networking, no volume mounts. Just databases running on localhost, ready in seconds.
+Spin up PostgreSQL, MySQL, and SQLite instances for local development. No Docker daemon, no container networking, no volume mounts. Just databases running on localhost, ready in seconds.
 
 ---
 
@@ -176,11 +176,37 @@ spindb deps check --engine mysql
 
 **Linux users:** MariaDB works as a drop-in replacement for MySQL. If you have MariaDB installed, SpinDB will detect and use it automatically. In a future release, MariaDB will be available as its own engine with support for MariaDB-specific features.
 
+#### SQLite
+
+| | |
+|---|---|
+| Version | 3 (system) |
+| Default port | N/A (file-based) |
+| Data location | Project directory (CWD) |
+| Binary source | System installation |
+
+SQLite is a file-based database—no server process, no ports. Databases are stored in your project directory by default, not `~/.spindb/`. SpinDB tracks registered SQLite databases in a registry file.
+
+```bash
+# Create in current directory
+spindb create mydb --engine sqlite
+
+# Create with custom path
+spindb create mydb --engine sqlite --path ./data/mydb.sqlite
+
+# Connect to it
+spindb connect mydb
+
+# Use litecli for enhanced experience
+spindb connect mydb --litecli
+```
+
+**Note:** Unlike server databases, SQLite databases don't need to be "started" or "stopped"—they're always available as long as the file exists.
+
 ### Planned Engines
 
 | Engine | Type | Status |
 |--------|------|--------|
-| SQLite | File-based | Planned for v1.2 |
 | Redis | In-memory key-value | Planned for v1.2 |
 | MongoDB | Document database | Planned for v1.2 |
 
@@ -195,10 +221,14 @@ spindb deps check --engine mysql
 ```bash
 spindb create mydb                           # PostgreSQL (default)
 spindb create mydb --engine mysql            # MySQL
+spindb create mydb --engine sqlite           # SQLite (file-based)
 spindb create mydb --version 16              # Specific PostgreSQL version
 spindb create mydb --port 5433               # Custom port
 spindb create mydb --database my_app         # Custom database name
 spindb create mydb --no-start                # Create without starting
+
+# SQLite with custom path
+spindb create mydb --engine sqlite --path ./data/app.sqlite
 ```
 
 Create and restore in one command:
@@ -213,10 +243,11 @@ spindb create mydb --from "postgresql://user:pass@host:5432/production"
 
 | Option | Description |
 |--------|-------------|
-| `--engine`, `-e` | Database engine (`postgresql`, `mysql`) |
+| `--engine`, `-e` | Database engine (`postgresql`, `mysql`, `sqlite`) |
 | `--version`, `-v` | Engine version |
-| `--port`, `-p` | Port number |
+| `--port`, `-p` | Port number (not applicable for SQLite) |
 | `--database`, `-d` | Primary database name |
+| `--path` | File path for SQLite databases |
 | `--max-connections` | Maximum database connections (default: 200) |
 | `--from` | Restore from backup file or connection string |
 | `--no-start` | Create without starting |
@@ -333,11 +364,12 @@ spindb clone source-db new-db
 spindb start new-db
 ```
 
-#### `edit` - Rename, change port, or edit database config
+#### `edit` - Rename, change port, relocate, or edit database config
 
 ```bash
 spindb edit mydb --name newname              # Must be stopped
 spindb edit mydb --port 5433
+spindb edit mydb --relocate ~/new/path       # Move SQLite database file
 spindb edit mydb --set-config max_connections=300   # PostgreSQL config
 spindb edit mydb                             # Interactive mode
 ```
@@ -405,6 +437,43 @@ spindb version --check    # Check for updates
 spindb self-update
 ```
 
+#### `doctor` - System health check
+
+```bash
+spindb doctor            # Interactive health check
+spindb doctor --json     # JSON output for scripting
+```
+
+Checks performed:
+- Configuration file validity and binary cache freshness
+- Container status across all engines
+- SQLite registry for orphaned entries (files deleted outside SpinDB)
+- Database tool availability
+
+Example output:
+
+```
+SpinDB Health Check
+═══════════════════
+
+✓ Configuration
+  └─ Configuration valid, 12 tools cached
+
+✓ Containers
+  └─ 4 container(s)
+     postgresql: 2 running, 0 stopped
+     mysql: 0 running, 1 stopped
+     sqlite: 1 exist, 0 missing
+
+⚠ SQLite Registry
+  └─ 1 orphaned entry found
+     "old-project" → /path/to/missing.sqlite
+
+? What would you like to do?
+❯ Remove orphaned entries from registry
+  Skip (do nothing)
+```
+
 ---
 
 ## Enhanced CLI Tools
@@ -415,7 +484,7 @@ SpinDB supports enhanced database shells that provide features like auto-complet
 |--------|----------|----------|-----------|
 | PostgreSQL | `psql` | `pgcli` | `usql` |
 | MySQL | `mysql` | `mycli` | `usql` |
-| SQLite (planned) | `sqlite3` | `litecli` | `usql` |
+| SQLite | `sqlite3` | `litecli` | `usql` |
 | Redis (planned) | `redis-cli` | `iredis` | - |
 | MongoDB (planned) | `mongosh` | - | - |
 
@@ -456,8 +525,13 @@ spindb connect mydb --install-tui      # usql
 │           ├── container.json
 │           ├── data/
 │           └── mysql.log
+├── sqlite-registry.json                    # Tracks SQLite file locations
 ├── logs/                                   # Error logs
 └── config.json                             # Tool paths cache
+
+# SQLite databases are stored in project directories, not ~/.spindb/
+./myproject/
+└── mydb.sqlite                             # Created with: spindb create mydb -e sqlite
 ```
 
 ### How Data Persists
@@ -521,7 +595,6 @@ See [TODO.md](TODO.md) for the full roadmap.
 - Secrets management (macOS Keychain)
 
 ### v1.2 - Additional Engines
-- SQLite (file-based, no server)
 - Redis (in-memory key-value)
 - MongoDB (document database)
 - MariaDB as standalone engine

package/cli/commands/connect.ts

@@ -1,5 +1,6 @@
 import { Command } from 'commander'
 import { spawn } from 'child_process'
+import { existsSync } from 'fs'
 import chalk from 'chalk'
 import { containerManager } from '../../core/container-manager'
 import { processManager } from '../../core/process-manager'
@@ -7,18 +8,22 @@ import {
   isUsqlInstalled,
   isPgcliInstalled,
   isMycliInstalled,
+  isLitecliInstalled,
   detectPackageManager,
   installUsql,
   installPgcli,
   installMycli,
+  installLitecli,
   getUsqlManualInstructions,
   getPgcliManualInstructions,
   getMycliManualInstructions,
+  getLitecliManualInstructions,
 } from '../../core/dependency-manager'
 import { getEngine } from '../../engines'
 import { getEngineDefaults } from '../../config/defaults'
 import { promptContainerSelect } from '../ui/prompts'
 import { error, warning, info, success } from '../ui/theme'
+import { Engine } from '../../types'
 
 export const connectCommand = new Command('connect')
   .alias('shell')
@@ -37,6 +42,11 @@ export const connectCommand = new Command('connect')
     'Use mycli for enhanced MySQL shell (dropdown auto-completion)',
   )
   .option('--install-mycli', 'Install mycli if not present, then connect')
+  .option(
+    '--litecli',
+    'Use litecli for enhanced SQLite shell (auto-completion, syntax highlighting)',
+  )
+  .option('--install-litecli', 'Install litecli if not present, then connect')
   .action(
     async (
       name: string | undefined,
@@ -48,6 +58,8 @@ export const connectCommand = new Command('connect')
         installPgcli?: boolean
         mycli?: boolean
         installMycli?: boolean
+        litecli?: boolean
+        installLitecli?: boolean
       },
     ) => {
       try {
@@ -55,9 +67,15 @@ export const connectCommand = new Command('connect')
 
         if (!containerName) {
           const containers = await containerManager.list()
-          const running = containers.filter((c) => c.status === 'running')
+          // SQLite containers are always "available" if file exists, server containers need to be running
+          const connectable = containers.filter((c) => {
+            if (c.engine === Engine.SQLite) {
+              return existsSync(c.database)
+            }
+            return c.status === 'running'
+          })
 
-          if (running.length === 0) {
+          if (connectable.length === 0) {
             if (containers.length === 0) {
               console.log(
                 warning('No containers found. Create one with: spindb create'),
@@ -73,7 +91,7 @@ export const connectCommand = new Command('connect')
           }
 
           const selected = await promptContainerSelect(
-            running,
+            connectable,
             'Select container to connect to:',
           )
           if (!selected) return
@@ -92,16 +110,29 @@ export const connectCommand = new Command('connect')
         const database =
           options.database ?? config.database ?? engineDefaults.superuser
 
-        const running = await processManager.isRunning(containerName, {
-          engine: engineName,
-        })
-        if (!running) {
-          console.error(
-            error(
-              `Container "${containerName}" is not running. Start it first.`,
-            ),
-          )
-          process.exit(1)
+        // SQLite: check file exists instead of running status
+        if (engineName === Engine.SQLite) {
+          if (!existsSync(config.database)) {
+            console.error(
+              error(
+                `SQLite database file not found: ${config.database}`,
+              ),
+            )
+            process.exit(1)
+          }
+        } else {
+          // Server databases need to be running
+          const running = await processManager.isRunning(containerName, {
+            engine: engineName,
+          })
+          if (!running) {
+            console.error(
+              error(
+                `Container "${containerName}" is not running. Start it first.`,
+              ),
+            )
+            process.exit(1)
+          }
         }
 
         const engine = getEngine(engineName)
@@ -275,13 +306,74 @@ export const connectCommand = new Command('connect')
           }
         }
 
+        const useLitecli = options.litecli || options.installLitecli
+        if (useLitecli) {
+          if (engineName !== Engine.SQLite) {
+            console.error(error('litecli is only available for SQLite containers'))
+            if (engineName === 'postgresql') {
+              console.log(chalk.gray('For PostgreSQL, use: spindb connect --pgcli'))
+            } else if (engineName === 'mysql') {
+              console.log(chalk.gray('For MySQL, use: spindb connect --mycli'))
+            }
+            process.exit(1)
+          }
+
+          const litecliInstalled = await isLitecliInstalled()
+
+          if (!litecliInstalled) {
+            if (options.installLitecli) {
+              console.log(info('Installing litecli for enhanced SQLite shell...'))
+              const pm = await detectPackageManager()
+              if (pm) {
+                const result = await installLitecli(pm)
+                if (result.success) {
+                  console.log(success('litecli installed successfully!'))
+                  console.log()
+                } else {
+                  console.error(
+                    error(`Failed to install litecli: ${result.error}`),
+                  )
+                  console.log()
+                  console.log(chalk.gray('Manual installation:'))
+                  for (const instruction of getLitecliManualInstructions()) {
+                    console.log(chalk.cyan(`  ${instruction}`))
+                  }
+                  process.exit(1)
+                }
+              } else {
+                console.error(error('No supported package manager found'))
+                console.log()
+                console.log(chalk.gray('Manual installation:'))
+                for (const instruction of getLitecliManualInstructions()) {
+                  console.log(chalk.cyan(`  ${instruction}`))
+                }
+                process.exit(1)
+              }
+            } else {
+              console.error(error('litecli is not installed'))
+              console.log()
+              console.log(chalk.gray('Install litecli for enhanced SQLite shell:'))
+              console.log(chalk.cyan('  spindb connect --install-litecli'))
+              console.log()
+              console.log(chalk.gray('Or install manually:'))
+              for (const instruction of getLitecliManualInstructions()) {
+                console.log(chalk.cyan(`  ${instruction}`))
+              }
+              process.exit(1)
+            }
+          }
+        }
+
         console.log(info(`Connecting to ${containerName}:${database}...`))
         console.log()
 
         let clientCmd: string
         let clientArgs: string[]
 
-        if (usePgcli) {
+        if (useLitecli) {
+          clientCmd = 'litecli'
+          clientArgs = [config.database]
+        } else if (usePgcli) {
           clientCmd = 'pgcli'
           clientArgs = [connectionString]
         } else if (useMycli) {
@@ -298,6 +390,9 @@ export const connectCommand = new Command('connect')
         } else if (useUsql) {
           clientCmd = 'usql'
           clientArgs = [connectionString]
+        } else if (engineName === Engine.SQLite) {
+          clientCmd = 'sqlite3'
+          clientArgs = [config.database]
         } else if (engineName === 'mysql') {
           clientCmd = 'mysql'
           clientArgs = [
@@ -339,6 +434,12 @@ export const connectCommand = new Command('connect')
             } else if (clientCmd === 'mycli') {
               console.log(chalk.gray('  Install mycli:'))
               console.log(chalk.cyan('  brew install mycli'))
+            } else if (clientCmd === 'litecli') {
+              console.log(chalk.gray('  Install litecli:'))
+              console.log(chalk.cyan('  brew install litecli'))
+            } else if (clientCmd === 'sqlite3') {
+              console.log(chalk.gray('  sqlite3 comes with macOS.'))
+              console.log(chalk.gray('  If not available, check your PATH.'))
             } else if (engineName === 'mysql') {
               console.log(chalk.gray('  On macOS with Homebrew:'))
               console.log(chalk.cyan('  brew install mysql-client'))

package/cli/commands/create.ts

@@ -21,6 +21,96 @@ import { platformService } from '../../core/platform-service'
 import { startWithRetry } from '../../core/start-with-retry'
 import { TransactionManager } from '../../core/transaction-manager'
 import { Engine } from '../../types'
+import type { BaseEngine } from '../../engines/base-engine'
+import { resolve } from 'path'
+
+/**
+ * Simplified SQLite container creation flow
+ * SQLite is file-based, so no port, start/stop, or server management needed
+ */
+async function createSqliteContainer(
+  containerName: string,
+  dbEngine: BaseEngine,
+  version: string,
+  options: { path?: string; from?: string | null },
+): Promise<void> {
+  const { path: filePath, from: restoreLocation } = options
+
+  // Check dependencies
+  const depsSpinner = createSpinner('Checking required tools...')
+  depsSpinner.start()
+
+  const missingDeps = await getMissingDependencies('sqlite')
+  if (missingDeps.length > 0) {
+    depsSpinner.warn(`Missing tools: ${missingDeps.map((d) => d.name).join(', ')}`)
+    const installed = await promptInstallDependencies(missingDeps[0].binary, 'sqlite')
+    if (!installed) {
+      process.exit(1)
+    }
+  } else {
+    depsSpinner.succeed('Required tools available')
+  }
+
+  // Check if container already exists
+  while (await containerManager.exists(containerName)) {
+    console.log(chalk.yellow(`  Container "${containerName}" already exists.`))
+    containerName = await promptContainerName()
+  }
+
+  // Determine file path
+  const defaultPath = `./${containerName}.sqlite`
+  const absolutePath = resolve(filePath || defaultPath)
+
+  // Check if file already exists
+  if (existsSync(absolutePath)) {
+    console.error(error(`File already exists: ${absolutePath}`))
+    process.exit(1)
+  }
+
+  const createSpinnerInstance = createSpinner('Creating SQLite database...')
+  createSpinnerInstance.start()
+
+  try {
+    // Initialize the SQLite database file and register in registry
+    await dbEngine.initDataDir(containerName, version, { path: absolutePath })
+    createSpinnerInstance.succeed('SQLite database created')
+  } catch (err) {
+    createSpinnerInstance.fail('Failed to create SQLite database')
+    throw err
+  }
+
+  // Handle --from restore
+  if (restoreLocation) {
+    const config = await containerManager.getConfig(containerName)
+    if (config) {
+      const format = await dbEngine.detectBackupFormat(restoreLocation)
+      const restoreSpinner = createSpinner(`Restoring from ${format.description}...`)
+      restoreSpinner.start()
+
+      try {
+        await dbEngine.restore(config, restoreLocation)
+        restoreSpinner.succeed('Backup restored successfully')
+      } catch (err) {
+        restoreSpinner.fail('Failed to restore backup')
+        throw err
+      }
+    }
+  }
+
+  // Display success
+  console.log()
+  console.log(chalk.green('  ✓ SQLite database ready'))
+  console.log()
+  console.log(chalk.gray('  File path:'))
+  console.log(chalk.cyan(`    ${absolutePath}`))
+  console.log()
+  console.log(chalk.gray('  Connection string:'))
+  console.log(chalk.cyan(`    sqlite:///${absolutePath}`))
+  console.log()
+  console.log(chalk.gray('  Connect with:'))
+  console.log(chalk.cyan(`    spindb connect ${containerName}`))
+  console.log()
+}
 
 function detectLocationType(location: string): {
   type: 'connection' | 'file' | 'not_found'
@@ -37,7 +127,15 @@ function detectLocationType(location: string): {
     return { type: 'connection', inferredEngine: Engine.MySQL }
   }
 
+  if (location.startsWith('sqlite://')) {
+    return { type: 'connection', inferredEngine: Engine.SQLite }
+  }
+
   if (existsSync(location)) {
+    // Check if it's a SQLite file
+    if (location.endsWith('.sqlite') || location.endsWith('.db') || location.endsWith('.sqlite3')) {
+      return { type: 'file', inferredEngine: Engine.SQLite }
+    }
     return { type: 'file' }
   }
 
@@ -47,10 +145,14 @@ function detectLocationType(location: string): {
 export const createCommand = new Command('create')
   .description('Create a new database container')
   .argument('[name]', 'Container name')
-  .option('-e, --engine <engine>', 'Database engine (postgresql, mysql)')
+  .option('-e, --engine <engine>', 'Database engine (postgresql, mysql, sqlite)')
   .option('-v, --version <version>', 'Database version')
   .option('-d, --database <database>', 'Database name')
   .option('-p, --port <port>', 'Port number')
+  .option(
+    '--path <path>',
+    'Path for SQLite database file (default: ./<name>.sqlite)',
+  )
   .option(
     '--max-connections <number>',
     'Maximum number of database connections (default: 200)',
@@ -68,6 +170,7 @@ export const createCommand = new Command('create')
         version?: string
         database?: string
         port?: string
+        path?: string
         maxConnections?: string
         start: boolean
         from?: string
@@ -140,6 +243,15 @@ export const createCommand = new Command('create')
 
         const dbEngine = getEngine(engine)
 
+        // SQLite has a simplified flow (no port, no start/stop)
+        if (engine === Engine.SQLite) {
+          await createSqliteContainer(containerName, dbEngine, version, {
+            path: options.path,
+            from: restoreLocation,
+          })
+          return
+        }
+
         const depsSpinner = createSpinner('Checking required tools...')
         depsSpinner.start()