privatecontext 0.1.0__py3-none-any.whl

privatecontext/dashboard.py

@@ -0,0 +1,168 @@
+"""Local dashboard for PrivateContext (stdlib http.server only).
+
+Single page on 127.0.0.1:18790. The page polls /api/timeline and /api/usage
+every 2 seconds — live updates without WebSockets. Views: today's timeline
+(reverse-chron), app-usage bars, FTS5 search, and a big Purge button.
+"""
+from __future__ import annotations
+
+import json
+import threading
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from urllib.parse import urlparse, parse_qs
+
+from .db import app_usage, connect, init_db, search, timeline
+
+PAGE = """<!doctype html>
+<html><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>PrivateContext</title>
+<style>
+:root{color-scheme:dark}
+body{font-family:system-ui,-apple-system,sans-serif;background:#141414;color:#e8e8e8;
+     max-width:920px;margin:0 auto;padding:24px;line-height:1.45}
+h1 small{color:#888;font-weight:normal}
+#status{color:#888;font-size:0.9em}
+input#q{width:60%;padding:8px;font-size:1em;background:#222;color:#eee;border:1px solid #444;border-radius:6px}
+button{padding:8px 14px;font-size:1em;border-radius:6px;border:1px solid #444;background:#2a2a2a;color:#eee;cursor:pointer}
+button:hover{background:#333}
+.ev{padding:6px 0;border-bottom:1px solid #222;font-size:0.95em}
+.ev .t{color:#888;font-variant-numeric:tabular-nums}
+.ev .ty{display:inline-block;min-width:52px;color:#9cf;font-size:0.85em}
+.ev .c{color:#8a8;font-size:0.85em}
+.bar{display:flex;align-items:center;gap:10px;margin:6px 0}
+.bar .al{width:180px;text-align:right;color:#bbb;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.bar .track{flex:1;background:#222;border-radius:4px;height:14px}
+.bar .fill{background:#4a9;height:14px;border-radius:4px}
+.bar .v{width:60px;color:#888;font-size:0.9em}
+a{color:#9cf}
+#purge{background:#5a1d1d;border-color:#a33;margin-top:24px;font-size:1.1em;padding:12px 22px}
+#purge:hover{background:#7a2626}
+</style></head>
+<body>
+<h1>&#9673; PrivateContext <small>v0 &middot; local only</small></h1>
+<p id="status">loading&hellip;</p>
+<div>
+<input id="q" placeholder="Search everything: servicenow, eduroam, zoom&hellip;" autocomplete="off">
+<button onclick="doSearch()">Search</button>
+</div>
+<div id="results"></div>
+<h2>Today &mdash; app usage</h2>
+<div id="usage"></div>
+<h2>Timeline (newest first)</h2>
+<div id="timeline"></div>
+<hr>
+<button id="purge" onclick="doPurge()">&#128465; Purge all data</button>
+<script>
+async function j(p, opt){ const r = await fetch(p, opt); return r.json(); }
+function esc(s){ return (s==null?'':String(s)).replace(/[&<>"]/g,
+  c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c])); }
+function fmtT(ts){ return new Date(ts*1000).toLocaleTimeString(); }
+function evHTML(e){
+  return '<div class="ev"><span class="t">'+fmtT(e.ts)+'</span> '+
+    '<span class="ty">'+esc(e.type)+'</span> '+
+    '<b>'+esc(e.app)+'</b> &mdash; '+esc(e.title)+
+    (e.url ? ' <a href="'+esc(e.url)+'">link</a>' : '')+
+    (e.tags ? ' <span class="c">['+esc(e.tags)+']</span>' : '')+
+    (e.x!=null ? ' <span class="c">click@'+e.x+','+e.y+'</span>' : '')+
+    (e.duration_ms!=null ? ' <span class="c">'+Math.round(e.duration_ms/1000)+'s idle</span>' : '')+
+    '</div>';
+}
+async function refresh(){
+  try{
+    const tl = await j('/api/timeline?limit=200');
+    const u = await j('/api/usage');
+    document.getElementById('timeline').innerHTML = tl.map(evHTML).join('');
+    const max = Math.max(1, ...u.map(x=>x[1]));
+    document.getElementById('usage').innerHTML = u.map(pair =>
+      '<div class="bar"><span class="al">'+esc(pair[0])+'</span>'+
+      '<div class="track"><div class="fill" style="width:'+(100*pair[1]/max).toFixed(1)+'%"></div></div>'+
+      '<span class="v">'+(pair[1]/60).toFixed(0)+'m</span></div>').join('');
+    document.getElementById('status').textContent =
+      tl.length+' events today · updated '+new Date().toLocaleTimeString()+' (auto-refreshes every 2s)';
+  }catch(e){ document.getElementById('status').textContent = 'error: '+e; }
+}
+async function doSearch(){
+  const q = document.getElementById('q').value;
+  const r = await j('/api/search?q='+encodeURIComponent(q));
+  document.getElementById('results').innerHTML =
+    '<h3>'+r.length+' result'+(r.length==1?'':'s')+'</h3>'+r.map(evHTML).join('');
+}
+async function doPurge(){
+  if(!confirm('Delete ALL captured data? This cannot be undone.')) return;
+  const r = await j('/api/purge', {method:'POST'});
+  alert('Deleted '+r.deleted+' events.');
+  document.getElementById('results').innerHTML='';
+  refresh();
+}
+document.getElementById('q').addEventListener('keydown', e=>{ if(e.key==='Enter') doSearch(); });
+setInterval(refresh, 2000);
+refresh();
+</script>
+</body></html>
+"""
+
+
+class Handler(BaseHTTPRequestHandler):
+    server_version = "PrivateContext/0.1"
+
+    def _json(self, obj, code: int = 200) -> None:
+        body = json.dumps(obj).encode()
+        self.send_response(code)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _with_db(self, fn):
+        with self.server.lock:
+            return fn(self.server.db)
+
+    def do_GET(self) -> None:
+        u = urlparse(self.path)
+        if u.path == "/":
+            body = PAGE.encode()
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+        elif u.path == "/api/timeline":
+            qs = parse_qs(u.query)
+            limit = int(qs.get("limit", ["200"])[0])
+            self._json(self._with_db(lambda db: timeline(db, min(limit, 1000))))
+        elif u.path == "/api/usage":
+            self._json(self._with_db(app_usage))
+        elif u.path == "/api/search":
+            q = parse_qs(u.query).get("q", [""])[0]
+            self._json(self._with_db(lambda db: search(db, q)))
+        else:
+            self._json({"error": "not found"}, 404)
+
+    def do_POST(self) -> None:
+        if urlparse(self.path).path == "/api/purge":
+            def _purge(db):
+                n = db.execute("DELETE FROM events").rowcount
+                db.execute("DELETE FROM days")
+                db.commit()
+                db.execute("VACUUM")
+                return {"deleted": n}
+            self._json(self._with_db(_purge))
+        else:
+            self._json({"error": "not found"}, 404)
+
+    def log_message(self, *args) -> None:  # keep the console quiet
+        pass
+
+
+def serve(db_path: str | None = None, port: int = 18790) -> None:
+    db = connect(db_path)
+    init_db(db)
+    server = ThreadingHTTPServer(("127.0.0.1", port), Handler)
+    server.db = db  # type: ignore[attr-defined]
+    server.lock = threading.Lock()  # type: ignore[attr-defined]
+    print(f"[privatecontext] dashboard at http://127.0.0.1:{port} — Ctrl-C to stop")
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\n[privatecontext] dashboard stopped.")

privatecontext/db.py

@@ -0,0 +1,140 @@
+"""SQLite helpers for PrivateContext: connect, init, insert, search, usage."""
+from __future__ import annotations
+
+import os
+import sqlite3
+import time
+from datetime import datetime
+from pathlib import Path
+
+from .tagging import extract_tags
+
+APP_NAME = "privatecontext"
+DB_NAME = "context.db"
+
+
+def data_dir() -> Path:
+    base = os.environ.get("XDG_DATA_HOME") or str(Path.home() / ".local" / "share")
+    d = Path(base) / APP_NAME
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def default_db_path() -> str:
+    return str(data_dir() / DB_NAME)
+
+
+def _schema_text() -> str:
+    here = Path(__file__).resolve()
+    for p in (here.parent / "schema.sql", here.parent.parent / "schema.sql"):
+        if p.exists():
+            return p.read_text()
+    raise FileNotFoundError("schema.sql not found next to package or repo root")
+
+
+def connect(path: str | None = None) -> sqlite3.Connection:
+    """Open the DB, creating parent dirs. Safe to share across threads."""
+    p = Path(path) if path else Path(default_db_path())
+    p.parent.mkdir(parents=True, exist_ok=True)
+    con = sqlite3.connect(str(p), check_same_thread=False)
+    con.row_factory = sqlite3.Row
+    return con
+
+
+def init_db(con: sqlite3.Connection) -> None:
+    con.executescript(_schema_text())
+    # Migration for databases created before the tags column existed.
+    cols = [r[1] for r in con.execute("PRAGMA table_info(events)")]
+    if "tags" not in cols:
+        con.execute("ALTER TABLE events ADD COLUMN tags TEXT")
+    con.commit()
+
+
+def strip_url(url: str | None) -> str | None:
+    """Strip query params and fragments. Never store tracking junk."""
+    if not url:
+        return url
+    return url.split("#", 1)[0].split("?", 1)[0]
+
+
+def log_event(con: sqlite3.Connection, type: str, ts: float | None = None,
+              app: str | None = None, title: str | None = None,
+              url: str | None = None, x: int | None = None,
+              y: int | None = None, duration_ms: int | None = None,
+              tags: str | list | None = None,
+              commit: bool = True) -> int:
+    if tags is None:
+        found = extract_tags(app, title, url)
+        tag_str = ",".join(found) if found else None
+    elif isinstance(tags, (list, tuple)):
+        tag_str = ",".join(tags) if tags else None
+    else:
+        tag_str = tags or None
+    cur = con.execute(
+        "INSERT INTO events(ts, type, app, title, url, x, y, duration_ms, tags)"
+        " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        (ts if ts is not None else time.time(), type, app, title,
+         strip_url(url), x, y, duration_ms, tag_str),
+    )
+    if commit:
+        con.commit()
+    return cur.lastrowid
+
+
+def today_range() -> tuple[float, float]:
+    now = datetime.now().astimezone()
+    start = now.replace(hour=0, minute=0, second=0, microsecond=0)
+    return start.timestamp(), now.timestamp()
+
+
+def timeline(con: sqlite3.Connection, limit: int = 200) -> list[dict]:
+    start, _ = today_range()
+    rows = con.execute(
+        "SELECT id, ts, type, app, title, url, x, y, duration_ms, tags FROM events"
+        " WHERE ts >= ? ORDER BY ts DESC LIMIT ?",
+        (start, limit),
+    ).fetchall()
+    return [dict(r) for r in rows]
+
+
+def app_usage(con: sqlite3.Connection, cap_s: float = 600) -> list[tuple[str, float]]:
+    """Seconds per app today. Each window event owns time until the next
+    event, capped so a forgotten window doesn't claim the whole afternoon."""
+    start, _ = today_range()
+    rows = con.execute(
+        "SELECT ts, app FROM events WHERE type = 'window' AND ts >= ? ORDER BY ts",
+        (start,),
+    ).fetchall()
+    usage: dict[str, float] = {}
+    now = time.time()
+    for i, r in enumerate(rows):
+        nxt = rows[i + 1]["ts"] if i + 1 < len(rows) else now
+        dur = min(max(0.0, nxt - r["ts"]), cap_s)
+        app = r["app"] or "unknown"
+        usage[app] = usage.get(app, 0.0) + dur
+    return sorted(usage.items(), key=lambda kv: -kv[1])
+
+
+def _fts_query(q: str) -> str:
+    # Quote each token so user punctuation can't break FTS5 syntax.
+    toks = [t for t in q.split() if t]
+    if not toks:
+        return '""'
+    return " ".join('"' + t.replace('"', '""') + '"' for t in toks)
+
+
+def search(con: sqlite3.Connection, q: str, limit: int = 50) -> list[dict]:
+    if not q.strip():
+        return []
+    rows = con.execute(
+        "SELECT e.id, e.ts, e.type, e.app, e.title, e.url"
+        " FROM events_fts f JOIN events e ON e.id = f.rowid"
+        " WHERE events_fts MATCH ? ORDER BY rank LIMIT ?",
+        (_fts_query(q), limit),
+    ).fetchall()
+    return [dict(r) for r in rows]
+
+
+def counts(con: sqlite3.Connection) -> dict:
+    rows = con.execute("SELECT type, COUNT(*) AS n FROM events GROUP BY type").fetchall()
+    return {r["type"]: r["n"] for r in rows}