fastmcp-agents-library-agent-simple-code 0.5.1__tar.gz

fastmcp_agents_library_agent_simple_code-0.5.1/.gitignore

@@ -0,0 +1,183 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.env.*
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+secrets
+
+prompt_suggestions
+agent-working-dir
+
+**/*.bak
+
+storage

fastmcp_agents_library_agent_simple_code-0.5.1/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: fastmcp-agents-library-agent-simple-code
+Version: 0.5.1
+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

fastmcp_agents_library_agent_simple_code-0.5.1/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-0.5.1/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-0.5.1/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-0.5.1/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-0.5.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-0.5.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-0.5.1/fastmcp_agents/library/agent/simple_code/investigate.py

@@ -0,0 +1,158 @@
+"""
+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)
+
+if __name__ == "__main__":
+    server.run(transport="sse")

fastmcp_agents_library_agent_simple_code-0.5.1/pyproject.toml

@@ -0,0 +1,51 @@
+[project]
+name = "fastmcp-agents-library-agent-simple-code"
+version = "0.5.1"
+description = "Agents for Simple Code"
+readme = "README.md"
+requires-python = ">=3.13"
+
+dependencies = [
+    "fastmcp-ai-agent-bridge-pydantic-ai>=0.1.2",
+    "gitpython>=3.1.44",
+]
+
+[project.scripts]
+simple-code = "fastmcp_agents.library.agent.simple_code:main"
+
+[tool.uv.sources]
+fastmcp-agents-library-mcp = { workspace = true }
+
+[dependency-groups]
+dev = [
+    "pytest>=8.4.1",
+    "pytest-asyncio>=1.1.0",
+    "pytest-dotenv>=0.5.2",
+    "pytest-env>=1.1.5",
+    "ruff>=0.12.4",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/fastmcp_agents"]
+
+[tool.hatch.build.targets.sdist]
+packages = ["src/fastmcp_agents"]
+
+[tool.pytest.ini_options]
+env = ["COLUMNS=120"]
+
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+addopts = "-s -vvv"  # Disable Captures
+
+
+[tool.ruff]
+extend="../../../pyproject.toml"
+
+[tool.pyright]
+extends = "../../../pyproject.toml"