fix: handle missing 'name' key in memory JSON import (#241)

Signed-off-by: Joe P <joe@basicmemory.com>
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: jope-bm <jope-bm@users.noreply.github.com>

Author: jope-bm

src/basic_memory/cli/commands/import_memory_json.py

@@ -76,7 +76,8 @@ def memory_json(
             Panel(
                 f"[green]Import complete![/green]\n\n"
                 f"Created {result.entities} entities\n"
-                f"Added {result.relations} relations",
+                f"Added {result.relations} relations\n"
+                f"Skipped {result.skipped_entities} entities\n",
                 expand=False,
             )
         )

src/basic_memory/importers/memory_json_importer.py

@@ -32,6 +32,7 @@ async def import_data(
             # First pass - collect all relations by source entity
             entity_relations: Dict[str, List[Relation]] = {}
             entities: Dict[str, Dict[str, Any]] = {}
+            skipped_entities: int = 0
 
             # Ensure the base path exists
             base_path = config.home  # pragma: no cover
@@ -42,7 +43,13 @@ async def import_data(
             for line in source_data:
                 data = line
                 if data["type"] == "entity":
-                    entities[data["name"]] = data
+                    # Handle different possible name keys
+                    entity_name = data.get("name") or data.get("entityName") or data.get("id")
+                    if not entity_name:
+                        logger.warning(f"Entity missing name field: {data}")
+                        skipped_entities += 1
+                        continue
+                    entities[entity_name] = data
                 elif data["type"] == "relation":
                     # Store relation with its source entity
                     source = data.get("from") or data.get("from_id")
@@ -58,25 +65,31 @@ async def import_data(
             # Second pass - create and write entities
             entities_created = 0
             for name, entity_data in entities.items():
+                # Get entity type with fallback
+                entity_type = entity_data.get("entityType") or entity_data.get("type") or "entity"
+
                 # Ensure entity type directory exists
-                entity_type_dir = base_path / entity_data["entityType"]
+                entity_type_dir = base_path / entity_type
                 entity_type_dir.mkdir(parents=True, exist_ok=True)
 
+                # Get observations with fallback to empty list
+                observations = entity_data.get("observations", [])
+
                 entity = EntityMarkdown(
                     frontmatter=EntityFrontmatter(
                         metadata={
-                            "type": entity_data["entityType"],
+                            "type": entity_type,
                             "title": name,
-                            "permalink": f"{entity_data['entityType']}/{name}",
+                            "permalink": f"{entity_type}/{name}",
                         }
                     ),
                     content=f"# {name}\n",
-                    observations=[Observation(content=obs) for obs in entity_data["observations"]],
+                    observations=[Observation(content=obs) for obs in observations],
                     relations=entity_relations.get(name, []),
                 )
 
                 # Write entity file
-                file_path = base_path / f"{entity_data['entityType']}/{name}.md"
+                file_path = base_path / f"{entity_type}/{name}.md"
                 await self.write_entity(entity, file_path)
                 entities_created += 1
 
@@ -87,6 +100,7 @@ async def import_data(
                 success=True,
                 entities=entities_created,
                 relations=relations_count,
+                skipped_entities=skipped_entities,
             )
 
         except Exception as e:  # pragma: no cover

src/basic_memory/mcp/tools/read_note.py

@@ -68,7 +68,7 @@ async def read_note(
 
     # Get the file via REST API - first try direct permalink lookup
     entity_path = memory_url_path(identifier)
-    
+
     # Validate path to prevent path traversal attacks
     project_path = active_project.home
     if not validate_project_path(entity_path, project_path):

src/basic_memory/schemas/importer.py

@@ -32,3 +32,4 @@ class EntityImportResult(ImportResult):
 
     entities: int = 0
     relations: int = 0
+    skipped_entities: int = 0

src/basic_memory/utils.py

@@ -220,23 +220,23 @@ def validate_project_path(path: str, project_path: Path) -> bool:
     # Allow empty strings as they resolve to the project root
     if not path:
         return True
-    
+
     # Check for obvious path traversal patterns first
     if ".." in path or "~" in path:
         return False
-    
+
     # Check for Windows-style path traversal (even on Unix systems)
     if "\\.." in path or path.startswith("\\"):
         return False
-    
+
     # Block absolute paths (Unix-style starting with / or Windows-style with drive letters)
     if path.startswith("/") or (len(path) >= 2 and path[1] == ":"):
         return False
-    
+
     # Block paths with control characters (but allow whitespace that will be stripped)
-    if path.strip() and any(ord(c) < 32 and c not in [' ', '\t'] for c in path):
+    if path.strip() and any(ord(c) < 32 and c not in [" ", "\t"] for c in path):
         return False
-    
+
     try:
         resolved = (project_path / path).resolve()
         return resolved.is_relative_to(project_path.resolve())

tests/cli/test_import_memory_json.py

@@ -113,3 +113,43 @@ def test_import_json_command_handle_old_format(tmp_path):
     result = runner.invoke(import_app, ["memory-json", str(json_file)])
     assert result.exit_code == 0
     assert "Import complete" in result.output
+
+
+def test_import_json_command_missing_name_key(tmp_path):
+    """Test handling JSON with missing 'name' key using 'id' instead."""
+    # Create JSON with id instead of name (common in Knowledge Graph Memory Server)
+    data_with_id = [
+        {
+            "type": "entity",
+            "id": "test_entity_id",
+            "entityType": "test",
+            "observations": ["Test observation with id"],
+        },
+        {
+            "type": "entity",
+            "entityName": "test_entity_2",
+            "entityType": "test",
+            "observations": ["Test observation with entityName"],
+        },
+        {
+            "type": "entity",
+            "name": "test_entity_title",
+            "entityType": "test",
+            "observations": ["Test observation with name"],
+        },
+    ]
+
+    json_file = tmp_path / "missing_name.json"
+    with open(json_file, "w", encoding="utf-8") as f:
+        for item in data_with_id:
+            f.write(json.dumps(item) + "\n")
+
+    # Set up test environment
+    monkeypatch = pytest.MonkeyPatch()
+    monkeypatch.setenv("HOME", str(tmp_path))
+
+    # Run import - should not fail even without 'name' key
+    result = runner.invoke(import_app, ["memory-json", str(json_file)])
+    assert result.exit_code == 0
+    assert "Import complete" in result.output
+    assert "Created 3 entities" in result.output

tests/mcp/test_tool_move_note.py

@@ -650,7 +650,7 @@ async def test_move_note_allows_safe_paths(self, client):
             assert isinstance(result, str)
             # Should NOT contain security error message
             assert "Security Validation Error" not in result
-            
+
             # If it fails, it should be for other reasons like "already exists" or API errors
             if "Move Failed" in result:
                 assert "paths must stay within project boundaries" not in result
@@ -672,7 +672,7 @@ async def test_move_note_security_logging(self, client, caplog):
         )
 
         assert "# Move Failed - Security Validation Error" in result
-        
+
         # Check that security violation was logged
         # Note: This test may need adjustment based on the actual logging setup
         # The security validation should generate a warning log entry
@@ -710,7 +710,7 @@ async def test_move_note_current_directory_references_security(self, client):
         # Test current directory references (should be safe)
         safe_paths = [
             "./notes/file.md",
-            "folder/./file.md", 
+            "folder/./file.md",
             "./folder/subfolder/file.md",
         ]