diff options
Diffstat (limited to 'claude_sesiones')
| -rw-r--r-- | claude_sesiones/cli.py | 159 | ||||
| -rw-r--r-- | claude_sesiones/memory.py | 272 | ||||
| -rw-r--r-- | claude_sesiones/template.html | 434 | ||||
| -rw-r--r-- | claude_sesiones/terminal.py | 121 | ||||
| -rw-r--r-- | claude_sesiones/webpage.py | 28 |
5 files changed, 966 insertions, 48 deletions
diff --git a/claude_sesiones/cli.py b/claude_sesiones/cli.py index 90fb51b..4dc5ab2 100644 --- a/claude_sesiones/cli.py +++ b/claude_sesiones/cli.py @@ -14,9 +14,10 @@ from .sessions import ( load_sessions, pick, public_records, session_path, ) from .terminal import ( - Style, clip, fmt_date, fmt_size, plural, print_chat, print_table, - resume_cmd, + 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" @@ -46,6 +47,15 @@ borrado (irreversible; pregunta antes, salvo con -y): claude-sesiones --delete-empty borra las vacías claude-sesiones -D 101 -D e0a4300e borra sesiones puntuales claude-sesiones -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-sesiones -m tabla de memorias + claude-sesiones -m docker busca en nombre, descripción y cuerpo + claude-sesiones -m -s 3 lee la memoria nº 3 + claude-sesiones -m -s deadlock lo mismo, por nombre + claude-sesiones -m --check audita índices, enlaces y orígenes + claude-sesiones -m -D 3 la borra y la saca de MEMORY.md """ @@ -75,6 +85,14 @@ def build_parser(): 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") @@ -214,19 +232,23 @@ def delete_targets(pool, args): def cmd_json(sessions): import json - json.dump(public_records(sessions), sys.stdout, - ensure_ascii=False, separators=(",", ":")) + 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 - stats = webpage.write(public_records(sessions), out, + 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 → {out}", file=sys.stderr) + f"de transcripción · {stats['memorias']} memorias → {out}", + file=sys.stderr) if args.open: webbrowser.open("file://" + os.path.abspath(out)) return 0 @@ -263,6 +285,124 @@ def cmd_table(sessions, args, st): 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): @@ -275,13 +415,16 @@ def run(args): 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) - st = Style.from_stream(sys.stdout, args.no_color) - if args.delete or args.delete_empty: targets = delete_targets(filtered(sessions, args), args) return delete_sessions(targets, args, st) diff --git a/claude_sesiones/memory.py b/claude_sesiones/memory.py new file mode 100644 index 0000000..ccb2e65 --- /dev/null +++ b/claude_sesiones/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_sesiones/template.html b/claude_sesiones/template.html index 279749c..e56cc30 100644 --- a/claude_sesiones/template.html +++ b/claude_sesiones/template.html @@ -570,6 +570,153 @@ .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; } } @@ -590,6 +737,15 @@ <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"> @@ -598,8 +754,10 @@ <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"><input type="checkbox" id="deep"> buscar dentro del chat</label> - <label class="toggle"><input type="checkbox" id="hideEmpty"> ocultar vacías</label> + <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> @@ -607,7 +765,7 @@ </div> <div class="grid" role="table" aria-label="Sesiones de Claude Code"> - <div class="row head" role="row"> + <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> @@ -615,12 +773,19 @@ <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"> + <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> @@ -628,7 +793,16 @@ <span><i style="background:var(--line)"></i>más viejo</span> </div> - <div class="foot"> + <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> @@ -660,18 +834,30 @@ <script id="payload" type="application/json">__DATA__</script> <script> -const DATA = JSON.parse(document.getElementById('payload').textContent); +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)))); +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'); + readerEl = $('#reader'), scrimEl = $('#scrim'), bodyEl = $('#rBody'), + typeEl = $('#mtype'), unlistedEl = $('#unlisted'); -let sortKey = 'l', sortDir = -1, openId = null, lastFocus = null; +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 ---------- */ @@ -723,7 +909,7 @@ function mark(text, q) { // 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) { +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. @@ -735,6 +921,16 @@ function renderBody(text) { 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]); } @@ -752,17 +948,31 @@ function renderBody(text) { ['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 projects() { +function fillProjects() { + const src = mode === 'm' ? MEM : DATA; const counts = {}; - DATA.forEach(d => counts[d.p] = (counts[d.p] || 0) + 1); - projEl.innerHTML = `<option value="">todos los proyectos (${DATA.length})</option>` + + 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) { @@ -808,7 +1018,7 @@ function current() { return list; } -function render() { +function renderSessions() { const list = current(); const q = qEl.value.trim(); const ql = q.toLowerCase(); @@ -854,15 +1064,99 @@ function render() { : `${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 entr |