Merge pull request #5 from martinmoldrup/features/add-extendable-configuration-options

Refactor configuration loading and enhance CLI functionality

Author: martinmoldrup

CHANGELOG.md

@@ -3,6 +3,9 @@ All notable changes to this project will be documented in this file.
 
 *NOTE:* Version 0.X.X might have breaking changes in bumps of the minor version number. This is because the project is still in early development and the API is not yet stable. It will still be marked clearly in the release notes.
 
+## [0.4.0] - 14-09-2025
+- Add ability to customize configurations in a toolit.ini or pyproject.toml file in the project root. Makes the devtools folder configurable, and allows plugins to add their own configurations.
+
 ## [0.3.0] - 09-09-2025
 - Added toolit `create-vscode-tasks-json` CLI command to create the `.vscode/tasks.json` file from the command line.
 - Improved error handling and user feedback when the `devtools` folder does not exist.

README.md

@@ -36,6 +36,14 @@ toolit --help  # To see available commands
 toolit my-command --to_print "Hello, Toolit!"  # To run your command
 ```
 
+### Customizing the DevTools Folder
+By default, Toolit looks for a folder named `devtools` in the project root. You can customize this by creating a `toolit.ini` or use your `pyproject.toml` file in your project root with the following content:
+
+```toml
+[toolit]
+tools_folder = "tools"
+```
+
 ## Create the VS code tasks.json file
 You can automatically create a `tasks.json` file for Visual Studio Code to run your ToolIt commands directly from the editor. This is useful for integrating your development tools into your workflow.
 
@@ -76,10 +84,13 @@ Toolit supports a plugin system that allows you to create and share your own too
 
 To create a plugin, follow these steps:
 1. Create a new Python package for your plugin. You can use tools like `setuptools`, `poetry` or `uv` to set up your package structure.
-2. In your package, create a module where you define your tools using the `@tool` decorator.
-3. Make sure to include `toolit` as a dependency in your package's `setup.py` or `pyproject.toml`.
-4. Register your plugin with Toolit by adding an entry point in your `setup.py` or `pyproject.toml`, so Toolit can discover your tools when the package is installed. The entry point is called `toolit_plugins`.
-5. Publish your package to PyPI or install it from a git repository where you need it.
+2. In your package, create one or several modules where you define your tools using the `@tool` decorator.
+3. You can include your own user-configurations, and load them using the `get_config_value` function from the `toolit.config` module.
+4. Make sure to include `toolit` as a dependency in your package's `setup.py` or `pyproject.toml`.
+5. Register your plugin with Toolit by adding an entry point in your `setup.py` or `pyproject.toml`, so Toolit can discover your tools when the package is installed. The entry point is called `toolit_plugins`.
+6. Publish your package to PyPI or install it from a git repository where you need it.
+
+See an example plugin here: [toolit-azure-devops-trunk-based-branching](https://github.com/martinmoldrup/toolit-azure-devops-trunk-based-branching)
 
 ## Contributing
 We welcome contributions to Toolit! If you have ideas for new features, improvements, or bug fixes, please open an issue or submit a pull request on our GitHub repository. We appreciate your feedback and support in making Toolit even better for the community.

pyproject.toml

@@ -1,11 +1,12 @@
 [project]  
 name = "toolit"  
-version = "0.3.0"  
+version = "0.4.0"  
 description = "MCP Server, Typer CLI and vscode tasks in one, provides an easy way to configure your own DevTools and python scripts in a project."
 readme = "README.md"
 requires-python = ">=3.9"  # mcp[cli] requires Python 3.10+
 dependencies = [
-    "typer"
+    "toml",
+    "typer",
 ]
 classifiers = [  
     "Framework :: Pytest",
@@ -44,7 +45,7 @@ dev = [
     "pytest-asyncio>=0.26.0",
     "requests>=2.32.4",
     "ruff>=0.11.13",
-    "toml>=0.10.2",
+    "types-toml>=0.10.8.20240310",
 ]  
 
 [project.optional-dependencies]

tests/configuration_loader_test.py

@@ -0,0 +1,96 @@
+"""Tests for configuration loading functions in toolit.config."""
+
+import toml
+import pytest
+import pathlib
+from toolit import config
+from toolit.constants import ConfigFileKeys
+
+
+def create_toml_file(path: pathlib.Path, data: dict) -> None:
+    """Helper to create a TOML file with given data."""
+    with open(path, "w", encoding="utf-8") as f:
+        toml.dump(data, f)
+
+
+def test_load_ini_config_returns_empty_for_missing_file(tmp_path: pathlib.Path) -> None:
+    """Test load_ini_config returns empty dict if file does not exist."""
+    file_path: pathlib.Path = tmp_path / "toolit.ini"
+    result: dict[str, str] = config.load_ini_config(file_path)
+    assert result == {}
+
+
+def test_load_ini_config_reads_toolit_section(tmp_path: pathlib.Path) -> None:
+    """Test load_ini_config reads 'toolit' section from ini file."""
+    file_path: pathlib.Path = tmp_path / "toolit.ini"
+    data: dict[str, dict[str, str]] = {"toolit": {"foo": "bar"}}
+    create_toml_file(file_path, data)
+    result: dict[str, str] = config.load_ini_config(file_path)
+    assert result == {"foo": "bar"}
+
+
+def test_load_ini_config_reads_flat_config(tmp_path: pathlib.Path) -> None:
+    """Test load_ini_config returns flat config if no 'toolit' section."""
+    file_path: pathlib.Path = tmp_path / "toolit.ini"
+    data: dict[str, str] = {"foo": "bar"}
+    create_toml_file(file_path, data)
+    result: dict[str, str] = config.load_ini_config(file_path)
+    assert result == {"foo": "bar"}
+
+
+def test_load_pyproject_config_returns_empty_for_missing_file(tmp_path: pathlib.Path) -> None:
+    """Test load_pyproject_config returns empty dict if file does not exist."""
+    file_path: pathlib.Path = tmp_path / "pyproject.toml"
+    result: dict[str, str] = config.load_pyproject_config(file_path)
+    assert result == {}
+
+
+def test_load_pyproject_config_reads_toolit_section(tmp_path: pathlib.Path) -> None:
+    """Test load_pyproject_config reads 'toolit' section from pyproject.toml."""
+    file_path: pathlib.Path = tmp_path / "pyproject.toml"
+    data: dict[str, dict[str, str]] = {"toolit": {"foo": "bar"}}
+    create_toml_file(file_path, data)
+    result: dict[str, str] = config.load_pyproject_config(file_path)
+    assert result == {"foo": "bar"}
+
+
+def test_load_pyproject_config_returns_empty_if_no_toolit_section(tmp_path: pathlib.Path) -> None:
+    """Test load_pyproject_config returns empty dict if no 'toolit' section."""
+    file_path: pathlib.Path = tmp_path / "pyproject.toml"
+    data: dict[str, str] = {"foo": "bar"}
+    create_toml_file(file_path, data)
+    result: dict[str, str] = config.load_pyproject_config(file_path)
+    assert result == {}
+
+
+def test_get_config_value_returns_value(monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path) -> None:
+    """Test get_config_value returns correct value from config."""
+    config_data: dict[str, str] = {"mykey": "myvalue"}
+    monkeypatch.setattr(config, "_load_config", lambda: config_data)
+    result: str | None = config.get_config_value("mykey")
+    assert result == "myvalue"
+
+
+def test_get_config_value_returns_default(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Test get_config_value returns default if key not found."""
+    monkeypatch.setattr(config, "_load_config", lambda: {})
+    result: str | None = config.get_config_value("missing", default="defaultval")
+    assert result == "defaultval"
+
+
+def test_load_devtools_folder_returns_configured_path(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Test load_devtools_folder returns configured folder path."""
+    folder: str = "custom_tools_folder"
+    monkeypatch.setattr(
+        config,
+        "get_config_value",
+        lambda key, default=None: folder if key == ConfigFileKeys.TOOLS_FOLDER else default,
+    )
+    result: pathlib.Path = config.load_devtools_folder()
+    assert str(result) == folder
+
+
+def test_load_devtools_folder_returns_default_path() -> None:
+    """Test load_devtools_folder returns default folder path if not configured."""
+    result: pathlib.Path = config.load_devtools_folder()
+    assert str(result) == ConfigFileKeys.TOOLS_FOLDER_DEFAULT

tests/conftest.py

@@ -0,0 +1,4 @@
+import sys
+import os
+# Add the root directory to the path
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))

toolit/__init__.py

@@ -1,5 +1,9 @@
 """Public API for the package."""
 
+from .config import get_config_value
 from .decorators import tool
 
-__all__ = ["tool"]
+__all__ = [
+    "get_config_value",
+    "tool",
+]

toolit/cli.py

@@ -1,11 +1,10 @@
 """CLI entry point for the toolit package."""
-import pathlib
 from .auto_loader import load_tools_from_folder, load_tools_from_plugins, register_command
+from .config import load_devtools_folder
 from .create_apps_and_register import app
 from .create_tasks_json import create_vscode_tasks_json
 
-PATH = pathlib.Path() / "devtools"
-load_tools_from_folder(PATH)
+load_tools_from_folder(load_devtools_folder())
 load_tools_from_plugins()
 register_command(create_vscode_tasks_json)
 

toolit/config.py

@@ -0,0 +1,70 @@
+"""
+Load configurations for packages.
+
+The toolit package lets the user change configurations (azure devops pipeline id, folder for tools, etc.).
+User can define the configuration by either:
+- Creating a `toolit.ini` toml file in the current working directory
+- Adding to the `pyproject.toml` file in the current working directory
+"""
+from __future__ import annotations
+
+import toml
+import pathlib
+from .constants import ConfigFileKeys
+from functools import lru_cache
+from typing import Callable, overload
+
+
+def load_ini_config(file_path: pathlib.Path) -> dict[str, str]:
+    """Load configuration from a toolit.ini file."""
+    if not file_path.is_file():
+        return {}
+    configurations = toml.load(file_path)
+    if "toolit" in configurations:
+        return configurations["toolit"]
+    return configurations
+
+
+def load_pyproject_config(file_path: pathlib.Path) -> dict[str, str]:
+    """Load configuration from a pyproject.toml file."""
+    if not file_path.is_file():
+        return {}
+    config = toml.load(file_path)
+    return config.get("toolit", {})
+
+
+CONFIG_FILENAMES: dict[str, Callable[[pathlib.Path], dict[str, str]]] = {
+    "toolit.ini": load_ini_config,
+    "pyproject.toml": load_pyproject_config,
+}
+
+
+@lru_cache(maxsize=1)
+def _load_config() -> dict[str, str]:
+    """Load configuration from toolit.ini or pyproject.toml, only once."""
+    config: dict[str, str] = {}
+    for filename, loader in CONFIG_FILENAMES.items():
+        file_path = pathlib.Path.cwd() / filename
+        file_config = loader(file_path)
+        config.update(file_config)
+
+    return config
+
+
+@overload
+def get_config_value(key: str, default: None = None) -> str | None: ...
+
+@overload
+def get_config_value(key: str, default: str) -> str: ...
+
+
+def get_config_value(key: str, default: str | None = None) -> str | None:
+    """Get a configuration value by key with type-safe default."""
+    config: dict[str, str] = _load_config()
+    return config.get(key, default)
+
+
+def load_devtools_folder() -> pathlib.Path:
+    """Load the tools folder path from configuration or use default."""
+    folder = get_config_value(ConfigFileKeys.TOOLS_FOLDER, ConfigFileKeys.TOOLS_FOLDER_DEFAULT)
+    return pathlib.Path(folder)

toolit/constants.py

@@ -5,6 +5,13 @@
 MARKER_TOOL = "__toolit_tool_type__"
 
 
+class ConfigFileKeys:
+    """Namespace for the different configuration file keys for user configuration."""
+
+    TOOLS_FOLDER: str = "tools_folder"
+    TOOLS_FOLDER_DEFAULT: str = "devtools"
+
+
 class ToolitTypesEnum(enum.Enum):
     """Enum for the different types of toolit tools."""
 

toolit/create_tasks_json.py

@@ -12,11 +12,12 @@
     tool_group_strategy,
     tool_strategy,
 )
+from toolit.config import load_devtools_folder
 from toolit.constants import ToolitTypesEnum
 from types import FunctionType
 from typing import Any
 
-PATH: pathlib.Path = pathlib.Path() / "devtools"
+PATH: pathlib.Path = load_devtools_folder()
 output_file_path: pathlib.Path = pathlib.Path() / ".vscode" / "tasks.json"