navori 0.2.17 → 0.2.19

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/plugins/cognitive/plugin.json

@@ -2,7 +2,7 @@
   "id": "cognitive",
   "name": "Cognitive complexity guardrails",
   "description": "Detección de complejidad cognitiva alta via ESLint rule SonarJS",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "managed": [
     {
       "id": "cognitive-protocol",
@@ -34,12 +34,6 @@
       "command": "bash .claude/scripts/check-cognitive.sh",
       "timeout": 180,
       "statusMessage": "navori/cognitive: complexity scan"
-    },
-    {
-      "event": "Stop",
-      "command": "bash .claude/scripts/check-cognitive.sh",
-      "timeout": 180,
-      "statusMessage": "navori/cognitive: complexity scan (cierre de sesión)"
     }
   ]
 }

package/dist/assets/plugins/jscpd/plugin.json

@@ -2,7 +2,7 @@
   "id": "jscpd",
   "name": "jscpd (code duplication detector)",
   "description": "Detección de duplicación de código en el diff vs branch base",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "managed": [
     {
       "id": "jscpd-protocol",
@@ -33,12 +33,6 @@
       "command": "bash .claude/scripts/check-jscpd.sh",
       "timeout": 180,
       "statusMessage": "navori/jscpd: dup check"
-    },
-    {
-      "event": "Stop",
-      "command": "bash .claude/scripts/check-jscpd.sh",
-      "timeout": 180,
-      "statusMessage": "navori/jscpd: dup check (cierre de sesión)"
     }
   ]
 }

package/dist/assets/plugins/jscpd/scripts/check-jscpd.sh

@@ -3,16 +3,15 @@
 # `{{branchBase}}`. Skips silently if jscpd or git are absent — the tool is
 # optional, not a hard dependency of the project.
 #
-# Triggered as a PreToolUse(Bash) hook (gated to git commit/push) and as a
-# Stop hook (runs unconditionally at session close).
+# Triggered as a PreToolUse(Bash) hook, gated to git commit/push — so the
+# duplication check runs right before code lands, not on every turn.
 
 set -euo pipefail
 
-# PreToolUse(Bash) passes the command — gate to commit/push. The Stop hook
-# passes no command — run unconditionally at session close. Extract without
+# PreToolUse(Bash) passes the command — gate to commit/push. Extract without
 # hard-depending on jq (not preinstalled on macOS): try jq, then node (Claude
 # Code's own runtime), then a best-effort sed unwrap. No command extracted →
-# empty $cmd → runs unconditionally.
+# empty $cmd → runs unconditionally (defensive: never silently skip a commit).
 payload=$(cat)
 extract_cmd() {
   if command -v jq >/dev/null 2>&1; then
@@ -69,7 +68,7 @@ jscpd \
   --min-tokens 100 \
   --min-lines 10 \
   --mode strict \
-  --threshold 3 \
+  --threshold {{jscpdThreshold}} \
   --reporters console \
   --output "$tmpdir" \
   "${files[@]}"

package/dist/assets/plugins/semgrep/plugin.json

@@ -2,7 +2,7 @@
   "id": "semgrep",
   "name": "semgrep (security + pattern analysis)",
   "description": "Detección de vulnerabilidades y patrones inseguros local opt-in",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "managed": [
     {
       "id": "semgrep-protocol",
@@ -32,12 +32,6 @@
       "command": "bash .claude/scripts/check-semgrep.sh",
       "timeout": 180,
       "statusMessage": "navori/semgrep: security scan"
-    },
-    {
-      "event": "Stop",
-      "command": "bash .claude/scripts/check-semgrep.sh",
-      "timeout": 180,
-      "statusMessage": "navori/semgrep: security scan (cierre de sesión)"
     }
   ]
 }