aboutsummaryrefslogtreecommitdiffstats
path: root/claude_logbook
diff options
context:
space:
mode:
Diffstat (limited to 'claude_logbook')
-rw-r--r--claude_logbook/__init__.py8
-rw-r--r--claude_logbook/__main__.py6
-rw-r--r--claude_logbook/cli.py455
-rw-r--r--claude_logbook/memory.py272
-rw-r--r--claude_logbook/sessions.py409
-rw-r--r--claude_logbook/template.html1394
-rw-r--r--claude_logbook/terminal.py372
-rw-r--r--claude_logbook/webpage.py74
8 files changed, 2990 insertions, 0 deletions
diff --git a/claude_logbook/__init__.py b/claude_logbook/__init__.py
new file mode 100644
index 0000000..fa839b1
--- /dev/null
+++ b/claude_logbook/__init__.py
@@ -0,0 +1,8 @@
+"""Explorador de las sesiones que Claude Code guarda en ~/.claude/projects/.
+
+Sin dependencias: solo la biblioteca estándar.
+"""
+
+__version__ = "1.0.0"
+
+__all__ = ["__version__"]
diff --git a/claude_logbook/__main__.py b/claude_logbook/__main__.py
new file mode 100644
index 0000000..dbdd066
--- /dev/null
+++ b/claude_logbook/__main__.py
@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/claude_logbook/cli.py b/claude_logbook/cli.py
new file mode 100644
index 0000000..6a465dd
--- /dev/null
+++ b/claude_logbook/cli.py
@@ -0,0 +1,455 @@
+"""Interfaz de línea de comandos."""
+
+import argparse
+import io
+import os
+import sys
+import textwrap
+import time
+import webbrowser
+
+from . import __version__
+from .sessions import (
+ SessionError, apply_filters, default_root, drop_from_cache, latest_activity,
+ load_sessions, pick, public_records, session_path,
+)
+from .terminal import (
+ Style, clip, fmt_date, fmt_size, plural, print_audit, print_chat,
+ print_memories, print_memory, print_table, resume_cmd,
+)
+from . import memory as mem
+from . import webpage
+
+DEFAULT_HTML = "sesiones.html"
+
+# Una sesión escrita hace menos de esto puede estar abierta en otra terminal.
+RECENT_SECONDS = 300
+
+EPILOG = """\
+ejemplos:
+ claude-logbook tabla de todas las sesiones
+ claude-logbook docker filtra por título, ruta o rama
+ claude-logbook -s 3 lee el chat nº 3 de la tabla
+ claude-logbook -s 5d10f1ee lo mismo, por prefijo de UUID
+ claude-logbook -g "port already" busca dentro de las conversaciones
+ claude-logbook -r 3 comando para reanudar la nº 3
+ eval "$(claude-logbook -r 3)" reanudarla directamente
+ claude-logbook --html --open genera sesiones.html y lo abre
+
+el nº es la posición en la tabla que estás viendo, así que si filtraste
+hay que repetir el filtro para leer esa fila:
+
+ claude-logbook docker muestra 3 resultados
+ claude-logbook docker -s 2 lee el 2º de esos tres
+
+borrado (irreversible; pregunta antes, salvo con -y):
+ claude-logbook --delete-empty --dry-run qué borraría
+ claude-logbook --delete-empty borra las vacías
+ claude-logbook -D 101 -D e0a4300e borra sesiones puntuales
+ claude-logbook -p /tmp --delete-empty solo las vacías de ese proyecto
+
+memoria de los proyectos (-m cambia de sesiones a memorias y reusa los mismos
+verbos: filtro, -s para leer, -D para borrar):
+ claude-logbook -m tabla de memorias
+ claude-logbook -m docker busca en nombre, descripción y cuerpo
+ claude-logbook -m -s 3 lee la memoria nº 3
+ claude-logbook -m -s deadlock lo mismo, por nombre
+ claude-logbook -m --check audita índices, enlaces y orígenes
+ claude-logbook -m -D 3 la borra y la saca de MEMORY.md
+"""
+
+
+def build_parser():
+ ap = argparse.ArgumentParser(
+ prog="claude-logbook",
+ description="Explorador de sesiones de Claude Code para la terminal.",
+ formatter_class=argparse.RawDescriptionHelpFormatter,
+ epilog=textwrap.dedent(EPILOG),
+ )
+ ap.add_argument("query", nargs="*", help="texto a buscar en título, ruta o rama")
+ ap.add_argument("-s", "--show", metavar="REF",
+ help="muestra el chat: índice de la tabla o prefijo de UUID")
+ ap.add_argument("-r", "--resume", metavar="REF",
+ help="imprime el comando para reanudar esa sesión")
+ ap.add_argument("-g", "--grep", metavar="TEXTO",
+ help="filtra por contenido de las conversaciones")
+ ap.add_argument("-p", "--project", metavar="RUTA",
+ help="filtra por ruta del proyecto")
+ ap.add_argument("-n", "--limit", type=int, metavar="N",
+ help="muestra solo las N más recientes")
+ ap.add_argument("-E", "--hide-empty", action="store_true",
+ help="oculta las sesiones sin mensajes")
+ ap.add_argument("--no-tools", action="store_true",
+ help="en el chat, oculta las llamadas a herramientas")
+ ap.add_argument("--no-pager", action="store_true",
+ help="no usa $PAGER para el chat")
+ ap.add_argument("--no-color", action="store_true", help="salida sin color")
+
+ recuerdos = ap.add_argument_group("memoria de los proyectos")
+ recuerdos.add_argument("-m", "--memory", action="store_true",
+ help="trabaja sobre las memorias en vez de las sesiones")
+ recuerdos.add_argument("--type", metavar="TIPO", choices=mem.TYPES,
+ help="filtra por tipo: " + " | ".join(mem.TYPES))
+ recuerdos.add_argument("--check", action="store_true",
+ help="audita índices, enlaces y sesiones de origen")
+
+ salida = ap.add_argument_group("exportar")
+ salida.add_argument("--json", action="store_true",
+ help="vuelca todas las sesiones en JSON")
+ salida.add_argument("--html", nargs="?", const=DEFAULT_HTML, metavar="ARCHIVO",
+ help=f"genera una página autocontenida (por defecto {DEFAULT_HTML})")
+ salida.add_argument("--template", metavar="ARCHIVO",
+ help="usa otro template para --html")
+ salida.add_argument("--open", action="store_true",
+ help="abre en el navegador lo que genere --html")
+
+ borrar = ap.add_argument_group("borrado")
+ borrar.add_argument("-D", "--delete", metavar="REF", nargs="+",
+ help="borra esas sesiones (índice o prefijo de UUID)")
+ borrar.add_argument("--delete-empty", action="store_true",
+ help="borra todas las sesiones sin mensajes")
+ borrar.add_argument("-y", "--yes", action="store_true",
+ help="no pregunta antes de borrar")
+ borrar.add_argument("--dry-run", action="store_true",
+ help="muestra qué se borraría y no toca nada")
+
+ ap.add_argument("--no-cache", action="store_true",
+ help="ignora el caché y re-parsea todo")
+ ap.add_argument("--version", action="version",
+ version=f"claude-logbook {__version__}")
+ return ap
+
+
+def filtered(sessions, args):
+ return apply_filters(
+ sessions,
+ project=args.project,
+ grep=args.grep,
+ query=" ".join(args.query) if args.query else None,
+ hide_empty=args.hide_empty,
+ )
+
+
+# ──────────────────────────────── borrado ────────────────────────────────
+
+def confirm(question):
+ """Pregunta s/N. Sin terminal no hay confirmación posible: devuelve False."""
+ try:
+ tty = open("/dev/tty")
+ except OSError:
+ return False
+ try:
+ sys.stderr.write(question)
+ sys.stderr.flush()
+ return tty.readline().strip().lower() in ("s", "si", "sí", "y", "yes")
+ except (OSError, KeyboardInterrupt):
+ return False
+ finally:
+ tty.close()
+
+
+def delete_sessions(targets, args, st):
+ """Borra las sesiones dadas. Devuelve el código de salida."""
+ if not targets:
+ print("No hay sesiones que borrar con ese criterio.", file=sys.stderr)
+ return 0
+
+ print(f"{st.bold}Se van a borrar "
+ f"{plural(len(targets), 'sesión', 'sesiones')}:{st.reset}\n")
+
+ total_kb = 0
+ recent = []
+ for s in targets:
+ path = session_path(s)
+ total_kb += s["k"]
+ title = s["t"] or "sesión abierta sin mensajes"
+ flag = ""
+ try:
+ if time.time() - os.stat(path).st_mtime < RECENT_SECONDS:
+ recent.append(s)
+ flag = f" {st.copper}← modificada hace menos de 5 min{st.reset}"
+ except OSError:
+ flag = f" {st.copper}← ya no existe{st.reset}"
+ print(f" {st.faint}{s['id'][:8]}{st.reset} {clip(title, 52):<52} "
+ f"{st.grey}{clip(s['p'], 34):<34}{st.reset} "
+ f"{fmt_date(s['l'])} {st.faint}{s['k']:>7.1f} KB{st.reset}{flag}")
+
+ print(f"\n{st.faint}{fmt_size(total_kb)} en total{st.reset}")
+
+ if recent:
+ verbo = "se escribió" if len(recent) == 1 else "se escribieron"
+ print(f"\n{st.copper}Ojo: {len(recent)} de estas {verbo} hace menos de "
+ f"5 minutos. Si es una sesión abierta ahora mismo, Claude Code la "
+ f"sigue usando y va a volver a escribirla al cerrarse.{st.reset}")
+
+ if args.dry_run:
+ print(f"\n{st.faint}--dry-run: no se tocó nada.{st.reset}")
+ return 0
+
+ if not args.yes:
+ print(f"\n{st.copper}Esto no se puede deshacer.{st.reset}")
+ if not confirm("¿Confirmás? [s/N] "):
+ print("Cancelado.", file=sys.stderr)
+ return 1
+
+ done, failed, paths = 0, 0, []
+ for s in targets:
+ path = session_path(s)
+ try:
+ os.remove(path)
+ paths.append(path)
+ done += 1
+ except OSError as e:
+ print(f"error: {s['id'][:8]}: {e}", file=sys.stderr)
+ failed += 1
+
+ drop_from_cache(paths)
+
+ print(f"\n{plural(done, 'sesión borrada', 'sesiones borradas')}.")
+ return 1 if failed else 0
+
+
+def delete_targets(pool, args):
+ """Las sesiones que pidió borrar, sin repetidas y en el orden pedido."""
+ targets, seen = [], set()
+
+ if args.delete_empty:
+ for s in pool:
+ if s["e"]:
+ targets.append(s)
+ seen.add(s["id"])
+
+ for ref in args.delete or []:
+ s = pick(pool, ref)
+ if s["id"] not in seen:
+ seen.add(s["id"])
+ targets.append(s)
+
+ return targets
+
+
+# ──────────────────────────────── comandos ────────────────────────────────
+
+def cmd_json(sessions):
+ import json
+ payload = webpage.build_payload(
+ public_records(sessions),
+ mem.public_records(mem.load_memories(sessions)))
+ json.dump(payload, sys.stdout, ensure_ascii=False, separators=(",", ":"))
+ sys.stdout.write("\n")
+ return 0
+
+
+def cmd_html(sessions, args):
+ out = args.html
+ memories = mem.public_records(mem.load_memories(sessions))
+ stats = webpage.write(public_records(sessions), out, memories=memories,
+ template=webpage.template_text(args.template))
+ print(f"{stats['sesiones']} sesiones · {stats['proyectos']} proyectos · "
+ f"{stats['mensajes']} mensajes · {stats['bloques']} bloques "
+ f"de transcripción · {stats['memorias']} memorias → {out}",
+ file=sys.stderr)
+ if args.open:
+ webbrowser.open("file://" + os.path.abspath(out))
+ return 0
+
+
+def cmd_show(sessions, args, st):
+ s = pick(filtered(sessions, args), args.show)
+ buf = io.StringIO()
+ print_chat(s, st, buf, show_tools=not args.no_tools)
+ text = buf.getvalue()
+ if args.no_pager:
+ sys.stdout.write(text)
+ else:
+ from .terminal import pager
+ pager(text)
+ return 0
+
+
+def cmd_table(sessions, args, st):
+ shown = filtered(sessions, args)
+ if not shown:
+ print("Ninguna sesión coincide con ese filtro.", file=sys.stderr)
+ return 1
+ if args.limit:
+ shown = shown[: args.limit]
+
+ print_table(shown, st, latest_activity(sessions), sys.stdout)
+
+ total, projects = len(sessions), len({s["p"] for s in sessions})
+ tail = (f"{len(shown)} de {total} sesiones" if len(shown) != total
+ else f"{plural(total, 'sesión', 'sesiones')} · "
+ f"{plural(projects, 'proyecto', 'proyectos')}")
+ print(f"\n{st.faint}{tail} · -s <nº> para leer una{st.reset}")
+ return 0
+
+
+def mem_filtered(memories, args):
+ return mem.apply_filters(memories, project=args.project,
+ query=" ".join(args.query) or None,
+ kind=args.type)
+
+
+def cmd_mem_show(memories, args, st):
+ m = mem.pick(mem_filtered(memories, args), args.show)
+ buf = io.StringIO()
+ print_memory(m, st, buf, path=mem.memory_path(m))
+ text = buf.getvalue()
+ if args.no_pager:
+ sys.stdout.write(text)
+ else:
+ from .terminal import pager
+ pager(text)
+ return 0
+
+
+def cmd_mem_check(memories, sessions, st):
+ report = mem.audit(memories, sessions)
+ total = print_audit(report, st, sys.stdout)
+ if total:
+ print(f"{st.faint}{plural(total, 'cosa para mirar', 'cosas para mirar')} "
+ f"en {plural(len(memories), 'memoria', 'memorias')}.{st.reset}")
+ return 1
+ print(f"{st.amber}Todo en orden: "
+ f"{plural(len(memories), 'memoria', 'memorias')}, "
+ f"índices y enlaces consistentes.{st.reset}")
+ return 0
+
+
+def delete_memories(targets, args, st):
+ if not targets:
+ print("No hay memorias que borrar con ese criterio.", file=sys.stderr)
+ return 0
+
+ print(f"{st.bold}Se van a borrar "
+ f"{plural(len(targets), 'memoria', 'memorias')}:{st.reset}\n")
+ total_kb = 0
+ for m in targets:
+ total_kb += m["k"]
+ print(f" {st.ink}{clip(m['name'], 38):<38}{st.reset} "
+ f"{clip(m['ty'], 9):<9} "
+ f"{st.grey}{clip(m['p'], 34):<34}{st.reset} "
+ f"{st.faint}{fmt_size(m['k']):>9}{st.reset}")
+ if m["desc"]:
+ print(f" {st.faint}{clip(m['desc'], 86)}{st.reset}")
+
+ print(f"\n{st.faint}{fmt_size(total_kb)} en total · "
+ f"también se quita su línea de MEMORY.md{st.reset}")
+
+ if args.dry_run:
+ print(f"\n{st.faint}--dry-run: no se tocó nada.{st.reset}")
+ return 0
+
+ if not args.yes:
+ print(f"\n{st.copper}Esto no se puede deshacer.{st.reset}")
+ if not confirm("¿Confirmás? [s/N] "):
+ print("Cancelado.", file=sys.stderr)
+ return 1
+
+ done = failed = unlisted = 0
+ for m in targets:
+ try:
+ if mem.delete(m):
+ unlisted += 1
+ done += 1
+ except OSError as e:
+ print(f"error: {m['name']}: {e}", file=sys.stderr)
+ failed += 1
+
+ extra = f", {unlisted} sacadas del índice" if unlisted else ""
+ print(f"\n{plural(done, 'memoria borrada', 'memorias borradas')}{extra}.")
+ return 1 if failed else 0
+
+
+def cmd_mem_table(memories, args, st, total):
+ if not memories:
+ print("Ninguna memoria coincide con ese filtro.", file=sys.stderr)
+ return 1
+ shown = memories[: args.limit] if args.limit else memories
+
+ print_memories(shown, st, latest_activity(shown), sys.stdout)
+
+ projects = len({m["p"] for m in memories})
+ tail = (f"{len(shown)} de {total} memorias" if len(shown) != total
+ else f"{plural(total, 'memoria', 'memorias')} · "
+ f"{plural(projects, 'proyecto', 'proyectos')}")
+ print(f"\n{st.faint}{tail} · -m -s <nº> para leer una{st.reset}")
+ return 0
+
+
+def run_memory(sessions, args, st):
+ memories = mem.load_memories(sessions)
+ if not memories:
+ print("Ningún proyecto tiene memorias todavía.", file=sys.stderr)
+ return 1
+
+ if args.check:
+ return cmd_mem_check(memories, sessions, st)
+
+ if args.delete:
+ pool = mem_filtered(memories, args)
+ targets, seen = [], set()
+ for ref in args.delete:
+ m = mem.pick(pool, ref)
+ if m["name"] not in seen:
+ seen.add(m["name"])
+ targets.append(m)
+ return delete_memories(targets, args, st)
+
+ if args.show:
+ return cmd_mem_show(memories, args, st)
+
+ return cmd_mem_table(mem_filtered(memories, args), args, st, len(memories))
+
+
+def run(args):
+ root = default_root()
+ if not os.path.isdir(root):
+ print(f"error: no existe {root} — ¿usaste Claude Code en esta máquina?",
+ file=sys.stderr)
+ return 2
+
+ sessions = load_sessions(root=root, use_cache=not args.no_cache)
+ if not sessions:
+ print("No hay ninguna sesión registrada todavía.", file=sys.stderr)
+ return 1
+
+ st = Style.from_stream(sys.stdout, args.no_color)
+
+ if args.memory:
+ return run_memory(sessions, args, st)
+
+ if args.json:
+ return cmd_json(sessions)
+ if args.html:
+ return cmd_html(sessions, args)
+
+ if args.delete or args.delete_empty:
+ targets = delete_targets(filtered(sessions, args), args)
+ return delete_sessions(targets, args, st)
+
+ if args.resume:
+ print(resume_cmd(pick(filtered(sessions, args), args.resume)))
+ return 0
+
+ if args.show:
+ return cmd_show(sessions, args, st)
+
+ return cmd_table(sessions, args, st)
+
+
+def main(argv=None):
+ args = build_parser().parse_args(argv)
+ try:
+ return run(args)
+ except SessionError as e:
+ print(f"error: {e}", file=sys.stderr)
+ return 2
+ except (BrokenPipeError, KeyboardInterrupt):
+ # El pipe ya está cerrado: silenciamos el flush de salida al terminar.
+ try:
+ sys.stdout.close()
+ except Exception:
+ pass
+ return 130
diff --git a/claude_logbook/memory.py b/claude_logbook/memory.py
new file mode 100644
index 0000000..ccb2e65
--- /dev/null
+++ b/claude_logbook/memory.py
@@ -0,0 +1,272 @@
+"""Memorias de proyecto: los .md que Claude Code deja en <proyecto>/memory/.
+
+Cada proyecto puede acumular recuerdos en
+
+ ~/.claude/projects/<proyecto>/memory/<nombre>.md
+
+Un archivo por recuerdo, con frontmatter YAML (`name`, `description`,
+`metadata.type`, `metadata.originSessionId`) y cuerpo markdown. Al lado vive
+`MEMORY.md`, el índice: una línea por memoria, y es lo único que se carga en
+contexto al arrancar una sesión. Una memoria que no figura ahí sigue en disco
+pero deja de recordarse, así que la diferencia entre ambos vale la pena mirarla.
+
+Esquema del registro que devuelve `read_memory`, con las mismas claves cortas
+que `sessions` porque también viaja embebido en el HTML:
+
+ name nombre del frontmatter (o el del archivo si falta)
+ file nombre del archivo, con extensión
+ p cwd del proyecto
+ desc descripción del frontmatter
+ ty tipo declarado: project | user | feedback | reference
+ src uuid de la sesión que la creó, si lo declara
+ body cuerpo markdown, sin el frontmatter
+ ln enlaces [[...]] que aparecen en el cuerpo
+ k tamaño en KB
+ l mtime del archivo (ISO 8601)
+ ix True si figura en MEMORY.md
+ hix True si el proyecto tiene MEMORY.md
+
+`project_dir` es interno y `public_records()` lo saca antes de serializar.
+"""
+
+import glob
+import os
+import re
+from datetime import datetime, timezone
+
+from .sessions import SessionError, default_root
+
+INDEX_NAME = "MEMORY.md"
+
+INTERNAL_KEYS = ("project_dir",)
+
+TYPES = ("project", "user", "feedback", "reference")
+
+FRONTMATTER_RE = re.compile(r"^---\s*\n(.*?)\n---\s*\n?", re.S)
+LINK_RE = re.compile(r"\[\[([^\]\n]+)\]\]")
+# En el índice cada línea es "- [Título](archivo.md) — pista".
+INDEX_LINK_RE = re.compile(r"\(([^)\n]+)\.md\)")
+
+
+def memory_dir(project_dir, root=None):
+ return os.path.join(root or default_root(), project_dir, "memory")
+
+
+def memory_path(m, root=None):
+ return os.path.join(memory_dir(m["project_dir"], root), m["file"])
+
+
+def index_path(project_dir, root=None):
+ return os.path.join(memory_dir(project_dir, root), INDEX_NAME)
+
+
+# ──────────────────────────────── parseo ────────────────────────────────
+
+def _field(front, key):
+ """Valor de una clave del frontmatter. Plano: alcanza para lo que escribe
+ Claude Code, que anida `type` y `originSessionId` pero sin repetirlas."""
+ hit = re.search(r"^\s*%s:\s*(.+?)\s*$" % re.escape(key), front, re.M)
+ if not hit:
+ return None
+ value = hit.group(1).strip()
+ # YAML de una línea: si viene entrecomillado, las comillas internas están
+ # escapadas y hay que devolverlas como estaban.
+ for quote in ('"', "'"):
+ if len(value) >= 2 and value[0] == quote and value[-1] == quote:
+ value = value[1:-1]
+ if quote == '"':
+ value = value.replace('\\"', '"').replace("\\\\", "\\")
+ break
+ return value or None
+
+
+def read_memory(path, project_dir):
+ with open(path, "r", encoding="utf-8", errors="ignore") as f:
+ raw = f.read()
+
+ match = FRONTMATTER_RE.match(raw)
+ front, body = (match.group(1), raw[match.end():]) if match else ("", raw)
+ stat = os.stat(path)
+ filename = os.path.basename(path)
+
+ return {
+ "name": _field(front, "name") or filename[:-3],
+ "file": filename,
+ "project_dir": project_dir,
+ "desc": _field(front, "description") or "",
+ "ty": _field(front, "type") or "—",
+ "src": _field(front, "originSessionId"),
+ "body": body.strip(),
+ "ln": sorted(set(LINK_RE.findall(body))),
+ "k": round(stat.st_size / 1024, 1),
+ "l": datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc).isoformat(),
+ }
+
+
+def read_index(project_dir, root=None):
+ """Nombres (sin .md) que el MEMORY.md del proyecto enlaza."""
+ try:
+ with open(index_path(project_dir, root), "r",
+ encoding="utf-8", errors="ignore") as f:
+ return set(INDEX_LINK_RE.findall(f.read()))
+ except OSError:
+ return set()
+
+
+# ──────────────────────────────── carga ────────────────────────────────
+
+def load_memories(sessions, root=None):
+ """Lee las memorias de todos los proyectos.
+
+ La ruta real del proyecto sale de las sesiones: el nombre del directorio
+ codifica "/" y "." los dos como "-" y no se puede invertir.
+ """
+ root = root or default_root()
+ cwd_by_dir = {}
+ for s in sessions:
+ cwd_by_dir.setdefault(s.get("project_dir"), s.get("p"))
+
+ memories = []
+ for d in sorted(glob.glob(os.path.join(root, "*", "memory"))):
+ project_dir = os.path.basename(os.path.dirname(d))
+ files = sorted(f for f in glob.glob(os.path.join(d, "*.md"))
+ if os.path.basename(f) != INDEX_NAME)
+ if not files:
+ continue # un memory/ vacío no es un proyecto con memoria
+
+ has_index = os.path.exists(os.path.join(d, INDEX_NAME))
+ listed = read_index(project_dir, root) if has_index else set()
+
+ for path in files:
+ try:
+ m = read_memory(path, project_dir)
+ except OSError:
+ continue
+ m["p"] = cwd_by_dir.get(project_dir) or project_dir
+ m["hix"] = has_index
+ m["ix"] = m["file"][:-3] in listed
+ memories.append(m)
+
+ memories.sort(key=lambda m: m["l"], reverse=True)
+ return memories
+
+
+def public_records(memories):
+ """Copia sin las claves internas, lista para serializar."""
+ out = []
+ for m in memories:
+ clean = dict(m)
+ for key in INTERNAL_KEYS:
+ clean.pop(key, None)
+ out.append(clean)
+ return out
+
+
+# ──────────────────────────────── filtros ────────────────────────────────
+
+def apply_filters(memories, project=None, query=None, kind=None):
+ out = memories
+
+ if project:
+ needle = os.path.expanduser(project).rstrip("/").lower()
+ out = [m for m in out if needle in m["p"].lower()]
+
+ if kind:
+ out = [m for m in out if m["ty"].lower() == kind.lower()]
+
+ if query:
+ needle = query.lower()
+ out = [m for m in out
+ if needle in m["name"].lower()
+ or needle in m["desc"].lower()
+ or needle in m["p"].lower()
+ or needle in m["body"].lower()]
+
+ return out
+
+
+def pick(memories, ref):
+ """Resuelve un índice de la tabla (1-based) o un prefijo del nombre."""
+ if ref.isdigit():
+ i = int(ref)
+ if 1 <= i <= len(memories):
+ return memories[i - 1]
+ raise SessionError(
+ f"el índice {i} está fuera de rango (hay {len(memories)} memorias)")
+
+ needle = ref.lower()
+ hits = [m for m in memories if m["name"].lower().startswith(needle)]
+ if not hits:
+ hits = [m for m in memories if needle in m["name"].lower()]
+ if len(hits) == 1:
+ return hits[0]
+ if not hits:
+ raise SessionError(f"ninguna memoria coincide con '{ref}'")
+ nombres = ", ".join(m["name"] for m in hits[:4])
+ raise SessionError(
+ f"'{ref}' es ambiguo, coincide con {len(hits)}: {nombres}"
+ + (", …" if len(hits) > 4 else ""))
+
+
+# ──────────────────────────────── auditoría ────────────────────────────────
+
+def audit(memories, sessions, root=None):
+ """Inconsistencias entre archivos, índices, enlaces y sesiones de origen."""
+ known = {m["name"] for m in memories} | {m["file"][:-3] for m in memories}
+ session_ids = {s["id"] for s in sessions}
+
+ report = {
+ "sin_indice": [m for m in memories if not m["hix"]],
+ "sin_listar": [m for m in memories if m["hix"] and not m["ix"]],
+ "enlaces_rotos": [(m, link) for m in memories
+ for link in m["ln"] if link not in known],
+ "origen_perdido": [m for m in memories
+ if m["src"] and m["src"] not in session_ids],
+ "indice_fantasma": [],
+ }
+
+ for project_dir in sorted({m["project_dir"] for m in memories if m["hix"]}):
+ real = {m["file"][:-3] for m in memories
+ if m["project_dir"] == project_dir}
+ for missing in sorted(read_index(project_dir, root) - real):
+ report["indice_fantasma"].append((project_dir, missing))
+
+ return report
+
+
+def audit_total(report):
+ return sum(len(v) for v in report.values())
+
+
+# ──────────────────────────────── borrado ────────────────────────────────
+
+def unindex(m, root=None):
+ """Saca del MEMORY.md la línea que apunta a esta memoria.
+
+ Devuelve True si el índice cambió. No es un error que no cambie: la memoria
+ podía no estar listada.
+ """
+ path = index_path(m["project_dir"], root)
+ try:
+ with open(path, "r", encoding="utf-8", errors="ignore") as f:
+ lines = f.readlines()
+ except OSError:
+ return False
+
+ needle = "(%s)" % m["file"]
+ kept = [ln for ln in lines if needle not in ln]
+ if len(kept) == len(lines):
+ return False
+
+ try:
+ with open(path, "w", encoding="utf-8") as f:
+ f.writelines(kept)
+ except OSError:
+ return False
+ return True
+
+
+def delete(m, root=None):
+ """Borra el archivo y lo saca del índice. Devuelve si se desindexó."""
+ os.remove(memory_path(m, root))
+ return unindex(m, root)
diff --git a/claude_logbook/sessions.py b/claude_logbook/sessions.py
new file mode 100644
index 0000000..1ff48c0
--- /dev/null
+++ b/claude_logbook/sessions.py
@@ -0,0 +1,409 @@
+"""Parseo de los .jsonl que Claude Code deja en ~/.claude/projects/.
+
+Cada conversación es un archivo JSON Lines: una línea por evento. De ahí sale un
+registro por sesión con claves de una letra, porque ese mismo registro viaja
+embebido dentro del HTML y los nombres largos se pagan una vez por sesión.
+
+Esquema del registro que devuelve `read_session`:
+
+ id uuid de la sesión (el nombre del archivo)
+ p cwd del proyecto
+ b rama de git
+ t título
+ ai True si el título lo generó Claude, False si es el primer mensaje
+ n True si parece un `claude -p` no interactivo
+ e True si la sesión no tiene ningún mensaje
+ i True si `p` se dedujo de otra sesión del mismo proyecto
+ f/l timestamp del primer y del último evento (ISO 8601)
+ d duración en minutos
+ u/a cantidad de mensajes tuyos / de Claude
+ k tamaño del .jsonl en KB
+ v versión de Claude Code
+ c transcripción: [{"r": "u" | "a" | "t", "x": texto}]
+
+`project_dir` y `mtime` son internos y no salen del módulo: `public_records()`
+los saca antes de que el registro se serialice.
+"""
+
+import glob
+import json
+import os
+import re
+from datetime import datetime, timezone
+
+# Sube si cambia el esquema del registro: invalida los cachés viejos en vez de
+# leer registros con la forma anterior.
+CACHE_VERSION = 2
+
+EPOCH = datetime(1970, 1, 1, tzinfo=timezone.utc)
+
+INTERNAL_KEYS = ("project_dir", "mtime")
+
+
+class SessionError(Exception):
+ """Error de uso que la CLI convierte en un mensaje y un código de salida."""
+
+
+# ──────────────────────────────── ubicaciones ────────────────────────────────
+
+def default_root():
+ """~/.claude/projects, o el equivalente si CLAUDE_CONFIG_DIR está seteada."""
+ base = os.environ.get("CLAUDE_CONFIG_DIR") or os.path.join(
+ os.path.expanduser("~"), ".claude")
+ return os.path.join(base, "projects")
+
+
+def default_cache_path():
+ base = os.environ.get("XDG_CACHE_HOME") or os.path.expanduser("~/.cache")
+ return os.path.join(base, "claude-logbook", "cache.json")
+
+
+def session_path(s, root=None):
+ """Ruta del .jsonl. El nombre del archivo es el UUID y el del directorio
+ padre es lo que guardamos en project_dir, así que es reconstruible."""
+ return os.path.join(root or default_root(),
+ s["project_dir"], s["id"] + ".jsonl")
+
+
+# ─────────────────────────── parseo de los .jsonl ───────────────────────────
+
+TAG_RE = re.compile(r"<[^>]+>")
+REMINDER_RE = re.compile(r"<system-reminder>.*?</system-reminder>", re.S)
+
+# Un mensaje que empieza con alguno de estos no es texto del usuario: es un
+# bloque que genera la propia CLI al ejecutar un comando local.
+SKIP_PREFIXES = (
+ "<local-command-caveat", "<command-name", "<command-message",
+ "<command-args", "<local-command-stdout", "<system-reminder",
+)
+
+TITLE_MAX = 160
+TOOL_ARG_MAX = 140
+
+# Umbral del heurístico de `claude -p`: un único mensaje más largo que esto, sin
+# ninguna ida y vuelta, es un pipe por stdin y no una conversación.
+NONINTERACTIVE_CHARS = 1500
+
+# Para cada herramienta, el parámetro que mejor resume qué hizo.
+TOOL_KEY = {
+ "Bash": "command", "Read": "file_path", "Edit": "file_path",
+ "Write": "file_path", "NotebookEdit": "notebook_path", "Glob": "pattern",
+ "Grep": "pattern", "WebFetch": "url", "WebSearch": "query",
+ "Task": "description", "Agent": "description", "Skill": "skill",
+}
+
+
+def clean_text(s):
+ """Devuelve texto de usuario legible, o None si es ruido del harness."""
+ if not isinstance(s, str):
+ return None
+ s = s.strip()
+ if not s or s.startswith(SKIP_PREFIXES):
+ return None
+ s = REMINDER_RE.sub(" ", s)
+ s = TAG_RE.sub(" ", s)
+ s = re.sub(r"\s+", " ", s).strip()
+ return s if len(s) >= 3 else None
+
+
+def tool_summary(block):
+ """Una línea del estilo 'Bash: git status' para una llamada a herramienta."""
+ name = block.get("name") or "tool"
+ args = block.get("input") or {}
+ if not isinstance(args, dict):
+ return name
+ val = args.get(TOOL_KEY.get(name, ""))
+ if val is None:
+ val = next((v for v in args.values() if isinstance(v, str)), None)
+ if not isinstance(val, str):
+ return name
+ val = re.sub(r"\s+", " ", val).strip()
+ if len(val) > TOOL_ARG_MAX:
+ val = val[:TOOL_ARG_MAX] + "…"
+ return f"{name}: {val}" if val else name
+
+
+def blocks_of(message):
+ content = message.get("content")
+ if isinstance(content, str):
+ return [{"type": "text", "text": content}]
+ return content if isinstance(content, list) else []
+
+
+def parse_ts(ts):
+ """ISO 8601 → datetime con zona, o None si no se puede leer."""
+ if not ts:
+ return None
+ try:
+ return datetime.fromisoformat(ts.replace("Z", "+00:00"))
+ except (ValueError, AttributeError):
+ return None
+
+
+def read_session(path):
+ """Parsea un .jsonl entero y devuelve el registro de esa sesión."""
+ session_id = os.path.basename(path)[:-6] # sin .jsonl
+ first_ts = last_ts = cwd = git_branch = version = None
+ ai_title = fallback_title = None
+ user_msgs = assistant_msgs = 0
+ convo = []
+
+ with open(path, "r", encoding="utf-8", errors="ignore") as f:
+ for line in f:
+ line = line.strip()
+ if not line:
+ continue
+ try:
+ obj = json.loads(line)
+ except json.JSONDecodeError:
+ continue # línea truncada por una sesión que sigue escribiendo
+ if not isinstance(obj, dict):
+ continue
+
+ kind = obj.get("type")
+
+ if kind == "ai-title":
+ if obj.get("aiTitle"):
+ ai_title = obj["aiTitle"] # nos quedamos con el más reciente
+ continue
+
+ ts = obj.get("timestamp")
+ if ts:
+ if first_ts is None:
+ first_ts = ts
+ last_ts = ts
+ if cwd is None and obj.get("cwd"):
+ cwd = obj["cwd"]
+ if git_branch is None and obj.get("gitBranch"):
+ git_branch = obj["gitBranch"]
+ if obj.get("version"):
+ version = obj["version"]
+
+ if kind not in ("user", "assistant") or obj.get("isSidechain"):
+ continue
+
+ message = obj.get("message")
+ if not isinstance(message, dict):
+ continue
+
+ if kind == "user":
+ if obj.get("isMeta"):
+ continue
+ for b in blocks_of(message):
+ if not isinstance(b, dict):
+ continue
+ if b.get("type") == "text":
+ text = clean_text(b.get("text"))
+ if text:
+ user_msgs += 1
+ if fallback_title is None:
+ fallback_title = text[:TITLE_MAX]
+ convo.append({"r": "u", "x": text})
+ elif b.get("type") == "image":
+ convo.append({"r": "u", "x": "[imagen adjunta]"})
+ else:
+ counted = False
+ for b in blocks_of(message):
+ if not isinstance(b, dict):
+ continue
+ if b.get("type") == "text":
+ text = (b.get("text") or "").strip()
+ if text:
+ convo.append({"r": "a", "x": text})
+ counted = True
+ elif b.get("type") == "tool_use":
+ convo.append({"r": "t", "x": tool_summary(b)})
+ if counted:
+ assistant_msgs += 1
+
+ st = os.stat(path)
+ ft, lt = parse_ts(first_ts), parse_ts(last_ts)
+
+ # Un único mensaje enorme y ninguna ida y vuelta es la firma de un
+ # `claude -p` con algo piped por stdin (p. ej. un git diff para redactar el
+ # mensaje de commit), no de una conversación.
+ noninteractive = (
+ user_msgs == 1 and not ai_title and bool(convo)
+ and len(convo[0]["x"]) > NONINTERACTIVE_CHARS
+ )
+
+ return {
+ "id": session_id,
+ "project_dir": os.path.basename(os.path.dirname(path)),
+ "p": cwd,
+ "b": git_branch,
+ "t": ai_title or fallback_title,
+ "ai": bool(ai_title),
+ "n": noninteractive,
+ "e": not convo,
+ "f": first_ts,
+ "l": last_ts,
+ "d": round((lt - ft).total_seconds() / 60) if ft and lt else None,
+ "u": user_msgs,
+ "a": assistant_msgs,
+ "k": round(st.st_size / 1024, 1),
+ "v": version,
+ "c": convo,
+ "mtime": datetime.fromtimestamp(st.st_mtime, tz=timezone.utc).isoformat(),
+ }
+
+
+# ──────────────────────────────── caché ────────────────────────────────
+
+def _load_cache(path):
+ """Entradas del caché, o {} si no existe, está roto o quedó viejo."""
+ try:
+ with open(path, encoding="utf-8") as f:
+ blob = json.load(f)
+ except (OSError, ValueError, UnicodeDecodeError):
+ return {}
+ if not isinstance(blob, dict) or blob.get("v") != CACHE_VERSION:
+ return {}
+ entries = blob.get("entries")
+ return entries if isinstance(entries, dict) else {}
+
+
+def _save_cache(path, entries):
+ """Escribe el caché de forma atómica. Si falla, no pasa nada."""
+ try:
+ os.makedirs(os.path.dirname(path), exist_ok=True)
+ # El pid en el temporal evita que dos corridas simultáneas se pisen.
+ tmp = f"{path}.{os.getpid()}.tmp"
+ with open(tmp, "w", encoding="utf-8") as f:
+ json.dump({"v": CACHE_VERSION, "entries": entries}, f,
+ ensure_ascii=False, separators=(",", ":"))
+ os.replace(tmp, path)
+ except OSError:
+ pass # el caché es una optimización, no una condición de uso
+
+
+def drop_from_cache(paths, cache_path=None):
+ """Saca del caché las sesiones borradas para que no reaparezcan."""
+ cache_path = cache_path or default_cache_path()
+ entries = _load_cache(cache_path)
+ if not entries:
+ return
+ if any(entries.pop(p, None) is not None for p in list(paths)):
+ _save_cache(cache_path, entries)
+
+
+# ──────────────────────────────── carga ────────────────────────────────
+
+def _fill_gaps(sessions):
+ """Completa lo que falta después de parsear todos los archivos.
+
+ Algunas sesiones (un /resume cancelado) nunca registran cwd. El nombre del
+ directorio no se puede invertir de forma fiable porque "/" y "." se
+ codifican los dos como "-", así que tomamos la ruta prestada de otra sesión
+ del mismo proyecto y lo dejamos marcado en `i`.
+ """
+ known = {}
+ for s in sessions:
+ if s["p"]:
+ known.setdefault(s["project_dir"], s["p"])
+
+ for s in sessions:
+ s["i"] = not s["p"]
+ if not s["p"]:
+ s["p"] = known.get(s["project_dir"], s["project_dir"])
+ if not s["l"]:
+ s["l"] = s["mtime"]
+ if not s["f"]:
+ s["f"] = s["mtime"]
+
+
+def load_sessions(root=None, cache_path=None, use_cache=True):
+ """Parsea todas las sesiones, reusando del caché las que no cambiaron."""
+ root = root or default_root()
+ cache_path = cache_path or default_cache_path()
+ paths = sorted(glob.glob(os.path.join(root, "*", "*.jsonl")))
+
+ cache = _load_cache(cache_path) if use_cache else {}
+
+ sessions, fresh, reparsed = [], {}, False
+ for path in paths:
+ try:
+ st = os.stat(path)
+ except OSError:
+ continue
+ stamp = f"{st.st_mtime_ns}:{st.st_size}"
+ hit = cache.get(path)
+ if (isinstance(hit, dict) and hit.get("stamp") == stamp
+ and isinstance(hit.get("rec"), dict)):
+ rec = hit["rec"]
+ else:
+ try:
+ rec = read_session(path)
+ except OSError:
+ continue
+ reparsed = True
+ fresh[path] = {"stamp": stamp, "rec": rec}
+ sessions.append(rec)
+
+ # Antes de `_fill_gaps`, a propósito: al caché va el registro tal como salió
+ # del archivo, sin los campos deducidos a partir de las otras sesiones.
+ if use_cache and (reparsed or len(fresh) != len(cache)):
+ _save_cache(cache_path, fresh)
+
+ _fill_gaps(sessions)
+ sessions.sort(key=lambda s: parse_ts(s["l"]) or EPOCH, reverse=True)
+ return sessions
+
+
+def latest_activity(sessions):
+ """El instante más reciente de los datos: el "ahora" contra el que se
+ calculan las fechas relativas, para que no dependan del reloj de quien mira."""
+ stamps = [parse_ts(s["l"]) for s in sessions]
+ return max([t for t in stamps if t], default=EPOCH)
+
+
+def public_records(sessions):
+ """Copias sin las claves internas, listas para serializar."""
+ return [{k: v for k, v in s.items() if k not in INTERNAL_KEYS}
+ for s in sessions]
+
+
+# ──────────────────────────────── filtros ────────────────────────────────
+
+def apply_filters(sessions, project=None, grep=None, query=None,
+ hide_empty=False):
+ out = sessions
+
+ if project:
+ needle = os.path.expanduser(project).rstrip("/").lower()
+ out = [s for s in out if needle in s["p"].lower()]
+
+ if grep:
+ needle = grep.lower()
+ out = [s for s in out
+ if any(needle in m["x"].lower() for m in s["c"])]
+
+ if query:
+ needle = query.lower()
+ out = [s for s in out
+ if needle in (s["t"] or "").lower()
+ or needle in s["p"].lower()
+ or needle in (s["b"] or "").lower()
+ or s["id"].startswith(needle)]
+
+ if hide_empty:
+ out = [s for s in out if not s["e"]]
+
+ return out
+
+
+def pick(sessions, ref):
+ """Resuelve un índice de la tabla (1-based) o un prefijo de UUID."""
+ if ref.isdigit():
+ i = int(ref)
+ if 1 <= i <= len(sessions):
+ return sessions[i - 1]
+ raise SessionError(
+ f"el índice {i} está fuera de rango (hay {len(sessions)})")
+
+ hits = [s for s in sessions if s["id"].startswith(ref.lower())]
+ if len(hits) == 1:
+ return hits[0]
+ if not hits:
+ raise SessionError(f"ninguna sesión empieza con '{ref}'")
+ raise SessionError(f"'{ref}' es ambiguo, coincide con {len(hits)} sesiones")
diff --git a/claude_logbook/template.html b/claude_logbook/template.html
new file mode 100644
index 0000000..7c8ba76
--- /dev/null
+++ b/claude_logbook/template.html
@@ -0,0 +1,1394 @@
+<!doctype html>
+<html lang="es">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="color-scheme" content="light dark">
+<meta name="robots" content="noindex, nofollow">
+<title>Sesiones de Claude Code</title>
+
+<script>
+ // Corre antes del primer pintado para que el tema elegido no parpadee:
+ // primero la preferencia guardada, si no la del sistema.
+ (function () {
+ var saved = null;
+ try { saved = localStorage.getItem('cs-tema'); } catch (e) {}
+ var dark = saved ? saved === 'dark'
+ : matchMedia('(prefers-color-scheme: dark)').matches;
+ document.documentElement.dataset.theme = dark ? 'dark' : 'light';
+ })();
+</script>
+
+<style>
+ /* Una paleta por tema y nada más: el data-theme lo pone el script de arriba
+ antes de pintar, así que no hace falta repetir los valores dentro de una
+ @media. El botón del toolbar cambia ese mismo atributo. */
+
+ :root, :root[data-theme="light"] {
+ --ground: #EDEEF2;
+ --surface: #FFFFFF;
+ --raised: #F6F7F9;
+ --ink: #14161C;
+ --ink-soft: #3D4250;
+ --muted: #6A6F7E;
+ --faint: #9AA0AE;
+ --line: #DCDEE5;
+ --line-soft:#E7E9EE;
+ --amber: #A85A16;
+ --amber-lo: #C98A47;
+ --amber-bg: rgba(168, 90, 22, 0.09);
+ --scrim: rgba(20, 22, 28, .38);
+ --shadow: 0 1px 2px rgba(20, 22, 28, .06), 0 8px 24px -12px rgba(20, 22, 28, .18);
+ --shadow-lg:0 24px 70px -20px rgba(20, 22, 28, .45);
+ --focus: #2C6FD1;
+
+ --sans: ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+ --mono: ui-monospace, "JetBrains Mono", "SFMono-Regular", "SF Mono", Menlo, Consolas, "Liberation Mono", monospace;
+ }
+
+ :root[data-theme="dark"] {
+ --ground: #0E1015;
+ --surface: #171A21;
+ --raised: #1D212A;
+ --ink: #DFE2EA;
+ --ink-soft: #B4BAC7;
+ --muted: #878DA0;
+ --faint: #666C7D;
+ --line: #262A34;
+ --line-soft:#1F232C;
+ --amber: #E29A4A;
+ --amber-lo: #8A6435;
+ --amber-bg: rgba(226, 154, 74, 0.11);
+ --scrim: rgba(0, 0, 0, .62);
+ --shadow: 0 1px 2px rgba(0,0,0,.4), 0 8px 24px -12px rgba(0,0,0,.7);
+ --shadow-lg:0 24px 70px -20px rgba(0,0,0,.85);
+ --focus: #6BA5F0;
+ }
+
+ * { box-sizing: border-box; }
+
+ body {
+ margin: 0;
+ background: var(--ground);
+ color: var(--ink);
+ font-family: var(--sans);
+ font-size: 15px;
+ line-height: 1.5;
+ -webkit-font-smoothing: antialiased;
+ }
+ body.locked { overflow: hidden; }
+
+ .wrap { max-width: 1180px; margin: 0 auto; padding: 40px 24px 96px; }
+
+ /* ---------- masthead ---------- */
+
+ .masthead { display: flex; flex-direction: column; gap: 8px; margin-bottom: 28px; }
+
+ .eyebrow {
+ font-family: var(--mono);
+ font-size: 11px;
+ letter-spacing: .14em;
+ text-transform: uppercase;
+ color: var(--amber);
+ }
+
+ h1 {
+ margin: 0;
+ font-size: clamp(28px, 4.5vw, 40px);
+ line-height: 1.1;
+ letter-spacing: -.022em;
+ font-weight: 620;
+ text-wrap: balance;
+ }
+
+ .lede { margin: 0; max-width: 64ch; color: var(--muted); font-size: 15px; }
+ .lede code, .foot code {
+ font-family: var(--mono);
+ font-size: .88em;
+ background: var(--amber-bg);
+ color: var(--amber);
+ padding: 1px 5px;
+ border-radius: 4px;
+ }
+
+ /* ---------- stats ---------- */
+
+ .stats {
+ display: grid;
+ grid-template-columns: repeat(auto-fit, minmax(132px, 1fr));
+ gap: 1px;
+ background: var(--line);
+ border: 1px solid var(--line);
+ border-radius: 10px;
+ overflow: hidden;
+ margin-bottom: 24px;
+ }
+ .stat { background: var(--surface); padding: 14px 16px 16px; }
+ .stat-k {
+ display: block;
+ font-family: var(--mono);
+ font-size: 10px;
+ letter-spacing: .13em;
+ text-transform: uppercase;
+ color: var(--faint);
+ margin-bottom: 5px;
+ }
+ .stat-v {
+ font-family: var(--mono);
+ font-size: 22px;
+ font-variant-numeric: tabular-nums;
+ letter-spacing: -.02em;
+ color: var(--ink);
+ }
+ .stat-v small { font-size: 12px; color: var(--muted); letter-spacing: 0; }
+
+ /* ---------- toolbar ---------- */
+
+ .toolbar {
+ position: sticky;
+ top: 0;
+ z-index: 20;
+ display: flex;
+ flex-wrap: wrap;
+ gap: 8px;
+ align-items: center;
+ padding: 12px 0;
+ background: linear-gradient(var(--ground) 76%, transparent);
+ }
+
+ .field { position: relative; flex: 1 1 240px; min-width: 180px; }
+ .field svg { position: absolute; left: 11px; top: 50%; transform: translateY(-50%); color: var(--faint); pointer-events: none; }
+
+ input[type="search"], select {
+ width: 100%;
+ font: inherit;
+ font-size: 14px;
+ color: var(--ink);
+ background: var(--surface);
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ padding: 9px 12px;
+ appearance: none;
+ }
+ input[type="search"] { padding-left: 34px; font-family: var(--mono); font-size: 13px; }
+ input[type="search"]::-webkit-search-cancel-button { filter: grayscale(1) opacity(.5); }
+
+ select {
+ flex: 0 1 auto;
+ width: auto;
+ max-width: 300px;
+ padding-right: 30px;
+ font-family: var(--mono);
+ font-size: 12.5px;
+ background-image: linear-gradient(45deg, transparent 50%, var(--muted) 50%), linear-gradient(135deg, var(--muted) 50%, transparent 50%);
+ background-position: calc(100% - 16px) calc(50% + 1px), calc(100% - 11px) calc(50% + 1px);
+ background-size: 5px 5px, 5px 5px;
+ background-repeat: no-repeat;
+ }
+
+ .toggle {
+ display: inline-flex;
+ align-items: center;
+ gap: 7px;
+ font-family: var(--mono);
+ font-size: 12px;
+ color: var(--muted);
+ background: var(--surface);
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ padding: 9px 12px;
+ cursor: pointer;
+ user-select: none;
+ white-space: nowrap;
+ }
+ .toggle input { accent-color: var(--amber); margin: 0; }
+ .toggle:hover { color: var(--ink); }
+ .toggle:has(input:checked) { color: var(--amber); border-color: var(--amber-lo); background: var(--amber-bg); }
+
+ .tbtn {
+ display: inline-flex;
+ align-items: center;
+ justify-content: center;
+ color: var(--muted);
+ background: var(--surface);
+ border: 1px solid var(--line);
+ border-radius: 8px;
+ padding: 9px 11px;
+ cursor: pointer;
+ flex-shrink: 0;
+ }
+ .tbtn:hover { color: var(--amber); border-color: var(--amber-lo); }
+ .tbtn .sun { display: none; }
+ :root[data-theme="dark"] .tbtn .sun { display: block; }
+ :root[data-theme="dark"] .tbtn .moon { display: none; }
+
+ .noscript {
+ margin: 0 0 24px;
+ padding: 14px 16px;
+ border: 1px solid var(--amber-lo);
+ background: var(--amber-bg);
+ border-radius: 10px;
+ color: var(--ink);
+ font-size: 14px;
+ }
+
+ :is(input, select, button, .toggle, .row[tabindex]):focus-visible {
+ outline: 2px solid var(--focus);
+ outline-offset: 1px;
+ }
+
+ /* ---------- tabla ---------- */
+
+ .grid { border: 1px solid var(--line); border-radius: 10px; overflow: hidden; background: var(--surface); box-shadow: var(--shadow); }
+
+ .row {
+ display: grid;
+ grid-template-columns: 3px 1fr 108px 58px 66px 128px;
+ align-items: center;
+ gap: 0 14px;
+ border-bottom: 1px solid var(--line-soft);
+ }
+ .row:last-child { border-bottom: 0; }
+ .row.clickable { cursor: pointer; }
+ .row.clickable:hover { background: var(--raised); }
+
+ .head {
+ position: sticky;
+ top: 62px;
+ z-index: 10;
+ background: var(--raised);
+ border-bottom: 1px solid var(--line);
+ }
+ .head span, .head button {
+ font-family: var(--mono);
+ font-size: 10px;
+ letter-spacing: .12em;
+ text-transform: uppercase;
+ color: var(--faint);
+ padding: 9px 0;
+ background: none;
+ border: 0;
+ text-align: left;
+ cursor: default;
+ }
+ .head button { cursor: pointer; display: inline-flex; align-items: center; gap: 4px; }
+ .head button:hover { color: var(--ink); }
+ .head button[aria-sort] { color: var(--amber); }
+ .head button .car { opacity: 0; }
+ .head button[aria-sort] .car { opacity: 1; }
+ .head .num { justify-content: flex-end; text-align: right; }
+ .head .pad-l { padding-left: 14px; }
+ .head .pad-r { padding-right: 16px; }
+
+ .r-body { padding: 11px 0 12px; min-width: 0; }
+
+ .stripe { align-self: stretch; background: var(--stripe, transparent); }
+
+ .title {
+ margin: 0 0 3px;
+ font-size: 14px;
+ line-height: 1.42;
+ color: var(--ink);
+ display: -webkit-box;
+ -webkit-line-clamp: 2;
+ -webkit-box-orient: vertical;
+ overflow: hidden;
+ }
+ mark { background: var(--amber-bg); color: var(--amber); border-radius: 3px; padding: 0 1px; }
+
+ .meta {
+ display: flex;
+ flex-wrap: wrap;
+ align-items: center;
+ gap: 4px 8px;
+ font-family: var(--mono);
+ font-size: 11.5px;
+ color: var(--muted);
+ min-width: 0;
+ }
+ .path { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; max-width: 100%; }
+
+ .chip {
+ font-size: 10px;
+ letter-spacing: .06em;
+ text-transform: uppercase;
+ padding: 1px 5px;
+ border-radius: 3px;
+ border: 1px solid var(--line);
+ color: var(--faint);
+ white-space: nowrap;
+ }
+ .chip-branch { color: var(--muted); }
+ .chip-empty, .chip-auto { color: var(--amber); border-color: var(--amber-lo); background: var(--amber-bg); }
+
+ .snippet {
+ margin: 5px 0 0;
+ font-family: var(--mono);
+ font-size: 11.5px;
+ line-height: 1.5;
+ color: var(--muted);
+ border-left: 2px solid var(--amber-lo);
+ padding-left: 9px;
+ }
+
+ .cell-n {
+ font-family: var(--mono);
+ font-size: 12px;
+ font-variant-numeric: tabular-nums;
+ color: var(--ink-soft);
+ text-align: right;
+ padding: 11px 0 12px;
+ }
+ .cell-date { font-family: var(--mono); font-size: 12px; font-variant-numeric: tabular-nums; color: var(--ink-soft); padding: 11px 0 12px; }
+ .cell-date small { display: block; color: var(--faint); font-size: 10.5px; letter-spacing: .04em; }
+ .dim { color: var(--faint); }
+
+ .cell-act { padding: 9px 16px 9px 0; display: flex; justify-content: flex-end; }
+
+ .copy {
+ font-family: var(--mono);
+ font-size: 11px;
+ color: var(--muted);
+ background: var(--raised);
+ border: 1px solid var(--line);
+ border-radius: 6px;
+ padding: 6px 9px;
+ cursor: pointer;
+ display: inline-flex;
+ align-items: center;
+ gap: 6px;
+ white-space: nowrap;
+ transition: color .12s, border-color .12s, background .12s;
+ }
+ .copy:hover, .copy.done { color: var(--amber); border-color: var(--amber-lo); background: var(--amber-bg); }
+
+ .empty-row .title { color: var(--muted); font-style: italic; }
+
+ .none { padding: 48px 20px; text-align: center; color: var(--muted); font-family: var(--mono); font-size: 13px; }
+ .count { font-family: var(--mono); font-size: 11.5px; color: var(--faint); padding: 10px 2px 0; letter-spacing: .04em; }
+
+ /* ---------- lector ---------- */
+
+ .scrim {
+ position: fixed;
+ inset: 0;
+ background: var(--scrim);
+ opacity: 0;
+ pointer-events: none;
+ transition: opacity .2s;
+ z-index: 40;
+ }
+ .scrim.open { opacity: 1; pointer-events: auto; }
+
+ .reader {
+ position: fixed;
+ top: 0;
+ right: 0;
+ height: 100%;
+ width: min(920px, 100%);
+ display: flex;
+ flex-direction: column;
+ background: var(--ground);
+ border-left: 1px solid var(--line);
+ box-shadow: var(--shadow-lg);
+ transform: translateX(100%);
+ transition: transform .24s cubic-bezier(.4, 0, .2, 1);
+ z-index: 41;
+ visibility: hidden;
+ }
+ .reader.open { transform: none; visibility: visible; }
+
+ .reader-head {
+ display: flex;
+ align-items: flex-start;
+ gap: 14px;
+ padding: 18px 20px 15px;
+ border-bottom: 1px solid var(--line);
+ background: var(--surface);
+ }
+ .reader-head h2 {
+ margin: 0 0 6px;
+ font-size: 17px;
+ line-height: 1.3;
+ letter-spacing: -.012em;
+ font-weight: 600;
+ text-wrap: balance;
+ }
+ .rh-text { flex: 1; min-width: 0; }
+ .rh-acts { display: flex; gap: 7px; flex-shrink: 0; }
+
+ .xbtn {
+ background: var(--raised);
+ border: 1px solid var(--line);
+ border-radius: 6px;
+ color: var(--muted);
+ cursor: pointer;
+ padding: 7px 9px;
+ display: inline-flex;
+ align-items: center;
+ transition: color .12s, border-color .12s, background .12s;
+ }
+ .xbtn:hover { color: var(--ink); }
+ .xbtn.done { color: var(--amber); border-color: var(--amber-lo); background: var(--amber-bg); }
+
+ .transcript {
+ flex: 1;
+ overflow-y: auto;
+ overscroll-behavior: contain;
+ padding: 20px 20px 64px;
+ display: flex;
+ flex-direction: column;
+ gap: 14px;
+ }
+
+ .turn { display: flex; flex-direction: column; gap: 5px; }
+ .who {
+ font-family: var(--mono);
+ font-size: 10px;
+ letter-spacing: .13em;
+ text-transform: uppercase;
+ color: var(--faint);
+ }
+ .turn-u .who { color: var(--amber); }
+
+ .bubble {
+ border-radius: 8px;
+ padding: 11px 14px;
+ font-size: 14.5px;
+ line-height: 1.62;
+ white-space: pre-wrap;
+ overflow-wrap: anywhere;
+ border: 1px solid var(--line-soft);
+ background: var(--surface);
+ color: var(--ink-soft);
+ }
+ .turn-u .bubble { background: var(--amber-bg); border-color: var(--amber-lo); color: var(--ink); }
+
+ .bubble pre {
+ margin: 9px 0;
+ padding: 10px 12px;
+ background: var(--ground);
+ border: 1px solid var(--line);
+ border-radius: 6px;
+ overflow-x: auto;
+ font-family: var(--mono);
+ font-size: 12.5px;
+ line-height: 1.55;
+ white-space: pre;
+ color: var(--ink);
+ }
+ .bubble code {
+ font-family: var(--mono);
+ font-size: .87em;
+ background: var(--raised);
+ border: 1px solid var(--line-soft);
+ border-radius: 4px;
+ padding: 1px 4px;
+ }
+ .bubble strong { color: var(--ink); font-weight: 600; }
+ .bubble .h {
+ display: block;
+ margin: 4px 0 -2px;
+ font-size: .95em;
+ font-weight: 620;
+ letter-spacing: -.008em;
+ color: var(--ink);
+ }
+ .bubble pre code { background: none; border: 0; padding: 0; font-size: inherit; }
+
+ .tool {
+ font-family: var(--mono);
+ font-size: 11.5px;
+ color: var(--muted);
+ display: flex;
+ align-items: baseline;
+ gap: 8px;
+ padding: 3px 0 3px 12px;
+ border-left: 2px solid var(--line);
+ overflow-wrap: anywhere;
+ }
+ .tool b { color: var(--amber); font-weight: 500; flex-shrink: 0; }
+
+ .reader-empty { color: var(--muted); font-family: var(--mono); font-size: 13px; text-align: center; padding: 60px 20px; }
+
+ /* ---------- toast ---------- */
+
+ .toast {
+ position: fixed;
+ left: 50%;
+ bottom: 26px;
+ transform: translate(-50%, 14px);
+ background: var(--ink);
+ color: var(--ground);
+ font-family: var(--mono);
+ font-size: 12px;
+ padding: 9px 14px;
+ border-radius: 7px;
+ box-shadow: var(--shadow);
+ opacity: 0;
+ pointer-events: none;
+ transition: opacity .16s, transform .16s;
+ z-index: 60;
+ max-width: min(90vw, 560px);
+ overflow: hidden;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+ }
+ .toast.show { opacity: 1; transform: translate(-50%, 0); }
+
+ .legend {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 6px 16px;
+ align-items: center;
+ margin-top: 18px;
+ font-family: var(--mono);
+ font-size: 11px;
+ color: var(--faint);
+ }
+ .legend i { display: inline-block; width: 16px; height: 3px; border-radius: 2px; margin-right: 6px; vertical-align: middle; }
+
+ .foot {
+ margin-top: 26px;
+ padding-top: 18px;
+ border-top: 1px solid var(--line);
+ color: var(--muted);
+ font-size: 13px;
+ max-width: 68ch;
+ }
+ .foot p { margin: 0 0 8px; }
+
+ @media (max-width: 860px) {
+ .wrap { padding: 28px 14px 72px; }
+ .row { grid-template-columns: 3px 1fr auto; gap: 0 12px; }
+ .head { display: none; }
+ .r-body { padding: 12px 0 4px; grid-column: 2 / -1; }
+ .cell-date { grid-column: 2; padding: 0 0 10px; }
+ .cell-n { display: none; }
+ .cell-act { grid-column: 3; grid-row: 2; padding: 0 12px 10px 0; }
+ select { max-width: 100%; flex: 1 1 100%; }
+ .reader { width: 100%; border-left: 0; }
+ }
+
+ /* ---------- pestañas y memorias ---------- */
+
+ .tabs {
+ display: flex;
+ gap: 2px;
+ margin-bottom: 18px;
+ border-bottom: 1px solid var(--line);
+ }
+ .tab {
+ font: inherit;
+ font-size: 13.5px;
+ color: var(--muted);
+ background: none;
+ border: 0;
+ border-bottom: 2px solid transparent;
+ padding: 8px 14px;
+ margin-bottom: -1px;
+ cursor: pointer;
+ display: inline-flex;
+ align-items: center;
+ gap: 7px;
+ }
+ .tab:hover { color: var(--ink); }
+ .tab[aria-selected="true"] { color: var(--amber); border-bottom-color: var(--amber); }
+ .tab .n {
+ font-family: var(--mono);
+ font-size: 11px;
+ font-variant-numeric: tabular-nums;
+ color: var(--faint);
+ background: var(--raised);
+ border: 1px solid var(--line);
+ border-radius: 10px;
+ padding: 0 6px;
+ }
+ .tab[aria-selected="true"] .n { color: var(--amber); border-color: var(--amber-lo); background: var(--amber-bg); }
+
+ body[data-mode="s"] .only-m,
+ body[data-mode="m"] .only-s { display: none; }
+
+ .row.mem { grid-template-columns: 3px 1fr 104px 210px 108px; }
+
+ .mem-name { display: flex; align-items: baseline; gap: 7px; flex-wrap: wrap; }
+ .mem-name .nm { font-size: 14px; color: var(--ink); font-family: var(--mono); }
+ .mem-desc {
+ margin: 3px 0 0;
+ font-size: 12.5px;
+ line-height: 1.45;
+ color: var(--muted);
+ display: -webkit-box;
+ -webkit-line-clamp: 2;
+ -webkit-box-orient: vertical;
+ overflow: hidden;
+ }
+
+ .ty {
+ font-family: var(--mono);
+ font-size: 10.5px;
+ letter-spacing: .05em;
+ padding: 1px 6px;
+ border-radius: 3px;
+ border: 1px solid var(--line);
+ color: var(--muted);
+ white-space: nowrap;
+ }
+ .ty-project { color: var(--amber); border-color: var(--amber-lo); background: var(--amber-bg); }
+ .ty-user { color: var(--focus); border-color: var(--focus); background: transparent; }
+ .ty-feedback { color: var(--copper, var(--amber)); border-color: var(--amber-lo); }
+ .ty-reference { color: var(--muted); }
+
+ /* Una memoria fuera de MEMORY.md sigue en disco pero no se carga en contexto. */
+ .chip-unlisted { color: var(--amber); border-color: var(--amber-lo); background: var(--amber-bg); }
+
+ .mem-body {
+ font-size: 14.5px;
+ line-height: 1.68;
+ color: var(--ink-soft);
+ white-space: pre-wrap;
+ overflow-wrap: anywhere;
+ }
+ .mem-body pre {
+ margin: 10px 0;
+ padding: 10px 12px;
+ background: var(--surface);
+ border: 1px solid var(--line);
+ border-radius: 6px;
+ overflow-x: auto;
+ font-family: var(--mono);
+ font-size: 12.5px;
+ white-space: pre;
+ color: var(--ink);
+ }
+ .mem-body code {
+ font-family: var(--mono);
+ font-size: .87em;
+ background: var(--surface);
+ border: 1px solid var(--line-soft);
+ border-radius: 4px;
+ padding: 1px 4px;
+ }
+ .mem-body pre code { background: none; border: 0; padding: 0; font-size: inherit; }
+ .mem-body strong { color: var(--ink); font-weight: 600; }
+ .mem-body .h { display: block; margin: 10px 0 -2px; font-weight: 620; color: var(--ink); }
+
+ .wl {
+ font-family: var(--mono);
+ font-size: .9em;
+ color: var(--amber);
+ background: var(--amber-bg);
+ border: 1px solid var(--amber-lo);
+ border-radius: 4px;
+ padding: 0 4px;
+ cursor: pointer;
+ }
+ .wl.dead { color: var(--faint); border-color: var(--line); background: none; cursor: default; }
+
+ .mem-foot {
+ margin-top: 22px;
+ padding-top: 14px;
+ border-top: 1px solid var(--line);
+ display: flex;
+ flex-direction: column;
+ gap: 8px;
+ font-family: var(--mono);
+ font-size: 11.5px;
+ color: var(--muted);
+ }
+ .mem-foot .lbl { color: var(--faint); margin-right: 6px; }
+
+ .jump {
+ align-self: flex-start;
+ font-family: var(--mono);
+ font-size: 11.5px;
+ color: var(--muted);
+ background: var(--raised);
+ border: 1px solid var(--line);
+ border-radius: 6px;
+ padding: 6px 10px;
+ cursor: pointer;
+ }
+ .jump:hover { color: var(--amber); border-color: var(--amber-lo); background: var(--amber-bg); }
+
+ @media (max-width: 860px) {
+ .row.mem { grid-template-columns: 3px 1fr auto; }
+ .row.mem .cell-ty { grid-column: 2; padding-bottom: 10px; }
+ .row.mem .cell-proj { display: none; }
+ }
+
+ @media (prefers-reduced-motion: reduce) {
+ * { transition: none !important; }
+ }
+</style>
+</head>
+
+<body>
+<div class="wrap">
+ <header class="masthead">
+ <span class="eyebrow">~/.claude/projects</span>
+ <h1>Tus sesiones de Claude Code</h1>
+ <p class="lede">Cada conversación queda en un <code>.jsonl</code> local. Hacé clic en cualquier fila para leerla, o copiá el comando para retomarla — el <code>--resume</code> solo encuentra la sesión desde su directorio original, así que el botón copia el <code>cd</code> también.</p>
+ </header>
+
+ <noscript>
+ <p class="noscript">Esta página arma la lista con JavaScript. Con JavaScript
+ desactivado no se ve nada — los datos igual están adentro del archivo, en el
+ <code>&lt;script id="payload"&gt;</code>.</p>
+ </noscript>
+
+ <div class="tabs" role="tablist" aria-label="Qué mirar">
+ <button type="button" class="tab" role="tab" data-mode="s" aria-selected="true">
+ Sesiones <span class="n" id="nS"></span>
+ </button>
+ <button type="button" class="tab" role="tab" data-mode="m" aria-selected="false">
+ Memorias <span class="n" id="nM"></span>
+ </button>
+ </div>
+
+ <div class="stats" id="stats"></div>
+
+ <div class="toolbar">
+ <div class="field">
+ <svg width="14" height="14" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.6"><circle cx="7" cy="7" r="4.5"/><path d="M10.5 10.5 14 14"/></svg>
+ <input type="search" id="q" placeholder="buscar título, ruta o uuid… (/)" autocomplete="off" spellcheck="false" aria-label="Buscar sesiones">
+ </div>
+ <select id="proj" aria-label="Filtrar por proyecto"></select>
+ <label class="toggle only-s"><input type="checkbox" id="deep"> buscar dentro del chat</label>
+ <label class="toggle only-s"><input type="checkbox" id="hideEmpty"> ocultar vacías</label>
+ <select id="mtype" class="only-m" aria-label="Filtrar por tipo de memoria"></select>
+ <label class="toggle only-m"><input type="checkbox" id="unlisted"> solo fuera del índice</label>
+ <button type="button" class="tbtn" id="theme" title="Cambiar entre claro y oscuro" aria-label="Cambiar tema">
+ <svg class="moon" width="14" height="14" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.4"><path d="M13.5 9.6A5.8 5.8 0 0 1 6.4 2.5a5.8 5.8 0 1 0 7.1 7.1Z"/></svg>
+ <svg class="sun" width="14" height="14" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.4"><circle cx="8" cy="8" r="3.1"/><path d="M8 1v1.6M8 13.4V15M1 8h1.6M13.4 8H15M3.1 3.1l1.1 1.1M11.8 11.8l1.1 1.1M12.9 3.1l-1.1 1.1M4.2 11.8l-1.1 1.1"/></svg>
+ </button>
+ </div>
+
+ <div class="grid" role="table" aria-label="Sesiones de Claude Code">
+ <div class="row head only-s" role="row">
+ <span></span>
+ <button type="button" data-sort="t" class="pad-l">Sesión <span class="car">▾</span></button>
+ <button type="button" data-sort="l">Fecha <span class="car">▾</span></button>
+ <button type="button" data-sort="u" class="num">Msgs <span class="car">▾</span></button>
+ <button type="button" data-sort="d" class="num">Dur. <span class="car">▾</span></button>
+ <span class="pad-r" style="text-align:right">Reanudar</span>
+ </div>
+ <div class="row head mem only-m" role="row">
+ <span></span>
+ <button type="button" data-msort="name" class="pad-l">Memoria <span class="car">▾</span></button>
+ <button type="button" data-msort="ty">Tipo <span class="car">▾</span></button>
+ <button type="button" data-msort="p">Proyecto <span class="car">▾</span></button>
+ <button type="button" data-msort="l">Fecha <span class="car">▾</span></button>
+ </div>
+ <div id="rows"></div>
+ </div>
+
+ <p class="count" id="count"></p>
+
+ <div class="legend only-s">
+ <span>Franja izquierda = antigüedad:</span>
+ <span><i style="background:var(--amber)"></i>hoy / ayer</span>
+ <span><i style="background:var(--amber);opacity:.55"></i>última semana</span>
+ <span><i style="background:var(--amber);opacity:.26"></i>dos semanas</span>
+ <span><i style="background:var(--line)"></i>más viejo</span>
+ </div>
+
+ <div class="legend only-m">
+ <span><span class="chip chip-unlisted">fuera del índice</span> = está en disco pero no figura en MEMORY.md, así que no se carga en contexto</span>
+ </div>
+
+ <div class="foot only-m">
+ <p>Cada proyecto guarda sus recuerdos en <code>&lt;proyecto&gt;/memory/</code>: un <code>.md</code> por memoria y un <code>MEMORY.md</code> que los indexa. El índice es lo único que se lee al arrancar una sesión.</p>
+ <p>Los tipos los define Claude al escribirlas: <b>project</b> es trabajo en curso, <b>user</b> quién sos y cómo trabajás, <b>feedback</b> correcciones tuyas, <b>reference</b> punteros a recursos externos.</p>
+ </div>
+
+ <div class="foot only-s">
+ <p>Los títulos los genera Claude durante la sesión. Cuando falta, cae al primer mensaje tuyo — y ahí se nota, porque arranca en minúscula o suena a pregunta suelta.</p>
+ <p><b>Vacía</b> es una sesión que se abrió pero nunca recibió un mensaje: un <code>/resume</code> cancelado, un <code>/login</code>. <b>No interactiva</b> es un <code>claude -p</code> con algo piped por stdin — típicamente un <code>git diff</code> para redactar el mensaje de commit, no un chat.</p>
+ <p>La transcripción trae el texto de la conversación y una línea por herramienta usada, pero no lo que esas herramientas devolvieron: son el 95 % del volumen en disco.</p>
+ <p id="snap"></p>
+ </div>
+</div>
+
+<div class="scrim" id="scrim"></div>
+
+<aside class="reader" id="reader" role="dialog" aria-modal="true" aria-labelledby="rTitle" tabindex="-1">
+ <div class="reader-head">
+ <div class="rh-text">
+ <h2 id="rTitle"></h2>
+ <div class="meta" id="rMeta"></div>
+ </div>
+ <div class="rh-acts">
+ <button type="button" class="xbtn" id="rCopy" title="Copiar comando para reanudar" aria-label="Copiar comando para reanudar">
+ <svg width="13" height="13" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5"><rect x="5.5" y="5.5" width="8" height="9" rx="1.5"/><path d="M10.5 3.5H3a.5.5 0 0 0-.5.5v8"/></svg>
+ </button>
+ <button type="button" class="xbtn" id="rClose" title="Cerrar (Esc)" aria-label="Cerrar">
+ <svg width="13" height="13" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.6"><path d="m4 4 8 8M12 4l-8 8"/></svg>
+ </button>
+ </div>
+ </div>
+ <div class="transcript" id="rBody"></div>
+</aside>
+
+<div class="toast" id="toast" role="status" aria-live="polite"></div>
+
+<script id="payload" type="application/json">__DATA__</script>
+<script>
+const PAYLOAD = JSON.parse(document.getElementById('payload').textContent);
+const DATA = PAYLOAD.s || [];
+const MEM = PAYLOAD.m || [];
+// Instantánea = la actividad más reciente de los datos, para que "hoy" siga siendo
+// cierto respecto de cuándo se leyeron los logs y no del reloj de quien mira.
+const NOW = new Date(Math.max(
+ ...DATA.map(d => +new Date(d.l)), ...MEM.map(m => +new Date(m.l))));
+const BY_ID = new Map(DATA.map(d => [d.id, d]));
+const BY_NAME = new Map(MEM.map(m => [m.name, m]));
+// Los enlaces [[...]] pueden apuntar al nombre declarado o al del archivo.
+MEM.forEach(m => { const f = m.file.replace(/\.md$/, ''); if (!BY_NAME.has(f)) BY_NAME.set(f, m); });
+
+const $ = s => document.querySelector(s);
+const rowsEl = $('#rows'), qEl = $('#q'), projEl = $('#proj'), deepEl = $('#deep'),
+ emptyEl = $('#hideEmpty'), countEl = $('#count'), toastEl = $('#toast'),
+ readerEl = $('#reader'), scrimEl = $('#scrim'), bodyEl = $('#rBody'),
+ typeEl = $('#mtype'), unlistedEl = $('#unlisted');
+
+let sortKey = 'l', sortDir = -1, lastFocus = null;
+let mSortKey = 'l', mSortDir = -1;
+// Qué hay abierto en el lector: {kind: 's'|'m', key} o null.
+let open_ = null;
+// Sin memorias la pestaña no aporta nada, así que arrancamos siempre en sesiones.
+let mode = 's';
+
+/* ---------- formato ---------- */
+
+const DAY = 864e5;
+const MES = ['ene','feb','mar','abr','may','jun','jul','ago','sep','oct','nov','dic'];
+const pad = n => String(n).padStart(2, '0');
+
+const daysAgo = iso => (NOW - new Date(iso)) / DAY;
+const fmtDate = iso => { const d = new Date(iso); return `${pad(d.getDate())} ${MES[d.getMonth()]}`; };
+const fmtTime = iso => { const d = new Date(iso); return `${pad(d.getHours())}:${pad(d.getMinutes())}`; };
+
+function fmtRel(iso) {
+ const n = daysAgo(iso);
+ if (n < 1) return 'hoy';
+ if (n < 2) return 'ayer';
+ if (n < 7) return `hace ${Math.floor(n)} d`;
+ if (n < 30) return `hace ${Math.floor(n / 7)} sem`;
+ return `hace ${Math.floor(n / 30)} mes`;
+}
+function fmtDur(m) {
+ if (m == null) return '—';
+ if (m < 1) return '<1m';
+ if (m < 60) return m + 'm';
+ const h = Math.floor(m / 60), r = m % 60;
+ return r ? `${h}h${pad(r)}` : `${h}h`;
+}
+function stripeFor(iso) {
+ const n = daysAgo(iso);
+ if (n < 2) return 'var(--amber)';
+ if (n < 7) return 'color-mix(in srgb, var(--amber) 55%, transparent)';
+ if (n < 14) return 'color-mix(in srgb, var(--amber) 26%, transparent)';
+ return 'var(--line)';
+}
+
+const esc = s => String(s).replace(/[&<>"']/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
+
+// Resalta la primera coincidencia. La aguja se escapa igual que el pajar: si
+// no, buscar "&" o "<" nunca encontraría nada, porque en `s` ya son entidades.
+function mark(text, q) {
+ const s = esc(text);
+ if (!q) return s;
+ const needle = esc(q);
+ const i = s.toLowerCase().indexOf(needle.toLowerCase());
+ if (i < 0) return s;
+ return s.slice(0, i) + '<mark>' + s.slice(i, i + needle.length) + '</mark>'
+ + s.slice(i + needle.length);
+}
+
+// Markdown mínimo: código, negritas y títulos. Los saltos los resuelve pre-wrap.
+// El código se guarda aparte antes de tocar negritas, para que un ** dentro de
+// un bloque de código quede tal cual.
+function renderBody(text, wikilinks) {
+ const stash = [];
+ // Tras esc() no queda ningún "<" crudo en el texto: todos son &lt;. Por eso un
+ // marcador con "<" no puede colisionar con el contenido del mensaje.
+ const keep = html => `<K${stash.push(html) - 1}>`;
+
+ let out = esc(text);
+ out = out.replace(/```[a-zA-Z0-9_+-]*\n?([\s\S]*?)```/g,
+ (_, code) => keep(`<pre>${code.replace(/\n+$/, '')}</pre>`));
+ out = out.replace(/`([^`\n]+)`/g, (_, code) => keep(`<code>${code}</code>`));
+ out = out.replace(/^#{1,6}\s+(.+)$/gm, '<b class="h">$1</b>');
+ out = out.replace(/\*\*([^*\n]+)\*\*/g, '<strong>$1</strong>');
+ if (wikilinks) {
+ // Va acá adentro, con el código ya guardado aparte: un [[...]] dentro de un
+ // bloque de código tiene que quedar como texto.
+ out = out.replace(/\[\[([^\]\n]+)\]\]/g, (_, name) => {
+ const hit = BY_NAME.get(name);
+ return hit
+ ? `<button type="button" class="wl" data-wl="${esc(hit.name)}">${esc(name)}</button>`
+ : `<span class="wl dead" title="todavía no existe una memoria con ese nombre">${esc(name)}</span>`;
+ });
+ }
+
+ return out.replace(/<K(\d+)>/g, (_, i) => stash[i]);
+}
+
+/* ---------- cabecera ---------- */
+
+(function stats() {
+ const msgs = DATA.reduce((a, d) => a + d.u, 0);
+ const mb = DATA.reduce((a, d) => a + d.k, 0) / 1024;
+ const ds = DATA.map(d => new Date(d.l)).sort((a, b) => a - b);
+ const f = ds[0], l = ds[ds.length - 1];
+ $('#stats').innerHTML = [
+ ['sesiones', DATA.length, ''],
+ ['proyectos', new Set(DATA.map(d => d.p)).size, ''],
+ ['tus mensajes', msgs, ''],
+ ['en disco', mb.toFixed(1), ' MB'],
+ ['período', `${pad(f.getDate())} ${MES[f.getMonth()]} – ${pad(l.getDate())} ${MES[l.getMonth()]}`, ''],
+ ['memorias', MEM.length, ''],
+ ].map(([k, v, s]) => `<div class="stat"><span class="stat-k">${k}</span><span class="stat-v">${v}${s ? `<small>${s}</small>` : ''}</span></div>`).join('');
+})();
+
+function fillProjects() {
+ const src = mode === 'm' ? MEM : DATA;
+ const counts = {};
+ src.forEach(d => counts[d.p] = (counts[d.p] || 0) + 1);
+ const label = mode === 'm' ? 'memorias' : 'sesiones';
+ projEl.innerHTML = `<option value="">todos los proyectos (${src.length} ${label})</option>` +
+ Object.entries(counts).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+ .map(([p, n]) => `<option value="${esc(p)}">${esc(p)} · ${n}</option>`).join('');
+}
+
+(function types() {
+ const counts = {};
+ MEM.forEach(m => counts[m.ty] = (counts[m.ty] || 0) + 1);
+ typeEl.innerHTML = `<option value="">todos los tipos (${MEM.length})</option>` +
+ Object.entries(counts).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+ .map(([t, n]) => `<option value="${esc(t)}">${esc(t)} · ${n}</option>`).join('');
+})();
+
+$('#nS').textContent = DATA.length;
+$('#nM').textContent = MEM.length;
+
+/* ---------- lista ---------- */
+
+function convoText(d) {
+ if (d._flat === undefined) d._flat = d.c.map(m => m.x).join('\n').toLowerCase();
+ return d._flat;
+}
+
+function snippetFor(d, q) {
+ for (const m of d.c) {
+ const i = m.x.toLowerCase().indexOf(q);
+ if (i < 0) continue;
+ const from = Math.max(0, i - 55);
+ const raw = m.x.slice(from, i + q.length + 75).replace(/\s+/g, ' ');
+ return (from ? '…' : '') + raw + '…';
+ }
+ return null;
+}
+
+function current() {
+ const q = qEl.value.trim().toLowerCase();
+ const proj = projEl.value;
+ const deep = deepEl.checked;
+
+ const list = DATA.filter(d => {
+ if (proj && d.p !== proj) return false;
+ if (emptyEl.checked && d.e) return false;
+ if (!q) return true;
+ if ((d.t || '').toLowerCase().includes(q) || d.p.toLowerCase().includes(q)
+ || d.id.toLowerCase().includes(q) || (d.b || '').toLowerCase().includes(q)) return true;
+ return deep && convoText(d).includes(q);
+ });
+
+ const k = sortKey;
+ list.sort((a, b) => {
+ if (k === 't') {
+ const av = (a.t || '~').toLowerCase(), bv = (b.t || '~').toLowerCase();
+ return av < bv ? -sortDir : av > bv ? sortDir : 0;
+ }
+ const av = k === 'l' ? new Date(a.l) : (a[k] ?? -1);
+ const bv = k === 'l' ? new Date(b.l) : (b[k] ?? -1);
+ return (av - bv) * sortDir;
+ });
+ return list;
+}
+
+function renderSessions() {
+ const list = current();
+ const q = qEl.value.trim();
+ const ql = q.toLowerCase();
+
+ if (!list.length) {
+ rowsEl.innerHTML = `<div class="none">Ninguna sesión coincide con ese filtro.</div>`;
+ countEl.textContent = '';
+ return;
+ }
+
+ rowsEl.innerHTML = list.map(d => {
+ const inMeta = q && ((d.t || '').toLowerCase().includes(ql) || d.p.toLowerCase().includes(ql));
+ const snip = q && deepEl.checked && !inMeta ? snippetFor(d, ql) : null;
+ const chips = [
+ d.e ? '<span class="chip chip-empty">vacía</span>' : '',
+ d.n ? '<span class="chip chip-auto">no interactiva</span>' : '',
+ d.b && d.b !== 'HEAD' ? `<span class="chip chip-branch">${esc(d.b)}</span>` : '',
+ d.i ? '<span class="chip" title="Ruta deducida de otras sesiones del mismo proyecto">ruta inferida</span>' : '',
+ ].join('');
+
+ return `
+ <div class="row${d.e ? ' empty-row' : ' clickable'}" role="row" data-id="${d.id}"${d.e ? '' : ' tabindex="0"'}>
+ <div class="stripe" style="--stripe:${stripeFor(d.l)}"></div>
+ <div class="r-body">
+ <p class="title">${d.t ? mark(d.t, q) : 'sesión abierta sin mensajes'}</p>
+ <div class="meta"><span class="path" title="${esc(d.p)}">${mark(d.p, q)}</span>${chips}</div>
+ ${snip ? `<p class="snippet">${mark(snip, q)}</p>` : ''}
+ </div>
+ <div class="cell-date">${fmtDate(d.l)}<small>${fmtRel(d.l)} · ${fmtTime(d.l)}</small></div>
+ <div class="cell-n${d.u ? '' : ' dim'}">${d.u || '—'}</div>
+ <div class="cell-n${d.d ? '' : ' dim'}">${fmtDur(d.d)}</div>
+ <div class="cell-act">
+ <button type="button" class="copy" data-copy="${d.id}" title="cd ${esc(d.p)} &amp;&amp; claude --resume ${d.id}">
+ <svg width="11" height="11" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5"><rect x="5.5" y="5.5" width="8" height="9" rx="1.5"/><path d="M10.5 3.5H3a.5.5 0 0 0-.5.5v8"/></svg>
+ <span>${d.id.slice(0, 8)}</span>
+ </button>
+ </div>
+ </div>`;
+ }).join('');
+
+ countEl.textContent = list.length === DATA.length
+ ? `${DATA.length} sesiones · clic en una fila para leerla`
+ : `${list.length} de ${DATA.length} sesiones`;
+}
+
+/* ---------- memorias ---------- */
+
+function currentMem() {
+ const q = qEl.value.trim().toLowerCase();
+ const proj = projEl.value, ty = typeEl.value;
+
+ const list = MEM.filter(m => {
+ if (proj && m.p !== proj) return false;
+ if (ty && m.ty !== ty) return false;
+ if (unlistedEl.checked && m.ix) return false;
+ if (!q) return true;
+ return m.name.toLowerCase().includes(q)
+ || m.desc.toLowerCase().includes(q)
+ || m.p.toLowerCase().includes(q)
+ || m.body.toLowerCase().includes(q);
+ });
+
+ list.sort((a, b) => {
+ const k = mSortKey;
+ if (k === 'l') return (new Date(a.l) - new Date(b.l)) * mSortDir;
+ const av = String(a[k]).toLowerCase(), bv = String(b[k]).toLowerCase();
+ return av < bv ? -mSortDir : av > bv ? mSortDir : 0;
+ });
+ return list;
+}
+
+function renderMem() {
+ const list = currentMem();
+ const q = qEl.value.trim();
+
+ if (!list.length) {
+ rowsEl.innerHTML = `<div class="none">Ninguna memoria coincide con ese filtro.</div>`;
+ countEl.textContent = '';
+ return;
+ }
+
+ rowsEl.innerHTML = list.map(m => `
+ <div class="row mem clickable" role="row" data-mem="${esc(m.name)}" tabindex="0">
+ <div class="stripe" style="--stripe:${stripeFor(m.l)}"></div>
+ <div class="r-body">
+ <div class="mem-name">
+ <span class="nm">${mark(m.name, q)}</span>
+ ${m.ix ? '' : '<span class="chip chip-unlisted">fuera del índice</span>'}
+ </div>
+ ${m.desc ? `<p class="mem-desc">${mark(m.desc, q)}</p>` : ''}
+ </div>
+ <div class="cell-ty"><span class="ty ty-${esc(m.ty)}">${esc(m.ty)}</span></div>
+ <div class="cell-proj meta"><span class="path" title="${esc(m.p)}">${mark(m.p, q)}</span></div>
+ <div class="cell-date">${fmtDate(m.l)}<small>${fmtRel(m.l)}</small></div>
+ </div>`).join('');
+
+ countEl.textContent = list.length === MEM.length
+ ? `${MEM.length} memorias · clic en una para leerla`
+ : `${list.length} de ${MEM.length} memorias`;
+}
+
+function render() {
+ return mode === 'm' ? renderMem() : renderSessions();
+}
+
+function setMode(next) {
+ if (next === mode) return;
+ mode = next;
+ document.body.dataset.mode = mode;
+ document.querySelectorAll('.tab').forEach(t =>
+ t.setAttribute('aria-selected', String(t.dataset.mode === mode)));
+ qEl.placeholder = mode === 'm'
+ ? 'buscar nombre, descripción o contenido… (/)'
+ : 'buscar título, ruta o uuid… (/)';
+ // Los filtros son de otro conjunto: arrastrarlos entre pestañas confunde.
+ projEl.value = '';
+ fillProjects();
+ render();
+}
+
+/* ---------- lector ---------- */
+
+const WHO = { u: 'vos', a: 'claude' };
+
+function showReader() {
+ bodyEl.scrollTop = 0;
+ scrimEl.classList.add('open');
+ readerEl.classList.add('open');
+ document.body.classList.add('locked');
+ readerEl.focus();
+}
+
+function openChat(id) {
+ const d = BY_ID.get(id);
+ if (!d || d.e) return;
+ open_ = { kind: 's', key: id };
+ lastFocus = document.activeElement;
+ $('#rCopy').hidden = false;
+
+ $('#rTitle').textContent = d.t || 'Sesión sin título';
+ $('#rMeta').innerHTML = [
+ `<span class="path">${esc(d.p)}</span>`,
+ `<span>${fmtDate(d.l)} · ${fmtTime(d.l)}</span>`,
+ `<span>${d.u} tuyos / ${d.a} de Claude</span>`,
+ `<span>${fmtDur(d.d)}</span>`,
+ `<span class="chip">${d.id.slice(0, 8)}</span>`,
+ ].join('');
+
+ bodyEl.innerHTML = d.c.length
+ ? d.c.map(m => m.r === 't'
+ ? `<div class="tool"><b>⚒</b><span>${esc(m.x)}</span></div>`
+ : `<div class="turn turn-${m.r}"><span class="who">${WHO[m.r]}</span><div class="bubble">${renderBody(m.x)}</div></div>`
+ ).join('')
+ : `<p class="reader-empty">Esta sesión no tiene mensajes.</p>`;
+
+ if (location.hash.slice(1) !== id) history.replaceState(null, '', '#' + id);
+ showReader();
+}
+
+function openMemory(name) {
+ const m = BY_NAME.get(name);
+ if (!m) return;
+ open_ = { kind: 'm', key: m.name };
+ lastFocus = document.activeElement;
+ // El botón de copiar reanuda una sesión: en una memoria no aplica.
+ $('#rCopy').hidden = true;
+
+ $('#rTitle').textContent = m.name;
+ $('#rMeta').innerHTML = [
+ `<span class="ty ty-${esc(m.ty)}">${esc(m.ty)}</span>`,
+ `<span class="path">${esc(m.p)}</span>`,
+ `<span>${fmtDate(m.l)} · ${fmtTime(m.l)}</span>`,
+ `<span>${m.k} KB</span>`,
+ m.ix ? '' : '<span class="chip chip-unlisted">fuera del índice</span>',
+ ].filter(Boolean).join('');
+
+ const origen = BY_ID.get(m.src);
+ const pie = [];
+ if (m.desc) pie.push(`<div><span class="lbl">descripción</span>${esc(m.desc)}</div>`);
+ pie.push(`<div><span class="lbl">archivo</span>${esc(m.file)}</div>`);
+ if (!m.ix) {
+ pie.push(`<div>${m.hix
+ ? 'No figura en MEMORY.md: sigue en disco, pero no se carga en contexto.'
+ : 'Este proyecto no tiene MEMORY.md, así que no se carga ninguna de sus memorias.'}</div>`);
+ }
+ if (m.src) {
+ pie.push(origen
+ ? `<button type="button" class="jump" data-chat="${esc(m.src)}">↩ la escribió esta sesión: ${esc(origen.t || m.src.slice(0, 8))}</button>`
+ : `<div><span class="lbl">la escribió</span>la sesión ${esc(m.src.slice(0, 8))}, que ya no está en disco</div>`);
+ }
+
+ bodyEl.innerHTML = `<div class="mem-body">${renderBody(m.body, true)}</div>`
+ + `<div class="mem-foot">${pie.join('')}</div>`;
+
+ const hash = 'm:' + m.name;
+ if (decodeURIComponent(location.hash.slice(1)) !== hash) {
+ history.replaceState(null, '', '#' + encodeURIComponent(hash));
+ }
+ showReader();
+}
+
+function closeReader() {
+ if (!open_) return;
+ open_ = null;
+ if (location.hash) history.replaceState(null, '', location.pathname + location.search);
+ scrimEl.classList.remove('open');
+ readerEl.classList.remove('open');
+ document.body.classList.remove('locked');
+ if (lastFocus && document.contains(lastFocus)) lastFocus.focus();
+}
+
+function openFromHash() {
+ const ref = decodeURIComponent(location.hash.slice(1));
+ if (!ref) return;
+ if (ref.startsWith('m:')) {
+ const name = ref.slice(2);
+ if (BY_NAME.has(name)) { setMode('m'); openMemory(name); }
+ } else if (BY_ID.has(ref)) {
+ openChat(ref);
+ }
+}
+
+// El diálogo es aria-modal: el foco tiene que quedar adentro mientras está abierto.
+readerEl.addEventListener('keydown', e => {
+ if (e.key !== 'Tab') return;
+ const f = [...readerEl.querySelectorAll('button, [tabindex]:not([tabindex="-1"])')]
+ .filter(el => el.offsetParent !== null);
+ if (!f.length) return;
+ const first = f[0], last = f[f.length - 1];
+ if (e.shiftKey && (document.activeElement === first || document.activeElement === readerEl)) {
+ e.preventDefault(); last.focus();
+ } else if (!e.shiftKey && document.activeElement === last) {
+ e.preventDefault(); first.focus();
+ }
+});
+
+/* ---------- copiar ---------- */
+
+const cmdFor = d => `cd ${d.p} && claude --resume ${d.id}`;
+
+function copyText(text) {
+ if (navigator.clipboard && window.isSecureContext) return navigator.clipboard.writeText(text);
+ return new Promise((res, rej) => {
+ const ta = document.createElement('textarea');
+ ta.value = text;
+ ta.style.cssText = 'position:fixed;opacity:0;top:0;left:0';
+ document.body.appendChild(ta);
+ ta.select();
+ try { document.execCommand('copy') ? res() : rej(); }
+ catch (e) { rej(e); }
+ finally { ta.remove(); }
+ });
+}
+
+let toastTimer;
+function toast(msg) {
+ toastEl.textContent = msg;
+ toastEl.classList.add('show');
+ clearTimeout(toastTimer);
+ toastTimer = setTimeout(() => toastEl.classList.remove('show'), 2600);
+}
+
+function copyFor(d, btn) {
+ if (!d) return;
+ copyText(cmdFor(d)).then(() => {
+ if (btn) { btn.classList.add('done'); setTimeout(() => btn.classList.remove('done'), 1400); }
+ toast('Copiado: ' + cmdFor(d));
+ }).catch(() => toast('No se pudo copiar — el comando está en el tooltip'));
+}
+
+/* ---------- eventos ---------- */
+
+rowsEl.addEventListener('click', e => {
+ const copyBtn = e.target.closest('[data-copy]');
+ if (copyBtn) {
+ e.stopPropagation();
+ copyFor(BY_ID.get(copyBtn.dataset.copy), copyBtn);
+ return;
+ }
+ const row = e.target.closest('.row.clickable');
+ if (!row) return;
+ if (row.dataset.mem) openMemory(row.dataset.mem);
+ else openChat(row.dataset.id);
+});
+
+rowsEl.addEventListener('keydown', e => {
+ if (e.key !== 'Enter' && e.key !== ' ') return;
+ const row = e.target.closest('.row.clickable');
+ if (!row || e.target.closest('[data-copy]')) return;
+ e.preventDefault();
+ if (row.dataset.mem) openMemory(row.dataset.mem);
+ else openChat(row.dataset.id);
+});
+
+// Dentro del lector: enlaces [[...]] entre memorias y salto a la sesión de origen.
+bodyEl.addEventListener('click', e => {
+ const wl = e.target.closest('[data-wl]');
+ if (wl) { openMemory(wl.dataset.wl); return; }
+ const jump = e.target.closest('[data-chat]');
+ if (jump) { setMode('s'); openChat(jump.dataset.chat); }
+});
+
+$('#rClose').addEventListener('click', closeReader);
+scrimEl.addEventListener('click', closeReader);
+$('#rCopy').addEventListener('click', e => {
+ if (open_ && open_.kind === 's') copyFor(BY_ID.get(open_.key), e.currentTarget);
+});
+
+document.addEventListener('keydown', e => {
+ if (e.key === 'Escape') {
+ if (open_) closeReader();
+ else if (document.activeElement === qEl && qEl.value) { qEl.value = ''; render(); }
+ return;
+ }
+ if (open_) return;
+ const typing = /^(INPUT|SELECT|TEXTAREA)$/.test(document.activeElement.tagName);
+ if ((e.key === '/' && !typing) || (e.key.toLowerCase() === 'k' && (e.metaKey || e.ctrlKey))) {
+ e.preventDefault();
+ qEl.focus();
+ qEl.select();
+ }
+});
+
+$('#theme').addEventListener('click', () => {
+ const next = document.documentElement.dataset.theme === 'dark' ? 'light' : 'dark';
+ document.documentElement.dataset.theme = next;
+ try { localStorage.setItem('cs-tema', next); } catch (e) {}
+});
+
+document.querySelectorAll('[data-sort]').forEach(btn => {
+ btn.addEventListener('click', () => {
+ const k = btn.dataset.sort;
+ if (sortKey === k) sortDir = -sortDir;
+ else { sortKey = k; sortDir = k === 't' ? 1 : -1; }
+ document.querySelectorAll('[data-sort]').forEach(b => b.removeAttribute('aria-sort'));
+ btn.setAttribute('aria-sort', sortDir === 1 ? 'ascending' : 'descending');
+ btn.querySelector('.car').textContent = sortDir === 1 ? '▴' : '▾';
+ render();
+ });
+});
+document.querySelector('[data-sort="l"]').setAttribute('aria-sort', 'descending');
+
+document.querySelectorAll('[data-msort]').forEach(btn => {
+ btn.addEventListener('click', () => {
+ const k = btn.dataset.msort;
+ if (mSortKey === k) mSortDir = -mSortDir;
+ else { mSortKey = k; mSortDir = k === 'l' ? -1 : 1; }
+ document.querySelectorAll('[data-msort]').forEach(b => b.removeAttribute('aria-sort'));
+ btn.setAttribute('aria-sort', mSortDir === 1 ? 'ascending' : 'descending');
+ btn.querySelector('.car').textContent = mSortDir === 1 ? '▴' : '▾';
+ render();
+ });
+});
+document.querySelector('[data-msort="l"]').setAttribute('aria-sort', 'descending');
+
+document.querySelectorAll('.tab').forEach(t =>
+ t.addEventListener('click', () => setMode(t.dataset.mode)));
+
+// Sin memorias la pestaña no tiene nada que mostrar.
+if (!MEM.length) document.querySelector('.tab[data-mode="m"]').hidden = true;
+
+$('#snap').textContent = `Instantánea leída el ${pad(NOW.getDate())} ${MES[NOW.getMonth()]} ${NOW.getFullYear()} a las ${fmtTime(NOW.toISOString())}. Las fechas relativas son respecto de ese momento; volvé a correr claude-logbook --html para actualizarla.`;
+
+[qEl, projEl, deepEl, emptyEl, typeEl, unlistedEl].forEach(
+ el => el.addEventListener(el === qEl ? 'input' : 'change', render));
+
+document.body.dataset.mode = mode;
+fillProjects();
+render();
+openFromHash();
+</script>
+</body>
+</html>
diff --git a/claude_logbook/terminal.py b/claude_logbook/terminal.py
new file mode 100644
index 0000000..1b56770
--- /dev/null
+++ b/claude_logbook/terminal.py
@@ -0,0 +1,372 @@
+"""Salida para la terminal: colores, tabla y lectura de una conversación."""
+
+import os
+import re
+import shutil
+import subprocess
+import sys
+import textwrap
+
+from .sessions import parse_ts
+
+MES = ["ene", "feb", "mar", "abr", "may", "jun",
+ "jul", "ago", "sep", "oct", "nov", "dic"]
+
+ANSI_RE = re.compile(r"\x1b\[[0-9;]*m")
+
+# Anchos mínimos de terminal para mostrar cada columna opcional.
+MIN_COLS_PATH = 92
+MIN_COLS_DUR = 74
+
+
+class Style:
+ """Códigos ANSI, o cadenas vacías si la salida no es una terminal."""
+
+ CODES = {
+ "reset": "0", "bold": "1", "dim": "2", "italic": "3",
+ "amber": "38;5;179", "copper": "38;5;173", "grey": "38;5;245",
+ "faint": "38;5;240", "ink": "38;5;252", "blue": "38;5;110",
+ # barra de antigüedad, del ámbar vivo al gris
+ "age0": "38;5;214", "age1": "38;5;179",
+ "age2": "38;5;137", "age3": "38;5;239",
+ }
+
+ def __init__(self, enabled):
+ self.on = enabled
+
+ def __getattr__(self, name):
+ try:
+ code = self.CODES[name]
+ except KeyError:
+ raise AttributeError(name) from None
+ return f"\x1b[{code}m" if self.on else ""
+
+ @classmethod
+ def from_stream(cls, stream, no_color=False):
+ """Color solo si hay terminal, no lo desactivaron y no hay NO_COLOR."""
+ return cls(bool(getattr(stream, "isatty", lambda: False)())
+ and not no_color
+ and not os.environ.get("NO_COLOR"))
+
+
+# ──────────────────────────────── formato ────────────────────────────────
+
+def visible_len(s):
+ return len(ANSI_RE.sub("", s))
+
+
+def clip(s, width):
+ """Recorta a `width` columnas, con … si no entra."""
+ s = s.replace("\n", " ")
+ if len(s) <= width:
+ return s
+ return s[: max(0, width - 1)] + "…"
+
+
+def fmt_date(iso):
+ d = parse_ts(iso).astimezone()
+ return f"{d.day:02d} {MES[d.month - 1]}"
+
+
+def fmt_time(iso):
+ return parse_ts(iso).astimezone().strftime("%H:%M")
+
+
+def fmt_rel(iso, now):
+ n = (now - parse_ts(iso)).total_seconds() / 86400
+ if n < 1:
+ return "hoy"
+ if n < 2:
+ return "ayer"
+ if n < 7:
+ return f"hace {int(n)}d"
+ if n < 30:
+ return f"hace {int(n // 7)}sem"
+ return f"hace {int(n // 30)}mes"
+
+
+def plural(n, singular, plural_):
+ return f"{n} {singular if n == 1 else plural_}"
+
+
+def fmt_dur(m):
+ if m is None:
+ return "—"
+ if m < 1:
+ return "<1m"
+ if m < 60:
+ return f"{m}m"
+ h, r = divmod(m, 60)
+ return f"{h}h{r:02d}" if r else f"{h}h"
+
+
+def fmt_size(kb):
+ return f"{kb / 1024:.1f} MB" if kb >= 1024 else f"{kb:.1f} KB"
+
+
+def stripe(iso, now, st):
+ """Barra de antigüedad a la izquierda de cada fila."""
+ if not st.on:
+ return "|"
+ n = (now - parse_ts(iso)).total_seconds() / 86400
+ color = st.age0 if n < 2 else st.age1 if n < 7 else st.age2 if n < 14 else st.age3
+ return f"{color}▌{st.reset}"
+
+
+# ──────────────────────────────── tabla ────────────────────────────────
+
+def print_table(sessions, st, now, out, width=None):
+ width = width or shutil.get_terminal_size((100, 24)).columns
+ show_path = width >= MIN_COLS_PATH
+ show_dur = width >= MIN_COLS_DUR
+
+ # columnas fijas: idx(3) barra(1) fecha(6) rel(9) msgs(4) dur(6) id(8) + gaps
+ fixed = 3 + 1 + 6 + 9 + 4 + (6 if show_dur else 0) + 8
+ gaps = 7 if show_dur else 6
+ flex = max(24, width - fixed - gaps)
+ w_title = int(flex * 0.58) if show_path else flex
+ w_path = flex - w_title - 1 if show_path else 0
+
+ head = [
+ f"{'#':>3}", " ",
+ f"{st.faint}{'SESIÓN':<{w_title}}{st.reset}",
+ ]
+ if show_path:
+ head.append(f"{st.faint}{'RUTA':<{w_path}}{st.reset}")
+ head.append(f"{st.faint}{'FECHA':<6} {'CUÁNDO':<9}{st.reset}")
+ head.append(f"{st.faint}{'MSG':>4}{st.reset}")
+ if show_dur:
+ head.append(f"{st.faint}{'DUR':>6}{st.reset}")
+ head.append(f"{st.faint}{'ID':<8}{st.reset}")
+ print(" ".join(head), file=out)
+
+ for i, s in enumerate(sessions, 1):
+ title = s["t"] or "sesión abierta sin mensajes"
+ tcolor = st.dim + st.italic if s["e"] else (st.ink if s["ai"] else "")
+ tags = ""
+ if s["e"]:
+ tags = f" {st.faint}[vacía]{st.reset}"
+ elif s["n"]:
+ tags = f" {st.faint}[auto]{st.reset}"
+
+ avail = w_title - visible_len(tags)
+ cells = [
+ f"{st.faint}{i:>3}{st.reset}",
+ stripe(s["l"], now, st),
+ f"{tcolor}{clip(title, avail):<{avail}}{st.reset}{tags}",
+ ]
+ if show_path:
+ cells.append(f"{st.grey}{clip(s['p'], w_path):<{w_path}}{st.reset}")
+ cells.append(
+ f"{fmt_date(s['l']):<6} {st.faint}{fmt_rel(s['l'], now):<9}{st.reset}"
+ )
+ cells.append(f"{s['u'] or '—':>4}")
+ if show_dur:
+ cells.append(f"{st.grey}{fmt_dur(s['d']):>6}{st.reset}")
+ cells.append(f"{st.faint}{s['id'][:8]}{st.reset}")
+ print(" ".join(cells), file=out)
+
+
+# ──────────────────────────── una conversación ────────────────────────────
+
+def strip_md(text):
+ """Markdown mínimo para la terminal: saca ** y marcadores de título."""
+ text = re.sub(r"^#{1,6}\s+", "", text, flags=re.M)
+ return re.sub(r"\*\*([^*\n]+)\*\*", r"\1", text)
+
+
+def render_block(text, st, width, code_color):
+ """Formatea un mensaje respetando las cercas de código."""
+ lines = []
+ in_code = False
+ for raw in text.split("\n"):
+ if raw.lstrip().startswith("```"):
+ in_code = not in_code
+ continue
+ if in_code:
+ lines.append(f" {code_color}{raw}{st.reset}")
+ elif not raw.strip():
+ lines.append("")
+ else:
+ wrapped = textwrap.wrap(
+ strip_md(raw), width=width,
+ break_long_words=False, break_on_hyphens=False,
+ )
+ lines.extend(" " + w for w in (wrapped or [""]))
+ return lines
+
+
+def print_chat(s, st, out, show_tools=True, width=None):
+ width = min(width or shutil.get_terminal_size((100, 24)).columns, 100)
+ body = width - 2
+
+ print(f"{st.amber}{st.bold}{s['t'] or 'Sesión sin título'}{st.reset}", file=out)
+ meta = (f"{s['p']} · {fmt_date(s['l'])} {fmt_time(s['l'])} · "
+ f"{s['u']} tuyos / {s['a']} de Claude · {fmt_dur(s['d'])}")
+ print(f"{st.faint}{meta}{st.reset}", file=out)
+ print(f"{st.faint}{resume_cmd(s)}{st.reset}", file=out)
+ print(f"{st.faint}{'─' * min(width, 80)}{st.reset}\n", file=out)
+
+ if not s["c"]:
+ print(f"{st.dim}Esta sesión no tiene mensajes.{st.reset}", file=out)
+ return
+
+ first = True
+ for m in s["c"]:
+ if m["r"] == "t":
+ if show_tools:
+ print(f" {st.faint}⚒ {clip(m['x'], body - 4)}{st.reset}", file=out)
+ first = False
+ continue
+
+ # La separación va antes de cada turno: así una tanda de herramientas
+ # queda pegada al mensaje que la lanzó y separada del siguiente.
+ if not first:
+ print(file=out)
+ first = False
+
+ who = "vos" if m["r"] == "u" else "claude"
+ color = st.amber if m["r"] == "u" else st.blue
+ print(f"{color}{who}{st.reset}", file=out)
+ for line in render_block(m["x"], st, body, st.grey):
+ print(line, file=out)
+
+
+def resume_cmd(s):
+ """El --resume solo encuentra la sesión desde su directorio original."""
+ return f"cd {s['p']} && claude --resume {s['id']}"
+
+
+def pager(text):
+ """Manda el texto a $PAGER si hay terminal; si no, a stdout."""
+ if not sys.stdout.isatty():
+ sys.stdout.write(text)
+ return
+ cmd = os.environ.get("PAGER", "less")
+ args = [cmd, "-R", "-F", "-X"] if os.path.basename(cmd) == "less" else [cmd]
+ try:
+ p = subprocess.Popen(args, stdin=subprocess.PIPE)
+ p.communicate(text.encode())
+ except (OSError, BrokenPipeError):
+ sys.stdout.write(text)
+
+
+# ──────────────────────────────── memorias ────────────────────────────────
+
+# Anchos mínimos para las columnas opcionales de la tabla de memorias.
+MIN_COLS_MEM_PROJECT = 78
+MIN_COLS_MEM_DESC = 104
+
+TYPE_COLOR = {"project": "amber", "user": "blue",
+ "feedback": "copper", "reference": "grey"}
+
+
+def print_memories(memories, st, now, out, width=None):
+ width = width or shutil.get_terminal_size((100, 24)).columns
+ show_project = width >= MIN_COLS_MEM_PROJECT
+ show_desc = width >= MIN_COLS_MEM_DESC
+
+ # columnas fijas: idx(3) tipo(9) fecha(6) cuándo(9) + separadores
+ fixed = 3 + 9 + 6 + 9
+ gaps = 4 + (1 if show_project else 0) + (1 if show_desc else 0)
+ flex = max(18, width - fixed - gaps)
+ if show_desc:
+ w_name, w_project = int(flex * 0.34), int(flex * 0.28)
+ elif show_project:
+ w_name, w_project = int(flex * 0.58), flex - int(flex * 0.58)
+ else:
+ w_name, w_project = flex, 0
+ w_desc = flex - w_name - w_project if show_desc else 0
+
+ head = [f"{'#':>3}", f"{st.faint}{'MEMORIA':<{w_name}}{st.reset}",
+ f"{st.faint}{'TIPO':<9}{st.reset}"]
+ if show_project:
+ head.append(f"{st.faint}{'PROYECTO':<{w_project}}{st.reset}")
+ if show_desc:
+ head.append(f"{st.faint}{'DESCRIPCIÓN':<{w_desc}}{st.reset}")
+ head.append(f"{st.faint}{'FECHA':<6} {'CUÁNDO':<9}{st.reset}")
+ print(" ".join(head), file=out)
+
+ for i, m in enumerate(memories, 1):
+ # El asterisco marca lo que no está en MEMORY.md: existe pero no se carga.
+ tag = "" if m["ix"] else f" {st.copper}*{st.reset}"
+ avail = w_name - visible_len(tag)
+ cells = [
+ f"{st.faint}{i:>3}{st.reset}",
+ f"{st.ink}{clip(m['name'], avail):<{avail}}{st.reset}{tag}",
+ f"{getattr(st, TYPE_COLOR.get(m['ty'], 'grey'))}"
+ f"{clip(m['ty'], 9):<9}{st.reset}",
+ ]
+ if show_project:
+ cells.append(f"{st.grey}{clip(m['p'], w_project):<{w_project}}{st.reset}")
+ if show_desc:
+ cells.append(f"{st.grey}{clip(m['desc'], w_desc):<{w_desc}}{st.reset}")
+ cells.append(f"{fmt_date(m['l']):<6} "
+ f"{st.faint}{fmt_rel(m['l'], now):<9}{st.reset}")
+ print(" ".join(cells), file=out)
+
+
+def print_memory(m, st, out, path=None, width=None):
+ width = min(width or shutil.get_terminal_size((100, 24)).columns, 100)
+
+ print(f"{st.amber}{st.bold}{m['name']}{st.reset}", file=out)
+ if m["desc"]:
+ for line in textwrap.wrap(m["desc"], width=width - 2):
+ print(f"{st.grey}{line}{st.reset}", file=out)
+
+ meta = (f"{m['ty']} · {m['p']} · "
+ f"{fmt_date(m['l'])} {fmt_time(m['l'])} · {fmt_size(m['k'])}")
+ print(f"{st.faint}{meta}{st.reset}", file=out)
+ if path:
+ print(f"{st.faint}{path}{st.reset}", file=out)
+
+ if not m["ix"]:
+ aviso = ("este proyecto no tiene MEMORY.md" if not m["hix"]
+ else "no figura en MEMORY.md, así que no se carga en contexto")
+ print(f"{st.copper}* {aviso}{st.reset}", file=out)
+
+ print(f"{st.faint}{'─' * min(width, 80)}{st.reset}\n", file=out)
+
+ for line in render_block(m["body"], st, width - 2, st.grey):
+ print(line, file=out)
+
+ if m["ln"]:
+ print(f"\n{st.faint}enlaces: {', '.join(m['ln'])}{st.reset}", file=out)
+ if m["src"]:
+ print(f"{st.faint}la creó la sesión {m['src'][:8]} "
+ f"(claude-logbook -s {m['src'][:8]}){st.reset}", file=out)
+
+
+def print_audit(report, st, out):
+ """Informe de inconsistencias. Devuelve cuántas se listaron."""
+ bloques = (
+ ("sin_indice", "Proyectos con memorias pero sin MEMORY.md",
+ "sin índice no se carga ninguna de sus memorias",
+ lambda m: f"{clip(m['name'], 38):<38} {st.grey}{m['p']}{st.reset}"),
+ ("sin_listar", "Memorias que no figuran en su MEMORY.md",
+ "el índice es lo que se lee al arrancar: si no está, no se recuerda",
+ lambda m: f"{clip(m['name'], 38):<38} {st.grey}{m['p']}{st.reset}"),
+ ("indice_fantasma", "Entradas del índice sin archivo",
+ "apuntan a una memoria que ya no existe",
+ lambda t: f"{clip(t[1], 38):<38} {st.grey}{t[0]}{st.reset}"),
+ ("enlaces_rotos", "Enlaces [[...]] sin destino",
+ "el formato los permite: marcan algo que todavía no se escribió",
+ lambda t: f"{clip(t[0]['name'], 38):<38} {st.grey}→ [[{t[1]}]]{st.reset}"),
+ ("origen_perdido", "Memorias cuya sesión de origen ya no existe",
+ "la memoria sobrevivió a la conversación que la creó",
+ lambda m: f"{clip(m['name'], 38):<38} {st.grey}{m['src'][:8]}{st.reset}"),
+ )
+
+ total = 0
+ for key, titulo, nota, fmt in bloques:
+ items = report.get(key) or []
+ if not items:
+ continue
+ total += len(items)
+ print(f"{st.copper}{titulo} ({len(items)}){st.reset}", file=out)
+ print(f"{st.faint} {nota}{st.reset}", file=out)
+ for item in items:
+ print(f" {fmt(item)}", file=out)
+ print(file=out)
+
+ return total
diff --git a/claude_logbook/webpage.py b/claude_logbook/webpage.py
new file mode 100644
index 0000000..c8550fe
--- /dev/null
+++ b/claude_logbook/webpage.py
@@ -0,0 +1,74 @@
+"""Genera la página HTML autocontenida a partir de las sesiones.
+
+El resultado no necesita red ni servidor: los datos y las transcripciones van
+embebidos adentro y se abre con doble clic.
+"""
+
+import json
+from importlib import resources
+
+MARKER = "__DATA__"
+
+TEMPLATE_NAME = "template.html"
+
+
+class TemplateError(Exception):
+ """El template no tiene la forma que espera el generador."""
+
+
+def template_text(path=None):
+ if path:
+ with open(path, encoding="utf-8") as f:
+ return f.read()
+ return (resources.files(__package__) / TEMPLATE_NAME).read_text(encoding="utf-8")
+
+
+def build_payload(sessions, memories=None):
+ """Estructura que viaja embebida en la página.
+
+ Un objeto y no una lista porque la página muestra dos cosas distintas:
+ sesiones y memorias de proyecto.
+ """
+ return {"s": list(sessions), "m": list(memories or ())}
+
+
+def encode_payload(payload):
+ """Serializa el payload para meterlo en un <script type=application/json>.
+
+ El parser de HTML corta ese bloque en el primer "</script", y las
+ transcripciones tienen HTML adentro. Escapamos "</" como "<\\/", que es un
+ escape válido de JSON: JSON.parse lo devuelve intacto.
+ """
+ raw = json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
+ return raw.replace("</", "<\\/")
+
+
+def render(records, memories=None, template=None):
+ """Devuelve el HTML completo con los datos ya embebidos."""
+ html = template if template is not None else template_text()
+ # No se puede verificar el resultado buscando el marcador: estas mismas
+ # sesiones incluyen conversaciones sobre este script, así que el payload lo
+ # contiene como texto. Validamos el template antes de sustituir.
+ if html.count(MARKER) != 1:
+ raise TemplateError(
+ f"el template debe tener exactamente un {MARKER} "
+ f"(encontrados: {html.count(MARKER)})")
+ return html.replace(MARKER, encode_payload(build_payload(records, memories)))
+
+
+def write(records, out_path, memories=None, template=None):
+ """Escribe la página y devuelve un resumen de lo que quedó adentro."""
+ html = render(records, memories=memories, template=template)
+ with open(out_path, "w", encoding="utf-8") as f:
+ f.write(html)
+ return summary(records, memories)
+
+
+def summary(records, memories=None):
+ return {
+ "sesiones": len(records),
+ "proyectos": len({r["p"] for r in records}),
+ "mensajes": sum(r["u"] for r in records),
+ "bloques": sum(len(r["c"]) for r in records),
+ "memorias": len(memories or ()),
+ }