feat(index): implement per-project database isolation

Store memory index in project-local .memory/index.db instead of a global
database. This ensures complete isolation between repositories:

- Each repo clone gets its own SQLite index
- Sync/reindex operations only affect current project
- No cross-contamination or orphaned databases
- Deleting a project removes its memory index

Changes:
- Add get_project_index_path() and get_project_memory_dir() to config
- Update SyncService, RecallService, and hooks to use project index
- Add .memory/ to .gitignore
- Bump schema version to 2 with repo_path column for metadata

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: zircote

.gitignore

@@ -78,3 +78,6 @@ dmypy.json
 .cs-session-state.json
 .prompt-log.json
 .prompt-log-enabled
+
+# Memory plugin local index
+.memory/

src/git_notes_memory/config.py

@@ -39,8 +39,12 @@
     "INDEX_DB_NAME",
     "MODELS_DIR_NAME",
     "LOCK_FILE_NAME",
+    "MEMORY_DIR_NAME",
     "get_data_path",
     "get_index_path",
+    "get_project_index_path",
+    "get_project_identifier",
+    "get_project_memory_dir",
     "get_models_path",
     "get_lock_path",
     # Embedding Configuration
@@ -177,14 +181,96 @@ def get_data_path() -> Path:
 
 
 def get_index_path() -> Path:
-    """Get the path to the SQLite index database.
+    """Get the path to the global SQLite index database.
+
+    Note: For per-project isolation, use get_project_index_path() instead.
 
     Returns:
         Path to index.db file.
     """
     return get_data_path() / INDEX_DB_NAME
 
 
+MEMORY_DIR_NAME = ".memory"
+
+
+def get_project_identifier(repo_path: Path | str | None = None) -> str:
+    """Get a unique identifier for a repository.
+
+    Uses the repository's git remote URL if available, otherwise falls back
+    to the canonical path. The identifier is a short hash for filesystem safety.
+
+    Args:
+        repo_path: Path to the repository. If None, uses current directory.
+
+    Returns:
+        A short identifier string (e.g., "a1b2c3d4") unique to this repository.
+    """
+    import hashlib
+    import subprocess
+
+    if repo_path is None:
+        repo_path = Path.cwd()
+    else:
+        repo_path = Path(repo_path).resolve()
+
+    # Try to get the remote URL for a stable identifier across machines
+    try:
+        result = subprocess.run(  # noqa: S603
+            ["git", "-C", str(repo_path), "config", "--get", "remote.origin.url"],  # noqa: S607
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            identifier_source = result.stdout.strip()
+        else:
+            # Fall back to canonical path
+            identifier_source = str(repo_path)
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        identifier_source = str(repo_path)
+
+    # Create a short hash for filesystem-safe naming
+    hash_digest = hashlib.sha256(identifier_source.encode()).hexdigest()[:12]
+    return hash_digest
+
+
+def get_project_memory_dir(repo_path: Path | str | None = None) -> Path:
+    """Get the path to the project's .memory directory.
+
+    The .memory directory stores project-specific memory data including
+    the SQLite index. This directory should be added to .gitignore.
+
+    Args:
+        repo_path: Path to the repository. If None, uses current directory.
+
+    Returns:
+        Path to .memory/ directory in the repository root.
+    """
+    if repo_path is None:
+        repo_path = Path.cwd()
+    else:
+        repo_path = Path(repo_path).resolve()
+
+    return repo_path / MEMORY_DIR_NAME
+
+
+def get_project_index_path(repo_path: Path | str | None = None) -> Path:
+    """Get the path to a project-specific SQLite index database.
+
+    Each repository gets its own index database stored in <repo>/.memory/index.db.
+    This ensures sync/reindex operations only affect the current project.
+    The .memory directory should be added to .gitignore.
+
+    Args:
+        repo_path: Path to the repository. If None, uses current directory.
+
+    Returns:
+        Path to project-specific index.db file (e.g., <repo>/.memory/index.db).
+    """
+    return get_project_memory_dir(repo_path) / INDEX_DB_NAME
+
+
 def get_models_path() -> Path:
     """Get the path to the embedding models directory.
 

src/git_notes_memory/hooks/context_builder.py

@@ -18,7 +18,7 @@
 from datetime import datetime, timedelta
 from typing import TYPE_CHECKING
 
-from git_notes_memory.config import TOKENS_PER_CHAR, get_index_path
+from git_notes_memory.config import TOKENS_PER_CHAR, get_project_index_path
 from git_notes_memory.hooks.config_loader import (
     BudgetMode,
     HookConfig,
@@ -105,7 +105,7 @@ def _get_index_service(self) -> IndexService:
         if self._index_service is None:
             from git_notes_memory.index import IndexService
 
-            self._index_service = IndexService(get_index_path())
+            self._index_service = IndexService(get_project_index_path())
         return self._index_service
 
     # -------------------------------------------------------------------------

src/git_notes_memory/hooks/session_start_handler.py

@@ -34,7 +34,7 @@
 import sys
 from typing import Any
 
-from git_notes_memory.config import HOOK_SESSION_START_TIMEOUT, get_index_path
+from git_notes_memory.config import HOOK_SESSION_START_TIMEOUT, get_project_index_path
 from git_notes_memory.hooks.config_loader import load_hook_config
 from git_notes_memory.hooks.context_builder import ContextBuilder
 from git_notes_memory.hooks.guidance_builder import GuidanceBuilder
@@ -125,7 +125,7 @@ def _get_memory_count() -> int:
         Number of memories indexed, or 0 if index doesn't exist.
     """
     try:
-        index_path = get_index_path()
+        index_path = get_project_index_path()
         if not index_path.exists():
             return 0
         index = IndexService(index_path)

src/git_notes_memory/index.py

@@ -21,6 +21,7 @@
 
 from __future__ import annotations
 
+import contextlib
 import sqlite3
 from contextlib import contextmanager
 from datetime import UTC, datetime
@@ -47,7 +48,7 @@
 # =============================================================================
 
 # Schema version for migrations
-SCHEMA_VERSION = 1
+SCHEMA_VERSION = 2
 
 # SQL statements for schema creation
 _CREATE_MEMORIES_TABLE = """
@@ -58,6 +59,7 @@
     summary TEXT NOT NULL,
     content TEXT NOT NULL,
     timestamp TEXT NOT NULL,
+    repo_path TEXT,
     spec TEXT,
     phase TEXT,
     tags TEXT,
@@ -74,8 +76,18 @@
     "CREATE INDEX IF NOT EXISTS idx_memories_commit ON memories(commit_sha)",
     "CREATE INDEX IF NOT EXISTS idx_memories_timestamp ON memories(timestamp)",
     "CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status)",
+    "CREATE INDEX IF NOT EXISTS idx_memories_repo_path ON memories(repo_path)",
 ]
 
+# Migration SQL for schema version upgrades
+_MIGRATIONS = {
+    2: [
+        # Add repo_path column for per-repository memory isolation
+        "ALTER TABLE memories ADD COLUMN repo_path TEXT",
+        "CREATE INDEX IF NOT EXISTS idx_memories_repo_path ON memories(repo_path)",
+    ],
+}
+
 _CREATE_VEC_TABLE = f"""
 CREATE VIRTUAL TABLE IF NOT EXISTS vec_memories USING vec0(
     id TEXT PRIMARY KEY,
@@ -199,8 +211,48 @@ def _load_vec_extension(self) -> None:
                 "Install sqlite-vec: pip install sqlite-vec",
             ) from e
 
+    def _get_current_schema_version(self) -> int:
+        """Get the current schema version from the database.
+
+        Returns:
+            Current schema version, or 0 if metadata table doesn't exist.
+        """
+        if self._conn is None:
+            return 0
+
+        cursor = self._conn.cursor()
+        try:
+            cursor.execute("SELECT value FROM metadata WHERE key = 'schema_version'")
+            row = cursor.fetchone()
+            return int(row[0]) if row else 1  # Default to v1 for existing DBs
+        except sqlite3.OperationalError:
+            # Metadata table doesn't exist - new database
+            return 0
+
+    def _run_migrations(self, from_version: int, to_version: int) -> None:
+        """Run schema migrations from one version to another.
+
+        Args:
+            from_version: Current schema version.
+            to_version: Target schema version.
+        """
+        if self._conn is None:
+            return
+
+        cursor = self._conn.cursor()
+        for version in range(from_version + 1, to_version + 1):
+            if version in _MIGRATIONS:
+                for sql in _MIGRATIONS[version]:
+                    try:
+                        cursor.execute(sql)
+                    except sqlite3.OperationalError as e:
+                        # Column may already exist from a partial migration
+                        if "duplicate column" not in str(e).lower():
+                            raise
+        self._conn.commit()
+
     def _create_schema(self) -> None:
-        """Create database tables and indices."""
+        """Create database tables and indices, running migrations if needed."""
         if self._conn is None:
             raise MemoryIndexError(
                 "Database connection not established",
@@ -209,28 +261,36 @@ def _create_schema(self) -> None:
 
         cursor = self._conn.cursor()
         try:
+            # Check current schema version before creating tables
+            current_version = self._get_current_schema_version()
+
             # Create memories table
             cursor.execute(_CREATE_MEMORIES_TABLE)
 
-            # Create indices
+            # Create indices (ignore if they already exist)
             for index_sql in _CREATE_INDICES:
-                cursor.execute(index_sql)
+                with contextlib.suppress(sqlite3.OperationalError):
+                    cursor.execute(index_sql)
 
             # Create vector table
             cursor.execute(_CREATE_VEC_TABLE)
 
             # Create metadata table
             cursor.execute(_CREATE_METADATA_TABLE)
 
+            # Run migrations if needed
+            if 0 < current_version < SCHEMA_VERSION:
+                self._run_migrations(current_version, SCHEMA_VERSION)
+
             # Set schema version
             cursor.execute(
                 "INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)",
                 ("schema_version", str(SCHEMA_VERSION)),
             )
 
-            # Set last sync to now
+            # Set last sync to now (only if not already set)
             cursor.execute(
-                "INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)",
+                "INSERT OR IGNORE INTO metadata (key, value) VALUES (?, ?)",
                 ("last_sync", datetime.now(UTC).isoformat()),
             )
 
@@ -309,9 +369,9 @@ def insert(
                     """
                     INSERT INTO memories (
                         id, commit_sha, namespace, summary, content,
-                        timestamp, spec, phase, tags, status, relates_to,
+                        timestamp, repo_path, spec, phase, tags, status, relates_to,
                         created_at, updated_at
-                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                     """,
                     (
                         memory.id,
@@ -320,6 +380,7 @@ def insert(
                         memory.summary,
                         memory.content,
                         memory.timestamp.isoformat(),
+                        memory.repo_path,
                         memory.spec,
                         memory.phase,
                         ",".join(memory.tags) if memory.tags else None,

src/git_notes_memory/models.py

@@ -105,6 +105,7 @@ class Memory:
         summary: One-line summary (max 100 chars)
         content: Full markdown content of the note
         timestamp: When the memory was captured
+        repo_path: Absolute path to the git repository containing this memory
         spec: Specification slug this memory belongs to (may be None for global)
         phase: Lifecycle phase (planning, implementation, review, etc.)
         tags: Categorization tags
@@ -118,6 +119,7 @@ class Memory:
     summary: str
     content: str
     timestamp: datetime
+    repo_path: str | None = None
     spec: str | None = None
     phase: str | None = None
     tags: tuple[str, ...] = field(default_factory=tuple)

src/git_notes_memory/recall.py

@@ -17,7 +17,7 @@
 from collections.abc import Sequence
 from typing import TYPE_CHECKING
 
-from git_notes_memory.config import TOKENS_PER_CHAR, get_index_path
+from git_notes_memory.config import TOKENS_PER_CHAR, get_project_index_path
 from git_notes_memory.exceptions import RecallError
 from git_notes_memory.models import (
     CommitInfo,
@@ -89,7 +89,8 @@ def __init__(
             git_ops: Optional pre-configured GitOps instance.
                 If not provided, one will be created lazily.
         """
-        self._index_path = index_path or get_index_path()
+        # Use project-specific index for per-repository isolation
+        self._index_path = index_path or get_project_index_path()
         self._index_service = index_service
         self._embedding_service = embedding_service
         self._git_ops = git_ops

src/git_notes_memory/sync.py

@@ -17,7 +17,7 @@
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from git_notes_memory.config import NAMESPACES, get_data_path
+from git_notes_memory.config import NAMESPACES, get_project_index_path
 from git_notes_memory.exceptions import RecallError
 from git_notes_memory.models import Memory, NoteRecord, VerificationResult
 
@@ -74,11 +74,12 @@ def __init__(
         self._note_parser = note_parser
 
     def _get_index(self) -> IndexService:
-        """Get or create IndexService instance."""
+        """Get or create IndexService instance using project-specific database."""
         if self._index is None:
             from git_notes_memory.index import IndexService
 
-            self._index = IndexService(get_data_path() / "index.db")
+            # Use project-specific index for per-repository isolation
+            self._index = IndexService(get_project_index_path(self.repo_path))
             self._index.initialize()
         return self._index
 

tests/test_index.py

@@ -153,7 +153,7 @@ def test_initialize_sets_schema_version(self, db_path: Path) -> None:
         cursor.execute("SELECT value FROM metadata WHERE key = 'schema_version'")
         row = cursor.fetchone()
         assert row is not None
-        assert row[0] == "1"
+        assert row[0] == "2"  # Schema v2 adds repo_path column
 
         service.close()