fips-agents-cli 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

fips_agents_cli/tools/generators.py

@@ -0,0 +1,311 @@
+"""Generator utilities for rendering MCP component templates."""
+
+import ast
+import json
+import subprocess
+from pathlib import Path
+from typing import Any
+
+import jinja2
+import tomlkit
+from rich.console import Console
+
+console = Console()
+
+
+def get_project_info(project_root: Path) -> dict[str, Any]:
+    """
+    Extract project metadata from pyproject.toml.
+
+    Args:
+        project_root: Path to the project root directory
+
+    Returns:
+        dict: Project metadata including:
+            - name: Project name
+            - module_name: Module name (with underscores)
+            - version: Project version
+
+    Raises:
+        FileNotFoundError: If pyproject.toml doesn't exist
+        ValueError: If pyproject.toml is malformed
+
+    Example:
+        >>> info = get_project_info(Path("/path/to/project"))
+        >>> print(info["name"])
+        'my-mcp-server'
+    """
+    pyproject_path = project_root / "pyproject.toml"
+
+    if not pyproject_path.exists():
+        raise FileNotFoundError(f"pyproject.toml not found at {pyproject_path}")
+
+    try:
+        with open(pyproject_path) as f:
+            pyproject = tomlkit.parse(f.read())
+
+        project_name = pyproject.get("project", {}).get("name", "unknown")
+        project_version = pyproject.get("project", {}).get("version", "0.1.0")
+        module_name = project_name.replace("-", "_")
+
+        return {
+            "name": project_name,
+            "module_name": module_name,
+            "version": project_version,
+        }
+
+    except Exception as e:
+        raise ValueError(f"Failed to parse pyproject.toml: {e}") from e
+
+
+def load_template(project_root: Path, component_type: str, template_name: str) -> jinja2.Template:
+    """
+    Load a Jinja2 template from the project's generator templates.
+
+    Args:
+        project_root: Path to the project root directory
+        component_type: Type of component ('tool', 'resource', 'prompt', 'middleware')
+        template_name: Name of the template file (e.g., 'component.py.j2')
+
+    Returns:
+        jinja2.Template: Loaded Jinja2 template
+
+    Raises:
+        FileNotFoundError: If template file doesn't exist
+        jinja2.TemplateError: If template is malformed
+
+    Example:
+        >>> template = load_template(root, "tool", "component.py.j2")
+        >>> rendered = template.render(component_name="my_tool")
+    """
+    template_path = (
+        project_root / ".fips-agents-cli" / "generators" / component_type / template_name
+    )
+
+    if not template_path.exists():
+        raise FileNotFoundError(f"Template not found: {template_path}")
+
+    try:
+        with open(template_path) as f:
+            template_content = f.read()
+
+        # Create a Jinja2 environment with the template directory as the loader path
+        template_dir = template_path.parent
+        env = jinja2.Environment(
+            loader=jinja2.FileSystemLoader(str(template_dir)),
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+        return env.from_string(template_content)
+
+    except jinja2.TemplateError as e:
+        raise jinja2.TemplateError(f"Failed to load template {template_name}: {e}") from e
+
+
+def load_params_file(params_path: Path) -> list[dict[str, Any]]:
+    """
+    Load and validate parameter definitions from a JSON file.
+
+    Expected schema:
+    [
+      {
+        "name": "query",
+        "type": "str",
+        "description": "Search query",
+        "required": true,
+        "min_length": 1,
+        "max_length": 100
+      }
+    ]
+
+    Args:
+        params_path: Path to the JSON parameter file
+
+    Returns:
+        list: List of parameter definition dictionaries
+
+    Raises:
+        FileNotFoundError: If params file doesn't exist
+        ValueError: If JSON is invalid or schema is incorrect
+
+    Example:
+        >>> params = load_params_file(Path("params.json"))
+        >>> print(params[0]["name"])
+        'query'
+    """
+    if not params_path.exists():
+        raise FileNotFoundError(f"Parameters file not found: {params_path}")
+
+    try:
+        with open(params_path) as f:
+            params = json.load(f)
+
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Invalid JSON in parameters file: {e}") from e
+
+    # Validate schema
+    if not isinstance(params, list):
+        raise ValueError("Parameters file must contain a JSON array of parameter definitions")
+
+    for i, param in enumerate(params):
+        if not isinstance(param, dict):
+            raise ValueError(f"Parameter {i} must be a JSON object")
+
+        # Check required fields
+        required_fields = ["name", "type", "description"]
+        for field in required_fields:
+            if field not in param:
+                raise ValueError(f"Parameter {i} missing required field: {field}")
+
+        # Validate name is a valid Python identifier
+        if not param["name"].isidentifier():
+            raise ValueError(f"Parameter {i} has invalid name: {param['name']}")
+
+        # Validate type
+        valid_types = [
+            "str",
+            "int",
+            "float",
+            "bool",
+            "list[str]",
+            "list[int]",
+            "list[float]",
+            "Optional[str]",
+            "Optional[int]",
+            "Optional[float]",
+            "Optional[bool]",
+        ]
+        if param["type"] not in valid_types:
+            raise ValueError(
+                f"Parameter {i} has invalid type: {param['type']}. "
+                f"Valid types: {', '.join(valid_types)}"
+            )
+
+    return params
+
+
+def render_component(template: jinja2.Template, variables: dict[str, Any]) -> str:
+    """
+    Render a Jinja2 template with the provided variables.
+
+    Args:
+        template: Jinja2 template object
+        variables: Dictionary of template variables
+
+    Returns:
+        str: Rendered template as a string
+
+    Raises:
+        jinja2.TemplateError: If rendering fails
+
+    Example:
+        >>> template = load_template(root, "tool", "component.py.j2")
+        >>> code = render_component(template, {"component_name": "my_tool"})
+    """
+    try:
+        return template.render(**variables)
+    except jinja2.TemplateError as e:
+        raise jinja2.TemplateError(f"Failed to render template: {e}") from e
+
+
+def validate_python_syntax(code: str) -> tuple[bool, str]:
+    """
+    Validate Python code syntax using ast.parse().
+
+    Args:
+        code: Python code as a string
+
+    Returns:
+        tuple: (is_valid, error_message)
+               is_valid is True if syntax is valid, False otherwise
+               error_message is empty string if valid, otherwise contains error description
+
+    Example:
+        >>> code = "def my_func():\\n    return 42"
+        >>> is_valid, msg = validate_python_syntax(code)
+        >>> print(is_valid)
+        True
+    """
+    try:
+        ast.parse(code)
+        return True, ""
+    except SyntaxError as e:
+        return False, f"Syntax error at line {e.lineno}: {e.msg}"
+    except Exception as e:
+        return False, f"Failed to validate syntax: {e}"
+
+
+def write_component_file(content: str, file_path: Path) -> None:
+    """
+    Write component content to a file, creating parent directories if needed.
+
+    Args:
+        content: File content as a string
+        file_path: Path where the file should be written
+
+    Raises:
+        OSError: If file cannot be written (permissions, etc.)
+
+    Example:
+        >>> write_component_file("print('hello')", Path("src/tools/my_tool.py"))
+    """
+    try:
+        # Create parent directories if they don't exist
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Write the file
+        with open(file_path, "w") as f:
+            f.write(content)
+
+    except OSError as e:
+        raise OSError(f"Failed to write file {file_path}: {e}") from e
+
+
+def run_component_tests(project_root: Path, test_file: Path) -> tuple[bool, str]:
+    """
+    Run pytest on a generated test file and capture output.
+
+    Args:
+        project_root: Path to the project root directory
+        test_file: Path to the test file to run (relative or absolute)
+
+    Returns:
+        tuple: (success, output)
+               success is True if tests passed, False if failed
+               output is the pytest output as a string
+
+    Example:
+        >>> success, output = run_component_tests(root, Path("tests/tools/test_my_tool.py"))
+        >>> if success:
+        ...     print("Tests passed!")
+    """
+    try:
+        # Make test_file relative to project_root if it's absolute
+        if test_file.is_absolute():
+            try:
+                test_file = test_file.relative_to(project_root)
+            except ValueError:
+                # test_file is not relative to project_root, use as-is
+                pass
+
+        # Run pytest with minimal output
+        result = subprocess.run(
+            ["pytest", str(test_file), "-v", "--tb=short"],
+            cwd=str(project_root),
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        output = result.stdout + result.stderr
+        success = result.returncode == 0
+
+        return success, output
+
+    except subprocess.TimeoutExpired:
+        return False, "Test execution timed out after 30 seconds"
+    except FileNotFoundError:
+        return False, "pytest not found. Install with: pip install pytest"
+    except Exception as e:
+        return False, f"Failed to run tests: {e}"

fips_agents_cli/tools/project.py

@@ -3,7 +3,6 @@
 import re
 import shutil
 from pathlib import Path
-from typing import Optional
 
 import tomlkit
 from rich.console import Console
@@ -11,7 +10,7 @@ from rich.console import Console
 console = Console()
 
 
-def validate_project_name(name: str) -> tuple[bool, Optional[str]]:
+def validate_project_name(name: str) -> tuple[bool, str | None]:
     """
     Validate project name according to Python package naming conventions.
 

fips_agents_cli/tools/validation.py

@@ -0,0 +1,183 @@
+"""Validation utilities for MCP component generation."""
+
+import keyword
+import re
+from pathlib import Path
+
+import tomlkit
+from rich.console import Console
+
+console = Console()
+
+
+def find_project_root() -> Path | None:
+    """
+    Find the project root by walking up from current directory.
+
+    Looks for pyproject.toml with fastmcp dependency to identify MCP server projects.
+
+    Returns:
+        Path: Project root path if found
+        None: If no valid MCP project root is found
+
+    Example:
+        >>> root = find_project_root()
+        >>> if root:
+        ...     print(f"Found project at {root}")
+    """
+    current_path = Path.cwd()
+
+    # Walk up the directory tree
+    for parent in [current_path] + list(current_path.parents):
+        pyproject_path = parent / "pyproject.toml"
+
+        if pyproject_path.exists():
+            try:
+                with open(pyproject_path) as f:
+                    pyproject = tomlkit.parse(f.read())
+
+                # Check if this is an MCP server project
+                dependencies = pyproject.get("project", {}).get("dependencies", [])
+
+                # Check for fastmcp dependency
+                for dep in dependencies:
+                    if isinstance(dep, str) and "fastmcp" in dep.lower():
+                        return parent
+
+            except Exception as e:
+                console.print(f"[yellow]⚠[/yellow] Could not parse {pyproject_path}: {e}")
+                continue
+
+    return None
+
+
+def is_valid_component_name(name: str) -> tuple[bool, str]:
+    """
+    Validate component name as a valid Python identifier.
+
+    Component names must:
+    - Be valid Python identifiers (snake_case)
+    - Not be Python keywords
+    - Not be empty
+    - Start with a letter or underscore
+    - Contain only letters, numbers, and underscores
+
+    Args:
+        name: The component name to validate
+
+    Returns:
+        tuple: (is_valid, error_message)
+               is_valid is True if valid, False otherwise
+               error_message is empty string if valid, otherwise contains error description
+
+    Examples:
+        >>> is_valid_component_name("my_tool")
+        (True, '')
+        >>> is_valid_component_name("123invalid")
+        (False, 'Component name must start with a letter or underscore')
+    """
+    if not name:
+        return False, "Component name cannot be empty"
+
+    # Check if it's a valid Python identifier
+    if not name.isidentifier():
+        if name[0].isdigit():
+            return False, "Component name must start with a letter or underscore"
+        return False, (
+            "Component name must be a valid Python identifier (use snake_case: "
+            "letters, numbers, underscores only)"
+        )
+
+    # Check if it's a Python keyword
+    if keyword.iskeyword(name):
+        return False, f"Component name '{name}' is a Python keyword and cannot be used"
+
+    # Recommend snake_case
+    if not re.match(r"^[a-z_][a-z0-9_]*$", name):
+        return False, (
+            "Component name should use snake_case (lowercase letters, numbers, " "underscores only)"
+        )
+
+    return True, ""
+
+
+def component_exists(project_root: Path, component_type: str, name: str) -> bool:
+    """
+    Check if a component file already exists.
+
+    Args:
+        project_root: Path to the project root directory
+        component_type: Type of component ('tool', 'resource', 'prompt', 'middleware')
+        name: Component name (will check for {name}.py)
+
+    Returns:
+        bool: True if component file exists, False otherwise
+
+    Example:
+        >>> root = Path("/path/to/project")
+        >>> component_exists(root, "tool", "my_tool")
+        False
+    """
+    # Map component types to their directory locations
+    component_dirs = {
+        "tool": "tools",
+        "resource": "resources",
+        "prompt": "prompts",
+        "middleware": "middleware",
+    }
+
+    if component_type not in component_dirs:
+        return False
+
+    component_dir = component_dirs[component_type]
+    component_file = project_root / "src" / component_dir / f"{name}.py"
+
+    return component_file.exists()
+
+
+def validate_generator_templates(project_root: Path, component_type: str) -> tuple[bool, str]:
+    """
+    Validate that generator templates exist for the component type.
+
+    Args:
+        project_root: Path to the project root directory
+        component_type: Type of component ('tool', 'resource', 'prompt', 'middleware')
+
+    Returns:
+        tuple: (is_valid, error_message)
+               is_valid is True if templates exist, False otherwise
+               error_message is empty string if valid, otherwise contains error description
+
+    Example:
+        >>> root = Path("/path/to/project")
+        >>> is_valid, msg = validate_generator_templates(root, "tool")
+        >>> if is_valid:
+        ...     print("Templates found!")
+    """
+    generators_dir = project_root / ".fips-agents-cli" / "generators" / component_type
+
+    if not generators_dir.exists():
+        return False, (
+            f"Generator templates not found for '{component_type}'\n"
+            f"Expected: {generators_dir}\n"
+            "Was this project created with fips-agents create mcp-server?"
+        )
+
+    # Check for required template files
+    component_template = generators_dir / "component.py.j2"
+    test_template = generators_dir / "test.py.j2"
+
+    missing_files = []
+    if not component_template.exists():
+        missing_files.append("component.py.j2")
+    if not test_template.exists():
+        missing_files.append("test.py.j2")
+
+    if missing_files:
+        return False, (
+            f"Missing template files for '{component_type}':\n"
+            f"  {', '.join(missing_files)}\n"
+            f"Expected location: {generators_dir}"
+        )
+
+    return True, ""

fips_agents_cli/version.py

@@ -1,3 +1,3 @@
 """Version information for fips-agents-cli."""
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"