gitgotchi 0.3.0__tar.gz → 0.3.1__tar.gz

{gitgotchi-0.3.0 → gitgotchi-0.3.1}/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 0.3.1
+
+### Fixed
+
+- **Security:** GitGotchi loaded every variable from a repo's `.env` file, so a cloned repo could
+  inject git settings and run commands during `gitgotchi seance`. Now only `ANTHROPIC_API_KEY` is read.
+- AI-agent detection no longer flags people: co-authors at Anthropic, OpenAI or Gemini, anyone named
+  Cline, or messages that merely mention ChatGPT. It now matches agent noreply addresses and bot accounts.
+- The pet now lives in `.git/gitgotchi/`, so every worktree of a repo shares one pet (agents often
+  commit from worktrees). Existing pets are moved there automatically.
+- `haunt` watches every local branch, doesn't feed commits that arrive by pull, groups bursts of
+  commits into one reaction, keeps running through a busy database, and no longer crashes on
+  brackets in commit messages.
+- Amending a commit no longer counts it again.
+- Running `adopt` while a commit is being processed could lose an update; writes are now atomic.
+- `adopt` on an existing pet no longer puts it to sleep.
+- The séance handles non-ASCII file names, renamed files, and more TODOs in big repos; the
+  witching hour uses each author's own timezone.
+- Petting a dormant pet now really wakes it, and friendship grows even while it sleeps.
+- The hook works when Python's path contains spaces or shell characters, runs before any `exit` in
+  an existing hook, and refuses to edit non-shell hooks.
+- Repos in folders with `?` or `%` in their path work.
+- `gitgotchi name` rejects empty and very long names; `card` reports the size it actually saved;
+  `adopt --limit` must be at least 1.
+- Requires `typer>=0.15.4`: older versions crash with current `click`.
+
 ## 0.3.0 - Halloween
 
 ### New

{gitgotchi-0.3.0 → gitgotchi-0.3.1}/MANIFEST.in

@@ -7,3 +7,4 @@ global-exclude __pycache__
 global-exclude *.py[co]
 prune docs
 prune previews
+prune site

{gitgotchi-0.3.0 → gitgotchi-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitgotchi
-Version: 0.3.0
+Version: 0.3.1
 Summary: A 3D pixel-art Halloween spirit that haunts your git repo and reacts as you (and your AI agents) commit
 Author-email: M K Sai Srikar <Srikarmks@gmail.com>
 License-Expression: MIT
@@ -28,7 +28,7 @@ Requires-Dist: rich>=13.7.0
 Requires-Dist: gitpython>=3.1.40
 Requires-Dist: anthropic>=1.0.0
 Requires-Dist: sqlalchemy>=2.0.36
-Requires-Dist: typer>=0.12.0
+Requires-Dist: typer>=0.15.4
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: numpy>=1.24
 Provides-Extra: dev
@@ -73,7 +73,9 @@ gitgotchi haunt     # open the live pane
 ```
 
 Keep `gitgotchi haunt` open in a split next to the terminal where you or your agent are working. Every
-commit gets a reaction, agent commits glitch the screen, and evolutions play out live.
+commit gets a reaction, agent commits glitch the screen, and evolutions play out live. It watches every
+local branch, so it sees commits from other worktrees too. Commits that arrive by `git pull` aren't yours,
+so they don't feed your companion.
 
 ![The haunt pane reacting to commits](https://raw.githubusercontent.com/Srikarmk/Gitgotchi/main/docs/haunt.gif)
 
@@ -106,7 +108,9 @@ gitgotchi seance
 Your companion digs through the history for its ghosts: the oldest TODO still in the code, the file
 nobody has opened in ages, the biggest deletion, commits made between midnight and 4am, and the first
 commit an AI agent wrote. Then it tells you a story about them. Set `ANTHROPIC_API_KEY` (or put it in a
-`.env` file) to have Claude tell it; otherwise your companion tells it in its own words.
+`.env` file) to have Claude tell it; otherwise your companion tells it in its own words. With a key set,
+the findings (file names, TODO text and recent commit messages) are sent to the Anthropic API to write the
+story. GitGotchi reads only `ANTHROPIC_API_KEY` from `.env` and ignores everything else in it.
 
 ## 🎮 All commands
 
@@ -158,8 +162,9 @@ also shows the image inline in terminals that support it. Set `GITGOTCHI_GRAPHIC
 
 ## 🗂️ Where state lives
 
-Your companion is stored in `.gitgotchi/state.db` at the root of the repository. GitGotchi adds
-`.gitgotchi/` to `.git/info/exclude`, so it never shows up in `git status` and is never committed.
+Your companion lives in `.git/gitgotchi/state.db`, inside the repository's git directory. It never
+shows up in `git status`, can't be committed, and every `git worktree` of the repo shares the same pet, so
+commits your agents make in their own worktrees count too.
 
 ## 🛠️ Development
 

{gitgotchi-0.3.0 → gitgotchi-0.3.1}/README.md

@@ -32,7 +32,9 @@ gitgotchi haunt     # open the live pane
 ```
 
 Keep `gitgotchi haunt` open in a split next to the terminal where you or your agent are working. Every
-commit gets a reaction, agent commits glitch the screen, and evolutions play out live.
+commit gets a reaction, agent commits glitch the screen, and evolutions play out live. It watches every
+local branch, so it sees commits from other worktrees too. Commits that arrive by `git pull` aren't yours,
+so they don't feed your companion.
 
 ![The haunt pane reacting to commits](https://raw.githubusercontent.com/Srikarmk/Gitgotchi/main/docs/haunt.gif)
 
@@ -65,7 +67,9 @@ gitgotchi seance
 Your companion digs through the history for its ghosts: the oldest TODO still in the code, the file
 nobody has opened in ages, the biggest deletion, commits made between midnight and 4am, and the first
 commit an AI agent wrote. Then it tells you a story about them. Set `ANTHROPIC_API_KEY` (or put it in a
-`.env` file) to have Claude tell it; otherwise your companion tells it in its own words.
+`.env` file) to have Claude tell it; otherwise your companion tells it in its own words. With a key set,
+the findings (file names, TODO text and recent commit messages) are sent to the Anthropic API to write the
+story. GitGotchi reads only `ANTHROPIC_API_KEY` from `.env` and ignores everything else in it.
 
 ## 🎮 All commands
 
@@ -117,8 +121,9 @@ also shows the image inline in terminals that support it. Set `GITGOTCHI_GRAPHIC
 
 ## 🗂️ Where state lives
 
-Your companion is stored in `.gitgotchi/state.db` at the root of the repository. GitGotchi adds
-`.gitgotchi/` to `.git/info/exclude`, so it never shows up in `git status` and is never committed.
+Your companion lives in `.git/gitgotchi/state.db`, inside the repository's git directory. It never
+shows up in `git status`, can't be committed, and every `git worktree` of the repo shares the same pet, so
+commits your agents make in their own worktrees count too.
 
 ## 🛠️ Development
 

{gitgotchi-0.3.0 → gitgotchi-0.3.1}/pyproject.toml

@@ -44,7 +44,7 @@ dependencies = [
     "gitpython>=3.1.40",
     "anthropic>=1.0.0",
     "sqlalchemy>=2.0.36",
-    "typer>=0.12.0",
+    "typer>=0.15.4",
     "python-dotenv>=1.0.0",
     "numpy>=1.24",
 ]

{gitgotchi-0.3.0 → gitgotchi-0.3.1}/src/gitgotchi/__init__.py

@@ -1,3 +1,3 @@
 """GitGotchi - A Halloween-inspired terminal companion for your git repository."""
 
-__version__ = "0.3.0"
+__version__ = "0.3.1"

{gitgotchi-0.3.0 → gitgotchi-0.3.1}/src/gitgotchi/cli.py

@@ -1,10 +1,11 @@
 """Main CLI interface."""
+import os
 import random
 from pathlib import Path
 from typing import Optional
 
 import typer
-from dotenv import find_dotenv, load_dotenv
+from dotenv import dotenv_values, find_dotenv
 from rich.panel import Panel
 from rich.table import Table
 from rich.text import Text
@@ -24,10 +25,24 @@ app = typer.Typer(
 
 def cli():
     """Entry point for console script."""
-    load_dotenv(find_dotenv(usecwd=True))
+    load_api_key()
     app()
 
 
+def load_api_key() -> None:
+    """Pick up ANTHROPIC_API_KEY from a .env file if it isn't already set.
+
+    Only that one variable is read: a repo's .env could otherwise inject
+    settings such as GIT_CONFIG_* into the git commands GitGotchi runs.
+    """
+    if os.environ.get("ANTHROPIC_API_KEY"):
+        return
+    path = find_dotenv(usecwd=True)
+    key = dotenv_values(path).get("ANTHROPIC_API_KEY") if path else None
+    if key:
+        os.environ["ANTHROPIC_API_KEY"] = key
+
+
 def load_state() -> StateManager:
     try:
         return StateManager()
@@ -106,6 +121,9 @@ def pet():
         raise typer.Exit(1)
 
 
+MAX_NAME_LENGTH = 30
+
+
 @app.command()
 def name(new_name: str):
     """Give your companion a name."""
@@ -113,6 +131,11 @@ def name(new_name: str):
         state_manager = load_state()
         pet_stats = state_manager.get_pet_state()
 
+        new_name = " ".join(new_name.split())
+        if not new_name or len(new_name) > MAX_NAME_LENGTH:
+            render_error(f"Names need between 1 and {MAX_NAME_LENGTH} characters.")
+            raise typer.Exit(1)
+
         old_name = pet_stats.pet_name
         pet_stats.pet_name = new_name
         state_manager.save_pet_state(pet_stats)
@@ -245,7 +268,7 @@ def story():
 
 @app.command()
 def adopt(
-    limit: Optional[int] = typer.Option(None, help="Only replay the most recent N commits"),
+    limit: Optional[int] = typer.Option(None, min=1, help="Only replay the most recent N commits"),
     reset: bool = typer.Option(False, "--reset", help="Start the pet over before replaying"),
 ):
     """Raise your companion on this repo's existing history."""
@@ -308,7 +331,8 @@ def card(
     repo_name = Path(require_repo().working_tree_dir).name
 
     image = make_card(stats, repo_name, state_manager.agent_counts())
-    output.write_bytes(encode_png(upscale(image, max(1, min(12, scale)))))
+    scale = max(1, min(12, scale))
+    output.write_bytes(encode_png(upscale(image, scale)))
 
     protocol = graphics_protocol()
     if protocol and console.is_terminal:

{gitgotchi-0.3.0 → gitgotchi-0.3.1}/src/gitgotchi/db/models.py

@@ -2,7 +2,8 @@
 from datetime import datetime
 from typing import Optional
 
-from sqlalchemy import Float, Integer, String, Text, create_engine, inspect, text
+from sqlalchemy import Float, Integer, String, Text, create_engine, event, inspect, text
+from sqlalchemy.engine import URL, Engine
 from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
 
 
@@ -28,6 +29,7 @@ class PetState(Base):
     evolution_points: Mapped[int] = mapped_column(Integer, default=0)
     friend_level: Mapped[float] = mapped_column(Float, default=1.0)
     ai_commits: Mapped[int] = mapped_column(Integer, default=0)
+    last_visit: Mapped[Optional[datetime]] = mapped_column(nullable=True)
     last_fed: Mapped[datetime] = mapped_column(default=datetime.now)
     current_mood: Mapped[str] = mapped_column(String(20), default="content")
     current_form: Mapped[str] = mapped_column(String(20), default="egg")
@@ -72,25 +74,31 @@ class StoryMemory(Base):
     tokens_used: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
 
 
-def get_engine(db_path: str = ".gitgotchi/state.db"):
-    """Create database engine.
+def get_engine(db_path: str) -> Engine:
+    """Create the database engine.
 
-    Args:
-        db_path: Path to SQLite database file
-
-    Returns:
-        SQLAlchemy engine instance
+    Every transaction takes SQLite's write lock up front (BEGIN IMMEDIATE),
+    so the hook, haunt and adopt can't interleave a read-modify-write of the
+    pet and lose an update. Waiters retry for up to 15 seconds.
     """
-    return create_engine(f"sqlite:///{db_path}", echo=False)
+    engine = create_engine(
+        URL.create("sqlite", database=str(db_path)),
+        connect_args={"timeout": 15},
+    )
 
+    @event.listens_for(engine, "connect")
+    def _no_implicit_transactions(dbapi_connection, _record):
+        dbapi_connection.isolation_level = None
 
-def init_db(db_path: str = ".gitgotchi/state.db") -> None:
-    """Initialize database schema.
+    @event.listens_for(engine, "begin")
+    def _begin_immediate(conn):
+        conn.exec_driver_sql("BEGIN IMMEDIATE")
 
-    Args:
-        db_path: Path to SQLite database file
-    """
-    engine = get_engine(db_path)
+    return engine
+
+
+def init_db(engine: Engine) -> None:
+    """Create the schema, upgrading older databases in place."""
     Base.metadata.create_all(engine)
     add_missing_columns(engine)
 
@@ -99,13 +107,16 @@ def init_db(db_path: str = ".gitgotchi/state.db") -> None:
 ADDED_COLUMNS = [
     ("pet_state", "ai_commits", "INTEGER NOT NULL DEFAULT 0"),
     ("commit_history", "agent", "VARCHAR(50)"),
+    ("pet_state", "last_visit", "DATETIME"),
 ]
 
 
 def add_missing_columns(engine) -> None:
     """Upgrade databases created by older versions in place."""
-    inspector = inspect(engine)
+    # Inspect on the same connection: every transaction holds the write lock,
+    # so a second connection would wait on this one
     with engine.begin() as conn:
+        inspector = inspect(conn)
         for table, column, ddl in ADDED_COLUMNS:
             existing = {c["name"] for c in inspector.get_columns(table)}
             if column not in existing:

gitgotchi-0.3.1/src/gitgotchi/db/state_manager.py

@@ -0,0 +1,311 @@
+"""State management for pet persistence."""
+from collections import Counter
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, Iterable, List, Optional, Sequence
+
+from sqlalchemy import func
+from sqlalchemy.orm import Session
+
+from gitgotchi.db.models import (
+    CommitHistory,
+    PetState,
+    StoryMemory,
+    get_engine,
+    init_db,
+)
+from gitgotchi.paths import require_repo, state_db_path
+from gitgotchi.pet.possession import detect_agent
+from gitgotchi.pet.states import PetForm, PetMood, PetStats
+
+if TYPE_CHECKING:
+    from gitgotchi.history import HistoryCommit
+
+
+class StateManager:
+    """Manages pet state persistence and retrieval."""
+
+    def __init__(self, db_path: Optional[str] = None) -> None:
+        """Initialize state manager.
+
+        Args:
+            db_path: Path to SQLite database file. Defaults to the pet of
+                the git repo containing the current directory.
+        """
+        if db_path is None:
+            db_path = str(state_db_path(require_repo()))
+        self.db_path = db_path
+        Path(db_path).parent.mkdir(parents=True, exist_ok=True)
+        self.engine = get_engine(db_path)
+        init_db(self.engine)
+
+    def close(self) -> None:
+        """Release the database file (needed before deleting it on Windows)."""
+        self.engine.dispose()
+
+    @staticmethod
+    def _row(session: Session) -> PetState:
+        pet_state = session.query(PetState).first()
+        if pet_state is None:
+            pet_state = PetState()
+            session.add(pet_state)
+            session.flush()
+        return pet_state
+
+    @staticmethod
+    def _to_stats(pet_state: PetState) -> PetStats:
+        stats = PetStats()
+        stats.pet_name = pet_state.pet_name
+        stats.total_commits = pet_state.total_commits
+        stats.lines_added = pet_state.lines_added
+        stats.lines_deleted = pet_state.lines_deleted
+        stats.merge_conflicts = pet_state.merge_conflicts
+        stats.reverts = pet_state.reverts
+        stats.quality_score = pet_state.quality_score
+        stats.evolution_points = pet_state.evolution_points
+        stats.friend_level = pet_state.friend_level
+        stats.last_fed = pet_state.last_fed
+        stats.last_visit = pet_state.last_visit
+        stats.current_mood = PetMood(pet_state.current_mood)
+        stats.current_form = PetForm(pet_state.current_form)
+        stats.created_at = pet_state.created_at
+        stats.ai_commits = pet_state.ai_commits or 0
+        return stats
+
+    @staticmethod
+    def _write(pet_state: PetState, stats: PetStats) -> None:
+        pet_state.pet_name = stats.pet_name
+        pet_state.total_commits = stats.total_commits
+        pet_state.lines_added = stats.lines_added
+        pet_state.lines_deleted = stats.lines_deleted
+        pet_state.merge_conflicts = stats.merge_conflicts
+        pet_state.reverts = stats.reverts
+        pet_state.quality_score = stats.quality_score
+        pet_state.evolution_points = stats.evolution_points
+        pet_state.friend_level = stats.friend_level
+        pet_state.ai_commits = stats.ai_commits
+        pet_state.created_at = stats.created_at
+        pet_state.last_fed = stats.last_fed
+        pet_state.last_visit = stats.last_visit
+        pet_state.current_mood = stats.current_mood.value
+        pet_state.current_form = stats.current_form.value
+        pet_state.updated_at = datetime.now()
+
+    def get_pet_state(self) -> PetStats:
+        """Load current pet state from database.
+
+        Returns:
+            PetStats instance with current state
+        """
+        with Session(self.engine) as session:
+            stats = self._to_stats(self._row(session))
+            session.commit()
+
+        stats.update_mood()
+        return stats
+
+    def save_pet_state(self, stats: PetStats) -> None:
+        """Save pet state to database.
+
+        Args:
+            stats: PetStats instance to persist
+        """
+        with Session(self.engine) as session:
+            self._write(self._row(session), stats)
+            session.commit()
+
+    def has_commit(self, commit_hash: str) -> bool:
+        """Check whether a commit has already been processed."""
+        with Session(self.engine) as session:
+            return (
+                session.query(CommitHistory)
+                .filter_by(commit_hash=commit_hash)
+                .first()
+                is not None
+            )
+
+    def reset(self) -> None:
+        """Start the pet over from a pumpkin, keeping its name."""
+        name = self.get_pet_state().pet_name
+        with Session(self.engine) as session:
+            session.query(CommitHistory).delete()
+            session.query(StoryMemory).delete()
+            session.query(PetState).delete()
+            session.add(PetState(pet_name=name))
+            session.commit()
+
+    def replay_history(self, commits: Iterable["HistoryCommit"]) -> "Replay":
+        """Feed a batch of past commits (oldest first) in one transaction."""
+        rows, agents = [], Counter()
+        first: Optional[datetime] = None
+        with Session(self.engine) as session:
+            pet_state = self._row(session)
+            stats = self._to_stats(pet_state)
+            was_new = stats.total_commits == 0
+            last_fed = stats.last_fed
+            known = {row[0] for row in session.query(CommitHistory.commit_hash)}
+
+            for c in commits:
+                if c.hexsha in known:
+                    continue
+                known.add(c.hexsha)
+                agent = detect_agent(c.message, c.author_name, c.author_email)
+                impact = stats.eat_commit(
+                    c.message, c.lines_added, c.lines_deleted, c.is_merge, c.is_revert,
+                    c.files, agent, when=c.timestamp,
+                )
+                if agent:
+                    agents[agent] += 1
+                first = first or c.timestamp
+                rows.append(
+                    CommitHistory(
+                        commit_hash=c.hexsha,
+                        author=f"{c.author_name} <{c.author_email}>",
+                        message=c.message,
+                        timestamp=c.timestamp,
+                        lines_added=c.lines_added,
+                        lines_deleted=c.lines_deleted,
+                        files_changed=len(c.files),
+                        is_merge=c.is_merge,
+                        is_revert=c.is_revert,
+                        quality_impact=impact,
+                        agent=agent,
+                    )
+                )
+
+            if not was_new:
+                # Old history mustn't make a pet that was fed today look starved
+                stats.last_fed = max(stats.last_fed, last_fed)
+            elif first:
+                stats.created_at = first
+            session.add_all(rows)
+            self._write(pet_state, stats)
+            session.commit()
+
+        stats.update_mood()
+        return Replay(stats=stats, count=len(rows), agents=agents, since=first)
+
+    def agent_counts(self) -> Counter:
+        """How many tracked commits each AI agent wrote."""
+        with Session(self.engine) as session:
+            rows = (
+                session.query(CommitHistory.agent, func.count())
+                .filter(CommitHistory.agent.isnot(None))
+                .group_by(CommitHistory.agent)
+                .all()
+            )
+            return Counter(dict(rows))
+
+    def get_recent_events(self, limit: int = 6) -> List[CommitHistory]:
+        """Most recent tracked commits, newest first."""
+        with Session(self.engine, expire_on_commit=False) as session:
+            return (
+                session.query(CommitHistory)
+                .order_by(CommitHistory.processed_at.desc(), CommitHistory.id.desc())
+                .limit(limit)
+                .all()
+            )
+
+    def replace_commit(self, old_hash: str, new_hash: str, message: str) -> bool:
+        """Point a tracked commit at its amended version.
+
+        Returns:
+            False if the old commit was never tracked
+        """
+        with Session(self.engine) as session:
+            row = session.query(CommitHistory).filter_by(commit_hash=old_hash).first()
+            if row is None:
+                return False
+            row.commit_hash = new_hash
+            row.message = message
+            session.commit()
+            return True
+
+    def get_recent_commits(self, limit: int = 5) -> List[str]:
+        """Most recent tracked commit messages, newest first."""
+        with Session(self.engine) as session:
+            rows = (
+                session.query(CommitHistory.message)
+                .order_by(CommitHistory.timestamp.desc())
+                .limit(limit)
+                .all()
+            )
+            return [row.message for row in rows]
+
+    def process_commit_event(
+        self,
+        commit_hash: str,
+        author: str,
+        message: str,
+        timestamp: datetime,
+        lines_added: int = 0,
+        lines_deleted: int = 0,
+        files_changed: int = 0,
+        is_merge: bool = False,
+        is_revert: bool = False,
+        files: Sequence[str] = (),
+        agent: Optional[str] = None,
+    ) -> PetStats:
+        """Process a commit event and update pet state.
+
+        Args:
+            commit_hash: Git commit SHA
+            author: Commit author
+            message: Commit message
+            timestamp: Commit timestamp
+            lines_added: Lines added in commit
+            lines_deleted: Lines deleted in commit
+            files_changed: Number of files changed
+            is_merge: Whether this is a merge commit
+            is_revert: Whether this is a revert commit
+            files: Paths touched by the commit
+            agent: AI agent that wrote the commit, if any
+
+        Returns:
+            Updated PetStats
+        """
+        with Session(self.engine) as session:
+            pet_state = self._row(session)
+            stats = self._to_stats(pet_state)
+
+            # Checked inside the same locked transaction, so the hook and
+            # haunt can't both count a commit
+            seen = session.query(CommitHistory.id).filter_by(commit_hash=commit_hash).first()
+            if seen:
+                session.commit()
+                stats.update_mood()
+                return stats
+
+            quality_impact = stats.eat_commit(
+                message, lines_added, lines_deleted, is_merge, is_revert, files, agent
+            )
+            session.add(
+                CommitHistory(
+                    commit_hash=commit_hash,
+                    author=author,
+                    message=message,
+                    timestamp=timestamp,
+                    lines_added=lines_added,
+                    lines_deleted=lines_deleted,
+                    files_changed=files_changed,
+                    is_merge=is_merge,
+                    is_revert=is_revert,
+                    quality_impact=quality_impact,
+                    agent=agent,
+                )
+            )
+            self._write(pet_state, stats)
+            session.commit()
+
+        return stats
+
+
+@dataclass
+class Replay:
+    """Result of replaying history."""
+
+    stats: PetStats
+    count: int
+    agents: Counter
+    since: Optional[datetime]

{gitgotchi-0.3.0 → gitgotchi-0.3.1}/src/gitgotchi/demo.py

@@ -5,7 +5,6 @@ import shutil
 import subprocess
 import tempfile
 import threading
-import time
 from pathlib import Path
 
 from git import Repo
@@ -43,6 +42,8 @@ def run_demo(interval: float = 2.8, fps: int = 12) -> None:
     root = Path(tempfile.mkdtemp(prefix="gitgotchi-demo-"))
     cwd = os.getcwd()
     stop = threading.Event()
+    state = None
+    worker = None
     try:
         repo = Repo.init(root)
         with repo.config_writer() as cw:
@@ -63,10 +64,14 @@ def run_demo(interval: float = 2.8, fps: int = 12) -> None:
                 if stop.wait(interval):
                     return
 
-        threading.Thread(target=committer, daemon=True).start()
+        worker = threading.Thread(target=committer, daemon=True)
+        worker.start()
         haunt(Repo(root), state, fps=fps, grace=0.2)
     finally:
         stop.set()
-        time.sleep(0.1)
+        if worker:
+            worker.join(timeout=10)  # let a commit in progress finish
+        if state:
+            state.close()  # Windows can't delete an open database
         os.chdir(cwd)
         shutil.rmtree(root, ignore_errors=True)