navori 0.2.16 → 0.2.18

package/dist/assets/core/core-assets/hooks/quality-gate-pre-commit.sh

@@ -24,22 +24,60 @@ extract_cmd() {
 }
 cmd=$(extract_cmd)
 
+# Detect the project's REAL package manager from lockfiles / package.json, so a
+# gate command hardcoded to one PM (e.g. `pnpm run ...`) can still run in a repo
+# that actually uses another (e.g. bun). Mirrors lib/detect.ts precedence:
+# `packageManager` field first, then pnpm/bun/yarn/npm lockfiles. Prints the PM
+# name (or nothing) on stdout. Git runs hooks from the repo root, so relative
+# paths resolve against the project root.
+detect_pm() {
+  if [ -f package.json ]; then
+    pm=$(sed -n 's/.*"packageManager"[[:space:]]*:[[:space:]]*"\([a-z]*\)@.*/\1/p' package.json | head -n1)
+    case "$pm" in pnpm|npm|yarn|bun) printf '%s' "$pm"; return 0 ;; esac
+  fi
+  if [ -f pnpm-lock.yaml ]; then printf 'pnpm'; return 0; fi
+  if [ -f bun.lockb ] || [ -f bun.lock ]; then printf 'bun'; return 0; fi
+  if [ -f yarn.lock ]; then printf 'yarn'; return 0; fi
+  if [ -f package-lock.json ]; then printf 'npm'; return 0; fi
+  return 0
+}
+
+# True when the argument is a JS package manager (so we only try to remap the
+# leading token of the gate command when it's actually a PM, not `make`/`ruff`).
+is_pm() {
+  case "$1" in pnpm|npm|yarn|bun) return 0 ;; *) return 1 ;; esac
+}
+
+run_gate() {
+  echo "[navori] running quality-gate fast: $1" >&2
+  eval "$1" || {
+    echo "[navori] quality-gate fast failed. Commit/push aborted." >&2
+    exit 2
+  }
+}
+
 case "$cmd" in
   'git commit'*|'git push'*)
     gate="{{qualityGate.fast}}"
-    # Defensive: skip cleanly (exit 0) when the gate's runtime isn't on PATH —
-    # e.g. a Nix/nvm shell that hasn't loaded the project env. Never block a
-    # commit just because the tool is missing from THIS shell.
     gate_bin="${gate%% *}"
-    if ! command -v "$gate_bin" >/dev/null 2>&1; then
-      echo "[navori] '$gate_bin' no está en PATH — skip quality-gate (¿shell sin el entorno del proyecto?)" >&2
-      exit 0
+    if command -v "$gate_bin" >/dev/null 2>&1; then
+      run_gate "$gate"
+    else
+      # The declared runner isn't on PATH. If it's a package manager, detect the
+      # repo's real one from lockfiles and retry through it (a `pnpm run x` gate
+      # still runs in a bun-only checkout). #88: NEVER skip the gate silently —
+      # when nothing can run it, BLOCK the commit loudly instead of the old
+      # `exit 0` that handed a contributor zero quality gate without a word.
+      detected_pm="$(detect_pm)"
+      if is_pm "$gate_bin" && [ -n "$detected_pm" ] && [ "$detected_pm" != "$gate_bin" ] && command -v "$detected_pm" >/dev/null 2>&1; then
+        echo "[navori] '$gate_bin' no está en PATH; uso el package manager detectado por lockfile: '$detected_pm'." >&2
+        run_gate "$detected_pm ${gate#* }"
+      else
+        echo "[navori] quality-gate NO ejecutado: '$gate_bin' no está en PATH y no hay un package manager alternativo detectado que pueda correrlo." >&2
+        echo "[navori] Commit/push BLOQUEADO para no saltarnos el gate en silencio. Instala '$gate_bin' o usa 'git commit --no-verify' si de verdad quieres saltártelo." >&2
+        exit 2
+      fi
     fi
-    echo "[navori] running quality-gate fast: $gate" >&2
-    eval "$gate" || {
-      echo "[navori] quality-gate fast failed. Commit/push aborted." >&2
-      exit 2
-    }
     ;;
 esac
 

package/dist/assets/core/core-assets/lib-skills/axios.md

@@ -0,0 +1,62 @@
+---
+name: axios
+description: Patrones de Axios en TS — instancia central, interceptores, tipado de respuestas, manejo de errores y cancelación. Aplica al tocar llamadas HTTP a APIs.
+type: reference
+---
+
+# Axios — convenciones
+
+## Cuándo usar este skill
+
+Al hacer una llamada HTTP a una API: crear un endpoint del cliente, agregar auth, mapear errores, o cancelar una request. Axios se cablea **una vez** en una instancia central con interceptores — los componentes/servicios importan esa instancia, no `axios` crudo con la URL a mano en cada llamada.
+
+## El patrón
+
+Una instancia por API (baseURL + interceptores), funciones tipadas encima; nunca `axios.get(fullUrl)` disperso:
+
+```ts
+export const api = axios.create({
+  baseURL: import.meta.env.VITE_APP_NEXUS_URL,
+  timeout: 15_000,
+});
+
+api.interceptors.request.use((config) => {
+  const token = getToken();
+  if (token) config.headers.Authorization = `Bearer ${token}`;
+  return config;
+});
+
+api.interceptors.response.use(
+  (res) => res,
+  (error) => Promise.reject(normalizeError(error)),  // un solo shape de error
+);
+
+// Servicio tipado: el genérico es el TIPO DE DATA, no el del envelope.
+export const getSession = (id: string) =>
+  api.get<Session>(`/sessions/${id}`).then((r) => r.data);
+```
+
+## Gotchas que muerden
+
+- **`api.get<T>()` tipa `response.data`, no la respuesta entera.** El `T` describe el `data`; Axios envuelve en `{ data, status, headers }`. Devuelve `r.data` desde el servicio para que el caller vea `Session`, no `AxiosResponse<Session>`.
+- **Una instancia con `baseURL`, no la URL completa por llamada.** Centraliza host/timeout/headers. Repetir `axios.get('https://…/sessions')` esparce la config y rompe al cambiar de entorno.
+- **Auth/refresh/logging en interceptores, no copiados en cada request.** El token va en un `request.use`; el 401→refresh y el mapeo de error van en `response.use`. Nada de `headers: { Authorization }` a mano en cada endpoint.
+- **`axios.isAxiosError(err)` antes de leer `err.response`.** En el `catch`, `err` es `unknown`. Sin el type guard, `err.response.data` explota en errores de red (donde `response` es `undefined` y solo hay `err.request`).
+- **Un error de red NO es un error HTTP.** Timeout/DNS/offline no traen `response`. Distingue `err.response` (el server respondió con 4xx/5xx) de `err.request` (nunca llegó) para dar el mensaje correcto.
+- **Cancela requests en vuelo con `AbortController`.** En efectos/búsqueda-as-you-type pasa `{ signal: controller.signal }` y aborta en el cleanup; sin esto, una respuesta vieja pisa a una nueva (race).
+- **4xx/5xx ya rechazan la promesa.** No revises `res.status` en el `.then`; el flujo de error vive en `catch`/el interceptor. Solo `validateStatus` cambia esa regla, y rara vez la necesitas.
+
+## Reglas duras
+
+1. Todo HTTP pasa por la instancia central con `baseURL` + interceptores; nada de `axios` crudo con URL completa suelta.
+2. Auth, refresh y normalización de error en interceptores, una sola vez.
+3. Servicios tipados con `api.get<Data>(...)` que devuelven `.data`; el genérico es la data, no el envelope.
+4. En `catch`, `axios.isAxiosError` antes de tocar `.response`; distingue error de red de error HTTP.
+5. Requests cancelables (`AbortController`) donde puede haber carreras.
+
+## Antes de declarar listo
+
+- La llamada usa la instancia central; sin URLs absolutas ni headers de auth repetidos.
+- Respuestas tipadas devolviendo `.data`; el error se maneja con `isAxiosError` y un shape único.
+- Requests que compiten se cancelan en el cleanup.
+- `{{qualityGate.fast}}` en verde.

package/dist/assets/core/core-assets/lib-skills/mantine-form.md

@@ -0,0 +1,58 @@
+---
+name: mantine-form
+description: Patrones de @mantine/form — useForm, getInputProps, validación con zodResolver, campos anidados y listas. Aplica al crear o tocar formularios con Mantine.
+type: reference
+---
+
+# Mantine Form — convenciones
+
+## Cuándo usar este skill
+
+Al crear o tocar un formulario con `@mantine/form`: cablear inputs de Mantine, validar, manejar submit, o campos anidados/listas. `useForm` es la fuente de verdad del form — no espejees sus valores en `useState`, y valida con un schema Zod (vía `mantine-form-zod-resolver`), no con funciones sueltas por campo.
+
+## El patrón
+
+`useForm` + `getInputProps` (esparce value/onChange/error de un jalón) + `zodResolver` para el schema:
+
+```tsx
+const schema = z.object({
+  email: z.string().email(),
+  role: z.enum(['coach', 'coachee']),
+});
+
+const form = useForm({
+  mode: 'uncontrolled',                 // menos re-renders; el default recomendado
+  initialValues: { email: '', role: 'coachee' },
+  validate: zodResolver(schema),        // desde 'mantine-form-zod-resolver'
+});
+
+<form onSubmit={form.onSubmit((values) => save(values))}>
+  <TextInput {...form.getInputProps('email')} />
+  <Select data={['coach', 'coachee']} {...form.getInputProps('role')} />
+  <Button type="submit">Guardar</Button>
+</form>
+```
+
+## Gotchas que muerden
+
+- **`getInputProps('campo')` cablea todo; no lo desarmes.** Ya trae `value`/`onChange`/`error`/`onBlur`. Pasar `value`/`onChange` a mano encima rompe el binding — deja que el spread mande.
+- **`mode: 'uncontrolled'` cambia cómo lees valores.** En uncontrolled, `form.values` no re-renderiza al teclear; para reflejar un campo en la UI usa `form.watch('campo')` o `form.getValues()`. En `controlled` sí re-renderiza cada tecla (más caro en forms grandes).
+- **Validación con `zodResolver`, no funciones por campo.** `validate: { email: (v) => … }` disemina reglas y tipos. Un schema Zod + `zodResolver` da una fuente única y el tipo por `z.infer`. Requiere el paquete `mantine-form-zod-resolver`.
+- **Campos anidados/listas con notación de path.** `getInputProps('address.city')`, y listas con `form.insertListItem('items', {...})` / `form.removeListItem('items', i)` + `getInputProps('items.0.name')`. No manejes el array en `useState` aparte.
+- **`initialValues` define el shape; llénalo completo.** Un campo ausente arranca `undefined` → warning uncontrolled→controlled. Para edición async usa `form.setValues(data)` / `form.initialize(data)` en un efecto, no valores a mano por render.
+- **Submit con `form.onSubmit(handler)`.** Corre la validación y solo llama tu handler si pasa; además expone el segundo callback `(errors) => …` para enfocar el primer inválido. No valides "a mano" antes de enviar.
+
+## Reglas duras
+
+1. `useForm` es la única fuente del estado del form; nada de `useState` espejo.
+2. Inputs cableados con `getInputProps`; no dupliques `value`/`onChange`.
+3. Validación con schema Zod vía `zodResolver`; tipo por `z.infer`, sin reglas por campo.
+4. `initialValues` completo; edición async con `setValues`/`initialize`.
+5. Submit vía `form.onSubmit`; listas/anidados con la API de path, no arrays sueltos.
+
+## Antes de declarar listo
+
+- Todos los inputs usan `getInputProps`; sin estado espejo ni handlers duplicados.
+- Validación centralizada en un schema Zod con `zodResolver`; tipos por `z.infer`.
+- `initialValues` seteado; sin warnings uncontrolled→controlled. Submit con `form.onSubmit`.
+- `{{qualityGate.fast}}` en verde.

package/dist/assets/core/core-assets/lib-skills/react-router.md

@@ -0,0 +1,61 @@
+---
+name: react-router
+description: Patrones de React Router (v6/v7) — rutas anidadas, loaders, navegación, params y guards. Aplica al crear rutas, leer params, redirigir o proteger vistas.
+type: reference
+---
+
+# React Router — convenciones
+
+## Cuándo usar este skill
+
+Al tocar navegación: declarar una ruta, leer un param, redirigir, proteger una vista por rol, o cablear links. React Router es la fuente de verdad de **en qué URL estás y a dónde vas** — no dupliques la ruta en estado propio ni parsees `window.location` a mano.
+
+## El patrón
+
+Rutas anidadas con layout compartido vía `<Outlet />`; navegación por hooks, no por mutar `window.location`:
+
+```tsx
+const router = createBrowserRouter([
+  {
+    path: '/',
+    element: <AppLayout />,           // renderiza <Outlet /> para los hijos
+    children: [
+      { index: true, element: <Home /> },
+      { path: 'sessions/:id', element: <SessionDetail /> },
+      { path: '*', element: <NotFound /> },
+    ],
+  },
+]);
+
+function SessionDetail() {
+  const { id } = useParams();                 // string | undefined, siempre
+  const navigate = useNavigate();
+  const [params, setParams] = useSearchParams();
+  // ...
+  navigate('/sessions', { replace: true });   // no <a href> manual
+}
+```
+
+## Gotchas que muerden
+
+- **`useParams()` siempre da `string | undefined`.** Nunca `number`. Convierte y valida (`Number(id)`, guard) antes de usarlo como id; una ruta mal tecleada no lanza, solo llega `undefined`.
+- **Navegar imperativo con `useNavigate`, no `window.location`.** `window.location.href = …` recarga toda la SPA y tira el estado. Para volver: `navigate(-1)`; para redirigir sin dejar historial: `{ replace: true }`.
+- **`<NavLink>` para tabs/menús, `<Link>` para el resto.** `NavLink` expone `isActive` en `className`/`style`/children; no reimplementes "está activo" comparando `pathname` a mano.
+- **Search params son la URL, no `useState`.** Filtros/paginación viven en `useSearchParams` para que la vista sea linkeable y sobreviva al refresh. `setParams` reemplaza TODO el query — clona lo actual si solo cambias una clave.
+- **Ruta protegida = un wrapper con `<Navigate>`, no un `if` suelto.** `if (!user) return <Navigate to="/login" replace />;` dentro de un guard/layout. Redirigir desde un `useEffect` parpadea la vista privada un frame.
+- **Rutas relativas anidan; un `/` inicial las hace absolutas.** Dentro de `sessions/:id`, `navigate('edit')` va a `sessions/:id/edit`; `navigate('/edit')` va a la raíz. Es el error #1 al mover un componente de nivel.
+
+## Reglas duras
+
+1. Navegación por `useNavigate`/`<Link>`/`<NavLink>`; nunca `window.location` ni `<a href>` interno.
+2. `useParams` se valida antes de usar (puede ser `undefined`); ids numéricos se convierten explícito.
+3. Estado de filtros/paginación en `useSearchParams`, no en `useState` espejo.
+4. Vistas protegidas por un guard con `<Navigate replace>`, no por `if` + efecto.
+5. Layouts compartidos con rutas anidadas + `<Outlet />`; nada de repetir el chrome por página.
+
+## Antes de declarar listo
+
+- Sin `window.location`/`<a href>` para navegación interna; links con `<Link>`/`<NavLink>`.
+- Params validados; el estado de la URL (filtros, tab) vive en search params.
+- Rutas protegidas redirigen con `<Navigate replace>`; sin parpadeo de la vista privada.
+- `{{qualityGate.fast}}` en verde.

package/dist/assets/core/core-assets/presets/monorepo-turbopnpm/managed/stack.md

@@ -0,0 +1,11 @@
+## Stack — Monorepo (Turborepo + pnpm)
+
+Este directorio es la **raíz de un monorepo**: orquesta, no aloja producto. El código real vive en los workspaces (`apps/*`, `packages/*`), y **cada workspace tiene su propio harness** (su `CLAUDE.md` + `.claude/`) con el preset de su stack. El mapa de workspaces vivos está en el bloque "## Monorepo — raíz".
+
+Regla de oro: **enruta el trabajo al workspace dueño**. Un cambio de producto se hace desde el `CLAUDE.md` de su app, no desde aquí. La raíz solo se toca para lo transversal: `turbo.json`, `pnpm-workspace.yaml`, tsconfig/eslint base, scripts de CI, deps compartidas.
+
+- **Tareas scopeadas, no globales.** Corre por workspace con el filtro de Turbo: `pnpm turbo run <task> --filter=<workspace>` (o `--filter=./apps/<x>`). Evita correr el pipeline entero cuando solo tocaste un app.
+- **No cruces imports entre workspaces por ruta relativa** (`../../otro-app`). Consume un hermano por su nombre de paquete con el protocolo `workspace:*`; si no es un paquete publicable, probablemente el código debería vivir en un `packages/*` compartido.
+- **La dep va en el `package.json` del workspace que la usa**, no en la raíz. Deps en la raíz son solo tooling del monorepo (turbo, changesets, linters compartidos).
+
+Antes de tocar `turbo.json`, `pnpm-workspace.yaml` o mover deps entre workspaces, aplica el skill `turbo-workspaces`.

package/dist/assets/core/core-assets/presets/monorepo-turbopnpm/skills/turbo-workspaces.md

@@ -0,0 +1,50 @@
+---
+name: turbo-workspaces
+description: Cómo navegar y operar un monorepo Turborepo + pnpm — correr tareas scopeadas, agregar deps al workspace correcto, compartir código sin acoplar. Aplica antes de tocar turbo.json, pnpm-workspace.yaml o mover deps.
+type: reference
+---
+
+# Turborepo + pnpm — operación del monorepo
+
+## Cuándo usar este skill
+
+Antes de: correr tareas de build/test/lint, agregar o mover una dependencia, crear un workspace nuevo, o editar `turbo.json` / `pnpm-workspace.yaml`. En un monorepo, "dónde" vive un cambio importa tanto como "qué" cambia.
+
+## Correr tareas (siempre scopeadas)
+
+```bash
+# Una tarea en UN workspace (por nombre de paquete o por ruta)
+pnpm turbo run build --filter=@scope/backend
+pnpm turbo run test --filter=./apps/storefront
+
+# Un workspace y todo lo que depende de él (aguas abajo)
+pnpm turbo run build --filter=@scope/backend...
+
+# Solo lo afectado por tu diff vs una base
+pnpm turbo run test --filter='...[origin/main]'
+```
+
+Regla: no corras el pipeline entero (`turbo run build`) si solo tocaste un app. Turbo cachea, pero el ruido de logs y el tiempo de arranque sí cuestan. Deja el run global para CI.
+
+## Agregar dependencias (al workspace correcto)
+
+```bash
+# Dep de un app concreto — NO en la raíz
+pnpm add zod --filter @scope/backend
+
+# Dep de tooling del monorepo (turbo, changesets, prettier) — esa sí va en la raíz
+pnpm add -Dw turbo
+```
+
+- Una lib de producto (`stripe`, `@tanstack/react-query`, …) va en el `package.json` del app que la importa. Si aparece en la raíz, el harness de ese app no la "ve" y su skill no se materializa donde corresponde.
+- Consumir un workspace hermano se declara explícito: `"@scope/ui": "workspace:*"` en el `package.json` del consumidor. Nunca por `import '../../ui/src/...'`.
+
+## Compartir código sin acoplar
+
+- Código usado por ≥2 apps → extráelo a un `packages/*` con su propio `package.json` y su preset (`navori scan` lo detecta como workspace nuevo).
+- Tipos/utilidades cross-app también van en un `packages/*`, no en `apps/*`. Un app nunca es dependencia de otro app.
+
+## turbo.json — lo esencial
+
+- Cada `task` declara sus `dependsOn` (`^build` = build de las deps primero) y sus `outputs` (para cachear). Un output mal declarado = cache que no invalida o que no cachea.
+- Antes de editar el pipeline, verifica el efecto con `pnpm turbo run <task> --dry-run` (lista qué correría y desde qué caché) antes de correrlo de verdad.

package/dist/assets/core/core-assets/presets/monorepo-turbopnpm.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://navori.dev/schema/navori.preset.v1.json",
+  "id": "monorepo-turbopnpm",
+  "displayName": "Monorepo (Turborepo + pnpm)",
+  "extends": "core",
+  "extras": {
+    "managed": [
+      {
+        "id": "stack-monorepo-turbopnpm",
+        "relPath": "presets/monorepo-turbopnpm/managed/stack.md"
+      }
+    ],
+    "agents": [],
+    "skills": [
+      {
+        "id": "turbo-workspaces",
+        "relPath": "presets/monorepo-turbopnpm/skills/turbo-workspaces.md",
+        "destRelPath": ".claude/skills/turbo-workspaces.md"
+      }
+    ],
+    "hooks": []
+  }
+}