auto-coder-web 0.1.98__py3-none-any.whl → 0.1.100__py3-none-any.whl

auto_coder_web/file_manager.py

@@ -147,7 +147,7 @@ async def get_directory_tree_async(root_path: str, path: str = None, lazy: bool
 
     def should_ignore(name: str) -> bool:
         """Check if a file or directory should be ignored"""
-        allowed_hidden_files = {'.autocoderrules', '.gitignore', '.autocoderignore'}
+        allowed_hidden_files = {'.autocoderrules', '.gitignore', '.autocoderignore',".autocodercommands"}
         # Ignore hidden files/directories (starting with '.'), unless explicitly allowed
         ## and name != ".auto-coder": # Original comment kept for context if needed
         if name.startswith('.') and name not in allowed_hidden_files:

auto_coder_web/proxy.py

@@ -19,7 +19,7 @@ import sys
 from auto_coder_web.terminal import terminal_manager
 from autocoder.common import AutoCoderArgs
 from auto_coder_web.auto_coder_runner_wrapper import AutoCoderRunnerWrapper
-from auto_coder_web.routers import todo_router, settings_router, auto_router, commit_router, chat_router, coding_router, index_router, config_router, upload_router, rag_router, editable_preview_router, mcp_router, direct_chat_router, rules_router, chat_panels_router, code_editor_tabs_router
+from auto_coder_web.routers import todo_router, settings_router, auto_router, commit_router, chat_router, coding_router, index_router, config_router, upload_router, rag_router, editable_preview_router, mcp_router, direct_chat_router, rules_router, chat_panels_router, code_editor_tabs_router, file_command_router
 from auto_coder_web.expert_routers import history_router
 from auto_coder_web.common_router import completions_router, file_router, auto_coder_conf_router, chat_list_router, file_group_router, model_router, compiler_router
 from auto_coder_web.common_router import active_context_router
@@ -112,6 +112,7 @@ class ProxyServer:
         self.app.include_router(rules_router.router)
         self.app.include_router(chat_panels_router.router)
         self.app.include_router(code_editor_tabs_router.router)
+        self.app.include_router(file_command_router.router)
 
         @self.app.on_event("shutdown")
         async def shutdown_event():

auto_coder_web/routers/file_command_router.py

@@ -0,0 +1,315 @@
+"""
+Document Router for managing and analyzing document files.
+
+This router provides endpoints for listing documents and reading document variables
+using the CommandFileManager from the auto-coder project.
+"""
+
+import os
+import json
+import aiofiles
+from fastapi import APIRouter, HTTPException, Request, Depends
+from pydantic import BaseModel
+from pathlib import Path
+from typing import List, Dict, Optional, Set, Any
+from jinja2 import Template, Environment, meta
+
+# Import the CommandFileManager from the auto-coder project
+from autocoder.common.command_file_manager import CommandManager, JinjaVariable
+
+router = APIRouter()
+
+async def get_project_path(request: Request) -> str:
+    """Get the project path from the FastAPI request context."""
+    return request.app.state.project_path
+
+async def get_documents_path(project_path: str) -> Path:
+    """Get the documents directory path."""
+    # Default to .autocodercommands directory in the project
+    return Path(project_path) / ".autocodercommands"
+
+class DocumentFile(BaseModel):
+    """Model for document file information."""
+    file_name: str
+    file_path: str
+
+class DocumentVariable(BaseModel):
+    """Model for document variable information."""
+    name: str
+    default_value: Optional[str] = None
+    description: Optional[str] = None
+
+class DocumentAnalysis(BaseModel):
+    """Model for document analysis information."""
+    file_name: str
+    file_path: str
+    variables: List[DocumentVariable]
+
+class ListDocumentsResponse(BaseModel):
+    """Response model for listing documents."""
+    success: bool
+    documents: Optional[List[DocumentFile]] = None
+    errors: Optional[List[str]] = None
+
+class ReadDocumentResponse(BaseModel):
+    """Response model for reading a document."""
+    success: bool
+    document: Optional[DocumentFile] = None
+    content: Optional[str] = None
+    errors: Optional[List[str]] = None
+
+class AnalyzeDocumentResponse(BaseModel):
+    """Response model for analyzing a document."""
+    success: bool
+    analysis: Optional[DocumentAnalysis] = None
+    errors: Optional[List[str]] = None
+
+class AllVariablesResponse(BaseModel):
+    """Response model for getting all variables."""
+    success: bool
+    variables: Optional[Dict[str, List[str]]] = None
+    errors: Optional[List[str]] = None
+
+class RenderTemplateRequest(BaseModel):
+    """Request model for rendering a template."""
+    file_name: str
+    variables: Dict[str, str]
+
+class RenderTemplateResponse(BaseModel):
+    """Response model for rendering a template."""
+    success: bool
+    rendered_content: Optional[str] = None
+    errors: Optional[List[str]] = None
+
+@router.get("/api/file_commands", response_model=ListDocumentsResponse)
+async def list_documents(request: Request, recursive: bool = False):
+    """
+    List all document files in the documents directory.
+    
+    Args:
+        recursive: Whether to search recursively.
+        
+    Returns:
+        A ListDocumentsResponse object.
+    """
+    try:
+        project_path = await get_project_path(request)
+        documents_path = await get_documents_path(project_path)
+        
+        # Initialize the CommandManager
+        manager = CommandManager(str(documents_path))
+        
+        # List command files
+        result = manager.list_command_files(recursive=recursive)
+        
+        if not result.success:
+            return ListDocumentsResponse(
+                success=False,
+                errors=result.errors
+            )
+        
+        # Convert to DocumentFile objects
+        documents = []
+        for file_path in result.command_files:
+            file_name = os.path.basename(file_path)
+            documents.append(DocumentFile(
+                file_name=file_name,
+                file_path=file_path
+            ))
+        
+        return ListDocumentsResponse(
+            success=True,
+            documents=documents
+        )
+    except Exception as e:
+        return ListDocumentsResponse(
+            success=False,
+            errors=[f"Error listing documents: {str(e)}"]
+        )
+
+@router.get("/api/file_commands/{file_name}", response_model=ReadDocumentResponse)
+async def read_document(file_name: str, request: Request):
+    """
+    Read a document file.
+    
+    Args:
+        file_name: The name of the file to read.
+        
+    Returns:
+        A ReadDocumentResponse object.
+    """
+    try:
+        project_path = await get_project_path(request)
+        documents_path = await get_documents_path(project_path)
+        
+        # Initialize the CommandManager
+        manager = CommandManager(str(documents_path))
+        
+        # Read command file
+        command_file = manager.read_command_file(file_name)
+        
+        if not command_file:
+            return ReadDocumentResponse(
+                success=False,
+                errors=[f"Document '{file_name}' not found."]
+            )
+        
+        return ReadDocumentResponse(
+            success=True,
+            document=DocumentFile(
+                file_name=command_file.file_name,
+                file_path=command_file.file_path
+            ),
+            content=command_file.content
+        )
+    except Exception as e:
+        return ReadDocumentResponse(
+            success=False,
+            errors=[f"Error reading document: {str(e)}"]
+        )
+
+@router.get("/api/file_commands/{file_name}/variables", response_model=AnalyzeDocumentResponse)
+async def analyze_document(file_name: str, request: Request):
+    """
+    Analyze a document file to extract variables.
+    
+    Args:
+        file_name: The name of the file to analyze.
+        
+    Returns:
+        An AnalyzeDocumentResponse object.
+    """
+    try:
+        project_path = await get_project_path(request)
+        documents_path = await get_documents_path(project_path)
+        
+        # Initialize the CommandManager
+        manager = CommandManager(str(documents_path))
+        
+        # Analyze command file
+        analysis = manager.analyze_command_file(file_name)
+        
+        if not analysis:
+            return AnalyzeDocumentResponse(
+                success=False,
+                errors=[f"Document '{file_name}' not found or could not be analyzed."]
+            )
+        
+        # Convert to DocumentVariable objects
+        variables = []
+        for var in analysis.variables:
+            variables.append(DocumentVariable(
+                name=var.name,
+                default_value=var.default_value,
+                description=var.description
+            ))
+        
+        return AnalyzeDocumentResponse(
+            success=True,
+            analysis=DocumentAnalysis(
+                file_name=analysis.file_name,
+                file_path=analysis.file_path,
+                variables=variables
+            )
+        )
+    except Exception as e:
+        return AnalyzeDocumentResponse(
+            success=False,
+            errors=[f"Error analyzing document: {str(e)}"]
+        )
+
+@router.get("/api/file_commands/variables/all", response_model=AllVariablesResponse)
+async def get_all_variables(request: Request, recursive: bool = False):
+    """
+    Get all variables from all document files.
+    
+    Args:
+        recursive: Whether to search recursively.
+        
+    Returns:
+        An AllVariablesResponse object.
+    """
+    try:
+        project_path = await get_project_path(request)
+        documents_path = await get_documents_path(project_path)
+        
+        # Initialize the CommandManager
+        manager = CommandManager(str(documents_path))
+        
+        # Get all variables
+        variables = manager.get_all_variables(recursive=recursive)
+        
+        return AllVariablesResponse(
+            success=True,
+            variables=variables
+        )
+    except Exception as e:
+        return AllVariablesResponse(
+            success=False,
+            errors=[f"Error getting all variables: {str(e)}"]
+        )
+
+@router.get("/api/file_commands/path")
+async def get_documents_directory(request: Request):
+    """
+    Get the documents directory path.
+    
+    Returns:
+        The documents directory path.
+    """
+    try:
+        project_path = await get_project_path(request)
+        documents_path = await get_documents_path(project_path)
+        
+        return {
+            "success": True,
+            "path": str(documents_path)
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "errors": [f"Error getting documents directory: {str(e)}"]
+        }
+
+@router.post("/api/file_commands/render", response_model=RenderTemplateResponse)
+async def render_template(request: RenderTemplateRequest, req: Request):
+    """
+    Render a template with the provided variables.
+    
+    Args:
+        request: The request containing the file name and variables.
+        
+    Returns:
+        A RenderTemplateResponse object containing the rendered content.
+    """
+    try:
+        project_path = await get_project_path(req)
+        documents_path = await get_documents_path(project_path)
+        
+        # Initialize the CommandManager
+        manager = CommandManager(str(documents_path))
+        
+        # Read command file
+        command_file = manager.read_command_file(request.file_name)
+        
+        if not command_file:
+            return RenderTemplateResponse(
+                success=False,
+                errors=[f"Document '{request.file_name}' not found."]
+            )
+        
+        # Create Jinja2 template
+        template = Template(command_file.content)
+        
+        # Render template with provided variables
+        rendered_content = template.render(**request.variables)
+        
+        return RenderTemplateResponse(
+            success=True,
+            rendered_content=rendered_content
+        )
+    except Exception as e:
+        return RenderTemplateResponse(
+            success=False,
+            errors=[f"Error rendering template: {str(e)}"]
+        )

auto_coder_web/version.py

@@ -1 +1 @@
-__version__ = "0.1.98"
+__version__ = "0.1.100"