yamlgraph 0.3.9__py3-none-any.whl

examples/codegen/tools/jedi_analysis.py

@@ -0,0 +1,311 @@
+"""Jedi-based code analysis tools for cross-file reference tracking.
+
+Provides semantic analysis capabilities using jedi:
+- find_references: All usages of a symbol across project
+- get_callers: Functions that call a given function
+- get_callees: Functions called by a given function
+
+Requires: pip install jedi (optional dependency)
+"""
+
+from __future__ import annotations
+
+import ast
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Try to import jedi - graceful degradation if not available
+try:
+    import jedi
+
+    JEDI_AVAILABLE = True
+except ImportError:
+    jedi = None  # type: ignore[assignment]
+    JEDI_AVAILABLE = False
+
+
+def find_references(
+    file_path: str,
+    symbol_name: str,
+    line: int,
+    column: int = 0,
+    project_path: str | None = None,
+) -> list[dict] | dict:
+    """Find all references to a symbol across the project.
+
+    Args:
+        file_path: Path to file containing the symbol definition
+        symbol_name: Name of the symbol to find references for
+        line: Line number where symbol is defined (1-indexed)
+        column: Column offset (default: 0)
+        project_path: Root directory for cross-file analysis
+
+    Returns:
+        List of reference dicts with file, line, column, type.
+        Or error dict if file not found or jedi unavailable.
+    """
+    # Validate line argument - handle placeholder strings like 'TBD' or '<dynamic>'
+    try:
+        line = int(line)
+    except (ValueError, TypeError):
+        return {
+            "error": f"Invalid line number: {line!r}. "
+            "Use get_structure first to get actual line numbers."
+        }
+
+    if line <= 0:
+        return {
+            "error": f"Invalid line number: {line}. "
+            "Line numbers must be >= 1. Use get_structure first."
+        }
+
+    if not JEDI_AVAILABLE:
+        return {"error": "jedi not installed. Run: pip install jedi"}
+
+    path = Path(file_path)
+    if not path.exists():
+        return {"error": f"File not found: {file_path}"}
+
+    try:
+        source = path.read_text()
+
+        # Create jedi project for cross-file analysis
+        project = None
+        if project_path:
+            project = jedi.Project(path=project_path)
+
+        script = jedi.Script(source, path=path, project=project)
+
+        # Find the position of the symbol on the given line
+        # Try to find the symbol in the line to get correct column
+        lines = source.splitlines()
+        if 0 < line <= len(lines):
+            line_text = lines[line - 1]
+            if symbol_name in line_text:
+                column = line_text.find(symbol_name)
+
+        # Get references
+        references = script.get_references(line=line, column=column)
+
+        results = []
+        for ref in references:
+            ref_type = "usage"
+            if ref.is_definition():
+                ref_type = "definition"
+
+            results.append(
+                {
+                    "file": str(ref.module_path) if ref.module_path else file_path,
+                    "line": ref.line,
+                    "column": ref.column,
+                    "type": ref_type,
+                    "name": ref.name,
+                }
+            )
+
+        return results
+
+    except Exception as e:
+        logger.warning(f"jedi analysis failed: {e}")
+        return {"error": str(e)}
+
+
+def get_callers(
+    file_path: str,
+    function_name: str,
+    line: int,
+    project_path: str | None = None,
+) -> list[dict] | dict:
+    """Find all functions that call a given function.
+
+    Args:
+        file_path: Path to file containing the function
+        function_name: Name of the function to find callers for
+        line: Line number where function is defined (1-indexed)
+        project_path: Root directory for cross-file analysis
+
+    Returns:
+        List of caller dicts with file, line, caller name.
+        Or error dict if file not found.
+    """
+    # Validate line argument - handle placeholder strings like 'TBD' or '<dynamic>'
+    try:
+        line = int(line)
+    except (ValueError, TypeError):
+        return {
+            "error": f"Invalid line number: {line!r}. "
+            "Use get_structure first to get actual line numbers."
+        }
+
+    if line <= 0:
+        return {
+            "error": f"Invalid line number: {line}. "
+            "Line numbers must be >= 1. Use get_structure first."
+        }
+
+    if not JEDI_AVAILABLE:
+        return {"error": "jedi not installed. Run: pip install jedi"}
+
+    path = Path(file_path)
+    if not path.exists():
+        return {"error": f"File not found: {file_path}"}
+
+    try:
+        # Get all references to the function
+        refs = find_references(
+            file_path, function_name, line, project_path=project_path
+        )
+
+        if isinstance(refs, dict) and "error" in refs:
+            return refs
+
+        # Filter to only usages (not definitions)
+        callers = []
+        for ref in refs:
+            if ref.get("type") == "usage":
+                # Try to find which function contains this call
+                caller_info = _find_enclosing_function(
+                    ref.get("file", file_path),
+                    ref.get("line", 0),
+                )
+                if caller_info:
+                    callers.append(
+                        {
+                            "file": ref.get("file"),
+                            "line": ref.get("line"),
+                            "caller": caller_info.get("name"),
+                            "caller_line": caller_info.get("line"),
+                        }
+                    )
+
+        return callers
+
+    except Exception as e:
+        logger.warning(f"get_callers failed: {e}")
+        return {"error": str(e)}
+
+
+def get_callees(
+    file_path: str,
+    function_name: str,
+    line: int,
+    project_path: str | None = None,
+) -> list[dict] | dict:
+    """Find all functions called by a given function.
+
+    Args:
+        file_path: Path to file containing the function
+        function_name: Name of the function to analyze
+        line: Line number where function is defined (1-indexed)
+        project_path: Root directory for cross-file analysis
+
+    Returns:
+        List of callee dicts with name, line, file.
+        Or error dict if file not found.
+    """
+    # Validate line argument - handle placeholder strings like 'TBD' or '<dynamic>'
+    try:
+        line = int(line)
+    except (ValueError, TypeError):
+        return {
+            "error": f"Invalid line number: {line!r}. "
+            "Use get_structure first to get actual line numbers."
+        }
+
+    if line <= 0:
+        return {
+            "error": f"Invalid line number: {line}. "
+            "Line numbers must be >= 1. Use get_structure first."
+        }
+
+    if not JEDI_AVAILABLE:
+        return {"error": "jedi not installed. Run: pip install jedi"}
+
+    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)
+
+        # Find the function AST node
+        func_node = None
+        for node in ast.walk(tree):
+            if (
+                isinstance(node, ast.FunctionDef)
+                and node.name == function_name
+                and (
+                    node.lineno == line
+                    or node.lineno <= line <= (node.end_lineno or line)
+                )
+            ):
+                func_node = node
+                break
+
+        if not func_node:
+            return []
+
+        # Find all function calls within the function body
+        callees = []
+        for node in ast.walk(func_node):
+            if isinstance(node, ast.Call):
+                callee_name = None
+                if isinstance(node.func, ast.Name):
+                    callee_name = node.func.id
+                elif isinstance(node.func, ast.Attribute):
+                    callee_name = node.func.attr
+
+                if callee_name:
+                    callees.append(
+                        {
+                            "callee": callee_name,
+                            "line": node.lineno,
+                            "file": str(path),
+                        }
+                    )
+
+        return callees
+
+    except Exception as e:
+        logger.warning(f"get_callees failed: {e}")
+        return {"error": str(e)}
+
+
+def _find_enclosing_function(file_path: str, line: int) -> dict | None:
+    """Find the function that contains a given line.
+
+    Args:
+        file_path: Path to file
+        line: Line number to find enclosing function for
+
+    Returns:
+        Dict with function name and line, or None if not found.
+    """
+    try:
+        path = Path(file_path)
+        if not path.exists():
+            return None
+
+        source = path.read_text()
+        tree = ast.parse(source)
+
+        # Find the innermost function containing this line
+        best_match = None
+        for node in ast.walk(tree):
+            if (
+                isinstance(node, ast.FunctionDef)
+                and node.lineno <= line <= (node.end_lineno or line)
+                and (best_match is None or node.lineno > best_match.lineno)
+            ):
+                best_match = node
+
+        if best_match:
+            return {"name": best_match.name, "line": best_match.lineno}
+
+        return None
+
+    except Exception:
+        return None

examples/codegen/tools/meta_tools.py

@@ -0,0 +1,202 @@
+"""YAMLGraph meta-template tools for implementation agent.
+
+Extract patterns from existing graph and prompt YAML files.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import yaml
+
+
+def extract_graph_template(graph_path: str) -> dict:
+    """Extract reusable patterns from a graph YAML file.
+
+    Args:
+        graph_path: Path to the graph YAML file
+
+    Returns:
+        dict with:
+        - node_types: List of node types used
+        - edge_patterns: List of edge pattern types
+        - state_fields: List of state field definitions
+        - tool_patterns: List of tool type patterns
+        or dict with 'error' key if failed
+    """
+    path = Path(graph_path)
+    if not path.exists():
+        return {"error": f"File not found: {graph_path}"}
+
+    try:
+        content = path.read_text()
+        data = yaml.safe_load(content)
+    except yaml.YAMLError as e:
+        return {"error": f"YAML parse error: {e}"}
+
+    if not isinstance(data, dict):
+        return {"error": "Invalid graph format: expected dict"}
+
+    result = {
+        "node_types": [],
+        "edge_patterns": [],
+        "state_fields": [],
+        "tool_patterns": [],
+    }
+
+    # Extract node types
+    nodes = data.get("nodes", {})
+    node_types_seen = set()
+    for _node_name, node_config in nodes.items():
+        if isinstance(node_config, dict):
+            node_type = node_config.get("type", "unknown")
+            node_types_seen.add(node_type)
+
+    result["node_types"] = sorted(node_types_seen)
+
+    # Extract edge patterns
+    edges = data.get("edges", [])
+    has_conditional = False
+    has_sequential = False
+
+    for edge in edges:
+        if isinstance(edge, str):
+            has_sequential = True
+        elif isinstance(edge, dict):
+            # Check for conditional edges
+            for edge_def in edge.values():
+                if isinstance(edge_def, dict) and "condition" in edge_def:
+                    has_conditional = True
+
+    # Also check string edges for condition syntax
+    for edge in edges:
+        if isinstance(edge, str) and ":" in edge and "condition" in str(edges):
+            has_conditional = True
+
+    if has_sequential:
+        result["edge_patterns"].append("sequential")
+    if has_conditional:
+        result["edge_patterns"].append("conditional")
+
+    # Extract state fields
+    state = data.get("state", {})
+    if isinstance(state, dict):
+        for field_name, field_type in state.items():
+            result["state_fields"].append({"name": field_name, "type": str(field_type)})
+
+    # Extract tool patterns
+    tools = data.get("tools", {})
+    tool_types_seen = set()
+    for _tool_name, tool_config in tools.items():
+        if isinstance(tool_config, dict):
+            tool_type = tool_config.get("type", "unknown")
+            tool_types_seen.add(tool_type)
+
+    result["tool_patterns"] = sorted(tool_types_seen)
+
+    return result
+
+
+def extract_prompt_template(prompt_path: str) -> dict:
+    """Extract patterns from a prompt YAML file.
+
+    Args:
+        prompt_path: Path to the prompt YAML file
+
+    Returns:
+        dict with:
+        - system_structure: Analysis of system prompt sections
+        - variables: List of variable names found
+        - schema_patterns: Schema field patterns if present
+        - jinja_patterns: Jinja2 constructs used
+        or dict with 'error' key if failed
+    """
+    path = Path(prompt_path)
+    if not path.exists():
+        return {"error": f"File not found: {prompt_path}"}
+
+    try:
+        content = path.read_text()
+        data = yaml.safe_load(content)
+    except yaml.YAMLError as e:
+        return {"error": f"YAML parse error: {e}"}
+
+    if not isinstance(data, dict):
+        return {"error": "Invalid prompt format: expected dict"}
+
+    result = {
+        "system_structure": {},
+        "variables": [],
+        "schema_patterns": [],
+        "jinja_patterns": [],
+    }
+
+    # Extract system prompt structure
+    system = data.get("system", "")
+    if system:
+        sections = _extract_sections(system)
+        result["system_structure"] = {"sections": sections, "length": len(system)}
+
+    # Extract variables from all text fields
+    variables = set()
+    for key in ["system", "user"]:
+        text = data.get(key, "")
+        if text:
+            # Find {variable} patterns (simple format)
+            simple_vars = re.findall(r"\{(\w+)\}", str(text))
+            variables.update(simple_vars)
+
+            # Find {{ variable }} patterns (Jinja2)
+            jinja_vars = re.findall(r"\{\{\s*(\w+)", str(text))
+            variables.update(jinja_vars)
+
+    result["variables"] = sorted(variables)
+
+    # Extract schema patterns
+    schema = data.get("schema", {})
+    if isinstance(schema, dict):
+        properties = schema.get("properties", {})
+        for prop_name, prop_def in properties.items():
+            prop_type = (
+                prop_def.get("type", "unknown")
+                if isinstance(prop_def, dict)
+                else "unknown"
+            )
+            result["schema_patterns"].append({"name": prop_name, "type": prop_type})
+
+    # Extract Jinja patterns
+    jinja_constructs = set()
+    full_text = str(data.get("system", "")) + str(data.get("user", ""))
+
+    if "{%" in full_text:
+        if "{% if" in full_text:
+            jinja_constructs.add("if")
+        if "{% for" in full_text:
+            jinja_constructs.add("for")
+        if "{% endif" in full_text:
+            jinja_constructs.add("endif")
+        if "{% endfor" in full_text:
+            jinja_constructs.add("endfor")
+        if "{% else" in full_text:
+            jinja_constructs.add("else")
+        if "{% elif" in full_text:
+            jinja_constructs.add("elif")
+
+    result["jinja_patterns"] = sorted(jinja_constructs)
+
+    return result
+
+
+def _extract_sections(text: str) -> list[str]:
+    """Extract section headers from text (## or ### style)."""
+    sections = []
+    for line in text.splitlines():
+        line = line.strip()
+        if line.startswith("##"):
+            # Remove ## prefix and clean
+            section = line.lstrip("#").strip()
+            if section:
+                sections.append(section)
+
+    return sections

examples/codegen/tools/syntax_tools.py

@@ -0,0 +1,26 @@
+"""Syntax validation tools for implementation agent.
+
+Provides syntax checking for proposed code changes.
+"""
+
+import ast
+
+
+def syntax_check(code: str) -> dict:
+    """Check if Python code is syntactically valid.
+
+    Args:
+        code: Python code string to check
+
+    Returns:
+        dict with 'valid' boolean. If invalid, includes 'error' string
+        with line number and description.
+    """
+    try:
+        ast.parse(code)
+        return {"valid": True}
+    except SyntaxError as e:
+        error_msg = f"line {e.lineno}: {e.msg}"
+        if e.text:
+            error_msg += f" (near: {e.text.strip()[:50]})"
+        return {"valid": False, "error": error_msg}