worklog-for-claude-code 0.3.0__tar.gz → 0.3.1__tar.gz

{worklog_for_claude_code-0.3.0/worklog_for_claude_code.egg-info → worklog_for_claude_code-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: worklog-for-claude-code
-Version: 0.3.0
+Version: 0.3.1
 Summary: See what you did with Claude Code each day and how many tokens it used: an automatic daily work log across accounts and devices, private by default
 Author: Urvin
 License-Expression: MIT
@@ -33,7 +33,7 @@ Provides-Extra: test
 Requires-Dist: pytest>=7; extra == "test"
 Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == "dev"
-Requires-Dist: ruff==0.17.0; extra == "dev"
+Requires-Dist: ruff==0.17.3; extra == "dev"
 Requires-Dist: build; extra == "dev"
 Dynamic: license-file
 

{worklog_for_claude_code-0.3.0 → worklog_for_claude_code-0.3.1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 # Distribution name on PyPI. The command stays `claude-worklog` and the package stays `worklog`.
 name = "worklog-for-claude-code"
-version = "0.3.0"
+version = "0.3.1"
 description = "See what you did with Claude Code each day and how many tokens it used: an automatic daily work log across accounts and devices, private by default"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -35,7 +35,7 @@ dependencies = ['tomli>=2.0; python_version < "3.11"']
 
 [project.optional-dependencies]
 test = ["pytest>=7"]
-dev = ["pytest>=7", "ruff==0.17.0", "build"]
+dev = ["pytest>=7", "ruff==0.17.3", "build"]
 
 [project.urls]
 Homepage = "https://github.com/us-urvin/worklog-for-claude-code"

{worklog_for_claude_code-0.3.0 → worklog_for_claude_code-0.3.1}/tests/test_chats.py

@@ -13,7 +13,7 @@ from pathlib import Path
 
 import pytest
 
-from worklog import chats, cli, identity, store, web
+from worklog import chats, cli, identity, store, syncstatus, web
 from worklog.config import ConfigError, dump_config, load_config
 from worklog.report import aggregate, render
 
@@ -73,7 +73,7 @@ def home(tmp_path, monkeypatch):
                      ("APPDATA", "AppData/Roaming"), ("LOCALAPPDATA", "AppData/Local")):
         monkeypatch.setenv(var, str(h / sub) if sub else str(h))
     state = h / ".local/state/claude-worklog"
-    for mod in (identity, store, cli, chats):
+    for mod in (identity, store, cli, chats, syncstatus):
         monkeypatch.setattr(mod, "STATE_DIR", state)
     assert Path.home() == h
     return h

worklog_for_claude_code-0.3.1/tests/test_forget.py

@@ -0,0 +1,170 @@
+"""Forget a login: deletes exactly its Worklog history on this device, after a confirmation."""
+import json
+from datetime import datetime, timedelta
+
+import pytest
+from test_accounts import EMAIL_A, EMAIL_B, UID_A, UID_B, login, make_cfg, records, start_session, transcript
+
+from worklog import collector, forget, identity, watcher, web
+from worklog.config import load_config, save_config
+
+UID_C, EMAIL_C = "33333333-cccc-4ccc-8ccc-333333333333", "stranger@viitor.example"
+
+
+@pytest.fixture
+def isolated(home, monkeypatch):
+    wpath = home / ".local/state/claude-worklog/watch.json"
+    monkeypatch.setattr(watcher, "state_path", lambda: wpath)
+    monkeypatch.setattr(collector, "watch_state", lambda: watcher.load_state(wpath))
+    return home
+
+
+def setup_user_case(home, repo):
+    """Like the reported setup: three logins in ~/.claude, two named, one ("stranger") without a name."""
+    cfg = make_cfg(home, repo, f'[[accounts]]\nname = "laracopilot"\nconfig_dir = "~/.claude"\n'
+                               f'match_account_id = "{UID_B}"\n')
+    cfg.accounts[0] = cfg.accounts[0].__class__("personal", cfg.accounts[0].config_dir, match_account_id=UID_A)
+    cfg.accounts.reverse()  # laracopilot first: it is the folder default for logins without a name
+    save_config(cfg, cfg.path)
+    cfg = load_config(cfg.path)
+    now = datetime.now().astimezone().replace(microsecond=0)
+    for uid, email, sid, days_ago in ((UID_A, EMAIL_A, "s-personal", 0), (UID_B, EMAIL_B, "s-lara", 0),
+                                      (UID_C, EMAIL_C, "s-stranger-old", 6), (UID_C, EMAIL_C, "s-stranger", 0)):
+        login(home, uid, email)
+        start_session(home, sid)
+        transcript(home, sid, now - timedelta(days=days_ago), home)
+    collector.collect(cfg, [now.date() - timedelta(days=6), now.date()])
+    return cfg, now
+
+
+def paths(repo):
+    return sorted(records(repo))
+
+
+def test_forget_an_unnamed_login_deletes_only_its_sessions(isolated, repo):
+    cfg, now = setup_user_case(isolated, repo)
+    before = paths(repo)
+    assert len(before) == 4 and sum("s-stranger" in p for p in before) == 2
+    p = forget.plan(cfg, identity.ref(UID_C))
+    assert p.sessions == {"s-stranger", "s-stranger-old"} and len(p.files) == 2 and len(p.days) == 2
+    assert p.account is None  # it was never named: no account goes away
+
+    msg = forget.apply(load_config(cfg.path), p)
+    assert "deleted 2 session record(s) from 2 day(s)" in msg
+    after = paths(repo)
+    assert not any("s-stranger" in x for x in after) and len(after) == 2
+    assert {x.split("/")[3] for x in after} == {"personal", "laracopilot"}
+    assert UID_C not in {x["account_id"] for x in identity.detected_logins()}
+
+    # a later sync never writes the forgotten sessions again
+    collector.collect(load_config(cfg.path), [now.date() - timedelta(days=6), now.date()])
+    assert not any("s-stranger" in x for x in paths(repo))
+
+
+def test_forget_a_named_login_removes_its_account_and_rehomes_the_rest(isolated, repo):
+    cfg, now = setup_user_case(isolated, repo)
+    cfg.summarizer_account = "laracopilot"
+    save_config(cfg, cfg.path)
+    p = forget.plan(load_config(cfg.path), identity.ref(UID_B))
+    assert p.account == "laracopilot" and p.sessions == {"s-lara"}
+    msg = forget.apply(load_config(cfg.path), p)
+    new = load_config(cfg.path)
+    assert new.account("laracopilot") is None and new.summarizer_account == "personal"
+    assert "removed account laracopilot" in msg and "moved 2 other record(s)" in msg
+    after = paths(repo)
+    assert not any("s-lara" in x for x in after)
+    # the stranger's sessions had fallen back to laracopilot: now with the folder's new default, not orphaned
+    assert all("/laracopilot/" not in x for x in after)
+    assert sum("/personal/s-stranger" in x for x in after) == 2
+    assert records(repo)[next(x for x in after if "s-stranger" in x)]["account"] == "personal"
+
+
+def test_forget_the_only_account_keeps_it_but_unlinks(isolated, repo):
+    cfg = make_cfg(isolated, repo, "")
+    cfg.accounts[0] = cfg.accounts[0].__class__("solo", cfg.accounts[0].config_dir, match_account_id=UID_A)
+    cfg.summarizer_account = "solo"
+    save_config(cfg, cfg.path)
+    cfg = load_config(cfg.path)
+    login(isolated, UID_A, EMAIL_A)
+    start_session(isolated, "s1")
+    transcript(isolated, "s1", datetime.now().astimezone(), isolated)
+    collector.collect(cfg, [datetime.now().date()])
+    p = forget.plan(cfg, identity.ref(UID_A))
+    assert p.keep_account
+    forget.apply(cfg, p)
+    new = load_config(cfg.path)
+    assert [a.name for a in new.accounts] == ["solo"] and new.accounts[0].match_account_id is None
+    assert paths(repo) == []
+
+
+def test_forget_finds_sessions_the_watcher_matched(isolated, repo):
+    cfg = make_cfg(isolated, repo,
+                   f'[[accounts]]\nname = "work"\nconfig_dir = "~/.claude"\nmatch_account_id = "{UID_B}"\n')
+    now = datetime.now().astimezone().replace(microsecond=0)
+    w = watcher.Watcher(watcher.state_path())
+    t = now - timedelta(minutes=20)
+    login(isolated, UID_B, EMAIL_B)  # switched by some tool; no hook anywhere
+    while t <= now:
+        w._last_discover = float("inf")
+        w.step(now=t)
+        t += timedelta(seconds=30)
+    transcript(isolated, "s-w", now - timedelta(minutes=10), isolated)
+    collector.collect(cfg, [now.date()])
+    rec = records(repo)[f"records/{now.date().isoformat()}/dev1/work/s-w.json"]
+    assert rec["account_source"] == "watcher"
+    p = forget.plan(cfg, identity.ref(UID_B))
+    assert p.sessions == {"s-w"} and p.account == "work"
+
+
+def test_forget_drops_the_saved_summaries_of_those_projects(isolated, repo):
+    cfg, now = setup_user_case(isolated, repo)
+    d = now.date().isoformat()
+    rep = repo / "reports" / d
+    rep.mkdir(parents=True)
+    (rep / "dev1.json").write_text(json.dumps({"summaries": {"misc:R&D / misc": {"bullets": ["- secret work"]},
+                                                             "other": {"bullets": ["- keep me"]}}}))
+    (rep / "dev1.md").write_text("- secret work\n")
+    forget.apply(load_config(cfg.path), forget.plan(cfg, identity.ref(UID_C)))
+    meta = json.loads((rep / "dev1.json").read_text())
+    assert "misc:R&D / misc" not in meta["summaries"] and "other" in meta["summaries"]
+    assert not (rep / "dev1.md").exists()
+
+
+def test_the_same_account_logging_in_again_is_tracked_again(isolated, repo):
+    cfg, now = setup_user_case(isolated, repo)
+    forget.apply(load_config(cfg.path), forget.plan(cfg, identity.ref(UID_C)))
+    login(isolated, UID_C, EMAIL_C)
+    start_session(isolated, "s-stranger-new")
+    transcript(isolated, "s-stranger-new", now, isolated)
+    collector.collect(load_config(cfg.path), [now.date()])
+    assert any("s-stranger-new" in x for x in paths(repo))
+    assert UID_C in {x["account_id"] for x in identity.detected_logins()}
+
+
+def test_ui_asks_first_and_explains_what_is_lost(isolated, repo, monkeypatch):
+    cfg, _ = setup_user_case(isolated, repo)
+    monkeypatch.setattr(web, "_try_config", lambda: load_config(cfg.path))
+    app = web.App(8765)
+    ref = identity.ref(UID_C)
+    settings = web.page_settings(app, cfg)
+    assert f'href="/settings?forget={ref}#forget"' in settings and "Forget…" in settings
+
+    card = web.page_settings(app, cfg, ref)
+    assert "Forget s***@viitor.example?" in card and "2 Claude Code session records" in card
+    assert "can&#39;t be undone" in card and "Claude Code&#39;s own files" in card and 'required' in card
+    assert EMAIL_C not in card and UID_C not in card  # masked, as everywhere
+
+    n = len(paths(repo))
+    loc, err, _ = app.post("/accounts/forget", {"ref": ref})  # the box isn't ticked: nothing happens
+    assert err and len(paths(repo)) == n
+    loc, err, _ = app.post("/accounts/forget", {"ref": "000000000000", "confirm": "1"})
+    assert err and len(paths(repo)) == n
+    loc, err, _ = app.post("/accounts/forget", {"ref": ref, "confirm": "1"})
+    assert err is None and loc.startswith("/settings?ok=job")
+    import time
+    for _ in range(200):
+        if not app.jobs.snapshot()["running"]:
+            break
+        time.sleep(0.02)
+    assert app.jobs.snapshot()["ok"], app.jobs.snapshot()["message"]
+    assert not any("s-stranger" in x for x in paths(repo))

worklog_for_claude_code-0.3.1/tests/test_syncstatus.py

@@ -0,0 +1,116 @@
+"""Settings → Private data repo: connected or not, which repo, private or public, and whether syncing works."""
+import io
+import json
+import subprocess
+from urllib.error import HTTPError
+
+import pytest
+from test_accounts import make_cfg
+
+from worklog import syncstatus, web
+from worklog.store import GitStore
+
+
+def git(repo, *args):
+    subprocess.run(["git", "-C", str(repo), *args], check=True, capture_output=True)
+
+
+def section(cfg):
+    return web.data_repo_section(web.App(1), cfg)
+
+
+@pytest.fixture
+def no_network(monkeypatch):
+    def fail(*a, **k):
+        raise AssertionError("no network expected here")
+    monkeypatch.setattr(syncstatus, "urlopen", fail)
+
+
+def test_not_a_git_folder_says_not_set_up(home, repo, no_network):
+    cfg = make_cfg(home, repo)
+    cfg.store_repo = home / "nowhere"
+    html = section(cfg)
+    assert "Not set up" in html and "git init" in html
+
+
+def test_local_only_explains_how_to_connect(home, repo, no_network):
+    html = section(make_cfg(home, repo))
+    assert "Local only" in html and "Not connected" in html and "remote add origin" in html and "Copy" in html
+
+
+def test_connected_shows_which_repo_and_never_the_credentials(home, repo, monkeypatch):
+    git(repo, "remote", "add", "origin", "https://me:ghp_SECRET123@github.com/me/claude-worklog-data.git")
+    monkeypatch.setattr(syncstatus, "urlopen", lambda *a, **k: (_ for _ in ()).throw(
+        HTTPError("u", 404, "Not Found", {}, io.BytesIO(b""))))
+    syncstatus.visibility("github.com", "me/claude-worklog-data")  # what the background check does
+    html = section(make_cfg(home, repo))
+    assert "Connected" in html and "github.com/me/claude-worklog-data" in html
+    assert 'href="https://github.com/me/claude-worklog-data"' in html
+    assert "SECRET" not in html and "ghp_" not in html and "me:" not in html
+    assert "🔒 Private" in html and "Not uploaded yet" in html
+
+
+def test_public_repo_is_flagged_everywhere(home, repo, monkeypatch):
+    git(repo, "remote", "add", "origin", "git@github.com:me/claude-worklog-data.git")
+    monkeypatch.setattr(syncstatus, "urlopen", lambda *a, **k: io.BytesIO(json.dumps({"private": False}).encode()))
+    assert syncstatus.visibility("github.com", "me/claude-worklog-data") == "public"
+    cfg = make_cfg(home, repo)
+    assert "PUBLIC" in section(cfg) and "Change visibility" in section(cfg)
+    assert "is public" in web._public_repo_warning(cfg)  # the warning on every page
+
+
+def test_visibility_is_cached_and_only_asked_for_github(home, monkeypatch):
+    calls = []
+
+    def fake(req, timeout):
+        calls.append(req.full_url)
+        return io.BytesIO(b'{"private": true}')
+    monkeypatch.setattr(syncstatus, "urlopen", fake)
+    assert syncstatus.visibility("github.com", "me/r") == "private"
+    assert syncstatus.visibility("github.com", "me/r") == "private" and len(calls) == 1  # cached
+    assert syncstatus.visibility("gitlab.com", "me/r") == "unknown" and len(calls) == 1  # never asks other hosts
+    assert calls == ["https://api.github.com/repos/me/r"]
+    monkeypatch.setattr(syncstatus, "urlopen", lambda *a, **k: (_ for _ in ()).throw(OSError("offline")))
+    assert syncstatus.visibility("github.com", "me/other") == "unknown"
+
+
+def test_store_records_uploads_and_failures(home, repo, tmp_path, no_network):
+    bare = tmp_path / "remote.git"
+    subprocess.run(["git", "init", "-q", "--bare", str(bare)], check=True)
+    git(repo, "remote", "add", "origin", str(bare))
+    store = GitStore(repo)
+    store.write_json("records/2026-11-01/dev/personal/a.json", {"a": 1})
+    store.commit_and_push("test")
+    assert syncstatus.last("push")["ok"] is True
+    git(repo, "remote", "set-url", "origin", str(tmp_path / "missing.git"))
+    store.write_json("records/2026-11-01/dev/personal/b.json", {"b": 1})
+    store.commit_and_push("test 2")
+    failed = syncstatus.last("push")
+    assert failed["ok"] is False and failed["error"]
+
+
+def test_failed_upload_and_waiting_changes_are_shown(home, repo, no_network):
+    git(repo, "remote", "add", "origin", "git@gitlab.com:me/data.git")
+    GitStore(repo).write_json("records/2026-11-01/dev/personal/a.json", {"a": 1})
+    git(repo, "add", "-A")
+    subprocess.run(["git", "-C", str(repo), "-c", "user.name=t", "-c", "user.email=t@t", "commit", "-qm", "x"],
+                   check=True)
+    syncstatus.record("push", False, "fatal: Could not read from remote repository.")
+    html = section(make_cfg(home, repo))
+    assert "Last upload failed" in html and "Could not read from remote repository" in html
+    assert "1 change waiting to upload" in html
+    assert "Privacy not checked" in html  # not GitHub: no request is made
+    syncstatus.record("push", True)
+    assert "Synced" in section(make_cfg(home, repo))
+
+
+def test_test_connection_works_and_explains_failures(home, repo, tmp_path):
+    bare = tmp_path / "remote.git"
+    subprocess.run(["git", "init", "-q", "--bare", str(bare)], check=True)
+    git(repo, "remote", "add", "origin", str(bare))
+    cfg = make_cfg(home, repo)
+    ok, msg = syncstatus.test_connection(cfg)
+    assert ok and "Connection works" in msg
+    git(repo, "remote", "set-url", "origin", str(tmp_path / "missing.git"))
+    ok, msg = syncstatus.test_connection(cfg)
+    assert not ok and msg.startswith("Can't reach your data repo")

{worklog_for_claude_code-0.3.0 → worklog_for_claude_code-0.3.1}/worklog/__init__.py

@@ -1,3 +1,3 @@
 """claude-worklog: daily work log + token report for Claude Code."""
 
-__version__ = "0.3.0"
+__version__ = "0.3.1"

{worklog_for_claude_code-0.3.0 → worklog_for_claude_code-0.3.1}/worklog/collector.py

@@ -9,7 +9,7 @@ from pathlib import Path
 from urllib.parse import urlsplit
 
 from .config import SUMMARIZER_CWD, Account, Config, home_relative
-from .identity import Identity, load_state, session_logins
+from .identity import Identity, forgotten_sessions, load_state, session_logins
 from .parser import ParseStats, SessionDay, parse_transcript
 from .redact import redact
 from .store import GitStore
@@ -181,6 +181,7 @@ def collect(cfg: Config, days: list[date]) -> int:
     store = GitStore(cfg.store_repo)
     logins: dict[str, Identity] = session_logins()  # local state written by the SessionStart hook
     watched = watch_state()  # login timeline kept by the watcher (covers sessions without a hook record)
+    forgotten = forgotten_sessions()  # deleted by "Forget this login": never written again
     written = 0
     with store.lock():
         store.pull()
@@ -198,6 +199,8 @@ def collect(cfg: Config, days: list[date]) -> int:
                     except OSError as exc:
                         log.warning("cannot read %s: %s", path, exc)
                 for sd in sessions.values():
+                    if sd.session_id in forgotten:
+                        continue
                     login = logins.get(sd.session_id)
                     source = "hook"
                     if login is None:

worklog_for_claude_code-0.3.1/worklog/forget.py

@@ -0,0 +1,211 @@
+"""Forget a login: delete Worklog's records of its Claude Code sessions on this device.
+
+Two steps, so the UI can show exactly what will be lost before anything happens:
+
+* `plan(cfg, ref)` works out which sessions belong to the login (recorded by the hook, or
+  matched by the account watcher), which record files and days that touches, and which
+  account goes away with it. It changes nothing.
+* `apply(cfg, plan)` deletes those records and the saved summaries of the projects involved,
+  removes the account linked only to that login, forgets the login, and remembers the
+  sessions so a later sync never writes them again.
+
+Claude Code's own files are never touched. Records synced from other devices aren't removed
+(this device can't tell which of their sessions belong to the login), and the old versions
+stay in the data repo's git history.
+"""
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass, field, replace
+from datetime import date, datetime
+from pathlib import Path
+
+from .config import Config, home_relative, save_config
+from .identity import _lock, _save_state, detected_logins, load_state, mask_email, state_path
+from .store import GitStore
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class Plan:
+    ref: str
+    account_id: str
+    email: str | None
+    dirs: list[Path]
+    sessions: set[str] = field(default_factory=set)  # session ids that belong to this login
+    files: list[str] = field(default_factory=list)  # record paths in the data repo (this device)
+    days: set[date] = field(default_factory=set)
+    projects: dict[date, set[str]] = field(default_factory=dict)  # project keys touched, per day
+    account: str | None = None  # the account linked only to this login, removed with it
+    keep_account: bool = False  # it's the last account: keep it, just unlink the login
+
+    @property
+    def label(self) -> str:
+        return mask_email(self.email)
+
+
+def _linked_account(cfg: Config, account_id: str, email: str | None):
+    for a in cfg.accounts:
+        if a.match_account_id == account_id:
+            return a
+        if a.match_email and email and a.match_email.casefold() == email.casefold():
+            return a
+    return None
+
+
+def plan(cfg: Config, ref_: str) -> Plan | None:
+    """What forgetting this login would delete. None if the login isn't known on this device."""
+    from . import watcher
+    from .collector import _SAFE
+    from .report import project_key
+
+    login = next((x for x in detected_logins() if x["ref"] == ref_), None)
+    if login is None:
+        return None
+    uid = login["account_id"]
+    p = Plan(ref_, uid, login["email"], login["dirs"])
+
+    # 1. Sessions the hook saw starting (or ending) under this login.
+    for sid, entry in load_state()["sessions"].items():
+        if entry.get("id") == uid or (entry.get("id") is None and entry.get("end_id") == uid):
+            p.sessions.add(sid)
+
+    # 2. Records on this device: hook sessions by id, watcher-matched ones by the login timeline.
+    watched = watcher.load_state()
+    folders = {a.name: a.config_dir for a in cfg.accounts}
+    base = cfg.store_repo / "records"
+    safe_ids = {_SAFE.sub("_", s): s for s in p.sessions}
+    for f in sorted(base.glob(f"*/{cfg.device}/*/*.json")) if base.is_dir() else []:
+        try:
+            rec = json.loads(f.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            continue
+        if rec.get("source") == "claude.ai":
+            continue  # imported chats belong to a claude.ai login, not to a Claude Code one
+        sid = str(rec.get("session_id") or "")
+        mine = f.stem in safe_ids or sid in p.sessions
+        if not mine and rec.get("account_source") == "watcher":
+            folder = folders.get(str(rec.get("account")))
+            try:
+                start = datetime.fromisoformat(str(rec.get("start")))
+            except ValueError:
+                start = None
+            if folder is not None and start is not None and folder in p.dirs:
+                m = watcher.login_at(watched, folder, start)
+                mine = m.status == "match" and m.account_id == uid
+        if not mine:
+            continue
+        p.sessions.add(sid)
+        rel = f.relative_to(cfg.store_repo).as_posix()
+        p.files.append(rel)
+        try:
+            d = date.fromisoformat(f.parts[-4])
+        except ValueError:
+            continue
+        p.days.add(d)
+        p.projects.setdefault(d, set()).add(project_key(rec.get("project") or {}))
+
+    linked = _linked_account(cfg, uid, login["email"])
+    if linked is not None:
+        p.account = linked.name
+        p.keep_account = len(cfg.accounts) == 1
+    return p
+
+
+def apply(cfg: Config, p: Plan, now: datetime | None = None) -> str:
+    """Do it. Returns a message for the UI."""
+    from . import watcher
+    now = now or datetime.now().astimezone()
+    stamp = now.isoformat(timespec="seconds")
+    store = GitStore(cfg.store_repo)
+    with store.lock():
+        store.pull()
+        # 1. The account linked only to this login. Its remaining records (other logins that fell back
+        #    to it as the folder default) move to the folder's new default, so nothing is left orphaned.
+        moved = 0
+        if p.account and not p.keep_account:
+            gone = cfg.account(p.account)
+            cfg.accounts = [a for a in cfg.accounts if a.name != p.account]
+            if cfg.summarizer_account == p.account:
+                cfg.summarizer_account = cfg.accounts[0].name
+            if cfg.chat_account == p.account:
+                cfg.chat_account = None
+            save_config(cfg, cfg.path)
+            doomed = set(p.files)
+            for f in sorted((cfg.store_repo / "records").glob(f"*/{cfg.device}/{p.account}/*.json")):
+                rel = f.relative_to(cfg.store_repo).as_posix()
+                if rel in doomed:
+                    continue
+                try:
+                    rec = json.loads(f.read_text(encoding="utf-8"))
+                except (OSError, ValueError):
+                    continue
+                folder = gone.config_dir if gone else None
+                new = (cfg.default_account(folder) if folder in cfg.accounts_by_dir() else cfg.accounts[0]).name
+                rec["account"] = new
+                store.write_json(f"records/{f.parts[-4]}/{cfg.device}/{new}/{f.name}", rec)
+                f.unlink()
+                moved += 1
+        elif p.account and p.keep_account:
+            cfg.accounts = [replace(a, match_account_id=None, match_email=None) if a.name == p.account else a
+                            for a in cfg.accounts]
+            save_config(cfg, cfg.path)
+
+        # 2. The session records themselves.
+        deleted = 0
+        for rel in p.files:
+            f = cfg.store_repo / rel
+            if f.exists():
+                f.unlink()
+                deleted += 1
+                try:
+                    f.parent.rmdir()  # drop the account folder if it is now empty
+                except OSError:
+                    pass
+
+        # 3. Saved summaries of the projects those sessions were in: written again on demand.
+        for d, keys in p.projects.items():
+            meta_file = cfg.store_repo / "reports" / d.isoformat() / f"{cfg.device}.json"
+            try:
+                meta = json.loads(meta_file.read_text(encoding="utf-8"))
+            except (OSError, ValueError):
+                continue
+            summaries = meta.get("summaries") or {}
+            for k in keys:
+                summaries.pop(k, None)
+            meta["summaries"] = summaries
+            store.write_json(meta_file.relative_to(cfg.store_repo).as_posix(), meta)
+            md = cfg.store_repo / "reports" / d.isoformat() / f"{cfg.device}.md"
+            if md.exists():
+                md.unlink()  # the Markdown report mentions them too; it is rebuilt with the next summaries
+
+        store.commit_and_push(f"forget a login on {cfg.device}: {deleted} session record(s)")
+
+    # 4. Forget the login, remember its sessions as forgotten, and blank it out of the watcher's timeline.
+    path = state_path()
+    with _lock(path, 5.0):
+        state = load_state(path)
+        state["logins"].pop(p.account_id, None)
+        state["sessions"] = {k: v for k, v in state["sessions"].items()
+                             if v.get("id") != p.account_id and v.get("end_id") != p.account_id}
+        for sid in p.sessions:
+            state["forgotten"][sid] = stamp
+        _save_state(state, path)
+    with _lock(watcher.state_path(), 5.0):
+        ws = watcher.load_state()
+        for entries in ws["timeline"].values():
+            for e in entries:
+                if e.get("id") == p.account_id:
+                    e["id"] = None
+        ws["dismissed"] = [k for k in ws["dismissed"] if p.ref not in k]
+        _save_state(ws, watcher.state_path())
+
+    where = ", ".join(home_relative(d) for d in p.dirs) or "this device"
+    parts = [f"Forgot {p.label} ({where}): deleted {deleted} session record(s) from {len(p.days)} day(s)"]
+    if p.account and not p.keep_account:
+        parts.append(f"removed account {p.account}" + (f", moved {moved} other record(s) to the folder default"
+                                                       if moved else ""))
+    log.info("forgot login %s: %d records", p.ref, deleted)
+    return "; ".join(parts) + "."

{worklog_for_claude_code-0.3.0 → worklog_for_claude_code-0.3.1}/worklog/identity.py

@@ -104,7 +104,8 @@ def state_path() -> Path:
 
 
 def _empty() -> dict:
-    return {"version": STATE_VERSION, "sessions": {}, "logins": {}}
+    # forgotten: session id -> when it was forgotten. The collector never writes those sessions again.
+    return {"version": STATE_VERSION, "sessions": {}, "logins": {}, "forgotten": {}}
 
 
 def load_state(path: Path | None = None) -> dict:
@@ -123,6 +124,8 @@ def load_state(path: Path | None = None) -> dict:
     for key in ("sessions", "logins"):
         if isinstance(data.get(key), dict):
             state[key] = {k: v for k, v in data[key].items() if isinstance(k, str) and isinstance(v, dict)}
+    if isinstance(data.get("forgotten"), dict):
+        state["forgotten"] = {k: v for k, v in data["forgotten"].items() if isinstance(k, str) and isinstance(v, str)}
     return state
 
 
@@ -146,6 +149,7 @@ def _lock(path: Path, timeout: float):
 def _prune(state: dict, now: datetime) -> None:
     cutoff = (now - timedelta(days=KEEP_DAYS)).isoformat()
     state["sessions"] = {k: v for k, v in state["sessions"].items() if str(v.get("at", "")) >= cutoff}
+    state["forgotten"] = {k: v for k, v in state["forgotten"].items() if v >= cutoff}
 
 
 def record_session(session_id: str, config_dir: Path, ident: Identity | None, event: str,
@@ -212,6 +216,11 @@ def session_logins(path: Path | None = None) -> dict[str, Identity]:
     return out
 
 
+def forgotten_sessions(path: Path | None = None) -> set[str]:
+    """Sessions the user asked Worklog to forget: never collected again."""
+    return set(load_state(path)["forgotten"])
+
+
 def detected_logins(path: Path | None = None) -> list[dict]:
     """Accounts seen logged in, newest first: {ref, account_id, email, dirs, last_seen}."""
     rows = []

{worklog_for_claude_code-0.3.0 → worklog_for_claude_code-0.3.1}/worklog/store.py

@@ -14,6 +14,7 @@ import time
 from contextlib import contextmanager
 from pathlib import Path
 
+from . import syncstatus
 from .config import STATE_DIR, ConfigError
 from .locks import exclusive
 
@@ -61,10 +62,12 @@ class GitStore:
             return
         try:
             self._git("pull", "--rebase", "--autostash", timeout=90)
+            syncstatus.record("pull", True)
         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])
+            syncstatus.record("pull", False, detail)
             if (self.path / ".git" / "rebase-merge").exists() or (self.path / ".git" / "rebase-apply").exists():
                 self._git("rebase", "--abort", check=False)
 
@@ -85,9 +88,11 @@ class GitStore:
             return
         try:
             self._git("push", "-q", "-u", "origin", "HEAD", timeout=90)
+            syncstatus.record("push", True)
         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])
+            syncstatus.record("push", False, detail)
 
     # ----------------------------------------------------------------- files
     def _target(self, rel: str) -> Path:

worklog_for_claude_code-0.3.1/worklog/syncstatus.py

@@ -0,0 +1,148 @@
+"""Is the data repo connected to a remote, which one, is it private, and does syncing work?
+
+* The store records the result of every pull and push here (`record`), so Settings can say
+  "last upload 5 min ago" or show the last error.
+* For GitHub remotes, `visibility` asks GitHub's public API whether the repo can be seen
+  without logging in: a 404 means private (good), "private": false means anyone can read it.
+  Only the repo's name is sent, to the host that stores it anyway; the answer is kept 6 hours.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import time
+from pathlib import Path
+from urllib.error import HTTPError
+from urllib.request import Request, urlopen
+
+from .config import STATE_DIR, Config
+
+VISIBILITY_TTL = 6 * 3600
+
+
+def _path() -> Path:
+    return STATE_DIR / "sync.json"
+
+
+def _load() -> dict:
+    try:
+        data = json.loads(_path().read_text(encoding="utf-8"))
+        return data if isinstance(data, dict) else {}
+    except (OSError, ValueError):
+        return {}
+
+
+def _save(data: dict) -> None:
+    try:
+        _path().parent.mkdir(parents=True, exist_ok=True)
+        _path().write_text(json.dumps(data), encoding="utf-8")
+    except OSError:
+        pass  # status bookkeeping must never break a sync
+
+
+def record(kind: str, ok: bool, error: str = "") -> None:
+    """Remember the outcome of a "pull" or "push" (called by the store)."""
+    data = _load()
+    data[kind] = {"at": time.time(), "ok": ok, "error": error.strip()[:300]}
+    _save(data)
+
+
+def last(kind: str) -> dict | None:
+    v = _load().get(kind)
+    return v if isinstance(v, dict) else None
+
+
+def _git(repo: Path, *args: str, timeout: int = 10) -> tuple[int, str, str]:
+    env = dict(os.environ, GIT_TERMINAL_PROMPT="0")
+    env.setdefault("GIT_SSH_COMMAND", "ssh -o BatchMode=yes -o ConnectTimeout=15")
+    try:
+        r = subprocess.run(["git", "-C", str(repo), *args], capture_output=True, text=True, encoding="utf-8",
+                           errors="replace", timeout=timeout, env=env)
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return 1, "", str(exc)
+    return r.returncode, r.stdout.strip(), r.stderr.strip()
+
+
+def remote(cfg: Config) -> dict | None:
+    """{"host", "slug"} of the data repo's origin (credentials dropped), or None. One local git call."""
+    from .collector import sanitize_remote
+    if not (cfg.store_repo / ".git").exists():
+        return None
+    _, url, _ = _git(cfg.store_repo, "remote", "get-url", "origin")
+    return sanitize_remote(url) if url else None
+
+
+def status(cfg: Config) -> dict:
+    """Everything Settings shows about the data repo. Runs only local git commands."""
+    from .collector import sanitize_remote
+    repo = cfg.store_repo
+    out: dict = {"is_repo": (repo / ".git").exists(), "remote": None, "web_url": None, "branch": "",
+                 "last_change": "", "waiting": 0, "push": last("push"), "pull": last("pull")}
+    if not out["is_repo"]:
+        return out
+    _, url, _ = _git(repo, "remote", "get-url", "origin")
+    r = sanitize_remote(url) if url else None
+    if r:
+        out["remote"] = f"{r['host']}/{r['slug']}"
+        out["host"], out["slug"] = r["host"], r["slug"]
+        out["web_url"] = f"https://{r['host']}/{r['slug']}"
+    _, out["branch"], _ = _git(repo, "rev-parse", "--abbrev-ref", "HEAD")
+    _, out["last_change"], _ = _git(repo, "log", "-1", "--format=%cr")
+    if out["remote"]:
+        code, n, _ = _git(repo, "rev-list", "--count", "@{u}..HEAD")
+        if code != 0:  # never pushed (no upstream yet): everything is waiting
+            code, n, _ = _git(repo, "rev-list", "--count", "HEAD")
+        out["waiting"] = int(n) if code == 0 and n.isdigit() else 0
+    return out
+
+
+def cached_visibility(host: str | None, slug: str | None) -> str | None:
+    """The last answer for this repo if it is fresh, "unknown" for non-GitHub hosts, else None (not checked yet)."""
+    if host != "github.com" or not slug:
+        return "unknown"
+    cached = _load().get("visibility") or {}
+    if cached.get("slug") == slug and time.time() - float(cached.get("at", 0)) < VISIBILITY_TTL:
+        return str(cached.get("value", "unknown"))
+    return None
+
+
+def visibility(host: str | None, slug: str | None, force: bool = False, timeout: float = 5.0) -> str:
+    """"private", "public" or "unknown" (not GitHub, offline, or rate-limited). Cached for 6 hours."""
+    if host != "github.com" or not slug:
+        return "unknown"
+    data = _load()
+    cached = data.get("visibility") or {}
+    if not force and cached.get("slug") == slug and time.time() - float(cached.get("at", 0)) < VISIBILITY_TTL:
+        return str(cached.get("value", "unknown"))
+    value = "unknown"
+    try:
+        req = Request(f"https://api.github.com/repos/{slug}",
+                      headers={"Accept": "application/vnd.github+json", "User-Agent": "claude-worklog"})
+        with urlopen(req, timeout=timeout) as resp:  # noqa: S310 - fixed https host
+            info = json.loads(resp.read(200_000).decode("utf-8"))
+            value = "private" if info.get("private") else "public"
+    except HTTPError as exc:
+        value = "private" if exc.code == 404 else "unknown"  # 404: not visible without logging in
+    except (OSError, ValueError):
+        value = "unknown"
+    data["visibility"] = {"slug": slug, "value": value, "at": time.time()}
+    _save(data)
+    return value
+
+
+def test_connection(cfg: Config) -> tuple[bool, str]:
+    """Can this computer reach the remote without a password prompt? (git ls-remote)"""
+    code, _, err = _git(cfg.store_repo, "ls-remote", "--heads", "origin", timeout=30)
+    if code == 0:
+        return True, "Connection works: this computer can reach your data repo."
+    hint = err.splitlines()[-1] if err else "no answer"
+    if "Permission denied" in err or "publickey" in err:
+        hint += " (the SSH key isn't allowed on this repo: add it as a deploy key with write access)"
+    elif "could not read Username" in err or "terminal prompts disabled" in err:
+        hint += " (this computer has no saved login for the repo: set up an SSH key, see the Full setup guide)"
+    elif "Could not resolve host" in err:
+        hint += " (no internet, or the host name is wrong)"
+    elif "not found" in err.lower() or "Repository not found" in err:
+        hint += " (check the repo name, and that this key or account can see it)"
+    return False, f"Can't reach your data repo: {hint[:250]}"

{worklog_for_claude_code-0.3.0 → worklog_for_claude_code-0.3.1}/worklog/web.py

@@ -25,8 +25,8 @@ from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
 from urllib.parse import parse_qs, unquote, urlsplit
 
-from . import __version__, chats, checks, services, updates, viz, watcher
-from .collector import collect, sanitize_remote
+from . import __version__, chats, checks, forget, services, syncstatus, updates, viz, watcher
+from .collector import collect
 from .config import (
     _NAME_RE,
     CONFIG_PATH,
@@ -284,6 +284,11 @@ ol.checks>li>details,ol.checks>li>span{min-width:0}.tips{margin-top:12px}
 background:var(--glass);border:1px solid var(--rule);backdrop-filter:blur(14px);-webkit-backdrop-filter:blur(14px);box-shadow:var(--shadow)}
 .notice .ico{font-size:1.3rem}.notice .txt{flex:1 1 280px}.notice .acts{display:flex;gap:8px;align-items:center}
 .notice .acts form{margin:0}.notice.hook,.notice.apikey{border-color:color-mix(in srgb,var(--bad) 55%,var(--rule))}
+.danger-zone{border-color:color-mix(in srgb,var(--bad) 60%,var(--rule))!important;box-shadow:0 0 0 1px color-mix(in srgb,var(--bad) 35%,transparent),var(--shadow)}
+.danger-zone h2{color:var(--bad)}.danger-zone ul{margin:6px 0 12px;padding-left:1.2em}.danger-zone li{margin:4px 0}
+button.danger-solid{background:#C2334B;color:#fff;box-shadow:none}
+#forget,#logins,#checklist,#add,#data-repo{scroll-margin-top:96px}
+#data-repo .meta{display:flex;flex-wrap:wrap;gap:8px;align-items:center}a.btn.forget{color:var(--bad);border-color:color-mix(in srgb,var(--bad) 45%,var(--rule))}
 .notice.update{border-color:color-mix(in srgb,var(--ok) 55%,var(--rule))}.notice.update code{margin-right:4px}
 .notice.login,.notice.folder{border-color:color-mix(in srgb,var(--accent) 55%,var(--rule))}
 /* ---- motion: everything here is switched off by prefers-reduced-motion below */
@@ -891,13 +896,63 @@ def top_panels(app: App, cfg: Config, active: str = "") -> str:
                            f'<a class="btn" href="/settings#checklist">Fix it</a></span></div>' for x in broken)
         elif active != "settings":  # Settings shows the full checklist in its own section
             out += checklist_html(app, items)
-    return out + _notices_html(app, cfg)
+    return out + _public_repo_warning(cfg) + _notices_html(app, cfg)
+
+
+def _public_repo_warning(cfg: Config) -> str:
+    """Shown on every page while the data repo is public (from the last check, never waits for the network)."""
+    r = syncstatus.remote(cfg)
+    if not r or syncstatus.cached_visibility(r["host"], r["slug"]) != "public":
+        return ""
+    return (f'<div class="notice hook" role="alert"><span class="ico" aria-hidden="true">⚠️</span><span class="txt">'
+            f'<b>Your data repo {e(r["host"])}/{e(r["slug"])} is public.</b> Anyone can read your prompts and project names. '
+            f'Make it private on GitHub.</span><span class="acts"><a class="btn" href="/settings#data-repo">How</a>'
+            f'</span></div>')
 
 
 MODEL_CHOICES = (("", "Account default"), ("opus", "Opus (latest)"), ("sonnet", "Sonnet (latest)"),
                  ("haiku", "Haiku (latest)"), ("fable", "Fable (latest)"))
 
 
+def _forget_link(login: dict) -> str:
+    return (f'<a class="btn quiet forget" href="/settings?forget={e(login["ref"])}#forget" '
+            f'title="Delete Worklog\'s history of this login">Forget…</a>')
+
+
+def _forget_confirm(app: App, cfg: Config, ref_: str) -> str:
+    """The "are you sure?" card: exactly what forgetting this login deletes, and what it doesn't."""
+    p = forget.plan(cfg, ref_)
+    if p is None:
+        return '<div class="banner bad" role="alert">That login is no longer recorded on this device.</div>'
+    days = sorted(p.days)
+    span = (f" from {len(days)} day{'s' * (len(days) != 1)} ({days[0]:%d %b %Y} – {days[-1]:%d %b %Y})"
+            if len(days) > 1 else f" from {days[0]:%d %b %Y}" if days else "")
+    lost = [f"<li><b>{len(p.files)} Claude Code session record{'s' * (len(p.files) != 1)}</b>{span}: what you worked "
+            f"on, prompts, tokens, files and commits</li>"]
+    if p.projects:
+        lost.append("<li>The saved summaries of the projects in those sessions (write them again with "
+                    "“Write summaries” on each day)</li>")
+    if p.account and not p.keep_account:
+        lost.append(f"<li>The account <b>{e(p.account)}</b>. Its other sessions (from logins without a name) move to "
+                    f"the folder&#39;s default account.</li>")
+    elif p.account:
+        lost.append(f"<li>The link between <b>{e(p.account)}</b> and this login (it&#39;s your only account, so it stays)</li>")
+    lost.append("<li>The login itself, from this list</li>")
+    c = f'<input type="hidden" name="csrf" value="{app.csrf}">'
+    return f"""<section class="block danger-zone" id="forget" role="alertdialog" aria-labelledby="forget-title">
+<h2 id="forget-title">Forget {e(p.label)}?</h2>
+<p><b>This permanently deletes Worklog&#39;s history of this login on this device.</b> You will lose:</p>
+<ul>{"".join(lost)}</ul>
+<p class="muted">Not touched: Claude Code&#39;s own files, your other accounts, and records synced from your other
+computers. The old versions stay in your data repo&#39;s git history. If this account logs in again later, its new
+sessions are tracked as usual.</p>
+<form method="post" action="/accounts/forget">{c}<input type="hidden" name="ref" value="{e(p.ref)}">
+<div class="check"><input type="checkbox" id="forget_ok" name="confirm" value="1" required>
+<label for="forget_ok">I understand this deletes the history above and can&#39;t be undone</label></div>
+<div class="row"><button class="danger-solid">Forget and delete</button><a class="btn quiet" href="/settings#logins">Cancel</a></div>
+</form></section>"""
+
+
 def _detected_section(cfg: Config, csrf_field: str) -> str:
     """Logins seen by the SessionStart hook. E-mails are masked; forms carry an opaque ref, never the id."""
     by_dir = cfg.accounts_by_dir()
@@ -918,7 +973,8 @@ def _detected_section(cfg: Config, csrf_field: str) -> str:
             where = f'<span class="muted">folder <code>{e(home_relative(d))}</code> · last seen {e(seen)}</span>'
             if len(by_dir[d]) == 1 and per_dir[d] == 1:  # the only login in its own folder: nothing to tell apart
                 rows.append(f'<div class="acct"><h3>{e(mask_email(login["email"]))}</h3><div class="meta">'
-                            f'<span class="pill ok">Counted as {e(current.name)}</span>{where}</div></div>')
+                            f'<span class="pill ok">Counted as {e(current.name)}</span>{where}</div>'
+                            f'<div class="row" style="margin-top:8px">{_forget_link(login)}</div></div>')
                 continue
             status = (f'<span class="pill ok">Counted as {e(current.name)}</span>' if linked
                       else f'<span class="pill bad">No name yet</span> <span class="muted">counted as {e(current.name)} '
@@ -933,7 +989,8 @@ def _detected_section(cfg: Config, csrf_field: str) -> str:
                 f'<label for="{list_id}-in" class="muted" style="margin:0">Account name</label>'
                 f'<input type="text" id="{list_id}-in" name="name" list="{list_id}" value="{e(current.name) if linked else ""}" '
                 f'placeholder="work" required pattern="{NAME_PATTERN}" style="width:auto"><datalist id="{list_id}">{names}</datalist>'
-                f'<button class="{"quiet" if linked else ""}">{"Rename" if linked else "Name this login"}</button></form></div>')
+                f'<button class="{"quiet" if linked else ""}">{"Rename" if linked else "Name this login"}</button>'
+                f'{_forget_link(login)}</form></div>')
     body = "".join(rows) or ('<div class="empty">No logins recorded yet. Install the hook, then start a Claude Code '
                              'session. Each account you log in with appears here.</div>')
     return (f'<h3 id="logins" style="margin-top:22px">Logins seen on this device</h3><p class="help" style="margin-top:6px">Each account '
@@ -943,16 +1000,74 @@ def _detected_section(cfg: Config, csrf_field: str) -> str:
             f'device.</p>{body}')
 
 
-def page_settings(app: App, cfg: Config) -> str:
+def _ago(ts: float | None) -> str:
+    if not ts:
+        return "never"
+    s = max(0, int(time.time() - ts))
+    for size, unit in ((86400, "day"), (3600, "hour"), (60, "minute")):
+        if s >= size:
+            n = s // size
+            return f"{n} {unit}{'s' * (n != 1)} ago"
+    return "just now"
+
+
+def data_repo_section(app: App, cfg: Config) -> str:
+    """Connected or not, to which repo, private or not, and whether uploads work."""
     c = f'<input type="hidden" name="csrf" value="{app.csrf}">'
-    store = _store(cfg)
-    if store:
-        remotes = [sanitize_remote(u) for u in _git_out(cfg.store_repo, "remote", "get-url", "origin").splitlines()]
-        remote = next((f"{r['host']}/{r['slug']}" for r in remotes if r), "none (local only)")
-        last = _git_out(cfg.store_repo, "log", "-1", "--format=%cr") or "no commits yet"
-        store_state = f'<span class="state-ok">Connected</span>. Remote: {e(remote)}. Last change {e(last)}.'
+    st = syncstatus.status(cfg)
+    folder = e(home_relative(cfg.store_repo))
+    if not st["is_repo"]:
+        body = (f'<div class="meta"><span class="pill bad">Not set up</span><span class="muted"><code>{folder}</code> '
+                f'is not a git folder yet.</span></div><p class="help" style="margin-top:10px">Create it with '
+                f'<code>git init {folder}</code>, or clone your private repo there.</p>')
+        return f'<section class="block" id="data-repo"><h2>Private data repo</h2>{body}</section>'
+    buttons = (f'<div class="row"><form method="post" action="/action/collect">{c}<button>Sync now</button></form>'
+               f'<form method="post" action="/sync/test">{c}<button class="quiet">Test connection</button></form></div>')
+    if not st["remote"]:
+        body = (f'<div class="meta"><span class="pill">Local only</span><span class="muted">Not connected. Your log '
+                f'stays in <code>{folder}</code> on this computer and isn&#39;t backed up.</span></div>'
+                f'<p class="help" style="margin-top:10px">Using Claude Code on more than one computer, or want a backup? '
+                f'Create an <b>empty, private</b> repo on GitHub, GitLab or Bitbucket and connect this folder to it:</p>'
+                f'<div class="cmdrow"><pre class="cmd">git -C {folder} remote add origin git@github.com:YOU/claude-worklog-data.git</pre>'
+                f'<button type="button" class="quiet copy" data-copy="git -C {folder} remote add origin '
+                f'git@github.com:YOU/claude-worklog-data.git">Copy</button></div>'
+                f'<p class="help"><a href="https://github.com/us-urvin/worklog-for-claude-code/blob/main/docs/GUIDE.md#full-setup" '
+                f'target="_blank" rel="noopener noreferrer">Step-by-step guide ↗</a> (including a key so the background '
+                f'service can upload without a password)</p>')
+        return f'<section class="block" id="data-repo"><h2>Private data repo</h2>{body}</section>'
+    vis = syncstatus.cached_visibility(st.get("host"), st.get("slug"))
+    if vis is None:  # ask GitHub in the background; the page never waits for it
+        threading.Thread(target=syncstatus.visibility, args=(st["host"], st["slug"]), daemon=True).start()
+    privacy = {"private": '<span class="pill ok">🔒 Private</span>',
+               "public": '<span class="pill bad">⚠️ PUBLIC: anyone can read your log</span>',
+               "unknown": '<span class="pill">Privacy not checked (only possible for GitHub)</span>',
+               None: '<span class="pill">Checking privacy…</span>'}[vis]
+    push, pull = st["push"], st["pull"]
+    if push and not push["ok"]:
+        health = (f'<span class="pill bad">Last upload failed</span><span class="muted">{_ago(push["at"])}: '
+                  f'{e(push["error"][:160])}</span>')
+    elif pull and not pull["ok"]:
+        health = (f'<span class="pill bad">Last download failed</span><span class="muted">{_ago(pull["at"])}: '
+                  f'{e(pull["error"][:160])}</span>')
+    elif push:
+        health = f'<span class="pill ok">Synced</span><span class="muted">last upload {_ago(push["at"])}</span>'
     else:
-        store_state = '<span class="state-bad">Not a git clone.</span> Clone your private data repo into this folder.'
+        health = '<span class="pill">Not uploaded yet</span><span class="muted">the next sync uploads your log</span>'
+    waiting = (f'<span class="muted">· {st["waiting"]} change{"s" * (st["waiting"] != 1)} waiting to upload</span>'
+               if st["waiting"] else "")
+    warn = ('<p class="state-bad" style="margin:10px 0 0"><b>This repo is public.</b> Your prompts, project names and '
+            'commit messages can be read by anyone. Make it private in the repo&#39;s settings on GitHub '
+            '(Settings → General → Danger Zone → Change visibility).</p>' if vis == "public" else "")
+    return f"""<section class="block" id="data-repo"><h2>Private data repo</h2>
+<div class="meta"><span class="pill ok">Connected</span><span>to <a href="{e(st["web_url"])}" target="_blank"
+rel="noopener noreferrer"><b>{e(st["remote"])}</b> ↗</a></span>{privacy}</div>
+<div class="meta" style="margin-top:8px">{health}{waiting}</div>{warn}
+<p class="muted" style="font-size:.85rem;margin:10px 0 0">Folder <code>{folder}</code> · branch <code>{e(st["branch"])}</code>
+· last change {e(st["last_change"] or "none yet")}</p>{buttons}</section>"""
+
+
+def page_settings(app: App, cfg: Config, forget_ref: str | None = None) -> str:
+    c = f'<input type="hidden" name="csrf" value="{app.csrf}">'
 
     logins = detected_logins()
     by_dir = cfg.accounts_by_dir()
@@ -1001,7 +1116,8 @@ def page_settings(app: App, cfg: Config) -> str:
     running = app.watcher is not None and app.watcher.running
     watch_state = ('<span class="state-ok">Watching now.</span>' if running else
                    '<span class="muted">Not watching in this window (it runs in the background service).</span>')
-    return f"""<h1><span class="grad">Settings</span><small>Device {e(cfg.device)}</small></h1>
+    confirm = _forget_confirm(app, cfg, forget_ref) if forget_ref else ""
+    return confirm + f"""<h1><span class="grad">Settings</span><small>Device {e(cfg.device)}</small></h1>
 <section class="block" style="margin-top:24px"><h2>Claude accounts</h2>
 <p class="help">Worklog counts every Claude Code session under one of these accounts. Pick the setup that matches how you use Claude Code:</p>
 <div class="setups"><div><b>Each account in its own folder</b>You start one account with plain <code>claude</code> and another with
@@ -1018,6 +1134,8 @@ def page_settings(app: App, cfg: Config) -> str:
 
 {"" if services.demo_mode() else checklist_html(app, checks.cached(cfg, running), "Setup checklist")}
 
+{data_repo_section(app, cfg)}
+
 <section class="block"><h2>Account switching and extras</h2>
 <p class="help">While Worklog runs, it notices when you switch Claude accounts (with <code>/login</code> or any one-click
 account tool) and when a new Claude folder appears, so sessions are counted under the right account even without a hook.
@@ -1047,7 +1165,8 @@ account tool) and when a new Claude folder appears, so sessions are counted unde
 <label for="device">Device name</label><input type="text" id="device" name="device" value="{e(cfg.device)}" required pattern="{NAME_PATTERN}">
 <p class="muted" style="font-size:.85rem">Renaming files new sessions under the new name. Earlier days keep the old one.</p>
 <label for="store">Data repo folder</label><input type="text" id="store" name="store" value="{e(home_relative(cfg.store_repo))}" required>
-<p style="font-size:.9rem">{store_state}</p><div class="row"><button>Save changes</button></div></form></section>
+<p class="muted" style="font-size:.85rem">Connection and sync status: see <a href="#data-repo">Private data repo</a>.</p>
+<div class="row"><button>Save changes</button></div></form></section>
 
 <section class="block"><h2>Background services</h2><p class="help">These keep running after you close the browser and start again when you log in.</p>
 <div class="tablewrap"><table><tr><th>Service</th><th>State</th></tr>{svc_rows}</table></div>
@@ -1112,6 +1231,16 @@ class App:
             return (f"/?d={day.isoformat()}&ok=job" if started else f"/?d={day.isoformat()}"), None, form
         if path == "/accounts/add":
             return self._account_add(cfg, form)
+        if path == "/sync/test":
+            def job():
+                ok, msg = syncstatus.test_connection(cfg)
+                if not ok:
+                    raise RuntimeError(msg)
+                return msg
+            started = self.jobs.start("Testing the connection", job)
+            return ("/settings?ok=job#data-repo" if started else "/settings#data-repo"), None, form
+        if path == "/accounts/forget":
+            return self._forget(cfg, form)
         if path == "/accounts/add-folder":
             return self._account_add_folder(cfg, form)
         if path == "/notices/dismiss":
@@ -1265,6 +1394,22 @@ class App:
     def restart(self) -> None:
         updates.restart_server(self.port, self.close)
 
+    def _forget(self, cfg: Config, form: dict):
+        """Delete a login's history after the user ticked "I understand" on the confirmation card."""
+        ref_ = form.get("ref", "")
+        if form.get("confirm") != "1":
+            return None, "Tick “I understand” to confirm.", form
+        p = forget.plan(cfg, ref_)
+        if p is None:
+            return None, "That login is no longer recorded on this device.", form
+
+        def job():
+            msg = forget.apply(cfg, p)
+            checks.forget_cache()
+            return msg
+        started = self.jobs.start("Forgetting a login", job)
+        return ("/settings?ok=job#logins" if started else "/settings"), None, form
+
     def _account_add_folder(self, cfg: Config, form: dict):
         """Add a folder the watcher found: pick a free name from the folder, then install its hook."""
         folder = _expand(form.get("folder", ""))
@@ -1425,7 +1570,8 @@ def make_handler(app: App):
                     body, err = page_day(app, cfg, day)
                     return self._page(f"{day:%d %b %Y}", body, "day", q.get("ok"), err)
                 if url.path == "/settings":
-                    return self._page("Settings", page_settings(app, cfg), "settings", q.get("ok"))
+                    forget_ref = q.get("forget") if re.fullmatch(r"[0-9a-f]{12}", q.get("forget", "")) else None
+                    return self._page("Settings", page_settings(app, cfg, forget_ref), "settings", q.get("ok"))
                 if url.path == "/sources":
                     return self._page("Sources", page_sources(app, cfg), "sources", q.get("ok"))
                 return self._send(404, "Not found", "text/plain")

{worklog_for_claude_code-0.3.0 → worklog_for_claude_code-0.3.1/worklog_for_claude_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: worklog-for-claude-code
-Version: 0.3.0
+Version: 0.3.1
 Summary: See what you did with Claude Code each day and how many tokens it used: an automatic daily work log across accounts and devices, private by default
 Author: Urvin
 License-Expression: MIT
@@ -33,7 +33,7 @@ Provides-Extra: test
 Requires-Dist: pytest>=7; extra == "test"
 Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == "dev"
-Requires-Dist: ruff==0.17.0; extra == "dev"
+Requires-Dist: ruff==0.17.3; extra == "dev"
 Requires-Dist: build; extra == "dev"
 Dynamic: license-file
 

{worklog_for_claude_code-0.3.0 → worklog_for_claude_code-0.3.1}/worklog_for_claude_code.egg-info/SOURCES.txt

@@ -5,7 +5,9 @@ tests/test_accounts.py
 tests/test_chats.py
 tests/test_checks.py
 tests/test_demo.py
+tests/test_forget.py
 tests/test_platforms.py
+tests/test_syncstatus.py
 tests/test_updates.py
 tests/test_viz.py
 tests/test_watcher.py
@@ -17,6 +19,7 @@ worklog/cli.py
 worklog/collector.py
 worklog/config.py
 worklog/demo.py
+worklog/forget.py
 worklog/hooks.py
 worklog/identity.py
 worklog/locks.py
@@ -25,6 +28,7 @@ worklog/redact.py
 worklog/report.py
 worklog/services.py
 worklog/store.py
+worklog/syncstatus.py
 worklog/updates.py
 worklog/viz.py
 worklog/watcher.py

{worklog_for_claude_code-0.3.0 → worklog_for_claude_code-0.3.1}/worklog_for_claude_code.egg-info/requires.txt

@@ -4,7 +4,7 @@ tomli>=2.0
 
 [dev]
 pytest>=7
-ruff==0.17.0
+ruff==0.17.3
 build
 
 [test]