isomorphic-jj 1.4.2 → 1.7.0

package/src/core/jj-checkout.js

@@ -19,6 +19,10 @@ const protoDir = inDist
   : path.join(__dirname, '..', 'protos');
 
 export class JJCheckout {
+  /**
+   * @param {any} fs - File system module (isomorphic-git compatible)
+   * @param {any} dir - Repository directory path
+   */
   constructor(fs, dir) {
     this.fs = fs;
     this.dir = dir;
@@ -42,7 +46,7 @@ export class JJCheckout {
     // Create message (use camelCase for protobufjs)
     const message = Checkout.create({
       operationId: opIdBuffer,
-      workspaceName: workspaceName
+      workspaceName: workspaceName,
     });
 
     // Verify the message
@@ -62,7 +66,7 @@ export class JJCheckout {
   /**
    * Read checkout file
    *
-   * @returns {Object} Decoded checkout data
+   * @returns {Promise<Record<string, any>>} Decoded checkout data
    */
   async readCheckout() {
     const checkoutPath = `${this.dir}/.jj/working_copy/checkout`;
@@ -73,12 +77,12 @@ export class JJCheckout {
     const Checkout = root.lookupType('local_working_copy.Checkout');
 
     // Decode
-    const message = Checkout.decode(buffer);
+    const message = /** @type {any} */ (Checkout.decode(buffer));
 
     // Return the decoded message with proper field access
     return {
       operation_id: message.operationId,
-      workspace_name: message.workspaceName
+      workspace_name: message.workspaceName,
     };
   }
 }

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

@@ -19,6 +19,10 @@ const protoDir = inDist
   : path.join(__dirname, '..', 'protos');
 
 export class JJOperationStore {
+  /**
+   * @param {any} fs - File system module (isomorphic-git compatible)
+   * @param {any} dir - Repository directory path
+   */
   constructor(fs, dir) {
     this.fs = fs;
     this.dir = dir;
@@ -31,7 +35,7 @@ export class JJOperationStore {
    * @param {string} operationId - Operation ID as hex string (128 characters)
    * @param {string} viewId - View ID as hex string (128 characters)
    * @param {Array<string>} parentIds - Parent operation IDs as hex strings
-   * @param {Object} metadata - Operation metadata
+   * @param {Record<string, any>} metadata - Operation metadata
    */
   async writeOperation(operationId, viewId, parentIds, metadata) {
     // Load protobuf schema
@@ -40,23 +44,23 @@ export class JJOperationStore {
 
     // Convert hex IDs to bytes
     const viewIdBuffer = Buffer.from(viewId, 'hex');
-    const parentBuffers = parentIds.map(id => Buffer.from(id, 'hex'));
+    const parentBuffers = parentIds.map((id) => Buffer.from(id, 'hex'));
 
     // Create metadata message (use camelCase for protobufjs)
     const metadataMsg = {
       startTime: {
         millisSinceEpoch: metadata.start_time.millis_since_epoch,
-        tzOffset: metadata.start_time.tz_offset
+        tzOffset: metadata.start_time.tz_offset,
       },
       endTime: {
         millisSinceEpoch: metadata.end_time.millis_since_epoch,
-        tzOffset: metadata.end_time.tz_offset
+        tzOffset: metadata.end_time.tz_offset,
       },
       description: metadata.description,
       hostname: metadata.hostname,
       username: metadata.username,
       isSnapshot: metadata.is_snapshot,
-      tags: metadata.tags
+      tags: metadata.tags,
     };
 
     // Create operation message (use camelCase for protobufjs)
@@ -65,7 +69,7 @@ export class JJOperationStore {
       parents: parentBuffers,
       metadata: metadataMsg,
       commitPredecessors: [], // Empty for now
-      storesCommitPredecessors: false
+      storesCommitPredecessors: false,
     });
 
     // Verify the message
@@ -86,7 +90,7 @@ export class JJOperationStore {
    * Read operation file
    *
    * @param {string} operationId - Operation ID as hex string (128 characters)
-   * @returns {Object} Decoded operation data
+   * @returns {Promise<Record<string, any>>} Decoded operation data
    */
   async readOperation(operationId) {
     // Read from .jj/repo/op_store/operations/OPERATIONID
@@ -98,7 +102,7 @@ export class JJOperationStore {
     const Operation = root.lookupType('simple_op_store.Operation');
 
     // Decode
-    const message = Operation.decode(buffer);
+    const message = /** @type {any} */ (Operation.decode(buffer));
 
     // Return the decoded message with proper field access
     return {
@@ -107,20 +111,20 @@ export class JJOperationStore {
       metadata: {
         start_time: {
           millis_since_epoch: message.metadata.startTime.millisSinceEpoch,
-          tz_offset: message.metadata.startTime.tzOffset
+          tz_offset: message.metadata.startTime.tzOffset,
         },
         end_time: {
           millis_since_epoch: message.metadata.endTime.millisSinceEpoch,
-          tz_offset: message.metadata.endTime.tzOffset
+          tz_offset: message.metadata.endTime.tzOffset,
         },
         description: message.metadata.description,
         hostname: message.metadata.hostname,
         username: message.metadata.username,
         is_snapshot: message.metadata.isSnapshot,
-        tags: message.metadata.tags
+        tags: message.metadata.tags,
       },
       commit_predecessors: message.commitPredecessors,
-      stores_commit_predecessors: message.storesCommitPredecessors
+      stores_commit_predecessors: message.storesCommitPredecessors,
     };
   }
 }

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

@@ -19,6 +19,10 @@ const protoDir = inDist
   : path.join(__dirname, '..', 'protos');
 
 export class JJTreeState {
+  /**
+   * @param {any} fs - File system module (isomorphic-git compatible)
+   * @param {any} dir - Repository directory path
+   */
   constructor(fs, dir) {
     this.fs = fs;
     this.dir = dir;
@@ -29,7 +33,7 @@ export class JJTreeState {
    * 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
+   * @param {Array<any>} fileStates - Array of file state objects
    */
   async writeTreeState(treeId, fileStates = []) {
     // Load protobuf schema
@@ -40,13 +44,13 @@ export class JJTreeState {
     const treeIdBuffer = Buffer.from(treeId, 'hex');
 
     // Convert file states to protobuf format
-    const fileStateEntries = fileStates.map(fs => ({
+    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
-      }
+        fileType: fs.fileType || 0, // 0 = Normal
+      },
     }));
 
     // Create message (use camelCase for protobufjs)
@@ -55,8 +59,8 @@ export class JJTreeState {
       fileStates: fileStateEntries,
       isFileStatesSorted: false, // We don't sort them
       sparsePatterns: {
-        prefixes: [] // No sparse patterns
-      }
+        prefixes: [], // No sparse patterns
+      },
     });
 
     // Verify the message
@@ -76,7 +80,7 @@ export class JJTreeState {
   /**
    * Read tree_state file
    *
-   * @returns {Object} Decoded tree state data
+   * @returns {Promise<Record<string, any>>} Decoded tree state data
    */
   async readTreeState() {
     const treeStatePath = `${this.dir}/.jj/working_copy/tree_state`;
@@ -87,14 +91,14 @@ export class JJTreeState {
     const TreeState = root.lookupType('local_working_copy.TreeState');
 
     // Decode
-    const message = TreeState.decode(buffer);
+    const message = /** @type {any} */ (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
+      sparse_patterns: message.sparsePatterns,
     };
   }
 }

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

@@ -19,6 +19,10 @@ const protoDir = inDist
   : path.join(__dirname, '..', 'protos');
 
 export class JJViewStore {
+  /**
+   * @param {any} fs - File system module (isomorphic-git compatible)
+   * @param {any} dir - Repository directory path
+   */
   constructor(fs, dir) {
     this.fs = fs;
     this.dir = dir;
@@ -38,9 +42,10 @@ export class JJViewStore {
     const View = root.lookupType('simple_op_store.View');
 
     // Convert hex IDs to bytes
-    const headBuffers = headIds.map(id => Buffer.from(id, 'hex'));
+    const headBuffers = headIds.map((id) => Buffer.from(id, 'hex'));
 
     // Convert wcCommitIds object to map
+    /** @type {Record<string, any>} */
     const wcCommitIdsMap = {};
     for (const [workspace, commitId] of Object.entries(wcCommitIds)) {
       wcCommitIdsMap[workspace] = Buffer.from(commitId, 'hex');
@@ -55,7 +60,7 @@ export class JJViewStore {
       remoteViews: [],
       gitRefs: [],
       gitHead: null,
-      hasGitRefsMigratedToRemoteTags: false
+      hasGitRefsMigratedToRemoteTags: false,
     });
 
     // Verify the message
@@ -76,7 +81,7 @@ export class JJViewStore {
    * Read view file
    *
    * @param {string} viewId - View ID as hex string (128 characters)
-   * @returns {Object} Decoded view data
+   * @returns {Promise<Record<string, any>>} Decoded view data
    */
   async readView(viewId) {
     // Read from .jj/repo/op_store/views/VIEWID
@@ -88,9 +93,10 @@ export class JJViewStore {
     const View = root.lookupType('simple_op_store.View');
 
     // Decode
-    const message = View.decode(buffer);
+    const message = /** @type {any} */ (View.decode(buffer));
 
     // Convert wcCommitIds map back to object
+    /** @type {Record<string, any>} */
     const wcCommitIds = {};
     for (const [workspace, commitIdBuffer] of Object.entries(message.wcCommitIds || {})) {
       wcCommitIds[workspace] = commitIdBuffer;
@@ -105,7 +111,7 @@ export class JJViewStore {
       remote_views: message.remoteViews,
       git_refs: message.gitRefs,
       git_head: message.gitHead,
-      has_git_refs_migrated_to_remote_tags: message.hasGitRefsMigratedToRemoteTags
+      has_git_refs_migrated_to_remote_tags: message.hasGitRefsMigratedToRemoteTags,
     };
   }
 }

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

@@ -21,12 +21,15 @@ function matchesPattern(path, pattern) {
 
   // Convert glob pattern to regex
   // Support: *, **, ?, [abc]
+  // Literal dots must be escaped BEFORE the ** -> '.*' substitution, otherwise
+  // the dot-escaping pass corrupts the inserted '.*' into the literal '\.*'
+  // (zero-or-more dots) instead of "any characters".
   const regexPattern = pattern
+    .replace(/\./g, '\\.')
     .replace(/\*\*/g, '__DOUBLESTAR__')
     .replace(/\*/g, '[^/]*')
     .replace(/__DOUBLESTAR__/g, '.*')
-    .replace(/\?/g, '[^/]')
-    .replace(/\./g, '\\.');
+    .replace(/\?/g, '[^/]');
 
   const regex = new RegExp(`^${regexPattern}$`);
   return regex.test(path);
@@ -46,12 +49,10 @@ function isBinaryContent(content) {
   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 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;
@@ -60,8 +61,8 @@ function isBinaryContent(content) {
 /**
  * Default merge driver - standard three-way text merge
  *
- * @param {MergeContext} context
- * @returns {Promise<MergeResult>}
+ * @param {{ content: { base?: string, ours?: string, theirs?: string } }} context
+ * @returns {Promise<Record<string, any>>}
  */
 async function defaultMergeDriver(context) {
   const { content } = context;
@@ -88,10 +89,12 @@ async function defaultMergeDriver(context) {
   return {
     content: conflictMarkers,
     hasConflict: true,
-    conflicts: [{
-      type: 'content',
-      sides: ['ours', 'theirs'],
-    }],
+    conflicts: [
+      {
+        type: 'content',
+        sides: ['ours', 'theirs'],
+      },
+    ],
   };
 }
 
@@ -102,14 +105,14 @@ async function defaultMergeDriver(context) {
  * @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 {any} [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) => {
+  return async (/** @type {any} */ context) => {
     let timeoutId;
     const timeoutPromise = new Promise((_, reject) => {
       timeoutId = setTimeout(() => reject(new Error('Driver timeout')), timeout);
@@ -120,10 +123,7 @@ function wrapDriver(driver, options = {}) {
     });
 
     try {
-      const result = await Promise.race([
-        driver(context),
-        timeoutPromise,
-      ]);
+      const result = await Promise.race([driver(context), timeoutPromise]);
 
       // Clear timeout if driver completed successfully
       clearTimeout(timeoutId);
@@ -140,14 +140,16 @@ function wrapDriver(driver, options = {}) {
 
       // 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(),
-          },
-        }));
+        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
@@ -170,16 +172,24 @@ function wrapDriver(driver, options = {}) {
  * MergeDriverRegistry manages custom merge drivers
  */
 export class MergeDriverRegistry {
+  /**
+   * @param {any} [jj]
+   */
   constructor(jj = null) {
-    /** @type {Array<{pattern: string, driver: Function, accepts: Object, strict: boolean}>} */
+    /** @type {Array<{pattern: string, driver: Function, accepts: any, strict: boolean}>} */
     this.drivers = [];
+    /** @type {any} */
     this.jj = jj; // JJ instance for event emission
+    // Expose the built-in fallback driver so callers (e.g. ConflictModel) can
+    // detect when findDriver() fell through to it rather than resolving a
+    // real custom driver, and skip driver execution in that case.
+    this.defaultDriver = defaultMergeDriver;
   }
 
   /**
    * Register one or more merge drivers
    *
-   * @param {Object<string, Function|Object>} drivers - Pattern -> driver map
+   * @param {Record<string, any>} drivers - Pattern -> driver map
    *
    * @example
    * registry.register({
@@ -206,11 +216,9 @@ export class MergeDriverRegistry {
       }
 
       if (typeof driver !== 'function') {
-        throw new JJError(
-          'INVALID_DRIVER',
-          `Driver for pattern "${pattern}" must be a function`,
-          { pattern }
-        );
+        throw new JJError('INVALID_DRIVER', `Driver for pattern "${pattern}" must be a function`, {
+          pattern,
+        });
       }
 
       // Wrap driver with error handling
@@ -325,7 +333,7 @@ export class MergeDriverRegistry {
    * @param {string|Buffer|null} context.theirs - Their content
    * @param {Object} context.metadata - Metadata
    * @param {boolean} isBinary - Whether content is binary
-   * @returns {Promise<MergeResult>}
+   * @returns {Promise<Record<string, any>>}
    */
   async executeDriver(driver, context, isBinary) {
     const { base, ours, theirs, ...rest } = context;
@@ -381,11 +389,30 @@ export class MergeDriverRegistry {
   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',
+      '.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();
@@ -412,11 +439,30 @@ export class MergeDriverRegistry {
  */
 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',
+    '.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();

package/src/core/operation-log.js

@@ -1,6 +1,6 @@
 /**
  * OperationLog - Manages the append-only operation log
- * 
+ *
  * Records all repository mutations for complete undo/redo and time-travel.
  */
 
@@ -13,6 +13,7 @@ export class OperationLog {
    */
   constructor(storage) {
     this.storage = storage;
+    /** @type {any[]} */
     this.operations = [];
     this.headOperationId = null;
   }
@@ -39,9 +40,9 @@ export class OperationLog {
 
   /**
    * Record a new operation
-   * 
-   * @param {Object} operation - Operation to record (without id)
-   * @returns {Promise<Object>} Recorded operation with id
+   *
+   * @param {Record<string, any>} operation - Operation to record (without id)
+   * @returns {Promise<Record<string, any>>} Recorded operation with id
    */
   async recordOperation(operation) {
     // Ensure operations are loaded
@@ -76,20 +77,20 @@ export class OperationLog {
 
   /**
    * Get all operations
-   * 
-   * @returns {Promise<Array>} Array of all operations (chronological order)
+   *
+   * @returns {Promise<Array<any>>} Array of all operations (chronological order)
    */
   async list() {
     if (this.operations.length === 0 && this.headOperationId === null) {
       await this.load();
     }
-    
+
     return this.operations;
   }
 
   /**
    * Get the head (latest) operation
-   * 
+   *
    * @returns {Promise<Object|null>} Latest operation or null if log is empty
    */
   async getHeadOperation() {
@@ -102,10 +103,10 @@ export class OperationLog {
 
   /**
    * Undo the last operation
-   * 
+   *
    * Returns the view from the previous operation, allowing the caller
    * to restore repository state.
-   * 
+   *
    * @returns {Promise<Object>} View from previous operation
    */
   async undo() {
@@ -128,10 +129,10 @@ export class OperationLog {
     // Return view from parent operation
     const currentHead = this.operations[this.operations.length - 1];
     const parentId = currentHead.parents[0];
-    
+
     // Find parent operation
-    const parentOp = this.operations.find(op => op.id === parentId);
-    
+    const parentOp = this.operations.find((op) => op.id === parentId);
+
     if (!parentOp) {
       // If parent not found, return view from operation before current
       return this.operations[this.operations.length - 2].view;
@@ -142,7 +143,7 @@ export class OperationLog {
 
   /**
    * Get snapshot (view) at a specific operation
-   * 
+   *
    * @param {string} operationId - Operation ID
    * @returns {Promise<Object>} View from that operation
    */
@@ -151,8 +152,8 @@ export class OperationLog {
       await this.load();
     }
 
-    const operation = this.operations.find(op => op.id === operationId);
-    
+    const operation = this.operations.find((op) => op.id === operationId);
+
     if (!operation) {
       throw new JJError('OPERATION_NOT_FOUND', `Operation ${operationId} not found`, {
         operationId,
@@ -174,7 +175,7 @@ export class OperationLog {
       await this.load();
     }
 
-    return this.operations.find(op => op.id === operationId) || null;
+    return this.operations.find((op) => op.id === operationId) || null;
   }
 
   /**
@@ -199,7 +200,7 @@ export class OperationLog {
     }
 
     // Find the operation
-    const opIndex = this.operations.findIndex(op => op.id === operationId);
+    const opIndex = this.operations.findIndex((op) => op.id === operationId);
     if (opIndex === -1) {
       throw new JJError('OPERATION_NOT_FOUND', `Operation ${operationId} not found`, {
         operationId,
@@ -217,23 +218,20 @@ export class OperationLog {
     }
 
     // Find children (operations that reference this as a parent)
-    const children = this.operations.filter(op =>
-      op.parents && op.parents.includes(operationId)
-    );
+    const children = this.operations.filter((op) => op.parents && op.parents.includes(operationId));
 
     // Get the parent of the operation being abandoned (may be undefined for root)
-    const grandparentId = operation.parents && operation.parents.length > 0
-      ? operation.parents[0]
-      : undefined;
+    const grandparentId =
+      operation.parents && operation.parents.length > 0 ? operation.parents[0] : undefined;
 
     // Relink children to grandparent
     const relinkedChildren = [];
     for (const child of children) {
       // Replace references to abandoned operation with grandparent
       const oldParents = [...child.parents];
-      child.parents = child.parents.map(p =>
-        p === operationId ? grandparentId : p
-      ).filter(Boolean); // Remove undefined if there was no grandparent
+      child.parents = child.parents
+        .map((/** @type {any} */ p) => (p === operationId ? grandparentId : p))
+        .filter(Boolean); // Remove undefined if there was no grandparent
 
       // If there was no grandparent, the child becomes a root operation
       if (!grandparentId && child.parents.length === 0) {
@@ -252,15 +250,14 @@ export class OperationLog {
 
     // Update head if we abandoned the head operation
     if (this.headOperationId === operationId) {
-      this.headOperationId = this.operations.length > 0
-        ? this.operations[this.operations.length - 1].id
-        : null;
+      this.headOperationId =
+        this.operations.length > 0 ? this.operations[this.operations.length - 1].id : null;
     }
 
     // Rewrite JSONL file
-    const content = this.operations
-      .map(op => JSON.stringify(op))
-      .join('\n') + (this.operations.length > 0 ? '\n' : '');
+    const content =
+      this.operations.map((op) => JSON.stringify(op)).join('\n') +
+      (this.operations.length > 0 ? '\n' : '');
     await this.storage.write('repo/op_log/oplog.jsonl', content);
 
     return {