prjct-cli 1.22.0 → 1.24.0

package/core/plugin/loader.ts

@@ -1,354 +0,0 @@
-/**
- * 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
- */
-
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { type EventCallback, eventBus } from '../bus'
-import pathManager from '../infrastructure/path-manager'
-import { getErrorMessage, isNotFoundError } from '../types/fs'
-import { hookSystem } from './hooks'
-
-type PluginSource = 'builtin' | 'global' | 'project'
-type HookHandler = (data: unknown) => unknown | Promise<unknown>
-
-interface Plugin {
-  name: string
-  version?: string
-  description?: string
-  hooks?: Record<string, HookHandler>
-  events?: Record<string, EventCallback>
-  commands?: Record<string, { handler: () => void; description?: string }>
-  priority?: number
-  activate?: (context: PluginContext) => Promise<void>
-  deactivate?: () => Promise<void>
-  source?: PluginSource
-  config?: Record<string, unknown>
-}
-
-interface PluginContext {
-  config: Record<string, unknown>
-  eventBus: typeof eventBus
-  hookSystem: typeof hookSystem
-  projectPath: string
-}
-
-interface PluginSpec {
-  path: string
-  config?: Record<string, unknown>
-}
-
-interface CommandInfo {
-  handler: () => void
-  plugin: string
-  description: string
-}
-
-class PluginLoader {
-  private plugins: Map<string, Plugin>
-  private pluginPaths: Map<string, string>
-  private initialized: boolean
-  private projectPath: string
-  private config: Record<string, unknown>
-
-  constructor() {
-    this.plugins = new Map()
-    this.pluginPaths = new Map()
-    this.initialized = false
-    this.projectPath = ''
-    this.config = {}
-  }
-
-  /**
-   * Initialize plugin system
-   */
-  async initialize(projectPath: string, config: Record<string, unknown> = {}): Promise<void> {
-    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 as Array<string | PluginSpec>) || [])
-
-    this.initialized = true
-  }
-
-  /**
-   * Load built-in plugins from core/plugin/builtin
-   */
-  async loadBuiltinPlugins(): Promise<void> {
-    const builtinPath = path.join(__dirname, 'builtin')
-
-    try {
-      const files = await fs.readdir(builtinPath)
-
-      for (const file of files) {
-        if (file.endsWith('.js') || file.endsWith('.ts')) {
-          const pluginPath = path.join(builtinPath, file)
-          await this.loadPlugin(pluginPath, 'builtin')
-        }
-      }
-    } catch (error) {
-      // No built-in plugins directory yet - expected
-      if (!isNotFoundError(error)) {
-        throw error
-      }
-    }
-  }
-
-  /**
-   * Load global plugins from ~/.prjct-cli/plugins
-   */
-  async loadGlobalPlugins(): Promise<void> {
-    const globalPath = path.join(pathManager.getGlobalBasePath(), 'plugins')
-
-    try {
-      const files = await fs.readdir(globalPath)
-
-      for (const file of files) {
-        const filePath = path.join(globalPath, file)
-        if (file.endsWith('.js') || file.endsWith('.ts') || (await this.isDirectory(filePath))) {
-          const pluginPath =
-            file.endsWith('.js') || file.endsWith('.ts')
-              ? filePath
-              : path.join(filePath, 'index.js')
-          await this.loadPlugin(pluginPath, 'global')
-        }
-      }
-    } catch (error) {
-      // No global plugins directory - expected
-      if (!isNotFoundError(error)) {
-        throw error
-      }
-    }
-  }
-
-  /**
-   * Load project-specific plugins from config
-   */
-  async loadProjectPlugins(plugins: Array<string | PluginSpec>): Promise<void> {
-    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}`, getErrorMessage(error))
-      }
-    }
-  }
-
-  /**
-   * Load a single plugin
-   */
-  async loadPlugin(
-    pluginPath: string,
-    source: PluginSource,
-    config: Record<string, unknown> = {}
-  ): Promise<void> {
-    try {
-      // Check if file exists
-      await fs.access(pluginPath)
-
-      // Import the plugin dynamically
-      const pluginModule = await import(pluginPath)
-      const plugin: Plugin = pluginModule.default || pluginModule
-
-      // 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] as Record<string, unknown>) || {}) },
-      })
-      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) {
-      const err = error as NodeJS.ErrnoException
-      if (err.code === 'ENOENT') {
-        // File not found - skip silently
-      } else if (err.code === 'MODULE_NOT_FOUND') {
-        console.error(`Plugin module not found: ${pluginPath}`)
-      } else {
-        console.error(`Failed to load plugin from ${pluginPath}:`, err.message)
-      }
-    }
-  }
-
-  /**
-   * Register plugin hooks
-   */
-  registerPluginHooks(plugin: Plugin): void {
-    for (const [hookPoint, handler] of Object.entries(plugin.hooks || {})) {
-      hookSystem.register(hookPoint, handler, {
-        pluginName: plugin.name,
-        priority: plugin.priority || 10,
-      })
-    }
-  }
-
-  /**
-   * Register plugin event listeners
-   */
-  registerPluginEvents(plugin: Plugin): void {
-    for (const [eventType, handler] of Object.entries(plugin.events || {})) {
-      eventBus.on(eventType, handler)
-    }
-  }
-
-  /**
-   * Unload a plugin
-   */
-  async unloadPlugin(name: string): Promise<void> {
-    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)
-
-    // Clear plugin path reference
-    this.pluginPaths.delete(name)
-  }
-
-  /**
-   * Reload a plugin
-   */
-  async reloadPlugin(name: string): Promise<void> {
-    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
-   */
-  getPlugin(name: string): Plugin | null {
-    return this.plugins.get(name) || null
-  }
-
-  /**
-   * Get all loaded plugins
-   */
-  getAllPlugins(): Plugin[] {
-    return Array.from(this.plugins.values())
-  }
-
-  /**
-   * Get plugins by source
-   */
-  getPluginsBySource(source: PluginSource): Plugin[] {
-    return this.getAllPlugins().filter((p) => p.source === source)
-  }
-
-  /**
-   * Get custom commands from all plugins
-   */
-  getPluginCommands(): Record<string, CommandInfo> {
-    const commands: Record<string, CommandInfo> = {}
-
-    for (const plugin of this.plugins.values()) {
-      if (plugin.commands) {
-        for (const [name, handler] of Object.entries(plugin.commands)) {
-          commands[name] = {
-            handler: handler.handler,
-            plugin: plugin.name,
-            description: handler.description || `Command from ${plugin.name}`,
-          }
-        }
-      }
-    }
-
-    return commands
-  }
-
-  /**
-   * Check if path is a directory
-   */
-  async isDirectory(p: string): Promise<boolean> {
-    try {
-      const stat = await fs.stat(p)
-      return stat.isDirectory()
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        return false
-      }
-      throw error
-    }
-  }
-}
-
-// Singleton instance
-const pluginLoader = new PluginLoader()
-
-export { PluginLoader, pluginLoader, type Plugin }

package/core/plugin/registry.ts

@@ -1,326 +0,0 @@
-/**
- * PluginRegistry - Plugin Discovery and Management
- *
- * Central registry for plugin information, discovery, and management.
- *
- * @version 1.0.0
- */
-
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import pathManager from '../infrastructure/path-manager'
-import { getErrorMessage, isNotFoundError } from '../types/fs'
-import { pluginLoader } from './loader'
-
-type PluginSource = 'builtin' | 'global' | 'project'
-
-interface PluginMetadata {
-  name: string
-  version: string
-  description: string
-  path?: string
-  source?: PluginSource
-}
-
-interface PluginInfo extends PluginMetadata {
-  loaded: boolean
-  active: boolean
-}
-
-class PluginRegistry {
-  private availablePlugins: Map<string, PluginMetadata>
-  private initialized: boolean
-
-  constructor() {
-    this.availablePlugins = new Map()
-    this.initialized = false
-  }
-
-  /**
-   * Initialize registry and discover available plugins
-   */
-  async initialize(): Promise<void> {
-    if (this.initialized) return
-
-    await this.discoverPlugins()
-    this.initialized = true
-  }
-
-  /**
-   * Discover all available plugins (not necessarily loaded)
-   */
-  async discoverPlugins(): Promise<void> {
-    // Built-in plugins
-    await this.discoverFromPath(path.join(__dirname, '..', 'plugins'), 'builtin')
-
-    // Global plugins
-    await this.discoverFromPath(path.join(pathManager.getGlobalBasePath(), 'plugins'), 'global')
-  }
-
-  /**
-   * Discover plugins from a path
-   */
-  async discoverFromPath(dir: string, source: PluginSource): Promise<void> {
-    try {
-      const entries = await fs.readdir(dir, { withFileTypes: true })
-
-      for (const entry of entries) {
-        try {
-          let pluginPath: string
-
-          if (entry.isFile() && (entry.name.endsWith('.js') || entry.name.endsWith('.ts'))) {
-            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 (error) {
-          // Skip invalid plugins - ENOENT expected for missing files
-          if (!isNotFoundError(error)) {
-            console.error(`Plugin discovery error: ${getErrorMessage(error)}`)
-          }
-        }
-      }
-    } catch (error) {
-      // Directory doesn't exist - expected
-      if (!isNotFoundError(error)) {
-        throw error
-      }
-    }
-  }
-
-  /**
-   * Read plugin metadata without fully loading
-   */
-  async readPluginMetadata(pluginPath: string): Promise<PluginMetadata | null> {
-    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 import (might have side effects)
-      const pluginModule = await import(pluginPath)
-      const plugin = pluginModule.default || pluginModule
-
-      if (plugin.name) {
-        return {
-          name: plugin.name,
-          version: plugin.version || '1.0.0',
-          description: plugin.description || '',
-        }
-      }
-    } catch (error) {
-      // Can't read metadata - ENOENT or parse error expected
-      if (!isNotFoundError(error) && !(error instanceof SyntaxError)) {
-        console.error(`Plugin metadata read error: ${getErrorMessage(error)}`)
-      }
-    }
-
-    return null
-  }
-
-  /**
-   * Get all available plugins
-   */
-  getAvailable(): PluginMetadata[] {
-    return Array.from(this.availablePlugins.values())
-  }
-
-  /**
-   * Get available plugins by source
-   */
-  getAvailableBySource(source: PluginSource): PluginMetadata[] {
-    return this.getAvailable().filter((p) => p.source === source)
-  }
-
-  /**
-   * Check if a plugin is available
-   */
-  isAvailable(name: string): boolean {
-    return this.availablePlugins.has(name)
-  }
-
-  /**
-   * Check if a plugin is loaded
-   */
-  isLoaded(name: string): boolean {
-    return pluginLoader.getPlugin(name) !== null
-  }
-
-  /**
-   * Get plugin info
-   */
-  getPluginInfo(name: string): PluginInfo | null {
-    const available = this.availablePlugins.get(name)
-    const loaded = pluginLoader.getPlugin(name)
-
-    if (!available && !loaded) return null
-
-    return {
-      ...(available || { name, version: '1.0.0', description: '' }),
-      loaded: !!loaded,
-      active: !!loaded,
-    }
-  }
-
-  /**
-   * Install a plugin (copy to global plugins)
-   */
-  async install(sourcePath: string, name: string | null = null): Promise<void> {
-    const globalPluginsPath = path.join(pathManager.getGlobalBasePath(), '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
-   */
-  async uninstall(name: string): Promise<void> {
-    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!
-
-    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
-   */
-  async copyDirectory(src: string, dest: string): Promise<void> {
-    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
-   */
-  generatePluginList(): string {
-    const available = this.getAvailable()
-
-    if (available.length === 0) {
-      return 'No plugins installed.'
-    }
-
-    let output = '## Installed Plugins\n\n'
-
-    const bySource: Record<PluginSource, PluginMetadata[]> = {
-      builtin: [],
-      global: [],
-      project: [],
-    }
-
-    for (const plugin of available) {
-      if (plugin.source) {
-        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()
-
-export { PluginRegistry, pluginRegistry, type PluginMetadata, type PluginInfo }

package/core/schemas/agents.ts

@@ -1,27 +0,0 @@
-/**
- * Agents Schema
- *
- * Defines the structure for agents.json - specialized AI agents.
- */
-
-export interface AgentSchema {
-  name: string
-  description: string
-  skills: string[]
-  patterns: string[]
-  filesOwned: string[]
-  successRate?: number
-  tasksCompleted?: number
-  bestFor: string[]
-  avoidFor: string[]
-}
-
-export type AgentsSchema = AgentSchema[]
-
-export const DEFAULT_AGENT: Omit<AgentSchema, 'name' | 'description'> = {
-  skills: [],
-  patterns: [],
-  filesOwned: [],
-  bestFor: [],
-  avoidFor: [],
-}