chatdeck 0.1.1__tar.gz → 0.2.1__tar.gz

{chatdeck-0.1.1/src/chatdeck.egg-info → chatdeck-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatdeck
-Version: 0.1.1
+Version: 0.2.1
 Summary: A local dashboard for your Claude Code chats: what's running, what needs you, and what it costs.
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/Abdifatah09/chatdeck
@@ -37,7 +37,10 @@ Python 3.9+ standard library only, no dependencies.
 - **Cleanup** – delete empty chats or chats older than 7, 30 or 90 days. Shows disk usage.
   Running chats are never deleted.
 - **By project** view: one section per project (git repo, including its worktrees and subfolders)
-  with its running and saved chats, and a **New chat** button that starts Claude Code in that project. Sort by recent, size, cost or messages. Light and dark themes.
+  with its running and saved chats, and a **New chat** button that starts Claude Code in that project.
+  **Add project** lists a folder before it has any chats; **Delete project** deletes its saved chats
+  and takes it off the list (the folder itself is never touched). Drag a project's header to move it
+  (**Reset order** goes back to the automatic order). Sort by recent, size, cost or messages. Light and dark themes.
   Keyboard shortcuts: `/` search, `j`/`k` move, `Enter` read, `r` resume, `e` rename, `x` select, `Del` delete, `?` help.
 - **Windows corner button and tray icon** – pop the dashboard up from the corner of the screen.
 

{chatdeck-0.1.1 → chatdeck-0.2.1}/README.md

@@ -19,7 +19,10 @@ Python 3.9+ standard library only, no dependencies.
 - **Cleanup** – delete empty chats or chats older than 7, 30 or 90 days. Shows disk usage.
   Running chats are never deleted.
 - **By project** view: one section per project (git repo, including its worktrees and subfolders)
-  with its running and saved chats, and a **New chat** button that starts Claude Code in that project. Sort by recent, size, cost or messages. Light and dark themes.
+  with its running and saved chats, and a **New chat** button that starts Claude Code in that project.
+  **Add project** lists a folder before it has any chats; **Delete project** deletes its saved chats
+  and takes it off the list (the folder itself is never touched). Drag a project's header to move it
+  (**Reset order** goes back to the automatic order). Sort by recent, size, cost or messages. Light and dark themes.
   Keyboard shortcuts: `/` search, `j`/`k` move, `Enter` read, `r` resume, `e` rename, `x` select, `Del` delete, `?` help.
 - **Windows corner button and tray icon** – pop the dashboard up from the corner of the screen.
 

{chatdeck-0.1.1 → chatdeck-0.2.1}/src/chatdeck/__init__.py

@@ -1,2 +1,2 @@
 """chatdeck: a local dashboard for Claude Code chats."""
-__version__ = "0.1.1"
+__version__ = "0.2.1"

{chatdeck-0.1.1 → chatdeck-0.2.1}/src/chatdeck/hooks.py

@@ -5,7 +5,7 @@
   their status line looks the same as before.
 - Notification (`chatdeck hook waiting`): marks a chat as waiting on a permission prompt or a
   question. The dashboard treats the mark as cleared once the transcript moves on."""
-import json, os, re, shutil, subprocess, sys, time
+import json, os, re, shlex, shutil, subprocess, sys, time
 
 from . import config
 
@@ -55,9 +55,9 @@ def command():
     """How settings.json should call chatdeck: the absolute path of the installed command,
     or this Python running the package from wherever it lives."""
     exe = shutil.which("chatdeck")
-    if exe: return exe
+    if exe: return shlex.quote(exe)
     src = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    return f"PYTHONPATH={src} {sys.executable} -m chatdeck"
+    return f"PYTHONPATH={shlex.quote(src)} {shlex.quote(sys.executable)} -m chatdeck"
 
 
 def _ours(cmd):

{chatdeck-0.1.1 → chatdeck-0.2.1}/src/chatdeck/server.py

@@ -1,9 +1,9 @@
 """chatdeck: a local dashboard for Claude Code chats.
 Lists running sessions (claude agents --json) and saved transcripts under
 ~/.claude/projects, and can view, search, rename, export and delete saved chats, stop
-sessions, and open chats in a terminal (see terminals.py). Binds 127.0.0.1 only; every API call needs
+sessions, add and delete projects, and open chats in a terminal (see terminals.py). Binds 127.0.0.1 only; every API call needs
 the per-run token embedded in the page (custom header => cross-site pages can't call it)."""
-import json, os, glob, secrets, shlex, signal, subprocess, threading, time
+import json, os, glob, secrets, shlex, signal, subprocess, sys, threading, time
 from http.server import ThreadingHTTPServer, BaseHTTPRequestHandler
 from urllib.parse import urlparse, parse_qs, quote
 
@@ -28,19 +28,25 @@ INDEX = transcripts.Index(PROJECTS)
 LIMITS = usage.LimitHistory(os.path.join(DATA, "limits-history.jsonl"))
 
 _agents = (0.0, {})
+_agents_ok = True   # did the latest fetch work?
 _agents_lock = threading.Lock()
 def _fetch_agents():
-    global _agents
+    """Refresh the cache; True if that worked. A failed check (non-zero exit, timeout, no output) keeps the last good list."""
+    global _agents, _agents_ok
+    _agents_ok = False
     try:
         if config.DEMO:
             with open(os.path.join(DATA, "demo-agents.json")) as f: out = f.read()
         else:
-            out = subprocess.run(["claude", "agents", "--json"], capture_output=True, text=True, timeout=30).stdout
-        res = {s["sessionId"]: s for s in json.loads(out or "[]") if s.get("sessionId")}
+            r = subprocess.run(["claude", "agents", "--json"], capture_output=True, text=True, timeout=30)
+            if r.returncode != 0 or not r.stdout.strip(): return False
+            out = r.stdout
+        res = {s["sessionId"]: s for s in json.loads(out) if s.get("sessionId")}
         with _agents_lock: _agents = (time.time(), res)
+        _agents_ok = True
+        return True
     except Exception:
-        pass
-    return _agents[1]
+        return False
 
 def _agents_loop():
     while True:
@@ -49,7 +55,16 @@ def _agents_loop():
 def agents(fresh=False):
     """Running sessions. Normal reads use the list a background thread keeps fresh, so pages never wait;
     destructive actions (delete/stop) ask for a fresh copy first."""
-    return _fetch_agents() if fresh else _agents[1]
+    if fresh: _fetch_agents()
+    return _agents[1]
+
+def agents_checked():
+    """A fresh running-sessions list, or None if we couldn't get one. Destructive actions use this, so a
+    failed check can never look like 'nothing is running'."""
+    act = agents(fresh=True)
+    return act if _agents_ok else None
+
+NO_CHECK = "couldn't check which chats are running"
 
 def waiting(act, chats):
     """{sid: message} for running chats stuck on a permission prompt or question. A mark from the
@@ -139,16 +154,16 @@ def state():
         a = act.get(sid, {})
         out.append({"sid": sid, "name": pend.get(sid) or a.get("name") or e.title or "(empty)",
                     "cwd": (a.get("cwd") or e.cwd or "").replace(HOME, "~"), "project": chat_project(e, a.get("cwd")),
-                    "ctx": e.ctx, "msgs": e.msgs, "mtime": e.mtime, "size": e.size, "cost": round(e.cost, 2),
+                    "ctx": e.ctx, "msgs": e.msgs, "mtime": e.mtime, "active": e.active or e.mtime, "size": e.size, "cost": round(e.cost, 2),
                     "status": a.get("status"), "kind": a.get("kind"), "started": a.get("startedAt"), "waiting": wait.get(sid)})
     for sid, a in act.items():  # running but no transcript yet
         if sid not in chats:
             out.append({"sid": sid, "name": pend.get(sid) or a.get("name") or "(new chat)", "cwd": (a.get("cwd") or "").replace(HOME, "~"),
                         "project": project(a.get("cwd")),
-                        "ctx": 0, "msgs": 0, "mtime": time.time(), "size": 0, "cost": 0, "status": a.get("status"),
+                        "ctx": 0, "msgs": 0, "mtime": time.time(), "active": time.time(), "size": 0, "cost": 0, "status": a.get("status"),
                         "kind": a.get("kind"), "started": a.get("startedAt"), "waiting": wait.get(sid)})
     out.sort(key=lambda x: -x["mtime"])
-    return {"chats": out, "now": time.time(), "usage": usage.summary([e for _, e in chats.values()], STATUS, LIMITS, project=chat_project)}
+    return {"chats": out, "projects": added_projects(), "now": time.time(), "usage": usage.summary([e for _, e in chats.values()], STATUS, LIMITS, project=chat_project)}
 
 def manual(cwd, command):
     """What to paste into a terminal when no terminal could be opened for the person."""
@@ -176,16 +191,22 @@ def transcript(sid):
     return hits[0]
 
 def delete(sids):
-    act = agents(fresh=True); done, refused = [], []
+    """Delete saved chats. Their projects stay listed, empty, until the project itself is deleted."""
+    act = agents_checked()
+    if act is None: return {"deleted": [], "refused": list(sids), "error": NO_CHECK}
+    done, refused = [], []; kept = added_projects(); keep = False
     for sid in sids:
         p = transcript(sid)
         if not p or sid in act:
             refused.append(sid); continue
+        e = INDEX.get(p); proj = chat_project(e)
+        if proj and proj not in kept: kept[proj] = e.active or e.mtime; keep = True
         os.remove(p); INDEX.forget(p)
         side = p[:-6]  # sibling folder with this chat's tool output / subagents
         if os.path.isdir(side):
             subprocess.run(["rm", "-rf", "--", side])
         done.append(sid)
+    if keep: _set_added(kept)
     return {"deleted": done, "refused": refused}
 
 def _demo_rename(sid, title):
@@ -239,7 +260,9 @@ def compact(sid):
 
 def stop(sid):
     if config.DEMO: return DEMO_OFF
-    a = agents(fresh=True).get(sid)
+    act = agents_checked()
+    if act is None: return {"ok": False, "error": NO_CHECK}
+    a = act.get(sid)
     if not a or not a.get("pid"): return {"ok": False, "error": "not running"}
     pid = int(a["pid"])
     cmd = subprocess.run(["ps", "-o", "command=", "-p", str(pid)], capture_output=True, text=True).stdout
@@ -260,11 +283,47 @@ def open_chat(sid, view=False):
     if terminals.launch(cwd, inner): return {"ok": True}
     return {"ok": False, "copy": manual(cwd, inner)}
 
+# Projects added by hand ({project: when added}), so a folder shows up before it has any chats.
+def added_projects():
+    return config.load().get("projects") or {}
+
+def _set_added(projects):
+    cfg = config.load(); cfg["projects"] = projects; config.save(cfg)
+
+def known_projects():
+    return ({chat_project(e) for _, e in INDEX.all().values()} | {project(a.get("cwd")) for a in agents().values()}
+            | set(added_projects()))
+
+def add_project(path):
+    """List a folder as a project. A folder inside a git repo adds the repo, like its chats would."""
+    path = str(path or "").strip()
+    if not path: return {"ok": False, "error": "type the folder's path"}
+    full = os.path.abspath(os.path.expanduser(path))
+    if not os.path.isdir(full): return {"ok": False, "error": f"there's no folder at {path}"}
+    proj = project(full)
+    if proj in known_projects(): return {"ok": True, "project": proj, "already": True}
+    _set_added(dict(added_projects(), **{proj: time.time()}))
+    return {"ok": True, "project": proj}
+
+def delete_project(proj):
+    """Take a project off the list: delete its saved chats and forget it was added. Its folder is never touched.
+    Refused while any of its chats are running, so nothing is half-deleted."""
+    act = agents_checked()
+    if act is None: return {"ok": False, "error": NO_CHECK}
+    chats = INDEX.all()
+    if any((chat_project(chats[sid][1], a.get("cwd")) if sid in chats else project(a.get("cwd"))) == proj for sid, a in act.items()):
+        return {"ok": False, "error": "it has running chats - stop them first"}
+    sids = [sid for sid, (_, e) in chats.items() if chat_project(e) == proj]
+    added = added_projects()
+    if not sids and proj not in added: return {"ok": False, "error": "unknown project"}
+    r = delete(sids); added = added_projects()   # re-read: delete() keeps the emptied project listed
+    if proj in added: del added[proj]; _set_added(added)
+    return {"ok": True, "deleted": len(r["deleted"])}
+
 def new_chat(proj):
     """Start a new Claude Code chat in a project folder. Only folders chatdeck lists as projects are allowed."""
     if config.DEMO: return DEMO_OFF
-    known = {chat_project(e) for _, e in INDEX.all().values()} | {project(a.get("cwd")) for a in agents().values()}
-    if proj not in known: return {"ok": False, "error": "unknown project"}
+    if proj not in known_projects(): return {"ok": False, "error": "unknown project"}
     cwd = os.path.join(HOME, proj[2:]) if proj.startswith("~/") else HOME if proj == "~" else proj
     if not os.path.isdir(cwd): return {"ok": False, "error": f"{proj} doesn't exist any more"}
     if terminals.launch(cwd, "claude"): return {"ok": True}
@@ -328,18 +387,40 @@ class H(BaseHTTPRequestHandler):
         if self.path == "/api/compact": return self.send(200, compact(body.get("sid", "")))
         if self.path == "/api/open": return self.send(200, open_chat(body.get("sid", ""), body.get("view", False)))
         if self.path == "/api/new": return self.send(200, new_chat(body.get("project", "")))
+        if self.path == "/api/project/add": return self.send(200, add_project(body.get("path", "")))
+        if self.path == "/api/project/delete": return self.send(200, delete_project(body.get("project", "")))
         if self.path == "/api/open-running": return self.send(200, open_running(body.get("sid", "")))
         self.send(404, {"error": "not found"})
 
+CODE = os.path.dirname(os.path.abspath(__file__))
+def _code_stamp():
+    """When chatdeck's Python files last changed. The page is read from disk on every request, so only these go stale."""
+    return max((os.path.getmtime(p) for p in glob.glob(os.path.join(CODE, "*.py"))), default=0)
+
+def _watch_code(httpd, restart):
+    """Stop the server once its code changes (a git pull or reinstall), so serve() can start the new code.
+    Waits until the files stop changing, so it never starts on a half-finished pull."""
+    start = seen = _code_stamp()
+    while True:
+        time.sleep(2); now = _code_stamp()
+        if now != start and now == seen: restart.set(); httpd.shutdown(); return
+        seen = now
+
 def serve(port):
-    """Run the dashboard until stopped. Raises OSError if the port is taken."""
+    """Run the dashboard until stopped. Raises OSError if the port is taken. Restarts itself when its code changes."""
     httpd = ThreadingHTTPServer(("127.0.0.1", port), H)
     os.makedirs(DATA, exist_ok=True)
     pidfile = os.path.join(DATA, "server.pid")
     with open(pidfile, "w") as f: f.write(str(os.getpid()))
     threading.Thread(target=_agents_loop, daemon=True).start()
+    restart = threading.Event()
+    threading.Thread(target=_watch_code, args=(httpd, restart), daemon=True).start()
     try:
         httpd.serve_forever()
     finally:
-        try: os.remove(pidfile)
-        except OSError: pass
+        httpd.server_close()
+        if not restart.is_set():
+            try: os.remove(pidfile)
+            except OSError: pass
+    # same pid, so server.pid and the desktop bubble stay valid; the open page reloads when its old token is refused
+    os.execv(sys.executable, [sys.executable, "-m", "chatdeck", "serve", "--port", str(port)])

{chatdeck-0.1.1 → chatdeck-0.2.1}/src/chatdeck/static/index.html

@@ -46,7 +46,11 @@ mark{background:var(--mark);color:inherit;border-radius:2px;padding:0 1px}
 .phead{display:flex;align-items:baseline;gap:8px;padding:9px 11px;cursor:pointer;user-select:none}.phead:hover{background:var(--panel2)}
 .phead .pn{font-weight:650;font-size:14px;white-space:nowrap}.phead .pp{color:var(--dim);font-size:11.5px;flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 .phead .pc{font-size:11.5px;color:var(--dim);white-space:nowrap}.phead .pc .r{color:var(--green);font-weight:600}.phead .pc .w{color:var(--amber);font-weight:600}
-.phead{flex-wrap:wrap}.phead .btn{align-self:center;margin-left:auto}
+.phead{flex-wrap:wrap}.phead .acts{align-self:center;margin-left:auto;display:flex;gap:6px}
+.addp{background:var(--panel);border:1px solid var(--line2);border-radius:10px;padding:10px 11px;margin-bottom:9px}.addp[hidden]{display:none}
+.addp .row input{flex:1;min-width:120px;background:var(--input);border:1px solid var(--line);color:var(--text);border-radius:6px;padding:4px 8px;font-size:12px;font-family:inherit}
+.addp .meta{white-space:normal;margin-top:6px}.addp .err{color:var(--red)}
+.psec.dragging{opacity:.45}.psec.dropBefore{box-shadow:0 -3px 0 var(--green)}.psec.dropAfter{box-shadow:0 3px 0 var(--green)}
 .caret{display:inline-block;transition:transform .15s;color:var(--dim);width:10px}.psec.closed .caret{transform:rotate(-90deg)}
 .pbody{padding:2px 10px 6px;border-top:1px solid var(--line)}.psec.closed .pbody{display:none}.pbody .card{background:var(--panel2);margin-top:7px}.pbody .card.waiting{background:linear-gradient(var(--amberbg),var(--amberbg)),var(--panel2)}
 .pbody .saved:last-child{border-bottom:0}
@@ -91,11 +95,14 @@ details.r pre{background:var(--code);border-radius:6px;padding:6px 8px;overflow:
 <div class="stats"><span id="nWait"></span><b id="nRun">–</b> running · <b id="nSaved">–</b> saved (<b id="disk">–</b>) · open chats hold <b id="tok">–</b> tokens</div></header>
 <div id="off">Dashboard server not reachable – retrying…</div>
 <main><h2>Usage</h2><div id="usage"></div>
-<div class="chatsHead"><h2 style="margin:0;flex:1">Chats</h2><div class="seg" title="How to list chats"><button data-mode="list">Running &amp; saved</button><button data-mode="project">By project</button></div></div>
+<div class="chatsHead"><h2 style="margin:0;flex:1">Chats</h2><button class="btn" id="porderReset" title="Go back to the automatic order: projects with running chats first, then the most recently used">Reset order</button><button class="btn" id="addBtn" title="List a folder as a project, so you can start chats in it">+ Add project</button><div class="seg" title="How to list chats"><button data-mode="list">Running &amp; saved</button><button data-mode="project">By project</button></div></div>
 <div class="tool"><input type="search" id="q" placeholder="Search names and messages  ( / )"></div>
 <div class="tool"><select class="btn" id="sort" title="Sort saved chats"><option value="recent">Recent</option><option value="size">Largest</option><option value="cost">Most expensive</option><option value="msgs">Most messages</option></select>
  <span style="flex:1"></span><select class="btn danger" id="cleanup" title="Delete old or empty chats"></select>
  <button class="btn danger" id="delSel" style="display:none">Delete selected</button></div>
+<div class="addp" id="addProj" hidden><div class="row"><input id="apPath" placeholder="Folder path, e.g. ~/code/my-app" spellcheck="false" autocomplete="off">
+ <button class="btn" id="apOk">Add</button><button class="btn" id="apCancel">Cancel</button></div>
+ <div class="meta" id="apMsg">A folder inside a git repo adds the whole repo.</div></div>
 <div id="list"></div></main>
 <div id="viewer"><header><div class="top"><button class="btn" id="vBack" title="Back (Esc)">←</button><span id="vTitle"></span>
   <button class="btn" id="vRen" title="Give this chat a name you'll recognise (e)">Rename</button></div>
@@ -109,7 +116,7 @@ details.r pre{background:var(--code);border-radius:6px;padding:6px 8px;overflow:
 <div id="toast"></div>
 <script>
 const TOKEN="__TOKEN__";if(new URLSearchParams(location.search).has("popup"))document.title="chatdeck\u200b";  // reads "chatdeck"; the zero-width space lets the desktop bubble tell its pop-up from the full window
-const $=id=>document.getElementById(id);let S=[],sel=new Set(),now=Date.now()/1000,hits={},cur=null,V=null,first=true,waitSeen=new Set();
+const $=id=>document.getElementById(id);let S=[],P={},sel=new Set(),now=Date.now()/1000,hits={},cur=null,V=null,first=true,waitSeen=new Set();
 const store={get(k,d){try{return localStorage.getItem(k)??d}catch{return d}},set(k,v){try{localStorage.setItem(k,v)}catch{}}};
 const esc=s=>String(s??"").replace(/[&<>"']/g,c=>({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"}[c]));
 const ago=t=>{const s=now-t;return s<60?"just now":s<3600?Math.round(s/60)+" min ago":s<86400?Math.round(s/3600)+" h ago":Math.round(s/86400)+" d ago"};
@@ -159,7 +166,7 @@ function renderUsage(U){if(!U)return;const t=U.today,w=U.week_tot,fresh=a=>a[0]+
   else lim=`<div class="meta" style="margin-bottom:8px;white-space:normal">Plan limits appear here once a Claude session updates its status line (needs the status-line hook – see README).</div>`;
   $("usage").innerHTML=`<div class="ugrid"><div class="tile"><div class="v">${k(fresh(t))}</div><div class="l">tokens today</div></div>
    <div class="tile"><div class="v">${k(fresh(w))}</div><div class="l">last 7 days</div></div>
-   <div class="tile"><div class="v">${U.cost_24h?("$"+U.cost_24h.toFixed(2)):"–"}</div><div class="l">API-equivalent cost (24h)</div></div></div>
+   <div class="tile"><div class="v">${U.cost_24h?("$"+U.cost_24h.toFixed(2)):"–"}</div><div class="l">total cost of chats active in 24h</div></div></div>
    ${lim}<div class="chart">${U.week.map((x,i)=>`<div class="${i===6?"today":""}" style="height:${Math.round(x[1]/max*100)}%" title="${k(x[1])} tokens"><span>${dn(x[0])}</span></div>`).join("")}</div>
    <div class="proj">Top this week: ${U.by_project.map(([p,n])=>`<b>${esc(p)}</b> ${k(n)}`).join(" · ")||"–"}</div>`}
 
@@ -168,19 +175,23 @@ const mode=()=>store.get("mode","list")==="project"?"project":"list";
 const pkey=x=>x.project||x.cwd||"(no folder)";
 const pname=k=>k==="~"?"Home folder":k.split("/").filter(Boolean).pop()||k;
 let collapsed=new Set();try{collapsed=new Set(JSON.parse(store.get("collapsed","[]")))}catch{}
+let porder=[];try{porder=JSON.parse(store.get("porder","[]"))}catch{}  // project keys in the order you dragged them into
 function savedFiltered(){const ws=words();let L=S.filter(x=>!x.status);
   if(ws.length)L=L.filter(x=>hits[x.sid]!==undefined||ws.every(w=>(x.name+" "+x.cwd).toLowerCase().includes(w)));
-  const by={recent:x=>-x.mtime,size:x=>-x.size,cost:x=>-x.cost,msgs:x=>-x.msgs}[$("sort").value];return L.sort((a,b)=>by(a)-by(b))}
+  const by={recent:x=>-x.active,size:x=>-x.size,cost:x=>-x.cost,msgs:x=>-x.msgs}[$("sort").value];return L.sort((a,b)=>by(a)-by(b))}
 /* orders stay put between refreshes (start time, not last activity) so nothing jumps while you aim at it */
 const running=()=>S.filter(x=>x.status).sort((a,b)=>!!b.waiting-!!a.waiting||(b.started||0)-(a.started||0));
 /* one entry per project: its running chats, its saved chats (after search and sort), and totals */
 function groups(){const m=new Map(),get=k=>m.get(k)||(m.set(k,{key:k,run:[],saved:[],all:[],last:0}),m.get(k));
-  for(const x of S){const g=get(pkey(x));g.last=Math.max(g.last,x.mtime);if(x.status)g.run.push(x);else g.all.push(x)}
+  for(const [key,at] of Object.entries(P))get(key).added=at;  // added by hand: listed even with no chats
+  for(const x of S){const g=get(pkey(x));g.last=Math.max(g.last,x.active);if(x.status)g.run.push(x);else g.all.push(x)}
   for(const x of savedFiltered())get(pkey(x)).saved.push(x);
-  for(const g of m.values())g.run.sort((a,b)=>b.mtime-a.mtime);  // the chat you last talked to on top
+  for(const g of m.values())g.run.sort((a,b)=>b.active-a.active);  // the chat you last talked to on top
   let G=[...m.values()];if(words().length)G=G.filter(g=>g.saved.length);
-  for(const g of m.values())g.lastSaved=Math.max(0,...g.all.map(x=>x.mtime));
-  return G.sort((a,b)=>!a.run.length-!b.run.length||(a.run.length?pname(a.key).localeCompare(pname(b.key)):b.lastSaved-a.lastSaved))}
+  for(const g of m.values())g.lastSaved=Math.max(g.added||0,...g.all.map(x=>x.active));
+  G.sort((a,b)=>!a.run.length-!b.run.length||(a.run.length?pname(a.key).localeCompare(pname(b.key)):b.lastSaved-a.lastSaved));
+  if(porder.length){const at=k=>porder.indexOf(k);G=G.map((g,i)=>[g,i]).sort(([a,i],[b,j])=>(at(a.key)-at(b.key))||i-j).map(([g])=>g)}  // projects new since you arranged them go on top
+  return G}
 /* saved chats in the order they're on screen, for j/k */
 function visibleSaved(){return mode()==="list"?savedFiltered():groups().filter(g=>!collapsed.has(g.key)).flatMap(g=>g.saved)}
 const where=(x,inProject)=>inProject?(x.cwd&&x.cwd!==x.project?esc(x.cwd)+" · ":""):esc(x.cwd||"–")+" · ";
@@ -191,16 +202,17 @@ function runCard(x,inProject){return `<div class="card${x.waiting?" waiting":""}
    <div class="row" style="margin-top:3px"><span class="meta" style="flex:1;margin:0"><b class="${cls(x.ctx)}">${k(x.ctx)} tokens</b>${x.ctx>=400e3?' · <span class="bad">expensive – every message re-sends all of this</span>':x.ctx>=150e3?' · getting big':''}</span>
    ${x.ctx>=150e3?`<button class="btn ${x.ctx>=400e3?"danger":""}" data-compact="${x.sid}" title="Run /compact in the chat: Claude summarises the conversation so far, so each message costs less">Compact</button>`:""}</div></div>`}
 function savedRow(x,inProject){const snip=hits[x.sid];return `<div class="saved${cur===x.sid?" cur":""}" data-row="${x.sid}"><input type="checkbox" data-sel="${x.sid}" ${sel.has(x.sid)?"checked":""}>
-   <div class="txt" data-view="${x.sid}"><div class="name" title="${esc(x.name)}">${hl(x.name)}</div><div class="meta">${where(x,inProject)}${x.msgs} msgs · ${mb(x.size)}${x.cost?" · "+usd(x.cost):""} · ${ago(x.mtime)}</div>
+   <div class="txt" data-view="${x.sid}"><div class="name" title="${esc(x.name)}">${hl(x.name)}</div><div class="meta">${where(x,inProject)}${x.msgs} msgs · ${mb(x.size)}${x.cost?" · "+usd(x.cost):""} · ${ago(x.active)}</div>
    ${snip?`<div class="snip">${hl(snip)}</div>`:""}</div>
    <button class="btn" data-ren="${x.sid}" title="Give this chat a name you'll recognise (e)">Rename</button><button class="btn" data-open="${x.sid}">Resume</button><button class="btn danger" data-del="${x.sid}">Delete</button></div>`}
-function cleanupSets(){const s=S.filter(x=>!x.status),old=d=>s.filter(x=>now-x.mtime>d*86400);
+function cleanupSets(){const s=S.filter(x=>!x.status),old=d=>s.filter(x=>now-x.active>d*86400);
   return [["empty","Empty chats",s.filter(x=>!x.msgs)],["7","Older than 7 days",old(7)],["30","Older than 30 days",old(30)],["90","Older than 90 days",old(90)]]}
 function render(){
   const run=running(),all=S.filter(x=>!x.status),nw=run.filter(x=>x.waiting).length,M=mode();
   $("nWait").innerHTML=nw?`<span class="w">${nw} waiting for you</span> · `:"";
   $("nRun").textContent=run.length;$("nSaved").textContent=all.length;$("disk").textContent=mb(all.reduce((a,x)=>a+x.size,0));$("tok").textContent=k(run.reduce((a,x)=>a+x.ctx,0));
   document.querySelectorAll(".seg button").forEach(b=>b.classList.toggle("on",b.dataset.mode===M));
+  $("addBtn").style.display=M==="project"?"":"none";$("porderReset").style.display=M==="project"&&porder.length?"":"none";if(M!=="project")$("addProj").hidden=true;
   const cs=cleanupSets();$("cleanup").innerHTML=`<option value="">Clean up…</option>`+cs.map(([v,l,L])=>`<option value="${v}" ${L.length?"":"disabled"}>${l} (${L.length}${L.length?", "+mb(L.reduce((a,x)=>a+x.size,0)):""})</option>`).join("");
   for(const s of [...sel]) if(!all.some(x=>x.sid===s)) sel.delete(s);
   if(cur&&!visibleSaved().some(x=>x.sid===cur))cur=null;
@@ -211,10 +223,11 @@ function render(){
     html=`<div class="sub">Running now</div>`+(run.length?run.map(x=>runCard(x,false)).join(""):'<div class="empty">No Claude sessions running.</div>')
      +`<div class="sub">Saved</div>`+(saved.length?saved.map(x=>savedRow(x,false)).join(""):q?noMatch:'<div class="empty">No saved chats.</div>')}
   else{const G=groups();html=G.length?G.map(g=>{const w=g.run.filter(x=>x.waiting).length,closed=collapsed.has(g.key);
-      return `<div class="psec${closed?" closed":""}"><div class="phead" data-ptoggle="${esc(g.key)}" title="${closed?"Show":"Hide"} this project's chats">
+      const real=g.key.startsWith("/")||g.key.startsWith("~");
+      return `<div class="psec${closed?" closed":""}" data-pkey="${esc(g.key)}"><div class="phead" data-ptoggle="${esc(g.key)}" draggable="true" title="${closed?"Show":"Hide"} this project's chats · drag to move it">
        <span class="caret">▾</span><span class="pn">${esc(pname(g.key))}</span><span class="pp">${esc(g.key)}</span>
-       <span class="pc">${w?`<span class="w">${w} waiting</span> · `:""}${g.run.length?`<span class="r">${g.run.length} running</span> · `:""}${g.all.length} saved${g.all.length?" · "+mb(g.all.reduce((a,x)=>a+x.size,0)):""}</span>${g.key.startsWith("/")||g.key.startsWith("~")?`<button class="btn" data-newchat="${esc(g.key)}" title="Start a new Claude Code chat in ${esc(g.key)}">+ New chat</button>`:""}</div>
-       <div class="pbody">${g.run.map(x=>runCard(x,true)).join("")}${g.saved.map(x=>savedRow(x,true)).join("")}${!g.run.length&&!g.saved.length?'<div class="empty">No chats.</div>':""}</div></div>`}).join(""):noMatch}
+       <span class="pc">${w?`<span class="w">${w} waiting</span> · `:""}${g.run.length?`<span class="r">${g.run.length} running</span> · `:""}${g.all.length?`${g.all.length} saved · ${mb(g.all.reduce((a,x)=>a+x.size,0))}`:g.run.length?"0 saved":"no chats yet"}</span>${real?`<span class="acts"><button class="btn" data-newchat="${esc(g.key)}" title="Start a new Claude Code chat in ${esc(g.key)}">+ New chat</button><button class="btn danger" data-pdel="${esc(g.key)}" title="Take this project off the list and delete its saved chats. The folder itself isn't touched">Delete project</button></span>`:""}</div>
+       <div class="pbody">${g.run.map(x=>runCard(x,true)).join("")}${g.saved.map(x=>savedRow(x,true)).join("")}${!g.run.length&&!g.saved.length?`<div class="empty">${g.all.length?"No chats.":real?"No chats yet – start one with + New chat.":"No chats."}</div>`:""}</div></div>`}).join(""):noMatch}
   $("list").innerHTML=html;
 }
 let lastSig="",lastDraw=0,pressing=false,hovering=false,heldSince=0,held=null;
@@ -225,11 +238,11 @@ document.addEventListener("mouseover",e=>{hovering=!!e.target.closest(HOT);if(!h
 document.documentElement.addEventListener("mouseleave",()=>{hovering=false;flush()});
 /* a redraw that arrived while the mouse was on a control; drawn when it moves off, or after 8s at most */
 function flush(){if(held&&!pressing){const d=held;held=null;draw(d)}}
-function draw(d){S=d.chats;now=d.now;lastDraw=Date.now();render();renderUsage(d.usage)}
+function draw(d){S=d.chats;P=d.projects||{};now=d.now;lastDraw=Date.now();render();renderUsage(d.usage)}
 let inflight=false;
 async function refresh(force){if(inflight&&!force)return;inflight=true;try{const d=await getJ("/api/state");$("off").style.display="none";
   const ws=new Set(d.chats.filter(x=>x.waiting).map(x=>x.sid));if(!first&&[...ws].some(s=>!waitSeen.has(s)))beep();waitSeen=ws;first=false;
-  const sig=JSON.stringify([d.chats.map(x=>[x.sid,x.name,x.status,x.ctx,x.msgs,x.size,x.cost,x.waiting]),d.usage]);
+  const sig=JSON.stringify([d.chats.map(x=>[x.sid,x.name,x.status,x.ctx,x.msgs,x.size,x.cost,x.waiting,x.active]),d.projects,d.usage]);
   const stale=Date.now()-lastDraw>60000;  // refresh the "x min ago" labels once a minute
   if(force||sig!==lastSig||stale){lastSig=sig;
     if(!force&&(editing||(pressing||hovering)&&(!held||Date.now()-heldSince<8000))){if(!held)heldSince=Date.now();held=d}else{held=null;draw(d)}}
@@ -242,9 +255,25 @@ function onSearch(){render();clearTimeout(searchT);const q=$("q").value.trim();i
 
 /* actions */
 async function del(sids){if(!sids.length)return false;if(!confirm(`Delete ${sids.length} saved chat${sids.length>1?"s":""} permanently?`))return false;
-  const r=await getJ("/api/delete",{sids});sids.forEach(s=>sel.delete(s));toast(`Deleted ${r.deleted.length}`+(r.refused.length?` · ${r.refused.length} skipped (running)`:""));refresh(true);return true}
+  const r=await getJ("/api/delete",{sids});if(r.error){toast("Couldn't delete: "+r.error,4000);return false}sids.forEach(s=>sel.delete(s));toast(`Deleted ${r.deleted.length}`+(r.refused.length?` · ${r.refused.length} skipped (running)`:""));refresh(true);return true}
 /* when no terminal could be opened, hand over the command to paste instead */
 async function opened(r,msg){if(r.ok)return toast(msg);if(r.copy){try{await navigator.clipboard.writeText(r.copy);toast("Couldn't open a terminal – command copied, paste it into one")}catch{prompt("Run this in a terminal:",r.copy)}}else toast("Couldn't open: "+(r.error||"unknown error"))}
+/* projects: add a folder by its path; delete takes the project off the list along with its saved chats */
+function showAdd(on){$("addProj").hidden=!on;$("apMsg").className="meta";$("apMsg").textContent="A folder inside a git repo adds the whole repo.";
+  if(on){$("apPath").value="";$("apPath").focus()}}
+function showProject(key){collapsed.delete(key);store.set("collapsed",JSON.stringify([...collapsed]));render();
+  const el=[...document.querySelectorAll("[data-pkey]")].find(e=>e.dataset.pkey===key);if(el)el.scrollIntoView({block:"nearest"})}
+async function addProject(){const path=$("apPath").value.trim();if(!path)return $("apPath").focus();
+  const r=await getJ("/api/project/add",{path});
+  if(!r.ok){$("apMsg").className="meta err";$("apMsg").textContent="Couldn't add it: "+r.error;return $("apPath").focus()}
+  showAdd(false);toast(r.already?`${pname(r.project)} is already listed`:`Added ${pname(r.project)}`);
+  await refresh(true);showProject(r.project)}
+async function deleteProject(key){const g=groups().find(x=>x.key===key)||{run:[],all:[]},n=g.all.length,name=pname(key);
+  if(g.run.length)return toast(`${name} has ${g.run.length} running chat${g.run.length>1?"s":""} – stop ${g.run.length>1?"them":"it"} first`,4000);
+  if(!confirm(n?`Delete the project "${name}"?\n\nThis permanently deletes its ${n} saved chat${n>1?"s":""} (${mb(g.all.reduce((a,x)=>a+x.size,0))}).\n\nThe folder ${key} and your files in it are not touched.`
+    :`Remove "${name}" from the list?\n\nThe folder ${key} isn't touched.`))return;
+  const r=await getJ("/api/project/delete",{project:key});
+  toast(r.ok?(r.deleted?`Deleted ${name} and its ${r.deleted} chat${r.deleted>1?"s":""}`:`Removed ${name}`):"Couldn't delete: "+r.error,4000);refresh(true)}
 async function resume(sid){await opened(await getJ("/api/open",{sid}),"Opening in a new terminal tab…")}
 
 /* viewer */
@@ -290,6 +319,11 @@ document.addEventListener("click",async e=>{if(e.target.classList.contains("ren"
   else if(d.orun){toast("Finding its terminal…",15000);const r=await getJ("/api/open-running",{sid:d.orun});await opened(r,"Opened – "+r.how)}
   else if(d.mode){store.set("mode",d.mode);cur=null;render()}
   else if(d.newchat){toast("Opening a new chat…",15000);await opened(await getJ("/api/new",{project:d.newchat}),"New chat opened in "+pname(d.newchat))}
+  else if(d.pdel){await deleteProject(d.pdel)}
+  else if(t.id==="addBtn"){showAdd($("addProj").hidden)}
+  else if(t.id==="porderReset"){porder=[];store.set("porder","[]");render();toast("Projects back in the automatic order")}
+  else if(t.id==="apOk"){await addProject()}
+  else if(t.id==="apCancel"){showAdd(false)}
   else if(t.closest("[data-ptoggle]")){const g=t.closest("[data-ptoggle]").dataset.ptoggle;collapsed.has(g)?collapsed.delete(g):collapsed.add(g);store.set("collapsed",JSON.stringify([...collapsed]));render()}
   else if(d.open){await resume(d.open)}
   else if(d.del){await del([d.del])}
@@ -337,6 +371,19 @@ document.addEventListener("keydown",async e=>{const typing=/INPUT|SELECT|TEXTARE
   else return;
   render();const r=document.querySelector(`[data-row="${cur}"]`);if(r)r.scrollIntoView({block:"nearest"})}catch(err){toast("Something went wrong: "+err.message)}});
 $("q").addEventListener("input",onSearch);
+/* dragging a project's header moves the project; refreshes wait until it's dropped (see pressing) */
+let dragKey=null;const psecs=()=>[...document.querySelectorAll(".psec")],clearDrop=()=>psecs().forEach(e=>e.classList.remove("dropBefore","dropAfter"));
+const below=(el,e)=>{const r=el.getBoundingClientRect();return e.clientY>r.top+r.height/2};
+$("list").addEventListener("dragstart",e=>{const h=e.target.closest&&e.target.closest(".phead");if(!h)return;dragKey=h.dataset.ptoggle;pressing=true;
+  e.dataTransfer.effectAllowed="move";e.dataTransfer.setData("text/plain",pname(dragKey));h.parentElement.classList.add("dragging")});
+$("list").addEventListener("dragover",e=>{const el=dragKey&&e.target.closest(".psec");if(!el)return;e.preventDefault();clearDrop();
+  if(el.dataset.pkey!==dragKey)el.classList.add(below(el,e)?"dropAfter":"dropBefore")});
+$("list").addEventListener("drop",e=>{const el=dragKey&&e.target.closest(".psec");if(!el)return;e.preventDefault();
+  const keys=groups().map(g=>g.key).filter(k=>k!==dragKey),i=keys.indexOf(el.dataset.pkey);
+  if(i>=0){keys.splice(below(el,e)?i+1:i,0,dragKey);porder=[...keys,...porder.filter(k=>!keys.includes(k))];store.set("porder",JSON.stringify(porder))}
+  dragKey=null;render()});
+$("list").addEventListener("dragend",()=>{dragKey=null;clearDrop();psecs().forEach(e=>e.classList.remove("dragging"));pressing=false;flush()});
+$("apPath").addEventListener("keydown",e=>{e.stopPropagation();if(e.key==="Enter")addProject().catch(err=>toast("Something went wrong: "+err.message));if(e.key==="Escape")showAdd(false)});
 $("sort").value=store.get("sort","recent");applyTheme();applySound();
 refresh(true);setInterval(refresh,4000);
 </script></body></html>

{chatdeck-0.1.1 → chatdeck-0.2.1}/src/chatdeck/transcripts.py

@@ -2,7 +2,7 @@
 
 The index reads each file incrementally: it remembers how far it got and only parses
 lines appended since, so a 30 MB chat that grows by one message costs one message."""
-import json, os, re, threading
+import datetime, json, os, re, threading
 
 UUID = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$")
 TAG = re.compile(r"<(system-reminder|local-command-[a-z]+|command-[a-z]+)>.*?</\1>", re.S)
@@ -19,6 +19,11 @@ def _user_text(c):
     return None
 
 
+def _secs(ts):
+    try: return datetime.datetime.fromisoformat(ts.replace("Z", "+00:00")).timestamp()
+    except (AttributeError, ValueError): return None
+
+
 def _assistant_text(c):
     if not isinstance(c, list): return ""
     return "\n".join(b.get("text", "") for b in c if isinstance(b, dict) and b.get("type") == "text").strip()
@@ -26,13 +31,14 @@ def _assistant_text(c):
 
 class Entry:
     __slots__ = ("ino", "offset", "size", "mtime", "custom", "ai", "summary", "first", "cwd", "ctx", "msgs",
-                 "days", "seen", "cost", "text", "text_lc", "cwds")
+                 "days", "seen", "cost", "text", "text_lc", "cwds", "active")
 
     def __init__(self, ino):
         self.ino = ino; self.offset = 0; self.size = 0; self.mtime = 0.0
         self.custom = self.ai = self.summary = self.first = self.cwd = None
         self.ctx = self.msgs = 0; self.days = {}; self.seen = set(); self.cost = 0.0
         self.text = []; self.text_lc = ""; self.cwds = {}   # folder -> lines written there, to tell where the chat mostly worked
+        self.active = None   # when the person last typed a message. Not mtime: idle chats keep appending bookkeeping lines
 
     @property
     def title(self):
@@ -54,6 +60,7 @@ class Entry:
             txt = _user_text(m.get("content"))
             if txt:
                 self.msgs += 1; self.first = self.first or txt.replace("\n", " ")[:90]
+                self.active = _secs(d.get("timestamp")) or self.active
                 self._add_text(txt)
         elif t == "assistant":
             u = m.get("usage") or {}

{chatdeck-0.1.1 → chatdeck-0.2.1}/src/chatdeck/usage.py

@@ -19,8 +19,11 @@ class LimitHistory:
         self.path = path; self.keep = keep; self.samples = []; self.lock = threading.Lock()
         try:
             with open(path) as f:
-                self.samples = [json.loads(l) for l in f if l.strip()]
-        except (FileNotFoundError, ValueError):
+                for l in f:
+                    try: s = json.loads(l)
+                    except ValueError: continue
+                    if isinstance(s, dict) and all(k in s for k in "wtpr"): self.samples.append(s)
+        except OSError:
             pass
 
     def add(self, at, data):
@@ -58,12 +61,13 @@ class LimitHistory:
             s = [x for x in self.samples if x["w"] == key]
         if not s: return None
         cur = s[-1]
+        if now >= cur["r"]: return {"eta": None, "rate": None}   # that window has already reset
         win = [x for x in s if x["r"] == cur["r"] and x["t"] >= cur["t"] - lookback]
         if len(win) < 2 or cur["t"] - win[0]["t"] < 900: return {"eta": None, "rate": None}
         rate = (cur["p"] - win[0]["p"]) / (cur["t"] - win[0]["t"])   # % per second
         if rate <= 0: return {"eta": None, "rate": 0}
         eta = cur["t"] + (100 - cur["p"]) / rate
-        return {"eta": eta if eta < cur["r"] else None, "rate": round(rate * 3600, 1)}
+        return {"eta": eta if now <= eta < cur["r"] else None, "rate": round(rate * 3600, 1)}
 
 
 def summary(entries, status_dir, history, today=None, project=None):
@@ -84,7 +88,7 @@ def summary(entries, status_dir, history, today=None, project=None):
         try:
             with open(f) as fh: d = json.load(fh)
             at = os.path.getmtime(f)
-            if at > now - 86400: cost += float((d.get("cost") or {}).get("total_cost_usd") or 0)
+            if at > now - 86400: cost += float((d.get("cost") or {}).get("total_cost_usd") or 0)   # lifetime cost; status files keep no history
             if d.get("rate_limits"):
                 limits = {"data": d["rate_limits"], "at": at}
                 history.add(at, d["rate_limits"])

{chatdeck-0.1.1 → chatdeck-0.2.1/src/chatdeck.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatdeck
-Version: 0.1.1
+Version: 0.2.1
 Summary: A local dashboard for your Claude Code chats: what's running, what needs you, and what it costs.
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/Abdifatah09/chatdeck
@@ -37,7 +37,10 @@ Python 3.9+ standard library only, no dependencies.
 - **Cleanup** – delete empty chats or chats older than 7, 30 or 90 days. Shows disk usage.
   Running chats are never deleted.
 - **By project** view: one section per project (git repo, including its worktrees and subfolders)
-  with its running and saved chats, and a **New chat** button that starts Claude Code in that project. Sort by recent, size, cost or messages. Light and dark themes.
+  with its running and saved chats, and a **New chat** button that starts Claude Code in that project.
+  **Add project** lists a folder before it has any chats; **Delete project** deletes its saved chats
+  and takes it off the list (the folder itself is never touched). Drag a project's header to move it
+  (**Reset order** goes back to the automatic order). Sort by recent, size, cost or messages. Light and dark themes.
   Keyboard shortcuts: `/` search, `j`/`k` move, `Enter` read, `r` resume, `e` rename, `x` select, `Del` delete, `?` help.
 - **Windows corner button and tray icon** – pop the dashboard up from the corner of the screen.
 

{chatdeck-0.1.1 → chatdeck-0.2.1}/src/chatdeck.egg-info/SOURCES.txt

@@ -26,4 +26,7 @@ src/chatdeck/static/logo.svg
 src/chatdeck/windows/bubble.ps1
 src/chatdeck/windows/focus_wt.ps1
 src/chatdeck/windows/start.ps1
-tests/test_chatdeck.py
+tests/test_chatdeck.py
+tests/test_delete_safety.py
+tests/test_hook_quoting.py
+tests/test_usage_fixes.py

{chatdeck-0.1.1 → chatdeck-0.2.1}/tests/test_chatdeck.py

@@ -64,6 +64,15 @@ class IndexTest(Tmp):
         self.assertEqual(e.days["2026-10-20"], [100, 7, 50, 3])
         self.assertEqual(e.ctx, 153)
 
+    def test_active_is_when_you_last_typed_not_when_the_file_changed(self):
+        self.write(user("hello") + assistant([{"type": "text", "text": "hi"}], ts="2026-10-20T10:05:00Z"))
+        e = self.idx.get(self.path); typed = e.active
+        self.assertEqual(typed, 1792490400.0)
+        self.write(line(type="system", subtype="away_summary", isMeta=True, timestamp="2026-10-20T10:08:00Z")
+                   + line(type="artifact-autoreact-ledger", sessionId=SID)
+                   + line(type="user", message={"content": [{"type": "tool_result", "content": "ok"}]}, timestamp="2026-10-20T10:09:00Z"))
+        self.assertEqual(self.idx.get(self.path).active, typed)
+
     def test_search_needs_every_word(self):
         self.write(user("deploy is slow") + assistant([{"type": "text", "text": "The Docker build cache was cold."}]))
         self.assertIn(SID, self.idx.search("docker cold"))
@@ -112,11 +121,11 @@ class ForecastTest(unittest.TestCase):
         return h
 
     def test_eta_from_pace(self):
-        f = self.hist([(0, 10), (1800, 20)]).forecast("five_hour")   # 10% per 30 min
+        f = self.hist([(0, 10), (1800, 20)]).forecast("five_hour", T0 + 1800)   # 10% per 30 min
         self.assertEqual(f["rate"], 20.0); self.assertAlmostEqual(f["eta"], T0 + 1800 + 4 * 3600)
 
     def test_no_eta_when_reset_comes_first(self):
-        f = self.hist([(0, 10), (1800, 20)], reset=5000).forecast("five_hour")
+        f = self.hist([(0, 10), (1800, 20)], reset=5000).forecast("five_hour", T0 + 1800)
         self.assertIsNone(f["eta"]); self.assertGreater(f["rate"], 0)
 
     def test_needs_enough_history_and_ignores_old_window(self):
@@ -124,7 +133,7 @@ class ForecastTest(unittest.TestCase):
         h = self.hist([(0, 90)], reset=100)
         h.add(T0 + 1000, {"five_hour": {"used_percentage": 1, "resets_at": T0 + 20000}})
         h.add(T0 + 2000, {"five_hour": {"used_percentage": 1, "resets_at": T0 + 20000}})
-        self.assertEqual(h.forecast("five_hour")["rate"], 0)
+        self.assertEqual(h.forecast("five_hour", T0 + 2000)["rate"], 0)
 
     def test_history_survives_restart(self):
         h = self.hist([(0, 10), (1800, 20)])
@@ -303,6 +312,46 @@ class NewChatTest(Tmp):
             self.assertEqual(server.new_chat("/etc")["error"], "unknown project")
 
 
+class ProjectsTest(Tmp):
+    def test_added_folder_is_listed_and_can_start_chats(self):
+        from chatdeck import server
+        proj = tempfile.mkdtemp(); launched = []
+        with unittest.mock.patch.object(server, "INDEX", self.idx), unittest.mock.patch.object(server, "agents", lambda fresh=False: {}), \
+             unittest.mock.patch.object(server.terminals, "launch", lambda cwd, cmd: launched.append((cwd, cmd)) or True):
+            self.assertIn("no folder", server.add_project("/no/such/dir")["error"])
+            r = server.add_project(proj); key = r["project"]
+            self.assertTrue(r["ok"]); self.assertIn(key, server.state()["projects"])
+            self.assertTrue(server.add_project(proj)["already"])
+            self.assertTrue(server.new_chat(key)["ok"]); self.assertEqual(launched, [(proj, "claude")])
+            self.assertTrue(server.delete_project(key)["ok"])
+            self.assertNotIn(key, server.state()["projects"]); self.assertTrue(os.path.isdir(proj))   # folder kept
+
+    def test_delete_removes_its_chats_but_not_while_one_runs(self):
+        from chatdeck import server
+        proj = tempfile.mkdtemp(); running = {SID: {"cwd": proj}}
+        self.write(line(type="user", message={"role": "user", "content": "hi"}, cwd=proj))
+        with unittest.mock.patch.object(server, "INDEX", self.idx), unittest.mock.patch.object(server, "PROJECTS", self.dir), \
+             unittest.mock.patch.object(server, "agents", lambda fresh=False: running):
+            key = server.project(proj)
+            self.assertIn("running", server.delete_project(key)["error"]); self.assertTrue(os.path.exists(self.path))
+            running.clear()
+            self.assertEqual(server.delete_project(key), {"ok": True, "deleted": 1})
+            self.assertFalse(os.path.exists(self.path)); self.assertTrue(os.path.isdir(proj))
+            self.assertEqual(server.delete_project(key)["error"], "unknown project")
+
+    def test_deleting_every_chat_leaves_the_project_listed_empty(self):
+        from chatdeck import server
+        proj = tempfile.mkdtemp()
+        self.write(line(type="user", message={"role": "user", "content": "hi"}, cwd=proj))
+        with unittest.mock.patch.object(server, "INDEX", self.idx), unittest.mock.patch.object(server, "PROJECTS", self.dir), \
+             unittest.mock.patch.object(server, "agents", lambda fresh=False: {}):
+            key = server.project(proj)
+            self.assertEqual(server.delete([SID])["deleted"], [SID])
+            self.assertIn(key, server.state()["projects"])
+            self.assertEqual(server.delete_project(key), {"ok": True, "deleted": 0})
+            self.assertNotIn(key, server.state()["projects"])
+
+
 class WslLaunchTest(unittest.TestCase):
     def test_new_window_by_default_tabs_when_asked(self):
         from chatdeck import terminals

chatdeck-0.2.1/tests/test_delete_safety.py

@@ -0,0 +1,59 @@
+import json, os, subprocess, sys, tempfile, unittest, unittest.mock
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+os.environ["CHATDECK_DIR"] = tempfile.mkdtemp()   # never touch the real ~/.chatdeck
+from chatdeck import config, server
+
+SID = "11111111-2222-3333-4444-555555555555"
+RUNNING = json.dumps([{"sessionId": SID, "pid": 1}])
+
+
+def done(code, out=""): return subprocess.CompletedProcess([], code, out, "")
+
+
+class DeleteSafetyTest(unittest.TestCase):
+    def setUp(self):
+        self.dir = tempfile.mkdtemp(); os.makedirs(os.path.join(self.dir, "-w-proj"))
+        self.path = os.path.join(self.dir, "-w-proj", SID + ".jsonl")
+        with open(self.path, "w") as f: f.write("{}\n")
+        for k, v in [("PROJECTS", self.dir), ("INDEX", server.transcripts.Index(self.dir))]:
+            p = unittest.mock.patch.object(server, k, v); p.start(); self.addCleanup(p.stop)
+        p = unittest.mock.patch.object(config, "DEMO", False); p.start(); self.addCleanup(p.stop)
+        server._agents = (0.0, {})
+
+    def run_delete(self, **kw):
+        with unittest.mock.patch.object(server.subprocess, "run", **kw): return server.delete([SID])
+
+    def test_nonzero_exit_refuses(self):
+        r = self.run_delete(return_value=done(1))
+        self.assertEqual((r["deleted"], r["refused"]), ([], [SID])); self.assertIn("couldn't check", r["error"])
+        self.assertTrue(os.path.exists(self.path))
+
+    def test_empty_stdout_refuses(self):
+        r = self.run_delete(return_value=done(0, ""))
+        self.assertEqual(r["refused"], [SID]); self.assertTrue(os.path.exists(self.path))
+
+    def test_timeout_refuses(self):
+        r = self.run_delete(side_effect=subprocess.TimeoutExpired("claude", 30))
+        self.assertEqual(r["refused"], [SID]); self.assertTrue(os.path.exists(self.path))
+
+    def test_failure_keeps_last_good_cache(self):
+        self.run_delete(return_value=done(0, RUNNING)); self.run_delete(return_value=done(1))
+        self.assertIn(SID, server.agents())
+
+    def test_running_chat_refused(self):
+        r = self.run_delete(return_value=done(0, RUNNING))
+        self.assertEqual(r["refused"], [SID]); self.assertNotIn("error", r); self.assertTrue(os.path.exists(self.path))
+
+    def test_deleted_when_check_succeeds_and_not_running(self):
+        r = self.run_delete(return_value=done(0, "[]"))
+        self.assertEqual((r["deleted"], r["refused"]), ([SID], [])); self.assertFalse(os.path.exists(self.path))
+
+    def test_delete_project_and_stop_refuse_on_failed_check(self):
+        with unittest.mock.patch.object(server.subprocess, "run", return_value=done(1)):
+            self.assertFalse(server.delete_project("/w/proj")["ok"])
+            self.assertFalse(server.stop(SID)["ok"])
+        self.assertTrue(os.path.exists(self.path))
+
+
+if __name__ == "__main__": unittest.main()

chatdeck-0.2.1/tests/test_hook_quoting.py

@@ -0,0 +1,66 @@
+import json, os, shlex, sys, tempfile, unittest, unittest.mock
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+os.environ["CHATDECK_DIR"] = tempfile.mkdtemp()   # never touch the real ~/.chatdeck
+from chatdeck import config, hooks
+
+SPACED = "/Users/jo smith/.local/bin/chatdeck"
+
+
+class QuotingTest(unittest.TestCase):
+    def setUp(self):
+        self.path = os.path.join(tempfile.mkdtemp(), "settings.json")
+        config.save({})   # other tests may have left a wrapped status line behind
+
+    def write(self, d):
+        with open(self.path, "w") as f: json.dump(d, f)
+
+    def read(self):
+        with open(self.path) as f: return json.load(f)
+
+    def old_install(self):
+        old = SPACED + " hook"
+        self.write({"statusLine": {"type": "command", "command": old + " statusline"},
+                    "hooks": {"Notification": [{"matcher": hooks.WAITING_MATCHER,
+                                                "hooks": [{"type": "command", "command": old + " waiting"}]}]}})
+
+    def test_command_quotes_spaced_paths(self):
+        with unittest.mock.patch("shutil.which", return_value=SPACED):
+            self.assertEqual(shlex.split(hooks.command()), [SPACED])
+        with unittest.mock.patch("shutil.which", return_value=None), \
+             unittest.mock.patch.object(sys, "executable", "/opt/my py/python3"):
+            parts = shlex.split(hooks.command())
+        self.assertTrue(parts[0].startswith("PYTHONPATH="))
+        self.assertEqual(parts[1:], ["/opt/my py/python3", "-m", "chatdeck"])
+
+    def test_normal_path_unchanged(self):
+        with unittest.mock.patch("shutil.which", return_value="/usr/local/bin/chatdeck"):
+            self.assertEqual(hooks.command(), "/usr/local/bin/chatdeck")
+
+    def test_install_writes_quoted_commands_and_uninstall_removes(self):
+        with unittest.mock.patch("shutil.which", return_value=SPACED):
+            hooks.install(self.path)
+        s = self.read()
+        self.assertEqual(shlex.split(s["statusLine"]["command"]), [SPACED, "hook", "statusline"])
+        self.assertEqual(shlex.split(s["hooks"]["Notification"][0]["hooks"][0]["command"]), [SPACED, "hook", "waiting"])
+        hooks.uninstall(self.path)
+        self.assertEqual(self.read(), {})
+
+    def test_reinstall_over_old_unquoted_install(self):
+        self.old_install()
+        with unittest.mock.patch("shutil.which", return_value=SPACED):
+            hooks.install(self.path)
+        s = self.read()
+        self.assertEqual(shlex.split(s["statusLine"]["command"]), [SPACED, "hook", "statusline"])
+        self.assertEqual(len(s["hooks"]["Notification"]), 1)
+        self.assertEqual(len(s["hooks"]["Notification"][0]["hooks"]), 1)
+        self.assertNotIn("statusline_command", config.load())   # old install wasn't mistaken for the user's own
+
+    def test_uninstall_removes_old_unquoted_install(self):
+        self.old_install()
+        hooks.uninstall(self.path)
+        self.assertEqual(self.read(), {})
+
+
+if __name__ == "__main__":
+    unittest.main()

chatdeck-0.2.1/tests/test_usage_fixes.py

@@ -0,0 +1,46 @@
+import json, os, sys, tempfile, time, unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+os.environ["CHATDECK_DIR"] = tempfile.mkdtemp()   # never touch the real ~/.chatdeck
+from chatdeck import usage
+
+
+T = time.time() - 3600
+
+
+def sample(t, p, r=10000, w="five_hour"): return {"t": t, "w": w, "p": p, "r": r}
+
+
+class HistoryTest(unittest.TestCase):
+    def path(self, *lines):
+        p = os.path.join(tempfile.mkdtemp(), "h.jsonl")
+        with open(p, "w") as f: f.write("\n".join(lines) + "\n")
+        return p
+
+    def test_corrupt_and_malformed_lines_skipped(self):
+        good = [sample(T + 1, 5), sample(T + 2, 6)]
+        h = usage.LimitHistory(self.path(json.dumps(good[0]), '{"t": 3, "w": "five', '{"w": "five_hour"}', "[1]", json.dumps(good[1])))
+        self.assertEqual(h.samples, good)
+        h.add(T + 5, {"five_hour": {"used_percentage": 7, "resets_at": 10000}})   # no KeyError
+        self.assertEqual(len(h.samples), 3)
+
+    def test_stale_window_has_no_eta(self):
+        h = usage.LimitHistory(self.path()); h.samples = [sample(0, 10), sample(3600, 20)]
+        self.assertEqual(h.forecast("five_hour", now=5000)["rate"], 10.0)
+        self.assertEqual(h.forecast("five_hour", now=10000), {"eta": None, "rate": None})
+        self.assertIsNone(h.forecast("five_hour", now=9000)["eta"])   # eta (36000) is past the reset
+        h.samples = [sample(0, 10, 99999), sample(3600, 20, 99999)]
+        self.assertEqual(h.forecast("five_hour", now=3700)["eta"], 3600 + 80 * 360)
+        self.assertIsNone(h.forecast("five_hour", now=3600 + 80 * 360 + 1)["eta"])
+
+    def test_cost_counts_only_recent_status_files(self):
+        d = tempfile.mkdtemp()
+        for name, cost, age in (("a", 1.5, 100), ("b", 2.0, 3 * 86400)):
+            p = os.path.join(d, name + ".json")
+            with open(p, "w") as f: json.dump({"cost": {"total_cost_usd": cost}}, f)
+            os.utime(p, (time.time() - age,) * 2)
+        h = usage.LimitHistory(os.path.join(d, "h.jsonl"))
+        self.assertEqual(usage.summary([], d, h)["cost_24h"], 1.5)
+
+
+if __name__ == "__main__": unittest.main()