spindb 0.8.1 → 0.9.0

package/cli/ui/prompts.ts

@@ -1,6 +1,9 @@
 import inquirer from 'inquirer'
 import chalk from 'chalk'
 import ora from 'ora'
+import { existsSync, statSync } from 'fs'
+import { resolve, join } from 'path'
+import { homedir } from 'os'
 import { listEngines, getEngine } from '../../engines'
 import { defaults, getEngineDefaults } from '../../config/defaults'
 import { installPostgresBinaries } from '../../engines/postgresql/binary-manager'
@@ -204,35 +207,69 @@ export async function promptConfirm(
 
 /**
  * Prompt for container selection from a list
+ * @param containers - List of containers to choose from
+ * @param message - Prompt message
+ * @param options - Optional settings
+ * @param options.includeBack - Include a back option (returns null when selected)
  */
 export async function promptContainerSelect(
   containers: ContainerConfig[],
   message: string = 'Select container:',
+  options: { includeBack?: boolean } = {},
 ): Promise<string | null> {
   if (containers.length === 0) {
     return null
   }
 
+  type Choice = { name: string; value: string; short?: string }
+  const choices: Choice[] = containers.map((c) => ({
+    name: `${c.name} ${chalk.gray(`(${getEngineIcon(c.engine)} ${c.engine} ${c.version}, port ${c.port})`)} ${
+      c.status === 'running'
+        ? chalk.green('● running')
+        : chalk.gray('○ stopped')
+    }`,
+    value: c.name,
+    short: c.name,
+  }))
+
+  if (options.includeBack) {
+    choices.push({ name: `${chalk.blue('←')} Back`, value: '__back__' })
+  }
+
   const { container } = await inquirer.prompt<{ container: string }>([
     {
       type: 'list',
       name: 'container',
       message,
-      choices: containers.map((c) => ({
-        name: `${c.name} ${chalk.gray(`(${getEngineIcon(c.engine)} ${c.engine} ${c.version}, port ${c.port})`)} ${
-          c.status === 'running'
-            ? chalk.green('● running')
-            : chalk.gray('○ stopped')
-        }`,
-        value: c.name,
-        short: c.name,
-      })),
+      choices,
     },
   ])
 
+  if (container === '__back__') {
+    return null
+  }
+
   return container
 }
 
+/**
+ * Sanitize a string to be a valid database name
+ * Replaces invalid characters with underscores
+ */
+function sanitizeDatabaseName(name: string): string {
+  // Replace invalid characters with underscores
+  let sanitized = name.replace(/[^a-zA-Z0-9_-]/g, '_')
+  // Ensure it starts with a letter or underscore
+  if (sanitized && !/^[a-zA-Z_]/.test(sanitized)) {
+    sanitized = '_' + sanitized
+  }
+  // Collapse multiple underscores
+  sanitized = sanitized.replace(/_+/g, '_')
+  // Trim trailing underscores
+  sanitized = sanitized.replace(/_+$/, '')
+  return sanitized
+}
+
 /**
  * Prompt for database name
  * @param defaultName - Default value for the database name
@@ -246,12 +283,15 @@ export async function promptDatabaseName(
   const label =
     engine === 'mysql' ? 'Database (schema) name:' : 'Database name:'
 
+  // Sanitize the default name to ensure it's valid
+  const sanitizedDefault = defaultName ? sanitizeDatabaseName(defaultName) : undefined
+
   const { database } = await inquirer.prompt<{ database: string }>([
     {
       type: 'input',
       name: 'database',
       message: label,
-      default: defaultName,
+      default: sanitizedDefault,
       validate: (input: string) => {
         if (!input) return 'Database name is required'
         // PostgreSQL database naming rules (also valid for MySQL)
@@ -362,6 +402,111 @@ export type CreateOptions = {
   version: string
   port: number
   database: string
+  path?: string // SQLite file path
+}
+
+/**
+ * Prompt for SQLite database file location
+ * Similar to the relocate logic in container-handlers.ts
+ */
+export async function promptSqlitePath(
+  containerName: string,
+): Promise<string | undefined> {
+  const defaultPath = `./${containerName}.sqlite`
+
+  console.log(chalk.gray('  SQLite databases are stored as files in your project directory.'))
+  console.log(chalk.gray(`  Default: ${defaultPath}`))
+  console.log()
+
+  const { useDefault } = await inquirer.prompt<{ useDefault: string }>([
+    {
+      type: 'list',
+      name: 'useDefault',
+      message: 'Where should the database file be created?',
+      choices: [
+        { name: `Use default location (${defaultPath})`, value: 'default' },
+        { name: 'Specify custom path', value: 'custom' },
+      ],
+    },
+  ])
+
+  if (useDefault === 'default') {
+    return undefined // Use default
+  }
+
+  const { inputPath } = await inquirer.prompt<{ inputPath: string }>([
+    {
+      type: 'input',
+      name: 'inputPath',
+      message: 'File path:',
+      default: defaultPath,
+      validate: (input: string) => {
+        if (!input) return 'Path is required'
+        return true
+      },
+    },
+  ])
+
+  // Expand ~ to home directory
+  let expandedPath = inputPath
+  if (inputPath === '~') {
+    expandedPath = homedir()
+  } else if (inputPath.startsWith('~/')) {
+    expandedPath = join(homedir(), inputPath.slice(2))
+  }
+
+  // Convert relative paths to absolute
+  if (!expandedPath.startsWith('/')) {
+    expandedPath = resolve(process.cwd(), expandedPath)
+  }
+
+  // Check if path looks like a file (has db extension) or directory
+  const hasDbExtension = /\.(sqlite3?|db)$/i.test(expandedPath)
+
+  // Treat as directory if:
+  // - ends with /
+  // - exists and is a directory
+  // - doesn't have a database file extension (assume it's a directory path)
+  const isDirectory =
+    expandedPath.endsWith('/') ||
+    (existsSync(expandedPath) && statSync(expandedPath).isDirectory()) ||
+    !hasDbExtension
+
+  let finalPath: string
+  if (isDirectory) {
+    // Remove trailing slash if present, then append filename
+    const dirPath = expandedPath.endsWith('/')
+      ? expandedPath.slice(0, -1)
+      : expandedPath
+    finalPath = join(dirPath, `${containerName}.sqlite`)
+  } else {
+    finalPath = expandedPath
+  }
+
+  // Check if file already exists
+  if (existsSync(finalPath)) {
+    console.log(chalk.yellow(`  Warning: File already exists: ${finalPath}`))
+    const { overwrite } = await inquirer.prompt<{ overwrite: string }>([
+      {
+        type: 'list',
+        name: 'overwrite',
+        message: 'A file already exists at this location. What would you like to do?',
+        choices: [
+          { name: 'Choose a different path', value: 'different' },
+          { name: 'Cancel', value: 'cancel' },
+        ],
+      },
+    ])
+
+    if (overwrite === 'cancel') {
+      throw new Error('Creation cancelled')
+    }
+
+    // Recursively prompt again
+    return promptSqlitePath(containerName)
+  }
+
+  return finalPath
 }
 
 /**
@@ -375,11 +520,17 @@ export async function promptCreateOptions(): Promise<CreateOptions> {
   const name = await promptContainerName()
   const database = await promptDatabaseName(name, engine) // Default to container name
 
-  // Get engine-specific default port
-  const engineDefaults = getEngineDefaults(engine)
-  const port = await promptPort(engineDefaults.defaultPort)
+  // SQLite is file-based, no port needed but needs path
+  let port = 0
+  let path: string | undefined
+  if (engine === 'sqlite') {
+    path = await promptSqlitePath(name)
+  } else {
+    const engineDefaults = getEngineDefaults(engine)
+    port = await promptPort(engineDefaults.defaultPort)
+  }
 
-  return { name, engine, version, port, database }
+  return { name, engine, version, port, database, path }
 }
 
 /**

package/config/engine-defaults.ts

@@ -59,6 +59,20 @@ export const engineDefaults: Record<string, EngineDefaults> = {
     clientTools: ['mysql', 'mysqldump', 'mysqlpump'],
     maxConnections: 200, // Higher than default 151 for parallel builds
   },
+  sqlite: {
+    defaultVersion: '3',
+    defaultPort: 0, // File-based, no port
+    portRange: { start: 0, end: 0 }, // N/A
+    supportedVersions: ['3'],
+    latestVersion: '3',
+    superuser: '', // No authentication
+    connectionScheme: 'sqlite',
+    logFileName: '', // No log file
+    pidFileName: '', // No PID file (no server process)
+    dataSubdir: '', // File is the data
+    clientTools: ['sqlite3'],
+    maxConnections: 0, // N/A - file-based
+  },
 }
 
 /**

package/config/os-dependencies.ts

@@ -289,6 +289,42 @@ const mysqlDependencies: EngineDependencies = {
   ],
 }
 
+// =============================================================================
+// SQLite Dependencies
+// =============================================================================
+
+const sqliteDependencies: EngineDependencies = {
+  engine: 'sqlite',
+  displayName: 'SQLite',
+  dependencies: [
+    {
+      name: 'sqlite3',
+      binary: 'sqlite3',
+      description: 'SQLite command-line interface',
+      packages: {
+        brew: { package: 'sqlite' },
+        apt: { package: 'sqlite3' },
+        yum: { package: 'sqlite' },
+        dnf: { package: 'sqlite' },
+        pacman: { package: 'sqlite' },
+      },
+      manualInstall: {
+        darwin: [
+          'Install Homebrew: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"',
+          'Then run: brew install sqlite',
+          'Note: macOS includes sqlite3 by default in /usr/bin/sqlite3',
+        ],
+        linux: [
+          'Debian/Ubuntu: sudo apt install sqlite3',
+          'CentOS/RHEL: sudo yum install sqlite',
+          'Fedora: sudo dnf install sqlite',
+          'Arch: sudo pacman -S sqlite',
+        ],
+      },
+    },
+  ],
+}
+
 // =============================================================================
 // Optional Tools (engine-agnostic)
 // =============================================================================
@@ -381,6 +417,35 @@ export const mycliDependency: Dependency = {
   },
 }
 
+/**
+ * litecli - SQLite CLI with auto-completion and syntax highlighting
+ * https://github.com/dbcli/litecli
+ */
+export const litecliDependency: Dependency = {
+  name: 'litecli',
+  binary: 'litecli',
+  description:
+    'SQLite CLI with intelligent auto-completion and syntax highlighting',
+  packages: {
+    brew: { package: 'litecli' },
+    apt: { package: 'litecli' },
+    dnf: { package: 'litecli' },
+    yum: { package: 'litecli' },
+    pacman: { package: 'litecli' },
+  },
+  manualInstall: {
+    darwin: [
+      'Install with Homebrew: brew install litecli',
+      'Or with pip: pip install litecli',
+    ],
+    linux: [
+      'Debian/Ubuntu: sudo apt install litecli',
+      'Fedora: sudo dnf install litecli',
+      'Or with pip: pip install litecli',
+    ],
+  },
+}
+
 // =============================================================================
 // Registry
 // =============================================================================
@@ -391,6 +456,7 @@ export const mycliDependency: Dependency = {
 export const engineDependencies: EngineDependencies[] = [
   postgresqlDependencies,
   mysqlDependencies,
+  sqliteDependencies,
 ]
 
 /**

package/config/paths.ts

@@ -114,4 +114,12 @@ export const paths = {
   getEngineContainersPath(engine: string): string {
     return join(this.containers, engine)
   },
+
+  /**
+   * Get path for SQLite registry file
+   * SQLite uses a registry (not container directories) since databases are stored externally
+   */
+  getSqliteRegistryPath(): string {
+    return join(this.root, 'sqlite-registry.json')
+  },
 }

package/core/container-manager.ts

@@ -1,10 +1,11 @@
 import { existsSync } from 'fs'
-import { mkdir, readdir, readFile, writeFile, rm, cp } from 'fs/promises'
+import { mkdir, readdir, readFile, writeFile, rm, cp, unlink } from 'fs/promises'
 import { paths } from '../config/paths'
 import { processManager } from './process-manager'
 import { portManager } from './port-manager'
 import { getEngineDefaults, getSupportedEngines } from '../config/defaults'
 import { getEngine } from '../engines'
+import { sqliteRegistry } from '../engines/sqlite/registry'
 import type { ContainerConfig } from '../types'
 import { Engine } from '../types'
 
@@ -74,6 +75,11 @@ export class ContainerManager {
     const { engine } = options || {}
 
     if (engine) {
+      // SQLite uses registry instead of filesystem
+      if (engine === 'sqlite') {
+        return this.getSqliteConfig(name)
+      }
+
       // Look in specific engine directory
       const configPath = paths.getContainerConfigPath(name, { engine })
       if (!existsSync(configPath)) {
@@ -84,8 +90,14 @@ export class ContainerManager {
       return this.migrateConfig(config)
     }
 
-    // Search all engine directories
-    const engines = getSupportedEngines()
+    // Search SQLite registry first
+    const sqliteConfig = await this.getSqliteConfig(name)
+    if (sqliteConfig) {
+      return sqliteConfig
+    }
+
+    // Search all engine directories (excluding sqlite which uses registry)
+    const engines = getSupportedEngines().filter((e) => e !== 'sqlite')
     for (const eng of engines) {
       const configPath = paths.getContainerConfigPath(name, { engine: eng })
       if (existsSync(configPath)) {
@@ -98,6 +110,29 @@ export class ContainerManager {
     return null
   }
 
+  /**
+   * Get SQLite container config from registry
+   */
+  private async getSqliteConfig(name: string): Promise<ContainerConfig | null> {
+    const entry = await sqliteRegistry.get(name)
+    if (!entry) {
+      return null
+    }
+
+    // Convert registry entry to ContainerConfig format
+    const fileExists = existsSync(entry.filePath)
+    return {
+      name: entry.name,
+      engine: Engine.SQLite,
+      version: '3',
+      port: 0,
+      database: entry.filePath, // For SQLite, database field stores file path
+      databases: [entry.filePath],
+      created: entry.created,
+      status: fileExists ? 'running' : 'stopped', // "running" = file exists
+    }
+  }
+
   /**
    * Migrate old container configs to include databases array
    * Ensures primary database is always in the databases array
@@ -165,12 +200,21 @@ export class ContainerManager {
     const { engine } = options || {}
 
     if (engine) {
+      // SQLite uses registry
+      if (engine === 'sqlite') {
+        return sqliteRegistry.exists(name)
+      }
       const configPath = paths.getContainerConfigPath(name, { engine })
       return existsSync(configPath)
     }
 
-    // Check all engine directories
-    const engines = getSupportedEngines()
+    // Check SQLite registry first
+    if (await sqliteRegistry.exists(name)) {
+      return true
+    }
+
+    // Check all engine directories (excluding sqlite)
+    const engines = getSupportedEngines().filter((e) => e !== 'sqlite')
     for (const eng of engines) {
       const configPath = paths.getContainerConfigPath(name, { engine: eng })
       if (existsSync(configPath)) {
@@ -185,14 +229,31 @@ export class ContainerManager {
    * List all containers across all engines
    */
   async list(): Promise<ContainerConfig[]> {
-    const containersDir = paths.containers
+    const containers: ContainerConfig[] = []
 
+    // List SQLite containers from registry
+    const sqliteEntries = await sqliteRegistry.list()
+    for (const entry of sqliteEntries) {
+      const fileExists = existsSync(entry.filePath)
+      containers.push({
+        name: entry.name,
+        engine: Engine.SQLite,
+        version: '3',
+        port: 0,
+        database: entry.filePath,
+        databases: [entry.filePath],
+        created: entry.created,
+        status: fileExists ? 'running' : 'stopped', // "running" = file exists
+      })
+    }
+
+    // List server-based containers (PostgreSQL, MySQL)
+    const containersDir = paths.containers
     if (!existsSync(containersDir)) {
-      return []
+      return containers
     }
 
-    const containers: ContainerConfig[] = []
-    const engines = getSupportedEngines()
+    const engines = getSupportedEngines().filter((e) => e !== 'sqlite')
 
     for (const engine of engines) {
       const engineDir = paths.getEngineContainersPath(engine)
@@ -236,7 +297,23 @@ export class ContainerManager {
 
     const { engine } = config
 
-    // Check if running
+    // SQLite: delete file, remove from registry, and clean up container directory
+    if (engine === Engine.SQLite) {
+      const entry = await sqliteRegistry.get(name)
+      if (entry && existsSync(entry.filePath)) {
+        await unlink(entry.filePath)
+      }
+      await sqliteRegistry.remove(name)
+
+      // Also remove the container directory (created by containerManager.create)
+      const containerPath = paths.getContainerPath(name, { engine })
+      if (existsSync(containerPath)) {
+        await rm(containerPath, { recursive: true, force: true })
+      }
+      return
+    }
+
+    // Server databases: check if running first
     const running = await processManager.isRunning(name, { engine })
     if (running && !force) {
       throw new Error(
@@ -335,7 +412,38 @@ export class ContainerManager {
       throw new Error(`Container "${newName}" already exists`)
     }
 
-    // Check container is not running
+    // SQLite: rename in registry and handle container directory
+    if (engine === Engine.SQLite) {
+      const entry = await sqliteRegistry.get(oldName)
+      if (!entry) {
+        throw new Error(`SQLite container "${oldName}" not found in registry`)
+      }
+
+      // Remove old entry and add new one with updated name
+      await sqliteRegistry.remove(oldName)
+      await sqliteRegistry.add({
+        name: newName,
+        filePath: entry.filePath,
+        created: entry.created,
+        lastVerified: entry.lastVerified,
+      })
+
+      // Rename container directory if it exists (created by containerManager.create)
+      const oldContainerPath = paths.getContainerPath(oldName, { engine })
+      const newContainerPath = paths.getContainerPath(newName, { engine })
+      if (existsSync(oldContainerPath)) {
+        await cp(oldContainerPath, newContainerPath, { recursive: true })
+        await rm(oldContainerPath, { recursive: true, force: true })
+      }
+
+      // Return updated config
+      return {
+        ...sourceConfig,
+        name: newName,
+      }
+    }
+
+    // Server databases: check container is not running
     const running = await processManager.isRunning(oldName, { engine })
     if (running) {
       throw new Error(`Container "${oldName}" is running. Stop it first`)

package/core/dependency-manager.ts

@@ -18,6 +18,7 @@ import {
   usqlDependency,
   pgcliDependency,
   mycliDependency,
+  litecliDependency,
 } from '../config/os-dependencies'
 import { platformService } from './platform-service'
 import { configManager } from './config-manager'
@@ -398,3 +399,20 @@ export function getMycliManualInstructions(
 ): string[] {
   return getManualInstallInstructions(mycliDependency, platform)
 }
+
+export async function isLitecliInstalled(): Promise<boolean> {
+  const status = await checkDependency(litecliDependency)
+  return status.installed
+}
+
+export async function installLitecli(
+  packageManager: DetectedPackageManager,
+): Promise<InstallResult> {
+  return installDependency(litecliDependency, packageManager)
+}
+
+export function getLitecliManualInstructions(
+  platform: Platform = getCurrentPlatform(),
+): string[] {
+  return getManualInstallInstructions(litecliDependency, platform)
+}

package/engines/index.ts

@@ -1,5 +1,6 @@
 import { postgresqlEngine } from './postgresql'
 import { mysqlEngine } from './mysql'
+import { sqliteEngine } from './sqlite'
 import type { BaseEngine } from './base-engine'
 import type { EngineInfo } from '../types'
 
@@ -14,6 +15,9 @@ export const engines: Record<string, BaseEngine> = {
   // MySQL and aliases
   mysql: mysqlEngine,
   mariadb: mysqlEngine, // MariaDB is MySQL-compatible
+  // SQLite and aliases
+  sqlite: sqliteEngine,
+  lite: sqliteEngine,
 }
 
 /**