claude-mneme 2.9.1 → 2.10.2

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-mneme",
-  "version": "2.8.0",
-  "description": "Persistent memory system for Claude Code - remembers context across sessions",
+  "version": "2.10.2",
+  "description": "Automatic session memory for Claude Code — every session picks up where the last one left off",
   "author": {
     "name": "Edin Mujkanovic"
   },
@@ -11,7 +11,12 @@
     "memory",
     "context",
     "persistence",
-    "mneme",
-    "claude-code"
+    "session",
+    "history",
+    "remember",
+    "summarization",
+    "project-context",
+    "claude-code",
+    "mneme"
   ]
 }

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="../assets/claude-mneme-mascot-128.png" alt="Claude Mneme Mascot" width="128">
+  <img src="https://raw.githubusercontent.com/edimuj/claude-mneme/main/assets/claude-mneme-mascot-128.png" alt="Claude Mneme Mascot" width="128">
 </p>
 
 # Claude Mneme — Plugin

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mneme",
-  "version": "2.9.1",
+  "version": "2.10.2",
   "type": "module",
   "scripts": {
     "install-deps": "npm install",

package/scripts/session-start.mjs

@@ -83,17 +83,21 @@ async function main() {
   // MEDIUM PRIORITY - Inject if relevant/recent
   // ============================================================================
 
+  // Read last session timestamp (used for git changes and temporal header)
+  let lastSessionTs = null;
+  if (existsSync(paths.lastSession)) {
+    try {
+      lastSessionTs = readFileSync(paths.lastSession, 'utf-8').trim() || null;
+    } catch {}
+  }
+
   // Git changes since last session
   let gitChanges = '';
   const gcConfig = sections.gitChanges || { enabled: true };
   if (gcConfig.enabled !== false) {
     try {
-      let sinceArg = null;
-      if (existsSync(paths.lastSession)) {
-        sinceArg = readFileSync(paths.lastSession, 'utf-8').trim();
-      }
-      if (sinceArg) {
-        const log = execFileSync('git', ['log', '--oneline', `--since=${sinceArg}`], {
+      if (lastSessionTs) {
+        const log = execFileSync('git', ['log', '--oneline', `--since=${lastSessionTs}`], {
           encoding: 'utf8',
           cwd,
           stdio: ['ignore', 'pipe', 'ignore']
@@ -176,6 +180,27 @@ async function main() {
   if (hasContent) {
     console.log(`<claude-mneme project="${escapeAttr(projectName)}">`);
 
+    // Temporal header — session time + last session reference
+    const now = new Date();
+    const sessionTime = now.toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit', hour12: false });
+    let temporalLine = `Session started: ${sessionTime}`;
+    if (lastSessionTs) {
+      const lastDate = new Date(lastSessionTs);
+      const lastFormatted = lastDate.toLocaleString(undefined, {
+        month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit', hour12: false
+      });
+      const diffMin = Math.floor((now - lastDate) / 60000);
+      let relative;
+      if (diffMin < 2) relative = 'just now';
+      else if (diffMin < 60) relative = `${diffMin} minutes ago`;
+      else {
+        const diffHours = Math.floor(diffMin / 60);
+        relative = `${diffHours} hour${diffHours !== 1 ? 's' : ''} ago`;
+      }
+      temporalLine += ` | Last session: ${lastFormatted} (${relative})`;
+    }
+    console.log(`\n${temporalLine}`);
+
     // HANDOFF from previous session (highest immediate value)
     if (handoff) {
       console.log('\n## Last Session\n');

package/scripts/sync.mjs

@@ -11,7 +11,7 @@ import { hostname } from 'os';
 import { randomUUID } from 'crypto';
 import http from 'http';
 import https from 'https';
-import { ensureMemoryDirs, getProjectName, logError } from './utils.mjs';
+import { ensureMemoryDirs, getProjectRoot, logError } from './utils.mjs';
 
 // ============================================================================
 // Client ID Management
@@ -180,7 +180,11 @@ class SyncClient {
 
     this.cwd = cwd;
     this.paths = ensureMemoryDirs(cwd);
-    this.projectId = syncConfig.projectId || getProjectName(cwd);
+    // Default projectId uses sanitized full path to match local dir naming.
+    // Breaking change for sync users without explicit projectId — server-side
+    // data needs manual rename or re-sync.
+    const root = getProjectRoot(cwd);
+    this.projectId = syncConfig.projectId || root.replace(/^\//, '-').replace(/\//g, '-');
     this.clientId = getClientId(this.paths.base);
 
     this.http = this.enabled

package/scripts/utils.mjs

@@ -19,36 +19,44 @@ export function escapeAttr(str) {
 }
 
 /**
- * Get the project name from cwd
- * Uses git repo root name if available, otherwise directory name
+ * Get the project root directory (absolute path).
+ * Uses git repo root if available, otherwise cwd.
  */
-export function getProjectName(cwd = process.cwd()) {
+export function getProjectRoot(cwd = process.cwd()) {
   try {
-    // Try to get git repo root using execFileSync (safer than execSync)
-    const gitRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], {
+    return execFileSync('git', ['rev-parse', '--show-toplevel'], {
       encoding: 'utf8',
       cwd,
       stdio: ['ignore', 'pipe', 'ignore']
     }).trim();
-    return basename(gitRoot);
   } catch {
-    // Not a git repo, use directory name
-    return basename(cwd);
+    return cwd;
   }
 }
 
 /**
- * Get the project-specific memory directory
+ * Get the project name from cwd (display name only — basename of root)
+ */
+export function getProjectName(cwd = process.cwd()) {
+  return basename(getProjectRoot(cwd));
+}
+
+/**
+ * Get the project-specific memory directory.
+ * Uses full absolute path as dirname to avoid collisions between
+ * projects with the same basename (e.g. ~/work/api vs ~/personal/api).
+ * Convention: /home/foo/bar → -home-foo-bar (matches Claude Code's own auto-memory).
  */
 function getProjectMemoryDir(cwd = process.cwd()) {
-  const projectName = getProjectName(cwd);
-  // Sanitize project name for filesystem
-  const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, '_');
+  const projectRoot = getProjectRoot(cwd);
+  // Convert absolute path to safe dirname: /home/foo/bar → -home-foo-bar
+  const safeName = projectRoot.replace(/^\//, '-').replace(/\//g, '-');
   return join(MEMORY_BASE, 'projects', safeName);
 }
 
 /**
- * Ensure memory directories exist and return paths
+ * Ensure memory directories exist and return paths.
+ * Migrates old-style (basename-only) dirs to new-style (full-path) dirs.
  */
 export function ensureMemoryDirs(cwd = process.cwd()) {
   const projectDir = getProjectMemoryDir(cwd);
@@ -57,8 +65,15 @@ export function ensureMemoryDirs(cwd = process.cwd()) {
     mkdirSync(MEMORY_BASE, { recursive: true });
   }
 
+  // Migrate old-style (basename-only) dir to new-style (full-path) dir
   if (!existsSync(projectDir)) {
-    mkdirSync(projectDir, { recursive: true });
+    const oldName = getProjectName(cwd).replace(/[^a-zA-Z0-9_-]/g, '_');
+    const oldDir = join(MEMORY_BASE, 'projects', oldName);
+    if (existsSync(oldDir)) {
+      renameSync(oldDir, projectDir);
+    } else {
+      mkdirSync(projectDir, { recursive: true });
+    }
   }
 
   return {

package/scripts/utils.test.mjs

@@ -29,6 +29,9 @@ import {
   loadConfig,
   flushPendingLog,
   ensureMemoryDirs,
+  getProjectRoot,
+  getProjectName,
+  MEMORY_BASE,
   calculateRecencyScore,
   calculateFileRelevanceScore,
   calculateTypePriorityScore,
@@ -1463,3 +1466,122 @@ describe('stripMarkdown', () => {
     assert.ok(result.includes('needs review'));
   });
 });
+
+// ============================================================================
+// getProjectRoot
+// ============================================================================
+
+describe('getProjectRoot', () => {
+  it('returns an absolute path', () => {
+    const root = getProjectRoot();
+    assert.ok(root.startsWith('/'), `Expected absolute path, got ${root}`);
+  });
+
+  it('returns git root when inside a git repo', () => {
+    // We're running from inside the claude-mneme repo
+    const root = getProjectRoot();
+    assert.ok(root.endsWith('claude-mneme'), `Expected git root ending in claude-mneme, got ${root}`);
+  });
+
+  it('returns cwd for non-git directories', () => {
+    const tmp = mkdtempSync(join(tmpdir(), 'mneme-root-'));
+    try {
+      const root = getProjectRoot(tmp);
+      assert.equal(root, tmp, 'Should return cwd for non-git dir');
+    } finally {
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+});
+
+// ============================================================================
+// getProjectName (display name — basename only)
+// ============================================================================
+
+describe('getProjectName', () => {
+  it('returns basename of git root', () => {
+    const name = getProjectName();
+    assert.equal(name, 'claude-mneme');
+  });
+});
+
+// ============================================================================
+// getProjectMemoryDir (full-path-based naming + migration)
+// ============================================================================
+
+describe('ensureMemoryDirs (full-path naming + migration)', () => {
+  it('creates dir with full-path-based name', () => {
+    const paths = ensureMemoryDirs();
+    // Should contain the full path sanitized, not just basename
+    assert.ok(paths.project.includes('-home-') || paths.project.includes('-Users-'),
+      `Expected full-path dir name, got ${paths.project}`);
+    assert.ok(!paths.project.endsWith('/projects/claude-mneme'),
+      `Should NOT be old-style basename-only dir: ${paths.project}`);
+  });
+
+  it('migrates old-style dir to new-style dir', () => {
+    // Create a temp directory to simulate a project root
+    const tmp = mkdtempSync(join(tmpdir(), 'mneme-migrate-'));
+    const projectsDir = join(MEMORY_BASE, 'projects');
+
+    // Derive what old-style and new-style names would be for this temp dir
+    const oldName = tmp.split('/').pop().replace(/[^a-zA-Z0-9_-]/g, '_');
+    const newName = tmp.replace(/^\//, '-').replace(/\//g, '-');
+    const oldDir = join(projectsDir, oldName);
+    const newDir = join(projectsDir, newName);
+
+    try {
+      // Clean up any pre-existing dirs
+      if (existsSync(newDir)) rmSync(newDir, { recursive: true, force: true });
+      if (existsSync(oldDir)) rmSync(oldDir, { recursive: true, force: true });
+
+      // Create old-style dir with a marker file
+      mkdirSync(oldDir, { recursive: true });
+      writeFileSync(join(oldDir, 'marker.txt'), 'migrated');
+
+      // Call ensureMemoryDirs — should migrate old → new
+      const paths = ensureMemoryDirs(tmp);
+
+      assert.ok(existsSync(newDir), 'New-style dir should exist after migration');
+      assert.ok(!existsSync(oldDir), 'Old-style dir should be gone after migration');
+      assert.ok(existsSync(join(newDir, 'marker.txt')), 'Marker file should survive migration');
+      assert.equal(paths.project, newDir);
+    } finally {
+      // Clean up
+      if (existsSync(newDir)) rmSync(newDir, { recursive: true, force: true });
+      if (existsSync(oldDir)) rmSync(oldDir, { recursive: true, force: true });
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
+  it('does not migrate if new-style dir already exists', () => {
+    const tmp = mkdtempSync(join(tmpdir(), 'mneme-nomigrate-'));
+    const projectsDir = join(MEMORY_BASE, 'projects');
+
+    const oldName = tmp.split('/').pop().replace(/[^a-zA-Z0-9_-]/g, '_');
+    const newName = tmp.replace(/^\//, '-').replace(/\//g, '-');
+    const oldDir = join(projectsDir, oldName);
+    const newDir = join(projectsDir, newName);
+
+    try {
+      if (existsSync(newDir)) rmSync(newDir, { recursive: true, force: true });
+      if (existsSync(oldDir)) rmSync(oldDir, { recursive: true, force: true });
+
+      // Create BOTH dirs
+      mkdirSync(oldDir, { recursive: true });
+      writeFileSync(join(oldDir, 'old-marker.txt'), 'old');
+      mkdirSync(newDir, { recursive: true });
+      writeFileSync(join(newDir, 'new-marker.txt'), 'new');
+
+      ensureMemoryDirs(tmp);
+
+      // Old dir should still exist (no migration attempted)
+      assert.ok(existsSync(oldDir), 'Old dir should remain when new dir already exists');
+      assert.ok(existsSync(join(newDir, 'new-marker.txt')), 'New dir contents should be untouched');
+    } finally {
+      if (existsSync(newDir)) rmSync(newDir, { recursive: true, force: true });
+      if (existsSync(oldDir)) rmSync(oldDir, { recursive: true, force: true });
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+});