yamlgraph 0.3.9__py3-none-any.whl

examples/codegen/tools/code_nav.py

@@ -0,0 +1,52 @@
+"""Code navigation tools for finding relevant files.
+
+Provides package-level module discovery and search capabilities.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from examples.codegen.tools.ast_analysis import get_module_structure
+
+logger = logging.getLogger(__name__)
+
+
+def list_package_modules(package_path: str) -> list[dict]:
+    """List all Python modules in a package with high-level summaries.
+
+    Args:
+        package_path: Path to package directory
+
+    Returns:
+        List of module summaries with file, docstring, classes, functions.
+        Returns empty list if path doesn't exist or has no Python files.
+    """
+    path = Path(package_path)
+    if not path.exists():
+        return []
+
+    results = []
+    for py_file in sorted(path.rglob("*.py")):
+        # Skip __pycache__ directories
+        if "__pycache__" in str(py_file):
+            continue
+
+        structure = get_module_structure(str(py_file))
+
+        # Skip files with errors (syntax errors, etc.)
+        if "error" in structure:
+            logger.warning(f"Skipping {py_file}: {structure['error']}")
+            continue
+
+        results.append(
+            {
+                "file": str(py_file),
+                "docstring": structure.get("docstring"),
+                "classes": [c["name"] for c in structure.get("classes", [])],
+                "functions": [f["name"] for f in structure.get("functions", [])],
+            }
+        )
+
+    return results

examples/codegen/tools/dependency_tools.py

@@ -0,0 +1,120 @@
+"""Dependency analysis tools for implementation agent.
+
+Provides import analysis and reverse dependency tracking.
+"""
+
+import ast
+import subprocess
+from pathlib import Path
+
+
+def get_imports(file_path: str) -> dict:
+    """Extract all imports from a Python file.
+
+    Args:
+        file_path: Path to the Python file
+
+    Returns:
+        dict with 'imports' list, each containing:
+        - module: The imported module name
+        - names: List of imported names (None for 'import X')
+        - alias: Alias if 'as' was used (optional)
+        or dict with error key if failed
+    """
+    path = Path(file_path)
+    if not path.exists():
+        return {"error": f"File not found: {file_path}"}
+
+    try:
+        source = path.read_text()
+        tree = ast.parse(source)
+    except SyntaxError as e:
+        return {"error": f"Syntax error in {file_path}: {e}"}
+
+    imports = []
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            # import X, Y, Z
+            for alias in node.names:
+                imports.append(
+                    {
+                        "module": alias.name,
+                        "names": None,
+                        "alias": alias.asname,
+                    }
+                )
+        elif isinstance(node, ast.ImportFrom):
+            # from X import Y, Z
+            module = node.module or ""
+            names = []
+            for alias in node.names:
+                name_info = {"name": alias.name}
+                if alias.asname:
+                    name_info["alias"] = alias.asname
+                names.append(name_info)
+            imports.append(
+                {
+                    "module": module,
+                    "names": names,
+                    "level": node.level,  # Relative import level (0 = absolute)
+                }
+            )
+
+    return {"imports": imports}
+
+
+def get_dependents(module_path: str, project_path: str) -> dict:
+    """Find all files that import a given module.
+
+    Args:
+        module_path: Module path to search for (e.g., 'yamlgraph.executor')
+        project_path: Root path of the project to search in
+
+    Returns:
+        dict with 'dependents' list of file paths that import the module
+        or dict with error key if failed
+    """
+    path = Path(project_path)
+    if not path.exists():
+        return {"error": f"Project path not found: {project_path}"}
+
+    # Convert module path to patterns for grep
+    # e.g., 'yamlgraph.executor' -> search for 'from yamlgraph.executor' or 'import yamlgraph.executor'
+    full_module = module_path
+
+    # Build grep patterns
+    patterns = [
+        f"from {full_module} import",
+        f"from {full_module}\\b",
+        f"import {full_module}\\b",
+    ]
+
+    # For single-word modules like 'logging', also search simpler patterns
+    if "." not in module_path:
+        patterns = [
+            f"import {module_path}\\b",
+            f"from {module_path} import",
+        ]
+
+    dependents = set()
+
+    for pattern in patterns:
+        try:
+            result = subprocess.run(
+                ["grep", "-rl", "-E", pattern, "--include=*.py", str(path)],
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            # grep returns 1 if no matches (not an error)
+            if result.returncode == 0 and result.stdout.strip():
+                for file_path in result.stdout.strip().split("\n"):
+                    if file_path.strip():
+                        dependents.add(file_path.strip())
+        except subprocess.TimeoutExpired:
+            return {"error": "Search timed out"}
+        except Exception as e:
+            return {"error": str(e)}
+
+    return {"dependents": sorted(dependents)}

examples/codegen/tools/example_tools.py

@@ -0,0 +1,188 @@
+"""Example discovery tools for implementation agent.
+
+Find usage examples and error handling patterns across the codebase.
+"""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+def find_example(
+    symbol_name: str,
+    project_path: str,
+    max_examples: int = 3,
+) -> dict:
+    """Find real usage examples of a function/class.
+
+    Prioritizes:
+    1. Test files (most complete examples)
+    2. Main modules (production usage)
+    3. Examples folder
+
+    Args:
+        symbol_name: Name of the symbol to find examples for
+        project_path: Root path to search
+        max_examples: Maximum examples to return
+
+    Returns:
+        dict with 'examples' list of {file, line, snippet}
+        or dict with 'error' key if failed
+    """
+    project = Path(project_path)
+    if not project.exists():
+        return {"error": f"Project path not found: {project_path}"}
+
+    examples = []
+    test_examples = []
+    other_examples = []
+
+    # Search all Python files
+    for py_file in project.rglob("*.py"):
+        try:
+            source = py_file.read_text()
+        except (OSError, UnicodeDecodeError):
+            continue
+
+        # Skip if symbol is defined here (we want usages, not definitions)
+        if _is_definition(source, symbol_name):
+            continue
+
+        # Find all occurrences
+        lines = source.splitlines()
+        for i, line in enumerate(lines, 1):
+            if symbol_name in line and _is_usage(line, symbol_name):
+                # Extract context (3 lines before and after)
+                start = max(0, i - 3)
+                end = min(len(lines), i + 3)
+                snippet = "\n".join(lines[start:end])
+
+                example = {
+                    "file": str(py_file),
+                    "line": i,
+                    "snippet": snippet,
+                }
+
+                # Prioritize test files
+                if "test" in py_file.name.lower():
+                    test_examples.append(example)
+                else:
+                    other_examples.append(example)
+
+    # Combine: tests first, then others
+    examples = test_examples + other_examples
+
+    return {"examples": examples[:max_examples]}
+
+
+def _is_definition(source: str, symbol_name: str) -> bool:
+    """Check if this file defines the symbol."""
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return False
+
+    for node in ast.walk(tree):
+        if (
+            isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef)
+            and node.name == symbol_name
+        ):
+            return True
+
+    return False
+
+
+def _is_usage(line: str, symbol_name: str) -> bool:
+    """Check if line contains actual usage (not import or def)."""
+    stripped = line.strip()
+
+    # Skip definitions
+    if stripped.startswith("def ") and f"def {symbol_name}" in stripped:
+        return False
+    if stripped.startswith("class ") and f"class {symbol_name}" in stripped:
+        return False
+
+    # Skip import-only lines
+    if stripped.startswith("from ") and stripped.endswith(f"import {symbol_name}"):
+        return False
+
+    # Must be a call or reference
+    return f"{symbol_name}(" in line or f"{symbol_name}." in line
+
+
+def find_error_handling(project_path: str) -> dict:
+    """Analyze error handling patterns in a project.
+
+    Args:
+        project_path: Root path to analyze
+
+    Returns:
+        dict with:
+        - exceptions: List of exception types used
+        - patterns: List of pattern names found
+        - logging: Dict with logging info
+        or dict with 'error' key if failed
+    """
+    project = Path(project_path)
+    if not project.exists():
+        return {"error": f"Project path not found: {project_path}"}
+
+    exceptions: set[str] = set()
+    patterns: list[str] = []
+    uses_logging = False
+    uses_dict_error = False
+
+    for py_file in project.rglob("*.py"):
+        try:
+            source = py_file.read_text()
+        except (OSError, UnicodeDecodeError):
+            continue
+
+        try:
+            tree = ast.parse(source)
+        except SyntaxError:
+            continue
+
+        # Find exception types
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ExceptHandler) and node.type:
+                exc_types = _extract_exception_types(node.type)
+                exceptions.update(exc_types)
+
+        # Check for dict error pattern
+        if 'return {"error"' in source or "return {'error'" in source:
+            uses_dict_error = True
+
+        # Check for logging
+        if "logger.error" in source or "logging.error" in source:
+            uses_logging = True
+
+    # Build patterns list
+    if uses_dict_error:
+        patterns.append("dict_error")
+    if exceptions:
+        patterns.append("try_except")
+
+    return {
+        "exceptions": sorted(exceptions),
+        "patterns": patterns,
+        "logging": {"uses_logging": uses_logging},
+    }
+
+
+def _extract_exception_types(node: ast.expr) -> list[str]:
+    """Extract exception type names from except clause."""
+    types = []
+
+    if isinstance(node, ast.Name):
+        types.append(node.id)
+    elif isinstance(node, ast.Tuple):
+        for elt in node.elts:
+            if isinstance(elt, ast.Name):
+                types.append(elt.id)
+    elif isinstance(node, ast.Attribute):
+        # e.g., requests.exceptions.Timeout
+        types.append(node.attr)
+
+    return types

examples/codegen/tools/git_tools.py

@@ -0,0 +1,151 @@
+"""Git analysis tools for implementation agent.
+
+Provides git blame and git log information for code context.
+"""
+
+import subprocess
+from pathlib import Path
+
+
+def git_blame(file_path: str, line: int) -> dict:
+    """Get blame info for a specific line.
+
+    Args:
+        file_path: Path to the file (relative or absolute)
+        line: Line number (1-indexed)
+
+    Returns:
+        dict with author, date, commit, summary, line_content
+        or dict with error key if failed
+    """
+    path = Path(file_path)
+    if not path.exists():
+        return {"error": f"File not found: {file_path}"}
+
+    try:
+        # Use porcelain format for machine-readable output
+        result = subprocess.run(
+            ["git", "blame", "-L", f"{line},{line}", "--porcelain", str(path)],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+
+        if result.returncode != 0:
+            return {
+                "error": result.stderr.strip()
+                or f"git blame failed for {file_path}:{line}"
+            }
+
+        # Parse porcelain output
+        lines = result.stdout.strip().split("\n")
+        if not lines or len(lines) < 2:
+            return {"error": f"Invalid line number: {line}"}
+
+        # First line is commit hash and original line number
+        first_line = lines[0].split()
+        if not first_line:
+            return {"error": "Failed to parse git blame output"}
+
+        commit = first_line[0]
+
+        # Parse the rest of the porcelain output
+        author = ""
+        date = ""
+        summary = ""
+        line_content = ""
+
+        for output_line in lines[1:]:
+            if output_line.startswith("author "):
+                author = output_line[7:]
+            elif output_line.startswith("author-time "):
+                # Convert Unix timestamp to readable format
+                import datetime
+
+                timestamp = int(output_line[12:])
+                date = datetime.datetime.fromtimestamp(timestamp).strftime(
+                    "%Y-%m-%d %H:%M"
+                )
+            elif output_line.startswith("summary "):
+                summary = output_line[8:]
+            elif output_line.startswith("\t"):
+                # Actual line content starts with tab
+                line_content = output_line[1:]
+
+        return {
+            "commit": commit[:8],  # Short hash
+            "author": author,
+            "date": date,
+            "summary": summary,
+            "line_content": line_content,
+        }
+
+    except subprocess.TimeoutExpired:
+        return {"error": "git blame timed out"}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def git_log(file_path: str, n: int = 5) -> dict:
+    """Get recent commits for a file.
+
+    Args:
+        file_path: Path to the file (relative or absolute)
+        n: Maximum number of commits to return (default 5)
+
+    Returns:
+        dict with commits list, each containing hash, author, date, message
+        or dict with error key if failed
+    """
+    path = Path(file_path)
+    if not path.exists():
+        return {"error": f"File not found: {file_path}"}
+
+    try:
+        # Use format for clean parsing
+        result = subprocess.run(
+            [
+                "git",
+                "log",
+                f"-{n}",
+                "--format=%H|%an|%ai|%s",
+                "--follow",
+                "--",
+                str(path),
+            ],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+
+        if result.returncode != 0:
+            error = result.stderr.strip()
+            if "does not have any commits" in error or not result.stdout.strip():
+                return {"error": f"No git history for {file_path}"}
+            return {"error": error or f"git log failed for {file_path}"}
+
+        output = result.stdout.strip()
+        if not output:
+            return {"error": f"No git history for {file_path}"}
+
+        commits = []
+        for line in output.split("\n"):
+            if not line.strip():
+                continue
+            parts = line.split("|", 3)
+            if len(parts) >= 4:
+                commits.append(
+                    {
+                        "hash": parts[0][:8],  # Short hash
+                        "author": parts[1],
+                        "date": parts[2][:10],  # Just the date part
+                        "message": parts[3],
+                    }
+                )
+
+        return {"commits": commits}
+
+    except subprocess.TimeoutExpired:
+        return {"error": "git log timed out"}
+    except Exception as e:
+        return {"error": str(e)}