rework-rate 0.1.0__tar.gz

rework_rate-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tetsuroh Hori
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rework_rate-0.1.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: rework-rate
+Version: 0.1.0
+Summary: Measure how much of your git history is rework. No config, no signup, no network.
+Author-email: Tetsuroh Hori <43089161+Tetsurohhori@users.noreply.github.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Tetsurohhori/rework-rate
+Project-URL: Repository, https://github.com/Tetsurohhori/rework-rate
+Keywords: git,rework,churn,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# rework-rate
+
+Measure how much of **your** git history is rework. One command. No config. No signup.
+
+```
+rework-rate
+rework-rate 34
+rework-rate 34 --minutes 20 --hourly 5000
+```
+
+`--minutes` and `--hourly` have **no defaults**. Both must be given, or neither. The printed yen line repeats those inputs. They are yours, not a measurement.
+
+## Definition (public, breakable)
+
+A commit counts as **rework** when:
+
+1. its subject starts with `fix` or `revert` (case-insensitive), **and**
+2. it touches a file that **this same history** already touched less than **24 hours** earlier.
+
+```
+rework = a fix touching a file you changed less than 24h earlier
+```
+
+That is the whole definition. If you disagree with it, you can show a counterexample on a real repository and we will treat that as a successful break. **This definition is not the only valid one. A claim that it is "the right" definition is not part of the tool.**
+
+## Limits of this definition
+
+- Fixes that are **not** labeled `fix` / `revert` are not counted.
+- Operators who **commit corrections** (instead of amending silently, squashing, or force-pushing) will score **higher**. The number rewards leaving a trail, not "worse work."
+- **24 hours is an arbitrary threshold.** It is not a natural unit of software. A 25-hour fix of the same file is invisible to this tool. A 23-hour rename that happens to start with `fix` is visible.
+- Merge commits, empty commits, and files whose names contain whitespace follow the same `git show --name-only` split the prototype used. That is a limitation, not a feature.
+
+If you have a definition that is stricter, looser, or labeled differently, write it down and run it. A definition that cannot be broken is not a definition.
+
+## When this tool cannot measure
+
+If the window contains **no** commit whose subject starts with `fix` or `revert`, the tool prints `not measurable here` and exits 0. It does **not** print 0%. A repository that never labels fixes is outside the definition, not a healthy score.
+
+If at least one such subject exists, the rate and the weekly table are printed. The published reference line is printed only when there are **5 or more** `fix`/`revert` subjects. Fewer than that is too thin to sit next to another person's number.
+
+## Published reference (one operator, one repo)
+
+```
+window     2026-07-21 … 2026-08-30 (34 days)
+commits    817
+overall    181 / 816 = 22.2%
+Cursor     170 / 593 = 28.7%
+reference  28.7%  (n=1 repository, 1 operator, 6 complete weeks)
+reference r = +0.87  (n=6 complete weeks)
+```
+
+**The n of the rate is not 817 commits.** It is one repository and one operator. The n of r = +0.87 is six complete ISO weeks. This is a published run, not a benchmark. The tool prints `yours` next to `reference` and does not say which is better.
+
+## Relation to change failure rate
+
+This number is a **pre-merge cousin of change failure rate** (CFR), the DORA / Accelerate term for the share of production deployments that fail.
+
+| | CFR | this tool |
+|--|-----|-----------|
+| Place | production | commit history |
+| Event | a deploy that failed in production | a `fix`/`revert` that retouches a file seen in the last 24 hours |
+
+They are not the same quantity. This tool is not part of the DORA research program, and it is not an AI-era stand-in for those four measures. The vocabulary is borrowed. The authority is not.
+
+Weekly correlation is Pearson's r of weekly commit count vs weekly rework rate. It is printed only when **at least 3 complete ISO weeks** remain after dropping incomplete weeks at **both ends** of the window. Two weeks can always produce r = ±1.00. We do not print that number.
+
+An ISO week is **incomplete** when:
+
+- it has not finished yet (the following Monday 00:00 UTC is still after the window end), **or**
+- the window opens two or more UTC days after that week's Monday.
+
+The first case is why a Monday run and a Sunday run used to disagree: one in-progress week (2 commits, 0% rework) moved r by 0.22. That week is still listed in the table, marked `(partial)`, and is **not** fed into r. The second case is why `N days ago` landing on a Tuesday does not, by itself, drop the first week. A two-day-or-more cut does.
+
+**Display:** every ISO week that has commits in the window appears in the weekly table. Incomplete weeks are marked `(partial)`. Exclusion applies to the correlation only.
+
+## What this tool does not do
+
+- It does not send telemetry, usage data, crash reports, or version-check requests.
+- It does not import `urllib`, `requests`, `http`, or `socket`.
+- It does not write to your repository. The only git verbs it runs are `log`, `show`, and `rev-parse`.
+- It does not create temporary files.
+- It does not fetch, checkout, or change branches.
+
+If it is not a git repository, or the window has no commits, it exits with a clear error.
+
+## Install (local)
+
+```
+pip install -e ./packaging
+```
+
+## License
+
+MIT.

rework_rate-0.1.0/README.md

@@ -0,0 +1,94 @@
+# rework-rate
+
+Measure how much of **your** git history is rework. One command. No config. No signup.
+
+```
+rework-rate
+rework-rate 34
+rework-rate 34 --minutes 20 --hourly 5000
+```
+
+`--minutes` and `--hourly` have **no defaults**. Both must be given, or neither. The printed yen line repeats those inputs. They are yours, not a measurement.
+
+## Definition (public, breakable)
+
+A commit counts as **rework** when:
+
+1. its subject starts with `fix` or `revert` (case-insensitive), **and**
+2. it touches a file that **this same history** already touched less than **24 hours** earlier.
+
+```
+rework = a fix touching a file you changed less than 24h earlier
+```
+
+That is the whole definition. If you disagree with it, you can show a counterexample on a real repository and we will treat that as a successful break. **This definition is not the only valid one. A claim that it is "the right" definition is not part of the tool.**
+
+## Limits of this definition
+
+- Fixes that are **not** labeled `fix` / `revert` are not counted.
+- Operators who **commit corrections** (instead of amending silently, squashing, or force-pushing) will score **higher**. The number rewards leaving a trail, not "worse work."
+- **24 hours is an arbitrary threshold.** It is not a natural unit of software. A 25-hour fix of the same file is invisible to this tool. A 23-hour rename that happens to start with `fix` is visible.
+- Merge commits, empty commits, and files whose names contain whitespace follow the same `git show --name-only` split the prototype used. That is a limitation, not a feature.
+
+If you have a definition that is stricter, looser, or labeled differently, write it down and run it. A definition that cannot be broken is not a definition.
+
+## When this tool cannot measure
+
+If the window contains **no** commit whose subject starts with `fix` or `revert`, the tool prints `not measurable here` and exits 0. It does **not** print 0%. A repository that never labels fixes is outside the definition, not a healthy score.
+
+If at least one such subject exists, the rate and the weekly table are printed. The published reference line is printed only when there are **5 or more** `fix`/`revert` subjects. Fewer than that is too thin to sit next to another person's number.
+
+## Published reference (one operator, one repo)
+
+```
+window     2026-07-21 … 2026-08-30 (34 days)
+commits    817
+overall    181 / 816 = 22.2%
+Cursor     170 / 593 = 28.7%
+reference  28.7%  (n=1 repository, 1 operator, 6 complete weeks)
+reference r = +0.87  (n=6 complete weeks)
+```
+
+**The n of the rate is not 817 commits.** It is one repository and one operator. The n of r = +0.87 is six complete ISO weeks. This is a published run, not a benchmark. The tool prints `yours` next to `reference` and does not say which is better.
+
+## Relation to change failure rate
+
+This number is a **pre-merge cousin of change failure rate** (CFR), the DORA / Accelerate term for the share of production deployments that fail.
+
+| | CFR | this tool |
+|--|-----|-----------|
+| Place | production | commit history |
+| Event | a deploy that failed in production | a `fix`/`revert` that retouches a file seen in the last 24 hours |
+
+They are not the same quantity. This tool is not part of the DORA research program, and it is not an AI-era stand-in for those four measures. The vocabulary is borrowed. The authority is not.
+
+Weekly correlation is Pearson's r of weekly commit count vs weekly rework rate. It is printed only when **at least 3 complete ISO weeks** remain after dropping incomplete weeks at **both ends** of the window. Two weeks can always produce r = ±1.00. We do not print that number.
+
+An ISO week is **incomplete** when:
+
+- it has not finished yet (the following Monday 00:00 UTC is still after the window end), **or**
+- the window opens two or more UTC days after that week's Monday.
+
+The first case is why a Monday run and a Sunday run used to disagree: one in-progress week (2 commits, 0% rework) moved r by 0.22. That week is still listed in the table, marked `(partial)`, and is **not** fed into r. The second case is why `N days ago` landing on a Tuesday does not, by itself, drop the first week. A two-day-or-more cut does.
+
+**Display:** every ISO week that has commits in the window appears in the weekly table. Incomplete weeks are marked `(partial)`. Exclusion applies to the correlation only.
+
+## What this tool does not do
+
+- It does not send telemetry, usage data, crash reports, or version-check requests.
+- It does not import `urllib`, `requests`, `http`, or `socket`.
+- It does not write to your repository. The only git verbs it runs are `log`, `show`, and `rev-parse`.
+- It does not create temporary files.
+- It does not fetch, checkout, or change branches.
+
+If it is not a git repository, or the window has no commits, it exits with a clear error.
+
+## Install (local)
+
+```
+pip install -e ./packaging
+```
+
+## License
+
+MIT.

rework_rate-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rework-rate"
+version = "0.1.0"
+description = "Measure how much of your git history is rework. No config, no signup, no network."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+  { name = "Tetsuroh Hori", email = "43089161+Tetsurohhori@users.noreply.github.com" },
+]
+keywords = ["git", "rework", "churn", "cli"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Typing :: Typed",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/Tetsurohhori/rework-rate"
+Repository = "https://github.com/Tetsurohhori/rework-rate"
+
+[project.scripts]
+rework-rate = "rework_rate.measure:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["rework_rate*"]

rework_rate-0.1.0/rework_rate/__init__.py

@@ -0,0 +1,43 @@
+"""rework-rate — local CLI. No network. Read-only git."""
+
+from rework_rate.measure import (
+    BASELINE_R,
+    BASELINE_RATE,
+    DEFAULT_DAYS,
+    LEADING_PARTIAL_SECONDS,
+    MIN_FIX_LIKE_FOR_REFERENCE,
+    MIN_WEEKS_FOR_CORRELATION,
+    REFERENCE_N,
+    REFERENCE_R,
+    REFERENCE_RATE,
+    REWORK_WINDOW_SECONDS,
+    CliOptions,
+    MeasureResult,
+    ReworkError,
+    WeekRow,
+    format_report,
+    measure,
+    parse_cli,
+    week_is_partial,
+)
+
+__all__ = [
+    "BASELINE_R",
+    "BASELINE_RATE",
+    "DEFAULT_DAYS",
+    "LEADING_PARTIAL_SECONDS",
+    "MIN_FIX_LIKE_FOR_REFERENCE",
+    "MIN_WEEKS_FOR_CORRELATION",
+    "REFERENCE_N",
+    "REFERENCE_R",
+    "REFERENCE_RATE",
+    "REWORK_WINDOW_SECONDS",
+    "CliOptions",
+    "MeasureResult",
+    "ReworkError",
+    "WeekRow",
+    "format_report",
+    "measure",
+    "parse_cli",
+    "week_is_partial",
+]

rework_rate-0.1.0/rework_rate/__main__.py

@@ -0,0 +1,4 @@
+from rework_rate.measure import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

rework_rate-0.1.0/rework_rate/measure.py

@@ -0,0 +1,390 @@
+#!/usr/bin/env python3
+"""Measure how much of a git history is rework. Stdlib only. Read-only git."""
+
+from __future__ import annotations
+
+import argparse
+import collections
+import datetime
+import statistics as st
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+DEFAULT_DAYS = 30
+REWORK_WINDOW_SECONDS = 86400
+MIN_WEEKS_FOR_CORRELATION = 3
+LEADING_PARTIAL_SECONDS = 2 * 86400
+MIN_FIX_LIKE_FOR_REFERENCE = 5
+REFERENCE_RATE = 28.7
+REFERENCE_R = 0.87
+REFERENCE_N = "n=1 repository, 1 operator, 6 complete weeks"
+REFERENCE_R_N = "n=6 complete weeks"
+BASELINE_RATE = REFERENCE_RATE
+BASELINE_R = REFERENCE_R
+REWORK_PREFIXES = ("fix", "revert")
+_ALLOWED_GIT = frozenset({"log", "show", "rev-parse"})
+_FORBIDDEN_GIT = frozenset(
+    {
+        "add",
+        "checkout",
+        "commit",
+        "fetch",
+        "merge",
+        "pull",
+        "push",
+        "rebase",
+        "reset",
+        "rm",
+        "stash",
+        "switch",
+        "tag",
+        "worktree",
+    }
+)
+
+
+class ReworkError(SystemExit):
+    """Clear failure: not a git repo, or no commits in the window."""
+
+
+@dataclass(frozen=True)
+class WeekRow:
+    week: str
+    commits: int
+    rework: int
+    rate: float
+    partial: bool = False
+
+
+@dataclass(frozen=True)
+class MeasureResult:
+    commits: int
+    rework: int
+    rate: float
+    weeks: tuple[WeekRow, ...]
+    correlation: float | None
+    days: int
+    fix_like: int
+    median_lag_seconds: float | None
+
+
+@dataclass(frozen=True)
+class CliOptions:
+    days: int
+    minutes: float | None
+    hourly: float | None
+
+
+def _git(repo: Path, *args: str) -> subprocess.CompletedProcess[str]:
+    if not args:
+        raise ReworkError("internal: empty git invocation")
+    verb = args[0]
+    if verb in _FORBIDDEN_GIT or verb not in _ALLOWED_GIT:
+        raise ReworkError(f"refusing git {verb}: read-only (log / show / rev-parse only)")
+    return subprocess.run(
+        ["git", *args],
+        cwd=str(repo),
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+
+def _require_repo(repo: Path) -> None:
+    probe = _git(repo, "rev-parse", "--is-inside-work-tree")
+    if probe.returncode != 0 or probe.stdout.strip() != "true":
+        raise ReworkError("not a git repository")
+
+
+def _iso_from_unix(ts: int) -> str:
+    return datetime.datetime.fromtimestamp(ts, datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _iso_week_bounds(week_label: str) -> tuple[int, int]:
+    year_s, week_s = week_label.split("-W", 1)
+    monday = datetime.date.fromisocalendar(int(year_s), int(week_s), 1)
+    start = datetime.datetime(monday.year, monday.month, monday.day, tzinfo=datetime.timezone.utc)
+    end = start + datetime.timedelta(days=7)
+    return int(start.timestamp()), int(end.timestamp())
+
+
+def week_is_partial(week_label: str, window_start: int, window_end: int) -> bool:
+    """Incomplete ISO week at either end of the measurement window.
+
+    Trailing: the week has not finished (next Monday 00:00 UTC is still after
+    window_end). Leading: the window opens two or more UTC days after that
+    week's Monday. A one-day cut from ``N days ago`` landing on Tuesday does
+    not drop the first week; a two-day-or-more cut does.
+    """
+    week_start, week_end = _iso_week_bounds(week_label)
+    if week_end > window_end:
+        return True
+    if week_start < window_start and (window_start - week_start) >= LEADING_PARTIAL_SECONDS:
+        return True
+    return False
+
+
+def _log(repo: Path, window_start: int, window_end: int) -> list[tuple[str, int, str]]:
+    raw = _git(
+        repo,
+        "log",
+        f"--since={_iso_from_unix(window_start)}",
+        f"--until={_iso_from_unix(window_end)}",
+        "--format=%H|%ct|%s",
+    )
+    if raw.returncode != 0:
+        err = (raw.stderr or raw.stdout or "git log failed").strip()
+        raise ReworkError(err)
+    lines = [ln for ln in raw.stdout.splitlines() if ln.strip()]
+    if not lines:
+        raise ReworkError("no commits in window")
+    commits: list[tuple[str, int, str]] = []
+    for line in lines:
+        hid, ts, subject = line.split("|", 2)
+        commits.append((hid, int(ts), subject))
+    commits.sort(key=lambda row: row[1])
+    return commits
+
+
+def _files(repo: Path, hid: str) -> list[str]:
+    shown = _git(repo, "show", "--name-only", "--format=", hid)
+    if shown.returncode != 0:
+        err = (shown.stderr or shown.stdout or f"git show failed for {hid}").strip()
+        raise ReworkError(err)
+    return [ln for ln in shown.stdout.split() if ln]
+
+
+def _is_rework_subject(subject: str) -> bool:
+    return subject.lower().startswith(REWORK_PREFIXES)
+
+
+def _pearson(xs: list[float], ys: list[float]) -> float | None:
+    if len(xs) < MIN_WEEKS_FOR_CORRELATION or len(xs) != len(ys):
+        return None
+    mx, my = st.mean(xs), st.mean(ys)
+    den = (sum((a - mx) ** 2 for a in xs) * sum((b - my) ** 2 for b in ys)) ** 0.5
+    if not den:
+        return None
+    return sum((a - mx) * (b - my) for a, b in zip(xs, ys)) / den
+
+
+def measure(
+    days: int = DEFAULT_DAYS,
+    repo: Path | None = None,
+    *,
+    now: int | None = None,
+) -> MeasureResult:
+    if days < 1:
+        raise ReworkError("days must be >= 1")
+    root = (repo or Path.cwd()).resolve()
+    _require_repo(root)
+    window_end = int(now if now is not None else time.time())
+    window_start = window_end - days * 86400
+    commits = _log(root, window_start, window_end)
+    last: dict[str, int] = {}
+    per: dict[str, list[int]] = collections.defaultdict(lambda: [0, 0])
+    total = 0
+    rework = 0
+    fix_like = 0
+    lags: list[float] = []
+    for hid, ts, subject in commits:
+        files = _files(root, hid)
+        week = datetime.datetime.fromtimestamp(ts, datetime.timezone.utc).strftime("%G-W%V")
+        per[week][0] += 1
+        total += 1
+        if _is_rework_subject(subject):
+            fix_like += 1
+            prior = [ts - last[name] for name in files if name in last]
+            if prior and min(prior) < REWORK_WINDOW_SECONDS:
+                gap = float(min(prior))
+                per[week][1] += 1
+                rework += 1
+                lags.append(gap)
+        for name in files:
+            last[name] = ts
+    rate = (rework / total * 100.0) if total else 0.0
+    weeks: list[WeekRow] = []
+    ns: list[float] = []
+    rs: list[float] = []
+    for week in sorted(per):
+        n, r = per[week]
+        p = r / n * 100.0
+        partial = week_is_partial(week, window_start, window_end)
+        weeks.append(WeekRow(week=week, commits=n, rework=r, rate=p, partial=partial))
+        if not partial:
+            ns.append(float(n))
+            rs.append(p)
+    return MeasureResult(
+        commits=total,
+        rework=rework,
+        rate=rate,
+        weeks=tuple(weeks),
+        correlation=_pearson(ns, rs),
+        days=days,
+        fix_like=fix_like,
+        median_lag_seconds=st.median(lags) if lags else None,
+    )
+
+
+def _bold(text: str) -> str:
+    if sys.stdout.isatty():
+        return f"\033[1m{text}\033[0m"
+    return text
+
+
+def _format_lag(seconds: float) -> str:
+    total = max(0, int(round(seconds)))
+    hours, rem = divmod(total, 3600)
+    minutes, secs = divmod(rem, 60)
+    if hours:
+        return f"{hours}h {minutes}m"
+    if minutes:
+        return f"{minutes}m"
+    return f"{secs}s"
+
+
+def _plain_number(value: float) -> str:
+    if value == int(value):
+        return str(int(value))
+    return f"{value:g}"
+
+
+def _yen(amount: float) -> str:
+    return f"¥{amount:,.0f}"
+
+
+def format_unmeasurable(result: MeasureResult) -> str:
+    return (
+        "\n"
+        "  not measurable here\n"
+        "\n"
+        f"  {result.commits} commits in the last {result.days} days, "
+        "0 of them with a fix/revert subject line.\n"
+        "  This tool infers rework from commit subjects. Your repository does not use\n"
+        "  that convention, so it has nothing to count — this is not a score of 0%.\n"
+        "\n"
+        "  It will work on a repository where fixes are labelled (Conventional Commits,\n"
+        '  or any subject starting with "fix" or "revert").\n'
+    )
+
+
+def format_report(
+    result: MeasureResult,
+    minutes: float | None = None,
+    hourly: float | None = None,
+) -> str:
+    if result.fix_like == 0:
+        return format_unmeasurable(result)
+    lines = [
+        "",
+        f"  commits {result.commits} · rework {result.rework} · {_bold(f'rework rate {result.rate:.1f}%')}",
+        "  (rework = a fix touching a file you changed less than 24h earlier)",
+        "",
+        "  week      commits  rework   rate",
+    ]
+    for row in result.weeks:
+        bar = "#" * int(row.rate / 2)
+        mark = "  (partial)" if row.partial else ""
+        lines.append(
+            f"  {row.week}  {row.commits:7d}  {row.rework:6d}  {row.rate:5.1f}%  {bar}{mark}"
+        )
+    if result.correlation is not None:
+        lines.append("")
+        lines.append(
+            f"  throughput vs rework   r = {result.correlation:+.2f}  (complete ISO weeks only)"
+        )
+        if result.correlation > 0.5:
+            lines.append("  → the weeks you shipped most are the weeks you redid most")
+    if result.median_lag_seconds is not None:
+        lines.append("")
+        lines.append(
+            f"  median {_format_lag(result.median_lag_seconds)} between the original commit and its fix"
+        )
+        lines.append("  (elapsed time in git, not effort)")
+    if minutes is not None and hourly is not None:
+        yen = result.rework * minutes / 60.0 * hourly
+        lines.append("")
+        lines.append(
+            f"  {result.rework} rework × {_plain_number(minutes)} min (yours) × "
+            f"{_yen(hourly)}/h (yours)  =  {_yen(yen)}"
+        )
+    if result.fix_like >= MIN_FIX_LIKE_FOR_REFERENCE:
+        lines.append("")
+        lines.append(
+            f"  yours: {result.rate:.1f}%   ·   "
+            f"reference: {REFERENCE_RATE}%  ({REFERENCE_N})"
+        )
+        lines.append(f"  reference r = {REFERENCE_R:+.2f}  ({REFERENCE_R_N})")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def _cli_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="rework-rate",
+        description="Measure rework in this git repo. Read-only. No network.",
+    )
+    parser.add_argument(
+        "days",
+        nargs="?",
+        type=int,
+        default=DEFAULT_DAYS,
+        help="Look-back window in days (default: 30)",
+    )
+    parser.add_argument(
+        "--minutes",
+        type=float,
+        default=None,
+        help="Minutes per rework you assign. No default. Requires --hourly.",
+    )
+    parser.add_argument(
+        "--hourly",
+        type=float,
+        default=None,
+        help="Hourly rate you assign. No default. Requires --minutes.",
+    )
+    return parser
+
+
+def parse_cli(argv: list[str]) -> CliOptions:
+    parser = _cli_parser()
+    try:
+        ns = parser.parse_args(argv)
+    except SystemExit as exc:
+        code = exc.code if isinstance(exc.code, int) else 1
+        if code == 0:
+            raise
+        raise ReworkError("usage: rework-rate [days] [--minutes MINUTES --hourly HOURLY]") from exc
+    if ns.days < 1:
+        raise ReworkError("days must be >= 1")
+    minutes = ns.minutes
+    hourly = ns.hourly
+    if (minutes is None) ^ (hourly is None):
+        raise ReworkError("--minutes and --hourly must be given together (no defaults)")
+    if minutes is not None and hourly is not None and (minutes <= 0 or hourly <= 0):
+        raise ReworkError("--minutes and --hourly must be positive")
+    return CliOptions(days=int(ns.days), minutes=minutes, hourly=hourly)
+
+
+def parse_days(argv: list[str]) -> int:
+    return parse_cli(argv).days
+
+
+def main(argv: list[str] | None = None) -> int:
+    try:
+        opts = parse_cli(sys.argv[1:] if argv is None else argv)
+        print(
+            format_report(measure(opts.days), minutes=opts.minutes, hourly=opts.hourly),
+            end="",
+        )
+        return 0
+    except ReworkError as exc:
+        print(str(exc) or "failed", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

rework_rate-0.1.0/rework_rate.egg-info/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: rework-rate
+Version: 0.1.0
+Summary: Measure how much of your git history is rework. No config, no signup, no network.
+Author-email: Tetsuroh Hori <43089161+Tetsurohhori@users.noreply.github.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Tetsurohhori/rework-rate
+Project-URL: Repository, https://github.com/Tetsurohhori/rework-rate
+Keywords: git,rework,churn,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# rework-rate
+
+Measure how much of **your** git history is rework. One command. No config. No signup.
+
+```
+rework-rate
+rework-rate 34
+rework-rate 34 --minutes 20 --hourly 5000
+```
+
+`--minutes` and `--hourly` have **no defaults**. Both must be given, or neither. The printed yen line repeats those inputs. They are yours, not a measurement.
+
+## Definition (public, breakable)
+
+A commit counts as **rework** when:
+
+1. its subject starts with `fix` or `revert` (case-insensitive), **and**
+2. it touches a file that **this same history** already touched less than **24 hours** earlier.
+
+```
+rework = a fix touching a file you changed less than 24h earlier
+```
+
+That is the whole definition. If you disagree with it, you can show a counterexample on a real repository and we will treat that as a successful break. **This definition is not the only valid one. A claim that it is "the right" definition is not part of the tool.**
+
+## Limits of this definition
+
+- Fixes that are **not** labeled `fix` / `revert` are not counted.
+- Operators who **commit corrections** (instead of amending silently, squashing, or force-pushing) will score **higher**. The number rewards leaving a trail, not "worse work."
+- **24 hours is an arbitrary threshold.** It is not a natural unit of software. A 25-hour fix of the same file is invisible to this tool. A 23-hour rename that happens to start with `fix` is visible.
+- Merge commits, empty commits, and files whose names contain whitespace follow the same `git show --name-only` split the prototype used. That is a limitation, not a feature.
+
+If you have a definition that is stricter, looser, or labeled differently, write it down and run it. A definition that cannot be broken is not a definition.
+
+## When this tool cannot measure
+
+If the window contains **no** commit whose subject starts with `fix` or `revert`, the tool prints `not measurable here` and exits 0. It does **not** print 0%. A repository that never labels fixes is outside the definition, not a healthy score.
+
+If at least one such subject exists, the rate and the weekly table are printed. The published reference line is printed only when there are **5 or more** `fix`/`revert` subjects. Fewer than that is too thin to sit next to another person's number.
+
+## Published reference (one operator, one repo)
+
+```
+window     2026-07-21 … 2026-08-30 (34 days)
+commits    817
+overall    181 / 816 = 22.2%
+Cursor     170 / 593 = 28.7%
+reference  28.7%  (n=1 repository, 1 operator, 6 complete weeks)
+reference r = +0.87  (n=6 complete weeks)
+```
+
+**The n of the rate is not 817 commits.** It is one repository and one operator. The n of r = +0.87 is six complete ISO weeks. This is a published run, not a benchmark. The tool prints `yours` next to `reference` and does not say which is better.
+
+## Relation to change failure rate
+
+This number is a **pre-merge cousin of change failure rate** (CFR), the DORA / Accelerate term for the share of production deployments that fail.
+
+| | CFR | this tool |
+|--|-----|-----------|
+| Place | production | commit history |
+| Event | a deploy that failed in production | a `fix`/`revert` that retouches a file seen in the last 24 hours |
+
+They are not the same quantity. This tool is not part of the DORA research program, and it is not an AI-era stand-in for those four measures. The vocabulary is borrowed. The authority is not.
+
+Weekly correlation is Pearson's r of weekly commit count vs weekly rework rate. It is printed only when **at least 3 complete ISO weeks** remain after dropping incomplete weeks at **both ends** of the window. Two weeks can always produce r = ±1.00. We do not print that number.
+
+An ISO week is **incomplete** when:
+
+- it has not finished yet (the following Monday 00:00 UTC is still after the window end), **or**
+- the window opens two or more UTC days after that week's Monday.
+
+The first case is why a Monday run and a Sunday run used to disagree: one in-progress week (2 commits, 0% rework) moved r by 0.22. That week is still listed in the table, marked `(partial)`, and is **not** fed into r. The second case is why `N days ago` landing on a Tuesday does not, by itself, drop the first week. A two-day-or-more cut does.
+
+**Display:** every ISO week that has commits in the window appears in the weekly table. Incomplete weeks are marked `(partial)`. Exclusion applies to the correlation only.
+
+## What this tool does not do
+
+- It does not send telemetry, usage data, crash reports, or version-check requests.
+- It does not import `urllib`, `requests`, `http`, or `socket`.
+- It does not write to your repository. The only git verbs it runs are `log`, `show`, and `rev-parse`.
+- It does not create temporary files.
+- It does not fetch, checkout, or change branches.
+
+If it is not a git repository, or the window has no commits, it exits with a clear error.
+
+## Install (local)
+
+```
+pip install -e ./packaging
+```
+
+## License
+
+MIT.

rework_rate-0.1.0/rework_rate.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+rework_rate/__init__.py
+rework_rate/__main__.py
+rework_rate/measure.py
+rework_rate.egg-info/PKG-INFO
+rework_rate.egg-info/SOURCES.txt
+rework_rate.egg-info/dependency_links.txt
+rework_rate.egg-info/entry_points.txt
+rework_rate.egg-info/top_level.txt

rework_rate-0.1.0/rework_rate.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rework_rate-0.1.0/rework_rate.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+rework-rate = rework_rate.measure:main

rework_rate-0.1.0/rework_rate.egg-info/top_level.txt

@@ -0,0 +1 @@
+rework_rate

rework_rate-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+