rewind-timeline 0.1.0__py3-none-any.whl

collectors/collect.py

@@ -0,0 +1,52 @@
+# collect.py
+
+import time
+import sys
+from pathlib import Path
+
+sys.path.append(
+    str(Path(__file__).resolve().parent.parent)
+)
+
+from database import Database
+
+from collectors.packages import PackageCollector
+from collectors.services import ServiceCollector
+from collectors.performance import PerformanceCollector
+from collectors.shell import ShellCollector
+from collectors.files import FileCollector
+
+def start(stop_event=None):
+    db = Database()
+
+    packages = PackageCollector()
+    services = ServiceCollector()
+    performance = PerformanceCollector()
+    shell = ShellCollector()
+
+    # Start file monitoring (queue-based) in parallel with other collectors.
+    # Watching / can be noisy; change watch_root if needed.
+    file_collector = FileCollector(watch_path="/", recursive=True)
+    file_collector.start()
+
+
+    print("Rewind monitor started.")
+
+    while True:
+        if stop_event is not None and stop_event.is_set():
+            break
+
+        all_events = []
+
+        all_events.extend(packages.read_new_events())
+        all_events.extend(services.check_changes())
+        all_events.extend(performance.check())
+        all_events.extend(shell.read_new_commands())
+        all_events.extend(file_collector.read_new_events())
+
+        db.add_events(all_events)
+
+        time.sleep(10)
+
+    file_collector.stop()
+    db.close()

collectors/files.py

@@ -0,0 +1,104 @@
+import os
+import time
+import threading
+from pathlib import Path
+from queue import Queue, Empty
+
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+
+
+class FileCollector(FileSystemEventHandler):
+    """Queue-based file change collector.
+
+    Produces events into an internal Queue so the main loop can batch them.
+    """
+
+    def __init__(
+        self,
+        watch_path: str | Path = "/",
+        recursive: bool = True,
+        throttle_seconds: float = 2.0,
+    ):
+        super().__init__()
+        self.watch_path = Path(watch_path)
+        self.recursive = recursive
+
+        self._queue: Queue = Queue()
+
+        # Debounce by (event_type, src_path) and only emit once per throttle window.
+        self.throttle_seconds = throttle_seconds
+        self._last_emitted = {}
+
+        self._observer: Observer | None = None
+
+    def start(self):
+        if self._observer is not None:
+            return
+
+        observer = Observer()
+        observer.schedule(self, str(self.watch_path), recursive=self.recursive)
+        observer.start()
+        self._observer = observer
+
+    def stop(self):
+        if self._observer is None:
+            return
+        self._observer.stop()
+        self._observer.join(timeout=5)
+        self._observer = None
+
+    def _enqueue(self, event_type: str, src_path: str):
+        now = time.time()
+        key = (event_type, src_path)
+        last = self._last_emitted.get(key)
+        if last is not None and (now - last) < self.throttle_seconds:
+            return
+
+        self._last_emitted[key] = now
+        title = f"{event_type}: {src_path}"
+
+        # Keep it consistent with other collectors.
+        self._queue.put({
+            "category": "file",
+            "title": title,
+        })
+
+    def on_modified(self, event):
+        if event.is_directory:
+            return
+        self._enqueue("Modified", event.src_path)
+
+    def on_created(self, event):
+        if event.is_directory:
+            return
+        self._enqueue("Created", event.src_path)
+
+    def on_deleted(self, event):
+        if event.is_directory:
+            return
+        self._enqueue("Deleted", event.src_path)
+
+    def read_new_events(self, max_events: int = 500):
+        events = []
+        for _ in range(max_events):
+            try:
+                events.append(self._queue.get_nowait())
+            except Empty:
+                break
+        return events
+
+
+# Backwards-compatible function kept for older imports.
+# This project primarily uses FileCollector.
+
+def monitor(path: str | Path):
+    collector = FileCollector(watch_path=path)
+    collector.start()
+
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        collector.stop()
+

collectors/packages.py

@@ -0,0 +1,62 @@
+# collectors/packages.py
+import os
+import re
+
+PACMAN_LOG = "/var/log/pacman.log"
+
+
+class PackageCollector:
+    def __init__(self):
+        self.last_position = 0
+
+    def read_new_events(self):
+        events = []
+
+        if not os.path.exists(PACMAN_LOG):
+            return events
+
+        with open(PACMAN_LOG, "r") as file:
+            file.seek(self.last_position)
+
+            for line in file:
+                line = line.strip()
+
+                installed = re.search(
+                    r"\[(.*?)\].*installed (.*?) \(",
+                    line
+                )
+
+                removed = re.search(
+                    r"\[(.*?)\].*removed (.*?) \(",
+                    line
+                )
+
+                upgraded = re.search(
+                    r"\[(.*?)\].*upgraded (.*?) \(",
+                    line
+                )
+
+                if installed:
+                    events.append({
+                        "timestamp": installed.group(1),
+                        "category": "package",
+                        "title": f"Installed {installed.group(2)}"
+                    })
+
+                elif removed:
+                    events.append({
+                        "timestamp": removed.group(1),
+                        "category": "package",
+                        "title": f"Removed {removed.group(2)}"
+                    })
+
+                elif upgraded:
+                    events.append({
+                        "timestamp": upgraded.group(1),
+                        "category": "package",
+                        "title": f"Upgraded {upgraded.group(2)}"
+                    })
+
+            self.last_position = file.tell()
+
+        return events

collectors/performance.py

@@ -0,0 +1,50 @@
+# collectors/performance.py
+
+import psutil
+import time
+
+
+class PerformanceCollector:
+    def __init__(self):
+        self.cpu_limit = 90
+        self.memory_limit = 90
+        self.disk_limit = 90
+
+        # Prevent alert spam when the system stays above threshold.
+        self.cooldown_seconds = 300  # 5 minutes
+        self._last_alert_ts = {}
+
+        # Warm up cpu_percent so subsequent calls don't block.
+        try:
+            psutil.cpu_percent(interval=None)
+        except Exception:
+            pass
+
+    def _emit(self, key, title, now, events):
+        last = self._last_alert_ts.get(key)
+        if last is None or (now - last) >= self.cooldown_seconds:
+            self._last_alert_ts[key] = now
+            events.append({
+                "category": "performance",
+                "title": title,
+            })
+
+    def check(self):
+        events = []
+        now = time.time()
+
+        # Non-blocking sample after warmup.
+        cpu = psutil.cpu_percent(interval=None)
+        memory = psutil.virtual_memory().percent
+        disk = psutil.disk_usage("/").percent
+
+        if cpu >= self.cpu_limit:
+            self._emit("cpu", f"CPU usage reached {cpu}%", now, events)
+
+        if memory >= self.memory_limit:
+            self._emit("memory", f"Memory usage reached {memory}%", now, events)
+
+        if disk >= self.disk_limit:
+            self._emit("disk", f"Disk usage reached {disk}%", now, events)
+
+        return events

collectors/services.py

@@ -0,0 +1,56 @@
+# collectors/services.py
+
+import subprocess
+
+
+class ServiceCollector:
+    def __init__(self):
+        self.previous_states = {}
+
+    def get_services(self):
+        result = subprocess.run(
+            [
+                "systemctl",
+                "list-units",
+                "--type=service",
+                "--no-pager",
+                "--no-legend"
+            ],
+            capture_output=True,
+            text=True
+        )
+
+        services = {}
+
+        for line in result.stdout.splitlines():
+            parts = line.split()
+
+            if len(parts) >= 4:
+                name = parts[0]
+                active = parts[2]
+
+                services[name] = active
+
+        return services
+
+    def check_changes(self):
+        events = []
+
+        current = self.get_services()
+
+        for service, state in current.items():
+            old_state = self.previous_states.get(service)
+
+            if old_state is None:
+                self.previous_states[service] = state
+                continue
+
+            if old_state != state:
+                events.append({
+                    "category": "service",
+                    "title": f"{service} changed: {old_state} → {state}"
+                })
+
+                self.previous_states[service] = state
+
+        return events

collectors/shell.py

@@ -0,0 +1,55 @@
+from pathlib import Path
+import time
+
+
+class ShellCollector:
+    def __init__(self):
+        self.history_file = Path.home() / ".bash_history"
+
+        # File offset for incremental reads.
+        self.position = 0
+        self._last_seen_ts = {}
+
+        # Cooldown to reduce duplicates for the exact same command.
+        self.cooldown_seconds = 60
+
+    def _current_size(self):
+        try:
+            return self.history_file.stat().st_size
+        except FileNotFoundError:
+            return 0
+
+    def read_new_commands(self):
+        events = []
+
+        if not self.history_file.exists():
+            return events
+
+        current_size = self._current_size()
+
+        # Handle rotation/truncation: if file shrank, reset offset.
+        if current_size < self.position:
+            self.position = 0
+
+        now = time.time()
+
+        with open(self.history_file, "r", encoding="utf-8", errors="ignore") as file:
+            file.seek(self.position)
+
+            for line in file:
+                command = line.strip()
+                if not command:
+                    continue
+
+                last = self._last_seen_ts.get(command)
+                if last is None or (now - last) >= self.cooldown_seconds:
+                    self._last_seen_ts[command] = now
+                    events.append({
+                        "category": "shell",
+                        "title": command,
+                    })
+
+            self.position = file.tell()
+
+        return events
+

commands/search.py

@@ -0,0 +1,28 @@
+# commands/search.py
+
+from database import Database
+
+
+def run(keyword):
+    db = Database()
+
+    results = db.search_events(keyword)
+
+    print(f"\nResults for: {keyword}\n")
+
+    if not results:
+        print("No matching events found.")
+        db.close()
+        return
+
+    for timestamp, category, title, details in results:
+        print(
+            f"{timestamp} "
+            f"[{category.upper()}] "
+            f"{title}"
+        )
+
+        if details:
+            print(f"    {details}")
+
+    db.close()

commands/stats.py

@@ -0,0 +1,54 @@
+# commands/stats.py
+
+from database import Database
+
+
+def run():
+    db = Database()
+
+    cursor = db.cursor
+
+    # Total events
+    cursor.execute("""
+        SELECT COUNT(*)
+        FROM events
+    """)
+
+    total = cursor.fetchone()[0]
+
+    print("\nRewind Statistics\n")
+    print(f"Total events: {total}\n")
+
+    # Events per category
+    print("By category:")
+
+    cursor.execute("""
+        SELECT category, COUNT(*)
+        FROM events
+        GROUP BY category
+        ORDER BY COUNT(*) DESC
+    """)
+
+    rows = cursor.fetchall()
+
+    for category, count in rows:
+        print(f"{category.upper():15} {count}")
+
+    # Most active day
+    cursor.execute("""
+        SELECT DATE(timestamp), COUNT(*)
+        FROM events
+        GROUP BY DATE(timestamp)
+        ORDER BY COUNT(*) DESC
+        LIMIT 1
+    """)
+
+    result = cursor.fetchone()
+
+    if result:
+        date, count = result
+
+        print("\nMost active day:")
+        print(f"{date} ({count} events)")
+
+    db.close()

commands/today.py

@@ -0,0 +1,31 @@
+# commands/today.py
+from datetime import datetime
+from database import Database
+
+
+def run():
+    db = Database()
+
+    today = datetime.now().strftime("%Y-%m-%d")
+
+    events = db.get_events_by_date(today)
+
+    print(f"\nRewind - {today}\n")
+
+    if not events:
+        print("No events found.")
+        return
+
+    for timestamp, category, title, details in events:
+        time_only = timestamp.split()[1]
+
+        print(
+            f"[{time_only}] "
+            f"[{category.upper()}] "
+            f"{title}"
+        )
+
+        if details:
+            print(f"    {details}")
+
+    db.close()

commands/yesterday.py

@@ -0,0 +1,35 @@
+# commands/yesterday.py
+
+from datetime import datetime, timedelta
+from database import Database
+
+
+def run():
+    db = Database()
+
+    yesterday = (
+        datetime.now() - timedelta(days=1)
+    ).strftime("%Y-%m-%d")
+
+    events = db.get_events_by_date(yesterday)
+
+    print(f"\nRewind - {yesterday}\n")
+
+    if not events:
+        print("No events found.")
+        db.close()
+        return
+
+    for timestamp, category, title, details in events:
+        time_only = timestamp.split()[1]
+
+        print(
+            f"[{time_only}] "
+            f"[{category.upper()}] "
+            f"{title}"
+        )
+
+        if details:
+            print(f"    {details}")
+
+    db.close()

database.py

@@ -0,0 +1,104 @@
+import sqlite3
+from pathlib import Path
+from datetime import datetime
+
+DB_PATH = Path.home() / ".rewind.db"
+
+
+class Database:
+    def __init__(self):
+        self.conn = sqlite3.connect(DB_PATH)
+        self.cursor = self.conn.cursor()
+        self.create_tables()
+
+    def create_tables(self):
+        self.cursor.execute("""
+        CREATE TABLE IF NOT EXISTS events (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            timestamp TEXT NOT NULL,
+            category TEXT NOT NULL,
+            title TEXT NOT NULL,
+            details TEXT
+        )
+        """)
+
+        # Indexes for faster timeline queries as the DB grows.
+        self.cursor.execute(
+            "CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp)"
+        )
+        self.cursor.execute(
+            "CREATE INDEX IF NOT EXISTS idx_events_category ON events(category)"
+        )
+        self.cursor.execute(
+            "CREATE INDEX IF NOT EXISTS idx_events_title ON events(title)"
+        )
+
+        self.conn.commit()
+
+    def add_event(self, category, title, details="", timestamp=None):
+        if timestamp is None:
+            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        self.cursor.execute(
+            "INSERT INTO events (timestamp, category, title, details) VALUES (?, ?, ?, ?)",
+            (timestamp, category, title, details),
+        )
+        self.conn.commit()
+
+    def add_events(self, events):
+        """Bulk insert events.
+
+        events: iterable of dicts with keys: category, title
+        optional keys: details, timestamp
+        """
+        rows = []
+        for event in events:
+            category = event.get("category")
+            title = event.get("title")
+            details = event.get("details", "")
+            timestamp = event.get("timestamp")
+            if category is None or title is None:
+                continue
+            if timestamp is None:
+                timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            rows.append((timestamp, category, title, details))
+
+        if not rows:
+            return
+
+        self.cursor.executemany(
+            "INSERT INTO events (timestamp, category, title, details) VALUES (?, ?, ?, ?)",
+            rows,
+        )
+        self.conn.commit()
+
+    def get_all_events(self):
+        self.cursor.execute("""
+        SELECT id, timestamp, category, title, details
+        FROM events
+        ORDER BY timestamp DESC
+        """)
+
+        return self.cursor.fetchall()
+
+    def get_events_by_date(self, date):
+        self.cursor.execute("""
+        SELECT timestamp, category, title, details
+        FROM events
+        WHERE DATE(timestamp) = ?
+        ORDER BY timestamp
+        """, (date,))
+
+        return self.cursor.fetchall()
+
+    def search_events(self, keyword):
+        self.cursor.execute("""
+        SELECT timestamp, category, title, details
+        FROM events
+        WHERE title LIKE ? OR details LIKE ?
+        ORDER BY timestamp DESC
+        """, (f"%{keyword}%", f"%{keyword}%"))
+
+        return self.cursor.fetchall()
+
+    def close(self):
+        self.conn.close()

rewind.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+
+import sys
+import threading
+import signal
+
+from commands import today
+from commands import yesterday
+from commands import search
+from commands import stats
+from collectors import collect
+
+
+
+def show_help():
+    print("""
+Rewind - Linux Time Machine
+
+Usage:
+    rewind today
+    rewind yesterday
+    rewind search <keyword>
+    rewind stats
+    rewind help
+""")
+
+
+def main():
+    stop_event = threading.Event()
+
+    def start_collector():
+        collect.start(stop_event=stop_event)
+
+    collector_thread = threading.Thread(target=start_collector, daemon=True)
+
+    def _handle_signal(signum, frame):
+        stop_event.set()
+        raise SystemExit(0)
+
+    signal.signal(signal.SIGINT, _handle_signal)
+    signal.signal(signal.SIGTERM, _handle_signal)
+
+    collector_thread.start()
+
+    if len(sys.argv) < 2:
+        show_help()
+        return
+
+    command = sys.argv[1]
+
+    if command == "monitor":
+        collect.start()
+
+    elif command == "today":
+        today.run()
+
+    elif command == "yesterday":
+        yesterday.run()
+
+    elif command == "search":
+        if len(sys.argv) < 3:
+            print("Error: missing search keyword.")
+            return
+
+        keyword = " ".join(sys.argv[2:])
+        search.run(keyword)
+
+    elif command == "stats":
+        stats.run()
+
+    elif command == "help":
+        show_help()
+
+    else:
+        print(f"Unknown command: {command}")
+        show_help()
+
+
+if __name__ == "__main__":
+    main()

rewind_timeline-0.1.0.dist-info/METADATA

@@ -0,0 +1,274 @@
+Metadata-Version: 2.4
+Name: rewind-timeline
+Version: 0.1.0
+Summary: Linux timeline collector and monitoring tool
+Home-page: https://github.com/LaVenganzaDelLadron/rewind.git
+Author: DarkGlitch
+Author-email: darkglitch5417@gmail.com
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Rewind
+
+**Rewind** is a Linux Time Machine that records important system events and allows users to revisit what happened on their machine.
+
+It helps answer questions such as:
+
+* What changed yesterday?
+* Why did my system become slow?
+* Which package was installed?
+* Which service stopped?
+* What commands did I run?
+* Which files were modified?
+
+Rewind stores these events locally in a SQLite database and provides a simple command-line interface for exploring the system timeline.
+
+---
+
+## Features
+
+* Package monitoring (Pacman support)
+* Service monitoring
+* Performance monitoring
+* Shell history tracking
+* File change monitoring
+* Timeline search
+* Daily activity reports
+* System statistics
+
+---
+
+## Project Structure
+
+```text
+rewind/
+├── collect.py
+├── rewind.py
+├── database.py
+│
+├── collectors/
+│   ├── files.py
+│   ├── packages.py
+│   ├── performance.py
+│   ├── services.py
+│   └── shell.py
+│
+├── commands/
+│   ├── search.py
+│   ├── stats.py
+│   ├── today.py
+│   └── yesterday.py
+│
+└── rewind.db
+```
+
+---
+
+## Requirements
+
+* Python 3.10+
+* Linux
+* systemd
+* SQLite
+
+Install dependencies:
+
+```bash
+pip install psutil watchdog
+```
+
+---
+
+## Running the Collector
+
+The collector continuously monitors the system and stores events.
+
+```bash
+python collect.py
+```
+
+The collector records:
+
+* package changes
+* service state changes
+* performance alerts
+* shell history
+* file modifications
+
+---
+
+## Commands
+
+### View today's events
+
+```bash
+python rewind.py today
+```
+
+### View yesterday's events
+
+```bash
+python rewind.py yesterday
+```
+
+### Search the timeline
+
+```bash
+python rewind.py search nginx
+```
+
+### View statistics
+
+```bash
+python rewind.py stats
+```
+
+### Show help
+
+```bash
+python rewind.py help
+```
+
+---
+
+## Example
+
+```text
+$ python rewind.py today
+
+Rewind - 2026-06-27
+
+[08:32:10] [PACKAGE] Installed nginx
+[09:15:22] [FILE] Modified /etc/ssh/sshd_config
+[11:10:33] [PERFORMANCE] CPU usage reached 95%
+[13:00:17] [SERVICE] nginx.service restarted
+[13:01:55] [SHELL] sudo systemctl restart nginx
+```
+
+---
+
+## Database
+
+Rewind stores events inside a local SQLite database.
+
+Location:
+
+```text
+~/.rewind.db
+```
+
+Schema:
+
+```sql
+CREATE TABLE events (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    timestamp TEXT NOT NULL,
+    category TEXT NOT NULL,
+    title TEXT NOT NULL,
+    details TEXT
+);
+```
+
+---
+
+## Current Collectors
+
+### Package Collector
+
+Parses:
+
+```text
+/var/log/pacman.log
+```
+
+Tracks:
+
+* installed packages
+* removed packages
+* upgraded packages
+
+---
+
+### Service Collector
+
+Uses:
+
+```text
+systemctl
+```
+
+Tracks:
+
+* started services
+* stopped services
+* restarted services
+* failed services
+
+---
+
+### Performance Collector
+
+Monitors:
+
+* CPU usage
+* memory usage
+* disk usage
+
+---
+
+### Shell Collector
+
+Reads:
+
+```text
+~/.bash_history
+```
+
+Tracks executed commands.
+
+---
+
+### File Collector
+
+Uses:
+
+```text
+watchdog
+```
+
+Tracks:
+
+* created files
+* modified files
+* deleted files
+
+---
+
+## Roadmap
+
+* systemd service support
+* daemon mode
+* multi-distribution package support
+* export reports
+* weekly summaries
+* interactive TUI
+* notifications
+* command learning mode
+* performance history graphs
+
+---
+
+## License
+
+MIT License
+
+---
+
+## Author
+
+Created by DarkGlitch.
+
+Rewind aims to become a personal timeline for Linux systems.

rewind_timeline-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+database.py,sha256=jEEnNslQ9AJx-Ag29jql8wgyrDg52aBJbkBgr-yTQGA,3116
+rewind.py,sha256=dfy_iV4jEcFsKOak8meqad_i_2PDRzwYWxcFtvFdqR0,1475
+collectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+collectors/collect.py,sha256=uxVsd8yP-S1faGVoLfaKtYMR_Iy_9hfM07k-LSaSOwU,1349
+collectors/files.py,sha256=0uFEgq2FeRuz184D-IolHk5OXMviSMmKkMwioyOwAEA,2748
+collectors/packages.py,sha256=yM_I1h10CcagxqLat8f6FR-nFrpBCqSR8Axk8sZS0Jo,1686
+collectors/performance.py,sha256=csT3aOoCX28fYH0UNalIU2xjnQ6lHn8vZDf_5bcteUk,1452
+collectors/services.py,sha256=PkmXJxDDk7jlcq1fTBXEZe8O7IpYE_wnLN5yOzI3P6g,1298
+collectors/shell.py,sha256=23ykBbNMTup4i2PBxJ-j8wmjbiqkmeDJuEdK2RXoe-A,1487
+commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+commands/search.py,sha256=7kJZXJZnXrd28fx9hqP_-PzdcXO5Zwl1B7CB_MQ36ns,515
+commands/stats.py,sha256=UpQvCqzaDSTZY9boz7aaX5alNJeA-U6wfi6K3NLDQVY,988
+commands/today.py,sha256=LJ0B2kB-iinAlFjKGs5yrncszDFA7VxqUGAU_2sX1e0,595
+commands/yesterday.py,sha256=3T91mOAQhTff6RHIJGoV3LghvvCMh5WKypd5ugUksj8,678
+rewind_timeline-0.1.0.dist-info/licenses/LICENSE,sha256=zRp28a4eWydIgwuAKXlfZPfHFcpLZh5eHVjAhiC6crU,1067
+rewind_timeline-0.1.0.dist-info/METADATA,sha256=XazGnysTja1Wal3Q-VhJ_rjsBaS9mDh9X4ZVknemjng,3733
+rewind_timeline-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+rewind_timeline-0.1.0.dist-info/top_level.txt,sha256=jyAjhXtmhL_E25CUy3kPoeWOnSxauknzUKwkFqhjAbY,36
+rewind_timeline-0.1.0.dist-info/RECORD,,

rewind_timeline-0.1.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
+

rewind_timeline-0.1.0.dist-info/licenses/LICENSE

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

rewind_timeline-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+collectors
+commands
+database
+rewind