drunken-chunk 1.0.0

package/drunken_chunk/cli.py

@@ -0,0 +1,834 @@
+import argparse
+import sys
+import os
+import re
+import collections
+import io
+from datetime import datetime, timedelta
+
+# Force UTF-8 stdout/stderr on Windows to prevent cp1252 box-drawing encode errors
+if sys.platform == 'win32':
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+    sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8')
+
+from .db import (
+    init_db, get_profile, save_profile, log_water, get_today_logs,
+    get_history_logs, get_shortcuts, get_daemon_state, set_daemon_state
+)
+from .shortcut import add_custom_shortcut, remove_custom_shortcut
+from .profile import (
+    calculate_recommended_intake, get_profile_insights, get_hydration_level,
+    calculate_bmi, get_bmi_category, get_situational_art_and_quote
+)
+from .reminder import (
+    start_background_daemon, stop_background_daemon, is_pid_running, is_waking_hours
+)
+from .analytics import analyze_drinking_behavior, get_day_name
+from .utils import (
+    Colors, colorize, bold, italic, print_banner, get_progress_bar, print_table
+)
+
+def parse_relative_time(time_str):
+    """Parses relative time strings like '10m ago', '2h ago', '14:30', or 'now'."""
+    now = datetime.now()
+    time_str = time_str.strip().lower()
+    
+    if time_str == "now":
+        return now
+        
+    # Check for minutes ago (e.g. 10m ago, 5 mins ago)
+    m_match = re.match(r'^(\d+)\s*(m|min|minute|minutes)\s*ago$', time_str)
+    if m_match:
+        minutes = int(m_match.group(1))
+        return now - timedelta(minutes=minutes)
+        
+    # Check for hours ago (e.g. 2h ago, 1 hour ago)
+    h_match = re.match(r'^(\d+)\s*(h|hr|hour|hours)\s*ago$', time_str)
+    if h_match:
+        hours = int(h_match.group(1))
+        return now - timedelta(hours=hours)
+        
+    # Check for absolute HH:MM
+    time_match = re.match(r'^(\d{1,2}):(\d{2})$', time_str)
+    if time_match:
+        h, m = int(time_match.group(1)), int(time_match.group(2))
+        if 0 <= h < 24 and 0 <= m < 60:
+            target_time = now.replace(hour=h, minute=m, second=0, microsecond=0)
+            if target_time > now:
+                # If target time is in the future, assume it refers to yesterday
+                target_time -= timedelta(days=1)
+            return target_time
+            
+    return None
+
+def check_profile_exists():
+    """Checks if the user profile exists, prompts to initialize if not."""
+    profile = get_profile()
+    if not profile:
+        print(colorize("No user profile found! Let's set up your profile now.", Colors.YELLOW))
+        print()
+        handle_init(None)
+        profile = get_profile()
+        if not profile:
+            print(colorize("Error: Profile setup is required to run this command.", Colors.RED))
+            sys.exit(1)
+    return profile
+
+# ---------------- COMMAND HANDLERS ----------------
+
+def handle_init(args):
+    """Runs the interactive wizard to set up or reset the profile."""
+    print_banner()
+    print(colorize("Welcome to Drunken Chunk setup! Let's build your profile.", Colors.BOLD + Colors.CYAN))
+    print(colorize("We will calculate your ideal hydration targets based on your dimensions.", Colors.GRAY))
+    print()
+    
+    # Try getting existing profile
+    existing = get_profile()
+    if existing:
+        confirm = input(colorize(f"A profile for '{existing['name']}' already exists. Overwrite? (y/N): ", Colors.YELLOW)).strip().lower()
+        if confirm != 'y':
+            print("Setup cancelled.")
+            return
+
+    # User Input with basic validations
+    while True:
+        name = input("Enter your name: ").strip()
+        if name:
+            break
+        print(colorize("Name cannot be empty.", Colors.RED))
+        
+    while True:
+        try:
+            weight = float(input("Enter your weight in kg (e.g. 72.5): "))
+            if weight > 0:
+                break
+            print(colorize("Weight must be greater than 0.", Colors.RED))
+        except ValueError:
+            print(colorize("Please enter a valid decimal number.", Colors.RED))
+            
+    while True:
+        try:
+            height = float(input("Enter your height in cm (e.g. 178): "))
+            if height > 0:
+                break
+            print(colorize("Height must be greater than 0.", Colors.RED))
+        except ValueError:
+            print(colorize("Please enter a valid decimal number.", Colors.RED))
+            
+    while True:
+        wake_input = input("Waking up time (24h format, e.g. 07:00 or 7:00): ").strip()
+        time_match = re.match(r'^(\d{1,2}):(\d{2})$', wake_input)
+        if time_match:
+            h, m = int(time_match.group(1)), int(time_match.group(2))
+            if 0 <= h < 24 and 0 <= m < 60:
+                wake = f"{h:02d}:{m:02d}"
+                break
+        print(colorize("Invalid format. Please enter as H:MM or HH:MM.", Colors.RED))
+        
+    while True:
+        sleep_input = input("Sleeping time (24h format, e.g. 23:00 or 11:00): ").strip()
+        time_match = re.match(r'^(\d{1,2}):(\d{2})$', sleep_input)
+        if time_match:
+            h, m = int(time_match.group(1)), int(time_match.group(2))
+            if 0 <= h < 24 and 0 <= m < 60:
+                sleep = f"{h:02d}:{m:02d}"
+                break
+        print(colorize("Invalid format. Please enter as H:MM or HH:MM.", Colors.RED))
+        
+    while True:
+        try:
+            interval_str = input("Reminder frequency in minutes (default 60): ").strip()
+            if not interval_str:
+                interval = 60
+                break
+            interval = int(interval_str)
+            if interval > 0:
+                break
+            print(colorize("Interval must be a positive integer.", Colors.RED))
+        except ValueError:
+            print(colorize("Please enter a valid integer.", Colors.RED))
+
+    # Calculate recommended intake
+    recommended = calculate_recommended_intake(weight, height)
+    bmi = calculate_bmi(weight, height)
+    bmi_cat, bmi_color = get_bmi_category(bmi)
+    
+    print()
+    print(colorize(f"[ BODY PROFILE RESULTS ]", Colors.BOLD + Colors.CYAN))
+    print(f"  - BMI: {colorize(f'{bmi:.1f}', Colors.BOLD)} ({colorize(bmi_cat, bmi_color)})")
+    print(f"  - Calculated daily water target: {colorize(f'{recommended} ml', Colors.BOLD + Colors.GREEN)}")
+    print()
+    
+    custom_target = None
+    override = input("Would you like to set a custom target? (y/N): ").strip().lower()
+    if override == 'y':
+        while True:
+            try:
+                custom_target = int(input("Enter custom target in ml (e.g. 2500): "))
+                if custom_target > 0:
+                    break
+                print(colorize("Target must be greater than 0.", Colors.RED))
+            except ValueError:
+                print(colorize("Please enter a valid integer.", Colors.RED))
+                
+    save_profile(name, weight, height, wake, sleep, interval, custom_target)
+    
+    print()
+    print(colorize("[SUCCESS] Profile created successfully!", Colors.BOLD + Colors.GREEN))
+    print(colorize("To start receiving periodic notifications, run: ", Colors.GRAY) + colorize("drunken-chunk start", Colors.BOLD + Colors.WHITE))
+    print(colorize("To log water, run: ", Colors.GRAY) + colorize("drunken-chunk log <amount_or_shortcut>", Colors.BOLD + Colors.WHITE))
+
+def get_next_alert_status(profile, today_logs):
+    """Calculates next reminder alert timing or state for the user."""
+    pid = get_daemon_state("daemon_pid", "")
+    is_active = get_daemon_state("is_active", "0")
+    if not (is_active == "1" and pid and is_pid_running(pid)):
+        return "Service Stopped"
+        
+    now = datetime.now()
+    current_time_str = now.strftime("%H:%M")
+    if not is_waking_hours(current_time_str, profile['wake_time'], profile['sleep_time']):
+        return "Quiet Hours"
+        
+    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 "Completed"
+        
+    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 now < snooze_until:
+                snooze_left = int((snooze_until - now).total_seconds() / 60.0)
+                return f"Snoozed ({snooze_left}m left)"
+        except ValueError:
+            pass
+            
+    if today_logs:
+        last_drink_time = datetime.strptime(today_logs[-1]['timestamp'], "%Y-%m-%d %H:%M:%S")
+    else:
+        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 last_drink_time > now:
+            last_drink_time -= timedelta(days=1)
+            
+    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
+        
+    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)
+    
+    mins_remaining = int((due_time - now).total_seconds() / 60.0)
+    if mins_remaining <= 0:
+        return "Alert Imminent"
+    else:
+        return f"Alert in {mins_remaining}m"
+
+def handle_status(args):
+    """Displays today's progress, logs, profile insights, and level."""
+    profile = check_profile_exists()
+    today_logs = get_today_logs()
+    
+    total_today = sum(log['amount'] for log in today_logs)
+    target = profile['custom_target'] if profile['custom_target'] else calculate_recommended_intake(profile['weight'], profile['height'])
+    
+    percentage = (total_today / target * 100) if target > 0 else 0
+    
+    if hasattr(args, "mini") and args.mini:
+        bar = get_progress_bar(percentage, width=15)
+        alert_status = get_next_alert_status(profile, today_logs)
+        print(f"{bar} | {total_today}/{target} ml | {alert_status}")
+        return
+        
+    # Get profile insights
+    insights_data = get_profile_insights(profile, total_today)
+    
+    print_banner()
+    print(f"Hello, {bold(profile['name'])}!")
+    print(f"Daily Target: {bold(f'{target} ml')} | Today's Consumption: {colorize(f'{total_today} ml', Colors.GREEN if total_today >= target else Colors.CYAN)}")
+    print()
+    
+    # Progress Bar
+    print(f"Progress: {get_progress_bar(percentage)}")
+    print()
+    
+    # Hydration level
+    print(f"Current Level: {colorize(bold(insights_data['level_name']), insights_data['level_color'])}")
+    print(f"Status: {italic(insights_data['level_desc'])}")
+    print()
+    
+    # Situational ASCII art & funny quote
+    art, quote = get_situational_art_and_quote(percentage / 100.0)
+    print(colorize(art, insights_data['level_color']))
+    print(colorize(f'"{quote}"', Colors.GRAY + Colors.BOLD))
+    print()
+    
+    # Display Daemon status
+    pid = get_daemon_state("daemon_pid", "")
+    is_active = get_daemon_state("is_active", "0")
+    if is_active == "1" and pid and is_pid_running(pid):
+        daemon_status = colorize(f"ACTIVE (PID: {pid})", Colors.GREEN)
+    else:
+        daemon_status = colorize("STOPPED (Run 'drunken-chunk start' to activate)", Colors.RED)
+    print(f"Reminder Service: {daemon_status}")
+    print()
+    
+    # Display Today's Logs in table
+    if today_logs:
+        rows = []
+        for i, log in enumerate(today_logs, 1):
+            log_time = log['timestamp'].split(' ')[1]
+            rows.append([f"#{i}", log_time, f"{log['amount']} ml", log['type']])
+        print_table(["Index", "Time Logged", "Amount", "Source"], rows, title="Today's Drink Logs")
+    else:
+        print(colorize("You haven't logged any water today yet. Stay active!", Colors.YELLOW))
+        print()
+        
+    # Profile Insights
+    print(colorize("─── Body & Hydration Insights ───", Colors.BOLD + Colors.CYAN))
+    for insight in insights_data['insights']:
+        print(insight)
+    print()
+
+def handle_log(args):
+    """Logs water consumption using numbers or shortcuts."""
+    profile = check_profile_exists()
+    arg_input = args.amount_or_shortcut.strip().lower()
+    
+    shortcuts = get_shortcuts()
+    
+    # Check if numerical
+    if arg_input.isdigit():
+        amount = int(arg_input)
+        log_water(amount, "direct")
+        print(colorize(f"[SUCCESS] Gulp gulp! Logged {amount} ml of water. Your kidneys are celebrating!", Colors.GREEN))
+    # Check if it matches a shortcut
+    elif arg_input in shortcuts:
+        amount = shortcuts[arg_input]
+        log_water(amount, arg_input)
+        print(colorize(f"[SUCCESS] Gulp gulp! Logged {amount} ml of water using shortcut '{arg_input}'! Your kidneys are celebrating!", Colors.GREEN))
+    else:
+        print(colorize(f"Error: '{arg_input}' is not a valid number or shortcut.", Colors.RED))
+        if shortcuts:
+            print("Available shortcuts: " + ", ".join(f"{k} ({v}ml)" for k, v in shortcuts.items()))
+        else:
+            print("No shortcuts configured. Create one using: drunken-chunk shortcut add <name> <amount>")
+
+def handle_log_custom(args):
+    """Logs custom water amount at a specific past time."""
+    check_profile_exists()
+    amount = args.amount
+    time_str = args.time
+    
+    if amount <= 0:
+        print(colorize("Amount must be a positive integer.", Colors.RED))
+        return
+        
+    dt = parse_relative_time(time_str)
+    if not dt:
+        print(colorize(f"Error: Invalid time format '{time_str}'.", Colors.RED))
+        print(colorize("Supported formats: '10m ago', '2h ago', '14:30' (24h absolute), 'now'.", Colors.GRAY))
+        return
+        
+    timestamp = dt.strftime("%Y-%m-%d %H:%M:%S")
+    log_water(amount, "custom-log", timestamp)
+    print(colorize(f"[SUCCESS] Time-travel logging complete. Registered {amount} ml at {dt.strftime('%H:%M')} ({time_str}).", Colors.GREEN))
+
+def handle_shortcut(args):
+    """Manages custom drinking shortcuts."""
+    check_profile_exists()
+    subcommand = args.subcommand
+    
+    if subcommand == "add":
+        if not args.name or not args.amount:
+            print(colorize("Error: Name and Amount are required for 'add'.", Colors.RED))
+            print("Usage: drunken-chunk shortcut add <name> <amount_in_ml>")
+            return
+        success, msg = add_custom_shortcut(args.name, args.amount)
+        print(colorize(msg, Colors.GREEN if success else Colors.RED))
+        
+    elif subcommand == "remove":
+        if not args.name:
+            print(colorize("Error: Name is required for 'remove'.", Colors.RED))
+            print("Usage: drunken-chunk shortcut remove <name>")
+            return
+        success, msg = remove_custom_shortcut(args.name)
+        print(colorize(msg, Colors.GREEN if success else Colors.RED))
+        
+    elif subcommand == "list" or subcommand is None:
+        shortcuts = get_shortcuts()
+        if not shortcuts:
+            print(colorize("No custom shortcuts registered.", Colors.YELLOW))
+            return
+        rows = [[name, f"{amount} ml"] for name, amount in shortcuts.items()]
+        print_table(["Shortcut Name", "Intake Volume"], rows, title="Configured Shortcuts")
+
+def handle_profile(args):
+    """View or update user profile parameters."""
+    # Delete does not strictly require check_profile_exists to succeed, but we want to know if one exists first.
+    profile = get_profile()
+    
+    if args.delete:
+        if not profile:
+            print(colorize("No profile exists to delete.", Colors.YELLOW))
+            return
+            
+        confirm = input(colorize("Are you sure you want to delete your profile? (y/N): ", Colors.RED + Colors.BOLD)).strip().lower()
+        if confirm == 'y':
+            # Stop daemon first if active
+            stop_background_daemon()
+            
+            # Check logs deletion
+            delete_logs = input(colorize("Do you also want to delete all your water consumption logs? (y/N): ", Colors.YELLOW)).strip().lower()
+            
+            from .db import get_connection
+            conn = get_connection()
+            cursor = conn.cursor()
+            cursor.execute("DELETE FROM profile")
+            if delete_logs == 'y':
+                cursor.execute("DELETE FROM water_log")
+                print(colorize("Historical water consumption logs deleted.", Colors.YELLOW))
+            cursor.execute("DELETE FROM reminder_state")
+            cursor.execute("INSERT OR IGNORE INTO reminder_state (key, value) VALUES ('is_active', '0')")
+            cursor.execute("INSERT OR IGNORE INTO reminder_state (key, value) VALUES ('last_notified', '')")
+            conn.commit()
+            conn.close()
+            print(colorize("[SUCCESS] Profile deleted successfully. No data loss of logs occurred unless explicitly chosen.", Colors.GREEN))
+        else:
+            print("Deletion cancelled.")
+        return
+
+    # Check existence for other operations
+    profile = check_profile_exists()
+
+    if args.edit:
+        print(colorize("--- Interactive Profile Editor ---", Colors.BOLD + Colors.CYAN))
+        print("Press Enter to keep the current value.")
+        print()
+        
+        # Name
+        name = input(f"Enter your name [current: {profile['name']}]: ").strip()
+        if not name:
+            name = profile['name']
+            
+        # Weight
+        while True:
+            weight_str = input(f"Enter weight in kg [current: {profile['weight']}]: ").strip()
+            if not weight_str:
+                weight = profile['weight']
+                break
+            try:
+                weight = float(weight_str)
+                if weight > 0:
+                    break
+                print(colorize("Weight must be greater than 0.", Colors.RED))
+            except ValueError:
+                print(colorize("Please enter a valid decimal number.", Colors.RED))
+                
+        # Height
+        while True:
+            height_str = input(f"Enter height in cm [current: {profile['height']}]: ").strip()
+            if not height_str:
+                height = profile['height']
+                break
+            try:
+                height = float(height_str)
+                if height > 0:
+                    break
+                print(colorize("Height must be greater than 0.", Colors.RED))
+            except ValueError:
+                print(colorize("Please enter a valid decimal number.", Colors.RED))
+                
+        # Wake time
+        while True:
+            wake_input = input(f"Waking up time [current: {profile['wake_time']}]: ").strip()
+            if not wake_input:
+                wake = profile['wake_time']
+                break
+            time_match = re.match(r'^(\d{1,2}):(\d{2})$', wake_input)
+            if time_match:
+                h, m = int(time_match.group(1)), int(time_match.group(2))
+                if 0 <= h < 24 and 0 <= m < 60:
+                    wake = f"{h:02d}:{m:02d}"
+                    break
+            print(colorize("Invalid format. Please enter as H:MM or HH:MM.", Colors.RED))
+            
+        # Sleep time
+        while True:
+            sleep_input = input(f"Sleeping time [current: {profile['sleep_time']}]: ").strip()
+            if not sleep_input:
+                sleep = profile['sleep_time']
+                break
+            time_match = re.match(r'^(\d{1,2}):(\d{2})$', sleep_input)
+            if time_match:
+                h, m = int(time_match.group(1)), int(time_match.group(2))
+                if 0 <= h < 24 and 0 <= m < 60:
+                    sleep = f"{h:02d}:{m:02d}"
+                    break
+            print(colorize("Invalid format. Please enter as H:MM or HH:MM.", Colors.RED))
+            
+        # Interval
+        while True:
+            interval_str = input(f"Reminder frequency in minutes [current: {profile['reminder_interval']}]: ").strip()
+            if not interval_str:
+                interval = profile['reminder_interval']
+                break
+            try:
+                interval = int(interval_str)
+                if interval > 0:
+                    break
+                print(colorize("Interval must be a positive integer.", Colors.RED))
+            except ValueError:
+                print(colorize("Please enter a valid integer.", Colors.RED))
+                
+        # Daily target
+        recommended = calculate_recommended_intake(weight, height)
+        curr_target_desc = f"{profile['custom_target']} ml" if profile['custom_target'] else f"{recommended} ml (Auto-calculated)"
+        while True:
+            target_str = input(f"Daily target in ml [current: {curr_target_desc} - enter 'reset' for auto]: ").strip()
+            if not target_str:
+                custom_target = profile['custom_target']
+                break
+            if target_str.lower() == 'reset':
+                custom_target = None
+                break
+            try:
+                custom_target = int(target_str)
+                if custom_target > 0:
+                    break
+                print(colorize("Target must be a positive integer.", Colors.RED))
+            except ValueError:
+                print(colorize("Please enter a valid integer or 'reset'.", Colors.RED))
+                
+        save_profile(name, weight, height, wake, sleep, interval, custom_target)
+        print()
+        print(colorize("[SUCCESS] Profile updated successfully interactively!", Colors.GREEN))
+        profile = get_profile() # Reload
+        
+    elif args.weight or args.height or args.wake or args.sleep or args.interval or args.target:
+        # Perform updates
+        name = profile['name']
+        weight = args.weight if args.weight else profile['weight']
+        height = args.height if args.height else profile['height']
+        wake = args.wake if args.wake else profile['wake_time']
+        sleep = args.sleep if args.sleep else profile['sleep_time']
+        interval = args.interval if args.interval else profile['reminder_interval']
+        custom_target = profile['custom_target']
+        
+        if args.target:
+            if args.target.lower() == 'reset':
+                custom_target = None
+            else:
+                try:
+                    custom_target = int(args.target)
+                except ValueError:
+                    print(colorize("Target must be a number or 'reset'.", Colors.RED))
+                    return
+                    
+        save_profile(name, weight, height, wake, sleep, interval, custom_target)
+        print(colorize("Profile updated successfully!", Colors.GREEN))
+        profile = get_profile() # Reload
+        
+    # Display Profile
+    recommended = calculate_recommended_intake(profile['weight'], profile['height'])
+    target = profile['custom_target'] if profile['custom_target'] else recommended
+    bmi = calculate_bmi(profile['weight'], profile['height'])
+    bmi_cat, bmi_color = get_bmi_category(bmi)
+    
+    print_table(
+        ["Field", "Value"],
+        [
+            ["Name", profile['name']],
+            ["Weight", f"{profile['weight']} kg"],
+            ["Height", f"{profile['height']} cm"],
+            ["BMI", f"{bmi:.1f} ({bmi_cat})"],
+            ["Waking Hours", f"{profile['wake_time']} - {profile['sleep_time']}"],
+            ["Reminder Interval", f"{profile['reminder_interval']} minutes"],
+            ["Recommended Target", f"{recommended} ml"],
+            ["Current Target", f"{target} ml" + (" (Custom)" if profile['custom_target'] else " (Auto)")],
+            ["Member Since", profile['joined_date'].split(' ')[0]]
+        ],
+        title="User Profile Details"
+    )
+
+def handle_history(args):
+    """Shows logging history over the last N days."""
+    profile = check_profile_exists()
+    days = args.days
+    
+    logs = get_history_logs(days)
+    if not logs:
+        print(colorize(f"No history logs found for the last {days} days.", Colors.YELLOW))
+        return
+        
+    target = profile['custom_target'] if profile['custom_target'] else calculate_recommended_intake(profile['weight'], profile['height'])
+    
+    # Group logs by date
+    daily_groups = collections.defaultdict(int)
+    daily_counts = collections.defaultdict(int)
+    for log in logs:
+        date = log['timestamp'].split(' ')[0]
+        daily_groups[date] += log['amount']
+        daily_counts[date] += 1
+        
+    rows = []
+    # Print chronological or reverse chronological? Let's do reverse chronological (newest first)
+    sorted_dates = sorted(daily_groups.keys(), reverse=True)
+    
+    for date in sorted_dates:
+        amount = daily_groups[date]
+        count = daily_counts[date]
+        pct = (amount / target * 100) if target > 0 else 0
+        status_lvl, _, _ = get_hydration_level(amount, target)
+        
+        # Colorize success
+        amt_str = colorize(f"{amount} ml", Colors.GREEN if amount >= target else Colors.CYAN)
+        bar = get_progress_bar(pct, width=15)
+        
+        rows.append([
+            date,
+            get_day_name(date),
+            amt_str,
+            f"{count} drinks",
+            bar,
+            status_lvl.split(' [')[0] if ' [' in status_lvl else status_lvl
+        ])
+        
+    print_table(["Date", "Day", "Total Consumed", "Count", "Progress Bar", "Level"], rows, title=f"Hydration Log - Last {days} Days")
+
+def handle_analyze(args):
+    """Runs the analytics engine to draw deep drinking habits insight."""
+    check_profile_exists()
+    analysis = analyze_drinking_behavior()
+    
+    if "error" in analysis:
+        print(colorize(analysis["error"], Colors.RED))
+        return
+        
+    print_banner()
+    print(bold(colorize("[ HYDRO-TELEMETRY INTELLIGENCE REPORT ]", Colors.CYAN)))
+    print(colorize("Analyzing your historical logs to map dehydration vectors & habit profiles.", Colors.GRAY))
+    print()
+    
+    # 1. High-level Summary Card
+    target = analysis['target']
+    summary_rows = [
+        ["Total Consumed Logs", f"{analysis['total_consumed']} ml across {analysis['total_entries']} entries"],
+        ["Unique Active Days", f"{analysis['unique_days']} days"],
+        ["Average Daily Intake", f"{analysis['avg_daily']:.0f} ml / day (Target: {target} ml)"],
+        ["Target Hit Rate", f"{analysis['hit_rate']:.1f}% of days"],
+        ["Consistency Index", f"{analysis['consistency_index']:.1f}% (Met 80% target in last 14 days)"]
+    ]
+    print_table(["Metric", "Measurement"], summary_rows, title="Summary Statistics")
+    
+    # 2. Weekday Analysis Graph
+    weekday_rows = []
+    for day, avg in analysis['weekday_averages'].items():
+        pct = (avg / target * 100) if target > 0 else 0
+        bar = get_progress_bar(pct, width=12)
+        weekday_rows.append([day, f"{avg:.0f} ml", bar])
+    print_table(["Day of Week", "Average Volume", "Progress Vs Target"], weekday_rows, title="Weekday Analysis")
+    
+    # 3. Time of Day Analysis Graph
+    time_rows = []
+    for block, pct in analysis['time_block_pct'].items():
+        # Custom small bar for percentage
+        bar_len = int(pct // 5)
+        bar = colorize("█" * bar_len, Colors.CYAN) + colorize("░" * (20 - bar_len), Colors.GRAY)
+        time_rows.append([block, f"{pct:.1f}%", f"[{bar}]"])
+    print_table(["Time Window", "Share of Consumption", "Visual Spread"], time_rows, title="Diurnal Hydration Spread")
+    
+    # 4. Habits, Insights and Warnings
+    print(colorize("─── Predictive Insights & Suggestions ───", Colors.BOLD + Colors.CYAN))
+    for sug in analysis['suggestions']:
+        print(sug)
+    print()
+
+def handle_start(args):
+    """Starts the notification background daemon."""
+    check_profile_exists()
+    success, msg = start_background_daemon()
+    if success:
+        print(colorize(msg, Colors.GREEN))
+    else:
+        print(colorize(msg, Colors.YELLOW))
+
+def handle_stop(args):
+    """Stops the notification background daemon."""
+    success, msg = stop_background_daemon()
+    if success:
+        print(colorize(msg, Colors.GREEN))
+    else:
+        print(colorize(msg, Colors.RED))
+
+def handle_snooze(args):
+    """Snoozes the water reminder alerts for a specific time."""
+    check_profile_exists()
+    minutes = args.minutes
+    if minutes <= 0:
+        print(colorize("[ERROR] Snooze duration must be a positive integer.", Colors.RED))
+        return
+        
+    snooze_until = datetime.now() + timedelta(minutes=minutes)
+    snooze_until_str = snooze_until.strftime("%Y-%m-%d %H:%M:%S")
+    set_daemon_state("snooze_until", snooze_until_str)
+    print(colorize(f"[SUCCESS] Alerts silenced. Go hide from your responsibilities (and hydration) for {minutes} minutes (until {snooze_until.strftime('%H:%M:%S')}).", Colors.GREEN))
+
+def handle_undo(args):
+    """Undoes and deletes the last water log recorded."""
+    check_profile_exists()
+    from .db import undo_last_log
+    undone = undo_last_log()
+    if undone:
+        print(colorize(f"[SUCCESS] Reverting time like a water-bending wizard. Undid last drink: deleted {undone['amount']} ml (logged at {undone['timestamp'].split(' ')[1]}).", Colors.GREEN))
+    else:
+        print(colorize("[WARNING] No water log entries found to undo.", Colors.YELLOW))
+
+def handle_autostart(args):
+    """Handles system startup autostart toggling/status operations."""
+    check_profile_exists()
+    from .reminder import manage_autostart
+    success, msg = manage_autostart(args.action)
+    if success:
+        print(colorize(msg, Colors.GREEN))
+    else:
+        print(colorize(f"[ERROR] {msg}", Colors.RED))
+
+# ---------------- CLI ARGUMENT ROUTING ----------------
+
+def main():
+    # Initialize the database and create tables if they do not exist yet
+    init_db()
+    
+    # Intercept '-help' typo and convert it to standard '--help'
+    for idx, arg in enumerate(sys.argv):
+        if arg.lower() in ('-help', '-hlep', '--hlep'):
+            sys.argv[idx] = '--help'
+            
+    parser = argparse.ArgumentParser(
+        description="drunken-chunk - Premium CLI Water Tracker, Reminders, and Behavioral Analytics."
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Subcommand to execute")
+
+    # init
+    subparsers.add_parser("init", help="Run interactive setup/wizard to build your profile. Example: drunken-chunk init")
+
+    # status
+    status_parser = subparsers.add_parser("status", help="Show today's logging dashboard and profile insights. Example: drunken-chunk status (or status -m)")
+    status_parser.add_argument("-m", "--mini", action="store_true", help="Print a single-line compact status summary")
+
+    # log
+    log_parser = subparsers.add_parser("log", help="Log water intake. Example: drunken-chunk log 300 (or log glass)")
+    log_parser.add_argument(
+        "amount_or_shortcut",
+        help="Volume in ml (e.g. 250) or a registered shortcut name (e.g. glass)"
+    )
+
+    # log-custom
+    log_cust_parser = subparsers.add_parser("log-custom", help="Log water at a custom/relative time. Example: drunken-chunk log-custom 250 '10m ago'")
+    log_cust_parser.add_argument("amount", type=int, help="Volume in ml")
+    log_cust_parser.add_argument("time", help="Relative time (e.g. '10m ago', '2h ago') or absolute HH:MM")
+
+    # shortcut
+    short_parser = subparsers.add_parser("shortcut", help="Manage shortcuts. Example: drunken-chunk shortcut list (or shortcut add cup 150)")
+    short_sub = short_parser.add_subparsers(dest="subcommand", help="Shortcut operation")
+    
+    # shortcut add
+    add_sub = short_sub.add_parser("add", help="Add/update a custom shortcut. Example: drunken-chunk shortcut add mug 350")
+    add_sub.add_argument("name", help="Name of shortcut (e.g. mug)")
+    add_sub.add_argument("amount", help="Water volume in ml (e.g. 350)")
+    
+    # shortcut remove
+    rem_sub = short_sub.add_parser("remove", help="Remove a shortcut. Example: drunken-chunk shortcut remove bottle")
+    rem_sub.add_argument("name", help="Name of shortcut to remove")
+    
+    # shortcut list
+    short_sub.add_parser("list", help="List registered shortcuts. Example: drunken-chunk shortcut list")
+
+    # profile
+    prof_parser = subparsers.add_parser("profile", help="View or modify your profile. Example: drunken-chunk profile --weight 72.5")
+    prof_parser.add_argument("--weight", type=float, help="Update weight in kg")
+    prof_parser.add_argument("--height", type=float, help="Update height in cm")
+    prof_parser.add_argument("--wake", help="Update wake time (HH:MM)")
+    prof_parser.add_argument("--sleep", help="Update sleep time (HH:MM)")
+    prof_parser.add_argument("--interval", type=int, help="Update reminder interval in minutes")
+    prof_parser.add_argument("--target", help="Update daily target in ml (or 'reset' to auto-calculate)")
+    prof_parser.add_argument("--edit", action="store_true", help="Interactively edit your profile data. Example: drunken-chunk profile --edit")
+    prof_parser.add_argument("--delete", action="store_true", help="Delete your profile (with warning check). Example: drunken-chunk profile --delete")
+
+    # history
+    hist_parser = subparsers.add_parser("history", help="Show intake logs over past days. Example: drunken-chunk history --days 5")
+    hist_parser.add_argument("--days", type=int, default=7, help="Number of history days to show (default: 7)")
+
+    # analyze
+    subparsers.add_parser("analyze", help="Analyze drinking behavior, habits, and get health insights. Example: drunken-chunk analyze")
+
+    # start daemon
+    subparsers.add_parser("start", help="Start background water reminder daemon. Example: drunken-chunk start")
+
+    # stop daemon
+    subparsers.add_parser("stop", help="Stop background water reminder daemon. Example: drunken-chunk stop")
+
+    # snooze
+    snooze_parser = subparsers.add_parser("snooze", help="Snooze reminder notifications. Example: drunken-chunk snooze 45")
+    snooze_parser.add_argument("minutes", type=int, nargs="?", default=30, help="Snooze duration in minutes (default: 30)")
+
+    # undo
+    subparsers.add_parser("undo", help="Undo/delete the last logged water consumption. Example: drunken-chunk undo")
+
+    # autostart
+    auto_parser = subparsers.add_parser("autostart", help="Toggle or configure system startup autostart. Example: drunken-chunk autostart status")
+    auto_parser.add_argument("action", nargs="?", default="toggle", choices=["toggle", "enable", "disable", "status"], help="Autostart action to perform (default: toggle)")
+
+    # Parse arguments
+    args = parser.parse_args()
+
+    # Route command to appropriate handler
+    if args.command == "init":
+        handle_init(args)
+    elif args.command == "status":
+        handle_status(args)
+    elif args.command == "log":
+        handle_log(args)
+    elif args.command == "log-custom":
+        handle_log_custom(args)
+    elif args.command == "shortcut":
+        handle_shortcut(args)
+    elif args.command == "profile":
+        handle_profile(args)
+    elif args.command == "history":
+        handle_history(args)
+    elif args.command == "analyze":
+        handle_analyze(args)
+    elif args.command == "start":
+        handle_start(args)
+    elif args.command == "stop":
+        handle_stop(args)
+    elif args.command == "snooze":
+        handle_snooze(args)
+    elif args.command == "undo":
+        handle_undo(args)
+    elif args.command == "autostart":
+        handle_autostart(args)
+    else:
+        # Default behavior: show status if profile exists, otherwise banner + help
+        profile = get_profile()
+        if profile:
+            handle_status(args)
+        else:
+            print_banner()
+            parser.print_help()
+
+if __name__ == "__main__":
+    main()