isomorphic-jj 1.0.0

package/src/core/background-ops.js

@@ -0,0 +1,272 @@
+/**
+ * BackgroundOps - Background operations manager
+ *
+ * Handles file watching, automatic snapshots, and async operations.
+ */
+
+import { JJError } from '../utils/errors.js';
+
+export class BackgroundOps {
+  /**
+   * @param {Object} jj - JJ instance
+   * @param {Object} fs - Filesystem implementation
+   * @param {string} dir - Repository directory
+   */
+  constructor(jj, fs, dir) {
+    this.jj = jj;
+    this.fs = fs;
+    this.dir = dir;
+    this.watchers = new Map();
+    this.operations = new Map(); // operationId -> operation
+    this.timers = new Map(); // watcherId -> timer
+    this.running = false;
+  }
+
+  /**
+   * Start background operations
+   */
+  async start() {
+    if (this.running) {
+      return;
+    }
+
+    this.running = true;
+  }
+
+  /**
+   * Stop background operations
+   */
+  async stop() {
+    if (!this.running) {
+      return;
+    }
+
+    // Clear all timers
+    for (const timer of this.timers.values()) {
+      clearTimeout(timer);
+    }
+    this.timers.clear();
+
+    // Stop all watchers
+    for (const watcher of this.watchers.values()) {
+      if (watcher.close) {
+        watcher.close();
+      }
+    }
+
+    this.watchers.clear();
+    this.running = false;
+  }
+
+  /**
+   * Watch a path for changes
+   *
+   * @param {string} path - Path to watch
+   * @param {Function} callback - Callback function(event, filename)
+   * @returns {string} Watcher ID
+   */
+  async watch(path, callback) {
+    if (!this.running) {
+      throw new JJError('BACKGROUND_OPS_NOT_RUNNING', 'Background operations not started', {
+        suggestion: 'Call start() first',
+      });
+    }
+
+    // Check if fs.watch is available (Node.js)
+    if (this.fs.watch) {
+      const watcherId = `watcher-${this.watchers.size}`;
+      const watcher = this.fs.watch(path, { recursive: true }, callback);
+      this.watchers.set(watcherId, watcher);
+      return watcherId;
+    }
+
+    // Browser: use FileSystem Access API observeDirectory if available
+    if (typeof FileSystemObserver !== 'undefined') {
+      const watcherId = `watcher-${this.watchers.size}`;
+      const observer = new FileSystemObserver(async (records) => {
+        for (const record of records) {
+          callback(record.type, record.relativePathComponents.join('/'));
+        }
+      });
+
+      // Note: This API is experimental and may not be available
+      this.watchers.set(watcherId, observer);
+      return watcherId;
+    }
+
+    throw new JJError('WATCH_NOT_SUPPORTED', 'File watching not supported in this environment');
+  }
+
+  /**
+   * Unwatch a path
+   *
+   * @param {string} watcherId - Watcher ID
+   */
+  async unwatch(watcherId) {
+    const watcher = this.watchers.get(watcherId);
+    if (!watcher) {
+      return;
+    }
+
+    // Clear any pending timer for this watcher
+    const timer = this.timers.get(watcherId);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(watcherId);
+    }
+
+    if (watcher.close) {
+      watcher.close();
+    } else if (watcher.disconnect) {
+      watcher.disconnect();
+    }
+
+    this.watchers.delete(watcherId);
+  }
+
+  /**
+   * Queue a background operation
+   *
+   * @param {Function} operation - Async operation to run
+   * @param {Object} opts - Options
+   * @param {string} [opts.description] - Operation description
+   * @returns {Promise<Object>} Operation result
+   */
+  async queue(operation, opts = {}) {
+    const operationId = `op-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+
+    const op = {
+      id: operationId,
+      description: opts.description || 'background operation',
+      status: 'pending',
+      created: new Date().toISOString(),
+      promise: null,
+      result: null,
+      error: null,
+    };
+
+    this.operations.set(operationId, op);
+
+    // Run operation asynchronously
+    op.promise = (async () => {
+      try {
+        op.status = 'running';
+        op.result = await operation();
+        op.status = 'completed';
+        op.completed = new Date().toISOString();
+        return op.result;
+      } catch (error) {
+        op.status = 'failed';
+        op.error = error;
+        op.completed = new Date().toISOString();
+        throw error;
+      }
+    })();
+
+    return {
+      id: operationId,
+      promise: op.promise,
+    };
+  }
+
+  /**
+   * Get operation status
+   *
+   * @param {string} operationId - Operation ID
+   * @returns {Object|null} Operation status
+   */
+  getOperation(operationId) {
+    return this.operations.get(operationId) || null;
+  }
+
+  /**
+   * List all operations
+   *
+   * @param {Object} opts - List options
+   * @param {string} [opts.status] - Filter by status
+   * @returns {Array<Object>} Operations
+   */
+  listOperations(opts = {}) {
+    let ops = Array.from(this.operations.values());
+
+    if (opts.status) {
+      ops = ops.filter(op => op.status === opts.status);
+    }
+
+    return ops.map(op => ({
+      id: op.id,
+      description: op.description,
+      status: op.status,
+      created: op.created,
+      completed: op.completed,
+      error: op.error ? op.error.message : null,
+    }));
+  }
+
+  /**
+   * Enable auto-snapshot on file changes
+   *
+   * @param {Object} opts - Options
+   * @param {number} [opts.debounceMs=1000] - Debounce delay in ms
+   */
+  async enableAutoSnapshot(opts = {}) {
+    const debounceMs = opts.debounceMs || 1000;
+
+    const watcherId = await this.watch(this.dir, (event, filename) => {
+      if (filename && filename.startsWith('.jj/')) {
+        return; // Ignore .jj directory changes
+      }
+
+      if (filename && filename.startsWith('.git/')) {
+        return; // Ignore .git directory changes
+      }
+
+      // Debounce: wait for changes to settle
+      const existingTimer = this.timers.get(watcherId);
+      if (existingTimer) {
+        clearTimeout(existingTimer);
+      }
+
+      const timer = setTimeout(async () => {
+        try {
+          // Create automatic snapshot
+          await this.queue(async () => {
+            await this.jj.describe({ message: `Auto-snapshot: ${filename || 'multiple files'} changed` });
+          }, { description: 'auto-snapshot' });
+        } catch (error) {
+          console.error('Auto-snapshot failed:', error);
+        } finally {
+          // Clean up timer reference
+          this.timers.delete(watcherId);
+        }
+      }, debounceMs);
+
+      // Use unref() to allow process to exit if this is the only pending timer
+      if (timer.unref) {
+        timer.unref();
+      }
+
+      this.timers.set(watcherId, timer);
+    });
+
+    return watcherId;
+  }
+
+  /**
+   * Clean up completed operations
+   *
+   * @param {number} [maxAge] - Max age in ms (default: 1 hour)
+   */
+  cleanupOperations(maxAge = 3600000) {
+    const cutoff = Date.now() - maxAge;
+
+    for (const [id, op] of this.operations.entries()) {
+      if (op.status === 'completed' || op.status === 'failed') {
+        const completedTime = new Date(op.completed).getTime();
+        if (completedTime < cutoff) {
+          this.operations.delete(id);
+        }
+      }
+    }
+  }
+}

package/src/core/bookmark-store.js

@@ -0,0 +1,232 @@
+/**
+ * BookmarkStore - Manages local and remote bookmarks
+ * 
+ * Bookmarks are named pointers to changes, similar to Git branches.
+ */
+
+import { JJError } from '../utils/errors.js';
+import { validateChangeId, validateBookmarkName } from '../utils/validation.js';
+
+export class BookmarkStore {
+  /**
+   * @param {Storage} storage - Storage manager instance
+   */
+  constructor(storage) {
+    this.storage = storage;
+    this.local = new Map();
+    this.remote = new Map(); // remote → (bookmark → changeId)
+  }
+
+  /**
+   * Initialize empty bookmark store
+   */
+  async init() {
+    this.local.clear();
+    this.remote.clear();
+
+    await this.storage.write('repo/store/bookmarks.json', {
+      version: 1,
+      local: {},
+      remote: {},
+      tracked: {},
+    });
+  }
+
+  /**
+   * Load bookmarks from storage
+   */
+  async load() {
+    const data = await this.storage.read('repo/store/bookmarks.json');
+
+    if (!data) {
+      throw new JJError('STORAGE_CORRUPT', 'repo/store/bookmarks.json not found', {
+        suggestion: 'Initialize repository with init()',
+      });
+    }
+
+    if (data.version !== 1) {
+      throw new JJError(
+        'STORAGE_VERSION_MISMATCH',
+        `Unsupported bookmarks version: ${data.version}`,
+        {
+          version: data.version,
+          suggestion: 'Upgrade isomorphic-jj or run migration tool',
+        }
+      );
+    }
+
+    this.local.clear();
+    this.remote.clear();
+
+    // Load local bookmarks
+    for (const [name, target] of Object.entries(data.local)) {
+      this.local.set(name, target);
+    }
+
+    // Load remote bookmarks
+    for (const [remoteName, bookmarks] of Object.entries(data.remote)) {
+      const remoteBookmarks = new Map();
+      for (const [name, target] of Object.entries(bookmarks)) {
+        remoteBookmarks.set(name, target);
+      }
+      this.remote.set(remoteName, remoteBookmarks);
+    }
+  }
+
+  /**
+   * Save bookmarks to storage
+   */
+  async save() {
+    const local = {};
+    for (const [name, target] of this.local.entries()) {
+      local[name] = target;
+    }
+
+    const remote = {};
+    for (const [remoteName, bookmarks] of this.remote.entries()) {
+      remote[remoteName] = {};
+      for (const [name, target] of bookmarks.entries()) {
+        remote[remoteName][name] = target;
+      }
+    }
+
+    await this.storage.write('repo/store/bookmarks.json', {
+      version: 1,
+      local,
+      remote,
+      tracked: {},
+    });
+  }
+
+  /**
+   * Set a local bookmark
+   * 
+   * @param {string} name - Bookmark name
+   * @param {string} target - Change ID to point to
+   */
+  async set(name, target) {
+    validateBookmarkName(name);
+    validateChangeId(target);
+
+    if (this.local.has(name)) {
+      throw new JJError('BOOKMARK_EXISTS', `Bookmark ${name} already exists`, {
+        name,
+        suggestion: 'Use move() to update existing bookmark',
+      });
+    }
+
+    this.local.set(name, target);
+    await this.save();
+  }
+
+  /**
+   * Move an existing local bookmark
+   * 
+   * @param {string} name - Bookmark name
+   * @param {string} target - New change ID to point to
+   */
+  async move(name, target) {
+    validateBookmarkName(name);
+    validateChangeId(target);
+
+    if (!this.local.has(name)) {
+      throw new JJError('BOOKMARK_NOT_FOUND', `Bookmark ${name} not found`, {
+        name,
+        suggestion: 'Use set() to create a new bookmark',
+      });
+    }
+
+    this.local.set(name, target);
+    await this.save();
+  }
+
+  /**
+   * Delete a local bookmark
+   * 
+   * @param {string} name - Bookmark name
+   */
+  async delete(name) {
+    validateBookmarkName(name);
+
+    if (!this.local.has(name)) {
+      throw new JJError('BOOKMARK_NOT_FOUND', `Bookmark ${name} not found`, {
+        name,
+      });
+    }
+
+    this.local.delete(name);
+    await this.save();
+  }
+
+  /**
+   * Get bookmark target
+   * 
+   * @param {string} name - Bookmark name
+   * @returns {Promise<string|null>} Change ID or null if not found
+   */
+  async get(name) {
+    return this.local.get(name) || null;
+  }
+
+  /**
+   * Set a remote bookmark
+   * 
+   * @param {string} remoteName - Remote name
+   * @param {string} name - Bookmark name
+   * @param {string} target - Change ID to point to
+   */
+  async setRemote(remoteName, name, target) {
+    validateBookmarkName(name);
+    validateChangeId(target);
+
+    if (!this.remote.has(remoteName)) {
+      this.remote.set(remoteName, new Map());
+    }
+
+    this.remote.get(remoteName).set(name, target);
+    await this.save();
+  }
+
+  /**
+   * Get remote bookmark target
+   * 
+   * @param {string} remoteName - Remote name
+   * @param {string} name - Bookmark name
+   * @returns {Promise<string|null>} Change ID or null if not found
+   */
+  async getRemote(remoteName, name) {
+    const remoteBookmarks = this.remote.get(remoteName);
+    return remoteBookmarks ? remoteBookmarks.get(name) || null : null;
+  }
+
+  /**
+   * List all bookmarks (local and remote)
+   *
+   * @returns {Promise<Array>} Array of bookmark objects
+   */
+  async list() {
+    const result = [];
+
+    // Add local bookmarks
+    for (const [name, target] of this.local.entries()) {
+      result.push({
+        name,
+        changeId: target,
+        remote: null,
+      });
+    }
+
+    // Add remote bookmarks
+    for (const [remoteName, bookmarks] of this.remote.entries()) {
+      for (const [name, target] of bookmarks.entries()) {
+        result.push({
+          name: `${remoteName}/${name}`,
+          changeId: target,
+          remote: remoteName,
+        });
+      }
+    }
+
+    return result;
+  }
+}