ostruct-cli 0.6.1__py3-none-any.whl → 0.6.2__py3-none-any.whl

ostruct/cli/cli.py

@@ -78,7 +78,11 @@ from .path_utils import validate_path_mapping
 from .security import SecurityManager
 from .serialization import LogSerializer
 from .template_env import create_jinja_env
-from .template_utils import SystemPromptError, render_template
+from .template_utils import (
+    SystemPromptError,
+    render_template,
+    validate_json_schema,
+)
 from .token_utils import estimate_tokens_with_encoding
 
 # Constants
@@ -831,7 +835,7 @@ def validate_schema_file(
         logger.error(msg)
         raise SchemaFileError(msg, schema_path=path)
     except Exception as e:
-        if isinstance(e, InvalidJSONError):
+        if isinstance(e, (InvalidJSONError, SchemaValidationError)):
             raise
         msg = f"Failed to read schema file {path}: {e}"
         logger.error(msg)
@@ -846,7 +850,13 @@ def validate_schema_file(
     if not isinstance(schema, dict):
         msg = f"Schema in {path} must be a JSON object"
         logger.error(msg)
-        raise SchemaValidationError(msg, context={"path": path})
+        raise SchemaValidationError(
+            msg,
+            context={
+                "validation_type": "schema",
+                "schema_path": path,
+            },
+        )
 
     # Validate schema structure
     if "schema" in schema:
@@ -856,7 +866,13 @@ def validate_schema_file(
         if not isinstance(inner_schema, dict):
             msg = f"Inner schema in {path} must be a JSON object"
             logger.error(msg)
-            raise SchemaValidationError(msg, context={"path": path})
+            raise SchemaValidationError(
+                msg,
+                context={
+                    "validation_type": "schema",
+                    "schema_path": path,
+                },
+            )
         if verbose:
             logger.debug("Inner schema validated successfully")
             logger.debug(
@@ -871,7 +887,20 @@ def validate_schema_file(
     if "type" not in schema.get("schema", schema):
         msg = f"Schema in {path} must specify a type"
         logger.error(msg)
-        raise SchemaValidationError(msg, context={"path": path})
+        raise SchemaValidationError(
+            msg,
+            context={
+                "validation_type": "schema",
+                "schema_path": path,
+            },
+        )
+
+    # Validate schema against JSON Schema spec
+    try:
+        validate_json_schema(schema)
+    except SchemaValidationError as e:
+        logger.error("Schema validation error: %s", str(e))
+        raise  # Re-raise to preserve error chain
 
     # Return the full schema including wrapper
     return schema
@@ -1225,19 +1254,24 @@ def handle_error(e: Exception) -> None:
     Provides enhanced debug logging for CLI errors.
     """
     # 1. Determine error type and message
-    if isinstance(e, click.UsageError):
+    if isinstance(e, SchemaValidationError):
+        msg = str(e)  # Already formatted in SchemaValidationError
+        exit_code = e.exit_code
+    elif isinstance(e, ModelCreationError):
+        # Unwrap ModelCreationError that might wrap SchemaValidationError
+        if isinstance(e.__cause__, SchemaValidationError):
+            return handle_error(e.__cause__)
+        msg = f"Model creation error: {str(e)}"
+        exit_code = ExitCode.SCHEMA_ERROR
+    elif isinstance(e, click.UsageError):
         msg = f"Usage error: {str(e)}"
         exit_code = ExitCode.USAGE_ERROR
     elif isinstance(e, SchemaFileError):
-        # Preserve specific schema error handling
         msg = str(e)  # Use existing __str__ formatting
         exit_code = ExitCode.SCHEMA_ERROR
     elif isinstance(e, (InvalidJSONError, json.JSONDecodeError)):
         msg = f"Invalid JSON error: {str(e)}"
         exit_code = ExitCode.DATA_ERROR
-    elif isinstance(e, SchemaValidationError):
-        msg = f"Schema validation error: {str(e)}"
-        exit_code = ExitCode.VALIDATION_ERROR
     elif isinstance(e, CLIError):
         msg = str(e)  # Use existing __str__ formatting
         exit_code = ExitCode(e.exit_code)  # Convert int to ExitCode
@@ -1249,7 +1283,7 @@ def handle_error(e: Exception) -> None:
     if isinstance(e, CLIError) and logger.isEnabledFor(logging.DEBUG):
         # Format context fields with lowercase keys and simple values
         context_str = ""
-        if hasattr(e, "context"):
+        if hasattr(e, "context") and e.context:
             for key, value in sorted(e.context.items()):
                 if key not in {
                     "timestamp",
@@ -1257,13 +1291,18 @@ def handle_error(e: Exception) -> None:
                     "version",
                     "python_version",
                 }:
-                    context_str += f"{key.lower()}: {value}\n"
+                    if isinstance(value, dict):
+                        context_str += (
+                            f"{key.lower()}:\n{json.dumps(value, indent=2)}\n"
+                        )
+                    else:
+                        context_str += f"{key.lower()}: {value}\n"
 
-        logger.debug(
-            "Error details:\n"
-            f"Type: {type(e).__name__}\n"
-            f"{context_str.rstrip()}"
-        )
+            logger.debug(
+                "Error details:\n"
+                f"Type: {type(e).__name__}\n"
+                f"{context_str.rstrip()}"
+            )
     elif not isinstance(e, click.UsageError):
         logger.error(msg, exc_info=True)
     else:
@@ -1467,30 +1506,11 @@ def run(
 ) -> None:
     """Run a structured task with template and schema.
 
-    TASK_TEMPLATE is the path to your Jinja2 template file that defines the task.
-    SCHEMA_FILE is the path to your JSON schema file that defines the expected output structure.
-
-    The command supports various options for file handling, variable definition,
-    model configuration, and output control. Use --help to see all available options.
-
-    Examples:
-        # Basic usage
-        ostruct run task.j2 schema.json
-
-        # Process multiple files
-        ostruct run task.j2 schema.json -f code main.py -f test tests/test_main.py
-
-        # Scan directories recursively
-        ostruct run task.j2 schema.json -d src ./src -R
-
-        # Define variables
-        ostruct run task.j2 schema.json -V debug=true -J config='{"env":"prod"}'
-
-        # Configure model
-        ostruct run task.j2 schema.json -m gpt-4 --temperature 0.7 --max-output-tokens 1000
-
-        # Control output
-        ostruct run task.j2 schema.json --output-file result.json --verbose
+    Args:
+        ctx: Click context
+        task_template: Path to task template file
+        schema_file: Path to schema file
+        **kwargs: Additional CLI options
     """
     try:
         # Convert Click parameters to typed dict
@@ -1511,25 +1531,33 @@ def run(
         try:
             exit_code = loop.run_until_complete(run_cli_async(params))
             sys.exit(int(exit_code))
+        except SchemaValidationError as e:
+            # Log the error with full context
+            logger.error("Schema validation error: %s", str(e))
+            if e.context:
+                logger.debug(
+                    "Error context: %s", json.dumps(e.context, indent=2)
+                )
+            # Re-raise to preserve error chain and exit code
+            raise
+        except (CLIError, InvalidJSONError, SchemaFileError) as e:
+            handle_error(e)
+            sys.exit(
+                e.exit_code
+                if hasattr(e, "exit_code")
+                else ExitCode.INTERNAL_ERROR
+            )
+        except click.UsageError as e:
+            handle_error(e)
+            sys.exit(ExitCode.USAGE_ERROR)
+        except Exception as e:
+            handle_error(e)
+            sys.exit(ExitCode.INTERNAL_ERROR)
         finally:
             loop.close()
-
-    except (
-        CLIError,
-        InvalidJSONError,
-        SchemaFileError,
-        SchemaValidationError,
-    ) as e:
-        handle_error(e)
-        sys.exit(
-            e.exit_code if hasattr(e, "exit_code") else ExitCode.INTERNAL_ERROR
-        )
-    except click.UsageError as e:
-        handle_error(e)
-        sys.exit(ExitCode.USAGE_ERROR)
-    except Exception as e:
-        handle_error(e)
-        sys.exit(ExitCode.INTERNAL_ERROR)
+    except KeyboardInterrupt:
+        logger.info("Operation cancelled by user")
+        raise
 
 
 # Remove the old @create_click_command() decorator and cli function definition
@@ -1582,6 +1610,7 @@ async def validate_inputs(
 
     Raises:
         CLIError: For various validation errors
+        SchemaValidationError: When schema is invalid
     """
     logger.debug("=== Input Validation Phase ===")
     security_manager = validate_security_manager(
@@ -1593,10 +1622,22 @@ async def validate_inputs(
     task_template = validate_task_template(
         args.get("task"), args.get("task_file")
     )
+
+    # Load and validate schema
     logger.debug("Validating schema from %s", args["schema_file"])
-    schema = validate_schema_file(
-        args["schema_file"], args.get("verbose", False)
-    )
+    try:
+        schema = validate_schema_file(
+            args["schema_file"], args.get("verbose", False)
+        )
+
+        # Validate schema structure before any model creation
+        validate_json_schema(
+            schema
+        )  # This will raise SchemaValidationError if invalid
+    except SchemaValidationError as e:
+        logger.error("Schema validation error: %s", str(e))
+        raise  # Re-raise the SchemaValidationError to preserve the error chain
+
     template_context = await create_template_context_from_args(
         args, security_manager
     )
@@ -1675,6 +1716,7 @@ async def validate_model_and_schema(
         ModelCreationError,
     ) as e:
         logger.error("Schema error: %s", str(e))
+        # Pass through the error without additional wrapping
         raise
 
     if not supports_structured_output(args["model"]):
@@ -1820,19 +1862,21 @@ async def execute_model(
 async def run_cli_async(args: CLIParams) -> ExitCode:
     """Async wrapper for CLI operations.
 
+    Args:
+        args: CLI parameters.
+
     Returns:
-        Exit code to return from the CLI
+        Exit code.
 
     Raises:
-        CLIError: For various error conditions
-        KeyboardInterrupt: When operation is cancelled by user
+        CLIError: For errors during CLI operations.
     """
     try:
         # 0. Model Parameter Validation
         logger.debug("=== Model Parameter Validation ===")
         params = await validate_model_params(args)
 
-        # 1. Input Validation Phase
+        # 1. Input Validation Phase (includes schema validation)
         security_manager, task_template, schema, template_context, env = (
             await validate_inputs(args)
         )
@@ -1849,15 +1893,12 @@ async def run_cli_async(args: CLIParams) -> ExitCode:
             )
         )
 
-        # 4. Dry Run Output Phase
+        # 4. Dry Run Output Phase - Moved after all validations
         if args.get("dry_run", False):
             logger.info("\n=== Dry Run Summary ===")
+            # Only log success if we got this far (no validation errors)
             logger.info("✓ Template rendered successfully")
             logger.info("✓ Schema validation passed")
-            logger.info("✓ Model compatibility validated")
-            logger.info(
-                f"✓ Token count: {total_tokens}/{registry.get_capabilities(args['model']).context_window}"
-            )
 
             if args.get("verbose", False):
                 logger.info("\nSystem Prompt:")
@@ -1867,6 +1908,7 @@ async def run_cli_async(args: CLIParams) -> ExitCode:
                 logger.info("-" * 40)
                 logger.info(user_prompt)
 
+            # Return success only if we got here (no validation errors)
             return ExitCode.SUCCESS
 
         # 5. Execution Phase
@@ -1877,6 +1919,10 @@ async def run_cli_async(args: CLIParams) -> ExitCode:
     except KeyboardInterrupt:
         logger.info("Operation cancelled by user")
         raise
+    except SchemaValidationError as e:
+        # Ensure schema validation errors are properly propagated with the correct exit code
+        logger.error("Schema validation error: %s", str(e))
+        raise  # Re-raise the SchemaValidationError to preserve the error chain
     except Exception as e:
         if isinstance(e, CLIError):
             raise  # Let our custom errors propagate

ostruct/cli/errors.py

@@ -323,60 +323,6 @@ class SchemaFileError(CLIError):
         return self.context.get("schema_path")
 
 
-class SchemaValidationError(CLIError):
-    """Error raised when a schema fails validation."""
-
-    def __init__(
-        self,
-        message: str,
-        context: Optional[Dict[str, Any]] = None,
-    ):
-        context = context or {}
-
-        # Format error message with tips
-        formatted_message = [message]
-
-        if "path" in context:
-            formatted_message.append(f"\nLocation: {context['path']}")
-
-        if "found" in context:
-            formatted_message.append(f"Found: {context['found']}")
-
-        if "count" in context:
-            formatted_message.append(f"Count: {context['count']}")
-
-        if "missing_required" in context:
-            formatted_message.append(
-                f"Missing required: {context['missing_required']}"
-            )
-
-        if "extra_required" in context:
-            formatted_message.append(
-                f"Extra required: {context['extra_required']}"
-            )
-
-        if "prohibited_used" in context:
-            formatted_message.append(
-                f"Prohibited keywords used: {context['prohibited_used']}"
-            )
-
-        if "tips" in context:
-            formatted_message.append("\nHow to fix:")
-            for tip in context["tips"]:
-                if isinstance(tip, dict):
-                    # Format JSON example
-                    formatted_message.append("Example schema:")
-                    formatted_message.append(json.dumps(tip, indent=2))
-                else:
-                    formatted_message.append(f"- {tip}")
-
-        super().__init__(
-            "\n".join(formatted_message),
-            context=context,
-            exit_code=ExitCode.SCHEMA_ERROR,
-        )
-
-
 class ModelCreationError(CLIError):
     """Base class for model creation errors."""
 
@@ -496,6 +442,67 @@ class OpenAIClientError(CLIError):
         super().__init__(message, exit_code=exit_code, context=context)
 
 
+class SchemaValidationError(ModelCreationError):
+    """Raised when schema validation fails."""
+
+    def __init__(
+        self,
+        message: str,
+        context: Optional[Dict[str, Any]] = None,
+        exit_code: ExitCode = ExitCode.SCHEMA_ERROR,
+    ):
+        context = context or {}
+        # Preserve validation type for error handling
+        context.setdefault("validation_type", "schema")
+
+        # Format error message with tips
+        formatted_message = []
+
+        if "path" in context:
+            formatted_message.append(f"\nLocation: {context['path']}")
+
+        if "found" in context:
+            formatted_message.append(f"Found: {context['found']}")
+
+        if "reference" in context:
+            formatted_message.append(f"Reference: {context['reference']}")
+
+        if "count" in context:
+            formatted_message.append(f"Count: {context['count']}")
+
+        if "missing_required" in context:
+            formatted_message.append(
+                f"Missing required: {context['missing_required']}"
+            )
+
+        if "extra_required" in context:
+            formatted_message.append(
+                f"Extra required: {context['extra_required']}"
+            )
+
+        if "prohibited_used" in context:
+            formatted_message.append(
+                f"Prohibited keywords used: {context['prohibited_used']}"
+            )
+
+        if "tips" in context:
+            formatted_message.append("\nHow to fix:")
+            for tip in context["tips"]:
+                if isinstance(tip, dict):
+                    # Format JSON example
+                    formatted_message.append("Example schema:")
+                    formatted_message.append(json.dumps(tip, indent=2))
+                else:
+                    formatted_message.append(f"- {tip}")
+
+        # Combine message with details
+        final_message = message
+        if formatted_message:
+            final_message += "\n" + "\n".join(formatted_message)
+
+        super().__init__(final_message, context=context, exit_code=exit_code)
+
+
 # Export public API
 __all__ = [
     "VariableError",

ostruct/cli/model_creation.py

@@ -40,6 +40,7 @@ from .errors import (
     NestedModelError,
     SchemaValidationError,
 )
+from .exit_codes import ExitCode
 
 logger = logging.getLogger(__name__)
 
@@ -297,90 +298,26 @@ def create_dynamic_model(
     show_schema: bool = False,
     debug_validation: bool = False,
 ) -> Type[BaseModel]:
-    """Create a Pydantic model from a JSON schema.
+    """Create a Pydantic model from a JSON Schema.
 
     Args:
-        schema: JSON schema to create model from
-        base_name: Name for the model class
-        show_schema: Whether to show the generated model schema
-        debug_validation: Whether to show detailed validation errors
+        schema: JSON Schema to create model from
+        base_name: Base name for the model class
+        show_schema: Whether to show the generated schema
+        debug_validation: Whether to show debug validation info
 
     Returns:
-        Type[BaseModel]: The generated Pydantic model class
+        Generated Pydantic model class
 
     Raises:
-        ModelValidationError: If the schema is invalid
-        SchemaValidationError: If the schema violates OpenAI requirements
+        SchemaValidationError: If schema validation fails
+        ModelCreationError: If model creation fails
     """
-    if debug_validation:
-        logger.info("Creating dynamic model from schema:")
-        logger.info(json.dumps(schema, indent=2))
-
     try:
-        # Handle our wrapper format if present
-        if "schema" in schema:
-            if debug_validation:
-                logger.info("Found schema wrapper, extracting inner schema")
-                logger.info(
-                    "Original schema: %s", json.dumps(schema, indent=2)
-                )
-            inner_schema = schema["schema"]
-            if not isinstance(inner_schema, dict):
-                if debug_validation:
-                    logger.info(
-                        "Inner schema must be a dictionary, got %s",
-                        type(inner_schema),
-                    )
-                raise SchemaValidationError(
-                    "Inner schema must be a dictionary"
-                )
-            if debug_validation:
-                logger.info("Using inner schema:")
-                logger.info(json.dumps(inner_schema, indent=2))
-            schema = inner_schema
-
-        # Validate against OpenAI requirements
-        from .schema_validation import validate_openai_schema
-
-        validate_openai_schema(schema)
-
-        # Create model configuration
-        config = ConfigDict(
-            title=schema.get("title", base_name),
-            extra="forbid",  # OpenAI requires additionalProperties: false
-            validate_default=True,
-            use_enum_values=True,
-            arbitrary_types_allowed=True,
-            json_schema_extra={
-                k: v
-                for k, v in schema.items()
-                if k
-                not in {
-                    "type",
-                    "properties",
-                    "required",
-                    "title",
-                    "description",
-                    "additionalProperties",
-                    "readOnly",
-                }
-            },
-        )
+        # Validate schema structure before model creation
+        from .template_utils import validate_json_schema
 
-        if debug_validation:
-            logger.info("Created model configuration:")
-            logger.info("  Title: %s", config.get("title"))
-            logger.info("  Extra: %s", config.get("extra"))
-            logger.info(
-                "  Validate Default: %s", config.get("validate_default")
-            )
-            logger.info("  Use Enum Values: %s", config.get("use_enum_values"))
-            logger.info(
-                "  Arbitrary Types: %s", config.get("arbitrary_types_allowed")
-            )
-            logger.info(
-                "  JSON Schema Extra: %s", config.get("json_schema_extra")
-            )
+        validate_json_schema(schema)
 
         # Process schema properties into fields
         properties = schema.get("properties", {})
@@ -438,23 +375,25 @@ def create_dynamic_model(
             )
             for name, (field_type, field) in field_definitions.items()
         }
-        model: Type[BaseModel] = create_model(
-            base_name, __config__=config, **field_defs
-        )
 
-        # Set the model config after creation
-        model.model_config = config
+        # Create model class
+        model = create_model(base_name, __base__=BaseModel, **field_defs)
 
-        if debug_validation:
-            logger.info("Successfully created model: %s", model.__name__)
-            logger.info("Model config: %s", dict(model.model_config))
+        # Set model config
+        model.model_config = ConfigDict(
+            title=schema.get("title", base_name),
+            extra="forbid",
+        )
+
+        if show_schema:
             logger.info(
-                "Model schema: %s",
+                "Generated schema for %s:\n%s",
+                base_name,
                 json.dumps(model.model_json_schema(), indent=2),
             )
 
-        # Validate the model's JSON schema
         try:
+            # Validate model schema
             model.model_json_schema()
         except ValidationError as e:
             validation_errors = (
@@ -467,18 +406,52 @@ def create_dynamic_model(
                 logger.error("  Error type: %s", type(e).__name__)
                 logger.error("  Error message: %s", str(e))
             raise ModelValidationError(base_name, validation_errors)
+        except KeyError as e:
+            # Handle Pydantic schema generation errors, particularly for recursive references
+            error_msg = str(e).strip(
+                "'\""
+            )  # Strip quotes from KeyError message
+            if error_msg.startswith("#/definitions/"):
+                context = {
+                    "schema_path": schema.get("$id", "unknown"),
+                    "reference": error_msg,
+                    "found": "circular reference or missing definition",
+                    "tips": [
+                        "Add explicit $ref definitions for recursive structures",
+                        "Use Pydantic's deferred annotations with typing.Self",
+                        "Limit recursion depth with max_depth validator",
+                        "Flatten nested structures using reference IDs",
+                    ],
+                }
 
-        return model
+                error_msg = (
+                    f"Invalid schema reference: {error_msg}\n"
+                    "Detected circular reference or missing definition.\n"
+                    "Solutions:\n"
+                    "1. Add missing $ref definitions to your schema\n"
+                    "2. Use explicit ID references instead of nested objects\n"
+                    "3. Implement depth limits for recursive structures"
+                )
 
-    except SchemaValidationError as e:
-        # Always log basic error info
-        logger.error("Schema validation error: %s", str(e))
+                if debug_validation:
+                    logger.error("Schema reference error:")
+                    logger.error("  Error type: %s", type(e).__name__)
+                    logger.error("  Error message: %s", error_msg)
 
-        # Log additional debug info if requested
-        if debug_validation:
-            logger.error("  Error type: %s", type(e).__name__)
-            logger.error("  Error details: %s", str(e))
-        # Always raise schema validation errors directly
+                raise SchemaValidationError(
+                    error_msg, context=context, exit_code=ExitCode.SCHEMA_ERROR
+                ) from e
+
+            # For other KeyErrors, preserve the original error
+            raise ModelCreationError(
+                f"Failed to create model {base_name}",
+                context={"error": str(e)},
+            ) from e
+
+        return model
+
+    except SchemaValidationError:
+        # Re-raise schema validation errors without wrapping
         raise
 
     except Exception as e:

ostruct/cli/security/errors.py

@@ -63,7 +63,7 @@ class PathSecurityError(SecurityErrorBase):
     @property
     def details(self) -> str:
         """Get the detailed explanation of the error."""
-        return self.details
+        return str(self.context.get("details", ""))
 
     @classmethod
     def from_expanded_paths(

ostruct/cli/security/normalization.py

@@ -61,7 +61,7 @@ from .errors import PathSecurityError, SecurityErrorReasons
 # Patterns for path normalization and validation
 _UNICODE_SAFETY_PATTERN = re.compile(
     r"[\u0000-\u001F\u007F-\u009F\u2028-\u2029\u0085]"  # Control chars and line separators
-    r"|\.{2,}"  # Directory traversal attempts
+    r"|(?:^|/)\.\.(?:/|$)"  # Directory traversal attempts (only ".." as a path component)
     r"|[\u2024\u2025\uFE52\u2024\u2025\u2026\uFE19\uFE30\uFE52\uFF0E\uFF61]"  # Alternative dots and separators
 )
 _BACKSLASH_PATTERN = re.compile(r"\\")