isomorphic-jj 1.0.0

package/src/core/jj-tree-state.js

@@ -0,0 +1,94 @@
+/**
+ * JJ TreeState File Manager
+ *
+ * Handles encoding/decoding of .jj/working_copy/tree_state file using protobuf.
+ * This file tracks the working copy tree and file states.
+ */
+
+import protobuf from 'protobufjs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export class JJTreeState {
+  constructor(fs, dir) {
+    this.fs = fs;
+    this.dir = dir;
+    this.protoPath = path.join(__dirname, '..', 'protos', 'local_working_copy.proto');
+  }
+
+  /**
+   * Write tree_state file
+   *
+   * @param {string} treeId - Tree ID as hex string (40 characters for SHA-1)
+   * @param {Array} fileStates - Array of file state objects
+   */
+  async writeTreeState(treeId, fileStates = []) {
+    // Load protobuf schema
+    const root = await protobuf.load(this.protoPath);
+    const TreeState = root.lookupType('local_working_copy.TreeState');
+
+    // Convert hex tree ID to bytes
+    const treeIdBuffer = Buffer.from(treeId, 'hex');
+
+    // Convert file states to protobuf format
+    const fileStateEntries = fileStates.map(fs => ({
+      path: fs.path,
+      state: {
+        mtimeMillisSinceEpoch: fs.mtime, // Use camelCase for protobufjs
+        size: fs.size,
+        fileType: fs.fileType || 0 // 0 = Normal
+      }
+    }));
+
+    // Create message (use camelCase for protobufjs)
+    const message = TreeState.create({
+      treeIds: [treeIdBuffer], // Single tree ID (no conflicts)
+      fileStates: fileStateEntries,
+      isFileStatesSorted: false, // We don't sort them
+      sparsePatterns: {
+        prefixes: [] // No sparse patterns
+      }
+    });
+
+    // Verify the message
+    const errMsg = TreeState.verify(message);
+    if (errMsg) {
+      throw new Error(`TreeState message verification failed: ${errMsg}`);
+    }
+
+    // Encode to binary
+    const buffer = TreeState.encode(message).finish();
+
+    // Write to .jj/working_copy/tree_state
+    const treeStatePath = `${this.dir}/.jj/working_copy/tree_state`;
+    await this.fs.promises.writeFile(treeStatePath, buffer);
+  }
+
+  /**
+   * Read tree_state file
+   *
+   * @returns {Object} Decoded tree state data
+   */
+  async readTreeState() {
+    const treeStatePath = `${this.dir}/.jj/working_copy/tree_state`;
+    const buffer = await this.fs.promises.readFile(treeStatePath);
+
+    // Load protobuf schema
+    const root = await protobuf.load(this.protoPath);
+    const TreeState = root.lookupType('local_working_copy.TreeState');
+
+    // Decode
+    const message = TreeState.decode(buffer);
+
+    // Return the decoded message with proper field access
+    return {
+      tree_ids: message.treeIds,
+      file_states: message.fileStates,
+      is_file_states_sorted: message.isFileStatesSorted,
+      sparse_patterns: message.sparsePatterns
+    };
+  }
+}

package/src/core/jj-view-store.js

@@ -0,0 +1,105 @@
+/**
+ * JJ View Store Manager
+ *
+ * Handles encoding/decoding of .jj/repo/op_store/views/* files using protobuf.
+ * Views represent the state of the repository at a given operation.
+ */
+
+import protobuf from 'protobufjs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export class JJViewStore {
+  constructor(fs, dir) {
+    this.fs = fs;
+    this.dir = dir;
+    this.protoPath = path.join(__dirname, '..', 'protos', 'simple_op_store.proto');
+  }
+
+  /**
+   * Write view file
+   *
+   * @param {string} viewId - View ID as hex string (128 characters)
+   * @param {Array<string>} headIds - Head commit IDs as hex strings
+   * @param {Object} wcCommitIds - Working copy commit IDs by workspace name
+   */
+  async writeView(viewId, headIds, wcCommitIds = {}) {
+    // Load protobuf schema
+    const root = await protobuf.load(this.protoPath);
+    const View = root.lookupType('simple_op_store.View');
+
+    // Convert hex IDs to bytes
+    const headBuffers = headIds.map(id => Buffer.from(id, 'hex'));
+
+    // Convert wcCommitIds object to map
+    const wcCommitIdsMap = {};
+    for (const [workspace, commitId] of Object.entries(wcCommitIds)) {
+      wcCommitIdsMap[workspace] = Buffer.from(commitId, 'hex');
+    }
+
+    // Create view message (use camelCase for protobufjs)
+    const message = View.create({
+      headIds: headBuffers,
+      wcCommitIds: wcCommitIdsMap,
+      bookmarks: [],
+      localTags: [],
+      remoteViews: [],
+      gitRefs: [],
+      gitHead: null,
+      hasGitRefsMigratedToRemoteTags: false
+    });
+
+    // Verify the message
+    const errMsg = View.verify(message);
+    if (errMsg) {
+      throw new Error(`View message verification failed: ${errMsg}`);
+    }
+
+    // Encode to binary
+    const buffer = View.encode(message).finish();
+
+    // Write to .jj/repo/op_store/views/VIEWID
+    const viewPath = `${this.dir}/.jj/repo/op_store/views/${viewId}`;
+    await this.fs.promises.writeFile(viewPath, buffer);
+  }
+
+  /**
+   * Read view file
+   *
+   * @param {string} viewId - View ID as hex string (128 characters)
+   * @returns {Object} Decoded view data
+   */
+  async readView(viewId) {
+    // Read from .jj/repo/op_store/views/VIEWID
+    const viewPath = `${this.dir}/.jj/repo/op_store/views/${viewId}`;
+    const buffer = await this.fs.promises.readFile(viewPath);
+
+    // Load protobuf schema
+    const root = await protobuf.load(this.protoPath);
+    const View = root.lookupType('simple_op_store.View');
+
+    // Decode
+    const message = View.decode(buffer);
+
+    // Convert wcCommitIds map back to object
+    const wcCommitIds = {};
+    for (const [workspace, commitIdBuffer] of Object.entries(message.wcCommitIds || {})) {
+      wcCommitIds[workspace] = commitIdBuffer;
+    }
+
+    // Return the decoded message with proper field access
+    return {
+      head_ids: message.headIds,
+      wc_commit_ids: wcCommitIds,
+      bookmarks: message.bookmarks,
+      local_tags: message.localTags,
+      remote_views: message.remoteViews,
+      git_refs: message.gitRefs,
+      git_head: message.gitHead,
+      has_git_refs_migrated_to_remote_tags: message.hasGitRefsMigratedToRemoteTags
+    };
+  }
+}

package/src/core/merge-driver-registry.js

@@ -0,0 +1,432 @@
+/**
+ * MergeDriverRegistry - Registry for custom merge drivers
+ *
+ * Manages registration, lookup, and execution of merge drivers.
+ * Drivers are matched against file paths using glob patterns.
+ */
+
+import { JJError } from '../utils/errors.js';
+
+/**
+ * Check if a file path matches a glob pattern
+ * Simple implementation - for complex patterns, consider using minimatch
+ *
+ * @param {string} path - File path
+ * @param {string} pattern - Glob pattern
+ * @returns {boolean} Whether path matches pattern
+ */
+function matchesPattern(path, pattern) {
+  // Exact match
+  if (pattern === path) return true;
+
+  // Convert glob pattern to regex
+  // Support: *, **, ?, [abc]
+  const regexPattern = pattern
+    .replace(/\*\*/g, '__DOUBLESTAR__')
+    .replace(/\*/g, '[^/]*')
+    .replace(/__DOUBLESTAR__/g, '.*')
+    .replace(/\?/g, '[^/]')
+    .replace(/\./g, '\\.');
+
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(path);
+}
+
+/**
+ * Check if a file is likely binary based on content
+ *
+ * @param {string|Buffer} content - File content
+ * @returns {boolean} Whether content appears binary
+ */
+function isBinaryContent(content) {
+  if (Buffer.isBuffer(content)) return true;
+  if (typeof content !== 'string') return false;
+
+  // Check for null bytes (common in binary files)
+  if (content.indexOf('\0') !== -1) return true;
+
+  // Check for high ratio of non-printable characters
+  const nonPrintable = content.split('').filter(
+    (char) => {
+      const code = char.charCodeAt(0);
+      return code < 32 && code !== 9 && code !== 10 && code !== 13;
+    }
+  ).length;
+
+  const ratio = nonPrintable / content.length;
+  return ratio > 0.3;
+}
+
+/**
+ * Default merge driver - standard three-way text merge
+ *
+ * @param {MergeContext} context
+ * @returns {Promise<MergeResult>}
+ */
+async function defaultMergeDriver(context) {
+  const { content } = context;
+  const { base, ours, theirs } = content;
+
+  // Simple cases
+  if (ours === theirs) {
+    return { content: ours, hasConflict: false };
+  }
+
+  if (ours === base) {
+    // No changes on our side, take theirs
+    return { content: theirs, hasConflict: false };
+  }
+
+  if (theirs === base) {
+    // No changes on their side, take ours
+    return { content: ours, hasConflict: false };
+  }
+
+  // Both sides changed - conflict
+  const conflictMarkers = `<<<<<<< ours\n${ours || ''}\n=======\n${theirs || ''}\n>>>>>>> theirs`;
+
+  return {
+    content: conflictMarkers,
+    hasConflict: true,
+    conflicts: [{
+      type: 'content',
+      sides: ['ours', 'theirs'],
+    }],
+  };
+}
+
+/**
+ * Wrap a driver with timeout and error handling
+ *
+ * @param {Function} driver - Driver function
+ * @param {Object} options - Wrapper options
+ * @param {number} [options.timeout=5000] - Timeout in ms
+ * @param {boolean} [options.strict=false] - Throw on error instead of falling back
+ * @param {Object} [options.jj] - JJ instance for event emission
+ * @param {string} [options.pattern] - Pattern that matched this driver
+ * @returns {Function} Wrapped driver
+ */
+function wrapDriver(driver, options = {}) {
+  const { timeout = 5000, strict = false, jj = null, pattern = null } = options;
+
+  return async (context) => {
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => reject(new Error('Driver timeout')), timeout);
+      // Use unref() to allow process to exit if this is the only pending timer
+      if (timeoutId.unref) {
+        timeoutId.unref();
+      }
+    });
+
+    try {
+      const result = await Promise.race([
+        driver(context),
+        timeoutPromise,
+      ]);
+
+      // Clear timeout if driver completed successfully
+      clearTimeout(timeoutId);
+
+      // Validate result
+      if (!result || typeof result.hasConflict !== 'boolean') {
+        throw new Error('Driver returned invalid result');
+      }
+
+      return result;
+    } catch (error) {
+      // Clear timeout on error too
+      clearTimeout(timeoutId);
+
+      // Emit driver:failed event if jj instance available
+      if (jj && jj.dispatchEvent) {
+        jj.dispatchEvent(new CustomEvent('driver:failed', {
+          detail: {
+            path: context.path,
+            pattern: pattern,
+            error: error.message,
+            timestamp: new Date().toISOString(),
+          },
+        }));
+      }
+
+      // In strict mode, throw the error
+      if (strict) {
+        throw error;
+      }
+
+      // Fall back to default merge with error metadata
+      const result = await defaultMergeDriver(context);
+      return {
+        ...result,
+        driverFailed: true,
+        driverError: error.message,
+      };
+    }
+  };
+}
+
+/**
+ * MergeDriverRegistry manages custom merge drivers
+ */
+export class MergeDriverRegistry {
+  constructor(jj = null) {
+    /** @type {Array<{pattern: string, driver: Function, accepts: Object, strict: boolean}>} */
+    this.drivers = [];
+    this.jj = jj; // JJ instance for event emission
+  }
+
+  /**
+   * Register one or more merge drivers
+   *
+   * @param {Object<string, Function|Object>} drivers - Pattern -> driver map
+   *
+   * @example
+   * registry.register({
+   *   'package.json': packageJsonDriver,
+   *   '*.md': markdownDriver,
+   *   'critical.txt': { driver: myDriver, strict: true },
+   * });
+   */
+  register(drivers) {
+    for (const [pattern, driverOrConfig] of Object.entries(drivers)) {
+      // Driver can be function or { driver, accepts, timeout, strict }
+      let driver, accepts, timeout, strict;
+
+      if (typeof driverOrConfig === 'function') {
+        driver = driverOrConfig;
+        accepts = { text: true, binary: false }; // Default: text only
+        timeout = 5000;
+        strict = false;
+      } else {
+        driver = driverOrConfig.driver || driverOrConfig.merge;
+        accepts = driverOrConfig.accepts || { text: true, binary: false };
+        timeout = driverOrConfig.timeout || 5000;
+        strict = driverOrConfig.strict || false;
+      }
+
+      if (typeof driver !== 'function') {
+        throw new JJError(
+          'INVALID_DRIVER',
+          `Driver for pattern "${pattern}" must be a function`,
+          { pattern }
+        );
+      }
+
+      // Wrap driver with error handling
+      const wrappedDriver = wrapDriver(driver, {
+        timeout,
+        strict,
+        jj: this.jj,
+        pattern,
+      });
+
+      this.drivers.push({ pattern, driver: wrappedDriver, accepts, strict });
+    }
+  }
+
+  /**
+   * Unregister a driver by pattern
+   *
+   * @param {string} pattern - Pattern to unregister
+   */
+  unregister(pattern) {
+    this.drivers = this.drivers.filter((d) => d.pattern !== pattern);
+  }
+
+  /**
+   * Get a specific driver by pattern
+   *
+   * @param {string} pattern - Pattern to look up
+   * @returns {Function|undefined} Driver function or undefined
+   */
+  get(pattern) {
+    const entry = this.drivers.find((d) => d.pattern === pattern);
+    return entry?.driver;
+  }
+
+  /**
+   * List all registered drivers
+   *
+   * @returns {Array<{pattern: string, accepts: Object}>} Driver list
+   */
+  list() {
+    return this.drivers.map(({ pattern, accepts }) => ({ pattern, accepts }));
+  }
+
+  /**
+   * Find the best matching driver for a file path
+   *
+   * Priority:
+   * 1. Per-merge custom drivers (from merge options)
+   * 2. Registered drivers (by pattern specificity)
+   * 3. Default driver (three-way merge)
+   *
+   * @param {string} filePath - File path
+   * @param {Object} customDrivers - Per-merge custom drivers
+   * @param {boolean} isBinary - Whether file is binary
+   * @returns {Function} Driver function
+   */
+  findDriver(filePath, customDrivers = {}, isBinary = false) {
+    // 1. Check custom drivers (highest priority)
+    for (const [pattern, driverOrConfig] of Object.entries(customDrivers)) {
+      if (matchesPattern(filePath, pattern)) {
+        let driver, accepts, timeout, strict;
+
+        if (typeof driverOrConfig === 'function') {
+          driver = driverOrConfig;
+          accepts = { text: true, binary: false };
+          timeout = 5000;
+          strict = false;
+        } else {
+          driver = driverOrConfig.driver || driverOrConfig.merge;
+          accepts = driverOrConfig.accepts || { text: true, binary: false };
+          timeout = driverOrConfig.timeout || 5000;
+          strict = driverOrConfig.strict || false;
+        }
+
+        // Check if driver accepts this file type
+        if ((isBinary && accepts.binary) || (!isBinary && accepts.text)) {
+          return wrapDriver(driver, {
+            timeout,
+            strict,
+            jj: this.jj,
+            pattern,
+          });
+        }
+      }
+    }
+
+    // 2. Check registered drivers (by specificity)
+    const matches = this.drivers
+      .filter(({ pattern, accepts }) => {
+        const matchesPath = matchesPattern(filePath, pattern);
+        const acceptsType = (isBinary && accepts.binary) || (!isBinary && accepts.text);
+        return matchesPath && acceptsType;
+      })
+      .sort((a, b) => b.pattern.length - a.pattern.length); // Most specific first
+
+    if (matches.length > 0) {
+      return matches[0].driver;
+    }
+
+    // 3. Fall back to default driver
+    return defaultMergeDriver;
+  }
+
+  /**
+   * Execute a driver with proper content encoding
+   *
+   * @param {Function} driver - Driver function
+   * @param {Object} context - Merge context
+   * @param {string} context.path - File path
+   * @param {string|Buffer|null} context.base - Base content
+   * @param {string|Buffer|null} context.ours - Our content
+   * @param {string|Buffer|null} context.theirs - Their content
+   * @param {Object} context.metadata - Metadata
+   * @param {boolean} isBinary - Whether content is binary
+   * @returns {Promise<MergeResult>}
+   */
+  async executeDriver(driver, context, isBinary) {
+    const { base, ours, theirs, ...rest } = context;
+
+    // Prepare content based on binary/text
+    const content = {
+      base: this.prepareContent(base, isBinary),
+      ours: this.prepareContent(ours, isBinary),
+      theirs: this.prepareContent(theirs, isBinary),
+    };
+
+    const driverContext = {
+      ...rest,
+      content,
+      isBinary,
+    };
+
+    return await driver(driverContext);
+  }
+
+  /**
+   * Prepare content for driver based on binary/text
+   *
+   * @param {string|Buffer|null} content - Raw content
+   * @param {boolean} isBinary - Whether to return as Buffer
+   * @returns {string|Buffer|null} Prepared content
+   */
+  prepareContent(content, isBinary) {
+    if (content === null || content === undefined) {
+      return null;
+    }
+
+    if (isBinary) {
+      // Convert to Buffer if needed
+      if (Buffer.isBuffer(content)) return content;
+      if (typeof content === 'string') return Buffer.from(content, 'utf-8');
+      return Buffer.from(String(content));
+    } else {
+      // Convert to string if needed
+      if (typeof content === 'string') return content;
+      if (Buffer.isBuffer(content)) return content.toString('utf-8');
+      return String(content);
+    }
+  }
+
+  /**
+   * Check if file is binary based on path or content
+   *
+   * @param {string} path - File path
+   * @param {string|Buffer} content - File content
+   * @returns {boolean} Whether file is binary
+   */
+  isBinaryFile(path, content) {
+    // Check by extension first
+    const binaryExtensions = [
+      '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico',
+      '.zip', '.tar', '.gz', '.bz2', '.7z',
+      '.pdf', '.doc', '.docx', '.xls', '.xlsx',
+      '.exe', '.dll', '.so', '.dylib',
+      '.mp3', '.mp4', '.avi', '.mov',
+    ];
+
+    const ext = path.substring(path.lastIndexOf('.')).toLowerCase();
+    if (binaryExtensions.includes(ext)) {
+      return true;
+    }
+
+    // Check content
+    if (content) {
+      return isBinaryContent(content);
+    }
+
+    return false;
+  }
+}
+
+/**
+ * Standalone helper to check if file is binary
+ * (exported for external use)
+ *
+ * @param {string} path - File path
+ * @param {string|Buffer} content - File content
+ * @returns {boolean} Whether file is binary
+ */
+export function isBinaryFile(path, content) {
+  const binaryExtensions = [
+    '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico',
+    '.zip', '.tar', '.gz', '.bz2', '.7z',
+    '.pdf', '.doc', '.docx', '.xls', '.xlsx',
+    '.exe', '.dll', '.so', '.dylib',
+    '.mp3', '.mp4', '.avi', '.mov',
+  ];
+
+  const ext = path.substring(path.lastIndexOf('.')).toLowerCase();
+  if (binaryExtensions.includes(ext)) {
+    return true;
+  }
+
+  if (content) {
+    return isBinaryContent(content);
+  }
+
+  return false;
+}