basic-memory 0.12.2__py3-none-any.whl → 0.13.0__py3-none-any.whl

basic_memory/sync/watch_service.py

@@ -1,21 +1,21 @@
 """Watch service for Basic Memory."""
 
+import asyncio
 import os
+from collections import defaultdict
 from datetime import datetime
 from pathlib import Path
 from typing import List, Optional, Set
 
-from basic_memory.config import ProjectConfig
-from basic_memory.services.file_service import FileService
-from basic_memory.sync.sync_service import SyncService
+from basic_memory.config import BasicMemoryConfig, WATCH_STATUS_JSON
+from basic_memory.models import Project
+from basic_memory.repository import ProjectRepository
 from loguru import logger
 from pydantic import BaseModel
 from rich.console import Console
 from watchfiles import awatch
 from watchfiles.main import FileChange, Change
 
-WATCH_STATUS_JSON = "watch-status.json"
-
 
 class WatchEvent(BaseModel):
     timestamp: datetime
@@ -72,16 +72,14 @@ class WatchServiceState(BaseModel):
 class WatchService:
     def __init__(
         self,
-        sync_service: SyncService,
-        file_service: FileService,
-        config: ProjectConfig,
+        app_config: BasicMemoryConfig,
+        project_repository: ProjectRepository,
         quiet: bool = False,
     ):
-        self.sync_service = sync_service
-        self.file_service = file_service
-        self.config = config
+        self.app_config = app_config
+        self.project_repository = project_repository
         self.state = WatchServiceState()
-        self.status_path = config.home / ".basic-memory" / WATCH_STATUS_JSON
+        self.status_path = Path.home() / ".basic-memory" / WATCH_STATUS_JSON
         self.status_path.parent.mkdir(parents=True, exist_ok=True)
 
         # quiet mode for mcp so it doesn't mess up stdout
@@ -89,10 +87,14 @@ class WatchService:
 
     async def run(self):  # pragma: no cover
         """Watch for file changes and sync them"""
+
+        projects = await self.project_repository.get_active_projects()
+        project_paths = [project.path for project in projects]
+
         logger.info(
             "Watch service started",
-            f"directory={str(self.config.home)}",
-            f"debounce_ms={self.config.sync_delay}",
+            f"directories={project_paths}",
+            f"debounce_ms={self.app_config.sync_delay}",
             f"pid={os.getpid()}",
         )
 
@@ -102,15 +104,30 @@ class WatchService:
 
         try:
             async for changes in awatch(
-                self.config.home,
-                debounce=self.config.sync_delay,
+                *project_paths,
+                debounce=self.app_config.sync_delay,
                 watch_filter=self.filter_changes,
                 recursive=True,
             ):
-                await self.handle_changes(self.config.home, changes)
+                # group changes by project
+                project_changes = defaultdict(list)
+                for change, path in changes:
+                    for project in projects:
+                        if self.is_project_path(project, path):
+                            project_changes[project].append((change, path))
+                            break
+
+                # create coroutines to handle changes
+                change_handlers = [
+                    self.handle_changes(project, changes)  # pyright: ignore
+                    for project, changes in project_changes.items()
+                ]
+
+                # process changes
+                await asyncio.gather(*change_handlers)
 
         except Exception as e:
-            logger.exception("Watch service error", error=str(e), directory=str(self.config.home))
+            logger.exception("Watch service error", error=str(e))
 
             self.state.record_error(str(e))
             await self.write_status()
@@ -119,7 +136,6 @@ class WatchService:
         finally:
             logger.info(
                 "Watch service stopped",
-                f"directory={str(self.config.home)}",
                 f"runtime_seconds={int((datetime.now() - self.state.start_time).total_seconds())}",
             )
 
@@ -132,15 +148,9 @@ class WatchService:
         Returns:
             True if the file should be watched, False if it should be ignored
         """
-        # Skip if path is invalid
-        try:
-            relative_path = Path(path).relative_to(self.config.home)
-        except ValueError:
-            # This is a defensive check for paths outside our home directory
-            return False
 
         # Skip hidden directories and files
-        path_parts = relative_path.parts
+        path_parts = Path(path).parts
         for part in path_parts:
             if part.startswith("."):
                 return False
@@ -155,14 +165,30 @@ class WatchService:
         """Write current state to status file"""
         self.status_path.write_text(WatchServiceState.model_dump_json(self.state, indent=2))
 
-    async def handle_changes(self, directory: Path, changes: Set[FileChange]):
+    def is_project_path(self, project: Project, path):
+        """
+        Checks if path is a subdirectory or file within a project
+        """
+        project_path = Path(project.path).resolve()
+        sub_path = Path(path).resolve()
+        return project_path in sub_path.parents
+
+    async def handle_changes(self, project: Project, changes: Set[FileChange]) -> None:
         """Process a batch of file changes"""
         import time
         from typing import List, Set
 
-        start_time = time.time()
+        # Lazily initialize sync service for project changes
+        from basic_memory.cli.commands.sync import get_sync_service
+
+        sync_service = await get_sync_service(project)
+        file_service = sync_service.file_service
 
-        logger.info(f"Processing file changes, change_count={len(changes)}, directory={directory}")
+        start_time = time.time()
+        directory = Path(project.path).resolve()
+        logger.info(
+            f"Processing project: {project.name} changes, change_count={len(changes)}, directory={directory}"
+        )
 
         # Group changes by type
         adds: List[str] = []
@@ -190,7 +216,7 @@ class WatchService:
 
         # because of our atomic writes on updates, an add may be an existing file
         for added_path in adds:  # pragma: no cover TODO add test
-            entity = await self.sync_service.entity_repository.get_by_file_path(added_path)
+            entity = await sync_service.entity_repository.get_by_file_path(added_path)
             if entity is not None:
                 logger.debug(f"Existing file will be processed as modified, path={added_path}")
                 adds.remove(added_path)
@@ -218,9 +244,7 @@ class WatchService:
                     continue  # pragma: no cover
 
                 # Skip directories for deleted paths (based on entity type in db)
-                deleted_entity = await self.sync_service.entity_repository.get_by_file_path(
-                    deleted_path
-                )
+                deleted_entity = await sync_service.entity_repository.get_by_file_path(deleted_path)
                 if deleted_entity is None:
                     # If this was a directory, it wouldn't have an entity
                     logger.debug("Skipping unknown path for move detection", path=deleted_path)
@@ -229,10 +253,10 @@ class WatchService:
                 if added_path != deleted_path:
                     # Compare checksums to detect moves
                     try:
-                        added_checksum = await self.file_service.compute_checksum(added_path)
+                        added_checksum = await file_service.compute_checksum(added_path)
 
                         if deleted_entity and deleted_entity.checksum == added_checksum:
-                            await self.sync_service.handle_move(deleted_path, added_path)
+                            await sync_service.handle_move(deleted_path, added_path)
                             self.state.add_event(
                                 path=f"{deleted_path} -> {added_path}",
                                 action="moved",
@@ -261,7 +285,7 @@ class WatchService:
         for path in deletes:
             if path not in processed:
                 logger.debug("Processing deleted file", path=path)
-                await self.sync_service.handle_delete(path)
+                await sync_service.handle_delete(path)
                 self.state.add_event(path=path, action="deleted", status="success")
                 self.console.print(f"[red]✕[/red] {path}")
                 logger.info(f"deleted: {path}")
@@ -281,7 +305,7 @@ class WatchService:
                     continue  # pragma: no cover
 
                 logger.debug(f"Processing new file, path={path}")
-                entity, checksum = await self.sync_service.sync_file(path, new=True)
+                entity, checksum = await sync_service.sync_file(path, new=True)
                 if checksum:
                     self.state.add_event(
                         path=path, action="new", status="success", checksum=checksum
@@ -314,7 +338,7 @@ class WatchService:
                     continue
 
                 logger.debug(f"Processing modified file: path={path}")
-                entity, checksum = await self.sync_service.sync_file(path, new=False)
+                entity, checksum = await sync_service.sync_file(path, new=False)
                 self.state.add_event(
                     path=path, action="modified", status="success", checksum=checksum
                 )
@@ -335,7 +359,7 @@ class WatchService:
                     repeat_count = 0
                     modify_count += 1
 
-                logger.debug(
+                logger.debug(  # pragma: no cover
                     "Modified file processed, "
                     f"path={path} "
                     f"entity_id={entity.id if entity else None} "

basic_memory/templates/prompts/continue_conversation.hbs

@@ -0,0 +1,110 @@
+# Continuing conversation on: {{ topic }}
+
+This is a memory retrieval session. 
+
+Please use the available basic-memory tools to gather relevant context before responding. Start by executing one of the suggested commands below to retrieve content.
+
+> **Knowledge Capture Recommendation:** As you continue this conversation, actively look for opportunities to record new information, decisions, or insights that emerge. Use `write_note()` to document important context.
+
+Here's what I found from previous conversations:
+
+{{#if has_results}}
+{{#each hierarchical_results}}
+<memory>
+--- memory://{{ primary_result.permalink }}
+
+## {{ primary_result.title }}
+- **Type**: {{ primary_result.type }}
+- **Created**: {{date primary_result.created_at "%Y-%m-%d %H:%M"}}
+
+{{#if primary_result.content}}
+**Excerpt**:
+<excerpt>
+{{ primary_result.content }}
+</excerpt>
+{{/if}}
+
+{{#if observations}}
+## Observations
+{{#each observations}}
+<observation>
+- [{{ category }}] {{ content }}
+</observation>
+{{/each}}
+{{/if}}
+
+You can read this document with: `read_note("{{ primary_result.permalink }}")`
+
+{{#if related_results}}
+## Related Context
+
+{{#each related_results}}
+<related>
+- type: **{{ type }}**
+- title: {{ title }}
+
+{{#if permalink}}
+You can view this document with: `read_note("{{ permalink }}")`
+{{else}}
+You can view this file with: `read_file("{{ file_path }}")`
+{{/if}}
+</related>
+{{/each}}
+{{/if}}
+
+</memory>
+{{/each}}
+{{else}}
+The supplied query did not return any information specifically on this topic.
+
+## Opportunity to Capture New Knowledge!
+
+This is an excellent chance to start documenting this topic:
+
+```python
+await write_note(
+    title="{{ topic }}",
+    content=f'''
+# {{ topic }}
+
+## Overview
+[Summary of what we know about {{ topic }}]
+
+## Key Points
+[Main aspects or components of {{ topic }}]
+
+## Observations
+- [category] [First important observation about {{ topic }}]
+- [category] [Second observation about {{ topic }}]
+
+## Relations
+- relates_to [[Related Topic]]
+- part_of [[Broader Context]]
+'''
+)
+```
+
+## Other Options
+
+Please use the available basic-memory tools to gather relevant context before responding.
+You can also:
+- Try a different search term
+- Check recent activity with `recent_activity(timeframe="1w")`
+{{/if}}
+## Next Steps
+<instructions>
+You can:
+- Explore more with: `search_notes("{{ topic }}")`
+- See what's changed: `recent_activity(timeframe="{{default timeframe "7d"}}")`
+- **Record new learnings or decisions from this conversation:** `write_note(folder="[Chose a folder]" title="[Create a meaningful title]", content="[Content with observations and relations]")`
+
+## Knowledge Capture Recommendation
+
+As you continue this conversation, **actively look for opportunities to:**
+1. Record key information, decisions, or insights that emerge
+2. Link new knowledge to existing topics 
+3. Suggest capturing important context when appropriate
+4. Create forward references to topics that might be created later
+
+Remember that capturing knowledge during conversations is one of the most valuable aspects of Basic Memory.
+</instructions>

basic_memory/templates/prompts/search.hbs

@@ -0,0 +1,101 @@
+# Search Results for: "{{ query }}"{{#if timeframe}} (after {{ timeframe }}){{/if}}
+
+This is a memory search session.
+Please use the available basic-memory tools to gather relevant context before responding.
+I found {{ result_count }} result(s) that match your query.
+
+{{#if has_results}}
+Here are the most relevant results:
+
+    {{#each results}}
+        {{#if_cond (lt @index 5)}}
+        {{#dedent}}
+            ## {{math @index "+" 1}}. {{ title }}
+            - **Type**: {{ type.value }}
+            {{#if metadata.created_at}}
+            - **Created**: {{date metadata.created_at "%Y-%m-%d %H:%M"}}
+            {{/if}}
+            - **Relevance Score**: {{round score 2}}
+
+            {{#if content}}
+            - **Excerpt**:
+            {{ content }}
+            {{/if}}
+
+            {{#if permalink}}
+            You can view this content with: `read_note("{{ permalink }}")`
+            Or explore its context with: `build_context("memory://{{ permalink }}")`
+            {{else}}
+            You can view this file with: `read_file("{{ file_path }}")`
+            {{/if}}
+        {{/dedent}}
+        {{/if_cond}}
+    {{/each}}
+
+## Next Steps
+
+You can:
+- Refine your search: `search_notes("{{ query }} AND additional_term")`
+- Exclude terms: `search_notes("{{ query }} NOT exclude_term")`
+- View more results: `search_notes("{{ query }}", after_date=None)`
+- Check recent activity: `recent_activity()`
+
+## Synthesize and Capture Knowledge
+
+Consider creating a new note that synthesizes what you've learned:
+
+```python
+await write_note(
+    title="Synthesis of {{capitalize query}} Information",
+    content='''
+    # Synthesis of {{capitalize query}} Information
+    
+    ## Overview
+    [Synthesis of the search results and your conversation]
+    
+    ## Key Insights
+    [Summary of main points learned from these results]
+    
+    ## Observations
+    - [insight] [Important observation from search results]
+    - [connection] [How this connects to other topics]
+    
+    ## Relations
+    - relates_to [[{{#if results.length}}{{#if results.0.title}}{{results.0.title}}{{else}}Related Topic{{/if}}{{else}}Related Topic{{/if}}]]
+    - extends [[Another Relevant Topic]]
+    '''
+)
+```
+
+Remember that capturing synthesized knowledge is one of the most valuable features of Basic Memory.
+{{else}}
+    I couldn't find any results for this query.
+
+    ## Opportunity to Capture Knowledge!
+
+    This is an excellent opportunity to create new knowledge on this topic. Consider:
+
+    ```python
+    await write_note(
+        title="{{capitalize query}}",
+        content='''
+        # {{capitalize query}}
+
+        ## Overview
+        [Summary of what we've discussed about {{ query }}]
+
+        ## Observations
+        - [category] [First observation about {{ query }}]
+        - [category] [Second observation about {{ query }}]
+
+        ## Relations
+        - relates_to [[Other Relevant Topic]]
+        '''
+    )
+    ```
+
+    ## Other Suggestions
+    - Try a different search term
+    - Broaden your search criteria
+    - Check recent activity with `recent_activity(timeframe="1w")`
+{{/if}}

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.dist-info → basic_memory-0.13.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: basic-memory
-Version: 0.12.2
+Version: 0.13.0
 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
@@ -13,18 +13,22 @@ Requires-Dist: aiosqlite>=0.20.0
 Requires-Dist: alembic>=1.14.1
 Requires-Dist: dateparser>=1.2.0
 Requires-Dist: fastapi[standard]>=0.115.8
+Requires-Dist: fastmcp>=2.3.4
 Requires-Dist: greenlet>=3.1.1
 Requires-Dist: icecream>=2.1.3
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: markdown-it-py>=3.0.0
 Requires-Dist: mcp>=1.2.0
 Requires-Dist: pillow>=11.1.0
+Requires-Dist: pybars3>=0.9.7
 Requires-Dist: pydantic-settings>=2.6.1
 Requires-Dist: pydantic[email,timezone]>=2.10.3
+Requires-Dist: pyjwt>=2.10.1
 Requires-Dist: pyright>=1.1.390
+Requires-Dist: pytest-aio>=1.9.0
+Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: python-frontmatter>=1.1.0
 Requires-Dist: pyyaml>=6.0.1
-Requires-Dist: qasync>=0.27.1
 Requires-Dist: rich>=13.9.4
 Requires-Dist: sqlalchemy>=2.0.0
 Requires-Dist: typer>=0.9.0
@@ -367,9 +371,9 @@ config:
       "command": "uvx",
       "args": [
         "basic-memory",
-        "mcp",
         "--project",
-        "your-project-name"
+        "your-project-name",
+        "mcp"
       ]
     }
   }
@@ -410,6 +414,24 @@ See the [Documentation](https://memory.basicmachines.co/) for more info, includi
 - [Managing multiple Projects](https://memory.basicmachines.co/docs/cli-reference#project)
 - [Importing data from OpenAI/Claude Projects](https://memory.basicmachines.co/docs/cli-reference#import)
 
+## Installation Options
+
+### Stable Release
+```bash
+pip install basic-memory
+```
+
+### Beta/Pre-releases
+```bash
+pip install basic-memory --pre
+```
+
+### Development Builds
+Development versions are automatically published on every commit to main with versions like `0.12.4.dev26+468a22f`:
+```bash
+pip install basic-memory --pre --force-reinstall
+```
+
 ## License
 
 AGPL-3.0