I Added a Stopwatch to My AI in 1 LOC Using the Livingrimoire While Corporations Need a Year

ai.add_skill(DiStopWatch())

import time

class DiStopWatch(Skill):
    """
    Stopwatch skill for voice-controlled timing.
    Auto-announces at each minute milestone while running.
    """

    def __init__(self):
        super().__init__()
        self.timer = Timer()
        self.last_announced_minute = 0

    # Override
    def input(self, ear: str, skin: str, eye: str):
        # ear is already lowercased and stripped upstream

        if ear == "start stopwatch":
            self.timer.start_timer()
            self.last_announced_minute = 0
            self.setSimpleAlg("Stopwatch started from zero")
            return

        if ear == "pause stopwatch":
            self.timer.pause_timer()
            self.setSimpleAlg("Stopwatch paused")
            return

        if ear == "resume stopwatch":
            self.timer.resume_timer()
            self.setSimpleAlg("Stopwatch resumed")
            return

        if ear == "reset stopwatch":
            self.timer.reset_timer()
            self.last_announced_minute = 0
            self.setSimpleAlg("Stopwatch reset to zero")
            return

        if ear == "stopwatch time":
            elapsed = self.timer.get_time_elapsed()
            self.setSimpleAlg(f"Elapsed time: {elapsed}")
            return

        if ear == "stopwatch status":
            if not self.timer._is_running:
                status = "not running"
            elif self.timer._is_paused:
                status = "paused"
            else:
                status = "running"
                self._check_and_announce_minute()
            self.setSimpleAlg(f"Stopwatch is {status}")
            return

        # Auto-check minute milestone on any input while running
        if self.timer._is_running and not self.timer._is_paused:
            self._check_and_announce_minute()

    def _check_and_announce_minute(self):
        """Check if a new minute has elapsed and announce it."""
        current_seconds = self.timer.get_current_seconds()
        current_minute = int(current_seconds // 60)

        if current_minute > self.last_announced_minute and current_minute > 0:
            self.last_announced_minute = current_minute
            minute_word = "minute" if current_minute == 1 else "minutes"
            self.setSimpleAlg(f"{current_minute} {minute_word} elapsed")

    def skillNotes(self, param: str) -> str:
        if param == "notes":
            return "Voice-controlled stopwatch with automatic minute announcements"
        if param == "triggers":
            return "start stopwatch, pause stopwatch, resume stopwatch, reset stopwatch, stopwatch time, stopwatch status"
        return "Note unavailable"


class Timer:
    """Precision timing. No redundancy."""

    def __init__(self):
        self._start_time = None
        self._paused_elapsed = 0.0
        self._is_paused = False
        self._is_running = False

    def start_timer(self):
        self._start_time = time.perf_counter()
        self._paused_elapsed = 0.0
        self._is_paused = False
        self._is_running = True

    def pause_timer(self):
        if self._is_running and not self._is_paused:
            self._paused_elapsed += time.perf_counter() - self._start_time
            self._is_paused = True

    def resume_timer(self):
        if self._is_running and self._is_paused:
            self._start_time = time.perf_counter()
            self._is_paused = False

    def reset_timer(self):
        self._is_running = False
        self._is_paused = False
        self._paused_elapsed = 0.0
        self._start_time = None

    def get_current_seconds(self):
        """Get raw total seconds elapsed."""
        if not self._is_running:
            return 0

        if self._is_paused:
            return self._paused_elapsed

        return self._paused_elapsed + (time.perf_counter() - self._start_time)

    def get_time_elapsed(self):
        """Get formatted elapsed time as string."""
        total_seconds = self.get_current_seconds()

        hours = int(total_seconds // 3600)
        minutes = int((total_seconds % 3600) // 60)
        seconds = int(total_seconds % 60)

        parts = []
        if hours > 0:
            parts.append(f"{hours} hour{'s' if hours != 1 else ''}")
        if minutes > 0:
            parts.append(f"{minutes} minute{'s' if minutes != 1 else ''}")
        if seconds > 0 or not parts:
            parts.append(f"{seconds} second{'s' if seconds != 1 else ''}")

        return " ".join(parts)