2mw2lt 0.1.0__tar.gz

2mw2lt-0.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,22 @@
+# 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/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "2mw2lt"
+version = "0.1.0"
+description = "Too Much Work, Too Little Time: see what every AI coding session on this machine is running."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = ["claude-code", "codex", "ai-agents", "sessions"]
+
+[project.scripts]
+2mw2lt = "twomw2lt.cli:main"
+
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]

2mw2lt-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

2mw2lt-0.1.0/src/2mw2lt.egg-info/PKG-INFO

@@ -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/src/2mw2lt.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/2mw2lt.egg-info/PKG-INFO
+src/2mw2lt.egg-info/SOURCES.txt
+src/2mw2lt.egg-info/dependency_links.txt
+src/2mw2lt.egg-info/entry_points.txt
+src/2mw2lt.egg-info/top_level.txt
+src/twomw2lt/__init__.py
+src/twomw2lt/__main__.py
+src/twomw2lt/cli.py
+src/twomw2lt/sessions.py
+tests/test_sessions.py

2mw2lt-0.1.0/src/2mw2lt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

2mw2lt-0.1.0/src/2mw2lt.egg-info/entry_points.txt

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

2mw2lt-0.1.0/src/2mw2lt.egg-info/top_level.txt

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

2mw2lt-0.1.0/src/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"

2mw2lt-0.1.0/src/twomw2lt/__main__.py

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

2mw2lt-0.1.0/src/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

2mw2lt-0.1.0/src/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)

2mw2lt-0.1.0/tests/test_sessions.py

@@ -0,0 +1,62 @@
+import json
+import os
+
+from twomw2lt.cli import main
+from twomw2lt.sessions import scan
+
+NOW = 1_800_000_000.0
+
+
+def write(path, records, mtime):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("".join(json.dumps(r) + "\n" for r in records))
+    os.utime(path, (mtime, mtime))
+
+
+def claude_line(model, effort="high", cwd="/w/app"):
+    return {"type": "assistant", "sessionId": "c1", "cwd": cwd, "effort": effort,
+            "message": {"model": model}}
+
+
+def test_a_claude_session_reports_its_latest_model_not_a_synthetic_reply(tmp_path):
+    write(tmp_path / "claude/projects/-w-app/c1.jsonl",
+          [claude_line("claude-sonnet-5", "low"), claude_line("claude-opus-5"),
+           claude_line("<synthetic>")], NOW - 60)
+    [s] = scan(3600, claude=[tmp_path / "claude"], codex=tmp_path / "codex", now=NOW)
+    # The model the session runs is the last real one, and the effort is the latest turn's.
+    assert (s.harness, s.id, s.model, s.effort, s.project) == (
+        "claude", "c1", "claude-opus-5", "high", "/w/app")
+
+
+def test_a_resumed_codex_session_is_one_row_filled_from_its_earlier_rollout(tmp_path):
+    meta = {"type": "session_meta", "payload": {"id": "x1", "cwd": "/w/api"}}
+    turn = {"type": "turn_context", "payload": {"cwd": "/w/api", "model": "gpt-5.6-sol",
+                                                "effort": "low"}}
+    write(tmp_path / "codex/sessions/2026/09/18/rollout-a-x1.jsonl", [meta, turn], NOW - 600)
+    # The resumed file has not restated its turn context yet.
+    write(tmp_path / "codex/sessions/2026/09/19/rollout-b-x1.jsonl", [meta], NOW - 10)
+    [s] = scan(3600, claude=[], codex=tmp_path / "codex", now=NOW)
+    assert (s.id, s.model, s.effort, s.last_active) == ("x1", "gpt-5.6-sol", "low", NOW - 10)
+
+
+def test_a_session_quiet_for_longer_than_the_window_is_left_out(tmp_path):
+    write(tmp_path / "claude/projects/-w-app/c1.jsonl", [claude_line("claude-opus-5")],
+          NOW - 7200)
+    assert scan(3600, claude=[tmp_path / "claude"], codex=tmp_path / "codex", now=NOW) == []
+
+
+def test_a_subagent_transcript_is_not_its_own_session(tmp_path):
+    write(tmp_path / "claude/projects/-w-app/c1/subagents/agent-1.jsonl",
+          [claude_line("claude-haiku-4-5")], NOW - 60)
+    assert scan(3600, claude=[tmp_path / "claude"], codex=tmp_path / "codex", now=NOW) == []
+
+
+def test_json_output_is_one_object_per_session(tmp_path, monkeypatch, capsys):
+    write(tmp_path / ".claude/projects/-w-app/c1.jsonl", [claude_line("claude-opus-5")],
+          os.path.getmtime(tmp_path))
+    monkeypatch.setenv("HOME", str(tmp_path))
+    monkeypatch.delenv("CLAUDE_CONFIG_DIR", raising=False)
+    monkeypatch.setenv("CODEX_HOME", str(tmp_path / "none"))
+    assert main(["--json", "--since", "7d"]) == 0
+    [line] = capsys.readouterr().out.splitlines()
+    assert json.loads(line)["model"] == "claude-opus-5"