openprompt-lang 0.3.0

package/docs/referencia-metodologia/docs/PROMPTS/PLANTILLAS/06-servicio-supabase.md

@@ -0,0 +1,74 @@
+---
+title: Servicio CRUD con Supabase
+tags: [servicio, supabase, crud, api]
+usado_en: []
+fecha_creacion: 2026-05-13
+ultima_modificacion: 2026-05-13
+---
+
+## Cuándo usar
+
+Cuando necesites una capa de servicio para operaciones CRUD contra una tabla de Supabase. Separa la lógica de base de datos de los hooks/componentes.
+
+## Prompt
+
+```markdown
+## Contexto
+Stack: TypeScript + Supabase.
+Convenciones: servicios en src/services/supabase/, un archivo por tabla/entidad, máximo 150 líneas.
+Patrón: servicio con métodos estáticos nombrados como verbo + entidad (createUser, getProductById).
+Referencia: docs/Framework de Desarrollo Asistido por IA.md sección 2 (estructura services/).
+
+## Objetivo
+Crear el servicio `{Entity}Service` para operaciones CRUD contra la tabla `{table_name}` de Supabase.
+
+## Especificaciones técnicas
+- Archivo: `src/services/supabase/{entity}Service.ts`
+- Cliente Supabase importado desde `src/services/supabase/client.ts`
+- Métodos requeridos:
+  - `getAll(filters?)`: listar con filtros opcionales
+  - `getById(id: string)`: obtener por ID
+  - `create(data: CreateDTO)`: crear registro
+  - `update(id: string, data: UpdateDTO)`: actualizar
+  - `delete(id: string)`: eliminar (lógico si aplica)
+- Tipos DTO en `src/services/supabase/types.ts` o local en el archivo
+
+## Reglas estrictas
+- Cada método debe tener su tipo de entrada y salida definido
+- Manejar errores con try/catch y devolver { data, error } siempre
+- No exponer errores de Supabase al cliente (traducirlos)
+- Si hay políticas RLS, el servicio debe recibir el userId como parámetro
+
+## Anti-patrones (prohibido)
+- NO hacer llamadas a Supabase directamente desde componentes
+- NO exponer errores internos de Supabase (code, hint, details)
+- NO mezclar lógica de negocio con lógica de presentación
+
+## Ejemplo de estructura
+```typescript
+interface CreateProductDTO {
+  name: string
+  price: number
+  category_id: string
+}
+
+interface Product {
+  id: string
+  name: string
+  price: number
+  created_at: string
+}
+
+export const productService = {
+  async getAll(): Promise<{ data: Product[]; error: string | null }> {
+    // implementación
+  },
+  async create(dto: CreateProductDTO): Promise<{ data: Product | null; error: string | null }> {
+    // implementación
+  },
+}
+```
+
+## Formato de salida esperado
+Archivo completo listo para `src/services/supabase/{entity}Service.ts`.
+```

package/docs/referencia-metodologia/docs/PROMPTS/PLANTILLAS/07-formulario-validacion.md

@@ -0,0 +1,63 @@
+---
+title: Formulario con validación (react-hook-form + zod)
+tags: [formulario, validacion, react-hook-form, zod, typescript]
+usado_en: []
+fecha_creacion: 2026-05-13
+ultima_modificacion: 2026-05-13
+---
+
+## Cuándo usar
+
+Cuando necesites un formulario con validación en frontend. La combinación react-hook-form + zod es la más usada en proyectos React modernos por su tipado y rendimiento.
+
+## Prompt
+
+```markdown
+## Contexto
+Stack: React 18 + TypeScript + Tailwind + react-hook-form + zod.
+Convenciones: formularios en src/features/{feature}/components/, schema de validación junto al formulario o en types/.
+Referencia: docs/Framework de Desarrollo Asistido por IA.md sección 7 (patrones de reutilización).
+
+## Objetivo
+Crear el formulario `{FormName}` con validación usando react-hook-form + zod.
+
+## Especificaciones técnicas
+- Archivo: `src/features/{feature}/components/{FormName}.tsx`
+- Schema zod: definir las validaciones de cada campo
+- hook-form con `zodResolver` para integración
+- Campos del formulario:
+  - {campo 1: tipo, validación, placeholder}
+  - {campo 2: tipo, validación, placeholder}
+- onSubmit: recibir callback `onSubmit(data: SchemaType) => void`
+- Estados: idle, submitting, error, success
+- Máximo 150 líneas
+
+## Reglas estrictas
+- El schema zod debe definir tipos explícitos (z.string(), z.number(), etc.)
+- Los mensajes de error deben estar en español
+- Cada campo debe mostrar su error debajo del input
+- Botón de submit deshabilitado mientras se envía
+- Los inputs deben usar componentes de ui/ (Input, Select, etc.)
+
+## Anti-patrones (prohibido)
+- NO usar any
+- NO mezclar lógica de negocio (llamadas API) dentro del formulario
+- NO usar useState para validación manual (para eso está hook-form)
+- NO mostrar errores de API en los mensajes de validación de campo
+
+## Ejemplo de schema
+```typescript
+import { z } from "zod"
+
+export const {FormName}Schema = z.object({
+  email: z.string().email("Email inválido"),
+  password: z.string().min(8, "Mínimo 8 caracteres"),
+  name: z.string().min(2, "Mínimo 2 caracteres").max(50, "Máximo 50 caracteres"),
+})
+
+export type {FormName}SchemaType = z.infer<typeof {FormName}Schema>
+```
+
+## Formato de salida esperado
+Archivo completo con schema + componente de formulario + exportaciones.
+```

package/docs/referencia-metodologia/docs/PROMPTS/PLANTILLAS/08-hook-capacitor.md

@@ -0,0 +1,65 @@
+---
+title: Hook para plugin nativo de Capacitor
+tags: [capacitor, hook, nativo, camara, plugin]
+usado_en: []
+fecha_creacion: 2026-05-13
+ultima_modificacion: 2026-05-13
+---
+
+## Cuándo usar
+
+Cuando necesites acceder a funcionalidad nativa del dispositivo (cámara, GPS, notificaciones, almacenamiento) a través de plugins de Capacitor. El hook encapsula la lógica del plugin y expone una interfaz limpia para los componentes.
+
+## Prompt
+
+```markdown
+## Contexto
+Stack: React 18 + TypeScript + Capacitor 6 + Ionic 8.
+Convenciones: hooks de Capacitor en src/hooks/ con prefijo useCapacitor*, un hook por archivo, máximo 80 líneas.
+NO mezclar con lógica de Tauri.
+Referencia: docs/Framework de Desarrollo Asistido por IA.md sección 1 (convenciones Capacitor).
+
+## Objetivo
+Crear el hook `useCapacitor{Feature}` que encapsule el plugin `@capacitor/{plugin}`.
+
+## Especificaciones técnicas
+- Archivo: `src/hooks/useCapacitor{Feature}.ts`
+- Plugin a usar: `@capacitor/{plugin}`
+- Retornar: `{ result: {tipo} | null; execute: () => Promise<void>; error: string | null; loading: boolean }`
+- Manejar permisos: verificar permiso antes de ejecutar, pedir si no está concedido
+- Manejar error si el permiso es denegado permanentemente
+- Máximo 70 líneas
+
+## Reglas estrictas
+- Tipar todas las funciones con TypeScript
+- Verificar permisos antes de ejecutar cualquier acción nativa
+- Si el permiso es denegado, mostrar mensaje claro (no el error interno del plugin)
+- El hook debe funcionar tanto en web (fallback) como en dispositivo real
+
+## Anti-patrones (prohibido)
+- NO usar any
+- NO poner lógica de UI en el hook
+- NO mezclar con lógica de Tauri
+- NO asumir que el plugin está disponible sin verificar
+
+## Ejemplo correcto
+```typescript
+interface UseCapacitorCameraResult {
+  photo: string | null
+  takePhoto: () => Promise<void>
+  error: string | null
+  loading: boolean
+}
+
+export function useCapacitorCamera(): UseCapacitorCameraResult {
+  // 1. Verificar permiso con Camera.checkPermissions()
+  // 2. Si no concedido, pedir con Camera.requestPermissions()
+  // 3. Si denegado, setear error
+  // 4. Si concedido, ejecutar Camera.getPhoto({ resultType: CameraResultType.Uri })
+  // 5. Retornar { photo, takePhoto, error, loading }
+}
+```
+
+## Formato de salida esperado
+Archivo completo listo para `src/hooks/useCapacitor{Feature}.ts`.
+```

package/docs/referencia-metodologia/docs/PROMPTS/PLANTILLAS/09-refactor-division.md

@@ -0,0 +1,51 @@
+---
+title: Refactorizar componente grande en módulos pequeños
+tags: [refactor, division, modularizacion, limites]
+usado_en: []
+fecha_creacion: 2026-05-13
+ultima_modificacion: 2026-05-13
+---
+
+## Cuándo usar
+
+Cuando un componente supera los límites definidos en el catálogo (120 líneas UI, 80 hooks, 200 páginas) y necesitas dividirlo siguiendo el protocolo de separación automática.
+
+## Prompt
+
+```markdown
+## Contexto
+Stack: React 18 + TypeScript + Tailwind.
+Convenciones: docs/Framework de Desarrollo Asistido por IA.md sección 6 (límites por archivo + reglas de separación automática).
+Archivo a refactorizar: `{ruta/al/archivo.tsx}` ({cantidad} líneas actuales).
+
+## Objetivo
+Dividir el archivo `{nombre}` en módulos más pequeños según los límites del catálogo.
+
+## Análisis del archivo actual
+El archivo contiene:
+1. {sección 1}: {subcomponente o lógica identificable}
+2. {sección 2}: {subcomponente o lógica identificable}
+3. {sección 3}: {estados, lógica de negocio, etc.}
+
+## Plan de división propuesto
+Crear los siguientes archivos:
+- `{ruta}/components/{SubComponente1}.tsx` (estimado {N} líneas)
+- `{ruta}/components/{SubComponente2}.tsx` (estimado {N} líneas)
+- `{ruta}/hooks/use{Nombre}Logic.ts` (estimado {N} líneas)
+- El archivo original debe quedar en máximo 120 líneas
+
+## Reglas estrictas
+- NO cambiar la funcionalidad existente, solo mover código
+- Mantener los mismos imports y tipos, solo reubicarlos
+- El archivo original debe importar desde los nuevos archivos
+- Actualizar barrel exports (index.ts) si existen
+- No crear archivos de menos de 20 líneas (si es tan pequeño, fusionar)
+
+## Anti-patrones (prohibido)
+- NO renombrar funciones o props a menos que sea necesario para claridad
+- NO cambiar la lógica de negocio durante la refactorización
+- NO crear dependencias circulares entre los nuevos archivos
+
+## Formato de salida esperado
+Lista de archivos creados/modificados con el contenido de cada uno y los imports actualizados.
+```

package/docs/referencia-metodologia/docs/PROMPTS/PLANTILLAS/10-scaffolding-inicial.md

@@ -0,0 +1,79 @@
+---
+title: Scaffolding completo de un feature/módulo
+tags: [scaffolding, feature, setup, estructura-inicial]
+usado_en: []
+fecha_creacion: 2026-05-13
+ultima_modificacion: 2026-05-13
+---
+
+## Cuándo usar
+
+Al iniciar un nuevo feature o módulo dentro del proyecto. Crea toda la estructura de archivos (esqueletos vacíos con contratos) para que luego solo haya que implementar la lógica.
+
+## Prompt
+
+```markdown
+## Contexto
+Stack: React 18 + TypeScript + {Tailwind/Supabase/etc}.
+Convenciones: scaffolding con contratos de método, throw new Error("pendiente"), un archivo por responsabilidad.
+Referencia: docs/Framework de Desarrollo Asistido por IA.md sección 2 (estructura features/) y sección 6 (límites).
+
+## Objetivo
+Crear el scaffolding completo del feature `{featureName}`.
+
+## Estructura a crear
+```
+src/features/{featureName}/
+├── components/
+│   ├── {Component1}.tsx
+│   ├── {Component2}.tsx
+│   └── index.ts
+├── hooks/
+│   ├── use{FeatureName}.ts
+│   └── index.ts
+├── services/
+│   └── {featureName}Service.ts
+├── types/
+│   └── index.ts
+├── {FeatureName}Page.tsx
+└── index.ts
+```
+
+## Especificaciones técnicas
+
+### types/index.ts
+- Interfaces de las entidades del feature
+- DTOs de creación y actualización
+
+### services/{featureName}Service.ts
+- Métodos CRUD con contrato de método (inputs, outputs, flujo, impacto, error handling)
+- Cuerpo: `throw new Error("Lógica pendiente: {descripción}")`
+
+### hooks/use{FeatureName}.ts
+- Hook que conecta el servicio con el estado del componente
+- Estados: data, loading, error
+- Acciones: fetch, create, update, delete
+
+### components/{Component1,Component2}.tsx
+- Componentes visuales del feature
+- Props tipadas con interfaces del feature
+- Contrato de componente comentado
+
+### {FeatureName}Page.tsx
+- Página principal que compone los componentes
+- Máximo 200 líneas, idealmente < 100
+
+## Reglas estrictas
+- Cada archivo debe tener su contrato de método completo como comentario
+- throw new Error("pendiente") en toda función implementable
+- NO implementar lógica de negocio real
+- Los imports deben ser correctos entre los archivos del feature
+
+## Anti-patrones (prohibido)
+- NO implementar lógica (solo scaffolding)
+- NO crear archivos de más de 80 líneas en scaffolding
+- NO olvidar los index.ts (barrel exports)
+
+## Formato de salida esperado
+Todos los archivos del feature listos para copiar a src/features/{featureName}/.
+```

package/docs/referencia-metodologia/docs/PROMPTS/PLANTILLAS/11-supabase-crud-service.md

@@ -0,0 +1,114 @@
+---
+title: Servicio CRUD con Supabase — operaciones batch + RLS + signed URLs
+tags: [service, supabase, crud, rls, typescript]
+usado_en: []
+fecha_creacion: 2026-05-14
+ultima_modificacion: 2026-05-14
+---
+
+## Cuándo usar
+
+Cuando necesites un servicio CRUD completo para una tabla de Supabase con operaciones batch, RLS policies, signed URLs para archivos y manejo de errores por código PostgreSQL.
+
+## Prompt
+
+```markdown
+## Contexto
+Stack: React 18 + TypeScript + Vite + Supabase.
+Convenciones: servicios en src/services/, un archivo por entidad, máximo 150 líneas.
+Referencia DB: docs/CONVENCIONES_DB.md (RLS, batch, signed URLs, error codes).
+Tipos generados desde DB: src/types/supabase.ts (Database).
+
+## Objetivo
+Crear el servicio CRUD `productService` para la tabla `products` con operaciones batch, RLS respetado desde el cliente, signed URLs para imágenes, y errores tipados por código PostgreSQL.
+
+## Especificaciones técnicas
+- Archivo: `src/services/productService.ts`
+- Cliente Supabase desde `src/services/supabase/client.ts`
+- Tipos desde `src/types/supabase.ts`
+
+Operaciones:
+- `getAll(filters?)` — Listar con filtros opcionales, SELECT columnas específicas
+- `getById(id)` — Obtener por ID
+- `create(data)` — Insert con tipado estricto, capturar error 23505 (unique)
+- `update(id, data)` — Update parcial
+- `remove(id)` — Soft delete (columna deleted_at) con transacción
+- `getImageUrl(productId)` — Signed URL expirable para imagen
+- `batchCreate(items)` — Batch insert múltiple
+
+Cada función debe:
+- SELECT columnas específicas (nunca `*`)
+- Usar tipos generados desde DB (Database['public']['Tables']['products']['Row'])
+- Capturar errores PostgreSQL por código (23505, 23503, 42501)
+- Respetar RLS (sin Service Role Key en frontend)
+
+## Reglas estrictas
+- SELECT con columnas explícitas: `.select('id, name, price, category_id, created_at')`
+- Errores capturados por código: `if (error?.code === '23505')` → mensaje amigable
+- Soft delete con `deleted_at`, nunca hard delete
+- Signed URLs con expiración máxima 1h (3600s)
+- Batch insert con un solo `.insert([...])`, no loop
+- Tipos desde Database generado, nunca interfaces manuales
+
+## Anti-patrones (prohibido)
+- NO usar `select('*')`
+- NO exponer Service Role Key en frontend
+- NO hacer inserts en loop
+- NO usar buckets públicos para imágenes
+- NO borrar físicamente (hard delete)
+
+## Ejemplo correcto (parcial)
+```typescript
+import { supabase } from './supabase/client'
+import type { Database } from '../types/supabase'
+
+type Product = Database['public']['Tables']['products']['Row']
+type ProductInsert = Database['public']['Tables']['products']['Insert']
+
+export async function getAll(filters?: { category_id?: string }) {
+  let query = supabase
+    .from('products')
+    .select('id, name, price, category_id, created_at')
+
+  if (filters?.category_id) {
+    query = query.eq('category_id', filters.category_id)
+  }
+
+  const { data, error } = await query
+  if (error) throw new Error(error.message)
+  return data as Product[]
+}
+
+export async function create(data: ProductInsert) {
+  const { data: product, error } = await supabase
+    .from('products')
+    .insert(data)
+    .select('id, name, price')
+    .single()
+
+  if (error?.code === '23505') {
+    throw new Error('Ya existe un producto con ese identificador')
+  }
+  if (error) throw new Error(error.message)
+
+  return product
+}
+```
+
+## Ejemplo incorrecto
+```typescript
+// ❌ SELECT *, sin tipos, sin manejo de errores
+export async function getProducts() {
+  const { data } = await supabase.from('products').select('*')
+  return data
+}
+
+export async function deleteProduct(id: string) {
+  await supabase.from('products').delete().eq('id', id)
+  // Hard delete irreversible, sin soft delete
+}
+```
+
+## Formato de salida esperado
+Archivo completo `src/services/productService.ts` con todas las funciones CRUD implementadas.
+```

package/docs/referencia-metodologia/docs/PROMPTS/PLANTILLAS/12-supabase-hook-usetable.md

@@ -0,0 +1,143 @@
+---
+title: Hook useSupabaseTable con keyset pagination y filtros
+tags: [hook, supabase, pagination, keyset, typescript]
+usado_en: []
+fecha_creacion: 2026-05-14
+ultima_modificacion: 2026-05-14
+---
+
+## Cuándo usar
+
+Cuando necesites un hook que liste datos con paginación keyset (cursor-based), filtros combinados y ordenamiento. Ideal para tablas con muchos datos que deben escalar sin degradación.
+
+## Prompt
+
+```markdown
+## Contexto
+Stack: React 18 + TypeScript + Vite + Supabase.
+Convenciones: hooks en src/hooks/, un hook por archivo, máximo 80 líneas.
+Referencia DB: docs/CONVENCIONES_DB.md (keyset pagination, partial indexes, columnas específicas).
+
+## Objetivo
+Crear el hook `useSupabaseList<T>` que implemente keyset pagination (cursor-based), filtros combinados y ordenamiento. Escala a millones de filas sin degradación.
+
+## Especificaciones técnicas
+- Archivo: `src/hooks/useSupabaseList.ts`
+- Retornar: `{ data: T[]; loading: boolean; error: string | null; hasMore: boolean; loadMore: () => void; refetch: () => void }`
+- Parámetros: `UseListOptions<T>`:
+  - `table: string` — Nombre de la tabla
+  - `select: string` — Columnas separadas por coma (nunca *)
+  - `filters?: Record<string, unknown>` — Filtros exactos (columna: valor)
+  - `search?: { column: string; value: string }` — Búsqueda textual
+  - `orderBy?: { column: keyof T; ascending: boolean }` — Ordenamiento
+  - `pageSize?: number` — Items por página (default: 25)
+  - `cursorColumn?: string` — Columna del cursor (default: 'id')
+
+## Reglas estrictas
+- Paginación keyset: `WHERE cursorColumn > lastValue LIMIT pageSize`
+- SELECT con columnas explícitas en `select`, nunca `*`
+- `loading` debe iniciar en `true` en la primera carga
+- `hasMore` se calcula: si la DB devuelve menos de `pageSize` filas, no hay más
+- `loadMore` append los nuevos datos al array existente (no reemplazar)
+- `refetch` reinicia el estado completo
+- Los filtros deben ser estables (usar `useMemo` para construir la query)
+- El cursor debe incluirse en `select` aunque no se muestre en UI
+
+## Anti-patrones (prohibido)
+- NO usar `range()` / offset — usar keyset
+- NO hacer fetch en el render, solo en `useEffect`
+- NO mutar estado directamente (usar spread o inmutable)
+- NO poner lógica de UI en el hook
+
+## Ejemplo correcto (parcial)
+```typescript
+interface UseListOptions<T> {
+  table: string
+  select: string
+  filters?: Record<string, unknown>
+  orderBy?: { column: keyof T; ascending: boolean }
+  pageSize?: number
+  cursorColumn?: string
+}
+
+interface UseListResult<T> {
+  data: T[]
+  loading: boolean
+  error: string | null
+  hasMore: boolean
+  loadMore: () => void
+  refetch: () => void
+}
+
+export function useSupabaseList<T extends Record<string, unknown>>({
+  table,
+  select,
+  filters,
+  orderBy,
+  pageSize = 25,
+  cursorColumn = 'id',
+}: UseListOptions<T>): UseListResult<T> {
+  const [data, setData] = useState<T[]>([])
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+  const [cursor, setCursor] = useState<string | null>(null)
+  const [hasMore, setHasMore] = useState(true)
+
+  const fetchData = async (isLoadMore = false) => {
+    setLoading(true)
+    setError(null)
+
+    let query = supabase
+      .from(table)
+      .select(select)
+      .limit(pageSize)
+      .order(orderBy?.column || 'id', { ascending: orderBy?.ascending ?? true })
+
+    if (filters) {
+      Object.entries(filters).forEach(([key, value]) => {
+        query = query.eq(key, value)
+      })
+    }
+
+    if (isLoadMore && cursor) {
+      query = query.gt(cursorColumn, cursor)
+    }
+
+    const { data: result, error: err } = await query
+    if (err) { setError(err.message); setLoading(false); return }
+
+    setData(prev => isLoadMore ? [...prev, ...(result as T[])] : (result as T[]))
+    setHasMore(result.length === pageSize)
+    if (result.length > 0) {
+      setCursor(String(result[result.length - 1][cursorColumn]))
+    }
+    setLoading(false)
+  }
+
+  useEffect(() => { fetchData() }, [table, JSON.stringify(filters), orderBy?.column, orderBy?.ascending])
+  const loadMore = () => { if (hasMore && !loading) fetchData(true) }
+  const refetch = () => { setCursor(null); setHasMore(true); fetchData() }
+
+  return { data, loading, error, hasMore, loadMore, refetch }
+}
+```
+
+## Ejemplo incorrecto
+```typescript
+// ❌ Offset pagination, select *, sin hasMore
+export function useProducts() {
+  const [data, setData] = useState<any[]>([])
+  const [page, setPage] = useState(0)
+
+  useEffect(() => {
+    supabase.from('products').select('*').range(page * 25, (page + 1) * 25).then(r => setData(r.data))
+  }, [page])
+
+  return { data, nextPage: () => setPage(p => p + 1) }
+  // Se degrada con datos grandes, any, mutación directa
+}
+```
+
+## Formato de salida esperado
+Archivo completo `src/hooks/useSupabaseList.ts` con hook genérico tipado.
+```

package/docs/referencia-metodologia/docs/PROMPTS/PLANTILLAS/13-tauri-command-rust.md

@@ -0,0 +1,84 @@
+---
+title: Comando Tauri en Rust con validación de inputs
+tags: [tauri, rust, command, backend]
+usado_en: []
+fecha_creacion: 2026-05-14
+ultima_modificacion: 2026-05-14
+---
+
+## Cuándo usar
+
+Cuando necesites crear un comando Tauri v2 en Rust con validación estricta de inputs, manejo de errores tipados, y path sanitization.
+
+## Prompt
+
+```markdown
+## Contexto
+Stack: Tauri v2 + Rust + React + TypeScript.
+Convenciones: comandos Rust en src-tauri/src/commands/, un archivo por comando.
+Referencia: Tauri v2 IPC — #[tauri::command] con Result<T, String>.
+
+## Objetivo
+Crear el comando Tauri `{command_name}` que {descripción del propósito} con validación de inputs, errores tipados y path sanitization.
+
+## Especificaciones técnicas
+Archivos a crear:
+- `src-tauri/src/commands/{module}.rs` — Implementación Rust
+- `src-tauri/src/main.rs` — Registrar el módulo con `.invoke_handler()`
+- `src/services/tauri/{module}.ts` — Wrapper TypeScript tipado
+
+Comando Rust:
+- `#[tauri::command]`
+- `fn {nombre}({parametros}) -> Result<{output}, String>`
+- Validar todos los inputs antes de ejecutar lógica
+- Sanitizar paths para evitar path traversal
+- Devolver error específico en español/inglés
+
+## Reglas estrictas
+- Tipar con tipos concretos (String, no &str; u64, no i32 cuando no negativo)
+- Sanitizar paths: rechazar `..`, `~`, y symlinks a directorios prohibidos
+- No permitir path traversal — restringir a directorio de trabajo
+- Error en String, no en custom enum (Tauri v2 IPC serializa String)
+- Documentar cada error posible con su causa
+
+## Anti-patrones
+- NO usar `std::fs::read_to_string` sin validar path
+- NO exponer comandos inseguros sin autenticación
+- NO usar `unwrap()` o `expect()` en producción
+- NO mezclar lógica de negocio con lógica de UI
+
+## Ejemplo correcto (parcial)
+```rust
+use std::path::{Path, PathBuf};
+use tauri::Manager;
+
+#[tauri::command]
+fn read_file_content(app_handle: tauri::AppHandle, path: String) -> Result<String, String> {
+    let base = PathBuf::from(&app_handle.path().resource_dir().map_err(|e| e.to_string())?);
+    let requested = base.join(&path);
+
+    // Sanitize: rechazar path traversal
+    if !requested.starts_with(&base) {
+        return Err("Acceso denegado: path fuera del directorio permitido".into());
+    }
+
+    if !requested.exists() {
+        return Err(format!("Archivo no encontrado: {}", path));
+    }
+
+    std::fs::read_to_string(&requested).map_err(|e| format!("Error de lectura: {}", e))
+}
+```
+
+## Ejemplo incorrecto
+```rust
+// ❌ Sin validación de path, sin manejo de errores
+#[tauri::command]
+fn read_file(path: String) -> String {
+    std::fs::read_to_string(path).unwrap()  // Panic en producción!
+}
+```
+
+## Formato de salida esperado
+Código Rust + registro en main.rs + wrapper TypeScript + instrucciones.
+```