@dboio/cli 0.6.3 → 0.6.5

package/README.md

@@ -62,7 +62,7 @@ Once installed, use `/dbo` in Claude Code:
 /dbo push assets/css/
 ```
 
-The command source lives in `tools/dbo-cli/src/plugins/claudecommands/`. Installed copies in `.claude/commands/` are gitignored and managed by `dbo install`. Each plugin's installation scope (project or global) is stored per-plugin in `.dbo/config.local.json`.
+The plugin source lives in `plugins/claude/dbo/` at the repository root. Installed copies in `.claude/plugins/` are gitignored and managed by `dbo install`. Each plugin's installation scope (project or global) is stored per-plugin in `.dbo/config.local.json`.
 
 ---
 
@@ -1169,7 +1169,7 @@ Smart behavior:
 - If plugins are already installed and up to date, reports "already up to date"
 - If plugins differ from source, prompts to upgrade to the latest version
 - Compares file hashes — unchanged files are skipped
-- Adds project-scoped command files to `.gitignore` (source of truth is `src/plugins/claudecommands/`)
+- Adds project-scoped plugins to `.gitignore` (source of truth is `plugins/claude/` at repo root)
 - Per-plugin scope (project or global) is stored in `.dbo/config.local.json` and remembered for future upgrades
 - On first install of a plugin without a stored preference, prompts for scope
 - `--global` / `--local` flags override stored preferences and update them

package/bin/dbo.js

@@ -46,7 +46,7 @@ function checkFirstRun() {
     console.log(`${BOLD}${CYAN}  Welcome to DBO.io CLI!${RESET}`);
     console.log('');
     console.log(`  ${DIM}Available plugins:${RESET}`);
-    console.log(`    ${YELLOW}Claude Code — /dbo slash command${RESET}`);
+    console.log(`    ${YELLOW}Claude Code — /dbo:cli slash command${RESET}`);
     console.log(`      ${DIM}dbo install --claudecommand dbo${RESET}`);
     console.log('');
     console.log(`  To install all plugins at once, run:`);

package/bin/postinstall.js

@@ -18,7 +18,7 @@ function write(message) {
 const PLUGINS = [
   {
     name: 'dbo',
-    label: 'Claude Code — /dbo slash command',
+    label: 'Claude Code — /dbo:cli slash command',
     command: 'dbo install --claudecommand dbo'
   }
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dboio/cli",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "CLI for the DBO.io framework",
   "type": "module",
   "bin": {
@@ -16,6 +16,7 @@
     "node": ">=18.0.0"
   },
   "scripts": {
+    "prepublishOnly": "node scripts/copy-plugins.js",
     "postinstall": "node bin/postinstall.js",
     "test": "node --test src/**/*.test.js tests/**/*.test.js"
   },

package/plugins/claude/dbo/.claude-plugin/plugin.json

@@ -0,0 +1,8 @@
+{
+  "name": "dbo",
+  "version": "0.6.5",
+  "description": "DBO.io CLI integration for Claude Code",
+  "author": {
+    "name": "DBO.io"
+  }
+}

package/{src/plugins/claudecommands/dbo.md → plugins/claude/dbo/skills/cli/SKILL.md}

@@ -1,6 +1,7 @@
 ---
+name: cli
 description: Execute DBO.io CLI commands (pull, push, add, clone, output, input, content, deploy, etc.)
-allowed-tools: [Bash, Read, Write, Grep, Glob]
+user-invokable: true
 ---
 
 # DBO CLI Command
@@ -9,7 +10,7 @@ The dbo CLI interacts with DBO.io — a database-driven application framework.
 
 **STEP 1: Check if `$ARGUMENTS` is empty or blank.**
 
-If `$ARGUMENTS` is empty — meaning the user typed just `/dbo` with nothing after it — then you MUST NOT run any bash command. Do NOT run `dbo`, `dbo --help`, or anything else. Instead, respond ONLY with this text message:
+If `$ARGUMENTS` is empty — meaning the user typed just `/dbo:cli` with nothing after it — then you MUST NOT run any bash command. Do NOT run `dbo`, `dbo --help`, or anything else. Instead, respond ONLY with this text message:
 
 ---
 

package/src/commands/install.js

@@ -1,16 +1,22 @@
 import { Command } from 'commander';
-import { readdir, readFile, writeFile, mkdir, access, copyFile } from 'fs/promises';
+import { readdir, readFile, writeFile, mkdir, access, copyFile, cp, rm } from 'fs/promises';
 import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { execSync } from 'child_process';
 import { createHash } from 'crypto';
+import { existsSync } from 'fs';
 import { homedir } from 'os';
 import { log } from '../lib/logger.js';
 import { getPluginScope, setPluginScope, isInitialized, removeFromGitignore } from '../lib/config.js';
 
+const CLAUDE_PLUGINS_DIR = join(homedir(), '.claude', 'plugins');
+const PLUGIN_REGISTRY_PATH = join(CLAUDE_PLUGINS_DIR, 'installed_plugins.json');
+const PLUGIN_MARKETPLACE = 'dboio';
+
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const CLI_ROOT = join(__dirname, '..', '..');
-const PLUGINS_DIR = join(__dirname, '..', 'plugins', 'claudecommands');
+const LEGACY_PLUGINS_DIR = join(__dirname, '..', 'plugins', 'claudecommands');
+const PLUGINS_DIR = join(CLI_ROOT, 'plugins', 'claude');
 
 async function fileExists(path) {
   try { await access(path); return true; } catch { return false; }
@@ -21,7 +27,7 @@ function fileHash(content) {
 }
 
 /**
- * Get the target commands directory based on scope.
+ * Get the target commands directory based on scope (legacy .md format).
  * @param {'project' | 'global'} scope
  * @returns {string} Absolute path to commands directory
  */
@@ -33,10 +39,143 @@ function getCommandsDir(scope) {
 }
 
 /**
- * Get plugin name from filename (strips .md extension).
+ * Get the target plugins directory based on scope (new directory-based format).
+ * For global scope, returns the cache path that Claude Code expects.
+ * @param {'project' | 'global'} scope
+ * @returns {string} Absolute path to plugins directory
+ */
+function getPluginsDir(scope) {
+  if (scope === 'global') {
+    return join(CLAUDE_PLUGINS_DIR, 'cache', PLUGIN_MARKETPLACE);
+  }
+  return join(process.cwd(), '.claude', 'plugins');
+}
+
+/**
+ * Get the install path for a global plugin in the cache directory.
+ * @param {string} pluginName - Plugin name
+ * @param {string} version - Plugin version
+ * @returns {string} Absolute path like ~/.claude/plugins/cache/dboio/<name>/<version>/
+ */
+function getGlobalPluginCachePath(pluginName, version) {
+  return join(CLAUDE_PLUGINS_DIR, 'cache', PLUGIN_MARKETPLACE, pluginName, version);
+}
+
+/**
+ * Read the Claude Code plugin registry (installed_plugins.json).
+ * @returns {Promise<object>} The registry object
  */
-function getPluginName(filename) {
-  return filename.replace(/\.md$/, '');
+async function readPluginRegistry() {
+  try {
+    const content = await readFile(PLUGIN_REGISTRY_PATH, 'utf8');
+    return JSON.parse(content);
+  } catch {
+    return { version: 2, plugins: {} };
+  }
+}
+
+/**
+ * Register a plugin in Claude Code's installed_plugins.json.
+ * @param {string} pluginName - Plugin name
+ * @param {string} version - Plugin version
+ * @param {string} installPath - Absolute path to installed plugin
+ */
+async function registerPlugin(pluginName, version, installPath) {
+  const registry = await readPluginRegistry();
+  const key = `${pluginName}@${PLUGIN_MARKETPLACE}`;
+  const now = new Date().toISOString();
+
+  const existing = registry.plugins[key]?.[0];
+  if (existing) {
+    existing.installPath = installPath;
+    existing.version = version;
+    existing.lastUpdated = now;
+  } else {
+    registry.plugins[key] = [{
+      scope: 'user',
+      installPath,
+      version,
+      installedAt: now,
+      lastUpdated: now,
+    }];
+  }
+
+  await writeFile(PLUGIN_REGISTRY_PATH, JSON.stringify(registry, null, 2) + '\n');
+}
+
+/**
+ * Unregister a plugin from Claude Code's installed_plugins.json.
+ * @param {string} pluginName - Plugin name
+ */
+async function unregisterPlugin(pluginName) {
+  const registry = await readPluginRegistry();
+  const key = `${pluginName}@${PLUGIN_MARKETPLACE}`;
+  if (registry.plugins[key]) {
+    delete registry.plugins[key];
+    await writeFile(PLUGIN_REGISTRY_PATH, JSON.stringify(registry, null, 2) + '\n');
+  }
+}
+
+/**
+ * Check if a plugin source is a directory-based plugin (has .claude-plugin/).
+ * @param {string} pluginPath - Path to the plugin directory
+ * @returns {boolean}
+ */
+function isDirectoryPlugin(pluginPath) {
+  return existsSync(join(pluginPath, '.claude-plugin', 'plugin.json'));
+}
+
+/**
+ * Discover all available plugins (both legacy .md and new directory-based).
+ * @returns {Array<{name: string, type: 'legacy'|'directory', path: string}>}
+ */
+async function discoverPlugins() {
+  const plugins = [];
+
+  // Check new directory-based plugins first
+  if (existsSync(PLUGINS_DIR)) {
+    try {
+      const entries = await readdir(PLUGINS_DIR, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const pluginPath = join(PLUGINS_DIR, entry.name);
+          if (isDirectoryPlugin(pluginPath)) {
+            plugins.push({ name: entry.name, type: 'directory', path: pluginPath });
+          }
+        }
+      }
+    } catch { /* ignore */ }
+  }
+
+  // Fall back to legacy .md plugins if no directory plugins found
+  if (plugins.length === 0 && existsSync(LEGACY_PLUGINS_DIR)) {
+    try {
+      const files = (await readdir(LEGACY_PLUGINS_DIR)).filter(f => f.endsWith('.md'));
+      for (const file of files) {
+        plugins.push({ name: file.replace(/\.md$/, ''), type: 'legacy', path: join(LEGACY_PLUGINS_DIR, file) });
+      }
+    } catch { /* ignore */ }
+  }
+
+  return plugins;
+}
+
+/**
+ * Compute a hash of a directory's contents for change detection.
+ * @param {string} dirPath - Path to the directory
+ * @returns {Promise<string>} MD5 hash of concatenated file contents
+ */
+async function directoryHash(dirPath) {
+  const hash = createHash('md5');
+  const entries = await readdir(dirPath, { withFileTypes: true, recursive: true });
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    const parentDir = entry.parentPath || entry.path || dirPath;
+    const filePath = join(parentDir, entry.name);
+    const content = await readFile(filePath, 'utf8');
+    hash.update(entry.name + content);
+  }
+  return hash.digest('hex');
 }
 
 /**
@@ -51,8 +190,8 @@ async function promptForScope(pluginName) {
     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' },
+      { name: 'Project directory (.claude/plugins/)', value: 'project' },
+      { name: 'User home directory (~/.claude/plugins/)', value: 'global' },
     ],
     default: 'project',
   }]);
@@ -78,33 +217,48 @@ async function resolvePluginScope(pluginName, options) {
 
 /**
  * Check if plugin exists in both project and global locations.
- * @param {string} fileName - Plugin filename (with .md)
+ * Checks cache path, old direct path, and legacy (.claude/commands/) paths.
+ * @param {string} pluginName - Plugin name (without extension)
+ * @param {string} [legacyFileName] - Legacy filename (with .md) for backward compat
  * @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),
-  };
+async function checkPluginLocations(pluginName, legacyFileName) {
+  const projectPlugin = join(getPluginsDir('project'), pluginName);
+  let project = await fileExists(projectPlugin);
+
+  // Check global: cache path first, then old direct path
+  const registry = await readPluginRegistry();
+  const key = `${pluginName}@${PLUGIN_MARKETPLACE}`;
+  let global = !!registry.plugins[key];
+  if (!global) {
+    // Check old direct path (~/.claude/plugins/<name>/)
+    global = await fileExists(join(CLAUDE_PLUGINS_DIR, pluginName, '.claude-plugin', 'plugin.json'));
+  }
+
+  // Also check legacy locations
+  if (legacyFileName) {
+    if (!project) project = await fileExists(join(getCommandsDir('project'), legacyFileName));
+    if (!global) global = await fileExists(join(getCommandsDir('global'), legacyFileName));
+  }
+
+  return { project, global };
 }
 
 /**
  * Handle conflict when plugin exists in both locations.
- * @param {string} fileName - Plugin filename
+ * @param {string} pluginName - Plugin name
  * @returns {Promise<'project' | 'global' | 'skip'>}
  */
-async function handleDualLocation(fileName) {
-  log.warn(`${fileName} exists in both project and global directories.`);
+async function handleDualLocation(pluginName) {
+  log.warn(`"${pluginName}" 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: 'Project (.claude/plugins/)', value: 'project' },
+      { name: 'Global (~/.claude/plugins/)', value: 'global' },
       { name: 'Skip this plugin', value: 'skip' },
     ],
   }]);
@@ -196,7 +350,7 @@ async function installInteractive(options = {}) {
     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 commands (adds /dbo:cli to Claude Code)', value: 'claudecommands' },
       { name: 'Claude Code CLI + commands', value: 'claudecode' },
       { name: 'Plugins (Claude commands)', value: 'plugins' },
     ],
@@ -404,17 +558,12 @@ export async function installOrUpdateClaudeCommands(options = {}) {
   const cwd = process.cwd();
   const hasProject = await isInitialized();
 
-  // Find all plugin source files
-  let pluginFiles;
-  try {
-    pluginFiles = (await readdir(PLUGINS_DIR)).filter(f => f.endsWith('.md'));
-  } catch {
-    log.error(`Plugin source directory not found: ${PLUGINS_DIR}`);
-    return;
-  }
+  // Discover all available plugins (directory-based or legacy)
+  const plugins = await discoverPlugins();
 
-  if (pluginFiles.length === 0) {
-    log.warn('No Claude command plugins found in source.');
+  if (plugins.length === 0) {
+    log.error('No Claude plugins found in package.');
+    log.dim(`  Searched: ${PLUGINS_DIR}`);
     return;
   }
 
@@ -423,23 +572,20 @@ export async function installOrUpdateClaudeCommands(options = {}) {
   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');
+  for (const plugin of plugins) {
+    const legacyFileName = `${plugin.name}.md`;
 
     // Check if plugin exists in both locations
-    const locations = await checkPluginLocations(file);
+    const locations = await checkPluginLocations(plugin.name, legacyFileName);
     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);
+        const choice = await handleDualLocation(plugin.name);
         if (choice === 'skip') {
           skipped++;
           continue;
@@ -447,11 +593,10 @@ export async function installOrUpdateClaudeCommands(options = {}) {
         targetScope = choice;
       }
     } else {
-      targetScope = await resolvePluginScope(pluginName, options);
+      targetScope = await resolvePluginScope(plugin.name, options);
     }
 
-    // Ensure target directory exists (prompt for project .claude/ only if needed)
-    const commandsDir = getCommandsDir(targetScope);
+    // Ensure target directory exists
     if (targetScope === 'project' && !await fileExists(join(cwd, '.claude'))) {
       const inquirer = (await import('inquirer')).default;
       const { create } = await inquirer.prompt([{
@@ -464,90 +609,192 @@ export async function installOrUpdateClaudeCommands(options = {}) {
         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.`);
-      }
-    }
+    if (plugin.type === 'directory') {
+      // New directory-based plugin installation
+      // Read version from plugin.json
+      const pluginMeta = JSON.parse(await readFile(join(plugin.path, '.claude-plugin', 'plugin.json'), 'utf8'));
+      const pluginVersion = pluginMeta.version || '0.0.0';
+
+      // For global scope, use the cache path and register in installed_plugins.json
+      const destDir = targetScope === 'global'
+        ? getGlobalPluginCachePath(plugin.name, pluginVersion)
+        : join(getPluginsDir('project'), plugin.name);
+      const scopeLabel = targetScope === 'global' ? '~/.claude/plugins/' : '.claude/plugins/';
+
+      // Check for existing installation (cache path or old direct path)
+      const oldDirectPath = join(CLAUDE_PLUGINS_DIR, plugin.name);
+      const existingPath = await fileExists(destDir) ? destDir
+        : (targetScope === 'global' && await fileExists(oldDirectPath)) ? oldDirectPath
+        : null;
+
+      if (existingPath) {
+        // Check if upgrade needed via directory hash
+        const srcHash = await directoryHash(plugin.path);
+        const destHash = await directoryHash(existingPath);
+        if (srcHash === destHash && existingPath === destDir) {
+          upToDate++;
+          continue;
+        }
 
-    const destPath = join(commandsDir, file);
-    const scopeLabel = targetScope === 'global' ? '~/.claude/commands/' : '.claude/commands/';
+        const inquirer = (await import('inquirer')).default;
+        const { upgrade } = await inquirer.prompt([{
+          type: 'confirm', name: 'upgrade',
+          message: `${scopeLabel}${plugin.name}/ is already installed. Upgrade to latest version?`,
+          default: true,
+        }]);
+        if (!upgrade) {
+          log.dim(`  Skipped ${plugin.name}`);
+          skipped++;
+          continue;
+        }
 
-    if (await fileExists(destPath)) {
-      // Already installed — check if upgrade needed
-      const destContent = await readFile(destPath, 'utf8');
-      if (fileHash(srcContent) === fileHash(destContent)) {
-        upToDate++;
-        continue;
+        await mkdir(destDir, { recursive: true });
+        await cp(plugin.path, destDir, { recursive: true, force: true });
+
+        // Clean up old direct path if migrating to cache path
+        if (targetScope === 'global' && existingPath === oldDirectPath && existingPath !== destDir) {
+          await rm(oldDirectPath, { recursive: true, force: true });
+          log.dim(`  Migrated from ${oldDirectPath} to cache path`);
+        }
+
+        if (targetScope === 'global') {
+          await registerPlugin(plugin.name, pluginVersion, destDir);
+        }
+
+        log.success(`Upgraded ${scopeLabel}${plugin.name}/`);
+        updated++;
+      } else {
+        await mkdir(destDir, { recursive: true });
+        await cp(plugin.path, destDir, { recursive: true });
+
+        if (targetScope === 'global') {
+          await registerPlugin(plugin.name, pluginVersion, destDir);
+        }
+
+        log.success(`Installed ${scopeLabel}${plugin.name}/`);
+        installed++;
+
+        if (targetScope === 'project') {
+          await addToGitignore(cwd, `.claude/plugins/${plugin.name}/`);
+        }
       }
 
-      // File differs — prompt for upgrade
-      const inquirer = (await import('inquirer')).default;
-      const { upgrade } = await inquirer.prompt([{
-        type: 'confirm', name: 'upgrade',
-        message: `${scopeLabel}${file} is already installed. Upgrade to latest version?`,
-        default: true,
-      }]);
-      if (!upgrade) {
-        log.dim(`  Skipped ${file}`);
-        skipped++;
-        continue;
+      // Persist scope + metadata to config.local.json
+      if (hasProject && (options.global || options.local || !await getPluginScope(plugin.name))) {
+        await setPluginScope(plugin.name, {
+          scope: targetScope === 'global' ? 'user' : 'project',
+          installPath: destDir,
+          version: pluginVersion,
+        });
+      } else if (targetScope === 'global' && !hasProject) {
+        log.warn(`Cannot persist scope preference (no .dbo/ directory). Run "dbo init" first.`);
       }
 
-      await copyFile(srcPath, destPath);
-      log.success(`Upgraded ${scopeLabel}${file}`);
-      updated++;
+      // Clean up legacy file if it exists
+      const legacyProjectPath = join(getCommandsDir('project'), legacyFileName);
+      const legacyGlobalPath = join(getCommandsDir('global'), legacyFileName);
+      if (await fileExists(legacyProjectPath)) {
+        const { unlink } = await import('fs/promises');
+        await unlink(legacyProjectPath);
+        await removeFromGitignore(`.claude/commands/${legacyFileName}`);
+        log.dim(`  Removed legacy command: .claude/commands/${legacyFileName}`);
+      }
+      if (await fileExists(legacyGlobalPath)) {
+        const { unlink } = await import('fs/promises');
+        await unlink(legacyGlobalPath);
+        log.dim(`  Removed legacy command: ~/.claude/commands/${legacyFileName}`);
+      }
+
+      if (targetScope === 'global' && locations.project) {
+        await removeFromGitignore(`.claude/plugins/${plugin.name}/`);
+      }
     } else {
-      // New install
-      await copyFile(srcPath, destPath);
-      log.success(`Installed ${scopeLabel}${file}`);
-      installed++;
+      // Legacy .md plugin installation
+      const commandsDir = getCommandsDir(targetScope);
+      await mkdir(commandsDir, { recursive: true });
+
+      const srcContent = await readFile(plugin.path, 'utf8');
+      const destPath = join(commandsDir, legacyFileName);
+      const scopeLabel = targetScope === 'global' ? '~/.claude/commands/' : '.claude/commands/';
+
+      if (await fileExists(destPath)) {
+        const destContent = await readFile(destPath, 'utf8');
+        if (fileHash(srcContent) === fileHash(destContent)) {
+          upToDate++;
+          continue;
+        }
 
-      // Only add to gitignore for project-scope installs
-      if (targetScope === 'project') {
-        await addToGitignore(cwd, `.claude/commands/${file}`);
+        const inquirer = (await import('inquirer')).default;
+        const { upgrade } = await inquirer.prompt([{
+          type: 'confirm', name: 'upgrade',
+          message: `${scopeLabel}${legacyFileName} is already installed. Upgrade to latest version?`,
+          default: true,
+        }]);
+        if (!upgrade) {
+          log.dim(`  Skipped ${legacyFileName}`);
+          skipped++;
+          continue;
+        }
+
+        await copyFile(plugin.path, destPath);
+        log.success(`Upgraded ${scopeLabel}${legacyFileName}`);
+        updated++;
+      } else {
+        await copyFile(plugin.path, destPath);
+        log.success(`Installed ${scopeLabel}${legacyFileName}`);
+        installed++;
+
+        if (targetScope === 'project') {
+          await addToGitignore(cwd, `.claude/commands/${legacyFileName}`);
+        }
       }
-    }
 
-    // If scope changed to global and project copy existed, remove from gitignore
-    if (targetScope === 'global' && locations.project) {
-      await removeFromGitignore(`.claude/commands/${file}`);
+      if (targetScope === 'global' && locations.project) {
+        await removeFromGitignore(`.claude/commands/${legacyFileName}`);
+      }
+
+      // Persist scope for legacy plugins
+      if (hasProject && (options.global || options.local || !await getPluginScope(plugin.name))) {
+        await setPluginScope(plugin.name, targetScope);
+      }
     }
   }
 
-  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) log.info(`${installed} plugin(s) installed.`);
+  if (updated > 0) log.info(`${updated} plugin(s) upgraded.`);
+  if (upToDate > 0) log.dim(`${upToDate} plugin(s) already up to date.`);
+  if (skipped > 0) log.dim(`${skipped} plugin(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).');
+    log.info('Use /dbo:cli in Claude Code.');
+    log.warn('Note: Plugins will be available in new Claude Code sessions (restart any active session).');
   }
 }
 
 // ─── 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)) {
-    log.error(`Command plugin "${name}" not found in ${PLUGINS_DIR}`);
-    const available = (await readdir(PLUGINS_DIR)).filter(f => f.endsWith('.md')).map(f => f.replace('.md', ''));
-    if (available.length > 0) log.dim(`  Available: ${available.join(', ')}`);
+  const pluginName = name.replace(/\.md$/, '');
+
+  // Find the plugin in available sources (directory-based first, then legacy)
+  const plugins = await discoverPlugins();
+  const plugin = plugins.find(p => p.name === pluginName);
+
+  if (!plugin) {
+    log.error(`Plugin "${pluginName}" not found.`);
+    if (plugins.length > 0) {
+      log.dim(`  Available: ${plugins.map(p => p.name).join(', ')}`);
+    } else {
+      log.dim(`  Searched: ${PLUGINS_DIR}`);
+    }
     return;
   }
 
   const hasProject = await isInitialized();
+  const legacyFileName = `${pluginName}.md`;
 
   // Check for dual location
-  const locations = await checkPluginLocations(fileName);
+  const locations = await checkPluginLocations(pluginName, legacyFileName);
   let targetScope;
 
   if (locations.project && locations.global) {
@@ -556,7 +803,7 @@ async function installOrUpdateSpecificCommand(name, options = {}) {
     } else if (options.local) {
       targetScope = 'project';
     } else {
-      const choice = await handleDualLocation(fileName);
+      const choice = await handleDualLocation(pluginName);
       if (choice === 'skip') return;
       targetScope = choice;
     }
@@ -564,54 +811,142 @@ async function installOrUpdateSpecificCommand(name, options = {}) {
     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.`);
-    }
-  }
+  if (plugin.type === 'directory') {
+    // Directory-based plugin installation
+    const pluginMeta = JSON.parse(await readFile(join(plugin.path, '.claude-plugin', 'plugin.json'), 'utf8'));
+    const pluginVersion = pluginMeta.version || '0.0.0';
+
+    const destDir = targetScope === 'global'
+      ? getGlobalPluginCachePath(pluginName, pluginVersion)
+      : join(getPluginsDir('project'), pluginName);
+    const scopeLabel = targetScope === 'global' ? '~/.claude/plugins/' : '.claude/plugins/';
+
+    // Check for existing installation (cache path or old direct path)
+    const oldDirectPath = join(CLAUDE_PLUGINS_DIR, pluginName);
+    const existingPath = await fileExists(destDir) ? destDir
+      : (targetScope === 'global' && await fileExists(oldDirectPath)) ? oldDirectPath
+      : null;
+
+    if (existingPath) {
+      const srcHash = await directoryHash(plugin.path);
+      const destHash = await directoryHash(existingPath);
+      if (srcHash === destHash && existingPath === destDir) {
+        log.success(`${pluginName} is already up to date in ${scopeLabel}`);
+        return;
+      }
 
-  const commandsDir = getCommandsDir(targetScope);
-  await mkdir(commandsDir, { recursive: true });
+      const inquirer = (await import('inquirer')).default;
+      const { upgrade } = await inquirer.prompt([{
+        type: 'confirm', name: 'upgrade',
+        message: `${scopeLabel}${pluginName}/ is already installed. Upgrade to latest version?`,
+        default: true,
+      }]);
+      if (!upgrade) return;
 
-  const destPath = join(commandsDir, fileName);
-  const srcContent = await readFile(srcPath, 'utf8');
-  const scopeLabel = targetScope === 'global' ? '~/.claude/commands/' : '.claude/commands/';
+      await mkdir(destDir, { recursive: true });
+      await cp(plugin.path, destDir, { recursive: true, force: true });
 
-  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;
+      // Clean up old direct path if migrating to cache path
+      if (targetScope === 'global' && existingPath === oldDirectPath && existingPath !== destDir) {
+        await rm(oldDirectPath, { recursive: true, force: true });
+        log.dim(`  Migrated from ${oldDirectPath} to cache path`);
+      }
+
+      if (targetScope === 'global') {
+        await registerPlugin(pluginName, pluginVersion, destDir);
+      }
+
+      log.success(`Upgraded ${scopeLabel}${pluginName}/`);
+    } else {
+      await mkdir(destDir, { recursive: true });
+      await cp(plugin.path, destDir, { recursive: true });
+
+      if (targetScope === 'global') {
+        await registerPlugin(pluginName, pluginVersion, destDir);
+      }
+
+      log.success(`Installed ${scopeLabel}${pluginName}/`);
+
+      if (targetScope === 'project') {
+        await addToGitignore(process.cwd(), `.claude/plugins/${pluginName}/`);
+      }
     }
 
-    const inquirer = (await import('inquirer')).default;
-    const { upgrade } = await inquirer.prompt([{
-      type: 'confirm', name: 'upgrade',
-      message: `${scopeLabel}${fileName} is already installed. Upgrade to latest version?`,
-      default: true,
-    }]);
-    if (!upgrade) return;
-
-    await copyFile(srcPath, destPath);
-    log.success(`Upgraded ${scopeLabel}${fileName}`);
+    // Persist scope + metadata to config.local.json
+    if (hasProject && (options.global || options.local || !await getPluginScope(pluginName))) {
+      await setPluginScope(pluginName, {
+        scope: targetScope === 'global' ? 'user' : 'project',
+        installPath: destDir,
+        version: pluginVersion,
+      });
+    } else if (targetScope === 'global' && !hasProject) {
+      log.warn(`Cannot persist scope preference (no .dbo/ directory). Run "dbo init" first.`);
+    }
+
+    // Clean up legacy files
+    const legacyProjectPath = join(getCommandsDir('project'), legacyFileName);
+    const legacyGlobalPath = join(getCommandsDir('global'), legacyFileName);
+    if (await fileExists(legacyProjectPath)) {
+      const { unlink } = await import('fs/promises');
+      await unlink(legacyProjectPath);
+      await removeFromGitignore(`.claude/commands/${legacyFileName}`);
+      log.dim(`  Removed legacy command: .claude/commands/${legacyFileName}`);
+    }
+    if (await fileExists(legacyGlobalPath)) {
+      const { unlink } = await import('fs/promises');
+      await unlink(legacyGlobalPath);
+      log.dim(`  Removed legacy command: ~/.claude/commands/${legacyFileName}`);
+    }
+
+    if (targetScope === 'global' && locations.project) {
+      await removeFromGitignore(`.claude/plugins/${pluginName}/`);
+    }
   } else {
-    await copyFile(srcPath, destPath);
-    log.success(`Installed ${scopeLabel}${fileName}`);
+    // Legacy .md plugin installation
+    const commandsDir = getCommandsDir(targetScope);
+    await mkdir(commandsDir, { recursive: true });
+
+    const destPath = join(commandsDir, legacyFileName);
+    const srcContent = await readFile(plugin.path, '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(`${legacyFileName} is already up to date in ${scopeLabel}`);
+        return;
+      }
+
+      const inquirer = (await import('inquirer')).default;
+      const { upgrade } = await inquirer.prompt([{
+        type: 'confirm', name: 'upgrade',
+        message: `${scopeLabel}${legacyFileName} is already installed. Upgrade to latest version?`,
+        default: true,
+      }]);
+      if (!upgrade) return;
 
-    if (targetScope === 'project') {
-      await addToGitignore(process.cwd(), `.claude/commands/${fileName}`);
+      await copyFile(plugin.path, destPath);
+      log.success(`Upgraded ${scopeLabel}${legacyFileName}`);
+    } else {
+      await copyFile(plugin.path, destPath);
+      log.success(`Installed ${scopeLabel}${legacyFileName}`);
+
+      if (targetScope === 'project') {
+        await addToGitignore(process.cwd(), `.claude/commands/${legacyFileName}`);
+      }
     }
-  }
 
-  // If scope changed to global and project copy existed, remove from gitignore
-  if (targetScope === 'global' && locations.project) {
-    await removeFromGitignore(`.claude/commands/${fileName}`);
+    if (targetScope === 'global' && locations.project) {
+      await removeFromGitignore(`.claude/commands/${legacyFileName}`);
+    }
+
+    // Persist scope for legacy plugins
+    if (hasProject && (options.global || options.local || !await getPluginScope(pluginName))) {
+      await setPluginScope(pluginName, targetScope);
+    }
   }
 
-  log.warn('Note: Commands will be available in new Claude Code sessions (restart any active session).');
+  log.warn('Note: Plugins will be available in new Claude Code sessions (restart any active session).');
 }
 
 // ─── Helpers ────────────────────────────────────────────────────────────────

package/src/lib/config.js

@@ -420,38 +420,81 @@ export async function saveLocalConfig(data) {
 }
 
 /**
- * Get the stored scope for a plugin by name (without extension).
- * @param {string} pluginName - Plugin name without extension
- * @param {string} [category='claudecommands'] - Plugin category
+ * Get the stored scope for a plugin.
+ * Reads from the registry-style format: plugins["name@marketplace"][0].scope
+ * Falls back to legacy format: plugins.claudecommands.name
+ * @param {string} pluginName - Plugin name (without extension)
+ * @param {string} [marketplace='dboio'] - Marketplace identifier
  * @returns {Promise<'project' | 'global' | null>}
  */
-export async function getPluginScope(pluginName, category = 'claudecommands') {
+export async function getPluginScope(pluginName, marketplace = 'dboio') {
   const config = await loadLocalConfig();
-  return config.plugins?.[category]?.[pluginName] || null;
+  const key = `${pluginName}@${marketplace}`;
+  const entry = config.plugins?.[key]?.[0];
+  if (entry) {
+    return entry.scope === 'user' ? 'global' : entry.scope || null;
+  }
+  // Legacy fallback: plugins.claudecommands.dbo = "global"
+  const legacy = config.plugins?.claudecommands?.[pluginName];
+  return legacy || null;
 }
 
 /**
- * Set the scope for a plugin by name.
- * @param {string} pluginName - Plugin name without extension
- * @param {'project' | 'global'} scope
- * @param {string} [category='claudecommands'] - Plugin category
+ * Set plugin metadata in registry-style format.
+ * @param {string} pluginName - Plugin name
+ * @param {object} meta - Plugin metadata { scope, installPath, version }
+ * @param {string} [marketplace='dboio'] - Marketplace identifier
  */
-export async function setPluginScope(pluginName, scope, category = 'claudecommands') {
+export async function setPluginScope(pluginName, meta, marketplace = 'dboio') {
   const config = await loadLocalConfig();
   if (!config.plugins) config.plugins = {};
-  if (!config.plugins[category]) config.plugins[category] = {};
-  config.plugins[category][pluginName] = scope;
+  const key = `${pluginName}@${marketplace}`;
+  const now = new Date().toISOString();
+
+  // Support legacy callers passing just a scope string
+  if (typeof meta === 'string') {
+    meta = { scope: meta === 'global' ? 'user' : meta };
+  }
+
+  const existing = config.plugins[key]?.[0];
+  if (existing) {
+    Object.assign(existing, meta);
+    existing.lastUpdated = now;
+  } else {
+    config.plugins[key] = [{
+      scope: meta.scope || 'user',
+      installPath: meta.installPath || null,
+      version: meta.version || null,
+      installedAt: now,
+      lastUpdated: now,
+    }];
+  }
+
+  // Remove legacy entry if present
+  if (config.plugins.claudecommands?.[pluginName]) {
+    delete config.plugins.claudecommands[pluginName];
+    if (Object.keys(config.plugins.claudecommands).length === 0) {
+      delete config.plugins.claudecommands;
+    }
+  }
+
   await saveLocalConfig(config);
 }
 
 /**
- * Get all stored plugin scopes for a category.
- * Returns object mapping plugin names to their scope strings.
- * @param {string} [category='claudecommands'] - Plugin category
+ * Get all stored plugin entries.
+ * Returns object mapping registry keys to their entry arrays.
  */
-export async function getAllPluginScopes(category = 'claudecommands') {
+export async function getAllPluginScopes() {
   const config = await loadLocalConfig();
-  return config.plugins?.[category] || {};
+  const result = {};
+  if (!config.plugins) return result;
+  for (const [key, value] of Object.entries(config.plugins)) {
+    // Skip legacy category keys
+    if (typeof value === 'object' && !Array.isArray(value) && !value.scope) continue;
+    result[key] = value;
+  }
+  return result;
 }
 
 // ─── Gitignore ────────────────────────────────────────────────────────────