secretside 0.1.0__tar.gz

secretside-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

secretside-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 magicalhack
+
+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.

secretside-0.1.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: secretside
+Version: 0.1.0
+Summary: Shift git commit timestamps out of work hours so your side project stays secret
+Project-URL: Homepage, https://codeberg.org/magicalhack/secretside
+Project-URL: Repository, https://codeberg.org/magicalhack/secretside
+Project-URL: Issues, https://codeberg.org/magicalhack/secretside/issues
+Author-email: magicalhack <hello@magicalhack.net>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.11
+Requires-Dist: click>=8.2.1
+Requires-Dist: git-filter-repo>=2.47.0
+Requires-Dist: holidays>=0.80
+Requires-Dist: pygit2>=1.18.2
+Requires-Dist: rich>=14.0.0
+Description-Content-Type: text/markdown
+
+# secretside
+
+Shift git commit timestamps out of work hours so your side project stays secret.
+
+If you committed at 10:47 on a Wednesday, secretside moves it to 17:47 (or later). It also catches identity leaks — commits made with your real name or work email when you meant to use a pseudonym.
+
+## Install
+
+```bash
+pip install secretside
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv tool install secretside
+```
+
+<small>Note: `libgit2` 1.9 headers are required.</small>
+
+## Quick start
+
+```bash
+secretside init
+secretside clean --dry-run
+secretside check # quick validate for use in a git hook
+```
+
+## Commands
+
+**`secretside init [repo] [--country XX] [--force]`** — Generate `secretside.toml` with jittered defaults so every project's config looks slightly different.
+
+**`secretside clean [repo] [--dry-run]`** — Preview and apply timestamp shifts. Only touches your most recent contiguous commits. With `local_only = true` in your config (the default), only unpushed commits are considered/modified.
+
+**`secretside inspect [repo]`** — Show commit time distribution and list all work-hour commits.
+
+**`secretside check [repo]`** — Validate that no commits fall in work hours and no banned identities appear. Designed for CI or pre-push hooks.
+
+## Config
+
+`secretside init` creates a `secretside.toml` in your repo:
+
+```toml
+holidays = "CA"
+work_days = "mon-fri"
+work_hours = "08:47..17:52"
+night_hours = "23:12..05:44"
+local_only = true
+banned = [
+    # ["Your Real Name", "real@email.com"],
+    # ["Your Real Name", "work@company.com"],
+]
+pto = [
+    # "2025-02-07",
+    # "2025-12-24..2025-12-31",
+]
+```
+
+| Key | Description |
+|-----|-------------|
+| `holidays` | Country code for public holidays (`"CA"`, `"US"`, `"GB"`, etc.) |
+| `work_days` | Which days are work days (`"mon-fri"`, `"mon-thu"`, `"mon-wed,fri"`) |
+| `work_hours` | Commits in this range on work days get shifted past `work_end` |
+| `night_hours` | Shifted commits avoid landing here (organic night commits are left alone) |
+| `local_only` | Only shift commits that haven't been pushed to any remote |
+| `banned` | Name/email pairs to flag in `check` — keep your real identity out of the repo |
+| `pto` | Dates (or `start..end` ranges) to treat as days off |
+
+## How it works
+
+- Only the **contiguous tail** of your commits is touched — other people's commits are never modified
+- **Weekend, holiday, and PTO commits** are left alone — already safe - unless they need shifting due to overflow from a work day
+- **Organic night commits** (you actually coded at 1am) stay put
+- **Chronological order** is always preserved, with original time gaps maintained where possible
+- History rewriting uses [git-filter-repo](https://github.com/newren/git-filter-repo) under the hood
+
+## Development
+
+Requires Python 3.11+ and [uv](https://docs.astral.sh/uv/).
+
+```bash
+uv sync
+bin/test
+uv run secretside <command>
+```

secretside-0.1.0/README.md

@@ -0,0 +1,85 @@
+# secretside
+
+Shift git commit timestamps out of work hours so your side project stays secret.
+
+If you committed at 10:47 on a Wednesday, secretside moves it to 17:47 (or later). It also catches identity leaks — commits made with your real name or work email when you meant to use a pseudonym.
+
+## Install
+
+```bash
+pip install secretside
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv tool install secretside
+```
+
+<small>Note: `libgit2` 1.9 headers are required.</small>
+
+## Quick start
+
+```bash
+secretside init
+secretside clean --dry-run
+secretside check # quick validate for use in a git hook
+```
+
+## Commands
+
+**`secretside init [repo] [--country XX] [--force]`** — Generate `secretside.toml` with jittered defaults so every project's config looks slightly different.
+
+**`secretside clean [repo] [--dry-run]`** — Preview and apply timestamp shifts. Only touches your most recent contiguous commits. With `local_only = true` in your config (the default), only unpushed commits are considered/modified.
+
+**`secretside inspect [repo]`** — Show commit time distribution and list all work-hour commits.
+
+**`secretside check [repo]`** — Validate that no commits fall in work hours and no banned identities appear. Designed for CI or pre-push hooks.
+
+## Config
+
+`secretside init` creates a `secretside.toml` in your repo:
+
+```toml
+holidays = "CA"
+work_days = "mon-fri"
+work_hours = "08:47..17:52"
+night_hours = "23:12..05:44"
+local_only = true
+banned = [
+    # ["Your Real Name", "real@email.com"],
+    # ["Your Real Name", "work@company.com"],
+]
+pto = [
+    # "2025-02-07",
+    # "2025-12-24..2025-12-31",
+]
+```
+
+| Key | Description |
+|-----|-------------|
+| `holidays` | Country code for public holidays (`"CA"`, `"US"`, `"GB"`, etc.) |
+| `work_days` | Which days are work days (`"mon-fri"`, `"mon-thu"`, `"mon-wed,fri"`) |
+| `work_hours` | Commits in this range on work days get shifted past `work_end` |
+| `night_hours` | Shifted commits avoid landing here (organic night commits are left alone) |
+| `local_only` | Only shift commits that haven't been pushed to any remote |
+| `banned` | Name/email pairs to flag in `check` — keep your real identity out of the repo |
+| `pto` | Dates (or `start..end` ranges) to treat as days off |
+
+## How it works
+
+- Only the **contiguous tail** of your commits is touched — other people's commits are never modified
+- **Weekend, holiday, and PTO commits** are left alone — already safe - unless they need shifting due to overflow from a work day
+- **Organic night commits** (you actually coded at 1am) stay put
+- **Chronological order** is always preserved, with original time gaps maintained where possible
+- History rewriting uses [git-filter-repo](https://github.com/newren/git-filter-repo) under the hood
+
+## Development
+
+Requires Python 3.11+ and [uv](https://docs.astral.sh/uv/).
+
+```bash
+uv sync
+bin/test
+uv run secretside <command>
+```

secretside-0.1.0/pyproject.toml

@@ -0,0 +1,67 @@
+[project]
+name = "secretside"
+dynamic = ["version"]
+description = "Shift git commit timestamps out of work hours so your side project stays secret"
+authors = [{ name = "magicalhack", email = "hello@magicalhack.net" }]
+license = "MIT"
+readme = "README.md"
+requires-python = ">=3.11"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Version Control :: Git",
+]
+
+dependencies = [
+    "click>=8.2.1",
+    "git-filter-repo>=2.47.0",
+    "holidays>=0.80",
+    "pygit2>=1.18.2",
+    "rich>=14.0.0",
+]
+
+[project.urls]
+Homepage = "https://codeberg.org/magicalhack/secretside"
+Repository = "https://codeberg.org/magicalhack/secretside"
+Issues = "https://codeberg.org/magicalhack/secretside/issues"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.2",
+    "ruff>=0.12.1",
+    "ty>=0.0.16",
+]
+
+[project.scripts]
+secretside = "secretside.__main__:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+path = "src/secretside/__init__.py"
+
+[tool.hatch.build]
+include = ["src/secretside/", "LICENSE", "README.md"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/secretside"]
+
+[tool.uv]
+default-groups = ['dev']
+
+[tool.ruff]
+line-length = 120
+target-version = "py311"
+lint.extend-select = ["I"]
+
+[tool.ruff.format]
+quote-style = "double"

secretside-0.1.0/src/secretside/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

secretside-0.1.0/src/secretside/__main__.py

@@ -0,0 +1,4 @@
+from secretside.command import main
+
+if __name__ == "__main__":
+    main()

secretside-0.1.0/src/secretside/command.py

@@ -0,0 +1,172 @@
+from pathlib import Path
+from sys import exit
+
+from click import argument, group
+from pygit2 import Repository
+from pygit2.enums import SortMode
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from secretside.commands.clean import clean
+from secretside.commands.init import init as init_cmd
+from secretside.config import Config, format_work_days
+from secretside.shift import CommitCategory
+from secretside.utils import FuzzyCommandGroup, SSCommit, configure
+
+
+@group(cls=FuzzyCommandGroup, name="secretside")
+def main():
+    """secretside - When you have a secret side project and want to keep it that way"""
+    pass
+
+
+@main.command("inspect", short_help="Look at your repo, and report on its secretside-yness")
+@configure
+@argument("repo", required=False, default=".")
+def inspect(config: Config, repo: str):
+    """Look at your repo, and report on its secretside-yness"""
+    console = Console()
+    repo_path = Path(repo).resolve()
+
+    if not (repo_path / ".git").exists():
+        console.print(f"[red]Error: {repo_path} is not a git repository[/red]")
+        exit(1)
+
+    repository = Repository(str(repo_path))
+    commits = []
+
+    category_counts = {
+        CommitCategory.WORK: 0,
+        CommitCategory.NIGHT: 0,
+        CommitCategory.FREE_HOLIDAY: 0,
+        CommitCategory.FREE_WEEKEND: 0,
+        CommitCategory.FREE_WEEKDAY: 0,
+    }
+
+    for commit in repository.walk(repository.head.target, SortMode.TIME):
+        c = SSCommit(commit, config)
+        category_counts[c.category] += 1
+        commits.append(c)
+
+    if not commits:
+        console.print("[yellow]No commits found in repository[/yellow]")
+        return
+
+    commits.sort(key=lambda x: x.when, reverse=True)
+    total_commits = len(commits)
+
+    work_commits = category_counts[CommitCategory.WORK]
+    holiday_commits = category_counts[CommitCategory.FREE_HOLIDAY]
+    weekend_commits = category_counts[CommitCategory.FREE_WEEKEND]
+    weekday_commits = category_counts[CommitCategory.FREE_WEEKDAY]
+
+    def pct(n):
+        return f"{n} ({n * 100 // total_commits}%)" if total_commits else "0"
+
+    console.print()
+    console.print(Panel(f"Inspecting: [bold]{repo_path.name}[/bold]", expand=False))
+    console.print()
+    header = Table(box=None, show_header=False, padding=(0, 1))
+    header.add_column(style="bold")
+    header.add_column()
+    header.add_row(
+        "Work hours",
+        f"{config.work_start.strftime('%H:%M')}..{config.work_end.strftime('%H:%M')} {format_work_days(config.work_days)}",
+    )
+    header.add_row("Night hours", f"{config.night_start.strftime('%H:%M')}..{config.night_end.strftime('%H:%M')}")
+    if config.holidays_country:
+        header.add_row("Holidays", config.holidays_country)
+    header.add_row("Total commits", str(total_commits))
+    header.add_row("During work hours", pct(work_commits))
+    header.add_row("After work hours", pct(weekday_commits))
+    header.add_row("Weekend", pct(weekend_commits))
+    if holiday_commits > 0:
+        label = "Holiday/PTO"
+        if config.holidays_country:
+            label += f" ({config.holidays_country})"
+        header.add_row(label, pct(holiday_commits))
+    console.print(header)
+    console.print()
+
+    table = Table(show_header=True)
+    table.add_column("Hash", style="cyan")
+    table.add_column("Time", style="yellow")
+    table.add_column("Message", style="white")
+
+    day_names = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
+    for commit in commits:
+        if commit.category != CommitCategory.WORK:
+            continue
+
+        time_str = commit.when.strftime("%Y-%m-%d %H:%M")
+        day_name = day_names[commit.when.weekday()]
+
+        table.add_row(commit.hash, f"{time_str} ({day_name})", commit.subject)
+
+    console.print(table)
+
+
+@main.command("check", short_help="Check if repo passes secretside validation")
+@configure
+@argument("repo", required=False, default=".")
+def check(config: Config, repo: str):
+    """Check if repository passes secretside validation (no work hour commits, no banned users)"""
+    console = Console()
+    repo_path = Path(repo).resolve()
+
+    if not (repo_path / ".git").exists():
+        console.print(f"[red]Error: {repo_path} is not a git repository[/red]")
+        exit(1)
+
+    # Print configuration being used
+    console.print("[dim]Configuration:[/dim]")
+    console.print(
+        f"[dim]  Work hours: {config.work_start.strftime('%H:%M')}-{config.work_end.strftime('%H:%M')} ({format_work_days(config.work_days)})[/dim]"
+    )
+    console.print(
+        f"[dim]  Night hours: {config.night_start.strftime('%H:%M')}-{config.night_end.strftime('%H:%M')}[/dim]"
+    )
+    if config.holidays_country:
+        console.print(f"[dim]  Holidays: {config.holidays_country}[/dim]")
+    if config.pto_dates:
+        console.print(f"[dim]  PTO dates: {len(config.pto_dates)} configured[/dim]")
+    if config.banned:
+        for name, email in config.banned:
+            console.print(f"[dim]  Banned: {name} <{email}>[/dim]")
+    console.print()
+
+    repository = Repository(str(repo_path))
+    violations = []
+    total_commits = 0
+
+    for commit in repository.walk(repository.head.target, SortMode.TIME):
+        total_commits += 1
+        c = SSCommit(commit, config)
+
+        # Check for work hour violations
+        if c.category == CommitCategory.WORK:
+            violations.append(f"Work hour commit: {c.hash} at {c.when.strftime('%Y-%m-%d %H:%M')} - {c.subject}")
+
+        # Check for banned identity (name or email match)
+        author_name = c.author.name.lower()
+        author_email = c.author.email.lower()
+        if author_name in config.banned_names:
+            violations.append(f"Banned name: {c.hash} by {c.author.name} <{c.author.email}> - {c.subject}")
+        elif author_email in config.banned_emails:
+            violations.append(f"Banned email: {c.hash} by {c.author.name} <{c.author.email}> - {c.subject}")
+
+    if violations:
+        console.print(
+            f"[red]✗ Repository validation failed with {len(violations)} violation(s) out of {total_commits} commits:[/red]"
+        )
+        for violation in violations:
+            console.print(f"  [red]• {violation}[/red]")
+        exit(1)
+    else:
+        console.print(f"[green]✓ Repository passes secretside validation ({total_commits} commits checked)[/green]")
+
+
+# Add subcommands to the main group
+main.add_command(clean)
+main.add_command(init_cmd)

secretside-0.1.0/src/secretside/commands/__init__.py

@@ -0,0 +1 @@
+# Commands module

secretside-0.1.0/src/secretside/commands/clean.py

@@ -0,0 +1,195 @@
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from sys import exit
+
+from click import argument, command, option
+from pygit2 import Repository
+from pygit2.enums import SortMode
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm
+from rich.table import Table
+
+from secretside.config import Config, format_work_days
+from secretside.shift import CommitInfo, compute_shifts, find_unpushed_tail, find_user_tail
+from secretside.utils import configure
+
+
+@command("clean", short_help="Clean repository by shifting commits out of work hours")
+@configure
+@option("--dry-run", is_flag=True, default=False, help="Preview changes without rewriting")
+@argument("repo", required=False, default=".")
+def clean(config: Config, repo: str, dry_run: bool):
+    """Clean repository by shifting commits out of work hours with cascading logic"""
+    console = Console()
+    repo_path = Path(repo).resolve()
+
+    if not (repo_path / ".git").exists():
+        console.print(f"[red]Error: {repo_path} is not a git repository[/red]")
+        exit(1)
+
+    # Walk repo → build CommitInfo list (oldest first)
+    repository = Repository(str(repo_path))
+    commit_infos = []
+    for git_commit in repository.walk(repository.head.target, SortMode.TIME | SortMode.REVERSE):
+        author_time = datetime.fromtimestamp(git_commit.author.time, tz=timezone.utc).astimezone()
+        commit_time = datetime.fromtimestamp(git_commit.commit_time, tz=timezone.utc).astimezone()
+        commit_infos.append(
+            CommitInfo(
+                id=str(git_commit.id),
+                timestamp=min(author_time, commit_time),
+                author_email=git_commit.author.email,
+            )
+        )
+
+    commit_infos.sort(key=lambda c: c.timestamp)
+
+    if not commit_infos:
+        console.print("[yellow]No commits found in repository[/yellow]")
+        return
+
+    # Only shift the contiguous tail of the current user's commits
+    try:
+        user_email = repository.config["user.email"]
+    except KeyError:
+        console.print("[red]Error: git user.email not configured[/red]")
+        exit(1)
+
+    others_skipped = find_user_tail(commit_infos, user_email)
+    my_commits = commit_infos[others_skipped:]
+
+    # If local_only, further trim to unpushed commits
+    pushed_skipped = 0
+    if config.local_only and my_commits:
+        pushed_oids = set()
+        for ref_name in repository.references:
+            if ref_name.startswith("refs/remotes/"):
+                ref = repository.references[ref_name]
+                for c in repository.walk(ref.peel().id, SortMode.TIME):
+                    pushed_oids.add(str(c.id))
+
+        pushed_skipped = find_unpushed_tail(my_commits, pushed_oids)
+        my_commits = my_commits[pushed_skipped:]
+
+    if not my_commits:
+        console.print(f"[green]✓ No commits by {user_email} to shift ({len(commit_infos)} commits checked)[/green]")
+        return
+
+    # Compute shifts
+    shifted = compute_shifts(my_commits, config)
+
+    # Show preview
+    changed = [s for s in shifted if s.changed]
+    first_changed_idx = next((i for i, s in enumerate(shifted) if s.changed), len(shifted))
+
+    # Report header
+    console.print()
+    console.print(Panel(f"Cleaning: [bold]{repo_path.name}[/bold]", expand=False))
+    console.print()
+    header = Table(box=None, show_header=False, padding=(0, 1))
+    header.add_column(style="bold")
+    header.add_column()
+    header.add_row(
+        "Work hours",
+        f"{config.work_start.strftime('%H:%M')}..{config.work_end.strftime('%H:%M')} {format_work_days(config.work_days)}",
+    )
+    header.add_row("Night hours", f"{config.night_start.strftime('%H:%M')}..{config.night_end.strftime('%H:%M')}")
+    if config.holidays_country:
+        header.add_row("Holidays", config.holidays_country)
+    if config.pto_dates:
+        header.add_row("PTO", f"{len(config.pto_dates)} days")
+    if config.local_only:
+        header.add_row("Local only", "yes")
+    header.add_row("Author", user_email)
+    skipped_parts = [f"{others_skipped} before exclusive tail"]
+    if pushed_skipped:
+        skipped_parts.append(f"{pushed_skipped} pushed")
+    skipped_parts.append(f"{first_changed_idx} OK")
+    header.add_row("Skipped", ", ".join(skipped_parts))
+    header.add_row("Shifting", f"{len(changed)} of {len(shifted)}")
+    console.print(header)
+    console.print()
+
+    if not changed:
+        console.print("[green]✓ Nothing to shift[/green]")
+        return
+
+    visible = shifted[first_changed_idx:]
+
+    table = Table(show_header=True)
+    table.add_column("Hash", style="cyan")
+    table.add_column("Original")
+    table.add_column("New")
+    table.add_column("Delta")
+
+    day_names = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
+    for s in visible:
+        orig_day = day_names[s.original_dt.weekday()]
+        new_day = day_names[s.new_dt.weekday()]
+
+        if s.changed:
+            delta = s.new_dt - s.original_dt
+            hours = int(delta.total_seconds() // 3600)
+            minutes = int((delta.total_seconds() % 3600) // 60)
+            delta_str = f"+{hours}h{minutes:02d}m"
+            orig_style = "red"
+            new_style = "green"
+        else:
+            delta_str = ""
+            orig_style = "dim"
+            new_style = "dim"
+
+        table.add_row(
+            s.id[:8],
+            f"[{orig_style}]{s.original_dt.strftime('%Y-%m-%d %H:%M')} ({orig_day})[/{orig_style}]",
+            f"[{new_style}]{s.new_dt.strftime('%Y-%m-%d %H:%M')} ({new_day})[/{new_style}]",
+            delta_str,
+        )
+
+    console.print(table)
+
+    if dry_run:
+        return
+
+    if not Confirm.ask(f"Rewrite {len(changed)} commits?", console=console):
+        console.print("[yellow]Aborted[/yellow]")
+        return
+
+    rewrite_history(repo_path, shifted, console)
+    console.print(f"[green]✓ Rewrote {len(changed)} commits[/green]")
+
+
+def rewrite_history(repo_path: Path, shifted: list, console: Console):
+    """Use git-filter-repo to rewrite author/committer dates."""
+    from git_filter_repo import FilteringOptions, RepoFilter
+
+    # Build lookup: original_id (bytes) → new datetime
+    lookup: dict[bytes, datetime] = {}
+    for s in shifted:
+        if s.changed:
+            lookup[s.id.encode()] = s.new_dt
+
+    def commit_callback(commit, callback_metadata):
+        original_id = commit.original_id
+        if original_id in lookup:
+            new_dt = lookup[original_id]
+            ts = int(new_dt.timestamp())
+            # Preserve original timezone offset — extract from existing date
+            existing = commit.author_date
+            # author_date is b"<unix_ts> <tz_offset>"
+            tz_offset = existing.split(b" ")[1]
+            new_date = f"{ts} ".encode() + tz_offset
+            commit.author_date = new_date
+            commit.committer_date = new_date
+
+    args = FilteringOptions.parse_args(["--force", "--quiet"])
+
+    # git-filter-repo requires cwd to be the repo
+    original_cwd = os.getcwd()
+    try:
+        os.chdir(repo_path)
+        repo_filter = RepoFilter(args, commit_callback=commit_callback)
+        repo_filter.run()
+    finally:
+        os.chdir(original_cwd)

secretside-0.1.0/src/secretside/commands/init.py

@@ -0,0 +1,104 @@
+import locale
+import random
+from datetime import date, timedelta
+from pathlib import Path
+from sys import exit
+from textwrap import dedent
+
+from click import argument, command, option
+from holidays import list_supported_countries
+from rich.console import Console
+from rich.prompt import Prompt
+
+
+def detect_country() -> str | None:
+    """Try to detect country from system locale."""
+    try:
+        loc = locale.getlocale()[0]  # e.g. "en_CA", "de_DE"
+        if loc and "_" in loc:
+            code = loc.split("_")[1].upper()
+            if code in list_supported_countries():
+                return code
+    except Exception:
+        pass
+    return None
+
+
+def prompt_country(console: Console) -> str:
+    """Ask the user to pick a country code."""
+    supported = sorted(list_supported_countries().keys())
+    console.print(f"[dim]Supported: {', '.join(supported)}[/dim]")
+    while True:
+        code = Prompt.ask("Country code for public holidays").strip().upper()
+        if code in supported:
+            return code
+        console.print(f"[red]Unknown country code: {code}[/red]")
+
+
+def jittered_time(base_hour: int, base_minute: int, jitter: int = 30) -> str:
+    """Return HH:MM with random jitter applied to the minute offset."""
+    total_minutes = base_hour * 60 + base_minute + random.randint(-jitter, jitter)
+    total_minutes = max(0, min(total_minutes, 23 * 60 + 59))
+    h, m = divmod(total_minutes, 60)
+    return f"{h:02d}:{m:02d}"
+
+
+def last_friday(today: date | None = None) -> date:
+    """Return the most recent Friday on or before today."""
+    today = today or date.today()
+    days_since_friday = (today.weekday() - 4) % 7
+    return today - timedelta(days=days_since_friday)
+
+
+def generate_config(country: str) -> str:
+    work_start = jittered_time(9, 0)
+    work_end = jittered_time(17, 30)
+    night_start = jittered_time(23, 0)
+    night_end = jittered_time(6, 0)
+    friday = last_friday()
+
+    return dedent(f"""\
+        holidays = "{country}"
+        work_days = "mon-fri"
+        work_hours = "{work_start}..{work_end}"
+        night_hours = "{night_start}..{night_end}"
+        local_only = true
+        banned = [
+            # ["Your Real Name", "real@email.com"],
+            # ["Your Real Name", "work@company.com"],
+        ]
+        pto = [
+            # "{friday.isoformat()}",
+        ]
+    """)
+
+
+@command("init", short_help="Initialize secretside.toml in a repository")
+@option("--country", default=None, help="Country code for public holidays (e.g. CA, GB, US)")
+@option("--force", is_flag=True, default=False, help="Overwrite existing secretside.toml")
+@argument("repo", required=False, default=".")
+def init(repo: str, country: str | None, force: bool):
+    """Generate a secretside.toml with sensible, slightly randomized defaults."""
+    console = Console()
+    repo_path = Path(repo).resolve()
+
+    if not (repo_path / ".git").exists():
+        console.print(f"[red]Error: {repo_path} is not a git repository[/red]")
+        exit(1)
+
+    config_path = repo_path / "secretside.toml"
+    if config_path.exists() and not force:
+        console.print(f"[red]Error: {config_path} already exists (use --force to overwrite)[/red]")
+        exit(1)
+
+    if not country:
+        country = detect_country()
+        if country:
+            console.print(f"[dim]Detected country: {country}[/dim]")
+        else:
+            country = prompt_country(console)
+
+    content = generate_config(country)
+    config_path.write_text(content)
+    console.print(f"[green]Wrote {config_path}[/green]")
+    console.print(f"[dim]{content}[/dim]", end="")

secretside-0.1.0/src/secretside/config.py

@@ -0,0 +1,76 @@
+from datetime import date, datetime, time
+
+from holidays import country_holidays
+
+DAY_NAMES = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"]
+DEFAULT_WORK_DAYS = {0, 1, 2, 3, 4}  # mon-fri
+
+
+def parse_work_days(spec: str) -> set[int]:
+    """Parse a work_days spec like 'mon-thu', 'mon-wed,fri', 'mon,wed,fri' into weekday ints."""
+    result = set()
+    for part in spec.split(","):
+        part = part.strip().lower()
+        if "-" in part:
+            start, end = part.split("-", 1)
+            start_idx = DAY_NAMES.index(start.strip())
+            end_idx = DAY_NAMES.index(end.strip())
+            if end_idx < start_idx:
+                raise ValueError(f"Invalid range: {part}")
+            result.update(range(start_idx, end_idx + 1))
+        else:
+            result.add(DAY_NAMES.index(part))
+
+    return result
+
+
+def format_work_days(days: set[int]) -> str:
+    """Format weekday ints back to a compact string like 'mon-thu' or 'mon-wed,fri'."""
+    if not days:
+        return ""
+    sorted_days = sorted(days)
+    ranges = []
+    start = prev = sorted_days[0]
+    for d in sorted_days[1:]:
+        if d == prev + 1:
+            prev = d
+        else:
+            ranges.append((start, prev))
+            start = prev = d
+    ranges.append((start, prev))
+    parts = []
+    for s, e in ranges:
+        if s == e:
+            parts.append(DAY_NAMES[s])
+        else:
+            parts.append(f"{DAY_NAMES[s]}-{DAY_NAMES[e]}")
+    return ",".join(parts)
+
+
+class Config:
+    """Configuration for secretside analysis."""
+
+    def __init__(
+        self,
+        work_start: time | None = None,
+        work_end: time | None = None,
+        night_start: time | None = None,
+        night_end: time | None = None,
+        pto_dates: set[date] | None = None,
+        holidays_country: str | None = None,
+        banned: list[tuple[str, str]] | None = None,
+        work_days: set[int] | None = None,
+        local_only: bool = False,
+    ):
+        self.work_start = work_start or datetime.strptime("09:30", "%H:%M").time()
+        self.work_end = work_end or datetime.strptime("18:30", "%H:%M").time()
+        self.night_start = night_start or datetime.strptime("00:00", "%H:%M").time()
+        self.night_end = night_end or datetime.strptime("07:00", "%H:%M").time()
+        self.holidays_country = holidays_country
+        self.pto_dates = pto_dates or set()
+        self.holiday_list = country_holidays(holidays_country) if holidays_country else set()
+        self.banned = banned or []
+        self.banned_names = {name.lower() for name, _ in self.banned}
+        self.banned_emails = {email.lower() for _, email in self.banned}
+        self.work_days = work_days if work_days is not None else DEFAULT_WORK_DAYS
+        self.local_only = local_only

secretside-0.1.0/src/secretside/shift.py

@@ -0,0 +1,180 @@
+from dataclasses import dataclass
+from datetime import datetime, time, timedelta
+from enum import Enum
+
+from secretside.config import Config
+
+
+@dataclass
+class CommitInfo:
+    id: str
+    timestamp: datetime
+    author_email: str = ""
+
+
+@dataclass
+class ShiftedCommit:
+    id: str
+    original_dt: datetime
+    new_dt: datetime
+
+    @property
+    def changed(self) -> bool:
+        return self.original_dt != self.new_dt
+
+
+class CommitCategory(Enum):
+    WORK = "work"
+    NIGHT = "night"
+    FREE_HOLIDAY = "free_holiday"
+    FREE_WEEKEND = "free_weekend"
+    FREE_WEEKDAY = "free_weekday"
+
+
+def categorize_datetime(dt: datetime, config: Config) -> CommitCategory:
+    d = dt.date()
+    t = dt.time()
+    is_day_off = dt.weekday() not in config.work_days
+    is_holiday = d in config.holiday_list
+    is_pto = d in config.pto_dates
+
+    is_work_hours = config.work_start <= t < config.work_end
+
+    is_night = False
+    if config.night_start <= config.night_end:
+        is_night = config.night_start <= t <= config.night_end
+    else:
+        is_night = t >= config.night_start or t <= config.night_end
+
+    if is_day_off:
+        return CommitCategory.FREE_WEEKEND
+    if is_holiday or is_pto:
+        return CommitCategory.FREE_HOLIDAY
+    if is_work_hours:
+        return CommitCategory.WORK
+    if is_night:
+        return CommitCategory.NIGHT
+    return CommitCategory.FREE_WEEKDAY
+
+
+def _is_night_time(t: time, config: Config) -> bool:
+    """Check if a clock time falls in night hours, independent of day type."""
+    if config.night_start <= config.night_end:
+        return config.night_start <= t <= config.night_end
+    else:
+        return t >= config.night_start or t <= config.night_end
+
+
+def place_in_valid_slot(dt: datetime, original_minutes: int, config: Config, avoid_night: bool = True) -> datetime:
+    """Move dt out of work hours (on workdays) and optionally night hours. Loops max 14 iterations."""
+    for _ in range(14):
+        cat = categorize_datetime(dt, config)
+        # Night check uses the clock directly — categorize_datetime masks it on holidays/weekends
+        is_night = _is_night_time(dt.time(), config)
+
+        if cat == CommitCategory.WORK:
+            # Jump to work_end + original_minutes
+            base = dt.replace(hour=config.work_end.hour, minute=config.work_end.minute, second=0, microsecond=0)
+            dt = base + timedelta(minutes=original_minutes)
+        elif is_night and avoid_night:
+            # Shift out of night regardless of day type (holiday, weekend, etc.)
+            if config.night_start > config.night_end:
+                if dt.time() >= config.night_start:
+                    next_day = dt.date() + timedelta(days=1)
+                    base = datetime.combine(next_day, config.night_end, dt.tzinfo)
+                else:
+                    base = dt.replace(
+                        hour=config.night_end.hour, minute=config.night_end.minute, second=0, microsecond=0
+                    )
+            else:
+                base = dt.replace(hour=config.night_end.hour, minute=config.night_end.minute, second=0, microsecond=0)
+            dt = base + timedelta(minutes=original_minutes)
+        else:
+            return dt
+
+    return dt
+
+
+def find_user_tail(commits: list[CommitInfo], user_email: str) -> int:
+    """Return the index where the contiguous tail of user's commits begins.
+
+    Walks backwards from the end; stops at the first commit by someone else.
+    Returns len(commits) if no user commits are at the tail.
+    """
+    tail_start = len(commits)
+    for i in range(len(commits) - 1, -1, -1):
+        if commits[i].author_email.lower() == user_email.lower():
+            tail_start = i
+        else:
+            break
+    return tail_start
+
+
+def find_unpushed_tail(commits: list[CommitInfo], pushed_oids: set[str]) -> int:
+    """Return the index where the contiguous tail of unpushed commits begins.
+
+    Walks backwards from the end; stops at the first pushed commit.
+    Returns len(commits) if all commits are pushed.
+    """
+    tail_start = len(commits)
+    for i in range(len(commits) - 1, -1, -1):
+        if commits[i].id in pushed_oids:
+            break
+        tail_start = i
+    return tail_start
+
+
+def compute_shifts(commits: list[CommitInfo], config: Config) -> list[ShiftedCommit]:
+    """
+    Compute shifted timestamps for commits, moving work-hour and night-hour commits
+    to valid slots while preserving relative gaps and enforcing monotonicity.
+
+    Commits must be in chronological order (oldest first).
+    """
+    results: list[ShiftedCommit] = []
+    # accumulated delta per original date — the max shift applied to commits on that date
+    delta: dict = {}  # date -> timedelta
+
+    for i, commit in enumerate(commits):
+        original_dt = commit.timestamp
+        original_date = original_dt.date()
+        original_minutes = original_dt.minute
+
+        # Night is only restricted for commits that weren't originally at night.
+        # Use clock check directly — categorize_datetime masks night on holidays/weekends.
+        avoid_night = not _is_night_time(original_dt.time(), config)
+
+        # 1. Apply accumulated delta for this original date
+        base_delta = delta.get(original_date, timedelta(0))
+        candidate = original_dt + base_delta
+
+        # 2. Place in valid slot
+        candidate = place_in_valid_slot(candidate, original_minutes, config, avoid_night)
+
+        # 3. Enforce monotonicity
+        if results:
+            prev = results[-1]
+            if candidate <= prev.new_dt:
+                prev_original_minutes = prev.original_dt.minute
+                # Check if this is a cross-day collision (overflow from different original date)
+                if prev.original_dt.date() != original_date:
+                    # Cross-day: gap = prev original minutes + current original minutes
+                    gap = timedelta(minutes=prev_original_minutes + original_minutes)
+                else:
+                    # Same day: preserve original gap between commits
+                    gap = original_dt - prev.original_dt
+                    if gap <= timedelta(0):
+                        gap = timedelta(minutes=1)
+
+                candidate = prev.new_dt + gap
+                # Re-place after gap adjustment
+                candidate = place_in_valid_slot(candidate, original_minutes, config, avoid_night)
+
+        # 4. Update accumulated delta for this original date
+        new_delta = candidate - original_dt
+        if new_delta > delta.get(original_date, timedelta(0)):
+            delta[original_date] = new_delta
+
+        results.append(ShiftedCommit(id=commit.id, original_dt=original_dt, new_dt=candidate))
+
+    return results

secretside-0.1.0/src/secretside/utils.py

@@ -0,0 +1,189 @@
+from datetime import datetime, timedelta, timezone
+from functools import wraps
+from pathlib import Path
+from sys import exit
+from tomllib import TOMLDecodeError
+from tomllib import load as tomlload
+
+from click import Group
+from pygit2 import Commit
+from rich.console import Console
+
+from secretside.config import DEFAULT_WORK_DAYS, Config, parse_work_days
+from secretside.shift import categorize_datetime
+
+
+class SSCommit:
+    def __init__(
+        self,
+        commit: Commit,
+        config: Config,
+    ):
+        self.commit = commit
+        self.config = config
+        self.author_time = datetime.fromtimestamp(commit.author.time, tz=timezone.utc).astimezone()
+        self.commit_time = datetime.fromtimestamp(commit.commit_time, tz=timezone.utc).astimezone()
+        self.when = min(self.author_time, self.commit_time)
+        self.category = self.categorize()
+
+    def categorize(self):
+        return categorize_datetime(self.when, self.config)
+
+    @property
+    def hash(self):
+        return str(self.commit.id)[:8]
+
+    @property
+    def message(self):
+        return self.commit.message
+
+    @property
+    def subject(self):
+        return self.commit.message.split("\n")[0][:50]
+
+    @property
+    def author(self):
+        return self.commit.author
+
+
+class FuzzyCommandGroup(Group):
+    aliases = {}
+
+    def get_command(self, ctx, cmd_name):
+        rv = Group.get_command(self, ctx, cmd_name)
+        if rv is not None:
+            return rv
+
+        # fuzzy matching
+        matches = []
+        for command in self.list_commands(ctx) + list(self.aliases.keys()):
+            if command.startswith(cmd_name.lower()):
+                if command in self.aliases:
+                    matches.append(self.aliases[command])
+                else:
+                    matches.append(command)
+
+        if len(matches) == 1:
+            return Group.get_command(self, ctx, matches[0])
+        elif len(matches) > 1:
+            ctx.fail(f"Ambiguous command: {cmd_name}. Could be: {', '.join(matches)}")
+        else:
+            ctx.fail(f"No such command: {cmd_name}")
+
+
+def configure(f):
+    """Decorator that loads secretside.toml and injects a Config object as the first argument."""
+
+    @wraps(f)
+    def wrapper(*args, **kwargs):
+        repo_path = None
+        if "repo" in kwargs:
+            repo_path = Path(kwargs["repo"]).resolve()
+
+        config = build_config(repo_path)
+        return f(config, *args, **kwargs)
+
+    return wrapper
+
+
+def load_config_file(repo_path: Path) -> dict:
+    """Load config from secretside.toml in the repo directory."""
+    config_path = repo_path / "secretside.toml"
+    if not config_path.exists():
+        return {}
+
+    try:
+        with open(config_path, "rb") as f:
+            return tomlload(f)
+    except TOMLDecodeError as e:
+        console = Console()
+        console.print(f"[yellow]Warning: Invalid TOML in {config_path}: {e}[/yellow]")
+        return {}
+    except Exception as e:
+        console = Console()
+        console.print(f"[yellow]Warning: Could not read {config_path}: {e}[/yellow]")
+        return {}
+
+
+def build_config(repo_path: Path | None) -> Config:
+    """Build Config object from secretside.toml (if present) with hardcoded defaults as fallback."""
+    console = Console()
+
+    file_config = {}
+    if repo_path:
+        file_config = load_config_file(repo_path)
+
+    # Work hours
+    work_start = "09:30"
+    work_end = "18:30"
+    if file_config.get("work_hours") and ".." in file_config["work_hours"]:
+        work_start, work_end = file_config["work_hours"].split("..")
+
+    # Night hours
+    night_start = "00:00"
+    night_end = "07:00"
+    if file_config.get("night_hours") and ".." in file_config["night_hours"]:
+        night_start, night_end = file_config["night_hours"].split("..")
+
+    # Holidays
+    holidays_country = file_config.get("holidays")
+
+    # Banned identities — list of [name, email] pairs
+    banned = []
+    for entry in file_config.get("banned", []):
+        if isinstance(entry, (list, tuple)) and len(entry) == 2:
+            banned.append((entry[0], entry[1]))
+        else:
+            console.print(f"[yellow]Warning: Invalid banned entry: {entry} (expected [name, email])[/yellow]")
+
+    # local_only flag
+    local_only = file_config.get("local_only", False)
+
+    # Work days
+    work_days = DEFAULT_WORK_DAYS
+    if file_config.get("work_days"):
+        try:
+            work_days = parse_work_days(file_config["work_days"])
+        except (ValueError, IndexError):
+            console.print(f"[yellow]Warning: Invalid work_days in config: {file_config['work_days']}[/yellow]")
+
+    # PTO dates
+    pto_dates = set()
+    for pto_spec in file_config.get("pto", []):
+        try:
+            if ".." in pto_spec:
+                start_str, end_str = pto_spec.split("..")
+                start_date = datetime.strptime(start_str.strip(), "%Y-%m-%d").date()
+                end_date = datetime.strptime(end_str.strip(), "%Y-%m-%d").date()
+                current_date = start_date
+                while current_date <= end_date:
+                    pto_dates.add(current_date)
+                    current_date = current_date + timedelta(days=1)
+            else:
+                pto_dates.add(datetime.strptime(pto_spec, "%Y-%m-%d").date())
+        except ValueError:
+            console.print(
+                f"[yellow]Warning: Invalid PTO date format: {pto_spec} (use YYYY-MM-DD or YYYY-MM-DD..YYYY-MM-DD)[/yellow]"
+            )
+
+    # Parse time strings
+    try:
+        work_start_time = datetime.strptime(work_start, "%H:%M").time()
+        work_end_time = datetime.strptime(work_end, "%H:%M").time()
+        night_start_time = datetime.strptime(night_start, "%H:%M").time()
+        night_end_time = datetime.strptime(night_end, "%H:%M").time()
+    except ValueError:
+        console.print("[red]Error: Invalid time format in config. Use HH:MM format.[/red]")
+        exit(1)
+
+    return Config(
+        holidays_country=holidays_country,
+        pto_dates=pto_dates,
+        work_start=work_start_time,
+        work_end=work_end_time,
+        night_start=night_start_time,
+        night_end=night_end_time,
+        banned=banned,
+        work_days=work_days,
+        local_only=local_only,
+    )