model-generator-kit 0.1.0__py3-none-any.whl

model_generator/validate.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""
+Model JSON Validator.
+
+Validates model definition JSON files against the multi-entity schema.
+
+Usage:
+    python validate.py <model.json>
+    python validate.py models/users.model.json
+    python validate.py --all models/
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any, cast
+
+from jsonschema import Draft7Validator
+
+from . import __version__
+
+
+def load_schema() -> dict[str, Any]:
+    """Load the model schema from the skill directory."""
+    script_dir = Path(__file__).parent
+    schema_path = script_dir / "schema" / "model.schema.json"
+
+    if not schema_path.exists():
+        print(f"Error: Schema not found at {schema_path}")
+        sys.exit(1)
+
+    with open(schema_path) as f:
+        return cast(dict[str, Any], json.load(f))
+
+
+def validate_model(model_path: Path, schema: dict[str, Any]) -> list[str]:
+    """
+    Validate a model JSON file against the schema.
+
+    Returns list of error messages (empty if valid).
+    """
+    errors = []
+
+    if not model_path.exists():
+        return [f"File not found: {model_path}"]
+
+    try:
+        with open(model_path) as f:
+            model = json.load(f)
+    except json.JSONDecodeError as e:
+        return [f"Invalid JSON: {e}"]
+
+    # Validate against schema
+    validator = Draft7Validator(schema)
+    for error in sorted(validator.iter_errors(model), key=lambda e: e.path):
+        path = " -> ".join(str(p) for p in error.path) if error.path else "(root)"
+        errors.append(f"  {path}: {error.message}")
+
+    # Additional semantic validations
+    if not errors:
+        errors.extend(validate_semantics(model))
+
+    return errors
+
+
+def validate_semantics(model: dict[str, Any]) -> list[str]:
+    """
+    Perform semantic validations beyond schema.
+
+    Validates each entity for:
+    - Primary key field exists
+    - Enum fields have values or reference existing enum
+    - Reference fields point to valid tables
+    - Constraint field references exist
+    - Relationship targets exist within the domain
+    - Immutable entity constraints
+    """
+    errors = []
+    entities = model.get("entities", {})
+
+    for entity_name, entity in entities.items():
+        prefix = f"  [{entity_name}]"
+        fields = entity.get("fields", {})
+
+        # Check for primary key
+        has_pk = any(f.get("primary_key", False) for f in fields.values())
+        if not has_pk:
+            errors.append(f"{prefix} No primary key field defined")
+
+        # Check enum fields
+        for field_name, field in fields.items():
+            if field.get("type") == "enum":
+                if not field.get("enum_name"):
+                    errors.append(
+                        f"{prefix} Enum field '{field_name}' missing enum_name"
+                    )
+                if not field.get("enum_values") and not field.get("enum_existing"):
+                    errors.append(
+                        f"{prefix} Enum field '{field_name}' "
+                        "needs enum_values or enum_existing=true"
+                    )
+
+        # Check reference fields
+        for field_name, field in fields.items():
+            if field.get("type") == "reference":
+                if not field.get("reference_table"):
+                    errors.append(
+                        f"{prefix} Reference field '{field_name}' "
+                        "missing reference_table"
+                    )
+
+        # Check field constraints reference valid fields
+        for field_name, field in fields.items():
+            for constraint in field.get("constraints", []):
+                if constraint.get("type") == "depends":
+                    other_field = constraint.get("other_field")
+                    if other_field and other_field not in fields:
+                        errors.append(
+                            f"{prefix} Constraint on '{field_name}' references "
+                            f"non-existent field '{other_field}'"
+                        )
+
+        # Check table constraints reference valid fields
+        for constraint in entity.get("constraints", []):
+            for field_ref in constraint.get("fields", []):
+                if field_ref not in fields:
+                    errors.append(
+                        f"{prefix} Table constraint references "
+                        f"non-existent field '{field_ref}'"
+                    )
+
+        # Collect all known field names (explicit + timestamp-generated)
+        all_field_names = set(fields.keys())
+        timestamps = entity.get("timestamps", {})
+        if timestamps.get("created", True):
+            all_field_names.add("created_at")
+        if timestamps.get("updated", True):
+            all_field_names.add("updated_at")
+
+        # Check index fields exist
+        for index in entity.get("indexes", []):
+            for field_ref in index.get("fields", []):
+                if field_ref not in all_field_names:
+                    errors.append(
+                        f"{prefix} Index references non-existent field '{field_ref}'"
+                    )
+
+        # Check immutable entities
+        if entity.get("mutability") == "immutable":
+            if entity.get("timestamps", {}).get("updated"):
+                errors.append(
+                    f"{prefix} Immutable entities should not have updated_at timestamp"
+                )
+            api_endpoints = entity.get("api", {}).get("endpoints", [])
+            if "update" in api_endpoints or "delete" in api_endpoints:
+                errors.append(
+                    f"{prefix} Immutable entities should not have "
+                    "'update' or 'delete' endpoints"
+                )
+
+        # Relationship targets: cross-domain refs are allowed, no validation here.
+
+    return errors
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Validate model JSON files")
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    parser.add_argument(
+        "path",
+        type=Path,
+        help="Model JSON file or directory containing model files",
+    )
+    parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Validate all *.model.json files in directory",
+    )
+
+    args = parser.parse_args()
+    schema = load_schema()
+
+    if args.path.is_dir() or args.all:
+        directory = args.path if args.path.is_dir() else args.path.parent
+        model_files = list(directory.glob("*.model.json"))
+        if not model_files:
+            print(f"No *.model.json files found in {directory}")
+            sys.exit(1)
+    else:
+        model_files = [args.path]
+
+    all_valid = True
+    for model_path in sorted(model_files):
+        errors = validate_model(model_path, schema)
+        if errors:
+            all_valid = False
+            print(f"\n❌ {model_path.name}:")
+            for error in errors:
+                print(error)
+        else:
+            # Show entity count
+            with open(model_path) as f:
+                model = json.load(f)
+            entity_count = len(model.get("entities", {}))
+            print(f"✅ {model_path.name}: Valid ({entity_count} entities)")
+
+    if not all_valid:
+        sys.exit(1)
+
+    print(f"\n✅ All {len(model_files)} model(s) valid")
+
+
+if __name__ == "__main__":
+    main()

model_generator/wizard/__init__.py

@@ -0,0 +1,10 @@
+"""
+Interactive wizard for model-generator.
+
+Usage:
+    model-gen --interactive
+"""
+
+from .menu import run_menu as run_wizard
+
+__all__ = ["run_wizard"]

model_generator/wizard/actions/__init__.py

@@ -0,0 +1 @@
+"""Wizard actions package."""

model_generator/wizard/actions/clean.py

@@ -0,0 +1,55 @@
+"""
+Action: Clean generated files.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from ..prompts import confirm, select
+
+
+def _find_project_root() -> Path:
+    """Find project root by looking for .model-generator.yaml."""
+    cwd = Path.cwd()
+    if (cwd / ".model-generator.yaml").exists():
+        return cwd
+    parent = cwd.parent
+    if (parent / ".model-generator.yaml").exists():
+        return parent
+    return cwd
+
+
+def run_clean() -> None:
+    """Select scope, preview, confirm, and clean generated files."""
+    project_root = _find_project_root()
+
+    if not (project_root / ".model-generator.yaml").exists():
+        print("\nNo .model-generator.yaml found.")
+        print("Run 'Setup/update project settings' first.")
+        return
+
+    scope = select(
+        "Cleanup scope:",
+        choices=["selective", "full"],
+        default="selective",
+    )
+
+    print(f"\nScope: {scope}")
+    if scope == "selective":
+        print("  Will remove only files that would be regenerated.")
+    else:
+        print("  Will remove all generated directories, caches, and venvs.")
+
+    # Dry run first
+    from ...generate import cleanup_generated
+
+    print("\nPreview (what would be deleted):")
+    cleanup_generated(project_root, scope=scope, dry_run=True)
+
+    if not confirm("\nProceed with deletion?", default=False):
+        print("Cancelled.")
+        return
+
+    cleanup_generated(project_root, scope=scope, dry_run=False)
+    print("\nCleanup complete.")

model_generator/wizard/actions/generate.py

@@ -0,0 +1,166 @@
+"""
+Action: Generate code from model specifications.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from ..prompts import checkbox, confirm, select
+
+INFRASTRUCTURE_TARGETS = {"all", "infrastructure"}
+
+
+def _find_project_root() -> Path:
+    """Find project root by looking for .model-generator.yaml."""
+    cwd = Path.cwd()
+    if (cwd / ".model-generator.yaml").exists():
+        return cwd
+    parent = cwd.parent
+    if (parent / ".model-generator.yaml").exists():
+        return parent
+    return cwd
+
+
+def _find_models_dir(project_root: Path) -> Path | None:
+    """Find the models directory."""
+    models_dir = project_root / "models"
+    if models_dir.exists():
+        return models_dir
+    return None
+
+
+def run_generate() -> None:
+    """Select domains and targets, then run generation."""
+    project_root = _find_project_root()
+
+    if not (project_root / ".model-generator.yaml").exists():
+        print("\nNo .model-generator.yaml found.")
+        print("Run 'Setup/update project settings' first.")
+        return
+
+    models_dir = _find_models_dir(project_root)
+    if models_dir is None:
+        print(f"\nNo models/ directory found in {project_root}")
+        return
+
+    # Scan for model files
+    model_files = sorted(models_dir.glob("*.model.json"))
+    if not model_files:
+        print(f"\nNo *.model.json files found in {models_dir}")
+        return
+
+    domain_names = [f.stem.replace(".model", "") for f in model_files]
+    print(f"\nFound {len(model_files)} domain(s): {', '.join(domain_names)}")
+
+    # Select domains
+    if len(model_files) > 1:
+        selected = checkbox(
+            "Select domains to generate:",
+            choices=["all"] + domain_names,
+        )
+        if "all" in selected:
+            selected_files = model_files
+        else:
+            selected_files = [
+                f for f in model_files if f.stem.replace(".model", "") in selected
+            ]
+    else:
+        selected_files = model_files
+
+    if not selected_files:
+        print("No domains selected.")
+        return
+
+    # Select target
+    targets = [
+        "all",
+        "infrastructure",
+        "database",
+        "factories",
+        "api-models",
+        "api-routes",
+        "api-tests",
+        "enums",
+        "constraints",
+        "migration-init",
+    ]
+    target = select("Generation target:", choices=targets, default="all")
+
+    # Confirm
+    file_names = [f.name for f in selected_files]
+    print(f"\nWill generate '{target}' for: {', '.join(file_names)}")
+    if not confirm("Proceed?"):
+        return
+
+    # Generate infrastructure if needed (same logic as main())
+    if target in INFRASTRUCTURE_TARGETS:
+        from ...generate import _has_encrypted_binary_field
+        from ...generators.infrastructure import generate_infrastructure
+        from ...utils import (
+            get_layout,
+            get_template_env,
+            load_config,
+            load_model,
+            run_quality_tools,
+        )
+        from ...utils.templates import snake_case
+
+        stack = "python-fastapi"
+        config = load_config(stack)
+        env = get_template_env(stack, config)
+        layout = get_layout(config)
+
+        domains: list[str] = []
+        route_modules: list[str] = []
+        factory_modules: list[str] = []
+        loaded_models: list[dict[str, Any]] = []
+        for model_file in selected_files:
+            model = load_model(model_file)
+            loaded_models.append(model)
+            domain = model.get("domain", "unknown")
+            has_api = any(
+                e.get("api", {}).get("enabled", True)
+                for e in model.get("entities", {}).values()
+            )
+            if domain not in domains and has_api:
+                domains.append(domain)
+            if layout == "per-entity":
+                for name, entity in model.get("entities", {}).items():
+                    stem = snake_case(name)
+                    if (
+                        entity.get("api", {}).get("enabled", True)
+                        and stem not in route_modules
+                    ):
+                        route_modules.append(stem)
+                    if has_api and stem not in factory_modules:
+                        factory_modules.append(stem)
+        if layout != "per-entity":
+            route_modules = list(domains)
+            factory_modules = list(domains)
+
+        infra_files = generate_infrastructure(
+            config=config,
+            env=env,
+            project_root=project_root,
+            domains=domains,
+            route_modules=route_modules,
+            factory_modules=factory_modules,
+            project_config=config,
+            has_encrypted_binary=_has_encrypted_binary_field(loaded_models),
+        )
+        if infra_files:
+            run_quality_tools(config, project_root, infra_files)
+
+    if target == "infrastructure":
+        print("\nInfrastructure generation complete.")
+        return
+
+    # Generate per domain using the existing generate() function
+    from ...generate import generate
+
+    for model_file in selected_files:
+        generate(model_path=model_file, target=target)
+
+    print("\nGeneration complete.")

model_generator/wizard/actions/project_setup.py

@@ -0,0 +1,142 @@
+"""
+Action: Setup or update project settings (.model-generator.yaml).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from ..prompts import confirm, select, text
+
+
+def _find_project_root() -> Path:
+    """Find project root by looking for .model-generator.yaml."""
+    cwd = Path.cwd()
+    if (cwd / ".model-generator.yaml").exists():
+        return cwd
+    parent = cwd.parent
+    if (parent / ".model-generator.yaml").exists():
+        return parent
+    return cwd
+
+
+def _scan_stacks() -> list[str]:
+    """Scan available stacks from the stacks directory."""
+    stacks_dir = Path(__file__).parent.parent / "stacks"
+    if not stacks_dir.exists():
+        return ["python-fastapi"]
+    return sorted(
+        d.name
+        for d in stacks_dir.iterdir()
+        if d.is_dir() and not d.name.startswith(".")
+    )
+
+
+_PATH_LAYOUTS: dict[str, dict[str, str]] = {
+    "full-stack (backend/src/)": {
+        "database_models": "backend/src/database/models",
+        "factories": "backend/src/database/models/factories",
+        "api_models": "backend/src/api/models",
+        "api_routes": "backend/src/api/routes",
+        "api_tests": "tests/contract/api",
+        "base": "backend/src/database/models/base.py",
+        "engine": "backend/src/database/engine.py",
+        "main": "backend/src/main.py",
+        "errors": "backend/src/api/errors.py",
+        "validators": "backend/src/api/validators.py",
+        "test_conftest_root": "tests/conftest.py",
+        "enums": "backend/src/database/models/enums.py",
+        "constraints": "backend/src/database/models/constraints.py",
+    },
+    "backend-only (src/)": {
+        "database_models": "src/database/models",
+        "factories": "src/database/models/factories",
+        "api_models": "src/api/models",
+        "api_routes": "src/api/routes",
+        "api_tests": "tests/api",
+        "base": "src/database/models/base.py",
+        "engine": "src/database/engine.py",
+        "main": "src/main.py",
+        "errors": "src/api/errors.py",
+        "validators": "src/api/validators.py",
+        "test_conftest_root": "tests/conftest.py",
+        "enums": "src/database/models/enums.py",
+        "constraints": "src/database/models/constraints.py",
+    },
+}
+
+
+def run_setup() -> None:
+    """Create or update .model-generator.yaml interactively."""
+    project_root = _find_project_root()
+    config_path = project_root / ".model-generator.yaml"
+
+    if config_path.exists():
+        _update_config(config_path)
+    else:
+        _create_config(config_path, project_root)
+
+
+def _create_config(config_path: Path, project_root: Path) -> None:
+    """Guide user through creating a new config."""
+    print("\n--- Create Project Settings ---\n")
+
+    name = text("Project name:", default=project_root.name)
+    description = text("Description (optional):", default="")
+    version = text("Version:", default="0.1.0")
+
+    stacks = _scan_stacks()
+    stack = select("Stack:", choices=stacks, default="python-fastapi")
+
+    layout_choices = list(_PATH_LAYOUTS.keys()) + ["custom"]
+    layout = select("Path layout:", choices=layout_choices, default=layout_choices[0])
+
+    config: dict[str, Any] = {
+        "project": {"name": name, "version": version},
+        "stack": stack,
+    }
+    if description:
+        config["project"]["description"] = description
+
+    if layout != "custom" and layout in _PATH_LAYOUTS:
+        config["paths"] = _PATH_LAYOUTS[layout]
+
+    config_path.write_text(yaml.dump(config, default_flow_style=False, sort_keys=False))
+    print(f"\nCreated: {config_path}")
+
+    # Create models directory
+    models_dir = project_root / "models"
+    if not models_dir.exists():
+        if confirm("Create models/ directory?"):
+            models_dir.mkdir(parents=True)
+            print(f"Created: {models_dir}")
+
+
+def _update_config(config_path: Path) -> None:
+    """Show current config and offer updates."""
+    print("\n--- Update Project Settings ---\n")
+
+    with open(config_path) as f:
+        config = yaml.safe_load(f) or {}
+
+    print("Current configuration:")
+    print(yaml.dump(config, default_flow_style=False))
+
+    if not confirm("Update settings?", default=False):
+        return
+
+    project = config.get("project", {})
+    project["name"] = text("Project name:", default=project.get("name", ""))
+    project["version"] = text("Version:", default=project.get("version", "0.1.0"))
+    config["project"] = project
+
+    stacks = _scan_stacks()
+    config["stack"] = select(
+        "Stack:", choices=stacks, default=config.get("stack", "python-fastapi")
+    )
+
+    config_path.write_text(yaml.dump(config, default_flow_style=False, sort_keys=False))
+    print(f"\nUpdated: {config_path}")

model_generator/wizard/actions/test_runner.py

@@ -0,0 +1,60 @@
+"""
+Action: Run tests via pytest.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+from ..prompts import confirm, select
+
+
+def _find_project_root() -> Path:
+    """Find project root by looking for .model-generator.yaml."""
+    cwd = Path.cwd()
+    if (cwd / ".model-generator.yaml").exists():
+        return cwd
+    parent = cwd.parent
+    if (parent / ".model-generator.yaml").exists():
+        return parent
+    return cwd
+
+
+def _find_test_dir(project_root: Path) -> Path | None:
+    """Find the test directory."""
+    for candidate in ["tests", "test"]:
+        test_dir = project_root / candidate
+        if test_dir.exists():
+            return test_dir
+    return None
+
+
+def run_tests() -> None:
+    """Run pytest with selected options."""
+    project_root = _find_project_root()
+    test_dir = _find_test_dir(project_root)
+
+    if test_dir is None:
+        print(f"\nNo tests/ directory found in {project_root}")
+        return
+
+    mode = select(
+        "Test mode:",
+        choices=["all tests", "verbose (-v)", "with coverage"],
+        default="all tests",
+    )
+
+    cmd = [sys.executable, "-m", "pytest", str(test_dir)]
+
+    if mode == "verbose (-v)":
+        cmd.append("-v")
+    elif mode == "with coverage":
+        cmd.extend(["--cov", "--cov-report=term-missing"])
+
+    print(f"\nRunning: {' '.join(cmd)}")
+    if not confirm("Proceed?"):
+        return
+
+    subprocess.run(cmd, cwd=str(project_root))