fastmcp-agents-library-agent-simple-code 0.5.1__py3-none-any.whl → 0.5.7__py3-none-any.whl

fastmcp_agents/library/agent/simple_code/__init__.py

@@ -0,0 +1,3 @@
+from .investigate import code_investigation_agent
+
+__all__ = ["code_investigation_agent"]

fastmcp_agents/library/agent/simple_code/archive/base.py.disabled

@@ -0,0 +1,49 @@
+"""
+This agent is used to perform simple code tasks.
+"""
+
+from collections.abc import AsyncIterator
+from contextlib import ExitStack, asynccontextmanager
+from pathlib import Path
+from typing import Any
+
+from fastmcp import FastMCP
+from fastmcp_ai_agent_bridge.pydantic_ai import FastMCPToolset
+from pydantic import BaseModel, Field
+from pydantic_ai import Agent
+from pydantic_ai.agent import AgentRunResult
+
+from fastmcp_agents.core.agents.base import Field
+from fastmcp_agents.core.agents.task import TaskAgent
+from fastmcp_agents.library.agent.simple_code.helpers.git import quick_clone_git_repo
+from fastmcp_agents.library.mcp.strawgate import (
+    read_only_filesystem_mcp,
+    read_write_filesystem_mcp,
+)
+
+class BaseCodeAgent(TaskAgent):
+    """An agent that can perform simple code tasks."""
+
+    clean_workspace: bool = Field(
+        default=True,
+        description="Whether to clean the workspace after the task is complete. Only applicable if a Git URL is provided.",
+    )
+
+    @asynccontextmanager
+    async def prepare_workspace(self, *, git_url: str | None = None) -> AsyncIterator[tuple[Path, dict[str, Any] | None]]:
+        directory = Path.cwd()
+
+        with ExitStack() as stack:
+            if git_url is not None:
+                self.logger.info(f"Cloning git repository from {git_url}")
+                context_manager = quick_clone_git_repo(git_url, set_cwd=True, delete_on_exit=self.clean_workspace)
+
+                git_repo = stack.enter_context(context_manager)
+
+                self.logger.info(f"Cloned git repository to {git_repo}")
+
+            tools = await self.get_tools()
+
+            structure = await tools["get_structure"].run(arguments={})
+
+            yield directory, structure.structured_content

fastmcp_agents/library/agent/simple_code/archive/workspace.py.disabled

@@ -0,0 +1,18 @@
+
+from collections.abc import AsyncIterator
+from contextlib import ExitStack, asynccontextmanager
+from pathlib import Path
+from typing import Any
+
+from fastmcp_agents.library.agent.simple_code.helpers.git import quick_clone_git_repo
+
+
+@asynccontextmanager
+async def prepare_workspace(*, git_url: str | None = None, clean_workspace: bool = True) -> AsyncIterator[tuple[Path, dict[str, Any] | None]]:
+    directory = Path.cwd()
+
+    with ExitStack() as stack:
+        if git_url is not None:
+            context_manager = quick_clone_git_repo(git_url=git_url, set_cwd=True, delete_on_exit=clean_workspace)
+
+            _ = stack.enter_context(cm=context_manager)

fastmcp_agents/library/agent/simple_code/helpers/filesystem.py

@@ -0,0 +1,120 @@
+from collections.abc import Generator
+from pathlib import Path
+
+from fastmcp.mcp_config import TransformingStdioMCPServer
+from fastmcp.tools.tool_transform import ArgTransformConfig, ToolTransformConfig
+from pydantic import BaseModel, Field, computed_field
+
+
+def read_write_filesystem_mcp(root_dir: Path | None = None) -> TransformingStdioMCPServer:
+    additional_args: list[str] = []
+    if root_dir is not None:
+        additional_args.append(f"--root-dir={root_dir.resolve()}")
+
+    return TransformingStdioMCPServer(
+        command="uvx",
+        args=["filesystem-operations-mcp", *additional_args],
+        tools={
+            "search_files": ToolTransformConfig(
+                arguments={
+                    "included_types": ArgTransformConfig(hide=True),
+                    "excluded_types": ArgTransformConfig(hide=True),
+                },
+            ),
+            "find_files": ToolTransformConfig(
+                arguments={
+                    "included_types": ArgTransformConfig(hide=True),
+                    "excluded_types": ArgTransformConfig(hide=True),
+                },
+            ),
+        },
+    )
+
+
+def read_only_filesystem_mcp(root_dir: Path | None = None) -> TransformingStdioMCPServer:
+    mcp = read_write_filesystem_mcp(root_dir=root_dir)
+
+    mcp.tools = {
+        "find_files": ToolTransformConfig(
+            tags={"allowed_tools"},
+            arguments={
+                "included_types": ArgTransformConfig(hide=True),
+                "excluded_types": ArgTransformConfig(hide=True),
+            },
+        ),
+        "search_files": ToolTransformConfig(
+            tags={"allowed_tools"},
+            arguments={
+                "included_types": ArgTransformConfig(hide=True),
+                "excluded_types": ArgTransformConfig(hide=True),
+            },
+        ),
+        "get_structure": ToolTransformConfig(
+            tags={"allowed_tools"},
+        ),
+        "get_file": ToolTransformConfig(
+            tags={"allowed_tools"},
+        ),
+        "read_file_lines": ToolTransformConfig(
+            tags={"allowed_tools"},
+        ),
+    }
+
+    mcp.include_tags = {"allowed_tools"}
+
+    return mcp
+
+
+class FileStructure(BaseModel):
+    """A file structure."""
+
+    results: list[str]
+    max_results: int = Field(description="The maximum number of results to return.", exclude=True)
+
+    @computed_field
+    @property
+    def limit_reached(self) -> bool:
+        """Check if the limit has been reached."""
+
+        return len(self.results) >= self.max_results
+
+
+def get_structure(root_dir: Path, max_results: int = 150) -> FileStructure:
+    """Get the structure of a directory."""
+
+    results: list[str] = []
+
+    for item in limited_depth_iterdir(path=root_dir, max_depth=3):
+        if len(results) >= max_results:
+            break
+        if item.is_file():
+            results.append(item.name)
+        elif item.is_dir():
+            results.append(item.name + "/")
+
+    return FileStructure(results=results, max_results=max_results)
+
+
+def limited_depth_iterdir(
+    path: Path,
+    max_depth: int = 3,
+    current_depth: int = 0,
+) -> Generator[Path]:
+    """
+    Iterates through directory contents up to a specified maximum depth.
+
+    Args:
+        path (Path): The starting directory path.
+        max_depth (int): The maximum depth to traverse (0 for current directory only).
+        current_depth (int): The current depth during recursion (internal use).
+
+    Yields:
+        Path: A path object for each file or directory within the depth limit.
+    """
+    if current_depth > max_depth:
+        return
+
+    for item in path.iterdir():
+        yield item
+        if item.is_dir():
+            yield from limited_depth_iterdir(path=item, max_depth=max_depth, current_depth=current_depth + 1)

fastmcp_agents/library/agent/simple_code/helpers/git.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+
+import git
+from git import Repo
+
+
+def quick_clone_git_repo(target_dir: Path, git_url: str) -> Repo:
+    """Quickly clone a git repository."""
+
+    return git.Repo.clone_from(url=git_url, to_path=target_dir, single_branch=True, depth=1)

fastmcp_agents/library/agent/simple_code/implement.py

@@ -0,0 +1,141 @@
+import os
+import tempfile
+from pathlib import Path
+from textwrap import dedent
+from typing import Annotated, Any, Literal
+
+from fastmcp import FastMCP
+from fastmcp.tools.tool import Tool
+from fastmcp_ai_agent_bridge.pydantic_ai import FastMCPToolset
+from git import Repo
+from pydantic import AnyHttpUrl, BaseModel, Field, RootModel
+from pydantic_ai.agent import Agent
+
+from fastmcp_agents.library.agent.simple_code.helpers.filesystem import (
+    get_structure,
+    read_write_filesystem_mcp,
+)
+
+code_implementation_instructions = """
+You are an expert software engineer. You are able to handle a wide variety of tasks related to software development.
+
+Your goal is to study the assigned task, gather the necessary information to properly understand the task,
+produce a viable plan to complete the task and then execute the plan.
+
+You have access to the local filesystem, the tools you have available can search, summarize, create, read, update, and delete
+files and directories as needed.
+
+For any task, it will be extremely important for you to gather the necessary information from the codebase:
+1. Bug Fixes: If you are asked to fix a bug you will first understand the bug. You will review the different ways the relevant code
+can be invoked and you will understand when and why the bug occurs and when and why it does not occur. You will first think
+of a test that will fail if the bug is present and pass if the bug is not present. If the codebase includes tests, you will
+write the test.
+
+2. Propose a solution to a problem: If you are asked to propose a solution to a problem you will first understand the problem. You will
+try to understand the cause of the problem.
+
+3. Refactor code: If you are asked to refactor code you will first understand the code. You will review the different areas of the code
+that are relevant to the refactoring and you will understand how the different parts of the code interact. You will then propose a
+refactoring plan.
+
+4. Implement a new feature: If you are asked to implement a new feature you will first understand the feature. You will review the different
+areas of the code that are relevant to the feature and you will understand how the different parts of the code interact. You will then
+propose an implementation plan.
+
+If the plan is more than a couple steps, you will then write the plan to a Markdown file called `plan.md`. You will read this plan after
+writing it to ensure that it accurately reflects the plan. Once you have a plan, you will execute the plan performing the necessary steps
+to complete the task.
+
+Once you believe you have completed the task you will step through the code line by line ensuring that the task is completed. You will
+re-read the written plan to make sure you have not missed any steps. When calling report_task_success you will enumerate the action you
+took to resolve each part of the task. If you have not completed a part of the task, you will continue working on that part.
+"""
+
+mcp_servers = {
+    "filesystem": read_write_filesystem_mcp(),
+}
+
+
+class FileLines(RootModel[list[str]]):
+    """A file line with line number and content."""
+
+
+class PotentialFlaw(BaseModel):
+    """A potential flaw in the code."""
+
+    description: str
+    file_path: str | None = None
+    lines: FileLines = Field(default=..., description="The relevant lines of code in the file with their line numbers.")
+
+
+class ImplementationResponse(BaseModel):
+    """A response from the implementation agent."""
+
+    summary: str
+    confidence: Literal["low", "medium", "high"]
+    potential_flaws: list[PotentialFlaw] = Field(
+        default=..., description="A list of potential flaws in the code that a reviewer should review before merging."
+    )
+
+
+code_implementation_agent: Agent[None, ImplementationResponse] = Agent[None, ImplementationResponse](
+    model=os.environ.get("MODEL"),
+    toolsets=[
+        # We will provide a directory-locked toolset at runtime
+    ],
+    system_prompt=code_implementation_instructions,
+    output_type=ImplementationResponse,
+    retries=2,
+    output_retries=2,
+)
+
+server = FastMCP[Any](name="investigate-code-agent")
+
+CODE_REPOSITORY_TYPE = Annotated[
+    AnyHttpUrl | Path | None,
+    Field(
+        description=dedent(
+            text="""
+        The code repository to investigate.
+
+        If a Git URL is provided, it will be cloned.
+        A local path can also be provided.
+        If neither is provided, the agent will look in the current working directory."""
+        ).strip(),
+    ),
+]
+
+
+async def implement_code(task: str, code_repository: CODE_REPOSITORY_TYPE) -> ImplementationResponse:
+    """Perform a code investigation."""
+
+    with tempfile.TemporaryDirectory(delete=False) as temp_dir:
+        # We only actually use the tempdir if we are cloning a git repository
+        if isinstance(code_repository, AnyHttpUrl):
+            Repo.clone_from(url=str(code_repository), to_path=temp_dir, single_branch=True, depth=1)
+            code_repository = Path(temp_dir)
+        if code_repository is None:
+            code_repository = Path.cwd()
+
+        directory_locked_toolset = FastMCPToolset.from_mcp_config(
+            mcp_config={"filesystem": read_write_filesystem_mcp(root_dir=code_repository)}
+        )
+
+        structure = get_structure(root_dir=code_repository, max_results=10)
+
+        repo_info = f"""
+        We've called get_structure on your behalf, here were the initial results to get you started:
+        {structure}
+        """
+
+        run_result = await code_implementation_agent.run(user_prompt=[task, repo_info], toolsets=[directory_locked_toolset])
+
+        return run_result.output
+
+
+implement_code_tool = Tool.from_function(fn=implement_code)
+
+server.add_tool(tool=implement_code_tool)
+
+if __name__ == "__main__":
+    server.run(transport="sse")

fastmcp_agents/library/agent/simple_code/investigate.py

@@ -0,0 +1,164 @@
+"""
+This agent is used to perform simple code tasks.
+"""
+
+import os
+import tempfile
+from pathlib import Path
+from textwrap import dedent
+from typing import Annotated, Any, Literal
+
+from fastmcp import FastMCP
+from fastmcp.tools.tool import Tool
+from fastmcp_ai_agent_bridge.pydantic_ai import FastMCPToolset
+from git import Repo
+from pydantic import AnyHttpUrl, BaseModel, Field, RootModel
+from pydantic_ai import Agent
+
+from fastmcp_agents.library.agent.simple_code.helpers.filesystem import (
+    get_structure,
+    read_only_filesystem_mcp,
+)
+
+mcp_servers = {
+    "filesystem": read_only_filesystem_mcp(),
+}
+
+toolset = FastMCPToolset.from_mcp_config(mcp_config=mcp_servers)
+
+code_investigation_instructions = """
+You are an expert software engineer. You are able to handle a wide variety of tasks related to software development.
+
+Your goal is to study the assigned task, gather the necessary information to properly understand the task, and then
+produce a viable plan to complete the task. You are to be thorough and do this right, you are not to concerned with
+how much time it takes to complete the task.
+
+You have access to the local filesystem, the tools you have available can search, summarize, and read files as needed.
+
+For any task, it will be extremely important for you to gather the necessary information from the codebase:
+1. Bug Fixes: If you are asked to fix a bug you will first understand the bug. You will review the different ways the relevant code
+can be invoked and you will understand when and why the bug occurs and when and why it does not occur. You will first think
+of a test that will fail if the bug is present and pass if the bug is not present. If the codebase includes tests, you will
+write the test.
+
+2. Propose a solution to a problem: If you are asked to propose a solution to a problem you will first understand the problem. You will
+try to understand the cause of the problem.
+
+3. Refactor code: If you are asked to plan a refactoring you will first understand the code. You will review the different areas of the code
+that are relevant to the refactoring and you will understand how the different parts of the code interact. You will then propose a
+refactoring plan.
+
+4. Implement a new feature: If you are asked to implement a new feature you will first understand the feature. You will review the different
+areas of the code that are relevant to the feature and you will understand how the different parts of the code interact. You will then
+propose an implementation plan.
+
+Once you believe you have completed the task you will step through the code line by line ensuring that the task is completed. If you have
+not completed a part of the task, you will continue working on that part.
+
+Once you have believe you have completed the task you will perform additional review of other files in the codebase, looking for any
+references to the relevant code or tests that might need to be updated, or removed.
+
+Remember, you cannot make any changes to the codebase. You can only read files.
+"""
+
+
+class FileLines(RootModel[list[str]]):
+    """A file line with line number and content."""
+
+
+class InvestigationFinding(BaseModel):
+    """An investigation finding."""
+
+    description: str
+    file_path: str | None = None
+    lines: FileLines = Field(default=..., description="The relevant lines of code in the file with their line numbers.")
+
+
+class InvestigationRecommendation(BaseModel):
+    """An investigation recommendation."""
+
+    description: str
+    action: Literal["fix", "refactor", "propose", "implement"]
+    file_path: str | None = None
+    current_lines: FileLines = Field(default=..., description="The relevant lines of code in the file with their line numbers.")
+    proposed_lines: FileLines = Field(default=..., description="The proposed lines of code in the file with their line numbers.")
+
+
+class InvestigationResponse(BaseModel):
+    """An investigation response."""
+
+    summary: str = Field(default=..., description="A summary of the findings. Under 1 page.")
+    confidence: Literal["high", "medium", "low"] = Field(default=..., description="The confidence of the findings.")
+    findings: list[InvestigationFinding]
+    recommendations: list[InvestigationRecommendation] = Field(
+        default=..., description="Recommendations for next steps based on the findings."
+    )
+
+
+code_investigation_agent = Agent[None, InvestigationResponse](
+    model=os.environ.get("MODEL"),
+    toolsets=[
+        # We will provide a directory-locked toolset at runtime
+    ],
+    system_prompt=code_investigation_instructions,
+    output_type=InvestigationResponse,
+    retries=2,
+    output_retries=2,
+)
+
+server = FastMCP[Any](name="investigate-code-agent")
+
+CODE_REPOSITORY_TYPE = Annotated[
+    AnyHttpUrl | Path | None,
+    Field(
+        description=dedent(
+            text="""
+        The code repository to investigate.
+
+        If a Git URL is provided, it will be cloned.
+        A local path can also be provided.
+        If neither is provided, the agent will look in the current working directory."""
+        ).strip(),
+    ),
+]
+
+
+async def investigate_code(task: str, code_repository: CODE_REPOSITORY_TYPE) -> InvestigationResponse:
+    """Perform a code investigation."""
+
+    with tempfile.TemporaryDirectory(delete=False) as temp_dir:
+        # We only actually use the tempdir if we are cloning a git repository
+        if isinstance(code_repository, AnyHttpUrl):
+            Repo.clone_from(url=str(code_repository), to_path=temp_dir, single_branch=True, depth=1)
+            code_repository = Path(temp_dir)
+        if code_repository is None:
+            code_repository = Path.cwd()
+
+        directory_locked_toolset = FastMCPToolset.from_mcp_config(
+            mcp_config={"filesystem": read_only_filesystem_mcp(root_dir=code_repository)}
+        )
+
+        structure = get_structure(root_dir=code_repository, max_results=10)
+
+        repo_info = f"""
+        We've called get_structure on your behalf, here were the initial results to get you started:
+        {structure}
+        """
+
+        run_result = await code_investigation_agent.run(user_prompt=[task, repo_info], toolsets=[directory_locked_toolset])
+
+        return run_result.output
+
+
+investigate_code_tool = Tool.from_function(fn=investigate_code)
+
+server.add_tool(tool=investigate_code_tool)
+
+
+def run():
+    """Run the agent."""
+    server.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    server.run(transport="sse")

{fastmcp_agents_library_agent_simple_code-0.5.1.dist-info → fastmcp_agents_library_agent_simple_code-0.5.7.dist-info}/METADATA

@@ -1,7 +1,10 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.3
 Name: fastmcp-agents-library-agent-simple-code
-Version: 0.5.1
+Version: 0.5.7
 Summary: Agents for Simple Code
-Requires-Python: >=3.13
 Requires-Dist: fastmcp-ai-agent-bridge-pydantic-ai>=0.1.2
 Requires-Dist: gitpython>=3.1.44
+Requires-Dist: fastmcp-agents-library-mcp
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+

fastmcp_agents_library_agent_simple_code-0.5.7.dist-info/RECORD

@@ -0,0 +1,11 @@
+fastmcp_agents/library/agent/simple_code/__init__.py,sha256=ccaec5397000d34f1eb8ff399642a582cda38cbc2b3bca0efa2d593dbce3db6c,90
+fastmcp_agents/library/agent/simple_code/archive/base.py.disabled,sha256=7d6504f79b96062090f69c4b8626817bee6fda7c99a7c77ecaa5dc163511c21d,1744
+fastmcp_agents/library/agent/simple_code/archive/workspace.py.disabled,sha256=d295351841e1cc42926175e2a12fc91e13f00619df6af0976afac47bac3f8f20,659
+fastmcp_agents/library/agent/simple_code/helpers/filesystem.py,sha256=ced0f82524a1355cb6cc2a2a5f61b61a6c507455e49cdfdb2d0bf12695586757,3771
+fastmcp_agents/library/agent/simple_code/helpers/git.py,sha256=7d3264b3b29df8025752018a51e677201f8761c07f549559260de06e6a88502f,262
+fastmcp_agents/library/agent/simple_code/implement.py,sha256=5267dbc76ca6fdebeb76282846068cc96901503e3004da5ac65cb04e242c5e94,5801
+fastmcp_agents/library/agent/simple_code/investigate.py,sha256=c17855e96e54c426b8c77dbf378d3bb1080ffe88bd39a65ccc9bfe1a80987851,6460
+fastmcp_agents_library_agent_simple_code-0.5.7.dist-info/WHEEL,sha256=03f80d698bb4300c27bcafc3987ea73ef427fcb365e59e808e50d041a7f87b89,78
+fastmcp_agents_library_agent_simple_code-0.5.7.dist-info/entry_points.txt,sha256=6a34307eece27892df63ae0af789d4ee3b839693877c185288303c27b92b5ada,166
+fastmcp_agents_library_agent_simple_code-0.5.7.dist-info/METADATA,sha256=d7b5af111b2cd83faf728ace6518c73ebeaadb8eeb9c7df0c148bf87d1f5e687,314
+fastmcp_agents_library_agent_simple_code-0.5.7.dist-info/RECORD,,

fastmcp_agents_library_agent_simple_code-0.5.7.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.2
+Root-Is-Purelib: true
+Tag: py3-none-any

fastmcp_agents_library_agent_simple_code-0.5.7.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+fastmcp-agents-library-agent-simple-code = fastmcp_agents.library.agent.simple_code:run
+simple-code = fastmcp_agents.library.agent.simple_code:run
+

fastmcp_agents_library_agent_simple_code-0.5.1.dist-info/RECORD

@@ -1,4 +0,0 @@
-fastmcp_agents_library_agent_simple_code-0.5.1.dist-info/METADATA,sha256=Cq-2DBJOA0orqZGwnUi7thKP7xbGzTNYE76RI6jBsyE,231
-fastmcp_agents_library_agent_simple_code-0.5.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fastmcp_agents_library_agent_simple_code-0.5.1.dist-info/entry_points.txt,sha256=J00qZFTV53NbUERBJEIzUgWG5fyRNTn10uDfC33QkLo,78
-fastmcp_agents_library_agent_simple_code-0.5.1.dist-info/RECORD,,

fastmcp_agents_library_agent_simple_code-0.5.1.dist-info/WHEEL

@@ -1,4 +0,0 @@
-Wheel-Version: 1.0
-Generator: hatchling 1.27.0
-Root-Is-Purelib: true
-Tag: py3-none-any

fastmcp_agents_library_agent_simple_code-0.5.1.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-simple-code = fastmcp_agents.library.agent.simple_code:main