linksee-memory 0.0.4 → 0.0.6

package/dist/bin/import-sessions.js

@@ -11,7 +11,7 @@ import { readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { openDb, runMigrations } from '../db/migrate.js';
-import { parseSessionFile, projectNameFromCwd } from '../lib/session-parser.js';
+import { parseSessionFile, detectProjectName } from '../lib/session-parser.js';
 import { extractSession } from '../lib/session-extractor.js';
 const CLAUDE_PROJECTS = join(homedir(), '.claude', 'projects');
 function usage() {
@@ -76,7 +76,7 @@ async function main() {
             console.log(`[skip] empty or invalid session: ${sessionFile}`);
             return;
         }
-        const projectName = projectNameFromCwd(parsed.project_cwd) || 'unknown';
+        const projectName = detectProjectName(parsed) || 'unknown';
         const result = extractSession(parsed, projectName);
         if (dryRun) {
             console.log(`[dry] session ${result.session_id.slice(0, 8)} (${projectName}): ${result.memories.length} memories, ${result.file_edits.length} file_edits`);
@@ -86,9 +86,10 @@ async function main() {
             return;
         // Idempotent: wipe any prior data for THIS session before re-inserting
         const wiped = wipeSession(db, result.session_id);
-        // Resolve project entity
+        // Resolve project entity (canonical_key = project:<name>, so same project across
+        // different sessions/cwds collapses to one entity)
         let projectEntityId;
-        const canonicalKey = parsed.project_cwd;
+        const canonicalKey = `project:${projectName.toLowerCase()}`;
         const existing = db.prepare('SELECT id FROM entities WHERE canonical_key = ? OR (kind = ? AND LOWER(name) = LOWER(?))').get(canonicalKey, 'project', projectName);
         if (existing) {
             projectEntityId = existing.id;
@@ -169,7 +170,11 @@ async function main() {
             continue;
         }
         agg.projects++;
-        const dirName = projectDir.replace(/\\/g, '/').split('/').filter(Boolean).pop() ?? 'unknown';
+        // Decode Claude Code's project-dir encoding: "C--Users-HP-KanseiLINK" → "KanseiLINK"
+        // (the encoding replaces `/` with `--`, so the last segment is the actual project name)
+        const rawDirName = projectDir.replace(/\\/g, '/').split('/').filter(Boolean).pop() ?? 'unknown';
+        const decodedParts = rawDirName.split('--').filter(Boolean);
+        const dirName = decodedParts.length > 1 ? decodedParts[decodedParts.length - 1] : rawDirName;
         console.log(`\n=== Project: ${dirName} (${files.length} session files) ===`);
         let projectEntityId = null;
         for (const f of files) {
@@ -186,7 +191,10 @@ async function main() {
                 agg.sessions_skipped++;
                 continue;
             }
-            const projectName = projectNameFromCwd(parsed.project_cwd) || dirName;
+            // Detect project name from actual file edits (majority vote), falling back
+            // to cwd-based detection. Previously used cwd alone, which collapsed many
+            // distinct projects under one entity (e.g. "Card_Navi" for everything).
+            const projectName = detectProjectName(parsed) || dirName;
             const result = extractSession(parsed, projectName);
             agg.sessions_parsed++;
             agg.memories_planned += result.memories.length;
@@ -196,17 +204,16 @@ async function main() {
             }
             if (!db)
                 continue;
-            // Ensure entity exists (once per project)
-            if (projectEntityId === null) {
-                const canonicalKey = parsed.project_cwd;
-                const existing = db.prepare('SELECT id FROM entities WHERE canonical_key = ? OR (kind = ? AND LOWER(name) = LOWER(?))').get(canonicalKey, 'project', projectName);
-                if (existing) {
-                    projectEntityId = existing.id;
-                }
-                else {
-                    const ins = db.prepare('INSERT INTO entities (kind, name, canonical_key) VALUES (?, ?, ?)').run('project', projectName, canonicalKey);
-                    projectEntityId = Number(ins.lastInsertRowid);
-                }
+            // Resolve entity per-SESSION (not per-project-dir) since each session may
+            // belong to a different project based on its file ops.
+            const canonicalKey = `project:${projectName.toLowerCase()}`;
+            const existing = db.prepare('SELECT id FROM entities WHERE canonical_key = ? OR (kind = ? AND LOWER(name) = LOWER(?))').get(canonicalKey, 'project', projectName);
+            if (existing) {
+                projectEntityId = existing.id;
+            }
+            else {
+                const ins = db.prepare('INSERT INTO entities (kind, name, canonical_key) VALUES (?, ?, ?)').run('project', projectName, canonicalKey);
+                projectEntityId = Number(ins.lastInsertRowid);
             }
             // Idempotent: wipe any prior data for THIS session before re-inserting (Phase B)
             wipeSession(db, result.session_id);

package/dist/lib/session-parser.d.ts

@@ -38,3 +38,6 @@ export declare function isPastedExternalContent(text: string): boolean;
 export declare function isAutomatedSession(firstUserText: string): boolean;
 export declare function parseSessionFile(jsonlPath: string): ParsedSession | null;
 export declare function projectNameFromCwd(cwd: string): string;
+export declare function projectNameFromFilePath(filePath: string): string | null;
+export declare function projectNameFromFileOps(file_ops: ParsedSession['file_ops']): string | null;
+export declare function detectProjectName(parsed: ParsedSession): string;

package/dist/lib/session-parser.js

@@ -300,4 +300,97 @@ export function projectNameFromCwd(cwd) {
         return 'unknown';
     return cwd.replace(/\\/g, '/').replace(/\/$/, '').split('/').filter(Boolean).pop() ?? 'unknown';
 }
+// ─── Improved entity detection ───────────────────────────────────────────
+// Problem: projectNameFromCwd() uses the session's starting cwd, but Claude Code
+// sessions often edit files across many projects. Everything ends up tagged with
+// the one cwd name (e.g. "Card_Navi"), destroying recall precision.
+//
+// Solution: inspect file_ops, extract the project name from each file path,
+// and take the majority vote. Fall back to cwd if no useful file ops exist.
+// Directories we never treat as "project" — they're just user home conventions
+// or Claude Code internal dirs.
+const SKIP_DIR_SEGMENTS = new Set([
+    '.claude', '.config', '.cache', '.local', '.vscode', '.git', '.ssh', '.npm',
+    'Downloads', 'Documents', 'Desktop', 'Pictures', 'Music', 'Videos',
+    'node_modules', 'tmp', 'temp', 'AppData', 'Library',
+    'OneDrive', 'Dropbox', 'Google Drive',
+    'Users', 'home', 'HP', // part of the user home path itself
+    // Claude Code internal subdirs (appear when Claude reads its own state files):
+    'projects', 'commands', 'skills', 'worktrees', 'hooks', 'agents', 'plugins',
+    'settings', 'memory', 'todos', 'shell-snapshots', 'ide',
+]);
+// User-home-like prefixes we strip before looking for the project segment.
+// Add drive-letter-agnostic patterns that match Windows / macOS / Linux / WSL.
+const HOME_PATTERNS = [
+    /^[A-Za-z]:\/Users\/[^\/]+\//i, // C:/Users/HP/...
+    /^\/Users\/[^\/]+\//, // /Users/HP/... (macOS)
+    /^\/home\/[^\/]+\//, // /home/HP/... (Linux)
+    /^\/mnt\/[a-z]\/Users\/[^\/]+\//i, // /mnt/c/Users/HP/... (WSL)
+    /^[A-Za-z]:\/Set up company\//i, // D:/Set up company/... (Michie-specific)
+];
+function stripHomePrefix(normalized) {
+    for (const p of HOME_PATTERNS) {
+        if (p.test(normalized))
+            return normalized.replace(p, '');
+    }
+    return normalized;
+}
+// Extract a project name from a single file path.
+// Returns null if the path doesn't contain a meaningful project segment.
+export function projectNameFromFilePath(filePath) {
+    if (!filePath)
+        return null;
+    const normalized = filePath.replace(/\\/g, '/');
+    // Paths inside Claude Code's own state dir are internal — never a real project signal.
+    // e.g. C:/Users/HP/.claude/projects/C--Users-HP-KanseiLINK/abc.jsonl
+    if (/\/\.claude\//.test(normalized))
+        return null;
+    const rest = stripHomePrefix(normalized);
+    if (rest === normalized)
+        return null; // no home prefix matched, can't safely extract
+    const segments = rest.split('/').filter(Boolean);
+    for (const seg of segments) {
+        if (SKIP_DIR_SEGMENTS.has(seg))
+            continue;
+        if (seg.startsWith('.'))
+            continue;
+        // Skip single-file-like segments (have extension) — we want a directory name
+        if (/\.[a-z0-9]{1,5}$/i.test(seg))
+            continue;
+        // Skip Claude Code's project-dir encoding (e.g. "C--Users-HP-Xxx")
+        if (/^[A-Z]--/.test(seg))
+            continue;
+        return seg;
+    }
+    return null;
+}
+// Aggregate file_ops into a single project name by majority vote.
+// Returns null if no file_op yields a usable name.
+export function projectNameFromFileOps(file_ops) {
+    if (!file_ops || file_ops.length === 0)
+        return null;
+    const counts = new Map();
+    for (const op of file_ops) {
+        const name = projectNameFromFilePath(op.path);
+        if (name)
+            counts.set(name, (counts.get(name) ?? 0) + 1);
+    }
+    if (counts.size === 0)
+        return null;
+    let bestName = null;
+    let bestCount = 0;
+    for (const [name, count] of counts) {
+        if (count > bestCount) {
+            bestName = name;
+            bestCount = count;
+        }
+    }
+    return bestName;
+}
+// Combined detector: prefers file_ops majority, falls back to cwd-based.
+// This is the function import-sessions.ts should call.
+export function detectProjectName(parsed) {
+    return (projectNameFromFileOps(parsed.file_ops) ??
+        projectNameFromCwd(parsed.project_cwd));
+}
 //# sourceMappingURL=session-parser.js.map

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "linksee-memory",
-  "version": "0.0.4",
+  "version": "0.0.6",
+  "mcpName": "io.github.michielinksee/linksee-memory",
   "description": "Local-first agent memory MCP — cross-agent brain with 6-layer structured memory + token-saving file diff cache",
   "type": "module",
   "bin": {