agentpool 2.1.9__py3-none-any.whl → 2.2.3__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

@@ -95,6 +95,9 @@ class SQLSessionStore:
             agent_name=data.agent_name,
             conversation_id=data.conversation_id,
             pool_id=data.pool_id,
+            project_id=data.project_id,
+            parent_id=data.parent_id,
+            version=data.version,
             title=data.title,
             cwd=data.cwd,
             created_at=data.created_at,
@@ -109,6 +112,9 @@ class SQLSessionStore:
             agent_name=row.agent_name,
             conversation_id=row.conversation_id,
             pool_id=row.pool_id,
+            project_id=row.project_id,
+            parent_id=row.parent_id,
+            version=row.version,
             title=row.title,
             cwd=row.cwd,
             created_at=row.created_at,

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."""
 

agentpool_storage/sql_provider/sql_provider.py

@@ -15,7 +15,12 @@ from agentpool.utils.now import get_now
 from agentpool.utils.parse_time import parse_time_period
 from agentpool_storage.base import StorageProvider
 from agentpool_storage.models import QueryFilters
-from agentpool_storage.sql_provider.models import CommandHistory, Conversation, Message
+from agentpool_storage.sql_provider.models import (
+    CommandHistory,
+    Conversation,
+    Message,
+    Project,
+)
 from agentpool_storage.sql_provider.utils import (
     build_message_query,
     format_conversation,
@@ -33,6 +38,7 @@ if TYPE_CHECKING:
 
     from agentpool.common_types import JsonValue
     from agentpool.messaging import ChatMessage
+    from agentpool.sessions.models import ProjectData
     from agentpool_config.session import SessionQuery
     from agentpool_config.storage import SQLStorageConfig
     from agentpool_storage.models import ConversationData, StatsFilters
@@ -120,6 +126,7 @@ class SQLModelProvider(StorageProvider):
         content: str,
         role: str,
         name: str | None = None,
+        parent_id: str | None = None,
         cost_info: TokenCost | None = None,
         model: str | None = None,
         response_time: float | None = None,
@@ -138,6 +145,7 @@ class SQLModelProvider(StorageProvider):
             msg = Message(
                 conversation_id=conversation_id,
                 id=message_id,
+                parent_id=parent_id,
                 content=content,
                 role=role,
                 name=name,
@@ -442,3 +450,128 @@ class SQLModelProvider(StorageProvider):
         msg_count = len(msg_result.scalars().all())
 
         return conv_count, msg_count
+
+    async def delete_conversation_messages(
+        self,
+        conversation_id: str,
+    ) -> int:
+        """Delete all messages for a conversation."""
+        from sqlalchemy import delete, func
+
+        async with AsyncSession(self.engine) as session:
+            # First count messages to return
+            count_result = await session.execute(
+                select(func.count()).where(Message.conversation_id == conversation_id)
+            )
+            count = count_result.scalar() or 0
+
+            # Then delete
+            await session.execute(
+                delete(Message).where(Message.conversation_id == conversation_id)  # type: ignore[arg-type]
+            )
+            await session.commit()
+            return count
+
+    # Project methods
+
+    def _to_project_data(self, row: Project) -> ProjectData:
+        """Convert database model to ProjectData."""
+        from agentpool.sessions.models import ProjectData
+
+        return ProjectData(
+            project_id=row.project_id,
+            worktree=row.worktree,
+            name=row.name,
+            vcs=row.vcs,
+            config_path=row.config_path,
+            created_at=row.created_at,
+            last_active=row.last_active,
+            settings=row.settings_json or {},
+        )
+
+    def _to_project_model(self, data: ProjectData) -> Project:
+        """Convert ProjectData to database model."""
+        return Project(
+            project_id=data.project_id,
+            worktree=data.worktree,
+            name=data.name,
+            vcs=data.vcs,
+            config_path=data.config_path,
+            created_at=data.created_at,
+            last_active=data.last_active,
+            settings_json=data.settings,
+        )
+
+    async def save_project(self, project: ProjectData) -> None:
+        """Save or update a project."""
+        from sqlalchemy import delete
+
+        async with AsyncSession(self.engine) as session:
+            # Delete existing if present (upsert via delete+insert)
+            stmt = delete(Project).where(Project.project_id == project.project_id)  # type: ignore[arg-type]
+            await session.execute(stmt)
+
+            # Insert new/updated
+            db_project = self._to_project_model(project)
+            session.add(db_project)
+            await session.commit()
+            logger.debug("Saved project", project_id=project.project_id)
+
+    async def get_project(self, project_id: str) -> ProjectData | None:
+        """Get a project by ID."""
+        async with AsyncSession(self.engine) as session:
+            stmt = select(Project).where(Project.project_id == project_id)
+            result = await session.execute(stmt)
+            row = result.scalars().first()
+            return self._to_project_data(row) if row else None
+
+    async def get_project_by_worktree(self, worktree: str) -> ProjectData | None:
+        """Get a project by worktree path."""
+        async with AsyncSession(self.engine) as session:
+            stmt = select(Project).where(Project.worktree == worktree)
+            result = await session.execute(stmt)
+            row = result.scalars().first()
+            return self._to_project_data(row) if row else None
+
+    async def get_project_by_name(self, name: str) -> ProjectData | None:
+        """Get a project by friendly name."""
+        async with AsyncSession(self.engine) as session:
+            stmt = select(Project).where(Project.name == name)
+            result = await session.execute(stmt)
+            row = result.scalars().first()
+            return self._to_project_data(row) if row else None
+
+    async def list_projects(self, limit: int | None = None) -> list[ProjectData]:
+        """List all projects, ordered by last_active descending."""
+        async with AsyncSession(self.engine) as session:
+            stmt = select(Project).order_by(desc(Project.last_active))
+            if limit is not None:
+                stmt = stmt.limit(limit)
+            result = await session.execute(stmt)
+            return [self._to_project_data(row) for row in result.scalars().all()]
+
+    async def delete_project(self, project_id: str) -> bool:
+        """Delete a project."""
+        from sqlalchemy import delete
+
+        async with AsyncSession(self.engine) as session:
+            stmt = delete(Project).where(Project.project_id == project_id)  # type: ignore[arg-type]
+            result = await session.execute(stmt)
+            await session.commit()
+            deleted: bool = result.rowcount > 0  # type: ignore[attr-defined]
+            if deleted:
+                logger.debug("Deleted project", project_id=project_id)
+            return deleted
+
+    async def touch_project(self, project_id: str) -> None:
+        """Update project's last_active timestamp."""
+        from sqlalchemy import update
+
+        async with AsyncSession(self.engine) as session:
+            stmt = (
+                update(Project)
+                .where(Project.project_id == project_id)  # type: ignore[arg-type]
+                .values(last_active=get_now())
+            )
+            await session.execute(stmt)
+            await session.commit()

agentpool_storage/sql_provider/utils.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import contextlib
 from datetime import datetime
 from decimal import Decimal
 from typing import TYPE_CHECKING, Any
@@ -101,9 +102,14 @@ def auto_migrate_columns(sync_conn: Any, dialect: Any) -> None:
     from sqlmodel import SQLModel
 
     inspector = inspect(sync_conn)
+    existing_tables = set(inspector.get_table_names())
 
     # For each table in our models
     for table_name, table in SQLModel.metadata.tables.items():
+        # Skip tables that don't exist yet (they'll be created fresh)
+        if table_name not in existing_tables:
+            continue
+
         existing = {col["name"] for col in inspector.get_columns(table_name)}
 
         # For each column in model that doesn't exist in DB
@@ -116,7 +122,9 @@ def auto_migrate_columns(sync_conn: Any, dialect: Any) -> None:
                 sql = (
                     f"ALTER TABLE {table_name} ADD COLUMN {col.name} {type_sql}{nullable}{default}"
                 )
-                sync_conn.execute(text(sql))
+                # Column may already exist (race condition or stale inspector cache)
+                with contextlib.suppress(Exception):
+                    sync_conn.execute(text(sql))
 
 
 def parse_model_info(model: str | None) -> tuple[str | None, str | None]:
@@ -222,6 +230,7 @@ def format_conversation(
                     },
                     cost=float(msg.cost_info.total_cost) if msg.cost_info else None,
                     response_time=msg.response_time,
+                    parent_id=msg.parent_id,
                 )
                 for msg in chat_messages
             ],

agentpool_storage/text_log_provider.py

@@ -196,6 +196,7 @@ class TextLogProvider(StorageProvider):
         provider_response_id: str | None = None,
         messages: str | None = None,
         finish_reason: str | None = None,
+        parent_id: str | None = None,
     ) -> None:
         """Store message and update log."""
         entry = {

agentpool_toolsets/builtin/__init__.py

@@ -4,30 +4,22 @@ from __future__ import annotations
 
 
 # Import provider classes
-from agentpool_toolsets.builtin.agent_management import AgentManagementTools
 from agentpool_toolsets.builtin.code import CodeTools
 from agentpool_toolsets.builtin.debug import DebugTools
 from agentpool_toolsets.builtin.execution_environment import ExecutionEnvironmentTools
-from agentpool_toolsets.builtin.history import HistoryTools
-from agentpool_toolsets.builtin.integration import IntegrationTools
 from agentpool_toolsets.builtin.skills import SkillsTools
 from agentpool_toolsets.builtin.subagent_tools import SubagentTools
-from agentpool_toolsets.builtin.tool_management import ToolManagementTools
 from agentpool_toolsets.builtin.user_interaction import UserInteractionTools
 from agentpool_toolsets.builtin.workers import WorkersTools
 
 
 __all__ = [
     # Provider classes
-    "AgentManagementTools",
     "CodeTools",
     "DebugTools",
     "ExecutionEnvironmentTools",
-    "HistoryTools",
-    "IntegrationTools",
     "SkillsTools",
     "SubagentTools",
-    "ToolManagementTools",
     "UserInteractionTools",
     "WorkersTools",
 ]