devtoolkit-mcp 0.1.0__py3-none-any.whl

devtoolkit_mcp/__init__.py

@@ -0,0 +1,2 @@
+def main() -> None:
+    print("Hello from devtoolkit-mcp!")

devtoolkit_mcp/server.py

@@ -0,0 +1,23 @@
+from fastmcp import FastMCP
+
+from devtoolkit_mcp.tools.repository import analyze_repository
+from devtoolkit_mcp.tools.explain_code import explain_code
+from devtoolkit_mcp.tools.analyze_error import analyze_error
+from devtoolkit_mcp.tools.check_dependencies import check_dependencies
+from devtoolkit_mcp.tools.run_tests import run_tests
+
+mcp = FastMCP("DevToolKit MCP")
+
+mcp.tool(analyze_repository)
+mcp.tool(explain_code)
+mcp.tool(analyze_error)
+mcp.tool(check_dependencies)
+mcp.tool(run_tests)
+
+
+def main():
+    """Main entry point for the DevToolKit MCP server"""
+    mcp.run()
+
+if __name__ == "__main__":
+    main()

devtoolkit_mcp/tools/analyze_error.py

@@ -0,0 +1,108 @@
+import re
+import builtins
+
+MAX_TRACEBACK_SIZE_BYTES = 100_000
+
+def _validate_error_input(error_text: str) -> str:
+    """validate and normalize the supplied python error text"""
+
+    if not isinstance(error_text, str):
+        raise ValueError("Error input must be a string.")
+    
+    if not error_text.strip():
+        raise ValueError("Error input cannot be empty.")
+    
+    if len(error_text.encode("utf-8")) > MAX_TRACEBACK_SIZE_BYTES:
+        raise ValueError("Error input exceeds the 100 KB size limit.")
+    
+    return error_text.strip()
+
+
+
+def _extract_exception(error_text: str) -> dict | None:
+    """Extract the exception type and message."""
+
+    lines = error_text.splitlines()
+
+    for line in reversed(lines):
+        line = line.strip()
+
+        if not line:
+            continue
+
+        match = re.match(
+            r"^([A-Za-z_][A-Za-z0-9_.]*)(?::\s*(.*))?$",
+            line,
+        )
+
+        if not match:
+            return None
+
+        exception_type = match.group(1)
+        message = match.group(2)
+
+        # A colon indicates an exception name followed by a message.
+        if message is None:
+            # For exceptions without messages, accept known built-in
+            # exception classes only.
+            builtin_exception = getattr(
+                builtins,
+                exception_type,
+                None,
+            )
+
+            if not (
+                isinstance(builtin_exception, type)
+                and issubclass(builtin_exception, BaseException)
+            ):
+                return None
+
+            message = ""
+
+        return {
+            "type": exception_type,
+            "message": message,
+        }
+
+    return None
+
+
+def _extract_traceback_frames(error_text: str) -> list[dict]:
+    """Extract file, line number, and function from traceback frames."""
+
+    frame_pattern = re.compile(
+        r'^\s*File "(.+)", line (\d+), in (.+)$'
+    )
+
+    frames = []
+
+    for line in error_text.splitlines():
+        match = frame_pattern.match(line)
+
+        if match:
+            frames.append({
+                "filename": match.group(1),
+                "line_number": int(match.group(2)),
+                "function": match.group(3),
+            })
+    
+    return frames
+
+
+def analyze_error(error_text: str) -> dict:
+    """Analyze Python errors and extract structured debugging information."""
+
+    validated_text = _validate_error_input(error_text)
+
+    exception = _extract_exception(validated_text)
+    frames = _extract_traceback_frames(validated_text)
+
+    error_location = frames[-1] if frames else None
+
+    return {
+        "exception": exception,
+        "frames": frames,
+        "error_location": error_location,
+        "has_traceback": bool(frames)
+    }
+

devtoolkit_mcp/tools/check_dependencies.py

@@ -0,0 +1,366 @@
+from pathlib import Path
+import tomllib
+from packaging.requirements import Requirement
+from packaging.version import InvalidVersion, Version
+import httpx
+
+
+MAX_MANIFEST_SIZE_BYTES = 1_000_000
+
+
+def _validate_project_path(project_path: str) -> Path:
+    """Validate the supplied project directory."""
+
+    if not isinstance(project_path, str):
+        raise ValueError("Project path must be a string.")
+
+    if not project_path.strip():
+        raise ValueError("Project path cannot be empty.")
+
+    root = Path(project_path).expanduser()
+
+    if not root.exists():
+        raise ValueError("Project directory does not exist.")
+
+    if root.is_symlink():
+        raise ValueError("Symbolic links are not supported.")
+
+    if not root.is_dir():
+        raise ValueError("Path must point to a directory.")
+
+    return root.resolve()
+
+
+SUPPORTED_MANIFESTS = (
+    "requirements.txt",
+    "pyproject.toml",
+)
+
+
+def _discover_manifests(project_root: Path) -> list[Path]:
+    """Find supported dependency manifest files in the project root."""
+
+    if not project_root.is_dir():
+        raise ValueError("Project root must be a directory.")
+
+    manifests = []
+
+    for filename in SUPPORTED_MANIFESTS:
+        manifest_path = project_root / filename
+
+        if manifest_path.is_symlink():
+            raise ValueError(
+                f"Symbolic links are not supported: {filename}"
+            )
+
+        if manifest_path.exists():
+            if not manifest_path.is_file():
+                raise ValueError(
+                    f"Manifest must be a file: {filename}"
+                )
+
+            manifests.append(manifest_path)
+
+    if not manifests:
+        raise ValueError("No supported dependency manifest found.")
+
+    return manifests
+
+
+## Parse the requirements.txt file
+def _parse_requirements_txt(manifest_path: Path) -> list[dict]:
+    """Prase dependencies from a requirements.txt file"""
+
+    dependencies = []
+
+    content = manifest_path.read_text(encoding='utf-8')
+
+    for line_number, line in enumerate(content.splitlines(), start=1):
+        line = line.strip()
+
+        if not line or line.startswith("#"):
+            continue
+
+        ## also skip pip options 
+        if line.startswith("-"):
+            continue
+
+        try:
+            requirement = Requirement(line)
+        except Exception as exc:
+            raise ValueError(
+                f"Invalid dependency on line {line_number} : {line}"
+            ) from exc
+        
+        dependencies.append({
+            "name": requirement.name,
+            "specifier": str(requirement.specifier)
+        })
+
+    return dependencies
+
+
+## Parse the pyproject.toml file
+def _parse_pyproject_toml(manifest_path: Path) -> list[dict]:
+    """Prase dependencies from a pep 621 pyproject.toml file"""
+
+    with manifest_path.open("rb") as file:
+        data = tomllib.load(file)
+
+    project = data.get("project", {})
+    dependency_lines = list(project.get("dependencies",[]))
+
+    optional_dependencies = project.get("optional-dependencies", {})
+
+    for optional_group in optional_dependencies.values():
+        dependency_lines.extend(optional_group)
+
+    dependencies = []
+
+    for line in dependency_lines:
+        try:
+            requirement =Requirement(line)
+        except Exception as exc:
+            raise ValueError(
+                f"Invalid dependency declaration: {line}"
+            ) from exc
+        
+        dependencies.append({
+            "name": requirement.name,
+            "specifier": str(requirement.specifier),
+        })
+    
+    return dependencies
+
+
+def _get_latest_version(package_name: str) -> dict:
+    """Fetch the latest published package version from PyPI"""
+
+    url = f"https://pypi.org/pypi/{package_name}/json"
+
+    try:
+        response = httpx.get(url, timeout=10)
+    except httpx.TimeoutException:
+        return {
+            "latest_version": None,
+            "status": "timeout",
+        }
+    except httpx.RequestError:
+        return{
+            "latest_version": None,
+            "status": "network_error",
+        }
+    
+    if response.status_code == 404:
+        return{
+            "latest_version": None,
+            "status": "package_not_found",
+        }
+    
+    try:
+        response.raise_for_status()
+        data = response.json()
+        latest_version = data["info"]["version"]
+
+        if not isinstance(latest_version, str) or not latest_version:
+            raise ValueError("Invalid version returned by PyPI")
+        
+        return {
+            "latest_version": latest_version,
+            "status":"success",
+        }
+    except (httpx.HTTPStatusError, ValueError, KeyError, TypeError):
+        return{
+            "latest_version": None,
+            "status": 'api_error',
+        }
+    
+
+def _compare_versions(
+    package_name: str,
+    specifier: str,
+    latest_version: str | None,
+) -> dict:
+    """Compare a declared exact version with the latest PyPI version."""
+
+    declared_version = None
+
+    # Only compare exact pinned versions for now.
+    if specifier.startswith("==") and not specifier.startswith("==="):
+        declared_version = specifier[2:]
+
+    if latest_version is None:
+        return {
+            "name": package_name,
+            "declared_version": declared_version,
+            "latest_version": None,
+            "update_available": None,
+            "status": "version_unavailable",
+        }
+
+    if declared_version is None:
+        return {
+            "name": package_name,
+            "declared_version": None,
+            "latest_version": latest_version,
+            "update_available": None,
+            "status": "unpinned_version",
+        }
+
+    try:
+        current = Version(declared_version)
+        latest = Version(latest_version)
+
+    except InvalidVersion:
+        return {
+            "name": package_name,
+            "declared_version": declared_version,
+            "latest_version": latest_version,
+            "update_available": None,
+            "status": "invalid_version",
+        }
+
+    return {
+        "name": package_name,
+        "declared_version": declared_version,
+        "latest_version": latest_version,
+        "update_available": latest > current,
+        "status": "success",
+    }
+
+
+def _check_vulnerabilities(
+    package_name: str,
+    version: str | None,
+) -> dict:
+    """Check a python package version against the OSV database"""
+
+    if not version:
+        return {
+            "vulnerabilities": [],
+            "status": "version_unavailable",
+        }
+    
+    url = "https://api.osv.dev/v1/query"
+
+    payload = {
+        "package": {
+            "name": package_name,
+            "ecosystem": "PyPI",
+        },
+        "version": version,
+    }
+
+    try:
+        response = httpx.post(
+            url,
+            json=payload,
+            timeout=10,
+        )
+
+        response.raise_for_status()
+        data = response.json()
+    
+    except httpx.TimeoutException:
+        return {
+            "vulnerabilities": [],
+            "status":"timeout",
+        }
+    except httpx.RequestError:
+        return{
+            "vulnerabilities": [],
+            "status": "network_error"
+        }
+    except (httpx.HTTPStatusError, ValueError):
+        return {
+            "vulnerabilities": [],
+            "status": "api_error",
+        }
+    
+    vulnerabilities = []
+
+    for vulnerability in data.get("vulns", []):
+        vulnerabilities.append({
+            "id": vulnerability.get("id"),
+            "summary": vulnerability.get("summary"),
+            "aliases": vulnerability.get("aliases",[]),
+        })
+    
+    return {
+        "vulnerabilities": vulnerabilities,
+        "status": "success"
+    }
+
+
+def check_dependencies(project_path: str) -> dict:
+    """Analyze project dependencies, latest versions, and known vulnerabilities"""
+
+    project_root = _validate_project_path(project_path=project_path)
+    manifest_paths = _discover_manifests(project_root)
+
+    dependencies = []
+
+    for manifest_path in manifest_paths:
+        if manifest_path.stat().st_size > MAX_MANIFEST_SIZE_BYTES:
+            raise ValueError(
+                f"Manifest exceeds the 1 MB size limit : {manifest_path.name}"
+            )
+        
+        try:
+            if manifest_path.name == "requirements.txt":
+                parsed = _parse_requirements_txt(manifest_path)
+            else:
+                parsed = _parse_pyproject_toml(manifest_path)
+        except (OSError, UnicodeDecodeError, tomllib.TOMLDecodeError) as exc:
+            raise ValueError(
+                f"Could not read manifest {manifest_path.name} : {exc}"
+            ) from exc
+        
+        for dependency in parsed:
+            dependencies.append({
+                **dependency,
+                "source": manifest_path.name
+            })
+        
+    ## avoid checking the same package and version twice
+    unique_dependencies = {}
+    for dependency in dependencies:
+        key = (
+            dependency["name"].lower(),
+            dependency["specifier"],
+        )
+        unique_dependencies.setdefault(key, dependency)
+    
+    results = []
+
+    for dependency in unique_dependencies.values():
+        name = dependency["name"]
+        specifier = dependency["specifier"]
+
+        pypi_result = _get_latest_version(name)
+
+        version_result = _compare_versions(
+            name, 
+            specifier,
+            pypi_result["latest_version"]
+        )
+
+        vulnerability_result = _check_vulnerabilities(
+            name,
+            version_result["declared_version"],
+        )
+
+        results.append({
+            **version_result,
+            "source": dependency["source"],
+            "pypi_status": pypi_result["status"],
+            "vulnerability_status": vulnerability_result["status"],
+            "vulnerabilities": vulnerability_result["vulnerabilities"],
+        })
+    
+    return {
+        "project_path": str(project_path),
+        "manifests": [path.name for path in manifest_paths],
+        "total_dependencies": len(results),
+        "dependencies": results,
+    }