prjct-cli 0.10.13 → 0.11.0

package/core/domain/snapshot-manager.js

@@ -0,0 +1,375 @@
+/**
+ * SnapshotManager - Git-based Undo/Redo System
+ *
+ * Uses Git internally to track file changes and enable undo/redo.
+ * Inspired by OpenCode's snapshot system.
+ *
+ * Storage: ~/.prjct-cli/projects/{projectId}/snapshots/
+ *
+ * @version 1.0.0
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+const { exec } = require('child_process')
+const { promisify } = require('util')
+const pathManager = require('../infrastructure/path-manager')
+const configManager = require('../infrastructure/config-manager')
+const { emit } = require('../bus')
+
+const execAsync = promisify(exec)
+
+class SnapshotManager {
+  constructor(projectPath) {
+    this.projectPath = projectPath
+    this.projectId = null
+    this.snapshotDir = null
+    this.initialized = false
+  }
+
+  /**
+   * Initialize snapshot system for project
+   */
+  async initialize() {
+    this.projectId = await configManager.getProjectId(this.projectPath)
+    if (!this.projectId) {
+      throw new Error('No prjct project found. Run /p:init first.')
+    }
+
+    // Snapshots live in global storage
+    const globalPath = pathManager.getGlobalProjectPath(this.projectId)
+    this.snapshotDir = path.join(globalPath, 'snapshots')
+
+    // Ensure directory exists
+    await fs.mkdir(this.snapshotDir, { recursive: true })
+
+    // Initialize bare git repo if not exists
+    const gitDir = path.join(this.snapshotDir, '.git')
+    try {
+      await fs.access(gitDir)
+    } catch {
+      await this.initGitRepo()
+    }
+
+    this.initialized = true
+  }
+
+  /**
+   * Initialize internal Git repository
+   */
+  async initGitRepo() {
+    const gitDir = path.join(this.snapshotDir, '.git')
+
+    // Create bare-ish repo structure
+    await execAsync(`git init "${this.snapshotDir}"`, { cwd: this.projectPath })
+
+    // Configure for snapshot use
+    await execAsync(`git config user.email "prjct@local"`, { cwd: this.snapshotDir })
+    await execAsync(`git config user.name "prjct-snapshots"`, { cwd: this.snapshotDir })
+
+    // Create initial empty commit
+    await execAsync(`git commit --allow-empty -m "init: snapshot system"`, { cwd: this.snapshotDir })
+  }
+
+  /**
+   * Create a snapshot of current project state
+   *
+   * @param {string} message - Snapshot description
+   * @param {string[]} files - Specific files to track (optional, defaults to all changed)
+   * @returns {Promise<Object>} Snapshot info {hash, message, timestamp, files}
+   */
+  async create(message, files = null) {
+    if (!this.initialized) await this.initialize()
+
+    const timestamp = new Date().toISOString()
+
+    // Copy changed files to snapshot directory
+    const changedFiles = files || await this.getChangedFiles()
+
+    if (changedFiles.length === 0) {
+      return {
+        hash: null,
+        message: 'No changes to snapshot',
+        timestamp,
+        files: []
+      }
+    }
+
+    // Copy files to snapshot dir maintaining structure
+    for (const file of changedFiles) {
+      const srcPath = path.join(this.projectPath, file)
+      const destPath = path.join(this.snapshotDir, file)
+
+      try {
+        const content = await fs.readFile(srcPath, 'utf-8')
+        await fs.mkdir(path.dirname(destPath), { recursive: true })
+        await fs.writeFile(destPath, content)
+      } catch (err) {
+        // File might be deleted, mark for removal
+        try {
+          await fs.unlink(destPath)
+        } catch {}
+      }
+    }
+
+    // Stage and commit in snapshot repo
+    await execAsync(`git add -A`, { cwd: this.snapshotDir })
+
+    const commitMsg = `${message}\n\nFiles: ${changedFiles.length}\nTimestamp: ${timestamp}`
+    await execAsync(`git commit -m "${commitMsg.replace(/"/g, '\\"')}"`, { cwd: this.snapshotDir })
+
+    // Get commit hash
+    const { stdout } = await execAsync(`git rev-parse HEAD`, { cwd: this.snapshotDir })
+    const hash = stdout.trim()
+
+    // Log to manifest
+    await this.logSnapshot({
+      hash,
+      message,
+      timestamp,
+      files: changedFiles
+    })
+
+    // Emit event for plugins
+    await emit.snapshotCreated({
+      hash,
+      message,
+      timestamp,
+      filesCount: changedFiles.length,
+      projectId: this.projectId
+    })
+
+    return { hash, message, timestamp, files: changedFiles }
+  }
+
+  /**
+   * Get list of changed files in project
+   */
+  async getChangedFiles() {
+    try {
+      const { stdout } = await execAsync(
+        `git status --porcelain`,
+        { cwd: this.projectPath }
+      )
+
+      return stdout
+        .split('\n')
+        .filter(Boolean)
+        .map(line => line.slice(3).trim())
+        .filter(file => !file.startsWith('.prjct/'))
+    } catch {
+      return []
+    }
+  }
+
+  /**
+   * List all snapshots
+   *
+   * @param {number} limit - Max snapshots to return
+   * @returns {Promise<Array>} List of snapshots
+   */
+  async list(limit = 10) {
+    if (!this.initialized) await this.initialize()
+
+    try {
+      const { stdout } = await execAsync(
+        `git log --pretty=format:'{"hash":"%H","short":"%h","message":"%s","date":"%ai"}' -n ${limit}`,
+        { cwd: this.snapshotDir }
+      )
+
+      return stdout
+        .split('\n')
+        .filter(Boolean)
+        .map(line => {
+          try {
+            return JSON.parse(line)
+          } catch {
+            return null
+          }
+        })
+        .filter(Boolean)
+    } catch {
+      return []
+    }
+  }
+
+  /**
+   * Restore project to a specific snapshot
+   *
+   * @param {string} hash - Commit hash to restore
+   * @returns {Promise<Object>} Restore result
+   */
+  async restore(hash) {
+    if (!this.initialized) await this.initialize()
+
+    // Get files changed in that commit
+    const { stdout: filesOutput } = await execAsync(
+      `git diff-tree --no-commit-id --name-only -r ${hash}`,
+      { cwd: this.snapshotDir }
+    )
+
+    const files = filesOutput.split('\n').filter(Boolean)
+
+    // Checkout files from that snapshot
+    await execAsync(`git checkout ${hash} -- .`, { cwd: this.snapshotDir })
+
+    // Copy files back to project
+    for (const file of files) {
+      const srcPath = path.join(this.snapshotDir, file)
+      const destPath = path.join(this.projectPath, file)
+
+      try {
+        const content = await fs.readFile(srcPath, 'utf-8')
+        await fs.mkdir(path.dirname(destPath), { recursive: true })
+        await fs.writeFile(destPath, content)
+      } catch (err) {
+        // File doesn't exist in snapshot, might need to delete from project
+        try {
+          await fs.unlink(destPath)
+        } catch {}
+      }
+    }
+
+    // Log restoration
+    await this.logRestore(hash, files)
+
+    const timestamp = new Date().toISOString()
+
+    // Emit event for plugins
+    await emit.snapshotRestored({
+      hash,
+      filesCount: files.length,
+      timestamp,
+      projectId: this.projectId
+    })
+
+    return { hash, files, timestamp }
+  }
+
+  /**
+   * Get diff between current state and a snapshot
+   *
+   * @param {string} hash - Snapshot hash to compare
+   * @returns {Promise<string>} Diff output
+   */
+  async diff(hash) {
+    if (!this.initialized) await this.initialize()
+
+    try {
+      const { stdout } = await execAsync(
+        `git diff ${hash} --stat`,
+        { cwd: this.snapshotDir }
+      )
+      return stdout
+    } catch {
+      return ''
+    }
+  }
+
+  /**
+   * Get the most recent snapshot hash
+   */
+  async getLatestHash() {
+    if (!this.initialized) await this.initialize()
+
+    try {
+      const { stdout } = await execAsync(
+        `git rev-parse HEAD`,
+        { cwd: this.snapshotDir }
+      )
+      return stdout.trim()
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Get the hash before the current one (for undo)
+   */
+  async getPreviousHash() {
+    if (!this.initialized) await this.initialize()
+
+    try {
+      const { stdout } = await execAsync(
+        `git rev-parse HEAD~1`,
+        { cwd: this.snapshotDir }
+      )
+      return stdout.trim()
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Log snapshot to manifest
+   */
+  async logSnapshot(snapshot) {
+    const manifestPath = path.join(this.snapshotDir, 'manifest.jsonl')
+    const entry = JSON.stringify({
+      type: 'snapshot',
+      ...snapshot
+    }) + '\n'
+
+    await fs.appendFile(manifestPath, entry)
+  }
+
+  /**
+   * Log restoration to manifest
+   */
+  async logRestore(hash, files) {
+    const manifestPath = path.join(this.snapshotDir, 'manifest.jsonl')
+    const entry = JSON.stringify({
+      type: 'restore',
+      hash,
+      files,
+      timestamp: new Date().toISOString()
+    }) + '\n'
+
+    await fs.appendFile(manifestPath, entry)
+  }
+
+  /**
+   * Get redo stack (snapshots after current position)
+   * This tracks undone snapshots that can be redone
+   */
+  async getRedoStack() {
+    const stackPath = path.join(this.snapshotDir, 'redo-stack.json')
+    try {
+      const content = await fs.readFile(stackPath, 'utf-8')
+      return JSON.parse(content)
+    } catch {
+      return []
+    }
+  }
+
+  /**
+   * Push to redo stack (when undoing)
+   */
+  async pushToRedoStack(snapshot) {
+    const stack = await this.getRedoStack()
+    stack.push(snapshot)
+    const stackPath = path.join(this.snapshotDir, 'redo-stack.json')
+    await fs.writeFile(stackPath, JSON.stringify(stack, null, 2))
+  }
+
+  /**
+   * Pop from redo stack (when redoing)
+   */
+  async popFromRedoStack() {
+    const stack = await this.getRedoStack()
+    const snapshot = stack.pop()
+    const stackPath = path.join(this.snapshotDir, 'redo-stack.json')
+    await fs.writeFile(stackPath, JSON.stringify(stack, null, 2))
+    return snapshot
+  }
+
+  /**
+   * Clear redo stack (when creating new snapshot after undo)
+   */
+  async clearRedoStack() {
+    const stackPath = path.join(this.snapshotDir, 'redo-stack.json')
+    await fs.writeFile(stackPath, '[]')
+  }
+}
+
+module.exports = SnapshotManager

package/core/plugin/hooks.js

@@ -0,0 +1,313 @@
+/**
+ * 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
+ */
+
+const { eventBus, EventTypes } = require('../bus')
+
+/**
+ * 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'
+}
+
+class HookSystem {
+  constructor() {
+    this.hooks = new Map()
+    this.pluginHooks = new Map() // Track hooks by plugin
+  }
+
+  /**
+   * 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 = {}) {
+    const { pluginName = 'anonymous', priority = 10 } = options
+
+    if (!this.hooks.has(hookPoint)) {
+      this.hooks.set(hookPoint, [])
+    }
+
+    const 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
+   * @param {string} hookPoint
+   * @param {string} id
+   */
+  unregister(hookPoint, id) {
+    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
+   * @param {string} pluginName
+   */
+  unregisterPlugin(pluginName) {
+    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)
+   * @param {string} hookPoint
+   * @param {Object} data - Data that can be modified
+   * @returns {Promise<Object>} Modified data
+   */
+  async executeBefore(hookPoint, data) {
+    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 }
+        }
+      } catch (error) {
+        console.error(`Hook error [${hook.pluginName}] at ${hookPoint}:`, error.message)
+        // Continue with other hooks
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * Execute an "after" hook (side effects only)
+   * @param {string} hookPoint
+   * @param {Object} data - Read-only data
+   * @returns {Promise<void>}
+   */
+  async executeAfter(hookPoint, data) {
+    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}:`, error.message)
+        }
+      })
+    )
+
+    // 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)
+   * @param {string} hookPoint
+   * @param {*} value - Value to transform
+   * @param {Object} context - Additional context
+   * @returns {Promise<*>} Transformed value
+   */
+  async executeTransform(hookPoint, value, context = {}) {
+    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
+        }
+      } catch (error) {
+        console.error(`Transform hook error [${hook.pluginName}] at ${hookPoint}:`, error.message)
+        // Keep previous value on error
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * Map hook point to event type
+   * @param {string} hookPoint
+   * @returns {string|null}
+   */
+  hookToEvent(hookPoint) {
+    const mapping = {
+      [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
+   * @param {string} hookPoint
+   * @returns {Object[]}
+   */
+  getHooks(hookPoint) {
+    return (this.hooks.get(hookPoint) || []).map(h => ({
+      pluginName: h.pluginName,
+      priority: h.priority
+    }))
+  }
+
+  /**
+   * Get all hooks registered by a plugin
+   * @param {string} pluginName
+   * @returns {string[]} Hook points
+   */
+  getPluginHooks(pluginName) {
+    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) {
+    const hooks = this.hooks.get(hookPoint)
+    return hooks && hooks.length > 0
+  }
+
+  /**
+   * Clear all hooks
+   */
+  clear() {
+    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, handler, options) => {
+    const hookPoint = `before:${point}`
+    return hookSystem.register(hookPoint, handler, options)
+  },
+
+  /**
+   * Register an after hook
+   */
+  after: (point, handler, options) => {
+    const hookPoint = `after:${point}`
+    return hookSystem.register(hookPoint, handler, options)
+  },
+
+  /**
+   * Register a transform hook
+   */
+  transform: (point, handler, options) => {
+    const hookPoint = `transform:${point}`
+    return hookSystem.register(hookPoint, handler, options)
+  },
+
+  /**
+   * Execute before hooks
+   */
+  runBefore: (point, data) => {
+    return hookSystem.executeBefore(`before:${point}`, data)
+  },
+
+  /**
+   * Execute after hooks
+   */
+  runAfter: (point, data) => {
+    return hookSystem.executeAfter(`after:${point}`, data)
+  },
+
+  /**
+   * Execute transform hooks
+   */
+  runTransform: (point, value, context) => {
+    return hookSystem.executeTransform(`transform:${point}`, value, context)
+  }
+}
+
+module.exports = {
+  HookSystem,
+  HookPoints,
+  hookSystem,
+  hooks
+}