drunken-chunk 1.0.0

package/drunken_chunk/reminder.py

@@ -0,0 +1,386 @@
+import os
+import sys
+import time
+import subprocess
+import random
+from datetime import datetime, timedelta
+
+from .db import (
+    get_profile, get_today_logs, get_daemon_state, set_daemon_state, init_db
+)
+from .profile import calculate_recommended_intake
+
+PACKAGE_PARENT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+# List of rich, motivational, and sometimes humorous notifications
+REMINDER_MESSAGES = [
+    "Hydrate or diedrate! Drink up!",
+    "A hydrated brain writes fewer bugs. Go grab a cup!",
+    "Drunken Chunk alert: Time to wash down those keystrokes!",
+    "Your cells are crying out for water! Give them a gulp!",
+    "Hydration check! Put down your mouse and pick up your flask.",
+    "Drink water now. Future hydrated you will thank you!",
+    "Water: 0 calories, 100% vital. Pour yourself a fresh glass!",
+    "Time to level up your hydration status. Sip sip hooray!"
+]
+
+def send_windows_toast(title, message):
+    """Sends a Windows native toast notification via a headless PowerShell script."""
+    escaped_title = title.replace('"', '`"').replace("'", "`'")
+    escaped_message = message.replace('"', '`"').replace("'", "`'")
+    
+    ps_code = f'''
+    [void][Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime]
+    $Template = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)
+    $Xml = [xml]$Template.GetXml()
+    $Xml.toast.visual.binding.text[0].AppendChild($Xml.CreateTextNode("{escaped_title}")) | Out-Null
+    $Xml.toast.visual.binding.text[1].AppendChild($Xml.CreateTextNode("{escaped_message}")) | Out-Null
+    $XmlDocument = New-Object Windows.Data.Xml.Dom.XmlDocument
+    $XmlDocument.LoadXml($Xml.OuterXml)
+    $Toast = [Windows.UI.Notifications.ToastNotification]::new($XmlDocument)
+    [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier("DrunkenChunk.Reminder").Show($Toast)
+    '''
+    
+    # Hide window completely using creationflags=0x08000000 on Windows
+    creation_flags = 0x08000000 if os.name == 'nt' else 0
+    try:
+        subprocess.run(
+            ["powershell", "-NoProfile", "-NonInteractive", "-Command", ps_code],
+            capture_output=True,
+            text=True,
+            creationflags=creation_flags
+        )
+    except Exception:
+        # Fallback if Powershell fails
+        pass
+
+def send_macos_notification(title, message):
+    """Sends a macOS native desktop notification via AppleScript."""
+    escaped_title = title.replace('\\', '\\\\').replace('"', '\\"')
+    escaped_message = message.replace('\\', '\\\\').replace('"', '\\"')
+    cmd = ["osascript", "-e", f'display notification "{escaped_message}" with title "{escaped_title}"']
+    try:
+        subprocess.run(cmd, capture_output=True, check=False)
+    except Exception:
+        pass
+
+def send_linux_notification(title, message):
+    """Sends a Linux desktop notification via notify-send."""
+    try:
+        subprocess.run(["notify-send", title, message], capture_output=True, check=False)
+    except Exception:
+        pass
+
+def send_notification(title, message):
+    """Dispatches native desktop notifications based on the current platform."""
+    if sys.platform == 'win32':
+        send_windows_toast(title, message)
+    elif sys.platform == 'darwin':
+        send_macos_notification(title, message)
+    else:
+        send_linux_notification(title, message)
+
+def is_waking_hours(current_time_str, wake_time_str, sleep_time_str):
+    """
+    Checks if current time (HH:MM) is within the waking hours range.
+    Supports shift workers (e.g., wake at 22:00, sleep at 06:00).
+    """
+    curr_h, curr_m = map(int, current_time_str.split(':'))
+    wake_h, wake_m = map(int, wake_time_str.split(':'))
+    sleep_h, sleep_m = map(int, sleep_time_str.split(':'))
+    
+    curr = curr_h * 60 + curr_m
+    wake = wake_h * 60 + wake_m
+    sleep = sleep_h * 60 + sleep_m
+    
+    if wake <= sleep:
+        # Day shift (e.g. 07:00 to 22:00)
+        return wake <= curr <= sleep
+    else:
+        # Night shift (e.g. 22:00 to 06:00 next day)
+        return curr >= wake or curr <= sleep
+
+def check_and_notify():
+    """Runs the core reminder algorithm logic."""
+    # Check if currently snoozed
+    snooze_until_str = get_daemon_state("snooze_until", "")
+    if snooze_until_str:
+        try:
+            snooze_until = datetime.strptime(snooze_until_str, "%Y-%m-%d %H:%M:%S")
+            if datetime.now() < snooze_until:
+                return # In snooze mode, skip alert
+        except ValueError:
+            pass
+
+    profile = get_profile()
+    if not profile:
+        return
+        
+    now = datetime.now()
+    current_time_str = now.strftime("%H:%M")
+    
+    # Check if we are inside waking hours
+    if not is_waking_hours(current_time_str, profile['wake_time'], profile['sleep_time']):
+        return # Quiet hours, do not disturb
+        
+    today_logs = get_today_logs()
+    
+    # Calculate target and check if completed
+    target = profile['custom_target'] if profile['custom_target'] else calculate_recommended_intake(profile['weight'], profile['height'])
+    total_today = sum(log['amount'] for log in today_logs)
+    if total_today >= target:
+        return # Target already hit, don't nag the user
+        
+    # Get last drink log timestamp
+    if today_logs:
+        last_drink_time = datetime.strptime(today_logs[-1]['timestamp'], "%Y-%m-%d %H:%M:%S")
+    else:
+        # If no drinks today, baseline is today at wake_time
+        wake_h, wake_m = map(int, profile['wake_time'].split(':'))
+        last_drink_time = now.replace(hour=wake_h, minute=wake_m, second=0, microsecond=0)
+        # If wake_time was technically in the future for a night shift, adjust back 1 day
+        if last_drink_time > now:
+            last_drink_time -= timedelta(days=1)
+            
+    # Get last notified time
+    last_notified_str = get_daemon_state("last_notified", "")
+    if last_notified_str:
+        try:
+            last_notified_time = datetime.strptime(last_notified_str, "%Y-%m-%d %H:%M:%S")
+        except ValueError:
+            last_notified_time = datetime.min
+    else:
+        last_notified_time = datetime.min
+        
+    # Determine the timing constraint: must be > interval since last drink AND last notification
+    interval_mins = profile['reminder_interval']
+    next_due_after_drink = last_drink_time + timedelta(minutes=interval_mins)
+    next_due_after_notif = last_notified_time + timedelta(minutes=interval_mins)
+    
+    due_time = max(next_due_after_drink, next_due_after_notif)
+    
+    if now >= due_time:
+        # Trigger notification!
+        title = "Drunken Chunk [~]"
+        message = random.choice(REMINDER_MESSAGES)
+        send_notification(title, message)
+        
+        # Save state
+        set_daemon_state("last_notified", now.strftime("%Y-%m-%d %H:%M:%S"))
+
+def is_pid_running(pid):
+    """Check to see if a process ID is still running (Windows & Unix native)."""
+    if not pid:
+        return False
+    try:
+        pid_val = int(pid)
+        if os.name != 'nt':
+            try:
+                os.kill(pid_val, 0)
+                return True
+            except ProcessLookupError:
+                return False
+            except PermissionError:
+                return True
+            except OSError as e:
+                import errno
+                return e.errno == errno.EPERM
+            
+        import ctypes
+        PROCESS_QUERY_INFORMATION = 0x0400
+        PROCESS_SYNCHRONIZE = 0x00100000
+        handle = ctypes.windll.kernel32.OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_SYNCHRONIZE, False, pid_val)
+        if handle:
+            exit_code = ctypes.c_ulong()
+            ctypes.windll.kernel32.GetExitCodeProcess(handle, ctypes.byref(exit_code))
+            ctypes.windll.kernel32.CloseHandle(handle)
+            return exit_code.value == 259 # STILL_ACTIVE
+        return False
+    except Exception:
+        return False
+
+def run_daemon_loop():
+    """Runs the main daemon polling loop."""
+    init_db()
+    set_daemon_state("is_active", "1")
+    set_daemon_state("daemon_pid", str(os.getpid()))
+    
+    # Send a launch notification
+    send_notification("Drunken Chunk [~]", "Water reminder service started. Happy hydrating!")
+    
+    try:
+        while True:
+            # Check if we were told to stop
+            is_active = get_daemon_state("is_active", "0")
+            if is_active != "1":
+                break
+                
+            check_and_notify()
+            time.sleep(20) # Poll every 20 seconds
+    finally:
+        set_daemon_state("is_active", "0")
+        set_daemon_state("daemon_pid", "")
+
+def start_background_daemon():
+    """Spawns the daemon process detached from the current console."""
+    pid = get_daemon_state("daemon_pid", "")
+    if pid and is_pid_running(pid):
+        return False, f"Daemon is already running with PID {pid}."
+        
+    set_daemon_state("is_active", "1")
+    
+    # Spawn background daemon
+    cmd = [sys.executable, "-c", f"import sys; sys.path.insert(0, r'{PACKAGE_PARENT}'); import drunken_chunk.reminder as r; r.run_daemon_loop()"]
+    
+    popen_kwargs = {
+        "close_fds": True,
+        "stdout": subprocess.DEVNULL,
+        "stderr": subprocess.DEVNULL,
+        "stdin": subprocess.DEVNULL,
+    }
+    if os.name == 'nt':
+        # DETACHED_PROCESS | CREATE_NO_WINDOW
+        popen_kwargs["creationflags"] = 0x00000008 | 0x08000000
+    else:
+        popen_kwargs["start_new_session"] = True
+        
+    subprocess.Popen(cmd, **popen_kwargs)
+    
+    # Give it a second to boot up and write PID
+    time.sleep(1.5)
+    new_pid = get_daemon_state("daemon_pid", "")
+    
+    return True, f"Daemon successfully started in background (PID: {new_pid})."
+
+def stop_background_daemon():
+    """Stops the daemon gracefully by modifying database state."""
+    pid = get_daemon_state("daemon_pid", "")
+    set_daemon_state("is_active", "0")
+    
+    if not pid:
+        return False, "Daemon is not running."
+        
+    # Wait for graceful exit
+    for _ in range(5):
+        if not is_pid_running(pid):
+            set_daemon_state("daemon_pid", "")
+            return True, "Daemon stopped gracefully."
+            
+        time.sleep(0.5)
+        
+    # Force kill if it didn't exit
+    try:
+        if os.name == 'nt':
+            subprocess.run(["taskkill", "/F", "/PID", pid], capture_output=True, creationflags=0x08000000)
+        else:
+            os.kill(int(pid), 9)
+        set_daemon_state("daemon_pid", "")
+        return True, f"Daemon process {pid} was forced to stop."
+    except Exception as e:
+        return False, f"Failed to stop daemon {pid}: {str(e)}"
+
+def manage_autostart(action):
+    """
+    Manages startup autostart toggle/enable/disable/status for Windows, macOS, and Linux.
+    action: 'status', 'enable', 'disable', or 'toggle'
+    Returns: (success_bool, message_str)
+    """
+    platform = sys.platform
+    
+    # Identify target file and startup path
+    if platform == 'win32':
+        appdata = os.environ.get("APPDATA")
+        if not appdata:
+            return False, "Could not locate APPDATA directory."
+        startup_dir = os.path.join(appdata, r"Microsoft\Windows\Start Menu\Programs\Startup")
+        startup_file = os.path.join(startup_dir, "drunken-chunk-autostart.bat")
+    elif platform == 'darwin':
+        startup_dir = os.path.expanduser("~/Library/LaunchAgents")
+        startup_file = os.path.join(startup_dir, "com.drunkenchunk.reminder.plist")
+    else: # Assume Linux / generic Unix
+        startup_dir = os.path.expanduser("~/.config/autostart")
+        startup_file = os.path.join(startup_dir, "drunken-chunk.desktop")
+        
+    exists = os.path.exists(startup_file)
+    
+    if action == 'status':
+        status_str = "ENABLED" if exists else "DISABLED"
+        return True, f"Startup Autostart is currently: {status_str}"
+        
+    if action == 'toggle':
+        action = 'disable' if exists else 'enable'
+        
+    if action == 'enable':
+        try:
+            os.makedirs(startup_dir, exist_ok=True)
+            
+            if platform == 'win32':
+                python_exe = sys.executable
+                cmd_str = f'@"{python_exe}" -c "import sys; sys.path.insert(0, r\'{PACKAGE_PARENT}\'); import drunken_chunk.reminder as r; r.start_background_daemon()"\n'
+                with open(startup_file, "w", encoding="utf-8") as f:
+                    f.write(cmd_str)
+            elif platform == 'darwin':
+                plist_content = f"""<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.drunkenchunk.reminder</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>{sys.executable}</string>
+        <string>-c</string>
+        <string>import sys; sys.path.insert(0, '{PACKAGE_PARENT}'); import drunken_chunk.reminder as r; r.start_background_daemon()</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <false/>
+</dict>
+</plist>
+"""
+                with open(startup_file, "w", encoding="utf-8") as f:
+                    f.write(plist_content)
+                # Load the launch agent immediately
+                subprocess.run(["launchctl", "load", startup_file], capture_output=True)
+            else: # Linux
+                desktop_content = f"""[Desktop Entry]
+Type=Application
+Name=Drunken Chunk Reminder
+Comment=Starts the Drunken Chunk background reminder daemon
+Exec={sys.executable} -c "import sys; sys.path.insert(0, '{PACKAGE_PARENT}'); import drunken_chunk.reminder as r; r.start_background_daemon()"
+Terminal=false
+X-GNOME-Autostart-enabled=true
+"""
+                with open(startup_file, "w", encoding="utf-8") as f:
+                    f.write(desktop_content)
+                    
+            # Automatically start the background reminder service immediately
+            daemon_started, daemon_msg = start_background_daemon()
+            msg = "Autostart ENABLED. Drunken Chunk will now launch on system startup."
+            if daemon_started:
+                msg += f"\nReminder service started automatically in background (PID: {get_daemon_state('daemon_pid', '')})."
+            else:
+                msg += "\nReminder service is already active."
+            return True, msg
+        except Exception as e:
+            return False, f"Failed to enable autostart: {str(e)}"
+            
+    elif action == 'disable':
+        if exists:
+            try:
+                if platform == 'darwin':
+                    # Unload the launch agent
+                    subprocess.run(["launchctl", "unload", startup_file], capture_output=True)
+                os.remove(startup_file)
+                return True, "Autostart DISABLED. Drunken Chunk will no longer launch on system startup."
+            except Exception as e:
+                return False, f"Failed to disable autostart: {str(e)}"
+        else:
+            return True, "Autostart was already disabled."
+            
+    return False, f"Unknown action: {action}"
+
+if __name__ == "__main__":
+    # If run directly as a script
+    run_daemon_loop()

package/drunken_chunk/shortcut.py

@@ -0,0 +1,43 @@
+import re
+from .db import save_shortcut, delete_shortcut, get_shortcuts
+
+def validate_shortcut_name(name):
+    """
+    Validates that a shortcut name is alphanumeric and not a pure integer.
+    Pure integers are reserved for raw logging of milliliters (e.g., 'log 250').
+    """
+    name = name.strip().lower()
+    if not name:
+        return False, "Shortcut name cannot be empty."
+    if not re.match(r"^[a-zA-Z0-9_\-]+$", name):
+        return False, "Shortcut name can only contain letters, numbers, underscores, and hyphens."
+    if name.isdigit():
+        return False, "Shortcut name cannot be a number. Numbers are reserved for logging raw milliliters."
+    return True, ""
+
+def add_custom_shortcut(name, amount):
+    """Registers or updates a shortcut if validation passes."""
+    name = name.strip().lower()
+    is_valid, err_msg = validate_shortcut_name(name)
+    if not is_valid:
+        return False, err_msg
+        
+    try:
+        amount_val = int(amount)
+        if amount_val <= 0:
+            return False, "Amount must be a positive integer."
+    except ValueError:
+        return False, "Amount must be a valid integer number (in ml)."
+        
+    save_shortcut(name, amount_val)
+    return True, f"Vessel size locked and loaded. Shortcut '{name}' registered with {amount_val} ml. Logging is now 10x faster."
+
+def remove_custom_shortcut(name):
+    """Removes a shortcut if it exists."""
+    name = name.strip().lower()
+    shortcuts = get_shortcuts()
+    if name not in shortcuts:
+        return False, f"Shortcut '{name}' does not exist."
+        
+    delete_shortcut(name)
+    return True, f"Shortcut '{name}' has been destroyed. May it rest in plastic."

package/drunken_chunk/utils.py

@@ -0,0 +1,122 @@
+import os
+import sys
+
+# Enable Virtual Terminal Processing for Windows to support ANSI color sequences natively
+def enable_ansi_support():
+    if os.name == 'nt':
+        import ctypes
+        kernel32 = ctypes.windll.kernel32
+        # -11 is STD_OUTPUT_HANDLE
+        h_out = kernel32.GetStdHandle(-11)
+        if h_out != -1:
+            mode = ctypes.c_ulong()
+            if kernel32.GetConsoleMode(h_out, ctypes.byref(mode)):
+                # 0x0004 is ENABLE_VIRTUAL_TERMINAL_PROCESSING
+                kernel32.SetConsoleMode(h_out, mode.value | 0x0004)
+
+# Call on import to ensure colors are enabled
+enable_ansi_support()
+
+# ANSI Color Codes
+class Colors:
+    BLUE = "\033[38;5;39m"
+    CYAN = "\033[38;5;81m"
+    GREEN = "\033[38;5;76m"
+    RED = "\033[38;5;196m"
+    YELLOW = "\033[38;5;220m"
+    MAGENTA = "\033[38;5;170m"
+    GRAY = "\033[38;5;244m"
+    WHITE = "\033[97m"
+    
+    # Backgrounds
+    BG_BLUE = "\033[48;5;27m"
+    BG_CYAN = "\033[48;5;39m"
+    
+    # Styles
+    BOLD = "\033[1m"
+    UNDERLINE = "\033[4m"
+    RESET = "\033[0m"
+
+# Styling Helper Functions
+def colorize(text, color):
+    return f"{color}{text}{Colors.RESET}"
+
+def bold(text):
+    return f"{Colors.BOLD}{text}{Colors.RESET}"
+
+def italic(text):
+    return f"\033[3m{text}{Colors.RESET}"
+
+def print_banner():
+    banner = f"""
+  {Colors.BLUE}┌────────────────────────────────────────────────────────┐{Colors.RESET}
+  {Colors.BLUE}│{Colors.RESET}  {Colors.CYAN}{Colors.BOLD}[ DRUNKEN CHUNK ]{Colors.RESET}                                      {Colors.BLUE}│{Colors.RESET}
+  {Colors.BLUE}│{Colors.RESET}  {Colors.GRAY}The ultimate CLI water tracker, reminders & analytics{Colors.RESET} {Colors.BLUE}│{Colors.RESET}
+  {Colors.BLUE}└────────────────────────────────────────────────────────┘{Colors.RESET}
+"""
+    print(banner)
+
+def get_progress_bar(percentage, width=30):
+    """Generates a colored ASCII progress bar."""
+    percentage = min(max(percentage, 0.0), 100.0)
+    filled_length = int(width * percentage // 100)
+    empty_length = width - filled_length
+    
+    # Determine color based on completion
+    if percentage < 25:
+        bar_color = Colors.RED
+    elif percentage < 75:
+        bar_color = Colors.YELLOW
+    elif percentage < 100:
+        bar_color = Colors.CYAN
+    else:
+        bar_color = Colors.GREEN
+        
+    bar = colorize("█" * filled_length, bar_color) + colorize("░" * empty_length, Colors.GRAY)
+    return f"[{bar}] {colorize(f'{percentage:.1f}%', Colors.BOLD)}"
+
+def print_table(headers, rows, title=None):
+    """Draws a beautiful custom ASCII table."""
+    if not rows:
+        print(colorize("No data to display in table.", Colors.GRAY))
+        return
+
+    # Calculate column widths
+    col_widths = [len(str(h)) for h in headers]
+    for row in rows:
+        for idx, cell in enumerate(row):
+            col_widths[idx] = max(col_widths[idx], len(str(cell)))
+
+    # Generate border formats
+    top_border = "┌─" + "─┬─".join("─" * w for w in col_widths) + "─┐"
+    header_sep = "├─" + "─┼─".join("─" * w for w in col_widths) + "─┤"
+    bottom_border = "└─" + "─┴─".join("─" * w for w in col_widths) + "─┘"
+
+    # Display Title
+    if title:
+        print(colorize(f"\n─── {title} ───", Colors.BOLD + Colors.CYAN))
+    else:
+        print()
+
+    # Print Top Border
+    print(colorize(top_border, Colors.BLUE))
+    
+    # Print Headers
+    header_cells = [str(headers[i]).ljust(col_widths[i]) for i in range(len(headers))]
+    print(colorize("│ ", Colors.BLUE) + colorize(" │ ", Colors.BLUE).join(colorize(c, Colors.BOLD + Colors.WHITE) for c in header_cells) + colorize(" │", Colors.BLUE))
+    
+    # Print Header Separator
+    print(colorize(header_sep, Colors.BLUE))
+
+    # Print Rows
+    for row in rows:
+        row_cells = []
+        for i, cell in enumerate(row):
+            cell_str = str(cell)
+            # Try to colorize numbers/statuses if needed or just display
+            row_cells.append(cell_str.ljust(col_widths[i]))
+        print(colorize("│ ", Colors.BLUE) + colorize(" │ ", Colors.BLUE).join(row_cells) + colorize(" │", Colors.BLUE))
+
+    # Print Bottom Border
+    print(colorize(bottom_border, Colors.BLUE))
+    print()

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "drunken-chunk",
+  "version": "1.0.0",
+  "description": "A beautiful, premium CLI water tracker, reminders & behavior analytics tool with cross-platform native desktop notifications.",
+  "main": "bin/index.js",
+  "bin": {
+    "drunken-chunk": "bin/index.js"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "keywords": [
+    "water",
+    "tracker",
+    "cli",
+    "hydrator",
+    "hydration",
+    "health",
+    "wellness",
+    "reminders",
+    "analytics"
+  ],
+  "author": "Antigravity Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vikashpatel04/drunken-chunk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vikashpatel04/drunken-chunk/issues"
+  },
+  "homepage": "https://github.com/vikashpatel04/drunken-chunk#readme"
+}