Primeros pasos con Lino

Lino es una herramienta de línea de comandos para crear, evolucionar y estandarizar aplicaciones .NET profesionales con una arquitectura bien definida. Automatiza tareas repetitivas de scaffolding, pero su propósito va más allá de generar archivos: Lino guía al desarrollador por una estructura técnica consistente, con separación de responsabilidades, capas explícitas, modelado de dominio, casos de uso, APIs, integraciones, eventos, persistencia, aplicaciones web y recursos transversales. El objetivo es acelerar el inicio y la evolución de sistemas reales sin renunciar a calidad, trazabilidad y claridad arquitectónica.

Prerrequisitos

Antes de instalar Lino, verifique que su entorno esté debidamente preparado:

✅ .NET 10.0 SDK o superior instalado. Descargar .NET
✅ CLI de .NET disponible en el terminal. Verifique con: dotnet --version
✅ Git instalado para control de versiones. Descargar Git
✅ Entity Framework Core CLI instalada para soporte de migrations: dotnet tool install --global dotnet-ef
✅ Entorno de contenedores compatible con OCI, como Docker Desktop o Podman.

Compatibilidad de plataforma

Lino es multiplataforma y puede utilizarse en los principales sistemas operativos:

✅ Windows
✅ macOS
✅ Linux

Instalación

Lino se distribuye como una herramienta global de .NET. Antes de continuar, asegúrese de tener instalado el SDK de .NET 10 o superior.

Para instalar la versión más reciente, ejecute:

dotnet tool install --global Tolitech.Lino

Después de la instalación, valide el funcionamiento de Lino ejecutando:

lino --version

Si la instalación se realiza correctamente, la versión instalada se mostrará en el terminal.

Autenticación

Después de instalar Lino, es necesario autenticarse para acceder a todas las funcionalidades.

Si ya tiene una cuenta, inicie sesión con el comando:

lino auth login

Se le solicitará informar:

Usuario: Dirección de correo electrónico previamente registrada.
Contraseña: Contraseña asociada a la cuenta.

Si todavía no tiene una cuenta, regístrese directamente por la CLI utilizando:

lino user register

Durante el registro, informe:

Nombre: Primer nombre del usuario.
Apellido: Apellido del usuario.
Correo electrónico: Dirección de correo electrónico que también servirá como inicio de sesión.
Contraseña: Contraseña segura con al menos 6 caracteres.
Confirmación de contraseña: Escriba nuevamente la contraseña para validación.

Al concluir el registro, el usuario será autenticado automáticamente.

Preferencias de idioma

De forma predeterminada, la CLI de Lino se muestra en inglés en, pero puede cambiar el idioma según su preferencia entre las opciones disponibles:

en | pt | es | de | fr | it | ja | ko | ru | zh

Para definir un nuevo idioma, ejecute el siguiente comando:

lino preferences culture set --name <culture>

Sustituya <culture> por una de las culturas admitidas. Por ejemplo, use pt para portugués, en para inglés o es para español.

Como alternativa, puede seleccionar el idioma mediante una lista interactiva con:

lino preferences culture set

Ajuste de codificación UTF-8 (opcional)

Para una visualización correcta de idiomas con caracteres especiales (como japonés, coreano, ruso o chino), asegúrese de que su terminal esté configurado para usar la codificación UTF-8.

En Windows PowerShell, ajuste la codificación ejecutando los siguientes comandos:

[console]::InputEncoding = [System.Text.Encoding]::UTF8

[console]::OutputEncoding = [System.Text.Encoding]::UTF8

Nota: En Linux, macOS y Windows Terminal, el soporte de UTF-8 suele ser nativo. Aun así, se recomienda validar la configuración si ocurre algún problema al mostrar caracteres.

Comandos disponibles

Lino organiza su automatización en grupos de comandos. Cada grupo representa una intención arquitectónica: crear la solución, agregar servicios, modelar el dominio, exponer APIs, generar páginas, configurar integraciones, controlar migrations, versionar artefactos y preparar builds.

La referencia más confiable para su máquina es la ayuda de la propia CLI instalada. Use lino --help para ver el árbol completo de comandos y use --help en cualquier grupo para consultar opciones, aliases, parámetros obligatorios y ejemplos.

Como Lino evoluciona continuamente, pueden aparecer nuevos comandos y opciones entre versiones. Trate esta documentación como una orientación de uso y confirme la sintaxis exacta en el terminal siempre que automatice un flujo o capacite a alguien del equipo.

Para mostrar la lista de comandos disponibles, puede ejecutar el comando raíz o solicitar ayuda explícitamente:

lino
lino --help

lino --help
lino project --help
lino database migrations --help
lino integration operation --help

Para ver subcomandos y opciones de cualquier grupo, use el nombre del comando solo o combínelo con --help:

lino <command>
lino <command> --help

Por ejemplo, al consultar el grupo project, la CLI muestra la descripción del grupo, ejemplos comunes y los subcomandos disponibles:

lino project --help

DESCRIPCIÓN:
    Administra proyectos Lino.

EJEMPLOS:
    lino project new --name MyProject
    lino project list

COMANDOS:
    new     Crea un nuevo proyecto.
    list    Lista los proyectos creados.
    delete  Elimina un proyecto existente.

Al leer ejemplos, los valores entre <...> indican argumentos que deben sustituirse por el valor real de su proyecto. Por ejemplo, <ProjectName> debe cambiarse por el nombre de la solución, <ServiceName> por el nombre del servicio y <culture> por una cultura admitida, como pt o en.

Principales grupos de comandos:

Grupo	Comandos principales	Uso
`project`	`new`, `list`, `delete`	Crea, lista y elimina proyectos Lino.
`service`	`new`, `list`, `delete`	Agrega, lista y elimina servicios backend.
`module`	`new`, `list`, `delete`	Agrega, lista y elimina módulos dentro de servicios modulares.
`entity`	`new`, `edit`, `list`, `delete`	Crea, edita, lista y elimina entidades de dominio.
`shadow-entity` (`shadow`)	`new`	Crea copias locales controladas de datos de otro módulo o servicio.
`enumeration` (`enum`)	`new`, `edit`, `list`, `delete`	Crea, edita, lista y elimina enumeraciones de dominio.
`value-object` (`vo`)	`new`, `edit`, `list`, `delete`	Crea, edita, lista y elimina Value Objects.
`property` (`prop`)	`delete`	Elimina propiedades de entidades de dominio.
`command`	`new`, `list`	Genera casos de uso de escritura, normalmente vinculados a cambios de estado, reglas transaccionales y validaciones de intención.
`query`	`new`, `list`	Genera casos de uso de lectura, normalmente enfocados en consulta, proyección y retorno de datos sin alterar estado.
`api`	`new`, `list`	Genera y lista endpoints de API para casos de uso.
`web-app` (`webapp`)	`new`	Agrega aplicaciones web.
`page`	`new`, `edit`, `list`	Genera, edita y lista páginas Blazor.
`event`	`new`, `edit`, `list`	Crea y mantiene eventos de dominio o integración.
`event-handler` (`handler`)	`new`, `list`	Crea y lista handlers de eventos.
`error-definition` (`error`)	`new`, `list`	Crea definiciones estandarizadas de error.
`integration`	`new`, `list`, `resource` (`new/list`), `operation` (`new/list`), `consume`	Modela integraciones, resources, operaciones y consumidores.
`feature`	`background-job add`, `auth add`, `tenant add`	Agrega recursos transversales, incluidos background jobs, autenticación y tenancy.
`database migrations`	`add`, `remove`, `list`, `apply`, `revert`	Administra migrations de Entity Framework Core.
`secret`	`list`, `set`, `remove`, `clear`	Administra secrets locales del proyecto.
`plan`	`add`	Registra un plan de ejecución asistido por IA.
`version`	`show`, `list`, `bump`	Consulta e incrementa versiones de servicios y web apps.
`build`	-	Genera artefactos e imágenes de contenedor.
`user`	`register`	Registra un usuario para acceder a las funcionalidades autenticadas de Lino.
`auth`	`login`, `logout`	Administra la sesión local de la CLI, incluida la autenticación y el cierre de sesión.
`preferences`	`culture set`	Configura preferencias locales de la CLI, como el idioma mostrado en los comandos interactivos.

Algunos comandos muestran un alias corto entre paréntesis por conveniencia. Los nombres originales siguen siendo la referencia principal para lectura, documentación, capacitación, automatizaciones y soporte.

Inicio rápido

Cree rápidamente una aplicación .NET moderna, escalable y preparada para evolución continua con el siguiente comando:

lino project new --name <ProjectName>

Sustituya <ProjectName> por el nombre real de su solución. Por ejemplo, para crear un proyecto llamado MyApp, ejecute lino project new --name MyApp.

Este comando genera una solution .NET estructurada con separación clara entre dominio, aplicación, infraestructura, persistencia, API, orquestación y pruebas. La estructura inicial ayuda a mantener visibles las decisiones arquitectónicas desde el primer commit, evitando que reglas de negocio, acceso a datos, endpoints y detalles operativos queden mezclados en el mismo lugar.

Visualmente, una solución inicial llamada MyApp puede entenderse así:

MyApp/
├── MyApp.slnx
├── src/
│   ├── Aspire/
│   │   ├── AppHost/
│   │   │   └── MyApp.AppHost.csproj
│   │   └── ServiceDefaults/
│   │       └── MyApp.ServiceDefaults.csproj
│   └── Services/
│       └── Shared/
│           ├── Api/
│           │   └── MyApp.Shared.Api.csproj
│           ├── Application/
│           │   └── MyApp.Shared.Application.csproj
│           ├── Domain/
│           │   └── MyApp.Shared.Domain.csproj
│           ├── Infrastructure/
│           │   └── MyApp.Shared.Infrastructure.csproj
│           └── Infrastructure.Persistence/
│               └── MyApp.Shared.Infrastructure.Persistence.csproj
└── tests/

Este árbol es un ejemplo didáctico de la estructura generada para el proyecto del usuario. Muestra cómo la solución separa ejecución local, servicios, capas técnicas y pruebas desde el inicio.

Qué entrega el proyecto inicial

La solución inicial creada por Lino ya nace organizada por responsabilidades técnicas. En lugar de entregar solo un proyecto vacío, la CLI prepara una base con capas y componentes adecuados para aplicaciones empresariales.

Área	Responsabilidad
Domain	Concentra entidades, Value Objects, enumerations, eventos de dominio, contratos de repositorio y reglas que pertenecen al negocio.
Application	Orquesta casos de uso, comandos, queries, validaciones, handlers y contratos de entrada y salida de la aplicación.
Infrastructure	Aísla detalles externos, como servicios auxiliares, integraciones, proveedores, autenticación, mensajería y recursos transversales.
Persistence	Centraliza mapeos, contexto de base de datos, migrations, repositorios concretos y unidad de trabajo.
Api	Expone endpoints, contratos HTTP, filtros, autenticación, autorización y documentación de entrada para consumidores externos.
Orquestación	Prepara la ejecución local de los componentes, observabilidad básica e integración entre servicios durante el desarrollo.
Tests	Organiza pruebas por responsabilidad, permitiendo validar dominio, aplicación, APIs e integraciones de forma progresiva.

El nombre informado en <ProjectName> pasa a formar parte de la identidad técnica de la solución. Elija un nombre corto, estable y representativo, porque se usará en namespaces, assemblies, artefactos, configuraciones y referencias entre componentes.

Principales beneficios:

Arquitectura explícita: separación entre reglas de negocio, casos de uso, infraestructura, persistencia y contratos de entrada.
Evolución modular: base preparada para servicios tradicionales, monolitos modulares, microservicios y aplicaciones SaaS cuando el contexto lo exija.
Patrones técnicos consistentes: soporte para DDD, Clean Architecture, CQRS, eventos, integraciones, migrations, pruebas y observabilidad.
Menos trabajo mecánico: generación de estructuras repetitivas para que el desarrollador concentre energía en dominio, reglas, contratos y decisiones de producto.
Código más previsible: convenciones de nomenclatura, organización de carpetas y responsabilidades reducen la ambigüedad entre miembros del equipo.

Con Lino, el desarrollador no comienza desde una carpeta vacía ni desde un template genérico. Comienza desde una base opinada, pensada para sistemas empresariales, donde cada artefacto generado tiene una función técnica clara y puede evolucionar de forma incremental.

Nota de revisión: después de cada comando de generación, ejecute dotnet build y revise el diff. Lino acelera el trabajo repetitivo, pero las decisiones de dominio, seguridad y límites siguen siendo responsabilidad del desarrollador.