fix(prompting): avoid rejecting prefilled payloads

- Skip final jsonschema validation for prompt_for_schema (prompt schema is lossy)

- Add schema_validation helper and regression coverage

- Bump Typer minimum version

Signed-off-by: Matthew Grigsby <38010437+MatthewGrigsby@users.noreply.github.com>

Author: MatthewGrigsby

cforge/common/prompting.py

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+"""Copyright 2025
+SPDX-License-Identifier: Apache-2.0
+
+JSON Schema validation helpers.
+
+This module centralizes jsonschema-based validation so callers can validate
+full payloads or individual field values against sub-schemas while preserving
+root-schema `$ref` resolution.
+"""
+
+# Standard
+from typing import Any, Dict, Optional, Tuple
+
+# Third-Party
+from jsonschema import SchemaError
+from jsonschema.exceptions import ValidationError
+from jsonschema.validators import validator_for
+
+
+def _error_sort_key(error: ValidationError) -> Tuple[Tuple[str, ...], Tuple[str, ...]]:
+    """Sort errors deterministically by instance path then schema path."""
+    return tuple(str(part) for part in error.path), tuple(str(part) for part in error.schema_path)
+
+
+def _format_error_path(error: ValidationError) -> str:
+    """Format an instance path in a compact jsonpath-like style."""
+    if not error.path:
+        return "$"
+
+    segments = ["$"]
+    for part in error.path:
+        if isinstance(part, int):
+            segments.append(f"[{part}]")
+        else:
+            segments.append(f".{part}")
+    return "".join(segments)
+
+
+def _format_validation_error(error: ValidationError) -> str:
+    """Format a validation error for user-facing CLI messages."""
+    location = _format_error_path(error)
+    if location == "$":
+        return error.message
+    return f"{location}: {error.message}"
+
+
+def _first_validation_error_message(errors: list[ValidationError]) -> Optional[str]:
+    """Return a formatted first error message when validation fails."""
+    if not errors:
+        return None
+    return _format_validation_error(errors[0])
+
+
+def _build_root_validator(schema: Dict[str, Any]) -> Any:
+    """Build a jsonschema validator from a root schema."""
+    validator_cls = validator_for(schema)
+    validator_cls.check_schema(schema)
+    return validator_cls(schema)
+
+
+def validate_instance(schema: Dict[str, Any], instance: Any) -> Optional[str]:
+    """Validate an instance against a full schema.
+
+    Returns:
+        A user-facing error message when invalid, otherwise ``None``.
+    """
+    if not isinstance(schema, dict):
+        return "Input schema must be a JSON object"
+
+    try:
+        validator = _build_root_validator(schema)
+        errors = sorted(validator.iter_errors(instance), key=_error_sort_key)
+        return _first_validation_error_message(errors)
+    except SchemaError as exc:
+        return f"Invalid JSON Schema: {exc}"
+    except Exception as exc:  # pragma: no cover - defensive fallback for validator internals
+        return f"Schema validation failed: {exc}"
+
+
+def validate_instance_against_subschema(root_schema: Dict[str, Any], subschema: Dict[str, Any], instance: Any) -> Optional[str]:
+    """Validate an instance against a subschema with root `$ref` context.
+
+    Returns:
+        A user-facing error message when invalid, otherwise ``None``.
+    """
+    if not isinstance(root_schema, dict):
+        return "Input schema must be a JSON object"
+    if not isinstance(subschema, dict):
+        return "Input schema must be a JSON object"
+
+    try:
+        root_validator = _build_root_validator(root_schema)
+        root_validator.__class__.check_schema(subschema)
+        subschema_validator = root_validator.evolve(schema=subschema)
+        errors = sorted(subschema_validator.iter_errors(instance), key=_error_sort_key)
+        return _first_validation_error_message(errors)
+    except SchemaError as exc:
+        return f"Invalid JSON Schema: {exc}"
+    except Exception as exc:  # pragma: no cover - defensive fallback for validator internals
+        return f"Schema validation failed: {exc}"

cforge/common/schema_validation.py

@@ -21,7 +21,6 @@
 from mcpgateway.config import Settings
 from mcpgateway.config import get_settings as cf_get_settings
 
-
 HOME_DIR_NAME = ".contextforge"
 DEFAULT_HOME = Path.home() / HOME_DIR_NAME
 

cforge/config.py

@@ -47,9 +47,10 @@ maintainers = [
 # ----------------------------------------------------------------
 dependencies = [
     "rich>=13.9.4",
-    "typer>=0.20.0",
+    "typer>=0.23.1",
     "mcp-contextforge-gateway==1.0.0b2",
     "cryptography>=44.0.0",
+    "jsonschema>=4.23.0",
 ]
 
 # ----------------------------------------------------------------

pyproject.toml

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+"""Tests for cforge.common.console."""
+
+# First-Party
+from cforge.common.console import get_app, get_console
+
+
+class TestSingletons:
+    """Tests for singleton getter functions."""
+
+    def test_get_console_returns_console(self) -> None:
+        """Test that get_console returns a Console instance."""
+        console = get_console()
+        assert console is not None
+        # Should return same instance
+        assert get_console() is console
+
+    def test_get_app_returns_typer_app(self) -> None:
+        """Test that get_app returns a Typer instance."""
+        app = get_app()
+        assert app is not None
+        # Should return same instance
+        assert get_app() is app

tests/common/test_console.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+"""Tests for cforge.common.errors."""
+
+# First-Party
+from cforge.common.errors import AuthenticationError, CLIError
+
+
+class TestErrors:
+    """Tests for custom error classes."""
+
+    def test_cli_error(self) -> None:
+        """Test CLIError exception."""
+        error = CLIError("Test error")
+        assert str(error) == "Test error"
+
+    def test_authentication_error(self) -> None:
+        """Test AuthenticationError exception."""
+        error = AuthenticationError("Auth failed")
+        assert str(error) == "Auth failed"
+        assert isinstance(error, CLIError)