claude-memory-admin 1.5.0 → 1.5.2

package/public/views/header.mjs

@@ -0,0 +1,126 @@
+import * as ui from '/ui.mjs';
+import { el, node } from '/dom.mjs';
+import { state, worstSeverity } from '/state.mjs';
+import { paint } from '/bus.mjs';
+import { openRememberPathDialog, forgetProjectPath } from '/dialogs/remember-path.mjs';
+
+const TABS = [
+  { id: 'memories', label: 'Memories' },
+  { id: 'index', label: 'MEMORY.md' },
+  { id: 'graph', label: 'Graph' },
+  { id: 'prune', label: 'Prune' },
+  { id: 'context', label: 'Context' },
+  { id: 'sessions', label: 'Sessions' },
+  { id: 'health', label: 'Health' },
+  { id: 'settings', label: 'Settings' },
+  { id: 'trash', label: 'Trash' },
+];
+
+export function renderTabs() {
+  const container = el('tabs');
+  container.textContent = '';
+  const global = state.store.kind === 'global';
+  const hasProjectDir = state.store.kind === 'auto'
+    ? state.store.resolvedBy !== 'unresolved'
+    : Boolean(state.store.projectPath);
+
+  for (const tab of TABS) {
+    if (global && tab.id !== 'context') continue;
+    if (!global && tab.id === 'context' && !hasProjectDir) continue;
+    if (tab.id === 'sessions' && !state.store.sessions?.count) continue;
+    let badge = null;
+    let tone = 'neutral';
+    if (tab.id === 'memories') badge = String(state.store.memories.length);
+    if (tab.id === 'trash' && state.store.trash.length) badge = String(state.store.trash.length);
+    if (tab.id === 'health' && state.store.health.issueCount) {
+      badge = String(state.store.health.issueCount);
+      tone = state.store.health.severity;
+    }
+    if (tab.id === 'prune' && state.store.stats.index.level !== 'ok') {
+      badge = '!';
+      tone = state.store.stats.index.level === 'over' ? 'bad' : 'warn';
+    }
+    if (tab.id === 'sessions' && state.store.sessions) {
+      badge = String(state.store.sessions.count);
+      if (state.store.sessions.expiringCount) tone = 'warn';
+    }
+    if (tab.id === 'context' && state.aux.instructions?.problems.length) {
+      badge = String(state.aux.instructions.problems.length);
+      tone = worstSeverity(state.aux.instructions.problems);
+    }
+    if (tab.id === 'settings' && state.aux.settings?.problems.length) {
+      badge = String(state.aux.settings.problems.length);
+      tone = worstSeverity(state.aux.settings.problems);
+    }
+
+    container.append(node('button', {
+      class: ui.tab(state.tab === tab.id),
+      onclick: () => { state.tab = tab.id; paint('tabs', 'tab'); },
+    }, [
+      document.createTextNode(tab.label),
+      badge ? node('span', { class: ui.tabBadge(tone), text: badge }) : null,
+    ]));
+  }
+}
+
+export function renderStoreHeader() {
+  const store = state.store;
+  el('project-title').textContent = store.label;
+  el('delete-project').hidden = store.kind === 'global';
+
+  const sub = el('project-sub');
+  sub.textContent = '';
+
+  if (store.kind === 'global') {
+    sub.append(node('span', { text: store.dir }));
+    sub.append(node('span', { class: ui.subNote, text: 'instructions every session loads, before any project is chosen' }));
+    return;
+  }
+
+  if (store.kind !== 'auto') {
+    const scope = store.kind === 'agent-user' ? 'user'
+      : store.kind === 'agent-project' ? 'project' : 'local';
+    sub.append(node('span', { text: store.dir }));
+    sub.append(node('span', { class: ui.subNote, text: `subagent memory, ${scope} scope` }));
+    if (store.kind === 'agent-project') {
+      sub.append(node('span', { class: ui.subWarn, text: 'checked into the repository - changes here show up in git status' }));
+    }
+    return;
+  }
+
+  sub.append(node('span', { text: store.resolvedBy === 'unresolved'
+    ? `${store.path}  (real path unresolved)`
+    : store.path }));
+
+  const others = (store.workingDirs || []).filter((d) => d !== store.path);
+  if (others.length) {
+    sub.append(node('span', { class: ui.subNote, text: `also used from ${others.join(', ')}` }));
+  }
+  if (store.resolvedBy === 'unresolved') {
+    sub.append(node('button', { class: ui.linkButton, text: 'Remember path\u2026', onclick: openRememberPathDialog }));
+  } else if (store.resolvedBy === 'remembered') {
+    sub.append(node('span', { class: ui.subNote }, [
+      document.createTextNode('path remembered, not recovered from a transcript  '),
+      node('button', { class: ui.linkButton, text: 'Forget', onclick: forgetProjectPath }),
+    ]));
+  }
+
+  const evidence = store.sessions?.evidenceExpiresInDays;
+  if (!store.sessions?.remembered
+      && (store.resolvedBy === 'transcript' || store.resolvedBy === 'repo-root')
+      && typeof evidence === 'number' && evidence <= 14) {
+    sub.append(node('span', { class: ui.subWarn }, [
+      document.createTextNode(evidence === 0
+        ? 'the last transcript proving this path is due to be swept - the store keeps its memories and loses its name  '
+        : `the last transcript proving this path is swept in ${evidence} days, and nothing else records it  `),
+      node('button', { class: ui.linkButton, text: 'Remember path\u2026', onclick: openRememberPathDialog }),
+    ]));
+  }
+
+  const auto = store.autoMemory;
+  if (auto && auto.known && !auto.enabled) {
+    sub.append(node('span', { class: ui.subWarn, text: auto.scope === 'env'
+      ? 'auto memory is off (CLAUDE_CODE_DISABLE_AUTO_MEMORY) - this store will not grow'
+      : `auto memory is off (${auto.setBy}) - this store will not grow` }));
+  }
+}

package/public/views/health.mjs

@@ -0,0 +1,21 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { state } from '/state.mjs';
+import { renderIssue } from '/views/issue.mjs';
+import { renderPathCheck } from '/views/path-check.mjs';
+
+export function renderHealth(container) {
+  const { health, memories } = state.store;
+
+  if (!health.issues.length) {
+    container.append(node('div', { class: ui.card }, [
+      node('p', { class: ui.okLine, text: '\u2713 No consistency problems found.' }),
+      node('p', { class: ui.noteTight, text: 'Every memory file is referenced by MEMORY.md, every pointer resolves, and every [[wikilink]] finds its target.' }),
+    ]));
+  } else {
+    for (const item of health.issues) container.append(renderIssue(item, memories));
+  }
+
+  container.append(node('div', { class: ui.sectionLabel, text: 'Beyond the memory directory' }));
+  renderPathCheck(container);
+}

package/public/views/index.mjs

@@ -0,0 +1,122 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { renderMarkdown } from '/markdown.mjs';
+import { api, toast } from '/api.mjs';
+import { state } from '/state.mjs';
+import { paint } from '/bus.mjs';
+import { openStore, selectMemory, restoreFromTrash } from '/store.mjs';
+import { cutMarker } from '/parts.mjs';
+import { memoryLookup, openTarget } from '/views/memories.mjs';
+
+const INDEX_VIEWS = [
+  { id: 'rendered', label: 'Rendered' },
+  { id: 'source', label: 'Source' },
+];
+
+function setIndexView(view) {
+  state.indexView = view;
+  localStorage.setItem('memoryIndexView', view);
+  paint('tab');
+}
+
+function indexViewPicker() {
+  return node('div', { class: ui.segmentGroup, role: 'tablist' }, INDEX_VIEWS.map((view) => node('button', {
+    class: ui.segment(state.indexView === view.id),
+    text: view.label,
+    role: 'tab',
+    'aria-selected': String(state.indexView === view.id),
+    onclick: () => setIndexView(view.id),
+  })));
+}
+
+export function renderIndex(container) {
+  const project = state.store;
+  if (!project.hasIndex) {
+    container.append(node('p', { class: ui.note, text: 'This project has no MEMORY.md.' }));
+    return;
+  }
+
+  const card = node('div', { class: ui.card });
+  card.append(node('div', { class: ui.cardHeadRow }, [
+    node('p', { class: ui.note, text: `${project.index.entries.length} index entries · ${project.index.lines.length} lines` }),
+    indexViewPicker(),
+  ]));
+
+  if (state.indexView === 'source') renderIndexSource(card, project);
+  else renderIndexRendered(card, project);
+
+  container.append(card);
+}
+
+function renderIndexRendered(card, project) {
+  const { cutoff } = project.stats.index;
+  const files = new Set(project.memories.map((memory) => memory.file));
+  const byName = memoryLookup(project);
+  const options = {
+    resolveWikilink: (target) => openTarget(byName.get(target)),
+    resolveHref: (href) => openTarget(files.has(href) ? href : null),
+  };
+
+  const lines = project.index.raw.split('\n');
+  const loaded = node('div', { class: ui.prose });
+  renderMarkdown(loaded, cutoff ? lines.slice(0, cutoff.rawLine).join('\n') : project.index.raw, options);
+  card.append(loaded);
+
+  if (!cutoff) return;
+  card.append(cutMarker(cutoff));
+  const dropped = node('div', { class: ui.proseDim });
+  renderMarkdown(dropped, lines.slice(cutoff.rawLine).join('\n'), options);
+  card.append(dropped);
+}
+
+function renderIndexSource(card, project) {
+  const missing = new Set(project.health.danglingIndex.map((d) => d.index));
+  const { cutoff } = project.stats.index;
+
+  for (const line of project.index.lines) {
+    if (cutoff && line.index === cutoff.rawLine) card.append(cutMarker(cutoff));
+
+    const dangling = missing.has(line.index);
+    const dropped = Boolean(cutoff) && line.index >= cutoff.rawLine;
+    const clickable = line.kind === 'index' && !dangling;
+    const content = node('span', {
+      class: ui.indexLineText({ kind: line.kind, clickable, dropped }),
+      text: line.text || ' ',
+    });
+    if (clickable) content.onclick = () => selectMemory(line.file);
+
+    card.append(node('div', { class: ui.indexLine({ dangling, dropped }) }, [
+      node('span', { class: ui.indexLineNumber, text: String(line.index + 1) }),
+      content,
+    ]));
+  }
+}
+
+export function indexEntryAt(lineIndex) {
+  return state.store.index?.entries.find((entry) => entry.index === lineIndex) || null;
+}
+
+export function sectionsAbove(limit) {
+  const seen = [];
+  for (const line of state.store.index?.lines || []) {
+    if (line.kind !== 'heading') continue;
+    if (limit !== null && line.index >= limit) continue;
+    if (line.section && !seen.includes(line.section)) seen.push(line.section);
+  }
+  return seen;
+}
+
+export async function runIndexEdit(action, body, message) {
+  try {
+    const result = await api(`/api/stores/${encodeURIComponent(state.storeId)}/${action}`, {
+      method: 'POST',
+      body: JSON.stringify(body),
+    });
+    await openStore(state.storeId, { keepTab: true });
+    toast(message(result), { action: { label: 'Undo', run: () => restoreFromTrash(result.record.id) } });
+    return result;
+  } catch (err) {
+    toast(err.message, { error: true });
+    return null;
+  }
+}

package/public/views/issue.mjs

@@ -0,0 +1,270 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { confirmDialog } from '/dialog.mjs';
+import { api, toast } from '/api.mjs';
+import { state } from '/state.mjs';
+import { issue, goToTab } from '/parts.mjs';
+import { openStore, selectMemory, restoreFromTrash } from '/store.mjs';
+import { openDeleteDialog } from '/dialogs/delete.mjs';
+import { openAddEntryDialog } from '/dialogs/add-entry.mjs';
+
+async function removeIndexLine(lineIndex, expectedText, done) {
+  const go = await confirmDialog({
+    title: `Remove line ${lineIndex + 1} from MEMORY.md?`,
+    confirmLabel: 'Remove',
+    tone: 'danger',
+    body: [
+      node('div', { class: ui.willBlock }, [
+        node('div', { class: ui.willTitle, text: 'Will be removed' }),
+        node('div', { class: ui.willItem('remove'), text: expectedText }),
+      ]),
+      node('p', { class: ui.noteTight, text: 'Only this line goes. The memory file it points at is left on disk.' }),
+    ],
+  });
+  if (!go) return;
+  try {
+    await api(`/api/stores/${encodeURIComponent(state.storeId)}/index-line/delete`, {
+      method: 'POST',
+      body: JSON.stringify({ lineIndex, expectedText }),
+    });
+    toast(done);
+    await openStore(state.storeId, { keepTab: true });
+  } catch (err) {
+    toast(err.message, { error: true });
+  }
+}
+
+export function renderIssue(item, memories) {
+  const bad = item.severity === 'bad';
+
+  if (item.kind === 'dangling-index') {
+    const { entry } = item;
+    return issue(
+      `MEMORY.md points at a file that does not exist: ${entry.file}`,
+      `line ${entry.index + 1}: ${entry.text}`,
+      {
+        bad,
+        action: {
+          label: 'Remove pointer',
+          run: () => removeIndexLine(entry.index, entry.text, 'Pointer removed'),
+        },
+      },
+    );
+  }
+
+  if (item.kind === 'dangling-wikilink') {
+    const { link } = item;
+    return issue(
+      `Broken [[${link.target}]]`,
+      `referenced from ${link.from} - no memory has that name`,
+      {
+        bad,
+        secondary: { label: 'Open source', run: () => selectMemory(link.from) },
+        action: {
+          label: 'Remove link',
+          run: async () => {
+            const go = await confirmDialog({
+              title: `Remove [[${link.target}]] from ${link.from}?`,
+              confirmLabel: 'Remove link',
+              tone: 'danger',
+              body: [
+                node('p', { class: ui.noteTight, text: 'The link markup goes, the words stay.' }),
+                node('div', { class: ui.willBlock }, [
+                  node('div', { class: ui.willTitle, text: 'Will change' }),
+                  node('div', { class: ui.willItem('remove'), text: `see [[${link.target}]]` }),
+                  node('div', { class: ui.willItem('keep'), text: `see ${link.target}` }),
+                ]),
+                node('p', { class: ui.noteTight, text: 'A copy of the file is kept in the trash, so this can be undone.' }),
+              ],
+            });
+            if (!go) return;
+            try {
+              const result = await api(`/api/stores/${encodeURIComponent(state.storeId)}/wikilink/remove`, {
+                method: 'POST',
+                body: JSON.stringify({ file: link.from, target: link.target }),
+              });
+              await openStore(state.storeId, { keepTab: true });
+              toast(`Unlinked ${result.occurrences} reference(s)`, {
+                action: { label: 'Undo', run: () => restoreFromTrash(result.record.id) },
+              });
+            } catch (err) {
+              toast(err.message, { error: true });
+            }
+          },
+        },
+      },
+    );
+  }
+
+  if (item.kind === 'orphan') {
+    const memory = memories.find((m) => m.file === item.file);
+    return issue(
+      `Not referenced anywhere in MEMORY.md: ${item.file}`,
+      `"${memory?.name || item.file}" exists on disk but nothing points to it, so Claude will not load it.`,
+      {
+        bad,
+        secondary: { label: 'Open', run: () => selectMemory(item.file) },
+        action: { label: 'Add to MEMORY.md', run: () => openAddEntryDialog(item.file) },
+      },
+    );
+  }
+
+  if (item.kind === 'referenced-only') {
+    const memory = memories.find((m) => m.file === item.file);
+    return issue(
+      `Linked mid-sentence, not indexed: ${item.file}`,
+      `"${memory?.name || item.file}" is mentioned inside prose in MEMORY.md but has no index bullet of its own.`,
+      {
+        bad,
+        secondary: { label: 'Open', run: () => selectMemory(item.file) },
+        action: { label: 'Add to MEMORY.md', run: () => openAddEntryDialog(item.file) },
+      },
+    );
+  }
+
+  if (item.kind === 'name-mismatch') {
+    return issue(
+      `Frontmatter name differs from filename: ${item.mismatch.file}`,
+      `name: "${item.mismatch.name}" - [[wikilinks]] must use this name, not the filename.`,
+      { bad, action: { label: 'Open', run: () => selectMemory(item.mismatch.file) } },
+    );
+  }
+
+  if (item.kind === 'missing-frontmatter') {
+    return issue(
+      `No YAML frontmatter: ${item.file}`,
+      'Type and description cannot be read from this file.',
+      { bad, action: { label: 'Open', run: () => selectMemory(item.file) } },
+    );
+  }
+
+  if (item.kind === 'long-hooks') {
+    return issue(
+      `${item.count} index hook${item.count === 1 ? '' : 's'} over 200 characters`,
+      `longest is ${item.longest.hookLength} chars on "${item.longest.title}" - hooks load every session, so these are the cheapest thing to trim.`,
+      {
+        bad,
+        action: { label: 'Open Prune', run: () => goToTab('prune') },
+      },
+    );
+  }
+
+  if (item.kind === 'duplicate-name') {
+    return issue(
+      `Two memories claim the name "${item.name}"`,
+      `${item.files.join(', ')} - every [[${item.name}]] resolves to ${item.reachable}, so the other one cannot be linked at all.`,
+      {
+        bad,
+        secondary: { label: 'Open first', run: () => selectMemory(item.files[0]) },
+        action: { label: 'Open second', run: () => selectMemory(item.files[1]) },
+      },
+    );
+  }
+
+  if (item.kind === 'duplicate-index-entry') {
+    return issue(
+      `Listed twice in MEMORY.md: ${item.file}`,
+      `lines ${item.lines.map((line) => line + 1).join(' and ')} - one memory, two index lines, both loaded every session.`,
+      {
+        bad,
+        action: {
+          label: 'Remove duplicate',
+          run: () => removeIndexLine(item.removable.index, item.removable.text, 'Duplicate removed'),
+        },
+      },
+    );
+  }
+
+  if (item.kind === 'missing-description') {
+    return issue(
+      `No description: ${item.file}`,
+      'The description is what a memory is recalled by, so this one is found on its name alone.',
+      { bad, action: { label: 'Open', run: () => selectMemory(item.file) } },
+    );
+  }
+
+  if (item.kind === 'unknown-type') {
+    return issue(
+      `Unrecognised type: ${item.file}`,
+      `type: "${item.type}" - expected one of user, feedback, project, reference.`,
+      { bad, action: { label: 'Open', run: () => selectMemory(item.file) } },
+    );
+  }
+
+  if (item.kind === 'empty-body') {
+    const memory = memories.find((m) => m.file === item.file);
+    return issue(
+      `Almost nothing in it: ${item.file}`,
+      `"${memory?.name || item.file}" has ${item.chars} characters of body - it costs an index line every session and says nothing.`,
+      {
+        bad,
+        secondary: { label: 'Open', run: () => selectMemory(item.file) },
+        action: { label: 'Delete', run: () => openDeleteDialog(item.file) },
+      },
+    );
+  }
+
+  if (item.kind === 'hook-repeats-description') {
+    return issue(
+      `Hook repeats the description: ${item.file}`,
+      `MEMORY.md line ${item.index + 1} - ${item.hookLength} characters restating what the file's own description already says. Only the hook loads every session.`,
+      {
+        bad,
+        secondary: { label: 'Open', run: () => selectMemory(item.file) },
+        action: { label: 'Open Prune', run: () => goToTab('prune') },
+      },
+    );
+  }
+
+  if (item.kind === 'empty-section') {
+    return issue(
+      `Empty section in MEMORY.md: "${item.section}"`,
+      `line ${item.index + 1} - the heading has no entries under it, and headings count against the 200-line budget too.`,
+      { bad, action: { label: 'Open MEMORY.md', run: () => goToTab('index') } },
+    );
+  }
+
+  if (item.kind === 'stale-path') {
+    return issue(
+      `No file matches ${item.token}`,
+      `named by "${item.name || item.file}"`,
+      { bad, action: { label: 'Open', run: () => selectMemory(item.file) } },
+    );
+  }
+
+  if (item.kind === 'index-continuation') {
+    return issue(
+      `${item.count} index ${item.count === 1 ? 'entry spills' : 'entries spill'} onto extra lines`,
+      `${item.extraLines} extra line${item.extraLines === 1 ? '' : 's'} of the 200-line budget - the guidance is one line per entry, with the detail in the topic file.`,
+      { bad, action: { label: 'Open MEMORY.md', run: () => goToTab('index') } },
+    );
+  }
+
+  if (item.kind === 'provenance-expired') {
+    return issue(
+      `Provenance gone: ${item.name}`,
+      `the session it was written in (${item.sessionId}) has been swept, so why this memory exists can no longer be traced. Nothing recovers it - judge the memory on what it says.`,
+      { bad, action: { label: 'Open', run: () => selectMemory(item.file) } },
+    );
+  }
+
+  if (item.kind === 'path-evidence-expiring') {
+    return issue(
+      item.days === 0
+        ? 'The last transcript naming this project is due to be swept'
+        : `The last transcript naming this project is swept in ${item.days} days`,
+      `${item.path} is recovered from the session transcripts, and Claude Code drops those after ${item.retentionDays} days while never touching memory/. Once the last one goes this store shows its raw folder name instead. Remember path records it now.`,
+      { bad, action: { label: 'Remember path\u2026', run: openRememberPathDialog } },
+    );
+  }
+
+  if (item.kind === 'no-memory-despite-sessions') {
+    return issue(
+      `${item.sessionCount} ${item.sessionCount === 1 ? 'session' : 'sessions'}, and no memory written`,
+      `auto memory is on for this project, but nothing has been saved in the ${item.retentionDays} days of transcripts kept here. Either nothing was worth remembering, or memory is not being written.`,
+      { bad },
+    );
+  }
+
+  return issue(item.kind, JSON.stringify(item));
+}