jung 0.4.0__py3-none-any.whl

jung/__init__.py

@@ -0,0 +1,3 @@
+"""jung — version control context for AI-assisted development."""
+
+__version__ = "0.4.0"

jung/__main__.py

@@ -0,0 +1,4 @@
+from jung.main import cli
+
+if __name__ == "__main__":
+    cli()

jung/_daemonize.py

@@ -0,0 +1,137 @@
+"""Daemonize support for Windows and POSIX.
+
+Windows: spawns a background subprocess with CREATE_NO_WINDOW flag.
+POSIX: double-fork pattern with /dev/null redirection.
+
+This module provides a single daemonize() function that starts the
+daemon entrypoint in the background and writes a PID file.
+"""
+
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import sys
+from pathlib import Path
+
+
+JUNG_DIR_NAME = ".jung"
+PID_FILENAME = "daemon.pid"
+
+
+def daemonize(chronicle_dir: Path, extra_args: list[str] | None = None) -> int:
+    """Launch the jung daemon in the background.
+
+    Returns the PID of the background process.
+    """
+    chronicle_dir.mkdir(parents=True, exist_ok=True)
+    pid_path = chronicle_dir / PID_FILENAME
+
+    if os.name == "nt":
+        return _daemonize_windows(chronicle_dir, pid_path, extra_args)
+    else:
+        return _daemonize_posix(chronicle_dir, pid_path, extra_args)
+
+
+def is_running(chronicle_dir: Path) -> bool:
+    """Check if the daemon is running by reading PID file."""
+    pid_path = chronicle_dir / PID_FILENAME
+    if not pid_path.exists():
+        return False
+    pid_str = pid_path.read_text().strip()
+    if not pid_str:
+        return False
+    try:
+        pid = int(pid_str)
+    except ValueError:
+        return False
+
+    if os.name == "nt":
+        return _is_pid_alive_windows(pid)
+    else:
+        return _is_pid_alive_posix(pid)
+
+
+def stop_daemon(chronicle_dir: Path) -> bool:
+    """Stop the running daemon. Returns True if stopped, False if not running."""
+    pid_path = chronicle_dir / PID_FILENAME
+    if not pid_path.exists():
+        return False
+    pid_str = pid_path.read_text().strip()
+    if not pid_str:
+        return False
+    try:
+        pid = int(pid_str)
+    except ValueError:
+        return False
+
+    try:
+        if os.name == "nt":
+            subprocess.run(["taskkill", "/F", "/PID", str(pid)], capture_output=True)
+        else:
+            os.kill(pid, signal.SIGTERM)
+    except (OSError, subprocess.SubprocessError):
+        pass
+
+    pid_path.unlink(missing_ok=True)
+    return True
+
+
+def _daemonize_windows(chronicle_dir: Path, pid_path: Path, extra_args: list[str] | None = None) -> int:
+    """Spawn the daemon as a background subprocess."""
+    args = extra_args or []
+    proc = subprocess.Popen(
+        [sys.executable, "-m", "jung.daemon", "--daemon"] + args,
+        cwd=str(chronicle_dir.parent),
+        creationflags=subprocess.CREATE_NO_WINDOW | subprocess.DETACHED_PROCESS,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        stdin=subprocess.DEVNULL,
+    )
+    pid_path.write_text(str(proc.pid))
+    return proc.pid
+
+
+def _daemonize_posix(chronicle_dir: Path, pid_path: Path, extra_args: list[str] | None = None) -> int:
+    """Double-fork daemonize for POSIX systems."""
+    pid = os.fork()
+    if pid > 0:
+        return pid
+
+    os.setsid()
+    pid2 = os.fork()
+    if pid2 > 0:
+        os._exit(0)
+
+    devnull = os.open(os.devnull, os.O_RDWR)
+    os.dup2(devnull, sys.stdin.fileno())
+    os.dup2(devnull, sys.stdout.fileno())
+    os.dup2(devnull, sys.stderr.fileno())
+    os.close(devnull)
+
+    pid_path.write_text(str(os.getpid()))
+
+    from jung.daemon import run_daemon
+    run_daemon(chronicle_dir=str(chronicle_dir.parent))
+
+    return os.getpid()
+
+
+def _is_pid_alive_windows(pid: int) -> bool:
+    try:
+        result = subprocess.run(
+            ["tasklist", "/FI", f"PID eq {pid}", "/NH"],
+            capture_output=True, text=True, timeout=5,
+        )
+        return str(pid) in result.stdout
+    except (subprocess.SubprocessError, OSError):
+        return False
+
+
+def _is_pid_alive_posix(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+        return True
+    except OSError:
+        return False

jung/adapter/__init__.py

@@ -0,0 +1,31 @@
+"""IngestionAdapter protocol — contract all IDE adapters must satisfy."""
+
+from typing import Iterator, Protocol
+
+from jung.models import NormalizedEvent, RawEvent, SessionRef
+
+
+class IngestionAdapter(Protocol):
+    """Interface for IDE-specific ingestion adapters.
+
+    Every adapter must implement these three methods.
+    Nothing downstream of this layer knows or cares
+    which IDE produced the data.
+    """
+
+    ide_name: str
+
+    def discover_sessions(self, workspace_path: str) -> list[SessionRef]:
+        """Find IDE-native sessions relevant to this workspace."""
+        ...
+
+    def stream_events(self, session_ref: SessionRef) -> Iterator[RawEvent]:
+        """Yield events from the IDE's native storage in real-time."""
+        ...
+
+    def parse_event(self, raw: RawEvent) -> NormalizedEvent | None:
+        """Convert an IDE-specific raw event into jung's canonical schema.
+
+        Returns None for unparseable entries (logged but skipped).
+        """
+        ...