julee 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

julee/docs/sphinx_hcd/repositories/memory/accelerator.py

@@ -0,0 +1,86 @@
+"""Memory implementation of AcceleratorRepository."""
+
+import logging
+
+from ...domain.models.accelerator import Accelerator
+from ...domain.repositories.accelerator import AcceleratorRepository
+from .base import MemoryRepositoryMixin
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryAcceleratorRepository(
+    MemoryRepositoryMixin[Accelerator], AcceleratorRepository
+):
+    """In-memory implementation of AcceleratorRepository.
+
+    Accelerators are stored in a dictionary keyed by slug. This implementation
+    is used during Sphinx builds where accelerators are populated during doctree
+    processing and support incremental builds via docname tracking.
+    """
+
+    def __init__(self) -> None:
+        """Initialize with empty storage."""
+        self.storage: dict[str, Accelerator] = {}
+        self.entity_name = "Accelerator"
+        self.id_field = "slug"
+
+    async def get_by_status(self, status: str) -> list[Accelerator]:
+        """Get all accelerators with a specific status."""
+        status_normalized = status.lower().strip()
+        return [
+            accel
+            for accel in self.storage.values()
+            if accel.status_normalized == status_normalized
+        ]
+
+    async def get_by_docname(self, docname: str) -> list[Accelerator]:
+        """Get all accelerators defined in a specific document."""
+        return [accel for accel in self.storage.values() if accel.docname == docname]
+
+    async def clear_by_docname(self, docname: str) -> int:
+        """Remove all accelerators defined in a specific document."""
+        to_remove = [
+            slug for slug, accel in self.storage.items() if accel.docname == docname
+        ]
+        for slug in to_remove:
+            del self.storage[slug]
+        return len(to_remove)
+
+    async def get_by_integration(
+        self, integration_slug: str, relationship: str
+    ) -> list[Accelerator]:
+        """Get accelerators that have a relationship with an integration."""
+        result = []
+        for accel in self.storage.values():
+            if relationship == "sources_from":
+                if integration_slug in accel.get_sources_from_slugs():
+                    result.append(accel)
+            elif relationship == "publishes_to":
+                if integration_slug in accel.get_publishes_to_slugs():
+                    result.append(accel)
+        return result
+
+    async def get_dependents(self, accelerator_slug: str) -> list[Accelerator]:
+        """Get accelerators that depend on a specific accelerator."""
+        return [
+            accel
+            for accel in self.storage.values()
+            if accelerator_slug in accel.depends_on
+        ]
+
+    async def get_fed_by(self, accelerator_slug: str) -> list[Accelerator]:
+        """Get accelerators that feed into a specific accelerator."""
+        return [
+            accel
+            for accel in self.storage.values()
+            if accelerator_slug in accel.feeds_into
+        ]
+
+    async def get_all_statuses(self) -> set[str]:
+        """Get all unique statuses across all accelerators."""
+        return {
+            accel.status_normalized
+            for accel in self.storage.values()
+            if accel.status_normalized
+        }

julee/docs/sphinx_hcd/repositories/memory/app.py

@@ -0,0 +1,45 @@
+"""Memory implementation of AppRepository."""
+
+import logging
+
+from ...domain.models.app import App, AppType
+from ...domain.repositories.app import AppRepository
+from ...utils import normalize_name
+from .base import MemoryRepositoryMixin
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryAppRepository(MemoryRepositoryMixin[App], AppRepository):
+    """In-memory implementation of AppRepository.
+
+    Apps are stored in a dictionary keyed by slug. This implementation
+    is used during Sphinx builds where apps are populated at builder-inited
+    and queried during doctree processing.
+    """
+
+    def __init__(self) -> None:
+        """Initialize with empty storage."""
+        self.storage: dict[str, App] = {}
+        self.entity_name = "App"
+        self.id_field = "slug"
+
+    async def get_by_type(self, app_type: AppType) -> list[App]:
+        """Get all apps of a specific type."""
+        return [app for app in self.storage.values() if app.app_type == app_type]
+
+    async def get_by_name(self, name: str) -> App | None:
+        """Get an app by its display name (case-insensitive)."""
+        name_normalized = normalize_name(name)
+        for app in self.storage.values():
+            if app.name_normalized == name_normalized:
+                return app
+        return None
+
+    async def get_all_types(self) -> set[AppType]:
+        """Get all unique app types that have apps."""
+        return {app.app_type for app in self.storage.values()}
+
+    async def get_apps_with_accelerators(self) -> list[App]:
+        """Get all apps that have accelerators defined."""
+        return [app for app in self.storage.values() if app.accelerators]

julee/docs/sphinx_hcd/repositories/memory/base.py

@@ -0,0 +1,106 @@
+"""Memory repository base classes and mixins for sphinx_hcd.
+
+Provides common functionality for in-memory repository implementations,
+following julee patterns but simplified for sphinx_hcd's needs.
+"""
+
+import logging
+from typing import Any, Generic, TypeVar
+
+from pydantic import BaseModel
+
+T = TypeVar("T", bound=BaseModel)
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryRepositoryMixin(Generic[T]):
+    """Mixin providing common repository patterns for memory implementations.
+
+    Encapsulates common functionality used across all memory repository
+    implementations:
+    - Dictionary-based entity storage and retrieval
+    - Standardized logging patterns
+    - Generic CRUD operations
+
+    Classes using this mixin must provide:
+    - self.storage: dict[str, T] for entity storage
+    - self.entity_name: str for logging
+    - self.id_field: str naming the entity's ID field
+    """
+
+    storage: dict[str, T]
+    entity_name: str
+    id_field: str
+
+    def _get_entity_id(self, entity: T) -> str:
+        """Extract the entity ID from an entity instance."""
+        return getattr(entity, self.id_field)
+
+    async def get(self, entity_id: str) -> T | None:
+        """Retrieve an entity by ID."""
+        entity = self.storage.get(entity_id)
+        if entity is None:
+            logger.debug(
+                f"Memory{self.entity_name}Repository: {self.entity_name} not found",
+                extra={f"{self.entity_name.lower()}_id": entity_id},
+            )
+        return entity
+
+    async def get_many(self, entity_ids: list[str]) -> dict[str, T | None]:
+        """Retrieve multiple entities by ID."""
+        result: dict[str, T | None] = {}
+        for entity_id in entity_ids:
+            result[entity_id] = self.storage.get(entity_id)
+        return result
+
+    async def save(self, entity: T) -> None:
+        """Save an entity to storage."""
+        entity_id = self._get_entity_id(entity)
+        self.storage[entity_id] = entity
+        logger.debug(
+            f"Memory{self.entity_name}Repository: Saved {self.entity_name}",
+            extra={f"{self.entity_name.lower()}_id": entity_id},
+        )
+
+    async def list_all(self) -> list[T]:
+        """List all entities."""
+        return list(self.storage.values())
+
+    async def delete(self, entity_id: str) -> bool:
+        """Delete an entity by ID."""
+        if entity_id in self.storage:
+            del self.storage[entity_id]
+            logger.debug(
+                f"Memory{self.entity_name}Repository: Deleted {self.entity_name}",
+                extra={f"{self.entity_name.lower()}_id": entity_id},
+            )
+            return True
+        return False
+
+    async def clear(self) -> None:
+        """Remove all entities from storage."""
+        count = len(self.storage)
+        self.storage.clear()
+        logger.debug(
+            f"Memory{self.entity_name}Repository: Cleared {count} entities",
+        )
+
+    # Additional query methods that subclasses can use
+
+    async def find_by_field(self, field: str, value: Any) -> list[T]:
+        """Find all entities where field equals value."""
+        return [
+            entity
+            for entity in self.storage.values()
+            if getattr(entity, field, None) == value
+        ]
+
+    async def find_by_field_in(self, field: str, values: list[Any]) -> list[T]:
+        """Find all entities where field is in values."""
+        value_set = set(values)
+        return [
+            entity
+            for entity in self.storage.values()
+            if getattr(entity, field, None) in value_set
+        ]

julee/docs/sphinx_hcd/repositories/memory/code_info.py

@@ -0,0 +1,59 @@
+"""Memory implementation of CodeInfoRepository."""
+
+import logging
+
+from ...domain.models.code_info import BoundedContextInfo
+from ...domain.repositories.code_info import CodeInfoRepository
+from .base import MemoryRepositoryMixin
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryCodeInfoRepository(
+    MemoryRepositoryMixin[BoundedContextInfo], CodeInfoRepository
+):
+    """In-memory implementation of CodeInfoRepository.
+
+    Bounded context info is stored in a dictionary keyed by slug. This implementation
+    is used during Sphinx builds where code info is populated at builder-inited
+    by scanning src/ directories.
+    """
+
+    def __init__(self) -> None:
+        """Initialize with empty storage."""
+        self.storage: dict[str, BoundedContextInfo] = {}
+        self.entity_name = "BoundedContextInfo"
+        self.id_field = "slug"
+
+    async def get_by_code_dir(self, code_dir: str) -> BoundedContextInfo | None:
+        """Get bounded context info by its code directory name."""
+        for info in self.storage.values():
+            if info.code_dir == code_dir:
+                return info
+        return None
+
+    async def get_with_entities(self) -> list[BoundedContextInfo]:
+        """Get all bounded contexts that have domain entities."""
+        return [info for info in self.storage.values() if info.has_entities]
+
+    async def get_with_use_cases(self) -> list[BoundedContextInfo]:
+        """Get all bounded contexts that have use cases."""
+        return [info for info in self.storage.values() if info.has_use_cases]
+
+    async def get_with_infrastructure(self) -> list[BoundedContextInfo]:
+        """Get all bounded contexts that have infrastructure."""
+        return [info for info in self.storage.values() if info.has_infrastructure]
+
+    async def get_all_entity_names(self) -> set[str]:
+        """Get all unique entity class names across all bounded contexts."""
+        names: set[str] = set()
+        for info in self.storage.values():
+            names.update(info.get_entity_names())
+        return names
+
+    async def get_all_use_case_names(self) -> set[str]:
+        """Get all unique use case class names across all bounded contexts."""
+        names: set[str] = set()
+        for info in self.storage.values():
+            names.update(info.get_use_case_names())
+        return names

julee/docs/sphinx_hcd/repositories/memory/epic.py

@@ -0,0 +1,54 @@
+"""Memory implementation of EpicRepository."""
+
+import logging
+
+from ...domain.models.epic import Epic
+from ...domain.repositories.epic import EpicRepository
+from ...utils import normalize_name
+from .base import MemoryRepositoryMixin
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryEpicRepository(MemoryRepositoryMixin[Epic], EpicRepository):
+    """In-memory implementation of EpicRepository.
+
+    Epics are stored in a dictionary keyed by slug. This implementation
+    is used during Sphinx builds where epics are populated during doctree
+    processing and support incremental builds via docname tracking.
+    """
+
+    def __init__(self) -> None:
+        """Initialize with empty storage."""
+        self.storage: dict[str, Epic] = {}
+        self.entity_name = "Epic"
+        self.id_field = "slug"
+
+    async def get_by_docname(self, docname: str) -> list[Epic]:
+        """Get all epics defined in a specific document."""
+        return [epic for epic in self.storage.values() if epic.docname == docname]
+
+    async def clear_by_docname(self, docname: str) -> int:
+        """Remove all epics defined in a specific document."""
+        to_remove = [
+            slug for slug, epic in self.storage.items() if epic.docname == docname
+        ]
+        for slug in to_remove:
+            del self.storage[slug]
+        return len(to_remove)
+
+    async def get_with_story_ref(self, story_title: str) -> list[Epic]:
+        """Get epics that contain a specific story."""
+        story_normalized = normalize_name(story_title)
+        return [
+            epic
+            for epic in self.storage.values()
+            if any(normalize_name(ref) == story_normalized for ref in epic.story_refs)
+        ]
+
+    async def get_all_story_refs(self) -> set[str]:
+        """Get all unique story references across all epics."""
+        refs: set[str] = set()
+        for epic in self.storage.values():
+            refs.update(normalize_name(ref) for ref in epic.story_refs)
+        return refs

julee/docs/sphinx_hcd/repositories/memory/integration.py

@@ -0,0 +1,70 @@
+"""Memory implementation of IntegrationRepository."""
+
+import logging
+
+from ...domain.models.integration import Direction, Integration
+from ...domain.repositories.integration import IntegrationRepository
+from ...utils import normalize_name
+from .base import MemoryRepositoryMixin
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryIntegrationRepository(
+    MemoryRepositoryMixin[Integration], IntegrationRepository
+):
+    """In-memory implementation of IntegrationRepository.
+
+    Integrations are stored in a dictionary keyed by slug. This implementation
+    is used during Sphinx builds where integrations are populated at builder-inited
+    and queried during doctree processing.
+    """
+
+    def __init__(self) -> None:
+        """Initialize with empty storage."""
+        self.storage: dict[str, Integration] = {}
+        self.entity_name = "Integration"
+        self.id_field = "slug"
+
+    async def get_by_direction(self, direction: Direction) -> list[Integration]:
+        """Get all integrations with a specific direction."""
+        return [
+            integration
+            for integration in self.storage.values()
+            if integration.direction == direction
+        ]
+
+    async def get_by_module(self, module: str) -> Integration | None:
+        """Get an integration by its module name."""
+        for integration in self.storage.values():
+            if integration.module == module:
+                return integration
+        return None
+
+    async def get_by_name(self, name: str) -> Integration | None:
+        """Get an integration by its display name (case-insensitive)."""
+        name_normalized = normalize_name(name)
+        for integration in self.storage.values():
+            if integration.name_normalized == name_normalized:
+                return integration
+        return None
+
+    async def get_all_directions(self) -> set[Direction]:
+        """Get all unique directions that have integrations."""
+        return {integration.direction for integration in self.storage.values()}
+
+    async def get_with_dependencies(self) -> list[Integration]:
+        """Get all integrations that have external dependencies."""
+        return [
+            integration
+            for integration in self.storage.values()
+            if integration.depends_on
+        ]
+
+    async def get_by_dependency(self, dep_name: str) -> list[Integration]:
+        """Get all integrations that depend on a specific external system."""
+        return [
+            integration
+            for integration in self.storage.values()
+            if integration.has_dependency(dep_name)
+        ]

julee/docs/sphinx_hcd/repositories/memory/journey.py

@@ -0,0 +1,96 @@
+"""Memory implementation of JourneyRepository."""
+
+import logging
+
+from ...domain.models.journey import Journey
+from ...domain.repositories.journey import JourneyRepository
+from ...utils import normalize_name
+from .base import MemoryRepositoryMixin
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryJourneyRepository(MemoryRepositoryMixin[Journey], JourneyRepository):
+    """In-memory implementation of JourneyRepository.
+
+    Journeys are stored in a dictionary keyed by slug. This implementation
+    is used during Sphinx builds where journeys are populated during doctree
+    processing and support incremental builds via docname tracking.
+    """
+
+    def __init__(self) -> None:
+        """Initialize with empty storage."""
+        self.storage: dict[str, Journey] = {}
+        self.entity_name = "Journey"
+        self.id_field = "slug"
+
+    async def get_by_persona(self, persona: str) -> list[Journey]:
+        """Get all journeys for a persona."""
+        persona_normalized = normalize_name(persona)
+        return [
+            journey
+            for journey in self.storage.values()
+            if journey.persona_normalized == persona_normalized
+        ]
+
+    async def get_by_docname(self, docname: str) -> list[Journey]:
+        """Get all journeys defined in a specific document."""
+        return [
+            journey for journey in self.storage.values() if journey.docname == docname
+        ]
+
+    async def clear_by_docname(self, docname: str) -> int:
+        """Remove all journeys defined in a specific document."""
+        to_remove = [
+            slug for slug, journey in self.storage.items() if journey.docname == docname
+        ]
+        for slug in to_remove:
+            del self.storage[slug]
+        return len(to_remove)
+
+    async def get_dependents(self, journey_slug: str) -> list[Journey]:
+        """Get journeys that depend on a specific journey."""
+        return [
+            journey
+            for journey in self.storage.values()
+            if journey.has_dependency(journey_slug)
+        ]
+
+    async def get_dependencies(self, journey_slug: str) -> list[Journey]:
+        """Get journeys that a specific journey depends on."""
+        journey = self.storage.get(journey_slug)
+        if not journey:
+            return []
+        return [
+            self.storage[dep_slug]
+            for dep_slug in journey.depends_on
+            if dep_slug in self.storage
+        ]
+
+    async def get_all_personas(self) -> set[str]:
+        """Get all unique personas across all journeys."""
+        return {
+            journey.persona_normalized
+            for journey in self.storage.values()
+            if journey.persona_normalized
+        }
+
+    async def get_with_story_ref(self, story_title: str) -> list[Journey]:
+        """Get journeys that reference a specific story."""
+        story_normalized = normalize_name(story_title)
+        return [
+            journey
+            for journey in self.storage.values()
+            if any(
+                normalize_name(ref) == story_normalized
+                for ref in journey.get_story_refs()
+            )
+        ]
+
+    async def get_with_epic_ref(self, epic_slug: str) -> list[Journey]:
+        """Get journeys that reference a specific epic."""
+        return [
+            journey
+            for journey in self.storage.values()
+            if epic_slug in journey.get_epic_refs()
+        ]

julee/docs/sphinx_hcd/repositories/memory/story.py

@@ -0,0 +1,63 @@
+"""Memory implementation of StoryRepository."""
+
+import logging
+
+from ...domain.models.story import Story
+from ...domain.repositories.story import StoryRepository
+from ...utils import normalize_name
+from .base import MemoryRepositoryMixin
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryStoryRepository(MemoryRepositoryMixin[Story], StoryRepository):
+    """In-memory implementation of StoryRepository.
+
+    Stories are stored in a dictionary keyed by slug. This implementation
+    is used during Sphinx builds where stories are populated at builder-inited
+    and queried during doctree processing.
+    """
+
+    def __init__(self) -> None:
+        """Initialize with empty storage."""
+        self.storage: dict[str, Story] = {}
+        self.entity_name = "Story"
+        self.id_field = "slug"
+
+    async def get_by_app(self, app_slug: str) -> list[Story]:
+        """Get all stories for an application."""
+        app_normalized = normalize_name(app_slug)
+        return [
+            story
+            for story in self.storage.values()
+            if story.app_normalized == app_normalized
+        ]
+
+    async def get_by_persona(self, persona: str) -> list[Story]:
+        """Get all stories for a persona."""
+        persona_normalized = normalize_name(persona)
+        return [
+            story
+            for story in self.storage.values()
+            if story.persona_normalized == persona_normalized
+        ]
+
+    async def get_by_feature_title(self, feature_title: str) -> Story | None:
+        """Get a story by its feature title."""
+        title_normalized = normalize_name(feature_title)
+        for story in self.storage.values():
+            if normalize_name(story.feature_title) == title_normalized:
+                return story
+        return None
+
+    async def get_apps_with_stories(self) -> set[str]:
+        """Get the set of app slugs that have stories."""
+        return {story.app_slug for story in self.storage.values()}
+
+    async def get_all_personas(self) -> set[str]:
+        """Get all unique personas across all stories."""
+        return {
+            story.persona_normalized
+            for story in self.storage.values()
+            if story.persona_normalized != "unknown"
+        }

julee/docs/sphinx_hcd/sphinx/__init__.py

@@ -0,0 +1,28 @@
+"""Sphinx application layer for sphinx_hcd.
+
+Contains Sphinx-specific code:
+- adapters.py: SyncRepositoryAdapter for sync access to async repos
+- context.py: HCDContext for unified repository access
+- initialization.py: Builder-inited handlers
+- directives/: Sphinx directive implementations
+- event_handlers/: Sphinx lifecycle event handlers
+"""
+
+from .adapters import SyncRepositoryAdapter
+from .context import (
+    HCDContext,
+    ensure_hcd_context,
+    get_hcd_context,
+    set_hcd_context,
+)
+from .initialization import initialize_hcd_context, purge_doc_from_context
+
+__all__ = [
+    "HCDContext",
+    "SyncRepositoryAdapter",
+    "ensure_hcd_context",
+    "get_hcd_context",
+    "initialize_hcd_context",
+    "purge_doc_from_context",
+    "set_hcd_context",
+]