basic-memory 0.2.12__py3-none-any.whl → 0.16.1__py3-none-any.whl

basic_memory/services/link_resolver.py

@@ -1,14 +1,13 @@
 """Service for resolving markdown links to permalinks."""
 
-from typing import Optional, Tuple, List
+from typing import Optional, Tuple
 
 from loguru import logger
 
-from basic_memory.repository.entity_repository import EntityRepository
-from basic_memory.repository.search_repository import SearchIndexRow
-from basic_memory.services.search_service import SearchService
 from basic_memory.models import Entity
+from basic_memory.repository.entity_repository import EntityRepository
 from basic_memory.schemas.search import SearchQuery, SearchItemType
+from basic_memory.services.search_service import SearchService
 
 
 class LinkResolver:
@@ -17,8 +16,9 @@ class LinkResolver:
     Uses a combination of exact matching and search-based resolution:
     1. Try exact permalink match (fastest)
     2. Try exact title match
-    3. Fall back to search for fuzzy matching
-    4. Generate new permalink if no match found
+    3. Try exact file path match
+    4. Try file path with .md extension (for folder/title patterns)
+    5. Fall back to search for fuzzy matching
     """
 
     def __init__(self, entity_repository: EntityRepository, search_service: SearchService):
@@ -26,9 +26,17 @@ class LinkResolver:
         self.entity_repository = entity_repository
         self.search_service = search_service
 
-    async def resolve_link(self, link_text: str, use_search: bool = True) -> Optional[Entity]:
-        """Resolve a markdown link to a permalink."""
-        logger.debug(f"Resolving link: {link_text}")
+    async def resolve_link(
+        self, link_text: str, use_search: bool = True, strict: bool = False
+    ) -> Optional[Entity]:
+        """Resolve a markdown link to a permalink.
+
+        Args:
+            link_text: The link text to resolve
+            use_search: Whether to use search-based fuzzy matching as fallback
+            strict: If True, only exact matches are allowed (no fuzzy search fallback)
+        """
+        logger.trace(f"Resolving link: {link_text}")
 
         # Clean link text and extract any alias
         clean_text, alias = self._normalize_link_text(link_text)
@@ -40,26 +48,47 @@ class LinkResolver:
             return entity
 
         # 2. Try exact title match
-        entity = await self.entity_repository.get_by_title(clean_text)
-        if entity:
+        found = await self.entity_repository.get_by_title(clean_text)
+        if found:
+            # Return first match if there are duplicates (consistent behavior)
+            entity = found[0]
             logger.debug(f"Found title match: {entity.title}")
             return entity
 
-        if use_search:
-            # 3. Fall back to search for fuzzy matching on title if specified
+        # 3. Try file path
+        found_path = await self.entity_repository.get_by_file_path(clean_text)
+        if found_path:
+            logger.debug(f"Found entity with path: {found_path.file_path}")
+            return found_path
+
+        # 4. Try file path with .md extension if not already present
+        if not clean_text.endswith(".md") and "/" in clean_text:
+            file_path_with_md = f"{clean_text}.md"
+            found_path_md = await self.entity_repository.get_by_file_path(file_path_with_md)
+            if found_path_md:
+                logger.debug(f"Found entity with path (with .md): {found_path_md.file_path}")
+                return found_path_md
+
+        # In strict mode, don't try fuzzy search - return None if no exact match found
+        if strict:
+            return None
+
+        # 5. Fall back to search for fuzzy matching (only if not in strict mode)
+        if use_search and "*" not in clean_text:
             results = await self.search_service.search(
-                query=SearchQuery(title=clean_text, types=[SearchItemType.ENTITY]),
+                query=SearchQuery(text=clean_text, entity_types=[SearchItemType.ENTITY]),
             )
 
             if results:
                 # Look for best match
-                best_match = self._select_best_match(clean_text, results)
-                logger.debug(
+                best_match = min(results, key=lambda x: x.score)  # pyright: ignore
+                logger.trace(
                     f"Selected best match from {len(results)} results: {best_match.permalink}"
                 )
-                return await self.entity_repository.get_by_permalink(best_match.permalink)
+                if best_match.permalink:
+                    return await self.entity_repository.get_by_permalink(best_match.permalink)
 
-            # if we couldn't find anything then return None
+        # if we couldn't find anything then return None
         return None
 
     def _normalize_link_text(self, link_text: str) -> Tuple[str, Optional[str]]:
@@ -84,43 +113,8 @@ class LinkResolver:
             text, alias = text.split("|", 1)
             text = text.strip()
             alias = alias.strip()
+        else:
+            # Strip whitespace from text even if no alias
+            text = text.strip()
 
         return text, alias
-
-    def _select_best_match(self, search_text: str, results: List[SearchIndexRow]) -> Entity:
-        """Select best match from search results.
-
-        Uses multiple criteria:
-        1. Word matches in title field
-        2. Word matches in path
-        3. Overall search score
-        """
-        # Get search terms for matching
-        terms = search_text.lower().split()
-
-        # Score each result
-        scored_results = []
-        for result in results:
-            # Start with base score (lower is better)
-            score = result.score
-            assert score is not None
-
-            # Parse path components
-            path_parts = result.permalink.lower().split("/")
-            last_part = path_parts[-1] if path_parts else ""
-
-            # Title word match boosts
-            term_matches = [term for term in terms if term in last_part]
-            if term_matches:
-                score *= 0.5  # Boost for each matching term
-
-            # Exact title match is best
-            if last_part == search_text.lower():
-                score *= 0.2
-
-            scored_results.append((score, result))
-
-        # Sort by score (lowest first) and return best
-        scored_results.sort(key=lambda x: x[0], reverse=True)
-
-        return scored_results[0][1]