hdsp-jupyter-extension 2.0.23__py3-none-any.whl → 2.0.26__py3-none-any.whl

agent_server/routers/chat.py

@@ -2,10 +2,12 @@
 Chat Router - Chat and streaming endpoints
 
 Handles conversational interactions with the LLM.
+Supports @file context injection for including file contents in prompts.
 """
 
 import json
 import logging
+import os
 from typing import Any, AsyncGenerator, Dict
 
 from fastapi import APIRouter, HTTPException
@@ -14,6 +16,7 @@ from hdsp_agent_core.managers.config_manager import ConfigManager
 from hdsp_agent_core.managers.session_manager import get_session_manager
 from hdsp_agent_core.models.chat import ChatRequest, ChatResponse
 
+from agent_server.context_providers import ContextProcessor
 from agent_server.core.llm_service import LLMService
 
 router = APIRouter()
@@ -83,6 +86,7 @@ async def chat_message(request: ChatRequest) -> Dict[str, Any]:
     """
     Send a chat message and get a response.
 
+    Supports @file context injection (e.g., "@file:path/to/file.py").
     Maintains conversation context across messages using conversation ID.
     """
     logger.info(f"Chat message received: {request.message[:100]}...")
@@ -104,25 +108,52 @@ async def chat_message(request: ChatRequest) -> Dict[str, Any]:
         conversation_id = _get_or_create_conversation(request.conversationId)
 
         # Build context from history
-        context = _build_context(conversation_id)
+        history_context = _build_context(conversation_id)
+
+        # Process @file and other context commands
+        base_dir = getattr(request, 'baseDir', None) or os.getcwd()
+        context_processor = ContextProcessor(base_dir=base_dir)
+        file_context, cleaned_message, context_errors = context_processor.process_message(
+            request.message
+        )
+
+        # Log any context processing errors
+        if context_errors:
+            logger.warning(f"Context processing errors: {context_errors}")
+
+        # Combine all context
+        all_context_parts = []
+        if file_context:
+            all_context_parts.append(file_context)
+        if history_context:
+            all_context_parts.append(history_context)
+        combined_context = "\n\n".join(all_context_parts) if all_context_parts else None
 
         # Call LLM with client-provided config
         llm_service = LLMService(config)
-        response = await llm_service.generate_response(request.message, context=context)
+        response = await llm_service.generate_response(
+            cleaned_message, context=combined_context
+        )
 
-        # Store messages
-        _store_messages(conversation_id, request.message, response)
+        # Store messages (use cleaned message for history)
+        _store_messages(conversation_id, cleaned_message, response)
 
         # Get model info
         provider = config.get("provider", "unknown")
         model = config.get(provider, {}).get("model", "unknown")
 
-        return {
+        result = {
             "response": response,
             "conversationId": conversation_id,
             "model": f"{provider}/{model}",
         }
 
+        # Include context errors if any
+        if context_errors:
+            result["contextErrors"] = context_errors
+
+        return result
+
     except HTTPException:
         raise
     except Exception as e:
@@ -135,6 +166,7 @@ async def chat_stream(request: ChatRequest) -> StreamingResponse:
     """
     Send a chat message and get a streaming response.
 
+    Supports @file context injection (e.g., "@file:path/to/file.py").
     Returns Server-Sent Events (SSE) with partial responses.
     """
     logger.info(f"Stream chat request: {request.message[:100]}...")
@@ -154,21 +186,40 @@ async def chat_stream(request: ChatRequest) -> StreamingResponse:
             # Get or create conversation
             conversation_id = _get_or_create_conversation(request.conversationId)
 
-            # Build context
-            context = _build_context(conversation_id)
+            # Build context from history
+            history_context = _build_context(conversation_id)
+
+            # Process @file and other context commands
+            base_dir = getattr(request, 'baseDir', None) or os.getcwd()
+            context_processor = ContextProcessor(base_dir=base_dir)
+            file_context, cleaned_message, context_errors = context_processor.process_message(
+                request.message
+            )
+
+            # Send context errors as a warning event
+            if context_errors:
+                yield f"data: {json.dumps({'warning': 'Context errors: ' + '; '.join(context_errors)})}\n\n"
+
+            # Combine all context
+            all_context_parts = []
+            if file_context:
+                all_context_parts.append(file_context)
+            if history_context:
+                all_context_parts.append(history_context)
+            combined_context = "\n\n".join(all_context_parts) if all_context_parts else None
 
             # Stream LLM response with client-provided config
             llm_service = LLMService(config)
             full_response = ""
 
             async for chunk in llm_service.generate_response_stream(
-                request.message, context=context
+                cleaned_message, context=combined_context
             ):
                 full_response += chunk
                 yield f"data: {json.dumps({'content': chunk, 'done': False})}\n\n"
 
-            # Store messages after streaming complete
-            _store_messages(conversation_id, request.message, full_response)
+            # Store messages after streaming complete (use cleaned message)
+            _store_messages(conversation_id, cleaned_message, full_response)
 
             # Send final chunk with conversation ID
             yield f"data: {json.dumps({'content': '', 'done': True, 'conversationId': conversation_id})}\n\n"

agent_server/routers/context.py

@@ -0,0 +1,168 @@
+"""
+Context Router - Context provider autocomplete and resolution
+
+Handles @file and other context command autocomplete and processing.
+Inspired by jupyter-ai's autocomplete API.
+"""
+
+import logging
+import os
+from typing import Optional
+
+from fastapi import APIRouter, Query
+from pydantic import BaseModel
+
+from agent_server.context_providers import FileContextProvider, ResetContextProvider
+from agent_server.context_providers.base import ListOptionsResponse
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+
+
+# All available providers (context and action)
+def _get_all_providers(base_dir: str):
+    """Get all available context/action providers."""
+    return {
+        "@file": FileContextProvider(base_dir=base_dir),
+        "@reset": ResetContextProvider(base_dir=base_dir),
+    }
+
+
+class ContextOptionsRequest(BaseModel):
+    """Request for context options."""
+
+    partial_command: Optional[str] = None  # e.g., "@file:src/"
+    base_dir: Optional[str] = None  # Base directory for file resolution
+
+
+class FileContentRequest(BaseModel):
+    """Request to get file content."""
+
+    filepath: str
+    base_dir: Optional[str] = None
+
+
+class FileContentResponse(BaseModel):
+    """Response with file content."""
+
+    content: str
+    filepath: str
+    error: Optional[str] = None
+
+
+@router.get("/autocomplete", response_model=ListOptionsResponse)
+async def get_autocomplete_options(
+    partial_command: Optional[str] = Query(None, alias="partialCommand"),
+    base_dir: Optional[str] = Query(None, alias="baseDir"),
+) -> ListOptionsResponse:
+    """
+    Get autocomplete options for context commands.
+
+    Query Parameters:
+        partialCommand: Partial command to complete
+            - "@" -> list all available commands
+            - "@fi" -> list commands starting with "@fi"
+            - "@file:" -> list files in current directory
+            - "@file:src/" -> list files in src directory
+        baseDir: Base directory for file resolution (default: cwd)
+    """
+    base_directory = base_dir or os.getcwd()
+    providers = _get_all_providers(base_directory)
+
+    if not partial_command:
+        # Return all available context commands
+        options = [p.get_provider_option() for p in providers.values()]
+        return ListOptionsResponse(options=options)
+
+    # Check if it's just "@" or a partial command name (no colon)
+    if ":" not in partial_command:
+        # Filter providers that match the partial command
+        options = []
+        for cmd_id, provider in providers.items():
+            if cmd_id.startswith(partial_command):
+                options.append(provider.get_provider_option())
+        return ListOptionsResponse(options=options)
+
+    # Has colon - parse the partial command
+    cmd_id, _, arg_prefix = partial_command.partition(":")
+
+    # Find matching provider
+    if cmd_id in providers:
+        provider = providers[cmd_id]
+        if provider.requires_arg:
+            options = provider.get_arg_options(arg_prefix)
+            return ListOptionsResponse(options=options)
+        else:
+            # For commands without args (like @reset), return the command itself
+            return ListOptionsResponse(options=[provider.get_provider_option()])
+
+    # No matching provider
+    return ListOptionsResponse(options=[])
+
+
+@router.post("/file/content", response_model=FileContentResponse)
+async def get_file_content(request: FileContentRequest) -> FileContentResponse:
+    """
+    Get the content of a file for context injection.
+
+    This is used when processing @file commands to include file contents
+    in the LLM prompt.
+    """
+    try:
+        base_directory = request.base_dir or os.getcwd()
+        file_provider = FileContextProvider(base_dir=base_directory)
+
+        # Create a command object
+        from agent_server.context_providers.base import ContextCommand
+
+        cmd = ContextCommand(cmd=f"@file:{request.filepath}")
+        content = file_provider.make_context(cmd)
+
+        return FileContentResponse(
+            content=content,
+            filepath=request.filepath,
+        )
+    except Exception as e:
+        logger.error(f"Failed to read file {request.filepath}: {e}")
+        return FileContentResponse(
+            content="",
+            filepath=request.filepath,
+            error=str(e),
+        )
+
+
+@router.get("/providers")
+async def list_context_providers():
+    """
+    List all available context providers.
+
+    Returns information about each context provider including:
+    - ID (e.g., "@file")
+    - Description
+    - Whether it requires an argument
+    - Whether it's an action command
+    """
+    providers = [
+        {
+            "id": "@file",
+            "description": "Include file contents in the prompt",
+            "requires_arg": True,
+            "is_action": False,
+            "usage": "@file:path/to/file.py",
+            "examples": [
+                "@file:main.py",
+                "@file:src/utils.py",
+                "@file:'path with spaces/file.py'",
+            ],
+        },
+        {
+            "id": "@reset",
+            "description": "Clear session and reset agent",
+            "requires_arg": False,
+            "is_action": True,
+            "usage": "@reset",
+            "examples": ["@reset"],
+        },
+    ]
+
+    return {"providers": providers}