awatch 1.0.0__py3-none-any.whl

awatch/__init__.py

@@ -0,0 +1,5 @@
+"""awatch - Terminal log monitoring dashboard."""
+__version__ = "1.0.0"
+__author__ = "Ashish"
+
+from .dashboard import main

awatch/dashboard.py

@@ -0,0 +1,963 @@
+#!/usr/bin/env python3
+
+
+# Release version: 2/jan/2026 
+# created by: Ashish
+# python dash.py 
+# python dash.py --no-limit (for no log limit)
+
+
+import curses
+import time
+import re
+import os
+from datetime import datetime
+from collections import deque, Counter
+import sys
+import threading
+
+class LogParser:
+    SYSLOG_PATTERN = re.compile(
+        r'(?P<timestamp>\w{3}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2}|'
+        r'\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?)\s+'
+        r'(?P<host>\S+)\s+(?P<process>\S+?)(?:\[(?P<pid>\d+)\])?:\s+(?P<message>.*)'
+    )
+    
+    SEVERITY_MAP = {
+        'CRITICAL': re.compile(r'\b(CRITICAL|CRIT|FATAL|EMERG|EMERGENCY)\b', re.I),
+        'ALERT': re.compile(r'\bALERT\b', re.I),
+        'ERROR': re.compile(r'\b(ERROR|ERR|FAILURE|FAILED)\b', re.I),
+        'WARN': re.compile(r'\b(WARN|WARNING)\b', re.I),
+        'INFO': re.compile(r'\b(INFO|INFORMATION|NOTICE)\b', re.I),
+        'DEBUG': re.compile(r'\b(DEBUG|TRACE)\b', re.I),
+    }
+    
+    @staticmethod
+    def parse(line):
+        line = line.strip()
+        if not line:
+            return None
+        
+        match = LogParser.SYSLOG_PATTERN.match(line)
+        data = match.groupdict() if match else {
+            'timestamp': '', 'host': '', 'process': '', 'pid': '', 'message': line
+        }
+        
+        for sev, pat in LogParser.SEVERITY_MAP.items():
+            if pat.search(line):
+                data['severity'] = sev
+                break
+        else:
+            data['severity'] = 'INFO'
+        
+        data['raw'] = line
+        return data
+
+class LogMonitor:
+    def __init__(self, filepath, callback, max_history=10000, no_limit=False):
+        self.filepath = filepath
+        self.callback = callback
+        self.max_history = max_history
+        self.no_limit = no_limit
+        self.running = False
+        self.thread = None
+        self.file_handle = None
+        self.chunk_size = 8192
+        
+    def start(self):
+        self.running = True
+        self.thread = threading.Thread(target=self._monitor, daemon=True)
+        self.thread.start()
+    
+    def stop(self):
+        self.running = False
+        if self.file_handle:
+            self.file_handle.close()
+    
+    def _monitor(self):
+        try:
+            if os.path.exists(self.filepath):
+                with open(self.filepath, 'r', errors='ignore') as f:
+                    # CRITICAL FIX: Always read from the END of file to get LATEST logs
+                    f.seek(0, 2)  # Go to end
+                    file_size = f.tell()
+                    
+                    if self.no_limit:
+                        # If no limit, read entire file from start
+                        f.seek(0)
+                    else:
+                        # IMPORTANT: For recent logs, read ONLY the last portion
+                        # Read last 2MB or 10000 lines, whichever comes first
+                        read_size = min(2 * 1024 * 1024, file_size)  # Last 2MB max
+                        f.seek(max(0, file_size - read_size))
+                        
+                        # Skip partial first line
+                        if file_size > read_size:
+                            f.readline()
+                    
+                    # Read all remaining lines into memory first
+                    all_lines = []
+                    for line in f:
+                        if self.running and line.strip():
+                            all_lines.append(line)
+                    
+                    # If we have more lines than max_history, take only the LAST ones
+                    if not self.no_limit and len(all_lines) > self.max_history:
+                        all_lines = all_lines[-self.max_history:]
+                    
+                    # Now process these lines
+                    for line in all_lines:
+                        if not self.running:
+                            return
+                        self.callback(line, False)
+                
+                # Open handle for monitoring NEW logs from current position
+                self.file_handle = open(self.filepath, 'r', errors='ignore')
+                self.file_handle.seek(0, 2)  # Start at absolute END
+                
+                # Monitor for new lines
+                while self.running:
+                    current_pos = self.file_handle.tell()
+                    line = self.file_handle.readline()
+                    
+                    if line:
+                        if line.strip():
+                            self.callback(line, True)
+                    else:
+                        # Check for file rotation/truncation
+                        try:
+                            current_size = os.path.getsize(self.filepath)
+                            
+                            if current_size < current_pos:
+                                # File was rotated or truncated
+                                self.file_handle.close()
+                                time.sleep(0.1)
+                                
+                                if os.path.exists(self.filepath):
+                                    self.file_handle = open(self.filepath, 'r', errors='ignore')
+                                    self.file_handle.seek(0, 2)
+                            else:
+                                # No new data yet
+                                self.file_handle.seek(current_pos)
+                                time.sleep(0.05)
+                        except (OSError, IOError):
+                            time.sleep(0.1)
+                            
+        except Exception as e:
+            import traceback
+            error_msg = f"ERROR: {str(e)}\n{traceback.format_exc()}\n"
+            self.callback(error_msg, True)
+
+class LogDashboard:
+    def __init__(self, stdscr, logfile=None, no_limit=False):
+        self.stdscr = stdscr
+        self.logfile = logfile or "/var/log/syslog"
+        self.no_limit = no_limit
+        self.search_term = ""
+        self.search_severity = ""
+        self.input_mode = None
+        self.input_buffer = ""
+        self.loading = False
+        self.needs_redraw = True
+        self.last_draw_time = 0
+        
+        curses.start_color()
+        curses.init_pair(1, curses.COLOR_RED, curses.COLOR_BLACK)
+        curses.init_pair(2, curses.COLOR_YELLOW, curses.COLOR_BLACK)
+        curses.init_pair(3, curses.COLOR_CYAN, curses.COLOR_BLACK)
+        curses.init_pair(4, curses.COLOR_BLUE, curses.COLOR_BLACK)
+        curses.init_pair(5, curses.COLOR_GREEN, curses.COLOR_BLACK)
+        curses.init_pair(6, curses.COLOR_WHITE, curses.COLOR_BLACK)
+        curses.init_pair(7, curses.COLOR_MAGENTA, curses.COLOR_BLACK)
+        curses.init_pair(8, curses.COLOR_BLACK, curses.COLOR_YELLOW)  # Highlight color
+        
+        max_len = None if no_limit else 10000
+        self.logs = deque(maxlen=max_len)
+        self.filtered_logs = deque(maxlen=max_len)
+        self.severity_counts = Counter()
+        self.total_logs = 0
+        
+        self.critical_history = deque([0]*50, maxlen=50)
+        self.warn_history = deque([0]*50, maxlen=50)
+        self.error_history = deque([0]*50, maxlen=50)
+        self.info_history = deque([0]*50, maxlen=50)
+        
+        self.system_name = os.uname().nodename if hasattr(os, 'uname') else "SYSTEM"
+        self.status = "LOADING"
+        self.monitor = None
+        self.scroll_pos = 0
+        self.detail_view = False
+        self.detail_scroll = 0
+        self.detail_search = ""
+        self.detail_input_mode = False
+        self.detail_input_buffer = ""
+        self.last_log_time = None  # Track when last log was received
+        
+        curses.curs_set(0)
+        self.stdscr.nodelay(1)
+        self.start_monitoring()
+    
+    def get_file_size(self):
+        try:
+            if os.path.exists(self.logfile):
+                size = os.path.getsize(self.logfile)
+                if size < 1024:
+                    return f"{size}B"
+                elif size < 1024*1024:
+                    return f"{size/1024:.1f}KB"
+                elif size < 1024*1024*1024:
+                    return f"{size/(1024*1024):.1f}MB"
+                else:
+                    return f"{size/(1024*1024*1024):.1f}GB"
+        except:
+            pass
+        return "N/A"
+    
+    def start_monitoring(self):
+        if self.monitor:
+            self.monitor.stop()
+        
+        self.status = "LOADING"
+        
+        # CRITICAL: Clear ALL old data before loading new
+        self.logs.clear()
+        self.filtered_logs.clear()
+        self.severity_counts.clear()
+        self.total_logs = 0
+        self.scroll_pos = 0
+        self.last_log_time = None
+        
+        # Clear time series
+        self.critical_history.clear()
+        self.warn_history.clear()
+        self.error_history.clear()
+        self.info_history.clear()
+        for _ in range(50):
+            self.critical_history.append(0)
+            self.warn_history.append(0)
+            self.error_history.append(0)
+            self.info_history.append(0)
+        
+        self.loading = True
+        self.needs_redraw = True
+        
+        try:
+            if os.path.exists(self.logfile):
+                self.monitor = LogMonitor(self.logfile, self.on_log_line, no_limit=self.no_limit)
+                self.monitor.start()
+                time.sleep(0.5)
+                self.status = "LIVE"
+            else:
+                self.status = "FILE NOT FOUND"
+        except Exception as e:
+            self.status = f"ERROR: {str(e)}"
+        finally:
+            self.loading = False
+            self.needs_redraw = True
+    
+    def on_log_line(self, line, is_new=False):
+        parsed = LogParser.parse(line)
+        if not parsed:
+            return
+        
+        self.logs.append(parsed)
+        self.total_logs += 1
+        self.severity_counts[parsed['severity']] += 1
+        self.last_log_time = datetime.now()  # Update last log time
+        
+        if self.total_logs % 10 == 0:
+            self.update_time_series()
+        
+        self.update_filtered_logs()
+        self.needs_redraw = True
+    
+    def update_time_series(self):
+        recent = list(self.logs)[-100:] if len(self.logs) > 100 else list(self.logs)
+        
+        self.critical_history.append(sum(1 for l in recent if l['severity'] in ['CRITICAL', 'ALERT']))
+        self.warn_history.append(sum(1 for l in recent if l['severity'] == 'WARN'))
+        self.error_history.append(sum(1 for l in recent if l['severity'] == 'ERROR'))
+        self.info_history.append(sum(1 for l in recent if l['severity'] in ['INFO', 'DEBUG']))
+    
+    def update_filtered_logs(self):
+        self.filtered_logs.clear()
+        for log in self.logs:
+            if self.search_severity and log['severity'] != self.search_severity:
+                continue
+            if self.search_term and self.search_term.lower() not in log['raw'].lower():
+                continue
+            self.filtered_logs.append(log)
+        self.needs_redraw = True
+    
+    def safe_addch(self, y, x, ch, attr=0):
+        max_y, max_x = self.stdscr.getmaxyx()
+        if 0 <= y < max_y and 0 <= x < max_x:
+            try:
+                self.stdscr.addch(y, x, ch, attr)
+            except curses.error:
+                pass
+    
+    def safe_addstr(self, y, x, text, attr=0):
+        max_y, max_x = self.stdscr.getmaxyx()
+        if 0 <= y < max_y and 0 <= x < max_x:
+            available = max_x - x - 1
+            if len(text) > available:
+                text = text[:available]
+            try:
+                self.stdscr.addstr(y, x, text, attr)
+            except curses.error:
+                pass
+    
+    def highlight_text(self, y, x, text, base_color, search_term, search_severity):
+        """Draw text with highlighted search terms"""
+        max_y, max_x = self.stdscr.getmaxyx()
+        if y < 0 or y >= max_y or x < 0 or x >= max_x:
+            return
+        
+        available = max_x - x - 1
+        if available <= 0:
+            return
+        
+        # Truncate text if needed
+        if len(text) > available:
+            text = text[:available]
+        
+        if not search_term and not search_severity:
+            # No highlighting needed
+            self.safe_addstr(y, x, text, base_color)
+            return
+        
+        # Convert to lowercase for case-insensitive search
+        text_lower = text.lower()
+        search_lower = search_term.lower() if search_term else ""
+        severity_lower = search_severity.lower() if search_severity else ""
+        
+        # Find all matches
+        matches = []
+        if search_lower:
+            start = 0
+            while True:
+                pos = text_lower.find(search_lower, start)
+                if pos == -1:
+                    break
+                matches.append((pos, pos + len(search_lower)))
+                start = pos + 1
+        
+        if severity_lower:
+            start = 0
+            while True:
+                pos = text_lower.find(severity_lower, start)
+                if pos == -1:
+                    break
+                matches.append((pos, pos + len(severity_lower)))
+                start = pos + 1
+        
+        if not matches:
+            # No matches found, draw normally
+            self.safe_addstr(y, x, text, base_color)
+            return
+        
+        # Merge overlapping ranges
+        matches.sort()
+        merged = []
+        for start, end in matches:
+            if merged and start <= merged[-1][1]:
+                merged[-1] = (merged[-1][0], max(merged[-1][1], end))
+            else:
+                merged.append((start, end))
+        
+        # Draw text with highlights
+        current_x = x
+        last_end = 0
+        
+        for match_start, match_end in merged:
+            # Draw text before match
+            if match_start > last_end:
+                before = text[last_end:match_start]
+                self.safe_addstr(y, current_x, before, base_color)
+                current_x += len(before)
+            
+            # Draw highlighted match
+            match = text[match_start:match_end]
+            self.safe_addstr(y, current_x, match, curses.color_pair(8) | curses.A_BOLD)
+            current_x += len(match)
+            
+            last_end = match_end
+        
+        # Draw remaining text
+        if last_end < len(text):
+            remaining = text[last_end:]
+            self.safe_addstr(y, current_x, remaining, base_color)
+    
+    def draw_box(self, y, x, h, w, title="", bottom_hint=""):
+        max_y, max_x = self.stdscr.getmaxyx()
+        if y < 0 or x < 0 or y + h > max_y or x + w > max_x:
+            return
+        
+        self.safe_addstr(y, x, "╭")
+        self.safe_addstr(y, x + w - 1, "╮")
+        self.safe_addstr(y + h - 1, x, "╰")
+        self.safe_addstr(y + h - 1, x + w - 1, "╯")
+        
+        for i in range(1, w - 1):
+            self.safe_addstr(y, x + i, "─")
+            self.safe_addstr(y + h - 1, x + i, "─")
+        
+        for i in range(1, h - 1):
+            self.safe_addstr(y + i, x, "│")
+            self.safe_addstr(y + i, x + w - 1, "│")
+        
+        if title and len(title) < w - 4:
+            self.safe_addstr(y, x + 2, f" {title} ", curses.A_BOLD)
+        
+        if bottom_hint and len(bottom_hint) < w - 4:
+            hint_x = x + (w - len(bottom_hint) - 2) // 2
+            self.safe_addstr(y + h - 1, hint_x, f" {bottom_hint} ", curses.A_DIM)
+    
+    def draw_bar_chart(self, y, x, h, w, data):
+        if not data or h < 3 or w < 5:
+            return
+        
+        chart_h = h - 2
+        chart_w = w - 4
+        if chart_w <= 0 or chart_h <= 0:
+            return
+        
+        num_bars = min(len(data), chart_w)
+        display = list(data)[-num_bars:]
+        max_val = max(display) if display else 1
+        
+        for i, val in enumerate(display):
+            bar_h = int((val / max_val) * chart_h) if max_val > 0 else 0
+            bar_h = min(bar_h, chart_h)
+            bar_x = x + 2 + i
+            
+            if bar_x >= x + w - 2:
+                break
+            
+            for j in range(bar_h):
+                bar_y = y + h - 2 - j
+                if bar_y > y and bar_x < x + w - 2:
+                    self.safe_addch(bar_y, bar_x, '|')
+    
+    def get_severity_color(self, severity):
+        colors = {
+            'CRITICAL': curses.color_pair(1),
+            'ALERT': curses.color_pair(7),
+            'ERROR': curses.color_pair(1),
+            'WARN': curses.color_pair(2),
+            'INFO': curses.color_pair(3),
+            'DEBUG': curses.color_pair(4),
+        }
+        return colors.get(severity, curses.color_pair(6))
+    
+    def draw_loading(self, max_y, max_x):
+        main_width = max_x - 2
+        self.draw_box(0, 1, max_y, main_width, "LOADING")
+        
+        mario = [
+                "██╗   ██╗███████╗██╗  ██╗ █████╗ ███╗   ██╗████████╗ ",
+                "██║   ██║██╔════╝██║  ██║██╔══██╗████╗  ██║╚══██╔══╝ ",
+                "██║   ██║█████╗  ███████║███████║██╔██╗ ██║   ██║    ",
+                "╚██╗ ██╔╝██╔══╝  ██╔══██║██╔══██║██║╚██╗██║   ██║    ",
+                " ╚████╔╝ ███████╗██║  ██║██║  ██║██║ ╚████║   ██║    ",
+                "  ╚═══╝  ╚══════╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝   ╚═╝    "
+                ]
+        
+        start_y = max_y // 2 - len(mario) // 2
+        for i, line in enumerate(mario):
+            self.safe_addstr(start_y + i, (max_x - len(line)) // 2, line, curses.color_pair(1) | curses.A_BOLD)
+        
+        msg = "LOADING LOGS..."
+        self.safe_addstr(start_y + len(mario) + 2, (max_x - len(msg)) // 2, msg, curses.A_BOLD)
+        
+        if self.no_limit:
+            limit_msg = "Mode: NO LIMIT (Loading all logs)"
+            self.safe_addstr(start_y + len(mario) + 3, (max_x - len(limit_msg)) // 2, limit_msg, curses.color_pair(2))
+        else:
+            limit_msg = "Mode: LIMITED (Last 10,000 logs)"
+            self.safe_addstr(start_y + len(mario) + 3, (max_x - len(limit_msg)) // 2, limit_msg, curses.color_pair(3))
+    
+    def draw_main_dashboard(self, max_y, max_x):
+        main_width = max_x - 2
+        
+        self.draw_box(0, 1, max_y, main_width, "")
+        
+        self.draw_box(1, 2, 3, main_width - 2, "")
+        status_color = curses.color_pair(5) if self.status == "LIVE" else curses.color_pair(1)
+        self.safe_addstr(2, 4, f"STATUS: {self.status}", status_color | curses.A_BOLD)
+        
+        # Show last log time in the middle
+        if self.last_log_time and self.logs:
+            last_log = list(self.logs)[-1]  # Get the most recent log
+            last_ts = last_log.get('timestamp', '')
+            
+            # Also get first log to show range
+            first_log = list(self.logs)[0]
+            first_ts = first_log.get('timestamp', '')
+            
+            if last_ts:
+                # Extract just the date part for comparison
+                last_date = last_ts[:10] if len(last_ts) >= 10 else last_ts[:8]
+                last_info = f"LAST LOG: {last_ts[:19]}"
+                
+                # Color code based on how recent it is
+                log_color = curses.color_pair(3)
+                current_date = datetime.now().strftime("%Y-%m-%d")
+                if last_date != current_date[:10] and last_date != current_date[:8]:
+                    # Log is not from today - show in yellow/red
+                    log_color = curses.color_pair(2) | curses.A_BOLD
+                
+                self.safe_addstr(2, (main_width // 2) - 15, last_info, log_color)
+        
+        date_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        self.safe_addstr(2, max_x - len(date_time) - 10, f"TIME: {date_time}")
+        
+        has_graphs = max_x >= 130
+        left_width = (max_x // 2) - 3 if has_graphs else main_width - 2
+        
+        system_y = 5
+        system_h = 5  # Increased from 4 to 5 for date range line
+        self.draw_box(system_y, 2, system_h, left_width, "SYSTEM INFO")
+        
+        self.safe_addstr(system_y + 1, 4, f"SYSTEM: {self.system_name}")
+        file_size = self.get_file_size()
+        self.safe_addstr(system_y + 1, left_width - len(file_size) - 10, f"SIZE: {file_size}")
+        
+        crit = self.severity_counts['CRITICAL'] + self.severity_counts['ALERT']
+        row2_text = f"TOTAL LOGS: {self.total_logs}  |  CRITICAL: {crit}  ERROR: {self.severity_counts['ERROR']}  WARN: {self.severity_counts['WARN']}  INFO: {self.severity_counts['INFO']}"
+        self.safe_addstr(system_y + 2, 4, row2_text[:left_width-8], curses.A_BOLD)
+        
+        # Show log date range if available
+        if len(self.logs) > 0:
+            first_ts = list(self.logs)[0].get('timestamp', '')[:10]
+            last_ts = list(self.logs)[-1].get('timestamp', '')[:10]
+            if first_ts and last_ts:
+                if first_ts == last_ts:
+                    date_range = f"Date: {last_ts}"
+                else:
+                    date_range = f"Range: {first_ts} to {last_ts}"
+                self.safe_addstr(system_y + 3, 4, date_range, curses.color_pair(2))
+        
+        filter_y = system_y + system_h + 1
+        filter_h = 3
+        
+        if self.input_mode == 'search_text':
+            self.draw_box(filter_y, 2, filter_h, left_width, "SEARCH & FILTER", " t:text | v:severity | c:clear ")
+            prompt = f"Text: {self.input_buffer}_"
+            self.safe_addstr(filter_y + 1, 4, prompt, curses.A_BOLD | curses.A_REVERSE)
+        elif self.input_mode == 'search_severity':
+            self.draw_box(filter_y, 2, filter_h, left_width, "SEARCH & FILTER", " t:text | v:severity | c:clear ")
+            prompt = f"Severity: {self.input_buffer}_"
+            self.safe_addstr(filter_y + 1, 4, prompt, curses.A_BOLD | curses.A_REVERSE)
+        else:
+            self.draw_box(filter_y, 2, filter_h, left_width, "SEARCH & FILTER", "t:text | v:severity | c:clear")
+        
+        log_y = filter_y + filter_h + 1
+        log_h = max_y - log_y - 5
+        if log_h < 10:
+            log_h = 10
+        
+        self.draw_box(log_y, 2, log_h, left_width, "RECENT LOGS")
+        
+        # Show count of logs and filtering info
+        filter_info = ""
+        if self.search_term or self.search_severity:
+            filter_info = f"[Filtered: {len(self.filtered_logs)}/{len(self.logs)}] "
+        
+        self.safe_addstr(log_y, left_width - 40, f"{filter_info}l:details | ↑↓:scroll", curses.A_DIM)
+        
+        # FIX 1: Show logs newest first (from the end of deque)
+        display = list(self.filtered_logs)
+        visible = log_h - 3
+        
+        # Calculate proper indices - newest logs are at the END of the deque
+        total_logs = len(display)
+        if total_logs > 0:
+            # Start from the end and go backwards
+            start_idx = max(0, total_logs - visible - self.scroll_pos)
+            end_idx = total_logs - self.scroll_pos
+            
+            # Get the slice and reverse it to show newest at top
+            display_slice = display[start_idx:end_idx]
+            display_slice.reverse()
+        else:
+            display_slice = []
+        
+        for i, log in enumerate(display_slice):
+            y = log_y + 1 + i
+            if y >= log_y + log_h - 1:
+                break
+            
+            ts = log.get('timestamp', '')[:15]
+            sev = log.get('severity', 'INFO')[:4]
+            msg = log.get('message', log.get('raw', ''))
+            
+            max_msg = left_width - 28
+            if len(msg) > max_msg:
+                msg = msg[:max_msg - 3] + "..."
+            
+            line = f"[{ts}] [{sev:4s}] {msg}"
+            color = self.get_severity_color(log.get('severity', 'INFO'))
+            
+            # Use highlighting function
+            self.highlight_text(y, 4, line, color, self.search_term, self.search_severity)
+        
+        if self.scroll_pos > 0:
+            self.safe_addstr(log_y + log_h - 1, left_width - 18, f"↑↓ scroll:{self.scroll_pos}")
+        
+        if has_graphs:
+            right_x = left_width + 3
+            total_right_width = main_width - 2 - left_width - 1
+            graph_w = (total_right_width - 2) // 2
+            
+            total_available = max_y - 5 - 5
+            gap_between = 1
+            graph_h = (total_available - gap_between) // 2
+            
+            graph_start_y = 5
+            self.draw_box(graph_start_y, right_x, graph_h, graph_w, "CRITICAL")
+            self.safe_addstr(graph_start_y + 1, right_x + 2, f"Count: {crit}", curses.color_pair(1))
+            self.draw_bar_chart(graph_start_y + 2, right_x, graph_h - 2, graph_w, self.critical_history)
+            
+            self.draw_box(graph_start_y, right_x + graph_w + 1, graph_h, graph_w + 1, "WARNINGS")
+            self.safe_addstr(graph_start_y + 1, right_x + graph_w + 3, f"Count: {self.severity_counts['WARN']}", curses.color_pair(2))
+            self.draw_bar_chart(graph_start_y + 2, right_x + graph_w + 1, graph_h - 2, graph_w + 1, self.warn_history)
+            
+            bottom_y = graph_start_y + graph_h + gap_between
+            
+            self.draw_box(bottom_y, right_x, graph_h, graph_w, "ERRORS")
+            self.safe_addstr(bottom_y + 1, right_x + 2, f"Count: {self.severity_counts['ERROR']}", curses.color_pair(1))
+            self.draw_bar_chart(bottom_y + 2, right_x, graph_h - 2, graph_w, self.error_history)
+            
+            self.draw_box(bottom_y, right_x + graph_w + 1, graph_h, graph_w + 1, "INFO")
+            self.safe_addstr(bottom_y + 1, right_x + graph_w + 3, f"Count: {self.severity_counts['INFO']}", curses.color_pair(3))
+            self.draw_bar_chart(bottom_y + 2, right_x + graph_w + 1, graph_h - 2, graph_w + 1, self.info_history)
+        
+        path_y = max_y - 4
+        if self.input_mode == 'path':
+            self.draw_box(path_y, 2, 3, main_width - 2, "FILE PATH", "Press Enter to apply, ESC to cancel")
+            prompt = f"Enter: {self.input_buffer}_"
+            self.safe_addstr(path_y + 1, 4, prompt, curses.A_BOLD | curses.A_REVERSE)
+        else:
+            self.draw_box(path_y, 2, 3, main_width - 2, "FILE PATH")
+            filename = os.path.basename(self.logfile)
+            if len(filename) > 40:
+                filename = "..." + filename[-37:]
+            self.safe_addstr(path_y + 1, 4, f"Current: {filename}")
+            options_text = "q:quit | r:reload | p:path | t:text | v:severity | c:clear | l:details | ↑↓:scroll"
+            self.safe_addstr(path_y + 1, main_width - len(options_text) - 4, options_text, curses.A_DIM)
+    
+    def draw_detail_view(self, max_y, max_x):
+        main_width = max_x - 2
+        self.draw_box(0, 1, max_y, main_width, "LOG DETAIL VIEW")
+        
+        total = f"TOTAL LOGS: {len(self.filtered_logs)}"
+        self.safe_addstr(1, max_x - len(total) - 4, total, curses.A_BOLD)
+        
+        header_y = 3
+        self.safe_addstr(header_y, 4, "TIMESTAMP", curses.A_BOLD | curses.A_UNDERLINE)
+        self.safe_addstr(header_y, 30, "SEVERITY", curses.A_BOLD | curses.A_UNDERLINE)
+        self.safe_addstr(header_y, 45, "LOGS", curses.A_BOLD | curses.A_UNDERLINE)
+        self.safe_addstr(header_y + 1, 3, "─" * (main_width - 4))
+        
+        # FIX 1: Show logs newest first in detail view too
+        display = list(self.filtered_logs)
+        if self.detail_search:
+            search_lower = self.detail_search.lower()
+            display = [l for l in display if search_lower in l.get('raw', '').lower() or
+                      search_lower in l.get('severity', '').lower() or
+                      search_lower in l.get('timestamp', '').lower()]
+        
+        log_start = header_y + 2
+        log_h = max_y - log_start - 5
+        
+        # Calculate proper indices for newest-first display
+        total_logs = len(display)
+        if total_logs > 0:
+            start_idx = max(0, total_logs - log_h - self.detail_scroll)
+            end_idx = total_logs - self.detail_scroll
+            
+            display_slice = display[start_idx:end_idx]
+            display_slice.reverse()
+        else:
+            display_slice = []
+        
+        for i, log in enumerate(display_slice):
+            y = log_start + i
+            if y >= max_y - 5:
+                break
+            
+            ts = log.get('timestamp', '')
+            sev = log.get('severity', 'INFO')
+            msg = log.get('message', log.get('raw', ''))
+            
+            max_msg = main_width - 50
+            if len(msg) > max_msg:
+                msg = msg[:max_msg - 3] + "..."
+            
+            color = self.get_severity_color(sev)
+            
+            # Highlight timestamp
+            self.highlight_text(y, 4, ts[:24], curses.A_NORMAL, self.detail_search, "")
+            
+            # Highlight severity
+            self.highlight_text(y, 30, sev, color | curses.A_BOLD, self.detail_search, "")
+            
+            # Highlight message
+            self.highlight_text(y, 45, msg, color, self.detail_search, "")
+        
+        search_y = max_y - 4
+        self.draw_box(search_y, 2, 3, main_width - 2, "")
+        
+        if self.detail_input_mode:
+            prompt = f"SEARCH: {self.detail_input_buffer}_"
+            self.safe_addstr(search_y + 1, 4, prompt, curses.A_BOLD | curses.A_REVERSE)
+        else:
+            if self.detail_search:
+                self.safe_addstr(search_y + 1, 4, f"ACTIVE: {self.detail_search}", curses.A_BOLD)
+            else:
+                self.safe_addstr(search_y + 1, 4, "SEARCH: ")
+            
+            if total_logs > 0:
+                showing_start = max(1, total_logs - self.detail_scroll - log_h + 1)
+                showing_end = total_logs - self.detail_scroll
+                scroll_info = f"Showing {showing_start}-{showing_end} of {total_logs}"
+            else:
+                scroll_info = "No logs"
+            self.safe_addstr(search_y + 1, main_width - len(scroll_info) - 4, scroll_info, curses.A_DIM)
+        
+        help_text = "ESC:back | s:search | c:clear | ↑↓:scroll | PgUp/PgDn:page | q:quit"
+        self.safe_addstr(max_y - 2, 3, help_text, curses.A_DIM)
+    
+    def draw(self):
+        current_time = time.time()
+        if not self.needs_redraw and (current_time - self.last_draw_time) < 1.0:
+            return
+        
+        max_y, max_x = self.stdscr.getmaxyx()
+        
+        self.stdscr.erase()
+        
+        if self.loading:
+            self.draw_loading(max_y, max_x)
+            self.stdscr.refresh()
+            self.needs_redraw = False
+            self.last_draw_time = current_time
+            return
+        
+        if max_y < 30 or max_x < 80:
+            self.safe_addstr(max_y // 2, (max_x - 30) // 2, "Terminal too small!")
+            self.safe_addstr(max_y // 2 + 1, (max_x - 30) // 2, f"Current: {max_x}x{max_y}")
+            self.safe_addstr(max_y // 2 + 2, (max_x - 30) // 2, "Minimum: 80x30")
+            self.stdscr.refresh()
+            self.needs_redraw = False
+            self.last_draw_time = current_time
+            return
+        
+        if self.detail_view:
+            self.draw_detail_view(max_y, max_x)
+        else:
+            self.draw_main_dashboard(max_y, max_x)
+        
+        self.stdscr.refresh()
+        self.needs_redraw = False
+        self.last_draw_time = current_time
+    
+    def handle_input_mode(self, key):
+        if key in (10, curses.KEY_ENTER):
+            if self.input_mode == 'path':
+                if os.path.exists(self.input_buffer):
+                    self.logfile = self.input_buffer
+                    self.start_monitoring()
+            elif self.input_mode == 'search_text':
+                self.search_term = self.input_buffer
+                self.update_filtered_logs()
+                self.scroll_pos = 0  # Reset scroll when searching
+            elif self.input_mode == 'search_severity':
+                sev = self.input_buffer.upper()
+                if sev in ['CRITICAL', 'ALERT', 'ERROR', 'WARN', 'INFO', 'DEBUG', '']:
+                    self.search_severity = sev
+                    self.update_filtered_logs()
+                    self.scroll_pos = 0  # Reset scroll when filtering
+            self.input_mode = None
+            self.input_buffer = ""
+            self.needs_redraw = True
+        elif key == 27:
+            self.input_mode = None
+            self.input_buffer = ""
+            self.needs_redraw = True
+        elif key in (curses.KEY_BACKSPACE, 127, 8):
+            self.input_buffer = self.input_buffer[:-1]
+            self.needs_redraw = True
+        elif 32 <= key <= 126:
+            self.input_buffer += chr(key)
+            self.needs_redraw = True
+    
+    def handle_detail_input(self, key):
+        if key in (10, curses.KEY_ENTER):
+            self.detail_search = self.detail_input_buffer
+            self.detail_input_mode = False
+            self.detail_scroll = 0
+            self.needs_redraw = True
+        elif key == 27:
+            self.detail_input_mode = False
+            self.detail_input_buffer = ""
+            self.needs_redraw = True
+        elif key in (curses.KEY_BACKSPACE, 127, 8):
+            self.detail_input_buffer = self.detail_input_buffer[:-1]
+            self.needs_redraw = True
+        elif 32 <= key <= 126:
+            self.detail_input_buffer += chr(key)
+            self.needs_redraw = True
+    
+    def run(self):
+        scroll_delay = 0
+        
+        try:
+            curses.mousemask(0)
+        except:
+            pass
+        
+        while True:
+            try:
+                key = self.stdscr.getch()
+                current_time = time.time()
+                
+                if key == curses.KEY_MOUSE:
+                    continue
+                
+                if self.detail_view:
+                    if self.detail_input_mode:
+                        self.handle_detail_input(key)
+                    else:
+                        if key in (27, ord('b'), ord('B')):
+                            self.loading = True
+                            self.draw()
+                            time.sleep(0.3)
+                            self.detail_view = False
+                            self.detail_scroll = 0
+                            self.detail_search = ""
+                            self.loading = False
+                            self.needs_redraw = True
+                        elif key in (ord('q'), ord('Q')):
+                            break
+                        elif key in (ord('s'), ord('S')):
+                            self.detail_input_mode = True
+                            self.detail_input_buffer = self.detail_search
+                            self.needs_redraw = True
+                        elif key in (ord('c'), ord('C')):
+                            self.detail_search = ""
+                            self.detail_scroll = 0
+                            self.needs_redraw = True
+                        elif key == curses.KEY_UP and current_time - scroll_delay > 0.05:
+                            # Scroll down to see older logs
+                            max_scroll = max(0, len(self.filtered_logs) - 10)
+                            self.detail_scroll = min(self.detail_scroll + 1, max_scroll)
+                            scroll_delay = current_time
+                            self.needs_redraw = True
+                        elif key == curses.KEY_DOWN and current_time - scroll_delay > 0.05:
+                            # Scroll up to see newer logs
+                            self.detail_scroll = max(self.detail_scroll - 1, 0)
+                            scroll_delay = current_time
+                            self.needs_redraw = True
+                        elif key == curses.KEY_PPAGE:
+                            self.detail_scroll = min(self.detail_scroll + 10, max(0, len(self.filtered_logs) - 10))
+                            self.needs_redraw = True
+                        elif key == curses.KEY_NPAGE:
+                            self.detail_scroll = max(self.detail_scroll - 10, 0)
+                            self.needs_redraw = True
+                
+                elif self.input_mode:
+                    self.handle_input_mode(key)
+                else:
+                    if key in (ord('q'), ord('Q')):
+                        break
+                    elif key in (ord('r'), ord('R')):
+                        # Force reload logs from file
+                        self.start_monitoring()
+                        self.needs_redraw = True
+                    elif key in (ord('l'), ord('L')):
+                        self.loading = True
+                        self.draw()
+                        time.sleep(0.3)
+                        self.detail_view = True
+                        self.detail_scroll = 0
+                        self.loading = False
+                        self.needs_redraw = True
+                    elif key in (ord('p'), ord('P')):
+                        self.input_mode = 'path'
+                        self.input_buffer = self.logfile
+                        self.needs_redraw = True
+                    elif key in (ord('t'), ord('T')):
+                        self.input_mode = 'search_text'
+                        self.input_buffer = self.search_term
+                        self.needs_redraw = True
+                    elif key in (ord('v'), ord('V')):
+                        self.input_mode = 'search_severity'
+                        self.input_buffer = self.search_severity
+                        self.needs_redraw = True
+                    elif key in (ord('c'), ord('C')):
+                        self.search_term = ""
+                        self.search_severity = ""
+                        self.scroll_pos = 0
+                        self.update_filtered_logs()
+                        self.needs_redraw = True
+                    elif key == curses.KEY_UP and current_time - scroll_delay > 0.05:
+                        # Scroll down to see older logs
+                        max_scroll = max(0, len(self.filtered_logs) - 1)
+                        self.scroll_pos = min(self.scroll_pos + 1, max_scroll)
+                        scroll_delay = current_time
+                        self.needs_redraw = True
+                    elif key == curses.KEY_DOWN and current_time - scroll_delay > 0.05:
+                        # Scroll up to see newer logs
+                        self.scroll_pos = max(self.scroll_pos - 1, 0)
+                        scroll_delay = current_time
+                        self.needs_redraw = True
+            except:
+                pass
+            
+            self.draw()
+            time.sleep(0.05)
+        
+        if self.monitor:
+            self.monitor.stop()
+
+# NEW
+def main(stdscr, logfile="/var/log/syslog", no_limit=False):
+    dashboard = LogDashboard(stdscr, logfile, no_limit=no_limit)
+    dashboard.run()
+
+__version__ = "1.0.0"
+
+def cli():
+    """Entry point for CLI."""
+    args = sys.argv[1:]
+
+    # Handle version flag before curses starts
+    if "-v" in args or "--version" in args:
+        print(f"awtach v{__version__}")
+        sys.exit(0)
+
+    logfile = "/var/log/syslog"
+    no_limit = False
+
+    for arg in args:
+        if arg in ['--no-limit', '--on-limit']:
+            no_limit = True
+        elif not arg.startswith('--') and not arg.startswith('-'):
+            logfile = arg
+
+    try:
+        curses.wrapper(lambda stdscr: main(stdscr, logfile, no_limit))
+    except KeyboardInterrupt:
+        print("\nDashboard closed.")
+    except Exception as e:
+        print(f"Error: {e}")
+
+def cli_no_limit():
+    sys.argv.append("--no-limit")
+    cli()
+
+if __name__ == "__main__":
+    cli()

awatch-1.0.0.dist-info/METADATA

@@ -0,0 +1,248 @@
+Metadata-Version: 2.4
+Name: awatch
+Version: 1.0.0
+Summary: Terminal TUI dashboard for real-time log monitoring
+Author-email: Ashish <your@email.com>
+License: MIT License
+        
+        Copyright (c) 2026 Ashish
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/ashishnxt/awatch
+Project-URL: Repository, https://github.com/ashishnxt/awatch
+Project-URL: Bug Tracker, https://github.com/ashishnxt/awatch/issues
+Keywords: log,monitoring,tui,terminal,dashboard,syslog
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console :: Curses
+Classifier: Intended Audience :: System Administrators
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Logging
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: Terminals
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# awatch 🖥️
+
+> **A** **W**atchful **T**erminal **A**nalytics for **C**ontinuous **H**osting logs
+
+Real-time TUI (Terminal UI) log monitoring dashboard for Linux and macOS. Monitor any log file live — with severity filtering, text search, bar charts, and a scrollable detail view — all inside your terminal.
+
+---
+
+## Screenshot
+
+```
+╭──────────────────────────────────────────────────────────────────────────────────────╮
+│ ╭─────────────────────────────────────────────────────────────────────────────────╮  │
+│ │ STATUS: LIVE           LAST LOG: 2026-01-02T14:32:01       TIME: 2026-01-02 ... │  │
+│ ╰─────────────────────────────────────────────────────────────────────────────────╯  │
+│ ╭─ SYSTEM INFO ─────────────────────────╮  ╭─ CRITICAL ──╮  ╭─ WARNINGS ──╮        │
+│ │ SYSTEM: prod-server-01   SIZE: 42.3MB │  │ Count: 2    │  │ Count: 14   │        │
+│ │ TOTAL: 8432 | CRIT:2 ERR:11 WARN:14  │  │ |  |        │  │ | || |      │        │
+│ │ Range: 2026-01-01 to 2026-01-02       │  ╰─────────────╯  ╰─────────────╯        │
+│ ╰───────────────────────────────────────╯                                            │
+│ ╭─ RECENT LOGS ──────────────────────── [Filtered: 120/8432] l:details | ↑↓:scroll ─╮│
+│ │ [Jan  2 14:32:01] [CRIT] kernel: BIOS bug: ...                                    ││
+│ │ [Jan  2 14:31:55] [ERR ] nginx: connect() failed (111: Connection refused)        ││
+│ │ [Jan  2 14:31:40] [WARN] systemd: Unit ssh.service is degraded.                  ││
+│ │ [Jan  2 14:31:22] [INFO] sshd[2341]: Accepted publickey for ashish               ││
+│ ╰────────────────────────────────────────────────────────────────────────────────────╯│
+╰──────────────────────────────────────────────────────────────────────────────────────╯
+```
+
+---
+
+## Features
+
+- **Live tail** — monitors any log file in real-time, handles file rotation and truncation automatically
+- **Severity detection** — auto-classifies each line as `CRITICAL`, `ALERT`, `ERROR`, `WARN`, `INFO`, or `DEBUG` using regex pattern matching
+- **Text search** — filter logs by any keyword with highlighted matches
+- **Severity filter** — show only the severity level you care about
+- **Bar charts** — live sparkline-style bar charts for CRITICAL, WARNINGS, ERRORS, and INFO counts (visible on wide terminals ≥ 130 cols)
+- **Detail view** — full-width table with timestamp, severity, and message columns; searchable separately
+- **Scroll** — scroll through history in both main and detail views
+- **Date range** — shows the date range of logs currently loaded
+- **File rotation handling** — detects truncation/rotation and re-opens the file automatically
+- **No-limit mode** — load the entire log file instead of the default last 10,000 lines
+- **Zero dependencies** — uses only Python stdlib (`curses`, `threading`, `re`, `collections`)
+
+---
+
+## Install
+
+```bash
+pip install awatch
+```
+
+---
+
+## Usage
+
+```bash
+# Monitor default syslog
+awatch
+
+# Monitor a specific file
+awatch /var/log/nginx/error.log
+awatch /var/log/auth.log
+awatch /var/log/postgresql/postgresql.log
+
+# Load entire file (no 10,000 line cap)
+awatch --no-limit
+awatch /var/log/syslog --no-limit
+
+# Check version
+awatch -v
+awatch --version
+```
+
+---
+
+## Keybindings
+
+### Main View
+
+| Key | Action |
+|-----|--------|
+| `t` | Enter text search — type keyword, press `Enter` to apply |
+| `v` | Filter by severity — type `ERROR`, `WARN`, `INFO`, `CRITICAL`, `DEBUG`, or `ALERT` |
+| `c` | Clear all active filters |
+| `l` | Open detail view (full table with all fields) |
+| `r` | Reload — re-reads file from disk |
+| `p` | Change log file path — type new path, press `Enter` |
+| `↑` | Scroll up (older logs) |
+| `↓` | Scroll down (newer logs) |
+| `q` | Quit |
+| `ESC` | Cancel current input |
+
+### Detail View
+
+| Key | Action |
+|-----|--------|
+| `s` | Search within detail view |
+| `c` | Clear detail search |
+| `↑` / `↓` | Scroll one line |
+| `PgUp` / `PgDn` | Scroll ten lines |
+| `ESC` or `b` | Back to main dashboard |
+| `q` | Quit |
+
+---
+
+## Severity Levels
+
+| Level | Color | Matches |
+|-------|-------|---------|
+| `CRITICAL` | 🔴 Red | `CRITICAL`, `CRIT`, `FATAL`, `EMERG`, `EMERGENCY` |
+| `ALERT` | 🟣 Magenta | `ALERT` |
+| `ERROR` | 🔴 Red | `ERROR`, `ERR`, `FAILURE`, `FAILED` |
+| `WARN` | 🟡 Yellow | `WARN`, `WARNING` |
+| `INFO` | 🔵 Cyan | `INFO`, `INFORMATION`, `NOTICE` |
+| `DEBUG` | 🔷 Blue | `DEBUG`, `TRACE` |
+
+---
+
+## Supported Log Formats
+
+awatch parses standard syslog format automatically:
+
+```
+Jan  2 14:32:01 hostname process[pid]: message
+2026-01-02T14:32:01.123Z hostname process[pid]: message
+```
+
+Any line that doesn't match syslog format is still displayed — the full raw line is shown as the message. This means awatch works with any plain-text log file.
+
+---
+
+## Terminal Requirements
+
+| Requirement | Minimum |
+|-------------|---------|
+| Terminal size | 80 × 30 |
+| Terminal size (with graphs) | 130+ columns wide |
+| OS | Linux, macOS |
+| Python | 3.8+ |
+
+---
+
+## Performance
+
+| Mode | Behavior |
+|------|----------|
+| Default | Reads last 2MB of file → keeps last 10,000 lines in memory |
+| `--no-limit` | Reads entire file from start, no line cap |
+
+New lines are polled every 50ms. Screen redraws are throttled to once per second minimum unless new data arrives.
+
+---
+
+## Common Log Files
+
+```bash
+# System
+awatch /var/log/syslog
+awatch /var/log/messages
+awatch /var/log/kern.log
+
+# Auth
+awatch /var/log/auth.log
+awatch /var/log/secure
+
+# Web servers
+awatch /var/log/nginx/error.log
+awatch /var/log/nginx/access.log
+awatch /var/log/apache2/error.log
+
+# Database
+awatch /var/log/postgresql/postgresql-16-main.log
+awatch /var/log/mysql/error.log
+
+# Application / Docker
+awatch /var/log/myapp/app.log
+awatch /var/lib/docker/containers/<id>/<id>-json.log
+```
+
+---
+
+## Requirements
+
+- Python 3.8 or higher
+- Linux or macOS (Windows not supported — `curses` is unavailable)
+- No third-party packages required
+
+---
+
+## License
+
+MIT License — see [LICENSE](LICENSE) for details.
+
+---
+
+## Author
+
+Built by **Ashish** — [github.com/ashishnxt](https://github.com/ashishnxt)

awatch-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+awatch/__init__.py,sha256=st1LDqnzm7nIM08DA6Xv2S1_tY46atr9ByOuQH26nwc,123
+awatch/dashboard.py,sha256=Lr550WwGJBaqSf1pFQY5um_dy5ptca77cGrgYpjoSCA,40057
+awatch-1.0.0.dist-info/licenses/LICENSE,sha256=qx7BgQNwDCrOZNufdW_CZBKALIieS_aCJSWOM5IrDYI,804
+awatch-1.0.0.dist-info/METADATA,sha256=WHG3SAdf3uJenigFUAWdv4x3sdtTmmqwyTz-2BFnT50,9532
+awatch-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+awatch-1.0.0.dist-info/entry_points.txt,sha256=cRb5DiYL9mDOCgn4CYpyakHKS6kcKh0OXvbdBgKVfSw,95
+awatch-1.0.0.dist-info/top_level.txt,sha256=qyUH1KPNUpsK_vCwFTz2mQLyckPA--MIAerHqZ6ZHJM,7
+awatch-1.0.0.dist-info/RECORD,,

awatch-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

awatch-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+awatch = awatch.dashboard:cli
+awatch-nolimit = awatch.dashboard:cli_no_limit

awatch-1.0.0.dist-info/licenses/LICENSE

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

awatch-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+awatch