agentpool 2.1.9__py3-none-any.whl → 2.5.0__py3-none-any.whl

agentpool_storage/project_store.py

@@ -0,0 +1,325 @@
+"""High-level project store with auto-detection."""
+
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from agentpool.log import get_logger
+from agentpool.sessions.models import ProjectData
+from agentpool.utils.now import get_now
+
+
+if TYPE_CHECKING:
+    from agentpool.storage.manager import StorageManager
+
+logger = get_logger(__name__)
+
+# Config file names to search for in .agentpool/ directory
+CONFIG_FILENAMES = ["config.yml", "config.yaml", "config.json", "config.toml"]
+
+
+def resolve_config(project: ProjectData | None = None, cwd: str | None = None) -> str | None:
+    """Resolve config path using project settings and global fallback.
+
+    Resolution order:
+    1. Project's explicit config_path (if set)
+    2. .agentpool/config.yml in project worktree (auto-discovered)
+    3. Global default from ConfigStore (CLI fallback)
+    4. None (use built-in defaults)
+
+    Args:
+        project: Project data (optional)
+        cwd: Current working directory for discovery if no project
+
+    Returns:
+        Path to config file, or None if no config found
+    """
+    # 1. Project-specific explicit config
+    if project and project.config_path:
+        config_path = Path(project.config_path)
+        if config_path.is_file():
+            return str(config_path)
+        logger.warning("Project config not found", path=project.config_path)
+
+    # 2. Auto-discover in project worktree
+    worktree = project.worktree if project else cwd
+    if worktree:
+        local_config = discover_config_path(worktree)
+        if local_config:
+            return local_config
+
+    # 3. Global default from ConfigStore
+    try:
+        from agentpool_cli.store import ConfigStore
+
+        config_store = ConfigStore()
+        if active := config_store.get_active():
+            config_path = Path(active.path)
+            if config_path.is_file():
+                return str(config_path)
+            logger.warning("Active config not found", path=active.path)
+    except ImportError:
+        # CLI not installed, skip fallback
+        pass
+    except Exception:
+        logger.exception("Error loading ConfigStore")
+
+    # 4. No config found
+    return None
+
+
+def detect_project_root(cwd: str) -> tuple[str, str | None]:
+    """Walk up directory tree to find VCS root or use cwd.
+
+    Args:
+        cwd: Current working directory
+
+    Returns:
+        Tuple of (worktree_path, vcs_type).
+        vcs_type is "git", "hg", or None if no VCS found.
+    """
+    path = Path(cwd).resolve()
+    for parent in [path, *path.parents]:
+        if (parent / ".git").exists():
+            return str(parent), "git"
+        if (parent / ".hg").exists():
+            return str(parent), "hg"
+    # No VCS found, use the original directory
+    return str(path), None
+
+
+def generate_project_id(worktree: str) -> str:
+    """Generate stable hash of canonical worktree path.
+
+    Args:
+        worktree: Absolute path to project root
+
+    Returns:
+        40-character hex string (SHA1 hash)
+    """
+    canonical = str(Path(worktree).resolve())
+    return hashlib.sha1(canonical.encode()).hexdigest()
+
+
+def discover_config_path(worktree: str) -> str | None:
+    """Search for config file in .agentpool/ directory.
+
+    Args:
+        worktree: Project root path
+
+    Returns:
+        Path to config file if found, None otherwise
+    """
+    config_dir = Path(worktree) / ".agentpool"
+    if not config_dir.is_dir():
+        return None
+
+    for filename in CONFIG_FILENAMES:
+        config_path = config_dir / filename
+        if config_path.is_file():
+            return str(config_path)
+    return None
+
+
+class ProjectStore:
+    """High-level API for project management.
+
+    Provides:
+    - Auto-detection of project root from cwd
+    - Auto-creation of projects
+    - Config file discovery
+    - Convenient lookup methods
+    """
+
+    def __init__(self, storage: StorageManager) -> None:
+        """Initialize project store.
+
+        Args:
+            storage: Storage manager for persistence
+        """
+        self.storage = storage
+
+    async def get_or_create(self, cwd: str) -> ProjectData:
+        """Get existing project or create one for the given directory.
+
+        Detects VCS root, generates project ID, discovers config,
+        and creates/updates the project.
+
+        Args:
+            cwd: Current working directory
+
+        Returns:
+            ProjectData for the detected/created project
+        """
+        # Detect project root and VCS
+        worktree, vcs = detect_project_root(cwd)
+
+        # Check if project already exists
+        existing = await self.storage.get_project_by_worktree(worktree)
+        if existing:
+            # Update last_active and return
+            await self.storage.touch_project(existing.project_id)
+            return existing.touch()
+
+        # Create new project
+        project_id = generate_project_id(worktree)
+        config_path = discover_config_path(worktree)
+
+        project = ProjectData(
+            project_id=project_id,
+            worktree=worktree,
+            name=None,  # Can be set later
+            vcs=vcs,
+            config_path=config_path,
+            created_at=get_now(),
+            last_active=get_now(),
+            settings={},
+        )
+
+        await self.storage.save_project(project)
+        logger.info(
+            "Created project",
+            project_id=project_id,
+            worktree=worktree,
+            vcs=vcs,
+            config_path=config_path,
+        )
+        return project
+
+    async def get_by_cwd(self, cwd: str) -> ProjectData | None:
+        """Get project for the given directory without creating.
+
+        Args:
+            cwd: Current working directory
+
+        Returns:
+            ProjectData if found, None otherwise
+        """
+        worktree, _ = detect_project_root(cwd)
+        return await self.storage.get_project_by_worktree(worktree)
+
+    async def get_by_name(self, name: str) -> ProjectData | None:
+        """Get project by friendly name.
+
+        Args:
+            name: Project name
+
+        Returns:
+            ProjectData if found, None otherwise
+        """
+        return await self.storage.get_project_by_name(name)
+
+    async def get_by_id(self, project_id: str) -> ProjectData | None:
+        """Get project by ID.
+
+        Args:
+            project_id: Project identifier
+
+        Returns:
+            ProjectData if found, None otherwise
+        """
+        return await self.storage.get_project(project_id)
+
+    async def list_recent(self, limit: int = 20) -> list[ProjectData]:
+        """List recent projects ordered by last_active.
+
+        Args:
+            limit: Maximum number of projects to return
+
+        Returns:
+            List of projects
+        """
+        projects = await self.storage.list_projects(limit=limit)
+        return projects if projects is not None else []
+
+    async def set_name(self, project_id: str, name: str) -> ProjectData | None:
+        """Set friendly name for a project.
+
+        Args:
+            project_id: Project identifier
+            name: New name for the project
+
+        Returns:
+            Updated ProjectData, or None if project not found
+        """
+        project = await self.storage.get_project(project_id)
+        if not project:
+            return None
+
+        updated = project.model_copy(update={"name": name, "last_active": get_now()})
+        await self.storage.save_project(updated)
+        return updated
+
+    async def set_config_path(self, project_id: str, config_path: str | None) -> ProjectData | None:
+        """Set or clear config path for a project.
+
+        Args:
+            project_id: Project identifier
+            config_path: Path to config file, or None to use auto-discovery
+
+        Returns:
+            Updated ProjectData, or None if project not found
+        """
+        project = await self.storage.get_project(project_id)
+        if not project:
+            return None
+
+        updated = project.model_copy(update={"config_path": config_path, "last_active": get_now()})
+        await self.storage.save_project(updated)
+        return updated
+
+    async def update_settings(self, project_id: str, **settings: object) -> ProjectData | None:
+        """Update project-specific settings.
+
+        Args:
+            project_id: Project identifier
+            **settings: Settings to update
+
+        Returns:
+            Updated ProjectData, or None if project not found
+        """
+        project = await self.storage.get_project(project_id)
+        if not project:
+            return None
+
+        updated = project.with_settings(**settings)
+        await self.storage.save_project(updated)
+        return updated
+
+    async def delete(self, project_id: str) -> bool:
+        """Delete a project.
+
+        Args:
+            project_id: Project identifier
+
+        Returns:
+            True if deleted, False if not found
+        """
+        result = await self.storage.delete_project(project_id)
+        return bool(result)
+
+    async def refresh_config(self, project_id: str) -> ProjectData | None:
+        """Re-discover config file for a project.
+
+        Useful after user adds .agentpool/config.yml to their project.
+
+        Args:
+            project_id: Project identifier
+
+        Returns:
+            Updated ProjectData, or None if project not found
+        """
+        project = await self.storage.get_project(project_id)
+        if not project:
+            return None
+
+        config_path = discover_config_path(project.worktree)
+        if config_path != project.config_path:
+            updated = project.model_copy(
+                update={"config_path": config_path, "last_active": get_now()}
+            )
+            await self.storage.save_project(updated)
+            return updated
+        return project

agentpool_storage/session_store.py

@@ -5,10 +5,6 @@ from __future__ import annotations
 from datetime import timedelta
 from typing import TYPE_CHECKING, Any, Self
 
-from sqlalchemy import delete, select
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlmodel import SQLModel
-
 from agentpool.log import get_logger
 from agentpool.sessions.models import SessionData
 from agentpool.utils.now import get_now
@@ -45,6 +41,8 @@ class SQLSessionStore:
 
     async def __aenter__(self) -> Self:
         """Initialize database connection and create tables."""
+        from sqlmodel import SQLModel
+
         self._engine = self._config.get_engine()
 
         async with self._engine.begin() as conn:
@@ -95,7 +93,9 @@ class SQLSessionStore:
             agent_name=data.agent_name,
             conversation_id=data.conversation_id,
             pool_id=data.pool_id,
-            title=data.title,
+            project_id=data.project_id,
+            parent_id=data.parent_id,
+            version=data.version,
             cwd=data.cwd,
             created_at=data.created_at,
             last_active=data.last_active,
@@ -109,7 +109,9 @@ class SQLSessionStore:
             agent_name=row.agent_name,
             conversation_id=row.conversation_id,
             pool_id=row.pool_id,
-            title=row.title,
+            project_id=row.project_id,
+            parent_id=row.parent_id,
+            version=row.version,
             cwd=row.cwd,
             created_at=row.created_at,
             last_active=row.last_active,
@@ -124,6 +126,9 @@ class SQLSessionStore:
         Args:
             data: Session data to persist
         """
+        from sqlalchemy import delete
+        from sqlalchemy.ext.asyncio import AsyncSession
+
         engine = self._get_engine()
 
         async with AsyncSession(engine) as session:
@@ -146,6 +151,9 @@ class SQLSessionStore:
         Returns:
             Session data if found, None otherwise
         """
+        from sqlalchemy import select
+        from sqlalchemy.ext.asyncio import AsyncSession
+
         engine = self._get_engine()
 
         async with AsyncSession(engine) as session:
@@ -167,6 +175,9 @@ class SQLSessionStore:
         Returns:
             True if session was deleted, False if not found
         """
+        from sqlalchemy import delete
+        from sqlalchemy.ext.asyncio import AsyncSession
+
         engine = self._get_engine()
 
         async with AsyncSession(engine) as session:
@@ -193,6 +204,9 @@ class SQLSessionStore:
         Returns:
             List of session IDs
         """
+        from sqlalchemy import select
+        from sqlalchemy.ext.asyncio import AsyncSession
+
         engine = self._get_engine()
 
         async with AsyncSession(engine) as session:
@@ -217,6 +231,9 @@ class SQLSessionStore:
         Returns:
             Number of sessions removed
         """
+        from sqlalchemy import delete
+        from sqlalchemy.ext.asyncio import AsyncSession
+
         engine = self._get_engine()
         cutoff = get_now() - timedelta(hours=max_age_hours)
 
@@ -244,6 +261,9 @@ class SQLSessionStore:
         Returns:
             List of session data objects
         """
+        from sqlalchemy import select
+        from sqlalchemy.ext.asyncio import AsyncSession
+
         engine = self._get_engine()
 
         async with AsyncSession(engine) as session:

agentpool_storage/sql_provider/__init__.py

@@ -4,11 +4,12 @@ from __future__ import annotations
 
 from agentpool_storage.sql_provider.sql_provider import SQLModelProvider
 from agentpool_storage.sql_provider.models import (
+    CommandHistory,
     Conversation,
+    ConversationLog,
     Message,
-    CommandHistory,
     MessageLog,
-    ConversationLog,
+    Project,
 )
 
 __all__ = [
@@ -17,5 +18,6 @@ __all__ = [
     "ConversationLog",
     "Message",
     "MessageLog",
+    "Project",
     "SQLModelProvider",
 ]

agentpool_storage/sql_provider/models.py

@@ -127,6 +127,9 @@ class Message(AsyncAttrs, SQLModel, table=True):
     conversation_id: str = Field(index=True)
     """ID of the conversation this message belongs to"""
 
+    parent_id: str | None = Field(default=None, index=True)
+    """ID of the parent message for tree-structured conversations."""
+
     timestamp: datetime = Field(
         sa_column=Column(UTCDateTime, default=get_now), default_factory=get_now
     )
@@ -201,6 +204,15 @@ class Session(AsyncAttrs, SQLModel, table=True):
     pool_id: str | None = Field(default=None, index=True)
     """Optional pool/manifest identifier for multi-pool setups."""
 
+    project_id: str | None = Field(default=None, index=True)
+    """Project identifier (e.g., for OpenCode compatibility)."""
+
+    parent_id: str | None = Field(default=None, index=True)
+    """Parent session ID for forked sessions."""
+
+    version: str = Field(default="1")
+    """Session version string."""
+
     title: str | None = Field(default=None, index=True)
     """AI-generated or user-provided title for the conversation."""
 
@@ -225,6 +237,42 @@ class Session(AsyncAttrs, SQLModel, table=True):
     model_config = SQLModelConfig(use_attribute_docstrings=True)  # pyright: ignore[reportCallIssue]
 
 
+class Project(AsyncAttrs, SQLModel, table=True):
+    """Database model for project/worktree tracking."""
+
+    project_id: str = Field(primary_key=True)
+    """Unique identifier (hash of canonical worktree path)."""
+
+    worktree: str = Field(sa_column=Column(Text, index=True, unique=True))
+    """Absolute path to the project root/worktree."""
+
+    name: str | None = Field(default=None, index=True)
+    """Optional friendly name for the project."""
+
+    vcs: str | None = Field(default=None)
+    """Version control system type (git, hg, or None)."""
+
+    config_path: str | None = Field(default=None, sa_column=Column(Text))
+    """Path to the project's config file, or None for auto-discovery."""
+
+    created_at: datetime = Field(
+        sa_column=Column(UTCDateTime, index=True),
+        default_factory=get_now,
+    )
+    """When the project was first registered."""
+
+    last_active: datetime = Field(
+        sa_column=Column(UTCDateTime, index=True),
+        default_factory=get_now,
+    )
+    """Last activity timestamp."""
+
+    settings_json: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
+    """Project-specific settings overrides."""
+
+    model_config = SQLModelConfig(use_attribute_docstrings=True)  # pyright: ignore[reportCallIssue]
+
+
 class Conversation(AsyncAttrs, SQLModel, table=True):
     """Database model for conversations."""