isomorphic-jj 1.2.0 → 1.4.0

package/dist/index.cjs

@@ -6294,69 +6294,116 @@ async function createJJ(options) {
      * @param {string[]} [args.paths] - Paths to move between changes (for history operations)
      * @returns {Promise<Object>} Returns change object for history operations, file info for file operations
      */
-    async move(args) {
-      if (!args || typeof args !== 'object') {
-        throw new JJError('INVALID_ARGUMENT', 'Missing or invalid arguments', {
-          suggestion: 'Use file.move({ from, to }) for files or rebase({ changeId, newParent }) for history',
+    /**
+     * Move a file in the working copy
+     *
+     * @param {Object} args - Move file arguments
+     * @param {string} args.from - Source file path
+     * @param {string} args.to - Destination file path
+     * @returns {Promise<Object>} Operation result including from, to paths and file stats
+     */
+    async moveFile(args) {
+      if (!args.from || typeof args.from !== 'string') {
+        throw new JJError('INVALID_ARGUMENT', 'Missing or invalid from path', {
+          suggestion: 'Provide a valid source file path',
+          provided: { from: args.from, type: typeof args.from },
         });
       }
 
-      // Detect operation type based on arguments
-      const isHistoryOp = this._detectHistoryOperation(args);
+      if (!args.to || typeof args.to !== 'string') {
+        throw new JJError('INVALID_ARGUMENT', 'Missing or invalid to path', {
+          suggestion: 'Provide a valid destination file path',
+          provided: { to: args.to, type: typeof args.to },
+        });
+      }
 
-      if (isHistoryOp) {
-        return await this._moveChange(args);
-      } else {
-        return await this._moveFile(args);
+      // Prevent moving to the same location
+      if (args.from === args.to) {
+        throw new JJError('INVALID_OPERATION', 'Source and destination paths are the same', {
+          path: args.from,
+          suggestion: 'Specify a different destination path',
+        });
       }
-    },
 
-    /**
-     * Detect if move operation is for history (rebase) or files
-     *
-     * @private
-     * @param {Object} args - Move arguments
-     * @returns {boolean} True if history operation, false if file operation
-     */
-    _detectHistoryOperation(args) {
-      // Explicit history operation indicators
-      if (args.paths || args.changeId || args.newParent) {
-        return true;
+      // Prevent absolute paths
+      if (args.from.startsWith('/') || args.to.startsWith('/')) {
+        throw new JJError('INVALID_PATH', 'Absolute paths are not allowed', {
+          suggestion: 'Use paths relative to the repository root',
+          provided: { from: args.from, to: args.to },
+        });
       }
 
-      // If only from/to are present, check if they look like change IDs
-      if (args.from && args.to && !args.changeId && !args.newParent && !args.paths) {
-        // Change IDs are 32-character hex strings
-        const changeIdPattern = /^[0-9a-f]{32}$/;
-        const fromLooksLikeChangeId = changeIdPattern.test(args.from);
-        const toLooksLikeChangeId = changeIdPattern.test(args.to);
+      // Prevent parent directory traversal
+      if (args.from.includes('..') || args.to.includes('..')) {
+        throw new JJError('INVALID_PATH', 'Parent directory traversal (..) is not allowed', {
+          suggestion: 'Use paths within the repository',
+          provided: { from: args.from, to: args.to },
+        });
+      }
 
-        // If both look like change IDs, it's likely a history operation
-        // However, we err on the side of file operations to be safe
-        // Users should use explicit { changeId, newParent } for clarity
-        if (fromLooksLikeChangeId && toLooksLikeChangeId) {
-          // This is ambiguous - throw a helpful error
-          throw new JJError('AMBIGUOUS_OPERATION',
-            'Ambiguous move operation: arguments look like change IDs', {
-            suggestion: 'Use { changeId, newParent } for history operations or ensure file paths don\'t match change ID pattern',
-            args,
-          });
-        }
+      const fromPath = `${dir}/${args.from}`;
+      const toPath = `${dir}/${args.to}`;
 
-        return false; // Treat as file operation
+      // Check if source file exists
+      try {
+        await fs.promises.stat(fromPath);
+      } catch (error) {
+        throw new JJError('FILE_NOT_FOUND', `Source file not found: ${args.from}`, {
+          path: args.from,
+          suggestion: 'Check that the source file exists',
+        });
       }
 
-      return false;
+      // Ensure destination directory exists
+      const toDir = toPath.substring(0, toPath.lastIndexOf('/'));
+      try {
+        await fs.promises.mkdir(toDir, { recursive: true });
+      } catch (error) {
+        throw new JJError('FILE_SYSTEM_ERROR', `Failed to create destination directory: ${error.message}`, {
+          path: toDir,
+          error: error.message,
+        });
+      }
+
+      // Move the file
+      try {
+        await fs.promises.rename(fromPath, toPath);
+      } catch (error) {
+        throw new JJError('FILE_SYSTEM_ERROR', `Failed to move file: ${error.message}`, {
+          from: args.from,
+          to: args.to,
+          error: error.message,
+        });
+      }
+
+      // Update working copy tracking
+      await workingCopy.load();
+      await workingCopy.untrackFile(args.from);
+      const stats = await fs.promises.stat(toPath);
+      await workingCopy.trackFile(args.to, {
+        mtime: stats.mtime,
+        size: stats.size,
+        mode: stats.mode,
+      });
+
+      return {
+        from: args.from,
+        to: args.to,
+        size: stats.size,
+        mode: stats.mode,
+        mtime: stats.mtime,
+      };
     },
 
     /**
-     * Move/rebase a change to a new parent (history operation)
+     * Move (rebase) a change to a new parent
      *
-     * @private
-     * @param {Object} args - Move arguments
+     * @param {Object} args - Move change arguments
+     * @param {string} args.changeId - Change ID to move (also accepts 'from' or 'source')
+     * @param {string} args.newParent - New parent change ID (also accepts 'to' or 'destination')
      * @returns {Promise<Object>} Updated change object
      */
-    async _moveChange(args) {
+    async moveChange(args) {
       await graph.load();
 
       // Support multiple parameter names for flexibility
@@ -6444,110 +6491,62 @@ async function createJJ(options) {
     },
 
     /**
-     * Move/rename a file in the working copy (file operation)
-     *
-     * @private
-     * @param {Object} args - Move arguments
-     * @returns {Promise<Object>} Operation result including from, to paths and file stats
+     * @deprecated Use moveFile() for files or moveChange() for history operations
+     * Move operation - delegates to moveFile or moveChange based on arguments
      */
-    async _moveFile(args) {
-      if (!args.from || typeof args.from !== 'string') {
-        throw new JJError('INVALID_ARGUMENT', 'Missing or invalid from path', {
-          suggestion: 'Provide a valid source file path',
-          provided: { from: args.from, type: typeof args.from },
-        });
-      }
-
-      if (!args.to || typeof args.to !== 'string') {
-        throw new JJError('INVALID_ARGUMENT', 'Missing or invalid to path', {
-          suggestion: 'Provide a valid destination file path',
-          provided: { to: args.to, type: typeof args.to },
+    async move(args) {
+      if (!args || typeof args !== 'object') {
+        throw new JJError('INVALID_ARGUMENT', 'Missing or invalid arguments', {
+          suggestion: 'Use moveFile({ from, to }) for files or moveChange({ changeId, newParent }) for history',
         });
       }
 
-      // Prevent moving to the same location
-      if (args.from === args.to) {
-        throw new JJError('INVALID_OPERATION', 'Source and destination paths are the same', {
-          path: args.from,
-          suggestion: 'Specify a different destination path',
-        });
-      }
+      // Detect operation type based on arguments
+      const isHistoryOp = this._detectHistoryOperation(args);
 
-      // Prevent absolute paths
-      if (args.from.startsWith('/') || args.to.startsWith('/')) {
-        throw new JJError('INVALID_PATH', 'Absolute paths are not allowed', {
-          suggestion: 'Use paths relative to the repository root',
-          provided: { from: args.from, to: args.to },
-        });
+      if (isHistoryOp) {
+        return await this.moveChange(args);
+      } else {
+        return await this.moveFile(args);
       }
+    },
 
-      // Prevent parent directory traversal
-      if (args.from.includes('..') || args.to.includes('..')) {
-        throw new JJError('INVALID_PATH', 'Parent directory traversal (..) is not allowed', {
-          suggestion: 'Use paths within the repository',
-          provided: { from: args.from, to: args.to },
-        });
+    /**
+     * Detect if move operation is for history (rebase) or files
+     *
+     * @private
+     * @param {Object} args - Move arguments
+     * @returns {boolean} True if history operation, false if file operation
+     */
+    _detectHistoryOperation(args) {
+      // Explicit history operation indicators
+      if (args.paths || args.changeId || args.newParent) {
+        return true;
       }
 
-      const fromPath = `${dir}/${args.from}`;
-      const toPath = `${dir}/${args.to}`;
-
-      // Check if source file exists
-      try {
-        await fs.promises.access(fromPath);
-      } catch (error) {
-        throw new JJError('FILE_NOT_FOUND', `Source file not found: ${args.from}`, {
-          path: args.from,
-          fullPath: fromPath,
-          suggestion: 'Check that the file exists',
-        });
-      }
+      // If only from/to are present, check if they look like change IDs
+      if (args.from && args.to && !args.changeId && !args.newParent && !args.paths) {
+        // Change IDs are 32-character hex strings
+        const changeIdPattern = /^[0-9a-f]{32}$/;
+        const fromLooksLikeChangeId = changeIdPattern.test(args.from);
+        const toLooksLikeChangeId = changeIdPattern.test(args.to);
 
-      // Ensure destination directory exists
-      const pathParts = args.to.split('/');
-      if (pathParts.length > 1) {
-        const dirPath = pathParts.slice(0, -1).join('/');
-        const fullDirPath = `${dir}/${dirPath}`;
-        try {
-          await fs.promises.mkdir(fullDirPath, { recursive: true });
-        } catch (error) {
-          throw new JJError('DIRECTORY_CREATE_FAILED',
-            `Failed to create destination directory: ${dirPath}`, {
-            directory: dirPath,
-            originalError: error.message,
+        // If both look like change IDs, it's likely a history operation
+        // However, we err on the side of file operations to be safe
+        // Users should use explicit { changeId, newParent } for clarity
+        if (fromLooksLikeChangeId && toLooksLikeChangeId) {
+          // This is ambiguous - throw a helpful error
+          throw new JJError('AMBIGUOUS_OPERATION',
+            'Ambiguous move operation: arguments look like change IDs', {
+            suggestion: 'Use { changeId, newParent } for history operations or ensure file paths don\'t match change ID pattern',
+            args,
           });
         }
-      }
 
-      // Move the file
-      try {
-        await fs.promises.rename(fromPath, toPath);
-      } catch (error) {
-        throw new JJError('FILE_MOVE_FAILED', `Failed to move file: ${error.message}`, {
-          from: args.from,
-          to: args.to,
-          originalError: error.message,
-        });
+        return false; // Treat as file operation
       }
 
-      // Update working copy tracking
-      await workingCopy.load();
-      await workingCopy.untrackFile(args.from);
-      const stats = await fs.promises.stat(toPath);
-      await workingCopy.trackFile(args.to, {
-        mtime: stats.mtime,
-        size: stats.size,
-        mode: stats.mode,
-      });
-
-      // Return useful information about the move operation
-      return {
-        from: args.from,
-        to: args.to,
-        size: stats.size,
-        mode: stats.mode,
-        mtime: stats.mtime,
-      };
+      return false;
     },
 
     /**
@@ -6623,6 +6622,11 @@ async function createJJ(options) {
         change.timestamp = new Date().toISOString();
       }
 
+      // Update metadata
+      if (args.metadata !== undefined) {
+        change.metadata = args.metadata;
+      }
+
       // Only snapshot files if describing working copy
       if (isWorkingCopy) {
         // Snapshot current file contents for conflict detection
@@ -7227,10 +7231,11 @@ async function createJJ(options) {
      * @param {Object} [args={}] - Arguments
      * @param {string} [args.message] - Description for current change
      * @param {Object} [args.author] - Author for current change
+     * @param {Object} [args.metadata] - Metadata to attach to the change
      * @returns {Promise<Object>} The newly created change
      */
     async commit(args = {}) {
-      await this.describe({ message: args.message, author: args.author });
+      await this.describe({ message: args.message, author: args.author, metadata: args.metadata });
       return await this.new({ message: args.nextMessage });
     },
 
@@ -8054,7 +8059,7 @@ async function createJJ(options) {
      * });
      */
     async rebase(args) {
-      return await this._moveChange(args);
+      return await this.moveChange(args);
     },
 
     /**