@dboio/cli 0.6.2 → 0.6.4

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

@@ -2,6 +2,9 @@
 
 import { Command } from 'commander';
 import { createRequire } from 'module';
+import { existsSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
 
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
@@ -28,6 +31,36 @@ import { diffCommand } from '../src/commands/diff.js';
 import { rmCommand } from '../src/commands/rm.js';
 import { mvCommand } from '../src/commands/mv.js';
 
+// First-run welcome message
+function checkFirstRun() {
+  const markerFile = join(homedir(), '.dbo-cli-welcomed');
+
+  if (!existsSync(markerFile)) {
+    const RESET = '\x1b[0m';
+    const BOLD = '\x1b[1m';
+    const DIM = '\x1b[2m';
+    const CYAN = '\x1b[36m';
+    const YELLOW = '\x1b[33m';
+
+    console.log('');
+    console.log(`${BOLD}${CYAN}  Welcome to DBO.io CLI!${RESET}`);
+    console.log('');
+    console.log(`  ${DIM}Available plugins:${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:`);
+    console.log(`    ${BOLD}dbo install plugins${RESET}`);
+    console.log('');
+
+    try {
+      writeFileSync(markerFile, new Date().toISOString());
+    } catch {
+      // Ignore write errors
+    }
+  }
+}
+
 const program = new Command();
 
 program
@@ -57,4 +90,7 @@ program.addCommand(diffCommand);
 program.addCommand(rmCommand);
 program.addCommand(mvCommand);
 
+// Show welcome message on first run
+checkFirstRun();
+
 program.parse();

package/bin/postinstall.js

@@ -3,32 +3,22 @@
 // Post-install hook for `npm i @dboio/cli`
 // Interactive plugin picker when TTY is available, static message otherwise.
 
-import { openSync, writeSync, closeSync } from 'fs';
-
 const RESET = '\x1b[0m';
 const BOLD = '\x1b[1m';
 const DIM = '\x1b[2m';
 const CYAN = '\x1b[36m';
 const YELLOW = '\x1b[33m';
 
-// Write to TTY directly to bypass npm's output suppression
+// Simple log function - console.log works fine in postinstall
 function write(message) {
-  try {
-    // Try to write directly to /dev/tty (works on Unix-like systems)
-    const fd = openSync('/dev/tty', 'w');
-    writeSync(fd, message);
-    closeSync(fd);
-  } catch {
-    // Fallback to console.error if /dev/tty is not available
-    console.error(message);
-  }
+  console.log(message);
 }
 
 // Available plugins — add new entries here as plugins are created
 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.2",
+  "version": "0.6.4",
   "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,13 @@
+{
+  "name": "dbo",
+  "version": "0.6.4",
+  "description": "DBO.io CLI integration for Claude Code",
+  "author": "DBO.io",
+  "skills": [
+    {
+      "path": "skills/cli/SKILL.md",
+      "name": "cli",
+      "description": "Execute DBO.io CLI commands"
+    }
+  ]
+}

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,18 @@
 import { Command } from 'commander';
-import { readdir, readFile, writeFile, mkdir, access, copyFile } from 'fs/promises';
+import { readdir, readFile, writeFile, mkdir, access, copyFile, cp } 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 __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 +23,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 +35,77 @@ function getCommandsDir(scope) {
 }
 
 /**
- * Get plugin name from filename (strips .md extension).
+ * Get the target plugins directory based on scope (new directory-based format).
+ * @param {'project' | 'global'} scope
+ * @returns {string} Absolute path to plugins directory
+ */
+function getPluginsDir(scope) {
+  if (scope === 'global') {
+    return join(homedir(), '.claude', 'plugins');
+  }
+  return join(process.cwd(), '.claude', 'plugins');
+}
+
+/**
+ * Check if a plugin source is a directory-based plugin (has .claude-plugin/).
+ * @param {string} pluginPath - Path to the plugin directory
+ * @returns {boolean}
  */
-function getPluginName(filename) {
-  return filename.replace(/\.md$/, '');
+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 +120,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 +147,41 @@ async function resolvePluginScope(pluginName, options) {
 
 /**
  * Check if plugin exists in both project and global locations.
- * @param {string} fileName - Plugin filename (with .md)
+ * Checks both legacy (.claude/commands/) and new (.claude/plugins/) 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);
+  const globalPlugin = join(getPluginsDir('global'), pluginName);
+  let project = await fileExists(projectPlugin);
+  let global = await fileExists(globalPlugin);
+
+  // 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 +273,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 +481,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 +495,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 +516,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 +532,155 @@ export async function installOrUpdateClaudeCommands(options = {}) {
         return;
       }
     }
-    await mkdir(commandsDir, { recursive: true });
 
     // Persist the scope preference
-    if (options.global || options.local || !await getPluginScope(pluginName)) {
+    if (options.global || options.local || !await getPluginScope(plugin.name)) {
       if (hasProject) {
-        await setPluginScope(pluginName, targetScope);
+        await setPluginScope(plugin.name, 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/';
+    if (plugin.type === 'directory') {
+      // New directory-based plugin installation
+      const destDir = join(getPluginsDir(targetScope), plugin.name);
+      const scopeLabel = targetScope === 'global' ? '~/.claude/plugins/' : '.claude/plugins/';
+
+      if (await fileExists(destDir)) {
+        // Check if upgrade needed via directory hash
+        const srcHash = await directoryHash(plugin.path);
+        const destHash = await directoryHash(destDir);
+        if (srcHash === destHash) {
+          upToDate++;
+          continue;
+        }
 
-    if (await fileExists(destPath)) {
-      // Already installed — check if upgrade needed
-      const destContent = await readFile(destPath, 'utf8');
-      if (fileHash(srcContent) === fileHash(destContent)) {
-        upToDate++;
-        continue;
+        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;
+        }
+
+        await cp(plugin.path, destDir, { recursive: true, force: true });
+        log.success(`Upgraded ${scopeLabel}${plugin.name}/`);
+        updated++;
+      } else {
+        await mkdir(destDir, { recursive: true });
+        await cp(plugin.path, destDir, { recursive: true });
+        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;
+      // 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}`);
       }
 
-      await copyFile(srcPath, destPath);
-      log.success(`Upgraded ${scopeLabel}${file}`);
-      updated++;
+      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}`);
+      }
     }
   }
 
-  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 +689,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;
     }
@@ -573,45 +706,98 @@ async function installOrUpdateSpecificCommand(name, options = {}) {
     }
   }
 
-  const commandsDir = getCommandsDir(targetScope);
-  await mkdir(commandsDir, { recursive: true });
+  if (plugin.type === 'directory') {
+    // Directory-based plugin installation
+    const destDir = join(getPluginsDir(targetScope), pluginName);
+    const scopeLabel = targetScope === 'global' ? '~/.claude/plugins/' : '.claude/plugins/';
 
-  const destPath = join(commandsDir, fileName);
-  const srcContent = await readFile(srcPath, 'utf8');
-  const scopeLabel = targetScope === 'global' ? '~/.claude/commands/' : '.claude/commands/';
+    if (await fileExists(destDir)) {
+      const srcHash = await directoryHash(plugin.path);
+      const destHash = await directoryHash(destDir);
+      if (srcHash === destHash) {
+        log.success(`${pluginName} is already up to date in ${scopeLabel}`);
+        return;
+      }
 
-  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 { upgrade } = await inquirer.prompt([{
+        type: 'confirm', name: 'upgrade',
+        message: `${scopeLabel}${pluginName}/ is already installed. Upgrade to latest version?`,
+        default: true,
+      }]);
+      if (!upgrade) return;
+
+      await cp(plugin.path, destDir, { recursive: true, force: true });
+      log.success(`Upgraded ${scopeLabel}${pluginName}/`);
+    } else {
+      await mkdir(destDir, { recursive: true });
+      await cp(plugin.path, destDir, { recursive: true });
+      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}`);
+    // 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}`);
+    }
   }
 
-  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 ────────────────────────────────────────────────────────────────