git-utimes

Change all files modification time to their last commit date

$ git utimes

$ git utimes --newer

git utimes [options] [path...]

--index
    Set utimes from the Git index. This is typically the default behavior if no --commit is specified.

--commit=
    Set utimes from the specified commit or tree object. The tree-ish can be a commit hash, branch name, or any reference that resolves to a tree.

--dry-run
    Perform a dry run. Do not actually change any file timestamps, but instead show what actions would be taken.

--verbose
    Be verbose. Display more details about the operations being performed, such as which files are being processed and their new timestamps.

...
    Limit the operation to the specified paths. If no paths are provided, git-utimes will operate on all tracked files in the current working directory.

git-utimes is a Git subcommand (often found in git-contrib) designed to restore the access and modification times (utimes) of files within the Git working tree. It provides a mechanism to set these timestamps based on information from the Git index or from a specific commit's tree-ish. This utility is particularly valuable in situations where file timestamps are unintentionally altered or lost – for instance, during git clone operations, git checkout to a different branch, or when files are copied outside of Git's direct management. Preserving these timestamps is crucial for various reasons, such as ensuring that build systems like make accurately detect whether files need recompilation, or for maintaining consistency in timestamp-sensitive applications. By default, git-utimes operates on all files currently tracked by Git within the active working directory, making it a powerful tool for maintaining the integrity of your project's file metadata.

git-utimes is typically a script located in the git-contrib repository, meaning it is not a built-in command of the core Git distribution. It may not be available by default on all systems and might require manual installation or adding to your PATH.
File modification times (mtime) stored within Git are generally based on the time the blob object was created or committed, not necessarily the original file's modification time. This command restores timestamps based on Git's internal records, which might differ from the absolute original file timestamps.
Access times (atime) are generally not tracked by Git. This command might set atime to match mtime or leave it as the current time, depending on the script's specific implementation and the underlying operating system's capabilities.

This command is particularly valuable in environments where build systems (like make) rely on file modification times to determine if a recompilation or rebuild is necessary. If a Git operation (like git clone or git checkout) updates files without preserving original timestamps, make might incorrectly rebuild everything, even if the source code hasn't changed. git-utimes helps prevent this by restoring timestamps consistent with the repository state, ensuring efficient and correct build processes.

The precision of the timestamps set by git-utimes depends on the operating system's capabilities and the timestamps stored by Git. Git typically stores timestamps with second-level precision, while some modern file systems support sub-second precision. This might lead to minor discrepancies if sub-second precision was crucial for the original file.

git-utimes originated as a supplementary script within the git-contrib collection, which serves as a repository for various useful but non-core Git utilities. Its development addresses a common pain point for Git users: the loss of original file timestamps during standard Git operations like cloning or checking out branches. This utility provides a solution for scenarios where maintaining accurate timestamps is crucial, especially for build systems that rely on them for dependency tracking, thus filling a gap in Git's native timestamp management capabilities.

git-update-index(1), git-ls-files(1), git-status(1), utime(2)