feat: Refactor NLP modelers to use Strategies architecture

src/CTModels.jl

@@ -28,15 +28,28 @@ using KernelAbstractions
 using NLPModels
 
 # Modules
-include("Options/Options.jl")
+include(joinpath(@__DIR__, "Options", "Options.jl"))
 using .Options
 
-include("Strategies/Strategies.jl")
+include(joinpath(@__DIR__, "Strategies", "Strategies.jl"))
 using .Strategies
 
-include("Orchestration/Orchestration.jl")
+include(joinpath(@__DIR__, "Orchestration", "Orchestration.jl"))
 using .Orchestration
 
+# Optimization module provides general optimization types (AbstractOptimizationProblem, builders)
+include(joinpath(@__DIR__, "Optimization", "Optimization.jl"))
+using .Optimization
+
+# Modelers module uses AbstractOptimizationProblem from Optimization (general)
+include(joinpath(@__DIR__, "Modelers", "Modelers.jl"))
+using .Modelers
+
+# DOCP module provides concrete DOCP types (DiscretizedOptimalControlProblem)
+# Loaded after Modelers since Modelers only need the general AbstractOptimizationProblem
+include(joinpath(@__DIR__, "DOCP", "DOCP.jl"))
+using .DOCP
+
 # ============================================================================ #
 # TYPES AND FOUNDATIONS
 # ============================================================================ #
@@ -45,7 +58,7 @@ using .Orchestration
 
 # 1. Type aliases (Dimension, ctNumber, Time, etc.) and export/import types
 #    These are the most basic types with no dependencies
-include("types/types.jl")
+include(joinpath(@__DIR__, "types", "types.jl"))
 
 # 2. OCP defaults (functions returning default values)
 #    Depends on: type aliases (uses Dimension, ctVector, etc.)
@@ -56,18 +69,18 @@ include(joinpath(@__DIR__, "ocp", "defaults.jl"))
 #    Must be loaded before OCP types because @ensure macro is used in OCP types
 include(joinpath(@__DIR__, "utils", "utils.jl"))
 
-# 4. OCP type definitions (components, model, solution)
+# 4. Initial guess types
+#    Depends on: type aliases
+include(joinpath(@__DIR__, "init", "types.jl"))
+
+# 5. OCP type definitions (components, model, solution)
 #    Depends on: type aliases, defaults, and utils (@ensure macro)
 include(joinpath(@__DIR__, "ocp", "types", "components.jl"))
 include(joinpath(@__DIR__, "ocp", "types", "model.jl"))
 include(joinpath(@__DIR__, "ocp", "types", "solution.jl"))
 
-# 5. NLP types (backends, builders, modelers)
-#    Depends on: OCP types (uses AbstractModel, AbstractSolution)
-include(joinpath(@__DIR__, "nlp", "types.jl"))
-
-# 6. Export/import functions (require OCP types)
-#    Depends on: OCP types (uses AbstractModel, AbstractSolution)
+# # 6. Export/import functions (require OCP types)
+# #    Depends on: OCP types (uses AbstractModel, AbstractSolution)
 include(joinpath(@__DIR__, "types", "export_import_functions.jl"))
 
 # ============================================================================ #
@@ -99,16 +112,8 @@ const AbstractOptimalControlSolution = CTModels.AbstractSolution
 #    Depends on: all OCP types
 include(joinpath(@__DIR__, "ocp", "ocp.jl"))
 
-# 7. NLP implementations (problem core, backends, discretization)
-#    Depends on: OCP and NLP types
-include(joinpath(@__DIR__, "nlp", "problem_core.jl"))
-include(joinpath(@__DIR__, "nlp", "nlp_backends.jl"))
-include(joinpath(@__DIR__, "nlp", "extract_solver_infos.jl"))
-include(joinpath(@__DIR__, "nlp", "discretized_ocp.jl"))
-include(joinpath(@__DIR__, "nlp", "model_api.jl"))
-# 8. Initialization (types and functions for initial guesses)
-#    Depends on: OCP types (uses AbstractModel, AbstractSolution)
-include(joinpath(@__DIR__, "init", "types.jl"))
+# 7. Initial guess implementations
+#    Depends on: OCP types (uses AbstractOptimalControlProblem)
 include(joinpath(@__DIR__, "init", "initial_guess.jl"))
 
 end

src/Modelers/Modelers.jl

@@ -0,0 +1,32 @@
+# Modelers Module
+# 
+# This module provides strategy-based modelers for converting discretized optimal 
+# control problems to NLP backend models using the new AbstractStrategy contract.
+#
+# Author: CTModels Development Team
+# Date: 2026-01-25
+
+module Modelers
+
+using CTBase: CTBase
+using DocStringExtensions
+using SolverCore
+using ADNLPModels
+using ExaModels
+using KernelAbstractions
+using ..CTModels.Options
+using ..CTModels.Strategies
+using ..CTModels.Optimization: AbstractOptimizationProblem,
+    get_adnlp_model_builder, get_exa_model_builder,
+    get_adnlp_solution_builder, get_exa_solution_builder
+
+# Include submodules
+include(joinpath(@__DIR__, "abstract_modeler.jl"))
+include(joinpath(@__DIR__, "adnlp_modeler.jl"))
+include(joinpath(@__DIR__, "exa_modeler.jl"))
+
+# Public API
+export AbstractOptimizationModeler
+export ADNLPModeler, ExaModeler
+
+end # module Modelers

src/Modelers/abstract_modeler.jl

@@ -0,0 +1,93 @@
+# Abstract Optimization Modeler
+#
+# Defines the AbstractOptimizationModeler strategy contract for all modeler strategies.
+# This extends the AbstractStrategy contract with modeler-specific interfaces.
+#
+# Author: CTModels Development Team
+# Date: 2026-01-25
+
+"""
+    AbstractOptimizationModeler
+
+Abstract base type for all modeler strategies.
+
+Modeler strategies are responsible for converting discretized optimal control
+problems (AbstractOptimizationProblem) into NLP backend models. They implement 
+the `AbstractStrategy` contract and provide modeler-specific interfaces for 
+model and solution building.
+
+# Implementation Requirements
+All concrete modeler strategies must:
+- Implement the `AbstractStrategy` contract (see Strategies module)
+- Provide callable interfaces for model building from AbstractOptimizationProblem
+- Provide callable interfaces for solution building
+- Define strategy metadata with option specifications
+
+# Example
+```julia
+struct MyModeler <: AbstractOptimizationModeler
+    options::Strategies.StrategyOptions
+end
+
+Strategies.id(::Type{<:MyModeler}) = :my_modeler
+
+function (modeler::MyModeler)(
+    prob::AbstractOptimizationProblem, 
+    initial_guess
+)
+    # Build NLP model from problem and initial guess
+    return nlp_model
+end
+```
+"""
+abstract type AbstractOptimizationModeler <: Strategies.AbstractStrategy end
+
+"""
+    (modeler::AbstractOptimizationModeler)(prob::AbstractOptimizationProblem, initial_guess)
+
+Build an NLP model from a discretized optimal control problem and initial guess.
+
+# Arguments
+- `modeler::AbstractOptimizationModeler`: The modeler strategy instance
+- `prob::AbstractOptimizationProblem`: The discretized optimal control problem
+- `initial_guess`: Initial guess for optimization variables
+
+# Returns
+- An NLP model compatible with the target backend (e.g., ADNLPModel, ExaModel)
+
+# Throws
+- `CTBase.NotImplemented`: If not implemented by concrete type
+"""
+function (modeler::AbstractOptimizationModeler)(
+    ::AbstractOptimizationProblem, 
+    initial_guess
+)
+    throw(CTBase.NotImplemented(
+        "Model building not implemented for $(typeof(modeler))"
+    ))
+end
+
+"""
+    (modeler::AbstractOptimizationModeler)(prob::AbstractOptimizationProblem, nlp_solution)
+
+Build a solution object from a discretized optimal control problem and NLP solution.
+
+# Arguments
+- `modeler::AbstractOptimizationModeler`: The modeler strategy instance
+- `prob::AbstractOptimizationProblem`: The discretized optimal control problem
+- `nlp_solution::SolverCore.AbstractExecutionStats`: Solution from NLP solver
+
+# Returns
+- A solution object appropriate for the problem type
+
+# Throws
+- `CTBase.NotImplemented`: If not implemented by concrete type
+"""
+function (modeler::AbstractOptimizationModeler)(
+    ::AbstractOptimizationProblem,
+    ::SolverCore.AbstractExecutionStats
+)
+    throw(CTBase.NotImplemented(
+        "Solution building not implemented for $(typeof(modeler))"
+    ))
+end

src/Modelers/adnlp_modeler.jl

@@ -0,0 +1,108 @@
+# ADNLP Modeler
+#
+# Implementation of ADNLPModeler using the AbstractStrategy contract.
+# This modeler converts discretized optimal control problems to ADNLPModels.
+#
+# Author: CTModels Development Team
+# Date: 2026-01-25
+
+# Default option values
+"""
+$(TYPEDSIGNATURES)
+
+Return the default value for the `show_time` option of [`ADNLPModeler`](@ref).
+
+Default is `false`.
+"""
+__adnlp_model_show_time() = false
+
+"""
+$(TYPEDSIGNATURES)
+
+Return the default automatic differentiation backend for [`ADNLPModeler`](@ref).
+
+Default is `:optimized`.
+"""
+__adnlp_model_backend() = :optimized
+
+"""
+    ADNLPModeler
+
+Modeler for building ADNLPModels from discretized optimal control problems.
+
+This modeler uses the ADNLPModels.jl package to create NLP models with
+automatic differentiation support. It provides configurable options for
+timing information and AD backend selection.
+
+# Options
+- `show_time::Bool`: Whether to show timing information (default: `false`)
+- `backend::Symbol`: AD backend to use (default: `:optimized`)
+
+# Example
+```julia
+modeler = ADNLPModeler(show_time=true, backend=:forwarddiff)
+nlp_model = modeler(problem, initial_guess)
+```
+"""
+struct ADNLPModeler <: AbstractOptimizationModeler
+    options::Strategies.StrategyOptions
+end
+
+# Strategy identification
+Strategies.id(::Type{<:ADNLPModeler}) = :adnlp
+
+# Strategy metadata with option definitions
+function Strategies.metadata(::Type{<:ADNLPModeler})
+    return Strategies.StrategyMetadata(
+        Strategies.OptionDefinition(;
+            name=:show_time,
+            type=Bool,
+            default=__adnlp_model_show_time(),
+            description="Whether to show timing information while building the ADNLP model"
+        ),
+        Strategies.OptionDefinition(;
+            name=:backend,
+            type=Symbol,
+            default=__adnlp_model_backend(),
+            description="Automatic differentiation backend used by ADNLPModels"
+        )
+    )
+end
+
+# Constructor with option validation
+function ADNLPModeler(; kwargs...)
+    opts = Strategies.build_strategy_options(
+        ADNLPModeler; kwargs...
+    )
+    return ADNLPModeler(opts)
+end
+
+# Access to strategy options
+Strategies.options(m::ADNLPModeler) = m.options
+
+# Model building interface
+function (modeler::ADNLPModeler)(
+    prob::AbstractOptimizationProblem,
+    initial_guess
+)::ADNLPModels.ADNLPModel
+    opts = Strategies.options(modeler)
+
+    # Get the appropriate builder for this problem type
+    builder = get_adnlp_model_builder(prob)
+
+    # Extract raw values from OptionValue wrappers and filter out nothing values
+    raw_opts = Options.extract_raw_options(opts.options)
+
+    # Build the ADNLP model passing all options generically
+    return builder(initial_guess; raw_opts...)
+end
+
+# Solution building interface
+function (modeler::ADNLPModeler)(
+    prob::AbstractOptimizationProblem,
+    nlp_solution::SolverCore.AbstractExecutionStats
+)
+    # Get the appropriate solution builder for this problem type
+    builder = get_adnlp_solution_builder(prob)
+    return builder(nlp_solution)
+end