In generale non c'e' niente di male nel fare tanti import, se stai usando
molti componenti.
Se vuoi raggruppare tutto, allora dovresti fare un *object* contenitore che
espone tutte le chiamate che desideri, delegandole ai singoli pezzetti.

Tipo,

  object globalDSL {

    import a0Dominio._
    import a0DSL._
    import a0DSL.ComponentDSL._
    import a0DSL.AddFunction._
    import a0DSL.GroupDSL._
    import.....

    def myFun1 = ...delega al componente
    def myFun2 = ...delega al componente
    ...
    val myVal1 = ...delega al componente
    ...
    type MyType1 = ... una classe che vuoi rendere visibile
    ...
  }

una volta che hai fatto questo nel client ti basta fare l'import di questo
oggetto per avere visibilita' su tutto quello che hai delegato all'interno,
con un semplice:

import globalDSL._

Vorrei farti presente che la scelta di come organizzare il codice in package
diversi, e di cosa importare, non e' un punto secondario.
La modularizzazione (ogni oggetto che ingloba funzioni, variabili, tipi e'
una specie di modulo del tuo programma) e' un argomento che va gestito con
attenzione e considerazione, per evitare che il tuo namespace finisca
presto affogato di nomi (di metodi, classi, variabili) che vanno in
conflitto e di cui non e' chiara la provenienza.
Per questo un import semplice e automatico come adesso ti tornerebbe comodo
non e' previsto di default, ma e' necessario specificare ogni volta cosa
deve essere visibile ad ogni parte del codice.
Anche per questo in scala e' permesso fare import in qualunque parte del
codice e non solo all'inizio del file.

Purtroppo non posso fare test ma la "delegazione" dovrebbe funzionare come
segue.

package a0DSL

object A0DSL {
import ComponentDSL._
import SAInterfaceDSL._

//dominio
implicit def nameToDescriptionComponent (nm: String) = new
DescriptionHelperComponent (nm)
implicit def componentToProperties(cm: Component) = new
PropertiesHelperComponent (cm)
 //dsl
implicit def sainterfaceToProperties(in: SAInterface) = new
PropertiesHelperSAInterface(in)
def sainterface(ds: String)  = SAInterfaceDSL.sainterface(ds)

A questo punto puoi rimuovere le tue conversioni implicite da *ComponentDSL
*e *SAInterfaceDSL** *ed avere tutto disponibile con un solo

import a0DSL.A0DSL._

In questo caso con un solo import avresti reso visibili solo ed
esclusivamente le operazioni di interesse per il codice client e non tutto
quello che c'e' all'interno della tua libreria.

Non so se il tutto funziona, purtroppo non ho il modello completo e non ho
tempo per riscrivere da zero un modello di test. Lascio a te la verifica e
le eventuali correzioni.