basic-memory 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

basic_memory/file_utils.py

@@ -1,7 +1,8 @@
 """Utilities for file operations."""
+
 import hashlib
 from pathlib import Path
-from typing import Dict, Any, Tuple
+from typing import Dict, Any
 
 import yaml
 from loguru import logger
@@ -9,35 +10,38 @@ from loguru import logger
 
 class FileError(Exception):
     """Base exception for file operations."""
+
     pass
 
 
 class FileWriteError(FileError):
     """Raised when file operations fail."""
+
     pass
 
 
 class ParseError(FileError):
     """Raised when parsing file content fails."""
+
     pass
 
 
 async def compute_checksum(content: str) -> str:
     """
     Compute SHA-256 checksum of content.
-    
+
     Args:
         content: Text content to hash
-        
+
     Returns:
         SHA-256 hex digest
-        
+
     Raises:
         FileError: If checksum computation fails
     """
     try:
         return hashlib.sha256(content.encode()).hexdigest()
-    except Exception as e:
+    except Exception as e:  # pragma: no cover
         logger.error(f"Failed to compute checksum: {e}")
         raise FileError(f"Failed to compute checksum: {e}")
 
@@ -45,16 +49,16 @@ async def compute_checksum(content: str) -> str:
 async def ensure_directory(path: Path) -> None:
     """
     Ensure directory exists, creating if necessary.
-    
+
     Args:
         path: Directory path to ensure
-        
+
     Raises:
         FileWriteError: If directory creation fails
     """
     try:
         path.mkdir(parents=True, exist_ok=True)
-    except Exception as e:
+    except Exception as e:  # pragma: no cover
         logger.error(f"Failed to create directory: {path}: {e}")
         raise FileWriteError(f"Failed to create directory {path}: {e}")
 
@@ -62,22 +66,20 @@ async def ensure_directory(path: Path) -> None:
 async def write_file_atomic(path: Path, content: str) -> None:
     """
     Write file with atomic operation using temporary file.
-    
+
     Args:
         path: Target file path
         content: Content to write
-        
+
     Raises:
         FileWriteError: If write operation fails
     """
     temp_path = path.with_suffix(".tmp")
     try:
         temp_path.write_text(content)
-        
-        # TODO check for path.exists()
         temp_path.replace(path)
         logger.debug(f"wrote file: {path}")
-    except Exception as e:
+    except Exception as e:  # pragma: no cover
         temp_path.unlink(missing_ok=True)
         logger.error(f"Failed to write file: {path}: {e}")
         raise FileWriteError(f"Failed to write file {path}: {e}")
@@ -85,16 +87,19 @@ async def write_file_atomic(path: Path, content: str) -> None:
 
 def has_frontmatter(content: str) -> bool:
     """
-    Check if content contains YAML frontmatter.
+    Check if content contains valid YAML frontmatter.
 
     Args:
         content: Content to check
 
     Returns:
-        True if content has frontmatter delimiter (---), False otherwise
+        True if content has valid frontmatter markers (---), False otherwise
     """
     content = content.strip()
-    return content.startswith("---") and "---" in content[3:]
+    if not content.startswith("---"):
+        return False
+
+    return "---" in content[3:]
 
 
 def parse_frontmatter(content: str) -> Dict[str, Any]:
@@ -111,7 +116,7 @@ def parse_frontmatter(content: str) -> Dict[str, Any]:
         ParseError: If frontmatter is invalid or parsing fails
     """
     try:
-        if not has_frontmatter(content):
+        if not content.strip().startswith("---"):
             raise ParseError("Content has no frontmatter")
 
         # Split on first two occurrences of ---
@@ -132,7 +137,7 @@ def parse_frontmatter(content: str) -> Dict[str, Any]:
         except yaml.YAMLError as e:
             raise ParseError(f"Invalid YAML in frontmatter: {e}")
 
-    except Exception as e:
+    except Exception as e:  # pragma: no cover
         if not isinstance(e, ParseError):
             logger.error(f"Failed to parse frontmatter: {e}")
             raise ParseError(f"Failed to parse frontmatter: {e}")
@@ -147,27 +152,23 @@ def remove_frontmatter(content: str) -> str:
         content: Content with frontmatter
 
     Returns:
-        Content with frontmatter removed
+        Content with frontmatter removed, or original content if no frontmatter
 
     Raises:
-        ParseError: If frontmatter format is invalid
+        ParseError: If content starts with frontmatter marker but is malformed
     """
-    try:
-        if not has_frontmatter(content):
-            return content.strip()
+    content = content.strip()
 
-        # Split on first two occurrences of ---
-        parts = content.split("---", 2)
-        if len(parts) < 3:
-            raise ParseError("Invalid frontmatter format")
+    # Return as-is if no frontmatter marker
+    if not content.startswith("---"):
+        return content
 
-        return parts[2].strip()
+    # Split on first two occurrences of ---
+    parts = content.split("---", 2)
+    if len(parts) < 3:
+        raise ParseError("Invalid frontmatter format")
 
-    except Exception as e:
-        if not isinstance(e, ParseError):
-            logger.error(f"Failed to remove frontmatter: {e}")
-            raise ParseError(f"Failed to remove frontmatter: {e}")
-        raise
+    return parts[2].strip()
 
 
 async def update_frontmatter(path: Path, updates: Dict[str, Any]) -> str:
@@ -208,6 +209,6 @@ async def update_frontmatter(path: Path, updates: Dict[str, Any]) -> str:
         await write_file_atomic(path, final_content)
         return await compute_checksum(final_content)
 
-    except Exception as e:
+    except Exception as e:  # pragma: no cover
         logger.error(f"Failed to update frontmatter in {path}: {e}")
-        raise FileError(f"Failed to update frontmatter: {e}")
+        raise FileError(f"Failed to update frontmatter: {e}")

basic_memory/markdown/entity_parser.py

@@ -2,6 +2,7 @@
 
 Uses markdown-it with plugins to parse structured data from markdown content.
 """
+
 from dataclasses import dataclass, field
 from pathlib import Path
 from datetime import datetime
@@ -21,11 +22,12 @@ from basic_memory.markdown.schemas import (
 
 md = MarkdownIt().use(observation_plugin).use(relation_plugin)
 
+
 @dataclass
 class EntityContent:
-    content: str 
-    observations: list[Observation] = field(default_factory=list) 
-    relations: list[Relation] = field(default_factory=list) 
+    content: str
+    observations: list[Observation] = field(default_factory=list)
+    relations: list[Relation] = field(default_factory=list)
 
 
 def parse(content: str) -> EntityContent:
@@ -53,13 +55,13 @@ def parse(content: str) -> EntityContent:
         relations=relations,
     )
 
+
 def parse_tags(tags: Any) -> list[str]:
     """Parse tags into list of strings."""
-    if isinstance(tags, str):
-        return [t.strip() for t in tags.split(",") if t.strip()]
     if isinstance(tags, (list, tuple)):
         return [str(t).strip() for t in tags if str(t).strip()]
-    return []
+    return [t.strip() for t in tags.split(",") if t.strip()]
+
 
 class EntityParser:
     """Parser for markdown files into Entity objects."""
@@ -68,21 +70,6 @@ class EntityParser:
         """Initialize parser with base path for relative permalink generation."""
         self.base_path = base_path.resolve()
 
-
-    def relative_path(self, file_path: Path) -> str:
-        """Get file path relative to base_path.
-
-        Example:
-            base_path: /project/root
-            file_path: /project/root/design/models/data.md
-            returns: "design/models/data"
-        """
-        # Get relative path and remove .md extension
-        rel_path = file_path.resolve().relative_to(self.base_path)
-        if rel_path.suffix.lower() == ".md":
-            return str(rel_path.with_suffix(""))
-        return str(rel_path)
-
     def parse_date(self, value: Any) -> Optional[datetime]:
         """Parse date strings using dateparser for maximum flexibility.
 
@@ -96,21 +83,18 @@ class EntityParser:
         if isinstance(value, datetime):
             return value
         if isinstance(value, str):
-            try:
-                parsed = dateparser.parse(value)
-                if parsed:
-                    return parsed
-            except Exception:
-                pass
+            parsed = dateparser.parse(value)
+            if parsed:
+                return parsed
         return None
 
     async def parse_file(self, file_path: Path) -> EntityMarkdown:
         """Parse markdown file into EntityMarkdown."""
-        
+
         absolute_path = self.base_path / file_path
         # Parse frontmatter and content using python-frontmatter
         post = frontmatter.load(str(absolute_path))
-        
+
         # Extract file stat info
         file_stats = absolute_path.stat()
 
@@ -134,4 +118,3 @@ class EntityParser:
             created=datetime.fromtimestamp(file_stats.st_ctime),
             modified=datetime.fromtimestamp(file_stats.st_mtime),
         )
-

basic_memory/markdown/markdown_processor.py

@@ -19,7 +19,7 @@ class DirtyFileError(Exception):
 
 class MarkdownProcessor:
     """Process markdown files while preserving content and structure.
-    
+
     used only for import
 
     This class handles the file I/O aspects of our markdown processing. It:
@@ -90,14 +90,14 @@ class MarkdownProcessor:
 
         # Convert frontmatter to dict
         frontmatter_dict = OrderedDict()
-        frontmatter_dict["title"] =  markdown.frontmatter.title
-        frontmatter_dict["type"] =  markdown.frontmatter.type
+        frontmatter_dict["title"] = markdown.frontmatter.title
+        frontmatter_dict["type"] = markdown.frontmatter.type
         frontmatter_dict["permalink"] = markdown.frontmatter.permalink
-        
+
         metadata = markdown.frontmatter.metadata or {}
-        for k,v in metadata.items():
+        for k, v in metadata.items():
             frontmatter_dict[k] = v
-        
+
         # Start with user content (or minimal title for new files)
         content = markdown.content or f"# {markdown.frontmatter.title}\n"
 
@@ -107,7 +107,7 @@ class MarkdownProcessor:
         # add a blank line if we have semantic content
         if markdown.observations or markdown.relations:
             content += "\n"
-            
+
         if markdown.observations:
             content += self.format_observations(markdown.observations)
         if markdown.relations:

basic_memory/markdown/plugins.py

@@ -8,19 +8,19 @@ from markdown_it.token import Token
 # Observation handling functions
 def is_observation(token: Token) -> bool:
     """Check if token looks like our observation format."""
-    if token.type != 'inline':
+    if token.type != "inline":  # pragma: no cover
         return False
-        
+
     content = token.content.strip()
-    if not content:
+    if not content:  # pragma: no cover
         return False
-    
+
     # if it's a markdown_task, return false
-    if content.startswith('[ ]') or content.startswith('[x]') or content.startswith('[-]'):
+    if content.startswith("[ ]") or content.startswith("[x]") or content.startswith("[-]"):
         return False
-    
-    has_category = content.startswith('[') and ']' in content
-    has_tags = '#' in content
+
+    has_category = content.startswith("[") and "]" in content
+    has_tags = "#" in content
     return has_category or has_tags
 
 
@@ -28,119 +28,126 @@ def parse_observation(token: Token) -> Dict[str, Any]:
     """Extract observation parts from token."""
     # Strip bullet point if present
     content = token.content.strip()
-    if content.startswith('- '):
-        content = content[2:].strip()
-    elif content.startswith('-'):
-        content = content[1:].strip()
-    
+
     # Parse [category]
     category = None
-    if content.startswith('['):
-        end = content.find(']')
+    if content.startswith("["):
+        end = content.find("]")
         if end != -1:
             category = content[1:end].strip() or None  # Convert empty to None
-            content = content[end + 1:].strip()
-    
+            content = content[end + 1 :].strip()
+
     # Parse (context)
     context = None
-    if content.endswith(')'):
-        start = content.rfind('(')
+    if content.endswith(")"):
+        start = content.rfind("(")
         if start != -1:
-            context = content[start + 1:-1].strip()
+            context = content[start + 1 : -1].strip()
             content = content[:start].strip()
-    
-    # Parse #tags and content
+
+    # Extract tags and keep original content
+    tags = []
     parts = content.split()
-    content_parts = []
-    tags = set()  # Use set to avoid duplicates
-    
     for part in parts:
-        if part.startswith('#'):
+        if part.startswith("#"):
             # Handle multiple #tags stuck together
-            if '#' in part[1:]:
+            if "#" in part[1:]:
                 # Split on # but keep non-empty tags
-                subtags = [t for t in part.split('#') if t]
-                tags.update(subtags)
+                subtags = [t for t in part.split("#") if t]
+                tags.extend(subtags)
             else:
-                tags.add(part[1:])
-        else:
-            content_parts.append(part)
-    
+                tags.append(part[1:])
+
     return {
-        'category': category,
-        'content': content,
-        'tags': list(tags) if tags else None,
-        'context': context
+        "category": category,
+        "content": content,
+        "tags": tags if tags else None,
+        "context": context,
     }
 
 
 # Relation handling functions
 def is_explicit_relation(token: Token) -> bool:
     """Check if token looks like our relation format."""
-    if token.type != 'inline':
+    if token.type != "inline":  # pragma: no cover
         return False
-    
+
     content = token.content.strip()
-    return '[[' in content and ']]' in content
+    return "[[" in content and "]]" in content
 
 
-def parse_relation(token: Token) -> Dict[str, Any]:
+def parse_relation(token: Token) -> Dict[str, Any] | None:
     """Extract relation parts from token."""
     # Remove bullet point if present
     content = token.content.strip()
-    if content.startswith('- '):
-        content = content[2:].strip()
-    elif content.startswith('-'):
-        content = content[1:].strip()
-    
+
     # Extract [[target]]
     target = None
-    rel_type = 'relates_to'  # default
+    rel_type = "relates_to"  # default
     context = None
-    
-    start = content.find('[[')
-    end = content.find(']]')
-    
+
+    start = content.find("[[")
+    end = content.find("]]")
+
     if start != -1 and end != -1:
         # Get text before link as relation type
         before = content[:start].strip()
         if before:
             rel_type = before
-            
+
         # Get target
-        target = content[start + 2:end].strip()
-        
+        target = content[start + 2 : end].strip()
+
         # Look for context after
-        after = content[end + 2:].strip()
-        if after.startswith('(') and after.endswith(')'):
+        after = content[end + 2 :].strip()
+        if after.startswith("(") and after.endswith(")"):
             context = after[1:-1].strip() or None
-    
-    if not target:
+
+    if not target:  # pragma: no cover
         return None
-        
-    return {
-        'type': rel_type,
-        'target': target,
-        'context': context
-    }
+
+    return {"type": rel_type, "target": target, "context": context}
 
 
 def parse_inline_relations(content: str) -> List[Dict[str, Any]]:
     """Find wiki-style links in regular content."""
     relations = []
-    
-    import re
-    pattern = r'\[\[([^\]]+)\]\]'
-    
-    for match in re.finditer(pattern, content):
-        target = match.group(1).strip()
-        if target and not target.startswith('[['):  # Avoid nested matches
-            relations.append({
-                'type': 'links to',
-                'target': target,
-                'context': None
-            })
-            
+    start = 0
+
+    while True:
+        # Find next outer-most [[
+        start = content.find("[[", start)
+        if start == -1:  # pragma: no cover
+            break
+
+        # Find matching ]]
+        depth = 1
+        pos = start + 2
+        end = -1
+
+        while pos < len(content):
+            if content[pos : pos + 2] == "[[":
+                depth += 1
+                pos += 2
+            elif content[pos : pos + 2] == "]]":
+                depth -= 1
+                if depth == 0:
+                    end = pos
+                    break
+                pos += 2
+            else:
+                pos += 1
+
+        if end == -1:
+            # No matching ]] found
+            break
+
+        target = content[start + 2 : end].strip()
+        if target:
+            relations.append({"type": "links to", "target": target, "context": None})
+
+        start = end + 2
+
     return relations
 
 
@@ -149,88 +156,67 @@ def observation_plugin(md: MarkdownIt) -> None:
     - [category] Content text #tag1 #tag2 (context)
     - Content text #tag1 (context)  # No category is also valid
     """
-    
+
     def observation_rule(state: Any) -> None:
         """Process observations in token stream."""
         tokens = state.tokens
-        current_section = None
-        in_list_item = False
-        
+
         for idx in range(len(tokens)):
             token = tokens[idx]
-            
-            # Track current section by headings
-            if token.type == 'heading_open':
-                next_token = tokens[idx + 1] if idx + 1 < len(tokens) else None
-                if next_token and next_token.type == 'inline':
-                    current_section = next_token.content.lower()
-            
-            # Track list nesting
-            elif token.type == 'list_item_open':
-                in_list_item = True
-            elif token.type == 'list_item_close':
-                in_list_item = False
-            
+
             # Initialize meta for all tokens
             token.meta = token.meta or {}
-            
+
             # Parse observations in list items
-            if token.type == 'inline' and is_observation(token):
+            if token.type == "inline" and is_observation(token):
                 obs = parse_observation(token)
-                if obs['content']:  # Only store if we have content
-                    token.meta['observation'] = obs
-    
+                if obs["content"]:  # Only store if we have content
+                    token.meta["observation"] = obs
+
     # Add the rule after inline processing
-    md.core.ruler.after('inline', 'observations', observation_rule)
+    md.core.ruler.after("inline", "observations", observation_rule)
 
 
 def relation_plugin(md: MarkdownIt) -> None:
     """Plugin for parsing relation formats:
-    
+
     Explicit relations:
     - relation_type [[target]] (context)
-    
+
     Implicit relations (links in content):
     Some text with [[target]] reference
     """
-    
+
     def relation_rule(state: Any) -> None:
         """Process relations in token stream."""
         tokens = state.tokens
-        current_section = None
         in_list_item = False
-        
+
         for idx in range(len(tokens)):
             token = tokens[idx]
-            
-            # Track current section by headings
-            if token.type == 'heading_open':
-                next_token = tokens[idx + 1] if idx + 1 < len(tokens) else None
-                if next_token and next_token.type == 'inline':
-                    current_section = next_token.content.lower()
-            
+
             # Track list nesting
-            elif token.type == 'list_item_open':
+            if token.type == "list_item_open":
                 in_list_item = True
-            elif token.type == 'list_item_close':
+            elif token.type == "list_item_close":
                 in_list_item = False
-            
+
             # Initialize meta for all tokens
             token.meta = token.meta or {}
-            
+
             # Only process inline tokens
-            if token.type == 'inline':
+            if token.type == "inline":
                 # Check for explicit relations in list items
                 if in_list_item and is_explicit_relation(token):
                     rel = parse_relation(token)
                     if rel:
-                        token.meta['relations'] = [rel]
-                
+                        token.meta["relations"] = [rel]
+
                 # Always check for inline links in any text
-                elif '[[' in token.content:
+                elif "[[" in token.content:
                     rels = parse_inline_relations(token.content)
                     if rels:
-                        token.meta['relations'] = token.meta.get('relations', []) + rels
-    
+                        token.meta["relations"] = token.meta.get("relations", []) + rels
+
     # Add the rule after inline processing
-    md.core.ruler.after('inline', 'relations', relation_rule)
+    md.core.ruler.after("inline", "relations", relation_rule)