prjct-cli 0.10.14 → 0.11.1

package/core/command-registry.js

@@ -427,6 +427,71 @@ const COMMANDS = [
     isOptional: true,
   },
 
+  // ===== SNAPSHOT COMMANDS (Undo/Redo Support) =====
+  {
+    name: 'undo',
+    category: 'optional',
+    description: 'Revert to previous snapshot',
+    usage: {
+      claude: '/p:undo',
+      terminal: 'prjct undo',
+    },
+    params: null,
+    implemented: true,
+    hasTemplate: true,
+    icon: 'RotateCcw',
+    requiresInit: true,
+    blockingRules: null,
+    isOptional: true,
+    features: [
+      'Git-based snapshots',
+      'Preserves redo history',
+      'Non-destructive',
+    ],
+  },
+  {
+    name: 'redo',
+    category: 'optional',
+    description: 'Redo previously undone changes',
+    usage: {
+      claude: '/p:redo',
+      terminal: 'prjct redo',
+    },
+    params: null,
+    implemented: true,
+    hasTemplate: true,
+    icon: 'RotateCw',
+    requiresInit: true,
+    blockingRules: null,
+    isOptional: true,
+    features: [
+      'Only available after undo',
+      'Restores undone state',
+      'Clears on new snapshot',
+    ],
+  },
+  {
+    name: 'history',
+    category: 'optional',
+    description: 'View snapshot history',
+    usage: {
+      claude: '/p:history',
+      terminal: 'prjct history',
+    },
+    params: null,
+    implemented: true,
+    hasTemplate: true,
+    icon: 'Clock',
+    requiresInit: true,
+    blockingRules: null,
+    isOptional: true,
+    features: [
+      'Shows all snapshots',
+      'Current position indicator',
+      'Redo availability count',
+    ],
+  },
+
   // ===== SETUP COMMANDS (Not part of daily workflow) =====
   {
     name: 'start',

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