work-tracker 0.1.0__tar.gz

work_tracker-0.1.0/LICENSE

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

work_tracker-0.1.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.2
+Name: work-tracker
+Version: 0.1.0
+Summary: A Python library that helps tracking your work time.
+Author-email: Karol Kiszka <karolkisz22@gmail.com>
+License: MIT
+Project-URL: source, https://github.com/kiszkacy/work-tracker
+Keywords: work,time,tracker
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Requires-Python: <4.0,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: workalendar~=17.0.0
+Requires-Dist: pydantic~=2.10.5
+Requires-Dist: appdirs~=1.4.4
+Requires-Dist: path~=17.1.0
+Requires-Dist: PyYAML~=6.0.2
+Requires-Dist: pyperclip~=1.9.0
+Requires-Dist: colorama~=0.4.6
+Requires-Dist: multimethod~=2.0
+Requires-Dist: prompt_toolkit~=3.0.48
+Provides-Extra: dev
+Requires-Dist: pytest~=8.3.4; extra == "dev"
+Requires-Dist: pytest-mock~=3.14.0; extra == "dev"
+Requires-Dist: pytest-order~=1.3.0; extra == "dev"
+Requires-Dist: pytest-random-order~=1.1.1; extra == "dev"
+Requires-Dist: pytest-cov~=6.0.0; extra == "dev"
+
+
+# WorkTracker
+
+
+![Python version](https://img.shields.io/badge/python-%3E%3D%203.10-blue.svg)
+![License](https://img.shields.io/badge/license-MIT-green.svg)
+![PyPI](https://img.shields.io/pypi/v/work-tracker.svg)
+[![wakatime](https://wakatime.com/badge/user/92cf3ac1-102d-4d79-b9a8-c960cf206839/project/8c8f1653-1d14-4d7e-90bc-01591ea36159.svg)](https://wakatime.com/badge/user/92cf3ac1-102d-4d79-b9a8-c960cf206839/project/8c8f1653-1d14-4d7e-90bc-01591ea36159 "Total time spent coding")
+
+**WorkTracker** is a Python library that helps you track your time spent at work and manage your work schedule, providing a simple way to monitor your working hours.
+
+> **Note:** This library is still in very early development. Many features may not be fully stable, and things could and probably will break with future updates until the final release.
+
+
+## Installation
+
+Before installing **WorkTracker**, ensure you have Python 3.10 or a newer version installed. You can download and install it from the [official Python website](https://www.python.org/downloads/).
+
+To install the latest **WorkTracker** version, run the following command in your terminal:
+
+```bash
+pip install work-tracker
+```
+
+## Usage
+
+Once installed, you can launch the **WorkTracker** by running the following command in your terminal:
+
+```bash
+work-tracker
+```
+
+## License
+
+This project is licensed under the MIT License.

work_tracker-0.1.0/README.md

@@ -0,0 +1,35 @@
+
+# WorkTracker
+
+
+![Python version](https://img.shields.io/badge/python-%3E%3D%203.10-blue.svg)
+![License](https://img.shields.io/badge/license-MIT-green.svg)
+![PyPI](https://img.shields.io/pypi/v/work-tracker.svg)
+[![wakatime](https://wakatime.com/badge/user/92cf3ac1-102d-4d79-b9a8-c960cf206839/project/8c8f1653-1d14-4d7e-90bc-01591ea36159.svg)](https://wakatime.com/badge/user/92cf3ac1-102d-4d79-b9a8-c960cf206839/project/8c8f1653-1d14-4d7e-90bc-01591ea36159 "Total time spent coding")
+
+**WorkTracker** is a Python library that helps you track your time spent at work and manage your work schedule, providing a simple way to monitor your working hours.
+
+> **Note:** This library is still in very early development. Many features may not be fully stable, and things could and probably will break with future updates until the final release.
+
+
+## Installation
+
+Before installing **WorkTracker**, ensure you have Python 3.10 or a newer version installed. You can download and install it from the [official Python website](https://www.python.org/downloads/).
+
+To install the latest **WorkTracker** version, run the following command in your terminal:
+
+```bash
+pip install work-tracker
+```
+
+## Usage
+
+Once installed, you can launch the **WorkTracker** by running the following command in your terminal:
+
+```bash
+work-tracker
+```
+
+## License
+
+This project is licensed under the MIT License.

work_tracker-0.1.0/pyproject.toml

@@ -0,0 +1,63 @@
+[project]
+name = "work-tracker"
+description = "A Python library that helps tracking your work time."
+authors = [
+  {name = "Karol Kiszka", email = "karolkisz22@gmail.com"}
+]
+readme = "README.md"
+license = { text = "MIT" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Environment :: Console",
+]
+dependencies = [
+    "workalendar~=17.0.0",
+    "pydantic~=2.10.5",
+    "appdirs~=1.4.4",
+    "path~=17.1.0",
+    "PyYAML~=6.0.2",
+    "pyperclip~=1.9.0",
+    "colorama~=0.4.6",
+    "multimethod~=2.0",
+    "prompt_toolkit~=3.0.48",
+]
+requires-python = ">=3.10,<4.0"
+keywords = ["work", "time", "tracker"]
+dynamic = ["version"]
+
+[project.scripts]
+work-tracker = "work_tracker.main:main"
+
+[project.optional-dependencies]
+dev = [
+    "pytest~=8.3.4",
+    "pytest-mock~=3.14.0",
+    "pytest-order~=1.3.0",
+    "pytest-random-order~=1.1.1",
+    "pytest-cov~=6.0.0",
+]
+
+[project.urls]
+source = "https://github.com/kiszkacy/work-tracker"
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["work_tracker"]
+
+[tool.setuptools.dynamic]
+version = {attr = "work_tracker.version.__version__"}
+
+[tool.coverage.report]
+include_namespace_packages = true
+omit = ["**/__init__.py"]
+skip_empty = true

work_tracker-0.1.0/setup.cfg

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

work_tracker-0.1.0/work_tracker/__init__.py

@@ -0,0 +1,8 @@
+from .version import VERSION, __version__
+from ._work_tracker import WorkTracker
+
+__all__ = (
+    "__version__",
+    "VERSION",
+    "WorkTracker",
+)

work_tracker-0.1.0/work_tracker/_work_tracker.py

@@ -0,0 +1,236 @@
+import calendar
+import datetime
+import shutil
+import signal
+import subprocess
+import sys
+import traceback
+from pathlib import Path
+
+from workalendar.registry import registry
+
+from work_tracker import __version__
+from work_tracker.checkpoint_manager import CheckpointManager
+from work_tracker.command.command_parser import CommandParser
+from work_tracker.command.command_query_handler import CommandQueryHandler
+from work_tracker.command.common import ParseResult
+from work_tracker.common import AppData, Date, Mode, AppState, get_data_path
+from work_tracker.text.common import Color
+from work_tracker.text.input_output_handler import InputOutputHandler
+from .config import Config
+from .error import VersionCheckError
+
+
+class WorkTracker:
+    def __init__(self):
+        self.state: AppState = AppState()
+        self.data: AppData
+        self.io: InputOutputHandler
+        self.command_handler: CommandQueryHandler
+        self._initialized: bool = False
+
+    def initialize(self, check_is_new_version_available: bool = True):
+        self._initialized = True
+
+        if is_first_time_launch := self._is_first_time_launch():
+            self._create_basic_files()
+        if was_version_file_missing := self._is_version_file_missing():
+            self._update_version_file()
+        if was_config_file_missing := self._is_config_file_missing():
+            self._create_default_config_file()
+        if was_macros_file_missing := self._is_macros_file_missing():
+            self._create_default_macros_file()
+        if was_updated_since_last_launch := self._was_updated_since_last_launch():
+            self._update_version_file()
+
+        # config access check must be before io, because io uses config values
+        if not Config.ready():
+            raise RuntimeError("Something went wrong trying to access config.")
+
+        self._initialize_io()
+        if is_first_time_launch:
+            self._first_time_prompt()
+        else:
+            if was_version_file_missing:
+                self.io.output("WARNING: version file could not be found. This may lead to unpredicted behavior.", color=Color.Yellow)
+            if was_config_file_missing:
+                self.io.output("WARNING: config file could not be found. Default config will be used instead.", color=Color.Yellow)
+            if was_macros_file_missing:
+                self.io.output("WARNING: macros file could not be found. Default macros will be used instead.", color=Color.Yellow)
+
+        if not is_first_time_launch:
+            self._load_data()
+            if self.data is None:
+                self.io.output("WARNING: it appears that no saved data file was found to load from. As a result, the app will default to the first-time launch screen.", color=Color.Yellow)
+                self._first_time_prompt()
+            elif not self.data.is_latest_data_version():
+                self.data.update_data_to_latest_version()
+
+        self._initialize_command_handler()
+        self._clear_old_cache()
+
+        if not was_updated_since_last_launch and check_is_new_version_available and (latest_version := self._is_new_version_available()) is not None:
+            self._display_new_version_available_message(latest_version)
+        self.io.output(f"Using {Color.Brightblue.value}WorkTracker{Color.Clear.value} version {Color.Brightblue.value}{__version__}{Color.Clear.value}.")
+
+    def _is_first_time_launch(self) -> bool:
+        expected_files: list[Path] = [get_data_path().joinpath("version"), get_data_path().joinpath("config.yaml"), get_data_path().joinpath("macros.txt")]
+        return all(not path.exists() for path in expected_files)
+
+    def _create_basic_files(self):
+        self._create_default_config_file()
+        self._create_default_macros_file()
+
+    def _create_default_config_file(self):
+        shutil.copy(Path(__file__).parent.joinpath("data/default.config.yaml"), get_data_path().joinpath("config.yaml"))
+
+    def _create_default_macros_file(self):
+        shutil.copy(Path(__file__).parent.joinpath("data/default.macros.txt"), get_data_path().joinpath("macros.txt"))
+
+    def _initialize_io(self):
+        self.io = InputOutputHandler()
+
+    def _load_data(self):
+        self.data = CheckpointManager.load_latest()
+
+    def _first_time_prompt(self):
+        self.io.write("Welcome to WorkTracker!", color=Color.Brightblue)
+        self.io.write("WorkTracker helps you track your work hours efficiently and manage your schedule with ease.", color=Color.Cyan)
+        self.io.output(f"Before you start using it, please provide your country code. This will allow {Color.Brightblue.value}WorkTracker{Color.Reset.value} to automatically import all relevant holidays and mark your non-working days accordingly.")
+
+        country_code: str
+        valid_codes: list[str] = sorted(list(registry.get_calendars().keys()))
+        while True:
+            country_code = self.io.input(f"{Config.data.input.prefix} ", custom_autocomplete=valid_codes).upper()
+            if country_code in valid_codes: # TODO use of private method
+                break
+            else:
+                self.io.output("Invalid country code. Please input valid contry code.", color=Color.Brightred)
+
+        self.io.output("Would you like to run the initial setup? This process can take some time but is recommended, as it enables the app to automatically fill your calendar with the suggested work schedule.")
+        user_input: str = self.io.input(f"{Config.data.input.prefix} ", custom_autocomplete=["yes", "no"])
+        if "yes".startswith(user_input):
+            self.io.output("Setup command is not yet implemented. Skipping setup phase...", color=Color.Brightred)
+        else:
+            self.io.output(f"Initial setup skipped. You can always run setup later by using {Color.Brightblue.value}setup{Color.Reset.value} command.")
+
+        self.data = AppData(country_code=country_code)
+        CheckpointManager.save("initial", self.data)
+
+        self.io.write(f"Everything is set up and ready.", color=Color.Cyan, end=" ")
+        self.io.write(f"To view a list of available commands type {Color.Brightblue.value}help{Color.Reset.value}.", end=" ")
+        self.io.write(f"For detailed information about a specific command use {Color.Brightblue.value}help <command_name>{Color.Reset.value}.", end=" ")
+        self.io.write(f"It is recommended that you use {Color.Brightblue.value}tutorial{Color.Reset.value} command to quickly get familiar with the available features.", end=" ")
+        self.io.output(f"Remember to leave {Color.Brightblue.value}WorkTracker{Color.Reset.value} by using {Color.Brightblue.value}exit{Color.Reset.value} command to avoid {Color.Underline.value}{Color.Brightred.value}loss of data{Color.Reset.value}!")
+
+    def _is_version_file_missing(self) -> bool:
+        return not get_data_path().joinpath("version").exists() # TODO make file name a constant
+
+    def _is_config_file_missing(self) -> bool:
+        return not get_data_path().joinpath("config.yaml").exists() # TODO make file name a constant
+
+    def _is_macros_file_missing(self) -> bool:
+        return not get_data_path().joinpath("macros.txt").exists() # TODO make file name a constant
+
+    def _was_updated_since_last_launch(self) -> bool:
+        path: Path = get_data_path().joinpath("version")
+        if not path.exists():
+            raise RuntimeError("Something went wrong when trying to access version file.")
+
+        with open(path, "r") as file:
+            version: str = file.read()
+
+        return version < __version__
+
+    def _update_version_file(self):
+        with open(get_data_path().joinpath("version"), "w") as file:
+            file.write(__version__)
+
+    def _initialize_command_handler(self):
+        self.command_handler = CommandQueryHandler(self.data, self.io, self.state)
+
+    def _is_new_version_available(self) -> str | None:
+        try:
+            installed_version: str = __version__
+            result = subprocess.run(
+                ["pip", "index", "versions", "work-tracker"],
+                capture_output=True, text=True
+            )
+            if result.returncode != 0:
+                self.io.output("WARNING: unable to retrieve data from pip while checking for available updates.", color=Color.Yellow)
+                return None
+
+            latest_version: str = result.stdout.strip().split("\n")[-1].split()[-1]
+            return latest_version if installed_version != latest_version else None
+        except subprocess.SubprocessError as e:
+            raise VersionCheckError("Subprocess error during version check.")
+        except Exception as e:
+            raise VersionCheckError(f"Unexpected error: {e}")
+
+    def _display_new_version_available_message(self, version: str):
+        self.io.write(f"New version {Color.Brightcyan.value}{version}{Color.Reset.value} is available!", end=" ")
+        self.io.output(f"Update with {Color.Brightblue.value}pip install --upgrade work-tracker{Color.Reset.value}.")
+
+    def _clear_old_cache(self):
+        CheckpointManager.clear_cache()
+
+    def _at_crash_exit(self, crash_message: str | None = None, exception: Exception | None = None):
+        CheckpointManager.save(f"crash-{datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}", self.data)
+        with open(get_data_path().joinpath(f"crash-log-{datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}.txt"), "w") as file:
+            if crash_message is not None:
+                file.write(crash_message)
+            if exception is not None:
+                traceback.print_exc(file=file)
+        sys.exit()
+
+    def _at_exit(self):
+        CheckpointManager.save(f"{datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}", self.data)
+        sys.exit()
+
+    def handle_exit_signal(self): # TODO check if this works | no it doesnt :(
+        self._at_crash_exit(crash_message=f"received exit signal")
+
+    def _run(self):
+        error_log_last_processed_input: str = "None"
+        try:
+            while True:
+                today: Date = Date.today()
+                mode: Mode = self.state.mode
+                date: Date = self.state.active_date
+                prefix: str = (
+                    f"{Config.data.input.prefix} "                                            if mode == Mode.Today else
+                    f"[{date.day:02}.{date.month:02}.{date.year}]{Config.data.input.prefix} " if mode == Mode.Day and today.year != date.year else
+                    f"[{date.day:02}.{date.month:02}]{Config.data.input.prefix} "             if mode == Mode.Day and today.year == date.year else
+                    f"[{calendar.month_abbr[date.month].lower()}]{Config.data.input.prefix} " if mode == Mode.Month else
+                    "?> "
+                )
+
+                user_input: str = self.get_user_input(prefix)
+                error_log_last_processed_input = user_input
+
+                result: ParseResult = CommandParser.parse(user_input)
+                if result.error:
+                    self.io.output(f"ERROR: {result.error.message or 'missing error description'}", color=Color.Brightred)
+                    continue
+
+                for query in result.queries:
+                    self.command_handler.run(query)
+        except KeyboardInterrupt:
+            self.io.output("UNSAFE EXIT: saving data...", color=Color.Brightred, end="")
+            self._at_exit()
+        except Exception as exception:
+            self.io.output("FATAL ERROR: saving data and creating error log...", color=Color.Brightred, end="")
+            self._at_crash_exit(crash_message=f"{error_log_last_processed_input}\n\n", exception=exception)
+
+    def start(self):
+        if not self._initialized:
+            self.initialize()
+
+        # TODO add atexit.register() to automatically save data somewhere here ?
+        signal.signal(signal.SIGINT, self.handle_exit_signal)
+        signal.signal(signal.SIGTERM, self.handle_exit_signal)
+
+        self._run()
+
+    def get_user_input(self, prefix: str) -> str:
+        return self.io.input(prefix)

work_tracker-0.1.0/work_tracker/checkpoint_manager.py

@@ -0,0 +1,56 @@
+import datetime
+import lzma
+import os
+import pickle
+
+from path import Path
+
+from .common import AppData, get_data_path, get_cache_path
+
+
+class CheckpointManager:
+    @classmethod
+    def load(cls, identifier: str, manual_checkpoint: bool = False) -> AppData | None: # TODO os exceptions
+        if manual_checkpoint:
+            for checkpoint_path in cls.all_manual_checkpoints():
+                name, date = checkpoint_path.name.removesuffix('.save.checkpoint').split("__") # TODO hardcoded '.save.checkpoint'
+                if name == identifier:
+                    identifier = f"{name}__{date}"
+
+        path: Path = (get_data_path() if not manual_checkpoint else get_cache_path()).joinpath(f"{identifier}.save.checkpoint")
+        if not path.exists():
+            return None
+        with lzma.open(path, "rb") as file:
+            data: AppData = pickle.load(file)
+        return data
+
+    @staticmethod
+    def save(identifier: str, data: AppData, manual_checkpoint: bool = False): # TODO os exceptions
+        full_identifier: str = identifier if not manual_checkpoint else f"{identifier}__{datetime.datetime.now().strftime('%H-%M-%S')}"
+        path: Path = (get_data_path() if not manual_checkpoint else get_cache_path()).joinpath(f"{full_identifier}.save.checkpoint")
+        with lzma.open(path, "wb") as file:
+            pickle.dump(data, file)
+
+    @classmethod
+    def load_latest(cls) -> AppData | None: # TODO os exceptions
+        files: list[Path] = cls.all_automatic_checkpoints()
+        if not files:
+            return None
+
+        newest_file: str = max(files, key=os.path.getctime) # TODO this sorting might be unclear for user
+        return cls.load(os.path.basename(newest_file.rstrip(".save.checkpoint")))
+
+    @staticmethod
+    def all_automatic_checkpoints() -> list[Path]: # TODO os exceptions
+        return [get_data_path().joinpath(file) for file in os.listdir(get_data_path()) if file.endswith(".save.checkpoint") and os.path.isfile(get_data_path().joinpath(file))]
+
+    @staticmethod
+    def all_manual_checkpoints() -> list[Path]: # TODO os exceptions
+        return [get_cache_path().joinpath(file) for file in os.listdir(get_cache_path()) if file.endswith(".save.checkpoint") and os.path.isfile(get_cache_path().joinpath(file))]
+
+    @staticmethod
+    def clear_cache():
+        for name in os.listdir(get_cache_path()):
+            if not os.path.isfile(get_cache_path().joinpath(name)):
+                continue
+            os.remove(get_cache_path().joinpath(name))

work_tracker-0.1.0/work_tracker/command/__init__.py

@@ -0,0 +1 @@
+

work_tracker-0.1.0/work_tracker/command/command_handler.py

@@ -0,0 +1,36 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+from work_tracker.command.command_parser import CommandParser
+from work_tracker.command.common import CommandArgument, AdditionalInputArgument, CommandQuery
+from work_tracker.error import CommandError
+from work_tracker.common import AppData, Date, ReadonlyAppState
+from work_tracker.config import Config
+from work_tracker.text.input_output_handler import InputOutputHandler
+
+
+@dataclass(frozen=True)
+class CommandHandlerResult:
+    undoable: bool
+    error: CommandError | None = None
+    change_active_date: Date | None = None
+    change_state_by: int | None = None
+    execute_after: list[CommandQuery] | None = None
+
+
+class CommandHandler(ABC):
+    def __init__(self, work_data: AppData, io: InputOutputHandler):
+        self.data: AppData = work_data
+        self.io: InputOutputHandler = io
+
+    @property
+    def command_name(self) -> str:
+        return self.__class__.__name__.split("Handler")[0].lower()
+
+    @abstractmethod
+    def handle(self, dates: list[Date], date_count: int, arguments: list[CommandArgument], argument_count: int, state: ReadonlyAppState) -> CommandHandlerResult:
+        raise NotImplementedError()
+
+    def get_additional_input(self, custom_autocomplete: list[str] = None) -> list[AdditionalInputArgument]:
+        text: str = self.io.input(f"{Config.data.input.sub_prefix} ", show_autocomplete=custom_autocomplete is not None, custom_autocomplete=custom_autocomplete)
+        return CommandParser.parse_arguments(text)

work_tracker-0.1.0/work_tracker/command/command_history.py

@@ -0,0 +1,48 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class CommandHistoryEntry:
+    state_key: str
+    command: str
+
+
+class CommandHistory:
+    def __init__(self, max_size: int):
+        self._max_size: int = max_size
+        self._current_state_index: int = -1
+        self._states: list[CommandHistoryEntry] = []
+
+    def add(self, state_key: str, command_used: str):
+        if self._current_state_index < self._max_size:
+            self._states = self._states[:self._current_state_index + 1]
+
+        if self._current_state_index == self._max_size:
+            self._states.pop(0)
+        else:
+            self._current_state_index += 1
+
+        self._states.append(CommandHistoryEntry(
+            state_key=state_key,
+            command=command_used
+        ))
+
+    def undo(self) -> str | None:
+        if self._current_state_index > 0:
+            self._current_state_index -= 1
+            return self._states[self._current_state_index].state_key
+        return None
+
+    def redo(self) -> str | None:
+        if self._current_state_index < len(self._states) - 1:
+            self._current_state_index += 1
+            return self._states[self._current_state_index].state_key
+        return None
+
+    @property
+    def states(self) -> tuple[CommandHistoryEntry]:
+        return tuple(self._states)
+
+    @property
+    def current_state_index(self) -> int:
+        return self._current_state_index