gbm-local 1.1.0__tar.gz

gbm_local-1.1.0/LICENSE

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

gbm_local-1.1.0/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: gbm-local
+Version: 1.1.0
+Summary: Automatic local project checkpoints and recovery
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/SumanyuDeshpande/GBM
+Project-URL: Repository, https://github.com/SumanyuDeshpande/GBM
+Project-URL: Issues, https://github.com/SumanyuDeshpande/GBM/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# GBM — Automatic Project Checkpointing and Recovery
+
+GBM records saved project files locally and restores earlier versions without Git commits. Python 3.10+; no runtime dependencies. This implementation uses portable filesystem polling and argparse rather than the proposed Watchdog and Typer dependencies. Windows is the tested platform; Linux/macOS code paths require validation.
+
+## Install
+
+From this directory:
+
+```powershell
+python -m pip install .
+gbm --help
+```
+
+Or install the wheel from `dist`. If your Python Scripts folder is not on PATH, use `python -m gbm` in place of `gbm`. Source checkout usage also works from this directory without installation.
+
+## Use
+
+Open a terminal in the project to protect:
+
+```powershell
+gbm watch                 # Initial checkpoint; detached background process
+gbm status                # Process liveness + recent heartbeat
+gbm undo main.py          # Previous distinct recorded file version
+gbm undo main.py --minutes 5 # Jump to the last checkpoint at/before five minutes ago
+gbm redo main.py          # Reapply file undo; supports multiple levels
+gbm undo                  # Preview affected count and confirm project undo
+gbm undo --yes            # Project undo without interactive confirmation
+gbm stop                  # Capture current state, stop monitoring
+gbm recover               # Roll back an interrupted restore
+```
+
+`watch` returns after the background process starts. It runs as your user, without a visible console window on Windows. It is not an operating-system service and does not restart at login. Run `watch` again after reboot or a watcher failure. Errors are written to `.gbm/watcher.log`.
+
+Commands discover the nearest ancestor with `.gbm`; otherwise `watch` initializes the current directory. File arguments are relative to the current working directory. Checkpoints include additions and deletions, binary contents and empty files. A rename is recorded as deletion plus addition. Unsaved editor buffers are not recorded.
+
+Example: start watching with `main.py` containing `print(1)`, save `print(2)`, wait about three seconds, then run `gbm undo main.py`. The file returns to `print(1)`; `gbm redo main.py` restores `print(2)`.
+
+## History and recovery semantics
+
+`.gbm/history.db` stores full content manifests and operation metadata; `.gbm/objects` stores deduplicated SHA-256 objects. History persists across terminal sessions. There is no automatic pruning or size limit; disk usage grows with unique contents.
+
+The default scan interval is 0.5 seconds with two seconds of inactivity before a checkpoint. Files are read and hashed on each scan, so this release is intended for small to medium source trees. Rapid intermediate versions between scans are not guaranteed to be captured. Changes that never settle are saved when `stop` is called or a restore is requested.
+
+Recovery captures pending changes first. File undo walks the distinct versions for that file; redo follows its undo stack. A new checkpointed edit to a file clears that file's redo stack. Unrelated edits retain it. Project undo walks backward through automatic project checkpoints, resets file redo stacks, and restores the whole monitored manifest. File restores do not advance the automatic project checkpoint sequence. Safety checkpoints preserve the state before every restoration and are excluded from ordinary undo navigation. There is no project redo command or general safety-checkpoint browser in this release.
+
+Restore plans compare the current manifest immediately before application. A mismatch aborts before project writes. GBM serializes its own operations with an OS file lock, checks object hashes, writes each file with atomic replacement, verifies the final manifest, and keeps a durable pending-operation journal. A failed or interrupted restore blocks further checkpointing/restores until `gbm recover` rolls back to its pre-restore state. Recovery first preserves the currently visible contents as another safety checkpoint. A multi-file restore is not a filesystem-wide atomic transaction. External editors do not honor GBM's lock: avoid saving files during restoration; races during the write phase can still occur.
+
+## Scope and exclusions
+
+Edit `.gbm/config.json` while monitoring is stopped. `exclude` is a list of shell-style patterns matched against each path component. `.gbm` and `.git` are always excluded. Defaults also exclude `node_modules`, `.venv`, `venv`, `__pycache__`, `dist`, `build`, `.pytest_cache`, `.mypy_cache`, `.env`, `.env.*`, `*.pem`, `*.key`, `*.pfx`, `*.pyc`, `*.swp`, and `*.tmp`.
+
+These patterns are not a secret scanner. Other sensitive files will be stored unless you exclude them. Objects are not encrypted. Removing an exclusion or changing scope after recording history can make older restores fail; keep the monitoring policy stable. GBM never intentionally traverses symbolic links or Windows junctions. Keep its internal storage private and do not modify it manually. Paths and history are trusted local data, not a security boundary against another process actively replacing filesystem entries.
+
+For a conventional `.git` directory, initialization adds `/.gbm/` to `.git/info/exclude`. For Git worktrees or before creating a Git repository, add `.gbm/` to your `.gitignore` yourself.
+
+Only file bytes and existence are versioned. Permissions, timestamps, alternate data streams, hard-link relationships and empty directories are not preserved. File/directory type collisions or locked files can prevent a restore; the journal permits recovery after resolving the obstruction. No cloud backup, project redo, GUI, encryption, history export, or production database recovery is included. GBM complements source control and backups.
+
+## Validate and publish
+
+```powershell
+python -m unittest discover -s tests -v
+python -m pip wheel . --no-deps --wheel-dir dist
+```
+
+Tests cover file/project history, repeated undo/redo, additions/deletions, preservation of pending edits, conflicts, object corruption, interruption recovery, exclusions, deduplication, and a real detached Windows watcher lifecycle.
+
+The source is prepared for a GitHub repository, including MIT licensing and CI. The destination repository is https://github.com/SumanyuDeshpande/GBM. The implementation has not yet been pushed or published. Review this release before publication. Treat this as an initial implementation requiring broader real-project testing before relying on it as your only recovery mechanism.
+
+## Time-based file undo (1.1)
+
+`gbm undo main.py --minutes 5` restores only that file from the most recent automatic checkpoint at or before five minutes before the command starts. Fractional minutes work (`--minutes 0.5` is 30 seconds). The selected checkpoint's local timestamp is displayed. If no checkpoint is old enough, GBM reports this without restoring anything; it never guesses an older version. If the file did not exist in the selected checkpoint, it is removed, with its current contents preserved for `gbm redo main.py`. Unrelated files stay unchanged. Redo reverses the entire jump in one command. Ordinary file undo after a jump continues backward from the selected checkpoint. A repeated time jump uses the current clock time, not the last undo position. Checkpoints record observed saved states, not exact historical filesystem contents between scans.

gbm_local-1.1.0/README.md

@@ -0,0 +1,71 @@
+# GBM — Automatic Project Checkpointing and Recovery
+
+GBM records saved project files locally and restores earlier versions without Git commits. Python 3.10+; no runtime dependencies. This implementation uses portable filesystem polling and argparse rather than the proposed Watchdog and Typer dependencies. Windows is the tested platform; Linux/macOS code paths require validation.
+
+## Install
+
+From this directory:
+
+```powershell
+python -m pip install .
+gbm --help
+```
+
+Or install the wheel from `dist`. If your Python Scripts folder is not on PATH, use `python -m gbm` in place of `gbm`. Source checkout usage also works from this directory without installation.
+
+## Use
+
+Open a terminal in the project to protect:
+
+```powershell
+gbm watch                 # Initial checkpoint; detached background process
+gbm status                # Process liveness + recent heartbeat
+gbm undo main.py          # Previous distinct recorded file version
+gbm undo main.py --minutes 5 # Jump to the last checkpoint at/before five minutes ago
+gbm redo main.py          # Reapply file undo; supports multiple levels
+gbm undo                  # Preview affected count and confirm project undo
+gbm undo --yes            # Project undo without interactive confirmation
+gbm stop                  # Capture current state, stop monitoring
+gbm recover               # Roll back an interrupted restore
+```
+
+`watch` returns after the background process starts. It runs as your user, without a visible console window on Windows. It is not an operating-system service and does not restart at login. Run `watch` again after reboot or a watcher failure. Errors are written to `.gbm/watcher.log`.
+
+Commands discover the nearest ancestor with `.gbm`; otherwise `watch` initializes the current directory. File arguments are relative to the current working directory. Checkpoints include additions and deletions, binary contents and empty files. A rename is recorded as deletion plus addition. Unsaved editor buffers are not recorded.
+
+Example: start watching with `main.py` containing `print(1)`, save `print(2)`, wait about three seconds, then run `gbm undo main.py`. The file returns to `print(1)`; `gbm redo main.py` restores `print(2)`.
+
+## History and recovery semantics
+
+`.gbm/history.db` stores full content manifests and operation metadata; `.gbm/objects` stores deduplicated SHA-256 objects. History persists across terminal sessions. There is no automatic pruning or size limit; disk usage grows with unique contents.
+
+The default scan interval is 0.5 seconds with two seconds of inactivity before a checkpoint. Files are read and hashed on each scan, so this release is intended for small to medium source trees. Rapid intermediate versions between scans are not guaranteed to be captured. Changes that never settle are saved when `stop` is called or a restore is requested.
+
+Recovery captures pending changes first. File undo walks the distinct versions for that file; redo follows its undo stack. A new checkpointed edit to a file clears that file's redo stack. Unrelated edits retain it. Project undo walks backward through automatic project checkpoints, resets file redo stacks, and restores the whole monitored manifest. File restores do not advance the automatic project checkpoint sequence. Safety checkpoints preserve the state before every restoration and are excluded from ordinary undo navigation. There is no project redo command or general safety-checkpoint browser in this release.
+
+Restore plans compare the current manifest immediately before application. A mismatch aborts before project writes. GBM serializes its own operations with an OS file lock, checks object hashes, writes each file with atomic replacement, verifies the final manifest, and keeps a durable pending-operation journal. A failed or interrupted restore blocks further checkpointing/restores until `gbm recover` rolls back to its pre-restore state. Recovery first preserves the currently visible contents as another safety checkpoint. A multi-file restore is not a filesystem-wide atomic transaction. External editors do not honor GBM's lock: avoid saving files during restoration; races during the write phase can still occur.
+
+## Scope and exclusions
+
+Edit `.gbm/config.json` while monitoring is stopped. `exclude` is a list of shell-style patterns matched against each path component. `.gbm` and `.git` are always excluded. Defaults also exclude `node_modules`, `.venv`, `venv`, `__pycache__`, `dist`, `build`, `.pytest_cache`, `.mypy_cache`, `.env`, `.env.*`, `*.pem`, `*.key`, `*.pfx`, `*.pyc`, `*.swp`, and `*.tmp`.
+
+These patterns are not a secret scanner. Other sensitive files will be stored unless you exclude them. Objects are not encrypted. Removing an exclusion or changing scope after recording history can make older restores fail; keep the monitoring policy stable. GBM never intentionally traverses symbolic links or Windows junctions. Keep its internal storage private and do not modify it manually. Paths and history are trusted local data, not a security boundary against another process actively replacing filesystem entries.
+
+For a conventional `.git` directory, initialization adds `/.gbm/` to `.git/info/exclude`. For Git worktrees or before creating a Git repository, add `.gbm/` to your `.gitignore` yourself.
+
+Only file bytes and existence are versioned. Permissions, timestamps, alternate data streams, hard-link relationships and empty directories are not preserved. File/directory type collisions or locked files can prevent a restore; the journal permits recovery after resolving the obstruction. No cloud backup, project redo, GUI, encryption, history export, or production database recovery is included. GBM complements source control and backups.
+
+## Validate and publish
+
+```powershell
+python -m unittest discover -s tests -v
+python -m pip wheel . --no-deps --wheel-dir dist
+```
+
+Tests cover file/project history, repeated undo/redo, additions/deletions, preservation of pending edits, conflicts, object corruption, interruption recovery, exclusions, deduplication, and a real detached Windows watcher lifecycle.
+
+The source is prepared for a GitHub repository, including MIT licensing and CI. The destination repository is https://github.com/SumanyuDeshpande/GBM. The implementation has not yet been pushed or published. Review this release before publication. Treat this as an initial implementation requiring broader real-project testing before relying on it as your only recovery mechanism.
+
+## Time-based file undo (1.1)
+
+`gbm undo main.py --minutes 5` restores only that file from the most recent automatic checkpoint at or before five minutes before the command starts. Fractional minutes work (`--minutes 0.5` is 30 seconds). The selected checkpoint's local timestamp is displayed. If no checkpoint is old enough, GBM reports this without restoring anything; it never guesses an older version. If the file did not exist in the selected checkpoint, it is removed, with its current contents preserved for `gbm redo main.py`. Unrelated files stay unchanged. Redo reverses the entire jump in one command. Ordinary file undo after a jump continues backward from the selected checkpoint. A repeated time jump uses the current clock time, not the last undo position. Checkpoints record observed saved states, not exact historical filesystem contents between scans.

gbm_local-1.1.0/gbm/__init__.py

@@ -0,0 +1,2 @@
+"""GBM: automatic local checkpointing."""
+__version__ = "1.1.0"

gbm_local-1.1.0/gbm/__main__.py

@@ -0,0 +1,3 @@
+import sys
+from .cli import main
+sys.exit(main())

gbm_local-1.1.0/gbm/cli.py

@@ -0,0 +1,114 @@
+"""Command line entry point."""
+import argparse
+import os
+from pathlib import Path
+import subprocess
+import sys
+import time
+import uuid
+from .core import Project, GBMError
+from .watcher import active, run
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(prog='gbm', description='Automatic local project checkpoints and recovery')
+    commands = parser.add_subparsers(dest='command', required=True)
+    commands.add_parser('watch', help='Start background monitoring')
+    commands.add_parser('status', help='Show watcher heartbeat and checkpoint count')
+    commands.add_parser('stop', help='Stop monitoring gracefully')
+    undo = commands.add_parser('undo', help='Restore the previous project or file version')
+    undo.add_argument('file', nargs='?')
+    undo.add_argument('--minutes', type=float, help='Restore file from the latest checkpoint at or before N minutes ago')
+    undo.add_argument('-y', '--yes', action='store_true', help='Confirm project restoration')
+    redo = commands.add_parser('redo', help='Redo a file-specific undo')
+    redo.add_argument('file')
+    recover = commands.add_parser('recover', help='Roll back an interrupted restore')
+    recover.add_argument('-y', '--yes', action='store_true')
+    internal = commands.add_parser('_watch', help=argparse.SUPPRESS)
+    internal.add_argument('root')
+    internal.add_argument('token')
+    args = parser.parse_args(argv)
+    if args.command == 'undo' and args.minutes is not None and not args.file:
+        parser.error('--minutes requires a file, for example: gbm undo main.py --minutes 5')
+    try:
+        if args.command == '_watch':
+            run(Project(args.root), args.token)
+            return 0
+        project = Project.discover()
+        if args.command != 'watch' and not (project.home / 'history.db').exists():
+            if args.command == 'status':
+                print('[GBM] Watcher: INACTIVE. No history initialized.')
+                return 0
+            raise GBMError('No GBM history exists. Run gbm watch first.')
+        if args.command == 'watch':
+            project.initialize()
+            with project.lock():
+                if active(project):
+                    print('[GBM] Already watching this project.')
+                    return 0
+                project.capture()
+                token = uuid.uuid4().hex
+                project.set('watcher', {'token': token, 'running': True, 'heartbeat': 0})
+                env = os.environ.copy()
+                source = str(Path(__file__).resolve().parent.parent)
+                env['PYTHONPATH'] = source + os.pathsep + env.get('PYTHONPATH', '')
+                options = {'start_new_session': True} if os.name != 'nt' else {
+                    'creationflags': subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.CREATE_NO_WINDOW}
+                with (project.home / 'watcher.log').open('ab') as log:
+                    subprocess.Popen([sys.executable, '-m', 'gbm', '_watch', str(project.root), token],
+                                     stdin=subprocess.DEVNULL, stdout=log, stderr=log, env=env, **options)
+            for _ in range(50):
+                if active(project):
+                    print(f'[GBM] Watching {project.root}. Automatic checkpointing enabled.')
+                    return 0
+                time.sleep(.1)
+            raise GBMError('Watcher did not start. See .gbm/watcher.log.')
+        if args.command == 'status':
+            with project.lock():
+                with project.db() as db:
+                    count, latest = db.execute('SELECT COUNT(*),MAX(created) FROM checkpoints').fetchone()
+                print(f'Project: {project.root}\nWatcher: {"ACTIVE" if active(project) else "INACTIVE"}')
+                print(f'Checkpoints: {count}\nLast checkpoint: {time.ctime(latest) if latest else "none"}')
+                if project.pending():
+                    print('ATTENTION: Interrupted restoration. Run gbm recover.')
+            return 0
+        if args.command == 'stop':
+            with project.lock():
+                status = project.get('watcher', {})
+                status['running'] = False
+                project.set('watcher', status)
+                if not project.pending():
+                    project.capture()
+            print('[GBM] Monitoring stopped; current files checkpointed.')
+            return 0
+        if args.command == 'recover':
+            if not args.yes and input('Roll back interrupted restoration? [y/N]: ').lower() != 'y':
+                return 0
+            with project.lock():
+                project.recover()
+            print('[GBM] Pre-restore project state recovered.')
+            return 0
+        rel = project.file_arg(args.file) if args.file else None
+        with project.lock():
+            before, target, action = project.preview(rel, args.command == 'redo', getattr(args, 'minutes', None))
+        affected = sum(before.get(p) != target.get(p) for p in set(before) | set(target))
+        if 'checkpoint' in action:
+            print(f"[GBM] Target checkpoint: #{action['checkpoint']} ({time.ctime(action['created'])})")
+        print(f'[GBM] Files affected: {affected}')
+        if affected == 0:
+            print('[GBM] File already matches the selected checkpoint. Nothing restored.')
+            return 0
+        if not rel and not args.yes and input('Restore project? [y/N]: ').lower() != 'y':
+            return 0
+        with project.lock():
+            project.apply(before, target, action)
+        print('[GBM] Restored successfully.')
+        return 0
+    except (GBMError, OSError, ValueError, KeyError) as error:
+        print(f'[GBM] {error}', file=sys.stderr)
+        return 1
+    except (KeyboardInterrupt, EOFError):
+        print('\n[GBM] Cancelled.', file=sys.stderr)
+        return 130
+
+if __name__ == '__main__':
+    sys.exit(main())

gbm_local-1.1.0/gbm/core.py

@@ -0,0 +1,351 @@
+"""Persistent history, bounded filesystem access, and serialized recovery."""
+import contextlib
+import fnmatch
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import sqlite3
+import time
+import uuid
+
+DEFAULTS = {"settle_seconds": 2.0, "poll_seconds": 0.5,
+            "exclude": [".gbm", ".git", "node_modules", ".venv", "venv", "__pycache__",
+                        "dist", "build", ".pytest_cache", ".mypy_cache", ".env", ".env.*",
+                        "*.pem", "*.key", "*.pfx", "*.pyc", "*.swp", "*.tmp"]}
+
+class GBMError(Exception):
+    pass
+
+class Project:
+    def __init__(self, root):
+        self.root = Path(root).resolve()
+        self.home = self.root / '.gbm'
+        if self.home.is_symlink():
+            raise GBMError('.gbm must not be a symbolic link.')
+
+    @classmethod
+    def discover(cls, start=None):
+        start = Path(start or Path.cwd()).resolve()
+        for directory in (start, *start.parents):
+            if (directory / '.gbm').is_dir():
+                return cls(directory)
+        return cls(start)
+
+    def initialize(self):
+        self.home.mkdir(exist_ok=True)
+        (self.home / 'objects').mkdir(exist_ok=True)
+        if not (self.home / 'config.json').exists():
+            self.atomic(self.home / 'config.json', json.dumps(DEFAULTS, indent=2).encode())
+        with self.db() as db:
+            db.executescript('''
+                CREATE TABLE IF NOT EXISTS checkpoints(id INTEGER PRIMARY KEY, created REAL, kind TEXT, state TEXT);
+                CREATE TABLE IF NOT EXISTS meta(key TEXT PRIMARY KEY, value TEXT);
+                CREATE TABLE IF NOT EXISTS redo(path TEXT PRIMARY KEY, stack TEXT);
+                CREATE TABLE IF NOT EXISTS operations(id TEXT PRIMARY KEY, created REAL, status TEXT, before_state TEXT, target_state TEXT);
+            ''')
+        # Git's local exclude avoids changing tracked project configuration.
+        git = self.root / '.git'
+        if git.is_dir() and not git.is_symlink():
+            exclude = git / 'info' / 'exclude'
+            exclude.parent.mkdir(exist_ok=True)
+            old = exclude.read_text() if exclude.exists() else ''
+            if '/.gbm/' not in old.splitlines():
+                exclude.write_text(old + '\n/.gbm/\n')
+
+    @contextlib.contextmanager
+    def db(self):
+        db = sqlite3.connect(self.home / 'history.db', timeout=15)
+        db.execute('PRAGMA synchronous=FULL')
+        try:
+            with db:
+                yield db
+        finally:
+            db.close()
+
+    @contextlib.contextmanager
+    def lock(self):
+        with (self.home / 'lock').open('a+b') as f:
+            f.seek(0)
+            f.write(b'0')
+            f.flush()
+            f.seek(0)
+            if os.name == 'nt':
+                import msvcrt
+                deadline = time.monotonic() + 15
+                while True:
+                    try:
+                        msvcrt.locking(f.fileno(), msvcrt.LK_NBLCK, 1)
+                        break
+                    except OSError:
+                        if time.monotonic() > deadline:
+                            raise GBMError('Project is busy; retry shortly.')
+                        time.sleep(.05)
+            else:
+                import fcntl
+                fcntl.flock(f, fcntl.LOCK_EX)
+            try:
+                yield
+            finally:
+                f.seek(0)
+                if os.name == 'nt':
+                    msvcrt.locking(f.fileno(), msvcrt.LK_UNLCK, 1)
+                else:
+                    fcntl.flock(f, fcntl.LOCK_UN)
+
+    @staticmethod
+    def atomic(path, data):
+        temp = path.with_name(path.name + '.gbm-' + uuid.uuid4().hex)
+        try:
+            with temp.open('xb') as f:
+                f.write(data)
+                f.flush()
+                os.fsync(f.fileno())
+            os.replace(temp, path)
+        finally:
+            temp.unlink(missing_ok=True)
+
+    def config(self):
+        config = json.loads((self.home / 'config.json').read_text())
+        if config['poll_seconds'] <= 0 or config['settle_seconds'] < 0:
+            raise GBMError('Monitoring intervals must be positive (settle may be zero).')
+        return config
+
+    def eligible(self, rel):
+        parts = Path(rel).parts
+        return '.gbm' not in parts and '.git' not in parts and not any(
+            fnmatch.fnmatch(part, pattern) for part in parts for pattern in self.config()['exclude'])
+
+    def path(self, rel):
+        candidate = self.root / rel
+        if Path(rel).is_absolute() or '..' in Path(rel).parts or not self.eligible(rel):
+            raise GBMError('Path is outside the monitored scope.')
+        current = self.root
+        for part in Path(rel).parts:
+            current = current / part
+            if current.is_symlink() or (hasattr(current, 'is_junction') and current.is_junction()):
+                raise GBMError('Symbolic links and junctions are not monitored.')
+        if not candidate.resolve().is_relative_to(self.root):
+            raise GBMError('Path escapes the project.')
+        return candidate
+
+    def file_arg(self, value):
+        candidate = Path(value)
+        if '..' in candidate.parts:
+            raise GBMError('Path is outside the monitored scope.')
+        if not candidate.is_absolute():
+            candidate = Path.cwd() / candidate
+        # Canonicalize Windows short-name aliases just as Project.__init__ does.
+        # Check the original path first so resolution cannot hide a symlink.
+        for part in (candidate, *candidate.parents):
+            if part.resolve() == self.root:
+                break
+            if part.is_symlink() or (hasattr(part, 'is_junction') and part.is_junction()):
+                raise GBMError('Symbolic links and junctions are not monitored.')
+        try:
+            rel = candidate.resolve().relative_to(self.root).as_posix()
+        except ValueError:
+            raise GBMError('File must be inside the project.')
+        self.path(rel)
+        return rel
+
+    def scan(self):
+        state = {}
+        def scan_error(error):
+            raise error
+        for directory, dirs, files in os.walk(self.root, followlinks=False, onerror=scan_error):
+            parent = Path(directory)
+            dirs[:] = [d for d in dirs if self.eligible((parent / d).relative_to(self.root))
+                       and not (parent / d).is_symlink()
+                       and not (hasattr(parent / d, 'is_junction') and (parent / d).is_junction())]
+            for name in files:
+                path = parent / name
+                rel = path.relative_to(self.root).as_posix()
+                if not self.eligible(rel) or path.is_symlink():
+                    continue
+                data = self.path(rel).read_bytes()
+                digest = hashlib.sha256(data).hexdigest()
+                obj = self.home / 'objects' / digest
+                if not obj.exists():
+                    self.atomic(obj, data)
+                state[rel] = digest
+        return state
+
+    def get(self, key, default=None):
+        with self.db() as db:
+            row = db.execute('SELECT value FROM meta WHERE key=?', (key,)).fetchone()
+        return json.loads(row[0]) if row else default
+
+    def set(self, key, value):
+        with self.db() as db:
+            db.execute('INSERT OR REPLACE INTO meta VALUES (?,?)', (key, json.dumps(value)))
+
+    def pending(self):
+        with self.db() as db:
+            return db.execute("SELECT id FROM operations WHERE status='pending'").fetchall()
+
+    def checkpoint(self, state, kind='automatic'):
+        with self.db() as db:
+            cursor = db.execute('INSERT INTO checkpoints(created,kind,state) VALUES (?,?,?)',
+                                (time.time(), kind, json.dumps(state)))
+            number = cursor.lastrowid
+        return number
+
+    def capture(self, state=None):
+        if self.pending():
+            raise GBMError('Interrupted restore detected. Run gbm recover before continuing.')
+        state = self.scan() if state is None else state
+        baseline = self.get('baseline')
+        if baseline == state:
+            return None
+        number = self.checkpoint(state)
+        # New edits invalidate redo only for the edited files.
+        with self.db() as db:
+            for rel in set(baseline or {}) | set(state):
+                if baseline is not None and baseline.get(rel) != state.get(rel):
+                    db.execute('DELETE FROM redo WHERE path=?', (rel,))
+                    db.execute('DELETE FROM meta WHERE key=?', ('file_head:' + rel,))
+        self.set('baseline', state)
+        self.set('head', number)
+        return number
+
+    def preview(self, rel=None, redo=False, minutes=None):
+        if minutes is not None:
+            if redo or not rel:
+                raise GBMError('--minutes requires a file-specific undo.')
+            if not math.isfinite(minutes) or minutes <= 0:
+                raise GBMError('--minutes must be a finite number greater than zero.')
+        cutoff = time.time() - minutes * 60 if minutes is not None else None
+        if self.pending():
+            raise GBMError('Interrupted restore detected. Run gbm recover.')
+        current = self.scan()
+        self.capture(current)
+        if redo:
+            with self.db() as db:
+                row = db.execute('SELECT stack FROM redo WHERE path=?', (rel,)).fetchone()
+            stack = json.loads(row[0]) if row else []
+            if not stack:
+                raise GBMError('No eligible redo state exists for this file.')
+            target = dict(current)
+            self.assign(target, rel, stack[-1]['value'])
+            return current, target, {'redo': stack[:-1], 'rel': rel, 'file_head': stack[-1]['head']}
+        head = self.get('head')
+        if cutoff is not None:
+            with self.db() as db:
+                row = db.execute(
+                    "SELECT id,created,state FROM checkpoints WHERE kind='automatic' AND created<=? "
+                    "ORDER BY created DESC,id DESC LIMIT 1", (cutoff,)).fetchone()
+            if not row:
+                raise GBMError('No checkpoint exists at or before the requested time. Nothing restored.')
+            number, created, payload = row
+            target = dict(current)
+            self.assign(target, rel, json.loads(payload).get(rel))
+            return current, target, {'rel': rel, 'push': current.get(rel),
+                                     'file_head': number,
+                                     'old_head': self.get('file_head:' + rel, head),
+                                     'checkpoint': number, 'created': created}
+        with self.db() as db:
+            rows = db.execute("SELECT id,state FROM checkpoints WHERE id<=? AND kind='automatic' ORDER BY id DESC", (head or 0,)).fetchall()
+        if rel:
+            cursor = self.get('file_head:' + rel, head)
+            versions = []
+            for number, payload in rows:
+                if number > cursor:
+                    continue
+                value = json.loads(payload).get(rel)
+                if not versions or versions[-1][1] != value:
+                    versions.append((number, value))
+            if len(versions) < 2:
+                raise GBMError('No previous recoverable version exists for this file.')
+            target = dict(current)
+            self.assign(target, rel, versions[1][1])
+            return current, target, {'rel': rel, 'push': current.get(rel),
+                                     'file_head': versions[1][0], 'old_head': cursor}
+        if len(rows) < 2:
+            raise GBMError('No previous project checkpoint exists.')
+        return current, json.loads(rows[1][1]), {'head': rows[1][0]}
+
+    @staticmethod
+    def assign(state, rel, value):
+        if value is None:
+            state.pop(rel, None)
+        else:
+            state[rel] = value
+
+    def apply(self, before, target, action):
+        if self.scan() != before:
+            raise GBMError('Recovery conflict: project changed after preview. Nothing restored.')
+        self.checkpoint(before, 'safety')
+        # Validate every object and destination before any project mutation.
+        for rel, digest in target.items():
+            self.path(rel)
+            self.object(digest)
+        operation = uuid.uuid4().hex
+        with self.db() as db:
+            db.execute('INSERT INTO operations VALUES (?,?,?,?,?)',
+                       (operation, time.time(), 'pending', json.dumps(before), json.dumps(target)))
+        self.write_state(before, target)
+        with self.db() as db:
+            if 'rel' in action:
+                rel = action['rel']
+                if 'redo' in action:
+                    stack = action['redo']
+                else:
+                    row = db.execute('SELECT stack FROM redo WHERE path=?', (rel,)).fetchone()
+                    stack = json.loads(row[0]) if row else []
+                    stack.append({'value': action['push'], 'head': action['old_head']})
+                db.execute('INSERT OR REPLACE INTO redo VALUES (?,?)', (rel, json.dumps(stack)))
+                db.execute('INSERT OR REPLACE INTO meta VALUES (?,?)', ('file_head:' + rel, json.dumps(action['file_head'])))
+            else:
+                db.execute('DELETE FROM redo')
+                db.execute("DELETE FROM meta WHERE key LIKE 'file_head:%'")
+            db.execute('INSERT OR REPLACE INTO meta VALUES (?,?)', ('baseline', json.dumps(target)))
+            if 'head' in action:
+                db.execute('INSERT OR REPLACE INTO meta VALUES (?,?)', ('head', json.dumps(action['head'])))
+            db.execute("UPDATE operations SET status='complete' WHERE id=?", (operation,))
+
+    def object(self, digest):
+        if len(digest) != 64 or any(c not in '0123456789abcdef' for c in digest):
+            raise GBMError('Invalid history object reference.')
+        data = (self.home / 'objects' / digest).read_bytes()
+        if hashlib.sha256(data).hexdigest() != digest:
+            raise GBMError('History object is corrupt; restoration stopped.')
+        return data
+
+    def write_state(self, before, target):
+        for rel in sorted(set(before) | set(target), key=lambda r: (-len(Path(r).parts), r)):
+            if before.get(rel) == target.get(rel):
+                continue
+            path = self.path(rel)
+            if rel not in target:
+                path.unlink(missing_ok=True)
+                # Only remove now-empty directories, never unmonitored contents.
+                parent = path.parent
+                while parent != self.root:
+                    try:
+                        parent.rmdir()
+                    except OSError:
+                        break
+                    parent = parent.parent
+        for rel, digest in target.items():
+            if before.get(rel) != digest:
+                path = self.path(rel)
+                path.parent.mkdir(parents=True, exist_ok=True)
+                self.atomic(path, self.object(digest))
+        if self.scan() != target:
+            raise GBMError('Restore verification failed; recovery journal retained.')
+
+    def recover(self):
+        with self.db() as db:
+            rows = db.execute("SELECT id,before_state FROM operations WHERE status='pending' ORDER BY created DESC").fetchall()
+        if not rows:
+            raise GBMError('No interrupted restoration exists.')
+        current = self.scan()
+        self.checkpoint(current, 'safety')
+        target = json.loads(rows[0][1])
+        self.write_state(current, target)
+        with self.db() as db:
+            db.execute("UPDATE operations SET status='recovered' WHERE status='pending'")
+            db.execute('DELETE FROM redo')
+        self.set('baseline', target)

gbm_local-1.1.0/gbm/watcher.py

@@ -0,0 +1,55 @@
+"""Detached polling watcher with a token-scoped heartbeat."""
+import os
+import time
+from .core import GBMError
+
+def active(project):
+    state = project.get('watcher', {})
+    if not (state.get('running') and time.time() - state.get('heartbeat', 0) < 5):
+        return False
+    pid = state.get('pid')
+    if not pid:
+        return False
+    if os.name == 'nt':
+        import ctypes
+        from ctypes import wintypes
+        kernel = ctypes.WinDLL('kernel32', use_last_error=True)
+        kernel.OpenProcess.restype = wintypes.HANDLE
+        kernel.OpenProcess.argtypes = [wintypes.DWORD, wintypes.BOOL, wintypes.DWORD]
+        kernel.GetExitCodeProcess.argtypes = [wintypes.HANDLE, ctypes.POINTER(wintypes.DWORD)]
+        kernel.CloseHandle.argtypes = [wintypes.HANDLE]
+        handle = kernel.OpenProcess(0x1000, False, pid)
+        if not handle:
+            return False
+        try:
+            code = wintypes.DWORD()
+            return bool(kernel.GetExitCodeProcess(handle, ctypes.byref(code)) and code.value == 259)
+        finally:
+            kernel.CloseHandle(handle)
+    try:
+        os.kill(pid, 0)
+        return True
+    except OSError:
+        return False
+
+def run(project, token):
+    pending = None
+    since = time.monotonic()
+    while True:
+        with project.lock():
+            status = project.get('watcher', {})
+            if status.get('token') != token or not status.get('running'):
+                return
+            status.update(pid=os.getpid(), heartbeat=time.time())
+            project.set('watcher', status)
+            config = project.config()
+            if not project.pending():
+                state = project.scan()
+                if state == project.get('baseline'):
+                    pending = None
+                elif state != pending:
+                    pending, since = state, time.monotonic()
+                elif time.monotonic() - since >= config['settle_seconds']:
+                    project.capture(state)
+                    pending = None
+        time.sleep(config['poll_seconds'])

gbm_local-1.1.0/gbm_local.egg-info/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: gbm-local
+Version: 1.1.0
+Summary: Automatic local project checkpoints and recovery
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/SumanyuDeshpande/GBM
+Project-URL: Repository, https://github.com/SumanyuDeshpande/GBM
+Project-URL: Issues, https://github.com/SumanyuDeshpande/GBM/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# GBM — Automatic Project Checkpointing and Recovery
+
+GBM records saved project files locally and restores earlier versions without Git commits. Python 3.10+; no runtime dependencies. This implementation uses portable filesystem polling and argparse rather than the proposed Watchdog and Typer dependencies. Windows is the tested platform; Linux/macOS code paths require validation.
+
+## Install
+
+From this directory:
+
+```powershell
+python -m pip install .
+gbm --help
+```
+
+Or install the wheel from `dist`. If your Python Scripts folder is not on PATH, use `python -m gbm` in place of `gbm`. Source checkout usage also works from this directory without installation.
+
+## Use
+
+Open a terminal in the project to protect:
+
+```powershell
+gbm watch                 # Initial checkpoint; detached background process
+gbm status                # Process liveness + recent heartbeat
+gbm undo main.py          # Previous distinct recorded file version
+gbm undo main.py --minutes 5 # Jump to the last checkpoint at/before five minutes ago
+gbm redo main.py          # Reapply file undo; supports multiple levels
+gbm undo                  # Preview affected count and confirm project undo
+gbm undo --yes            # Project undo without interactive confirmation
+gbm stop                  # Capture current state, stop monitoring
+gbm recover               # Roll back an interrupted restore
+```
+
+`watch` returns after the background process starts. It runs as your user, without a visible console window on Windows. It is not an operating-system service and does not restart at login. Run `watch` again after reboot or a watcher failure. Errors are written to `.gbm/watcher.log`.
+
+Commands discover the nearest ancestor with `.gbm`; otherwise `watch` initializes the current directory. File arguments are relative to the current working directory. Checkpoints include additions and deletions, binary contents and empty files. A rename is recorded as deletion plus addition. Unsaved editor buffers are not recorded.
+
+Example: start watching with `main.py` containing `print(1)`, save `print(2)`, wait about three seconds, then run `gbm undo main.py`. The file returns to `print(1)`; `gbm redo main.py` restores `print(2)`.
+
+## History and recovery semantics
+
+`.gbm/history.db` stores full content manifests and operation metadata; `.gbm/objects` stores deduplicated SHA-256 objects. History persists across terminal sessions. There is no automatic pruning or size limit; disk usage grows with unique contents.
+
+The default scan interval is 0.5 seconds with two seconds of inactivity before a checkpoint. Files are read and hashed on each scan, so this release is intended for small to medium source trees. Rapid intermediate versions between scans are not guaranteed to be captured. Changes that never settle are saved when `stop` is called or a restore is requested.
+
+Recovery captures pending changes first. File undo walks the distinct versions for that file; redo follows its undo stack. A new checkpointed edit to a file clears that file's redo stack. Unrelated edits retain it. Project undo walks backward through automatic project checkpoints, resets file redo stacks, and restores the whole monitored manifest. File restores do not advance the automatic project checkpoint sequence. Safety checkpoints preserve the state before every restoration and are excluded from ordinary undo navigation. There is no project redo command or general safety-checkpoint browser in this release.
+
+Restore plans compare the current manifest immediately before application. A mismatch aborts before project writes. GBM serializes its own operations with an OS file lock, checks object hashes, writes each file with atomic replacement, verifies the final manifest, and keeps a durable pending-operation journal. A failed or interrupted restore blocks further checkpointing/restores until `gbm recover` rolls back to its pre-restore state. Recovery first preserves the currently visible contents as another safety checkpoint. A multi-file restore is not a filesystem-wide atomic transaction. External editors do not honor GBM's lock: avoid saving files during restoration; races during the write phase can still occur.
+
+## Scope and exclusions
+
+Edit `.gbm/config.json` while monitoring is stopped. `exclude` is a list of shell-style patterns matched against each path component. `.gbm` and `.git` are always excluded. Defaults also exclude `node_modules`, `.venv`, `venv`, `__pycache__`, `dist`, `build`, `.pytest_cache`, `.mypy_cache`, `.env`, `.env.*`, `*.pem`, `*.key`, `*.pfx`, `*.pyc`, `*.swp`, and `*.tmp`.
+
+These patterns are not a secret scanner. Other sensitive files will be stored unless you exclude them. Objects are not encrypted. Removing an exclusion or changing scope after recording history can make older restores fail; keep the monitoring policy stable. GBM never intentionally traverses symbolic links or Windows junctions. Keep its internal storage private and do not modify it manually. Paths and history are trusted local data, not a security boundary against another process actively replacing filesystem entries.
+
+For a conventional `.git` directory, initialization adds `/.gbm/` to `.git/info/exclude`. For Git worktrees or before creating a Git repository, add `.gbm/` to your `.gitignore` yourself.
+
+Only file bytes and existence are versioned. Permissions, timestamps, alternate data streams, hard-link relationships and empty directories are not preserved. File/directory type collisions or locked files can prevent a restore; the journal permits recovery after resolving the obstruction. No cloud backup, project redo, GUI, encryption, history export, or production database recovery is included. GBM complements source control and backups.
+
+## Validate and publish
+
+```powershell
+python -m unittest discover -s tests -v
+python -m pip wheel . --no-deps --wheel-dir dist
+```
+
+Tests cover file/project history, repeated undo/redo, additions/deletions, preservation of pending edits, conflicts, object corruption, interruption recovery, exclusions, deduplication, and a real detached Windows watcher lifecycle.
+
+The source is prepared for a GitHub repository, including MIT licensing and CI. The destination repository is https://github.com/SumanyuDeshpande/GBM. The implementation has not yet been pushed or published. Review this release before publication. Treat this as an initial implementation requiring broader real-project testing before relying on it as your only recovery mechanism.
+
+## Time-based file undo (1.1)
+
+`gbm undo main.py --minutes 5` restores only that file from the most recent automatic checkpoint at or before five minutes before the command starts. Fractional minutes work (`--minutes 0.5` is 30 seconds). The selected checkpoint's local timestamp is displayed. If no checkpoint is old enough, GBM reports this without restoring anything; it never guesses an older version. If the file did not exist in the selected checkpoint, it is removed, with its current contents preserved for `gbm redo main.py`. Unrelated files stay unchanged. Redo reverses the entire jump in one command. Ordinary file undo after a jump continues backward from the selected checkpoint. A repeated time jump uses the current clock time, not the last undo position. Checkpoints record observed saved states, not exact historical filesystem contents between scans.

gbm_local-1.1.0/gbm_local.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+gbm/__init__.py
+gbm/__main__.py
+gbm/cli.py
+gbm/core.py
+gbm/watcher.py
+gbm_local.egg-info/PKG-INFO
+gbm_local.egg-info/SOURCES.txt
+gbm_local.egg-info/dependency_links.txt
+gbm_local.egg-info/entry_points.txt
+gbm_local.egg-info/top_level.txt
+tests/test_core.py
+tests/test_minutes.py
+tests/test_paths.py
+tests/test_watcher.py

gbm_local-1.1.0/gbm_local.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gbm_local-1.1.0/gbm_local.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gbm = gbm.cli:main

gbm_local-1.1.0/gbm_local.egg-info/top_level.txt

@@ -0,0 +1 @@
+gbm

gbm_local-1.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "gbm-local"
+version = "1.1.0"
+description = "Automatic local project checkpoints and recovery"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+
+[project.scripts]
+gbm = "gbm.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["gbm*"]
+
+[project.urls]
+Homepage = "https://github.com/SumanyuDeshpande/GBM"
+Repository = "https://github.com/SumanyuDeshpande/GBM"
+Issues = "https://github.com/SumanyuDeshpande/GBM/issues"

gbm_local-1.1.0/setup.cfg

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

gbm_local-1.1.0/tests/test_core.py

@@ -0,0 +1,81 @@
+import json
+import tempfile
+import unittest
+from pathlib import Path
+from gbm.core import Project, GBMError
+
+class HistoryTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp.cleanup)
+        self.root = Path(self.temp.name)
+        self.p = Project(self.root)
+        self.p.initialize()
+    def write(self, name, text):
+        (self.root / name).write_text(text)
+    def capture(self):
+        return self.p.capture()
+    def restore(self, rel=None, redo=False):
+        self.p.apply(*self.p.preview(rel, redo))
+    def test_file_undo_redo_multiple_levels(self):
+        self.write('a', 'one'); self.capture()
+        self.write('a', 'two'); self.capture()
+        self.write('a', 'three'); self.write('b','untouched'); self.capture()
+        self.restore('a'); self.assertEqual((self.root/'a').read_text(), 'two')
+        self.restore('a'); self.assertEqual((self.root/'a').read_text(), 'one')
+        self.restore('a', True); self.assertEqual((self.root/'a').read_text(), 'two')
+        self.restore('a', True); self.assertEqual((self.root/'a').read_text(), 'three')
+        self.assertEqual((self.root/'b').read_text(), 'untouched')
+    def test_project_add_delete_and_repeated_undo(self):
+        self.write('a','one'); self.capture()
+        (self.root/'a').unlink(); self.write('b','two'); self.capture()
+        self.write('b','three'); self.capture()
+        self.restore(); self.assertEqual((self.root/'b').read_text(),'two')
+        self.restore(); self.assertTrue((self.root/'a').exists()); self.assertFalse((self.root/'b').exists())
+    def test_unsaved_checkpoint_changes_preserved(self):
+        self.write('a','one'); self.capture()
+        self.write('a','two'); self.restore('a')
+        self.restore('a',True); self.assertEqual((self.root/'a').read_text(),'two')
+    def test_conflict(self):
+        self.write('a','one'); self.capture()
+        self.write('a','two'); self.capture()
+        plan=self.p.preview('a'); self.write('a','new work')
+        with self.assertRaises(GBMError): self.p.apply(*plan)
+        self.assertEqual((self.root/'a').read_text(),'new work')
+    def test_interrupt_and_recovery(self):
+        self.write('a','one'); self.capture()
+        self.write('a','two'); self.capture()
+        plan=self.p.preview('a')
+        original=self.p.write_state
+        def fail(before,target):
+            self.write('a','partial')
+            raise OSError('interrupted')
+        self.p.write_state=fail
+        with self.assertRaises(OSError): self.p.apply(*plan)
+        with self.assertRaises(GBMError): self.capture()
+        self.p.write_state=original; self.p.recover()
+        self.assertEqual((self.root/'a').read_text(),'two')
+        self.assertFalse(self.p.pending())
+    def test_exclusions_and_boundaries(self):
+        self.write('.env','secret'); self.write('a','code'); self.capture()
+        self.assertEqual(set(self.p.scan()), {'a'})
+        for name in ['../outside', '.gbm/config.json', '.env']:
+            with self.assertRaises(GBMError): self.p.path(name)
+    def test_new_edit_invalidates_redo(self):
+        self.write('a','one'); self.capture()
+        self.write('a','two'); self.capture(); self.restore('a')
+        self.write('a','three'); self.capture()
+        with self.assertRaises(GBMError): self.p.preview('a',True)
+    def test_identical_state_deduplicated(self):
+        self.write('a','one'); self.capture()
+        self.assertIsNone(self.capture())
+        self.assertEqual(len(list((self.p.home/'objects').iterdir())),1)
+    def test_corrupt_object_never_overwrites(self):
+        self.write('a','one'); self.capture()
+        self.write('a','two'); self.capture()
+        plan=self.p.preview('a')
+        (self.p.home/'objects'/plan[1]['a']).write_bytes(b'broken')
+        with self.assertRaises(GBMError): self.p.apply(*plan)
+        self.assertEqual((self.root/'a').read_text(),'two')
+
+if __name__=='__main__': unittest.main()

gbm_local-1.1.0/tests/test_minutes.py

@@ -0,0 +1,64 @@
+import contextlib
+import io
+import math
+from unittest.mock import patch
+import unittest
+import test_core
+from gbm.core import GBMError
+from gbm.cli import main
+
+class TimedUndoTests(unittest.TestCase):
+    setUp = test_core.HistoryTests.setUp
+    write = test_core.HistoryTests.write
+    capture = test_core.HistoryTests.capture
+    restore = test_core.HistoryTests.restore
+    def timeline(self):
+        with patch('gbm.core.time.time', return_value=1000):
+            self.write('a','one'); self.write('other','original'); self.capture()
+        with patch('gbm.core.time.time', return_value=1120):
+            self.write('a','two'); self.capture()
+        with patch('gbm.core.time.time', return_value=1240):
+            self.write('a','three'); self.write('other','new'); self.capture()
+    def plan(self, minutes):
+        with patch('gbm.core.time.time', return_value=1300):
+            return self.p.preview('a', minutes=minutes)
+    def test_jump_and_single_redo(self):
+        self.timeline()
+        self.p.apply(*self.plan(3))
+        self.assertEqual((self.root/'a').read_text(),'two')
+        self.assertEqual((self.root/'other').read_text(),'new')
+        self.restore('a',True)
+        self.assertEqual((self.root/'a').read_text(),'three')
+    def test_fractional_minutes(self):
+        self.timeline(); self.p.apply(*self.plan(1.5))
+        self.assertEqual((self.root/'a').read_text(),'two')
+    def test_exact_boundary(self):
+        self.timeline(); self.p.apply(*self.plan(3))
+        self.assertEqual(self.p.get('file_head:a'),2)
+        self.restore('a'); self.assertEqual((self.root/'a').read_text(),'one')
+    def test_no_old_enough_checkpoint(self):
+        self.timeline()
+        with self.assertRaisesRegex(GBMError,'No checkpoint'):
+            self.plan(6)
+        self.assertEqual((self.root/'a').read_text(),'three')
+    def test_absent_file_and_redo(self):
+        with patch('gbm.core.time.time',return_value=1000): self.capture()
+        with patch('gbm.core.time.time',return_value=1240):
+            self.write('a','new'); self.capture()
+        self.p.apply(*self.plan(3))
+        self.assertFalse((self.root/'a').exists())
+        self.restore('a',True); self.assertEqual((self.root/'a').read_text(),'new')
+    def test_invalid_minutes(self):
+        self.timeline()
+        for minutes in [0,-1,math.nan,math.inf,-math.inf]:
+            with self.subTest(minutes=minutes), self.assertRaises(GBMError):
+                self.plan(minutes)
+        with self.assertRaises(GBMError): self.p.preview(minutes=5)
+    def test_jump_conflict(self):
+        self.timeline(); plan=self.plan(3); self.write('a','new work')
+        with self.assertRaises(GBMError): self.p.apply(*plan)
+        self.assertEqual((self.root/'a').read_text(),'new work')
+    def test_cli_requires_file(self):
+        with contextlib.redirect_stderr(io.StringIO()), self.assertRaises(SystemExit) as caught:
+            main(['undo','--minutes','5'])
+        self.assertEqual(caught.exception.code,2)

gbm_local-1.1.0/tests/test_paths.py

@@ -0,0 +1,47 @@
+import ctypes
+import os
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import patch
+from gbm.core import Project, GBMError
+
+class PathTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp.cleanup)
+        self.root = Path(self.temp.name) / 'project with spaces'
+        self.root.mkdir()
+        self.p = Project(self.root)
+        self.p.initialize()
+        (self.root / 'a.py').write_text('source')
+
+    @unittest.skipUnless(os.name == 'nt', 'Windows short paths')
+    def test_short_path_alias(self):
+        function = ctypes.windll.kernel32.GetShortPathNameW
+        function.argtypes = [ctypes.c_wchar_p, ctypes.c_wchar_p, ctypes.c_uint]
+        function.restype = ctypes.c_uint
+        buffer = ctypes.create_unicode_buffer(32768)
+        size = function(str(self.root), buffer, len(buffer))
+        self.assertTrue(size)
+        short = Path(buffer.value)
+        if short == self.root:
+            self.skipTest('Filesystem does not supply a distinct short-name alias')
+        # Relative and absolute arguments, including a deleted target.
+        with patch('gbm.core.Path.cwd', return_value=short):
+            self.assertEqual(self.p.file_arg('a.py'), 'a.py')
+            self.assertEqual(self.p.file_arg('deleted.py'), 'deleted.py')
+        self.assertEqual(self.p.file_arg(str(short/'a.py')), 'a.py')
+
+    def test_outside_file_rejected(self):
+        with self.assertRaises(GBMError):
+            self.p.file_arg(str(self.root.parent/'outside.py'))
+
+    def test_symlink_inside_project_rejected(self):
+        link = self.root/'linked.py'
+        try:
+            link.symlink_to(self.root/'a.py')
+        except OSError:
+            self.skipTest('Symlink creation unavailable')
+        with self.assertRaises(GBMError):
+            self.p.file_arg(str(link))

gbm_local-1.1.0/tests/test_watcher.py

@@ -0,0 +1,44 @@
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+from gbm.core import Project
+
+class WatcherTests(unittest.TestCase):
+    def test_detached_watch_checkpoint_restore_stop(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root=Path(directory)
+            env=os.environ.copy()
+            env['PYTHONPATH']=str(Path(__file__).resolve().parents[1])
+            def cli(*args):
+                result=subprocess.run([sys.executable,'-m','gbm',*args],cwd=root,env=env,
+                                      capture_output=True,text=True,timeout=15)
+                self.assertEqual(result.returncode,0,result.stdout+result.stderr)
+                return result.stdout
+            (root/'a').write_text('one')
+            try:
+                cli('watch')
+                self.assertIn('ACTIVE',cli('status'))
+                (root/'a').write_text('two')
+                p=Project(root)
+                deadline=time.monotonic()+10
+                while time.monotonic()<deadline:
+                    if p.get('baseline',{}).get('a') == __import__('hashlib').sha256(b'two').hexdigest():
+                        break
+                    time.sleep(.2)
+                else:
+                    self.fail('Background watcher did not checkpoint the edit')
+                cli('undo','a'); self.assertEqual((root/'a').read_text(),'one')
+                with p.db() as db:
+                    count=db.execute("SELECT COUNT(*) FROM checkpoints WHERE kind='automatic'").fetchone()[0]
+                time.sleep(3)
+                with p.db() as db:
+                    self.assertEqual(count,db.execute("SELECT COUNT(*) FROM checkpoints WHERE kind='automatic'").fetchone()[0])
+                cli('redo','a'); self.assertEqual((root/'a').read_text(),'two')
+                cli('stop'); self.assertIn('INACTIVE',cli('status'))
+            finally:
+                cli('stop')
+                time.sleep(1)