diff options
Diffstat (limited to 'claude_logbook')
| -rw-r--r-- | claude_logbook/__init__.py | 8 | ||||
| -rw-r--r-- | claude_logbook/__main__.py | 6 | ||||
| -rw-r--r-- | claude_logbook/cli.py | 455 | ||||
| -rw-r--r-- | claude_logbook/memory.py | 272 | ||||
| -rw-r--r-- | claude_logbook/sessions.py | 409 | ||||
| -rw-r--r-- | claude_logbook/template.html | 1394 | ||||
| -rw-r--r-- | claude_logbook/terminal.py | 372 | ||||
| -rw-r--r-- | claude_logbook/webpage.py | 74 |
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><script id="payload"></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><proyecto>/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 => ({'&':'&','<':'<','>':'>','"':'"',"'":'''}[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 <. 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)} && 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 ()), + } |