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

fips_agents_cli/cli.py

@@ -4,6 +4,7 @@ import click
 from rich.console import Console
 
 from fips_agents_cli.commands.create import create
+from fips_agents_cli.commands.generate import generate
 from fips_agents_cli.version import __version__
 
 console = Console()
@@ -23,6 +24,7 @@ def cli(ctx):
 
 # Register commands
 cli.add_command(create)
+cli.add_command(generate)
 
 
 def main():

fips_agents_cli/commands/create.py

@@ -1,7 +1,6 @@
 """Create command for generating new projects from templates."""
 
 import sys
-from typing import Optional
 
 import click
 from rich.console import Console
@@ -43,7 +42,7 @@ def create():
     default=False,
     help="Skip git repository initialization",
 )
-def mcp_server(project_name: str, target_dir: Optional[str], no_git: bool):
+def mcp_server(project_name: str, target_dir: str | None, no_git: bool):
     """
     Create a new MCP server project from template.
 

fips_agents_cli/commands/generate.py

@@ -0,0 +1,405 @@
+"""Generate command for scaffolding MCP components in existing projects."""
+
+import sys
+from pathlib import Path
+from typing import Any
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from fips_agents_cli.tools.generators import (
+    get_project_info,
+    load_params_file,
+    load_template,
+    render_component,
+    run_component_tests,
+    validate_python_syntax,
+    write_component_file,
+)
+from fips_agents_cli.tools.validation import (
+    component_exists,
+    find_project_root,
+    is_valid_component_name,
+    validate_generator_templates,
+)
+
+console = Console()
+
+
+def generate_component_workflow(
+    component_type: str,
+    name: str,
+    template_vars: dict[str, Any],
+    params_path: str | None,
+    dry_run: bool,
+    description: str | None,
+) -> None:
+    """
+    Common workflow for generating any component type.
+
+    Args:
+        component_type: Type of component ('tool', 'resource', 'prompt', 'middleware')
+        name: Component name
+        template_vars: Template variables dictionary
+        params_path: Optional path to params JSON file
+        dry_run: If True, only show what would be generated
+        description: Component description
+    """
+    # Step 1: Find project root
+    project_root = find_project_root()
+    if not project_root:
+        console.print(
+            "[red]✗[/red] Not in an MCP server project directory\n"
+            "[yellow]Hint:[/yellow] Run this command from within an MCP server project, "
+            "or use 'fips-agents create mcp-server' to create one"
+        )
+        sys.exit(1)
+
+    console.print(f"[green]✓[/green] Found project root: {project_root}")
+
+    # Step 2: Validate component name
+    is_valid, error_msg = is_valid_component_name(name)
+    if not is_valid:
+        console.print(f"[red]✗[/red] Invalid component name: {error_msg}")
+        sys.exit(1)
+
+    console.print(f"[green]✓[/green] Component name '{name}' is valid")
+
+    # Step 3: Check if component already exists
+    if component_exists(project_root, component_type, name):
+        console.print(
+            f"[red]✗[/red] Component '{name}' already exists in src/{component_type}s/\n"
+            "[yellow]Hint:[/yellow] Choose a different name or manually remove the existing file"
+        )
+        sys.exit(1)
+
+    # Step 4: Validate generator templates
+    is_valid, error_msg = validate_generator_templates(project_root, component_type)
+    if not is_valid:
+        console.print(f"[red]✗[/red] {error_msg}")
+        sys.exit(1)
+
+    console.print(f"[green]✓[/green] Generator templates found for '{component_type}'")
+
+    # Step 5: Prompt for description if not provided
+    if not description:
+        description = click.prompt(
+            f"Enter a description for the {component_type}",
+            type=str,
+            default="TODO: Add description",
+        )
+
+    template_vars["description"] = description
+    template_vars["component_name"] = name
+
+    # Step 6: Load params file if provided
+    if params_path:
+        try:
+            params = load_params_file(Path(params_path))
+            template_vars["params"] = params
+            console.print(f"[green]✓[/green] Loaded {len(params)} parameter(s) from {params_path}")
+        except Exception as e:
+            console.print(f"[red]✗[/red] Failed to load parameters file: {e}")
+            sys.exit(1)
+    elif "params" not in template_vars:
+        template_vars["params"] = []
+
+    # Step 7: Get project info
+    try:
+        project_info = get_project_info(project_root)
+        template_vars["project_name"] = project_info["name"]
+    except Exception as e:
+        console.print(f"[yellow]⚠[/yellow] Could not load project info: {e}")
+        template_vars["project_name"] = "unknown"
+
+    # Step 8: Define file paths
+    component_dir_map = {
+        "tool": "tools",
+        "resource": "resources",
+        "prompt": "prompts",
+        "middleware": "middleware",
+    }
+    component_dir = component_dir_map[component_type]
+
+    component_file = project_root / "src" / component_dir / f"{name}.py"
+    test_file = project_root / "tests" / component_dir / f"test_{name}.py"
+
+    # Step 9: Dry run - show paths and exit
+    if dry_run:
+        console.print("\n[bold cyan]Dry Run - Files that would be generated:[/bold cyan]\n")
+        console.print(f"  [cyan]Component:[/cyan] {component_file}")
+        console.print(f"  [cyan]Test:[/cyan] {test_file}")
+        console.print("\n[dim]Template variables:[/dim]")
+        for key, value in template_vars.items():
+            if key == "params" and isinstance(value, list):
+                console.print(f"  {key}: {len(value)} parameter(s)")
+            else:
+                console.print(f"  {key}: {value}")
+        sys.exit(0)
+
+    # Step 10: Load and render templates
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        progress.add_task(description="Generating component files...", total=None)
+
+        try:
+            # Load templates
+            component_template = load_template(project_root, component_type, "component.py.j2")
+            test_template = load_template(project_root, component_type, "test.py.j2")
+
+            # Render templates
+            component_code = render_component(component_template, template_vars)
+            test_code = render_component(test_template, template_vars)
+
+        except Exception as e:
+            console.print(f"\n[red]✗[/red] Failed to render templates: {e}")
+            sys.exit(1)
+
+    # Step 11: Validate Python syntax
+    is_valid, error_msg = validate_python_syntax(component_code)
+    if not is_valid:
+        console.print(f"[red]✗[/red] Generated component has syntax errors: {error_msg}")
+        console.print("[red]This is a bug in the template. Please report this issue.[/red]")
+        sys.exit(1)
+
+    is_valid, error_msg = validate_python_syntax(test_code)
+    if not is_valid:
+        console.print(f"[red]✗[/red] Generated test has syntax errors: {error_msg}")
+        console.print("[red]This is a bug in the template. Please report this issue.[/red]")
+        sys.exit(1)
+
+    console.print("[green]✓[/green] Generated code passed syntax validation")
+
+    # Step 12: Write files
+    try:
+        write_component_file(component_code, component_file)
+        console.print(f"[green]✓[/green] Created: {component_file.relative_to(project_root)}")
+
+        write_component_file(test_code, test_file)
+        console.print(f"[green]✓[/green] Created: {test_file.relative_to(project_root)}")
+
+    except Exception as e:
+        console.print(f"[red]✗[/red] Failed to write files: {e}")
+        sys.exit(1)
+
+    # Step 13: Run tests
+    console.print("\n[cyan]Running generated tests...[/cyan]")
+    success, output = run_component_tests(project_root, test_file)
+
+    if success:
+        console.print("[green]✓[/green] Tests passed!\n")
+    else:
+        console.print("[yellow]⚠[/yellow] Tests failed or had issues:\n")
+        console.print(output)
+        console.print(
+            "\n[yellow]Note:[/yellow] Generated tests are placeholders. "
+            "Update them with your actual test cases."
+        )
+
+    # Step 14: Success message
+    success_message = f"""
+[bold green]✓ Successfully generated {component_type} component![/bold green]
+
+[bold cyan]Files Created:[/bold cyan]
+  • {component_file.relative_to(project_root)}
+  • {test_file.relative_to(project_root)}
+
+[bold cyan]Next Steps:[/bold cyan]
+  1. Review the generated code and implement the business logic
+  2. Update the test file with real test cases
+  3. Run tests: [dim]pytest {test_file.relative_to(project_root)}[/dim]
+  4. Import and use your {component_type} in your MCP server
+
+[bold cyan]Implementation Notes:[/bold cyan]
+  • Replace TODO comments with actual implementation
+  • Remove placeholder return values
+  • Add proper error handling
+  • Update docstrings as needed
+"""
+
+    console.print(Panel(success_message, border_style="green", padding=(1, 2)))
+
+
+@click.group()
+def generate():
+    """Generate new MCP components in existing projects."""
+    pass
+
+
+@generate.command("tool")
+@click.argument("name")
+@click.option(
+    "--async/--sync",
+    "is_async",
+    default=True,
+    help="Generate async or sync function (default: async)",
+)
+@click.option("--with-context", is_flag=True, help="Include FastMCP Context parameter")
+@click.option("--with-auth", is_flag=True, help="Include authentication decorator")
+@click.option("--description", "-d", help="Tool description")
+@click.option("--params", type=click.Path(exists=True), help="JSON file with parameter definitions")
+@click.option(
+    "--read-only", is_flag=True, default=True, help="Mark as read-only operation (default: true)"
+)
+@click.option("--idempotent", is_flag=True, default=True, help="Mark as idempotent (default: true)")
+@click.option("--open-world", is_flag=True, help="Mark as open-world operation")
+@click.option("--return-type", default="str", help="Return type annotation (default: str)")
+@click.option("--dry-run", is_flag=True, help="Show what would be generated without creating files")
+def tool(
+    name: str,
+    is_async: bool,
+    with_context: bool,
+    with_auth: bool,
+    description: str | None,
+    params: str | None,
+    read_only: bool,
+    idempotent: bool,
+    open_world: bool,
+    return_type: str,
+    dry_run: bool,
+):
+    """
+    Generate a new tool component.
+
+    NAME is the tool name in snake_case (e.g., search_documents, fetch_data)
+
+    Example:
+        fips-agents generate tool search_documents --description "Search through documents"
+        fips-agents generate tool fetch_data --params params.json --with-context
+    """
+    console.print("\n[bold cyan]Generating Tool Component[/bold cyan]\n")
+
+    template_vars = {
+        "async": is_async,
+        "with_context": with_context,
+        "with_auth": with_auth,
+        "read_only": read_only,
+        "idempotent": idempotent,
+        "open_world": open_world,
+        "return_type": return_type,
+    }
+
+    generate_component_workflow("tool", name, template_vars, params, dry_run, description)
+
+
+@generate.command("resource")
+@click.argument("name")
+@click.option(
+    "--async/--sync",
+    "is_async",
+    default=True,
+    help="Generate async or sync function (default: async)",
+)
+@click.option("--with-context", is_flag=True, help="Include FastMCP Context parameter")
+@click.option("--description", "-d", help="Resource description")
+@click.option("--uri", help="Resource URI (default: resource://<name>)")
+@click.option(
+    "--mime-type", default="text/plain", help="MIME type for resource (default: text/plain)"
+)
+@click.option("--dry-run", is_flag=True, help="Show what would be generated without creating files")
+def resource(
+    name: str,
+    is_async: bool,
+    with_context: bool,
+    description: str | None,
+    uri: str | None,
+    mime_type: str,
+    dry_run: bool,
+):
+    """
+    Generate a new resource component.
+
+    NAME is the resource name in snake_case (e.g., config_data, user_profile)
+
+    Example:
+        fips-agents generate resource config_data --description "Application configuration"
+        fips-agents generate resource user_profile --uri "resource://users/{id}"
+    """
+    console.print("\n[bold cyan]Generating Resource Component[/bold cyan]\n")
+
+    # Default URI if not provided
+    if not uri:
+        uri = f"resource://{name}"
+
+    template_vars = {
+        "async": is_async,
+        "with_context": with_context,
+        "uri": uri,
+        "mime_type": mime_type,
+        "return_type": "str",  # Resources typically return strings
+    }
+
+    generate_component_workflow("resource", name, template_vars, None, dry_run, description)
+
+
+@generate.command("prompt")
+@click.argument("name")
+@click.option("--description", "-d", help="Prompt description")
+@click.option("--params", type=click.Path(exists=True), help="JSON file with parameter definitions")
+@click.option("--with-schema", is_flag=True, help="Include JSON schema in prompt")
+@click.option("--dry-run", is_flag=True, help="Show what would be generated without creating files")
+def prompt(
+    name: str,
+    description: str | None,
+    params: str | None,
+    with_schema: bool,
+    dry_run: bool,
+):
+    """
+    Generate a new prompt component.
+
+    NAME is the prompt name in snake_case (e.g., code_review, summarize_text)
+
+    Example:
+        fips-agents generate prompt code_review --description "Review code for best practices"
+        fips-agents generate prompt summarize_text --params params.json
+    """
+    console.print("\n[bold cyan]Generating Prompt Component[/bold cyan]\n")
+
+    template_vars = {
+        "with_schema": with_schema,
+        "async": False,  # Prompts are typically not async
+        "return_type": "list[PromptMessage]",
+    }
+
+    generate_component_workflow("prompt", name, template_vars, params, dry_run, description)
+
+
+@generate.command("middleware")
+@click.argument("name")
+@click.option(
+    "--async/--sync",
+    "is_async",
+    default=True,
+    help="Generate async or sync function (default: async)",
+)
+@click.option("--description", "-d", help="Middleware description")
+@click.option("--dry-run", is_flag=True, help="Show what would be generated without creating files")
+def middleware(
+    name: str,
+    is_async: bool,
+    description: str | None,
+    dry_run: bool,
+):
+    """
+    Generate a new middleware component.
+
+    NAME is the middleware name in snake_case (e.g., auth_middleware, rate_limiter)
+
+    Example:
+        fips-agents generate middleware auth_middleware --description "Authentication middleware"
+        fips-agents generate middleware rate_limiter --sync
+    """
+    console.print("\n[bold cyan]Generating Middleware Component[/bold cyan]\n")
+
+    template_vars = {
+        "async": is_async,
+        "return_type": "None",  # Middleware typically doesn't return values
+    }
+
+    generate_component_workflow("middleware", name, template_vars, None, dry_run, description)

fips_agents_cli/tools/filesystem.py

@@ -1,7 +1,6 @@
 """Filesystem utilities for project operations."""
 
 from pathlib import Path
-from typing import Optional
 
 from rich.console import Console
 
@@ -54,7 +53,7 @@ def check_directory_empty(path: Path) -> bool:
 
 def validate_target_directory(
     target_path: Path, allow_existing: bool = False
-) -> tuple[bool, Optional[str]]:
+) -> tuple[bool, str | None]:
     """
     Validate that a target directory is suitable for project creation.
 
@@ -86,7 +85,7 @@ def validate_target_directory(
     return True, None
 
 
-def resolve_target_path(project_name: str, target_dir: Optional[str] = None) -> Path:
+def resolve_target_path(project_name: str, target_dir: str | None = None) -> Path:
     """
     Resolve the target path for project creation.
 
@@ -105,7 +104,7 @@ def resolve_target_path(project_name: str, target_dir: Optional[str] = None) ->
     return base / project_name
 
 
-def get_relative_path(path: Path, base: Optional[Path] = None) -> str:
+def get_relative_path(path: Path, base: Path | None = None) -> str:
     """
     Get a relative path string for display purposes.
 

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.1"

{fips_agents_cli-0.1.0.dist-info → fips_agents_cli-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fips-agents-cli
-Version: 0.1.0
+Version: 0.1.1
 Summary: CLI tool for creating and managing FIPS-compliant AI agent projects
 Project-URL: Homepage, https://github.com/rdwj/fips-agents-cli
 Project-URL: Repository, https://github.com/rdwj/fips-agents-cli
@@ -13,15 +13,15 @@ Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Requires-Dist: click>=8.1.0
 Requires-Dist: gitpython>=3.1.0
+Requires-Dist: jinja2>=3.1.2
 Requires-Dist: rich>=13.0.0
 Requires-Dist: tomlkit>=0.12.0
 Provides-Extra: dev
@@ -40,9 +40,10 @@ A command-line tool for creating and managing FIPS-compliant AI agent projects,
 - 🚀 Quick project scaffolding from templates
 - 📦 MCP server project generation
 - 🔧 Automatic project customization
+- ⚡ Component generation (tools, resources, prompts, middleware)
 - 🎨 Beautiful CLI output with Rich
 - ✅ Git repository initialization
-- 🧪 Comprehensive test coverage
+- 🧪 Comprehensive test coverage with auto-run
 
 ## Installation
 
@@ -99,6 +100,25 @@ fips-agents create mcp-server my-server --target-dir ~/projects
 fips-agents create mcp-server my-server --no-git
 ```
 
+### Generate components in an existing project
+
+```bash
+# Navigate to your MCP server project
+cd my-mcp-server
+
+# Generate a new tool
+fips-agents generate tool search_documents --description "Search through documents"
+
+# Generate a resource
+fips-agents generate resource config_data --description "Application configuration"
+
+# Generate a prompt
+fips-agents generate prompt code_review --description "Review code for best practices"
+
+# Generate middleware
+fips-agents generate middleware auth_middleware --description "Authentication middleware"
+```
+
 ## Usage
 
 ### Basic Commands
@@ -111,6 +131,8 @@ fips-agents --version
 fips-agents --help
 fips-agents create --help
 fips-agents create mcp-server --help
+fips-agents generate --help
+fips-agents generate tool --help
 ```
 
 ### Create MCP Server
@@ -140,6 +162,168 @@ fips-agents create mcp-server my-server -t ~/projects
 fips-agents create mcp-server my-server --no-git
 ```
 
+### Generate Components
+
+The `generate` command group allows you to scaffold MCP components (tools, resources, prompts, middleware) in existing MCP server projects.
+
+**Important**: Run these commands from within your MCP server project directory.
+
+#### Generate Tool
+
+```bash
+fips-agents generate tool <name> [OPTIONS]
+```
+
+**Arguments:**
+- `name`: Tool name in snake_case (e.g., `search_documents`, `fetch_data`)
+
+**Options:**
+- `--description, -d TEXT`: Tool description
+- `--async/--sync`: Generate async or sync function (default: async)
+- `--with-context`: Include FastMCP Context parameter
+- `--with-auth`: Include authentication decorator
+- `--params PATH`: JSON file with parameter definitions
+- `--read-only`: Mark as read-only operation (default: true)
+- `--idempotent`: Mark as idempotent (default: true)
+- `--open-world`: Mark as open-world operation
+- `--return-type TEXT`: Return type annotation (default: str)
+- `--dry-run`: Show what would be generated without creating files
+
+**Examples:**
+
+```bash
+# Basic tool generation
+fips-agents generate tool search_documents --description "Search through documents"
+
+# Tool with context and authentication
+fips-agents generate tool fetch_user_data --description "Fetch user data" --with-context --with-auth
+
+# Tool with parameters from JSON file
+fips-agents generate tool advanced_search --params params.json
+
+# Sync tool with custom return type
+fips-agents generate tool process_data --sync --return-type "dict[str, Any]"
+
+# Dry run to preview
+fips-agents generate tool test_tool --description "Test" --dry-run
+```
+
+#### Generate Resource
+
+```bash
+fips-agents generate resource <name> [OPTIONS]
+```
+
+**Arguments:**
+- `name`: Resource name in snake_case (e.g., `config_data`, `user_profile`)
+
+**Options:**
+- `--description, -d TEXT`: Resource description
+- `--async/--sync`: Generate async or sync function (default: async)
+- `--with-context`: Include FastMCP Context parameter
+- `--uri TEXT`: Resource URI (default: `resource://<name>`)
+- `--mime-type TEXT`: MIME type for resource (default: text/plain)
+- `--dry-run`: Show what would be generated without creating files
+
+**Examples:**
+
+```bash
+# Basic resource
+fips-agents generate resource config_data --description "Application configuration"
+
+# Resource with custom URI
+fips-agents generate resource user_profile --uri "resource://users/{id}" --description "User profile data"
+
+# Resource with specific MIME type
+fips-agents generate resource json_config --mime-type "application/json"
+```
+
+#### Generate Prompt
+
+```bash
+fips-agents generate prompt <name> [OPTIONS]
+```
+
+**Arguments:**
+- `name`: Prompt name in snake_case (e.g., `code_review`, `summarize_text`)
+
+**Options:**
+- `--description, -d TEXT`: Prompt description
+- `--params PATH`: JSON file with parameter definitions
+- `--with-schema`: Include JSON schema in prompt
+- `--dry-run`: Show what would be generated without creating files
+
+**Examples:**
+
+```bash
+# Basic prompt
+fips-agents generate prompt code_review --description "Review code for best practices"
+
+# Prompt with parameters
+fips-agents generate prompt summarize_text --params params.json --with-schema
+```
+
+#### Generate Middleware
+
+```bash
+fips-agents generate middleware <name> [OPTIONS]
+```
+
+**Arguments:**
+- `name`: Middleware name in snake_case (e.g., `auth_middleware`, `rate_limiter`)
+
+**Options:**
+- `--description, -d TEXT`: Middleware description
+- `--async/--sync`: Generate async or sync function (default: async)
+- `--dry-run`: Show what would be generated without creating files
+
+**Examples:**
+
+```bash
+# Basic middleware
+fips-agents generate middleware auth_middleware --description "Authentication middleware"
+
+# Sync middleware
+fips-agents generate middleware rate_limiter --sync --description "Rate limiting middleware"
+```
+
+#### Parameters JSON Schema
+
+When using `--params` flag, provide a JSON file with parameter definitions:
+
+```json
+[
+  {
+    "name": "query",
+    "type": "str",
+    "description": "Search query",
+    "required": true,
+    "min_length": 1,
+    "max_length": 100
+  },
+  {
+    "name": "limit",
+    "type": "int",
+    "description": "Maximum results to return",
+    "required": false,
+    "default": 10,
+    "ge": 1,
+    "le": 100
+  }
+]
+```
+
+**Supported Types:**
+- `str`, `int`, `float`, `bool`
+- `list[str]`, `list[int]`, `list[float]`
+- `Optional[str]`, `Optional[int]`, `Optional[float]`, `Optional[bool]`
+
+**Pydantic Field Constraints:**
+- `min_length`, `max_length` (for strings)
+- `ge`, `le`, `gt`, `lt` (for numbers)
+- `pattern` (for regex validation on strings)
+- `default` (default value when optional)
+
 ## Project Name Requirements
 
 Project names must follow these rules:
@@ -249,7 +433,7 @@ fips-agents-cli/
 
 ## Requirements
 
-- Python 3.9 or higher
+- Python 3.10 or higher
 - Git (for cloning templates and initializing repositories)
 
 ## Dependencies
@@ -258,6 +442,7 @@ fips-agents-cli/
 - **rich** (>=13.0.0): Terminal output formatting
 - **gitpython** (>=3.1.0): Git operations
 - **tomlkit** (>=0.12.0): TOML file manipulation
+- **jinja2** (>=3.1.2): Template rendering for component generation
 
 ## Contributing
 
@@ -295,6 +480,28 @@ If template cloning fails:
 - Verify the template repository is accessible: https://github.com/rdwj/mcp-server-template
 - Try again later if GitHub is experiencing issues
 
+### "Not in an MCP server project directory"
+
+When using `generate` commands:
+- Ensure you're running the command from within an MCP server project
+- Check that `pyproject.toml` exists with `fastmcp` dependency
+- If the project wasn't created with `fips-agents create mcp-server`, generator templates may be missing
+
+### "Component already exists"
+
+If you see this error:
+- Choose a different component name
+- Manually remove the existing component file from `src/<component-type>/`
+- Check the component type directory for existing files
+
+### Invalid component name
+
+Component names must:
+- Be valid Python identifiers (snake_case)
+- Not be Python keywords (`for`, `class`, etc.)
+- Start with a letter or underscore
+- Contain only letters, numbers, and underscores
+
 ## License
 
 MIT License - see LICENSE file for details
@@ -307,6 +514,16 @@ MIT License - see LICENSE file for details
 
 ## Changelog
 
+### Version 0.1.1 (Current)
+
+- Added `fips-agents generate` command group
+- Component generation: tools, resources, prompts, middleware
+- Jinja2-based template rendering
+- Parameter validation and JSON schema support
+- Auto-run pytest on generated components
+- Dry-run mode for previewing changes
+- Comprehensive error handling and validation
+
 ### Version 0.1.0 (MVP)
 
 - Initial release

fips_agents_cli-0.1.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+fips_agents_cli/__init__.py,sha256=Jfo6y6T4HIQ-BeeF89w7F-F4BED63KyCIc1yoFGn9OM,167
+fips_agents_cli/__main__.py,sha256=rUeQY3jrV6hQVAI2IE0qZCcUnvXDMj5LiCjhlXsc9PQ,130
+fips_agents_cli/cli.py,sha256=c6ZSIfqZXTAfGc_2sKXanWDuWbxXTUjp4nSbl7yeDig,799
+fips_agents_cli/version.py,sha256=N1v0FJOEwbpJriPhyukh9-v8PmOs6ppJbMd7pTWGYmc,70
+fips_agents_cli/commands/__init__.py,sha256=AGxi2-Oc-gKE3sR9F39nIxwnzz-4bcfkkJzaP1qhMvU,40
+fips_agents_cli/commands/create.py,sha256=wWJZTa2NOoF40lnqIGKXKNcZT5jIZxInGk3CAkUfa3w,6372
+fips_agents_cli/commands/generate.py,sha256=hoPERkaYGlt-R79PRWnxE6vwNtWfun7SMtJN2zaOIKo,14113
+fips_agents_cli/tools/__init__.py,sha256=ah4OrYFuyQavuhwguFwFS0o-7ZLGIm5ZWWQK5ZTZZSs,47
+fips_agents_cli/tools/filesystem.py,sha256=1AOOJtkDSw-pqkuUJyVUbquuczpZBZMT4HLl3qCPB3k,3276
+fips_agents_cli/tools/generators.py,sha256=bwHKBzWkfJxug4YQXrkRQB_-BxR78kZqe46AjC7haHY,9372
+fips_agents_cli/tools/git.py,sha256=-z2EO7vNZhN6Vuzh34ZbqNteZE4vNnLG8oysgzhmypk,3042
+fips_agents_cli/tools/project.py,sha256=vgnctNgdRJJB14uqy7WM0bqpAoPoK_fZu16Io5Rn2hA,5699
+fips_agents_cli/tools/validation.py,sha256=3947i5UI46BmwBw4F0yLNdkWvkGJig8qH1nJzvQS6RA,5771
+fips_agents_cli-0.1.1.dist-info/METADATA,sha256=O8D_AVK27NvVPL61BdbWHAwpgbFhz7gsZOuGAZXh2eA,14660
+fips_agents_cli-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fips_agents_cli-0.1.1.dist-info/entry_points.txt,sha256=srO4LAGNp6zcB9zuPW1toLGPyLbcsad9YWsfNxgz20s,57
+fips_agents_cli-0.1.1.dist-info/licenses/LICENSE,sha256=dQJIqi2t9SinZu0yALTYJ8juzosu29KPbjU8WhyboRc,1068
+fips_agents_cli-0.1.1.dist-info/RECORD,,

fips_agents_cli-0.1.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-fips_agents_cli/__init__.py,sha256=Jfo6y6T4HIQ-BeeF89w7F-F4BED63KyCIc1yoFGn9OM,167
-fips_agents_cli/__main__.py,sha256=rUeQY3jrV6hQVAI2IE0qZCcUnvXDMj5LiCjhlXsc9PQ,130
-fips_agents_cli/cli.py,sha256=e2QGiAH73pHAjpdf7JdovyNZtc2nyb83LaVaLbLqS5o,718
-fips_agents_cli/version.py,sha256=EeROn-Cy9mXSPq-OrZ--hVR0oQvwMNqIyAgy4w-YowU,70
-fips_agents_cli/commands/__init__.py,sha256=AGxi2-Oc-gKE3sR9F39nIxwnzz-4bcfkkJzaP1qhMvU,40
-fips_agents_cli/commands/create.py,sha256=GvGm8VgsIfqZV_yIXXYzeV-nasLIwuD85_l831YjAho,6403
-fips_agents_cli/tools/__init__.py,sha256=ah4OrYFuyQavuhwguFwFS0o-7ZLGIm5ZWWQK5ZTZZSs,47
-fips_agents_cli/tools/filesystem.py,sha256=G9wzHrgQpoMw3z5EslsyEL91VLlUT6Cf5Rt80DtkwOw,3313
-fips_agents_cli/tools/git.py,sha256=-z2EO7vNZhN6Vuzh34ZbqNteZE4vNnLG8oysgzhmypk,3042
-fips_agents_cli/tools/project.py,sha256=d_qIhsEzPOM55ONSLzheTozXuyuiEEf9OG4hVXISAbk,5730
-fips_agents_cli-0.1.0.dist-info/METADATA,sha256=j3-wAEIftpKnjwj4BVKykYPQh4eDXGva_RNIKh55Qiw,8220
-fips_agents_cli-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fips_agents_cli-0.1.0.dist-info/entry_points.txt,sha256=srO4LAGNp6zcB9zuPW1toLGPyLbcsad9YWsfNxgz20s,57
-fips_agents_cli-0.1.0.dist-info/licenses/LICENSE,sha256=dQJIqi2t9SinZu0yALTYJ8juzosu29KPbjU8WhyboRc,1068
-fips_agents_cli-0.1.0.dist-info/RECORD,,