prjct-cli 1.22.0 → 1.23.0

package/core/outcomes/recorder.ts

@@ -1,195 +0,0 @@
-/**
- * Outcome Recorder
- *
- * Records execution outcomes for learning and analysis.
- * Appends to JSONL files for efficient streaming.
- */
-
-import path from 'node:path'
-import pathManager from '../infrastructure/path-manager'
-import { generateUUID } from '../schemas'
-import type { Outcome, OutcomeFilter, OutcomeInput } from '../types'
-import * as fileHelper from '../utils/file-helper'
-
-const OUTCOMES_DIR = 'outcomes'
-const OUTCOMES_FILE = 'outcomes.jsonl'
-
-/**
- * OutcomeRecorder - Records and retrieves execution outcomes.
- */
-export class OutcomeRecorder {
-  /**
-   * Get outcomes directory path for a project.
-   */
-  private getOutcomesDir(projectId: string): string {
-    const globalPath = pathManager.getGlobalProjectPath(projectId)
-    return path.join(globalPath, OUTCOMES_DIR)
-  }
-
-  /**
-   * Get outcomes file path for a project.
-   */
-  private getOutcomesPath(projectId: string): string {
-    return path.join(this.getOutcomesDir(projectId), OUTCOMES_FILE)
-  }
-
-  /**
-   * Record an outcome.
-   */
-  async record(projectId: string, input: OutcomeInput): Promise<Outcome> {
-    const outcome: Outcome = {
-      ...input,
-      id: generateUUID(),
-    }
-
-    const outcomesPath = this.getOutcomesPath(projectId)
-
-    // Ensure directory exists
-    await fileHelper.ensureDir(path.dirname(outcomesPath))
-
-    // Append to JSONL
-    await fileHelper.appendLine(outcomesPath, JSON.stringify(outcome))
-
-    return outcome
-  }
-
-  /**
-   * Get all outcomes for a project.
-   */
-  async getAll(projectId: string): Promise<Outcome[]> {
-    const outcomesPath = this.getOutcomesPath(projectId)
-
-    if (!(await fileHelper.fileExists(outcomesPath))) {
-      return []
-    }
-
-    const content = await fileHelper.readFile(outcomesPath)
-    if (!content.trim()) {
-      return []
-    }
-
-    return content
-      .trim()
-      .split('\n')
-      .filter((line) => line.trim())
-      .map((line) => JSON.parse(line) as Outcome)
-  }
-
-  /**
-   * Get outcomes matching a filter.
-   */
-  async filter(projectId: string, filter: OutcomeFilter): Promise<Outcome[]> {
-    const all = await this.getAll(projectId)
-
-    return all.filter((outcome) => {
-      if (filter.sessionId && outcome.sessionId !== filter.sessionId) {
-        return false
-      }
-      if (filter.command && outcome.command !== filter.command) {
-        return false
-      }
-      if (filter.agent && outcome.agentUsed !== filter.agent) {
-        return false
-      }
-      if (filter.fromDate && outcome.startedAt < filter.fromDate) {
-        return false
-      }
-      if (filter.toDate && outcome.completedAt > filter.toDate) {
-        return false
-      }
-      if (filter.minQuality && outcome.qualityScore < filter.minQuality) {
-        return false
-      }
-      if (filter.tags && filter.tags.length > 0) {
-        const outcomeTags = outcome.tags || []
-        if (!filter.tags.some((tag) => outcomeTags.includes(tag))) {
-          return false
-        }
-      }
-      return true
-    })
-  }
-
-  /**
-   * Get recent outcomes (last N).
-   */
-  async getRecent(projectId: string, count: number = 10): Promise<Outcome[]> {
-    const all = await this.getAll(projectId)
-    return all.slice(-count)
-  }
-
-  /**
-   * Get outcomes for a specific command.
-   */
-  async getByCommand(projectId: string, command: string): Promise<Outcome[]> {
-    return this.filter(projectId, { command })
-  }
-
-  /**
-   * Get outcomes for a specific agent.
-   */
-  async getByAgent(projectId: string, agent: string): Promise<Outcome[]> {
-    return this.filter(projectId, { agent })
-  }
-
-  /**
-   * Calculate estimate accuracy.
-   */
-  async getEstimateAccuracy(projectId: string): Promise<number> {
-    const outcomes = await this.getAll(projectId)
-
-    if (outcomes.length === 0) {
-      return 0
-    }
-
-    // Count outcomes where variance was within 20%
-    const accurate = outcomes.filter((o) => {
-      if (!o.variance) return false
-      const variance = this.parseVariance(o.variance)
-      const estimated = this.parseDuration(o.estimatedDuration)
-      if (estimated === 0) return false
-      return Math.abs(variance) / estimated <= 0.2
-    })
-
-    return Math.round((accurate.length / outcomes.length) * 100)
-  }
-
-  /**
-   * Parse variance string to minutes.
-   * "+30m" → 30, "-15m" → -15
-   */
-  private parseVariance(variance: string): number {
-    const match = variance.match(/^([+-])(\d+)([mh])$/)
-    if (!match) return 0
-
-    const sign = match[1] === '-' ? -1 : 1
-    const value = parseInt(match[2], 10)
-    const unit = match[3]
-
-    return sign * (unit === 'h' ? value * 60 : value)
-  }
-
-  /**
-   * Parse duration string to minutes.
-   * "2h" → 120, "30m" → 30, "1h 30m" → 90
-   */
-  private parseDuration(duration: string): number {
-    let minutes = 0
-
-    const hourMatch = duration.match(/(\d+)h/)
-    if (hourMatch) {
-      minutes += parseInt(hourMatch[1], 10) * 60
-    }
-
-    const minMatch = duration.match(/(\d+)m/)
-    if (minMatch) {
-      minutes += parseInt(minMatch[1], 10)
-    }
-
-    return minutes
-  }
-}
-
-// Singleton instance
-const outcomeRecorder = new OutcomeRecorder()
-export default outcomeRecorder

package/core/plugin/builtin/webhook.ts

@@ -1,148 +0,0 @@
-/**
- * Webhook Plugin for prjct-cli
- *
- * Sends HTTP POST requests to configured webhooks on events.
- * Useful for integrating with Slack, Discord, Zapier, etc.
- *
- * @version 1.0.0
- *
- * Configuration in prjct.config.json:
- * {
- *   "plugins": ["webhook"],
- *   "webhook": {
- *     "url": "https://hooks.example.com/...",
- *     "events": ["session.completed", "feature.shipped"],
- *     "secret": "optional-signing-secret"
- *   }
- * }
- */
-
-import crypto from 'node:crypto'
-import { EventTypes } from '../../bus'
-import type { WebhookConfig, WebhookPayload, WebhookPluginContext } from '../../types'
-import { getErrorMessage } from '../../types/fs'
-import { HookPoints } from '../hooks'
-
-const plugin = {
-  name: 'webhook',
-  version: '1.0.0',
-  description: 'Send HTTP webhooks on events',
-
-  // Plugin state
-  config: null as WebhookConfig | null,
-  enabled: false,
-  enabledEvents: [] as string[],
-
-  /**
-   * Activate plugin
-   */
-  async activate({ config }: WebhookPluginContext): Promise<void> {
-    plugin.config = config
-
-    if (!config.url) {
-      console.warn('[webhook] No URL configured, plugin disabled')
-      return
-    }
-
-    plugin.enabled = true
-    plugin.enabledEvents = config.events || [
-      EventTypes.SESSION_COMPLETED,
-      EventTypes.FEATURE_SHIPPED,
-      EventTypes.SNAPSHOT_CREATED,
-    ]
-  },
-
-  /**
-   * Deactivate plugin
-   */
-  async deactivate(): Promise<void> {
-    plugin.enabled = false
-  },
-
-  /**
-   * Event handlers
-   */
-  events: {
-    [EventTypes.SESSION_COMPLETED]: async (data: unknown): Promise<void> => {
-      await plugin.sendWebhook('session.completed', data)
-    },
-
-    [EventTypes.FEATURE_SHIPPED]: async (data: unknown): Promise<void> => {
-      await plugin.sendWebhook('feature.shipped', data)
-    },
-
-    [EventTypes.SNAPSHOT_CREATED]: async (data: unknown): Promise<void> => {
-      await plugin.sendWebhook('snapshot.created', data)
-    },
-
-    [EventTypes.TASK_COMPLETED]: async (data: unknown): Promise<void> => {
-      await plugin.sendWebhook('task.completed', data)
-    },
-  },
-
-  /**
-   * Hook handlers
-   */
-  hooks: {
-    [HookPoints.AFTER_FEATURE_SHIP]: async (data: {
-      feature: string
-      version: string
-      timestamp: string
-    }): Promise<void> => {
-      await plugin.sendWebhook('feature.shipped', {
-        feature: data.feature,
-        version: data.version,
-        timestamp: data.timestamp,
-      })
-    },
-  },
-
-  /**
-   * Send webhook request
-   */
-  async sendWebhook(event: string, data: unknown): Promise<void> {
-    if (!plugin.enabled || !plugin.config?.url) return
-
-    // Check if this event should be sent
-    if (plugin.config.events && !plugin.config.events.includes(event)) {
-      return
-    }
-
-    const payload: WebhookPayload = {
-      event,
-      timestamp: new Date().toISOString(),
-      source: 'prjct-cli',
-      data,
-    }
-
-    try {
-      const headers: Record<string, string> = {
-        'Content-Type': 'application/json',
-        'User-Agent': 'prjct-cli/webhook',
-      }
-
-      // Add signature if secret is configured
-      if (plugin.config.secret) {
-        const signature = crypto
-          .createHmac('sha256', plugin.config.secret)
-          .update(JSON.stringify(payload))
-          .digest('hex')
-        headers['X-Prjct-Signature'] = `sha256=${signature}`
-      }
-
-      const response = await fetch(plugin.config.url, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify(payload),
-      })
-
-      if (!response.ok) {
-        console.error(`[webhook] Request failed: ${response.status}`)
-      }
-    } catch (error) {
-      console.error(`[webhook] Error sending webhook:`, getErrorMessage(error))
-    }
-  },
-}
-
-export default plugin

package/core/plugin/hooks.ts

@@ -1,315 +0,0 @@
-/**
- * HookSystem - Plugin Lifecycle Hooks for prjct-cli
- *
- * Provides hook points for plugins to extend prjct functionality.
- * Hooks can modify data, add side effects, or integrate with external services.
- *
- * @version 1.0.0
- */
-
-import { EventTypes, eventBus } from '../bus'
-import { getErrorMessage } from '../types/fs'
-
-/**
- * Hook Points - Where plugins can intercept
- */
-const HookPoints = {
-  // Before hooks (can modify data)
-  BEFORE_SESSION_START: 'before:session.start',
-  BEFORE_SESSION_COMPLETE: 'before:session.complete',
-  BEFORE_TASK_CREATE: 'before:task.create',
-  BEFORE_FEATURE_SHIP: 'before:feature.ship',
-  BEFORE_SNAPSHOT_CREATE: 'before:snapshot.create',
-  BEFORE_COMMIT: 'before:git.commit',
-
-  // After hooks (for side effects)
-  AFTER_SESSION_START: 'after:session.start',
-  AFTER_SESSION_COMPLETE: 'after:session.complete',
-  AFTER_TASK_CREATE: 'after:task.create',
-  AFTER_TASK_COMPLETE: 'after:task.complete',
-  AFTER_FEATURE_SHIP: 'after:feature.ship',
-  AFTER_IDEA_CAPTURE: 'after:idea.capture',
-  AFTER_SNAPSHOT_CREATE: 'after:snapshot.create',
-  AFTER_SNAPSHOT_RESTORE: 'after:snapshot.restore',
-  AFTER_COMMIT: 'after:git.commit',
-  AFTER_PUSH: 'after:git.push',
-  AFTER_SYNC: 'after:project.sync',
-
-  // Transform hooks (must return modified data)
-  TRANSFORM_COMMIT_MESSAGE: 'transform:commit.message',
-  TRANSFORM_TASK_DATA: 'transform:task.data',
-  TRANSFORM_METRICS: 'transform:metrics',
-} as const
-
-export 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()
-  }
-
-  /**
-   * Register a hook handler
-   */
-  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: HookEntry = {
-      handler,
-      pluginName,
-      priority,
-      id: `${pluginName}:${Date.now()}`,
-    }
-
-    this.hooks.get(hookPoint)!.push(hookEntry)
-
-    // Sort by 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 })
-
-    // Return unregister function
-    return () => this.unregister(hookPoint, hookEntry.id)
-  }
-
-  /**
-   * Unregister a hook handler
-   */
-  unregister(hookPoint: string, id: string): void {
-    const hooks = this.hooks.get(hookPoint)
-    if (hooks) {
-      const index = hooks.findIndex((h) => h.id === id)
-      if (index !== -1) {
-        hooks.splice(index, 1)
-      }
-    }
-  }
-
-  /**
-   * Unregister all hooks from a plugin
-   */
-  unregisterPlugin(pluginName: string): void {
-    const pluginEntries = this.pluginHooks.get(pluginName)
-    if (pluginEntries) {
-      for (const entry of pluginEntries) {
-        this.unregister(entry.hookPoint, entry.id)
-      }
-      this.pluginHooks.delete(pluginName)
-    }
-  }
-
-  /**
-   * Execute a "before" hook (can modify data)
-   */
-  async executeBefore(
-    hookPoint: string,
-    data: Record<string, unknown>
-  ): Promise<Record<string, unknown>> {
-    const hooks = this.hooks.get(hookPoint) || []
-    let result = { ...data }
-
-    for (const hook of hooks) {
-      try {
-        const modified = await hook.handler(result)
-        if (modified !== undefined) {
-          result = { ...result, ...(modified as Record<string, unknown>) }
-        }
-      } catch (error) {
-        console.error(`Hook error [${hook.pluginName}] at ${hookPoint}:`, getErrorMessage(error))
-        // Continue with other hooks
-      }
-    }
-
-    return result
-  }
-
-  /**
-   * Execute an "after" hook (side effects only)
-   */
-  async executeAfter(hookPoint: string, data: Record<string, unknown>): Promise<void> {
-    const hooks = this.hooks.get(hookPoint) || []
-
-    // Execute all hooks in parallel for after hooks
-    await Promise.allSettled(
-      hooks.map(async (hook) => {
-        try {
-          await hook.handler(data)
-        } catch (error) {
-          console.error(`Hook error [${hook.pluginName}] at ${hookPoint}:`, getErrorMessage(error))
-        }
-      })
-    )
-
-    // Emit corresponding event for plugins listening via EventBus
-    const eventType = this.hookToEvent(hookPoint)
-    if (eventType) {
-      await eventBus.emit(eventType, data)
-    }
-  }
-
-  /**
-   * Execute a "transform" hook (must return modified value)
-   */
-  async executeTransform<T>(
-    hookPoint: string,
-    value: T,
-    context: Record<string, unknown> = {}
-  ): Promise<T> {
-    const hooks = this.hooks.get(hookPoint) || []
-    let result = value
-
-    for (const hook of hooks) {
-      try {
-        const transformed = await hook.handler(result, context)
-        if (transformed !== undefined) {
-          result = transformed as T
-        }
-      } catch (error) {
-        console.error(
-          `Transform hook error [${hook.pluginName}] at ${hookPoint}:`,
-          getErrorMessage(error)
-        )
-        // Keep previous value on error
-      }
-    }
-
-    return result
-  }
-
-  /**
-   * Map hook point to event type
-   */
-  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,
-      [HookPoints.AFTER_TASK_COMPLETE]: EventTypes.TASK_COMPLETED,
-      [HookPoints.AFTER_FEATURE_SHIP]: EventTypes.FEATURE_SHIPPED,
-      [HookPoints.AFTER_IDEA_CAPTURE]: EventTypes.IDEA_CAPTURED,
-      [HookPoints.AFTER_SNAPSHOT_CREATE]: EventTypes.SNAPSHOT_CREATED,
-      [HookPoints.AFTER_SNAPSHOT_RESTORE]: EventTypes.SNAPSHOT_RESTORED,
-      [HookPoints.AFTER_COMMIT]: EventTypes.COMMIT_CREATED,
-      [HookPoints.AFTER_PUSH]: EventTypes.PUSH_COMPLETED,
-      [HookPoints.AFTER_SYNC]: EventTypes.PROJECT_SYNCED,
-    }
-    return mapping[hookPoint] || null
-  }
-
-  /**
-   * Get all registered hooks for a point
-   */
-  getHooks(hookPoint: string): Array<{ pluginName: string; priority: number }> {
-    return (this.hooks.get(hookPoint) || []).map((h) => ({
-      pluginName: h.pluginName,
-      priority: h.priority,
-    }))
-  }
-
-  /**
-   * Get all hooks registered by a plugin
-   */
-  getPluginHooks(pluginName: string): string[] {
-    const entries = this.pluginHooks.get(pluginName) || []
-    return entries.map((e) => e.hookPoint)
-  }
-
-  /**
-   * Check if a hook point has any handlers
-   */
-  hasHooks(hookPoint: string): boolean {
-    const hooks = this.hooks.get(hookPoint)
-    return hooks !== undefined && hooks.length > 0
-  }
-
-  /**
-   * Clear all hooks
-   */
-  clear(): void {
-    this.hooks.clear()
-    this.pluginHooks.clear()
-  }
-}
-
-// Singleton instance
-const hookSystem = new HookSystem()
-
-// Convenience wrapper for common hook patterns
-const hooks = {
-  /**
-   * Register a before hook
-   */
-  before: (point: string, handler: HookHandler, options?: HookRegisterOptions) => {
-    const hookPoint = `before:${point}`
-    return hookSystem.register(hookPoint, handler, options)
-  },
-
-  /**
-   * Register an after hook
-   */
-  after: (point: string, handler: HookHandler, options?: HookRegisterOptions) => {
-    const hookPoint = `after:${point}`
-    return hookSystem.register(hookPoint, handler, options)
-  },
-
-  /**
-   * Register a transform hook
-   */
-  transform: (point: string, handler: HookHandler, options?: HookRegisterOptions) => {
-    const hookPoint = `transform:${point}`
-    return hookSystem.register(hookPoint, handler, options)
-  },
-
-  /**
-   * Execute before hooks
-   */
-  runBefore: (point: string, data: Record<string, unknown>) => {
-    return hookSystem.executeBefore(`before:${point}`, data)
-  },
-
-  /**
-   * Execute after hooks
-   */
-  runAfter: (point: string, data: Record<string, unknown>) => {
-    return hookSystem.executeAfter(`after:${point}`, data)
-  },
-
-  /**
-   * Execute transform hooks
-   */
-  runTransform: <T>(point: string, value: T, context?: Record<string, unknown>) => {
-    return hookSystem.executeTransform(`transform:${point}`, value, context)
-  },
-}
-
-export { HookSystem, HookPoints, hookSystem, hooks }

package/core/plugin/index.ts

@@ -1,50 +0,0 @@
-/**
- * Plugin System - Main Entry Point
- *
- * Exports all plugin-related functionality.
- *
- * @version 1.0.0
- */
-
-import { HookPoints, HookSystem, hookSystem, hooks } from './hooks'
-import { PluginLoader, pluginLoader } from './loader'
-import { PluginRegistry, pluginRegistry } from './registry'
-
-/**
- * Initialize the complete plugin system
- */
-async function initializePlugins(
-  projectPath: string,
-  config: Record<string, unknown> = {}
-): Promise<void> {
-  await pluginRegistry.initialize()
-  await pluginLoader.initialize(projectPath, config)
-}
-
-/**
- * Shutdown the plugin system
- */
-async function shutdownPlugins(): Promise<void> {
-  const plugins = pluginLoader.getAllPlugins()
-
-  for (const plugin of plugins) {
-    await pluginLoader.unloadPlugin(plugin.name)
-  }
-}
-
-export {
-  // Hook system
-  HookSystem,
-  HookPoints,
-  hookSystem,
-  hooks,
-  // Plugin loader
-  PluginLoader,
-  pluginLoader,
-  // Plugin registry
-  PluginRegistry,
-  pluginRegistry,
-  // Convenience functions
-  initializePlugins,
-  shutdownPlugins,
-}