worklog-for-claude-code 0.1.0__py3-none-any.whl

worklog/report.py

@@ -0,0 +1,229 @@
+"""Daily report: merge records from all devices/accounts, summarize, render Markdown."""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import shutil
+import subprocess
+from dataclasses import dataclass, field
+from datetime import date, datetime
+
+from .config import DEFAULT_CLAUDE_DIR, SUMMARIZER_CWD, Config
+from .parser import zero_tokens
+from .redact import redact
+from .store import GitStore
+
+log = logging.getLogger(__name__)
+_MAX_AI_INPUT_CHARS = 24_000  # keep each summary call small and well below arg-size limits
+
+
+def project_key(proj: dict) -> str:
+    """Same repo on two machines (different paths) merges via its remote slug."""
+    remote = proj.get("remote")
+    return f"{remote['host']}/{remote['slug']}" if remote else f"{proj.get('kind')}:{proj.get('name')}"
+
+
+@dataclass
+class ProjectDay:
+    key: str
+    name: str
+    kind: str
+    remote: dict | None
+    accounts: set[str] = field(default_factory=set)
+    devices: set[str] = field(default_factory=set)
+    sessions: int = 0
+    minutes: int = 0
+    tokens: dict[str, int] = field(default_factory=zero_tokens)
+    prompts: list[tuple[str, str]] = field(default_factory=list)  # (start time, prompt)
+    files: set[str] = field(default_factory=set)
+    folders: set[str] = field(default_factory=set)
+    commits: dict[str, str] = field(default_factory=dict)  # hash -> subject (deduped)
+    branches: set[str] = field(default_factory=set)
+
+
+def _add(dst: dict[str, int], src: object) -> None:
+    for k in dst:
+        v = src.get(k, 0) if isinstance(src, dict) else 0
+        dst[k] += v if isinstance(v, int) else 0
+
+
+def aggregate(records: list[dict]):
+    accounts: dict[str, dict] = {}
+    projects: dict[str, ProjectDay] = {}
+    for r in records:
+        acct = accounts.setdefault(r.get("account", "?"), {
+            "tokens": zero_tokens(), "sessions": 0, "devices": set(), "models": {}})
+        _add(acct["tokens"], r.get("tokens"))
+        acct["sessions"] += 1
+        acct["devices"].add(r.get("device", "?"))
+        for model, t in (r.get("tokens_by_model") or {}).items():
+            _add(acct["models"].setdefault(model, zero_tokens()), t)
+
+        proj = r.get("project") or {}
+        key = project_key(proj)
+        p = projects.setdefault(key, ProjectDay(key, str(proj.get("name", "?")), str(proj.get("kind")),
+                                                proj.get("remote")))
+        p.accounts.add(r.get("account", "?"))
+        p.devices.add(r.get("device", "?"))
+        p.sessions += 1
+        p.minutes += int(r.get("span_minutes") or 0)
+        _add(p.tokens, r.get("tokens"))
+        start = (r.get("start") or "")[11:16]
+        p.prompts.extend((start, q) for q in r.get("prompts") or [])
+        p.files.update(r.get("files_touched") or [])
+        p.branches.update(proj.get("branches") or [])
+        if proj.get("folder"):
+            p.folders.add(proj["folder"])
+        for c in r.get("commits") or []:
+            p.commits.setdefault(c.get("hash", ""), c.get("subject", ""))
+    for p in projects.values():
+        p.prompts.sort()
+    return accounts, projects
+
+
+# ------------------------------------------------------------ summarization
+def _claude_env(cfg: Config) -> dict[str, str]:
+    env = dict(os.environ)
+    acct = cfg.account(cfg.summarizer_account)
+    if acct and acct.config_dir != DEFAULT_CLAUDE_DIR:
+        env["CLAUDE_CONFIG_DIR"] = str(acct.config_dir)
+    else:
+        env.pop("CLAUDE_CONFIG_DIR", None)
+    return env
+
+
+def ai_summary(p: ProjectDay, day: date, cfg: Config) -> list[str] | None:
+    exe = shutil.which(cfg.claude_bin)
+    if not exe:
+        log.warning("claude binary %r not found; using plain summary", cfg.claude_bin)
+        return None
+    data = {
+        "project": p.name, "kind": p.kind, "branches": sorted(p.branches), "folders": sorted(p.folders),
+        "prompts_in_order": [q for _, q in p.prompts],
+        "commits": list(p.commits.values()), "files_edited": sorted(p.files)[:80],
+    }
+    blob = json.dumps(data, ensure_ascii=False)[:_MAX_AI_INPUT_CHARS]
+    prompt = (
+        f"You are writing a developer's end-of-day work log for {day.isoformat()}. "
+        "The JSON below was extracted from their Claude Code sessions for ONE project. "
+        "Write 2-7 concise bullet points describing what was accomplished or investigated "
+        "(features implemented, bugs fixed, refactors, research). Past tense, no fluff. "
+        "Use ONLY the data given; if something is unclear, describe it generically rather than guess. "
+        "Output only the bullets, each line starting with '- '. Do not use any tools.\n\n"
+        f"<data>\n{blob}\n</data>"
+    )
+    SUMMARIZER_CWD.mkdir(parents=True, exist_ok=True)  # excluded by the collector
+    try:
+        out = subprocess.run([exe, "-p", prompt, "--output-format", "text"], cwd=SUMMARIZER_CWD,
+                             env=_claude_env(cfg), capture_output=True, text=True, timeout=cfg.ai_timeout)
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        log.warning("claude -p failed for %s: %s", p.name, exc)
+        return None
+    if out.returncode != 0:
+        log.warning("claude -p exited %d for %s: %s", out.returncode, p.name, out.stderr.strip()[:300])
+        return None
+    bullets = [redact(line.strip())[:400] for line in out.stdout.splitlines()
+               if line.strip().startswith(("- ", "* "))]
+    return [("- " + b[2:]) for b in bullets] or None
+
+
+def plain_summary(p: ProjectDay) -> list[str]:
+    lines = [f"- {q.splitlines()[0][:140]}" for _, q in p.prompts[:6]]
+    if len(p.prompts) > 6:
+        lines.append(f"- …and {len(p.prompts) - 6} more prompt(s)")
+    return lines or ["- (no prompts captured)"]
+
+
+# ------------------------------------------------------------------ render
+def _n(v: int) -> str:
+    return f"{v:,}"
+
+
+def _dur(minutes: int) -> str:
+    h, m = divmod(minutes, 60)
+    return f"{h}h {m:02d}m" if h else f"{m}m"
+
+
+def summarize_all(projects: dict[str, ProjectDay], day: date, cfg: Config, use_ai: bool) -> dict[str, dict]:
+    out = {}
+    for key, p in projects.items():
+        bullets = ai_summary(p, day, cfg) if use_ai else None
+        out[key] = {"bullets": bullets or plain_summary(p), "source": "ai" if bullets else "plain"}
+    return out
+
+
+def render(day: date, cfg: Config, accounts: dict, projects: dict[str, ProjectDay], summaries: dict) -> str:
+    devices = sorted({d for a in accounts.values() for d in a["devices"]})
+    total_sessions = sum(a["sessions"] for a in accounts.values())
+    out = [f"# Claude Code work log — {day.isoformat()}", "",
+           f"_Generated {datetime.now().strftime('%Y-%m-%d %H:%M')} on `{cfg.device}` · "
+           f"{total_sessions} session(s) · devices: {', '.join(devices) or '—'}_", ""]
+    if not accounts:
+        out += ["No Claude Code activity recorded for this day.", ""]
+        return "\n".join(out)
+
+    head = "| Account | Sessions | Input | Output | Cache write | Cache read | Total |"
+    out += ["## Token usage by account", "", head, "|---|---:|---:|---:|---:|---:|---:|"]
+    grand = zero_tokens()
+    for name in sorted(accounts):
+        a = accounts[name]
+        t = a["tokens"]
+        _add(grand, t)
+        out.append(f"| {name} | {a['sessions']} | {_n(t['input'])} | {_n(t['output'])} | "
+                   f"{_n(t['cache_creation'])} | {_n(t['cache_read'])} | {_n(sum(t.values()))} |")
+    out.append(f"| **All** | **{total_sessions}** | **{_n(grand['input'])}** | **{_n(grand['output'])}** | "
+               f"**{_n(grand['cache_creation'])}** | **{_n(grand['cache_read'])}** | **{_n(sum(grand.values()))}** |")
+    out += ["", "### By model", "", "| Account | Model | Input | Output | Cache write | Cache read |",
+            "|---|---|---:|---:|---:|---:|"]
+    for name in sorted(accounts):
+        for model, t in sorted(accounts[name]["models"].items()):
+            out.append(f"| {name} | {model} | {_n(t['input'])} | {_n(t['output'])} | "
+                       f"{_n(t['cache_creation'])} | {_n(t['cache_read'])} |")
+    out += ["", "> Token counts are usage as logged by Claude Code, not a bill. "
+            "On Pro/Max plans they count against limits rather than cost money directly.", ""]
+
+    out += ["## What I worked on", ""]
+    ordered = sorted(projects.values(), key=lambda p: (p.kind == "misc", -p.sessions, p.name))
+    for p in ordered:
+        where = f"`{p.remote['host']}/{p.remote['slug']}`" if p.remote else (
+            "folders: " + ", ".join(sorted(p.folders)) if p.folders else "no git repo")
+        out += [f"### {p.name}", "",
+                f"{where} · accounts: {', '.join(sorted(p.accounts))} · devices: {', '.join(sorted(p.devices))} · "
+                f"{p.sessions} session(s) · {_dur(p.minutes)} span · {_n(sum(p.tokens.values()))} tokens · "
+                f"{len(p.files)} file(s) edited · {len(p.commits)} commit(s)", ""]
+        out += summaries.get(p.key, {}).get("bullets") or plain_summary(p)
+        out += [""]
+        if p.commits:
+            out += ["Commits:", ""] + [f"- `{h}` {s}" for h, s in p.commits.items()] + [""]
+    return "\n".join(out)
+
+
+def build_report(cfg: Config, day: date, use_ai: bool, write: bool) -> tuple[str, str | None]:
+    store = GitStore(cfg.store_repo)
+    with store.lock():  # short lock: sync + read only
+        store.pull()
+        records = list(store.iter_json(f"records/{day.isoformat()}"))
+    accounts, projects = aggregate(records)
+    summaries = summarize_all(projects, day, cfg, use_ai)  # AI calls run without the lock
+    text = render(day, cfg, accounts, projects, summaries)
+    if not write:
+        return text, None
+    rel = f"reports/{day.isoformat()}/{cfg.device}.md"
+    meta = {"date": day.isoformat(), "device": cfg.device, "summaries": summaries,
+            "generated_at": datetime.now().astimezone().isoformat(timespec="seconds")}
+    with store.lock():
+        store.pull()
+        store.write_text(rel, text)
+        store.write_json(f"reports/{day.isoformat()}/{cfg.device}.json", meta)
+        store.commit_and_push(f"report {day.isoformat()} ({cfg.device})")
+    return text, str(cfg.store_repo / rel)
+
+
+def load_saved_summaries(store: GitStore, day: date) -> dict:
+    """Newest saved summaries for `day` from any device (used by the web UI)."""
+    best: dict = {}
+    for meta in store.iter_json(f"reports/{day.isoformat()}"):
+        if isinstance(meta, dict) and meta.get("generated_at", "") > best.get("generated_at", ""):
+            best = meta
+    return best

worklog/services.py

@@ -0,0 +1,139 @@
+"""systemd --user units: the web UI (always on) + collect/report timers (replace cron).
+
+Timers use Persistent=true, so a run missed while the laptop was asleep/off happens on wake.
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+UNIT_DIR = Path(os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config") / "systemd" / "user"
+WEB, COLLECT, REPORT = "claude-worklog-web.service", "claude-worklog-collect.timer", "claude-worklog-report.timer"
+# Set by `claude-worklog demo`: the demo must never start, stop or enable the user's real units.
+DEMO_ENV = "CLAUDE_WORKLOG_DEMO"
+
+
+def demo_mode() -> bool:
+    return os.environ.get(DEMO_ENV) == "1"
+
+
+def _q(s: str) -> str:
+    """Quote for a systemd unit file (and escape % specifiers)."""
+    s = s.replace("%", "%%")
+    return f'"{s}"' if any(c in s for c in ' "\\') else s
+
+
+def _units(port: int) -> dict[str, str]:
+    py = _q(sys.executable)  # the pipx venv's python: always has the package
+    # Timers/services don't inherit your shell PATH; freeze it so `claude` and `git` are found.
+    env = f'Environment={_q("PATH=" + os.environ.get("PATH", "/usr/bin:/bin"))}\nEnvironment=PYTHONUNBUFFERED=1'
+    oneshot = "[Service]\nType=oneshot\nNice=10\n" + env + "\n"
+    return {
+        WEB: f"""[Unit]
+Description=claude-worklog web UI (http://worklog.localhost:{port})
+
+[Service]
+Type=simple
+ExecStart={py} -m worklog.cli serve --port {port}
+Restart=on-failure
+RestartSec=5
+NoNewPrivileges=yes
+{env}
+
+[Install]
+WantedBy=default.target
+""",
+        "claude-worklog-collect.service": f"""[Unit]
+Description=claude-worklog: collect Claude Code sessions (backstop for the hook)
+
+{oneshot}ExecStart={py} -m worklog.cli --quiet collect --days 2
+""",
+        COLLECT: """[Unit]
+Description=claude-worklog hourly collect
+
+[Timer]
+OnBootSec=3min
+OnCalendar=hourly
+Persistent=true
+RandomizedDelaySec=120
+
+[Install]
+WantedBy=timers.target
+""",
+        "claude-worklog-report.service": f"""[Unit]
+Description=claude-worklog: build daily report
+
+{oneshot}ExecStart={py} -m worklog.cli --quiet report --auto
+""",
+        REPORT: """[Unit]
+Description=claude-worklog daily report (23:30 today, 00:20 re-run for yesterday)
+
+[Timer]
+OnCalendar=*-*-* 23:30:00
+OnCalendar=*-*-* 00:20:00
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+""",
+    }
+
+
+def _systemctl(*args: str) -> subprocess.CompletedProcess:
+    if demo_mode():
+        raise RuntimeError("systemd is disabled in demo mode")
+    return subprocess.run(["systemctl", "--user", *args], capture_output=True, text=True, timeout=30)
+
+
+def available() -> bool:
+    return not demo_mode() and shutil.which("systemctl") is not None
+
+
+def install(port: int, report: bool, start: bool = True) -> list[str]:
+    UNIT_DIR.mkdir(parents=True, exist_ok=True)
+    msgs = []
+    for name, text in _units(port).items():
+        (UNIT_DIR / name).write_text(text, encoding="utf-8")
+        msgs.append(f"wrote {UNIT_DIR / name}")
+    if not start:
+        return msgs
+    if not available():
+        raise RuntimeError("systemctl not found; this needs a systemd-based system such as Ubuntu")
+    for args in (("daemon-reload",), ("enable", "--now", WEB, COLLECT), ("restart", WEB)):
+        r = _systemctl(*args)
+        if r.returncode != 0:
+            raise RuntimeError(f"systemctl --user {' '.join(args)} failed: {r.stderr.strip()}")
+    msgs.append(set_report_timer(report))
+    return msgs
+
+
+def set_report_timer(enabled: bool) -> str:
+    r = _systemctl("enable" if enabled else "disable", "--now", REPORT)
+    if r.returncode != 0:
+        raise RuntimeError(f"could not {'enable' if enabled else 'disable'} {REPORT}: {r.stderr.strip()}")
+    return f"daily report on this device: {'on' if enabled else 'off'}"
+
+
+def status() -> dict[str, str]:
+    if not available():
+        reason = "disabled in demo mode" if demo_mode() else "systemd not available"
+        return {u: reason for u in (WEB, COLLECT, REPORT)}
+    out = {}
+    for unit in (WEB, COLLECT, REPORT):
+        try:
+            active = _systemctl("is-active", unit).stdout.strip() or "unknown"
+            enabled = _systemctl("is-enabled", unit).stdout.strip() or "unknown"
+        except (OSError, subprocess.TimeoutExpired):
+            active = enabled = "unknown"
+        out[unit] = f"{active}, {enabled}"
+    return out
+
+
+def report_timer_enabled() -> bool:
+    try:
+        return available() and _systemctl("is-enabled", REPORT).stdout.strip() == "enabled"
+    except (OSError, subprocess.TimeoutExpired):
+        return False

worklog/store.py

@@ -0,0 +1,135 @@
+"""Git-backed central store (any host: GitHub, GitLab, Bitbucket, self-hosted).
+
+Layout (every path is device-specific, so devices never conflict):
+    records/<YYYY-MM-DD>/<device>/<account>/<session>.json
+    reports/<YYYY-MM-DD>/<device>.md
+"""
+from __future__ import annotations
+
+import errno
+import fcntl
+import json
+import logging
+import os
+import subprocess
+import time
+from contextlib import contextmanager
+from pathlib import Path
+
+from .config import STATE_DIR, ConfigError
+
+log = logging.getLogger(__name__)
+
+# Commits in the data repo use a neutral identity (no personal e-mail stored).
+_IDENTITY = ["-c", "user.name=claude-worklog", "-c", "user.email=claude-worklog@localhost"]
+
+
+class GitStore:
+    def __init__(self, path: Path):
+        self.path = path
+        if not (path / ".git").exists():
+            raise ConfigError(
+                f"{path} is not a git repo. Create a PRIVATE repo on your git host and clone it there."
+            )
+        env = dict(os.environ)
+        env["GIT_TERMINAL_PROMPT"] = "0"  # never hang waiting for a password (hooks/cron)
+        env.setdefault("GIT_SSH_COMMAND", "ssh -o BatchMode=yes -o ConnectTimeout=15")
+        self._env = env
+
+    # ---------------------------------------------------------------- locking
+    @contextmanager
+    def lock(self, timeout: float = 90.0):
+        """Serialize hook, cron and manual runs on this machine."""
+        STATE_DIR.mkdir(parents=True, exist_ok=True)
+        with open(STATE_DIR / "store.lock", "w") as fh:
+            deadline = time.monotonic() + timeout
+            while True:
+                try:
+                    fcntl.flock(fh, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                    break
+                except OSError as exc:
+                    if exc.errno not in (errno.EAGAIN, errno.EACCES) or time.monotonic() > deadline:
+                        raise TimeoutError("another claude-worklog run holds the lock") from exc
+                    time.sleep(1)
+            try:
+                yield
+            finally:
+                fcntl.flock(fh, fcntl.LOCK_UN)
+
+    # ------------------------------------------------------------------- git
+    def _git(self, *args: str, timeout: int = 60, check: bool = True) -> subprocess.CompletedProcess:
+        return subprocess.run(
+            ["git", "-C", str(self.path), *args],
+            capture_output=True, text=True, timeout=timeout, check=check, env=self._env,
+        )
+
+    def _has_remote(self) -> bool:
+        return bool(self._git("remote", check=False).stdout.strip())
+
+    def pull(self) -> None:
+        if not self._has_remote():
+            return
+        try:
+            self._git("pull", "--rebase", "--autostash", timeout=90)
+        except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as exc:
+            # Offline, empty repo, or first run: work locally, sync next time.
+            detail = getattr(exc, "stderr", "") or str(exc)
+            log.warning("git pull failed (continuing locally): %s", detail.strip()[:300])
+            if (self.path / ".git" / "rebase-merge").exists() or (self.path / ".git" / "rebase-apply").exists():
+                self._git("rebase", "--abort", check=False)
+
+    def commit_and_push(self, message: str) -> None:
+        dirs = [d for d in ("records", "reports") if (self.path / d).exists()]
+        if not dirs:
+            return
+        self._git("add", "-A", "--", *dirs)
+        if self._git("diff", "--cached", "--quiet", check=False).returncode == 0:
+            return  # nothing staged
+        self._git(*_IDENTITY, "commit", "-q", "-m", message)
+        if not self._has_remote():
+            log.info("committed locally (no remote configured)")
+            return
+        try:
+            self._git("push", "-q", "-u", "origin", "HEAD", timeout=90)
+        except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as exc:
+            detail = getattr(exc, "stderr", "") or str(exc)
+            log.warning("git push failed; commit kept locally and retried next run: %s", detail.strip()[:300])
+
+    # ----------------------------------------------------------------- files
+    def _target(self, rel: str) -> Path:
+        target = (self.path / rel).resolve()
+        if self.path.resolve() not in target.parents:
+            raise ValueError(f"refusing to write outside store: {rel}")
+        return target
+
+    def write_text(self, rel: str, text: str) -> bool:
+        """Atomically write; returns False if content is unchanged."""
+        target = self._target(rel)
+        if target.exists() and target.read_text(encoding="utf-8") == text:
+            return False
+        target.parent.mkdir(parents=True, exist_ok=True)
+        tmp = target.with_suffix(target.suffix + ".tmp")
+        tmp.write_text(text, encoding="utf-8")
+        os.replace(tmp, target)
+        return True
+
+    def move(self, src_rel: str, dst_rel: str) -> None:
+        """Rename a file inside the store (commit_and_push stages it as a rename)."""
+        src, dst = self._target(src_rel), self._target(dst_rel)
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        os.replace(src, dst)
+        try:
+            src.parent.rmdir()  # drop the now-empty account folder, if it is empty
+        except OSError:
+            pass
+
+    def write_json(self, rel: str, data: dict) -> bool:
+        return self.write_text(rel, json.dumps(data, indent=2, sort_keys=True, ensure_ascii=False) + "\n")
+
+    def iter_json(self, rel_dir: str):
+        base = self.path / rel_dir
+        for p in sorted(base.rglob("*.json")) if base.exists() else []:
+            try:
+                yield json.loads(p.read_text(encoding="utf-8"))
+            except (OSError, json.JSONDecodeError) as exc:
+                log.warning("skipping unreadable record %s: %s", p, exc)