claude-memory-admin 1.5.1 → 1.6.0

package/public/views/context.mjs

@@ -0,0 +1,121 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { renderMarkdown } from '/markdown.mjs';
+import { api } from '/api.mjs';
+import { state } from '/state.mjs';
+import { isAt } from '/parts.mjs';
+
+const SCOPE_ORDER = ['managed', 'user', 'project', 'local'];
+
+const CONTEXT_PROBLEMS = {
+  missing: (p) => ['Import does not resolve', `${p.spec} from ${p.from} - nothing at ${p.file}`],
+  'too-deep': (p) => ['Import chain is too deep', `${p.file} is a fifth hop; Claude Code follows four, so this never loads`],
+  cycle: (p) => ['Circular import', `${p.from} imports ${p.file}, which was already loaded`],
+  external: (p) => ['Import resolves outside the project', `${p.file} - Claude Code asks you to approve these once, and a declined one stays disabled silently`],
+  'invalid-glob': (p) => [`Rule matches nothing: ${p.pattern}`, `${p.file} - ${p.reason}`],
+  'glob-budget': (p) => ['Rule has too many brace expansions', `${p.file} expands to ${p.expansions} patterns, past the 1,000 budget, so it is used unexpanded and its literal braces match no file`],
+  'long-claude-md': (p) => [`${p.lines} lines, over the 200-line guidance`, `${p.file} - long files cost context every session and reduce adherence`],
+  'agents-md-not-imported': (p) => ['AGENTS.md is not loaded', `${p.file} exists, but Claude Code reads CLAUDE.md. Import it with @AGENTS.md, or symlink it.`],
+  'unreferenced-user-file': (p) => ['Nothing in the chain reaches this file', `${p.file} sits next to CLAUDE.md and loads nothing. Import it with @${p.file.split('/').pop()}, or delete it.`],
+  'duplicate-load': (p) => [`Loaded ${p.count} times: ${p.file}`, `reached from ${[...new Set(p.via)].join(' and ')} - every copy is read into context, so you pay ~${p.wastedTokens.toLocaleString()} extra tokens a session`],
+  'empty-instruction-file': (p) => ['Loads, but says nothing', `${p.file} is empty apart from its frontmatter, so it costs a read and contributes no instruction`],
+};
+
+export async function renderContext(container) {
+  let data = state.aux.instructions;
+  if (!data) {
+    container.append(node('p', { class: ui.note, text: 'Reading instruction files…' }));
+    try {
+      data = await api(`/api/stores/${encodeURIComponent(state.storeId)}/instructions`);
+    } catch (err) {
+      container.textContent = '';
+      return container.append(node('p', { class: ui.note, text: err.message }));
+    }
+    if (!isAt('environment', 'instructions')) return;
+  }
+  container.textContent = '';
+
+  const global = state.store.kind === 'global';
+  if (!data.projectDir && !global) {
+    return container.append(node('p', { class: ui.note, text: 'This store is not tied to a project directory, so there are no instruction files to resolve.' }));
+  }
+
+  const { totals } = data;
+  container.append(node('div', { class: ui.meter }, [
+    node('div', { class: ui.meterTop }, [
+      node('span', { class: ui.meterValue, text: `~${totals.alwaysTokens.toLocaleString()}` }),
+      node('span', { class: ui.meterUnit, text: 'estimated tokens of instructions, every session' }),
+    ]),
+    node('div', { class: ui.meterFacts }, [
+      node('span', {}, [node('b', { class: ui.meterFactValue, text: String(totals.files) }), document.createTextNode(' files resolved')]),
+      node('span', {}, [node('b', { class: ui.meterFactValue, text: String(totals.alwaysLines) }), document.createTextNode(' lines always loaded')]),
+      node('span', {}, [node('b', { class: ui.meterFactValue, text: `${(totals.alwaysBytes / 1024).toFixed(1)} KB` }), document.createTextNode(' always loaded')]),
+      node('span', {}, [node('b', { class: ui.meterFactValue, text: String(totals.conditionalFiles) }), document.createTextNode(' path-scoped rules, loaded only on a match')]),
+    ]),
+    node('p', { class: ui.meterNote, text: 'Unlike MEMORY.md, none of this is truncated: CLAUDE.md files load in full however long they are. The 200-line figure is Claude Code’s guidance, not a cutoff, because long files cost context every session and are followed less reliably.' }),
+  ]));
+
+  if (data.problems.length) {
+    container.append(node('div', { class: ui.sectionLabel, text: `Problems · ${data.problems.length}` }));
+    for (const problem of data.problems) {
+      const describe = CONTEXT_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 }),
+        ]),
+      ]));
+    }
+  }
+
+  container.append(node('div', { class: ui.sectionLabel, text: `Loaded in this order · ${data.files.length}` }));
+  const card = node('div', { class: ui.card });
+  for (const file of data.files) {
+    const tags = [node('span', { class: ui.scopeBadge(file.scope), text: file.scope })];
+    if (file.kind === 'import') tags.push(node('span', { class: ui.badge(), text: `import · depth ${file.depth}` }));
+    if (file.kind === 'rule') tags.push(node('span', { class: ui.badge(), text: 'rule' }));
+    if (file.kind === 'managed-settings') tags.push(node('span', { class: ui.badge(), text: 'claudeMd setting' }));
+    if (file.conditional) tags.push(node('span', { class: ui.badge('warn'), text: 'only on a path match' }));
+
+    const body = node('div', { class: ui.contextBody, hidden: true });
+    const bodyProse = node('div', { class: ui.prose });
+    body.append(bodyProse);
+    const caret = node('span', { class: ui.contextCaret, text: '\u25b8' });
+    let rendered = false;
+
+    card.append(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');
+        if (open && !rendered) {
+          rendered = true;
+          renderMarkdown(bodyProse, file.text);
+        }
+      },
+    }, [
+      node('div', { class: ui.contextMain }, [
+        node('div', { class: ui.contextTags }, tags),
+        node('div', { class: ui.contextFile }, [caret, document.createTextNode(file.file)]),
+      ]),
+      node('div', { class: ui.contextSize, text: `${file.lines} L · ~${file.tokens.toLocaleString()} tok` }),
+    ]));
+    card.append(body);
+  }
+  container.append(card);
+
+  if (data.excluded.length) {
+    container.append(node('div', { class: ui.sectionLabel, text: `Excluded by claudeMdExcludes · ${data.excluded.length}` }));
+    for (const file of data.excluded) {
+      container.append(node('div', { class: ui.issue(false) }, [
+        node('div', { class: ui.issueBody }, [node('div', { class: ui.issueDetail, text: file })]),
+      ]));
+    }
+  }
+
+  container.append(node('p', { class: ui.meterNote, text: 'This is re-derived from the documented resolution rules, not a report from Claude Code. Run /context in a session to see what it actually loaded.' }));
+}

package/public/views/cost-issue.mjs

@@ -0,0 +1,70 @@
+import * as ui from '/ui.mjs';
+import { node } from '/dom.mjs';
+import { issue } from '/parts.mjs';
+import { selectMemory } from '/store.mjs';
+import { openMergeDialog } from '/dialogs/merge.mjs';
+import { openMoveDialog } from '/dialogs/move.mjs';
+import { openHookEditor } from '/dialogs/hook-editor.mjs';
+
+export function renderCostIssue(item) {
+  if (item.kind === 'past-cutoff') {
+    const { entry } = item;
+    return issue(
+      `Past the cutoff, not loaded: ${entry.title || entry.file}`,
+      `MEMORY.md line ${entry.index + 1} · ${entry.file} - the file is on disk, but Claude never sees this entry.`,
+      {
+        bad: true,
+        secondary: { label: 'Open', run: () => selectMemory(entry.file) },
+        action: { label: 'Move up', run: () => openMoveDialog(entry) },
+      },
+    );
+  }
+
+  if (item.kind === 'long-hook') {
+    const { hook } = item;
+    const row = issue(
+      `${hook.hookLength}-character hook: ${hook.title}`,
+      `MEMORY.md line ${hook.index + 1} · ${hook.file} - the hook loads every session, so shortening it is the cheapest win available.`,
+      { secondary: { label: 'Open', run: () => selectMemory(hook.file) } },
+    );
+    row.append(node('button', {
+      class: ui.buttonPrimarySmall,
+      text: 'Edit hook',
+      onclick: () => openHookEditor(row, hook.index),
+    }));
+    return row;
+  }
+
+  if (item.kind === 'overlap') {
+    const { pair } = item;
+    return 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),
+        }),
+      ]),
+    ]);
+  }
+
+  return null;
+}
+
+export const COST_KINDS = new Set(['past-cutoff', 'long-hook', 'overlap']);

package/public/views/environment.mjs

@@ -0,0 +1,12 @@
+import { renderSegmented } from '/views/segments.mjs';
+import { renderContext } from '/views/context.mjs';
+import { renderSettings } from '/views/settings.mjs';
+import { renderSessions } from '/views/sessions.mjs';
+
+export function renderEnvironment(container) {
+  return renderSegmented(container, 'environment', {
+    instructions: renderContext,
+    settings: renderSettings,
+    sessions: renderSessions,
+  });
+}

package/public/views/header.mjs

@@ -0,0 +1,183 @@
+import * as ui from '/ui.mjs';
+import { el, node } from '/dom.mjs';
+import { state, worstSeverity } from '/state.mjs';
+import { paint } from '/bus.mjs';
+import { buildWorklist } from '/views/worklist.mjs';
+import { openRememberPathDialog, forgetProjectPath } from '/dialogs/remember-path.mjs';
+
+const NAVIGATION = [
+  {
+    id: 'memory',
+    label: 'Memory',
+    segments: [
+      { id: 'list', label: 'List' },
+      { id: 'index', label: 'MEMORY.md' },
+      { id: 'graph', label: 'Graph' },
+    ],
+  },
+  { id: 'cleanup', label: 'Cleanup', segments: [] },
+  {
+    id: 'environment',
+    label: 'Environment',
+    segments: [
+      { id: 'instructions', label: 'Instructions' },
+      { id: 'settings', label: 'Settings' },
+      { id: 'sessions', label: 'Sessions' },
+    ],
+  },
+];
+
+const hasProjectDir = (store) => (store.kind === 'auto'
+  ? store.resolvedBy !== 'unresolved'
+  : Boolean(store.projectPath));
+
+function segmentVisible(tab, segment, store) {
+  const global = store.kind === 'global';
+  if (tab === 'memory') {
+    if (global) return false;
+    return segment === 'index' ? Boolean(store.hasIndex) : true;
+  }
+  if (segment === 'instructions') return global || hasProjectDir(store);
+  if (global) return false;
+  if (segment === 'sessions') return Boolean(store.sessions?.count);
+  return true;
+}
+
+function segmentBadge(id) {
+  if (id === 'instructions') {
+    const problems = state.aux.instructions?.problems || [];
+    return problems.length ? { badge: String(problems.length), tone: worstSeverity(problems) } : {};
+  }
+  if (id === 'settings') {
+    const problems = state.aux.settings?.problems || [];
+    return problems.length ? { badge: String(problems.length), tone: worstSeverity(problems) } : {};
+  }
+  if (id === 'sessions') {
+    const sessions = state.store.sessions;
+    return sessions ? { badge: String(sessions.count), tone: sessions.expiringCount ? 'warn' : 'neutral' } : {};
+  }
+  return {};
+}
+
+export function segmentsFor(tab) {
+  const entry = NAVIGATION.find((item) => item.id === tab);
+  if (!entry || !state.store) return [];
+  return entry.segments
+    .filter((segment) => segmentVisible(tab, segment.id, state.store))
+    .map((segment) => ({ ...segment, ...segmentBadge(segment.id) }));
+}
+
+function tabVisible(tab, store) {
+  if (tab === 'cleanup') return store.kind !== 'global';
+  return segmentsFor(tab).length > 0;
+}
+
+function tabBadge(tab, store) {
+  if (tab === 'memory') return { badge: String(store.memories.length), tone: 'neutral' };
+
+  if (tab === 'cleanup') {
+    const count = buildWorklist(store).length;
+    if (!count) return {};
+    const level = store.stats ? store.stats.index.level : 'ok';
+    const bad = level === 'over' || store.health.severity === 'bad';
+    return { badge: String(count), tone: bad ? 'bad' : 'warn' };
+  }
+
+  const problems = [
+    ...(state.aux.instructions?.problems || []),
+    ...(state.aux.settings?.problems || []),
+  ];
+  return problems.length ? { badge: String(problems.length), tone: worstSeverity(problems) } : {};
+}
+
+function undoControl() {
+  const count = state.store.trash?.length || 0;
+  const button = el('undo');
+  button.hidden = state.store.kind === 'global' || !count;
+  button.textContent = '';
+  button.append(
+    document.createTextNode('\u21ba Undo'),
+    node('span', { class: ui.tabBadge('neutral'), text: String(count) }),
+  );
+}
+
+export function renderTabs() {
+  const container = el('tabs');
+  container.textContent = '';
+  undoControl();
+
+  for (const entry of NAVIGATION) {
+    if (!tabVisible(entry.id, state.store)) continue;
+    const { badge, tone } = tabBadge(entry.id, state.store);
+
+    container.append(node('button', {
+      class: ui.tab(state.tab === entry.id),
+      onclick: () => { state.tab = entry.id; paint('tabs', 'tab'); },
+    }, [
+      document.createTextNode(entry.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/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;
+  }
+}