claude-memory-admin 1.1.0 → 1.3.0

package/src/mutate.mjs

@@ -12,7 +12,21 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-import { parseIndex, removeIndexEntries, removeLine, insertLines, unwrapWikilink } from './parse.mjs';
+import {
+  parseIndex,
+  removeIndexEntries,
+  removeLine,
+  insertLines,
+  unwrapWikilink,
+  retargetWikilink,
+  setIndexHook,
+  moveIndexEntry as moveIndexEntryText,
+  sectionInsertIndex,
+  sectionStartIndex,
+  topInsertIndex,
+  insertIndexEntry,
+  dominantSeparator,
+} from './parse.mjs';
 import { listMemoryFiles } from './projects.mjs';
 import { TRASH_DIR, loadMemory } from './model.mjs';
 
@@ -340,6 +354,55 @@ export function restoreMemory(dir, id) {
 
   const record = JSON.parse(fs.readFileSync(recordPath, 'utf8'));
 
+  if (record.kind === 'index-edit') {
+    const current = readIndex(dir);
+    const unchanged = current !== null && sha256(current) === record.indexSha256After;
+
+    if (record.indexCreated) {
+      if (!unchanged) throw new Error('MEMORY.md has changed since it was created - not deleting it');
+      fs.unlinkSync(indexPath(dir));
+      fs.unlinkSync(recordPath);
+      return { restored: true, file: 'MEMORY.md', indexRestored: 'exact', kind: 'index-edit' };
+    }
+
+    const backup = path.join(trashPath, record.indexBackupFile);
+    if (!fs.existsSync(backup)) throw new Error('The backup copy of MEMORY.md is gone');
+    writeIndexAtomic(dir, fs.readFileSync(backup, 'utf8'));
+    fs.unlinkSync(backup);
+    fs.unlinkSync(recordPath);
+    return {
+      restored: true,
+      file: 'MEMORY.md',
+      indexRestored: unchanged ? 'exact' : 'overwritten',
+      kind: 'index-edit',
+    };
+  }
+
+  if (record.kind === 'merge') {
+    const entry = record.files[0];
+    safeMemoryPath(dir, entry.file);
+    if (fs.existsSync(path.join(dir, entry.file))) {
+      throw new Error(`${entry.file} already exists - not overwriting it`);
+    }
+    for (const backup of record.backups) {
+      if (!fs.existsSync(path.join(trashPath, backup.backupFile))) {
+        throw new Error(`The backup copy of ${backup.file} is gone`);
+      }
+    }
+    if (!fs.existsSync(path.join(trashPath, entry.trashedFile))) {
+      throw new Error(`The trashed copy of ${entry.file} is gone`);
+    }
+
+    for (const backup of record.backups) {
+      writeFileAtomic(dir, backup.file, fs.readFileSync(path.join(trashPath, backup.backupFile), 'utf8'));
+    }
+    fs.renameSync(path.join(trashPath, entry.trashedFile), path.join(dir, entry.file));
+    for (const backup of record.backups) fs.unlinkSync(path.join(trashPath, backup.backupFile));
+    fs.unlinkSync(recordPath);
+
+    return { restored: true, files: [entry.file, record.into], indexRestored: 'exact', kind: 'merge' };
+  }
+
   if (record.kind === 'wikilink') {
     safeMemoryPath(dir, record.sourceFile);
     const backup = path.join(trashPath, record.backupFile);
@@ -406,3 +469,294 @@ export function deleteIndexLine(dir, lineIndex, expectedText) {
   writeIndexAtomic(dir, text);
   return { removed };
 }
+
+function trashDir(dir) {
+  const trashPath = path.join(dir, TRASH_DIR);
+  fs.mkdirSync(trashPath, { recursive: true });
+  return trashPath;
+}
+
+function backupInto(trashPath, name, text) {
+  fs.writeFileSync(path.join(trashPath, name), text);
+  return name;
+}
+
+function editIndex(dir, { op, label, apply }) {
+  const before = readIndex(dir);
+  const created = before === null;
+  const { text, ...detail } = apply(before);
+
+  const trashPath = trashDir(dir);
+  const stamp = timestamp();
+  const backupFile = created ? null : backupInto(trashPath, `${stamp}_MEMORY.md.before-${op}.md`, before);
+
+  try {
+    writeIndexAtomic(dir, text);
+  } catch (err) {
+    if (backupFile) {
+      try { fs.unlinkSync(path.join(trashPath, backupFile)); } catch { /* best effort */ }
+    }
+    throw err;
+  }
+
+  const record = {
+    version: 2,
+    kind: 'index-edit',
+    op,
+    id: `${stamp}_${op}`,
+    label,
+    deletedAt: new Date().toISOString(),
+    indexBackupFile: backupFile,
+    indexCreated: created,
+    indexSha256Before: created ? null : sha256(before),
+    indexSha256After: sha256(text),
+    files: [],
+    removedLines: [],
+  };
+  fs.writeFileSync(path.join(trashPath, `${record.id}.restore.json`), JSON.stringify(record, null, 2));
+  return { record, ...detail };
+}
+
+function requireIndex(text) {
+  if (text === null) throw new Error('This project has no MEMORY.md');
+  return text;
+}
+
+export function editIndexHook(dir, { lineIndex, expectedText, hook }) {
+  return editIndex(dir, {
+    op: 'hook',
+    label: `hook on MEMORY.md line ${Number(lineIndex) + 1}`,
+    apply: (current) => {
+      const result = setIndexHook(requireIndex(current), lineIndex, expectedText, hook);
+      return { text: result.text, before: result.before, after: result.after, edited: true };
+    },
+  });
+}
+
+function resolveMoveTarget(parsed, { toIndex, section, top }) {
+  if (toIndex !== undefined && toIndex !== null) return Number(toIndex);
+  if (top) return topInsertIndex(parsed);
+  if (section) return sectionStartIndex(parsed, section);
+  throw new Error('No target given for the move');
+}
+
+export function moveIndexEntry(dir, { lineIndex, expectedText, toIndex, section = null, top = false }) {
+  return editIndex(dir, {
+    op: 'move',
+    label: `moved MEMORY.md line ${Number(lineIndex) + 1}`,
+    apply: (current) => {
+      const text = requireIndex(current);
+      const target = resolveMoveTarget(parseIndex(text), { toIndex, section, top });
+      const result = moveIndexEntryText(text, lineIndex, expectedText, target);
+      return { text: result.text, moved: result.moved, toIndex: result.toIndex, movedEntry: true };
+    },
+  });
+}
+
+function composeEntry(current, memory, title, hook) {
+  const parsed = current === null ? null : parseIndex(current);
+  const separator = parsed ? dominantSeparator(parsed) : ' — ';
+  const label = String(title ?? '').trim() || memory.name;
+  const text = String(hook ?? '').trim();
+  if (/[\r\n]/.test(label) || /[\r\n]/.test(String(hook ?? ''))) {
+    throw new Error('An index entry has to stay on one line');
+  }
+  const bullet = `- [${label.replace(/[[\]]/g, '')}](${memory.file})`;
+  return text ? `${bullet}${separator}${text}` : bullet;
+}
+
+function requireIndexable(dir, file) {
+  const full = safeMemoryPath(dir, file);
+  if (!fs.existsSync(full)) throw new Error(`No such memory: ${file}`);
+  const memory = loadMemory(dir, file);
+  if (!memory) throw new Error(`Could not read ${file}`);
+  return memory;
+}
+
+export function addIndexEntryPreview(dir, { file, section = null, title = null, hook = null }) {
+  const memory = requireIndexable(dir, file);
+  const current = readIndex(dir);
+  const parsed = current === null ? null : parseIndex(current);
+  const existing = parsed ? parsed.entries.find((entry) => entry.file === file) : null;
+
+  return {
+    file,
+    name: memory.name,
+    description: memory.description,
+    sections: parsed
+      ? [...new Set(parsed.parsedLines.filter((line) => line.kind === 'heading').map((line) => line.section))]
+      : [],
+    hasIndex: current !== null,
+    alreadyIndexed: Boolean(existing),
+    existingLine: existing ? { index: existing.index, text: existing.text } : null,
+    line: composeEntry(current, memory, title ?? memory.name, hook ?? memory.description),
+    at: parsed ? sectionInsertIndex(parsed, section) : 2,
+  };
+}
+
+export function addIndexEntry(dir, { file, section = null, title = null, hook = null }) {
+  const memory = requireIndexable(dir, file);
+
+  return editIndex(dir, {
+    op: 'add',
+    label: `index entry for ${file}`,
+    apply: (current) => {
+      const line = composeEntry(current, memory, title ?? memory.name, hook ?? memory.description);
+      if (current === null) return { text: `# Memory\n\n${line}\n`, line, at: 2, added: true };
+
+      const parsed = parseIndex(current);
+      if (parsed.entries.some((entry) => entry.file === file)) {
+        throw new Error(`MEMORY.md already has an entry for ${file}`);
+      }
+      const result = insertIndexEntry(current, sectionInsertIndex(parsed, section), line);
+      return { text: result.text, line, at: result.index, added: true };
+    },
+  });
+}
+
+function resolveTargets(memories) {
+  const byName = new Map();
+  const byStem = new Map();
+  for (const memory of memories) {
+    if (!byName.has(memory.name)) byName.set(memory.name, memory.file);
+    if (!byStem.has(memory.stem)) byStem.set(memory.stem, memory.file);
+  }
+  return (target) => byName.get(target) || byStem.get(target) || null;
+}
+
+function loadAll(dir) {
+  return listMemoryFiles(dir).map((file) => loadMemory(dir, file)).filter(Boolean);
+}
+
+function mergePlan(dir, into, from) {
+  if (into === from) throw new Error('A memory cannot be merged into itself');
+  const target = requireIndexable(dir, into);
+  const source = requireIndexable(dir, from);
+
+  const memories = loadAll(dir);
+  const resolve = resolveTargets(memories);
+  const pointsAtSource = (link) => resolve(link) === source.file;
+
+  const inbound = [];
+  const selfLinks = [];
+  for (const memory of memories) {
+    if (memory.file === source.file) continue;
+    const targets = memory.outbound.filter(pointsAtSource);
+    if (!targets.length) continue;
+    if (memory.file === target.file) selfLinks.push(...targets);
+    else inbound.push({ file: memory.file, name: memory.name, targets });
+  }
+
+  const indexText = readIndex(dir);
+  const parsed = indexText === null ? null : parseIndex(indexText);
+  const sourceEntries = parsed ? parsed.entries.filter((entry) => entry.file === from) : [];
+  const inlineRefs = parsed
+    ? parsed.inlineLinks.filter((link) => link.file === from).map((link) => ({ index: link.index, text: link.text }))
+    : [];
+
+  return { target, source, inbound, selfLinks, indexText, sourceEntries, inlineRefs };
+}
+
+export function mergePreview(dir, { into, from }) {
+  const plan = mergePlan(dir, into, from);
+  return {
+    into,
+    from,
+    intoName: plan.target.name,
+    fromName: plan.source.name,
+    heading: plan.source.name,
+    bodyLines: plan.source.body.trim() ? plan.source.body.trim().split('\n').length : 0,
+    inbound: plan.inbound,
+    selfLinks: plan.selfLinks,
+    indexLines: plan.sourceEntries.map((entry) => ({ index: entry.index, text: entry.text })),
+    inlineRefs: plan.inlineRefs,
+    hasIndex: plan.indexText !== null,
+  };
+}
+
+export function mergeMemories(dir, { into, from, heading = null }) {
+  const plan = mergePlan(dir, into, from);
+  const { target, source } = plan;
+
+  const title = String(heading ?? '').trim() || source.name;
+  if (/[\r\n]/.test(title)) throw new Error('A heading has to stay on one line');
+
+  const body = source.body.trim();
+  const joined = `${target.raw.replace(/\s*$/, '')}\n\n## ${title}\n\n${body}\n`;
+  const merged = plan.selfLinks.reduce((text, link) => unwrapWikilink(text, link).text, joined);
+
+  const rewrites = [{ file: target.file, text: merged }];
+  for (const entry of plan.inbound) {
+    const memory = loadMemory(dir, entry.file);
+    if (!memory) continue;
+    const text = entry.targets.reduce((current, link) => retargetWikilink(current, link, target.name).text, memory.raw);
+    if (text !== memory.raw) rewrites.push({ file: entry.file, text });
+  }
+
+  const indexBefore = plan.indexText;
+  const indexAfter = indexBefore === null ? null : removeIndexEntries(indexBefore, [from]);
+
+  const trashPath = trashDir(dir);
+  const stamp = timestamp();
+  const backups = [];
+
+  for (const rewrite of rewrites) {
+    const memory = loadMemory(dir, rewrite.file);
+    backups.push({
+      file: rewrite.file,
+      backupFile: backupInto(trashPath, `${stamp}_${rewrite.file}.before-merge.md`, memory.raw),
+    });
+  }
+  if (indexBefore !== null) {
+    backups.push({
+      file: 'MEMORY.md',
+      backupFile: backupInto(trashPath, `${stamp}_MEMORY.md.before-merge.md`, indexBefore),
+    });
+  }
+
+  const trashedFile = `${stamp}_${from}`;
+  const done = [];
+  try {
+    for (const rewrite of rewrites) {
+      writeFileAtomic(dir, rewrite.file, rewrite.text);
+      done.push(rewrite.file);
+    }
+    if (indexAfter && indexAfter.text !== indexBefore) writeIndexAtomic(dir, indexAfter.text);
+    fs.renameSync(path.join(dir, source.file), path.join(trashPath, trashedFile));
+  } catch (err) {
+    for (const backup of backups) {
+      try {
+        writeFileAtomic(dir, backup.file, fs.readFileSync(path.join(trashPath, backup.backupFile), 'utf8'));
+      } catch { /* best effort */ }
+    }
+    for (const backup of backups) {
+      try { fs.unlinkSync(path.join(trashPath, backup.backupFile)); } catch { /* best effort */ }
+    }
+    throw err;
+  }
+
+  const record = {
+    version: 2,
+    kind: 'merge',
+    id: `${stamp}_merge_${from}`,
+    label: `${source.name} into ${target.name}`,
+    deletedAt: new Date().toISOString(),
+    into: target.file,
+    from: source.file,
+    heading: title,
+    backups,
+    files: [{ file: source.file, trashedFile, name: source.name, description: source.description }],
+    removedLines: indexAfter ? indexAfter.removed : [],
+    indexSha256Before: indexBefore === null ? null : sha256(indexBefore),
+    indexSha256After: indexAfter === null ? null : sha256(indexAfter.text),
+  };
+  fs.writeFileSync(path.join(trashPath, `${record.id}.restore.json`), JSON.stringify(record, null, 2));
+
+  return {
+    merged: true,
+    record,
+    rewritten: rewrites.map((rewrite) => rewrite.file),
+    retargeted: plan.inbound.length,
+    unwrapped: plan.selfLinks.length,
+  };
+}

package/src/parse.mjs

@@ -253,3 +253,179 @@ export function unwrapWikilink(text, target) {
   });
   return { text: out, count };
 }
+
+function splitEntryLine(line) {
+  const match = line.match(INDEX_LINE);
+  if (!match || match[1] !== '') return null;
+  const file = match[3];
+  const marker = `](${file})`;
+  const linkEnd = line.indexOf(marker) + marker.length;
+  const tail = line.slice(linkEnd);
+  const separator = tail.match(HOOK_SEP);
+  return {
+    head: line.slice(0, linkEnd),
+    title: match[2].trim(),
+    file,
+    separator: separator ? separator[0] : null,
+    hook: tail.replace(HOOK_SEP, ''),
+  };
+}
+
+function normalizeSeparator(raw) {
+  const char = raw.trim();
+  return char === ':' ? ': ' : ` ${char} `;
+}
+
+export function dominantSeparator(parsed) {
+  const counts = new Map();
+  for (const entry of parsed.entries) {
+    const parts = splitEntryLine(entry.text);
+    if (!parts || !parts.separator) continue;
+    const separator = normalizeSeparator(parts.separator);
+    counts.set(separator, (counts.get(separator) || 0) + 1);
+  }
+  let best = ' — ';
+  let bestCount = 0;
+  for (const [separator, count] of counts) {
+    if (count > bestCount) {
+      best = separator;
+      bestCount = count;
+    }
+  }
+  return best;
+}
+
+function requireLine(lines, index, expectedText) {
+  if (!Number.isInteger(index) || index < 0 || index >= lines.length) {
+    throw new Error(`Line ${index} is out of range`);
+  }
+  if (typeof expectedText === 'string' && lines[index] !== expectedText) {
+    throw new Error('MEMORY.md changed since this was loaded - reload and try again');
+  }
+}
+
+export function setIndexHook(text, index, expectedText, hook) {
+  const lines = text.split('\n');
+  requireLine(lines, index, expectedText);
+
+  const parts = splitEntryLine(lines[index]);
+  if (!parts) throw new Error(`Line ${index + 1} is not an index entry`);
+
+  const next = String(hook ?? '');
+  if (/[\r\n]/.test(next)) throw new Error('A hook has to stay on one line');
+  const trimmed = next.trim();
+
+  const separator = parts.separator || dominantSeparator(parseIndex(text));
+  const before = lines[index];
+  lines[index] = trimmed ? `${parts.head}${separator}${trimmed}` : parts.head;
+  return { text: lines.join('\n'), before, after: lines[index] };
+}
+
+export function entryBlock(lines, index) {
+  const block = [index];
+  for (let i = index + 1; i < lines.length; i++) {
+    if (!lines[i].trim()) break;
+    if (!/^[ \t]/.test(lines[i])) break;
+    block.push(i);
+  }
+  return block;
+}
+
+export function moveIndexEntry(text, index, expectedText, toIndex) {
+  const lines = text.split('\n');
+  requireLine(lines, index, expectedText);
+  if (!splitEntryLine(lines[index])) throw new Error(`Line ${index + 1} is not an index entry`);
+
+  const block = entryBlock(lines, index);
+  const target = Number(toIndex);
+  if (!Number.isInteger(target) || target < 0 || target > lines.length) {
+    throw new Error(`Cannot move to line ${toIndex}`);
+  }
+  if (target >= index && target <= block[block.length - 1] + 1) {
+    throw new Error('That target is inside the entry being moved');
+  }
+
+  const moved = block.map((i) => ({ index: i, text: lines[i] }));
+  const dropped = new Set(block);
+  const kept = lines.filter((_, i) => !dropped.has(i));
+  const at = target - block.filter((i) => i < target).length;
+  kept.splice(at, 0, ...moved.map((entry) => entry.text));
+  return { text: kept.join('\n'), moved, toIndex: at };
+}
+
+export function retargetWikilink(text, from, to) {
+  let count = 0;
+  const pattern = new RegExp(WIKILINK.source, 'g');
+  const out = text.replace(pattern, (match, name, alias) => {
+    if (name.trim() !== from) return match;
+    count += 1;
+    return alias === undefined ? `[[${to}]]` : `[[${to}|${alias}]]`;
+  });
+  return { text: out, count };
+}
+
+function endOfContent(lines, limit, floor = 0) {
+  let at = limit;
+  while (at > floor && !lines[at - 1].trim()) at -= 1;
+  return at;
+}
+
+export function sectionInsertIndex(parsed, section) {
+  const heading = section
+    ? parsed.parsedLines.find((line) => line.kind === 'heading' && line.section === section)
+    : null;
+  if (!heading) return endOfContent(parsed.lines, parsed.lines.length);
+
+  let end = parsed.lines.length;
+  for (const line of parsed.parsedLines) {
+    if (line.kind === 'heading' && line.index > heading.index && line.level <= heading.level) {
+      end = line.index;
+      break;
+    }
+  }
+
+  const entries = parsed.entries.filter((entry) => entry.index > heading.index && entry.index < end);
+  if (entries.length) {
+    const last = entries[entries.length - 1];
+    return entryBlock(parsed.lines, last.index).pop() + 1;
+  }
+
+  return endOfContent(parsed.lines, end, heading.index + 1);
+}
+
+export function insertIndexEntry(text, at, line) {
+  const lines = text.split('\n');
+  const target = Math.max(0, Math.min(Number(at), lines.length));
+  lines.splice(target, 0, line);
+  return { text: lines.join('\n'), index: target };
+}
+
+export function topInsertIndex(parsed) {
+  const { lines } = parsed;
+  let at = 0;
+
+  if (lines.length && lines[0].trim() === '---') {
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i].trim() === '---') {
+        at = i + 1;
+        break;
+      }
+    }
+  }
+
+  while (at < lines.length && !lines[at].trim()) at += 1;
+  if (parsed.parsedLines.some((line) => line.index === at && line.kind === 'heading')) {
+    at += 1;
+    while (at < lines.length && !lines[at].trim()) at += 1;
+  }
+  return at;
+}
+
+export function sectionStartIndex(parsed, section) {
+  const heading = parsed.parsedLines.find((line) => line.kind === 'heading' && line.section === section);
+  if (!heading) return topInsertIndex(parsed);
+
+  let at = heading.index + 1;
+  while (at < parsed.lines.length && !parsed.lines[at].trim()) at += 1;
+  return at;
+}