@vodmal/vdx-cli 0.35.0 → 0.37.0

package/src/memory.ts

@@ -0,0 +1,367 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { remoteParts } from './author.ts';
+import { claudeConfigDir, projectDirName } from './conversations.ts';
+import { dict, str } from './narrow.ts';
+
+/**
+ * Where Claude Code keeps a project's memory (docs/tasks/claude-memory-in-project).
+ * Unset, it is `<config>/projects/<path, non-letters → "-">/memory/` — tied to the
+ * folder's path, so a moved folder loses it, and its conversations with it. The
+ * owner keeps it inside the project, `.claude/memory/`, named by
+ * `autoMemoryDirectory`: an absolute path or `~/`, nothing relative, no variables
+ * (Claude Code 2.1.308, DL #2). A path written there outlives a move as the trace of
+ * the old place.
+ */
+export type MemoryState =
+  /** In `.claude/memory/`, nothing left in the old place. */
+  | { kind: 'inside' }
+  /** In `.claude/memory/`, and notes still lie in the old place — a move made by hand. */
+  | { kind: 'leftovers'; old: string; notes: number; differ: number; onlyOld: number }
+  /** Not set: memory goes to the old place. */
+  | { kind: 'outside'; old: string; notes: number }
+  /**
+   * Set to `<X>/.claude/memory/` of a folder that is gone: the project moved from X. `stray`: X
+   * holds nothing but that memory — a session that read the old path wrote there after the move.
+   */
+  | { kind: 'moved'; setting: MemorySetting; from: string; conversations: string | null; stray: string | null }
+  /** Set to `<X>/.claude/memory/` of another folder that exists. */
+  | { kind: 'elsewhere'; setting: MemorySetting; from: string }
+  /** Set to a path of the owner's own choosing. */
+  | { kind: 'custom'; setting: MemorySetting };
+
+interface MemorySetting {
+  /** The settings file that names it. */
+  file: string;
+  /** The path it names, `~/` expanded, without the trailing slash. */
+  dir: string;
+}
+
+export interface MemoryCtx {
+  env: NodeJS.ProcessEnv;
+  home: string;
+}
+
+const MEMORY = path.join('.claude', 'memory');
+
+function realRoot(root: string): string {
+  try {
+    return fs.realpathSync(root);
+  } catch {
+    return path.resolve(root);
+  }
+}
+
+/** Where the setting is read, in Claude Code's order: local settings, the project's, the user's. */
+function settingFiles(root: string, ctx: MemoryCtx): string[] {
+  return [
+    path.join(root, '.claude', 'settings.local.json'),
+    path.join(root, '.claude', 'settings.json'),
+    path.join(claudeConfigDir(ctx.env, ctx.home), 'settings.json'),
+  ];
+}
+
+function readJson(file: string): Record<string, unknown> | null {
+  try {
+    return dict(JSON.parse(fs.readFileSync(file, 'utf8'))) ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function readSetting(root: string, ctx: MemoryCtx): MemorySetting | null {
+  for (const file of settingFiles(root, ctx)) {
+    const value = str(readJson(file)?.['autoMemoryDirectory']);
+    if (!value) continue;
+    const expanded = value.startsWith('~/') ? path.join(ctx.home, value.slice(2)) : value;
+    // Claude Code drops a relative path without a word (DL #2): it is no setting.
+    if (!path.isAbsolute(expanded)) continue;
+    return { file, dir: path.resolve(expanded) };
+  }
+  return null;
+}
+
+/** The old place: what Claude Code uses when nothing is set. */
+export function defaultMemoryDir(root: string, ctx: MemoryCtx): string {
+  return path.join(claudeConfigDir(ctx.env, ctx.home), 'projects', projectDirName(realRoot(root)), 'memory');
+}
+
+function entries(dir: string): string[] {
+  try {
+    return fs.readdirSync(dir).filter((n) => n !== '.DS_Store');
+  } catch {
+    return [];
+  }
+}
+
+function sameFile(a: string, b: string): boolean {
+  try {
+    return fs.readFileSync(a).equals(fs.readFileSync(b));
+  } catch {
+    return false;
+  }
+}
+
+export function memoryState(projectRoot: string, ctx: MemoryCtx): MemoryState {
+  const root = realRoot(projectRoot);
+  const target = path.join(root, MEMORY);
+  const old = defaultMemoryDir(root, ctx);
+  const setting = readSetting(root, ctx);
+  const notes = entries(old);
+  if (!setting) return { kind: 'outside', old, notes: notes.length };
+  if (setting.dir === target) {
+    if (notes.length === 0) return { kind: 'inside' };
+    const differ = notes.filter(
+      (n) => fs.existsSync(path.join(target, n)) && !sameFile(path.join(old, n), path.join(target, n)),
+    );
+    const onlyOld = notes.filter((n) => !fs.existsSync(path.join(target, n)));
+    return { kind: 'leftovers', old, notes: notes.length, differ: differ.length, onlyOld: onlyOld.length };
+  }
+  if (path.basename(setting.dir) === 'memory' && path.basename(path.dirname(setting.dir)) === '.claude') {
+    const from = path.dirname(path.dirname(setting.dir));
+    const stub = entries(from).join() === '.claude' && entries(path.join(from, '.claude')).join() === 'memory';
+    if (fs.existsSync(from) && !stub) return { kind: 'elsewhere', setting, from };
+    const conversations = path.join(claudeConfigDir(ctx.env, ctx.home), 'projects', projectDirName(from));
+    return {
+      kind: 'moved',
+      setting,
+      from,
+      conversations: fs.existsSync(conversations) ? conversations : null,
+      stray: stub ? setting.dir : null,
+    };
+  }
+  return { kind: 'custom', setting };
+}
+
+function git(root: string, args: string[]): string | null {
+  try {
+    return execFileSync('git', ['--no-optional-locks', '-C', root, ...args], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * A personal project's memory goes under git with it; anyone else's would reach
+ * whoever clones it (DL #3, #4). Personal: no origin, or origin on a host the
+ * profile names in `git.personal_hosts`.
+ */
+export function isPersonalProject(projectRoot: string, personalHosts: string[]): boolean {
+  const url = git(projectRoot, ['remote', 'get-url', 'origin']);
+  if (!url) return true;
+  const host = remoteParts(url).host.toLowerCase();
+  return personalHosts.some((h) => h.toLowerCase() === host);
+}
+
+/** Needs `vdx doctor --fix`: anything but inside, or a path of the owner's own. */
+export function memoryNeedsFix(state: MemoryState): boolean {
+  return state.kind !== 'inside' && state.kind !== 'custom';
+}
+
+function tilde(p: string, home: string): string {
+  return p === home || p.startsWith(home + path.sep) ? '~' + p.slice(home.length) : p;
+}
+
+/** One line on where the memory is, for doctor and `vdx ai`. */
+export function describeMemory(state: MemoryState, ctx: MemoryCtx): string {
+  switch (state.kind) {
+    case 'inside':
+      return 'in .claude/memory/';
+    case 'leftovers': {
+      const parts = [state.differ ? `${state.differ} differ` : '', state.onlyOld ? `${state.onlyOld} only there` : '']
+        .filter(Boolean)
+        .join(', ');
+      return `in .claude/memory/, and ${state.notes} note(s) still in the old place, ${tilde(state.old, ctx.home)}${parts ? ` (${parts})` : ''} — the project's agent takes what it needs, vdx copies nothing back`;
+    }
+    case 'outside':
+      return state.notes
+        ? `outside the project: ${state.notes} note(s) in ${tilde(state.old, ctx.home)} — a moved folder loses them, and its conversations`
+        : `not set: notes would go to ${tilde(state.old, ctx.home)}, by the folder's path — a moved folder loses them, and its conversations`;
+    case 'moved':
+      return `autoMemoryDirectory points to ${tilde(state.setting.dir, ctx.home)}/, ${state.stray ? 'in a folder that holds nothing else' : 'a folder that is gone'} — the project moved from ${tilde(state.from, ctx.home)}${state.conversations ? ', and its conversations stay under the old path' : ''}`;
+    case 'elsewhere':
+      return `autoMemoryDirectory points to the memory of another folder, ${tilde(state.from, ctx.home)} (set in ${tilde(state.setting.file, ctx.home)})`;
+    case 'custom':
+      return `in ${tilde(state.setting.dir, ctx.home)}/ (autoMemoryDirectory, set in ${tilde(state.setting.file, ctx.home)})`;
+  }
+}
+
+export interface MemoryFixOptions {
+  /** Personal project (`isPersonalProject`): the path goes into `.claude/settings.json`, the memory under git. */
+  personal: boolean;
+  /** Not personal: keep `.claude/memory/` under git anyway — the person said yes. */
+  underGit: boolean;
+  /** YYYY-MM-DD, for the name the old place is set aside under. */
+  today: string;
+}
+
+/** A free name beside `dir`: `<dir>.moved-<date>`, then `-2`, `-3`… */
+function asideName(dir: string, today: string): string {
+  const base = `${dir}.moved-${today}`;
+  let name = base;
+  for (let i = 2; fs.existsSync(name); i++) name = `${base}-${i}`;
+  return name;
+}
+
+/** Copies what `to` lacks; a name `to` already has stays as it is there. Returns the names kept. */
+function copyMissing(from: string, to: string): { copied: number; kept: string[] } {
+  fs.mkdirSync(to, { recursive: true });
+  let copied = 0;
+  const kept: string[] = [];
+  for (const name of entries(from)) {
+    const src = path.join(from, name);
+    const dst = path.join(to, name);
+    if (fs.existsSync(dst)) {
+      if (!sameFile(src, dst)) kept.push(name);
+      continue;
+    }
+    fs.cpSync(src, dst, { recursive: true, errorOnExist: true, force: false });
+    copied++;
+  }
+  return { copied, kept };
+}
+
+/** Sets `autoMemoryDirectory` in a settings file, keeping its other keys. */
+function writeSetting(file: string, dir: string): void {
+  let doc: Record<string, unknown> = {};
+  if (fs.existsSync(file)) {
+    const parsed = readJson(file);
+    if (!parsed)
+      throw new Error(`${file} is not a JSON object — nothing written; set autoMemoryDirectory there by hand`);
+    doc = parsed;
+  }
+  doc['autoMemoryDirectory'] = dir + '/';
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(doc, null, 2) + '\n');
+}
+
+/** `/.claude/memory/` in the clone's own exclude file — the repository itself does not change. */
+function excludeMemory(root: string): string | null {
+  const file = git(root, ['rev-parse', '--git-path', 'info/exclude']);
+  if (!file) return null;
+  const abs = path.resolve(root, file);
+  const line = '/.claude/memory/';
+  const text = fs.existsSync(abs) ? fs.readFileSync(abs, 'utf8') : '';
+  if (!text.split('\n').includes(line)) {
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, text + (text && !text.endsWith('\n') ? '\n' : '') + line + '\n');
+  }
+  return abs;
+}
+
+/**
+ * Moves the project's conversations to the folder's new path: Claude Code finds them
+ * by the path, and a moved folder starts with none. What the new place already has
+ * stays; the rest of the old place is set aside, never deleted.
+ */
+function moveConversations(from: string, to: string, today: string): string {
+  if (!fs.existsSync(to)) {
+    fs.renameSync(from, to);
+    return `conversations ${path.basename(from)} → ${path.basename(to)}`;
+  }
+  let moved = 0;
+  for (const name of entries(from)) {
+    const dst = path.join(to, name);
+    if (fs.existsSync(dst)) continue;
+    fs.renameSync(path.join(from, name), dst);
+    moved++;
+  }
+  const left = entries(from).length;
+  const aside = left ? asideName(from, today) : null;
+  if (aside) fs.renameSync(from, aside);
+  else fs.rmdirSync(from);
+  return `${moved} conversation file(s) ${path.basename(from)} → ${path.basename(to)}${aside ? `; ${left} already there, the rest set aside as ${path.basename(aside)}` : ''}`;
+}
+
+/**
+ * Puts the project's memory inside it — `vdx doctor --fix` and the question in
+ * `vdx ai`. Nothing is overwritten and nothing deleted: a name `.claude/memory/`
+ * already has stays, the old place is renamed. Returns what was done, one line each.
+ */
+export function fixMemory(projectRoot: string, state: MemoryState, ctx: MemoryCtx, opts: MemoryFixOptions): string[] {
+  const root = realRoot(projectRoot);
+  const target = path.join(root, MEMORY);
+  const done: string[] = [];
+  const setAside = (old: string) => {
+    if (!fs.existsSync(old)) return;
+    const aside = asideName(old, opts.today);
+    fs.renameSync(old, aside);
+    done.push(`the old place set aside: ${tilde(aside, ctx.home)}`);
+  };
+  switch (state.kind) {
+    case 'inside':
+    case 'custom':
+      return done;
+    case 'leftovers':
+      setAside(state.old);
+      return done;
+    case 'outside': {
+      const { copied, kept } = fs.existsSync(state.old) ? copyMissing(state.old, target) : { copied: 0, kept: [] };
+      if (!fs.existsSync(target)) fs.mkdirSync(target, { recursive: true });
+      done.push(`${copied} note(s) → .claude/memory/`);
+      if (kept.length) done.push(`kept .claude/memory/ as it is for ${kept.join(', ')} — the old copy differs`);
+      const file = path.join(root, '.claude', opts.personal ? 'settings.json' : 'settings.local.json');
+      writeSetting(file, target);
+      done.push(`autoMemoryDirectory → .claude/${path.basename(file)}`);
+      if (!opts.personal && !opts.underGit && excludeMemory(root)) done.push('.claude/memory/ → .git/info/exclude');
+      setAside(state.old);
+      if (opts.personal && git(root, ['rev-parse', '--git-dir']) !== null) {
+        done.push('commit .claude/memory/ and .claude/settings.json with the project');
+      }
+      return done;
+    }
+    case 'moved':
+    case 'elsewhere': {
+      writeSetting(state.setting.file, target);
+      done.push(`autoMemoryDirectory → ${target}/ (${path.relative(root, state.setting.file)})`);
+      if (state.kind === 'moved' && state.stray) {
+        const { copied, kept } = copyMissing(state.stray, target);
+        done.push(
+          `${copied} note(s) written at the old path after the move → .claude/memory/${kept.length ? `; kept .claude/memory/ as it is for ${kept.join(', ')}` : ''} — ${tilde(state.from, ctx.home)} holds only them, remove it`,
+        );
+      }
+      if (state.kind === 'moved' && state.conversations) {
+        const here = path.join(claudeConfigDir(ctx.env, ctx.home), 'projects', projectDirName(root));
+        done.push(moveConversations(state.conversations, here, opts.today));
+      }
+      return done;
+    }
+  }
+}
+
+export interface ProjectMemoryDeps {
+  /** One line from the person at the terminal; null without one. */
+  ask: (prompt: string) => string | null;
+  log: (line: string) => void;
+  today: string;
+  /** The profile's `git.personal_hosts`. */
+  personalHosts: string[];
+}
+
+/**
+ * `fixMemory` with the question it needs: outside a personal project the memory stays
+ * out of git unless the person says yes — a publication cannot be taken back (DL #3,
+ * #4); without a terminal, out.
+ */
+export function fixProjectMemory(
+  projectRoot: string,
+  state: MemoryState,
+  ctx: MemoryCtx,
+  deps: ProjectMemoryDeps,
+): string[] {
+  const personal = isPersonalProject(projectRoot, deps.personalHosts);
+  let underGit = false;
+  if (state.kind === 'outside' && !personal && git(projectRoot, ['rev-parse', '--git-dir']) !== null) {
+    deps.log(`  ${path.basename(projectRoot)} is not a personal repo: memory under git reaches whoever clones it`);
+    underGit = /^y(es)?$/i.test(deps.ask('  Keep .claude/memory/ under git? [y/N] ')?.trim() ?? '');
+  }
+  const done = fixMemory(projectRoot, state, ctx, { personal, underGit, today: deps.today });
+  if (done.length && (state.kind === 'outside' || state.kind === 'moved')) {
+    done.push('sessions of this project running now keep the old place until they restart');
+  }
+  return done;
+}

package/src/publish.ts

@@ -199,6 +199,17 @@ export function checkNpmAuth(registry: string | null, npm: NpmRunner): Preflight
         fix,
       };
     }
+    // A 5xx is the registry's trouble, not the login: 0.35.0 met E503 during an npm
+    // incident on 2026-10-22, and the line read as a failed login.
+    const outage = /\bE(5\d\d)\b/.exec(stderr);
+    if (outage) {
+      const npmjs = !registry || registry.includes('registry.npmjs.org');
+      return {
+        name: 'npm-auth',
+        ok: false,
+        message: `${where} is not answering (E${outage[1]}) — trouble on its side, not the login${npmjs ? '; status: https://status.npmjs.org' : ''}. Run vdx publish again once it answers`,
+      };
+    }
     return {
       name: 'npm-auth',
       ok: false,