logpeek-cli 0.1.0__py3-none-any.whl

logpeek/__init__.py

@@ -0,0 +1,2 @@
+"""logpeek - Log file viewer and analyzer CLI."""
+__version__ = "0.1.0"

logpeek/cli.py

@@ -0,0 +1,408 @@
+"""logpeek CLI - Log file viewer and analyzer."""
+import json
+import re
+import sys
+import time
+from collections import Counter
+from datetime import datetime
+
+import click
+
+from .parser import detect_level, parse_timestamp, extract_fields, detect_format, FIELD_PATTERNS
+
+# Colors for log levels
+LEVEL_COLORS = {
+    'ERROR': 'red',
+    'WARNING': 'yellow',
+    'INFO': 'green',
+    'DEBUG': 'cyan',
+}
+
+
+def colorize_line(line, level=None):
+    """Colorize a log line based on its level."""
+    if level is None:
+        level = detect_level(line)
+    if level and level in LEVEL_COLORS:
+        return click.style(line, fg=LEVEL_COLORS[level])
+    return line
+
+
+def read_lines(file, follow=False):
+    """Read lines from file or stdin. If follow, tail -f style."""
+    if file == '-' or file is None:
+        if follow:
+            raise click.ClickException("Cannot tail stdin. Provide a file path.")
+        for line in sys.stdin:
+            yield line.rstrip('\n')
+        return
+
+    if follow:
+        with open(file, 'r') as f:
+            # Seek to end
+            f.seek(0, 2)
+            while True:
+                line = f.readline()
+                if line:
+                    yield line.rstrip('\n')
+                else:
+                    time.sleep(0.1)
+    else:
+        with open(file, 'r') as f:
+            for line in f:
+                yield line.rstrip('\n')
+
+
+@click.group()
+@click.version_option()
+def main():
+    """View, tail, filter, search, and analyze log files."""
+    pass
+
+
+@main.command()
+@click.argument('file', default='-')
+@click.option('--json', 'as_json', is_flag=True, help='Output as JSON')
+@click.option('-n', '--lines', default=0, help='Last N lines (0=all)')
+@click.option('--no-color', is_flag=True, help='Disable colorization')
+def view(file, as_json, lines, no_color):
+    """View log file with syntax highlighting."""
+    try:
+        all_lines = list(read_lines(file))
+    except FileNotFoundError:
+        raise click.ClickException(f"File not found: {file}")
+
+    if lines > 0:
+        all_lines = all_lines[-lines:]
+
+    if as_json:
+        result = []
+        for line in all_lines:
+            level = detect_level(line)
+            ts = parse_timestamp(line)
+            result.append({
+                'line': line,
+                'level': level,
+                'timestamp': ts.isoformat() if ts else None,
+            })
+        click.echo(json.dumps(result, indent=2))
+    else:
+        for line in all_lines:
+            if no_color:
+                click.echo(line)
+            else:
+                click.echo(colorize_line(line))
+
+
+@main.command()
+@click.argument('file')
+@click.option('--json', 'as_json', is_flag=True, help='Output as JSON lines')
+@click.option('--no-color', is_flag=True, help='Disable colorization')
+def tail(file, as_json, no_color):
+    """Live tail a log file (like tail -f)."""
+    try:
+        for line in read_lines(file, follow=True):
+            if as_json:
+                level = detect_level(line)
+                ts = parse_timestamp(line)
+                click.echo(json.dumps({
+                    'line': line,
+                    'level': level,
+                    'timestamp': ts.isoformat() if ts else None,
+                }))
+            elif no_color:
+                click.echo(line)
+            else:
+                click.echo(colorize_line(line))
+    except KeyboardInterrupt:
+        pass
+
+
+@main.command()
+@click.argument('file', default='-')
+@click.option('--level', '-l', help='Filter by log level (error, warning, info, debug)')
+@click.option('--json', 'as_json', is_flag=True, help='Output as JSON')
+@click.option('--no-color', is_flag=True, help='Disable colorization')
+@click.option('--invert', '-v', is_flag=True, help='Invert match (exclude level)')
+def filter(file, level, as_json, no_color, invert):
+    """Filter log lines by level."""
+    if not level:
+        raise click.ClickException("--level is required")
+
+    target = level.upper()
+    # Normalize
+    if target in ('ERR',):
+        target = 'ERROR'
+    if target in ('WARN',):
+        target = 'WARNING'
+
+    results = []
+    try:
+        for line in read_lines(file):
+            detected = detect_level(line)
+            match = (detected == target)
+            if invert:
+                match = not match
+            if match:
+                if as_json:
+                    ts = parse_timestamp(line)
+                    results.append({
+                        'line': line,
+                        'level': detected,
+                        'timestamp': ts.isoformat() if ts else None,
+                    })
+                elif no_color:
+                    click.echo(line)
+                else:
+                    click.echo(colorize_line(line, detected))
+    except FileNotFoundError:
+        raise click.ClickException(f"File not found: {file}")
+
+    if as_json:
+        click.echo(json.dumps(results, indent=2))
+
+
+@main.command()
+@click.argument('file', default='-')
+@click.argument('pattern')
+@click.option('-A', '--after', 'after_ctx', default=0, help='Lines after match')
+@click.option('-B', '--before', 'before_ctx', default=0, help='Lines before match')
+@click.option('-C', '--context', default=0, help='Lines before and after match')
+@click.option('-i', '--ignore-case', is_flag=True, help='Case insensitive')
+@click.option('--json', 'as_json', is_flag=True, help='Output as JSON')
+@click.option('--no-color', is_flag=True, help='Disable colorization')
+@click.option('-c', '--count', is_flag=True, help='Only show match count')
+def search(file, pattern, after_ctx, before_ctx, context, ignore_case, as_json, no_color, count):
+    """Search log lines with regex pattern."""
+    if context > 0:
+        after_ctx = context
+        before_ctx = context
+
+    flags = re.IGNORECASE if ignore_case else 0
+    try:
+        regex = re.compile(pattern, flags)
+    except re.error as e:
+        raise click.ClickException(f"Invalid regex: {e}")
+
+    try:
+        all_lines = list(read_lines(file))
+    except FileNotFoundError:
+        raise click.ClickException(f"File not found: {file}")
+
+    matches = []
+    match_indices = set()
+    for i, line in enumerate(all_lines):
+        if regex.search(line):
+            match_indices.add(i)
+            for j in range(max(0, i - before_ctx), min(len(all_lines), i + after_ctx + 1)):
+                match_indices.add(j)
+            matches.append({'index': i, 'line': line, 'level': detect_level(line)})
+
+    if count:
+        if as_json:
+            click.echo(json.dumps({'count': len(matches)}))
+        else:
+            click.echo(len(matches))
+        return
+
+    if as_json:
+        click.echo(json.dumps(matches, indent=2))
+    else:
+        sorted_indices = sorted(match_indices)
+        prev = -2
+        for i in sorted_indices:
+            if i > prev + 1 and prev >= 0:
+                click.echo('--')
+            line = all_lines[i]
+            if no_color:
+                click.echo(line)
+            elif i in {m['index'] for m in matches}:
+                # Highlight the match
+                highlighted = regex.sub(lambda m: click.style(m.group(), fg='bright_white', bold=True), line)
+                click.echo(colorize_line(highlighted, detect_level(line)) if detect_level(line) else highlighted)
+            else:
+                click.echo(click.style(line, dim=True))
+            prev = i
+
+
+@main.command()
+@click.argument('file', default='-')
+@click.option('--json', 'as_json', is_flag=True, help='Output as JSON')
+def stats(file, as_json):
+    """Show log level distribution and statistics."""
+    level_counts = Counter()
+    total = 0
+    hourly = Counter()
+    first_ts = None
+    last_ts = None
+
+    try:
+        for line in read_lines(file):
+            total += 1
+            level = detect_level(line)
+            if level:
+                level_counts[level] += 1
+            ts = parse_timestamp(line)
+            if ts:
+                if first_ts is None:
+                    first_ts = ts
+                last_ts = ts
+                hourly[ts.strftime('%Y-%m-%d %H:00')] += 1
+    except FileNotFoundError:
+        raise click.ClickException(f"File not found: {file}")
+
+    error_count = level_counts.get('ERROR', 0)
+    error_rate = (error_count / total * 100) if total > 0 else 0
+
+    result = {
+        'total_lines': total,
+        'levels': dict(level_counts.most_common()),
+        'error_rate': round(error_rate, 2),
+        'first_timestamp': first_ts.isoformat() if first_ts else None,
+        'last_timestamp': last_ts.isoformat() if last_ts else None,
+        'lines_per_hour': dict(sorted(hourly.items())),
+    }
+
+    if as_json:
+        click.echo(json.dumps(result, indent=2))
+    else:
+        click.echo(f"Total lines: {total}")
+        click.echo(f"Error rate:  {error_rate:.1f}%")
+        click.echo()
+        if first_ts:
+            click.echo(f"Time range:  {first_ts} → {last_ts}")
+            click.echo()
+        click.echo("Level distribution:")
+        for level in ['ERROR', 'WARNING', 'INFO', 'DEBUG']:
+            count = level_counts.get(level, 0)
+            if count > 0:
+                pct = count / total * 100
+                bar = '█' * int(pct / 2)
+                color = LEVEL_COLORS.get(level, 'white')
+                click.echo(f"  {click.style(level.ljust(8), fg=color)} {count:>6} ({pct:5.1f}%) {bar}")
+        unlabeled = total - sum(level_counts.values())
+        if unlabeled > 0:
+            pct = unlabeled / total * 100
+            click.echo(f"  {'OTHER'.ljust(8)} {unlabeled:>6} ({pct:5.1f}%)")
+
+        if hourly:
+            click.echo()
+            click.echo("Lines per hour (top 10):")
+            for hour, cnt in Counter(hourly).most_common(10):
+                click.echo(f"  {hour}  {cnt}")
+
+
+@main.command()
+@click.argument('file', default='-')
+@click.option('--from', 'from_time', required=True, help='Start time (ISO or date)')
+@click.option('--to', 'to_time', required=True, help='End time (ISO or date)')
+@click.option('--json', 'as_json', is_flag=True, help='Output as JSON')
+@click.option('--no-color', is_flag=True, help='Disable colorization')
+def between(file, from_time, to_time, as_json, no_color):
+    """Filter log lines within a time range."""
+    try:
+        start = _parse_user_time(from_time)
+        end = _parse_user_time(to_time, end_of_day=True)
+    except ValueError as e:
+        raise click.ClickException(f"Cannot parse time: {e}")
+
+    results = []
+    try:
+        for line in read_lines(file):
+            ts = parse_timestamp(line)
+            if ts and start <= ts <= end:
+                if as_json:
+                    results.append({
+                        'line': line,
+                        'level': detect_level(line),
+                        'timestamp': ts.isoformat(),
+                    })
+                elif no_color:
+                    click.echo(line)
+                else:
+                    click.echo(colorize_line(line))
+    except FileNotFoundError:
+        raise click.ClickException(f"File not found: {file}")
+
+    if as_json:
+        click.echo(json.dumps(results, indent=2))
+
+
+def _parse_user_time(s, end_of_day=False):
+    """Parse user-provided time string."""
+    for fmt in ('%Y-%m-%dT%H:%M:%S', '%Y-%m-%d %H:%M:%S', '%Y-%m-%d'):
+        try:
+            dt = datetime.strptime(s, fmt)
+            if end_of_day and fmt == '%Y-%m-%d':
+                dt = dt.replace(hour=23, minute=59, second=59)
+            return dt
+        except ValueError:
+            continue
+    raise ValueError(f"Unrecognized time format: {s}")
+
+
+@main.command()
+@click.argument('file', default='-')
+@click.option('--field', '-f', required=True, type=click.Choice(['ip', 'url', 'email', 'status']),
+              help='Field type to extract')
+@click.option('--json', 'as_json', is_flag=True, help='Output as JSON')
+@click.option('--unique', '-u', is_flag=True, help='Only unique values')
+def extract(file, field, as_json, unique):
+    """Extract fields (IPs, URLs, emails, HTTP status codes) from logs."""
+    values = []
+    seen = set()
+    try:
+        for line in read_lines(file):
+            for val in extract_fields(line, field):
+                if unique:
+                    if val in seen:
+                        continue
+                    seen.add(val)
+                values.append(val)
+    except FileNotFoundError:
+        raise click.ClickException(f"File not found: {file}")
+
+    if as_json:
+        click.echo(json.dumps({'field': field, 'count': len(values), 'values': values}, indent=2))
+    else:
+        for v in values:
+            click.echo(v)
+
+
+@main.command()
+@click.argument('file', default='-')
+@click.option('--field', '-f', required=True, type=click.Choice(['ip', 'url', 'email', 'status']),
+              help='Field type to count')
+@click.option('-n', '--number', default=10, help='Top N results')
+@click.option('--json', 'as_json', is_flag=True, help='Output as JSON')
+def top(file, field, number, as_json):
+    """Show top N values for a field."""
+    counter = Counter()
+    try:
+        for line in read_lines(file):
+            for val in extract_fields(line, field):
+                counter[val] += 1
+    except FileNotFoundError:
+        raise click.ClickException(f"File not found: {file}")
+
+    top_items = counter.most_common(number)
+
+    if as_json:
+        click.echo(json.dumps({
+            'field': field,
+            'top': [{'value': v, 'count': c} for v, c in top_items],
+            'unique_count': len(counter),
+        }, indent=2))
+    else:
+        if not top_items:
+            click.echo(f"No {field} values found.")
+            return
+        max_count = top_items[0][1] if top_items else 1
+        for val, cnt in top_items:
+            bar = '█' * max(1, int(cnt / max_count * 20))
+            click.echo(f"  {cnt:>6}  {val}  {bar}")
+        click.echo(f"\n  {len(counter)} unique values")
+
+
+if __name__ == '__main__':
+    main()

logpeek/parser.py

@@ -0,0 +1,171 @@
+"""Log line parsing and format detection."""
+import json
+import re
+from datetime import datetime
+
+# Log level patterns
+LEVEL_PATTERNS = [
+    re.compile(r'\b(EMERGENCY|EMERG)\b', re.I),
+    re.compile(r'\b(ALERT)\b', re.I),
+    re.compile(r'\b(CRITICAL|CRIT|FATAL)\b', re.I),
+    re.compile(r'\b(ERROR|ERR)\b', re.I),
+    re.compile(r'\b(WARNING|WARN)\b', re.I),
+    re.compile(r'\b(NOTICE)\b', re.I),
+    re.compile(r'\b(INFO)\b', re.I),
+    re.compile(r'\b(DEBUG|TRACE)\b', re.I),
+]
+
+LEVEL_NAMES = {
+    'EMERGENCY': 'error', 'EMERG': 'error',
+    'ALERT': 'error',
+    'CRITICAL': 'error', 'CRIT': 'error', 'FATAL': 'error',
+    'ERROR': 'error', 'ERR': 'error',
+    'WARNING': 'warning', 'WARN': 'warning',
+    'NOTICE': 'info',
+    'INFO': 'info',
+    'DEBUG': 'debug', 'TRACE': 'debug',
+}
+
+LEVEL_CANONICAL = {
+    'EMERGENCY': 'ERROR', 'EMERG': 'ERROR',
+    'ALERT': 'ERROR',
+    'CRITICAL': 'ERROR', 'CRIT': 'ERROR', 'FATAL': 'ERROR',
+    'ERROR': 'ERROR', 'ERR': 'ERROR',
+    'WARNING': 'WARNING', 'WARN': 'WARNING',
+    'NOTICE': 'INFO',
+    'INFO': 'INFO',
+    'DEBUG': 'DEBUG', 'TRACE': 'DEBUG',
+}
+
+# Timestamp patterns (order matters - try most specific first)
+TIMESTAMP_PATTERNS = [
+    # ISO 8601: 2026-02-08T12:34:56.789Z or with offset
+    (re.compile(r'(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)'), '%Y-%m-%dT%H:%M:%S'),
+    # Common: 2026-02-08 12:34:56
+    (re.compile(r'(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})'), '%Y-%m-%d %H:%M:%S'),
+    # Common: 2026/02/08 12:34:56
+    (re.compile(r'(\d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2})'), '%Y/%m/%d %H:%M:%S'),
+    # Syslog: Feb  8 12:34:56
+    (re.compile(r'([A-Z][a-z]{2}\s+\d{1,2} \d{2}:\d{2}:\d{2})'), '%b %d %H:%M:%S'),
+    # Apache/nginx: 08/Feb/2026:12:34:56
+    (re.compile(r'(\d{2}/[A-Z][a-z]{2}/\d{4}:\d{2}:\d{2}:\d{2})'), '%d/%b/%Y:%H:%M:%S'),
+    # Date only: 2026-02-08
+    (re.compile(r'(\d{4}-\d{2}-\d{2})'), '%Y-%m-%d'),
+]
+
+# Field extraction patterns
+FIELD_PATTERNS = {
+    'ip': re.compile(r'\b(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})\b'),
+    'url': re.compile(r'(https?://[^\s"\'<>]+)'),
+    'email': re.compile(r'([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})'),
+    'status': re.compile(r'\b([1-5]\d{2})\b'),
+}
+
+
+def detect_level(line):
+    """Detect log level from a line. Returns canonical level or None."""
+    for pat in LEVEL_PATTERNS:
+        m = pat.search(line)
+        if m:
+            return LEVEL_CANONICAL.get(m.group(1).upper(), 'INFO')
+    return None
+
+
+def parse_timestamp(line):
+    """Try to extract a datetime from a log line. Returns datetime or None."""
+    # Try JSON first
+    try:
+        obj = json.loads(line)
+        for key in ('timestamp', 'time', 'ts', '@timestamp', 'date', 'datetime'):
+            if key in obj:
+                val = obj[key]
+                if isinstance(val, (int, float)):
+                    return datetime.fromtimestamp(val)
+                for pat, fmt in TIMESTAMP_PATTERNS:
+                    m = pat.search(str(val))
+                    if m:
+                        return _parse_ts(m.group(1), fmt)
+    except (json.JSONDecodeError, ValueError, TypeError):
+        pass
+
+    for pat, fmt in TIMESTAMP_PATTERNS:
+        m = pat.search(line)
+        if m:
+            return _parse_ts(m.group(1), fmt)
+    return None
+
+
+def _parse_ts(s, fmt):
+    """Parse a timestamp string, handling timezone suffixes."""
+    # Strip Z or timezone offset for simple parsing
+    clean = s.rstrip('Z')
+    # Remove colon in timezone offset
+    if re.search(r'[+-]\d{2}:\d{2}$', clean):
+        clean = clean[:-3] + clean[-2:]
+    # Remove timezone offset entirely for strptime
+    clean = re.sub(r'[+-]\d{4}$', '', clean)
+    # Remove fractional seconds
+    clean = re.sub(r'\.\d+', '', clean)
+    # Normalize T separator
+    clean = clean.replace('T', ' ')
+    # Pick appropriate format
+    if ' ' in clean and ':' in clean:
+        parts = clean.split()
+        if '/' in parts[0] and ':' in parts[0]:
+            fmt = '%d/%b/%Y:%H:%M:%S'
+        elif '-' in parts[0]:
+            fmt = '%Y-%m-%d %H:%M:%S'
+        elif '/' in parts[0]:
+            fmt = '%Y/%m/%d %H:%M:%S'
+        elif parts[0][0].isalpha():
+            fmt = '%b %d %H:%M:%S'
+        else:
+            fmt = '%Y-%m-%d %H:%M:%S'
+    try:
+        return datetime.strptime(clean, fmt)
+    except ValueError:
+        return None
+
+
+def extract_fields(line, field):
+    """Extract field values from a line."""
+    pat = FIELD_PATTERNS.get(field)
+    if not pat:
+        return []
+    return pat.findall(line)
+
+
+def detect_format(lines):
+    """Detect log format from sample lines. Returns format name."""
+    json_count = 0
+    syslog_count = 0
+    nginx_count = 0
+    apache_count = 0
+
+    for line in lines[:50]:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            json.loads(line)
+            json_count += 1
+            continue
+        except (json.JSONDecodeError, ValueError):
+            pass
+        if re.match(r'[A-Z][a-z]{2}\s+\d{1,2} \d{2}:\d{2}:\d{2} \S+', line):
+            syslog_count += 1
+        elif re.match(r'\d+\.\d+\.\d+\.\d+ - .+ \[\d{2}/[A-Z][a-z]{2}/\d{4}', line):
+            nginx_count += 1
+        elif re.match(r'\d+\.\d+\.\d+\.\d+ .+ \[\d{2}/[A-Z][a-z]{2}/\d{4}', line):
+            apache_count += 1
+
+    total = max(len(lines[:50]), 1)
+    if json_count > total * 0.5:
+        return 'jsonl'
+    if nginx_count > total * 0.3:
+        return 'nginx'
+    if apache_count > total * 0.3:
+        return 'apache'
+    if syslog_count > total * 0.3:
+        return 'syslog'
+    return 'generic'

logpeek_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: logpeek-cli
+Version: 0.1.0
+Summary: View, tail, filter, search, and analyze log files from the command line
+Author-email: Marcus <marcus.builds.things@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/marcusbuildsthings-droid/logpeek
+Project-URL: Repository, https://github.com/marcusbuildsthings-droid/logpeek
+Project-URL: Issues, https://github.com/marcusbuildsthings-droid/logpeek/issues
+Keywords: log,logs,tail,grep,filter,cli,analyzer,syslog,nginx
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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 :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Dynamic: license-file
+
+# logpeek
+
+View, tail, filter, search, and analyze log files from the command line. Think `tail -f` meets `grep` with stats and JSON output.
+
+## Install
+
+```bash
+pip install logpeek-cli
+```
+
+## Commands
+
+```bash
+logpeek view app.log                    # View with syntax highlighting
+logpeek view app.log -n 50              # Last 50 lines
+logpeek tail app.log                    # Live tail (like tail -f)
+logpeek filter app.log --level error    # Filter by log level
+logpeek filter app.log -l warning -v    # Exclude warnings
+logpeek search app.log "pattern"        # Regex search
+logpeek search app.log "error" -C 3     # With 3 lines context
+logpeek search app.log "fail" -c        # Count matches
+logpeek stats app.log                   # Log level distribution
+logpeek between app.log --from "2026-02-08" --to "2026-02-09"
+logpeek extract app.log --field ip      # Extract IP addresses
+logpeek extract app.log -f url -u       # Unique URLs
+logpeek top app.log --field ip -n 10    # Top 10 IPs
+```
+
+## Features
+
+- **Auto-detect log formats**: syslog, nginx, Apache, JSON lines, generic timestamped
+- **Log level detection**: ERROR, WARNING, INFO, DEBUG with colorized output
+- **Regex search**: with context lines (`-A`, `-B`, `-C`) like grep
+- **Time range filtering**: parse timestamps from any common format
+- **Statistics**: level distribution, lines per hour, error rate
+- **Field extraction**: IPs, URLs, emails, HTTP status codes
+- **Top N analysis**: most frequent values for any extractable field
+- **JSON output**: `--json` flag on every command
+- **Stdin support**: pipe logs from other commands
+- **No heavy deps**: just Python + Click
+
+## Stdin / Pipelines
+
+```bash
+cat /var/log/syslog | logpeek filter --level error
+kubectl logs pod-name | logpeek stats
+docker logs container | logpeek search "timeout" -C 2
+journalctl -u nginx | logpeek top --field ip -n 20
+```
+
+## JSON Output
+
+Every command supports `--json` for machine-readable output:
+
+```bash
+logpeek stats app.log --json
+logpeek top app.log -f status --json
+logpeek search app.log "error" --json
+```
+
+## For AI Agents
+
+See [SKILL.md](SKILL.md) for structured command reference and usage patterns.
+
+## License
+
+MIT

logpeek_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+logpeek/__init__.py,sha256=fkMVvK96phAlLufO3edVS736fGWwox5IPIUfTrDzFD0,72
+logpeek/cli.py,sha256=Wo_FPBTcru6GM0wiSDgTm1yhWpqnejpOy79cdWXUt7k,13892
+logpeek/parser.py,sha256=rHJPl2MuV8g05Rp3-HPb3PZMFA2vgN0S8trjApxmOHY,5586
+logpeek_cli-0.1.0.dist-info/licenses/LICENSE,sha256=9tNBpWq8KGbuJqmeComp40OiNnbvpvsKn1YP26PUtck,1063
+logpeek_cli-0.1.0.dist-info/METADATA,sha256=k6w5wMCn2lT72D9HV3bcXiPF1l5fAeIUDXaQeiBNRZM,3468
+logpeek_cli-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+logpeek_cli-0.1.0.dist-info/entry_points.txt,sha256=Fzt6N43XSkJIHjc1P0hSleoYkFeqnW__qiSvaCcLASQ,45
+logpeek_cli-0.1.0.dist-info/top_level.txt,sha256=D_khlMF3yn0IWm009xRmvjWYZf5EvQch0pWGIUW_Y2Q,8
+logpeek_cli-0.1.0.dist-info/RECORD,,

logpeek_cli-0.1.0.dist-info/WHEEL

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

logpeek_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+logpeek = logpeek.cli:main

logpeek_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Marcus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

logpeek_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+logpeek