claude-memory-admin 1.5.0 → 1.5.2

package/public/views/sessions.mjs

@@ -0,0 +1,235 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { api } from '/api.mjs';
+import { state } from '/state.mjs';
+import { sizeLabel, sessionDate } from '/parts.mjs';
+import { selectMemory } from '/store.mjs';
+import { paint } from '/bus.mjs';
+
+const TITLE_SOURCE = {
+  'ai-title': 'title Claude Code generated for this session',
+  slug: 'session slug, no generated title found in the part read',
+  prompt: 'first prompt, no generated title found in the part read',
+};
+
+function sessionRow(session, memoriesFrom) {
+  const soon = session.expiresInDays !== null && session.expiresInDays <= 7;
+  const caret = node('span', { class: ui.contextCaret, text: '\u25b8' });
+
+  const tags = [];
+  if (session.gitBranch) tags.push(node('span', { class: ui.badge('neutral'), text: session.gitBranch }));
+  if (session.model) tags.push(node('span', { class: ui.badge('neutral'), text: session.model }));
+  if (session.expiresInDays !== null) {
+    tags.push(node('span', {
+      class: ui.badge(soon ? 'warn' : 'neutral'),
+      text: session.expiresInDays === 0 ? 'due to be swept' : `swept in ${session.expiresInDays}d`,
+    }));
+  }
+  for (const memory of memoriesFrom) {
+    tags.push(node('span', { class: ui.badge('project'), text: memory.name }));
+  }
+
+  const body = node('div', { class: ui.contextBody, hidden: true });
+  const facts = node('dl', { class: ui.metaList });
+  const rows = [
+    ['session', session.id],
+    ['last active', `${sessionDate(session.modified)}  (file mtime)`],
+    ['size', sizeLabel(session.bytes)],
+  ];
+  if (session.cwd) rows.push(['cwd', session.cwd]);
+  if (session.version) rows.push(['version', session.version]);
+  if (session.titleFrom) rows.push(['title from', TITLE_SOURCE[session.titleFrom] || session.titleFrom]);
+  for (const [key, value] of rows) {
+    facts.append(node('dt', { class: ui.metaKey, text: key }), node('dd', { class: ui.metaValue, text: value }));
+  }
+  body.append(facts);
+  if (session.prompt) {
+    body.append(node('div', { class: ui.sectionLabel, text: 'Opened with' }));
+    body.append(node('p', { class: ui.note, text: session.prompt }));
+  }
+  if (memoriesFrom.length) {
+    body.append(node('div', { class: ui.sectionLabel, text: 'Memories written here' }));
+    const chips = node('div', { class: ui.linkRow });
+    for (const memory of memoriesFrom) {
+      chips.append(node('button', {
+        class: ui.chip(true),
+        text: memory.name,
+        onclick: () => selectMemory(memory.file),
+      }));
+    }
+    body.append(chips);
+  }
+
+  const button = node('button', {
+    class: ui.contextRowButton,
+    'aria-expanded': 'false',
+    onclick: (event) => {
+      const open = body.hidden;
+      body.hidden = !open;
+      caret.textContent = open ? '\u25be' : '\u25b8';
+      event.currentTarget.setAttribute('aria-expanded', open ? 'true' : 'false');
+    },
+  }, [
+    node('div', { class: ui.contextMain }, [
+      node('div', { class: ui.contextTags }, tags),
+      node('div', { class: ui.contextFile }, [caret, document.createTextNode(session.title || session.id)]),
+    ]),
+    node('div', { class: ui.contextSize, text: sessionDate(session.modified).slice(0, 10) }),
+  ]);
+
+  return node('div', {}, [button, body]);
+}
+
+function retentionTrack(sessions, days) {
+  const track = node('div', { class: ui.retentionTrack }, [node('span', { class: ui.retentionSweep })]);
+  for (const session of sessions) {
+    if (session.expiresInDays === null) continue;
+    const share = days > 0 ? Math.min(1, session.expiresInDays / days) : 1;
+    track.append(node('span', {
+      class: ui.retentionTick(session.expiresInDays <= 7),
+      style: `left: ${(share * 100).toFixed(2)}%`,
+      title: `${session.title || session.id}\nswept in ${session.expiresInDays} days`,
+    }));
+  }
+  return node('div', {}, [
+    track,
+    node('div', { class: ui.retentionScale }, [
+      node('span', { text: 'swept' }),
+      node('span', { text: `today · kept ${days} days` }),
+    ]),
+  ]);
+}
+
+const WEEKDAYS = ['Mon', '', 'Wed', '', 'Fri', '', ''];
+const LEVELS = [0, 1, 2, 3, 4];
+
+function dayLabel(cell) {
+  if (cell.count === 0) return `no sessions on ${cell.date}`;
+  return cell.count === 1 ? `1 session on ${cell.date}` : `${cell.count} sessions on ${cell.date}`;
+}
+
+function heatCell(cell, selected, onPick) {
+  if (cell.future) return node('span', { class: ui.heatBlank });
+  const label = dayLabel(cell);
+  const on = cell.date === selected;
+  return node('button', {
+    class: ui.heatTile(cell.level, on),
+    title: label,
+    'aria-label': label,
+    'aria-pressed': on ? 'true' : 'false',
+    onclick: () => onPick(on ? null : cell.date),
+  });
+}
+
+function activityGrid(heat, selected, onPick) {
+  const months = node('div', { class: ui.heatMonthRow });
+  for (const label of heat.months) {
+    months.append(node('div', { class: ui.heatMonthCell }, [
+      label ? node('span', { class: ui.heatMonthLabel, text: label }) : null,
+    ]));
+  }
+
+  const grid = node('div', { class: ui.heatGrid });
+  for (const week of heat.weeks) {
+    for (const cell of week) grid.append(heatCell(cell, selected, onPick));
+  }
+
+  const weekdays = node('div', { class: ui.heatDayCol });
+  for (const label of WEEKDAYS) weekdays.append(node('span', { class: ui.heatDayLabel, text: label }));
+
+  const legend = node('div', { class: ui.heatLegend }, [node('span', { text: 'Less' })]);
+  for (const level of LEVELS) legend.append(node('span', { class: ui.heatLegendSwatch(level) }));
+  legend.append(node('span', { text: 'More' }));
+
+  return node('div', { class: ui.heatBody }, [
+    weekdays,
+    node('div', { class: ui.heatMain }, [
+      node('div', { class: ui.heatScroll }, [months, grid]),
+      legend,
+    ]),
+  ]);
+}
+
+function meterPanel(title, aside, body) {
+  return node('div', { class: ui.meterPanel }, [
+    node('div', { class: ui.meterPanelHead }, [
+      node('span', { class: ui.meterPanelTitle, text: title }),
+      aside,
+    ]),
+    body,
+  ]);
+}
+
+export async function renderSessions(container) {
+  let data = state.aux.sessions;
+  if (!data) {
+    container.append(node('p', { class: ui.note, text: 'Reading session transcripts\u2026' }));
+    try {
+      data = await api(`/api/stores/${encodeURIComponent(state.storeId)}/sessions`);
+    } catch (err) {
+      container.textContent = '';
+      return container.append(node('p', { class: ui.note, text: err.message }));
+    }
+    if (state.tab !== 'sessions') return;
+    state.aux.sessions = data;
+  }
+  container.textContent = '';
+
+  const byOrigin = new Map();
+  for (const memory of state.store.memories) {
+    if (!memory.origin?.present) continue;
+    if (!byOrigin.has(memory.origin.sessionId)) byOrigin.set(memory.origin.sessionId, []);
+    byOrigin.get(memory.origin.sessionId).push(memory);
+  }
+
+  const selected = state.aux.sessionDay;
+  const pickDay = (date) => {
+    state.aux.sessionDay = date;
+    paint('tab');
+  };
+
+  container.append(node('p', { class: ui.noteTight, text: 'The transcripts sitting beside this store\u2019s memory. Claude Code deletes them once they pass the retention period and never touches memory/, so this is the evidence that expires while the memories stay. This tab only reads, and only the head of each file - nothing here deletes a transcript.' }));
+
+  container.append(node('div', { class: ui.meter }, [
+    node('div', { class: ui.meterTop }, [
+      node('span', { class: ui.meterValue, text: String(data.count) }),
+      node('span', { class: ui.meterUnit, text: data.count === 1 ? 'session kept' : 'sessions kept' }),
+    ]),
+    node('div', { class: ui.meterPanels }, [
+      meterPanel('Retention', null, retentionTrack(data.sessions, data.days)),
+      data.heat ? meterPanel('Activity', null, activityGrid(data.heat, selected, pickDay)) : null,
+    ]),
+    node('div', { class: ui.meterFacts }, [
+      node('span', {}, [node('b', { class: ui.meterFactValue, text: sizeLabel(data.bytes) }), document.createTextNode(' on disk')]),
+      node('span', {}, [node('b', { class: ui.meterFactValue, text: `${data.days} days` }), document.createTextNode(' retention (cleanupPeriodDays)')]),
+      node('span', {}, [
+        node('b', { class: ui.meterFactValue, text: data.evidenceExpiresInDays === null ? '-' : `${data.evidenceExpiresInDays} days` }),
+        document.createTextNode(' until the last proof of this path goes'),
+      ]),
+    ]),
+    node('p', { class: ui.meterNote, text: 'Sweep dates come from each file\u2019s mtime, which any copy or restore resets, so they are an estimate of when Claude Code will drop them rather than something the transcript recorded about itself.' }),
+  ]));
+
+  const visible = selected
+    ? data.sessions.filter((session) => session.modified.slice(0, 10) === selected)
+    : data.sessions;
+  const listHead = node('div', { class: ui.sectionLabelRow }, [
+    node('span', {
+      class: ui.sectionLabelInline,
+      text: selected ? `Sessions \u00b7 ${visible.length} on ${selected}` : `Sessions \u00b7 ${data.count}`,
+    }),
+  ]);
+  if (selected) {
+    listHead.append(node('button', {
+      class: ui.heatFilterClear,
+      text: 'show every day',
+      onclick: () => pickDay(null),
+    }));
+  }
+  container.append(listHead);
+  const card = node('div', { class: ui.card });
+  for (const session of visible) {
+    card.append(sessionRow(session, byOrigin.get(session.id) || []));
+  }
+  container.append(card);
+}

package/public/views/settings.mjs

@@ -0,0 +1,120 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { api } from '/api.mjs';
+import { state } from '/state.mjs';
+
+const SETTINGS_PROBLEMS = {
+  unparseable: (p) => [
+    `Not valid JSON: ${p.scope} settings`,
+    `${p.file} — Claude Code cannot read this file either, so every value in it is being ignored. ${p.detail}`,
+  ],
+  unreadable: (p) => [
+    `Cannot be read: ${p.scope} settings`,
+    `${p.file} — ${p.detail}`,
+  ],
+  'not-object': (p) => [
+    `Not a settings object: ${p.scope} settings`,
+    `${p.file} — ${p.detail}`,
+  ],
+  'invalid-auto-memory-directory': (p) => [
+    'autoMemoryDirectory cannot be used',
+    `${p.file} — ${p.detail}. Claude Code accepts only an absolute or ~/-prefixed path.`,
+  ],
+};
+
+const show = (value) => (value === undefined ? 'unset' : JSON.stringify(value));
+
+export async function renderSettings(container) {
+  let data = state.aux.settings;
+  if (!data) {
+    container.append(node('p', { class: ui.note, text: 'Reading settings files…' }));
+    try {
+      data = await api(`/api/stores/${encodeURIComponent(state.storeId)}/settings`);
+    } catch (err) {
+      container.textContent = '';
+      return container.append(node('p', { class: ui.note, text: err.message }));
+    }
+    if (state.tab !== 'settings') return;
+  }
+  container.textContent = '';
+
+  container.append(node('p', { class: ui.noteTight, text: 'What Claude Code would read for this store, in precedence order: managed policy first, then project and local settings, then your user file. This tab is read-only — it reports what is configured, it never changes it.' }));
+
+  if (!data.projectDir) {
+    container.append(node('p', { class: ui.subWarn, text: 'This store has no resolved project directory, so its project and local settings layers could not be consulted. Values below come from managed policy and your user file only.' }));
+  }
+
+  if (data.problems.length) {
+    container.append(node('div', { class: ui.sectionLabel, text: `Problems · ${data.problems.length}` }));
+    for (const problem of data.problems) {
+      const describe = SETTINGS_PROBLEMS[problem.kind];
+      const [title, detail] = describe ? describe(problem) : [problem.kind, problem.file || ''];
+      container.append(node('div', { class: ui.issue(problem.severity === 'bad') }, [
+        node('div', { class: ui.issueBody }, [
+          node('div', { class: ui.issueTitle, text: title }),
+          node('div', { class: ui.issueDetail, text: detail }),
+        ]),
+      ]));
+    }
+  }
+
+  if (data.env.overrides) {
+    container.append(node('div', { class: ui.sectionLabel, text: 'Environment override' }));
+    container.append(node('div', { class: ui.issue(false) }, [
+      node('div', { class: ui.issueBody }, [
+        node('div', { class: ui.issueTitle, text: `${data.env.name}=${data.env.value}` }),
+        node('div', { class: ui.issueDetail, text: `Set in this shell, so it outranks every settings file and forces ${data.env.overrides} off. The store will not grow while it is set.` }),
+      ]),
+    ]));
+  }
+
+  for (const entry of data.keys) {
+    const card = node('div', { class: ui.card });
+    const head = node('div', { class: ui.settingsKeyHead }, [
+      node('span', { class: ui.settingsKeyName, text: entry.key }),
+      node('span', {
+        class: ui.settingsEffective,
+        text: entry.effective ? show(entry.effective.value) : `${show(entry.fallback)} (default)`,
+      }),
+    ]);
+    if (entry.effective) {
+      head.append(node('span', { class: ui.scopeBadge(entry.effective.scope), text: entry.effective.scope }));
+    }
+    card.append(head);
+    card.append(node('p', { class: ui.noteTight, text: entry.detail }));
+
+    if (entry.normalized !== undefined && entry.effective && entry.normalized !== entry.effective.value) {
+      card.append(node('div', { class: ui.issue(false) }, [
+        node('div', { class: ui.issueBody }, [
+          node('div', { class: ui.issueTitle, text: `Configured ${show(entry.effective.value)}, but ${show(entry.normalized)} applies` }),
+          node('div', { class: ui.issueDetail, text: 'Claude Code ignores a value it cannot use and falls back to the default.' }),
+        ]),
+      ]));
+    }
+
+    if (!entry.values.length) {
+      card.append(node('p', { class: ui.note, text: 'No settings file sets this, so the built-in default applies.' }));
+    } else {
+      for (const value of entry.values) {
+        card.append(node('div', { class: ui.settingsLayerRow }, [
+          node('span', { class: ui.scopeBadge(value.scope), text: value.scope }),
+          node('span', { class: ui.settingsLayerValue(value.wins), text: show(value.value) }),
+          node('span', { class: ui.settingsLayerFile, text: value.file }),
+          value.wins ? node('span', { class: ui.badge('ok'), text: 'wins' }) : null,
+        ]));
+      }
+    }
+    container.append(card);
+  }
+
+  container.append(node('div', { class: ui.sectionLabel, text: `Files consulted · ${data.layers.length}` }));
+  const files = node('div', { class: ui.card });
+  for (const layer of data.layers) {
+    files.append(node('div', { class: ui.settingsLayerRow }, [
+      node('span', { class: ui.scopeBadge(layer.scope), text: layer.scope }),
+      node('span', { class: ui.settingsLayerValue(layer.status === 'ok'), text: layer.status }),
+      node('span', { class: ui.settingsLayerFile, text: layer.file }),
+    ]));
+  }
+  container.append(files);
+}

package/public/views/stores.mjs

@@ -0,0 +1,65 @@
+import * as ui from '/ui.mjs';
+import { el, node } from '/dom.mjs';
+import { state } from '/state.mjs';
+import { openStore } from '/store.mjs';
+
+function storeSubtitle(store) {
+  if (store.kind === 'global') return store.dir;
+  if (store.kind === 'auto') return store.path;
+  const scope = store.kind === 'agent-user' ? 'user'
+    : store.kind === 'agent-project' ? 'project' : 'local';
+  return `${scope} · ${store.sublabel}`;
+}
+
+function issueTitle(store) {
+  const parts = [];
+  if (store.issueCount) parts.push(`${store.issueCount} in Health`);
+  if (store.context) parts.push(`${store.context} in Context`);
+  if (store.settings) parts.push(`${store.settings} in Settings`);
+  if (store.kind === 'auto' && store.resolvedBy === 'unresolved') {
+    parts.push('Real path could not be resolved - showing the raw folder name');
+  }
+  return parts.length ? `${store.dir}\n${parts.join(', ')}` : store.dir;
+}
+
+function storeButton(store) {
+  const global = store.kind === 'global';
+  const health = !global && !store.hasMemoryDir ? 'none' : store.severity || 'ok';
+  const off = store.autoMemory && store.autoMemory.known && !store.autoMemory.enabled;
+  return node('button', {
+    class: ui.storeItem({ active: store.id === state.storeId, empty: !global && !store.hasMemoryDir }),
+    onclick: () => openStore(store.id),
+    title: issueTitle(store),
+  }, [
+    node('span', { class: ui.storeRow }, [
+      node('span', { class: ui.dot(health) }),
+      node('span', { class: ui.storeName, text: store.label }),
+      off ? node('span', { class: ui.offMarker, text: 'off', title: 'Auto memory is disabled for this project' }) : null,
+      global ? null : node('span', { class: ui.storeCount, text: store.hasMemoryDir ? String(store.memoryCount) : '-' }),
+    ]),
+    node('span', { class: ui.storePath, text: storeSubtitle(store) }),
+  ]);
+}
+
+export function renderStores() {
+  const list = el('project-list');
+  list.textContent = '';
+
+  const visible = state.stores.filter((s) => s.kind === 'global' || state.showAll || s.hasMemoryDir);
+  if (!visible.length) {
+    list.append(node('p', { class: ui.note, text: 'No memory stores found.' }));
+    return;
+  }
+
+  const groups = [
+    ['Global', visible.filter((s) => s.kind === 'global')],
+    ['Projects', visible.filter((s) => s.kind === 'auto')],
+    ['Subagents', visible.filter((s) => s.kind !== 'auto' && s.kind !== 'global')],
+  ];
+
+  const filled = groups.filter(([, stores]) => stores.length);
+  for (const [title, stores] of filled) {
+    if (filled.length > 1) list.append(node('div', { class: ui.sidebarGroup, text: title }));
+    for (const store of stores) list.append(storeButton(store));
+  }
+}

package/public/views/trash.mjs

@@ -0,0 +1,37 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { state } from '/state.mjs';
+import { restoreFromTrash } from '/store.mjs';
+
+const INDEX_EDIT_LABELS = {
+  hook: 'MEMORY.md hook shortened',
+  move: 'MEMORY.md entry moved',
+  add: 'MEMORY.md entry added',
+};
+
+export function renderTrash(container) {
+  const trash = state.store.trash;
+  if (!trash.length) {
+    container.append(node('p', { class: ui.note, text: 'Nothing in the trash. Deleted memories land here and can be restored.' }));
+    return;
+  }
+  for (const record of trash) {
+    const when = String(record.deletedAt).replace('T', ' ').replace(/\..*$/, '');
+    const detail = record.kind === 'wikilink'
+      ? `unlinked in ${record.sourceFile} · ${when}`
+      : record.kind === 'index-edit'
+        ? `${INDEX_EDIT_LABELS[record.op] || 'MEMORY.md edited'} · ${when}`
+        : record.kind === 'merge'
+          ? `merged into ${record.into} · ${when} · ${record.backups?.length || 0} file(s) rewritten`
+          : `${record.files.length} file(s)${record.indexTrashedFile ? ' + MEMORY.md' : ''} · ${when} · ${record.removedLines?.length || 0} index line(s) removed`;
+    container.append(node('div', { class: ui.issue(!record.present) }, [
+      node('div', { class: ui.issueBody }, [
+        node('div', { class: ui.issueTitle, text: record.label || record.id }),
+        node('div', { class: ui.issueDetail, text: record.present ? detail : `${detail}, backup missing, cannot restore` }),
+      ]),
+      record.present
+        ? node('button', { class: ui.buttonPrimarySmall, text: 'Restore', onclick: () => restoreFromTrash(record.id) })
+        : null,
+    ]));
+  }
+}

package/src/sessions.mjs

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { HEAD_READS, readHead } from './projects.mjs';
-import { cleanupPeriodDays } from './settings.mjs';
+import { cleanupPeriodDays, DEFAULT_CLEANUP_PERIOD_DAYS } from './settings.mjs';
 import { ageInDays } from './stats.mjs';
 
 export const EXPIRY_WARNING_DAYS = 7;
@@ -145,6 +145,73 @@ export function retention(sessions, { projectDir = null, now = Date.now() } = {}
   };
 }
 
+export const HEAT_WEEKS_MAX = 53;
+export const HEAT_LEVELS = 4;
+
+const DAY_MS = 86400000;
+const MONTH_LABELS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+
+const dayKey = (ms) => new Date(ms).toISOString().slice(0, 10);
+const startOfDay = (ms) => Math.floor(ms / DAY_MS) * DAY_MS;
+const mondayOf = (ms) => ms - ((new Date(ms).getUTCDay() + 6) % 7) * DAY_MS;
+const sundayOf = (ms) => ms + ((7 - new Date(ms).getUTCDay()) % 7) * DAY_MS;
+
+export function heatLevel(count, max) {
+  if (!count) return 0;
+  if (max <= HEAT_LEVELS) return count;
+  return Math.min(HEAT_LEVELS, Math.ceil((count / max) * HEAT_LEVELS));
+}
+
+export function heatmap(sessions, { days = DEFAULT_CLEANUP_PERIOD_DAYS, now = Date.now() } = {}) {
+  const today = startOfDay(now);
+  const counts = new Map();
+  for (const session of sessions) {
+    if (typeof session.modified !== 'string') continue;
+    const date = session.modified.slice(0, 10);
+    counts.set(date, (counts.get(date) || 0) + 1);
+  }
+
+  const span = Math.max(1, Math.round(days));
+  let earliest = today - (span - 1) * DAY_MS;
+  for (const date of counts.keys()) {
+    const at = Date.parse(`${date}T00:00:00.000Z`);
+    if (!Number.isNaN(at) && at < earliest) earliest = at;
+  }
+
+  const end = sundayOf(today);
+  let start = mondayOf(earliest);
+  if (Math.round((end + DAY_MS - start) / (7 * DAY_MS)) > HEAT_WEEKS_MAX) {
+    start = end - (HEAT_WEEKS_MAX * 7 - 1) * DAY_MS;
+  }
+
+  const max = counts.size ? Math.max(...counts.values()) : 0;
+  const weeks = [];
+  const months = [];
+  let labelled = null;
+  for (let monday = start; monday <= end; monday += 7 * DAY_MS) {
+    const week = [];
+    for (let offset = 0; offset < 7; offset += 1) {
+      const ms = monday + offset * DAY_MS;
+      const date = dayKey(ms);
+      const count = counts.get(date) || 0;
+      week.push({ date, count, level: heatLevel(count, max), future: ms > today });
+    }
+    const month = new Date(monday).getUTCMonth();
+    months.push(month === labelled ? null : MONTH_LABELS[month]);
+    labelled = month;
+    weeks.push(week);
+  }
+
+  return {
+    weeks,
+    months,
+    max,
+    total: [...counts.values()].reduce((sum, value) => sum + value, 0),
+    start: dayKey(start),
+    end: dayKey(end),
+  };
+}
+
 export function originSession(slugDir, sessionId) {
   if (typeof sessionId !== 'string' || !SESSION_ID.test(sessionId)) return null;
   const file = path.join(slugDir, `${sessionId}.jsonl`);
@@ -166,6 +233,7 @@ export function sessionsWithSummaries(slugDir, { projectDir = null, now = Date.n
   const report = retention(listSessions(slugDir), { projectDir, now });
   return {
     ...report,
+    heat: heatmap(report.sessions, { days: report.days, now }),
     sessions: report.sessions.map((session) => ({
       ...session,
       ...sessionSummary(session.file, { bytes: session.bytes }),