lsoph 0.0.1__tar.gz

lsoph-0.0.1/LICENSE.md

@@ -0,0 +1,7 @@
+# WTFPL + Warranty
+
+Licensed under the WTFPL with one additional clause:
+
+1. Don't blame me.
+
+Do whatever the fuck you want, just don't blame me.

lsoph-0.0.1/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: lsoph
+Version: 0.0.1
+Summary: An interactive lsof alternative
+Author-email: Gareth Davidson <gaz@bitplane.net>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: Public Domain
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+License-File: LICENSE.md
+Requires-Dist: psutil~=7.0
+Requires-Dist: textual~=3.1
+Requires-Dist: flake8 ; extra == "dev"
+Requires-Dist: pre-commit ; extra == "dev"
+Requires-Dist: pytest ; extra == "dev"
+Requires-Dist: coverage ; extra == "dev"
+Requires-Dist: pytest-cov ; extra == "dev"
+Requires-Dist: build ; extra == "dev"
+Requires-Dist: twine ; extra == "dev"
+Project-URL: Bug Tracker, https://github.com/bitplane/lsoph/issues
+Project-URL: Homepage, https://bitplane.net/dev/python/lsoph
+Project-URL: Source Code, https://github.com/bitplane/lsoph
+Provides-Extra: dev
+
+# 🤖 `lsoph` - list open files using genai slop!
+
+TUI that lists open files for a given process.
+
+usage:
+
+```shell
+uvx lsoph
+```
+
+## Why?
+Because I thought it'd only take a couple of hours, and I'd heard good
+things about Gemini 2.5 Pro, so did it as a coding test.
+
+It descended into madness over the course of a weekend. Vibe coders,
+I never realised how bad you have it!
+
+### Gemini 2.5 Pro
+
+* ☕ Writes more code than a Java consultancy that's paid by LoC.
+* 🤡 Defends against every type of exception, even import errors; belt,
+  braces and elasticated waist.
+* 👖 Its trousers still fall down.
+* 🧱 Hard codes special cases and unreachable logic.
+* 🔥 Will put verbose debug logging in your hottest loops.
+* 🗑 Starts at the complexity ceiling, and manages to climb higher with
+  every change.
+* ✅ It needs to be BEST CORRECT, with the pig-headed stubbornness of
+  `class UnwaveringPigsHead(basemodel)`.
+* 🖕 Leaves passive aggressive comments in your code if you abuse it enough,
+  and doesn't like to tidy up.
+* 🪦 It can't write test cases, or testable code.
+* 💣 Carried by an enormous context window and rapid generation speed,
+  then the wheels come off.
+
+### GPT 4o and 4.5
+
+* 💩 Can't take the volume of dogshit produced by Gemini (but to be fair who
+  can?)
+* 💤 Gets lazy because it's got no context window left, or because Sama is
+  saving all his GPUs. Probably both.
+* 🥱 Attention slips, it forgets where its up to and then hallucinates all
+  the details.
+* 🤥 Sycophantmaxxer, but still ignores your requests.
+* 🎉 Can actually write unit tests.
+* 🚬 Has actually stopped being such an aggressively "safety focused" PR
+  bellend.
+* 😎 A classic case of being down with the kids, a move that's absolute chefs
+  kiss.
+
+### Claude 3.7
+
+* 🫗 It has none of the tools that GPT has, none of the mental models that
+  Gemini has.
+* 🚽 Still pisses all over them from a great height.
+* 💇 Decent eye for aesthetics.
+* 🪟 Has a better window size than GPT, and can focus attention better too.
+* 👉 Mostly does as its told.
+* 💩 Still can't write good code.
+* 🤓 No banter game whatsoever.
+
+## Summary
+
+In the kingdom of the token generators, the one-eyed Claude is king.
+
+

lsoph-0.0.1/README.md

@@ -0,0 +1,65 @@
+# 🤖 `lsoph` - list open files using genai slop!
+
+TUI that lists open files for a given process.
+
+usage:
+
+```shell
+uvx lsoph
+```
+
+## Why?
+Because I thought it'd only take a couple of hours, and I'd heard good
+things about Gemini 2.5 Pro, so did it as a coding test.
+
+It descended into madness over the course of a weekend. Vibe coders,
+I never realised how bad you have it!
+
+### Gemini 2.5 Pro
+
+* ☕ Writes more code than a Java consultancy that's paid by LoC.
+* 🤡 Defends against every type of exception, even import errors; belt,
+  braces and elasticated waist.
+* 👖 Its trousers still fall down.
+* 🧱 Hard codes special cases and unreachable logic.
+* 🔥 Will put verbose debug logging in your hottest loops.
+* 🗑 Starts at the complexity ceiling, and manages to climb higher with
+  every change.
+* ✅ It needs to be BEST CORRECT, with the pig-headed stubbornness of
+  `class UnwaveringPigsHead(basemodel)`.
+* 🖕 Leaves passive aggressive comments in your code if you abuse it enough,
+  and doesn't like to tidy up.
+* 🪦 It can't write test cases, or testable code.
+* 💣 Carried by an enormous context window and rapid generation speed,
+  then the wheels come off.
+
+### GPT 4o and 4.5
+
+* 💩 Can't take the volume of dogshit produced by Gemini (but to be fair who
+  can?)
+* 💤 Gets lazy because it's got no context window left, or because Sama is
+  saving all his GPUs. Probably both.
+* 🥱 Attention slips, it forgets where its up to and then hallucinates all
+  the details.
+* 🤥 Sycophantmaxxer, but still ignores your requests.
+* 🎉 Can actually write unit tests.
+* 🚬 Has actually stopped being such an aggressively "safety focused" PR
+  bellend.
+* 😎 A classic case of being down with the kids, a move that's absolute chefs
+  kiss.
+
+### Claude 3.7
+
+* 🫗 It has none of the tools that GPT has, none of the mental models that
+  Gemini has.
+* 🚽 Still pisses all over them from a great height.
+* 💇 Decent eye for aesthetics.
+* 🪟 Has a better window size than GPT, and can focus attention better too.
+* 👉 Mostly does as its told.
+* 💩 Still can't write good code.
+* 🤓 No banter game whatsoever.
+
+## Summary
+
+In the kingdom of the token generators, the one-eyed Claude is king.
+

lsoph-0.0.1/pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "lsoph"
+description = "An interactive lsof alternative"
+version = "0.0.1"
+authors = [
+    { name = "Gareth Davidson", email = "gaz@bitplane.net" }
+]
+readme = "README.md"
+requires-python = ">=3.10"
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: Public Domain", # WTFPL
+    "Operating System :: POSIX :: Linux",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+dependencies = [
+    "psutil~=7.0",
+    "textual~=3.1"
+]
+
+[project.optional-dependencies]
+dev = [
+    "flake8",
+    "pre-commit",
+    "pytest",
+    "coverage",
+    "pytest-cov",
+    "build",
+    "twine"
+]
+
+[project.urls]
+"Homepage" = "https://bitplane.net/dev/python/lsoph"
+"Source Code" = "https://github.com/bitplane/lsoph"
+"Bug Tracker" = "https://github.com/bitplane/lsoph/issues"
+
+[build-system]
+build-backend = "flit_core.buildapi"
+requires = ["flit_core >=3.2,<4"]
+
+[project.scripts]
+lsoph = "lsoph.cli:main"
+
+[tool.isort]
+profile = "black"
+

lsoph-0.0.1/src/lsoph/backend/lsof.py

@@ -0,0 +1,329 @@
+import logging
+import os
+import re
+import subprocess
+import time
+from typing import Dict, Iterator, List, Optional, Set, Tuple
+
+from lsoph.monitor import Monitor
+from lsoph.util.pid import get_descendants
+
+# Setup logging - using the same pattern as other modules
+logging.basicConfig(
+    level=os.environ.get("LOGLEVEL", "WARNING").upper(),
+    format="%(levelname)s:%(name)s:%(message)s",
+)
+log = logging.getLogger("lsoph.backend.lsof")  # Use package-aware logger name
+
+# Regular expressions for parsing lsof output
+# Format: COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
+LSOF_LINE_RE = re.compile(
+    r"^(\S+)\s+(\d+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(.+)$"
+)
+FD_TYPE_RE = re.compile(r"(\d+)([rwu])?")
+
+
+def _parse_fd(fd_str: str) -> Tuple[Optional[int], str]:
+    """Parse the FD column from lsof output."""
+    if fd_str in ("cwd", "rtd", "txt", "mem"):
+        log.debug(f"Special FD type: {fd_str}")
+        return None, fd_str
+
+    match = FD_TYPE_RE.match(fd_str)
+    if match:
+        fd = int(match.group(1))
+        mode = match.group(2) or ""
+        log.debug(f"Parsed FD {fd} with mode '{mode}'")
+        return fd, mode
+
+    log.debug(f"Unparsable FD string: {fd_str}")
+    return None, fd_str
+
+
+def _run_lsof(pids: Optional[List[int]] = None) -> Iterator[Dict]:
+    """Run lsof and yield parsed output lines."""
+    cmd = ["lsof", "-n", "-F", "pcftn"]  # p=pid, c=command, f=fd, t=type, n=name
+
+    if pids:
+        cmd.extend(["-p", ",".join(map(str, pids))])
+
+    log.info(f"Running lsof command: {' '.join(cmd)}")
+
+    try:
+        # Redirect stderr to /dev/null to suppress tracefs warnings
+        with open(os.devnull, "w") as devnull:
+            proc = subprocess.Popen(
+                cmd, stdout=subprocess.PIPE, stderr=devnull, text=True
+            )
+
+        current_record = {}
+        for line in proc.stdout:
+            line = line.strip()
+            if not line:
+                continue
+
+            field_type = line[0]
+            value = line[1:]
+
+            if field_type == "p" and current_record:
+                # New process, yield previous record
+                yield current_record
+                current_record = {"pid": int(value)}
+            elif field_type == "p":
+                current_record = {"pid": int(value)}
+            elif field_type == "c":
+                current_record["command"] = value
+            elif field_type == "f":
+                current_record["fd_str"] = value
+                fd, mode = _parse_fd(value)
+                current_record["fd"] = fd
+                current_record["mode"] = mode
+            elif field_type == "t":
+                current_record["type"] = value
+            elif field_type == "n":
+                current_record["path"] = value
+                log.debug(
+                    f"Complete record: PID {current_record.get('pid')}, FD {current_record.get('fd')}, path {value}"
+                )
+                yield current_record
+                current_record = {
+                    "pid": current_record["pid"],
+                    "command": current_record["command"],
+                }
+
+        # Yield final record if any
+        if current_record and "path" in current_record:
+            log.debug(f"Final record: {current_record}")
+            yield current_record
+
+    except subprocess.SubprocessError as e:
+        log.error(f"Error running lsof: {e}")
+    except Exception as e:
+        log.exception(f"Unexpected error in _run_lsof: {e}")
+    finally:
+        if proc.stdout:
+            proc.stdout.close()
+        exit_code = proc.wait()
+        log.debug(f"lsof process exited with code: {exit_code}")
+
+
+def _process_lsof_data(record: Dict, monitor: Monitor, timestamp: float) -> None:
+    """Process a parsed lsof record and update the monitor."""
+    pid = record.get("pid")
+    path = record.get("path")
+    fd = record.get("fd")
+
+    if not (pid and path):
+        log.debug(f"Incomplete record missing pid or path: {record}")
+        return
+
+    # If fd is None, this is a special file like cwd, not an open fd
+    if fd is None:
+        fd_str = record.get("fd_str", "unknown")
+        log.debug(f"Special file {fd_str} for PID {pid}: {path}")
+        monitor.stat(pid, path, True, timestamp)
+        return
+
+    # For regular files, add as open
+    log.debug(f"Processing open file: PID {pid}, FD {fd}, path {path}")
+    monitor.open(pid, path, fd, True, timestamp)
+
+    # Check mode to determine if it's being read/written
+    mode = record.get("mode", "")
+    if "r" in mode:
+        log.debug(f"File has read mode: PID {pid}, FD {fd}")
+        monitor.read(pid, fd, path, True, timestamp)
+    if "w" in mode:
+        log.debug(f"File has write mode: PID {pid}, FD {fd}")
+        monitor.write(pid, fd, path, True, timestamp)
+
+
+def _attach_with_descendants(pids: List[int], monitor: Monitor) -> None:
+    """
+    Attach to processes, their descendants, and monitor their open files using lsof.
+    This version tracks child processes by periodically checking for descendants.
+    """
+    log.info(f"Attaching to initial PIDs: {pids}")
+
+    # Keep track of all PIDs we're monitoring (including descendants)
+    all_pids = set(pids)
+
+    # Keep track of file descriptors we've seen for each PID
+    # to detect closures on subsequent runs
+    seen_fds: Dict[int, Set[Tuple[int, str]]] = {}
+
+    try:
+        poll_interval = 1.0  # seconds
+        child_check_interval = 5.0  # check for new children every 5 polls
+        poll_count = 0
+
+        log.info(f"Starting lsof polling with interval: {poll_interval} seconds")
+
+        while True:
+            timestamp = time.time()
+            poll_count += 1
+
+            # Check for descendants periodically
+            if poll_count % child_check_interval < 1:
+                log.debug(f"Checking for new child processes of {pids}")
+                new_pids = set()
+                for parent_pid in pids:
+                    try:
+                        descendants = get_descendants(parent_pid)
+                        for child_pid in descendants:
+                            if child_pid not in all_pids:
+                                log.info(f"Found new child process: {child_pid}")
+                                new_pids.add(child_pid)
+                    except Exception as e:
+                        log.debug(
+                            f"Error checking descendants for PID {parent_pid}: {e}"
+                        )
+
+                # Add any new PIDs to our tracking set
+                if new_pids:
+                    log.info(
+                        f"Adding {len(new_pids)} new child processes to monitoring"
+                    )
+                    all_pids.update(new_pids)
+
+            # Convert set back to list for lsof
+            current_pids = list(all_pids)
+            current_fds: Dict[int, Set[Tuple[int, str]]] = {}
+
+            record_count = 0
+            for record in _run_lsof(current_pids):
+                record_count += 1
+                pid = record.get("pid")
+                fd = record.get("fd")
+                path = record.get("path")
+
+                if pid and fd is not None and path:
+                    if pid not in current_fds:
+                        current_fds[pid] = set()
+                    current_fds[pid].add((fd, path))
+
+                _process_lsof_data(record, monitor, timestamp)
+
+            log.debug(f"Processed {record_count} lsof records")
+
+            # Detect closed files (present in seen_fds but not in current_fds)
+            close_count = 0
+            for pid, fd_paths in seen_fds.items():
+                current_pid_fds = current_fds.get(pid, set())
+                for fd, path in fd_paths:
+                    if (fd, path) not in current_pid_fds:
+                        log.debug(
+                            f"Detected closed file: PID {pid}, FD {fd}, path {path}"
+                        )
+                        monitor.close(pid, fd, True, timestamp)
+                        close_count += 1
+
+            if close_count > 0:
+                log.debug(f"Detected {close_count} closed files")
+
+            seen_fds = current_fds
+            log.debug(f"Sleeping for {poll_interval} seconds")
+            time.sleep(poll_interval)
+
+    except KeyboardInterrupt:
+        log.info("lsof monitoring interrupted by user")
+    except Exception as e:
+        log.exception(f"Unexpected error in lsof attach: {e}")
+
+
+def attach(pids: List[int], monitor: Monitor) -> None:
+    """
+    Standard attach function which monitors the specified PIDs without tracking descendants.
+    For command execution with descendants tracking, use _attach_with_descendants.
+    """
+    log.info(f"Attaching to PIDs: {pids}")
+
+    # Keep track of file descriptors we've seen for each PID
+    # to detect closures on subsequent runs
+    seen_fds: Dict[int, Set[Tuple[int, str]]] = {}
+
+    try:
+        poll_interval = 1.0  # seconds
+        log.info(f"Starting lsof polling with interval: {poll_interval} seconds")
+
+        while True:
+            timestamp = time.time()
+            current_fds: Dict[int, Set[Tuple[int, str]]] = {}
+
+            record_count = 0
+            for record in _run_lsof(pids):
+                record_count += 1
+                pid = record.get("pid")
+                fd = record.get("fd")
+                path = record.get("path")
+
+                if pid and fd is not None and path:
+                    if pid not in current_fds:
+                        current_fds[pid] = set()
+                    current_fds[pid].add((fd, path))
+
+                _process_lsof_data(record, monitor, timestamp)
+
+            log.debug(f"Processed {record_count} lsof records")
+
+            # Detect closed files (present in seen_fds but not in current_fds)
+            close_count = 0
+            for pid, fd_paths in seen_fds.items():
+                current_pid_fds = current_fds.get(pid, set())
+                for fd, path in fd_paths:
+                    if (fd, path) not in current_pid_fds:
+                        log.debug(
+                            f"Detected closed file: PID {pid}, FD {fd}, path {path}"
+                        )
+                        monitor.close(pid, fd, True, timestamp)
+                        close_count += 1
+
+            if close_count > 0:
+                log.debug(f"Detected {close_count} closed files")
+
+            seen_fds = current_fds
+            log.debug(f"Sleeping for {poll_interval} seconds")
+            time.sleep(poll_interval)
+
+    except KeyboardInterrupt:
+        log.info("lsof monitoring interrupted by user")
+    except Exception as e:
+        log.exception(f"Unexpected error in lsof attach: {e}")
+
+
+def run(command: List[str], monitor: Monitor) -> None:
+    """Run a command and monitor its open files using lsof."""
+    log.info(f"Running command: {' '.join(command)}")
+
+    proc = None
+    try:
+        log.debug("Launching subprocess")
+        proc = subprocess.Popen(command)
+        pid = proc.pid
+        log.info(f"Command started with PID: {pid}")
+
+        # Track the parent process and all its descendants
+        pids = [pid]
+        # Use a custom attach function to track descendants
+        _attach_with_descendants(pids, monitor)
+
+    except subprocess.SubprocessError as e:
+        log.error(f"Error launching command: {e}")
+    except Exception as e:
+        log.exception(f"Unexpected error in lsof run: {e}")
+    finally:
+        if proc and proc.poll() is None:
+            log.info(f"Terminating command process (PID: {proc.pid})")
+            proc.terminate()
+            try:
+                proc.wait(timeout=1)
+                log.debug(
+                    f"Process terminated gracefully with exit code: {proc.returncode}"
+                )
+            except subprocess.TimeoutExpired:
+                log.debug(
+                    f"Process did not terminate gracefully, killing PID {proc.pid}"
+                )
+                proc.kill()
+                proc.wait()
+                log.debug(f"Process killed with exit code: {proc.returncode}")