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

basic_memory/services/service.py

@@ -1,36 +1,15 @@
 """Base service class."""
 
-from datetime import datetime
-from typing import TypeVar, Generic, List, Sequence
+from typing import TypeVar, Generic
 
 from basic_memory.models import Base
-from basic_memory.repository.repository import Repository
 
 T = TypeVar("T", bound=Base)
-R = TypeVar("R", bound=Repository)
+
 
 class BaseService(Generic[T]):
     """Base service that takes a repository."""
 
-    def __init__(self, repository: R):
+    def __init__(self, repository):
         """Initialize service with repository."""
         self.repository = repository
-
-    async def add(self, model: T) -> T:
-        """Add model to repository."""
-        return await self.repository.add(model)
-
-    async def add_all(self, models: List[T]) -> Sequence[T]:
-        """Add a List of models to repository."""
-        return await self.repository.add_all(models)
-
-    async def get_modified_since(self, since: datetime) -> Sequence[T]:
-        """Get all items modified since the given timestamp.
-        
-        Args:
-            since: Datetime to search from
-            
-        Returns:
-            Sequence of items modified since the timestamp
-        """
-        return await self.repository.find_modified_since(since)

basic_memory/sync/__init__.py

@@ -1,5 +1,5 @@
 from .file_change_scanner import FileChangeScanner
 from .sync_service import SyncService
+from .watch_service import WatchService
 
-__all__ = ["SyncService", "FileChangeScanner"]
-
+__all__ = ["SyncService", "FileChangeScanner", "WatchService"]

basic_memory/sync/file_change_scanner.py

@@ -69,11 +69,7 @@ class FileChangeScanner:
                 rel_path = str(path.relative_to(directory))
                 content = path.read_text()
                 checksum = await compute_checksum(content)
-
-                if checksum:  # Only store valid checksums
-                    result.files[rel_path] = checksum
-                else:
-                    result.errors[rel_path] = "Failed to compute checksum"
+                result.files[rel_path] = checksum
 
             except Exception as e:
                 rel_path = str(path.relative_to(directory))
@@ -134,7 +130,7 @@ class FileChangeScanner:
         logger.debug(f"  Moved: {len(report.moves)}")
         logger.debug(f"  Deleted: {len(report.deleted)}")
 
-        if scan_result.errors:
+        if scan_result.errors:  # pragma: no cover
             logger.warning("Files skipped due to errors:")
             for file_path, error in scan_result.errors.items():
                 logger.warning(f"  {file_path}: {error}")
@@ -151,7 +147,7 @@ class FileChangeScanner:
         """
         return {
             r.file_path: FileState(
-                file_path=r.file_path, permalink=r.permalink, checksum=r.checksum
+                file_path=r.file_path, permalink=r.permalink, checksum=r.checksum or ""
             )
             for r in db_records
         }

basic_memory/sync/sync_service.py

@@ -59,9 +59,6 @@ class SyncService:
             for permalink in permalinks:
                 await self.search_service.delete_by_permalink(permalink)
 
-        else:
-            logger.debug(f"No entity found to delete: {file_path}")
-
     async def sync(self, directory: Path) -> SyncReport:
         """Sync knowledge files with database."""
         changes = await self.scanner.find_knowledge_changes(directory)
@@ -77,69 +74,63 @@ class SyncService:
                     entity.id, {"file_path": new_path, "checksum": changes.checksums[new_path]}
                 )
                 # update search index
-                await self.search_service.index_entity(updated)
+                if updated:
+                    await self.search_service.index_entity(updated)
 
         # Handle deletions next
         # remove rows from db for files no longer present
-        for file_path in changes.deleted:
-            await self.handle_entity_deletion(file_path)
+        for path in changes.deleted:
+            await self.handle_entity_deletion(path)
 
         # Parse files that need updating
         parsed_entities: Dict[str, EntityMarkdown] = {}
 
-        for file_path in [*changes.new, *changes.modified]:
-            entity_markdown = await self.entity_parser.parse_file(directory / file_path)
-            parsed_entities[file_path] = entity_markdown
+        for path in [*changes.new, *changes.modified]:
+            entity_markdown = await self.entity_parser.parse_file(directory / path)
+            parsed_entities[path] = entity_markdown
 
         # First pass: Create/update entities
         # entities will have a null checksum to indicate they are not complete
-        for file_path, entity_markdown in parsed_entities.items():
-
+        for path, entity_markdown in parsed_entities.items():
             # Get unique permalink and update markdown if needed
             permalink = await self.entity_service.resolve_permalink(
-                file_path,
-                markdown=entity_markdown
+                Path(path), markdown=entity_markdown
             )
 
             if permalink != entity_markdown.frontmatter.permalink:
                 # Add/update permalink in frontmatter
-                logger.info(f"Adding permalink '{permalink}' to file: {file_path}")
+                logger.info(f"Adding permalink '{permalink}' to file: {path}")
 
                 # update markdown
                 entity_markdown.frontmatter.metadata["permalink"] = permalink
-                
+
                 # update file frontmatter
                 updated_checksum = await file_utils.update_frontmatter(
-                    directory / file_path,
-                    {"permalink": permalink}
+                    directory / path, {"permalink": permalink}
                 )
 
                 # Update checksum in changes report since file was modified
-                changes.checksums[file_path] = updated_checksum
-            
+                changes.checksums[path] = updated_checksum
+
             # if the file is new, create an entity
-            if file_path in changes.new:
+            if path in changes.new:
                 # Create entity with final permalink
-                logger.debug(f"Creating new entity_markdown: {file_path}")
-                await self.entity_service.create_entity_from_markdown(
-                    file_path, entity_markdown
-                )
+                logger.debug(f"Creating new entity_markdown: {path}")
+                await self.entity_service.create_entity_from_markdown(Path(path), entity_markdown)
             # otherwise we need to update the entity and observations
             else:
-                logger.debug(f"Updating entity_markdown: {file_path}")
+                logger.debug(f"Updating entity_markdown: {path}")
                 await self.entity_service.update_entity_and_observations(
-                    file_path, entity_markdown
+                    Path(path), entity_markdown
                 )
 
         # Second pass
-        for file_path, entity_markdown in parsed_entities.items():
-            logger.debug(f"Updating relations for: {file_path}")
+        for path, entity_markdown in parsed_entities.items():
+            logger.debug(f"Updating relations for: {path}")
 
             # Process relations
-            checksum = changes.checksums[file_path]
-            entity = await self.entity_service.update_entity_relations(
-                file_path, entity_markdown
-            )
+            checksum = changes.checksums[path]
+            entity = await self.entity_service.update_entity_relations(Path(path), entity_markdown)
 
             # add to search index
             await self.search_service.index_entity(entity)
@@ -153,18 +144,22 @@ class SyncService:
             target_entity = await self.entity_service.link_resolver.resolve_link(relation.to_name)
             # check we found a link that is not the source
             if target_entity and target_entity.id != relation.from_id:
-                logger.debug(f"Resolved forward reference: {relation.to_name} -> {target_entity.permalink}")
+                logger.debug(
+                    f"Resolved forward reference: {relation.to_name} -> {target_entity.permalink}"
+                )
 
                 try:
-                    await self.relation_repository.update(relation.id, {
-                        "to_id": target_entity.id,
-                        "to_name": target_entity.title  # Update to actual title
-                    })
-                except IntegrityError as e:
-                        logger.info(f"Ignoring duplicate relation {relation}")
+                    await self.relation_repository.update(
+                        relation.id,
+                        {
+                            "to_id": target_entity.id,
+                            "to_name": target_entity.title,  # Update to actual title
+                        },
+                    )
+                except IntegrityError:
+                    logger.debug(f"Ignoring duplicate relation {relation}")
 
                 # update search index
                 await self.search_service.index_entity(target_entity)
 
-
         return changes

basic_memory/sync/utils.py

@@ -2,44 +2,15 @@
 
 from dataclasses import dataclass, field
 from typing import Set, Dict, Optional
-from watchfiles import Change
-from basic_memory.services.file_service import FileService
-
 
-@dataclass
-class FileChange:
-    """A change to a file detected by the watch service.
-    
-    Attributes:
-        change_type: Type of change (added, modified, deleted)
-        path: Path to the file
-        checksum: File checksum (None for deleted files)
-    """
-    change_type: Change
-    path: str
-    checksum: Optional[str] = None
+from watchfiles import Change
 
-    @classmethod
-    async def from_path(cls, path: str, change_type: Change, file_service: FileService) -> "FileChange":
-        """Create FileChange from a path, computing checksum if file exists.
-        
-        Args:
-            path: Path to the file
-            change_type: Type of change detected
-            file_service: Service to read file and compute checksum
-            
-        Returns:
-            FileChange with computed checksum for non-deleted files
-        """
-        file_path = file_service.path(path)
-        content, checksum = await file_service.read_file(file_path) if change_type != Change.deleted else (None, None)
-        return cls(path=file_path, change_type=change_type, checksum=checksum)
 
 
 @dataclass
 class SyncReport:
     """Report of file changes found compared to database state.
-    
+
     Attributes:
         total: Total number of files in directory being synced
         new: Files that exist on disk but not in database
@@ -48,19 +19,16 @@ class SyncReport:
         moves: Files that have been moved from one location to another
         checksums: Current checksums for files on disk
     """
+
     total: int = 0
+    # We keep paths as strings in sets/dicts for easier serialization
     new: Set[str] = field(default_factory=set)
     modified: Set[str] = field(default_factory=set)
     deleted: Set[str] = field(default_factory=set)
-    moves: Dict[str, str] = field(default_factory=dict)  # old_path -> new_path  
-    checksums: Dict[str, str] = field(default_factory=dict) # path -> checksum
+    moves: Dict[str, str] = field(default_factory=dict)  # old_path -> new_path
+    checksums: Dict[str, str] = field(default_factory=dict)  # path -> checksum
 
     @property
     def total_changes(self) -> int:
         """Total number of changes."""
         return len(self.new) + len(self.modified) + len(self.deleted) + len(self.moves)
-
-    @property
-    def syned_files(self) -> int:
-        """Total number of files synced."""
-        return len(self.new) + len(self.modified) + len(self.moves)

basic_memory/sync/watch_service.py

@@ -8,7 +8,6 @@ from datetime import datetime
 from pathlib import Path
 from typing import List, Optional
 
-from rich import box
 from rich.console import Console
 from rich.live import Live
 from rich.table import Table
@@ -84,7 +83,7 @@ class WatchService:
 
     def generate_table(self) -> Table:
         """Generate status display table"""
-        table = Table(title="Basic Memory Sync Status")
+        table = Table()
 
         # Add status row
         table.add_column("Status", style="cyan")
@@ -131,13 +130,36 @@ class WatchService:
 
         return table
 
-    async def run(self):
+    async def run(self, console_status: bool = False):  # pragma: no cover
         """Watch for file changes and sync them"""
+        logger.info("Watching for sync changes")
         self.state.running = True
         self.state.start_time = datetime.now()
         await self.write_status()
 
-        with Live(self.generate_table(), refresh_per_second=4, console=self.console) as live:
+        if console_status:
+            with Live(self.generate_table(), refresh_per_second=4, console=self.console) as live:
+                try:
+                    async for changes in awatch(
+                        self.config.home,
+                        watch_filter=self.filter_changes,
+                        debounce=self.config.sync_delay,
+                        recursive=True,
+                    ):
+                        # Process changes
+                        await self.handle_changes(self.config.home)
+                        # Update display
+                        live.update(self.generate_table())
+
+                except Exception as e:
+                    self.state.record_error(str(e))
+                    await self.write_status()
+                    raise
+                finally:
+                    self.state.running = False
+                    await self.write_status()
+
+        else:
             try:
                 async for changes in awatch(
                     self.config.home,
@@ -148,7 +170,6 @@ class WatchService:
                     # Process changes
                     await self.handle_changes(self.config.home)
                     # Update display
-                    live.update(self.generate_table())
 
             except Exception as e:
                 self.state.record_error(str(e))

basic_memory/utils.py

@@ -1,38 +1,18 @@
 """Utility functions for basic-memory."""
+
 import os
 import re
-import unicodedata
+import sys
 from pathlib import Path
+from typing import Optional, Union
 
+from loguru import logger
 from unidecode import unidecode
 
-
-def sanitize_name(name: str) -> str:
-    """
-    Sanitize a name for filesystem use:
-    - Convert to lowercase
-    - Replace spaces/punctuation with underscores
-    - Remove emojis and other special characters
-    - Collapse multiple underscores
-    - Trim leading/trailing underscores
-    """
-    # Normalize unicode to compose characters where possible
-    name = unicodedata.normalize("NFKD", name)
-    # Remove emojis and other special characters, keep only letters, numbers, spaces
-    name = "".join(c for c in name if c.isalnum() or c.isspace())
-    # Replace spaces with underscores
-    name = name.replace(" ", "_")
-    # Remove newline
-    name = name.replace("\n", "")
-    # Convert to lowercase
-    name = name.lower()
-    # Collapse multiple underscores and trim
-    name = re.sub(r"_+", "_", name).strip("_")
-
-    return name
+from basic_memory.config import config
 
 
-def generate_permalink(file_path: Path | str) -> str:
+def generate_permalink(file_path: Union[Path, str]) -> str:
     """Generate a stable permalink from a file path.
 
     Args:
@@ -50,8 +30,11 @@ def generate_permalink(file_path: Path | str) -> str:
         >>> generate_permalink("design/unified_model_refactor.md")
         'design/unified-model-refactor'
     """
+    # Convert Path to string if needed
+    path_str = str(file_path)
+
     # Remove extension
-    base = os.path.splitext(file_path)[0]
+    base = os.path.splitext(path_str)[0]
 
     # Transliterate unicode to ascii
     ascii_text = unidecode(base)
@@ -63,16 +46,42 @@ def generate_permalink(file_path: Path | str) -> str:
     lower_text = ascii_text.lower()
 
     # replace underscores with hyphens
-    text_with_hyphens = lower_text.replace('_', '-')
+    text_with_hyphens = lower_text.replace("_", "-")
 
     # Replace remaining invalid chars with hyphens
-    clean_text = re.sub(r'[^a-z0-9/\-]', '-', text_with_hyphens)
+    clean_text = re.sub(r"[^a-z0-9/\-]", "-", text_with_hyphens)
 
     # Collapse multiple hyphens
-    clean_text = re.sub(r'-+', '-', clean_text)
+    clean_text = re.sub(r"-+", "-", clean_text)
 
     # Clean each path segment
-    segments = clean_text.split('/')
-    clean_segments = [s.strip('-') for s in segments]
+    segments = clean_text.split("/")
+    clean_segments = [s.strip("-") for s in segments]
+
+    return "/".join(clean_segments)
+
+
+def setup_logging(home_dir: Path = config.home, log_file: Optional[str] = None) -> None:
+    """
+    Configure logging for the application.
+    """
 
-    return '/'.join(clean_segments)
+    # Remove default handler and any existing handlers
+    logger.remove()
+
+    # Add file handler
+    if log_file:
+        log_path = home_dir / log_file
+        logger.add(
+            str(log_path),  # loguru expects a string path
+            level=config.log_level,
+            rotation="100 MB",
+            retention="10 days",
+            backtrace=True,
+            diagnose=True,
+            enqueue=True,
+            colorize=False,
+        )
+
+    # Add stderr handler
+    logger.add(sys.stderr, level=config.log_level, backtrace=True, diagnose=True, colorize=True)

{basic_memory-0.1.1.dist-info → basic_memory-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: basic-memory
-Version: 0.1.1
+Version: 0.2.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
@@ -23,17 +23,12 @@ Requires-Dist: pydantic[email,timezone]>=2.10.3
 Requires-Dist: pyright>=1.1.390
 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
 Requires-Dist: unidecode>=1.3.8
 Requires-Dist: watchfiles>=1.0.4
-Provides-Extra: dev
-Requires-Dist: pytest-asyncio>=0.24.0; extra == 'dev'
-Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
-Requires-Dist: pytest-mock>=3.12.0; extra == 'dev'
-Requires-Dist: pytest>=8.3.4; extra == 'dev'
-Requires-Dist: ruff>=0.1.6; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # Basic Memory

basic_memory-0.2.0.dist-info/RECORD

@@ -0,0 +1,78 @@
+basic_memory/__init__.py,sha256=_ij75bUYM3LqRQYHrJ1kLnDuUyauuHilEBF96OFw9hA,122
+basic_memory/config.py,sha256=PZA2qgwKACvKfRcM3H-BPB_8FYVhgZAwTmlKJ3ROfhU,1643
+basic_memory/db.py,sha256=BFZCp4aJ7Xj9_ZCMz0rnSBuCy5xIMvvWjSImmuKzdWg,4605
+basic_memory/deps.py,sha256=UzivBw6e6iYcU_8SQ8LNCmSsmFyHfjdzfWvnfNzqbRc,5375
+basic_memory/file_utils.py,sha256=gp7RCFWaddFnELIyTc1E19Rk8jJsrKshG2n8ZZR-kKA,5751
+basic_memory/utils.py,sha256=HiLorP5_YCQeNeTcDqvnkrwY7OBaFRS3i_hdV9iWKLs,2374
+basic_memory/alembic/README,sha256=MVlc9TYmr57RbhXET6QxgyCcwWP7w-vLkEsirENqiIQ,38
+basic_memory/alembic/env.py,sha256=XqJVQhS41ba7NCPmmaSZ09_tbSLnwsY2bcpJpqx_ZTc,2107
+basic_memory/alembic/migrations.py,sha256=CIbkMHEKZ60aDUhFGSQjv8kDNM7sazfvEYHGGcy1DBk,858
+basic_memory/alembic/script.py.mako,sha256=MEqL-2qATlST9TAOeYgscMn1uy6HUS9NFvDgl93dMj8,635
+basic_memory/alembic/versions/3dae7c7b1564_initial_schema.py,sha256=lTbWlAnd1es7xU99DoJgfaRe1_Kte8TL98riqeKGV80,4363
+basic_memory/api/__init__.py,sha256=wCpj-21j1D0KzKl9Ql6unLBVFY0K1uGp_FeSZRKtqpk,72
+basic_memory/api/app.py,sha256=AEHcslN4SBq5Ni7q7wkG4jDH0-SwMWV2DeTdaUSQKns,2083
+basic_memory/api/routers/__init__.py,sha256=iviQ1QVYobC8huUuyRhEjcA0BDjrOUm1lXHXhJkxP9A,239
+basic_memory/api/routers/knowledge_router.py,sha256=cMLhRczOfSRnsZdyR0bSS8PENPRTu70dlwaV27O34bs,5705
+basic_memory/api/routers/memory_router.py,sha256=pF0GzmWoxmjhtxZM8jCmfLwqjey_fmXER5vYbD8fsQw,4556
+basic_memory/api/routers/resource_router.py,sha256=_Gp5HSJr-L-GUkQKbEP2bAZvCY8Smd-sBNWpGyqXS4c,1056
+basic_memory/api/routers/search_router.py,sha256=dCRnBbp3r966U8UYwgAaxZBbg7yX7pC8QJqagdACUi0,1086
+basic_memory/cli/__init__.py,sha256=arcKLAWRDhPD7x5t80MlviZeYzwHZ0GZigyy3NKVoGk,33
+basic_memory/cli/app.py,sha256=hF4MgYCgFql4J6qi3lguqc6HQdP2gm6PpvtSxKBSjZc,34
+basic_memory/cli/main.py,sha256=Vvpmh33MSZJftCENEjzJH3yBbxD4B40Pl6IBIumiVX4,505
+basic_memory/cli/commands/__init__.py,sha256=OQGLaKTsOdPsp2INM_pHzmOlbVfdL0sytBNgvqTqCDY,159
+basic_memory/cli/commands/db.py,sha256=I92CRufPskvHl9c90f5Eg7U7D0uIzLBiwngQuAh5cLk,772
+basic_memory/cli/commands/import_memory_json.py,sha256=ZXSRHH_3GgJzmMLvDulakKIpzsKxrZIUmEuWgJmwMOE,5138
+basic_memory/cli/commands/mcp.py,sha256=a0v54iFL01_eykODHuWIupTHCn-COm-WZGdSO5iinc0,563
+basic_memory/cli/commands/status.py,sha256=aNpP8u-ECoVTiL5MIb-D2cXXLJtv6z2z8CMCh5nt2KY,5782
+basic_memory/cli/commands/sync.py,sha256=sb6OGl9IVZLmGfHUm0-aexD365BRTaHJhpwqt0O5yxk,7035
+basic_memory/markdown/__init__.py,sha256=DdzioCWtDnKaq05BHYLgL_78FawEHLpLXnp-kPSVfIc,501
+basic_memory/markdown/entity_parser.py,sha256=sJk8TRUd9cAaIjATiJn7dBQRorrYngRbd7MRVfc0Oc4,3781
+basic_memory/markdown/markdown_processor.py,sha256=mV3pYoDTaQMEl1tA5n_XztBvNlYyH2SzKs4vnKdAet4,4952
+basic_memory/markdown/plugins.py,sha256=gtIzKRjoZsyvBqLpVNnrmzl_cbTZ5ZGn8kcuXxQjRko,6639
+basic_memory/markdown/schemas.py,sha256=mzVEDUhH98kwETMknjkKw5H697vg_zUapsJkJVi17ho,1894
+basic_memory/markdown/utils.py,sha256=ZtHa-dG--ZwFEUC3jfl04KZGhM_ZWo5b-8d8KpJ90gY,2758
+basic_memory/mcp/__init__.py,sha256=dsDOhKqjYeIbCULbHIxfcItTbqudEuEg1Np86eq0GEQ,35
+basic_memory/mcp/async_client.py,sha256=Eo345wANiBRSM4u3j_Vd6Ax4YtMg7qbWd9PIoFfj61I,236
+basic_memory/mcp/server.py,sha256=L92Vit7llaKT9NlPZfxdp67C33niObmRH2QFyUhmnD0,355
+basic_memory/mcp/tools/__init__.py,sha256=MHZmWw016N0qbtC3f186Jg1tPzh2g88_ZsCKJ0oyrrs,873
+basic_memory/mcp/tools/knowledge.py,sha256=2U8YUKCizsAETHCC1mBVKMfCEef6tlc_pa2wOmA9mD4,2016
+basic_memory/mcp/tools/memory.py,sha256=gl4MBm9l2lMOfu_xmUqjoZacWSIHOAYZiAm8z7oDuY8,5203
+basic_memory/mcp/tools/notes.py,sha256=4GKnhDK53UkeZtpZENQ9id9XdemKxLzGwMQJeuX-Kok,3772
+basic_memory/mcp/tools/search.py,sha256=tx6aIuB2FWmmrvzu3RHSQvszlk-zHcwrWhkLLHWjuZc,1105
+basic_memory/mcp/tools/utils.py,sha256=icm-Xyqw3GxooGYkXqjEjoZvIGy_Z3CPw-uUYBxR_YQ,4831
+basic_memory/models/__init__.py,sha256=Bf0xXV_ryndogvZDiVM_Wb6iV2fHUxYNGMZNWNcZi0s,307
+basic_memory/models/base.py,sha256=4hAXJ8CE1RnjKhb23lPd-QM7G_FXIdTowMJ9bRixspU,225
+basic_memory/models/knowledge.py,sha256=R05mLr2GXDfUcmPe2ja20wvzP818b4npnxL1PvQooEY,5921
+basic_memory/models/search.py,sha256=IB-ySJUqlQq9FqLGfWnraIFcB_brWa9eBwsQP1rVTeI,1164
+basic_memory/repository/__init__.py,sha256=TnscLXARq2iOgQZFvQoT9X1Bn9SB_7s1xw2fOqRs3Jg,252
+basic_memory/repository/entity_repository.py,sha256=VFLymzJ1W6AZru_s1S3U6nlqSprBrVV5Toy0-qysIfw,3524
+basic_memory/repository/observation_repository.py,sha256=BOcy4wARqCXu-thYyt7mPxt2A2C8TW0le3s_X9wrK6I,1701
+basic_memory/repository/relation_repository.py,sha256=DwpTcn9z_1sZQcyMOUABz1k1VSwo_AU63x2zR7aerTk,2933
+basic_memory/repository/repository.py,sha256=jUScHWOfcB2FajwVZ2Sbjtg-gSI2Y2rhiIaTULjvmn8,11321
+basic_memory/repository/search_repository.py,sha256=OfocJZ7EWum33klFFvsLE7BEUnZPda1BNSwrbkRiXko,9233
+basic_memory/schemas/__init__.py,sha256=eVxrtuPT7-9JIQ7UDx2J8t8xlS3u0iUkV_VLNbzvxo4,1575
+basic_memory/schemas/base.py,sha256=epSauNNVZ2lRLATf-HIzqeberq4ZBTgxliNmjitAsWc,5538
+basic_memory/schemas/delete.py,sha256=UAR2JK99WMj3gP-yoGWlHD3eZEkvlTSRf8QoYIE-Wfw,1180
+basic_memory/schemas/discovery.py,sha256=6Y2tUiv9f06rFTsa8_wTH2haS2bhCfuQh0uW33hwdd8,876
+basic_memory/schemas/memory.py,sha256=mqslazV0lQswtbNgYv_y2-KxmifIvRlg5I3IuTTMnO4,2882
+basic_memory/schemas/request.py,sha256=rt_guNWrUMePJvDmsh1g1dc7IqEY6K6mGXMKx8tBCj8,1614
+basic_memory/schemas/response.py,sha256=2su3YP-gkbw4MvgGtgZLHEuTp6RuVlK736KakaV7fP4,6273
+basic_memory/schemas/search.py,sha256=pWBA1-xEQ3rH8vLIgrQT4oygq9MMwr0B7VCbFafVVOw,3278
+basic_memory/services/__init__.py,sha256=oop6SKmzV4_NAYt9otGnupLGVCCKIVgxEcdRQWwh25I,197
+basic_memory/services/context_service.py,sha256=Bu1wVl9q3FDGbGChrLqgFGQW95-W1OfjNqq6SGljqWg,9388
+basic_memory/services/entity_service.py,sha256=bm_Z63_AJmXiRQkVYWwoB3PYLMW1t1xS3Nh0Nm9SwiI,11538
+basic_memory/services/exceptions.py,sha256=VGlCLd4UD2w5NWKqC7QpG4jOM_hA7jKRRM-MqvEVMNk,288
+basic_memory/services/file_service.py,sha256=r4JfPY1wyenAH0Y-iq7vGHPwT616ayUWoLnvA1NuzpA,5695
+basic_memory/services/link_resolver.py,sha256=VdhoPAVa65T6LW7kSTLWts55zbnnN481fr7VLz3HaXE,4513
+basic_memory/services/search_service.py,sha256=iB-BgFwInrJxTfYBerj68QORlMv46wYy2-ceQx61Dd8,7839
+basic_memory/services/service.py,sha256=V-d_8gOV07zGIQDpL-Ksqs3ZN9l3qf3HZOK1f_YNTag,336
+basic_memory/sync/__init__.py,sha256=ko0xLQv1S5U7sAOmIP2XKl03akVPzoY-a9m3TFPcMh4,193
+basic_memory/sync/file_change_scanner.py,sha256=4whJej6t9sxwUp1ox93efJ0bBHSnAr6STpk_PsKU6to,5784
+basic_memory/sync/sync_service.py,sha256=nAOX4N90lbpRJeq5tRR_7PYptIoWwhXMUljE7yrneF4,7087
+basic_memory/sync/utils.py,sha256=uc7VLK34HufKyKavGwTPGU-ARfoQr_jYbjs4fsmUvuo,1233
+basic_memory/sync/watch_service.py,sha256=CtKBrP1imI3ZSEgJl7Ffi-JZ_oDGKrhiyGgs41h5QYI,7563
+basic_memory-0.2.0.dist-info/METADATA,sha256=54ldvapxyUcnEpifbzHUtP1py712UqQjxTQVcWHR_s0,7539
+basic_memory-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+basic_memory-0.2.0.dist-info/entry_points.txt,sha256=IDQa_VmVTzmvMrpnjhEfM0S3F--XsVGEj3MpdJfuo-Q,59
+basic_memory-0.2.0.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+basic_memory-0.2.0.dist-info/RECORD,,

basic_memory/mcp/main.py

@@ -1,21 +0,0 @@
-"""Main MCP entrypoint for Basic Memory.
-
-Creates and configures the shared MCP instance and handles server startup.
-"""
-
-from loguru import logger
-
-from basic_memory.config import config
-
-# Import shared mcp instance
-from basic_memory.mcp.server import mcp
-
-# Import tools to register them
-import basic_memory.mcp.tools # noqa: F401
-
-
-if __name__ == "__main__":
-    home_dir = config.home
-    logger.info("Starting Basic Memory MCP server")
-    logger.info(f"Home directory: {home_dir}")
-    mcp.run()

basic_memory/mcp/tools/ai_edit.py

@@ -1,84 +0,0 @@
-"""Tool for AI-assisted file editing."""
-
-from pathlib import Path
-from typing import List, Dict, Any
-
-from basic_memory.mcp.server import mcp
-
-
-def _detect_indent(text: str, match_pos: int) -> int:
-    """Get indentation level at a position in text."""
-    # Find start of line containing the match
-    line_start = text.rfind("\n", 0, match_pos)
-    if line_start < 0:
-        line_start = 0
-    else:
-        line_start += 1  # Skip newline char
-
-    # Count leading spaces
-    pos = line_start
-    while pos < len(text) and text[pos].isspace():
-        pos += 1
-    return pos - line_start
-
-
-def _apply_indent(text: str, spaces: int) -> str:
-    """Apply indentation to text."""
-    prefix = " " * spaces
-    return "\n".join(prefix + line if line.strip() else line for line in text.split("\n"))
-
-
-@mcp.tool()
-async def ai_edit(path: str, edits: List[Dict[str, Any]]) -> bool:
-    """AI-assisted file editing tool.
-
-    Args:
-        path: Path to file to edit
-        edits: List of edits to apply. Each edit is a dict with:
-            oldText: Text to replace
-            newText: New content
-            options: Optional dict with:
-                indent: Number of spaces to indent
-                preserveIndentation: Keep existing indent (default: true)
-
-    Returns:
-        bool: True if edits were applied successfully
-    """
-    try:
-        # Read file
-        content = Path(path).read_text()
-        original = content
-        success = True
-
-        # Apply each edit
-        for edit in edits:
-            old_text = edit["oldText"]
-            new_text = edit["newText"]
-            options = edit.get("options", {})
-
-            # Find text to replace
-            match_pos = content.find(old_text)
-            if match_pos < 0:
-                success = False
-                continue
-
-            # Handle indentation
-            if not options.get("preserveIndentation", True):
-                # Use existing indentation
-                indent = _detect_indent(content, match_pos)
-                new_text = _apply_indent(new_text, indent)
-            elif "indent" in options:
-                # Use specified indentation
-                new_text = _apply_indent(new_text, options["indent"])
-
-            # Apply the edit
-            content = content.replace(old_text, new_text)
-
-        # Write back if changed
-        if content != original:
-            Path(path).write_text(content)
-        return success
-
-    except Exception as e:
-        print(f"Error applying edits: {e}")
-        return False