Add describe function for strategy options and update documentation

- Add src/helpers/describe.jl with describe() function to inspect strategy options
- Update src/OptimalControl.jl to export describe function
- Update docs/src/manual-solve.md to use describe() for strategy option inspection
- Reorganize documentation structure for better clarity
- Update docs/src/assets/Manifest.toml for documentation build

Author: ocots

docs/src/assets/Manifest.toml

@@ -244,9 +244,9 @@ version = "0.8.9-beta"
 
 [[deps.CTSolvers]]
 deps = ["ADNLPModels", "CTBase", "CTModels", "CommonSolve", "DocStringExtensions", "ExaModels", "KernelAbstractions", "NLPModels", "SolverCore"]
-git-tree-sha1 = "914e4e30b6335ed64f9d51573a5914bda4dd9f3d"
+git-tree-sha1 = "a815a0e8128bd2d967a0200a08e31decf47fdc71"
 uuid = "d3e8d392-8e4b-4d9b-8e92-d7d4e3650ef6"
-version = "0.4.6"
+version = "0.4.7-beta"
 
     [deps.CTSolvers.extensions]
     CTSolversCUDA = "CUDA"
@@ -1750,9 +1750,9 @@ version = "1.22.0"
 
 [[deps.OrdinaryDiffEqCore]]
 deps = ["ADTypes", "Accessors", "Adapt", "ArrayInterface", "ConcreteStructs", "DataStructures", "DiffEqBase", "DocStringExtensions", "EnumX", "EnzymeCore", "FastBroadcast", "FastClosures", "FastPower", "FillArrays", "FunctionWrappersWrappers", "InteractiveUtils", "LinearAlgebra", "Logging", "MacroTools", "MuladdMacro", "Polyester", "PrecompileTools", "Preferences", "Random", "RecursiveArrayTools", "Reexport", "SciMLBase", "SciMLLogging", "SciMLOperators", "SciMLStructures", "Static", "StaticArrayInterface", "StaticArraysCore", "SymbolicIndexingInterface", "TruncatedStacktraces"]
-git-tree-sha1 = "fa1b29e844d9e118b1c8fbd778de6da0a1d25fa1"
+git-tree-sha1 = "d783e7f540774792c945019ab7774f41cdc6331f"
 uuid = "bbf590c4-e513-4bbe-9b18-05decba2e5d8"
-version = "3.18.0"
+version = "3.19.0"
 
     [deps.OrdinaryDiffEqCore.extensions]
     OrdinaryDiffEqCoreMooncakeExt = "Mooncake"

docs/src/manual-solve.md

@@ -54,6 +54,38 @@ This uses default strategies: collocation discretization, ADNLP modeler, and Ipo
     ERROR: ExtensionError. Please make: julia> using NLPModelsIpopt
     ```
 
+## Display
+
+Control the configuration display with the `display` option:
+
+```@example main
+# Suppress all output
+sol = solve(ocp; display=false)
+nothing # hide
+```
+
+## Initial guess
+
+Provide an initial guess using `initial_guess` (or the alias `init`):
+
+```@example main
+# Using the @init macro
+init = @init ocp begin
+    u = 0.5
+end
+
+sol = solve(ocp; initial_guess=init, grid_size=50, display=false)
+nothing # hide
+```
+
+```@example main
+# Or using the alias
+sol = solve(ocp; init=init, grid_size=50, display=false)
+nothing # hide
+```
+
+For more details on initial guess specification, see [Set an initial guess](@ref manual-initial-guess).
+
 ## Available methods
 
 OptimalControl.jl provides multiple solving strategies. To see all available combinations, call:
@@ -74,7 +106,7 @@ Each method is a **quadruplet** `(discretizer, modeler, solver, parameter)`:
 3. **Solver** — which NLP solver to use:
    - `:ipopt`: [Ipopt](https://coin-or.github.io/Ipopt/) interior point solver
    - `:madnlp`: [MadNLP](https://madnlp.github.io/MadNLP.jl/) pure-Julia solver (GPU-capable)
-   - `:madncl`: [MadNCL](https://madnlp.github.io/MadNLP.jl/) (GPU-capable)
+   - `:madncl`: [MadNCL](https://github.com/MadNLP/MadNCL.jl) (GPU-capable)
    - `:knitro`: [Knitro](https://www.artelys.com/solvers/knitro/) commercial solver (license required)
 
 4. **Parameter** — execution backend:
@@ -111,7 +143,7 @@ Or provide a **partial description**. Missing tokens are auto-completed using th
 
 ```@example main
 # Only specify the solver → defaults to :collocation, :adnlp, :cpu
-sol = solve(ocp, :madnlp)
+sol = solve(ocp, :madnlp; print_level=MadNLP.ERROR)
 nothing # hide
 ```
 
@@ -124,13 +156,13 @@ The completion algorithm searches `methods()` from top to bottom and selects the
 All of these are equivalent (they all complete to `:collocation, :adnlp, :ipopt, :cpu`):
 
 ```julia
-solve(ocp)                              # empty → use first method
-solve(ocp, :collocation)                # specify discretizer
-solve(ocp, :adnlp)                      # specify modeler
-solve(ocp, :ipopt)                      # specify solver
-solve(ocp, :cpu)                        # specify parameter
-solve(ocp, :collocation, :adnlp)        # specify discretizer + modeler
-solve(ocp, :collocation, :ipopt)        # specify discretizer + solver
+solve(ocp)                                      # empty → use first method
+solve(ocp, :collocation)                        # specify discretizer
+solve(ocp, :adnlp)                              # specify modeler
+solve(ocp, :ipopt)                              # specify solver
+solve(ocp, :cpu)                                # specify parameter
+solve(ocp, :collocation, :adnlp)                # specify discretizer + modeler
+solve(ocp, :collocation, :ipopt)                # specify discretizer + solver
 solve(ocp, :collocation, :adnlp, :ipopt, :cpu)  # complete description
 ```
 
@@ -140,9 +172,9 @@ You can pass options as keyword arguments. They are **automatically routed** to
 
 ```@example main
 sol = solve(ocp, :madnlp; 
-    grid_size=100,           # → discretizer (Collocation)
-    max_iter=500,            # → solver (MadNLP)
-    print_level=MadNLP.ERROR # → solver (MadNLP)
+    grid_size=100,              # → discretizer (Collocation)
+    max_iter=500,               # → solver (MadNLP)
+    print_level=MadNLP.ERROR    # → solver (MadNLP)
 )
 nothing # hide
 ```
@@ -167,82 +199,44 @@ Notice the `📦 Configuration` box showing:
 
 ## Strategy options
 
-Each strategy declares its available options. You can inspect them using `describe`:
+Each strategy declares its available options. You can inspect them using `describe`.
+
+### Discretizer options
 
 ```@example main
-using CTDirect, CTSolvers
-describe(Collocation)
+describe(:collocation)
 ```
 
+### Modeler options
+
 ```@example main
-describe(ADNLP)
+describe(:adnlp)
 ```
 
 ```@example main
-describe(Ipopt)
+describe(:exa)
 ```
 
-Common options include:
-
-**Discretizer (Collocation)**:
-
-- `grid_size` (default: `250`): number of time steps
-- `scheme` (default: `:midpoint`): discretization scheme (`:midpoint`, `:trapeze`, `:euler`, `:euler_implicit`, `:gauss_legendre_2`, `:gauss_legendre_3`)
-
-**Modeler (ADNLP)**:
-
-- `backend` (default: `:optimized`): AD backend (`:optimized`, `:manual`, `:default`)
-- `show_time` (default: `false`): display model building time
-
-**Solver (Ipopt)**:
-
-- `max_iter` (default: `3000`): maximum iterations
-- `tol` (default: `1e-8`): convergence tolerance
-- `print_level` (default: `5`): output verbosity (0-12)
-
-For complete option lists, see:
-
-- [Ipopt options](https://coin-or.github.io/Ipopt/OPTIONS.html)
-- [MadNLP options](https://madnlp.github.io/MadNLP.jl/stable/options/)
-
-!!! note "ExaModels syntax limitations"
-
-    When using `:exa` modeler (especially for [GPU solving](@ref manual-solve-gpu)):
-    - Dynamics must be declared coordinate-by-coordinate: `∂(q)(t) == v(t)` instead of `ẋ(t) == [v(t), u(t)]`
-    - Nonlinear constraints must be scalar expressions
-    - Only ExaModels-supported operations are allowed (see [ExaModels documentation](https://exanauts.github.io/ExaModels.jl/stable))
-
-## Initial guess
-
-Provide an initial guess using `initial_guess` (or the alias `init`):
+### Solver options
 
 ```@example main
-# Using the @init macro (recommended)
-init = @init begin
-    u = 0.5
-end
-
-sol = solve(ocp; initial_guess=init, grid_size=50, print_level=0)
-nothing # hide
+describe(:ipopt)
 ```
 
 ```@example main
-# Or using the alias
-sol = solve(ocp; init=init, grid_size=50, print_level=0)
-nothing # hide
+describe(:madnlp)
 ```
 
-For more details on initial guess specification, see [Set an initial guess](@ref manual-initial-guess).
-
-## Display control
+### Official documentation
 
-Control the configuration display with the `display` option:
+For complete option lists, see the official documentation:
 
-```@example main
-# Suppress all output
-sol = solve(ocp; display=false)
-nothing # hide
-```
+- **ADNLP**: [ADNLPModels documentation](https://jso.dev/ADNLPModels.jl/stable/)
+- **Exa**: [ExaModels documentation](https://exanauts.github.io/ExaModels.jl/stable/)
+- **Ipopt**: [Ipopt options](https://coin-or.github.io/Ipopt/OPTIONS.html)
+- **MadNLP**: [MadNLP options](https://madnlp.github.io/MadNLP.jl/stable/options/)
+- **MadNCL**: [MadNCL documentation](https://github.com/MadNLP/MadNCL.jl)
+- **Knitro**: [Knitro options](https://www.artelys.com/docs/knitro/3_referenceManual/userOptions.html)
 
 ## See also
 

src/OptimalControl.jl

@@ -75,6 +75,7 @@ include(joinpath(@__DIR__, "helpers", "kwarg_extraction.jl"))
 include(joinpath(@__DIR__, "helpers", "print.jl"))
 include(joinpath(@__DIR__, "helpers", "methods.jl"))
 include(joinpath(@__DIR__, "helpers", "registry.jl"))
+include(joinpath(@__DIR__, "helpers", "describe.jl"))
 include(joinpath(@__DIR__, "helpers", "component_checks.jl"))
 include(joinpath(@__DIR__, "helpers", "strategy_builders.jl"))
 include(joinpath(@__DIR__, "helpers", "component_completion.jl"))

src/helpers/describe.jl

@@ -0,0 +1,38 @@
+"""
+$(TYPEDSIGNATURES)
+
+Display detailed information about a strategy identified by its symbol.
+
+This is a convenience wrapper around `CTSolvers.describe` that uses OptimalControl's
+strategy registry. It shows the strategy's available options, their types, defaults,
+and descriptions.
+
+# Arguments
+- `strategy_id::Symbol`: Strategy identifier (e.g., `:collocation`, `:adnlp`, `:ipopt`, `:madnlp`)
+
+# Returns
+- Nothing (prints to stdout)
+
+# Example
+```julia-repl
+julia> using OptimalControl
+
+julia> describe(:collocation)
+```
+
+# Notes
+- For the complete list of options for each strategy, refer to:
+  - **Collocation**: [CTDirect documentation](https://control-toolbox.org/CTDirect.jl/stable/)
+  - **ADNLP**: [CTSolvers documentation](https://control-toolbox.org/CTSolvers.jl/stable/)
+  - **Exa**: [ExaModels documentation](https://exanauts.github.io/ExaModels.jl/stable/)
+  - **Ipopt**: [Ipopt options](https://coin-or.github.io/Ipopt/OPTIONS.html)
+  - **MadNLP**: [MadNLP options](https://madnlp.github.io/MadNLP.jl/stable/options/)
+  - **MadNCL**: [MadNCL documentation](https://github.com/MadNLP/MadNCL.jl)
+  - **Knitro**: [Knitro options](https://www.artelys.com/docs/knitro/3_referenceManual/userOptions.html)
+
+See also: [`methods`](@ref), [`get_strategy_registry`](@ref), [`solve`](@ref)
+"""
+function CTSolvers.describe(strategy_id::Symbol)
+    registry = get_strategy_registry()
+    CTSolvers.describe(strategy_id, registry)
+end