basic-memory 0.13.0b4__py3-none-any.whl → 0.13.0b5__py3-none-any.whl

basic_memory/services/project_service.py

@@ -159,7 +159,9 @@ class ProjectService:
         multiple projects might have is_default=True or no project is marked as default.
         """
         if not self.repository:
-            raise ValueError("Repository is required for _ensure_single_default_project") # pragma: no cover
+            raise ValueError(
+                "Repository is required for _ensure_single_default_project"
+            )  # pragma: no cover
 
         # Get all projects with is_default=True
         db_projects = await self.repository.find_all()
@@ -309,8 +311,11 @@ class ProjectService:
                     f"Changed default project to '{new_default.name}' as '{name}' was deactivated"
                 )
 
-    async def get_project_info(self) -> ProjectInfoResponse:
-        """Get comprehensive information about the current Basic Memory project.
+    async def get_project_info(self, project_name: Optional[str] = None) -> ProjectInfoResponse:
+        """Get comprehensive information about the specified Basic Memory project.
+
+        Args:
+            project_name: Name of the project to get info for. If None, uses the current config project.
 
         Returns:
             Comprehensive project information and statistics
@@ -318,19 +323,27 @@ class ProjectService:
         if not self.repository:  # pragma: no cover
             raise ValueError("Repository is required for get_project_info")
 
-        # Get statistics
-        statistics = await self.get_statistics()
+        # Use specified project or fall back to config project
+        project_name = project_name or config.project
+        # Get project path from configuration
+        project_path = config_manager.projects.get(project_name)
+        if not project_path:  # pragma: no cover
+            raise ValueError(f"Project '{project_name}' not found in configuration")
+
+        # Get project from database to get project_id
+        db_project = await self.repository.get_by_name(project_name)
+        if not db_project:  # pragma: no cover
+            raise ValueError(f"Project '{project_name}' not found in database")
+
+        # Get statistics for the specified project
+        statistics = await self.get_statistics(db_project.id)
 
-        # Get activity metrics
-        activity = await self.get_activity_metrics()
+        # Get activity metrics for the specified project
+        activity = await self.get_activity_metrics(db_project.id)
 
         # Get system status
         system = self.get_system_status()
 
-        # Get current project information from config
-        project_name = config.project
-        project_path = str(config.home)
-
         # Get enhanced project information from database
         db_projects = await self.repository.get_active_projects()
         db_projects_by_name = {p.name: p for p in db_projects}
@@ -361,60 +374,85 @@ class ProjectService:
             system=system,
         )
 
-    async def get_statistics(self) -> ProjectStatistics:
-        """Get statistics about the current project."""
+    async def get_statistics(self, project_id: int) -> ProjectStatistics:
+        """Get statistics about the specified project.
+
+        Args:
+            project_id: ID of the project to get statistics for (required).
+        """
         if not self.repository:  # pragma: no cover
             raise ValueError("Repository is required for get_statistics")
 
         # Get basic counts
         entity_count_result = await self.repository.execute_query(
-            text("SELECT COUNT(*) FROM entity")
+            text("SELECT COUNT(*) FROM entity WHERE project_id = :project_id"),
+            {"project_id": project_id},
         )
         total_entities = entity_count_result.scalar() or 0
 
         observation_count_result = await self.repository.execute_query(
-            text("SELECT COUNT(*) FROM observation")
+            text(
+                "SELECT COUNT(*) FROM observation o JOIN entity e ON o.entity_id = e.id WHERE e.project_id = :project_id"
+            ),
+            {"project_id": project_id},
         )
         total_observations = observation_count_result.scalar() or 0
 
         relation_count_result = await self.repository.execute_query(
-            text("SELECT COUNT(*) FROM relation")
+            text(
+                "SELECT COUNT(*) FROM relation r JOIN entity e ON r.from_id = e.id WHERE e.project_id = :project_id"
+            ),
+            {"project_id": project_id},
         )
         total_relations = relation_count_result.scalar() or 0
 
         unresolved_count_result = await self.repository.execute_query(
-            text("SELECT COUNT(*) FROM relation WHERE to_id IS NULL")
+            text(
+                "SELECT COUNT(*) FROM relation r JOIN entity e ON r.from_id = e.id WHERE r.to_id IS NULL AND e.project_id = :project_id"
+            ),
+            {"project_id": project_id},
         )
         total_unresolved = unresolved_count_result.scalar() or 0
 
         # Get entity counts by type
         entity_types_result = await self.repository.execute_query(
-            text("SELECT entity_type, COUNT(*) FROM entity GROUP BY entity_type")
+            text(
+                "SELECT entity_type, COUNT(*) FROM entity WHERE project_id = :project_id GROUP BY entity_type"
+            ),
+            {"project_id": project_id},
         )
         entity_types = {row[0]: row[1] for row in entity_types_result.fetchall()}
 
         # Get observation counts by category
         category_result = await self.repository.execute_query(
-            text("SELECT category, COUNT(*) FROM observation GROUP BY category")
+            text(
+                "SELECT o.category, COUNT(*) FROM observation o JOIN entity e ON o.entity_id = e.id WHERE e.project_id = :project_id GROUP BY o.category"
+            ),
+            {"project_id": project_id},
         )
         observation_categories = {row[0]: row[1] for row in category_result.fetchall()}
 
         # Get relation counts by type
         relation_types_result = await self.repository.execute_query(
-            text("SELECT relation_type, COUNT(*) FROM relation GROUP BY relation_type")
+            text(
+                "SELECT r.relation_type, COUNT(*) FROM relation r JOIN entity e ON r.from_id = e.id WHERE e.project_id = :project_id GROUP BY r.relation_type"
+            ),
+            {"project_id": project_id},
         )
         relation_types = {row[0]: row[1] for row in relation_types_result.fetchall()}
 
-        # Find most connected entities (most outgoing relations)
+        # Find most connected entities (most outgoing relations) - project filtered
         connected_result = await self.repository.execute_query(
             text("""
-            SELECT e.id, e.title, e.permalink, COUNT(r.id) AS relation_count, file_path
+            SELECT e.id, e.title, e.permalink, COUNT(r.id) AS relation_count, e.file_path
             FROM entity e
             JOIN relation r ON e.id = r.from_id
+            WHERE e.project_id = :project_id
             GROUP BY e.id
             ORDER BY relation_count DESC
             LIMIT 10
-        """)
+        """),
+            {"project_id": project_id},
         )
         most_connected = [
             {
@@ -427,15 +465,16 @@ class ProjectService:
             for row in connected_result.fetchall()
         ]
 
-        # Count isolated entities (no relations)
+        # Count isolated entities (no relations) - project filtered
         isolated_result = await self.repository.execute_query(
             text("""
             SELECT COUNT(e.id)
             FROM entity e
             LEFT JOIN relation r1 ON e.id = r1.from_id
             LEFT JOIN relation r2 ON e.id = r2.to_id
-            WHERE r1.id IS NULL AND r2.id IS NULL
-        """)
+            WHERE e.project_id = :project_id AND r1.id IS NULL AND r2.id IS NULL
+        """),
+            {"project_id": project_id},
         )
         isolated_count = isolated_result.scalar() or 0
 
@@ -451,19 +490,25 @@ class ProjectService:
             isolated_entities=isolated_count,
         )
 
-    async def get_activity_metrics(self) -> ActivityMetrics:
-        """Get activity metrics for the current project."""
+    async def get_activity_metrics(self, project_id: int) -> ActivityMetrics:
+        """Get activity metrics for the specified project.
+
+        Args:
+            project_id: ID of the project to get activity metrics for (required).
+        """
         if not self.repository:  # pragma: no cover
             raise ValueError("Repository is required for get_activity_metrics")
 
-        # Get recently created entities
+        # Get recently created entities (project filtered)
         created_result = await self.repository.execute_query(
             text("""
             SELECT id, title, permalink, entity_type, created_at, file_path 
             FROM entity
+            WHERE project_id = :project_id
             ORDER BY created_at DESC
             LIMIT 10
-        """)
+        """),
+            {"project_id": project_id},
         )
         recently_created = [
             {
@@ -477,14 +522,16 @@ class ProjectService:
             for row in created_result.fetchall()
         ]
 
-        # Get recently updated entities
+        # Get recently updated entities (project filtered)
         updated_result = await self.repository.execute_query(
             text("""
             SELECT id, title, permalink, entity_type, updated_at, file_path 
             FROM entity
+            WHERE project_id = :project_id
             ORDER BY updated_at DESC
             LIMIT 10
-        """)
+        """),
+            {"project_id": project_id},
         )
         recently_updated = [
             {
@@ -505,47 +552,50 @@ class ProjectService:
             now.year - (1 if now.month <= 6 else 0), ((now.month - 6) % 12) or 12, 1
         )
 
-        # Query for monthly entity creation
+        # Query for monthly entity creation (project filtered)
         entity_growth_result = await self.repository.execute_query(
-            text(f"""
+            text("""
             SELECT 
                 strftime('%Y-%m', created_at) AS month,
                 COUNT(*) AS count
             FROM entity
-            WHERE created_at >= '{six_months_ago.isoformat()}'
+            WHERE created_at >= :six_months_ago AND project_id = :project_id
             GROUP BY month
             ORDER BY month
-        """)
+        """),
+            {"six_months_ago": six_months_ago.isoformat(), "project_id": project_id},
         )
         entity_growth = {row[0]: row[1] for row in entity_growth_result.fetchall()}
 
-        # Query for monthly observation creation
+        # Query for monthly observation creation (project filtered)
         observation_growth_result = await self.repository.execute_query(
-            text(f"""
+            text("""
             SELECT 
-                strftime('%Y-%m', created_at) AS month,
+                strftime('%Y-%m', entity.created_at) AS month,
                 COUNT(*) AS count
             FROM observation
             INNER JOIN entity ON observation.entity_id = entity.id
-            WHERE entity.created_at >= '{six_months_ago.isoformat()}'
+            WHERE entity.created_at >= :six_months_ago AND entity.project_id = :project_id
             GROUP BY month
             ORDER BY month
-        """)
+        """),
+            {"six_months_ago": six_months_ago.isoformat(), "project_id": project_id},
         )
         observation_growth = {row[0]: row[1] for row in observation_growth_result.fetchall()}
 
-        # Query for monthly relation creation
+        # Query for monthly relation creation (project filtered)
         relation_growth_result = await self.repository.execute_query(
-            text(f"""
+            text("""
             SELECT 
-                strftime('%Y-%m', created_at) AS month,
+                strftime('%Y-%m', entity.created_at) AS month,
                 COUNT(*) AS count
             FROM relation
             INNER JOIN entity ON relation.from_id = entity.id
-            WHERE entity.created_at >= '{six_months_ago.isoformat()}'
+            WHERE entity.created_at >= :six_months_ago AND entity.project_id = :project_id
             GROUP BY month
             ORDER BY month
-        """)
+        """),
+            {"six_months_ago": six_months_ago.isoformat(), "project_id": project_id},
         )
         relation_growth = {row[0]: row[1] for row in relation_growth_result.fetchall()}
 
@@ -597,4 +647,4 @@ class ProjectService:
             database_size=db_size_readable,
             watch_status=watch_status,
             timestamp=datetime.now(),
-        )
+        )

basic_memory/services/sync_status_service.py

@@ -0,0 +1,181 @@
+"""Simple sync status tracking service."""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Dict, Optional
+
+
+class SyncStatus(Enum):
+    """Status of sync operations."""
+
+    IDLE = "idle"
+    SCANNING = "scanning"
+    SYNCING = "syncing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    WATCHING = "watching"
+
+
+@dataclass
+class ProjectSyncStatus:
+    """Sync status for a single project."""
+
+    project_name: str
+    status: SyncStatus
+    message: str = ""
+    files_total: int = 0
+    files_processed: int = 0
+    error: Optional[str] = None
+
+
+class SyncStatusTracker:
+    """Global tracker for all sync operations."""
+
+    def __init__(self):
+        self._project_statuses: Dict[str, ProjectSyncStatus] = {}
+        self._global_status: SyncStatus = SyncStatus.IDLE
+
+    def start_project_sync(self, project_name: str, files_total: int = 0) -> None:
+        """Start tracking sync for a project."""
+        self._project_statuses[project_name] = ProjectSyncStatus(
+            project_name=project_name,
+            status=SyncStatus.SCANNING,
+            message="Scanning files",
+            files_total=files_total,
+            files_processed=0,
+        )
+        self._update_global_status()
+
+    def update_project_progress(  # pragma: no cover
+        self,
+        project_name: str,
+        status: SyncStatus,
+        message: str = "",
+        files_processed: int = 0,
+        files_total: Optional[int] = None,
+    ) -> None:
+        """Update progress for a project."""
+        if project_name not in self._project_statuses:  # pragma: no cover
+            return
+
+        project_status = self._project_statuses[project_name]
+        project_status.status = status
+        project_status.message = message
+        project_status.files_processed = files_processed
+
+        if files_total is not None:
+            project_status.files_total = files_total
+
+        self._update_global_status()
+
+    def complete_project_sync(self, project_name: str) -> None:
+        """Mark project sync as completed."""
+        if project_name in self._project_statuses:
+            self._project_statuses[project_name].status = SyncStatus.COMPLETED
+            self._project_statuses[project_name].message = "Sync completed"
+            self._update_global_status()
+
+    def fail_project_sync(self, project_name: str, error: str) -> None:
+        """Mark project sync as failed."""
+        if project_name in self._project_statuses:
+            self._project_statuses[project_name].status = SyncStatus.FAILED
+            self._project_statuses[project_name].error = error
+            self._update_global_status()
+
+    def start_project_watch(self, project_name: str) -> None:
+        """Mark project as watching for changes (steady state after sync)."""
+        if project_name in self._project_statuses:
+            self._project_statuses[project_name].status = SyncStatus.WATCHING
+            self._project_statuses[project_name].message = "Watching for changes"
+            self._update_global_status()
+        else:
+            # Create new status if project isn't tracked yet
+            self._project_statuses[project_name] = ProjectSyncStatus(
+                project_name=project_name,
+                status=SyncStatus.WATCHING,
+                message="Watching for changes",
+                files_total=0,
+                files_processed=0,
+            )
+            self._update_global_status()
+
+    def _update_global_status(self) -> None:
+        """Update global status based on project statuses."""
+        if not self._project_statuses:  # pragma: no cover
+            self._global_status = SyncStatus.IDLE
+            return
+
+        statuses = [p.status for p in self._project_statuses.values()]
+
+        if any(s == SyncStatus.FAILED for s in statuses):
+            self._global_status = SyncStatus.FAILED
+        elif any(s in (SyncStatus.SCANNING, SyncStatus.SYNCING) for s in statuses):
+            self._global_status = SyncStatus.SYNCING
+        elif all(s in (SyncStatus.COMPLETED, SyncStatus.WATCHING) for s in statuses):
+            self._global_status = SyncStatus.COMPLETED
+        else:
+            self._global_status = SyncStatus.SYNCING
+
+    @property
+    def global_status(self) -> SyncStatus:
+        """Get overall sync status."""
+        return self._global_status
+
+    @property
+    def is_syncing(self) -> bool:
+        """Check if any sync operation is in progress."""
+        return self._global_status in (SyncStatus.SCANNING, SyncStatus.SYNCING)
+
+    @property
+    def is_ready(self) -> bool:  # pragma: no cover
+        """Check if system is ready (no sync in progress)."""
+        return self._global_status in (SyncStatus.IDLE, SyncStatus.COMPLETED)
+
+    def get_project_status(self, project_name: str) -> Optional[ProjectSyncStatus]:
+        """Get status for a specific project."""
+        return self._project_statuses.get(project_name)
+
+    def get_all_projects(self) -> Dict[str, ProjectSyncStatus]:
+        """Get all project statuses."""
+        return self._project_statuses.copy()
+
+    def get_summary(self) -> str:  # pragma: no cover
+        """Get a user-friendly summary of sync status."""
+        if self._global_status == SyncStatus.IDLE:
+            return "✅ System ready"
+        elif self._global_status == SyncStatus.COMPLETED:
+            return "✅ All projects synced successfully"
+        elif self._global_status == SyncStatus.FAILED:
+            failed_projects = [
+                p.project_name
+                for p in self._project_statuses.values()
+                if p.status == SyncStatus.FAILED
+            ]
+            return f"❌ Sync failed for: {', '.join(failed_projects)}"
+        else:
+            active_projects = [
+                p.project_name
+                for p in self._project_statuses.values()
+                if p.status in (SyncStatus.SCANNING, SyncStatus.SYNCING)
+            ]
+            total_files = sum(p.files_total for p in self._project_statuses.values())
+            processed_files = sum(p.files_processed for p in self._project_statuses.values())
+
+            if total_files > 0:
+                progress_pct = (processed_files / total_files) * 100
+                return f"🔄 Syncing {len(active_projects)} projects ({processed_files}/{total_files} files, {progress_pct:.0f}%)"
+            else:
+                return f"🔄 Syncing {len(active_projects)} projects"
+
+    def clear_completed(self) -> None:
+        """Remove completed project statuses to clean up memory."""
+        self._project_statuses = {
+            name: status
+            for name, status in self._project_statuses.items()
+            if status.status != SyncStatus.COMPLETED
+        }
+        self._update_global_status()
+
+
+# Global sync status tracker instance
+sync_status_tracker = SyncStatusTracker()

basic_memory/sync/sync_service.py

@@ -17,6 +17,7 @@ from basic_memory.models import Entity
 from basic_memory.repository import EntityRepository, RelationRepository
 from basic_memory.services import EntityService, FileService
 from basic_memory.services.search_service import SearchService
+from basic_memory.services.sync_status_service import sync_status_tracker, SyncStatus
 
 
 @dataclass
@@ -80,23 +81,38 @@ class SyncService:
         self.search_service = search_service
         self.file_service = file_service
 
-    async def sync(self, directory: Path) -> SyncReport:
+    async def sync(self, directory: Path, project_name: Optional[str] = None) -> SyncReport:
         """Sync all files with database."""
 
         start_time = time.time()
         logger.info(f"Sync operation started for directory: {directory}")
 
+        # Start tracking sync for this project if project name provided
+        if project_name:
+            sync_status_tracker.start_project_sync(project_name)
+
         # initial paths from db to sync
         # path -> checksum
         report = await self.scan(directory)
 
-        # Initialize progress tracking if requested
+        # Update progress with file counts
+        if project_name:
+            sync_status_tracker.update_project_progress(
+                project_name=project_name,
+                status=SyncStatus.SYNCING,
+                message="Processing file changes",
+                files_total=report.total,
+                files_processed=0,
+            )
+
         # order of sync matters to resolve relations effectively
         logger.info(
             f"Sync changes detected: new_files={len(report.new)}, modified_files={len(report.modified)}, "
             + f"deleted_files={len(report.deleted)}, moved_files={len(report.moves)}"
         )
 
+        files_processed = 0
+
         # sync moves first
         for old_path, new_path in report.moves.items():
             # in the case where a file has been deleted and replaced by another file
@@ -109,19 +125,56 @@ class SyncService:
             else:
                 await self.handle_move(old_path, new_path)
 
+            files_processed += 1
+            if project_name:
+                sync_status_tracker.update_project_progress(  # pragma: no cover
+                    project_name=project_name,
+                    status=SyncStatus.SYNCING,
+                    message="Processing moves",
+                    files_processed=files_processed,
+                )
+
         # deleted next
         for path in report.deleted:
             await self.handle_delete(path)
+            files_processed += 1
+            if project_name:
+                sync_status_tracker.update_project_progress(  # pragma: no cover
+                    project_name=project_name,
+                    status=SyncStatus.SYNCING,
+                    message="Processing deletions",
+                    files_processed=files_processed,
+                )
 
         # then new and modified
         for path in report.new:
             await self.sync_file(path, new=True)
+            files_processed += 1
+            if project_name:
+                sync_status_tracker.update_project_progress(
+                    project_name=project_name,
+                    status=SyncStatus.SYNCING,
+                    message="Processing new files",
+                    files_processed=files_processed,
+                )
 
         for path in report.modified:
             await self.sync_file(path, new=False)
+            files_processed += 1
+            if project_name:
+                sync_status_tracker.update_project_progress(  # pragma: no cover
+                    project_name=project_name,
+                    status=SyncStatus.SYNCING,
+                    message="Processing modified files",
+                    files_processed=files_processed,
+                )
 
         await self.resolve_relations()
 
+        # Mark sync as completed
+        if project_name:
+            sync_status_tracker.complete_project_sync(project_name)
+
         duration_ms = int((time.time() - start_time) * 1000)
         logger.info(
             f"Sync operation completed: directory={directory}, total_changes={report.total}, duration_ms={duration_ms}"

{basic_memory-0.13.0b4.dist-info → basic_memory-0.13.0b5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: basic-memory
-Version: 0.13.0b4
+Version: 0.13.0b5
 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
@@ -25,10 +25,10 @@ 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