2mw2lt 0.1.0__py3-none-any.whl

2mw2lt-0.1.0.dist-info/METADATA

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: 2mw2lt
+Version: 0.1.0
+Summary: Too Much Work, Too Little Time: see what every AI coding session on this machine is running.
+License-Expression: MIT
+Keywords: claude-code,codex,ai-agents,sessions
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# 2mw2lt
+
+**Too Much Work, Too Little Time** — when several AI coding sessions run at once, see what each
+one is doing.
+
+```console
+$ uvx 2mw2lt
+HARNESS  SESSION   MODEL          EFFORT  ACTIVE     PROJECT
+claude   e2583d33  claude-opus-5  high    just now   ~/code/app
+codex    01a0b790  gpt-5.6-sol    high    4m ago     ~/code/app
+claude   1242e7a2  claude-sonnet-5 medium 2h ago     ~/code/api
+```
+
+It reads the transcripts Claude Code (`~/.claude`, or `$CLAUDE_CONFIG_DIR`) and Codex
+(`~/.codex`, or `$CODEX_HOME`) already keep on disk. Nothing is sent anywhere and nothing is
+written.
+
+```
+2mw2lt [--since 24h] [--json]
+```
+
+`--since` takes `90m`, `24h`, `7d`. `--json` prints one object per session.

2mw2lt-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+2mw2lt-0.1.0.dist-info/licenses/LICENSE,sha256=r5JYxJ9uriQZAZHS_AwBEZkIN3ZwuIN9pVJgZUsRAAk,1064
+twomw2lt/__init__.py,sha256=xhHk_LyNUEZS52yjLV2Qr_i-O6uKt4Lef9AzpORi25I,122
+twomw2lt/__main__.py,sha256=j5lwipULQALDHnyH5fERAg3khOwgH1mcFcxipwiavdM,56
+twomw2lt/cli.py,sha256=wspEZ06NPH3OkndIICrsYeW-I47sXcj7WfGnV1PogVs,2185
+twomw2lt/sessions.py,sha256=sYlv0-Wf7Gm8bBIJhdd1TbsJ-jE1pznzTr8LWIiwqgs,5228
+2mw2lt-0.1.0.dist-info/METADATA,sha256=cEowOd6xYIYrzJb4X6CZGMhlMQiMBvyZ4DEJDNK8wkk,1041
+2mw2lt-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+2mw2lt-0.1.0.dist-info/entry_points.txt,sha256=cR4fGkqH-bGc86TFUqWhJrB_j7B9X5UE_JG5tqe0pEs,45
+2mw2lt-0.1.0.dist-info/top_level.txt,sha256=oCQRcVKI7RMgBgd9Z4ip0QkPIlK_rbOFlZeXh5F52TY,9
+2mw2lt-0.1.0.dist-info/RECORD,,

2mw2lt-0.1.0.dist-info/WHEEL

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

2mw2lt-0.1.0.dist-info/entry_points.txt

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

2mw2lt-0.1.0.dist-info/licenses/LICENSE

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

2mw2lt-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+twomw2lt

twomw2lt/__init__.py

@@ -0,0 +1,3 @@
+"""Too Much Work, Too Little Time: see what every AI coding session on this machine is running."""
+
+__version__ = "0.1.0"

twomw2lt/__main__.py

@@ -0,0 +1,3 @@
+from twomw2lt.cli import main
+
+raise SystemExit(main())

twomw2lt/cli.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import time
+from pathlib import Path
+
+from twomw2lt import __version__
+from twomw2lt.sessions import scan
+
+_UNITS = {"s": 1, "m": 60, "h": 3600, "d": 86400}
+
+
+def duration(text: str) -> float:
+    m = re.fullmatch(r"(\d+)([smhd])", text)
+    if not m:
+        raise argparse.ArgumentTypeError(f"{text!r} is not a duration like 90m, 24h or 7d")
+    return int(m.group(1)) * _UNITS[m.group(2)]
+
+
+def ago(seconds: float) -> str:
+    for unit, size in (("d", 86400), ("h", 3600), ("m", 60)):
+        if seconds >= size:
+            return f"{int(seconds // size)}{unit} ago"
+    return "just now"
+
+
+def project(path: str | None) -> str:
+    if not path:
+        return "-"
+    home = str(Path.home())
+    return "~" + path[len(home):] if path == home or path.startswith(home + "/") else path
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(
+        prog="2mw2lt",
+        description="List the Claude Code and Codex sessions on this machine: where each works, "
+        "which model it runs and at what effort. Reads local transcripts only.",
+    )
+    ap.add_argument("--since", type=duration, default=duration("24h"),
+                    help="only sessions active within this window (default 24h)")
+    ap.add_argument("--json", action="store_true", help="one JSON object per session")
+    ap.add_argument("--version", action="version", version=f"2mw2lt {__version__}")
+    args = ap.parse_args(argv)
+
+    now = time.time()
+    sessions = scan(args.since, now=now)
+    if args.json:
+        for s in sessions:
+            print(json.dumps(s.as_dict()))
+        return 0
+    if not sessions:
+        print("no sessions active in that window")
+        return 0
+    rows = [("HARNESS", "SESSION", "MODEL", "EFFORT", "ACTIVE", "PROJECT")] + [
+        (s.harness, s.id[:8], s.model or "-", s.effort or "-", ago(now - s.last_active),
+         project(s.project))
+        for s in sessions
+    ]
+    widths = [max(len(r[i]) for r in rows) for i in range(len(rows[0]) - 1)]
+    for r in rows:
+        print("  ".join(c.ljust(w) for c, w in zip(r, widths)) + "  " + r[-1])
+    return 0

twomw2lt/sessions.py

@@ -0,0 +1,144 @@
+"""Read the AI coding sessions on this machine from the transcripts their harnesses write.
+
+Nothing is sent anywhere and nothing is written: each harness already records, per session, the
+directory it works in, the model it runs and the reasoning effort it was given. This folds those
+records into one row per session.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+# A transcript's latest state is at its end; reading only the tail keeps a scan of long sessions
+# proportional to the number of sessions, not to how much each one said.
+TAIL_BYTES = 512 * 1024
+
+
+@dataclass
+class Session:
+    harness: str
+    id: str
+    project: str | None
+    model: str | None
+    effort: str | None
+    last_active: float
+    transcript: str
+
+    def as_dict(self) -> dict:
+        return asdict(self)
+
+
+def _tail_lines(path: Path, size: int = TAIL_BYTES) -> list[str]:
+    with path.open("rb") as f:
+        f.seek(0, os.SEEK_END)
+        end = f.tell()
+        f.seek(max(0, end - size))
+        data = f.read()
+    lines = data.decode("utf-8", "replace").splitlines()
+    # A cut mid-file leaves a partial first line.
+    return lines[1:] if end > size else lines
+
+
+def _records(lines: list[str]):
+    for line in lines:
+        try:
+            d = json.loads(line)
+        except ValueError:
+            continue
+        if isinstance(d, dict):
+            yield d
+
+
+def read_claude(path: Path) -> Session | None:
+    """A Claude Code transcript: one JSON object per line, `assistant` lines carry the model."""
+    project = model = effort = sid = None
+    for d in _records(_tail_lines(path)):
+        sid = d.get("sessionId") or sid
+        project = d.get("cwd") or project
+        if d.get("type") == "assistant":
+            m = d.get("message")
+            if isinstance(m, dict) and m.get("model") and not m["model"].startswith("<"):
+                model = m["model"]
+            effort = d.get("effort") or effort
+    if sid is None:
+        return None
+    return Session("claude", sid, project, model, effort, path.stat().st_mtime, str(path))
+
+
+def read_codex(path: Path) -> Session | None:
+    """A Codex rollout: `session_meta` opens it, and every turn restates its `turn_context`."""
+    with path.open("rb") as f:
+        head = f.readline().decode("utf-8", "replace")
+    s = _fold_codex(path, [head] + _tail_lines(path))
+    if s is not None and s.model is None:
+        # A turn's context can sit before the tail when one turn produced a long transcript.
+        s = _fold_codex(path, path.read_text("utf-8", "replace").splitlines())
+    return s
+
+
+def _fold_codex(path: Path, lines: list[str]) -> Session | None:
+    project = model = effort = sid = None
+    for d in _records(lines):
+        p = d.get("payload") if isinstance(d.get("payload"), dict) else {}
+        if d.get("type") == "session_meta":
+            sid = p.get("id") or p.get("session_id") or sid
+            project = p.get("cwd") or project
+        elif d.get("type") == "turn_context":
+            project = p.get("cwd") or project
+            model = p.get("model") or model
+            effort = p.get("effort") or effort
+    if sid is None:
+        return None
+    return Session("codex", sid, project, model, effort, path.stat().st_mtime, str(path))
+
+
+def claude_homes() -> list[Path]:
+    homes = [Path.home() / ".claude"]
+    if os.environ.get("CLAUDE_CONFIG_DIR"):
+        homes.insert(0, Path(os.environ["CLAUDE_CONFIG_DIR"]).expanduser())
+    return homes
+
+
+def codex_home() -> Path:
+    return Path(os.environ.get("CODEX_HOME") or Path.home() / ".codex").expanduser()
+
+
+def scan(
+    since: float,
+    claude: list[Path] | None = None,
+    codex: Path | None = None,
+    now: float | None = None,
+) -> list[Session]:
+    """Every session whose transcript changed in the last `since` seconds, most recent first."""
+    cutoff = (now if now is not None else time.time()) - since
+    found: dict[tuple[str, str], Session] = {}
+
+    def keep(s: Session | None) -> None:
+        if s is None:
+            return
+        held = found.get((s.harness, s.id))
+        if held is None:
+            found[(s.harness, s.id)] = s
+            return
+        # Codex starts a new rollout file for a resumed session; the newer file wins, and the
+        # older one fills what the newer has not recorded yet.
+        new, old = (s, held) if s.last_active > held.last_active else (held, s)
+        for field in ("project", "model", "effort"):
+            if getattr(new, field) is None:
+                setattr(new, field, getattr(old, field))
+        found[(s.harness, s.id)] = new
+
+    for home in claude if claude is not None else claude_homes():
+        # Subagent transcripts sit one level deeper and belong to their parent session.
+        for path in (home / "projects").glob("*/*.jsonl"):
+            if path.stat().st_mtime >= cutoff:
+                keep(read_claude(path))
+    root = (codex if codex is not None else codex_home()) / "sessions"
+    for path in root.glob("**/rollout-*.jsonl"):
+        if path.stat().st_mtime >= cutoff:
+            keep(read_codex(path))
+    return sorted(found.values(), key=lambda s: s.last_active, reverse=True)