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

agentpool_server/opencode_server/routes/app_routes.py

@@ -6,18 +6,19 @@ from pathlib import Path
 import subprocess
 from typing import TYPE_CHECKING
 
-from fastapi import APIRouter
+from fastapi import APIRouter, HTTPException
 
-from agentpool_server.opencode_server.dependencies import StateDep  # noqa: TC001
+from agentpool_server.opencode_server.dependencies import StateDep
 from agentpool_server.opencode_server.models import (
     App,
     AppTimeInfo,
     PathInfo,
     Project,
     ProjectTime,
+    ProjectUpdatedEvent,
+    ProjectUpdateRequest,
     VcsInfo,
 )
-from agentpool_storage.project_store import ProjectStore
 
 
 if TYPE_CHECKING:
@@ -65,6 +66,8 @@ def _project_data_to_response(data: ProjectData) -> Project:
 
 async def _get_current_project(state: StateDep) -> ProjectData:
     """Get or create the current project from storage."""
+    from agentpool_storage.project_store import ProjectStore
+
     storage = state.pool.storage
     project_store = ProjectStore(storage)
     return await project_store.get_or_create(state.working_dir)
@@ -73,6 +76,8 @@ async def _get_current_project(state: StateDep) -> ProjectData:
 @router.get("/project")
 async def list_projects(state: StateDep) -> list[Project]:
     """List all projects."""
+    from agentpool_storage.project_store import ProjectStore
+
     storage = state.pool.storage
     project_store = ProjectStore(storage)
     projects = await project_store.list_recent(limit=50)
@@ -86,6 +91,64 @@ async def get_project_current(state: StateDep) -> Project:
     return _project_data_to_response(project)
 
 
+@router.patch("/project/{project_id}")
+async def update_project(
+    project_id: str,
+    update: ProjectUpdateRequest,
+    state: StateDep,
+) -> Project:
+    """Update project metadata (name, settings).
+
+    Emits a project.updated event when successful.
+
+    Args:
+        project_id: Project identifier
+        update: Fields to update (name and/or settings)
+        state: Server state
+
+    Returns:
+        Updated project data
+
+    Raises:
+        HTTPException: If project not found
+    """
+    from agentpool_storage.project_store import ProjectStore
+
+    store = ProjectStore(state.pool.storage)
+    project_data = None
+
+    # Update name if provided
+    if update.name is not None:
+        project_data = await store.set_name(project_id, update.name)
+        if not project_data:
+            raise HTTPException(status_code=404, detail="Project not found")
+
+    # Update settings if provided
+    if update.settings:
+        if project_data:
+            # Already fetched from set_name, update with settings
+            project_data = await store.update_settings(project_id, **update.settings)
+        else:
+            project_data = await store.update_settings(project_id, **update.settings)
+
+        if not project_data:
+            raise HTTPException(status_code=404, detail="Project not found")
+
+    # If neither name nor settings provided, just fetch the project
+    if not project_data:
+        project_data = await store.get_by_id(project_id)
+        if not project_data:
+            raise HTTPException(status_code=404, detail="Project not found")
+
+    # Convert to OpenCode Project model
+    project = _project_data_to_response(project_data)
+
+    # Broadcast event
+    await state.broadcast_event(ProjectUpdatedEvent.create(project))
+
+    return project
+
+
 @router.get("/path")
 async def get_path(state: StateDep) -> PathInfo:
     """Get current path info."""

agentpool_server/opencode_server/routes/config_routes.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING
 
 from fastapi import APIRouter
 
-from agentpool_server.opencode_server.dependencies import StateDep  # noqa: TC001
+from agentpool_server.opencode_server.dependencies import StateDep
 from agentpool_server.opencode_server.models import (
     Config,
     Mode,
@@ -152,8 +152,49 @@ async def _get_available_models() -> list[TokoModelInfo]:
 @router.get("/config")
 async def get_config(state: StateDep) -> Config:
     """Get server configuration."""
-    _ = state  # unused for now
-    return Config()
+    import os
+
+    # Initialize config if not yet set
+    if state.config is None:
+        state.config = Config()
+
+    # Set a default model if not already configured
+    if state.config.model is None:
+        try:
+            # Get available models
+            toko_models = await state.agent.get_available_models()
+            if toko_models:
+                providers = _build_providers(toko_models)
+
+                # Find first connected provider and use its first model
+                for provider in providers:
+                    if any(os.environ.get(env) for env in provider.env) and provider.models:
+                        first_model = next(iter(provider.models.keys()))
+                        state.config.model = f"{provider.id}/{first_model}"
+                        break
+        except Exception:  # noqa: BLE001
+            pass  # If we can't set a default, that's okay
+
+    return state.config
+
+
+@router.patch("/config")
+async def update_config(state: StateDep, config_update: Config) -> Config:
+    """Update server configuration.
+
+    Only updates fields that are provided (non-None).
+    Returns the complete updated config.
+    """
+    # Initialize config if not yet set
+    if state.config is None:
+        state.config = Config()
+
+    # Update only the fields that were provided
+    update_data = config_update.model_dump(exclude_unset=True)
+    for field_name, value in update_data.items():
+        setattr(state.config, field_name, value)
+
+    return state.config
 
 
 def _get_dummy_providers() -> list[Provider]:
@@ -181,6 +222,8 @@ def _get_dummy_providers() -> list[Provider]:
 @router.get("/config/providers")
 async def get_providers(state: StateDep) -> ProvidersResponse:
     """Get available providers and models from agent."""
+    import os
+
     providers: list[Provider] = []
 
     # Try to get models from the agent
@@ -195,7 +238,18 @@ async def get_providers(state: StateDep) -> ProvidersResponse:
     if not providers:
         providers = _get_dummy_providers()
 
-    return ProvidersResponse(providers=providers)
+    # Build default models map: use first model for each connected provider
+    default_models: dict[str, str] = {}
+    connected_providers = [
+        provider.id for provider in providers if any(os.environ.get(env) for env in provider.env)
+    ]
+
+    for provider in providers:
+        if provider.id in connected_providers and provider.models:
+            # Simply use the first available model
+            default_models[provider.id] = next(iter(provider.models.keys()))
+
+    return ProvidersResponse(providers=providers, default=default_models)
 
 
 @router.get("/provider")
@@ -222,9 +276,16 @@ async def list_providers(state: StateDep) -> ProviderListResponse:
         provider.id for provider in providers if any(os.environ.get(env) for env in provider.env)
     ]
 
+    # Build default models map: use first model for each connected provider
+    default_models: dict[str, str] = {}
+    for provider in providers:
+        if provider.id in connected and provider.models:
+            # Simply use the first available model
+            default_models[provider.id] = next(iter(provider.models.keys()))
+
     return ProviderListResponse(
         all=providers,
-        default={},
+        default=default_models,
         connected=connected,
     )
 

agentpool_server/opencode_server/routes/file_routes.py

@@ -2,15 +2,18 @@
 
 from __future__ import annotations
 
+import asyncio
 import fnmatch
+import json
 from pathlib import Path
 import re
+import shutil
 from typing import TYPE_CHECKING, Any
 
 from fastapi import APIRouter, HTTPException, Query
 
-from agentpool_server.opencode_server.dependencies import StateDep  # noqa: TC001
-from agentpool_server.opencode_server.models import (  # noqa: TC001
+from agentpool_server.opencode_server.dependencies import StateDep
+from agentpool_server.opencode_server.models import (
     FileContent,
     FileNode,
     FindMatch,
@@ -106,6 +109,157 @@ def _get_fs(state: StateDep) -> tuple[AsyncFileSystem, str] | None:
         return (fs, base_path)
 
 
+def _is_local_fs(fs: AsyncFileSystem) -> bool:
+    """Check if filesystem is a local filesystem."""
+    return getattr(fs, "local_file", False)
+
+
+def _has_ripgrep() -> bool:
+    """Check if ripgrep is available."""
+    return shutil.which("rg") is not None
+
+
+async def _search_with_ripgrep(
+    pattern: str,
+    base_path: str,
+    max_matches: int = 100,
+) -> list[FindMatch]:
+    """Search using ripgrep for better performance on local filesystems.
+
+    Args:
+        pattern: Regex pattern to search for.
+        base_path: Directory to search in.
+        max_matches: Maximum number of matches to return.
+
+    Returns:
+        List of FindMatch objects.
+    """
+    # Build ripgrep command with JSON output
+    cmd = [
+        "rg",
+        "--json",
+        "--max-count",
+        str(max_matches),
+        "--no-binary",
+    ]
+
+    # Add exclude patterns for SKIP_DIRS
+    for skip_dir in SKIP_DIRS:
+        cmd.extend(["--glob", f"!{skip_dir}/"])
+
+    cmd.extend(["-e", pattern, base_path])
+
+    # Run ripgrep asynchronously
+    proc = await asyncio.create_subprocess_exec(
+        *cmd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout, _ = await proc.communicate()
+
+    matches: list[FindMatch] = []
+    base_path_prefix = base_path.rstrip("/") + "/"
+
+    for line in stdout.decode("utf-8", errors="replace").splitlines():
+        if not line.strip():
+            continue
+        try:
+            data = json.loads(line)
+            if data.get("type") != "match":
+                continue
+
+            match_data = data.get("data", {})
+            path = match_data.get("path", {}).get("text", "")
+            line_number = match_data.get("line_number", 0)
+            line_text = match_data.get("lines", {}).get("text", "").rstrip("\n")
+            absolute_offset = match_data.get("absolute_offset", 0)
+
+            # Convert to relative path
+            rel_path = path[len(base_path_prefix) :] if path.startswith(base_path_prefix) else path
+
+            # Extract submatches
+            submatches = []
+            for sm in match_data.get("submatches", []):
+                match_text = sm.get("match", {}).get("text", "")
+                start = sm.get("start", 0)
+                end = sm.get("end", 0)
+                submatches.append(SubmatchInfo.create(match_text, start, end))
+
+            matches.append(
+                FindMatch.create(
+                    path=rel_path,
+                    lines=line_text.strip(),
+                    line_number=line_number,
+                    absolute_offset=absolute_offset,
+                    submatches=submatches,
+                )
+            )
+
+            if len(matches) >= max_matches:
+                break
+        except json.JSONDecodeError:
+            continue
+
+    return matches
+
+
+async def _find_files_with_ripgrep(
+    query: str,
+    base_path: str,
+    max_results: int = 100,
+) -> list[str]:
+    """Find files using ripgrep --files for better performance.
+
+    Args:
+        query: Glob pattern to match file names.
+        base_path: Directory to search in.
+        max_results: Maximum number of results to return.
+
+    Returns:
+        List of relative file paths.
+    """
+    # Build ripgrep command to list files matching glob
+    cmd = ["rg", "--files"]
+
+    # Add exclude patterns for SKIP_DIRS
+    for skip_dir in SKIP_DIRS:
+        cmd.extend(["--glob", f"!{skip_dir}/"])
+
+    # Add the file name pattern as a glob
+    # rg --files --glob supports matching anywhere in the path
+    # If query doesn't contain glob chars, wrap it with * for substring matching
+    glob_chars = {"*", "?", "[", "]"}
+    if not any(c in query for c in glob_chars):
+        query = f"*{query}*"
+    # Use **/ prefix to match the filename in any directory
+    cmd.extend(["--glob", f"**/{query}"])
+    cmd.append(base_path)
+
+    # Run ripgrep asynchronously
+    proc = await asyncio.create_subprocess_exec(
+        *cmd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout, _ = await proc.communicate()
+
+    results: list[str] = []
+    base_path_prefix = base_path.rstrip("/") + "/"
+
+    for line in stdout.decode("utf-8", errors="replace").splitlines():
+        if not line.strip():
+            continue
+
+        # Convert to relative path
+        rel_path = line[len(base_path_prefix) :] if line.startswith(base_path_prefix) else line
+
+        results.append(rel_path)
+        if len(results) >= max_results:
+            break
+
+    return sorted(results)
+
+
 @router.get("/file")
 async def list_files(state: StateDep, path: str = Query(default="")) -> list[FileNode]:
     """List files in a directory."""
@@ -216,15 +370,29 @@ async def get_file_status(state: StateDep) -> list[dict[str, Any]]:
 @router.get("/find")
 async def find_text(state: StateDep, pattern: str = Query()) -> list[FindMatch]:  # noqa: PLR0915
     """Search for text pattern in files using regex."""
+    # Validate regex pattern
     try:
-        regex = re.compile(pattern)
+        re.compile(pattern)
     except re.error as e:
         raise HTTPException(status_code=400, detail=f"Invalid regex: {e}") from e
 
-    matches: list[FindMatch] = []
     max_matches = 100
     fs_info = _get_fs(state)
 
+    # Fast path: use ripgrep for local filesystems
+    if fs_info is not None:
+        fs, base_path = fs_info
+        if _is_local_fs(fs) and _has_ripgrep():
+            return await _search_with_ripgrep(pattern, base_path, max_matches)
+
+    # Fallback: use ripgrep directly if no fs but ripgrep available
+    if fs_info is None and _has_ripgrep():
+        return await _search_with_ripgrep(pattern, state.working_dir, max_matches)
+
+    # Slow path: manual file iteration
+    matches: list[FindMatch] = []
+    regex = re.compile(pattern)
+
     if fs_info is not None:
         fs, base_path = fs_info
 
@@ -326,10 +494,21 @@ async def find_files(
 ) -> list[str]:
     """Find files by name pattern (glob-style matching)."""
     include_dirs = dirs.lower() == "true"
-    results: list[str] = []
     max_results = 100
     fs_info = _get_fs(state)
 
+    # Fast path: use ripgrep for local filesystems (files only, not dirs)
+    if not include_dirs and _has_ripgrep():
+        if fs_info is not None:
+            fs, base_path = fs_info
+            if _is_local_fs(fs):
+                return await _find_files_with_ripgrep(query, base_path, max_results)
+        else:
+            return await _find_files_with_ripgrep(query, state.working_dir, max_results)
+
+    # Slow path: manual file iteration
+    results: list[str] = []
+
     if fs_info is not None:
         fs, base_path = fs_info
         # Use fsspec filesystem

agentpool_server/opencode_server/routes/global_routes.py

@@ -9,7 +9,7 @@ from typing import TYPE_CHECKING, Any
 from fastapi import APIRouter
 from sse_starlette.sse import EventSourceResponse
 
-from agentpool_server.opencode_server.dependencies import StateDep  # noqa: TC001
+from agentpool_server.opencode_server.dependencies import StateDep
 from agentpool_server.opencode_server.models import (  # noqa: TC001
     Event,
     HealthResponse,

agentpool_server/opencode_server/routes/lsp_routes.py

@@ -13,7 +13,7 @@ from typing import Literal
 from fastapi import APIRouter, HTTPException, Query
 from pydantic import BaseModel
 
-from agentpool_server.opencode_server.dependencies import StateDep  # noqa: TC001
+from agentpool_server.opencode_server.dependencies import StateDep
 from agentpool_server.opencode_server.models.events import LspStatus, LspUpdatedEvent