prjct-cli 0.11.5 → 0.12.0

package/core/plugin/{hooks.js → hooks.ts}

@@ -7,7 +7,7 @@
  * @version 1.0.0
  */
 
-const { eventBus, EventTypes } = require('../bus')
+import { eventBus, EventTypes } from '../bus'
 
 /**
  * Hook Points - Where plugins can intercept
@@ -38,47 +38,64 @@ const HookPoints = {
   TRANSFORM_COMMIT_MESSAGE: 'transform:commit.message',
   TRANSFORM_TASK_DATA: 'transform:task.data',
   TRANSFORM_METRICS: 'transform:metrics'
+} as const
+
+type HookPoint = typeof HookPoints[keyof typeof HookPoints]
+type HookHandler = (data: unknown, context?: unknown) => unknown | Promise<unknown>
+
+interface HookEntry {
+  handler: HookHandler
+  pluginName: string
+  priority: number
+  id: string
+}
+
+interface HookRegisterOptions {
+  pluginName?: string
+  priority?: number
+}
+
+interface PluginHookEntry {
+  hookPoint: string
+  id: string
 }
 
 class HookSystem {
+  private hooks: Map<string, HookEntry[]>
+  private pluginHooks: Map<string, PluginHookEntry[]>
+
   constructor() {
     this.hooks = new Map()
-    this.pluginHooks = new Map() // Track hooks by plugin
+    this.pluginHooks = new Map()
   }
 
   /**
    * Register a hook handler
-   * @param {string} hookPoint - Hook point from HookPoints
-   * @param {Function} handler - Handler function
-   * @param {Object} options
-   * @param {string} options.pluginName - Name of the plugin
-   * @param {number} options.priority - Execution order (lower = first)
-   * @returns {Function} Unregister function
    */
-  register(hookPoint, handler, options = {}) {
+  register(hookPoint: string, handler: HookHandler, options: HookRegisterOptions = {}): () => void {
     const { pluginName = 'anonymous', priority = 10 } = options
 
     if (!this.hooks.has(hookPoint)) {
       this.hooks.set(hookPoint, [])
     }
 
-    const hookEntry = {
+    const hookEntry: HookEntry = {
       handler,
       pluginName,
       priority,
       id: `${pluginName}:${Date.now()}`
     }
 
-    this.hooks.get(hookPoint).push(hookEntry)
+    this.hooks.get(hookPoint)!.push(hookEntry)
 
     // Sort by priority
-    this.hooks.get(hookPoint).sort((a, b) => a.priority - b.priority)
+    this.hooks.get(hookPoint)!.sort((a, b) => a.priority - b.priority)
 
     // Track by plugin
     if (!this.pluginHooks.has(pluginName)) {
       this.pluginHooks.set(pluginName, [])
     }
-    this.pluginHooks.get(pluginName).push({ hookPoint, id: hookEntry.id })
+    this.pluginHooks.get(pluginName)!.push({ hookPoint, id: hookEntry.id })
 
     // Return unregister function
     return () => this.unregister(hookPoint, hookEntry.id)
@@ -86,10 +103,8 @@ class HookSystem {
 
   /**
    * Unregister a hook handler
-   * @param {string} hookPoint
-   * @param {string} id
    */
-  unregister(hookPoint, id) {
+  unregister(hookPoint: string, id: string): void {
     const hooks = this.hooks.get(hookPoint)
     if (hooks) {
       const index = hooks.findIndex(h => h.id === id)
@@ -101,9 +116,8 @@ class HookSystem {
 
   /**
    * Unregister all hooks from a plugin
-   * @param {string} pluginName
    */
-  unregisterPlugin(pluginName) {
+  unregisterPlugin(pluginName: string): void {
     const pluginEntries = this.pluginHooks.get(pluginName)
     if (pluginEntries) {
       for (const entry of pluginEntries) {
@@ -115,11 +129,8 @@ class HookSystem {
 
   /**
    * Execute a "before" hook (can modify data)
-   * @param {string} hookPoint
-   * @param {Object} data - Data that can be modified
-   * @returns {Promise<Object>} Modified data
    */
-  async executeBefore(hookPoint, data) {
+  async executeBefore(hookPoint: string, data: Record<string, unknown>): Promise<Record<string, unknown>> {
     const hooks = this.hooks.get(hookPoint) || []
     let result = { ...data }
 
@@ -127,10 +138,10 @@ class HookSystem {
       try {
         const modified = await hook.handler(result)
         if (modified !== undefined) {
-          result = { ...result, ...modified }
+          result = { ...result, ...(modified as Record<string, unknown>) }
         }
       } catch (error) {
-        console.error(`Hook error [${hook.pluginName}] at ${hookPoint}:`, error.message)
+        console.error(`Hook error [${hook.pluginName}] at ${hookPoint}:`, (error as Error).message)
         // Continue with other hooks
       }
     }
@@ -140,11 +151,8 @@ class HookSystem {
 
   /**
    * Execute an "after" hook (side effects only)
-   * @param {string} hookPoint
-   * @param {Object} data - Read-only data
-   * @returns {Promise<void>}
    */
-  async executeAfter(hookPoint, data) {
+  async executeAfter(hookPoint: string, data: Record<string, unknown>): Promise<void> {
     const hooks = this.hooks.get(hookPoint) || []
 
     // Execute all hooks in parallel for after hooks
@@ -153,7 +161,7 @@ class HookSystem {
         try {
           await hook.handler(data)
         } catch (error) {
-          console.error(`Hook error [${hook.pluginName}] at ${hookPoint}:`, error.message)
+          console.error(`Hook error [${hook.pluginName}] at ${hookPoint}:`, (error as Error).message)
         }
       })
     )
@@ -167,12 +175,8 @@ class HookSystem {
 
   /**
    * Execute a "transform" hook (must return modified value)
-   * @param {string} hookPoint
-   * @param {*} value - Value to transform
-   * @param {Object} context - Additional context
-   * @returns {Promise<*>} Transformed value
    */
-  async executeTransform(hookPoint, value, context = {}) {
+  async executeTransform<T>(hookPoint: string, value: T, context: Record<string, unknown> = {}): Promise<T> {
     const hooks = this.hooks.get(hookPoint) || []
     let result = value
 
@@ -180,10 +184,10 @@ class HookSystem {
       try {
         const transformed = await hook.handler(result, context)
         if (transformed !== undefined) {
-          result = transformed
+          result = transformed as T
         }
       } catch (error) {
-        console.error(`Transform hook error [${hook.pluginName}] at ${hookPoint}:`, error.message)
+        console.error(`Transform hook error [${hook.pluginName}] at ${hookPoint}:`, (error as Error).message)
         // Keep previous value on error
       }
     }
@@ -193,11 +197,9 @@ class HookSystem {
 
   /**
    * Map hook point to event type
-   * @param {string} hookPoint
-   * @returns {string|null}
    */
-  hookToEvent(hookPoint) {
-    const mapping = {
+  hookToEvent(hookPoint: string): string | null {
+    const mapping: Record<string, string> = {
       [HookPoints.AFTER_SESSION_START]: EventTypes.SESSION_STARTED,
       [HookPoints.AFTER_SESSION_COMPLETE]: EventTypes.SESSION_COMPLETED,
       [HookPoints.AFTER_TASK_CREATE]: EventTypes.TASK_CREATED,
@@ -215,10 +217,8 @@ class HookSystem {
 
   /**
    * Get all registered hooks for a point
-   * @param {string} hookPoint
-   * @returns {Object[]}
    */
-  getHooks(hookPoint) {
+  getHooks(hookPoint: string): Array<{ pluginName: string; priority: number }> {
     return (this.hooks.get(hookPoint) || []).map(h => ({
       pluginName: h.pluginName,
       priority: h.priority
@@ -227,28 +227,24 @@ class HookSystem {
 
   /**
    * Get all hooks registered by a plugin
-   * @param {string} pluginName
-   * @returns {string[]} Hook points
    */
-  getPluginHooks(pluginName) {
+  getPluginHooks(pluginName: string): string[] {
     const entries = this.pluginHooks.get(pluginName) || []
     return entries.map(e => e.hookPoint)
   }
 
   /**
    * Check if a hook point has any handlers
-   * @param {string} hookPoint
-   * @returns {boolean}
    */
-  hasHooks(hookPoint) {
+  hasHooks(hookPoint: string): boolean {
     const hooks = this.hooks.get(hookPoint)
-    return hooks && hooks.length > 0
+    return hooks !== undefined && hooks.length > 0
   }
 
   /**
    * Clear all hooks
    */
-  clear() {
+  clear(): void {
     this.hooks.clear()
     this.pluginHooks.clear()
   }
@@ -262,7 +258,7 @@ const hooks = {
   /**
    * Register a before hook
    */
-  before: (point, handler, options) => {
+  before: (point: string, handler: HookHandler, options?: HookRegisterOptions) => {
     const hookPoint = `before:${point}`
     return hookSystem.register(hookPoint, handler, options)
   },
@@ -270,7 +266,7 @@ const hooks = {
   /**
    * Register an after hook
    */
-  after: (point, handler, options) => {
+  after: (point: string, handler: HookHandler, options?: HookRegisterOptions) => {
     const hookPoint = `after:${point}`
     return hookSystem.register(hookPoint, handler, options)
   },
@@ -278,7 +274,7 @@ const hooks = {
   /**
    * Register a transform hook
    */
-  transform: (point, handler, options) => {
+  transform: (point: string, handler: HookHandler, options?: HookRegisterOptions) => {
     const hookPoint = `transform:${point}`
     return hookSystem.register(hookPoint, handler, options)
   },
@@ -286,28 +282,30 @@ const hooks = {
   /**
    * Execute before hooks
    */
-  runBefore: (point, data) => {
+  runBefore: (point: string, data: Record<string, unknown>) => {
     return hookSystem.executeBefore(`before:${point}`, data)
   },
 
   /**
    * Execute after hooks
    */
-  runAfter: (point, data) => {
+  runAfter: (point: string, data: Record<string, unknown>) => {
     return hookSystem.executeAfter(`after:${point}`, data)
   },
 
   /**
    * Execute transform hooks
    */
-  runTransform: (point, value, context) => {
+  runTransform: <T>(point: string, value: T, context?: Record<string, unknown>) => {
     return hookSystem.executeTransform(`transform:${point}`, value, context)
   }
 }
 
-module.exports = {
+export {
   HookSystem,
   HookPoints,
   hookSystem,
   hooks
 }
+
+export default { HookSystem, HookPoints, hookSystem, hooks }

package/core/plugin/{index.js → index.ts}

@@ -6,16 +6,14 @@
  * @version 1.0.0
  */
 
-const { HookSystem, HookPoints, hookSystem, hooks } = require('./hooks')
-const { PluginLoader, pluginLoader } = require('./loader')
-const { PluginRegistry, pluginRegistry } = require('./registry')
+import { HookSystem, HookPoints, hookSystem, hooks } from './hooks'
+import { PluginLoader, pluginLoader } from './loader'
+import { PluginRegistry, pluginRegistry } from './registry'
 
 /**
  * Initialize the complete plugin system
- * @param {string} projectPath
- * @param {Object} config
  */
-async function initializePlugins(projectPath, config = {}) {
+async function initializePlugins(projectPath: string, config: Record<string, unknown> = {}): Promise<void> {
   await pluginRegistry.initialize()
   await pluginLoader.initialize(projectPath, config)
 }
@@ -23,7 +21,7 @@ async function initializePlugins(projectPath, config = {}) {
 /**
  * Shutdown the plugin system
  */
-async function shutdownPlugins() {
+async function shutdownPlugins(): Promise<void> {
   const plugins = pluginLoader.getAllPlugins()
 
   for (const plugin of plugins) {
@@ -31,7 +29,7 @@ async function shutdownPlugins() {
   }
 }
 
-module.exports = {
+export {
   // Hook system
   HookSystem,
   HookPoints,
@@ -50,3 +48,16 @@ module.exports = {
   initializePlugins,
   shutdownPlugins
 }
+
+export default {
+  HookSystem,
+  HookPoints,
+  hookSystem,
+  hooks,
+  PluginLoader,
+  pluginLoader,
+  PluginRegistry,
+  pluginRegistry,
+  initializePlugins,
+  shutdownPlugins
+}

package/core/plugin/{loader.js → loader.ts}

@@ -9,37 +9,66 @@
  * @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')
+import fs from 'fs/promises'
+import path from 'path'
+import { hookSystem } from './hooks'
+import { eventBus } from '../bus'
+import pathManager from '../infrastructure/path-manager'
+
+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, HookHandler>
+  commands?: Record<string, { handler: () => void; description?: string }>
+  priority?: number
+  activate?: (context: PluginContext) => Promise<void>
+  deactivate?: () => Promise<void>
+  source?: PluginSource
+  config?: Record<string, unknown>
+}
 
-/**
- * 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
- */
+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
-   * @param {string} projectPath - Project root path
-   * @param {Object} config - Project config
    */
-  async initialize(projectPath, config = {}) {
+  async initialize(projectPath: string, config: Record<string, unknown> = {}): Promise<void> {
     if (this.initialized) return
 
     this.projectPath = projectPath
@@ -48,7 +77,7 @@ class PluginLoader {
     // Load plugins in order
     await this.loadBuiltinPlugins()
     await this.loadGlobalPlugins()
-    await this.loadProjectPlugins(config.plugins || [])
+    await this.loadProjectPlugins((config.plugins as Array<string | PluginSpec>) || [])
 
     this.initialized = true
   }
@@ -56,14 +85,14 @@ class PluginLoader {
   /**
    * Load built-in plugins from core/plugins
    */
-  async loadBuiltinPlugins() {
+  async loadBuiltinPlugins(): Promise<void> {
     const builtinPath = path.join(__dirname, '..', 'plugins')
 
     try {
       const files = await fs.readdir(builtinPath)
 
       for (const file of files) {
-        if (file.endsWith('.js')) {
+        if (file.endsWith('.js') || file.endsWith('.ts')) {
           const pluginPath = path.join(builtinPath, file)
           await this.loadPlugin(pluginPath, 'builtin')
         }
@@ -76,17 +105,18 @@ class PluginLoader {
   /**
    * Load global plugins from ~/.prjct-cli/plugins
    */
-  async loadGlobalPlugins() {
+  async loadGlobalPlugins(): Promise<void> {
     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')
+        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')
         }
       }
@@ -97,9 +127,8 @@ class PluginLoader {
 
   /**
    * Load project-specific plugins from config
-   * @param {Array<string|Object>} plugins - Plugin specs from config
    */
-  async loadProjectPlugins(plugins) {
+  async loadProjectPlugins(plugins: Array<string | PluginSpec>): Promise<void> {
     for (const spec of plugins) {
       try {
         if (typeof spec === 'string') {
@@ -125,24 +154,21 @@ class PluginLoader {
           await this.loadPlugin(fullPath, 'project', spec.config)
         }
       } catch (error) {
-        console.error(`Failed to load plugin: ${spec}`, error.message)
+        console.error(`Failed to load plugin: ${spec}`, (error as 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 = {}) {
+  async loadPlugin(pluginPath: string, source: PluginSource, config: Record<string, unknown> = {}): Promise<void> {
     try {
       // Check if file exists
       await fs.access(pluginPath)
 
       // Require the plugin
-      const plugin = require(pluginPath)
+      const plugin: Plugin = require(pluginPath)
 
       // Validate plugin structure
       if (!plugin.name) {
@@ -158,7 +184,7 @@ class PluginLoader {
       this.plugins.set(plugin.name, {
         ...plugin,
         source,
-        config: { ...config, ...this.config[plugin.name] }
+        config: { ...config, ...(this.config[plugin.name] as Record<string, unknown> || {}) }
       })
       this.pluginPaths.set(plugin.name, pluginPath)
 
@@ -175,7 +201,7 @@ class PluginLoader {
       // Call activate if exists
       if (typeof plugin.activate === 'function') {
         await plugin.activate({
-          config: this.plugins.get(plugin.name).config,
+          config: this.plugins.get(plugin.name)!.config!,
           eventBus,
           hookSystem,
           projectPath: this.projectPath
@@ -183,22 +209,22 @@ class PluginLoader {
       }
 
     } catch (error) {
-      if (error.code === 'ENOENT') {
+      const err = error as NodeJS.ErrnoException
+      if (err.code === 'ENOENT') {
         // File not found - skip silently
-      } else if (error.code === 'MODULE_NOT_FOUND') {
+      } else if (err.code === 'MODULE_NOT_FOUND') {
         console.error(`Plugin module not found: ${pluginPath}`)
       } else {
-        console.error(`Failed to load plugin from ${pluginPath}:`, error.message)
+        console.error(`Failed to load plugin from ${pluginPath}:`, err.message)
       }
     }
   }
 
   /**
    * Register plugin hooks
-   * @param {Plugin} plugin
    */
-  registerPluginHooks(plugin) {
-    for (const [hookPoint, handler] of Object.entries(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
@@ -208,19 +234,17 @@ class PluginLoader {
 
   /**
    * Register plugin event listeners
-   * @param {Plugin} plugin
    */
-  registerPluginEvents(plugin) {
-    for (const [eventType, handler] of Object.entries(plugin.events)) {
+  registerPluginEvents(plugin: Plugin): void {
+    for (const [eventType, handler] of Object.entries(plugin.events || {})) {
       eventBus.on(eventType, handler)
     }
   }
 
   /**
    * Unload a plugin
-   * @param {string} name - Plugin name
    */
-  async unloadPlugin(name) {
+  async unloadPlugin(name: string): Promise<void> {
     const plugin = this.plugins.get(name)
     if (!plugin) return
 
@@ -234,20 +258,19 @@ class PluginLoader {
 
     // 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)]
     }
+    this.pluginPaths.delete(name)
   }
 
   /**
    * Reload a plugin
-   * @param {string} name - Plugin name
    */
-  async reloadPlugin(name) {
+  async reloadPlugin(name: string): Promise<void> {
     const pluginPath = this.pluginPaths.get(name)
     const plugin = this.plugins.get(name)
 
@@ -256,47 +279,41 @@ class PluginLoader {
     }
 
     await this.unloadPlugin(name)
-    await this.loadPlugin(pluginPath, plugin.source, plugin.config)
+    await this.loadPlugin(pluginPath, plugin.source!, plugin.config)
   }
 
   /**
    * Get a loaded plugin
-   * @param {string} name
-   * @returns {Plugin|null}
    */
-  getPlugin(name) {
+  getPlugin(name: string): Plugin | null {
     return this.plugins.get(name) || null
   }
 
   /**
    * Get all loaded plugins
-   * @returns {Plugin[]}
    */
-  getAllPlugins() {
+  getAllPlugins(): Plugin[] {
     return Array.from(this.plugins.values())
   }
 
   /**
    * Get plugins by source
-   * @param {string} source - 'builtin', 'global', or 'project'
-   * @returns {Plugin[]}
    */
-  getPluginsBySource(source) {
+  getPluginsBySource(source: PluginSource): Plugin[] {
     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 = {}
+  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.handler,
             plugin: plugin.name,
             description: handler.description || `Command from ${plugin.name}`
           }
@@ -309,10 +326,8 @@ class PluginLoader {
 
   /**
    * Check if path is a directory
-   * @param {string} p
-   * @returns {Promise<boolean>}
    */
-  async isDirectory(p) {
+  async isDirectory(p: string): Promise<boolean> {
     try {
       const stat = await fs.stat(p)
       return stat.isDirectory()
@@ -325,7 +340,10 @@ class PluginLoader {
 // Singleton instance
 const pluginLoader = new PluginLoader()
 
-module.exports = {
+export {
   PluginLoader,
-  pluginLoader
+  pluginLoader,
+  Plugin
 }
+
+export default { PluginLoader, pluginLoader }