claude-memory-admin 1.5.0 → 1.5.2

package/public/views/memories.mjs

@@ -0,0 +1,183 @@
+import * as ui from '/ui.mjs';
+import { el, node } from '/dom.mjs';
+import { renderMarkdown } from '/markdown.mjs';
+import { state } from '/state.mjs';
+import { selectMemory, loadSessionsForProvenance } from '/store.mjs';
+import { goToTab, sessionDate } from '/parts.mjs';
+import { openDeleteDialog } from '/dialogs/delete.mjs';
+
+export function memoryLookup(project) {
+  const byName = new Map();
+  for (const memory of project.memories) {
+    byName.set(memory.name, memory.file);
+    byName.set(memory.stem, memory.file);
+  }
+  return byName;
+}
+
+export function openTarget(file) {
+  return file ? { open: () => selectMemory(file) } : null;
+}
+
+export function renderBody(container, memory, project) {
+  const byName = memoryLookup(project);
+  renderMarkdown(container, memory.body, {
+    resolveWikilink: (target) => openTarget(byName.get(target)),
+  });
+}
+
+function memoryButton(memory) {
+  const active = state.selected === memory.file;
+  return node('button', {
+    class: ui.memoryItem(active),
+    'data-memory': memory.file,
+    'data-active': active ? '' : null,
+    onclick: () => selectMemory(memory.file),
+  }, [
+    node('span', { class: ui.memoryTop }, [
+      node('span', { class: ui.memoryName, text: memory.name }),
+      node('span', { class: ui.typeBadge(memory.type), text: memory.type }),
+      memory.status !== 'indexed'
+        ? node('span', { class: ui.badge('warn'), text: memory.status })
+        : null,
+    ]),
+    memory.description ? node('span', { class: ui.memoryDesc, text: memory.description }) : null,
+  ]);
+}
+
+export function renderMemories(container) {
+  const project = state.store;
+  if (!project.memories.length) {
+    container.append(node('p', { class: ui.note, text: 'This project has no memory files yet.' }));
+    return;
+  }
+
+  const left = node('div');
+  const groups = new Map();
+  for (const memory of project.memories) {
+    const key = memory.section || (memory.status === 'indexed' ? 'Index' : 'Not in the index');
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(memory);
+  }
+  for (const [section, memories] of groups) {
+    left.append(node('div', { class: ui.sectionLabel, text: `${section} · ${memories.length}` }));
+    for (const memory of memories) left.append(memoryButton(memory));
+  }
+
+  const right = node('div', { id: 'detail', class: ui.detailPane });
+  container.append(node('div', { class: ui.split }, [left, right]));
+  renderDetail();
+}
+
+function renderDetail() {
+  const host = el('detail');
+  if (!host) return;
+  host.textContent = '';
+
+  const memory = state.store.memories.find((m) => m.file === state.selected);
+  if (!memory) {
+    host.append(node('p', { class: ui.note, text: 'Select a memory to read it.' }));
+    return;
+  }
+
+  const card = node('div', { class: ui.card });
+  card.append(node('div', { class: ui.detailHead }, [
+    node('h3', { class: ui.detailTitle, text: memory.name }),
+    node('span', { class: ui.typeBadge(memory.type), text: memory.type }),
+    node('button', {
+      class: ui.buttonDangerSmall,
+      text: 'Delete',
+      onclick: () => openDeleteDialog(memory.file),
+    }),
+  ]));
+
+  if (memory.description) card.append(node('p', { class: ui.detailDesc, text: memory.description }));
+
+  const meta = node('dl', { class: ui.metaList });
+  const rows = [
+    ['file', memory.file],
+    ['status', memory.status],
+    ['modified', memory.modified
+      ? `${memory.modified.replace('T', ' ').replace(/\..*$/, '')}${memory.modifiedFrom === 'mtime' ? '  (file mtime)' : ''}`
+      : '-'],
+    ['size', `${(memory.bytes / 1024).toFixed(1)} KB`],
+  ];
+  if (!memory.nameMatchesFile) rows.push(['name', `${memory.name}  (differs from filename)`]);
+  for (const [key, value] of Object.entries(memory.metadata)) {
+    if (key !== 'type' && key !== 'modified' && key !== 'originSessionId') rows.push([key, value]);
+  }
+  for (const [key, value] of rows) {
+    meta.append(node('dt', { class: ui.metaKey, text: key }), node('dd', { class: ui.metaValue, text: String(value) }));
+  }
+  card.append(meta);
+
+  const origin = provenanceLine(memory);
+  if (origin) card.append(origin);
+
+  const body = node('div', { class: ui.prose });
+  card.append(body);
+  renderBody(body, memory, state.store);
+
+  const outbound = memory.outboundResolved || [];
+  if (outbound.length || memory.inbound.length) {
+    const links = node('div', { class: ui.linkSection });
+    if (outbound.length) {
+      links.append(node('div', { class: ui.sectionLabel, text: 'Links out' }));
+      const chips = node('div', { class: ui.linkRow });
+      for (const link of outbound) {
+        chips.append(node('button', {
+          class: ui.chip(Boolean(link.file)),
+          text: link.file ? link.target : `${link.target} (missing)`,
+          onclick: link.file ? () => selectMemory(link.file) : null,
+        }));
+      }
+      links.append(chips);
+    }
+    if (memory.inbound.length) {
+      links.append(node('div', { class: ui.sectionLabel, text: 'Linked from' }));
+      const chips = node('div', { class: ui.linkRow });
+      for (const link of memory.inbound) {
+        const source = state.store.memories.find((m) => m.file === link.from);
+        chips.append(node('button', {
+          class: ui.chip(true),
+          text: source ? source.name : link.from,
+          onclick: () => selectMemory(link.from),
+        }));
+      }
+      links.append(chips);
+    }
+    card.append(links);
+  }
+
+  host.append(card);
+}
+
+function provenanceLine(memory) {
+  const origin = memory.origin;
+  if (!origin) return null;
+
+  const known = state.aux.sessions?.sessions.find((session) => session.id === origin.sessionId);
+  const label = origin.present ? (known?.title || origin.sessionId) : origin.sessionId;
+
+  const row = node('div', { class: ui.provenanceRow }, [node('span', { text: 'written in' })]);
+
+  if (origin.present) {
+    row.append(node('button', {
+      class: ui.provenanceLink(true),
+      text: label,
+      title: 'Open the Sessions tab',
+      onclick: () => goToTab('sessions'),
+    }));
+    if (known?.gitBranch) row.append(node('span', { text: `on ${known.gitBranch}` }));
+    if (origin.modified) row.append(node('span', { text: sessionDate(origin.modified).slice(0, 10) }));
+    if (!known) loadSessionsForProvenance();
+  } else {
+    row.append(node('span', {
+      class: ui.provenanceLink(false),
+      text: label,
+      title: 'This transcript is no longer on disk',
+    }));
+    row.append(node('span', { text: '- transcript swept, so why this memory exists can no longer be traced' }));
+  }
+  return row;
+}

package/public/views/path-check.mjs

@@ -0,0 +1,102 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { api } from '/api.mjs';
+import { state } from '/state.mjs';
+import { paint } from '/bus.mjs';
+import { renderIssue } from '/views/issue.mjs';
+
+function storeHasProjectDir() {
+  return state.store.kind === 'auto'
+    ? state.store.resolvedBy !== 'unresolved'
+    : Boolean(state.store.projectPath);
+}
+
+const pathCheckKey = () => `pathCheck:${state.storeId}`;
+
+async function fetchPathCheck() {
+  const id = state.storeId;
+  let next;
+  try {
+    next = { running: false, data: await api(`/api/stores/${encodeURIComponent(id)}/path-check`) };
+  } catch (err) {
+    next = { running: false, error: err.message };
+  }
+  if (state.storeId !== id) return;
+  state.pathCheck = next;
+  if (state.tab === 'health') paint('tab');
+}
+
+function startPathCheck({ remember = true } = {}) {
+  if (remember) localStorage.setItem(pathCheckKey(), '1');
+  state.pathCheck = { running: true };
+  fetchPathCheck();
+}
+
+function runPathCheck() {
+  startPathCheck();
+  paint('tab');
+}
+
+function stopPathCheck() {
+  localStorage.removeItem(pathCheckKey());
+  state.pathCheck = null;
+  paint('tab');
+}
+
+export function renderPathCheck(container) {
+  if (!storeHasProjectDir()) return;
+
+  if (!state.pathCheck && localStorage.getItem(pathCheckKey()) === '1') {
+    startPathCheck({ remember: false });
+  }
+  const check = state.pathCheck;
+
+  const head = node('div', { class: ui.issue(false) });
+  const body = node('div', { class: ui.issueBody });
+
+  if (!check) {
+    body.append(
+      node('div', { class: ui.issueTitle, text: 'Paths named in memories are not being checked' }),
+      node('div', { class: ui.issueDetail, text: 'Every other check on this tab reads only memory/. This one reads the project itself, to find memories naming files that no longer exist. It stays off until you ask, and is remembered per store.' }),
+    );
+    head.append(body, node('button', { class: ui.buttonSmall, text: 'Check against the repo', onclick: () => runPathCheck() }));
+    return container.append(head);
+  }
+
+  if (check.running) {
+    body.append(node('div', { class: ui.issueTitle, text: 'Checking paths against the repo…' }));
+    head.append(body);
+    return container.append(head);
+  }
+
+  if (check.error) {
+    body.append(
+      node('div', { class: ui.issueTitle, text: 'Path check could not run' }),
+      node('div', { class: ui.issueDetail, text: check.error }),
+    );
+    head.append(body, node('button', { class: ui.buttonSmall, text: 'Turn off', onclick: () => stopPathCheck() }));
+    return container.append(head);
+  }
+
+  const { checked, capped, missing, indexed, truncated } = check.data;
+  const scanned = `${indexed.toLocaleString()} files and folders scanned${truncated ? ', stopped at the index limit' : ''}`;
+  body.append(
+    node('div', { class: ui.issueTitle, text: missing.length
+      ? `${missing.length} of ${checked} paths named in memories match no file in the project`
+      : `All ${checked} paths named in memories still match a file` }),
+    node('div', { class: ui.issueDetail, text: capped
+      ? `${scanned}; stopped after the first ${checked} paths, so there may be more`
+      : scanned }),
+  );
+  if (missing.length) {
+    body.append(node('div', { class: ui.issueDetail, text: 'A pointer rather than a verdict: a file that moved reads the same as one the memory never got right.' }));
+  }
+  head.append(
+    body,
+    node('button', { class: ui.buttonSmall, text: 'Turn off', onclick: () => stopPathCheck() }),
+    node('button', { class: ui.buttonSmall, text: 'Re-check', onclick: () => runPathCheck() }),
+  );
+  container.append(head);
+
+  for (const item of missing) container.append(renderIssue(item, state.store.memories));
+}

package/public/views/prune.mjs

@@ -0,0 +1,191 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { state } from '/state.mjs';
+import { paint } from '/bus.mjs';
+import { formatAge } from '/parts.mjs';
+import { selectMemory } from '/store.mjs';
+import { openBulkDeleteDialog } from '/dialogs/bulk-delete.mjs';
+import { openMergeDialog } from '/dialogs/merge.mjs';
+import { openMoveDialog } from '/dialogs/move.mjs';
+import { openHookEditor } from '/dialogs/hook-editor.mjs';
+
+const PRUNE_SORTS = {
+  oldest: { label: 'oldest first', compare: (a, b) => (b.ageDays ?? -1) - (a.ageDays ?? -1) },
+  largest: { label: 'largest first', compare: (a, b) => b.bytes - a.bytes },
+  unlinked: { label: 'least linked', compare: (a, b) => a.inbound.length - b.inbound.length || (b.ageDays ?? 0) - (a.ageDays ?? 0) },
+  name: { label: 'by name', compare: (a, b) => a.name.localeCompare(b.name) },
+};
+
+function renderBudget(container) {
+  const { index } = state.store.stats;
+  const percent = Math.min(100, index.worstPercent);
+  const level = index.level;
+
+  const note = index.level === 'over'
+    ? 'Over the limit. Everything past the cutoff is dropped when the session loads it, so those entries are effectively invisible to Claude right now.'
+    : index.level === 'near'
+      ? 'Approaching the limit. Once MEMORY.md passes it, everything after the cutoff stops being loaded at all.'
+      : 'Comfortably inside the limit. MEMORY.md is loaded at the start of every session.';
+
+  if (index.cutoff) {
+    const dropped = index.cutoff.droppedEntries;
+    const box = node('div', { class: ui.cutSummary });
+    box.append(node('div', { class: ui.cutSummaryHead, text: dropped.length
+      ? `${dropped.length} ${dropped.length === 1 ? 'memory is' : 'memories are'} past the cutoff and not loaded`
+      : `${index.cutoff.droppedLines} lines are past the cutoff and not loaded` }));
+    box.append(node('p', { class: ui.note, text: `MEMORY.md stops loading at line ${index.cutoff.rawLine + 1}, bounded by ${index.cutoff.by}. Claude cannot see anything below it.` }));
+    for (const entry of dropped.slice(0, 20)) {
+      box.append(node('div', { class: ui.issue(true) }, [
+        node('div', { class: ui.issueBody }, [
+          node('div', { class: ui.issueTitle, text: entry.title || entry.file }),
+          node('div', { class: ui.issueDetail, text: `MEMORY.md line ${entry.index + 1} · ${entry.file}` }),
+        ]),
+        node('button', { class: ui.buttonSmall, text: 'Open', onclick: () => selectMemory(entry.file) }),
+        node('button', { class: ui.buttonPrimarySmall, text: 'Move up', onclick: () => openMoveDialog(entry) }),
+      ]));
+    }
+    if (dropped.length > 20) {
+      box.append(node('p', { class: ui.note, text: `${dropped.length - 20} more not listed.` }));
+    }
+    container.append(box);
+  }
+
+  container.append(node('div', { class: ui.meter }, [
+    node('div', { class: ui.meterTop }, [
+      node('span', { class: ui.meterValue, text: `${Math.round(index.worstPercent)}%` }),
+      node('span', { class: ui.meterUnit, text: `of the MEMORY.md load limit, currently bounded by ${index.limitedBy}` }),
+    ]),
+    node('div', { class: ui.meterBar }, [
+      node('div', { class: ui.meterFill(level), style: `width:${percent.toFixed(1)}%` }),
+    ]),
+    node('p', { class: ui.meterNote, text: note }),
+    node('div', { class: ui.meterFacts }, [
+      node('span', {}, [node('b', { class: ui.meterFactValue, text: `${index.lines} / ${index.lineLimit}` }), document.createTextNode(' lines')]),
+      node('span', {}, [node('b', { class: ui.meterFactValue, text: `${(index.bytes / 1024).toFixed(1)} / ${index.byteLimit / 1024} KB` }), document.createTextNode(' loaded size')]),
+      node('span', {}, [node('b', { class: ui.meterFactValue, text: String(index.entryCount) }), document.createTextNode(' index entries')]),
+      node('span', {}, [node('b', { class: ui.meterFactValue, text: `~${index.tokens.toLocaleString()}` }), document.createTextNode(' tokens, every session')]),
+    ]),
+    node('p', { class: ui.meterNote, text: 'Claude Code loads the first 200 lines or 25KB of MEMORY.md, whichever comes first, and drops the rest. Topic files are only read when Claude follows a link, so detail belongs in them and MEMORY.md should stay one line per entry.' }),
+  ]));
+}
+
+export function renderPrune(container) {
+  const project = state.store;
+  renderBudget(container);
+
+  if (!project.memories.length) {
+    container.append(node('p', { class: ui.note, text: 'Nothing to prune - this project has no memories.' }));
+    return;
+  }
+
+  const selected = state.pruneSelection;
+  const bar = node('div', { class: ui.pruneBar });
+  const sort = node('select', { class: ui.select });
+  for (const [key, config] of Object.entries(PRUNE_SORTS)) {
+    sort.append(node('option', { value: key, text: config.label, selected: key === state.pruneSort ? '' : null }));
+  }
+  sort.value = state.pruneSort;
+  sort.onchange = () => { state.pruneSort = sort.value; paint('tab'); };
+
+  const count = node('span', { class: ui.note });
+  const deleteButton = node('button', { class: ui.buttonDangerSmall });
+  const clearButton = node('button', { class: ui.buttonSmall, text: 'Clear selection' });
+
+  bar.append(node('span', { class: ui.sectionLabel, text: 'Prune' }), sort, node('span', { class: ui.pruneSpacer }), count, clearButton, deleteButton);
+  container.append(bar);
+
+  const list = node('div');
+  const ordered = [...project.memories].sort(PRUNE_SORTS[state.pruneSort].compare);
+  const rows = [];
+  for (const memory of ordered) {
+    const box = node('input', { type: 'checkbox', class: ui.checkbox });
+    box.checked = selected.has(memory.file);
+    const row = node('label', { class: ui.pruneRow(box.checked) }, [
+      box,
+      node('span', { class: ui.pruneMain }, [
+        node('span', { class: ui.pruneName, text: memory.name }),
+        node('span', { class: ui.pruneDesc, text: memory.description || memory.file }),
+      ]),
+      node('span', { class: ui.pruneFacts }, [
+        node('span', { class: ui.pruneFact((memory.ageDays ?? 0) > 180), text: formatAge(memory.ageDays) }),
+        node('span', { text: `${(memory.bytes / 1024).toFixed(1)}K` }),
+        node('span', { class: ui.pruneFact(!memory.inbound.length), text: `${memory.inbound.length} in` }),
+        node('span', { class: ui.pruneFact(memory.status !== 'indexed'), text: memory.status }),
+      ]),
+    ]);
+    box.addEventListener('change', () => {
+      if (box.checked) selected.add(memory.file); else selected.delete(memory.file);
+      row.className = ui.pruneRow(box.checked);
+      updateBar();
+    });
+    rows.push({ box, memory });
+    list.append(row);
+  }
+  container.append(list);
+
+  function updateBar() {
+    count.textContent = selected.size ? `${selected.size} selected` : '';
+    deleteButton.textContent = `Delete ${selected.size || ''}`.trim();
+    deleteButton.disabled = selected.size === 0;
+  }
+  clearButton.onclick = () => {
+    selected.clear();
+    paint('tab');
+  };
+  deleteButton.onclick = () => openBulkDeleteDialog([...selected]);
+  updateBar();
+
+  const { longHooks } = project.stats.index;
+  if (longHooks.length) {
+    container.append(node('div', { class: ui.sectionLabel, text: `Long index hooks · ${longHooks.length}` }));
+    container.append(node('p', { class: ui.noteTight, text: 'The hook is the text after the dash in MEMORY.md. It is loaded every session, so a 400-character hook costs more than the memory it points at. Shortening these is the cheapest win.' }));
+    for (const hook of longHooks.slice(0, 12)) {
+      const row = node('div', { class: ui.issue(false) });
+      const editButton = node('button', { class: ui.buttonPrimarySmall, text: 'Edit hook' });
+      row.append(
+        node('div', { class: ui.issueBody }, [
+          node('div', { class: ui.issueTitle, text: `${hook.hookLength} chars: ${hook.title}` }),
+          node('div', { class: ui.issueDetail, text: `MEMORY.md line ${hook.index + 1} · ${hook.file}` }),
+        ]),
+        node('button', { class: ui.buttonSmall, text: 'Open', onclick: () => selectMemory(hook.file) }),
+        editButton,
+      );
+      editButton.onclick = () => openHookEditor(row, hook.index);
+      container.append(row);
+    }
+  }
+
+  if (project.duplicates.length) {
+    container.append(node('div', { class: ui.sectionLabel, text: `Possible overlap · ${project.duplicates.length}` }));
+    container.append(node('p', { class: ui.noteTight, text: 'Ranked by how much rare vocabulary these pairs share. This is a hint, not a verdict - open both and decide whether one covers the other.' }));
+    for (const pair of project.duplicates) {
+      container.append(node('div', { class: ui.dupe }, [
+        node('div', { class: ui.dupeHead }, [
+          node('span', { class: ui.dupeScore, text: `${pair.score}%` }),
+          node('span', { text: `shared: ${pair.shared.join(', ')}` }),
+        ]),
+        node('div', { class: ui.dupePair }, [
+          ...[pair.a, pair.b].map((side) => node('div', {
+            class: ui.dupeSide,
+            onclick: () => selectMemory(side.file),
+          }, [
+            node('div', { class: ui.dupeSideName, text: side.name }),
+            node('div', { class: ui.dupeSideDesc, text: side.description || side.file }),
+          ])),
+        ]),
+        node('div', { class: ui.dupeActions }, [
+          node('button', {
+            class: ui.buttonSmall,
+            text: `Merge into ${pair.a.name}`,
+            onclick: () => openMergeDialog(pair.a.file, pair.b.file),
+          }),
+          node('button', {
+            class: ui.buttonSmall,
+            text: `Merge into ${pair.b.name}`,
+            onclick: () => openMergeDialog(pair.b.file, pair.a.file),
+          }),
+        ]),
+      ]));
+    }
+  }
+}

package/public/views/search.mjs

@@ -0,0 +1,101 @@
+import * as ui from '/ui.mjs';
+import { el, node } from '/dom.mjs';
+import { api, toast } from '/api.mjs';
+import { state } from '/state.mjs';
+import { paint } from '/bus.mjs';
+import { highlight } from '/parts.mjs';
+import { openStore } from '/store.mjs';
+
+let searchTimer = null;
+
+export function scheduleSearch(value) {
+  state.query = value;
+  clearTimeout(searchTimer);
+  if (!value.trim()) {
+    state.search = null;
+    paint('view');
+    return;
+  }
+  searchTimer = setTimeout(runSearch, 180);
+}
+
+async function runSearch() {
+  const query = state.query.trim();
+  if (!query) return;
+  try {
+    state.search = await api(`/api/search?q=${encodeURIComponent(query)}`);
+  } catch (err) {
+    return toast(err.message, { error: true });
+  }
+  paint('view');
+}
+
+export function renderSearch() {
+  const data = state.search;
+  const host = el('search-results');
+  host.textContent = '';
+  el('search-title').textContent = data.total
+    ? `${data.total} result${data.total === 1 ? '' : 's'} for "${state.query.trim()}"`
+    : `No results for "${state.query.trim()}"`;
+
+  if (!data.total && !data.stores.length) {
+    host.append(node('p', { class: ui.note, text: 'Nothing matched. Every word has to appear somewhere in a memory, so try fewer words.' }));
+    return;
+  }
+
+  for (const group of data.stores) {
+    const block = node('div', { class: ui.resultGroup });
+    block.append(node('div', { class: ui.sectionLabel, text: group.sublabel
+      ? `${group.label} · ${group.sublabel} · ${group.results.length}`
+      : `${group.label} · ${group.results.length}` }));
+
+    for (const result of group.results) {
+      const button = node('button', {
+        class: ui.result,
+        onclick: () => openFromSearch(group.id, result.file),
+      });
+      const top = node('div', { class: ui.resultTop });
+      const name = node('span', { class: ui.resultName });
+      name.append(highlight(result.name, data.terms));
+      top.append(name, node('span', { class: ui.typeBadge(result.type), text: result.type }));
+      if (result.status !== 'indexed') top.append(node('span', { class: ui.badge('warn'), text: result.status }));
+      button.append(top);
+
+      if (result.snippet) {
+        const snippet = node('div', { class: ui.resultSnippet });
+        snippet.append(highlight(result.snippet.text, data.terms));
+        button.append(snippet);
+      }
+      button.append(node('div', { class: ui.resultWhere, text: `${result.file} · matched in ${result.fields.join(', ')}` }));
+      block.append(button);
+    }
+
+    for (const hit of group.indexHits) {
+      const button = node('button', {
+        class: ui.result,
+        onclick: () => openFromSearch(group.id, hit.file, 'index'),
+      });
+      button.append(node('div', { class: ui.resultWhere, text: `MEMORY.md line ${hit.index + 1}` }));
+      const line = node('div', { class: ui.resultSnippet });
+      line.append(highlight(hit.text.trim(), data.terms));
+      button.append(line);
+      block.append(button);
+    }
+    host.append(block);
+  }
+}
+
+async function openFromSearch(id, file, tab = 'memories') {
+  clearSearch();
+  if (id !== state.storeId) await openStore(id);
+  state.tab = tab;
+  if (file) state.selected = file;
+  paint('tabs', 'tab');
+}
+
+export function clearSearch() {
+  state.query = '';
+  state.search = null;
+  el('search').value = '';
+  paint('view');
+}