spindb 0.37.2 → 0.38.0

package/cli/commands/run.ts

@@ -1,178 +0,0 @@
-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 { promptInstallDependencies } from '../ui/prompts'
-import { uiError, uiWarning } from '../ui/theme'
-import { getMissingDependencies } from '../../core/dependency-manager'
-import { Engine, isFileBasedEngine } from '../../types'
-
-export const runCommand = new Command('run')
-  .description('Run script file or command against a container')
-  .argument('<name>', 'Container name')
-  .argument(
-    '[file]',
-    'Path to script file (SQL for relational DBs, Redis commands, etc.)',
-  )
-  .option('-d, --database <name>', 'Target database (defaults to primary)')
-  .option('-c, --command <cmd>', 'Command to execute (alternative to file)')
-  .option('--sql <statement>', 'Alias for --command (deprecated)')
-  .action(
-    async (
-      name: string,
-      file: string | undefined,
-      options: { database?: string; command?: string; sql?: string },
-    ) => {
-      // Deprecation warning for --sql option
-      if (options.sql) {
-        console.warn(
-          uiWarning(
-            'The --sql option is deprecated. Use -c/--command instead.',
-          ),
-        )
-      }
-
-      // Support both --command and --sql (deprecated alias)
-      // Prefer explicit --command over deprecated --sql
-      const command = options.command || options.sql
-
-      try {
-        const containerName = name
-
-        const config = await containerManager.getConfig(containerName)
-        if (!config) {
-          console.error(uiError(`Container "${containerName}" not found`))
-          process.exit(1)
-        }
-
-        const { engine: engineName } = config
-
-        // File-based databases: check file exists instead of running status
-        if (isFileBasedEngine(engineName)) {
-          if (!existsSync(config.database)) {
-            console.error(
-              uiError(`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(
-              uiError(
-                `Container "${containerName}" is not running. Start it first with: spindb start ${containerName}`,
-              ),
-            )
-            process.exit(1)
-          }
-        }
-
-        if (file && command) {
-          console.error(
-            uiError(
-              'Cannot specify both a file and --command option. Choose one.',
-            ),
-          )
-          process.exit(1)
-        }
-
-        if (!file && !command) {
-          console.error(
-            uiError('Must provide either a script file or --command option'),
-          )
-          console.log(chalk.gray('  Usage: spindb run <container> <file>'))
-          console.log(
-            chalk.gray('     or: spindb run <container> -c "command"'),
-          )
-          process.exit(1)
-        }
-
-        if (file && !existsSync(file)) {
-          console.error(uiError(`Script file not found: ${file}`))
-          process.exit(1)
-        }
-
-        const engine = getEngine(engineName)
-
-        let missingDeps = await getMissingDependencies(engineName)
-        if (missingDeps.length > 0) {
-          console.log(
-            uiWarning(
-              `Missing tools: ${missingDeps.map((d) => d.name).join(', ')}`,
-            ),
-          )
-
-          const installed = await promptInstallDependencies(
-            missingDeps[0].binary,
-            engineName,
-          )
-
-          if (!installed) {
-            process.exit(1)
-          }
-
-          missingDeps = await getMissingDependencies(engineName)
-          if (missingDeps.length > 0) {
-            console.error(
-              uiError(
-                `Still missing tools: ${missingDeps.map((d) => d.name).join(', ')}`,
-              ),
-            )
-            process.exit(1)
-          }
-
-          console.log(chalk.green('  ✓ All required tools are now available'))
-          console.log()
-        }
-
-        const database = options.database || config.database
-
-        await engine.runScript(config, {
-          file,
-          sql: command,
-          database,
-        })
-      } catch (error) {
-        const e = error as Error
-
-        // Map of tool patterns to their engines
-        const toolPatternToEngine: Record<string, Engine> = {
-          'psql not found': Engine.PostgreSQL,
-          'mysql not found': Engine.MySQL,
-          'mysql client not found': Engine.MySQL,
-          'redis-cli not found': Engine.Redis,
-          'mongosh not found': Engine.MongoDB,
-          'sqlite3 not found': Engine.SQLite,
-        }
-
-        const matchingPattern = Object.keys(toolPatternToEngine).find((p) =>
-          e.message.toLowerCase().includes(p.toLowerCase()),
-        )
-
-        if (matchingPattern) {
-          const missingTool = matchingPattern
-            .replace(' not found', '')
-            .replace(' client', '')
-          const toolEngine = toolPatternToEngine[matchingPattern]
-          const installed = await promptInstallDependencies(
-            missingTool,
-            toolEngine,
-          )
-          if (installed) {
-            console.log(
-              chalk.yellow('  Please re-run your command to continue.'),
-            )
-          }
-          process.exit(1)
-        }
-
-        console.error(uiError(e.message))
-        process.exit(1)
-      }
-    },
-  )

package/cli/commands/self-update.ts

@@ -1,121 +0,0 @@
-import { Command } from 'commander'
-import { execSync } from 'child_process'
-import chalk from 'chalk'
-import inquirer from 'inquirer'
-import { updateManager } from '../../core/update-manager'
-import { createSpinner } from '../ui/spinner'
-import { uiSuccess, uiError, uiInfo, header } from '../ui/theme'
-
-export const selfUpdateCommand = new Command('self-update')
-  .alias('update')
-  .description('Update spindb to the latest version')
-  .option('-f, --force', 'Update even if already on latest version')
-  .option('-y, --yes', 'Skip confirmation prompt')
-  .action(
-    async (options: { force?: boolean; yes?: boolean }): Promise<void> => {
-      console.log()
-      console.log(header('SpinDB Self-Update'))
-      console.log()
-
-      const checkSpinner = createSpinner('Checking for updates...')
-      checkSpinner.start()
-
-      const result = await updateManager.checkForUpdate(true)
-
-      if (!result) {
-        checkSpinner.fail('Could not reach npm registry')
-        console.log()
-        console.log(uiInfo('Check your internet connection and try again.'))
-        const pm = await updateManager.detectPackageManager()
-        const manualCmd = updateManager.getInstallCommand(pm)
-        console.log(chalk.gray(`  Manual update: ${manualCmd}`))
-        process.exit(1)
-      }
-
-      if (!result.updateAvailable && !options.force) {
-        checkSpinner.succeed('Already on latest version')
-        console.log()
-        console.log(chalk.gray(`  Current version: ${result.currentVersion}`))
-        console.log(chalk.gray(`  Latest version:  ${result.latestVersion}`))
-        console.log()
-        return
-      }
-
-      if (result.updateAvailable) {
-        checkSpinner.succeed('Update available')
-      } else {
-        checkSpinner.succeed('Version check complete')
-      }
-
-      console.log()
-      console.log(chalk.gray(`  Current version: ${result.currentVersion}`))
-      console.log(
-        chalk.gray(
-          `  Latest version:  ${result.updateAvailable ? chalk.green(result.latestVersion) : result.latestVersion}`,
-        ),
-      )
-      console.log()
-
-      // Confirm unless --yes
-      if (!options.yes) {
-        const message = result.updateAvailable
-          ? `Update spindb from ${result.currentVersion} to ${result.latestVersion}?`
-          : `Reinstall spindb ${result.currentVersion}?`
-
-        const { confirm } = await inquirer.prompt<{ confirm: boolean }>([
-          {
-            type: 'confirm',
-            name: 'confirm',
-            message,
-            default: true,
-          },
-        ])
-
-        if (!confirm) {
-          console.log(chalk.yellow('Update cancelled'))
-          return
-        }
-      }
-
-      console.log()
-      const updateSpinner = createSpinner('Updating spindb...')
-      updateSpinner.start()
-
-      const updateResult = await updateManager.performUpdate()
-
-      if (updateResult.success) {
-        updateSpinner.succeed('Update complete')
-        console.log()
-        console.log(
-          uiSuccess(
-            `Updated from ${updateResult.previousVersion} to ${updateResult.newVersion}`,
-          ),
-        )
-        console.log()
-
-        // Verify the new version by running spindb --version in a new process
-        // (new process loads the updated code)
-        if (updateResult.previousVersion !== updateResult.newVersion) {
-          try {
-            const versionOutput = execSync('spindb --version', {
-              encoding: 'utf-8',
-              cwd: '/',
-            }).trim()
-            console.log(chalk.gray(`  Verified: ${versionOutput}`))
-            console.log()
-          } catch {
-            // Verification failed, but update succeeded
-            console.log(
-              chalk.gray('  Run "spindb --version" to verify the update.'),
-            )
-            console.log()
-          }
-        }
-      } else {
-        updateSpinner.fail('Update failed')
-        console.log()
-        console.log(uiError(updateResult.error || 'Unknown error'))
-        process.exit(1)
-      }
-    },
-  )

package/cli/commands/sqlite.ts

@@ -1,273 +0,0 @@
-import { Command } from 'commander'
-import chalk from 'chalk'
-import { existsSync } from 'fs'
-import { resolve, basename } from 'path'
-import { sqliteRegistry } from '../../engines/sqlite/registry'
-import {
-  scanForUnregisteredSqliteFiles,
-  deriveContainerName,
-} from '../../engines/sqlite/scanner'
-import {
-  isValidExtensionForEngine,
-  formatExtensionsForEngine,
-} from '../../engines/file-based-utils'
-import { containerManager } from '../../core/container-manager'
-import { uiSuccess, uiError, uiInfo } from '../ui/theme'
-import { Engine } from '../../types'
-import { detachCommand } from './detach'
-
-export const sqliteCommand = new Command('sqlite').description(
-  'SQLite-specific operations',
-)
-
-// sqlite scan
-sqliteCommand
-  .command('scan')
-  .description('Scan folder for unregistered SQLite files')
-  .option('-p, --path <dir>', 'Directory to scan (default: current directory)')
-  .option('--json', 'Output as JSON')
-  .action(async (options: { path?: string; json?: boolean }): Promise<void> => {
-    const dir = options.path ? resolve(options.path) : process.cwd()
-
-    if (!existsSync(dir)) {
-      if (options.json) {
-        console.log(
-          JSON.stringify({ error: 'Directory not found', directory: dir }),
-        )
-      } else {
-        console.error(uiError(`Directory not found: ${dir}`))
-      }
-      process.exit(1)
-    }
-
-    const unregistered = await scanForUnregisteredSqliteFiles(dir)
-
-    if (options.json) {
-      console.log(JSON.stringify({ directory: dir, files: unregistered }))
-      return
-    }
-
-    if (unregistered.length === 0) {
-      console.log(uiInfo(`No unregistered SQLite files found in ${dir}`))
-      return
-    }
-
-    console.log(
-      chalk.cyan(`Found ${unregistered.length} unregistered SQLite file(s):`),
-    )
-    for (const file of unregistered) {
-      console.log(chalk.gray(`  ${file.fileName}`))
-    }
-    console.log()
-    console.log(chalk.gray('  Register with: spindb attach <path>'))
-  })
-
-// sqlite ignore
-sqliteCommand
-  .command('ignore')
-  .description('Add folder to ignore list for CWD scanning')
-  .argument('[folder]', 'Folder path to ignore (default: current directory)')
-  .option('--json', 'Output as JSON')
-  .action(
-    async (
-      folder: string | undefined,
-      options: { json?: boolean },
-    ): Promise<void> => {
-      const absolutePath = resolve(folder || process.cwd())
-      await sqliteRegistry.addIgnoreFolder(absolutePath)
-
-      if (options.json) {
-        console.log(JSON.stringify({ success: true, folder: absolutePath }))
-      } else {
-        console.log(uiSuccess(`Added to ignore list: ${absolutePath}`))
-      }
-    },
-  )
-
-// sqlite unignore
-sqliteCommand
-  .command('unignore')
-  .description('Remove folder from ignore list')
-  .argument('[folder]', 'Folder path to unignore (default: current directory)')
-  .option('--json', 'Output as JSON')
-  .action(
-    async (
-      folder: string | undefined,
-      options: { json?: boolean },
-    ): Promise<void> => {
-      const absolutePath = resolve(folder || process.cwd())
-      const removed = await sqliteRegistry.removeIgnoreFolder(absolutePath)
-
-      if (options.json) {
-        console.log(JSON.stringify({ success: removed, folder: absolutePath }))
-      } else {
-        if (removed) {
-          console.log(uiSuccess(`Removed from ignore list: ${absolutePath}`))
-        } else {
-          console.log(uiInfo(`Folder was not in ignore list: ${absolutePath}`))
-        }
-      }
-    },
-  )
-
-// sqlite ignored (list ignored folders)
-sqliteCommand
-  .command('ignored')
-  .description('List ignored folders')
-  .option('--json', 'Output as JSON')
-  .action(async (options: { json?: boolean }): Promise<void> => {
-    const folders = await sqliteRegistry.listIgnoredFolders()
-
-    if (options.json) {
-      console.log(JSON.stringify({ folders }))
-      return
-    }
-
-    if (folders.length === 0) {
-      console.log(uiInfo('No folders are being ignored'))
-      return
-    }
-
-    console.log(chalk.cyan('Ignored folders:'))
-    for (const folder of folders) {
-      console.log(chalk.gray(`  ${folder}`))
-    }
-  })
-
-// sqlite attach (alias to top-level attach)
-sqliteCommand
-  .command('attach')
-  .description(
-    'Register an existing SQLite database (alias for "spindb attach")',
-  )
-  .argument('<path>', 'Path to SQLite database file')
-  .option('-n, --name <name>', 'Container name')
-  .option('--json', 'Output as JSON')
-  .action(
-    async (
-      path: string,
-      options: { name?: string; json?: boolean },
-    ): Promise<void> => {
-      try {
-        const absolutePath = resolve(path)
-
-        // Validate extension matches SQLite
-        if (!isValidExtensionForEngine(absolutePath, Engine.SQLite)) {
-          const msg = `File extension must be one of: ${formatExtensionsForEngine(Engine.SQLite)}`
-          if (options.json) {
-            console.log(JSON.stringify({ success: false, error: msg }))
-          } else {
-            console.error(uiError(msg))
-            console.log(
-              chalk.gray(
-                '  For DuckDB files, use: spindb duckdb attach <path>',
-              ),
-            )
-          }
-          process.exit(1)
-        }
-
-        if (!existsSync(absolutePath)) {
-          if (options.json) {
-            console.log(
-              JSON.stringify({ success: false, error: 'File not found' }),
-            )
-          } else {
-            console.error(uiError(`File not found: ${absolutePath}`))
-          }
-          process.exit(1)
-        }
-
-        if (await sqliteRegistry.isPathRegistered(absolutePath)) {
-          const entry = await sqliteRegistry.getByPath(absolutePath)
-          if (options.json) {
-            console.log(
-              JSON.stringify({
-                success: false,
-                error: 'Already registered',
-                existingName: entry?.name,
-              }),
-            )
-          } else {
-            console.error(
-              uiError(`File is already registered as "${entry?.name}"`),
-            )
-          }
-          process.exit(1)
-        }
-
-        const containerName =
-          options.name || deriveContainerName(basename(absolutePath))
-
-        if (await containerManager.exists(containerName)) {
-          if (options.json) {
-            console.log(
-              JSON.stringify({
-                success: false,
-                error: 'Container name already exists',
-              }),
-            )
-          } else {
-            console.error(
-              uiError(`Container "${containerName}" already exists`),
-            )
-          }
-          process.exit(1)
-        }
-
-        await sqliteRegistry.add({
-          name: containerName,
-          filePath: absolutePath,
-          created: new Date().toISOString(),
-        })
-
-        if (options.json) {
-          console.log(
-            JSON.stringify({
-              success: true,
-              name: containerName,
-              filePath: absolutePath,
-            }),
-          )
-        } else {
-          console.log(
-            uiSuccess(
-              `Registered "${basename(absolutePath)}" as "${containerName}"`,
-            ),
-          )
-          console.log()
-          console.log(chalk.gray('  Connect with:'))
-          console.log(chalk.cyan(`    spindb connect ${containerName}`))
-        }
-      } catch (error) {
-        const e = error as Error
-        if (options.json) {
-          console.log(JSON.stringify({ success: false, error: e.message }))
-        } else {
-          console.error(uiError(e.message))
-        }
-        process.exit(1)
-      }
-    },
-  )
-
-// sqlite detach (alias to top-level detach)
-sqliteCommand
-  .command('detach')
-  .description('Unregister a SQLite database (alias for "spindb detach")')
-  .argument('<name>', 'Container name')
-  .option('-f, --force', 'Skip confirmation')
-  .option('--json', 'Output as JSON')
-  .action(
-    async (
-      name: string,
-      options: { force?: boolean; json?: boolean },
-    ): Promise<void> => {
-      // Build args array
-      const args = ['node', 'detach', name]
-      if (options.force) args.push('-f')
-      if (options.json) args.push('--json')
-
-      await detachCommand.parseAsync(args, { from: 'node' })
-    },
-  )