@dboio/cli 0.4.2 → 0.5.1

package/src/commands/install.js

@@ -1,44 +1,185 @@
 import { Command } from 'commander';
 import { readdir, readFile, writeFile, mkdir, access, copyFile } from 'fs/promises';
-import { join, dirname, basename } from 'path';
+import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { execSync } from 'child_process';
+import { createHash } from 'crypto';
+import { homedir } from 'os';
 import { log } from '../lib/logger.js';
+import { getPluginScope, setPluginScope, isInitialized, removeFromGitignore } from '../lib/config.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
+const CLI_ROOT = join(__dirname, '..', '..');
 const PLUGINS_DIR = join(__dirname, '..', 'plugins', 'claudecommands');
 
 async function fileExists(path) {
   try { await access(path); return true; } catch { return false; }
 }
 
+function fileHash(content) {
+  return createHash('md5').update(content).digest('hex');
+}
+
+/**
+ * Get the target commands directory based on scope.
+ * @param {'project' | 'global'} scope
+ * @returns {string} Absolute path to commands directory
+ */
+function getCommandsDir(scope) {
+  if (scope === 'global') {
+    return join(homedir(), '.claude', 'commands');
+  }
+  return join(process.cwd(), '.claude', 'commands');
+}
+
+/**
+ * Get plugin name from filename (strips .md extension).
+ */
+function getPluginName(filename) {
+  return filename.replace(/\.md$/, '');
+}
+
+/**
+ * Prompt user for plugin installation scope.
+ * @param {string} pluginName - Name of the plugin (without .md)
+ * @returns {Promise<'project' | 'global'>}
+ */
+async function promptForScope(pluginName) {
+  const inquirer = (await import('inquirer')).default;
+  const { scope } = await inquirer.prompt([{
+    type: 'list',
+    name: 'scope',
+    message: `Where should the "${pluginName}" command be installed?`,
+    choices: [
+      { name: 'Project directory (.claude/commands/)', value: 'project' },
+      { name: 'User home directory (~/.claude/commands/)', value: 'global' },
+    ],
+    default: 'project',
+  }]);
+  return scope;
+}
+
+/**
+ * Resolve the scope for a plugin based on flags and stored preferences.
+ * Priority: explicit flag > stored preference > prompt.
+ * @param {string} pluginName - Plugin name without .md
+ * @param {object} options - Command options with global/local flags
+ * @returns {Promise<'project' | 'global'>}
+ */
+async function resolvePluginScope(pluginName, options) {
+  if (options.global) return 'global';
+  if (options.local) return 'project';
+
+  const storedScope = await getPluginScope(pluginName);
+  if (storedScope) return storedScope;
+
+  return await promptForScope(pluginName);
+}
+
+/**
+ * Check if plugin exists in both project and global locations.
+ * @param {string} fileName - Plugin filename (with .md)
+ * @returns {Promise<{project: boolean, global: boolean}>}
+ */
+async function checkPluginLocations(fileName) {
+  const projectPath = join(getCommandsDir('project'), fileName);
+  const globalPath = join(getCommandsDir('global'), fileName);
+  return {
+    project: await fileExists(projectPath),
+    global: await fileExists(globalPath),
+  };
+}
+
+/**
+ * Handle conflict when plugin exists in both locations.
+ * @param {string} fileName - Plugin filename
+ * @returns {Promise<'project' | 'global' | 'skip'>}
+ */
+async function handleDualLocation(fileName) {
+  log.warn(`${fileName} exists in both project and global directories.`);
+  const inquirer = (await import('inquirer')).default;
+  const { target } = await inquirer.prompt([{
+    type: 'list',
+    name: 'target',
+    message: `Which location should be updated?`,
+    choices: [
+      { name: 'Project (.claude/commands/)', value: 'project' },
+      { name: 'Global (~/.claude/commands/)', value: 'global' },
+      { name: 'Skip this plugin', value: 'skip' },
+    ],
+  }]);
+  return target;
+}
+
+/**
+ * Parse a target string like "dbo@latest", "dbo@0.4.1", "plugins", "claudecommands", "claudecode",
+ * or a local path like "/path/to/cli/src".
+ */
+function parseTarget(target) {
+  if (!target) return { type: null };
+
+  // Check if it's a local path (starts with / or . or ~)
+  if (target.startsWith('/') || target.startsWith('.') || target.startsWith('~')) {
+    return { type: 'cli-local', path: target };
+  }
+
+  // Check for dbo@version syntax
+  if (target.startsWith('dbo@')) {
+    const version = target.slice(4);
+    return { type: 'cli', version };
+  }
+
+  // Plain targets
+  if (target === 'dbo' || target === 'cli') return { type: 'cli', version: 'latest' };
+  if (target === 'plugins') return { type: 'plugins' };
+  if (target === 'claudecommands') return { type: 'claudecommands' };
+  if (target === 'claudecode') return { type: 'claudecode' };
+
+  // If it looks like a path that exists or contains path separators
+  if (target.includes('/') || target.includes('\\')) {
+    return { type: 'cli-local', path: target };
+  }
+
+  return { type: 'unknown', value: target };
+}
+
 export const installCommand = new Command('install')
-  .description('Install dbo-cli components (Claude Code commands, plugins)')
-  .argument('[target]', 'What to install: claudecode, claudecommands')
-  .option('--claudecommand <name>', 'Install a specific Claude command by name')
+  .description('Install or upgrade dbo-cli, plugins, or Claude Code commands')
+  .argument('[target]', 'What to install: dbo[@version], plugins, claudecommands, claudecode, or a local path')
+  .option('--claudecommand <name>', 'Install/update a specific Claude command by name')
+  .option('-g, --global', 'Install Claude commands to user home directory (~/.claude/commands/)')
+  .option('--local', 'Install Claude commands to project directory (.claude/commands/)')
   .action(async (target, options) => {
     try {
       if (options.claudecommand) {
-        await installSpecificCommand(options.claudecommand);
-      } else if (target === 'claudecode') {
-        await installClaudeCode();
-      } else if (target === 'claudecommands') {
-        await installClaudeCommands();
+        await installOrUpdateSpecificCommand(options.claudecommand, options);
       } else {
-        // Interactive
-        const inquirer = (await import('inquirer')).default;
-        const { choice } = await inquirer.prompt([{
-          type: 'list', name: 'choice',
-          message: 'What would you like to install?',
-          choices: [
-            'Claude Code commands (adds /dbo to Claude Code)',
-            'Claude Code CLI + commands',
-          ],
-        }]);
-        if (choice.includes('CLI')) {
-          await installClaudeCode();
-        } else {
-          await installClaudeCommands();
+        const parsed = parseTarget(target);
+
+        switch (parsed.type) {
+          case 'cli':
+            await installCli(parsed.version);
+            break;
+          case 'cli-local':
+            await installCliFromLocal(parsed.path, options);
+            break;
+          case 'plugins':
+            await installPlugins(options);
+            break;
+          case 'claudecommands':
+            await installOrUpdateClaudeCommands(options);
+            break;
+          case 'claudecode':
+            await installClaudeCode(options);
+            break;
+          case 'unknown':
+            log.error(`Unknown install target: "${parsed.value}"`);
+            log.dim('Available targets: dbo[@version], plugins, claudecommands, claudecode, or a local path');
+            break;
+          default:
+            // Interactive
+            await installInteractive(options);
+            break;
         }
       }
     } catch (err) {
@@ -47,7 +188,199 @@ export const installCommand = new Command('install')
     }
   });
 
-async function installClaudeCode() {
+async function installInteractive(options = {}) {
+  const inquirer = (await import('inquirer')).default;
+  const { choice } = await inquirer.prompt([{
+    type: 'list', name: 'choice',
+    message: 'What would you like to install?',
+    choices: [
+      { name: 'DBO CLI (install or upgrade)', value: 'cli' },
+      { name: 'Claude Code commands (adds /dbo to Claude Code)', value: 'claudecommands' },
+      { name: 'Claude Code CLI + commands', value: 'claudecode' },
+      { name: 'Plugins (Claude commands)', value: 'plugins' },
+    ],
+  }]);
+
+  switch (choice) {
+    case 'cli': await installCli('latest'); break;
+    case 'claudecommands': await installOrUpdateClaudeCommands(options); break;
+    case 'claudecode': await installClaudeCode(options); break;
+    case 'plugins': await installPlugins(options); break;
+  }
+}
+
+// ─── CLI Installation ───────────────────────────────────────────────────────
+
+async function getInstalledVersion() {
+  try {
+    const pkg = JSON.parse(await readFile(join(CLI_ROOT, 'package.json'), 'utf8'));
+    return pkg.version;
+  } catch {
+    return null;
+  }
+}
+
+async function getAvailableVersions() {
+  try {
+    const output = execSync('npm view @dboio/cli versions --json 2>/dev/null', { encoding: 'utf8' });
+    return JSON.parse(output);
+  } catch {
+    return [];
+  }
+}
+
+async function getLatestVersion() {
+  try {
+    const output = execSync('npm view @dboio/cli version 2>/dev/null', { encoding: 'utf8' });
+    return output.trim();
+  } catch {
+    return null;
+  }
+}
+
+async function installCli(version) {
+  const currentVersion = await getInstalledVersion();
+  const isGitRepo = await fileExists(join(CLI_ROOT, '.git'));
+  const isInNodeModules = CLI_ROOT.includes('node_modules');
+
+  // If already installed, prompt for upgrade
+  if (currentVersion) {
+    log.label('Current version', currentVersion);
+
+    if (isGitRepo && !isInNodeModules) {
+      log.info('Detected git-based installation. Use a local path to upgrade from source:');
+      log.dim('  dbo install /path/to/local/cli/src');
+      log.info('Or switch to npm-based install:');
+      log.dim('  npm install -g @dboio/cli');
+      return;
+    }
+
+    // npm-based install — check for upgrade
+    const latestVersion = version === 'latest' ? await getLatestVersion() : version;
+
+    if (!latestVersion) {
+      log.error('Could not fetch version info from npm. Check your network.');
+      return;
+    }
+
+    if (version === 'latest' && latestVersion === currentVersion) {
+      log.success(`Already on the latest version (${currentVersion})`);
+      return;
+    }
+
+    if (latestVersion === currentVersion) {
+      log.success(`Already on version ${currentVersion}`);
+      return;
+    }
+
+    // Prompt for upgrade
+    const inquirer = (await import('inquirer')).default;
+
+    if (version === 'latest') {
+      const { upgrade } = await inquirer.prompt([{
+        type: 'confirm', name: 'upgrade',
+        message: `Upgrade from ${currentVersion} to ${latestVersion}?`,
+        default: true,
+      }]);
+      if (!upgrade) { log.dim('Skipped.'); return; }
+    } else {
+      // Specific version requested — validate it exists
+      const versions = await getAvailableVersions();
+      if (versions.length > 0 && !versions.includes(version)) {
+        log.error(`Version ${version} not found on npm`);
+        log.dim(`Available versions: ${versions.slice(-10).join(', ')}`);
+        return;
+      }
+    }
+
+    log.info(`Installing @dboio/cli@${latestVersion}...`);
+    try {
+      execSync(`npm install -g @dboio/cli@${latestVersion}`, { stdio: 'inherit' });
+      log.success(`dbo-cli upgraded to ${latestVersion}`);
+    } catch (err) {
+      log.error(`npm install failed: ${err.message}`);
+    }
+    return;
+  }
+
+  // Fresh install
+  const targetVersion = version === 'latest' ? '' : `@${version}`;
+  log.info(`Installing @dboio/cli${targetVersion}...`);
+  try {
+    execSync(`npm install -g @dboio/cli${targetVersion}`, { stdio: 'inherit' });
+    log.success('dbo-cli installed');
+    const newVersion = await getInstalledVersion();
+    if (newVersion) log.label('Version', newVersion);
+  } catch (err) {
+    log.error(`npm install failed: ${err.message}`);
+  }
+}
+
+async function installCliFromLocal(localPath, options = {}) {
+  const resolvedPath = resolve(localPath);
+
+  if (!await fileExists(resolvedPath)) {
+    log.error(`Path not found: ${resolvedPath}`);
+    return;
+  }
+
+  // Check for package.json in the local path
+  const pkgPath = join(resolvedPath, 'package.json');
+  if (!await fileExists(pkgPath)) {
+    log.error(`No package.json found at ${resolvedPath}`);
+    log.dim('Provide the path to the dbo-cli root directory (containing package.json).');
+    return;
+  }
+
+  const pkg = JSON.parse(await readFile(pkgPath, 'utf8'));
+  if (pkg.name !== '@dboio/cli') {
+    log.error(`Package at ${resolvedPath} is "${pkg.name}", not "@dboio/cli"`);
+    return;
+  }
+
+  const currentVersion = await getInstalledVersion();
+  const localVersion = pkg.version;
+
+  if (currentVersion) {
+    log.label('Current version', currentVersion);
+    log.label('Local version', localVersion);
+  }
+
+  const inquirer = (await import('inquirer')).default;
+  const { proceed } = await inquirer.prompt([{
+    type: 'confirm', name: 'proceed',
+    message: currentVersion
+      ? `Install dbo-cli from local source (${localVersion}) replacing ${currentVersion}?`
+      : `Install dbo-cli from local source (${localVersion})?`,
+    default: true,
+  }]);
+  if (!proceed) { log.dim('Skipped.'); return; }
+
+  log.info(`Installing from ${resolvedPath}...`);
+  try {
+    execSync('npm install', { cwd: resolvedPath, stdio: 'inherit' });
+    execSync(`npm install -g "${resolvedPath}"`, { stdio: 'inherit' });
+    log.success(`dbo-cli installed from local source (${localVersion})`);
+  } catch (err) {
+    log.error(`Local install failed: ${err.message}`);
+    log.dim('You can also use: cd <path> && npm link');
+    return;
+  }
+
+  // Offer to install/upgrade plugins after CLI install
+  const { installPluginsNow } = await inquirer.prompt([{
+    type: 'confirm', name: 'installPluginsNow',
+    message: 'Install/upgrade Claude Code command plugins?',
+    default: true,
+  }]);
+  if (installPluginsNow) {
+    await installOrUpdateClaudeCommands(options);
+  }
+}
+
+// ─── Claude Code Installation ───────────────────────────────────────────────
+
+async function installClaudeCode(options = {}) {
   // Check if claude is installed
   try {
     const version = execSync('claude --version 2>&1', { encoding: 'utf8' }).trim();
@@ -64,28 +397,21 @@ async function installClaudeCode() {
   }
 
   // Then install commands
-  await installClaudeCommands();
+  await installOrUpdateClaudeCommands(options);
 }
 
-export async function installClaudeCommands() {
-  const cwd = process.cwd();
-  const claudeDir = join(cwd, '.claude');
-  const commandsDir = join(claudeDir, 'commands');
+// ─── Plugins ────────────────────────────────────────────────────────────────
 
-  // Check/create .claude/commands/
-  if (!await fileExists(claudeDir)) {
-    const inquirer = (await import('inquirer')).default;
-    const { create } = await inquirer.prompt([{
-      type: 'confirm', name: 'create',
-      message: 'No .claude/ directory found. Create it for Claude Code integration?',
-      default: true,
-    }]);
-    if (!create) {
-      log.dim('Skipped Claude Code setup.');
-      return;
-    }
-  }
-  await mkdir(commandsDir, { recursive: true });
+async function installPlugins(options = {}) {
+  log.info('Installing plugins...');
+  await installOrUpdateClaudeCommands(options);
+}
+
+// ─── Claude Commands ────────────────────────────────────────────────────────
+
+export async function installOrUpdateClaudeCommands(options = {}) {
+  const cwd = process.cwd();
+  const hasProject = await isInitialized();
 
   // Find all plugin source files
   let pluginFiles;
@@ -102,42 +428,122 @@ export async function installClaudeCommands() {
   }
 
   let installed = 0;
+  let updated = 0;
+  let upToDate = 0;
+  let skipped = 0;
+
   for (const file of pluginFiles) {
+    const pluginName = getPluginName(file);
     const srcPath = join(PLUGINS_DIR, file);
+    const srcContent = await readFile(srcPath, 'utf8');
+
+    // Check if plugin exists in both locations
+    const locations = await checkPluginLocations(file);
+    let targetScope;
+
+    if (locations.project && locations.global) {
+      // Conflict — explicit flags resolve it, otherwise prompt
+      if (options.global) {
+        targetScope = 'global';
+      } else if (options.local) {
+        targetScope = 'project';
+      } else {
+        const choice = await handleDualLocation(file);
+        if (choice === 'skip') {
+          skipped++;
+          continue;
+        }
+        targetScope = choice;
+      }
+    } else {
+      targetScope = await resolvePluginScope(pluginName, options);
+    }
+
+    // Ensure target directory exists (prompt for project .claude/ only if needed)
+    const commandsDir = getCommandsDir(targetScope);
+    if (targetScope === 'project' && !await fileExists(join(cwd, '.claude'))) {
+      const inquirer = (await import('inquirer')).default;
+      const { create } = await inquirer.prompt([{
+        type: 'confirm', name: 'create',
+        message: 'No .claude/ directory found. Create it for Claude Code integration?',
+        default: true,
+      }]);
+      if (!create) {
+        log.dim('Skipped Claude Code setup.');
+        return;
+      }
+    }
+    await mkdir(commandsDir, { recursive: true });
+
+    // Persist the scope preference
+    if (options.global || options.local || !await getPluginScope(pluginName)) {
+      if (hasProject) {
+        await setPluginScope(pluginName, targetScope);
+      } else if (targetScope === 'global') {
+        log.warn(`Cannot persist scope preference (no .dbo/ directory). Run "dbo init" first.`);
+      }
+    }
+
     const destPath = join(commandsDir, file);
+    const scopeLabel = targetScope === 'global' ? '~/.claude/commands/' : '.claude/commands/';
 
-    // Check for existing file
     if (await fileExists(destPath)) {
+      // Already installed — check if upgrade needed
+      const destContent = await readFile(destPath, 'utf8');
+      if (fileHash(srcContent) === fileHash(destContent)) {
+        upToDate++;
+        continue;
+      }
+
+      // File differs — prompt for upgrade
       const inquirer = (await import('inquirer')).default;
-      const { overwrite } = await inquirer.prompt([{
-        type: 'confirm', name: 'overwrite',
-        message: `Overwrite existing .claude/commands/${file}?`,
-        default: false,
+      const { upgrade } = await inquirer.prompt([{
+        type: 'confirm', name: 'upgrade',
+        message: `${scopeLabel}${file} is already installed. Upgrade to latest version?`,
+        default: true,
       }]);
-      if (!overwrite) {
+      if (!upgrade) {
         log.dim(`  Skipped ${file}`);
+        skipped++;
         continue;
       }
-    }
 
-    await copyFile(srcPath, destPath);
-    log.success(`Installed .claude/commands/${file}`);
-    installed++;
+      await copyFile(srcPath, destPath);
+      log.success(`Upgraded ${scopeLabel}${file}`);
+      updated++;
+    } else {
+      // New install
+      await copyFile(srcPath, destPath);
+      log.success(`Installed ${scopeLabel}${file}`);
+      installed++;
+
+      // Only add to gitignore for project-scope installs
+      if (targetScope === 'project') {
+        await addToGitignore(cwd, `.claude/commands/${file}`);
+      }
+    }
 
-    // Add to .gitignore
-    await addToGitignore(cwd, `.claude/commands/${file}`);
+    // If scope changed to global and project copy existed, remove from gitignore
+    if (targetScope === 'global' && locations.project) {
+      await removeFromGitignore(`.claude/commands/${file}`);
+    }
   }
 
-  if (installed > 0) {
-    log.info(`${installed} Claude command(s) installed. Use /dbo in Claude Code.`);
+  if (installed > 0) log.info(`${installed} command(s) installed.`);
+  if (updated > 0) log.info(`${updated} command(s) upgraded.`);
+  if (upToDate > 0) log.dim(`${upToDate} command(s) already up to date.`);
+  if (skipped > 0) log.dim(`${skipped} command(s) skipped.`);
+  if (installed > 0 || updated > 0) {
+    log.info('Use /dbo in Claude Code.');
     log.warn('Note: Commands will be available in new Claude Code sessions (restart any active session).');
-  } else {
-    log.dim('No commands installed.');
   }
 }
 
-async function installSpecificCommand(name) {
+// ─── Specific Command ───────────────────────────────────────────────────────
+
+async function installOrUpdateSpecificCommand(name, options = {}) {
   const fileName = name.endsWith('.md') ? name : `${name}.md`;
+  const pluginName = getPluginName(fileName);
   const srcPath = join(PLUGINS_DIR, fileName);
 
   if (!await fileExists(srcPath)) {
@@ -147,27 +553,78 @@ async function installSpecificCommand(name) {
     return;
   }
 
-  const commandsDir = join(process.cwd(), '.claude', 'commands');
+  const hasProject = await isInitialized();
+
+  // Check for dual location
+  const locations = await checkPluginLocations(fileName);
+  let targetScope;
+
+  if (locations.project && locations.global) {
+    if (options.global) {
+      targetScope = 'global';
+    } else if (options.local) {
+      targetScope = 'project';
+    } else {
+      const choice = await handleDualLocation(fileName);
+      if (choice === 'skip') return;
+      targetScope = choice;
+    }
+  } else {
+    targetScope = await resolvePluginScope(pluginName, options);
+  }
+
+  // Persist scope
+  if (options.global || options.local || !await getPluginScope(pluginName)) {
+    if (hasProject) {
+      await setPluginScope(pluginName, targetScope);
+    } else if (targetScope === 'global') {
+      log.warn(`Cannot persist scope preference (no .dbo/ directory). Run "dbo init" first.`);
+    }
+  }
+
+  const commandsDir = getCommandsDir(targetScope);
   await mkdir(commandsDir, { recursive: true });
 
   const destPath = join(commandsDir, fileName);
+  const srcContent = await readFile(srcPath, 'utf8');
+  const scopeLabel = targetScope === 'global' ? '~/.claude/commands/' : '.claude/commands/';
 
   if (await fileExists(destPath)) {
+    const destContent = await readFile(destPath, 'utf8');
+    if (fileHash(srcContent) === fileHash(destContent)) {
+      log.success(`${fileName} is already up to date in ${scopeLabel}`);
+      return;
+    }
+
     const inquirer = (await import('inquirer')).default;
-    const { overwrite } = await inquirer.prompt([{
-      type: 'confirm', name: 'overwrite',
-      message: `Overwrite existing .claude/commands/${fileName}?`,
-      default: false,
+    const { upgrade } = await inquirer.prompt([{
+      type: 'confirm', name: 'upgrade',
+      message: `${scopeLabel}${fileName} is already installed. Upgrade to latest version?`,
+      default: true,
     }]);
-    if (!overwrite) return;
+    if (!upgrade) return;
+
+    await copyFile(srcPath, destPath);
+    log.success(`Upgraded ${scopeLabel}${fileName}`);
+  } else {
+    await copyFile(srcPath, destPath);
+    log.success(`Installed ${scopeLabel}${fileName}`);
+
+    if (targetScope === 'project') {
+      await addToGitignore(process.cwd(), `.claude/commands/${fileName}`);
+    }
+  }
+
+  // If scope changed to global and project copy existed, remove from gitignore
+  if (targetScope === 'global' && locations.project) {
+    await removeFromGitignore(`.claude/commands/${fileName}`);
   }
 
-  await copyFile(srcPath, destPath);
-  log.success(`Installed .claude/commands/${fileName}`);
   log.warn('Note: Commands will be available in new Claude Code sessions (restart any active session).');
-  await addToGitignore(process.cwd(), `.claude/commands/${fileName}`);
 }
 
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
 async function addToGitignore(projectDir, pattern) {
   const gitignorePath = join(projectDir, '.gitignore');
   let content = '';