basic-memory 0.12.2__tar.gz → 0.12.3__tar.gz

{basic_memory-0.12.2 → basic_memory-0.12.3}/CHANGELOG.md

@@ -1,6 +1,21 @@
 # CHANGELOG
 
 
+## v0.12.3 (2025-04-17)
+
+### Bug Fixes
+
+- Add extra logic for permalink generation with mixed Latin unicode and Chinese characters
+  ([`73ea91f`](https://github.com/basicmachines-co/basic-memory/commit/73ea91fe0d1f7ab89b99a1b691d59fe608b7fcbb))
+
+Signed-off-by: phernandez <paul@basicmachines.co>
+
+- Modify recent_activity args to be strings instead of enums
+  ([`3c1cc34`](https://github.com/basicmachines-co/basic-memory/commit/3c1cc346df519e703fae6412d43a92c7232c6226))
+
+Signed-off-by: phernandez <paul@basicmachines.co>
+
+
 ## v0.12.2 (2025-04-08)
 
 ### Bug Fixes

{basic_memory-0.12.2 → basic_memory-0.12.3}/CLAUDE.md

@@ -172,4 +172,18 @@ With GitHub integration, the development workflow includes:
 4. **Documentation maintenance** - Claude can keep documentation updated as the code evolves
 
 With this integration, the AI assistant is a full-fledged team member rather than just a tool for generating code
-snippets.
+snippets.
+
+
+### Basic Memory Pro
+
+Basic Memory Pro is a desktop GUI application that wraps the basic-memory CLI/MCP tools:
+
+- Built with Tauri (Rust), React (TypeScript), and a Python FastAPI sidecar
+- Provides visual knowledge graph exploration and project management
+- Uses the same core codebase but adds a desktop-friendly interface
+- Project configuration is shared between CLI and Pro versions
+- Multiple project support with visual switching interface
+
+local repo: /Users/phernandez/dev/basicmachines/basic-memory-pro
+github: https://github.com/basicmachines-co/basic-memory-pro

{basic_memory-0.12.2 → basic_memory-0.12.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: basic-memory
-Version: 0.12.2
+Version: 0.12.3
 Summary: Local-first knowledge management combining Zettelkasten with knowledge graphs
 Project-URL: Homepage, https://github.com/basicmachines-co/basic-memory
 Project-URL: Repository, https://github.com/basicmachines-co/basic-memory
@@ -367,9 +367,9 @@ config:
       "command": "uvx",
       "args": [
         "basic-memory",
-        "mcp",
         "--project",
-        "your-project-name"
+        "your-project-name",
+        "mcp"
       ]
     }
   }

{basic_memory-0.12.2 → basic_memory-0.12.3}/README.md

@@ -333,9 +333,9 @@ config:
       "command": "uvx",
       "args": [
         "basic-memory",
-        "mcp",
         "--project",
-        "your-project-name"
+        "your-project-name",
+        "mcp"
       ]
     }
   }

{basic_memory-0.12.2 → basic_memory-0.12.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "basic-memory"
-version = "0.12.2"
+version = "0.12.3"
 description = "Local-first knowledge management combining Zettelkasten with knowledge graphs"
 readme = "README.md"
 requires-python = ">=3.12.1"

{basic_memory-0.12.2 → basic_memory-0.12.3}/src/basic_memory/__init__.py

@@ -1,3 +1,3 @@
 """basic-memory - Local-first knowledge management combining Zettelkasten with knowledge graphs"""
 
-__version__ = "0.12.2"
+__version__ = "0.12.3"

{basic_memory-0.12.2 → basic_memory-0.12.3}/src/basic_memory/mcp/tools/read_note.py

@@ -111,7 +111,7 @@ def format_not_found_message(identifier: str) -> str:
         ## Search Instead
         Try searching for related content:
         ```
-        search(query="{identifier}")
+        search_notes(query="{identifier}")
         ```
         
         ## Recent Activity
@@ -172,7 +172,7 @@ def format_related_results(identifier: str, results) -> str:
         ## Search For More Results
         To see more related content:
         ```
-        search(query="{identifier}")
+        search_notes(query="{identifier}")
         ```
         
         ## Create New Note

{basic_memory-0.12.2 → basic_memory-0.12.3}/src/basic_memory/mcp/tools/recent_activity.py

@@ -1,6 +1,6 @@
 """Recent activity tool for Basic Memory MCP server."""
 
-from typing import Optional, List
+from typing import List, Union
 
 from loguru import logger
 
@@ -14,7 +14,7 @@ from basic_memory.schemas.search import SearchItemType
 
 @mcp.tool(
     description="""Get recent activity from across the knowledge base.
-    
+
     Timeframe supports natural language formats like:
     - "2 days ago"  
     - "last week"
@@ -25,9 +25,9 @@ from basic_memory.schemas.search import SearchItemType
     """,
 )
 async def recent_activity(
-    type: Optional[List[SearchItemType]] = None,
-    depth: Optional[int] = 1,
-    timeframe: Optional[TimeFrame] = "7d",
+    type: Union[str, List[str]] = "",
+    depth: int = 1,
+    timeframe: TimeFrame = "7d",
     page: int = 1,
     page_size: int = 10,
     max_related: int = 10,
@@ -35,11 +35,14 @@ async def recent_activity(
     """Get recent activity across the knowledge base.
 
     Args:
-        type: Filter by content type(s). Valid options:
-            - ["entity"] for knowledge entities
-            - ["relation"] for connections between entities
-            - ["observation"] for notes and observations
+        type: Filter by content type(s). Can be a string or list of strings.
+            Valid options:
+            - "entity" or ["entity"] for knowledge entities
+            - "relation" or ["relation"] for connections between entities
+            - "observation" or ["observation"] for notes and observations
             Multiple types can be combined: ["entity", "relation"]
+            Case-insensitive: "ENTITY" and "entity" are treated the same.
+            Default is an empty string, which returns all types.
         depth: How many relation hops to traverse (1-3 recommended)
         timeframe: Time window to search. Supports natural language:
             - Relative: "2 days ago", "last week", "yesterday"
@@ -59,14 +62,17 @@ async def recent_activity(
         # Get all entities for the last 10 days (default)
         recent_activity()
 
-        # Get all entities from yesterday
+        # Get all entities from yesterday (string format)
+        recent_activity(type="entity", timeframe="yesterday")
+
+        # Get all entities from yesterday (list format)
         recent_activity(type=["entity"], timeframe="yesterday")
 
         # Get recent relations and observations
         recent_activity(type=["relation", "observation"], timeframe="today")
 
         # Look back further with more context
-        recent_activity(type=["entity"], depth=2, timeframe="2 weeks ago")
+        recent_activity(type="entity", depth=2, timeframe="2 weeks ago")
 
     Notes:
         - Higher depth values (>3) may impact performance with large result sets
@@ -86,11 +92,27 @@ async def recent_activity(
     if timeframe:
         params["timeframe"] = timeframe  # pyright: ignore
 
-    # send enum values if we have an enum, else send string value
+    # Validate and convert type parameter
     if type:
-        params["type"] = [  # pyright: ignore
-            type.value if isinstance(type, SearchItemType) else type for type in type
-        ]
+        # Convert single string to list
+        if isinstance(type, str):
+            type_list = [type]
+        else:
+            type_list = type
+
+        # Validate each type against SearchItemType enum
+        validated_types = []
+        for t in type_list:
+            try:
+                # Try to convert string to enum
+                if isinstance(t, str):
+                    validated_types.append(SearchItemType(t.lower()))
+            except ValueError:
+                valid_types = [t.value for t in SearchItemType]
+                raise ValueError(f"Invalid type: {t}. Valid types are: {valid_types}")
+
+        # Add validated types to params
+        params["type"] = [t.value for t in validated_types]  # pyright: ignore
 
     response = await call_get(
         client,

{basic_memory-0.12.2 → basic_memory-0.12.3}/src/basic_memory/utils.py

@@ -5,11 +5,11 @@ import os
 import logging
 import re
 import sys
+import unicodedata
 from pathlib import Path
-from typing import Optional, Protocol, Union, runtime_checkable, List
+from typing import Optional, Protocol, Union, runtime_checkable, List, Any
 
 from loguru import logger
-from unidecode import unidecode
 
 
 @runtime_checkable
@@ -27,23 +27,23 @@ FilePath = Union[Path, str]
 logging.getLogger("opentelemetry.sdk.metrics._internal.instrument").setLevel(logging.ERROR)
 
 
-def generate_permalink(file_path: Union[Path, str, PathLike]) -> str:
-    """Generate a stable permalink from a file path.
-
-    Args:
-        file_path: Original file path (str, Path, or PathLike)
+def generate_permalink(file_path: Union[Path, str, Any]) -> str:
+    """
+    Generate a permalink from a file path.
 
     Returns:
         Normalized permalink that matches validation rules. Converts spaces and underscores
-        to hyphens for consistency.
+        to hyphens for consistency. Preserves non-ASCII characters like Chinese.
 
     Examples:
         >>> generate_permalink("docs/My Feature.md")
         'docs/my-feature'
-        >>> generate_permalink("specs/API (v2).md")
+        >>> generate_permalink("specs/API_v2.md")
         'specs/api-v2'
         >>> generate_permalink("design/unified_model_refactor.md")
         'design/unified-model-refactor'
+        >>> generate_permalink("中文/测试文档.md")
+        '中文/测试文档'
     """
     # Convert Path to string if needed
     path_str = str(file_path)
@@ -51,24 +51,74 @@ def generate_permalink(file_path: Union[Path, str, PathLike]) -> str:
     # Remove extension
     base = os.path.splitext(path_str)[0]
 
-    # Transliterate unicode to ascii
-    ascii_text = unidecode(base)
+    # Create a transliteration mapping for specific characters
+    transliteration_map = {
+        "ø": "o",  # Handle Søren -> soren
+        "å": "a",  # Handle Kierkegård -> kierkegard
+        "ü": "u",  # Handle Müller -> muller
+        "é": "e",  # Handle Café -> cafe
+        "è": "e",  # Handle Mère -> mere
+        "ê": "e",  # Handle Fête -> fete
+        "à": "a",  # Handle À la mode -> a la mode
+        "ç": "c",  # Handle Façade -> facade
+        "ñ": "n",  # Handle Niño -> nino
+        "ö": "o",  # Handle Björk -> bjork
+        "ä": "a",  # Handle Häagen -> haagen
+        # Add more mappings as needed
+    }
+
+    # Process character by character, transliterating Latin characters with diacritics
+    result = ""
+    for char in base:
+        # Direct mapping for known characters
+        if char.lower() in transliteration_map:
+            result += transliteration_map[char.lower()]
+        # General case using Unicode normalization
+        elif unicodedata.category(char).startswith("L") and ord(char) > 127:
+            # Decompose the character (e.g., ü -> u + combining diaeresis)
+            decomposed = unicodedata.normalize("NFD", char)
+            # If decomposition produced multiple characters and first one is ASCII
+            if len(decomposed) > 1 and ord(decomposed[0]) < 128:
+                # Keep only the base character
+                result += decomposed[0].lower()
+            else:
+                # For non-Latin scripts like Chinese, preserve the character
+                result += char
+        else:
+            # Add the character as is
+            result += char
+
+    # Handle special punctuation cases for apostrophes
+    result = result.replace("'", "")
 
     # Insert dash between camelCase
-    ascii_text = re.sub(r"([a-z0-9])([A-Z])", r"\1-\2", ascii_text)
+    # This regex finds boundaries between lowercase and uppercase letters
+    result = re.sub(r"([a-z0-9])([A-Z])", r"\1-\2", result)
+
+    # Insert dash between Chinese and Latin character boundaries
+    # This is needed for cases like "中文English" -> "中文-english"
+    result = re.sub(r"([\u4e00-\u9fff])([a-zA-Z])", r"\1-\2", result)
+    result = re.sub(r"([a-zA-Z])([\u4e00-\u9fff])", r"\1-\2", result)
 
-    # Convert to lowercase
-    lower_text = ascii_text.lower()
+    # Convert ASCII letters to lowercase, preserve non-ASCII characters
+    lower_text = "".join(c.lower() if c.isascii() and c.isalpha() else c for c in result)
 
-    # replace underscores with hyphens
+    # Replace underscores with hyphens
     text_with_hyphens = lower_text.replace("_", "-")
 
-    # Replace remaining invalid chars with hyphens
-    clean_text = re.sub(r"[^a-z0-9/\-]", "-", text_with_hyphens)
+    # Replace spaces and unsafe ASCII characters with hyphens, but preserve non-ASCII characters
+    # Include common Chinese character ranges and other non-ASCII characters
+    clean_text = re.sub(
+        r"[^a-z0-9\u4e00-\u9fff\u3000-\u303f\u3400-\u4dbf/\-]", "-", text_with_hyphens
+    )
 
     # Collapse multiple hyphens
     clean_text = re.sub(r"-+", "-", clean_text)
 
+    # Remove hyphens between adjacent Chinese characters only
+    # This handles cases like "你好-世界" -> "你好世界"
+    clean_text = re.sub(r"([\u4e00-\u9fff])-([\u4e00-\u9fff])", r"\1\2", clean_text)
+
     # Clean each path segment
     segments = clean_text.split("/")
     clean_segments = [s.strip("-") for s in segments]

basic_memory-0.12.2/tests/mcp/test_tool_memory.py → basic_memory-0.12.3/tests/mcp/test_tool_build_context.py

@@ -5,12 +5,9 @@ from datetime import datetime
 
 from mcp.server.fastmcp.exceptions import ToolError
 
-from basic_memory.mcp.tools import build_context, recent_activity
+from basic_memory.mcp.tools import build_context
 from basic_memory.schemas.memory import (
     GraphContext,
-    EntitySummary,
-    ObservationSummary,
-    RelationSummary,
 )
 
 
@@ -83,53 +80,6 @@ invalid_timeframes = [
 ]
 
 
-@pytest.mark.asyncio
-async def test_recent_activity_timeframe_formats(client, test_graph):
-    """Test that recent_activity accepts various timeframe formats."""
-    # Test each valid timeframe
-    for timeframe in valid_timeframes:
-        try:
-            result = await recent_activity(
-                type=["entity"], timeframe=timeframe, page=1, page_size=10, max_related=10
-            )
-            assert result is not None
-        except Exception as e:
-            pytest.fail(f"Failed with valid timeframe '{timeframe}': {str(e)}")
-
-    # Test invalid timeframes should raise ValidationError
-    for timeframe in invalid_timeframes:
-        with pytest.raises(ToolError):
-            await recent_activity(timeframe=timeframe)
-
-
-@pytest.mark.asyncio
-async def test_recent_activity_type_filters(client, test_graph):
-    """Test that recent_activity correctly filters by types."""
-    # Test single type
-    result = await recent_activity(type=["entity"])
-    assert result is not None
-    assert all(isinstance(r, EntitySummary) for r in result.primary_results)
-
-    # Test multiple types
-    result = await recent_activity(type=["entity", "observation"])
-    assert result is not None
-    assert all(
-        isinstance(r, EntitySummary) or isinstance(r, ObservationSummary)
-        for r in result.primary_results
-    )
-
-    # Test all types
-    result = await recent_activity(type=["entity", "observation", "relation"])
-    assert result is not None
-    # Results can be any type
-    assert all(
-        isinstance(r, EntitySummary)
-        or isinstance(r, ObservationSummary)
-        or isinstance(r, RelationSummary)
-        for r in result.primary_results
-    )
-
-
 @pytest.mark.asyncio
 async def test_build_context_timeframe_formats(client, test_graph):
     """Test that build_context accepts various timeframe formats."""

{basic_memory-0.12.2 → basic_memory-0.12.3}/tests/mcp/test_tool_read_note.py

@@ -267,7 +267,7 @@ async def test_read_note_text_search_fallback(mock_call_get, mock_search):
     assert "Related Note 1" in result
     assert "Related Note 2" in result
     assert 'read_note("notes/related-note-1")' in result
-    assert "search(query=" in result
+    assert "search_notes(query=" in result
     assert "write_note(" in result
 
 

basic_memory-0.12.3/tests/mcp/test_tool_recent_activity.py

@@ -0,0 +1,110 @@
+"""Tests for discussion context MCP tool."""
+
+import pytest
+
+from mcp.server.fastmcp.exceptions import ToolError
+
+from basic_memory.mcp.tools import recent_activity
+from basic_memory.schemas.memory import (
+    EntitySummary,
+    ObservationSummary,
+    RelationSummary,
+)
+from basic_memory.schemas.search import SearchItemType
+
+# Test data for different timeframe formats
+valid_timeframes = [
+    "7d",  # Standard format
+    "yesterday",  # Natural language
+    "0d",  # Zero duration
+]
+
+invalid_timeframes = [
+    "invalid",  # Nonsense string
+    "tomorrow",  # Future date
+]
+
+
+@pytest.mark.asyncio
+async def test_recent_activity_timeframe_formats(client, test_graph):
+    """Test that recent_activity accepts various timeframe formats."""
+    # Test each valid timeframe
+    for timeframe in valid_timeframes:
+        try:
+            result = await recent_activity(
+                type=["entity"], timeframe=timeframe, page=1, page_size=10, max_related=10
+            )
+            assert result is not None
+        except Exception as e:
+            pytest.fail(f"Failed with valid timeframe '{timeframe}': {str(e)}")
+
+    # Test invalid timeframes should raise ValidationError
+    for timeframe in invalid_timeframes:
+        with pytest.raises(ToolError):
+            await recent_activity(timeframe=timeframe)
+
+
+@pytest.mark.asyncio
+async def test_recent_activity_type_filters(client, test_graph):
+    """Test that recent_activity correctly filters by types."""
+
+    # Test single string type
+    result = await recent_activity(type=SearchItemType.ENTITY)
+    assert result is not None
+    assert all(isinstance(r, EntitySummary) for r in result.primary_results)
+
+    # Test single string type
+    result = await recent_activity(type="entity")
+    assert result is not None
+    assert all(isinstance(r, EntitySummary) for r in result.primary_results)
+
+    # Test single type
+    result = await recent_activity(type=["entity"])
+    assert result is not None
+    assert all(isinstance(r, EntitySummary) for r in result.primary_results)
+
+    # Test multiple types
+    result = await recent_activity(type=["entity", "observation"])
+    assert result is not None
+    assert all(
+        isinstance(r, EntitySummary) or isinstance(r, ObservationSummary)
+        for r in result.primary_results
+    )
+
+    # Test multiple types
+    result = await recent_activity(type=[SearchItemType.ENTITY, SearchItemType.OBSERVATION])
+    assert result is not None
+    assert all(
+        isinstance(r, EntitySummary) or isinstance(r, ObservationSummary)
+        for r in result.primary_results
+    )
+
+    # Test all types
+    result = await recent_activity(type=["entity", "observation", "relation"])
+    assert result is not None
+    # Results can be any type
+    assert all(
+        isinstance(r, EntitySummary)
+        or isinstance(r, ObservationSummary)
+        or isinstance(r, RelationSummary)
+        for r in result.primary_results
+    )
+
+
+@pytest.mark.asyncio
+async def test_recent_activity_type_invalid(client, test_graph):
+    """Test that recent_activity correctly filters by types."""
+
+    # Test single invalid string type
+    with pytest.raises(ValueError) as e:
+        await recent_activity(type="note")
+    assert (
+        str(e.value) == "Invalid type: note. Valid types are: ['entity', 'observation', 'relation']"
+    )
+
+    # Test invalid string array type
+    with pytest.raises(ValueError) as e:
+        await recent_activity(type=["note"])
+    assert (
+        str(e.value) == "Invalid type: note. Valid types are: ['entity', 'observation', 'relation']"
+    )

basic_memory-0.12.3/tests/utils/test_permalink_formatting.py

@@ -0,0 +1,120 @@
+"""Test permalink formatting during sync."""
+
+from pathlib import Path
+
+import pytest
+
+from basic_memory.config import ProjectConfig
+from basic_memory.services import EntityService
+from basic_memory.sync.sync_service import SyncService
+from basic_memory.utils import generate_permalink
+
+
+async def create_test_file(path: Path, content: str = "test content") -> None:
+    """Create a test file with given content."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content)
+
+
+@pytest.mark.asyncio
+async def test_permalink_formatting(
+    sync_service: SyncService, test_config: ProjectConfig, entity_service: EntityService
+):
+    """Test that permalinks are properly formatted during sync.
+
+    This ensures:
+    - Underscores are converted to hyphens
+    - Spaces are converted to hyphens
+    - Mixed case is lowercased
+    - Directory structure is preserved
+    - Multiple directories work correctly
+    """
+    project_dir = test_config.home
+
+    # Test cases with different filename formats
+    test_cases = [
+        # filename -> expected permalink
+        ("my_awesome_feature.md", "my-awesome-feature"),
+        ("MIXED_CASE_NAME.md", "mixed-case-name"),
+        ("spaces and_underscores.md", "spaces-and-underscores"),
+        ("design/model_refactor.md", "design/model-refactor"),
+        (
+            "test/multiple_word_directory/feature_name.md",
+            "test/multiple-word-directory/feature-name",
+        ),
+    ]
+
+    # Create test files
+    for filename, _ in test_cases:
+        content = """
+---
+type: knowledge
+created: 2024-01-01
+modified: 2024-01-01
+---
+# Test File
+
+Testing permalink generation.
+"""
+        await create_test_file(project_dir / filename, content)
+
+    # Run sync
+    await sync_service.sync(test_config.home)
+
+    # Verify permalinks
+    for filename, expected_permalink in test_cases:
+        entity = await entity_service.repository.get_by_file_path(filename)
+        assert entity.permalink == expected_permalink, (
+            f"File {filename} should have permalink {expected_permalink}"
+        )
+
+
+@pytest.mark.parametrize(
+    "input_path, expected",
+    [
+        ("test/Über File.md", "test/uber-file"),
+        ("docs/résumé.md", "docs/resume"),
+        ("notes/Déjà vu.md", "notes/deja-vu"),
+        ("papers/Jürgen's Findings.md", "papers/jurgens-findings"),
+        ("archive/François Müller.md", "archive/francois-muller"),
+        ("research/Søren Kierkegård.md", "research/soren-kierkegard"),
+        ("articles/El Niño.md", "articles/el-nino"),
+    ],
+)
+def test_latin_accents_transliteration(input_path, expected):
+    """Test that Latin letters with accents are properly transliterated."""
+    assert generate_permalink(input_path) == expected
+
+
+@pytest.mark.parametrize(
+    "input_path, expected",
+    [
+        ("中文/测试文档.md", "中文/测试文档"),
+        ("notes/北京市.md", "notes/北京市"),
+        ("research/上海简介.md", "research/上海简介"),
+        ("docs/中文 English Mixed.md", "docs/中文-english-mixed"),
+        ("articles/东京Tokyo混合.md", "articles/东京-tokyo-混合"),
+        ("papers/汉字_underscore_test.md", "papers/汉字-underscore-test"),
+        ("projects/中文CamelCase测试.md", "projects/中文-camel-case-测试"),
+    ],
+)
+def test_chinese_character_preservation(input_path, expected):
+    """Test that Chinese characters are preserved in permalinks."""
+    assert generate_permalink(input_path) == expected
+
+
+@pytest.mark.parametrize(
+    "input_path, expected",
+    [
+        ("mixed/北京Café.md", "mixed/北京-cafe"),
+        ("notes/东京Tōkyō.md", "notes/东京-tokyo"),
+        ("research/München中文.md", "research/munchen-中文"),
+        ("docs/Über测试.md", "docs/uber-测试"),
+        ("complex/北京Beijing上海Shanghai.md", "complex/北京-beijing-上海-shanghai"),
+        ("special/中文!@#$%^&*()_+.md", "special/中文"),
+        ("punctuation/你好，世界!.md", "punctuation/你好世界"),
+    ],
+)
+def test_mixed_character_sets(input_path, expected):
+    """Test handling of mixed character sets and edge cases."""
+    assert generate_permalink(input_path) == expected

{basic_memory-0.12.2 → basic_memory-0.12.3}/uv.lock

@@ -71,7 +71,7 @@ wheels = [
 
 [[package]]
 name = "basic-memory"
-version = "0.12.1"
+version = "0.12.2"
 source = { editable = "." }
 dependencies = [
     { name = "aiosqlite" },