feat(fields): add author-date and committer-date to FIELD_ATTR

* feat(fields): add author-date and committer-date to FIELD_ATTR

- Extend FIELD_ATTR in ops.py with 'author-date' and 'committer-date'
  mapped to commit.author_date / commit.committer_date; strip/replace
  now accept --field author-date and --field committer-date automatically
  (choices derive from the dict keys).
- Fix _get_field_value in cli.py: add %ad/%cd to the fmt_map and pass
  --date=raw for date fields so preview/match-counting reflects the raw
  b'<epoch> <tz>' format that git-filter-repo uses.
- Add examples/normalize_timezone.py: rewrites all timezone offsets to
  UTC (+0000) while preserving the epoch second.
- Update README --field table to list the two new fields and note they
  require git-filter-repo; add replace --field date examples.
- Add tests in test_ops.py (strip/replace on author-date, committer-date)
  and test_cli.py (parser accepts --field author-date/committer-date).

Closes #2

* fix(lint): resolve all 14 ruff errors (I001, E702, F401, F541, F841, E741)

* refactor(fields): drop lint churn; add strip-date warning to README

- Revert scope-creep from the fix(lint) commit:
  - cli.py: restore f-string on 'action' print, restore body variable,
    restore l loop variable in list comprehension
  - tests/test_cli.py: restore original import order (build_parser first)
    and blank line after import block
  - tests/test_ops.py: restore textwrap-before-tempfile import order
    and blank line after from-import

- README: add blockquote note under strip section explaining that using
  --field author-date / --field committer-date with strip zeroes the
  field to an empty byte string (invalid date); replace is the right
  operation for date fields

---------

Co-authored-by: gfargo-horizon-agent[bot] <294710345+gfargo-horizon-agent[bot]@users.noreply.github.com>

Author: gfargo-horizon-agent[bot]

README.md

@@ -81,6 +81,10 @@ git-rewrite strip --field author-email "old@example\.com"
 git-rewrite strip --invert "^[A-Z][a-z-]+: " --field message
 ```
 
+> **Note:** Using `strip` on a date field (`--field author-date` or `--field committer-date`) zeroes the
+> field to an empty byte string, producing an invalid date. Use `replace` instead to rewrite specific
+> parts of the date value while keeping it valid.
+
 #### `replace` — substitute a pattern with a replacement
 
 ```bash
@@ -89,6 +93,11 @@ git-rewrite replace "Co-Authored-By: Claude Sonnet \d+\.\d+" "Co-Authored-By: AI
 
 git-rewrite replace "Co-Authored-By: Claude Sonnet \d+\.\d+" "Co-Authored-By: AI"
 git-rewrite replace --field author-name "Old Name" "New Name"
+
+# Normalize timezone offsets to UTC (requires git-filter-repo)
+# Date values are in raw format: "<unix-timestamp> <tz-offset>", e.g. "1700000000 -0700"
+git-rewrite replace --field author-date "[-+]\d{4}$" "+0000"
+git-rewrite replace --field committer-date "[-+]\d{4}$" "+0000"
 ```
 
 #### `run` — execute a custom Python callback
@@ -105,7 +114,7 @@ git-rewrite run my_callback.py --refs main feature/branch
 | `--dry-run` | Show what would happen without modifying history |
 | `--yes / -y` | Skip the confirmation prompt |
 | `--refs REF …` | Limit to specific refs (default: all) |
-| `--field FIELD` | Field to target: `message`, `author-name`, `author-email`, `committer-name`, `committer-email` |
+| `--field FIELD` | Field to target: `message`, `author-name`, `author-email`, `committer-name`, `committer-email`, `author-date`, `committer-date` (date fields require git-filter-repo) |
 | `--case-sensitive` | Disable case-insensitive matching |
 | `--preview` | (`strip`/`replace`) Diff-style preview of changes — no history rewritten |
 | `--invert` | (`strip`) Keep only matches; strip everything else |

examples/normalize_timezone.py

@@ -0,0 +1,32 @@
+"""
+normalize_timezone.py — rewrite all commit timestamps to UTC (+0000).
+
+git-filter-repo stores dates as bytes in the format ``b"<unix-epoch> <tz-offset>"``,
+e.g. ``b"1700000000 -0700"``.  This script keeps the epoch second intact and
+replaces only the timezone offset with ``+0000``.
+
+Run:
+    git-rewrite run examples/normalize_timezone.py --dry-run
+    git-rewrite run examples/normalize_timezone.py
+
+Requires git-filter-repo (the ``run`` command always uses git-filter-repo).
+"""
+
+
+def _to_utc(date_bytes: bytes) -> bytes:
+    """Return *date_bytes* with the timezone offset replaced by +0000.
+
+    Input:  b"1700000000 -0700"
+    Output: b"1700000000 +0000"
+    """
+    parts = date_bytes.split(b" ", 1)
+    if len(parts) != 2:
+        # Unexpected format — leave untouched rather than corrupting history.
+        return date_bytes
+    epoch = parts[0]
+    return epoch + b" +0000"
+
+
+def process_commit(commit):
+    commit.author_date = _to_utc(commit.author_date)
+    commit.committer_date = _to_utc(commit.committer_date)

git_rewrite/cli.py

@@ -113,10 +113,19 @@ def _get_field_value(sha: str, field: str) -> str:
         "author-email": "%ae",
         "committer-name": "%cn",
         "committer-email": "%ce",
+        "author-date": "%ad",
+        "committer-date": "%cd",
     }
     fmt = fmt_map.get(field, "%B")
+    # --date=raw produces "<unix-timestamp> <tz-offset>" which matches the
+    # bytes format git-filter-repo uses (b"1234567890 +0000").  Only meaningful
+    # for date fields, but harmless for others.
+    is_date_field = field in ("author-date", "committer-date")
+    cmd = ["git", "log", "-1", f"--format={fmt}", sha]
+    if is_date_field:
+        cmd.append("--date=raw")
     result = subprocess.run(
-        ["git", "log", "-1", f"--format={fmt}", sha],
+        cmd,
         capture_output=True,
         text=True,
     )

git_rewrite/ops.py

@@ -17,6 +17,8 @@
     "author-email": "commit.author_email",
     "committer-name": "commit.committer_name",
     "committer-email": "commit.committer_email",
+    "author-date": "commit.author_date",
+    "committer-date": "commit.committer_date",
 }
 
 

tests/test_cli.py

@@ -78,6 +78,23 @@ def test_invalid_field_exits(self):
         with pytest.raises(SystemExit):
             self.parser.parse_args(["strip", "pat", "--field", "not-a-field"])
 
+    def test_strip_with_author_date_field(self):
+        args = self.parser.parse_args(["strip", "pat", "--field", "author-date"])
+        assert args.field == "author-date"
+
+    def test_strip_with_committer_date_field(self):
+        args = self.parser.parse_args(["strip", "pat", "--field", "committer-date"])
+        assert args.field == "committer-date"
+
+    def test_replace_with_author_date_field(self):
+        args = self.parser.parse_args(["replace", r"[-+]\d{4}$", "+0000", "--field", "author-date"])
+        assert args.field == "author-date"
+        assert args.pattern == r"[-+]\d{4}$"
+        assert args.replacement == "+0000"
+
+    def test_replace_with_committer_date_field(self):
+        args = self.parser.parse_args(["replace", r"[-+]\d{4}$", "+0000", "--field", "committer-date"])
+        assert args.field == "committer-date"
     def test_strip_scope_defaults_none(self):
         args = self.parser.parse_args(["strip", "pat"])
         assert args.since is None

tests/test_ops.py

@@ -77,6 +77,24 @@ def test_leaves_author_email_on_no_match(self):
         run_callback(code, c)
         assert c.author_email == b"keep@example.com"
 
+    def test_zeros_author_date_on_match(self):
+        code = ops.strip(r"[-+]\d{4}$", flags=0, field="author-date")
+        c = FakeCommit(author_date=b"1700000000 -0700")
+        run_callback(code, c)
+        assert c.author_date == b""
+
+    def test_leaves_author_date_on_no_match(self):
+        code = ops.strip(r"\+9999$", flags=0, field="author-date")
+        c = FakeCommit(author_date=b"1700000000 +0000")
+        run_callback(code, c)
+        assert c.author_date == b"1700000000 +0000"
+
+    def test_zeros_committer_date_on_match(self):
+        code = ops.strip(r"[-+]\d{4}$", flags=0, field="committer-date")
+        c = FakeCommit(committer_date=b"1700000000 +0530")
+        run_callback(code, c)
+        assert c.committer_date == b""
+
     def test_noop_on_empty_message(self):
         code = ops.strip("anything", flags=0, field="message")
         c = FakeCommit(message=b"")
@@ -135,6 +153,18 @@ def test_replaces_author_name_field(self):
         run_callback(code, c)
         assert c.author_name == b"New Name"
 
+    def test_replaces_author_date_timezone(self):
+        code = ops.replace(r"[-+]\d{4}$", "+0000", flags=0, field="author-date")
+        c = FakeCommit(author_date=b"1700000000 -0700")
+        run_callback(code, c)
+        assert c.author_date == b"1700000000 +0000"
+
+    def test_replaces_committer_date_timezone(self):
+        code = ops.replace(r"[-+]\d{4}$", "+0000", flags=0, field="committer-date")
+        c = FakeCommit(committer_date=b"1700000000 +0530")
+        run_callback(code, c)
+        assert c.committer_date == b"1700000000 +0000"
+
     def test_noop_when_no_match(self):
         code = ops.replace("not-there", "replacement", flags=0, field="message")
         c = FakeCommit(message=b"unchanged\n")