devsper 2.1.6__py3-none-any.whl

devsper/tools/code_intelligence/test_coverage_estimator.py

@@ -0,0 +1,62 @@
+"""Estimate test coverage: ratio of test files to source files and test/source layout."""
+
+from pathlib import Path
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class TestCoverageEstimatorTool(Tool):
+    """
+    Estimate test coverage heuristically: count test files vs source files and list test dirs.
+    """
+
+    name = "test_coverage_estimator"
+    description = "Estimate test coverage: test file count vs source file count and layout."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "path": {"type": "string", "description": "Root path of the repo"},
+            "test_dir_names": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Dir names that indicate tests (default: tests, test)",
+            },
+        },
+        "required": ["path"],
+    }
+
+    def run(self, **kwargs) -> str:
+        path = kwargs.get("path")
+        test_dir_names = kwargs.get("test_dir_names") or ["tests", "test"]
+        if not path or not isinstance(path, str):
+            return "Error: path must be a non-empty string"
+        root = Path(path).resolve()
+        if not root.exists() or not root.is_dir():
+            return f"Error: path must be an existing directory: {path}"
+        test_dirs = set(n.lower() for n in test_dir_names if isinstance(n, str))
+        source_files = []
+        test_files = []
+        for p in root.rglob("*.py"):
+            if not p.is_file():
+                continue
+            rel = p.relative_to(root)
+            parts = [x.lower() for x in rel.parts]
+            is_test = any(d in parts for d in test_dirs) or rel.name.startswith("test_") or rel.name.endswith("_test.py")
+            if is_test:
+                test_files.append(str(rel))
+            else:
+                source_files.append(str(rel))
+        ratio = len(test_files) / len(source_files) if source_files else 0
+        lines = [
+            "Test coverage estimate",
+            "=" * 40,
+            f"Source files: {len(source_files)}",
+            f"Test files: {len(test_files)}",
+            f"Ratio (test/source): {ratio:.2f}",
+            "Test dirs/files (sample): " + ", ".join(test_files[:15]),
+        ]
+        return "\n".join(lines)
+
+
+register(TestCoverageEstimatorTool())

devsper/tools/coding/__init__.py

@@ -0,0 +1,12 @@
+"""Coding tools: run Python, format, lint, analyze, refactor, etc."""
+
+from devsper.tools.coding.run_python import RunPythonTool
+from devsper.tools.coding.format_python import FormatPythonTool
+from devsper.tools.coding.lint_python import LintPythonTool
+from devsper.tools.coding.generate_unit_tests import GenerateUnitTestsTool
+from devsper.tools.coding.analyze_code_complexity import AnalyzeCodeComplexityTool
+from devsper.tools.coding.extract_functions import ExtractFunctionsTool
+from devsper.tools.coding.generate_docstrings import GenerateDocstringsTool
+from devsper.tools.coding.refactor_function import RefactorFunctionTool
+from devsper.tools.coding.dependency_analyzer import DependencyAnalyzerTool
+from devsper.tools.coding.repo_structure_map import RepoStructureMapTool

devsper/tools/coding/analyze_code_complexity.py

@@ -0,0 +1,48 @@
+"""Analyze code complexity: line count, cyclomatic complexity approximation, nesting."""
+
+import ast
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class AnalyzeCodeComplexityTool(Tool):
+    """Report simple complexity metrics: lines, number of branches, max nesting."""
+
+    name = "analyze_code_complexity"
+    description = "Analyze Python code: line count, branch count, nesting depth."
+    input_schema = {
+        "type": "object",
+        "properties": {"code": {"type": "string", "description": "Python code to analyze"}},
+        "required": ["code"],
+    }
+
+    def run(self, **kwargs) -> str:
+        code = kwargs.get("code")
+        if not code or not isinstance(code, str):
+            return "Error: code must be a non-empty string"
+        try:
+            tree = ast.parse(code)
+            lines = len(code.splitlines())
+            branches = 0
+            max_nest = 0
+
+            def visit(node: ast.AST, depth: int) -> None:
+                nonlocal branches, max_nest
+                max_nest = max(max_nest, depth)
+                if isinstance(node, (ast.If, ast.While, ast.For, ast.With, ast.Try, ast.Assert)):
+                    branches += 1
+                if isinstance(node, ast.comprehension):
+                    branches += 1
+                for child in ast.iter_child_nodes(node):
+                    visit(child, depth + 1)
+
+            visit(tree, 0)
+            return f"Lines: {lines}\nBranches (approx): {branches}\nMax nesting depth: {max_nest}"
+        except SyntaxError as e:
+            return f"Syntax error: {e}"
+        except Exception as e:
+            return f"Error: {e}"
+
+
+register(AnalyzeCodeComplexityTool())

devsper/tools/coding/dependency_analyzer.py

@@ -0,0 +1,42 @@
+"""Analyze import dependencies in Python code."""
+
+import ast
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class DependencyAnalyzerTool(Tool):
+    """List top-level import names (modules and aliases) from Python code."""
+
+    name = "dependency_analyzer"
+    description = "Extract import statements and dependency names from Python code."
+    input_schema = {
+        "type": "object",
+        "properties": {"code": {"type": "string", "description": "Python source code"}},
+        "required": ["code"],
+    }
+
+    def run(self, **kwargs) -> str:
+        code = kwargs.get("code")
+        if not code or not isinstance(code, str):
+            return "Error: code must be a non-empty string"
+        try:
+            tree = ast.parse(code)
+            imports = []
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    for alias in node.names:
+                        imports.append(f"import {alias.name}" + (f" as {alias.asname}" if alias.asname else ""))
+                elif isinstance(node, ast.ImportFrom):
+                    mod = node.module or ""
+                    names = ", ".join(a.name + (f" as {a.asname}" if a.asname else "") for a in node.names)
+                    imports.append(f"from {mod} import {names}")
+            return "\n".join(imports) if imports else "No imports found."
+        except SyntaxError as e:
+            return f"Syntax error: {e}"
+        except Exception as e:
+            return f"Error: {e}"
+
+
+register(DependencyAnalyzerTool())

devsper/tools/coding/extract_functions.py

@@ -0,0 +1,38 @@
+"""Extract function names and signatures from Python code."""
+
+import ast
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class ExtractFunctionsTool(Tool):
+    """List function names and their parameter names from Python code."""
+
+    name = "extract_functions"
+    description = "Extract function names and parameter lists from Python code."
+    input_schema = {
+        "type": "object",
+        "properties": {"code": {"type": "string", "description": "Python source code"}},
+        "required": ["code"],
+    }
+
+    def run(self, **kwargs) -> str:
+        code = kwargs.get("code")
+        if not code or not isinstance(code, str):
+            return "Error: code must be a non-empty string"
+        try:
+            tree = ast.parse(code)
+            result = []
+            for node in ast.walk(tree):
+                if isinstance(node, ast.FunctionDef):
+                    args = [a.arg for a in node.args.args]
+                    result.append(f"{node.name}({', '.join(args)})")
+            return "\n".join(result) if result else "No functions found."
+        except SyntaxError as e:
+            return f"Syntax error: {e}"
+        except Exception as e:
+            return f"Error: {e}"
+
+
+register(ExtractFunctionsTool())

devsper/tools/coding/format_python.py

@@ -0,0 +1,50 @@
+"""Format Python code using black if available, else return as-is."""
+
+import subprocess
+import tempfile
+from pathlib import Path
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class FormatPythonTool(Tool):
+    """Format Python code. Uses black if installed, otherwise returns code unchanged."""
+
+    name = "format_python"
+    description = "Format Python code with black. Returns formatted code or original if black not installed."
+    input_schema = {
+        "type": "object",
+        "properties": {"code": {"type": "string", "description": "Python code to format"}},
+        "required": ["code"],
+    }
+
+    def run(self, **kwargs) -> str:
+        code = kwargs.get("code")
+        if code is None:
+            return "Error: code is required"
+        if not isinstance(code, str):
+            code = str(code)
+        try:
+            with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+                f.write(code)
+                path = f.name
+            try:
+                result = subprocess.run(
+                    ["black", "-q", path],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                )
+                if result.returncode == 0:
+                    return Path(path).read_text(encoding="utf-8")
+                return code
+            finally:
+                Path(path).unlink(missing_ok=True)
+        except FileNotFoundError:
+            return code
+        except Exception as e:
+            return f"Error: {e}\nOriginal code:\n{code}"
+
+
+register(FormatPythonTool())

devsper/tools/coding/generate_docstrings.py

@@ -0,0 +1,40 @@
+"""Add or suggest docstring placeholders for functions that lack them."""
+
+import ast
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class GenerateDocstringsTool(Tool):
+    """List functions missing docstrings and suggest a one-line placeholder."""
+
+    name = "generate_docstrings"
+    description = "Find functions without docstrings and suggest a placeholder docstring."
+    input_schema = {
+        "type": "object",
+        "properties": {"code": {"type": "string", "description": "Python source code"}},
+        "required": ["code"],
+    }
+
+    def run(self, **kwargs) -> str:
+        code = kwargs.get("code")
+        if not code or not isinstance(code, str):
+            return "Error: code must be a non-empty string"
+        try:
+            tree = ast.parse(code)
+            result = []
+            for node in ast.walk(tree):
+                if isinstance(node, ast.FunctionDef):
+                    doc = ast.get_docstring(node)
+                    if not doc:
+                        args = [a.arg for a in node.args.args]
+                        result.append(f"{node.name}({', '.join(args)}): \"\"\"TODO: describe.\"\"\"")
+            return "\n".join(result) if result else "All functions have docstrings."
+        except SyntaxError as e:
+            return f"Syntax error: {e}"
+        except Exception as e:
+            return f"Error: {e}"
+
+
+register(GenerateDocstringsTool())

devsper/tools/coding/generate_unit_tests.py

@@ -0,0 +1,42 @@
+"""Generate skeleton unit test code for a function (template-based)."""
+
+import ast
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class GenerateUnitTestsTool(Tool):
+    """Generate a minimal pytest-style test skeleton for a function. No LLM."""
+
+    name = "generate_unit_tests"
+    description = "Generate skeleton pytest tests for a function. Uses function name and params."
+    input_schema = {
+        "type": "object",
+        "properties": {"code": {"type": "string", "description": "Python function or module code"}},
+        "required": ["code"],
+    }
+
+    def run(self, **kwargs) -> str:
+        code = kwargs.get("code")
+        if not code or not isinstance(code, str):
+            return "Error: code must be a non-empty string"
+        try:
+            tree = ast.parse(code)
+            tests = []
+            for node in ast.walk(tree):
+                if isinstance(node, ast.FunctionDef):
+                    params = [a.arg for a in node.args.args if a.arg != "self"]
+                    test_name = f"test_{node.name}"
+                    args_str = ", ".join(repr(f"arg_{p}") for p in params)
+                    tests.append(f"def {test_name}():\n    assert {node.name}({args_str}) is not None  # TODO\n")
+            if not tests:
+                return "No function definitions found in code."
+            return "import pytest\n\n" + "\n".join(tests)
+        except SyntaxError as e:
+            return f"Syntax error: {e}"
+        except Exception as e:
+            return f"Error: {e}"
+
+
+register(GenerateUnitTestsTool())

devsper/tools/coding/lint_python.py

@@ -0,0 +1,51 @@
+"""Lint Python code using ruff if available."""
+
+import subprocess
+import tempfile
+from pathlib import Path
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class LintPythonTool(Tool):
+    """Lint Python code. Uses ruff if installed; otherwise returns a message."""
+
+    name = "lint_python"
+    description = "Lint Python code with ruff. Returns lint output or suggests installing ruff."
+    input_schema = {
+        "type": "object",
+        "properties": {"code": {"type": "string", "description": "Python code to lint"}},
+        "required": ["code"],
+    }
+
+    def run(self, **kwargs) -> str:
+        code = kwargs.get("code")
+        if code is None:
+            return "Error: code is required"
+        if not isinstance(code, str):
+            code = str(code)
+        try:
+            with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+                f.write(code)
+                path = f.name
+            try:
+                result = subprocess.run(
+                    ["ruff", "check", path],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                )
+                out = result.stdout or result.stderr or ""
+                if result.returncode == 0 and not out:
+                    return "No issues found."
+                return out.strip() or "No output from ruff."
+            finally:
+                Path(path).unlink(missing_ok=True)
+        except FileNotFoundError:
+            return "ruff not installed. Install with: pip install ruff"
+        except Exception as e:
+            return f"Error: {e}"
+
+
+register(LintPythonTool())

devsper/tools/coding/refactor_function.py

@@ -0,0 +1,41 @@
+"""Suggest a refactor: rename and normalize style (placeholder / heuristic)."""
+
+import ast
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class RefactorFunctionTool(Tool):
+    """Suggest simple refactors: PEP8 name style, single return. No code rewrite."""
+
+    name = "refactor_function"
+    description = "Suggest refactoring tips for a function: naming, single return."
+    input_schema = {
+        "type": "object",
+        "properties": {"code": {"type": "string", "description": "Python function code"}},
+        "required": ["code"],
+    }
+
+    def run(self, **kwargs) -> str:
+        code = kwargs.get("code")
+        if not code or not isinstance(code, str):
+            return "Error: code must be a non-empty string"
+        try:
+            tree = ast.parse(code)
+            tips = []
+            for node in ast.walk(tree):
+                if isinstance(node, ast.FunctionDef):
+                    if not node.name.islower() and "_" not in node.name:
+                        tips.append(f"Consider snake_case for function name: {node.name}")
+                    returns = sum(1 for n in ast.walk(node) if isinstance(n, ast.Return))
+                    if returns > 1:
+                        tips.append("Multiple returns: consider single exit point.")
+            return "\n".join(tips) if tips else "No refactor suggestions."
+        except SyntaxError as e:
+            return f"Syntax error: {e}"
+        except Exception as e:
+            return f"Error: {e}"
+
+
+register(RefactorFunctionTool())

devsper/tools/coding/repo_structure_map.py

@@ -0,0 +1,54 @@
+"""Map directory structure (files and folders) under a path."""
+
+from pathlib import Path
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class RepoStructureMapTool(Tool):
+    """List directory tree structure (files and dirs) under a given path."""
+
+    name = "repo_structure_map"
+    description = "Map repo/directory structure. Returns indented list of files and dirs."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "path": {"type": "string", "description": "Root path to map"},
+            "max_depth": {"type": "integer", "description": "Max depth (default 4)"},
+        },
+        "required": ["path"],
+    }
+
+    def run(self, **kwargs) -> str:
+        path = kwargs.get("path")
+        max_depth = kwargs.get("max_depth", 4)
+        if not path or not isinstance(path, str):
+            return "Error: path must be a non-empty string"
+        if not isinstance(max_depth, int) or max_depth < 1:
+            max_depth = 4
+        root = Path(path)
+        if not root.exists() or not root.is_dir():
+            return f"Error: path must be an existing directory: {path}"
+        lines = []
+
+        def walk(p: Path, prefix: str, depth: int) -> None:
+            if depth > max_depth:
+                return
+            try:
+                entries = sorted(p.iterdir(), key=lambda x: (not x.is_dir(), x.name.lower()))
+            except PermissionError:
+                return
+            for i, e in enumerate(entries):
+                is_last = i == len(entries) - 1
+                branch = "└── " if is_last else "├── "
+                lines.append(prefix + branch + e.name)
+                if e.is_dir():
+                    ext = "    " if is_last else "│   "
+                    walk(e, prefix + ext, depth + 1)
+        lines.append(root.name + "/")
+        walk(root, "", 1)
+        return "\n".join(lines)
+
+
+register(RepoStructureMapTool())

devsper/tools/coding/run_python.py

@@ -0,0 +1,53 @@
+"""Run Python code in a subprocess and return stdout/stderr."""
+
+import subprocess
+import tempfile
+from pathlib import Path
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class RunPythonTool(Tool):
+    """Execute Python code in a subprocess. Returns combined stdout and stderr."""
+
+    name = "run_python"
+    description = "Run Python code string in a subprocess. Returns stdout and stderr."
+    input_schema = {
+        "type": "object",
+        "properties": {"code": {"type": "string", "description": "Python code to execute"}},
+        "required": ["code"],
+    }
+
+    def run(self, **kwargs) -> str:
+        code = kwargs.get("code")
+        if not code or not isinstance(code, str):
+            return "Error: code must be a non-empty string"
+        try:
+            with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+                f.write(code)
+                path = f.name
+            try:
+                result = subprocess.run(
+                    ["python", path],
+                    capture_output=True,
+                    text=True,
+                    timeout=30,
+                    cwd=Path(path).parent,
+                )
+                out = result.stdout or ""
+                err = result.stderr or ""
+                if err:
+                    out = out + "\n--- stderr ---\n" + err
+                if result.returncode != 0:
+                    out = f"[exit code {result.returncode}]\n" + out
+                return out.strip() or "(no output)"
+            finally:
+                Path(path).unlink(missing_ok=True)
+        except subprocess.TimeoutExpired:
+            return "Error: execution timed out (30s)"
+        except Exception as e:
+            return f"Error: {e}"
+
+
+register(RunPythonTool())

devsper/tools/data/__init__.py

@@ -0,0 +1,12 @@
+"""Data tools: CSV, JSON, dataframe stats, schema, sampling, etc."""
+
+from devsper.tools.data.csv_summary import CsvSummaryTool
+from devsper.tools.data.json_query import JsonQueryTool
+from devsper.tools.data.json_pretty_print import JsonPrettyPrintTool
+from devsper.tools.data.dataframe_stats import DataframeStatsTool
+from devsper.tools.data.dataframe_filter import DataframeFilterTool
+from devsper.tools.data.dataframe_groupby import DataframeGroupbyTool
+from devsper.tools.data.column_type_detection import ColumnTypeDetectionTool
+from devsper.tools.data.missing_value_report import MissingValueReportTool
+from devsper.tools.data.dataset_sampling import DatasetSamplingTool
+from devsper.tools.data.dataset_schema import DatasetSchemaTool

devsper/tools/data/column_type_detection.py

@@ -0,0 +1,64 @@
+"""Detect column types (numeric, string, etc.) for a CSV. Works with stdlib or pandas."""
+
+import csv
+from pathlib import Path
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class ColumnTypeDetectionTool(Tool):
+    """Infer column types from a CSV: int, float, or str based on sample rows."""
+
+    name = "column_type_detection"
+    description = "Detect column types (int, float, str) from a CSV file."
+    input_schema = {
+        "type": "object",
+        "properties": {"path": {"type": "string", "description": "Path to CSV file"}},
+        "required": ["path"],
+    }
+
+    def run(self, **kwargs) -> str:
+        path = kwargs.get("path")
+        if not path or not isinstance(path, str):
+            return "Error: path must be a non-empty string"
+        p = Path(path)
+        if not p.exists() or not p.is_file():
+            return f"Error: file not found: {path}"
+        try:
+            with p.open(encoding="utf-8", errors="replace", newline="") as f:
+                reader = csv.reader(f)
+                rows = list(reader)
+            if not rows:
+                return "Empty CSV."
+            header = rows[0]
+            data = rows[1:][:100]
+            result = []
+            for col_idx, col_name in enumerate(header):
+                values = [row[col_idx] if col_idx < len(row) else "" for row in data]
+                types = []
+                for v in values:
+                    v = (v or "").strip()
+                    if not v:
+                        continue
+                    try:
+                        int(v)
+                        types.append("int")
+                    except ValueError:
+                        try:
+                            float(v)
+                            types.append("float")
+                        except ValueError:
+                            types.append("str")
+                inferred = "str"
+                if all(t == "int" for t in types):
+                    inferred = "int"
+                elif types and "str" not in types:
+                    inferred = "float"
+                result.append(f"{col_name}: {inferred}")
+            return "\n".join(result)
+        except Exception as e:
+            return f"Error: {e}"
+
+
+register(ColumnTypeDetectionTool())

devsper/tools/data/csv_summary.py

@@ -0,0 +1,52 @@
+"""Summarize a CSV file: row count, column names, sample rows."""
+
+import csv
+from pathlib import Path
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class CsvSummaryTool(Tool):
+    """Summarize a CSV file: columns, row count, and first few rows."""
+
+    name = "csv_summary"
+    description = "Summarize a CSV file: column names, row count, and first N rows."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "path": {"type": "string", "description": "Path to the CSV file"},
+            "sample_rows": {"type": "integer", "description": "Number of rows to show (default 5)"},
+        },
+        "required": ["path"],
+    }
+
+    def run(self, **kwargs) -> str:
+        path = kwargs.get("path")
+        sample_rows = kwargs.get("sample_rows", 5)
+        if not path or not isinstance(path, str):
+            return "Error: path must be a non-empty string"
+        if not isinstance(sample_rows, int) or sample_rows < 1:
+            sample_rows = 5
+        p = Path(path)
+        if not p.exists() or not p.is_file():
+            return f"Error: file not found: {path}"
+        try:
+            with p.open(encoding="utf-8", errors="replace", newline="") as f:
+                reader = csv.reader(f)
+                rows = list(reader)
+            if not rows:
+                return "Empty CSV."
+            header = rows[0]
+            data = rows[1:]
+            n = len(data)
+            sample = data[:sample_rows]
+            lines = [f"Columns: {', '.join(header)}", f"Row count: {n}", "Sample:"]
+            for i, row in enumerate(sample, 1):
+                lines.append(f"  {i}: {row}")
+            return "\n".join(lines)
+        except Exception as e:
+            return f"Error: {e}"
+
+
+register(CsvSummaryTool())