basic-memory 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

basic_memory/sync/watch_service.py

@@ -1,22 +1,20 @@
 """Watch service for Basic Memory."""
 
 import dataclasses
-
-from loguru import logger
-from pydantic import BaseModel
+import os
 from datetime import datetime
 from pathlib import Path
-from typing import List, Optional
+from typing import List, Optional, Set
 
+from loguru import logger
+from pydantic import BaseModel
 from rich.console import Console
-from rich.live import Live
-from rich.table import Table
-from watchfiles import awatch, Change
-import os
+from watchfiles import awatch
+from watchfiles.main import FileChange, Change
 
 from basic_memory.config import ProjectConfig
-from basic_memory.sync.sync_service import SyncService
 from basic_memory.services.file_service import FileService
+from basic_memory.sync.sync_service import SyncService
 
 
 class WatchEvent(BaseModel):
@@ -81,138 +79,136 @@ class WatchService:
         self.status_path.parent.mkdir(parents=True, exist_ok=True)
         self.console = Console()
 
-    def generate_table(self) -> Table:
-        """Generate status display table"""
-        table = Table()
-
-        # Add status row
-        table.add_column("Status", style="cyan")
-        table.add_column("Last Scan", style="cyan")
-        table.add_column("Files", style="cyan")
-        table.add_column("Errors", style="red")
-
-        # Add main status row
-        table.add_row(
-            "✓ Running" if self.state.running else "✗ Stopped",
-            self.state.last_scan.strftime("%H:%M:%S") if self.state.last_scan else "-",
-            str(self.state.synced_files),
-            f"{self.state.error_count} ({self.state.last_error.strftime('%H:%M:%S') if self.state.last_error else 'none'})",
-        )
-
-        if self.state.recent_events:
-            # Add recent events
-            table.add_section()
-            table.add_row("Recent Events", "", "", "")
-
-            for event in self.state.recent_events[:5]:  # Show last 5 events
-                color = {
-                    "new": "green",
-                    "modified": "yellow",
-                    "moved": "blue",
-                    "deleted": "red",
-                    "error": "red",
-                }.get(event.action, "white")
-
-                icon = {
-                    "new": "✚",
-                    "modified": "✎",
-                    "moved": "→",
-                    "deleted": "✖",
-                    "error": "!",
-                }.get(event.action, "*")
-
-                table.add_row(
-                    f"[{color}]{icon} {event.action}[/{color}]",
-                    event.timestamp.strftime("%H:%M:%S"),
-                    f"[{color}]{event.path}[/{color}]",
-                    f"[dim]{event.checksum[:8] if event.checksum else ''}[/dim]",
-                )
-
-        return table
-
-    async def run(self, console_status: bool = False):  # pragma: no cover
+    async def run(self):  # 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()
+        try:
+            async for changes in awatch(
+                self.config.home,
+                debounce=self.config.sync_delay,
+                watch_filter=self.filter_changes,
+                recursive=True,
+            ):
+                await self.handle_changes(self.config.home, changes)
+
+        except Exception as e:
+            self.state.record_error(str(e))
+            await self.write_status()
+            raise
+        finally:
+            self.state.running = False
+            await self.write_status()
+
+    def filter_changes(self, change: Change, path: str) -> bool:
+        """Filter to only watch non-hidden files and directories.
+
+        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:
+            return False
+
+        # Skip hidden directories and files
+        path_parts = relative_path.parts
+        for part in path_parts:
+            if part.startswith("."):
+                return False
 
-        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,
-                    watch_filter=self.filter_changes,
-                    debounce=self.config.sync_delay,
-                    recursive=True,
-                ):
-                    # Process changes
-                    await self.handle_changes(self.config.home)
-                    # Update display
-
-            except Exception as e:
-                self.state.record_error(str(e))
-                await self.write_status()
-                raise
-            finally:
-                self.state.running = False
-                await self.write_status()
+        return True
 
     async def write_status(self):
         """Write current state to status file"""
         self.status_path.write_text(WatchServiceState.model_dump_json(self.state, indent=2))
 
-    def filter_changes(self, change: Change, path: str) -> bool:
-        """Filter to only watch markdown files"""
-        return path.endswith(".md") and not Path(path).name.startswith(".")
-
-    async def handle_changes(self, directory: Path):
+    async def handle_changes(self, directory: Path, changes: Set[FileChange]):
         """Process a batch of file changes"""
+        logger.debug(f"handling {len(changes)} changes in directory: {directory} ...")
+
+        # Group changes by type
+        adds = []
+        deletes = []
+        modifies = []
+
+        for change, path in changes:
+            # convert to relative path
+            relative_path = str(Path(path).relative_to(directory))
+            if change == Change.added:
+                adds.append(relative_path)
+            elif change == Change.deleted:
+                deletes.append(relative_path)
+            elif change == Change.modified:
+                modifies.append(relative_path)
+
+        # Track processed files to avoid duplicates
+        processed = set()
+
+        # First handle potential moves
+        for added_path in adds:
+            if added_path in processed:
+                continue  # pragma: no cover
+
+            for deleted_path in deletes:
+                if deleted_path in processed:
+                    continue  # pragma: no cover
+
+                if added_path != deleted_path:
+                    # Compare checksums to detect moves
+                    try:
+                        added_checksum = await self.file_service.compute_checksum(added_path)
+                        deleted_entity = await self.sync_service.entity_repository.get_by_file_path(
+                            deleted_path
+                        )
+
+                        if deleted_entity and deleted_entity.checksum == added_checksum:
+                            await self.sync_service.handle_move(deleted_path, added_path)
+                            self.state.add_event(
+                                path=f"{deleted_path} -> {added_path}",
+                                action="moved",
+                                status="success",
+                            )
+                            self.console.print(
+                                f"[blue]→[/blue] Moved: {deleted_path} → {added_path}"
+                            )
+                            processed.add(added_path)
+                            processed.add(deleted_path)
+                            break
+                    except Exception as e:  # pragma: no cover
+                        logger.warning(f"Error checking for move: {e}")
+
+        # Handle remaining changes
+        for path in deletes:
+            if path not in processed:
+                await self.sync_service.handle_delete(path)
+                self.state.add_event(path=path, action="deleted", status="success")
+                self.console.print(f"[red]✕[/red] Deleted: {path}")
+                processed.add(path)
+
+        for path in adds:
+            if path not in processed:
+                _, checksum = await self.sync_service.sync_file(path, new=True)
+                self.state.add_event(path=path, action="new", status="success", checksum=checksum)
+                self.console.print(f"[green]✓[/green] Added: {path}")
+                processed.add(path)
+
+        for path in modifies:
+            if path not in processed:
+                _, checksum = await self.sync_service.sync_file(path, new=False)
+                self.state.add_event(
+                    path=path, action="modified", status="success", checksum=checksum
+                )
+                self.console.print(f"[yellow]✎[/yellow] Modified: {path}")
+                processed.add(path)
 
-        logger.debug(f"handling change in directory: {directory} ...")
-        # Process changes with timeout
-        report = await self.sync_service.sync(directory)
-        self.state.last_scan = datetime.now()
-        self.state.synced_files = report.total
-
-        # Update stats
-        for path in report.new:
-            self.state.add_event(
-                path=path, action="new", status="success", checksum=report.checksums[path]
-            )
-        for path in report.modified:
-            self.state.add_event(
-                path=path, action="modified", status="success", checksum=report.checksums[path]
-            )
-        for old_path, new_path in report.moves.items():
-            self.state.add_event(
-                path=f"{old_path} -> {new_path}",
-                action="moved",
-                status="success",
-                checksum=report.checksums[new_path],
-            )
-        for path in report.deleted:
-            self.state.add_event(path=path, action="deleted", status="success")
+        # Add a divider if we processed any files
+        if processed:
+            self.console.print("─" * 50, style="dim")
 
+        self.state.last_scan = datetime.now()
+        self.state.synced_files += len(processed)
         await self.write_status()

basic_memory/utils.py

@@ -1,5 +1,6 @@
 """Utility functions for basic-memory."""
 
+import logging
 import os
 import re
 import sys
@@ -10,7 +11,6 @@ from loguru import logger
 from unidecode import unidecode
 
 import basic_memory
-from basic_memory.config import config
 
 import logfire
 
@@ -65,7 +65,11 @@ def generate_permalink(file_path: Union[Path, str]) -> str:
 
 
 def setup_logging(
-    home_dir: Path = config.home, log_file: Optional[str] = None, console: bool = True
+    env: str,
+    home_dir: Path,
+    log_file: Optional[str] = None,
+    log_level: str = "INFO",
+    console: bool = True,
 ) -> None:  # pragma: no cover
     """
     Configure logging for the application.
@@ -79,15 +83,14 @@ def setup_logging(
     logger.remove()
 
     # Add file handler if we are not running tests
-    if log_file and config.env != "test":
+    if log_file and env != "test":
         # enable pydantic logfire
         logfire.configure(
             code_source=logfire.CodeSource(
                 repository="https://github.com/basicmachines-co/basic-memory",
                 revision=basic_memory.__version__,
-                root_path="/src/basic_memory",
             ),
-            environment=config.env,
+            environment=env,
             console=False,
         )
         logger.configure(handlers=[logfire.loguru_handler()])
@@ -100,7 +103,7 @@ def setup_logging(
         log_path = home_dir / log_file
         logger.add(
             str(log_path),
-            level=config.log_level,
+            level=log_level,
             rotation="100 MB",
             retention="10 days",
             backtrace=True,
@@ -109,7 +112,19 @@ def setup_logging(
             colorize=False,
         )
 
-    # Add stderr handler
-    logger.add(sys.stderr, level=config.log_level, backtrace=True, diagnose=True, colorize=True)
+    if env == "test" or console:
+        # Add stderr handler
+        logger.add(sys.stderr, level=log_level, backtrace=True, diagnose=True, colorize=True)
 
-    logger.info(f"ENV: '{config.env}' Log level: '{config.log_level}' Logging to {log_file}")
+    logger.info(f"ENV: '{env}' Log level: '{log_level}' Logging to {log_file}")
+
+    # Get the logger for 'httpx'
+    httpx_logger = logging.getLogger("httpx")
+    # Set the logging level to WARNING to ignore INFO and DEBUG logs
+    httpx_logger.setLevel(logging.WARNING)
+
+    # turn watchfiles to WARNING
+    logging.getLogger("watchfiles.main").setLevel(logging.WARNING)
+
+    # disable open telemetry warning
+    logging.getLogger("instrumentor").setLevel(logging.ERROR)

{basic_memory-0.7.0.dist-info → basic_memory-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: basic-memory
-Version: 0.7.0
+Version: 0.8.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
@@ -19,6 +19,7 @@ Requires-Dist: logfire[fastapi,httpx,sqlalchemy,sqlite3]>=3.6.0
 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: pydantic-settings>=2.6.1
 Requires-Dist: pydantic[email,timezone]>=2.10.3
 Requires-Dist: pyright>=1.1.390

basic_memory-0.8.0.dist-info/RECORD

@@ -0,0 +1,91 @@
+basic_memory/__init__.py,sha256=1Vkhl1i_QQpYLtQxxfrs_tJ3ZUbmJC0C4zxgmVy7C60,122
+basic_memory/config.py,sha256=kh3LC9slFHoxfIufziyqafbI2tS9NXpEgJ8y3bH1Ixk,2129
+basic_memory/db.py,sha256=EVX3pgA2rah4tZpxy5wKvZSN8vVcrvo5l-hKjAXBb0U,5284
+basic_memory/deps.py,sha256=8LkcfppQEJpiflYZxLk-SmQuL04qknbsdfzIkM_ctuY,5530
+basic_memory/file_utils.py,sha256=Kx2WVewno_SnLMnorHdiWwsZztY6esKRVirmDQSiv2w,5864
+basic_memory/utils.py,sha256=2GOo14HUcnzpft6tkSCr8QTESlS5baxfm8oZJ6vdVds,3711
+basic_memory/alembic/alembic.ini,sha256=IEZsnF8CbbZnkwBr67LzKKNobHuzTaQNUvM8Psop5xc,3733
+basic_memory/alembic/env.py,sha256=GyQpEpQu84flqAdelxR0-H9nbkHrVoCboYGfmltBDoA,2737
+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/alembic/versions/502b60eaa905_remove_required_from_entity_permalink.py,sha256=k6xYTmYPM9Ros-7CA7BwZBKYwoK_gmVdC-2n8FAjdoE,1840
+basic_memory/alembic/versions/b3c3938bacdb_relation_to_name_unique_index.py,sha256=RsGymQzfRXV1LSNKiyi0lMilTxW1NgwS9jR67ye2apI,1428
+basic_memory/api/__init__.py,sha256=wCpj-21j1D0KzKl9Ql6unLBVFY0K1uGp_FeSZRKtqpk,72
+basic_memory/api/app.py,sha256=Ma-kLPkwlHUQ1dutExIqedMiFurzgBcazusQDq7IDsE,1374
+basic_memory/api/routers/__init__.py,sha256=iviQ1QVYobC8huUuyRhEjcA0BDjrOUm1lXHXhJkxP9A,239
+basic_memory/api/routers/knowledge_router.py,sha256=2encEkZw7gKyfwa2HjFtTJh5aXhl96DFLrSB2pk-HfI,5291
+basic_memory/api/routers/memory_router.py,sha256=wGoAWm1ehWSlDYI66eUtp99b7uPJtymh2RMaZiohh0Y,5371
+basic_memory/api/routers/resource_router.py,sha256=WEJEqEaY_yTKj5-U-rW4kXQKUcJflykgwI6_g_R41ck,8058
+basic_memory/api/routers/search_router.py,sha256=WCLuAkEZ-DpwHU8RsnZg63_LDiSYbbLLlBb9Avbc2fA,1164
+basic_memory/cli/__init__.py,sha256=arcKLAWRDhPD7x5t80MlviZeYzwHZ0GZigyy3NKVoGk,33
+basic_memory/cli/app.py,sha256=EyE-qactiI4QMGXZzmYcVNtn3-16zy1jT_G-a-yx2AU,324
+basic_memory/cli/main.py,sha256=KH2JDvQNIwV7VRKnKZ2jTkMSlTECziUmk1xgmU6ezfw,433
+basic_memory/cli/commands/__init__.py,sha256=OQGLaKTsOdPsp2INM_pHzmOlbVfdL0sytBNgvqTqCDY,159
+basic_memory/cli/commands/db.py,sha256=BW3VmoTKNfzkl85m9lyrx8lkk1IRb6wuAmrPKFQxNE8,906
+basic_memory/cli/commands/import_chatgpt.py,sha256=py3q9iMlB85olQBsBcEpUt0X03hHvAmRy8iQl2dbbuc,8394
+basic_memory/cli/commands/import_claude_conversations.py,sha256=_7n-nn1tbsaarwR25QXjYxSC_K2M0cXBTzthnCZ_4-w,7030
+basic_memory/cli/commands/import_claude_projects.py,sha256=fvXu6wwlmfA2wJCcp8IoJnz3INefkVcFhqAX8KhnCtc,6851
+basic_memory/cli/commands/import_memory_json.py,sha256=cS-1rxGYUC0-QsETIbA0QqbB1Cl74YcnoJRNCkMkM-o,5395
+basic_memory/cli/commands/mcp.py,sha256=BPdThcufdriIvrDskc87a0oCC1BkZ0PZsgNao_-oNKk,611
+basic_memory/cli/commands/status.py,sha256=YEw6SA82Y8GbtTIn-h6m15zjX5bGMx5abAbu19LXVjs,5398
+basic_memory/cli/commands/sync.py,sha256=uSzGPdjbMX7PKh8iA_Oo06zLc0tixX_cV6i_JWph95I,6766
+basic_memory/cli/commands/tools.py,sha256=P5EMifFHDlaTFje97Yxp9GawoRlCOML5Dy6wBBjMnjo,6117
+basic_memory/markdown/__init__.py,sha256=DdzioCWtDnKaq05BHYLgL_78FawEHLpLXnp-kPSVfIc,501
+basic_memory/markdown/entity_parser.py,sha256=LnjG_wg38LVN8JndsZJV2UVGPIaoIV5sGs94iQ9PL6k,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/main.py,sha256=p_zjCDSeT9EsjNmlzDfEQ7xI8Y_bBLmMG0g-y-DakTA,703
+basic_memory/mcp/server.py,sha256=vlhURihp7Ly1eVyI01J9zvYhbz7wgHkhoNLNq6KOGug,286
+basic_memory/mcp/prompts/__init__.py,sha256=BsjRBgxYjS-JXK8RqJQQd1xPEoWWgQ4Hw3BynaYxGwA,670
+basic_memory/mcp/prompts/ai_assistant_guide.py,sha256=e2DoP2Dv2HSDd00m6xGjGMWxUIqYJceJhw3RxuuJdeA,925
+basic_memory/mcp/prompts/continue_conversation.py,sha256=tXE626Qay8aY4tDQhAmvZYO8nf7tTfAMRqE24JShTvc,6666
+basic_memory/mcp/prompts/json_canvas_spec.py,sha256=yKO_9_ojF4tCEWSMuHn5YNHFkAibzPdOgluAKJ-K924,827
+basic_memory/mcp/prompts/recent_activity.py,sha256=3b9_jxPQ-c4lQH05Ig2a6k4ApWW5d9WhcArhMU0S6BM,1552
+basic_memory/mcp/prompts/search.py,sha256=1E8dHcPRCy19Emv7r4MWJ2ZYsuQNa4qRmIy2fnuWuoA,4496
+basic_memory/mcp/prompts/utils.py,sha256=cPdlJl1D5bS36hQBoBgf0RACE2ToUy-HgHukO8eRkZ4,3734
+basic_memory/mcp/tools/__init__.py,sha256=_MXdi0AJr5WB5C20WSQAwHhWOyhspyzbgWL9ijQh3to,953
+basic_memory/mcp/tools/canvas.py,sha256=wbSg-NauRmz_reNH3SUY2kLWNUKMA5kPvSoz_6ec7uw,3162
+basic_memory/mcp/tools/knowledge.py,sha256=JotFMQpMwidx0WLvOG4yWpwWwLmyp-PoO6bVjpQseYQ,2671
+basic_memory/mcp/tools/memory.py,sha256=rteQJSXIUGsJbA-AzZN1dyHKr98EELHGc-rvMXlG2JI,6474
+basic_memory/mcp/tools/notes.py,sha256=vAiQsJqJvxevYUPxVib10Jd5qvEMATeiSeu1sGe32nM,7415
+basic_memory/mcp/tools/resource.py,sha256=Imbl8exE27qPmWEZ4DXIeCdpQXSYYv_ul8whTu3d_cE,6526
+basic_memory/mcp/tools/search.py,sha256=UFPBDzfZ60SrvAgvISO3Jt6WdNwEQKsvibQdPxC7dOg,1511
+basic_memory/mcp/tools/utils.py,sha256=h_iDGduofU4GyQyyARkI4L-OJ9Rwppkx48BDSEMYsLY,4866
+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=lbKd8VOOVPqXtIhNMY30bIokoQutFjLpHwLD5At90MY,6644
+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=X59h8JevRn9sEZz6R41NvtyXo9Gbq22mY-XxsoIEwrQ,11324
+basic_memory/repository/search_repository.py,sha256=3AOrfTihzLKiXZTGerrKyRUpITNtXyLrp_XWEVpY3h0,10503
+basic_memory/schemas/__init__.py,sha256=WXQ2okYPC-OFa2xmCWq-EP52lSuqFX9Sx-zMJUPv8to,1318
+basic_memory/schemas/base.py,sha256=dwnaI5fJXsdp81mdH0ZpmJ-WICY-0M7ZPWeW5OUgBG8,5685
+basic_memory/schemas/delete.py,sha256=UAR2JK99WMj3gP-yoGWlHD3eZEkvlTSRf8QoYIE-Wfw,1180
+basic_memory/schemas/memory.py,sha256=ap8lKHxUfM6WTiAFlObs_rZWz3sQxhiGlcvc_NVA9f8,3094
+basic_memory/schemas/request.py,sha256=58r9mPGc4Am9rR_zGzo-yqXcsrl5I6n3M5LjGK5gFFk,1626
+basic_memory/schemas/response.py,sha256=lVYR31DTtSeFRddGWX_wQWnQgyiwX0LEpNJ4f4lKpTM,6440
+basic_memory/schemas/search.py,sha256=riODPc4EWgXTM4QRBJZ9vZga9lP9lYRF7Nfbtlw_gjg,3344
+basic_memory/services/__init__.py,sha256=oop6SKmzV4_NAYt9otGnupLGVCCKIVgxEcdRQWwh25I,197
+basic_memory/services/context_service.py,sha256=y2Kd9YRPdQbJ6uWcY71z2qCZZUt8Sb2Dy52dh2OMJxo,9651
+basic_memory/services/entity_service.py,sha256=cMas6BjtWJLt3QMUsR1U21Js_vpFFKz1SMwSnXD8Suk,12133
+basic_memory/services/exceptions.py,sha256=VGlCLd4UD2w5NWKqC7QpG4jOM_hA7jKRRM-MqvEVMNk,288
+basic_memory/services/file_service.py,sha256=Z81qnaIHEQd9M9SMCQwvo5Wga3R3hfP43hEllt5KTmc,8008
+basic_memory/services/link_resolver.py,sha256=m1ycdKrU9tnVHaMn1vuEN4_2YJ5f912Us61PTB2O7QI,4708
+basic_memory/services/search_service.py,sha256=OYnv15DVUZGI3WBVwdW3VARlWR377hwb5GH2eNts400,9336
+basic_memory/services/service.py,sha256=V-d_8gOV07zGIQDpL-Ksqs3ZN9l3qf3HZOK1f_YNTag,336
+basic_memory/sync/__init__.py,sha256=CVHguYH457h2u2xoM8KvOilJC71XJlZ-qUh8lHcjYj4,156
+basic_memory/sync/sync_service.py,sha256=1lytLbJO1RxKhihv3n7zsuek4MpbJ_bc2aCcqGl7hh0,13724
+basic_memory/sync/watch_service.py,sha256=FtamKOp_aTMdTdd8fNL60Bn3VU2IjHJJh8wzp3-T5DQ,7662
+basic_memory-0.8.0.dist-info/METADATA,sha256=7z2Vt7lYowomq0uUxzNT6aHcwfz8IseOPcmYCbZcZfE,10885
+basic_memory-0.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+basic_memory-0.8.0.dist-info/entry_points.txt,sha256=IDQa_VmVTzmvMrpnjhEfM0S3F--XsVGEj3MpdJfuo-Q,59
+basic_memory-0.8.0.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+basic_memory-0.8.0.dist-info/RECORD,,

basic_memory/alembic/README

@@ -1 +0,0 @@
-Generic single-database configuration.

basic_memory/schemas/discovery.py

@@ -1,28 +0,0 @@
-"""Schemas for knowledge discovery and analytics endpoints."""
-
-from typing import List, Optional
-from pydantic import BaseModel, Field
-
-from basic_memory.schemas.response import EntityResponse
-
-
-class EntityTypeList(BaseModel):
-    """List of unique entity types in the system."""
-
-    types: List[str]
-
-
-class ObservationCategoryList(BaseModel):
-    """List of unique observation categories in the system."""
-
-    categories: List[str]
-
-
-class TypedEntityList(BaseModel):
-    """List of entities of a specific type."""
-
-    entity_type: str = Field(..., description="Type of entities in the list")
-    entities: List[EntityResponse]
-    total: int = Field(..., description="Total number of entities")
-    sort_by: Optional[str] = Field(None, description="Field used for sorting")
-    include_related: bool = Field(False, description="Whether related entities are included")

basic_memory/sync/file_change_scanner.py

@@ -1,158 +0,0 @@
-"""Service for detecting changes between filesystem and database."""
-
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Dict, Sequence
-
-from loguru import logger
-
-from basic_memory.file_utils import compute_checksum
-from basic_memory.models import Entity
-from basic_memory.repository.entity_repository import EntityRepository
-from basic_memory.sync.utils import SyncReport
-
-
-@dataclass
-class FileState:
-    """State of a file including file path, permalink and checksum info."""
-
-    file_path: str
-    permalink: str
-    checksum: str
-
-
-@dataclass
-class ScanResult:
-    """Result of scanning a directory."""
-
-    # file_path -> checksum
-    files: Dict[str, str] = field(default_factory=dict)
-    # file_path -> error message
-    errors: Dict[str, str] = field(default_factory=dict)
-
-
-class FileChangeScanner:
-    """
-    Service for detecting changes between filesystem and database.
-    The filesystem is treated as the source of truth.
-    """
-
-    def __init__(self, entity_repository: EntityRepository):
-        self.entity_repository = entity_repository
-
-    async def scan_directory(self, directory: Path) -> ScanResult:
-        """
-        Scan directory for markdown files and their checksums.
-        Only processes .md files, logs and skips others.
-
-        Args:
-            directory: Directory to scan
-
-        Returns:
-            ScanResult containing found files and any errors
-        """
-        logger.debug(f"Scanning directory: {directory}")
-        result = ScanResult()
-
-        if not directory.exists():
-            logger.debug(f"Directory does not exist: {directory}")
-            return result
-
-        for path in directory.rglob("*"):
-            if not path.is_file() or not path.name.endswith(".md"):
-                if path.is_file():
-                    logger.debug(f"Skipping non-markdown file: {path}")
-                continue
-
-            try:
-                # Get relative path first - used in error reporting if needed
-                rel_path = str(path.relative_to(directory))
-                content = path.read_text()
-                checksum = await compute_checksum(content)
-                result.files[rel_path] = checksum
-
-            except Exception as e:
-                rel_path = str(path.relative_to(directory))
-                result.errors[rel_path] = str(e)
-                logger.error(f"Failed to read {rel_path}: {e}")
-
-        logger.debug(f"Found {len(result.files)} markdown files")
-        if result.errors:
-            logger.warning(f"Encountered {len(result.errors)} errors while scanning")
-
-        return result
-
-    async def find_changes(
-        self, directory: Path, db_file_state: Dict[str, FileState]
-    ) -> SyncReport:
-        """Find changes between filesystem and database."""
-        # Get current files and checksums
-        scan_result = await self.scan_directory(directory)
-        current_files = scan_result.files
-
-        # Build report
-        report = SyncReport(total=len(current_files))
-
-        # Track potentially moved files by checksum
-        files_by_checksum = {}  # checksum -> file_path
-
-        # First find potential new files and record checksums
-        for file_path, checksum in current_files.items():
-            logger.debug(f"{file_path} ({checksum[:8]})")
-
-            if file_path not in db_file_state:
-                # Could be new or could be the destination of a move
-                report.new.add(file_path)
-                files_by_checksum[checksum] = file_path
-            elif checksum != db_file_state[file_path].checksum:
-                report.modified.add(file_path)
-
-            report.checksums[file_path] = checksum
-
-        # Now detect moves and deletions
-        for db_file_path, db_state in db_file_state.items():
-            if db_file_path not in current_files:
-                if db_state.checksum in files_by_checksum:
-                    # Found a move - file exists at new path with same checksum
-                    new_path = files_by_checksum[db_state.checksum]
-                    report.moves[db_file_path] = new_path
-                    # Remove from new files since it's a move
-                    report.new.remove(new_path)
-                else:
-                    # Actually deleted
-                    report.deleted.add(db_file_path)
-
-        # Log summary
-        logger.debug(f"Total files: {report.total}")
-        logger.debug(f"Changes found: {report.total_changes}")
-        logger.debug(f"  New: {len(report.new)}")
-        logger.debug(f"  Modified: {len(report.modified)}")
-        logger.debug(f"  Moved: {len(report.moves)}")
-        logger.debug(f"  Deleted: {len(report.deleted)}")
-
-        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}")
-
-        return report
-
-    async def get_db_file_state(self, db_records: Sequence[Entity]) -> Dict[str, FileState]:
-        """Get file_path and checksums from database.
-        Args:
-            db_records: database records
-        Returns:
-            Dict mapping file paths to FileState
-            :param db_records: the data from the db
-        """
-        return {
-            r.file_path: FileState(
-                file_path=r.file_path, permalink=r.permalink, checksum=r.checksum or ""
-            )
-            for r in db_records
-        }
-
-    async def find_knowledge_changes(self, directory: Path) -> SyncReport:
-        """Find changes in knowledge directory."""
-        db_file_state = await self.get_db_file_state(await self.entity_repository.find_all())
-        return await self.find_changes(directory=directory, db_file_state=db_file_state)