prjct-cli 0.10.13 → 0.11.0

package/core/plugin/index.js

@@ -0,0 +1,52 @@
+/**
+ * Plugin System - Main Entry Point
+ *
+ * Exports all plugin-related functionality.
+ *
+ * @version 1.0.0
+ */
+
+const { HookSystem, HookPoints, hookSystem, hooks } = require('./hooks')
+const { PluginLoader, pluginLoader } = require('./loader')
+const { PluginRegistry, pluginRegistry } = require('./registry')
+
+/**
+ * Initialize the complete plugin system
+ * @param {string} projectPath
+ * @param {Object} config
+ */
+async function initializePlugins(projectPath, config = {}) {
+  await pluginRegistry.initialize()
+  await pluginLoader.initialize(projectPath, config)
+}
+
+/**
+ * Shutdown the plugin system
+ */
+async function shutdownPlugins() {
+  const plugins = pluginLoader.getAllPlugins()
+
+  for (const plugin of plugins) {
+    await pluginLoader.unloadPlugin(plugin.name)
+  }
+}
+
+module.exports = {
+  // Hook system
+  HookSystem,
+  HookPoints,
+  hookSystem,
+  hooks,
+
+  // Plugin loader
+  PluginLoader,
+  pluginLoader,
+
+  // Plugin registry
+  PluginRegistry,
+  pluginRegistry,
+
+  // Convenience functions
+  initializePlugins,
+  shutdownPlugins
+}

package/core/plugin/loader.js

@@ -0,0 +1,331 @@
+/**
+ * PluginLoader - Dynamic Plugin Loading for prjct-cli
+ *
+ * Loads plugins from:
+ * 1. Built-in plugins (core/plugins/*)
+ * 2. Global plugins (~/.prjct-cli/plugins/*)
+ * 3. Project plugins (configured in prjct.config.json)
+ *
+ * @version 1.0.0
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+const { hookSystem } = require('./hooks')
+const { eventBus } = require('../bus')
+const pathManager = require('../infrastructure/path-manager')
+
+/**
+ * Plugin Interface
+ * @typedef {Object} Plugin
+ * @property {string} name - Unique plugin name
+ * @property {string} version - Semver version
+ * @property {string} [description] - Plugin description
+ * @property {Object} [hooks] - Hook handlers
+ * @property {Object} [commands] - Custom commands
+ * @property {Function} [activate] - Called when plugin loads
+ * @property {Function} [deactivate] - Called when plugin unloads
+ */
+
+class PluginLoader {
+  constructor() {
+    this.plugins = new Map()
+    this.pluginPaths = new Map()
+    this.initialized = false
+  }
+
+  /**
+   * Initialize plugin system
+   * @param {string} projectPath - Project root path
+   * @param {Object} config - Project config
+   */
+  async initialize(projectPath, config = {}) {
+    if (this.initialized) return
+
+    this.projectPath = projectPath
+    this.config = config
+
+    // Load plugins in order
+    await this.loadBuiltinPlugins()
+    await this.loadGlobalPlugins()
+    await this.loadProjectPlugins(config.plugins || [])
+
+    this.initialized = true
+  }
+
+  /**
+   * Load built-in plugins from core/plugins
+   */
+  async loadBuiltinPlugins() {
+    const builtinPath = path.join(__dirname, '..', 'plugins')
+
+    try {
+      const files = await fs.readdir(builtinPath)
+
+      for (const file of files) {
+        if (file.endsWith('.js')) {
+          const pluginPath = path.join(builtinPath, file)
+          await this.loadPlugin(pluginPath, 'builtin')
+        }
+      }
+    } catch {
+      // No built-in plugins directory yet
+    }
+  }
+
+  /**
+   * Load global plugins from ~/.prjct-cli/plugins
+   */
+  async loadGlobalPlugins() {
+    const globalPath = path.join(pathManager.getGlobalStoragePath(), 'plugins')
+
+    try {
+      const files = await fs.readdir(globalPath)
+
+      for (const file of files) {
+        if (file.endsWith('.js') || (await this.isDirectory(path.join(globalPath, file)))) {
+          const pluginPath = file.endsWith('.js')
+            ? path.join(globalPath, file)
+            : path.join(globalPath, file, 'index.js')
+          await this.loadPlugin(pluginPath, 'global')
+        }
+      }
+    } catch {
+      // No global plugins directory
+    }
+  }
+
+  /**
+   * Load project-specific plugins from config
+   * @param {Array<string|Object>} plugins - Plugin specs from config
+   */
+  async loadProjectPlugins(plugins) {
+    for (const spec of plugins) {
+      try {
+        if (typeof spec === 'string') {
+          // Simple name or path
+          if (spec.startsWith('file://')) {
+            // Local file path
+            const filePath = spec.replace('file://', '')
+            const fullPath = path.resolve(this.projectPath, filePath)
+            await this.loadPlugin(fullPath, 'project')
+          } else if (spec.startsWith('./') || spec.startsWith('../')) {
+            // Relative path
+            const fullPath = path.resolve(this.projectPath, spec)
+            await this.loadPlugin(fullPath, 'project')
+          } else {
+            // Plugin name - check if already loaded
+            if (!this.plugins.has(spec)) {
+              console.warn(`Plugin not found: ${spec}`)
+            }
+          }
+        } else if (typeof spec === 'object' && spec.path) {
+          // Object with path and config
+          const fullPath = path.resolve(this.projectPath, spec.path)
+          await this.loadPlugin(fullPath, 'project', spec.config)
+        }
+      } catch (error) {
+        console.error(`Failed to load plugin: ${spec}`, error.message)
+      }
+    }
+  }
+
+  /**
+   * Load a single plugin
+   * @param {string} pluginPath - Path to plugin file
+   * @param {string} source - 'builtin', 'global', or 'project'
+   * @param {Object} config - Plugin-specific config
+   */
+  async loadPlugin(pluginPath, source, config = {}) {
+    try {
+      // Check if file exists
+      await fs.access(pluginPath)
+
+      // Require the plugin
+      const plugin = require(pluginPath)
+
+      // Validate plugin structure
+      if (!plugin.name) {
+        throw new Error('Plugin must have a name property')
+      }
+
+      if (this.plugins.has(plugin.name)) {
+        console.warn(`Plugin already loaded: ${plugin.name}`)
+        return
+      }
+
+      // Store plugin
+      this.plugins.set(plugin.name, {
+        ...plugin,
+        source,
+        config: { ...config, ...this.config[plugin.name] }
+      })
+      this.pluginPaths.set(plugin.name, pluginPath)
+
+      // Register hooks
+      if (plugin.hooks) {
+        this.registerPluginHooks(plugin)
+      }
+
+      // Register event listeners
+      if (plugin.events) {
+        this.registerPluginEvents(plugin)
+      }
+
+      // Call activate if exists
+      if (typeof plugin.activate === 'function') {
+        await plugin.activate({
+          config: this.plugins.get(plugin.name).config,
+          eventBus,
+          hookSystem,
+          projectPath: this.projectPath
+        })
+      }
+
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        // File not found - skip silently
+      } else if (error.code === 'MODULE_NOT_FOUND') {
+        console.error(`Plugin module not found: ${pluginPath}`)
+      } else {
+        console.error(`Failed to load plugin from ${pluginPath}:`, error.message)
+      }
+    }
+  }
+
+  /**
+   * Register plugin hooks
+   * @param {Plugin} plugin
+   */
+  registerPluginHooks(plugin) {
+    for (const [hookPoint, handler] of Object.entries(plugin.hooks)) {
+      hookSystem.register(hookPoint, handler, {
+        pluginName: plugin.name,
+        priority: plugin.priority || 10
+      })
+    }
+  }
+
+  /**
+   * Register plugin event listeners
+   * @param {Plugin} plugin
+   */
+  registerPluginEvents(plugin) {
+    for (const [eventType, handler] of Object.entries(plugin.events)) {
+      eventBus.on(eventType, handler)
+    }
+  }
+
+  /**
+   * Unload a plugin
+   * @param {string} name - Plugin name
+   */
+  async unloadPlugin(name) {
+    const plugin = this.plugins.get(name)
+    if (!plugin) return
+
+    // Call deactivate if exists
+    if (typeof plugin.deactivate === 'function') {
+      await plugin.deactivate()
+    }
+
+    // Unregister hooks
+    hookSystem.unregisterPlugin(name)
+
+    // Remove from loaded plugins
+    this.plugins.delete(name)
+    this.pluginPaths.delete(name)
+
+    // Clear require cache
+    const pluginPath = this.pluginPaths.get(name)
+    if (pluginPath) {
+      delete require.cache[require.resolve(pluginPath)]
+    }
+  }
+
+  /**
+   * Reload a plugin
+   * @param {string} name - Plugin name
+   */
+  async reloadPlugin(name) {
+    const pluginPath = this.pluginPaths.get(name)
+    const plugin = this.plugins.get(name)
+
+    if (!pluginPath || !plugin) {
+      throw new Error(`Plugin not found: ${name}`)
+    }
+
+    await this.unloadPlugin(name)
+    await this.loadPlugin(pluginPath, plugin.source, plugin.config)
+  }
+
+  /**
+   * Get a loaded plugin
+   * @param {string} name
+   * @returns {Plugin|null}
+   */
+  getPlugin(name) {
+    return this.plugins.get(name) || null
+  }
+
+  /**
+   * Get all loaded plugins
+   * @returns {Plugin[]}
+   */
+  getAllPlugins() {
+    return Array.from(this.plugins.values())
+  }
+
+  /**
+   * Get plugins by source
+   * @param {string} source - 'builtin', 'global', or 'project'
+   * @returns {Plugin[]}
+   */
+  getPluginsBySource(source) {
+    return this.getAllPlugins().filter(p => p.source === source)
+  }
+
+  /**
+   * Get custom commands from all plugins
+   * @returns {Object} Map of command name to handler
+   */
+  getPluginCommands() {
+    const commands = {}
+
+    for (const plugin of this.plugins.values()) {
+      if (plugin.commands) {
+        for (const [name, handler] of Object.entries(plugin.commands)) {
+          commands[name] = {
+            handler,
+            plugin: plugin.name,
+            description: handler.description || `Command from ${plugin.name}`
+          }
+        }
+      }
+    }
+
+    return commands
+  }
+
+  /**
+   * Check if path is a directory
+   * @param {string} p
+   * @returns {Promise<boolean>}
+   */
+  async isDirectory(p) {
+    try {
+      const stat = await fs.stat(p)
+      return stat.isDirectory()
+    } catch {
+      return false
+    }
+  }
+}
+
+// Singleton instance
+const pluginLoader = new PluginLoader()
+
+module.exports = {
+  PluginLoader,
+  pluginLoader
+}

package/core/plugin/registry.js

@@ -0,0 +1,325 @@
+/**
+ * PluginRegistry - Plugin Discovery and Management
+ *
+ * Central registry for plugin information, discovery, and management.
+ *
+ * @version 1.0.0
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+const pathManager = require('../infrastructure/path-manager')
+const { pluginLoader } = require('./loader')
+
+class PluginRegistry {
+  constructor() {
+    this.availablePlugins = new Map()
+    this.initialized = false
+  }
+
+  /**
+   * Initialize registry and discover available plugins
+   */
+  async initialize() {
+    if (this.initialized) return
+
+    await this.discoverPlugins()
+    this.initialized = true
+  }
+
+  /**
+   * Discover all available plugins (not necessarily loaded)
+   */
+  async discoverPlugins() {
+    // Built-in plugins
+    await this.discoverFromPath(
+      path.join(__dirname, '..', 'plugins'),
+      'builtin'
+    )
+
+    // Global plugins
+    await this.discoverFromPath(
+      path.join(pathManager.getGlobalStoragePath(), 'plugins'),
+      'global'
+    )
+  }
+
+  /**
+   * Discover plugins from a path
+   * @param {string} dir
+   * @param {string} source
+   */
+  async discoverFromPath(dir, source) {
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true })
+
+      for (const entry of entries) {
+        try {
+          let pluginPath
+
+          if (entry.isFile() && entry.name.endsWith('.js')) {
+            pluginPath = path.join(dir, entry.name)
+          } else if (entry.isDirectory()) {
+            pluginPath = path.join(dir, entry.name, 'index.js')
+          } else {
+            continue
+          }
+
+          // Check if file exists
+          await fs.access(pluginPath)
+
+          // Read plugin metadata without loading
+          const metadata = await this.readPluginMetadata(pluginPath)
+          if (metadata) {
+            this.availablePlugins.set(metadata.name, {
+              ...metadata,
+              path: pluginPath,
+              source
+            })
+          }
+        } catch {
+          // Skip invalid plugins
+        }
+      }
+    } catch {
+      // Directory doesn't exist
+    }
+  }
+
+  /**
+   * Read plugin metadata without fully loading
+   * @param {string} pluginPath
+   * @returns {Object|null}
+   */
+  async readPluginMetadata(pluginPath) {
+    try {
+      const content = await fs.readFile(pluginPath, 'utf-8')
+
+      // Extract basic metadata from comments or exports
+      const nameMatch = content.match(/name:\s*['"]([^'"]+)['"]/)
+      const versionMatch = content.match(/version:\s*['"]([^'"]+)['"]/)
+      const descMatch = content.match(/description:\s*['"]([^'"]+)['"]/)
+
+      if (nameMatch) {
+        return {
+          name: nameMatch[1],
+          version: versionMatch ? versionMatch[1] : '1.0.0',
+          description: descMatch ? descMatch[1] : ''
+        }
+      }
+
+      // Fallback: try to require (might have side effects)
+      const plugin = require(pluginPath)
+      delete require.cache[require.resolve(pluginPath)]
+
+      if (plugin.name) {
+        return {
+          name: plugin.name,
+          version: plugin.version || '1.0.0',
+          description: plugin.description || ''
+        }
+      }
+    } catch {
+      // Can't read metadata
+    }
+
+    return null
+  }
+
+  /**
+   * Get all available plugins
+   * @returns {Object[]}
+   */
+  getAvailable() {
+    return Array.from(this.availablePlugins.values())
+  }
+
+  /**
+   * Get available plugins by source
+   * @param {string} source
+   * @returns {Object[]}
+   */
+  getAvailableBySource(source) {
+    return this.getAvailable().filter(p => p.source === source)
+  }
+
+  /**
+   * Check if a plugin is available
+   * @param {string} name
+   * @returns {boolean}
+   */
+  isAvailable(name) {
+    return this.availablePlugins.has(name)
+  }
+
+  /**
+   * Check if a plugin is loaded
+   * @param {string} name
+   * @returns {boolean}
+   */
+  isLoaded(name) {
+    return pluginLoader.getPlugin(name) !== null
+  }
+
+  /**
+   * Get plugin info
+   * @param {string} name
+   * @returns {Object|null}
+   */
+  getPluginInfo(name) {
+    const available = this.availablePlugins.get(name)
+    const loaded = pluginLoader.getPlugin(name)
+
+    if (!available && !loaded) return null
+
+    return {
+      ...(available || {}),
+      loaded: !!loaded,
+      active: loaded ? true : false
+    }
+  }
+
+  /**
+   * Install a plugin (copy to global plugins)
+   * @param {string} sourcePath - Path to plugin file/directory
+   * @param {string} [name] - Optional name override
+   */
+  async install(sourcePath, name = null) {
+    const globalPluginsPath = path.join(pathManager.getGlobalStoragePath(), 'plugins')
+    await fs.mkdir(globalPluginsPath, { recursive: true })
+
+    const stat = await fs.stat(sourcePath)
+
+    if (stat.isFile()) {
+      // Single file plugin
+      const pluginName = name || path.basename(sourcePath)
+      const destPath = path.join(globalPluginsPath, pluginName)
+      await fs.copyFile(sourcePath, destPath)
+    } else if (stat.isDirectory()) {
+      // Directory plugin
+      const pluginName = name || path.basename(sourcePath)
+      const destPath = path.join(globalPluginsPath, pluginName)
+      await this.copyDirectory(sourcePath, destPath)
+    }
+
+    // Refresh available plugins
+    await this.discoverPlugins()
+  }
+
+  /**
+   * Uninstall a plugin
+   * @param {string} name
+   */
+  async uninstall(name) {
+    const plugin = this.availablePlugins.get(name)
+
+    if (!plugin) {
+      throw new Error(`Plugin not found: ${name}`)
+    }
+
+    if (plugin.source === 'builtin') {
+      throw new Error('Cannot uninstall built-in plugins')
+    }
+
+    // Unload if loaded
+    if (this.isLoaded(name)) {
+      await pluginLoader.unloadPlugin(name)
+    }
+
+    // Delete plugin file/directory
+    const pluginPath = plugin.path
+    const stat = await fs.stat(path.dirname(pluginPath))
+
+    if (path.basename(pluginPath) === 'index.js') {
+      // Directory plugin
+      await fs.rm(path.dirname(pluginPath), { recursive: true })
+    } else {
+      // Single file plugin
+      await fs.unlink(pluginPath)
+    }
+
+    // Remove from registry
+    this.availablePlugins.delete(name)
+  }
+
+  /**
+   * Copy directory recursively
+   * @param {string} src
+   * @param {string} dest
+   */
+  async copyDirectory(src, dest) {
+    await fs.mkdir(dest, { recursive: true })
+    const entries = await fs.readdir(src, { withFileTypes: true })
+
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name)
+      const destPath = path.join(dest, entry.name)
+
+      if (entry.isDirectory()) {
+        await this.copyDirectory(srcPath, destPath)
+      } else {
+        await fs.copyFile(srcPath, destPath)
+      }
+    }
+  }
+
+  /**
+   * Generate plugin list for display
+   * @returns {string}
+   */
+  generatePluginList() {
+    const available = this.getAvailable()
+
+    if (available.length === 0) {
+      return 'No plugins installed.'
+    }
+
+    let output = '## Installed Plugins\n\n'
+
+    const bySource = {
+      builtin: [],
+      global: [],
+      project: []
+    }
+
+    for (const plugin of available) {
+      bySource[plugin.source].push(plugin)
+    }
+
+    if (bySource.builtin.length > 0) {
+      output += '### Built-in\n'
+      for (const p of bySource.builtin) {
+        const status = this.isLoaded(p.name) ? '●' : '○'
+        output += `- ${status} **${p.name}** v${p.version}\n`
+        if (p.description) {
+          output += `  ${p.description}\n`
+        }
+      }
+      output += '\n'
+    }
+
+    if (bySource.global.length > 0) {
+      output += '### Global\n'
+      for (const p of bySource.global) {
+        const status = this.isLoaded(p.name) ? '●' : '○'
+        output += `- ${status} **${p.name}** v${p.version}\n`
+        if (p.description) {
+          output += `  ${p.description}\n`
+        }
+      }
+      output += '\n'
+    }
+
+    output += '\n● = loaded, ○ = available'
+
+    return output
+  }
+}
+
+// Singleton instance
+const pluginRegistry = new PluginRegistry()
+
+module.exports = {
+  PluginRegistry,
+  pluginRegistry
+}