basic-memory 0.6.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,45 +65,45 @@ def generate_permalink(file_path: Union[Path, str]) -> str:
 
 
 def setup_logging(
-    home_dir: Path = config.home, log_file: Optional[str] = None
+    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.
     :param home_dir: the root directory for the application
     :param log_file: the name of the log file to write to
     :param app: the fastapi application instance
+    :param console: whether to log to the console
     """
 
     # Remove default handler and any existing handlers
     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()])
 
         # instrument code spans
         logfire.instrument_sqlite3()
-        logfire.instrument_pydantic()
-
-        from basic_memory.db import _engine as engine
-
-        if engine:
-            logfire.instrument_sqlalchemy(engine=engine)
+        logfire.instrument_httpx()
 
         # setup logger
         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,
@@ -112,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: '{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)
 
-    logger.info(f"ENV: '{config.env}' Log level: '{config.log_level}' Logging to {log_file}")
+    # disable open telemetry warning
+    logging.getLogger("instrumentor").setLevel(logging.ERROR)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: basic-memory
-Version: 0.6.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
@@ -15,10 +15,11 @@ Requires-Dist: dateparser>=1.2.0
 Requires-Dist: fastapi[standard]>=0.115.8
 Requires-Dist: greenlet>=3.1.1
 Requires-Dist: icecream>=2.1.3
-Requires-Dist: logfire[fastapi,sqlalchemy,sqlite3]>=3.6.0
+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")