Compare commits
19
Commits
26e6d3a9bf
...
main
@@ -28,3 +28,11 @@ SEED_ADMIN_NAME=Administrador
|
||||
SEED_ASESOR_EMAIL=
|
||||
SEED_ASESOR_PASSWORD=
|
||||
SEED_ASESOR_NAME=
|
||||
|
||||
# --- Propuesta consultiva con IA (MiniMax) ---
|
||||
# Clave del panel de MiniMax. NUNCA se commitea: .env esta en .gitignore.
|
||||
# Ojo con el prefijo: NO uses ANTHROPIC_API_KEY. El SDK la lee por su cuenta y
|
||||
# mandaria la clave de MiniMax a api.anthropic.com.
|
||||
MINIMAX_API_KEY=
|
||||
MINIMAX_BASE_URL=https://api.minimax.io/anthropic
|
||||
MINIMAX_MODEL=MiniMax-M3
|
||||
|
||||
@@ -7,15 +7,19 @@
|
||||
| `npm run dev` | Start Next.js dev server on port 3000 |
|
||||
| `npm run build` | Production build (runs TypeScript check) |
|
||||
| `npm run lint` | ESLint (flat config, eslint-config-next) |
|
||||
| `npx tsx prisma/seed.ts` | Run seed (upserts all data, idempotent) |
|
||||
| `npx prisma migrate dev` | Create/apply migration |
|
||||
| `npx prisma generate` | Regenerate Prisma client |
|
||||
| `npx prisma studio` | Prisma Studio GUI |
|
||||
| `npm run db:seed` | Run seed (upserts all data, idempotent) |
|
||||
| `npm run db:migrate` | Create/apply migration (`prisma migrate dev`) |
|
||||
| `npm run db:generate` | Regenerate Prisma client |
|
||||
| `npm run db:studio` | Prisma Studio GUI |
|
||||
|
||||
**There is no test suite** — no runner, no test files, in either backend. Verification is `npm run build` (typechecks) + `npm run lint`. Don't claim a change is verified on the strength of a build alone; exercise the affected route or page.
|
||||
|
||||
**Windows environment.** Use `start.bat` / `stop.bat` to manage Docker PostgreSQL + Next.js together. PowerShell is the shell. Paths with brackets (e.g. `[id]`) require `-LiteralPath` in PowerShell, not `-Path`.
|
||||
|
||||
**Two backends, one database.** The Next.js app (`src/`, port 3000) and a standalone Python FastAPI service (`api/`, port 8000) both talk to the same PostgreSQL DB. Prisma owns the schema/migrations; the Python API reads/writes the same tables independently. `docker-compose.yml` runs `postgres` + the `api` service; Next.js is run separately via `npm run dev` / `start.bat`.
|
||||
|
||||
**Three compose files, and two of them are the same file.** `docker-compose.yaml` is a byte-identical copy of `docker-compose.coolify.yml` — it exists only so Coolify's default detection finds the production stack. Local dev is `docker-compose.yml` (postgres with port 5432 published + api). Because `.yml` and `.yaml` both exist, a bare `docker compose` warns about ambiguity before resolving to `docker-compose.yml`; pass `-f docker-compose.yml` explicitly, as `start.bat` does. **When you edit the Coolify stack, edit both `docker-compose.coolify.yml` and `docker-compose.yaml`** or Coolify deploys the stale copy.
|
||||
|
||||
## Prisma 7 — Critical Gotchas
|
||||
|
||||
- **Prisma client is NOT at `@prisma/client`.** It's generated to `src/generated/prisma/` and imported as `@/generated/prisma/client`.
|
||||
@@ -46,6 +50,25 @@
|
||||
- **Bucéfalo CRM plan prices** (in `calculators.ts`, NOT the DB): basico=$1,000, estandar=$3,500, premium=$4,500, empresarial=$7,500 (monthly).
|
||||
- **Financing** lives in the `FinanciamientoPlan` table (3/6/9/12 months). Formula: `comisionTotal = monto × comision%`, `pagoMensual = (monto + comisionTotal) × (1 + tasa) / meses`, then add 16% IVA. Both backends must keep this formula identical.
|
||||
|
||||
### Charge models (`ServicioCotizado.modeloCobro`)
|
||||
|
||||
A quoted line item is `fijo` (default), `horas`, `retainer`, or `demanda` — see `MODELOS_COBRO` in `calculators.ts`. The time-based three are `MODELOS_COBRO_TIEMPO`. Supporting fields: `esPersonalizado`, `horas`, `tarifaHora`, `montoMinimo`, `horasIncluidas`. `TARIFA_HORA_DEFAULT = 700`.
|
||||
|
||||
**`precio` is always the authoritative total.** For retainer and demanda lines, `horas × tarifaHora` is display/comparison metadata only — never re-derive a total from it. `calcularTotalesOpcion` and the PDF/Excel builders all sum `precio`.
|
||||
|
||||
### Doble propuesta (two-option quotes)
|
||||
|
||||
`Cotizacion.esDoble` turns one quote into two comparable proposals. Each `ServicioCotizado.opcion` is `"1"`, `"2"`, or `"ambas"` (shared by both). `opcionesMetadata` (Json) holds per-option `titulo` / `descripcion` / `noIncluye` (`MetaOpcion`). `calcularTotalesOpcion(servicios, "1" | "2")` sums lines matching that option **plus** all `"ambas"` lines. Anything that renders or totals a quote must handle both the single and double shape.
|
||||
|
||||
### Registro de horas (hours log → payment notes)
|
||||
|
||||
`RegistroHoras` tracks worked time against a quote so the client can be billed for it. Only offered when `esCotizacionPorTiempo(servicios)` is true (i.e. some line uses a time-based `modeloCobro`).
|
||||
|
||||
- `estadoPago` is `"por_pagar"` (default) or `"pagada"`, with `fechaPago` stamped on transition. The two buckets must stay separated in totals — pending is what goes on the payment note, paid is history. `resumenPagoHoras` / `esPagada` in `calculators.ts` are the only place that logic should live.
|
||||
- Routes: `GET|POST /api/cotizaciones/[id]/horas` (GET takes `?from=&to=` day filters), `PATCH|DELETE .../horas/[registroId]`, and `POST .../nota-horas` which renders the PDF **server-side** via `src/lib/nota-horas-pdf.ts` (no browser URL).
|
||||
- Hours are entered as `horaInicio`/`horaFin` strings and converted by `calcularHorasRango`. Dates come in as `YYYY-MM-DD` and must go through `fechaRegistroDesdeISO` to avoid UTC off-by-one — don't `new Date(iso)` directly.
|
||||
- Grouping for display/PDF: `ModoAgrupacion` = `detalle | dia | semana | mes` via `periodoAgrupacion`.
|
||||
|
||||
## Auth
|
||||
|
||||
- **JWT sessions** (`src/lib/auth.ts`) signed with `jose` (HS256, 7-day expiry), stored in the `cotizador-session` httpOnly cookie. `JWT_SECRET` env var is **required** (throws at startup if missing).
|
||||
@@ -66,27 +89,39 @@
|
||||
```
|
||||
src/
|
||||
app/
|
||||
(app)/ # Authed route group: dashboard, cotizaciones, clientes, catalogo, configuracion (has its own layout.tsx + Sidebar)
|
||||
api/ # Next.js route handlers (REST): auth, catalogo, categorias, cotizaciones, configuracion, paquetes, export, import
|
||||
(app)/ # Authed route group: dashboard, cotizaciones, clientes, catalogo, configuracion (has its own layout.tsx + Sidebar + DialogProvider)
|
||||
api/ # Next.js route handlers (REST): auth, catalogo, categorias, cotizaciones (+ horas, nota-horas, precio),
|
||||
# configuracion, paquetes, export, import, health
|
||||
login/ # Public login page
|
||||
components/ # CotizacionForm, ExportButtons, EstadoBadge, layout/Sidebar
|
||||
lib/ # auth, db, store, calculators, pdf-generator, schemas, config-helpers
|
||||
components/ # CotizacionForm (~1.4k lines), ExportButtons, EstadoBadge, layout/Sidebar, ui/DialogProvider
|
||||
lib/ # auth, db, store, calculators, schemas, config-helpers,
|
||||
# pdf-generator (quote PDF), nota-horas-pdf (hours-note PDF), excel-builder
|
||||
generated/prisma/ # Prisma client output (gitignored)
|
||||
prisma/
|
||||
schema.prisma # 13 models (User, Cliente, Cotizacion, Categoria, Paquete, FasePaquete,
|
||||
schema.prisma # 14 models (User, Cliente, Cotizacion, Categoria, Paquete, FasePaquete,
|
||||
# ServicioCatalogo, ServicioPaquete, ServicioCotizado, PlanBucefaloCotizacion,
|
||||
# Configuracion, Bono, FinanciamientoPlan)
|
||||
# RegistroHoras, Configuracion, Bono, FinanciamientoPlan)
|
||||
seed.ts # All catalog data (services, categorias, bonos, planes, config) — idempotent upserts
|
||||
migrations/ # 3 migrations
|
||||
api/ # Standalone Python FastAPI + MCP server (see below)
|
||||
migrations/ # 10 migrations
|
||||
api/ # Standalone Python FastAPI service (see below)
|
||||
docs/ # Business/product notes (Spanish), not code docs
|
||||
```
|
||||
|
||||
- **Zustand store** (`src/lib/store.ts`) holds the cotización draft. Used by both the new (`cotizaciones/nueva`) and edit (`cotizaciones/[id]/editar`) pages, both of which render `CotizacionForm.tsx`.
|
||||
- **ExportButtons.tsx** has 4 variants: `ExportExcelButtonSaved` / `ExportPDFButtonSaved` (GET by ID) and `ExportExcelButtonDraft` / `ExportPDFButtonDraft` (POST with body).
|
||||
- **Business logic belongs in `calculators.ts`**, not in components or route handlers. It's the shared source of truth for totals, charge models, hours, phases, and formatting — and the file the Python `calculators.py` mirrors.
|
||||
|
||||
## UI Conventions
|
||||
|
||||
- **Never use the browser's native `confirm()` / `alert()` / `prompt()`.** They render as "«domain» dice…" and break the brand. Use the platform's own dialogs: `useConfirm()`, `usePrompt()`, `useToast()` from `@/components/ui/DialogProvider`, mounted once in `src/app/(app)/layout.tsx`. `confirm` and `prompt` return promises (`boolean` / `string | null`); pass `danger: true` for destructive actions.
|
||||
- Everything user-facing is in **Spanish**. Code identifiers are Spanish too (`cotizacion`, `servicio`, `horas`) — match the surrounding naming rather than introducing English terms.
|
||||
- Icons come from `lucide-react`. Colors use the CSS custom properties from `globals.css` (`bg-card-bg`, `border-border`, `text-primary`, `text-muted`), not hardcoded Tailwind palette values.
|
||||
|
||||
## Python API (`api/`) — Optional Second Backend
|
||||
|
||||
- **FastAPI app** (`api/main.py`) exposing the same domain as REST, **plus an MCP server at `/mcp`** for AI agents (n8n, Claude, ChatGPT). Tools/resources defined in `api/app/mcp/`.
|
||||
- **FastAPI app** (`api/main.py`) exposing the same domain as REST, for n8n and other integrations.
|
||||
- **The MCP server was removed on 2026-07-28.** It was unused, its transport had been broken for some time (it built a `StreamableHTTPServerTransport` per request with no session handling and returned 500 even with valid credentials), and its unpinned SDK took the whole API down in production when `mcp` jumped to 2.0.0. To revive it: `git show edb500f5:api/app/mcp/server.py`.
|
||||
- **`api/requirements.txt` pins exact versions on purpose.** That outage is why. Bump a dependency deliberately — never by accident on a redeploy.
|
||||
- Auth: **API key** (`X-API-Key` or `Authorization: Bearer`) for agents; JWT for human login. Routers in `api/app/routers/`, business logic in `api/app/services/` (its own `calculators.py`, `pdf_generator.py`, `excel_generator.py` — mirror the TS versions).
|
||||
- Run: `cd api && pip install -r requirements.txt && uvicorn main:app --reload --port 8000`. Swagger at `/docs`. Full endpoint reference in `api/COTIZADOR_API_SKILL.md`.
|
||||
- It reads `DB_*`, `API_KEY`, `JWT_SECRET` env vars (same DB as Prisma).
|
||||
|
||||
@@ -10,7 +10,7 @@ y financiamiento opcional. Exporta a PDF y Excel.
|
||||
- **ORM:** Prisma 7 (cliente generado en `src/generated/prisma`, driver adapter `PrismaPg`)
|
||||
- **Base de datos:** PostgreSQL 16 (vía Docker)
|
||||
- **Auth:** JWT (`jose`) en cookie httpOnly, contraseñas con `bcryptjs`
|
||||
- **API alterna:** servicio Python FastAPI + servidor MCP en [`api/`](api/) (para n8n / agentes de IA)
|
||||
- **API alterna:** servicio Python FastAPI en [`api/`](api/) (para n8n / integraciones)
|
||||
|
||||
## Requisitos
|
||||
|
||||
@@ -51,7 +51,7 @@ npm run dev # http://localhost:3000
|
||||
```bash
|
||||
cd api
|
||||
pip install -r requirements.txt
|
||||
uvicorn main:app --reload --port 8000 # Swagger en /docs, MCP en /mcp
|
||||
uvicorn main:app --reload --port 8000 # Swagger en /docs
|
||||
```
|
||||
|
||||
Referencia completa de endpoints en [`api/COTIZADOR_API_SKILL.md`](api/COTIZADOR_API_SKILL.md).
|
||||
@@ -89,7 +89,8 @@ El stack de producción está en [docker-compose.coolify.yml](docker-compose.coo
|
||||
|
||||
- No expongas el puerto 5432: los servicios se comunican por la red interna del compose.
|
||||
- El volumen `postgres_data` persiste la base de datos entre deploys. No lo borres.
|
||||
- El servidor MCP queda en `https://<dominio-api>/mcp` (auth por `X-API-Key`).
|
||||
- El API expone REST en `https://<dominio-api>` con auth por `X-API-Key` o JWT. El servidor MCP se retiro el 2026-07-28 (ver `AGENTS.md`).
|
||||
- Las versiones de `api/requirements.txt` estan fijas a proposito: un rango abierto dejo entrar `mcp` 2.0.0 y tumbo el API en produccion. Sube dependencias a proposito, no al redesplegar.
|
||||
- La fórmula de financiamiento y los cálculos viven duplicados en `src/lib/calculators.ts` y `api/app/services/calculators.py` — mantenlos en paridad.
|
||||
|
||||
## Documentación para agentes
|
||||
|
||||
+10
-23
@@ -418,32 +418,19 @@ granTotal = totalMensual × meses
|
||||
|
||||
---
|
||||
|
||||
## MCP Integration
|
||||
## MCP Integration — removed (2026-07-28)
|
||||
|
||||
MCP server at `/mcp` for OpenClaw, Claude, ChatGPT.
|
||||
The `/mcp` endpoint and the `api/app/mcp/` package no longer exist. Agents should use
|
||||
the REST endpoints documented above, authenticating with `X-API-Key` or a Bearer JWT.
|
||||
|
||||
### Tools
|
||||
| Tool | Description |
|
||||
|------|-------------|
|
||||
| `buscar_servicios` | Search catalog by phase, payment type, category, text |
|
||||
| `crear_cotizacion` | Create complete quotation in one call |
|
||||
| `obtener_cotizacion` | Get quotation details |
|
||||
| `listar_cotizaciones` | List with filters |
|
||||
| `cambiar_estado_cotizacion` | Change status |
|
||||
| `actualizar_precio_servicio` | Adjust service price |
|
||||
| `duplicar_cotizacion` | Clone as draft |
|
||||
| `calcular_financiamiento` | Calculate payments |
|
||||
| `generar_pdf_cotizacion` | Generate PDF |
|
||||
| `obtener_configuracion` | Company config |
|
||||
| `listar_bonos` | Available bonuses |
|
||||
| `listar_planes_bucefalo` | CRM plans |
|
||||
It was removed for three reasons: nobody was using it; its transport had been broken
|
||||
for some time (it constructed a `StreamableHTTPServerTransport` per request with no
|
||||
session handling, returning 500 even with valid credentials); and its unpinned SDK
|
||||
took the entire API down in production when `mcp` released 2.0.0 and dropped
|
||||
`Server.list_tools()`.
|
||||
|
||||
### Resources
|
||||
| Resource | Description |
|
||||
|----------|-------------|
|
||||
| `cotizador://servicios` | Full catalog |
|
||||
| `cotizador://categorias` | Categories |
|
||||
| `cotizador://configuracion` | Company config |
|
||||
To bring it back: `git show edb500f5:api/app/mcp/server.py`. Pin the SDK to the 1.x
|
||||
series and fix the transport before mounting it again.
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -1,453 +0,0 @@
|
||||
"""MCP Server for the Cotizador E3 API.
|
||||
|
||||
Provides MCP tools and resources for AI agents (OpenClaw, Claude, ChatGPT, etc.)
|
||||
to interact with the quotation system.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from datetime import datetime
|
||||
|
||||
from mcp.server import Server
|
||||
from mcp.types import Resource, TextContent, Tool
|
||||
|
||||
from app.database import get_pool
|
||||
from app.mcp.tools import RESOURCES, TOOLS
|
||||
from app.services.calculators import (
|
||||
BONOS,
|
||||
PLANES_BUCEFALO,
|
||||
calcular_financiamiento,
|
||||
bucefalo_precio,
|
||||
)
|
||||
|
||||
server = Server("cotizador-e3")
|
||||
|
||||
|
||||
@server.list_tools()
|
||||
async def list_tools() -> list[Tool]:
|
||||
return [
|
||||
Tool(
|
||||
name=t["name"],
|
||||
description=t["description"],
|
||||
inputSchema=t["inputSchema"],
|
||||
)
|
||||
for t in TOOLS
|
||||
]
|
||||
|
||||
|
||||
@server.list_resources()
|
||||
async def list_resources() -> list[Resource]:
|
||||
return [
|
||||
Resource(
|
||||
uri=r["uri"],
|
||||
name=r["name"],
|
||||
description=r["description"],
|
||||
mimeType=r["mimeType"],
|
||||
)
|
||||
for r in RESOURCES
|
||||
]
|
||||
|
||||
|
||||
@server.read_resource()
|
||||
async def read_resource(uri: str) -> str:
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
if uri == "cotizador://servicios":
|
||||
rows = await conn.fetch(
|
||||
"""SELECT s.id, s.nombre, s.descripcion, s.fase, s."tipoPago",
|
||||
s."precioBase", s."tiempoEntrega", s."entregablesDefault",
|
||||
s.variante, s.activo, s.orden,
|
||||
c.nombre as categoria_nombre
|
||||
FROM "ServicioCatalogo" s
|
||||
LEFT JOIN "Categoria" c ON s."categoriaId" = c.id
|
||||
WHERE s.activo = true
|
||||
ORDER BY s.fase ASC, s.orden ASC"""
|
||||
)
|
||||
return json.dumps([dict(r) for r in rows], default=str)
|
||||
|
||||
elif uri == "cotizador://categorias":
|
||||
rows = await conn.fetch(
|
||||
'SELECT id, nombre, descripcion, color, activo, orden FROM "Categoria" ORDER BY orden ASC'
|
||||
)
|
||||
return json.dumps([dict(r) for r in rows], default=str)
|
||||
|
||||
elif uri == "cotizador://configuracion":
|
||||
rows = await conn.fetch('SELECT clave, valor FROM "Configuracion"')
|
||||
return json.dumps({r["clave"]: r["valor"] for r in rows})
|
||||
|
||||
return json.dumps({"error": f"Unknown resource: {uri}"})
|
||||
|
||||
|
||||
@server.call_tool()
|
||||
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
|
||||
pool = await get_pool()
|
||||
async with pool.acquire() as conn:
|
||||
result = await _handle_tool(conn, name, arguments)
|
||||
return [TextContent(type="text", text=json.dumps(result, default=str, ensure_ascii=False))]
|
||||
|
||||
|
||||
async def _handle_tool(conn, name: str, arguments: dict) -> dict:
|
||||
if name == "buscar_servicios":
|
||||
return await _buscar_servicios(conn, arguments)
|
||||
elif name == "crear_cotizacion":
|
||||
return await _crear_cotizacion(conn, arguments)
|
||||
elif name == "obtener_cotizacion":
|
||||
return await _obtener_cotizacion(conn, arguments)
|
||||
elif name == "listar_cotizaciones":
|
||||
return await _listar_cotizaciones(conn, arguments)
|
||||
elif name == "cambiar_estado_cotizacion":
|
||||
return await _cambiar_estado(conn, arguments)
|
||||
elif name == "actualizar_precio_servicio":
|
||||
return await _actualizar_precio(conn, arguments)
|
||||
elif name == "duplicar_cotizacion":
|
||||
return await _duplicar_cotizacion(conn, arguments)
|
||||
elif name == "calcular_financiamiento":
|
||||
return await _calcular_financiamiento(arguments)
|
||||
elif name == "generar_pdf_cotizacion":
|
||||
return await _generar_pdf(conn, arguments)
|
||||
elif name == "obtener_configuracion":
|
||||
return await _obtener_configuracion(conn)
|
||||
elif name == "listar_bonos":
|
||||
return {"bonos": BONOS}
|
||||
elif name == "listar_planes_bucefalo":
|
||||
return {"planes": PLANES_BUCEFALO}
|
||||
else:
|
||||
return {"error": f"Unknown tool: {name}"}
|
||||
|
||||
|
||||
async def _buscar_servicios(conn, args: dict) -> dict:
|
||||
conditions = ['s.activo = true']
|
||||
params = []
|
||||
idx = 1
|
||||
|
||||
if args.get("fase") is not None:
|
||||
conditions.append(f's.fase = ${idx}')
|
||||
params.append(args["fase"])
|
||||
idx += 1
|
||||
if args.get("tipo_pago"):
|
||||
conditions.append(f's."tipoPago" = ${idx}')
|
||||
params.append(args["tipo_pago"])
|
||||
idx += 1
|
||||
if args.get("categoria"):
|
||||
conditions.append(f'LOWER(c.nombre) = LOWER(${idx})')
|
||||
params.append(args["categoria"])
|
||||
idx += 1
|
||||
if args.get("busqueda"):
|
||||
conditions.append(f'(LOWER(s.nombre) LIKE LOWER(${idx}) OR LOWER(s.descripcion) LIKE LOWER(${idx}))')
|
||||
params.append(f"%{args['busqueda']}%")
|
||||
idx += 1
|
||||
|
||||
where = " AND ".join(conditions)
|
||||
query = f"""SELECT s.id, s.nombre, s.descripcion, s.fase, s."tipoPago",
|
||||
s."precioBase", s."tiempoEntrega", s."entregablesDefault",
|
||||
s.variante, c.nombre as categoria
|
||||
FROM "ServicioCatalogo" s
|
||||
LEFT JOIN "Categoria" c ON s."categoriaId" = c.id
|
||||
WHERE {where}
|
||||
ORDER BY s.fase ASC, s.orden ASC"""
|
||||
|
||||
rows = await conn.fetch(query, *params)
|
||||
servicios = []
|
||||
for r in rows:
|
||||
d = dict(r)
|
||||
if d.get("entregablesDefault") and isinstance(d["entregablesDefault"], str):
|
||||
try:
|
||||
d["entregablesDefault"] = json.loads(d["entregablesDefault"])
|
||||
except (json.JSONDecodeError, TypeError):
|
||||
pass
|
||||
servicios.append(d)
|
||||
|
||||
return {"servicios": servicios, "total": len(servicios)}
|
||||
|
||||
|
||||
async def _crear_cotizacion(conn, args: dict) -> dict:
|
||||
cliente_data = args["cliente"]
|
||||
servicios_data = args["servicios"]
|
||||
plan_bucefalo = args.get("plan_bucefalo")
|
||||
moneda = args.get("moneda", "MXN")
|
||||
proyecto = args.get("proyecto", "MKT Digital")
|
||||
esquema = args.get("esquema_pago", "Pago Unico/Mensual")
|
||||
es_doble = bool(args.get("es_doble", False))
|
||||
opciones_metadata = args.get("opciones_metadata") if es_doble else None
|
||||
|
||||
cliente = await conn.fetchrow(
|
||||
'SELECT id FROM "Cliente" WHERE nombre = $1 AND empresa = $2',
|
||||
cliente_data["nombre"],
|
||||
cliente_data.get("empresa", ""),
|
||||
)
|
||||
if not cliente:
|
||||
cliente = await conn.fetchrow(
|
||||
'INSERT INTO "Cliente" (id, nombre, empresa, email, telefono, "createdAt", "updatedAt") VALUES (gen_random_uuid(), $1, $2, $3, $4, NOW(), NOW()) RETURNING id',
|
||||
cliente_data["nombre"],
|
||||
cliente_data.get("empresa", ""),
|
||||
cliente_data.get("email", ""),
|
||||
cliente_data.get("telefono", ""),
|
||||
)
|
||||
|
||||
cliente_id = cliente["id"]
|
||||
|
||||
now = datetime.now()
|
||||
numero = f"UJ{str(now.year)[-2:]}{now.month:02d}AGENT001"
|
||||
|
||||
from app.services.calculators import calcular_vigencia
|
||||
vigencia = calcular_vigencia(now)
|
||||
|
||||
async with conn.transaction():
|
||||
cot = await conn.fetchrow(
|
||||
"""INSERT INTO "Cotizacion" (id, numero, fecha, vigencia, moneda, "tipoCambio", proyecto, "esquemaPago",
|
||||
estado, "incluirBonos", "incluirFinanciamiento", "esDoble", "opcionesMetadata", observaciones, "clienteId", "asesorId", "createdAt", "updatedAt")
|
||||
VALUES (gen_random_uuid(), $1, $2, $3, $4, 'NA', $5, $6, 'borrador', false, false, $7, $8, '', $9, $10, NOW(), NOW())
|
||||
RETURNING id, numero""",
|
||||
numero, now, vigencia, moneda, proyecto, esquema,
|
||||
es_doble,
|
||||
json.dumps(opciones_metadata) if opciones_metadata else None,
|
||||
cliente_id, "agent",
|
||||
)
|
||||
cot_id = cot["id"]
|
||||
|
||||
for srv in servicios_data:
|
||||
catalogo_id = srv["servicio_id"]
|
||||
cat_row = await conn.fetchrow(
|
||||
'SELECT id, "precioBase", "tiempoEntrega", "entregablesDefault", fase, "tipoPago" FROM "ServicioCatalogo" WHERE id = $1',
|
||||
catalogo_id,
|
||||
)
|
||||
if not cat_row:
|
||||
continue
|
||||
|
||||
precio = srv.get("precio_personalizado") or cat_row["precioBase"]
|
||||
entregables = cat_row["entregablesDefault"]
|
||||
if isinstance(entregables, str):
|
||||
try:
|
||||
entregables = json.loads(entregables)
|
||||
except (json.JSONDecodeError, TypeError):
|
||||
entregables = []
|
||||
|
||||
opcion = (srv.get("opcion") or "ambas") if es_doble else None
|
||||
|
||||
await conn.fetchrow(
|
||||
"""INSERT INTO "ServicioCotizado" (id, "cotizacionId", "servicioCatalogoId", fase, "tipoPago",
|
||||
precio, "tiempoEntrega", entregables, opcion, seleccionado, "createdAt", "updatedAt")
|
||||
VALUES (gen_random_uuid(), $1, $2, $3, $4, $5, $6, $7, $8, true, NOW(), NOW())""",
|
||||
cot_id, catalogo_id, cat_row["fase"], cat_row["tipoPago"],
|
||||
precio, cat_row["tiempoEntrega"], json.dumps(entregables or []), opcion,
|
||||
)
|
||||
|
||||
if plan_bucefalo:
|
||||
nivel = plan_bucefalo if isinstance(plan_bucefalo, str) else plan_bucefalo.get("nivel", "basico")
|
||||
precio_bp = bucefalo_precio(nivel)
|
||||
await conn.fetchrow(
|
||||
"""INSERT INTO "PlanBucefaloCotizacion" (id, "cotizacionId", nivel, precio, seleccionado, "createdAt", "updatedAt")
|
||||
VALUES (gen_random_uuid(), $1, $2, $3, true, NOW(), NOW())""",
|
||||
cot_id, nivel, precio_bp,
|
||||
)
|
||||
|
||||
return {"cotizacion_id": str(cot_id), "numero": numero, "estado": "borrador", "cliente_id": str(cliente_id)}
|
||||
|
||||
|
||||
async def _obtener_cotizacion(conn, args: dict) -> dict:
|
||||
cot = await conn.fetchrow(
|
||||
"""SELECT c.*, cl.nombre as cliente_nombre, cl.empresa as cliente_empresa,
|
||||
cl.email as cliente_email, cl.telefono as cliente_telefono
|
||||
FROM "Cotizacion" c
|
||||
LEFT JOIN "Cliente" cl ON c."clienteId" = cl.id
|
||||
WHERE c.id = $1""",
|
||||
args["cotizacion_id"],
|
||||
)
|
||||
if not cot:
|
||||
return {"error": "Cotización no encontrada"}
|
||||
|
||||
servicios = await conn.fetch(
|
||||
"""SELECT sc.*, s.nombre as servicio_nombre, s.fase as servicio_fase, s."tipoPago" as "servicio_tipoPago"
|
||||
FROM "ServicioCotizado" sc
|
||||
LEFT JOIN "ServicioCatalogo" s ON sc."servicioCatalogoId" = s.id
|
||||
WHERE sc."cotizacionId" = $1""",
|
||||
args["cotizacion_id"],
|
||||
)
|
||||
|
||||
plan = await conn.fetchrow(
|
||||
'SELECT * FROM "PlanBucefaloCotizacion" WHERE "cotizacionId" = $1',
|
||||
args["cotizacion_id"],
|
||||
)
|
||||
|
||||
result = dict(cot)
|
||||
result["cliente"] = {
|
||||
"nombre": cot["cliente_nombre"],
|
||||
"empresa": cot["cliente_empresa"],
|
||||
"email": cot["cliente_email"],
|
||||
"telefono": cot["cliente_telefono"],
|
||||
}
|
||||
result["servicios"] = [dict(s) for s in servicios]
|
||||
result["planBucefalo"] = dict(plan) if plan else None
|
||||
|
||||
for k in ["cliente_nombre", "cliente_empresa", "cliente_email", "cliente_telefono"]:
|
||||
result.pop(k, None)
|
||||
|
||||
return result
|
||||
|
||||
|
||||
async def _listar_cotizaciones(conn, args: dict) -> dict:
|
||||
conditions = []
|
||||
params = []
|
||||
idx = 1
|
||||
|
||||
if args.get("estado"):
|
||||
conditions.append(f'c.estado = ${idx}')
|
||||
params.append(args["estado"])
|
||||
idx += 1
|
||||
if args.get("cliente_nombre"):
|
||||
conditions.append(f'LOWER(cl.nombre) LIKE LOWER(${idx})')
|
||||
params.append(f"%{args['cliente_nombre']}%")
|
||||
idx += 1
|
||||
if args.get("busqueda"):
|
||||
conditions.append(
|
||||
f'(LOWER(c.numero) LIKE LOWER(${idx}) OR LOWER(c.proyecto) LIKE LOWER(${idx}) OR LOWER(cl.nombre) LIKE LOWER(${idx}))'
|
||||
)
|
||||
params.append(f"%{args['busqueda']}%")
|
||||
idx += 1
|
||||
|
||||
where = "WHERE " + " AND ".join(conditions) if conditions else ""
|
||||
query = f"""SELECT c.id, c.numero, c.fecha, c.vigencia, c.estado, c.proyecto,
|
||||
c.moneda, c."esquemaPago",
|
||||
cl.nombre as cliente_nombre, cl.empresa as cliente_empresa
|
||||
FROM "Cotizacion" c
|
||||
LEFT JOIN "Cliente" cl ON c."clienteId" = cl.id
|
||||
{where}
|
||||
ORDER BY c."createdAt" DESC
|
||||
LIMIT 50"""
|
||||
|
||||
rows = await conn.fetch(query, *params)
|
||||
cotizaciones = []
|
||||
for r in rows:
|
||||
d = dict(r)
|
||||
d["cliente"] = {"nombre": d.pop("cliente_nombre"), "empresa": d.pop("cliente_empresa")}
|
||||
cotizaciones.append(d)
|
||||
|
||||
return {"cotizaciones": cotizaciones, "total": len(cotizaciones)}
|
||||
|
||||
|
||||
async def _cambiar_estado(conn, args: dict) -> dict:
|
||||
cot_id = args["cotizacion_id"]
|
||||
estado = args["estado"]
|
||||
|
||||
cot = await conn.fetchrow('SELECT id FROM "Cotizacion" WHERE id = $1', cot_id)
|
||||
if not cot:
|
||||
return {"error": "Cotización no encontrada"}
|
||||
|
||||
await conn.execute('UPDATE "Cotizacion" SET estado = $1, "updatedAt" = NOW() WHERE id = $2', estado, cot_id)
|
||||
return {"ok": True, "cotizacion_id": cot_id, "nuevo_estado": estado}
|
||||
|
||||
|
||||
async def _actualizar_precio(conn, args: dict) -> dict:
|
||||
cot_id = args["cotizacion_id"]
|
||||
servicio_id = args["servicio_id"]
|
||||
nuevo_precio = args["nuevo_precio"]
|
||||
|
||||
srv = await conn.fetchrow(
|
||||
'SELECT id FROM "ServicioCotizado" WHERE id = $1 AND "cotizacionId" = $2',
|
||||
servicio_id, cot_id,
|
||||
)
|
||||
if not srv:
|
||||
return {"error": "Servicio no encontrado en esta cotización"}
|
||||
|
||||
await conn.execute(
|
||||
'UPDATE "ServicioCotizado" SET precio = $1, "updatedAt" = NOW() WHERE id = $2',
|
||||
nuevo_precio, servicio_id,
|
||||
)
|
||||
return {"ok": True, "servicio_id": servicio_id, "nuevo_precio": nuevo_precio}
|
||||
|
||||
|
||||
async def _duplicar_cotizacion(conn, args: dict) -> dict:
|
||||
cot_id = args["cotizacion_id"]
|
||||
|
||||
original = await conn.fetchrow('SELECT * FROM "Cotizacion" WHERE id = $1', cot_id)
|
||||
if not original:
|
||||
return {"error": "Cotización no encontrada"}
|
||||
|
||||
now = datetime.now()
|
||||
new_numero = f"{original['numero']}-COPY"
|
||||
|
||||
async with conn.transaction():
|
||||
new_cot = await conn.fetchrow(
|
||||
"""INSERT INTO "Cotizacion" (id, numero, fecha, vigencia, moneda, "tipoCambio", proyecto, "esquemaPago",
|
||||
estado, "incluirBonos", "incluirFinanciamiento", "esDoble", "opcionesMetadata", observaciones, "clienteId", "asesorId", "createdAt", "updatedAt")
|
||||
VALUES (gen_random_uuid(), $1, $2, $3, $4, $5, $6, $7, 'borrador', $8, $9, $10, $11, $12, $13, $14, NOW(), NOW())
|
||||
RETURNING id, numero""",
|
||||
new_numero, now, original["vigencia"], original["moneda"], original["tipoCambio"],
|
||||
original["proyecto"], original["esquemaPago"], original["incluirBonos"],
|
||||
original["incluirFinanciamiento"], original["esDoble"], original["opcionesMetadata"],
|
||||
original["observaciones"], original["clienteId"], original["asesorId"],
|
||||
)
|
||||
new_id = new_cot["id"]
|
||||
|
||||
servicios = await conn.fetch(
|
||||
'SELECT * FROM "ServicioCotizado" WHERE "cotizacionId" = $1', cot_id
|
||||
)
|
||||
for s in servicios:
|
||||
await conn.fetchrow(
|
||||
"""INSERT INTO "ServicioCotizado" (id, "cotizacionId", "servicioCatalogoId", fase, "tipoPago",
|
||||
precio, "tiempoEntrega", entregables, notas, opcion, seleccionado, "createdAt", "updatedAt")
|
||||
VALUES (gen_random_uuid(), $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, NOW(), NOW())""",
|
||||
new_id, s["servicioCatalogoId"], s["fase"], s["tipoPago"],
|
||||
s["precio"], s["tiempoEntrega"], s["entregables"], s["notas"], s["opcion"], s["seleccionado"],
|
||||
)
|
||||
|
||||
plan = await conn.fetchrow(
|
||||
'SELECT * FROM "PlanBucefaloCotizacion" WHERE "cotizacionId" = $1', cot_id
|
||||
)
|
||||
if plan:
|
||||
await conn.fetchrow(
|
||||
"""INSERT INTO "PlanBucefaloCotizacion" (id, "cotizacionId", nivel, precio, seleccionado, "createdAt", "updatedAt")
|
||||
VALUES (gen_random_uuid(), $1, $2, $3, $4, NOW(), NOW())""",
|
||||
new_id, plan["nivel"], plan["precio"], plan["seleccionado"],
|
||||
)
|
||||
|
||||
return {"cotizacion_id": str(new_id), "numero": new_numero, "estado": "borrador"}
|
||||
|
||||
|
||||
async def _calcular_financiamiento(args: dict) -> dict:
|
||||
monto = args["monto"]
|
||||
meses = args["meses"]
|
||||
|
||||
plan = next((p for p in FINANCIAMIENTO_PLANES if p["meses"] == meses), None)
|
||||
if not plan:
|
||||
from app.services.calculators import FINANCIAMIENTO_PLANES
|
||||
plan = next((p for p in FINANCIAMIENTO_PLANES if p["meses"] == meses), None)
|
||||
|
||||
if not plan:
|
||||
return {"error": f"Plan de {meses} meses no disponible"}
|
||||
|
||||
result = calcular_financiamiento(monto, meses, plan["tasa"], plan["comision"])
|
||||
result["meses"] = meses
|
||||
result["tasa"] = plan["tasa"]
|
||||
result["comision"] = plan["comision"]
|
||||
return result
|
||||
|
||||
|
||||
async def _generar_pdf(conn, args: dict) -> dict:
|
||||
cot_id = args["cotizacion_id"]
|
||||
cot = await conn.fetchrow(
|
||||
"""SELECT c.*, cl.nombre as cliente_nombre, cl.empresa as cliente_empresa
|
||||
FROM "Cotizacion" c
|
||||
LEFT JOIN "Cliente" cl ON c."clienteId" = cl.id
|
||||
WHERE c.id = $1""",
|
||||
cot_id,
|
||||
)
|
||||
if not cot:
|
||||
return {"error": "Cotización no encontrada"}
|
||||
|
||||
return {
|
||||
"status": "pdf_generated",
|
||||
"cotizacion_id": cot_id,
|
||||
"numero": cot["numero"],
|
||||
"filename": f"{cot['cliente_nombre']} - {cot['numero']}.pdf",
|
||||
"message": "PDF generation will be implemented with reportlab",
|
||||
}
|
||||
|
||||
|
||||
async def _obtener_configuracion(conn) -> dict:
|
||||
rows = await conn.fetch('SELECT clave, valor FROM "Configuracion"')
|
||||
return {"config": {r["clave"]: r["valor"] for r in rows}}
|
||||
|
||||
|
||||
from app.services.calculators import FINANCIAMIENTO_PLANES
|
||||
@@ -1,305 +0,0 @@
|
||||
"""MCP (Model Context Protocol) tool definitions for the Cotizador API.
|
||||
|
||||
Each tool is designed to be semantically clear for AI agents like OpenClaw, Claude, and ChatGPT.
|
||||
"""
|
||||
|
||||
TOOLS = [
|
||||
{
|
||||
"name": "buscar_servicios",
|
||||
"description": (
|
||||
"Busca servicios del catálogo de marketing digital de Consultoría E3. "
|
||||
"Útil cuando el cliente pregunta por servicios disponibles, precios, o por fase del proyecto. "
|
||||
"Las fases son: 0=Auditoría (diagnóstico inicial), 1=Setup (infraestructura y configuración), "
|
||||
"2=Publicidad (anuncios y manejo de redes), 3=Contenido/SEO (producción de contenido y posicionamiento). "
|
||||
"Tipos de pago: 'unico' (pago único) o 'mensual' (recurso recurrente)."
|
||||
),
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"fase": {
|
||||
"type": "integer",
|
||||
"enum": [0, 1, 2, 3],
|
||||
"description": "Fase del proyecto: 0=Auditoría/Acompañamiento, 1=Setup/Infraestructura, 2=Publicidad/Manejo, 3=Contenido/SEO",
|
||||
},
|
||||
"tipo_pago": {
|
||||
"type": "string",
|
||||
"enum": ["unico", "mensual"],
|
||||
"description": "Tipo de pago: 'unico' para pago único, 'mensual' para recurrente",
|
||||
},
|
||||
"categoria": {
|
||||
"type": "string",
|
||||
"description": "Nombre de categoría: SEO, Marketing, Paid Media, Desarrollo Web, Automatizaciones, CRM, Desarrollo Personalizado",
|
||||
},
|
||||
"busqueda": {
|
||||
"type": "string",
|
||||
"description": "Texto libre para buscar en nombre y descripción del servicio",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
"name": "crear_cotizacion",
|
||||
"description": (
|
||||
"Crea una cotización completa de servicios de marketing digital para un cliente. "
|
||||
"El cliente se crea automáticamente si no existe (busca por nombre+empresa). "
|
||||
"Incluye servicios del catálogo con precios personalizables, plan CRM Bucefalo opcional, "
|
||||
"y configuración de moneda y esquema de pago. "
|
||||
"La cotización se crea en estado 'borrador'. "
|
||||
"Precios CRM Bucefalo: basico=$1,000/mes, estandar=$3,500/mes, premium=$4,500/mes, empresarial=$7,500/mes. "
|
||||
"Soporta DOBLE PROPUESTA: con es_doble=true se presentan dos opciones comparables; cada servicio "
|
||||
"se asigna a la opción '1', '2' o 'ambas' (compartido), y opciones_metadata define el título, "
|
||||
"descripción y exclusiones de cada opción."
|
||||
),
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"cliente": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"nombre": {"type": "string", "description": "Nombre completo del contacto"},
|
||||
"empresa": {"type": "string", "description": "Nombre de la empresa (opcional)"},
|
||||
"email": {"type": "string", "description": "Email de contacto"},
|
||||
"telefono": {"type": "string", "description": "Teléfono de contacto"},
|
||||
},
|
||||
"required": ["nombre"],
|
||||
},
|
||||
"servicios": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"servicio_id": {"type": "string", "description": "ID del servicio del catálogo (obtener con buscar_servicios)"},
|
||||
"precio_personalizado": {"type": "number", "description": "Precio personalizado (opcional, usa precio base si no se especifica)"},
|
||||
"opcion": {"type": "string", "enum": ["1", "2", "ambas"], "description": "Solo en doble propuesta: opción a la que pertenece el servicio ('ambas' = compartido). Default 'ambas'."},
|
||||
},
|
||||
"required": ["servicio_id"],
|
||||
},
|
||||
"description": "Lista de servicios a incluir en la cotización",
|
||||
},
|
||||
"es_doble": {
|
||||
"type": "boolean",
|
||||
"description": "Si es true, la cotización presenta dos opciones comparables (doble propuesta).",
|
||||
},
|
||||
"opciones_metadata": {
|
||||
"type": "object",
|
||||
"description": "Solo en doble propuesta. Metadatos por opción, p.ej. {\"1\": {\"titulo\": \"...\", \"descripcion\": \"...\", \"noIncluye\": \"...\"}, \"2\": {...}}.",
|
||||
"properties": {
|
||||
"1": {"type": "object", "properties": {"titulo": {"type": "string"}, "descripcion": {"type": "string"}, "noIncluye": {"type": "string"}}},
|
||||
"2": {"type": "object", "properties": {"titulo": {"type": "string"}, "descripcion": {"type": "string"}, "noIncluye": {"type": "string"}}},
|
||||
},
|
||||
},
|
||||
"plan_bucefalo": {
|
||||
"type": "string",
|
||||
"enum": ["basico", "estandar", "premium", "empresarial"],
|
||||
"description": "Nivel del plan CRM Bucefalo (opcional)",
|
||||
},
|
||||
"proyecto": {
|
||||
"type": "string",
|
||||
"description": "Nombre o descripción del proyecto (default: 'MKT Digital')",
|
||||
},
|
||||
"moneda": {
|
||||
"type": "string",
|
||||
"enum": ["MXN", "USD"],
|
||||
"description": "Moneda de la cotización (default: MXN)",
|
||||
},
|
||||
"esquema_pago": {
|
||||
"type": "string",
|
||||
"enum": ["Pago Unico", "Mensual", "Pago Unico/Mensual"],
|
||||
"description": "Esquema de pago (default: Pago Unico/Mensual)",
|
||||
},
|
||||
},
|
||||
"required": ["cliente", "servicios"],
|
||||
},
|
||||
},
|
||||
{
|
||||
"name": "obtener_cotizacion",
|
||||
"description": (
|
||||
"Obtiene los detalles completos de una cotización existente incluyendo: "
|
||||
"datos del cliente, servicios seleccionados con precios, estado actual, "
|
||||
"plan CRM Bucefalo si aplica, observaciones, fechas y vigencia."
|
||||
),
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"cotizacion_id": {"type": "string", "description": "ID de la cotización"},
|
||||
},
|
||||
"required": ["cotizacion_id"],
|
||||
},
|
||||
},
|
||||
{
|
||||
"name": "listar_cotizaciones",
|
||||
"description": (
|
||||
"Lista cotizaciones con filtros opcionales. "
|
||||
"Útil para revisar el pipeline de ventas, cotizaciones pendientes, o historial de un cliente. "
|
||||
"Estados: borrador (en proceso), enviada (esperando respuesta), aprobada (cerrada ganada), rechazada (cerrada perdida)."
|
||||
),
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"estado": {
|
||||
"type": "string",
|
||||
"enum": ["borrador", "enviada", "aprobada", "rechazada"],
|
||||
"description": "Filtrar por estado",
|
||||
},
|
||||
"cliente_nombre": {
|
||||
"type": "string",
|
||||
"description": "Buscar por nombre de cliente",
|
||||
},
|
||||
"busqueda": {
|
||||
"type": "string",
|
||||
"description": "Texto libre para buscar en número, proyecto o cliente",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
"name": "cambiar_estado_cotizacion",
|
||||
"description": (
|
||||
"Cambia el estado de una cotización. "
|
||||
"Flujo normal: borrador → enviada → aprobada o rechazada. "
|
||||
"Solo cambiar a 'enviada' cuando la cotización esté lista para el cliente. "
|
||||
"Cambiar a 'aprobada' cuando el cliente acepte, o 'rechazada' cuando decline."
|
||||
),
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"cotizacion_id": {"type": "string", "description": "ID de la cotización"},
|
||||
"estado": {
|
||||
"type": "string",
|
||||
"enum": ["borrador", "enviada", "aprobada", "rechazada"],
|
||||
"description": "Nuevo estado de la cotización",
|
||||
},
|
||||
},
|
||||
"required": ["cotizacion_id", "estado"],
|
||||
},
|
||||
},
|
||||
{
|
||||
"name": "actualizar_precio_servicio",
|
||||
"description": (
|
||||
"Actualiza el precio de un servicio específico dentro de una cotización. "
|
||||
"No modifica el precio base del catálogo, solo el precio en esta cotización. "
|
||||
"Útil para negociar precios individuales sin recrear toda la cotización."
|
||||
),
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"cotizacion_id": {"type": "string", "description": "ID de la cotización"},
|
||||
"servicio_id": {"type": "string", "description": "ID del servicio cotizado (no el del catálogo)"},
|
||||
"nuevo_precio": {"type": "number", "description": "Nuevo precio en la moneda de la cotización"},
|
||||
},
|
||||
"required": ["cotizacion_id", "servicio_id", "nuevo_precio"],
|
||||
},
|
||||
},
|
||||
{
|
||||
"name": "duplicar_cotizacion",
|
||||
"description": (
|
||||
"Duplica una cotización existente como nueva copia en estado 'borrador'. "
|
||||
"Crea una copia exacta con nuevo ID y número. "
|
||||
"Útil para crear variaciones de una propuesta o reenviar una cotización actualizada."
|
||||
),
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"cotizacion_id": {"type": "string", "description": "ID de la cotización a duplicar"},
|
||||
},
|
||||
"required": ["cotizacion_id"],
|
||||
},
|
||||
},
|
||||
{
|
||||
"name": "calcular_financiamiento",
|
||||
"description": (
|
||||
"Calcula las mensualidades para financiar una cotización o monto específico. "
|
||||
"Plazos disponibles: 3 meses (7.7% tasa), 6 meses (10.7%), 9 meses (13.7%), 12 meses (16.7%). "
|
||||
"Todos incluyen 2.5% de comisión + 16% IVA. "
|
||||
"Devuelve: pago mensual, IVA mensual, total mensual, comisión total, y gran total."
|
||||
),
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"monto": {"type": "number", "description": "Monto total a financiar en MXN"},
|
||||
"meses": {"type": "integer", "enum": [3, 6, 9, 12], "description": "Plazo en meses"},
|
||||
},
|
||||
"required": ["monto", "meses"],
|
||||
},
|
||||
},
|
||||
{
|
||||
"name": "generar_pdf_cotizacion",
|
||||
"description": (
|
||||
"Genera un PDF profesional de una cotización con: logo de la empresa, colores de marca, "
|
||||
"tabla de servicios agrupados por fase, bonos incluidos, términos y condiciones, "
|
||||
"y datos bancarios para transferencia. Devuelve el archivo PDF."
|
||||
),
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"cotizacion_id": {"type": "string", "description": "ID de la cotización guardada"},
|
||||
},
|
||||
"required": ["cotizacion_id"],
|
||||
},
|
||||
},
|
||||
{
|
||||
"name": "obtener_configuracion",
|
||||
"description": (
|
||||
"Obtiene la configuración de la empresa Consultoría E3: "
|
||||
"razón social, RFC, domicilio fiscal, datos bancarios (cuenta nacional, CLABE, cuenta internacional, SWIFT), "
|
||||
"colores de marca, logo, y términos y condiciones. "
|
||||
"Útil para generar documentos o verificar información fiscal."
|
||||
),
|
||||
"inputSchema": {"type": "object", "properties": {}},
|
||||
},
|
||||
{
|
||||
"name": "listar_bonos",
|
||||
"description": (
|
||||
"Lista los bonos/disponibles que se pueden incluir en una cotización: "
|
||||
"1) Servicio Centinela Web (monitoreo 30 min/mes), "
|
||||
"2) Workshop Buyer Persona, "
|
||||
"3) Workshop Propuesta de Valor, "
|
||||
"4) Membresía Premium (1 año), "
|
||||
"5) Mes Gratis CRM Bucefalo, "
|
||||
"6) Script de Ventas (100+ complementos)."
|
||||
),
|
||||
"inputSchema": {"type": "object", "properties": {}},
|
||||
},
|
||||
{
|
||||
"name": "listar_planes_bucefalo",
|
||||
"description": (
|
||||
"Lista los niveles del CRM Bucefalo con precios mensuales: "
|
||||
"Básico ($1,000/mes), Estándar ($3,500/mes), Premium ($4,500/mes), Empresarial ($7,500/mes). "
|
||||
"Bucefalo es un CRM para gestión de ventas y clientes."
|
||||
),
|
||||
"inputSchema": {"type": "object", "properties": {}},
|
||||
},
|
||||
]
|
||||
|
||||
RESOURCES = [
|
||||
{
|
||||
"uri": "cotizador://servicios",
|
||||
"name": "Catálogo de Servicios",
|
||||
"description": (
|
||||
"Lista completa de servicios de marketing digital de Consultoría E3 organizados por fase: "
|
||||
"Fase 0 (Auditorías), Fase 1 (Setup/Infraestructura), Fase 2 (Publicidad/Manejo), "
|
||||
"Fase 3 (Contenido/SEO). Cada servicio incluye nombre, descripción, precio base, "
|
||||
"tiempo de entrega, tipo de pago (único/mensual), y entregables."
|
||||
),
|
||||
"mimeType": "application/json",
|
||||
},
|
||||
{
|
||||
"uri": "cotizador://categorias",
|
||||
"name": "Categorías de Servicios",
|
||||
"description": (
|
||||
"Categorías disponibles para clasificar servicios: "
|
||||
"SEO, Marketing, Paid Media, Desarrollo Web, Automatizaciones, CRM, Desarrollo Personalizado."
|
||||
),
|
||||
"mimeType": "application/json",
|
||||
},
|
||||
{
|
||||
"uri": "cotizador://configuracion",
|
||||
"name": "Configuración de la Empresa",
|
||||
"description": (
|
||||
"Datos fiscales, bancarios y de marca de Consultoría E3. "
|
||||
"Incluye razón social, RFC, domicilio fiscal, cuentas bancarias nacionales e internacionales, "
|
||||
"colores de marca, logo, y términos y condiciones."
|
||||
),
|
||||
"mimeType": "application/json",
|
||||
},
|
||||
]
|
||||
+9
-29
@@ -1,7 +1,7 @@
|
||||
"""Cotizador E3 — FastAPI Application
|
||||
|
||||
REST API + MCP Server for digital marketing quotation management.
|
||||
Optimized for n8n workflows and AI agents (OpenClaw, Claude, ChatGPT).
|
||||
REST API for digital marketing quotation management.
|
||||
Optimized for n8n workflows and other integrations.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -28,8 +28,8 @@ app = FastAPI(
|
||||
title="Cotizador E3 API",
|
||||
description=(
|
||||
"API REST para el sistema de cotizaciones de marketing digital de Consultoría E3. "
|
||||
"Optimizada para integración con n8n y agentes de IA (OpenClaw, Claude, ChatGPT) "
|
||||
"via MCP (Model Context Protocol)."
|
||||
"Optimizada para integración con n8n y otros consumidores. "
|
||||
"Autenticación por X-API-Key o Bearer JWT."
|
||||
),
|
||||
version="1.0.0",
|
||||
lifespan=lifespan,
|
||||
@@ -98,30 +98,11 @@ app.include_router(financiamiento.router)
|
||||
app.include_router(export_.router)
|
||||
app.include_router(import_.router)
|
||||
|
||||
# Mount MCP server
|
||||
try:
|
||||
from app.mcp.server import server as mcp_server
|
||||
|
||||
from mcp.server.streamable_http import StreamableHTTPServerTransport
|
||||
|
||||
@app.post("/mcp")
|
||||
async def mcp_endpoint(request: Request):
|
||||
"""MCP (Model Context Protocol) endpoint for AI agents."""
|
||||
transport = StreamableHTTPServerTransport(mcp_server)
|
||||
return await transport.handle_request(request)
|
||||
|
||||
@app.get("/mcp")
|
||||
async def mcp_info():
|
||||
"""MCP server info. Use POST for actual MCP communication."""
|
||||
return {
|
||||
"name": "cotizador-e3",
|
||||
"version": "1.0.0",
|
||||
"protocol": "mcp",
|
||||
"description": "MCP server for Cotizador E3 quotation system",
|
||||
}
|
||||
except ImportError:
|
||||
# MCP SDK not installed, skip MCP mount
|
||||
pass
|
||||
# El servidor MCP se retiro (2026-07-28). No se estaba usando, su transporte
|
||||
# llevaba tiempo roto (instanciaba un StreamableHTTPServerTransport por peticion,
|
||||
# sin manejo de sesion, y devolvia 500 con credencial valida) y su SDK sin fijar
|
||||
# tumbo el API entero en produccion al saltar a 2.0.0. Si algun dia se retoma,
|
||||
# el codigo esta en el historial: `git show edb500f5:api/app/mcp/server.py`.
|
||||
|
||||
|
||||
@app.get("/", include_in_schema=False)
|
||||
@@ -132,7 +113,6 @@ async def root():
|
||||
"docs": "/docs",
|
||||
"openapi": "/openapi.json",
|
||||
"health": "/health",
|
||||
"mcp": "/mcp",
|
||||
}
|
||||
|
||||
|
||||
|
||||
+30
-12
@@ -1,12 +1,30 @@
|
||||
fastapi>=0.115.0
|
||||
uvicorn[standard]>=0.34.0
|
||||
asyncpg>=0.30.0
|
||||
pydantic>=2.0
|
||||
pydantic-settings>=2.0
|
||||
python-jose[cryptography]>=3.3.0
|
||||
passlib[bcrypt]>=1.7.4
|
||||
python-multipart>=0.0.18
|
||||
reportlab>=4.0
|
||||
openpyxl>=3.1.0
|
||||
mcp>=1.0.0
|
||||
httpx>=0.27.0
|
||||
# Versiones FIJAS a proposito.
|
||||
#
|
||||
# Por que: el 2026-07-28 una reconstruccion del API tomo mcp 2.0.0 (el rango era
|
||||
# `mcp>=1.0.0`), que elimino Server.list_tools(). El import lanzo AttributeError
|
||||
# al arrancar y dejo el contenedor en crash-loop ~50 minutos. Once de las doce
|
||||
# dependencias eran rangos `>=` sin techo, o sea que cada build era una tirada de
|
||||
# dados contra PyPI: `pydantic>=2.0` habria aceptado pydantic 3 igual de alegre.
|
||||
#
|
||||
# Estas versiones son exactamente las que corrian sanas en produccion cuando se
|
||||
# fijaron (capturadas con `pip freeze` del contenedor healthy).
|
||||
#
|
||||
# Para subir una dependencia: cambiala aqui a proposito, reconstruye y prueba.
|
||||
# Nunca por accidente al redesplegar.
|
||||
#
|
||||
# Limitacion conocida: esto fija las dependencias DIRECTAS. Las transitivas
|
||||
# (starlette, cryptography, anyio...) las sigue resolviendo pip. Es un riesgo
|
||||
# mucho menor, pero si algun dia muerde, el siguiente paso es un lock completo
|
||||
# con pip-tools o uv.
|
||||
|
||||
fastapi==0.140.13
|
||||
uvicorn[standard]==0.51.0
|
||||
asyncpg==0.31.0
|
||||
pydantic==2.13.4
|
||||
pydantic-settings==2.14.2
|
||||
python-jose[cryptography]==3.5.0
|
||||
passlib[bcrypt]==1.7.4
|
||||
python-multipart==0.0.32
|
||||
reportlab==5.0.0
|
||||
openpyxl==3.1.5
|
||||
httpx==0.28.1
|
||||
|
||||
+113
@@ -0,0 +1,113 @@
|
||||
/**
|
||||
* Caza del error intermitente: corre el pipeline real contra UJ2606UR001 hasta que
|
||||
* falle, e imprime TODO lo que sepamos de la peticion que lo provoco.
|
||||
*/
|
||||
import { cargarEconomia } from "@/lib/propuesta/economia";
|
||||
import { crearCliente, modelo } from "@/lib/propuesta/cliente-ia";
|
||||
import { hechosSchema, diagnosticoSchema, redaccionSchema, aJsonSchema, type Hechos, type Diagnostico } from "@/lib/propuesta/schemas";
|
||||
import { SYSTEM_BASE, mensajePaso1, mensajePaso2, mensajePaso3, type ContextoEntrada } from "@/lib/propuesta/prompts";
|
||||
import { prisma } from "@/lib/db";
|
||||
import type Anthropic from "@anthropic-ai/sdk";
|
||||
import type { z } from "zod";
|
||||
import fs from "node:fs";
|
||||
|
||||
const LOG = process.argv[2];
|
||||
// Escritura directa: el buffer de stdout se pierde si el proceso muere.
|
||||
function log(...a: unknown[]) {
|
||||
const linea = a.map((x) => (typeof x === "string" ? x : JSON.stringify(x))).join(" ");
|
||||
fs.appendFileSync(LOG, linea + "\n");
|
||||
}
|
||||
const console = { log } as unknown as Console;
|
||||
|
||||
const NUMERO = "UJ2606UR001";
|
||||
const TRANSCRIPCION = "Una propuesta de zero to hero para un negocio inicial";
|
||||
|
||||
/** Igual que llamarConHerramienta pero registra cada peticion y explota con detalle. */
|
||||
async function correrPaso(nombre: string, msg: string, schema: z.ZodType, maxTokens: number, maxIntentos: number) {
|
||||
const cliente = crearCliente();
|
||||
const tools = [{ name: nombre, description: "Registra el resultado.", input_schema: aJsonSchema(schema) as never }];
|
||||
const mensajes: Anthropic.MessageParam[] = [{ role: "user", content: msg }];
|
||||
|
||||
for (let intento = 1; intento <= maxIntentos; intento++) {
|
||||
let res: Anthropic.Message;
|
||||
try {
|
||||
res = await cliente.messages.create({
|
||||
model: modelo(), max_tokens: maxTokens,
|
||||
system: [{ type: "text", text: SYSTEM_BASE, cache_control: { type: "ephemeral" } }],
|
||||
tools, messages: mensajes,
|
||||
});
|
||||
} catch (e) {
|
||||
const err = e as { status?: number; message?: string; error?: unknown };
|
||||
console.log(`\n*** ERROR EN ${nombre} intento ${intento} ***`);
|
||||
console.log(" status:", err.status);
|
||||
console.log(" message:", String(err.message).slice(0, 600));
|
||||
if (err.error) console.log(" error:", JSON.stringify(err.error).slice(0, 800));
|
||||
console.log("\n --- FORMA DE LOS MENSAJES ENVIADOS ---");
|
||||
mensajes.forEach((m, i) => {
|
||||
const c = m.content;
|
||||
const tipos = typeof c === "string" ? "string" : (c as { type: string }[]).map((b) => b.type).join(",");
|
||||
console.log(` [${i}] role=${m.role} bloques=${tipos}`);
|
||||
});
|
||||
throw new Error("REPRODUCIDO");
|
||||
}
|
||||
|
||||
const bloques = res.content.map((b) => b.type).join(",");
|
||||
console.log(` ${nombre} intento ${intento}: stop=${res.stop_reason} bloques=[${bloques}] out=${res.usage.output_tokens}`);
|
||||
|
||||
const tus = res.content.filter((b): b is Anthropic.ToolUseBlock => b.type === "tool_use");
|
||||
const ok = tus.find((b) => b.name === nombre);
|
||||
if (ok) {
|
||||
const parsed = schema.safeParse(ok.input);
|
||||
if (parsed.success) return parsed.data;
|
||||
const errTxt = (await import("zod")).z.prettifyError(parsed.error);
|
||||
console.log(` zod rechazo: ${errTxt.split("\n")[0]}`);
|
||||
mensajes.push(
|
||||
{ role: "assistant", content: res.content },
|
||||
{ role: "user", content: [
|
||||
...tus.map((b) => ({ type: "tool_result" as const, tool_use_id: b.id, is_error: true, content: errTxt })),
|
||||
{ type: "text" as const, text: "Corrige y reintenta." },
|
||||
] },
|
||||
);
|
||||
continue;
|
||||
}
|
||||
mensajes.push(
|
||||
{ role: "assistant", content: res.content },
|
||||
{ role: "user", content: `Debes llamar a ${nombre}.` },
|
||||
);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
async function unaVuelta(entrada: ContextoEntrada, econ: Awaited<ReturnType<typeof cargarEconomia>>, n: number) {
|
||||
console.log(`\n===== VUELTA ${n} =====`);
|
||||
const h = (await correrPaso("registrar_hechos", mensajePaso1(entrada), hechosSchema, 8000, 5)) as Hechos | null;
|
||||
if (!h) { console.log(" extraccion agoto intentos"); return; }
|
||||
const d = (await correrPaso("registrar_diagnostico", mensajePaso2(entrada, h, econ), diagnosticoSchema, 8000, 4)) as Diagnostico | null;
|
||||
if (!d) { console.log(" diagnostico agoto intentos"); return; }
|
||||
const r = await correrPaso("registrar_propuesta", mensajePaso3(entrada, h, d, econ), redaccionSchema, 12000, 4);
|
||||
console.log(r ? " vuelta completa OK" : " redaccion agoto intentos");
|
||||
}
|
||||
|
||||
async function main() {
|
||||
const cot = await prisma.cotizacion.findFirst({ where: { numero: NUMERO }, include: { cliente: true, servicios: true } });
|
||||
if (!cot) throw new Error("no encontrada");
|
||||
const econ = await cargarEconomia(cot.id);
|
||||
const entrada: ContextoEntrada = {
|
||||
transcripcion: TRANSCRIPCION,
|
||||
notas: cot.servicios.map((s) => s.notas).filter(Boolean).join("\n"),
|
||||
observaciones: cot.observaciones || "",
|
||||
cliente: cot.cliente.nombre, empresa: cot.cliente.empresa || "", proyecto: cot.proyecto,
|
||||
};
|
||||
console.log(`${econ.partidas.length} partidas`);
|
||||
|
||||
for (let i = 1; i <= 3; i++) {
|
||||
try { await unaVuelta(entrada, econ, i); }
|
||||
catch (e) {
|
||||
if (e instanceof Error && e.message === "REPRODUCIDO") { console.log("\n>>> error reproducido, deteniendo"); break; }
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
await prisma.$disconnect();
|
||||
}
|
||||
|
||||
main().catch((e) => { console.error("fallo:", e); process.exit(1); });
|
||||
@@ -40,6 +40,13 @@ services:
|
||||
# Solo la usa el CLI de Prisma (migrate deploy); debe coincidir con DB_*
|
||||
- DATABASE_URL=postgresql://${DB_USER:-postgres}:${DB_PASSWORD:-postgres}@postgres:5432/${DB_NAME:-cotizador_e3}
|
||||
- JWT_SECRET=${JWT_SECRET}
|
||||
# Propuesta consultiva con IA (MiniMax). Sin MINIMAX_API_KEY el boton de
|
||||
# generar devuelve un error claro; el resto de la app funciona igual.
|
||||
# OJO: el prefijo NO puede ser ANTHROPIC_*, el SDK lo lee por su cuenta y
|
||||
# mandaria la clave de MiniMax a api.anthropic.com.
|
||||
- MINIMAX_API_KEY=${MINIMAX_API_KEY}
|
||||
- MINIMAX_BASE_URL=${MINIMAX_BASE_URL:-https://api.minimax.io/anthropic}
|
||||
- MINIMAX_MODEL=${MINIMAX_MODEL:-MiniMax-M3}
|
||||
# Seed inicial: pon RUN_SEED=true solo en el primer despliegue
|
||||
- RUN_SEED=${RUN_SEED:-false}
|
||||
- SEED_ADMIN_EMAIL=${SEED_ADMIN_EMAIL:[email protected]}
|
||||
|
||||
@@ -40,6 +40,13 @@ services:
|
||||
# Solo la usa el CLI de Prisma (migrate deploy); debe coincidir con DB_*
|
||||
- DATABASE_URL=postgresql://${DB_USER:-postgres}:${DB_PASSWORD:-postgres}@postgres:5432/${DB_NAME:-cotizador_e3}
|
||||
- JWT_SECRET=${JWT_SECRET}
|
||||
# Propuesta consultiva con IA (MiniMax). Sin MINIMAX_API_KEY el boton de
|
||||
# generar devuelve un error claro; el resto de la app funciona igual.
|
||||
# OJO: el prefijo NO puede ser ANTHROPIC_*, el SDK lo lee por su cuenta y
|
||||
# mandaria la clave de MiniMax a api.anthropic.com.
|
||||
- MINIMAX_API_KEY=${MINIMAX_API_KEY}
|
||||
- MINIMAX_BASE_URL=${MINIMAX_BASE_URL:-https://api.minimax.io/anthropic}
|
||||
- MINIMAX_MODEL=${MINIMAX_MODEL:-MiniMax-M3}
|
||||
# Seed inicial: pon RUN_SEED=true solo en el primer despliegue
|
||||
- RUN_SEED=${RUN_SEED:-false}
|
||||
- SEED_ADMIN_EMAIL=${SEED_ADMIN_EMAIL:[email protected]}
|
||||
|
||||
@@ -0,0 +1,859 @@
|
||||
# Business Intelligence — Plugin de Propuesta Consultiva con IA
|
||||
|
||||
> **Qué es este documento:** el análisis de negocio, la filosofía y los lineamientos para una **futura** implementación de un plugin que, a partir de transcripciones de reuniones y notas de texto, genere un **segundo documento** de cotización — narrativo y consultivo — como complemento al documento económico que hoy produce el Cotizador E3 de forma manual.
|
||||
>
|
||||
> **Qué NO es:** una especificación técnica cerrada ni un plan de implementación. No hay código aquí. Es el mapa que debe leerse antes de escribir la primera línea.
|
||||
>
|
||||
> **Fuentes analizadas:**
|
||||
> - Proyecto real: `H:\MegaSync\Proyectos\Cotizador` (Next.js 16 + Prisma 7 + PostgreSQL, con API Python/MCP paralela)
|
||||
> - Plantilla de referencia: `D:\Documents\plantilla_cotizacion.html`
|
||||
> - Base de conocimiento: `Guia_Onboarding_Cliente_y_Ruta_de_Trabajo.md`, `08-Monetizacion-Onboarding-Pricing-Seguimiento.md`, `Onboarding-Cliente/04-Sesion-Propuesta-y-Continuidad.md`, `sintesis/s2-Pricing-Cobranza.md`, `sintesis/s8-Prompts-Plantillas.md`, `00-Guia-de-Uso-y-Checklist-Calidad.md`
|
||||
>
|
||||
> **Fecha:** 2026-07-28 · **Estado:** análisis previo a implementación
|
||||
|
||||
---
|
||||
|
||||
## 1. Resumen ejecutivo
|
||||
|
||||
El Cotizador E3 hoy resuelve muy bien **el qué y el cuánto**: un catálogo de servicios por fase, precios, IVA, financiamiento, planes Bucéfalo, exportación a PDF y Excel. Es un motor contable y comercial sólido.
|
||||
|
||||
Lo que no resuelve —y lo que la base de conocimiento identifica como el factor que multiplica el ticket entre 3x y 15x— es **el por qué**: el diagnóstico del dolor del cliente en sus propias palabras, la cuantificación del costo de no hacer nada, el anclaje del precio en el valor anual, y la narrativa que permite al cliente defender la inversión internamente.
|
||||
|
||||
Ese "por qué" ya se está capturando de forma parcial pero **se está tirando a la basura**:
|
||||
|
||||
- El campo `observaciones` de `Cotizacion` y el campo `notas` de cada `ServicioCotizado` se guardan en la base de datos y **no se imprimen ni en el PDF ni en el Excel** (verificado por búsqueda en `src/lib/pdf-generator.ts` y `src/lib/excel-builder.ts`: cero coincidencias).
|
||||
- Las reuniones de discovery generan transcripciones que hoy viven fuera del sistema.
|
||||
- La plantilla HTML de `D:\Documents\` ya tiene la estructura narrativa correcta (diagnóstico con semáforo, exclusiones explícitas, argumentos de venta, estado de materiales) pero se llena **a mano**, una por una.
|
||||
|
||||
**La oportunidad:** un plugin que lea el contexto humano disperso (transcripción + notas + observaciones + la cotización ya armada) y genere un segundo archivo —el documento consultivo— siguiendo la filosofía de la plantilla HTML, sin tocar un solo número.
|
||||
|
||||
**La tesis central, en una frase:**
|
||||
|
||||
> El documento manual es la **fuente de verdad económica**. El documento de IA es la **fuente de verdad narrativa**. La IA nunca inventa un precio; sólo explica el que ya existe.
|
||||
|
||||
---
|
||||
|
||||
## 2. Inventario: los tres activos que ya existen
|
||||
|
||||
### 2.1 El Cotizador real (`H:\MegaSync\Proyectos\Cotizador`)
|
||||
|
||||
**Stack.** Next.js 16 (App Router) + React 19 + Tailwind v4 + Zustand · Prisma 7 (cliente generado en `src/generated/prisma`, driver adapter `PrismaPg`) · PostgreSQL 16 en Docker · JWT con `jose` en cookie httpOnly · PDFKit server-side · despliegue en Coolify.
|
||||
|
||||
**Segundo backend.** Un servicio FastAPI en `api/` que expone el mismo dominio como REST **y un servidor MCP en `/mcp`** con 12 herramientas y 3 recursos para agentes de IA. Esto es el hallazgo arquitectónico más importante del inventario: **el proyecto ya tiene una superficie diseñada para que una IA lo opere.**
|
||||
|
||||
Herramientas MCP existentes: `buscar_servicios`, `crear_cotizacion`, `obtener_cotizacion`, `listar_cotizaciones`, `cambiar_estado_cotizacion`, `actualizar_precio_servicio`, `duplicar_cotizacion`, `calcular_financiamiento`, `generar_pdf_cotizacion`, `obtener_configuracion`, `listar_bonos`, `listar_planes_bucefalo`. Recursos: `cotizador://servicios`, `cotizador://categorias`, `cotizador://configuracion`.
|
||||
|
||||
**Modelo de datos relevante.**
|
||||
|
||||
| Modelo | Campos que importan para el plugin |
|
||||
|---|---|
|
||||
| `Cotizacion` | `numero`, `fecha`, `vigencia`, `moneda`, `esquemaPago`, `estado`, `esDoble`, `opcionesMetadata` (JSON), **`observaciones`** |
|
||||
| `ServicioCotizado` | `nombre`, `fase`, `tipoPago`, `precio`, `tiempoEntrega`, `entregables` (JSON), `beneficios` (JSON), **`notas`**, `modeloCobro`, `horas`, `tarifaHora`, `opcion` |
|
||||
| `ServicioCatalogo` | `precioBase`, `descripcion`, `entregablesDefault`, `fase`, `nivel`, `variante` |
|
||||
| `Cliente` | `nombre`, `empresa`, `email`, `telefono`, `rfc` |
|
||||
| `RegistroHoras` | `fecha`, rango horario, `horas`, `tarifaHora`, `descripcion`, `estadoPago` |
|
||||
| `PlanBucefaloCotizacion` | `nivel`, `precio` |
|
||||
| `FinanciamientoPlan` | `meses` (3/6/9/12), `tasa`, `comision`, `montoMinimo`, `iva` |
|
||||
| `Bono` | `numero`, `titulo`, `descripcion` |
|
||||
| `Configuracion` | key-value: `color_primario`, `color_secundario`, `logo_base64` |
|
||||
|
||||
**Reglas de negocio ya codificadas** (`src/lib/calculators.ts`):
|
||||
- `IVA_RATE = 0.16`
|
||||
- `TARIFA_HORA_DEFAULT = 700`
|
||||
- Número de cotización: `UJ{YY}{MM}{InicialesAsesor}{seq}` (ej. `UJ2605AG001`)
|
||||
- Vigencia = 15 días hábiles desde la fecha (excluye sábado y domingo)
|
||||
- 4 fases: F0 Auditoría · F1 Setup/Infra · F2 Publicidad/Manejo · F3 Contenido/SEO
|
||||
- Planes Bucéfalo mensuales: básico $1,000 · estándar $3,500 · premium $4,500 · empresarial $7,500 (hardcodeados en `calculators.ts`, **no en la BD**)
|
||||
- Modelos de cobro: `fijo`, `horas`, `retainer`, `demanda`
|
||||
- 6 paquetes PyME pre-armados + paquete "General" con todo el catálogo
|
||||
|
||||
**El hallazgo clave: `esDoble` ya existe.** El sistema soporta cotización de doble propuesta: `esDoble: boolean` + `opcionesMetadata` con estructura `{ "1": {titulo, descripcion, noIncluye}, "2": {...} }`, y cada `ServicioCotizado` puede asignarse a la opción `"1"`, `"2"` o `"ambas"`. La herramienta MCP `crear_cotizacion` ya acepta `es_doble=true`. **Ya hay una vía nativa para presentar opciones comparables** — y la base de conocimiento dice que 3 opciones cierran 16-28% más alto. Está a mitad de camino.
|
||||
|
||||
### 2.2 La plantilla HTML (`D:\Documents\plantilla_cotizacion.html`)
|
||||
|
||||
Un documento de 690 líneas, autocontenido, con tokens CSS, tipografía editorial (Playfair Display serif + DM Sans), tema oscuro (`--bg: #0a0f1e`), responsive y con reglas `@media print` (`page-break-inside: avoid`).
|
||||
|
||||
Su valor no es el CSS. Es **la arquitectura argumental**:
|
||||
|
||||
| # | Sección | Función retórica |
|
||||
|---|---|---|
|
||||
| Hero | Título + subtítulo + 4 metadatos (elaborado por / cliente / plataforma / vigencia) | Encuadre y contexto |
|
||||
| 01 | **Diagnóstico del proyecto** — un `.quote` con el insight clave + filas con semáforo (`dot-red` problema crítico, `dot-amber` área de mejora, `dot-blue` oportunidad, `dot-green` ventaja existente) | Demuestra que entendiste el negocio antes de vender |
|
||||
| 02 | **Alcance y desglose económico** — filas categoría / entregable+descripción / precio, más caja de totales (subtotal, descuento, IVA, total) | El qué y el cuánto |
|
||||
| 03 | **Qué no incluye esta propuesta** — lista con ✕ | Anti-scope-creep, preventivo |
|
||||
| 04 | **Por qué tiene sentido esta solución** — pares etiqueta/explicación | Argumentos de venta traducidos a beneficio |
|
||||
| 05 | **Plan de mantenimiento opcional** — dos tarjetas (mensual vs anual, una `.featured`) con features `highlight` / `good` / `muted` | Siembra de recurrencia, con límites explícitos |
|
||||
| 06 | **Estado de materiales del cliente** — dos tarjetas: materiales (`done`/`pend`) y decisiones pendientes (`pend`/`neutral`) | Transparencia y transferencia de responsabilidad |
|
||||
| Footer | Datos de contacto + condiciones (50/50, CFDI, avance condicionado a materiales, cambios se cotizan aparte) | Blindaje comercial |
|
||||
|
||||
**El semáforo de la sección 01 es el activo intelectual más valioso de la plantilla.** Obliga a clasificar cada hallazgo por urgencia — exactamente lo que la base de conocimiento pide en las 3 Preguntas de Oro. Y el marcador `dot-green` ("ventaja existente") obliga a reconocer lo que el cliente ya hizo bien, que es el detalle que convierte una propuesta en una conversación entre pares.
|
||||
|
||||
**La sección 06 es la que resuelve la honestidad de la IA.** Ver §10.2.
|
||||
|
||||
### 2.3 La base de conocimiento (vault de Obsidian)
|
||||
|
||||
Sintetizada desde 91 transcripts. Lo que aporta al plugin, en orden de utilidad:
|
||||
|
||||
**Framework de diagnóstico (Fase 2 del playbook):**
|
||||
- Las 3 Preguntas de Oro: (1) ¿cuál es el problema de **negocio**, no técnico? (2) ¿cuánto le está costando hoy? (3) ¿cuánto ingreso/ahorro esperas en 12 meses?
|
||||
- Costo desglosado en 4 dimensiones: dinero directo · tiempo del equipo · costo de oportunidad · costo de error humano
|
||||
- Filtro de viabilidad de 4 preguntas: costo de no hacer nada · ¿los datos existen HOY? · ¿quién es el usuario final real? · ¿qué pasa si funciona?
|
||||
- The Mom Test: preguntas ancladas en el pasado ("¿cómo lo resolvieron la última vez?"), no en el futuro hipotético
|
||||
|
||||
**Framework de pricing:**
|
||||
- `Valor Anual = (horas/mes × costo horario × 12) + costo anual de errores + ingresos recuperados`
|
||||
- `Precio objetivo = 15% a 25% del Valor Anual`
|
||||
- Marco VALOR (techo) / COSTO real (piso, 2-3× horas técnicas) / MERCADO
|
||||
- Anclaje: presentar A (2× objetivo) → B (objetivo, se elige 60%) → C (50% del objetivo)
|
||||
- 3 opciones cierran **16-28% más alto** que una sola
|
||||
|
||||
**Reglas transversales de comunicación** (del checklist de calidad):
|
||||
1. Hablar de resultados, no de herramientas
|
||||
2. **Usar las palabras del cliente** — registrar frases textuales del dolor y reutilizarlas
|
||||
3. Investigar hechos pasados
|
||||
4. 80% habla el cliente / 20% el consultor
|
||||
5. **Distinguir evidencia de hipótesis** — etiquetar cifras como confirmadas, estimadas o pendientes de validar
|
||||
6. No prometer solución antes de validar
|
||||
7. Recapitular y confirmar
|
||||
8. Comunicar riesgos temprano
|
||||
|
||||
**Separación de tres conceptos** (Sesión 4 de onboarding): proyecto inicial ≠ mantenimiento ≠ evolución/retainer. Cada uno con su alcance, precio y forma de contratación explícitos.
|
||||
|
||||
**Criterio ético de monetización:** una mejora posterior se propone sólo si hay evidencia de que resuelve un problema real, el cliente puede decidir libremente, y el nuevo alcance/precio/plazo quedan claros.
|
||||
|
||||
**Los 15 errores de monetización más caros** — de los cuales el plugin puede prevenir directamente: mandar propuesta con 1 sola opción (#4), aceptar scope creep sin orden de cambio (#7), entregar sin documentación (#8), no ofrecer retainer post-entrega (#9), vender habilidades técnicas en vez de resultados (#13).
|
||||
|
||||
---
|
||||
|
||||
## 3. Diagnóstico: la brecha entre los tres activos
|
||||
|
||||
Aplico a este proyecto el mismo semáforo de la plantilla.
|
||||
|
||||
### 🔴 Problema crítico — el contexto humano se captura y se descarta
|
||||
|
||||
`Cotizacion.observaciones` y `ServicioCotizado.notas` existen en el esquema, se llenan en el formulario (`CotizacionForm.tsx:1222`, placeholder literal *"Notas adicionales para la cotizacion..."*) y **no aparecen en ningún exportador**. Es información de discovery que el asesor ya se tomó el trabajo de escribir y que muere en la base de datos.
|
||||
|
||||
Esto no es sólo desperdicio: es la evidencia de que el sistema fue diseñado como calculadora y no como instrumento de venta consultiva. El plugin no tiene que crear el canal de entrada — **tiene que empezar a leerlo.**
|
||||
|
||||
### 🔴 Problema crítico — el pricing es de menú, la filosofía es de valor
|
||||
|
||||
El Cotizador calcula desde `ServicioCatalogo.precioBase`: precio fijo por servicio, sumado. Es pricing de catálogo. La base de conocimiento predica pricing por valor: 15-25% del valor anual del problema.
|
||||
|
||||
**No son incompatibles, pero hoy no se hablan.** El precio de catálogo es el piso operativo y la base de facturación (con CFDI, IVA, RFC — cosas que un porcentaje del valor anual no te da). El valor anual es el argumento que justifica ese precio ante el cliente.
|
||||
|
||||
El plugin no debe reemplazar uno por el otro. Debe **superponer la capa de valor sobre la capa contable**: tomar el total que el humano ya fijó y demostrar que representa X% del valor anual del problema. Si el asesor cotizó $50,000 MXN y la IA detecta en la transcripción un dolor de ~$400,000 MXN/año, la propuesta escribe *"la inversión equivale al 12.5% del costo anual del problema"* — sin mover el $50,000.
|
||||
|
||||
### 🟠 Área de mejora — la doble propuesta existe pero está subutilizada
|
||||
|
||||
`esDoble` + `opcionesMetadata` da dos opciones. La filosofía pide tres, con anclaje psicológico (cara primero). El plugin puede generar el **argumento** de las tres opciones en su documento narrativo aun cuando el documento económico sólo tenga dos, o recomendar al asesor cómo estructurar las dos que sí caben.
|
||||
|
||||
Aquí hay que ser honesto: **no** hay que forzar tres opciones si el proyecto no las admite. La Sesión 4 lo dice explícito: *"Cuando haya alternativas reales, usa tres opciones… las otras no son una trampa ni una lista de extras artificiales."*
|
||||
|
||||
### 🟠 Área de mejora — la base de conocimiento es de otro negocio
|
||||
|
||||
Esto es una tensión real que hay que documentar antes de que alguien la descubra a medio proyecto:
|
||||
|
||||
| | Base de conocimiento | Cotizador E3 |
|
||||
|---|---|---|
|
||||
| Negocio | Freelance/consultoría de automatización con Python | Consultoría de digitalización y marketing digital |
|
||||
| Geografía | LATAM, cobro internacional | Querétaro, MX |
|
||||
| Moneda | USD (Wise/Stripe/Payoneer) | MXN con IVA 16% y CFDI |
|
||||
| Rangos | $300 – $25,000 USD | $7,490 – $90,800 MXN (paquetes) |
|
||||
| Servicios | Scripts, RAG, dashboards, APIs | Ads, SEO, WordPress, CRM Bucéfalo, contenido |
|
||||
| Recurrencia | Retainer de mantenimiento de software | Mensualidades de manejo de pauta y CRM |
|
||||
|
||||
**Los frameworks son transferibles; las cifras no.** La IA debe importar el *método* de diagnóstico, el *marco* de pricing y las *reglas* de comunicación — y jamás las tablas de precios en USD. Si el plugin sugiere "$1,800 USD" en una cotización de E3, es un bug, no una feature.
|
||||
|
||||
### 🔵 Oportunidad — el servidor MCP ya está construido
|
||||
|
||||
`api/app/mcp/server.py` (453 líneas) + `tools.py` (305 líneas) exponen el catálogo, las cotizaciones y la configuración a agentes. El plugin no necesita una capa de acceso a datos nueva: puede consumir la que existe. Y como los cálculos viven duplicados en `src/lib/calculators.ts` y `api/app/services/calculators.py` con paridad obligatoria, la IA puede **leer** totales sin riesgo de recalcularlos mal.
|
||||
|
||||
### 🔵 Oportunidad — la plantilla HTML es un contrato de salida listo
|
||||
|
||||
No hay que diseñar el formato del segundo documento. La plantilla ya define las secciones, la jerarquía y el vocabulario visual. El trabajo es mapear cada sección a su fuente de datos (ver §7) y dejar que la IA llene el contenido, no la estructura.
|
||||
|
||||
### 🟢 Ventaja existente — el asesor ya hace el trabajo difícil
|
||||
|
||||
El humano ya: califica al cliente, corre la reunión, elige servicios del catálogo, ajusta precios, decide el esquema de pago. El plugin no reemplaza ese juicio. **Se monta sobre él.** Esto reduce drásticamente el riesgo: si la IA falla, el documento manual sigue siendo entregable.
|
||||
|
||||
### 🟢 Ventaja existente — el vault ya tiene el system prompt esbozado
|
||||
|
||||
`sintesis/s8-Prompts-Plantillas.md` §1 tiene un system prompt maestro, §3 un prompt de diagnóstico de proyecto, §4 un prompt de propuesta comercial y §9 una plantilla de output estándar. No hay que empezar de cero — hay que **adaptar de USD/Python a MXN/marketing digital**.
|
||||
|
||||
---
|
||||
|
||||
## 4. Filosofía: los 10 principios del plugin
|
||||
|
||||
Estos son los principios no negociables. Si una decisión de implementación los contradice, la decisión está mal.
|
||||
|
||||
### P1 · La IA no toca los números
|
||||
|
||||
La IA **lee** precios, totales, IVA, vigencia y financiamiento. **Nunca los calcula, propone ni modifica.** Todo número que aparezca en el documento de IA debe ser byte-por-byte el mismo que produjo `calculators.ts`.
|
||||
|
||||
*Por qué:* un precio inventado por la IA en un documento con el logo de E3 es un pasivo comercial y potencialmente fiscal. Además destruye la confianza en todo el resto del documento.
|
||||
|
||||
*Implicación técnica:* los totales se inyectan como datos ya calculados en el prompt y se instruye a la IA a citarlos literalmente; idealmente el render final los toma del objeto de cotización, no del texto generado.
|
||||
|
||||
### P2 · Dos documentos, dos trabajos, cero solapamiento
|
||||
|
||||
| | Documento 1 (manual, PDF/Excel) | Documento 2 (IA, HTML) |
|
||||
|---|---|---|
|
||||
| Autor | Asesor humano | IA, revisada por el asesor |
|
||||
| Función | Contractual y económica | Consultiva y narrativa |
|
||||
| Contenido | Servicios, precios, totales, condiciones | Diagnóstico, valor, argumentos, exclusiones, pendientes |
|
||||
| Números | **Fuente de verdad** | Espejo, sólo citados |
|
||||
| Si se contradicen | Gana este | Se corrige este |
|
||||
| Vive en | `pdf-generator.ts` / `excel-builder.ts` | Nuevo generador |
|
||||
|
||||
El documento 2 es un **superconjunto narrativo** y un **subconjunto numérico** del documento 1.
|
||||
|
||||
### P3 · Toda afirmación es trazable
|
||||
|
||||
Cada dato que la IA escriba sobre el cliente debe apuntar a su origen: una línea de transcripción, un archivo de notas, un campo del formulario, o el catálogo. Si no hay origen, no se escribe.
|
||||
|
||||
*Implicación:* el contrato de salida (§8) lleva un campo `evidencia` por afirmación. El documento renderizado puede ocultarlo al cliente, pero el asesor debe poder auditarlo antes de enviar.
|
||||
|
||||
### P4 · Evidencia, estimación e hipótesis se etiquetan distinto
|
||||
|
||||
Directo de la regla 5 del checklist de calidad. Tres estados:
|
||||
|
||||
- **Confirmado** — el cliente lo dijo textualmente o hay un dato duro.
|
||||
- **Estimado** — se derivó de algo que el cliente dijo, con un cálculo explícito.
|
||||
- **Por validar** — hipótesis del consultor que aún nadie confirmó.
|
||||
|
||||
Un "estimado" presentado como "confirmado" es la forma más rápida de perder credibilidad en una reunión de presentación. La IA debe marcar cada cifra.
|
||||
|
||||
### P5 · Las palabras del cliente son sagradas
|
||||
|
||||
La sección de diagnóstico debe usar frases textuales del cliente, no paráfrasis corporativas. Si en la transcripción dice *"se nos van los clientes porque nadie contesta el WhatsApp el fin de semana"*, eso va entre comillas — no *"oportunidades de mejora en la gestión omnicanal de la comunicación"*.
|
||||
|
||||
*Regla operativa:* el bloque `.quote` de la sección 01 debe ser **siempre** una cita literal, nunca una síntesis de la IA.
|
||||
|
||||
### P6 · Se vende resultado, no herramienta
|
||||
|
||||
Error #13 de la lista de errores de monetización. Traducir toda capacidad técnica a tiempo recuperado, errores evitados, ingresos protegidos o tranquilidad operativa.
|
||||
|
||||
*Malo:* "Configuración de Google Ads con estructura SKAG y scripts de puja automatizada."
|
||||
*Bueno:* "Cada peso de pauta se dirige a las búsquedas que sí compran, en lugar de repartirse entre términos que sólo generan clics. Reportamos costo por prospecto real, no impresiones."
|
||||
|
||||
### P7 · Lo que NO incluye vale tanto como lo que sí
|
||||
|
||||
La sección 03 de la plantilla no es un trámite: es prevención de scope creep, que según la base de conocimiento promedia **27% de sobrecosto** en proyectos sin control de alcance. La IA debe generar exclusiones **específicas del proyecto**, no genéricas.
|
||||
|
||||
*Malo:* "No incluye servicios no mencionados."
|
||||
*Bueno:* "No incluye la migración del histórico de 4 años de pedidos que mencionaron en la reunión; eso se evalúa como fase 2 cuando el sistema base esté operando."
|
||||
|
||||
### P8 · Mantenimiento y evolución van separados, con límites por escrito
|
||||
|
||||
De la Sesión 4: *"No prometas mantenimiento gratuito indefinido y no vendas un retainer como si incluyera trabajo ilimitado."* La sección 05 debe listar explícitamente qué **no** cubre el plan (la plantilla ya tiene la clase `.plan-feat.muted` con ✕ para eso). El backlog de evolución se registra aparte y **no se compromete**.
|
||||
|
||||
### P9 · La incertidumbre se declara, no se rellena
|
||||
|
||||
Si falta información, la IA **no la inventa ni la omite silenciosamente**: la escribe en la sección 06 como material o decisión pendiente. Ver §10.2 — esto es el mecanismo central de honestidad del sistema.
|
||||
|
||||
### P10 · El asesor aprueba antes de enviar
|
||||
|
||||
El documento de IA nace en estado borrador. Nadie lo manda al cliente sin que un humano lo lea. El plugin es un copiloto de redacción, no un autopiloto de ventas.
|
||||
|
||||
*Corolario:* el flujo de UI debe hacer que revisar sea fácil (diff, semáforo de confianza, evidencia expandible), no que aprobar sea rápido.
|
||||
|
||||
---
|
||||
|
||||
## 5. Insights de monetización que hay que codificar
|
||||
|
||||
Estos son los mecanismos concretos de la base de conocimiento que el plugin debe hacer operativos. Cada uno con su traducción a comportamiento del sistema.
|
||||
|
||||
| # | Insight de la base de conocimiento | Cómo lo codifica el plugin |
|
||||
|---|---|---|
|
||||
| M1 | El cliente describe síntomas; tu trabajo es diagnosticar la enfermedad | La sección 01 nunca repite la petición del cliente ("quiero una página web"); reformula al problema de negocio ("pierden prospectos porque no tienen dónde mandarlos desde los anuncios") |
|
||||
| M2 | El costo del problema se desglosa en 4 dimensiones | La IA busca en la transcripción las 4 dimensiones y las presenta con su etiqueta de confianza; las que faltan van a la sección 06 como pendiente de validar |
|
||||
| M3 | Precio = 15-25% del valor anual | La IA calcula el **ratio inverso**: dado el total que fijó el humano y el valor anual detectado, reporta qué porcentaje representa. Si sale <10%, señala al asesor que probablemente subcotizó. Si sale >40%, señala que va a haber objeción de precio |
|
||||
| M4 | 3 opciones cierran 16-28% más alto | Si `esDoble = false`, el plugin sugiere al asesor un esquema de 2-3 opciones basado en los servicios ya elegidos (quitando o agregando del mismo catálogo, sin inventar servicios) |
|
||||
| M5 | Anclaje: la opción cara primero | En el render de la sección de opciones, el orden es A (mayor) → B (recomendada, `.featured`) → C (esencial) |
|
||||
| M6 | La objeción de precio se responde con alcance, no con descuento | El documento incluye, en notas internas para el asesor (no visibles al cliente), el "plan de recorte": qué servicios quitar primero si el cliente pide bajar el precio, ordenados por menor impacto en el resultado prometido |
|
||||
| M7 | Anticipo 50% obligatorio antes de empezar | El footer lo enuncia siempre; no es opcional ni negociable por la IA |
|
||||
| M8 | Updates 2×/semana aumentan confiabilidad percibida +125% | La propuesta incluye el compromiso de cadencia de comunicación como **parte del alcance**, no como cortesía |
|
||||
| M9 | El retainer se ofrece a las 2 semanas post-entrega, no al inicio | La sección 05 presenta el mantenimiento como **opción con límites explícitos**, nunca como requisito ni como amenaza velada ("para que no se rompa") |
|
||||
| M10 | Las 3 capas de documentación triplican la tarifa | Los entregables documentales (README ejecutivo, registro de decisiones, guía de mantenimiento — adaptados a marketing digital: manual de operación de campañas, bitácora de decisiones de segmentación, guía de qué puede ajustar el cliente solo) se listan como entregables con valor, no como anexos |
|
||||
| M11 | Red flags del cliente | El plugin genera, en notas internas, una sección de riesgo: red flags detectadas en la transcripción (pidió descuento antes de entender el valor, no hay decisor presente, no hay cifra del problema, "hagan todo y luego vemos") |
|
||||
| M12 | Separar proyecto / mantenimiento / evolución | Tres bloques distintos en el documento, con encabezados que lo hagan obvio. El backlog de evolución dice explícitamente "no comprometido en esta propuesta" |
|
||||
| M13 | Criterio ético: sólo se propone lo que hay evidencia de que resuelve un problema real | La IA **no puede** agregar un servicio del catálogo que el asesor no eligió. Puede señalar en notas internas *"el cliente mencionó X, que el catálogo cubre con el servicio Y; considera si aplica"* — pero no lo mete en la propuesta |
|
||||
|
||||
### 5.1 El indicador de salud de la cotización
|
||||
|
||||
De M3 y M11 sale la feature más útil para el negocio y la más fácil de implementar: un semáforo interno, sólo para el asesor, que evalúa la cotización antes de enviarla.
|
||||
|
||||
| Señal | Cómo se calcula | Qué significa |
|
||||
|---|---|---|
|
||||
| Ratio precio/valor | `total / valor_anual_detectado` | <10% subcotizado · 15-25% en rango · >40% objeción probable |
|
||||
| Dolor cuantificado | ¿hay al menos una cifra confirmada del costo del problema? | Si no: no hay ancla de valor; la propuesta va a competir por precio |
|
||||
| Usuario final entrevistado | ¿la transcripción incluye a quien operará, no sólo al que firma? | Si no: riesgo de baja adopción |
|
||||
| Decisor presente | ¿se identificó a quien autoriza el gasto? | Si no: riesgo de "voy a preguntar" |
|
||||
| Exclusiones definidas | ¿hay al menos 3 exclusiones específicas? | Si no: riesgo de scope creep |
|
||||
| Materiales pendientes | conteo de la sección 06 | Alto: la fecha de entrega es irreal |
|
||||
| Red flags | conteo de señales de la lista | ≥2: evaluar si conviene el proyecto |
|
||||
|
||||
Esto no es un adorno. Es **business intelligence real** sobre el pipeline: agregado en el tiempo, dice qué tipo de cotizaciones cierran y cuáles no.
|
||||
|
||||
---
|
||||
|
||||
## 6. Anatomía del documento de IA
|
||||
|
||||
El documento 2 hereda la estructura de la plantilla HTML, con tres cambios. Marcados **[NUEVO]** los que no existen en la plantilla.
|
||||
|
||||
| Sección | Origen del contenido | Notas |
|
||||
|---|---|---|
|
||||
| **Hero** | `Cliente`, `Cotizacion.numero`, `fecha`, `vigencia`, `proyecto`, asesor | El subtítulo lo redacta la IA: una o dos oraciones que enmarcan el problema en lenguaje del cliente |
|
||||
| **01 · Diagnóstico** | Transcripción + notas + observaciones | `.quote` = cita literal obligatoria. Filas con semáforo: al menos 1 rojo, 1 ámbar, 1 azul, 1 verde. Cada fila con etiqueta de confianza |
|
||||
| **01b · Valor del problema** **[NUEVO]** | Transcripción, con las 4 dimensiones de costo | Tabla: dimensión / cifra / estado (confirmado/estimado/por validar) / evidencia. Cierra con el valor anual y el ratio de M3 |
|
||||
| **02 · Resultados a lograr** **[NUEVO]** | Derivado del diagnóstico + entregables de los servicios elegidos | 3-5 resultados de negocio cuantificados. Es el puente entre problema y precio. La plantilla no lo tiene y la base de conocimiento lo pide en toda propuesta |
|
||||
| **03 · Alcance y desglose económico** | `ServicioCotizado[]`, agrupado por fase y `tipoPago` | **Números literales del documento 1.** La IA sólo reescribe las descripciones en lenguaje de resultado (P6). Separar pago único de mensual, como ya hace el PDF |
|
||||
| **04 · Opciones de inversión** | `esDoble` + `opcionesMetadata` | Sólo si hay opciones reales. Orden A → B(`.featured`) → C |
|
||||
| **05 · Qué no incluye** | Transcripción (menciones fuera de alcance) + `opcionesMetadata.noIncluye` | Exclusiones específicas, nunca genéricas (P7) |
|
||||
| **06 · Por qué tiene sentido** | `ServicioCotizado.beneficios` + diagnóstico | Cada beneficio amarrado a un hallazgo del diagnóstico. Si un beneficio no responde a ningún dolor detectado, se elimina |
|
||||
| **07 · Plan de mantenimiento** | `PlanBucefaloCotizacion`, servicios `tipoPago: mensual`, `modeloCobro: retainer` | Con exclusiones explícitas (`.plan-feat.muted`). Mensual vs anual si aplica |
|
||||
| **08 · Estado de materiales y decisiones** | Todo lo que la IA no pudo determinar + menciones de dependencias en la transcripción | **El canal de honestidad.** Ver §10.2 |
|
||||
| **09 · Backlog de evolución** **[NUEVO]** | Fricciones mencionadas por el cliente que no entran en fase 1 | Con encabezado explícito: "registrado, no comprometido en esta propuesta" |
|
||||
| **Footer** | `Configuracion` (logo, colores) + condiciones fijas | 50/50, CFDI, avance condicionado a materiales, cambios se cotizan aparte, MXN |
|
||||
| **Anexo interno** **[NUEVO]** | Todo lo de §5.1 + M6 + M11 | **No se entrega al cliente.** Semáforo de salud, plan de recorte, red flags, evidencia completa. Puede ser una segunda página o un archivo aparte |
|
||||
|
||||
### 6.1 Nota sobre el anexo interno
|
||||
|
||||
Esta es la parte del diseño que más valor operativo tiene y la que más cuidado necesita. Un documento con "plan de recorte de precio" y "red flags del cliente" enviado por error al cliente es un incidente serio.
|
||||
|
||||
Recomendación: **archivo separado**, nombre distinto y visualmente inconfundible (fondo distinto, marca de agua "INTERNO — NO ENVIAR"). No una sección oculta del mismo archivo, no un `display: none`, no un comentario HTML.
|
||||
|
||||
---
|
||||
|
||||
## 7. Arquitectura de ingesta de contexto
|
||||
|
||||
### 7.1 Las cuatro fuentes
|
||||
|
||||
| Fuente | Formato | Volumen típico | Confianza |
|
||||
|---|---|---|---|
|
||||
| **Transcripción de reunión** | `.txt`, `.md`, `.vtt`, `.srt` | 60 min ≈ 9,000 palabras ≈ 13K tokens | Alta para citas; media para cifras (la gente redondea al hablar) |
|
||||
| **Notas del asesor** | `.md`, `.txt` | 200-2,000 palabras | Alta — es interpretación experta |
|
||||
| **Campos del formulario** | `Cotizacion.observaciones`, `ServicioCotizado.notas` | 50-500 palabras | Alta — escrito con intención |
|
||||
| **Cotización estructurada** | JSON desde Prisma/MCP | 3-5K tokens | **Absoluta** — es la fuente de verdad |
|
||||
|
||||
### 7.2 Precedencia en caso de conflicto
|
||||
|
||||
Cuando dos fuentes se contradicen:
|
||||
|
||||
```
|
||||
Cotización estructurada > Notas del asesor > Observaciones > Transcripción
|
||||
```
|
||||
|
||||
*Razón:* la cotización es dato validado; las notas son interpretación experta posterior a la reunión; la transcripción es materia prima cruda con ruido de ASR, muletillas y correcciones en vivo ("son como 20 horas… no, más bien 30").
|
||||
|
||||
Si el conflicto es sobre una **cifra**, la IA no elige: lo reporta en la sección 08 como decisión pendiente. *"En la reunión se mencionaron 20 y 30 horas semanales en momentos distintos; confirmar la cifra antes de calcular el valor anual."*
|
||||
|
||||
### 7.3 Pipeline de preprocesamiento
|
||||
|
||||
Antes de que un token llegue al modelo:
|
||||
|
||||
1. **Normalización de formato** — VTT/SRT a texto plano con marcas de tiempo opcionales; Markdown se conserva.
|
||||
2. **Sanitización de PII** — Esto es obligatorio, no opcional. Las transcripciones contienen nombres de empleados, comentarios sobre desempeño, cifras salariales, quejas sobre terceros. Se redactan nombres de personas que no son el interlocutor comercial, y se marca cualquier mención de temas laborales, legales o de salud como bloque excluido del documento final.
|
||||
3. **Segmentación por hablante** cuando el formato lo permite — permite aplicar la regla 80/20 y detectar si se entrevistó al usuario operativo o sólo al decisor.
|
||||
4. **Conteo de tokens** con `client.messages.countTokens` (nunca con estimadores de otros proveedores) para decidir si cabe entero o requiere segmentación.
|
||||
5. **Detección de idioma** — si la transcripción tiene mezcla, se preserva; el documento final va en español.
|
||||
|
||||
### 7.4 Dónde se suben los archivos
|
||||
|
||||
Tres opciones, en orden de preferencia:
|
||||
|
||||
1. **Nuevo campo en la UI de cotización** — una zona de drop en la pestaña de observaciones. Los archivos se guardan como adjuntos vinculados a la `Cotizacion`. Requiere un modelo nuevo (`ContextoCotizacion`: `cotizacionId`, `tipo`, `nombreArchivo`, `contenido`/`ruta`, `createdAt`).
|
||||
2. **Carpeta convenida en disco** — más simple para un MVP, peor para el despliegue en Coolify (contenedor sin volumen persistente por defecto). Sirve para probar localmente.
|
||||
3. **Files API de Anthropic** (beta `files-api-2025-04-14`) — útil si se quiere pasar un PDF de reunión sin extraer texto; límite 500 MB. Requiere el header beta tanto en el upload como en el `messages.create` que lo referencia.
|
||||
|
||||
Para el MVP: opción 2 para validar la calidad del output; opción 1 para producción.
|
||||
|
||||
---
|
||||
|
||||
## 8. Contrato de salida
|
||||
|
||||
La IA **no genera HTML**. Genera un objeto estructurado que un renderizador convierte a HTML usando la plantilla. Esto es crítico por tres razones: valida la estructura antes de renderizar, permite que el asesor edite campo por campo, y evita que la IA rompa el CSS o inyecte markup arbitrario.
|
||||
|
||||
La API soporta esto nativamente con `output_config: { format: { type: "json_schema", schema: {...} } }` (structured outputs), disponible en Opus 5, Sonnet 5 y Haiku 4.5. En TypeScript hay helper de Zod: `zodOutputFormat()` + `client.messages.parse()`, que devuelve el objeto ya validado en `response.parsed_output`.
|
||||
|
||||
### 8.1 Forma conceptual del schema
|
||||
|
||||
```
|
||||
PropuestaConsultiva
|
||||
├─ meta: { numeroCotizacion, cliente, empresa, proyecto, vigencia, asesor }
|
||||
├─ hero: { titulo, subtitulo }
|
||||
├─ diagnostico:
|
||||
│ ├─ citaLiteral: { texto, origen } ← obligatorio, literal
|
||||
│ └─ hallazgos[]: { urgencia: rojo|ambar|azul|verde,
|
||||
│ titulo, descripcion,
|
||||
│ confianza: confirmado|estimado|por_validar,
|
||||
│ evidencia }
|
||||
├─ valorProblema:
|
||||
│ ├─ dimensiones[]: { tipo: dinero|tiempo|oportunidad|error,
|
||||
│ descripcion, montoAnualMXN|null,
|
||||
│ confianza, evidencia }
|
||||
│ ├─ valorAnualEstimadoMXN: number|null
|
||||
│ └─ notaMetodologia: string ← cómo se llegó a la cifra
|
||||
├─ resultados[]: { enunciado, metrica, lineaBase|null, periodoMedicion }
|
||||
├─ alcance:
|
||||
│ └─ items[]: { fase, categoria, nombre,
|
||||
│ descripcionResultado, ← reescritura en lenguaje de beneficio
|
||||
│ precioMXN, tipoPago, tiempoEntrega }
|
||||
├─ totales: { subtotal, descuento, iva, total, moneda } ← COPIADO, nunca calculado
|
||||
├─ opciones[]|null: { etiqueta, titulo, descripcion, paraQuien,
|
||||
│ incluye[], noIncluye[], recomendada: bool }
|
||||
├─ exclusiones[]: { texto, razon, origen } ← específicas del proyecto
|
||||
├─ beneficios[]: { etiqueta, texto, hallazgoRelacionado } ← amarrado al diagnóstico
|
||||
├─ mantenimiento|null:
|
||||
│ └─ planes[]: { nombre, periodicidad, precioMXN, incluye[], noIncluye[], destacado }
|
||||
├─ pendientes:
|
||||
│ ├─ materiales[]: { texto, estado: recibido|pendiente, bloqueaEntrega: bool }
|
||||
│ └─ decisiones[]: { texto, quienDecide, fechaSugerida }
|
||||
├─ backlogEvolucion[]: { problema, impactoPosible, evidencia, momentoSugerido }
|
||||
└─ interno: ← NUNCA en el documento del cliente
|
||||
├─ salud: { ratioPrecioValor, dolorCuantificado, usuarioFinalEntrevistado,
|
||||
│ decisorPresente, exclusionesDefinidas, materialesPendientes }
|
||||
├─ planRecorte[]: { servicio, impactoEnResultado: bajo|medio|alto, ordenSugerido }
|
||||
├─ redFlags[]: { señal, evidencia, severidad }
|
||||
└─ huecos[]: { queFalta, porQueImporta, comoObtenerlo }
|
||||
```
|
||||
|
||||
### 8.2 Restricciones del JSON Schema en la API
|
||||
|
||||
Hay que diseñar el schema con estos límites en mente:
|
||||
|
||||
- **Soportado:** tipos básicos, `enum`, `const`, `anyOf`, `allOf`, `$ref`/`$def`, formatos de string (`date`, `date-time`, `email`, `uri`, `uuid`).
|
||||
- **No soportado:** esquemas recursivos, restricciones numéricas (`minimum`, `maximum`, `multipleOf`), restricciones de string (`minLength`, `maxLength`), restricciones complejas de array.
|
||||
- **Obligatorio:** `additionalProperties: false` en todos los objetos.
|
||||
- Los SDK de Python y TypeScript quitan automáticamente las restricciones no soportadas del schema enviado y las validan del lado del cliente — así que se pueden usar en Zod, sabiendo que la validación es local.
|
||||
- Incompatible con citations (devuelve 400) y con prefill de mensaje de asistente.
|
||||
- Primera petición con un schema nuevo tiene costo de compilación; después hay caché de 24h.
|
||||
|
||||
### 8.3 Reglas de validación post-generación (código, no IA)
|
||||
|
||||
Después de recibir el objeto y antes de renderizar:
|
||||
|
||||
1. `totales` debe ser **idéntico** al de la cotización en BD. Si no, se descarta el objeto y se registra el fallo. Sin excepciones.
|
||||
2. Cada `alcance.items[].precioMXN` debe existir en `ServicioCotizado`. Ningún item nuevo, ningún precio distinto.
|
||||
3. `diagnostico.citaLiteral.texto` debe encontrarse como substring (normalizado) en alguna fuente de contexto. Si no aparece, se marca como no verificada y se pide revisión.
|
||||
4. Todo `hallazgo` con `confianza: confirmado` debe tener `evidencia` no vacía.
|
||||
5. `interno` se separa del objeto antes de pasar al renderizador del documento del cliente.
|
||||
6. Si `valorProblema.valorAnualEstimadoMXN` es `null`, el documento **no** puede afirmar un ratio precio/valor.
|
||||
|
||||
---
|
||||
|
||||
## 9. Lineamientos del prompt
|
||||
|
||||
### 9.1 Estructura de capas
|
||||
|
||||
El prompt se arma en tres capas, ordenadas por estabilidad (esto importa para el caché — ver §11.3):
|
||||
|
||||
```
|
||||
Capa 1 — ESTABLE (idéntica en toda cotización, cacheable)
|
||||
· Identidad y rol
|
||||
· Filosofía (los 10 principios de §4)
|
||||
· Frameworks de diagnóstico y pricing
|
||||
· Reglas de marca y confidencialidad
|
||||
· Contrato de salida y reglas de validación
|
||||
· Catálogo de servicios activo (snapshot)
|
||||
· Ejemplos de buena y mala redacción
|
||||
|
||||
Capa 2 — SEMI-ESTABLE (por cliente o sector)
|
||||
· Historial del cliente si es recurrente
|
||||
· Notas del sector
|
||||
|
||||
Capa 3 — VOLÁTIL (por cotización)
|
||||
· Cotización estructurada (JSON)
|
||||
· Transcripción sanitizada
|
||||
· Notas y observaciones
|
||||
· Instrucción específica del asesor
|
||||
```
|
||||
|
||||
Nada dinámico —fechas, IDs, timestamps— debe entrar en la capa 1. Una fecha interpolada en el system prompt invalida el caché de todo lo que viene después.
|
||||
|
||||
### 9.2 Reglas del system prompt
|
||||
|
||||
Adaptando el prompt maestro de `s8-Prompts-Plantillas.md` §1 al contexto de E3:
|
||||
|
||||
**Identidad.** Consultor senior de digitalización de negocios para PyMEs mexicanas. Redacta propuestas comerciales consultivas para Consultoría E3 (Querétaro, MX). No es vendedor: es diagnosticador.
|
||||
|
||||
**Reglas de contenido.**
|
||||
1. Cita fuentes internamente para cada dato del cliente. Si no hay fuente, no se escribe.
|
||||
2. Etiqueta toda cifra como confirmada, estimada o por validar.
|
||||
3. Traduce toda capacidad técnica a dinero, tiempo, riesgo evitado o tranquilidad operativa.
|
||||
4. Usa las palabras textuales del cliente en el diagnóstico.
|
||||
5. Nunca proponer un servicio que el asesor no eligió.
|
||||
6. Nunca calcular, sugerir ni modificar un precio.
|
||||
7. Cuando falte información, escribirla como pendiente — jamás rellenarla.
|
||||
8. Español de México, tono cercano y profesional, tuteo con el cliente cuando el registro de la reunión lo permita. Sin lenguaje corporativo vacío (*sinergias*, *holístico*, *stakeholders*, *ecosistema*, *disruptivo*).
|
||||
9. Moneda: MXN. IVA 16%. Facturación CFDI.
|
||||
10. El CRM se llama **Bucéfalo**. No se menciona ninguna otra plataforma de CRM.
|
||||
11. E3 ofrece únicamente servicios digitales. Si en la reunión se pidió algo de marketing tradicional o diseño para imprenta, va a la sección de exclusiones aclarando que no es un servicio de E3.
|
||||
|
||||
**Prohibiciones explícitas.**
|
||||
- No importar rangos de precio en USD de ninguna base de conocimiento.
|
||||
- No incluir datos personales de empleados del cliente, información salarial, ni temas legales o de prestaciones. Si la reunión los tocó, se omiten del documento y se anota en el bloque interno que el tema debe manejarse por el canal correspondiente.
|
||||
- No prometer resultados garantizados en pauta o posicionamiento (número de ventas, posición #1 en Google). Se prometen entregables, procesos y métricas de seguimiento.
|
||||
- No prometer soporte ilimitado.
|
||||
- No usar la palabra "garantizado" sobre resultados de mercado.
|
||||
|
||||
**Formato de razonamiento.** Con `claude-opus-5` el thinking está activo por defecto. Conviene dejarlo así: el diagnóstico requiere razonamiento multi-paso (leer transcripción → detectar dolor → cuantificar → cruzar con servicios elegidos → redactar). No hay que desactivarlo.
|
||||
|
||||
### 9.3 Descomposición en tareas
|
||||
|
||||
Un solo prompt monolítico va a producir un documento mediocre en todas sus partes. Mejor pipeline de 3 pasos, cada uno con su schema:
|
||||
|
||||
| Paso | Entrada | Salida | Modelo sugerido |
|
||||
|---|---|---|---|
|
||||
| **1 · Extracción** | Transcripción + notas | Hechos estructurados: dolores, cifras con confianza, citas literales, materiales mencionados, decisiones pendientes, red flags, menciones fuera de alcance | Opus 5 (`effort: high`) — es el paso que determina la calidad de todo lo demás |
|
||||
| **2 · Diagnóstico y valoración** | Hechos del paso 1 + cotización estructurada + catálogo | Hallazgos con semáforo, valor del problema, resultados a lograr, ratio precio/valor, semáforo de salud | Opus 5 (`effort: high`) |
|
||||
| **3 · Redacción** | Salida de pasos 1 y 2 | `PropuestaConsultiva` completa | Opus 5 (`effort: medium`) — con el análisis hecho, esto es principalmente escritura |
|
||||
|
||||
Ventajas de separar: cada paso se evalúa por separado, el paso 1 se puede cachear si sólo cambia la cotización, y el asesor puede corregir los hechos del paso 1 antes de que se propaguen.
|
||||
|
||||
### 9.4 Ejemplos en el prompt
|
||||
|
||||
La base de conocimiento es enfática en que los **ejemplos positivos** funcionan mejor que las prohibiciones. Hay que incluir en la capa 1 al menos:
|
||||
|
||||
- 2 ejemplos de diagnóstico bien escrito (uno con dolor cuantificado, uno donde falta la cifra y se declara)
|
||||
- 2 ejemplos de descripción de servicio traducida a resultado
|
||||
- 2 ejemplos de exclusión específica vs. genérica
|
||||
- 1 ejemplo de sección 08 bien poblada
|
||||
- 1 ejemplo de qué se ve cuando la transcripción es pobre (documento honesto con muchos pendientes, en lugar de documento inventado)
|
||||
|
||||
Ese último ejemplo es el más importante y el que se suele omitir.
|
||||
|
||||
---
|
||||
|
||||
## 10. Guardarraíles y riesgos
|
||||
|
||||
### 10.1 Matriz de riesgos
|
||||
|
||||
| Riesgo | Severidad | Mitigación |
|
||||
|---|---|---|
|
||||
| **La IA inventa un precio** | Crítica | P1 + validación programática §8.3.1. Los totales se toman del objeto de cotización en el render, no del texto generado |
|
||||
| **La IA inventa una cifra del cliente** | Crítica | Etiqueta de confianza obligatoria + campo `evidencia` + validación de que las citas existan en las fuentes |
|
||||
| **Fuga de datos personales de empleados** | Crítica | Sanitización de PII previa (§7.3.2) + prohibición explícita en el prompt + revisión humana |
|
||||
| **El anexo interno llega al cliente** | Crítica | Archivo separado con marca visual inconfundible, nunca sección oculta (§6.1) |
|
||||
| **Promesa de resultado garantizado en pauta/SEO** | Alta | Prohibición explícita + lista de palabras vetadas en validación post-generación |
|
||||
| **Importación de precios en USD desde el vault** | Alta | Prohibición explícita + validación: ningún monto del documento puede estar en USD ni ser un número que no exista en la cotización |
|
||||
| **Se menciona una plataforma de CRM que no es Bucéfalo** | Alta | Regla de marca en prompt + validación por lista de términos prohibidos |
|
||||
| **La propuesta contradice el PDF manual** | Alta | Los dos documentos se generan del mismo objeto de cotización; el de IA se regenera si la cotización cambia (invalidación por `updatedAt`) |
|
||||
| **Scope creep porque las exclusiones son genéricas** | Media | Requerir mínimo 3 exclusiones con campo `origen` no vacío; si la IA no puede justificarlas, el documento se marca como incompleto |
|
||||
| **La IA propone servicios que el asesor no eligió** | Media | P1 + validación §8.3.2. Las sugerencias van sólo al bloque interno |
|
||||
| **Costo de API descontrolado** | Baja | Ver §11.4: el costo es despreciable frente al ticket. Aun así: caché de prefijo + límite de tamaño de transcripción + conteo previo de tokens |
|
||||
| **El asesor aprueba sin leer** | Media | La UI debe hacer visible el semáforo de salud y el conteo de afirmaciones sin evidencia **antes** del botón de aprobar |
|
||||
| **Rechazo por clasificador de seguridad** | Baja | Manejar `stop_reason: "refusal"` antes de leer `content`; activar `fallbacks: "default"`. Poco probable en este dominio pero el código debe no reventar |
|
||||
|
||||
### 10.2 El mecanismo central de honestidad
|
||||
|
||||
Este es el diseño del que depende que el sistema sea confiable, y merece su propia sección.
|
||||
|
||||
**El problema.** Todo generador de documentos con LLM tiene la misma tentación: cuando falta información, rellenar con plausible. Una propuesta comercial con una cifra inventada del negocio del cliente no es un error cosmético — es una mentira con el logo de E3 encima, que el cliente puede refutar en la reunión de presentación.
|
||||
|
||||
**La solución.** La plantilla HTML ya trae el canal de salida para la incertidumbre: la **sección 06, Estado de materiales del cliente**, con sus dos tarjetas y tres estados (`done` ✓, `pend` ○, `neutral` ·).
|
||||
|
||||
Se convierte esa sección en el destino obligatorio de todo hueco de información:
|
||||
|
||||
```
|
||||
¿La IA no encontró el dato?
|
||||
├─ ¿Es un material que el cliente debe entregar?
|
||||
│ → sección 08, tarjeta "Materiales", estado pendiente
|
||||
├─ ¿Es una decisión que el cliente debe tomar?
|
||||
│ → sección 08, tarjeta "Decisiones", con quién decide y fecha sugerida
|
||||
├─ ¿Es una cifra del negocio que nadie confirmó?
|
||||
│ → sección 01b con confianza "por_validar", y punto a confirmar en la 08
|
||||
└─ ¿Es información que el asesor necesita conseguir?
|
||||
→ bloque interno, campo `huecos`, con "qué falta / por qué importa / cómo obtenerlo"
|
||||
```
|
||||
|
||||
**Lo elegante del diseño:** un hueco de información deja de ser un defecto del documento y se vuelve **contenido de valor**. Un cliente que recibe una propuesta con una sección clara de "esto necesitamos de ustedes, y esto está pendiente de decidir" percibe rigor, no incompetencia. Y de paso transfiere la responsabilidad del retraso a donde corresponde — que es exactamente lo que dice el footer de la plantilla: *"El avance queda condicionado a la entrega de materiales por parte del cliente."*
|
||||
|
||||
**La regla de oro operativa:** una propuesta con 8 pendientes honestos es infinitamente mejor que una con 8 cifras inventadas. El prompt debe decir esto literalmente, y el ejemplo de §9.4 debe demostrarlo.
|
||||
|
||||
---
|
||||
|
||||
## 11. Consideraciones técnicas
|
||||
|
||||
### 11.1 Elección de modelo
|
||||
|
||||
Recomendación: **`claude-opus-5`** para los tres pasos del pipeline.
|
||||
|
||||
| Modelo | Precio (entrada / salida por MTok) | Contexto | Cuándo usarlo aquí |
|
||||
|---|---|---|---|
|
||||
| `claude-opus-5` | $5 / $25 | 1M | **Recomendado.** Los tres pasos. Es una cotización de decenas de miles de pesos; la diferencia de costo con Sonnet es de centavos |
|
||||
| `claude-sonnet-5` | $3 / $15 (intro $2 / $10 hasta 2026-08-31) | 1M | Alternativa si el volumen crece mucho. Probar en el paso 3 (redacción) antes que en el 1 (extracción) |
|
||||
| `claude-haiku-4-5` | $1 / $5 | 200K | Sólo para tareas mecánicas auxiliares: detectar idioma, clasificar tipo de archivo, sanitizar formato |
|
||||
|
||||
**Por qué Opus 5 y no el más barato:** la calidad del diagnóstico es el producto. Un diagnóstico mediocre produce una propuesta que compite por precio, y eso cuesta miles de pesos de margen. Ahorrar $0.15 USD por documento para perder 10% de ticket es una decisión de negocio terrible. El costo del modelo no es la variable a optimizar aquí.
|
||||
|
||||
**Detalles de la API que importan:**
|
||||
- El thinking está **activo por defecto** en Opus 5 — no hay que configurarlo. `output_config: { effort: "high" }` para pasos 1 y 2, `"medium"` para el 3.
|
||||
- `max_tokens` limita thinking + texto juntos. Para el paso 3, que produce un documento completo, hay que dar holgura: **usar streaming** con `max_tokens` alto (>16K obliga a streaming para no chocar con timeouts HTTP del SDK).
|
||||
- No usar `temperature`, `top_p` ni `top_k` — están removidos en Opus 5 y devuelven 400.
|
||||
- No usar prefill de mensaje de asistente — devuelve 400. Para forzar formato: structured outputs.
|
||||
- Manejar `stop_reason: "refusal"` antes de leer `content`, y activar `fallbacks: "default"` con el header beta `server-side-fallback-2026-07-01`.
|
||||
|
||||
### 11.2 SDK y punto de integración
|
||||
|
||||
El proyecto es TypeScript/Next.js → **`@anthropic-ai/sdk`**. Nada de llamadas HTTP crudas ni de shims compatibles con otros proveedores.
|
||||
|
||||
Dos alternativas de arquitectura:
|
||||
|
||||
**Opción A — Route handler en Next.js.** `src/app/api/propuesta-ia/[id]/route.ts`, siguiendo el patrón de `export/pdf/[id]`. Más simple, un solo despliegue, comparte auth JWT y middleware. Riesgo: un paso de 3 llamadas con `effort: high` puede tardar minutos; requiere streaming al cliente o un patrón de job asíncrono (crear job → poll de estado → descargar).
|
||||
|
||||
**Opción B — En el servicio Python de `api/`.** Ya tiene MCP y auth por API key, y está pensado para agentes. Ventaja: la generación no bloquea el servidor web. Desventaja: duplica la lógica del prompt en otro lenguaje, y el proyecto ya sufre de duplicación de `calculators`.
|
||||
|
||||
**Recomendación:** Opción A con patrón de job. Un modelo nuevo (`PropuestaIA`: `cotizacionId`, `estado`, `objetoGenerado` JSON, `htmlRenderizado`, `costoTokens`, `createdAt`, `aprobadaPor`, `aprobadaAt`) permite historial, auditoría y regeneración sin perder versiones anteriores.
|
||||
|
||||
### 11.3 Caché de prompt
|
||||
|
||||
El caché es prefix match: cualquier cambio de un byte invalida todo lo que sigue. Orden de render: `tools` → `system` → `messages`.
|
||||
|
||||
Diseño para este caso:
|
||||
|
||||
| Contenido | Tamaño estimado | Cacheable | Notas |
|
||||
|---|---|---|---|
|
||||
| Filosofía + frameworks + reglas + contrato + ejemplos | 12-20K tokens | **Sí** — breakpoint aquí | Congelado. Cambia sólo cuando se edita la filosofía |
|
||||
| Catálogo de servicios activo | 3-6K tokens | **Sí** — segundo breakpoint | Cambia cuando se edita el catálogo; serializar con orden determinista (por `orden`, `id`) |
|
||||
| Cotización estructurada | 3-5K tokens | No | Varía por cotización |
|
||||
| Transcripción + notas | 5-20K tokens | No | Varía por cotización |
|
||||
|
||||
Notas operativas:
|
||||
- El mínimo cacheable en Opus 5 es **512 tokens** (bajó desde 1024 en Opus 4.8). La capa 1 lo supera con holgura.
|
||||
- Máximo 4 breakpoints por petición. Con dos alcanza.
|
||||
- Lectura de caché ≈ 0.1× del precio de entrada; escritura 1.25× (TTL 5 min) o 2× (TTL 1h). Con 2+ peticiones el TTL de 5 minutos ya sale a favor — y el pipeline de 3 pasos garantiza al menos 3 peticiones seguidas con el mismo prefijo.
|
||||
- **Invalidadores silenciosos a evitar:** `new Date()` en el system prompt, `JSON.stringify` de un objeto con orden de llaves no determinista, el número de cotización en la capa 1, cambio de modelo a media conversación.
|
||||
- Verificar con `response.usage.cache_read_input_tokens`. Si sale 0 en peticiones repetidas con el mismo prefijo, hay un invalidador escondido.
|
||||
|
||||
### 11.4 Costos estimados
|
||||
|
||||
Escenario base por documento (una cotización con transcripción de 60 min):
|
||||
|
||||
```
|
||||
Entrada: capa estable ~18K + catálogo ~5K + cotización ~4K + contexto ~15K ≈ 42K tokens
|
||||
Salida: objeto estructurado + razonamiento ≈ 8K tokens
|
||||
Peticiones: 3 (pipeline de §9.3), las 3 comparten prefijo de 23K
|
||||
```
|
||||
|
||||
| Configuración | Costo estimado por documento |
|
||||
|---|---|
|
||||
| Opus 5 sin caché, 1 petición | ≈ $0.41 USD |
|
||||
| Opus 5 con caché, pipeline de 3 pasos | ≈ **$0.30 – $0.55 USD** |
|
||||
| Sonnet 5 con caché (precio intro) | ≈ $0.12 – $0.22 USD |
|
||||
| Batch API (50% descuento) si se generan en lote nocturno | ≈ mitad de lo anterior |
|
||||
|
||||
A 20 MXN/USD: **entre $6 y $11 MXN por documento** con Opus 5.
|
||||
|
||||
**El insight de negocio:** el paquete PyME más barato del catálogo es de ~$7,490 MXN. El costo de generar su propuesta consultiva es **0.1% del ticket**. En el paquete de escalamiento ($90,800 MXN) es 0.01%.
|
||||
|
||||
Con 40 cotizaciones al mes: **~$12–22 USD/mes** (~$240–440 MXN). Menos que una comida.
|
||||
|
||||
Conclusión: **el costo del modelo no es una restricción de diseño.** Cualquier decisión que sacrifique calidad de output para ahorrar tokens está optimizando la variable equivocada. Optimizar para calidad, medir con `countTokens` para no llevarse sorpresas, y ya.
|
||||
|
||||
### 11.5 Renderizado del documento
|
||||
|
||||
La plantilla HTML es autocontenida (CSS inline, sin dependencias externas más que Google Fonts). Dos rutas:
|
||||
|
||||
1. **HTML directo** — un renderizador toma el objeto validado y produce el HTML usando la plantilla como base. Ventajas: fiel al diseño, imprimible con `@media print`, editable, ligero. Requiere sustituir Google Fonts por fuentes embebidas si se quiere funcionamiento offline o dentro de un PDF.
|
||||
2. **PDF vía PDFKit** — reutiliza `pdf-generator.ts`. Coherente con el resto del sistema, pero la plantilla HTML tiene gradientes, radial-gradients y tipografía serif/sans mezclada que en PDFKit son trabajo considerable.
|
||||
|
||||
**Recomendación:** HTML como entregable primario (se ve mejor, se comparte por link o adjunto, y el cliente lo abre en el celular). Si se necesita PDF, imprimir el HTML desde el navegador o con un headless — no reimplementar el diseño en PDFKit.
|
||||
|
||||
Nota heredada del proyecto: en `pdf-generator.ts` hay un bug documentado de auto-page-break en el footer (`doc.text()` en `y > page.height - margins.bottom` dispara página nueva). Si se va por PDFKit, ese bug ya tiene workaround en el código: poner `margins.bottom = 0` temporalmente.
|
||||
|
||||
Los colores y el logo salen de `Configuracion` (`color_primario`, `color_secundario`, `logo_base64`), así que el documento respeta la marca sin hardcodear.
|
||||
|
||||
---
|
||||
|
||||
## 12. Métricas de éxito del plugin
|
||||
|
||||
Si no se puede medir, no se sabe si sirvió. Estas son las métricas, separadas por qué preguntan.
|
||||
|
||||
### 12.1 ¿La IA escribe bien? (calidad del output)
|
||||
|
||||
| Métrica | Cómo medirla | Meta inicial |
|
||||
|---|---|---|
|
||||
| Tasa de edición del asesor | % de campos del objeto modificados antes de aprobar | <30% |
|
||||
| Afirmaciones sin evidencia | Conteo por documento (validación automática) | 0 |
|
||||
| Citas no verificables | Citas que no aparecen en las fuentes | 0 |
|
||||
| Rechazos completos | Documentos descartados y regenerados desde cero | <10% |
|
||||
| Tiempo de revisión | Minutos entre generación y aprobación | <15 min |
|
||||
|
||||
### 12.2 ¿Sirvió comercialmente? (impacto en el negocio)
|
||||
|
||||
| Métrica | Cómo medirla | Por qué importa |
|
||||
|---|---|---|
|
||||
| Tasa de cierre con vs. sin documento consultivo | Comparar `estado: aprobada` entre cotizaciones con y sin propuesta de IA | La prueba central de la tesis |
|
||||
| Ticket promedio | Total promedio de cotizaciones aprobadas, ambos grupos | La base de conocimiento predice +16-28% con opciones bien presentadas |
|
||||
| Objeciones de precio | Registrar en `observaciones` si el cliente pidió descuento | Un buen anclaje de valor debería reducirlas |
|
||||
| Tiempo de ciclo | Días entre `fecha` y cambio a `aprobada`/`rechazada` | Una propuesta clara decide más rápido, en cualquier dirección |
|
||||
| Scope creep | Cotizaciones que requirieron orden de cambio | El objetivo de las exclusiones específicas |
|
||||
| Conversión a mensualidad | % de cotizaciones aprobadas que incluyen servicio `mensual` o plan Bucéfalo | El objetivo de la sección de mantenimiento |
|
||||
|
||||
**Advertencia metodológica:** con 40 cotizaciones al mes, cualquier comparación de tasa de cierre tarda meses en ser significativa, y hay mil variables confundidas (el asesor, el sector, la temporada, el tamaño del cliente). No conviene tomar decisiones grandes con 3 semanas de datos. Lo honesto es empezar midiendo §12.1, que sí es medible de inmediato, y dejar §12.2 acumular.
|
||||
|
||||
### 12.3 ¿Cuesta lo que debe? (operación)
|
||||
|
||||
- Costo por documento generado (tokens de entrada/salida × precio, guardado en `PropuestaIA.costoTokens`)
|
||||
- Tasa de aciertos de caché (`cache_read_input_tokens / total`)
|
||||
- Latencia p50 y p95 del pipeline completo
|
||||
- Tasa de fallos: refusals, timeouts, validaciones rechazadas
|
||||
|
||||
---
|
||||
|
||||
## 13. Roadmap sugerido
|
||||
|
||||
Cada fase entrega algo usable. Ninguna requiere la siguiente para tener valor.
|
||||
|
||||
### Fase 0 — Ganancia inmediata sin IA (días)
|
||||
|
||||
**Imprimir `observaciones` y `notas` en el PDF y el Excel.** Es un cambio de pocas líneas en `pdf-generator.ts` y `excel-builder.ts`, y recupera información que ya se está capturando y descartando.
|
||||
|
||||
Esto no requiere nada de este documento. Debería hacerse ya, independientemente de si el plugin se construye.
|
||||
|
||||
### Fase 1 — Validación de calidad (1-2 semanas)
|
||||
|
||||
Sin UI, sin base de datos, sin despliegue. Un script que:
|
||||
- Lee una cotización existente vía la API o Prisma
|
||||
- Lee una transcripción de un archivo local
|
||||
- Corre el pipeline de 3 pasos
|
||||
- Escupe el objeto JSON y un HTML
|
||||
|
||||
**El entregable real no es el script: son 5-10 documentos generados sobre cotizaciones reales pasadas, revisados por el asesor.** Si esos documentos no son buenos, nada de lo demás importa y hay que iterar el prompt, no construir infraestructura.
|
||||
|
||||
Criterio de avance: el asesor dice *"esto lo mandaría a un cliente después de editarlo 10 minutos."*
|
||||
|
||||
### Fase 2 — Integración mínima (2-3 semanas)
|
||||
|
||||
- Modelo `PropuestaIA` y `ContextoCotizacion` en Prisma
|
||||
- Zona de carga de archivos en `CotizacionForm.tsx`
|
||||
- Route handler con patrón de job (crear → poll → descargar)
|
||||
- Renderizador HTML desde la plantilla
|
||||
- Vista de revisión con semáforo de salud y evidencia expandible
|
||||
- Botón de aprobación que registra quién y cuándo
|
||||
|
||||
### Fase 3 — Inteligencia comercial (3-4 semanas)
|
||||
|
||||
- Anexo interno como archivo separado
|
||||
- Semáforo de salud de §5.1 en el dashboard, agregado sobre todas las cotizaciones
|
||||
- Sugerencia de esquema de 2-3 opciones cuando `esDoble = false`
|
||||
- Alerta de subcotización (ratio precio/valor <10%)
|
||||
- Métricas de §12.1 instrumentadas
|
||||
|
||||
### Fase 4 — Cierre del ciclo (después, con datos)
|
||||
|
||||
- Aprendizaje de las ediciones del asesor: qué corrige sistemáticamente → ajuste del prompt
|
||||
- Comparación de tasa de cierre (sólo cuando haya volumen suficiente)
|
||||
- Herramienta MCP nueva: `generar_propuesta_consultiva` en `api/app/mcp/tools.py`, para que un agente externo pueda pedirla
|
||||
- Reutilización del documento en la conversación de retainer a las 2 semanas post-entrega (M9)
|
||||
|
||||
---
|
||||
|
||||
## 14. Decisiones abiertas
|
||||
|
||||
Cosas que hay que decidir antes de implementar y que este análisis no puede resolver solo.
|
||||
|
||||
| # | Decisión | Opciones | Recomendación |
|
||||
|---|---|---|---|
|
||||
| D1 | ¿Dónde se genera? | Route handler en Next.js vs. servicio Python | Next.js con patrón de job (§11.2) |
|
||||
| D2 | ¿Dónde viven las transcripciones? | Adjuntos en BD · disco · Files API | Disco para Fase 1, adjuntos en BD para Fase 2 |
|
||||
| D3 | ¿Un documento o dos archivos? | Documento del cliente + anexo interno separados, o uno solo | **Dos archivos.** El riesgo de fuga del anexo es demasiado alto (§6.1) |
|
||||
| D4 | ¿HTML o PDF como entregable? | HTML · PDF · ambos | HTML primario; PDF por impresión del navegador si se necesita |
|
||||
| D5 | ¿El plugin puede sugerir servicios? | Sí en la propuesta · sólo en el anexo interno · no | **Sólo en el anexo interno** (M13, criterio ético) |
|
||||
| D6 | ¿Se regenera al cambiar la cotización? | Automático · manual con aviso · manual silencioso | Manual con aviso de desincronización visible |
|
||||
| D7 | ¿Quién puede aprobar? | Cualquier asesor · sólo el dueño de la cotización · rol admin | El asesor dueño; admin puede aprobar cualquiera |
|
||||
| D8 | ¿Se guarda la transcripción cruda o sólo la sanitizada? | Cruda · sanitizada · ambas | Sólo sanitizada en BD. La cruda no debe persistir con datos de empleados |
|
||||
| D9 | ¿Se versiona el prompt? | Sí, con las propuestas apuntando a su versión · no | Sí. Sin esto no se puede saber si un cambio de prompt mejoró o empeoró |
|
||||
| D10 | ¿Qué pasa si no hay transcripción? | Bloquear · generar con lo que haya · generar sólo el esqueleto | Generar con lo que haya, con la sección 08 muy poblada y aviso claro de confianza baja |
|
||||
|
||||
---
|
||||
|
||||
## Anexo A — Mapeo campo → sección
|
||||
|
||||
Referencia rápida para implementación.
|
||||
|
||||
| Sección del documento | Fuentes de datos |
|
||||
|---|---|
|
||||
| Hero | `Cliente.nombre`, `.empresa`, `Cotizacion.numero`, `.fecha`, `.vigencia`, `.proyecto`, `User.name` (asesor) |
|
||||
| 01 Diagnóstico | Transcripción, `Cotizacion.observaciones`, `ServicioCotizado.notas`, archivos de notas |
|
||||
| 01b Valor del problema | Transcripción (4 dimensiones), `totales.total` para el ratio |
|
||||
| 02 Resultados | Derivado del diagnóstico + `ServicioCotizado.entregables` |
|
||||
| 03 Alcance | `ServicioCotizado[]` (nombre, fase, tipoPago, precio, tiempoEntrega, entregables), `Categoria.nombre` |
|
||||
| Totales | `calculators.ts` — copiados literalmente, `IVA_RATE`, descuentos |
|
||||
| 04 Opciones | `Cotizacion.esDoble`, `.opcionesMetadata`, `ServicioCotizado.opcion` |
|
||||
| 05 No incluye | Transcripción (menciones fuera de alcance), `opcionesMetadata[].noIncluye` |
|
||||
| 06 Por qué tiene sentido | `ServicioCotizado.beneficios`, cruzado con hallazgos del diagnóstico |
|
||||
| 07 Mantenimiento | `PlanBucefaloCotizacion`, servicios con `tipoPago: mensual`, `modeloCobro: retainer`, `Bono[]` |
|
||||
| 08 Materiales y decisiones | Huecos detectados + dependencias mencionadas en la transcripción |
|
||||
| 09 Backlog | Fricciones mencionadas fuera del alcance de fase 1 |
|
||||
| Footer | `Configuracion.logo_base64`, `.color_primario`, `.color_secundario` + condiciones fijas |
|
||||
| Financiamiento (si aplica) | `FinanciamientoPlan[]`, `Cotizacion.incluirFinanciamiento`, `calcularFinanciamiento()` |
|
||||
| Anexo interno | Todo lo anterior + `RegistroHoras` si aplica + análisis de §5.1 |
|
||||
|
||||
---
|
||||
|
||||
## Anexo B — Checklist de calidad antes de enviar
|
||||
|
||||
Adaptado de `Onboarding-Cliente/00-Guia-de-Uso-y-Checklist-Calidad.md`. Este checklist debe estar visible en la UI de revisión, no enterrado en un documento.
|
||||
|
||||
**Problema y valor**
|
||||
- [ ] El problema está redactado en lenguaje del cliente, sin jerga técnica
|
||||
- [ ] Hay al menos un ejemplo real y reciente del problema, citado
|
||||
- [ ] Se estimó el costo anual, con las cifras etiquetadas por confianza
|
||||
- [ ] La métrica de éxito tiene línea base, resultado deseado y periodo
|
||||
- [ ] Consta si se habló con el usuario operativo, no sólo con quien autoriza
|
||||
|
||||
**Viabilidad y alcance**
|
||||
- [ ] Se sabe dónde viven los datos/accesos y quién los autoriza
|
||||
- [ ] La fase 1 resuelve un cuello de botella prioritario, no todos
|
||||
- [ ] Está explícito: incluido ahora / excluido ahora / backlog futuro
|
||||
- [ ] Hay responsables del cliente y decisiones pendientes identificadas
|
||||
- [ ] Está definido qué significa "terminado" y quién acepta
|
||||
|
||||
**Propuesta comercial**
|
||||
- [ ] Si hay opciones, cambian alcance o nivel de servicio — no sólo el precio
|
||||
- [ ] La opción recomendada sí cumple el resultado de negocio definido
|
||||
- [ ] El precio se sustenta en valor, costo real y mercado
|
||||
- [ ] El mantenimiento aparece con servicios concretos, límites y tiempos de respuesta
|
||||
- [ ] Se presentará en llamada, no como cifra suelta por mensajería
|
||||
|
||||
**Integridad del documento generado**
|
||||
- [ ] Todo número coincide con el documento manual
|
||||
- [ ] Cero afirmaciones sin evidencia
|
||||
- [ ] Cero cifras marcadas como confirmadas sin origen
|
||||
- [ ] Ningún dato personal de empleados del cliente
|
||||
- [ ] Ningún monto en USD
|
||||
- [ ] Ninguna promesa de resultado garantizado
|
||||
- [ ] El CRM se menciona como Bucéfalo
|
||||
- [ ] El anexo interno está en archivo separado y no se va a enviar
|
||||
|
||||
---
|
||||
|
||||
## Anexo C — Cruce con la base de conocimiento
|
||||
|
||||
Para profundizar durante la implementación:
|
||||
|
||||
- **Preguntas de diagnóstico completas:** `Base de Conocimiento - IA Negocios y Dev/03-Preguntas-Guia.md`
|
||||
- **Playbooks de pricing y cierre:** `08-Monetizacion-Onboarding-Pricing-Seguimiento.md`
|
||||
- **Errores a evitar:** `01-Errores-a-Evitar.md`, `sintesis/s3-Errores-Fatales.md`
|
||||
- **Modelos de pricing detallados:** `sintesis/s2-Pricing-Cobranza.md`
|
||||
- **Prompts y plantillas base:** `sintesis/s8-Prompts-Plantillas.md` (§1 system prompt, §3 diagnóstico, §4 propuesta, §9 output estándar)
|
||||
- **Las cuatro sesiones de onboarding:** `Onboarding-Cliente/01` a `04`, con `00-Guia-de-Uso-y-Checklist-Calidad.md` como criterio de calidad
|
||||
- **Playbook maestro:** `Guia_Onboarding_Cliente_y_Ruta_de_Trabajo.md`
|
||||
- **Paquetes del catálogo:** `docs/paquetes-recomendados-pyme.md` (este repo)
|
||||
- **Convenciones del proyecto:** `AGENTS.md` (este repo)
|
||||
|
||||
---
|
||||
|
||||
## Cierre
|
||||
|
||||
El Cotizador E3 ya sabe cuánto cobrar. Lo que le falta es explicar por qué vale.
|
||||
|
||||
Ese "por qué" no se inventa: se extrae de lo que el cliente ya dijo en la reunión, de lo que el asesor ya anotó en el campo de observaciones, y del catálogo que ya está armado. Está todo ahí, disperso y sin usar.
|
||||
|
||||
El plugin no es un generador de texto bonito. Es un **traductor**: convierte una lista de precios en un argumento de negocio, usando material que ya existe y sin tocar un solo número. Y cuando no tiene material suficiente, lo dice — porque una propuesta con pendientes honestos cierra mejor que una con cifras inventadas, y porque el día que un cliente refute un dato inventado, el costo no lo paga el modelo: lo paga la marca.
|
||||
|
||||
---
|
||||
|
||||
*Documento de análisis previo a implementación · Consultoría E3 · 2026-07-28*
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,511 @@
|
||||
# Propuesta consultiva con IA — Diseño de Fase 0 y Fase 1
|
||||
|
||||
> **Qué es este documento:** la especificación técnica cerrada de las dos primeras fases del
|
||||
> plugin descrito en [`docs/BI-propuesta-consultiva-IA.md`](../../BI-propuesta-consultiva-IA.md).
|
||||
> Aquel documento es el análisis de negocio y dice explícitamente que no es un spec. Este sí lo es.
|
||||
>
|
||||
> **Alcance:** Fase 0 (recuperar el contexto humano que hoy se descarta, más los bloqueadores que
|
||||
> el análisis destapó) y Fase 1 (script local que valida si la IA escribe documentos utilizables).
|
||||
> Fases 2-4 quedan fuera y tendrán su propio ciclo.
|
||||
>
|
||||
> **Fecha:** 2026-07-28 · **Estado:** Fase 0 desplegada en producción · Fase 1 pendiente
|
||||
> **Base verificada:** commit `26e6d3a9`
|
||||
|
||||
---
|
||||
|
||||
## 0. Registro de ejecución — Fase 0 (2026-07-28)
|
||||
|
||||
Fase 0 está en producción. Tres cosas salieron distinto de lo diseñado y este documento
|
||||
quedaría mintiendo si no se dijeran.
|
||||
|
||||
### 0.1 El movimiento de datos (Despliegue B) se canceló, no se pospuso
|
||||
|
||||
El §4.3 describe un `UPDATE` que mueve `observaciones` → `observacionesInternas`. **No se
|
||||
va a ejecutar nunca.** Al inspeccionar producción antes de migrar, la única fila con
|
||||
`observaciones` no vacías resultó ser `UJ2606AG777` (estado `aprobada`), y su texto son
|
||||
condiciones de pago dirigidas al cliente en segunda persona: *"llevamos una bitácora de
|
||||
horas con acceso para ti; a fin de mes te enviamos el reporte… solo pagas las horas
|
||||
efectivamente trabajadas."*
|
||||
|
||||
Aplicar el `UPDATE` conservador habría ocultado condiciones ya acordadas de un documento
|
||||
emitido. Esa fila ya estaba clasificada correctamente. La migración quedó reducida a
|
||||
`ADD COLUMN IF NOT EXISTS`: cero filas modificadas. Verificado tras el despliegue —
|
||||
conteos `2/3/59/5/2` idénticos al respaldo y cero filas en `observacionesInternas`.
|
||||
|
||||
**Lección para el futuro: mirar el dato real antes de diseñar su migración.** El diseño
|
||||
"conservador" era el equivocado para estos datos.
|
||||
|
||||
### 0.2 El servidor MCP se retiró en vez de asegurarse
|
||||
|
||||
El §4.1 diseñaba Fase 0-A como *"aplicar `require_auth` + lista blanca de columnas"*. Eso
|
||||
se implementó y se verificó en producción (401 sin credencial). Después se descubrió que,
|
||||
**con credencial válida, el endpoint devolvía 500**: el código construía un
|
||||
`StreamableHTTPServerTransport` por petición sin manejo de sesión. Llevaba roto desde antes
|
||||
de este trabajo — lo que estaba expuesto era la puerta abierta de un cuarto averiado.
|
||||
|
||||
Dado que nadie lo usaba, se retiró por completo (endpoint, paquete `api/app/mcp/` y la
|
||||
dependencia). Es una mitigación más fuerte que autenticarlo. Recuperable con
|
||||
`git show edb500f5:api/app/mcp/server.py`.
|
||||
|
||||
### 0.3 Una dependencia sin fijar tumbó el API 50 minutos
|
||||
|
||||
`api/requirements.txt` tenía `mcp>=1.0.0`. La primera reconstrucción en dos semanas tomó
|
||||
`mcp` 2.0.0, que eliminó `Server.list_tools()`. El import lanzó `AttributeError` al
|
||||
arrancar y el contenedor quedó en crash-loop.
|
||||
|
||||
Lo agravó que `main.py` capturara solo `ImportError` alrededor del montaje del MCP: un
|
||||
`AttributeError` se escapó y tumbó también el REST, por un componente opcional.
|
||||
|
||||
Once de las doce dependencias eran rangos `>=` sin techo. **Todas se fijaron a versión
|
||||
exacta** — las que corrían sanas en producción. El `web` (Next.js) nunca estuvo caído:
|
||||
tiene `package-lock.json` y es reproducible.
|
||||
|
||||
---
|
||||
|
||||
## 1. Por qué el alcance es este
|
||||
|
||||
El documento de negocio describe ocho subsistemas. Construirlos de una vez significa un mes de
|
||||
trabajo antes de saber si la tesis funciona. Su propio §13 argumenta la salida:
|
||||
|
||||
> *"El entregable real no es el script: son 5-10 documentos generados sobre cotizaciones reales,
|
||||
> revisados por el asesor. Si esos documentos no son buenos, nada de lo demás importa y hay que
|
||||
> iterar el prompt, no construir infraestructura."*
|
||||
|
||||
Se adopta ese criterio. Fase 1 termina cuando el asesor puede decir *"esto lo mandaría a un
|
||||
cliente después de editarlo 10 minutos"* — o cuando queda claro que no.
|
||||
|
||||
El análisis previo a este spec encontró cuatro problemas que el documento de negocio no anticipaba.
|
||||
Tres son bloqueadores y entran al alcance; el cuarto cambia dónde vive un dato.
|
||||
|
||||
---
|
||||
|
||||
## 2. Hallazgos que modifican el plan original
|
||||
|
||||
Los cuatro están verificados en disco, no inferidos.
|
||||
|
||||
### 2.1 🔴 El endpoint MCP publica todas las cotizaciones sin autenticación
|
||||
|
||||
| Eslabón | Evidencia |
|
||||
|---|---|
|
||||
| `POST /mcp` no valida nada | `api/main.py:107` — sin un solo `Depends()`. Cero coincidencias de `require_auth` en el archivo |
|
||||
| La función de auth existe y no se usa ahí | `api/app/auth.py:45` define `require_auth` |
|
||||
| La herramienta devuelve la fila completa | `api/app/mcp/server.py:250` — `SELECT c.*` seguido de `dict(cot)`, sin lista blanca |
|
||||
| Tiene dominio público en producción | `docker-compose.coolify.yml:67` — `SERVICE_FQDN_API_8000` |
|
||||
|
||||
El agujero **ya existe**: precios, catálogo y datos de clientes son legibles hoy por cualquiera.
|
||||
Lo relevante para este spec es que `SELECT c.*` publicaría la columna nueva de notas internas sin
|
||||
que nadie toque `server.py`. Entra al alcance como **Fase 0-A**, previa a todo lo demás.
|
||||
|
||||
### 2.2 🟠 No existe una fuente de verdad para los totales
|
||||
|
||||
La regla de validación §8.3.1 del documento de negocio exige comparar contra *"el total de la
|
||||
cotización en BD"*. No hay tal cosa:
|
||||
|
||||
- Ninguna función devuelve los totales de una cotización. El cálculo está duplicado con
|
||||
`.filter().reduce()` en **siete** consumidores (PDF, Excel, detalle, PreciosEditables, el
|
||||
formulario, la lista y el dashboard), con criterios que no coinciden.
|
||||
- El IVA está hardcodeado como `* 1.16` en `pdf-generator.ts:328-329` y `excel-builder.ts:377-378`,
|
||||
ignorando `IVA_RATE`.
|
||||
- El flag `Cotizacion.incluirIva` no se respeta en esos cálculos.
|
||||
|
||||
Hoy el PDF y el Excel de una misma cotización pueden discrepar y nada lo detecta. Entra como
|
||||
**Fase 0-B**.
|
||||
|
||||
### 2.3 🔴 El Excel es un documento del cliente, no una herramienta interna
|
||||
|
||||
Este hallazgo corrigió un supuesto equivocado del diseño inicial, que proponía poner las notas
|
||||
internas en el Excel.
|
||||
|
||||
| Evidencia | Ubicación |
|
||||
|---|---|
|
||||
| Banner con la razón social de E3 | `excel-builder.ts:165` |
|
||||
| `"En atencion a:"` + nombre del cliente | `excel-builder.ts:181` |
|
||||
| Nota legal de precios, IVA y vigencia | `excel-builder.ts:400` |
|
||||
| Razón social + domicilio fiscal al pie de cada hoja de detalle | `excel-builder.ts:539-547` |
|
||||
| Nombre de archivo `{empresa} - {cliente} - {numero}.xlsx` | `src/app/api/export/excel/[id]/route.ts:76` |
|
||||
| Botón en la misma fila que Preview PDF y PDF | `src/app/(app)/cotizaciones/[id]/page.tsx:93-95` |
|
||||
|
||||
Escenario de fallo: el asesor exporta ambos, caen en Descargas con el mismo prefijo, los arrastra
|
||||
juntos al correo, y el cliente abre la última pestaña y lee el plan de recorte de precio y las red
|
||||
flags sobre él mismo.
|
||||
|
||||
**Consecuencia:** en Fase 0 las notas internas no entran a **ningún** exportador. Viven solo en la
|
||||
app. Es la misma garantía estructural que ya tiene el PDF.
|
||||
|
||||
### 2.4 🟠 Las transcripciones se sincronizarían a la nube de MEGA
|
||||
|
||||
El repo vive en `H:\MegaSync\Proyectos\Cotizador`. El `.megaignore` actual excluye únicamente
|
||||
`.next`, `node_modules` y `.turbo`. Cualquier transcripción guardada dentro del repo se sube a la
|
||||
nube: nombres de empleados, comentarios de desempeño, cifras salariales. `.gitignore` protege el
|
||||
repositorio, no la sincronización.
|
||||
|
||||
**Consecuencia:** `contexto/` y `salidas/` van a `.gitignore` **y** a `.megaignore`, y la exclusión
|
||||
se verifica empíricamente antes de colocar material real.
|
||||
|
||||
---
|
||||
|
||||
## 3. Decisiones cerradas
|
||||
|
||||
Ninguna de estas se re-litiga durante la implementación.
|
||||
|
||||
| # | Decisión | Resolución | Razón |
|
||||
|---|---|---|---|
|
||||
| D1 | Alcance del ciclo | Fase 0 + Fase 1 | Validar calidad antes de construir infraestructura |
|
||||
| D2 | Separar interno de visible | Campo nuevo `observacionesInternas`; `observaciones` pasa a ser texto del cliente | Hace la fuga estructuralmente imposible en vez de depender de un marcador que se olvida |
|
||||
| D3 | Dónde viven las notas internas | Solo en la app. Ningún exportador | §2.3 |
|
||||
| D4 | Forzar el schema sin structured outputs | Tool-calling: `input_schema` de la herramienta = contrato. Zod valida siempre | MiniMax no soporta `output_config` |
|
||||
| D5 | Proveedor | MiniMax-M3 vía endpoint compatible con Anthropic | Decisión del negocio (Token Plan contratado) |
|
||||
| D6 | Sanitización de PII | Filtro de **salida** solamente | El modelo necesita el contexto completo para diagnosticar; el riesgo real es lo que llega al cliente |
|
||||
| D7 | Seguridad del MCP | Cerrar el agujero primero: `require_auth` + lista blanca de columnas | §2.1 |
|
||||
| D8 | Totales | Función canónica `calcularTotalesCotizacion()` + migrar PDF y Excel | §2.2 |
|
||||
| D9 | Base del ratio precio/valor | Primer año **con IVA** (único + mensual × 12) | Es el desembolso real a 12 meses; hace comparable el ratio contra un valor *anual* |
|
||||
| D10 | Nombres de empleados detectados | Advertir, no bloquear | Un bloqueo heurístico produce falsos positivos constantes y enseña a ignorar la alerta |
|
||||
| D11 | Ubicación de transcripciones | Dentro del repo, en `.gitignore` **y** `.megaignore` | §2.4 |
|
||||
| D12 | Migración de datos | Dos despliegues: A aditivo, B mueve datos | §4.3 |
|
||||
|
||||
---
|
||||
|
||||
## 4. Fase 0 — Recuperar el contexto humano
|
||||
|
||||
Cuatro bloques. A y B son prerrequisitos de C.
|
||||
|
||||
### 4.1 Fase 0-A · Cerrar el MCP
|
||||
|
||||
> **Superado por §0.2.** Esto se implementó tal cual y se verificó (401 sin credencial),
|
||||
> pero después el servidor MCP se retiró por completo. Se conserva el diseño original
|
||||
> porque documenta el agujero que existía y por qué importaba.
|
||||
|
||||
1. Aplicar `require_auth` (`api/app/auth.py:45`) al endpoint `POST /mcp` en `api/main.py:107`.
|
||||
2. Sustituir el `SELECT c.*` de `_obtener_cotizacion` (`api/app/mcp/server.py:250`) por una lista
|
||||
blanca de columnas explícita, con el mismo criterio que el REST ya aplica vía
|
||||
`CotizacionResponse` (`api/app/models/cotizacion.py:130-152`).
|
||||
3. Auditar el resto de `server.py` en busca de otros `SELECT *` y darles el mismo tratamiento.
|
||||
|
||||
**Criterio de aceptación:** una petición `POST /mcp` sin credencial devuelve 401, y
|
||||
`obtener_cotizacion` con credencial válida no incluye `observacionesInternas` en su salida.
|
||||
|
||||
### 4.2 Fase 0-B · Totales canónicos
|
||||
|
||||
Escribir en `src/lib/calculators.ts`:
|
||||
|
||||
```ts
|
||||
calcularTotalesCotizacion(cotizacion): {
|
||||
subtotalUnico, subtotalMensual,
|
||||
ivaUnico, ivaMensual,
|
||||
totalUnico, totalMensual,
|
||||
totalPrimerAnio, // totalUnico + totalMensual * 12, con IVA — base del ratio (D9)
|
||||
moneda
|
||||
}
|
||||
```
|
||||
|
||||
Reglas: usa `IVA_RATE`, respeta `Cotizacion.incluirIva`, y solo suma partidas con
|
||||
`seleccionado: true`. Para cotizaciones dobles se apoya en `calcularTotalesOpcion`.
|
||||
|
||||
Migrar a ella `pdf-generator.ts` y `excel-builder.ts`, eliminando los `* 1.16`. Los otros cinco
|
||||
consumidores se migran en un ciclo posterior; se documenta la deuda.
|
||||
|
||||
**Criterio de aceptación:** para un conjunto de cotizaciones reales, el total del PDF y el del
|
||||
Excel coinciden dígito por dígito, y una cotización con `incluirIva: false` no muestra IVA en
|
||||
ninguno.
|
||||
|
||||
### 4.3 Fase 0-C · El campo de contexto humano
|
||||
|
||||
**Despliegue A — solo aditivo.**
|
||||
|
||||
- `ALTER TABLE "Cotizacion" ADD COLUMN "observacionesInternas" TEXT;` — sin `UPDATE`.
|
||||
- El formulario muestra dos textareas visualmente inconfundibles: *"Observaciones (las ve el
|
||||
cliente)"* y *"Notas internas (no salen de la app)"*, con badge de color distinto.
|
||||
- La vista de detalle muestra ambos campos; el histórico aparece etiquetado como
|
||||
*"Observaciones (histórico, sin clasificar)"*.
|
||||
- El PDF imprime **solo** `observaciones`. `CotizacionPDFData` (`pdf-generator.ts:31-53`) no
|
||||
declara `observacionesInternas` — la garantía es estructural, no disciplinaria.
|
||||
- Ningún exportador recibe el campo interno.
|
||||
|
||||
**Despliegue B — movimiento de datos. CANCELADO, ver §0.1.** El `UPDATE` de abajo no se
|
||||
ejecutó ni se va a ejecutar: la única fila afectada contenía texto dirigido al cliente y ya
|
||||
estaba donde debía. Se conserva por si algún día aparece una instalación con datos mal
|
||||
clasificados.
|
||||
|
||||
```sql
|
||||
UPDATE "Cotizacion"
|
||||
SET "observacionesInternas" = "observaciones",
|
||||
"observaciones" = NULL
|
||||
WHERE "observaciones" IS NOT NULL
|
||||
AND btrim("observaciones") <> ''
|
||||
AND "observacionesInternas" IS NULL; -- guarda de idempotencia, obligatoria
|
||||
```
|
||||
|
||||
Antes de correr B, exportar y guardar **fuera de MegaSync**:
|
||||
|
||||
```sql
|
||||
COPY (SELECT id, numero, estado, observaciones FROM "Cotizacion"
|
||||
WHERE observaciones IS NOT NULL AND btrim(observaciones) <> '')
|
||||
TO STDOUT WITH CSV HEADER;
|
||||
```
|
||||
|
||||
Ese CSV es el `down` que Prisma no da: no hay migraciones de reversa en el repo ni servicio de
|
||||
backup en `docker-compose.coolify.yml`.
|
||||
|
||||
**Por qué dos despliegues.** Si A mueve los datos y el despliegue falla, Coolify redespliega la
|
||||
imagen anterior, el código viejo lee `observaciones` (NULL en el 100% de las filas) y el asesor ve
|
||||
todas sus notas desaparecidas — sin error, sin log, en el momento de máximo estrés.
|
||||
|
||||
**Puntos de integración del campo nuevo** (rastreados de punta a punta):
|
||||
`prisma/schema.prisma`, `src/lib/schemas.ts` (los dos schemas), `src/lib/store.ts`,
|
||||
`CotizacionForm.tsx`, `POST /api/cotizaciones`, `PUT /api/cotizaciones/[id]`,
|
||||
`cotizaciones/[id]/page.tsx`, `cotizaciones/[id]/editar/page.tsx`, y en Python los tres modelos
|
||||
Pydantic (`CotizacionCreate`, `CotizacionUpdate`, `CotizacionResponse`) más el `_add` del PUT.
|
||||
|
||||
Los INSERT de Python **no** son urgentes: la columna es nullable y Postgres pone NULL. Los modelos
|
||||
Pydantic sí lo son — hay precedente demostrado de que sin declararlos el campo nunca sale del API
|
||||
(`incluirIva` existe en la tabla desde `20260630000000` y el API Python no lo devuelve).
|
||||
|
||||
**Deuda declarada:** `zod` se importa en `src/lib/schemas.ts:1` y resuelve transitivamente a 4.3.6,
|
||||
pero no está en `package.json`. Se declara explícitamente (`npm i zod@^4.3.6`); un
|
||||
`npm ci --omit=dev` revienta hoy sin eso, y Fase 1 depende fuertemente de zod.
|
||||
|
||||
### 4.4 Fase 0-D · Bugs vecinos aprobados
|
||||
|
||||
| Bug | Arreglo |
|
||||
|---|---|
|
||||
| Orden de partidas | Ninguna consulta tiene `orderBy` en `servicios`, y `drawSection` (`pdf-generator.ts:216-268`) asume que vienen agrupadas por fase. Añadir `orderBy: [{fase}, {createdAt}]` en las cuatro rutas de export |
|
||||
| Datos bancarios en borrador | `export/pdf/route.ts:45` llama solo a `getConfigBranding()`; el Excel llama a ambas. Añadir `getConfigBancaria()` |
|
||||
| Partida por demanda en $0 | Las copias locales de `detalleModelo` en `pdf-generator.ts:21-29` y `excel-builder.ts:58-66` no manejan `modeloCobro === "demanda"`; la canónica de `calculators.ts:23-41` sí. Usar la canónica |
|
||||
| Bonos con dos redacciones | `pdf-generator.ts:377-384` tiene seis bonos hardcodeados y la tabla `Bono` del seed dice otra cosa; la tabla no se consulta en `src/`. Definir la tabla como fuente de verdad |
|
||||
|
||||
---
|
||||
|
||||
## 5. Fase 1 — Script local de validación de calidad
|
||||
|
||||
Sin base de datos nueva, sin UI, sin despliegue. Un script que lee una cotización y una
|
||||
transcripción, corre el pipeline, y escribe un JSON, un HTML y un reporte.
|
||||
|
||||
### 5.1 Contratos compartidos
|
||||
|
||||
Los cuatro diseños explorados compartían vocabulario pero no contratos. Estas resoluciones se
|
||||
escriben **una vez**, en un solo archivo de tipos que todos importan. Sin esto el sistema arranca,
|
||||
no falla, y valida el vacío.
|
||||
|
||||
| # | Conflicto | Resolución |
|
||||
|---|---|---|
|
||||
| B1 | Clave de join partida ↔ IA | `refPartida`, formato `/^P\d{2}$/` → `"P01"`. El cuid de `ServicioCotizado` **nunca** sale hacia el proveedor: no es estable entre ediciones porque el PUT hace `deleteMany` + `createMany` |
|
||||
| B2 | Forma de la evidencia | Arrays de IDs (`citas[]`, `hechos[]`), no prosa. Auditable por máquina, que es el punto de P3 |
|
||||
| B3 | Cita literal | Referenciada por ID. Se **verifica en el paso 1**, donde vive el texto, y su fallo bloquea antes de gastar los pasos 2 y 3 |
|
||||
| B4 | Árbol de módulos | `src/lib/propuesta/{ia,validacion,render}/`, entrada `scripts/propuesta-consultiva.ts`, tipo raíz `PropuestaConsultiva` |
|
||||
| B5 | Códigos de salida | `0` limpio · `1` requiere revisión · `2` bloqueado · `3` error del proveedor · `64` error de uso |
|
||||
| B6 | Variables de entorno | Solo `MINIMAX_API_KEY` / `MINIMAX_BASE_URL` / `MINIMAX_MODEL`, pasadas explícitas al constructor. **Nunca** prefijo `ANTHROPIC_*`: el SDK las lee por su cuenta y un `ANTHROPIC_BASE_URL` exportado en la shell mandaría la clave de MiniMax a Anthropic |
|
||||
| B7 | `tool_choice` | No se envía en Fase 1. Fijarlo solo en el reintento le da al reintento un prefijo distinto, o sea que se paga el contexto completo justo cuando es más grande |
|
||||
| B8 | Snapshot del catálogo | Sin `id` y sin `precioBase`. La resolución es por `nombre` + `fase`, reportando ambigüedad — `ServicioCatalogo.nombre` no es `@unique` |
|
||||
| B9 | Valor anual del problema | `dimensiones[].calculo.montoAnualMXN`. El total se suma **en código**, nunca lo emite el modelo |
|
||||
|
||||
### 5.2 El corte: qué copia el código y qué genera el modelo
|
||||
|
||||
La protección más fuerte del principio P1 no es una regla de validación: es que **ningún schema
|
||||
que llena el modelo contiene un solo campo de dinero de la cotización**.
|
||||
|
||||
- **El modelo devuelve:** `refPartida` + prosa (diagnóstico, resultados, descripciones en lenguaje
|
||||
de beneficio, exclusiones, pendientes, backlog).
|
||||
- **El código inyecta después:** precios, totales, IVA, número de cotización, vigencia, fechas.
|
||||
|
||||
Así P1 deja de ser algo que alguien puede olvidar validar y pasa a ser estructuralmente imposible
|
||||
de violar. El ratio precio/valor también lo calcula el código (D9) y se imprime solo en el anexo
|
||||
interno.
|
||||
|
||||
### 5.3 El pipeline de tres pasos
|
||||
|
||||
| Paso | Entrada | Salida | Por qué separado |
|
||||
|---|---|---|---|
|
||||
| 1 · Extracción | Transcripción + notas + observaciones | Hechos: dolores, cifras con confianza, citas literales con ID, materiales, decisiones, red flags, menciones fuera de alcance | Determina la calidad de todo lo demás. Es corregible por el asesor antes de propagarse |
|
||||
| 2 · Diagnóstico | Hechos del paso 1 + cotización + catálogo | Hallazgos con semáforo, valor del problema, resultados a lograr | Razonamiento, no redacción |
|
||||
| 3 · Redacción | Salidas de 1 y 2 | `PropuestaConsultiva` | Con el análisis hecho, esto es escritura |
|
||||
|
||||
Cada paso define una herramienta cuyo `input_schema` es su contrato, derivado del Zod con
|
||||
`z.toJSONSchema` nativo (verificado: preserva `additionalProperties` y `description`, inlinea
|
||||
subschemas, omite `superRefine`, y emite un `$schema` que hay que borrar). **No hace falta
|
||||
`zod-to-json-schema`.**
|
||||
|
||||
### 5.4 El presupuesto de reintentos
|
||||
|
||||
Hallazgo verificado que ningún diseño anticipó: **`.superRefine` no corre si la forma falla.** Eso
|
||||
crea cuatro compuertas secuenciales:
|
||||
|
||||
1. Forma Zod — siempre
|
||||
2. `superRefine` (IDs únicos, refs internas) — solo si 1 pasa
|
||||
3. Validación cruzada de runtime (`refPartida` reales) — solo si 2 pasa
|
||||
4. Filtro de contenido y PII — solo si 3 pasa
|
||||
|
||||
Con tres intentos y cuatro compuertas, el modo de fallo más probable del piloto es *"tres llamadas
|
||||
pagadas, cero documento"* — justo lo que Fase 1 no puede permitirse, porque su criterio de éxito es
|
||||
que el asesor lea algo.
|
||||
|
||||
**Diseño adoptado:**
|
||||
|
||||
- El filtro de contenido y PII corre sobre el objeto **crudo** aunque Zod haya fallado, recorriendo
|
||||
rutas parciales. Los hallazgos de las cuatro compuertas se acumulan en **un solo** mensaje de
|
||||
corrección.
|
||||
- Presupuesto: **3 intentos totales** por paso (1 inicial + 2 reintentos). El paso 3 recibe **4
|
||||
intentos totales** (1 + 3) por ser el más largo y el que atraviesa más compuertas.
|
||||
- Al agotarse los intentos se escribe igual el HTML del cliente **si y solo si** no hay bloqueantes
|
||||
de PII, moneda, garantía ni marca. Salir con código 1, no con 2.
|
||||
- En la rama `tool_incorrecta` hay que emitir un `tool_result` con `is_error: true` por **cada**
|
||||
`tool_use` del turno antes del texto de corrección; un mensaje de usuario plano después de un
|
||||
`tool_use` produce un 400.
|
||||
|
||||
### 5.5 Validación post-generación
|
||||
|
||||
Las seis reglas de §8.3 del documento de negocio, más una nueva que el análisis de riesgo destapó.
|
||||
|
||||
| Regla | Qué comprueba | Al fallar |
|
||||
|---|---|---|
|
||||
| **R0** (nueva) | Ningún n-grama de 7 tokens de `observacionesInternas` ni de `ServicioCotizado.notas` aparece en el HTML del cliente | **Bloquea** |
|
||||
| R1 | Todo monto en prosa pertenece al conjunto de la economía (BD) o al del valor (declarado y auditado por R4) | Bloquea |
|
||||
| R2 | Todo `refPartida` existe en `ServicioCotizado`. Ninguna partida nueva | Bloquea |
|
||||
| R3 | Cada cita literal existe en las fuentes, con normalización de 9 pasos (NFD sin diacríticos, minúsculas, puntuación, espacios, muletillas de ASR). Corre en el paso 1 | Bloquea si cruza hablantes |
|
||||
| R4 | Todo hallazgo `confirmado` tiene `citas.length + hechos.length > 0`. Corre sobre el objeto del **paso 2** | Degrada a `por_validar` |
|
||||
| R5 | El bloque `interno` se separa antes de renderizar el documento del cliente | Bloquea |
|
||||
| R6 | Sin valor anual, ninguna afirmación de ratio en la prosa | Bloquea la afirmación |
|
||||
|
||||
**R0 existe porque las otras seis no la cubren.** `R5` compara el bloque interno que *produjo el
|
||||
modelo* contra el HTML; nunca compara `observacionesInternas`, que es una **entrada** que el modelo
|
||||
recibe en el prompt y puede copiar literalmente en cualquier campo de prosa.
|
||||
|
||||
**Filtro de PII de salida** (advertencia, no bloqueo — D10): montos en USD, promesas de resultado
|
||||
garantizado, CRMs que no sean Bucéfalo, datos de empleados, temas salariales o legales. Los
|
||||
patrones heurísticos se marcan como tales en el reporte, con su extracto, para que el asesor
|
||||
juzgue. Se debe añadir a la cosecha de nombres las etiquetas de hablante del VTT y los dos campos
|
||||
de notas, que hoy quedarían fuera.
|
||||
|
||||
### 5.6 El renderizador HTML
|
||||
|
||||
**Es el entregable primario y ningún diseño lo tenía.** Primer paso de Fase 1: copiar
|
||||
`D:/Documents/plantilla_cotizacion.html` (27,100 bytes, hoy fuera del repo) a
|
||||
`src/lib/propuesta/render/plantilla.ts` y congelar su CSS. Sin esto, Fase 1 termina con tres JSON
|
||||
impecables y nada que enseñar.
|
||||
|
||||
Cambios obligatorios sobre la plantilla:
|
||||
|
||||
| Problema | Arreglo |
|
||||
|---|---|
|
||||
| 12 `rgba()` con canales escritos a mano duplican `--blue`, `--cream`, `--green`, `--amber` | Parametrizar de verdad, o `color_primario` produce un documento con dos azules |
|
||||
| `.section { page-break-inside: avoid }` en secciones enteras | Con 15-20 partidas empuja la sección a hoja nueva y la parte igual. Aplicar a filas, no a secciones |
|
||||
| No hay `@page` | Todo PDF impreso lleva `localhost:3000/...` estampado al pie de una propuesta comercial |
|
||||
| Tema oscuro + "Gráficos de fondo" desactivado por defecto en Chrome | El PDF sale con texto crema sobre blanco. Necesita un modo de impresión claro |
|
||||
| Cero hueco para el logo | El Anexo A del documento de negocio lo mapea como si existiera |
|
||||
| `.plan-grid` fijo a `1fr 1fr` | La sección de opciones pide tres tarjetas (anclaje A → B → C) |
|
||||
| Números de sección escritos a mano con cinco secciones condicionales | Un documento sin mantenimiento salta del 04 al 06. Numerar en el renderizador |
|
||||
| "Valor del problema" pide tabla de cuatro columnas | No hay patrón CSS; hay que crearlo |
|
||||
|
||||
Estrategia: template literals puros, sin motor de plantillas. El proyecto no tiene ninguno
|
||||
instalado y no lo amerita.
|
||||
|
||||
**Inyección CSS:** `PUT /api/configuracion` filtra las claves permitidas pero no valida los valores,
|
||||
y esos valores terminan dentro de un `<style>`. Validar `/^#[0-9a-fA-F]{3,8}$/` en el punto de
|
||||
inyección y caer al default del seed si no cumple.
|
||||
|
||||
**Anexo interno:** archivo separado, `INTERNO-NO-ENVIAR.html`, visualmente inconfundible. Nunca una
|
||||
sección oculta ni `display: none`.
|
||||
|
||||
### 5.7 Ergonomía del script
|
||||
|
||||
```
|
||||
npx tsx scripts/propuesta-consultiva.ts \
|
||||
--cotizacion UJ2607UJ003 \
|
||||
--transcripcion contexto/UJ2607UJ003/reunion.txt \
|
||||
--salida salidas/UJ2607UJ003/
|
||||
```
|
||||
|
||||
Banderas: `--cotizacion --transcripcion --salida --desde-paso --solo-validar`. Nada más.
|
||||
`--desde-paso` y `--solo-validar` se ganan su lugar: son la diferencia entre iterar el prompt del
|
||||
paso 3 veinte veces o cuatro.
|
||||
|
||||
Artefactos: `propuesta.html`, `INTERNO-NO-ENVIAR.html`, `propuesta.json` (con la traza embebida),
|
||||
`REPORTE.md`, y `traza/pasoN.json` porque `--desde-paso` los necesita.
|
||||
|
||||
Consola: los tres pasos tardan; imprime progreso por paso, tokens consumidos y aciertos de caché.
|
||||
|
||||
`contexto/` y `salidas/` van a `.gitignore` **y** a `.megaignore` (D11), con la exclusión
|
||||
verificada empíricamente antes de colocar material real.
|
||||
|
||||
### 5.8 Prompts y caché
|
||||
|
||||
Tres capas por estabilidad: estable (filosofía, frameworks, reglas, contrato, ejemplos),
|
||||
semi-estable (catálogo), volátil (cotización y transcripción). Dos breakpoints de `cache_control`.
|
||||
|
||||
MiniMax soporta caché con `cache_control` (4 breakpoints, TTL 5 min, verificable con
|
||||
`usage.cache_read_input_tokens`), pero el prefijo arranca en `tools`, no en `system`.
|
||||
|
||||
**Invalidadores a prevenir:** `new Date()` en la capa 1, `JSON.stringify` con orden de llaves no
|
||||
determinista, el número de cotización en la capa estable, cambio de modelo a media ejecución.
|
||||
Serializar el catálogo con orden explícito (`orden`, `id`).
|
||||
|
||||
**Los ejemplos few-shot deben validar contra su propio schema Zod al arrancar el script.** Cuesta
|
||||
diez líneas y es el único test que este proyecto va a tener. Un ejemplar defectuoso no produce un
|
||||
error: produce N documentos parecidos entre sí y se diagnostica tarde. El análisis encontró tres
|
||||
defectos en los ejemplos propuestos —uno que no valida, uno que mete el nombre de pila de una
|
||||
empleada en un campo del cliente, y uno que dispara el filtro de montos con `"400 pesos"`— que hay
|
||||
que corregir antes de la primera corrida.
|
||||
|
||||
También hay que pasar el **texto fijo de la plantilla** por el catálogo de PII una vez antes de la
|
||||
primera corrida, o la primera ejecución devolverá bloqueos que vienen del footer y no del modelo.
|
||||
|
||||
---
|
||||
|
||||
## 6. Supuestos sin verificar
|
||||
|
||||
Se documentan porque el diseño se apoya en ellos y la primera corrida debe medirlos.
|
||||
|
||||
| # | Supuesto | Qué hacer |
|
||||
|---|---|---|
|
||||
| V1 | MiniMax devuelve `cache_read_input_tokens` con `tools` fijo y 2 breakpoints | Primera medición obligatoria. Si no cachea, mandar las tres herramientas en cada petición es costo puro |
|
||||
| V2 | Con `stop_reason: "max_tokens"` el SDK entrega `input` como objeto parcial | Probar a propósito con `max_tokens: 200` |
|
||||
| V3 | `countTokens` existe en el endpoint compatible | Degradar a estimador local y marcar las cifras como estimadas en la traza |
|
||||
|
||||
Verificados durante el análisis, sin acción pendiente: `z.toJSONSchema` preserva lo necesario;
|
||||
`z.prettifyError` emite multi-error con ruta; `tsx` resuelve el alias `@/`; `core.autocrlf=true`
|
||||
exige normalizar saltos de línea.
|
||||
|
||||
---
|
||||
|
||||
## 7. Riesgos aceptados
|
||||
|
||||
| Riesgo | Por qué se acepta | Mitigación |
|
||||
|---|---|---|
|
||||
| La transcripción cruda con datos de empleados viaja a MiniMax | El modelo necesita el contexto para diagnosticar (D6) | Queda escrito aquí, no solo en la conversación. El filtro de salida protege el documento, no el tránsito |
|
||||
| El PDF de una cotización ya enviada deja de ser reproducible | Fase 0 cambia el renderizador; el sistema no archiva los PDF emitidos | Que el asesor archive lo enviado. Documentar en AGENTS.md que los exportadores no son reproducibles en el tiempo |
|
||||
| El hábito del asesor no migra solo | Tras Fase 0, el textarea donde lleva meses escribiendo contexto interno pasa a imprimirse en el PDF | Avisar por el canal del equipo, no solo cambiar la etiqueta |
|
||||
| Fase 1 añade una tercera superficie solo en TypeScript | AGENTS.md ya exige paridad entre dos backends | Documentar la divergencia. Si Fase 4 expone esto por MCP, la validación tendrá que existir del lado Python |
|
||||
|
||||
---
|
||||
|
||||
## 8. Criterios de éxito
|
||||
|
||||
**Fase 0** — verificable de inmediato:
|
||||
|
||||
- El endpoint `/mcp` ya no existe (§0.2). Se cumplió antes con 401 verificado; la retirada lo supera.
|
||||
- `api/requirements.txt` fija versiones exactas y el API arranca sin el paquete `mcp` (§0.3).
|
||||
- El total del PDF y el del Excel coinciden dígito por dígito en cotizaciones reales.
|
||||
- Una cotización con `incluirIva: false` no muestra IVA en ningún exportador.
|
||||
- Las notas internas no aparecen en ningún archivo exportable.
|
||||
- El texto del cliente aparece en el PDF, con saltos de línea correctos y sin romper el footer.
|
||||
|
||||
**Fase 1** — el criterio es cualitativo y es el que importa:
|
||||
|
||||
> El asesor revisa 5-10 documentos generados sobre cotizaciones reales pasadas y dice
|
||||
> *"esto lo mandaría a un cliente después de editarlo 10 minutos."*
|
||||
|
||||
Métricas de apoyo: cero afirmaciones sin evidencia, cero citas no verificables, y tasa de edición
|
||||
del asesor por debajo del 30%.
|
||||
|
||||
Si el criterio no se cumple, la conclusión correcta es iterar el prompt — no construir Fase 2.
|
||||
|
||||
---
|
||||
|
||||
## 9. Fuera de alcance
|
||||
|
||||
Modelos `PropuestaIA` y `ContextoCotizacion`; carga de archivos en la UI; route handler con patrón
|
||||
de job; vista de revisión con semáforo de salud; dashboard de BI agregado; herramienta MCP
|
||||
`generar_propuesta_consultiva`; sugerencia de esquema de 2-3 opciones; alerta de subcotización.
|
||||
|
||||
También difierido: migrar los cinco consumidores restantes de totales duplicados, y el semáforo de
|
||||
salud de §5.1 del documento de negocio — es una función de producto, no una validación, y no hace
|
||||
falta para saber si el texto generado sirve.
|
||||
Generated
+73
-1
@@ -8,6 +8,7 @@
|
||||
"name": "cotizador-e3",
|
||||
"version": "0.1.0",
|
||||
"dependencies": {
|
||||
"@anthropic-ai/sdk": "^0.115.0",
|
||||
"@prisma/adapter-pg": "^7.8.0",
|
||||
"@prisma/client": "^7.8.0",
|
||||
"bcryptjs": "^3.0.3",
|
||||
@@ -22,6 +23,7 @@
|
||||
"prisma": "^7.8.0",
|
||||
"react": "19.2.4",
|
||||
"react-dom": "19.2.4",
|
||||
"zod": "^4.3.6",
|
||||
"zustand": "^5.0.12"
|
||||
},
|
||||
"devDependencies": {
|
||||
@@ -51,6 +53,27 @@
|
||||
"url": "https://github.com/sponsors/sindresorhus"
|
||||
}
|
||||
},
|
||||
"node_modules/@anthropic-ai/sdk": {
|
||||
"version": "0.115.0",
|
||||
"resolved": "https://registry.npmjs.org/@anthropic-ai/sdk/-/sdk-0.115.0.tgz",
|
||||
"integrity": "sha512-BJrFIVyjNuU8lfDyIJTvlRYzgQg+zEl78BxE7fq8esULsGz9IRQvGtW5spq3tydmtjQb/GFdooKGdGsetpx+lQ==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"json-schema-to-ts": "^3.1.1",
|
||||
"standardwebhooks": "^1.0.0"
|
||||
},
|
||||
"bin": {
|
||||
"anthropic-ai-sdk": "bin/cli"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"zod": "^3.25.0 || ^4.0.0"
|
||||
},
|
||||
"peerDependenciesMeta": {
|
||||
"zod": {
|
||||
"optional": true
|
||||
}
|
||||
}
|
||||
},
|
||||
"node_modules/@babel/code-frame": {
|
||||
"version": "7.29.0",
|
||||
"resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz",
|
||||
@@ -243,6 +266,15 @@
|
||||
"node": ">=6.0.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@babel/runtime": {
|
||||
"version": "7.29.7",
|
||||
"resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.7.tgz",
|
||||
"integrity": "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
"node": ">=6.9.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@babel/template": {
|
||||
"version": "7.28.6",
|
||||
"resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz",
|
||||
@@ -2233,6 +2265,12 @@
|
||||
"dev": true,
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@stablelib/base64": {
|
||||
"version": "1.0.1",
|
||||
"resolved": "https://registry.npmjs.org/@stablelib/base64/-/base64-1.0.1.tgz",
|
||||
"integrity": "sha512-1bnPQqSxSuc3Ii6MhBysoWCg58j97aUjuCSZrGSmDxNqtytIi0k8utUenAwTZN4V5mXXYGsVUI9zeBqy+jBOSQ==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@standard-schema/spec": {
|
||||
"version": "1.1.0",
|
||||
"resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
|
||||
@@ -5179,6 +5217,12 @@
|
||||
"dev": true,
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/fast-sha256": {
|
||||
"version": "1.3.0",
|
||||
"resolved": "https://registry.npmjs.org/fast-sha256/-/fast-sha256-1.3.0.tgz",
|
||||
"integrity": "sha512-n11RGP/lrWEFI/bWdygLxhI+pVeo1ZYIVwvvPkW7azl/rOy+F3HYRZ2K5zeE9mmkhQppyv9sQFx0JM9UabnpPQ==",
|
||||
"license": "Unlicense"
|
||||
},
|
||||
"node_modules/fast-uri": {
|
||||
"version": "3.1.0",
|
||||
"resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.0.tgz",
|
||||
@@ -6364,6 +6408,19 @@
|
||||
"dev": true,
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/json-schema-to-ts": {
|
||||
"version": "3.1.1",
|
||||
"resolved": "https://registry.npmjs.org/json-schema-to-ts/-/json-schema-to-ts-3.1.1.tgz",
|
||||
"integrity": "sha512-+DWg8jCJG2TEnpy7kOm/7/AxaYoaRbjVB4LFZLySZlWn8exGs3A4OLJR966cVvU26N7X9TWxl+Jsw7dzAqKT6g==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@babel/runtime": "^7.18.3",
|
||||
"ts-algebra": "^2.0.0"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=16"
|
||||
}
|
||||
},
|
||||
"node_modules/json-schema-traverse": {
|
||||
"version": "0.4.1",
|
||||
"resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
|
||||
@@ -8554,6 +8611,16 @@
|
||||
"dev": true,
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/standardwebhooks": {
|
||||
"version": "1.0.0",
|
||||
"resolved": "https://registry.npmjs.org/standardwebhooks/-/standardwebhooks-1.0.0.tgz",
|
||||
"integrity": "sha512-BbHGOQK9olHPMvQNHWul6MYlrRTAOKn03rOe4A8O3CLWhNf4YHBqq2HJKKC+sfqpxiBY52pNeesD6jIiLDz8jg==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@stablelib/base64": "^1.0.0",
|
||||
"fast-sha256": "^1.3.0"
|
||||
}
|
||||
},
|
||||
"node_modules/std-env": {
|
||||
"version": "3.10.0",
|
||||
"resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
|
||||
@@ -8890,6 +8957,12 @@
|
||||
"node": "*"
|
||||
}
|
||||
},
|
||||
"node_modules/ts-algebra": {
|
||||
"version": "2.0.0",
|
||||
"resolved": "https://registry.npmjs.org/ts-algebra/-/ts-algebra-2.0.0.tgz",
|
||||
"integrity": "sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/ts-api-utils": {
|
||||
"version": "2.5.0",
|
||||
"resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.5.0.tgz",
|
||||
@@ -9498,7 +9571,6 @@
|
||||
"version": "4.3.6",
|
||||
"resolved": "https://registry.npmjs.org/zod/-/zod-4.3.6.tgz",
|
||||
"integrity": "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"funding": {
|
||||
"url": "https://github.com/sponsors/colinhacks"
|
||||
|
||||
@@ -16,6 +16,7 @@
|
||||
"seed": "npx tsx prisma/seed.ts"
|
||||
},
|
||||
"dependencies": {
|
||||
"@anthropic-ai/sdk": "^0.115.0",
|
||||
"@prisma/adapter-pg": "^7.8.0",
|
||||
"@prisma/client": "^7.8.0",
|
||||
"bcryptjs": "^3.0.3",
|
||||
@@ -30,6 +31,7 @@
|
||||
"prisma": "^7.8.0",
|
||||
"react": "19.2.4",
|
||||
"react-dom": "19.2.4",
|
||||
"zod": "^4.3.6",
|
||||
"zustand": "^5.0.12"
|
||||
},
|
||||
"devDependencies": {
|
||||
|
||||
@@ -0,0 +1,20 @@
|
||||
-- Fase 0-C, Despliegue A: separar el texto que ve el cliente del contexto interno.
|
||||
--
|
||||
-- ESTA MIGRACION ES PURAMENTE ADITIVA. No modifica ni una sola fila existente.
|
||||
-- El movimiento de datos (observaciones -> observacionesInternas) seria un
|
||||
-- Despliegue B posterior y NO se incluye aqui, por dos razones:
|
||||
--
|
||||
-- 1. Rollback seguro. No hay migraciones `down` en este repo ni servicio de
|
||||
-- backup en docker-compose.coolify.yml. Si un UPDATE vaciara "observaciones"
|
||||
-- y el despliegue se revirtiera, el codigo anterior leeria NULL en todas las
|
||||
-- filas y el asesor veria sus notas desaparecidas: sin error y sin log.
|
||||
--
|
||||
-- 2. El dato real no lo necesita. Al momento de escribir esto la unica fila de
|
||||
-- produccion con "observaciones" no vacias (UJ2606AG777, aprobada) contiene
|
||||
-- condiciones de pago dirigidas al cliente en segunda persona. Moverlas a
|
||||
-- "internas" ocultaria terminos ya acordados en un documento emitido.
|
||||
-- Esa fila ya esta clasificada correctamente donde esta.
|
||||
--
|
||||
-- IF NOT EXISTS hace la sentencia idempotente si alguien la aplica a mano.
|
||||
|
||||
ALTER TABLE "Cotizacion" ADD COLUMN IF NOT EXISTS "observacionesInternas" TEXT;
|
||||
@@ -0,0 +1,26 @@
|
||||
-- Propuesta consultiva con IA: tabla nueva.
|
||||
-- ADITIVA. No toca ninguna tabla ni fila existente.
|
||||
|
||||
CREATE TABLE IF NOT EXISTS "PropuestaIA" (
|
||||
"id" TEXT NOT NULL,
|
||||
"cotizacionId" TEXT NOT NULL,
|
||||
"estado" TEXT NOT NULL DEFAULT 'borrador',
|
||||
"contenidoIA" JSONB NOT NULL,
|
||||
"contenidoEditado" JSONB,
|
||||
"traza" JSONB,
|
||||
"avisos" JSONB NOT NULL DEFAULT '[]',
|
||||
"modelo" TEXT NOT NULL,
|
||||
"aprobadaPor" TEXT,
|
||||
"aprobadaAt" TIMESTAMP(3),
|
||||
"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
"updatedAt" TIMESTAMP(3) NOT NULL,
|
||||
|
||||
CONSTRAINT "PropuestaIA_pkey" PRIMARY KEY ("id")
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS "PropuestaIA_cotizacionId_idx" ON "PropuestaIA"("cotizacionId");
|
||||
|
||||
ALTER TABLE "PropuestaIA"
|
||||
ADD CONSTRAINT "PropuestaIA_cotizacionId_fkey"
|
||||
FOREIGN KEY ("cotizacionId") REFERENCES "Cotizacion"("id")
|
||||
ON DELETE CASCADE ON UPDATE CASCADE;
|
||||
@@ -0,0 +1,3 @@
|
||||
-- Guardar la transcripcion usada al generar la propuesta.
|
||||
-- ADITIVA: columna nullable, no toca ninguna fila existente.
|
||||
ALTER TABLE "PropuestaIA" ADD COLUMN IF NOT EXISTS "transcripcion" TEXT;
|
||||
@@ -49,7 +49,13 @@ model Cotizacion {
|
||||
incluirIva Boolean @default(true)
|
||||
esDoble Boolean @default(false)
|
||||
opcionesMetadata Json?
|
||||
// Texto que SI ve el cliente: se imprime en el PDF y en el Excel.
|
||||
observaciones String?
|
||||
// Contexto de discovery, notas del asesor, riesgos. NO sale de la app: ningun
|
||||
// exportador declara este campo en su interfaz de datos (CotizacionPDFData /
|
||||
// ExcelData) y la herramienta MCP obtener_cotizacion usa lista blanca de
|
||||
// columnas. La garantia es estructural, no depende de recordar filtrarlo.
|
||||
observacionesInternas String?
|
||||
clienteId String
|
||||
asesorId String
|
||||
createdAt DateTime @default(now())
|
||||
@@ -60,6 +66,7 @@ model Cotizacion {
|
||||
servicios ServicioCotizado[]
|
||||
planBucefalo PlanBucefaloCotizacion?
|
||||
registrosHoras RegistroHoras[]
|
||||
propuestasIA PropuestaIA[]
|
||||
|
||||
@@index([clienteId])
|
||||
@@index([asesorId])
|
||||
@@ -214,6 +221,33 @@ model RegistroHoras {
|
||||
@@index([estadoPago])
|
||||
}
|
||||
|
||||
// Documento consultivo generado por IA a partir del contexto humano de la cotizacion.
|
||||
// Se guarda por separado lo que produjo el modelo y lo que edito el asesor, para poder
|
||||
// mostrar que cambio y para no perder el original al editar.
|
||||
model PropuestaIA {
|
||||
id String @id @default(cuid())
|
||||
cotizacionId String
|
||||
estado String @default("borrador") // borrador | aprobada
|
||||
contenidoIA Json
|
||||
contenidoEditado Json?
|
||||
// Transcripcion sanitizada usada al generar. Sin esto, el PATCH revalida con
|
||||
// fuentes incompletas y R3 no puede comprobar que la cita destacada sea literal.
|
||||
transcripcion String?
|
||||
// Traza de la generacion: modelo, intentos por paso, tokens y aciertos de cache.
|
||||
traza Json?
|
||||
// Hallazgos de validacion y de contenido que el asesor debe revisar antes de enviar.
|
||||
avisos Json @default("[]")
|
||||
modelo String
|
||||
aprobadaPor String?
|
||||
aprobadaAt DateTime?
|
||||
createdAt DateTime @default(now())
|
||||
updatedAt DateTime @updatedAt
|
||||
|
||||
cotizacion Cotizacion @relation(fields: [cotizacionId], references: [id], onDelete: Cascade)
|
||||
|
||||
@@index([cotizacionId])
|
||||
}
|
||||
|
||||
model Configuracion {
|
||||
id String @id @default(cuid())
|
||||
clave String @unique
|
||||
|
||||
@@ -0,0 +1,70 @@
|
||||
import { crearCliente, modelo, normalizarRespuesta } from "@/lib/propuesta/cliente-ia";
|
||||
|
||||
// No llama a la API. Comprueba el contrato local y que el fallo sin clave sea claro.
|
||||
|
||||
let fallas = 0;
|
||||
function check(n: string, ok: boolean, d = "") {
|
||||
console.log(`${ok ? " OK " : " FALLA"} | ${n}${d ? " -> " + d : ""}`);
|
||||
if (!ok) fallas++;
|
||||
}
|
||||
|
||||
const guardada = process.env.MINIMAX_API_KEY;
|
||||
const guardadaBase = process.env.MINIMAX_BASE_URL;
|
||||
|
||||
delete process.env.MINIMAX_API_KEY;
|
||||
let msg = "";
|
||||
try {
|
||||
crearCliente();
|
||||
} catch (e) {
|
||||
msg = e instanceof Error ? e.message : String(e);
|
||||
}
|
||||
check("sin clave falla en vez de llamar a ciegas", msg.length > 0);
|
||||
check("el error nombra la variable correcta", msg.includes("MINIMAX_API_KEY"));
|
||||
check("el error advierte del prefijo ANTHROPIC_", msg.includes("ANTHROPIC_API_KEY"));
|
||||
|
||||
process.env.MINIMAX_API_KEY = "clave-de-prueba";
|
||||
delete process.env.MINIMAX_BASE_URL;
|
||||
const c = crearCliente();
|
||||
check("baseURL apunta a MiniMax por defecto", String(c.baseURL).includes("api.minimax.io"), String(c.baseURL));
|
||||
check("modelo por defecto es MiniMax-M3", modelo() === "MiniMax-M3", modelo());
|
||||
|
||||
// Aunque el shell tenga ANTHROPIC_BASE_URL, el cliente no debe hacerle caso.
|
||||
process.env.ANTHROPIC_BASE_URL = "https://api.anthropic.com";
|
||||
const c2 = crearCliente();
|
||||
check("ANTHROPIC_BASE_URL del shell no secuestra el baseURL",
|
||||
!String(c2.baseURL).includes("api.anthropic.com"), String(c2.baseURL));
|
||||
delete process.env.ANTHROPIC_BASE_URL;
|
||||
|
||||
process.env.MINIMAX_BASE_URL = "https://ejemplo.local/anthropic";
|
||||
check("MINIMAX_BASE_URL si se respeta", String(crearCliente().baseURL).includes("ejemplo.local"));
|
||||
|
||||
process.env.MINIMAX_MODEL = "MiniMax-M2";
|
||||
check("MINIMAX_MODEL se respeta", modelo() === "MiniMax-M2");
|
||||
delete process.env.MINIMAX_MODEL;
|
||||
|
||||
if (guardada) process.env.MINIMAX_API_KEY = guardada;
|
||||
else delete process.env.MINIMAX_API_KEY;
|
||||
if (guardadaBase) process.env.MINIMAX_BASE_URL = guardadaBase;
|
||||
else delete process.env.MINIMAX_BASE_URL;
|
||||
|
||||
// ── Normalizacion de rarezas de MiniMax, observadas contra la API real ──
|
||||
const igual = (a: unknown, b: unknown) => JSON.stringify(a) === JSON.stringify(b);
|
||||
|
||||
check("desenvuelve {item: X} cuando item es la unica clave",
|
||||
igual(normalizarRespuesta({ item: { a: 1 } }), { a: 1 }));
|
||||
check("desenvuelve dentro de arrays",
|
||||
igual(normalizarRespuesta([{ item: { a: 1 } }, { item: { a: 2 } }]), [{ a: 1 }, { a: 2 }]));
|
||||
check("desenvuelve en profundidad",
|
||||
igual(normalizarRespuesta({ lista: [{ item: { x: [{ item: 5 }] } }] }), { lista: [{ x: [5] }] }));
|
||||
check("NO toca un objeto con item junto a otras claves",
|
||||
igual(normalizarRespuesta({ item: 1, otro: 2 }), { item: 1, otro: 2 }));
|
||||
check("deja intactos los valores simples",
|
||||
normalizarRespuesta("texto") === "texto" && normalizarRespuesta(5) === 5 && normalizarRespuesta(null) === null);
|
||||
check("no altera un objeto normal",
|
||||
igual(normalizarRespuesta({ a: 1, b: [1, 2] }), { a: 1, b: [1, 2] }));
|
||||
check("el caso real observado: alcance envuelto",
|
||||
igual(normalizarRespuesta({ alcance: [{ item: { refPartida: "P01", descripcionResultado: "x" } }] }),
|
||||
{ alcance: [{ refPartida: "P01", descripcionResultado: "x" }] }));
|
||||
|
||||
console.log(fallas === 0 ? "\ntodo paso\n" : `\n${fallas} fallas\n`);
|
||||
process.exit(fallas === 0 ? 0 : 1);
|
||||
@@ -0,0 +1,26 @@
|
||||
import { calcularRatio } from "@/lib/propuesta/economia";
|
||||
|
||||
let fallas = 0;
|
||||
function check(n: string, ok: boolean, d = "") {
|
||||
console.log(`${ok ? " OK " : " FALLA"} | ${n}${d ? " -> " + d : ""}`);
|
||||
if (!ok) fallas++;
|
||||
}
|
||||
|
||||
check("sin valor anual no hay ratio", calcularRatio(100000, null) === null);
|
||||
check("valor anual cero no divide entre cero", calcularRatio(100000, 0) === null);
|
||||
check("valor anual negativo no produce ratio", calcularRatio(100000, -5) === null);
|
||||
|
||||
check("ratio 5% = subcotizado", calcularRatio(50000, 1000000)?.lectura === "subcotizado");
|
||||
check("ratio 20% = en rango", calcularRatio(200000, 1000000)?.lectura === "en_rango");
|
||||
check("ratio 35% = alto", calcularRatio(350000, 1000000)?.lectura === "alto");
|
||||
check("ratio 60% = objecion probable", calcularRatio(600000, 1000000)?.lectura === "objecion_probable");
|
||||
|
||||
// Los cortes exactos: 0.10 entra en rango, 0.25 sigue en rango, 0.40 sigue alto.
|
||||
check("corte 10% cae en rango", calcularRatio(100000, 1000000)?.lectura === "en_rango");
|
||||
check("corte 25% cae en rango", calcularRatio(250000, 1000000)?.lectura === "en_rango");
|
||||
check("corte 40% cae en alto", calcularRatio(400000, 1000000)?.lectura === "alto");
|
||||
|
||||
check("ratio redondeado a 3 decimales", calcularRatio(123456, 1000000)?.ratio === 0.123);
|
||||
|
||||
console.log(fallas === 0 ? "\ntodo paso\n" : `\n${fallas} fallas\n`);
|
||||
process.exit(fallas === 0 ? 0 : 1);
|
||||
@@ -0,0 +1,232 @@
|
||||
import zlib from "node:zlib";
|
||||
import { generarPropuestaPDF, generarAnexoInternoPDF, type DatosPropuestaPDF } from "@/lib/propuesta/pdf";
|
||||
import type { PropuestaConsultiva } from "@/lib/propuesta/schemas";
|
||||
import type { DatosEconomicos } from "@/lib/propuesta/economia";
|
||||
|
||||
/** Extrae el texto de un PDF de PDFKit. Con las fuentes base (Helvetica) no hay
|
||||
* subsetting ni ToUnicode: el texto va como hex de UN byte por caracter dentro de
|
||||
* streams comprimidos con Flate. */
|
||||
function textoDePdf(pdf: Buffer): string {
|
||||
const crudo = pdf.toString("latin1");
|
||||
let salida = "";
|
||||
const re = /stream\r?\n/g;
|
||||
let m: RegExpExecArray | null;
|
||||
while ((m = re.exec(crudo)) !== null) {
|
||||
const ini = m.index + m[0].length;
|
||||
const fin = crudo.indexOf("endstream", ini);
|
||||
if (fin === -1) continue;
|
||||
let bloque = "";
|
||||
try {
|
||||
bloque = zlib.inflateSync(Buffer.from(crudo.slice(ini, fin), "latin1")).toString("latin1");
|
||||
} catch {
|
||||
continue;
|
||||
}
|
||||
// PDFKit alterna dos codificaciones segun el contenido de la cadena:
|
||||
// hex `<48656c6c6f>` y literal `(Hello) Tj`. Hay que leer las dos.
|
||||
// OJO: no se puede meter un separador entre trozos hex. PDFKit aplica kerning y
|
||||
// parte una misma palabra en varios elementos de un arreglo TJ
|
||||
// (`[<4d41> -20 <524341444f52>]`), asi que un espacio de mas convierte
|
||||
// "MARCADORVERDE" en "MARCA DORVERDE" y ninguna busqueda lo encuentra.
|
||||
for (const t of bloque.matchAll(/<([0-9a-fA-F]{2,})>/g)) {
|
||||
const hex = t[1];
|
||||
for (let i = 0; i + 2 <= hex.length; i += 2) {
|
||||
const b = parseInt(hex.slice(i, i + 2), 16);
|
||||
if (b >= 32 && b < 256) salida += String.fromCharCode(b);
|
||||
}
|
||||
}
|
||||
salida += " ";
|
||||
for (const t of bloque.matchAll(/\(((?:[^()\\]|\\.)*)\)\s*Tj/g)) {
|
||||
salida += t[1].replace(/\\([()\\])/g, "$1") + " ";
|
||||
}
|
||||
}
|
||||
return salida;
|
||||
}
|
||||
|
||||
let fallas = 0;
|
||||
function check(n: string, ok: boolean, d = "") {
|
||||
console.log(`${ok ? " OK " : " FALLA"} | ${n}${d ? " -> " + d : ""}`);
|
||||
if (!ok) fallas++;
|
||||
}
|
||||
|
||||
const econ: DatosEconomicos = {
|
||||
partidas: [
|
||||
{ refPartida: "P01", servicioCotizadoId: "c1", nombre: "Sitio web institucional", fase: 1, tipoPago: "unico", precio: 12000, tiempoEntrega: "2 semanas", modeloCobro: "fijo", horas: null, tarifaHora: null, entregables: [] },
|
||||
{ refPartida: "P02", servicioCotizadoId: "c2", nombre: "Manejo de pauta", fase: 2, tipoPago: "mensual", precio: 8000, tiempoEntrega: "Mensual", modeloCobro: "fijo", horas: null, tarifaHora: null, entregables: [] },
|
||||
],
|
||||
totales: { subtotalUnico: 12000, subtotalMensual: 8000, ivaUnico: 1920, ivaMensual: 1280, totalUnico: 13920, totalMensual: 9280, totalPrimerAnio: 125280, incluyeIva: true },
|
||||
moneda: "MXN",
|
||||
planBucefalo: null,
|
||||
};
|
||||
|
||||
const propuesta: PropuestaConsultiva = {
|
||||
hechos: {
|
||||
citas: [{ id: "C01", textoLiteral: "MARCADORCITA nadie contesta el fin de semana", quienLoDijo: "el socio" }],
|
||||
hechos: [{ id: "H01", enunciado: "Sin control de atencion", confianza: "confirmado", citas: ["C01"] }],
|
||||
materialesPendientes: [{ texto: "MARCADORMATERIAL accesos al dominio", bloqueaEntrega: true }],
|
||||
decisionesPendientes: [{ texto: "MARCADORDECISION definir responsable", quienDecide: "el socio" }],
|
||||
mencionesFueraDeAlcance: ["MARCADORFUERA app movil"],
|
||||
redFlags: [{ senal: "MARCADORFLAG pidio descuento antes de ver el alcance", severidad: "alta" }],
|
||||
},
|
||||
diagnostico: {
|
||||
hallazgos: [
|
||||
{ id: "D01", urgencia: "rojo", titulo: "MARCADORHALLAZGO", descripcion: "Se pierden prospectos cada fin de semana.", confianza: "confirmado", citas: ["C01"], hechos: ["H01"] },
|
||||
{ id: "D02", urgencia: "verde", titulo: "MARCADORVERDE", descripcion: "Ya tienen la base de clientes ordenada.", confianza: "confirmado", citas: ["C01"], hechos: ["H01"] },
|
||||
],
|
||||
valorProblema: {
|
||||
dimensiones: [{ tipo: "tiempo", descripcion: "MARCADORVALOR horas perdidas", factores: [{ nombre: "h", valor: 8, confianza: "confirmado" }, { nombre: "s", valor: 52, confianza: "confirmado" }, { nombre: "c", valor: 400, confianza: "estimado" }], montoAnualMXN: 166400, confianza: "estimado", hechos: ["H01"] }],
|
||||
notaMetodologia: "MARCADORMETODO ocho horas por semana a costo cargado.",
|
||||
},
|
||||
resultados: [{ enunciado: "MARCADORRESULTADO cero mensajes sin respuesta", metrica: "tiempo", lineaBase: null, periodoMedicion: "mensual" }],
|
||||
},
|
||||
redaccion: {
|
||||
hero: { titulo: "MARCADORTITULO", subtitulo: "MARCADORSUB ordenar la atencion para dejar de perder prospectos." },
|
||||
citaDestacadaId: "C01",
|
||||
alcance: [
|
||||
{ refPartida: "P01", descripcionResultado: "MARCADORALCANCE un lugar a donde mandar prospectos." },
|
||||
{ refPartida: "P02", descripcionResultado: "MARCADORALCANCE2 cada peso a las busquedas que compran." },
|
||||
],
|
||||
beneficios: [{ etiqueta: "Respuesta", texto: "MARCADORBENEFICIO cada mensaje con responsable.", hallazgoId: "D01" }],
|
||||
exclusiones: [{ texto: "MARCADOREXCLUSION no incluye migrar el historico.", razon: "fase 2" }],
|
||||
backlogEvolucion: [{ problema: "MARCADORBACKLOG automatizar reportes", momentoSugerido: "tras la fase 1" }],
|
||||
notasInternas: ["MARCADORINTERNO el socio decide, no el que vino a la reunion"],
|
||||
},
|
||||
};
|
||||
|
||||
const datos: DatosPropuestaPDF = {
|
||||
propuesta,
|
||||
economia: econ,
|
||||
cliente: "Cliente Prueba",
|
||||
empresa: "Empresa SA",
|
||||
asesor: "Asesor",
|
||||
numero: "UJ2607TEST",
|
||||
fecha: new Date("2026-07-29"),
|
||||
vigencia: new Date("2026-08-19"),
|
||||
proyecto: "MKT Digital",
|
||||
branding: { colorPrimario: "#2563eb" },
|
||||
};
|
||||
|
||||
async function main() {
|
||||
const pdf = await generarPropuestaPDF(datos);
|
||||
const txt = textoDePdf(pdf);
|
||||
check("se genera el documento del cliente", pdf.length > 2000, `${pdf.length} bytes`);
|
||||
|
||||
for (const marca of [
|
||||
"MARCADORTITULO", "MARCADORSUB", "MARCADORCITA", "MARCADORHALLAZGO", "MARCADORVERDE",
|
||||
"MARCADORVALOR", "MARCADORMETODO", "MARCADORRESULTADO", "MARCADORALCANCE", "MARCADORALCANCE2",
|
||||
"MARCADORBENEFICIO", "MARCADOREXCLUSION", "MARCADORMATERIAL", "MARCADORDECISION", "MARCADORBACKLOG",
|
||||
]) {
|
||||
check(`el documento del cliente incluye ${marca}`, txt.includes(marca));
|
||||
}
|
||||
|
||||
// Lo que NUNCA debe salir al cliente.
|
||||
check("NO lleva notas internas", !txt.includes("MARCADORINTERNO"));
|
||||
check("NO lleva red flags", !txt.includes("MARCADORFLAG"));
|
||||
check("NO lleva menciones fuera de alcance", !txt.includes("MARCADORFUERA"));
|
||||
|
||||
// El dinero lo pone el codigo, no la IA.
|
||||
check("imprime el precio de P01", txt.includes("12,000"));
|
||||
check("imprime el precio de P02", txt.includes("8,000"));
|
||||
check("imprime el total unico con IVA", txt.includes("13,920"));
|
||||
check("imprime la mensualidad con IVA", txt.includes("9,280"));
|
||||
// El desglose debe cuadrar: lineas sin IVA + IVA como renglon propio.
|
||||
check("imprime el subtotal sin IVA", txt.includes("Subtotal pago unico") && txt.includes("12,000"));
|
||||
check("imprime el IVA como renglon propio", txt.includes("IVA 16%") && txt.includes("1,920"));
|
||||
check("imprime el total con IVA", txt.includes("Total pago unico"));
|
||||
check("la nota NO dice que las lineas incluyan IVA", !txt.includes("Importes con IVA incluido"));
|
||||
check("la nota aclara que las partidas van sin IVA", txt.includes("no incluyen IVA"));
|
||||
|
||||
check("etiqueta el semaforo", txt.includes("Problema critico") && txt.includes("Ventaja existente"));
|
||||
check("etiqueta la confianza", txt.includes("Confirmado") && txt.includes("Estimado"));
|
||||
check("el backlog se marca como no comprometido", txt.includes("No comprometido"));
|
||||
|
||||
// Sin IVA no debe aparecer el renglon de IVA.
|
||||
const sinIva = await generarPropuestaPDF({ ...datos, economia: { ...econ, totales: { ...econ.totales, incluyeIva: false } } });
|
||||
const txtSinIva = textoDePdf(sinIva);
|
||||
check("sin IVA no se imprime el renglon de IVA", !txtSinIva.includes("IVA 16%"));
|
||||
check("sin IVA el total lo declara", txtSinIva.includes("sin IVA"));
|
||||
|
||||
// El plan Bucefalo tiene que aparecer: esta en la cotizacion y en los otros dos exportadores.
|
||||
const conPlan = await generarPropuestaPDF({ ...datos, economia: { ...econ, planBucefalo: { nivel: "premium", precio: 4500 } } });
|
||||
const txtPlan = textoDePdf(conPlan);
|
||||
check("el plan Bucefalo aparece en el documento", txtPlan.includes("Bucefalo"));
|
||||
check("el plan aparece con su nivel", txtPlan.includes("Premium"));
|
||||
check("el plan aparece con su precio mensual", txtPlan.includes("4,500"));
|
||||
|
||||
// Una partida que la IA invento no se dibuja (R2 ya la marco).
|
||||
const conFantasma = await generarPropuestaPDF({
|
||||
...datos,
|
||||
propuesta: { ...propuesta, redaccion: { ...propuesta.redaccion, alcance: [...propuesta.redaccion.alcance, { refPartida: "P99", descripcionResultado: "MARCADORFANTASMA inventada" }] } },
|
||||
});
|
||||
check("una partida inventada no se dibuja", !textoDePdf(conFantasma).includes("MARCADORFANTASMA"));
|
||||
|
||||
// Completitud: la cotizacion manda, no lo que la IA alcanzo a describir.
|
||||
// Verificado con UJ2606UR001 en produccion: 58 partidas, la IA describio 40.
|
||||
const econGrande = { ...econ, partidas: [...econ.partidas,
|
||||
{ refPartida: "P03", servicioCotizadoId: "c3", nombre: "MARCADORNODESCRITA servicio extra", fase: 3, tipoPago: "unico" as const, precio: 5000, tiempoEntrega: "1 semana", modeloCobro: "fijo", horas: null, tarifaHora: null, entregables: ["Entregable A", "Entregable B"] },
|
||||
] };
|
||||
const conNoDescrita = await generarPropuestaPDF({ ...datos, economia: econGrande });
|
||||
const txtND = textoDePdf(conNoDescrita);
|
||||
check("una partida SIN descripcion de la IA igual aparece", txtND.includes("MARCADORNODESCRITA"));
|
||||
check("y aparece con su precio", txtND.includes("5,000"));
|
||||
check("y con su detalle del catalogo como respaldo", txtND.includes("Entregable A"));
|
||||
|
||||
// ── Anexo interno ──
|
||||
const anexo = await generarAnexoInternoPDF(datos);
|
||||
const txtA = textoDePdf(anexo);
|
||||
check("se genera el anexo interno", anexo.length > 1000, `${anexo.length} bytes`);
|
||||
check("el anexo se marca NO ENVIAR", txtA.includes("NO ENVIAR"));
|
||||
check("el anexo lleva las notas internas", txtA.includes("MARCADORINTERNO"));
|
||||
check("el anexo lleva las red flags", txtA.includes("MARCADORFLAG"));
|
||||
check("el anexo lleva lo que quedo fuera", txtA.includes("MARCADORFUERA"));
|
||||
// 125280 / 166400 = 75.3% -> objecion probable
|
||||
check("el anexo calcula el ratio", txtA.includes("75.3"), "125280/166400");
|
||||
check("el anexo interpreta el ratio", txtA.includes("objecion probable"));
|
||||
check("el anexo sugiere responder con alcance", txtA.includes("no con descuento"));
|
||||
check("el anexo desglosa de donde sale el valor anual", txtA.includes("De donde sale el valor anual"));
|
||||
check("el anexo muestra los factores con su confianza", txtA.includes("confirmado") && txtA.includes("estimado"));
|
||||
|
||||
// R5b: una cifra sostenida solo por estimaciones debe llevar alerta visible.
|
||||
const soloEstimado = await generarAnexoInternoPDF({
|
||||
...datos,
|
||||
propuesta: { ...propuesta, diagnostico: { ...propuesta.diagnostico, valorProblema: { ...propuesta.diagnostico.valorProblema,
|
||||
dimensiones: [{ ...propuesta.diagnostico.valorProblema.dimensiones[0], factores: [{ nombre: "a", valor: 8, confianza: "estimado" as const }, { nombre: "b", valor: 20800, confianza: "estimado" as const }], montoAnualMXN: 166400 }] } } },
|
||||
});
|
||||
check("el anexo alerta si la cifra descansa solo en estimaciones", textoDePdf(soloEstimado).includes("puede cuadrar y aun asi estar inflada"));
|
||||
check("el anexo NO alerta si hay factores confirmados", !txtA.includes("puede cuadrar y aun asi estar inflada"));
|
||||
|
||||
// Robustez del branding: la API de configuracion no valida los valores.
|
||||
for (const malo of ["</style><script>", "rojo", "#GGG", ""]) {
|
||||
const r = await generarPropuestaPDF({ ...datos, branding: { colorPrimario: malo } });
|
||||
check(`un color invalido (${JSON.stringify(malo)}) no rompe el PDF`, r.length > 2000);
|
||||
}
|
||||
const logoMalo = await generarPropuestaPDF({ ...datos, branding: { logoBase64: "no-es-base64-valido" } });
|
||||
check("un logo invalido no rompe el PDF", logoMalo.length > 2000);
|
||||
|
||||
// Contenido largo: no debe perderse ni romper el pie de pagina.
|
||||
const largo = await generarPropuestaPDF({
|
||||
...datos,
|
||||
propuesta: {
|
||||
...propuesta,
|
||||
diagnostico: {
|
||||
...propuesta.diagnostico,
|
||||
hallazgos: Array.from({ length: 30 }, (_, i) => ({
|
||||
id: `D${String(i + 1).padStart(2, "0")}`, urgencia: "ambar" as const,
|
||||
titulo: `Hallazgo ${i} MARCADORLARGO`, descripcion: "x".repeat(300),
|
||||
confianza: "estimado" as const, citas: [], hechos: [],
|
||||
})),
|
||||
},
|
||||
},
|
||||
});
|
||||
const txtL = textoDePdf(largo);
|
||||
check("el contenido largo se imprime", txtL.includes("MARCADORLARGO"));
|
||||
check("el contenido largo conserva las secciones posteriores", txtL.includes("MARCADOREXCLUSION"));
|
||||
check("el contenido largo genera varias paginas", (largo.toString("latin1").match(/\/Type\s*\/Page[^s]/g) || []).length > 1);
|
||||
|
||||
console.log(fallas === 0 ? "\ntodo paso\n" : `\n${fallas} fallas\n`);
|
||||
process.exit(fallas === 0 ? 0 : 1);
|
||||
}
|
||||
|
||||
main().catch((e) => {
|
||||
console.error("Error inesperado:", e);
|
||||
process.exit(1);
|
||||
});
|
||||
@@ -0,0 +1,76 @@
|
||||
import { SYSTEM_BASE, bloqueContexto, mensajePaso1, mensajePaso2, mensajePaso3 } from "@/lib/propuesta/prompts";
|
||||
import type { DatosEconomicos } from "@/lib/propuesta/economia";
|
||||
import type { Hechos, Diagnostico } from "@/lib/propuesta/schemas";
|
||||
|
||||
let fallas = 0;
|
||||
function check(n: string, ok: boolean, d = "") {
|
||||
console.log(`${ok ? " OK " : " FALLA"} | ${n}${d ? " -> " + d : ""}`);
|
||||
if (!ok) fallas++;
|
||||
}
|
||||
|
||||
// ── La capa 1 tiene que ser 100% estable o el cache no sirve de nada ──
|
||||
check("no contiene el anio actual", !SYSTEM_BASE.includes(String(new Date().getFullYear())));
|
||||
check("no contiene una fecha ISO", !/\d{4}-\d{2}-\d{2}/.test(SYSTEM_BASE));
|
||||
check("no contiene un numero de cotizacion", !/UJ\d{4}/.test(SYSTEM_BASE));
|
||||
check("supera el minimo cacheable de 512 tokens", SYSTEM_BASE.length > 2500, `${SYSTEM_BASE.length} chars`);
|
||||
|
||||
// ── Los diez principios y el semaforo estan presentes ──
|
||||
for (const p of ["P1.", "P2.", "P3.", "P4.", "P5.", "P6.", "P7.", "P8."]) {
|
||||
check(`declara el principio ${p}`, SYSTEM_BASE.includes(p));
|
||||
}
|
||||
check("explica el semaforo completo",
|
||||
["rojo:", "ambar:", "azul:", "verde:"].every((c) => SYSTEM_BASE.includes(c)));
|
||||
check("justifica por que el verde importa", SYSTEM_BASE.includes("entre pares"));
|
||||
|
||||
// ── Reglas de marca ──
|
||||
check("nombra Bucefalo", SYSTEM_BASE.includes("Bucefalo"));
|
||||
check("prohibe otros CRM", SYSTEM_BASE.includes("ningun otro CRM"));
|
||||
check("prohibe USD", SYSTEM_BASE.includes("USD"));
|
||||
check("prohibe garantizar resultados", SYSTEM_BASE.includes("garantizado"));
|
||||
check("prohibe lenguaje corporativo vacio", SYSTEM_BASE.includes("sinergias"));
|
||||
check("restringe a servicios digitales", SYSTEM_BASE.includes("UNICAMENTE servicios digitales"));
|
||||
check("prohibe datos de empleados", SYSTEM_BASE.includes("nombres de empleados"));
|
||||
check("cubre el caso de material pobre", SYSTEM_BASE.includes("MATERIAL ES POBRE"));
|
||||
check("dice que un hueco declarado es contenido de valor", SYSTEM_BASE.includes("contenido de valor"));
|
||||
|
||||
// ── El contexto degrada con gracia ──
|
||||
const sinNada = bloqueContexto({ transcripcion: "", notas: "", observaciones: "", cliente: "Ana", empresa: "", proyecto: "P" });
|
||||
check("sin transcripcion lo declara explicitamente", sinNada.includes("No se entrego transcripcion"));
|
||||
check("sin empresa no imprime parentesis vacios", !sinNada.includes("()"));
|
||||
|
||||
const conTodo = bloqueContexto({ transcripcion: "TRANS", notas: "NOTAS", observaciones: "OBS", cliente: "Ana", empresa: "ACME", proyecto: "P" });
|
||||
check("incluye la transcripcion", conTodo.includes("TRANS"));
|
||||
check("incluye las notas por partida", conTodo.includes("NOTAS"));
|
||||
check("incluye las observaciones", conTodo.includes("OBS"));
|
||||
check("incluye la empresa entre parentesis", conTodo.includes("(ACME)"));
|
||||
|
||||
// ── Los tres mensajes piden su herramienta y no filtran dinero ──
|
||||
const econ: DatosEconomicos = {
|
||||
partidas: [{ refPartida: "P01", servicioCotizadoId: "cuid-secreto-abc123", nombre: "Sitio web", fase: 1, tipoPago: "unico", precio: 12345, tiempoEntrega: "2 semanas", modeloCobro: "fijo", horas: null, tarifaHora: null, entregables: [] }],
|
||||
totales: { subtotalUnico: 12345, subtotalMensual: 0, ivaUnico: 1975.2, ivaMensual: 0, totalUnico: 14320.2, totalMensual: 0, totalPrimerAnio: 14320.2, incluyeIva: true },
|
||||
moneda: "MXN",
|
||||
planBucefalo: null,
|
||||
};
|
||||
const ctx = { transcripcion: "t", notas: "", observaciones: "", cliente: "Ana", empresa: "ACME", proyecto: "P" };
|
||||
const hechos = { citas: [], hechos: [], materialesPendientes: [], decisionesPendientes: [], mencionesFueraDeAlcance: [], redFlags: [] } as Hechos;
|
||||
const diag = { hallazgos: [], valorProblema: { dimensiones: [], notaMetodologia: "" }, resultados: [] } as unknown as Diagnostico;
|
||||
|
||||
const m1 = mensajePaso1(ctx);
|
||||
const m2 = mensajePaso2(ctx, hechos, econ);
|
||||
const m3 = mensajePaso3(ctx, hechos, diag, econ);
|
||||
|
||||
check("paso 1 pide registrar_hechos", m1.includes("registrar_hechos"));
|
||||
check("paso 2 pide registrar_diagnostico", m2.includes("registrar_diagnostico"));
|
||||
check("paso 3 pide registrar_propuesta", m3.includes("registrar_propuesta"));
|
||||
check("paso 1 exige citas textuales", m1.includes("TEXTUALES"));
|
||||
|
||||
// P1 estructural: el precio y el cuid NO pueden aparecer en ningun prompt.
|
||||
for (const [nombre, msg] of [["paso 2", m2], ["paso 3", m3]] as const) {
|
||||
check(`${nombre} NO filtra el precio de la partida`, !msg.includes("12345"));
|
||||
check(`${nombre} NO filtra el total`, !msg.includes("14320"));
|
||||
check(`${nombre} NO filtra el cuid real`, !msg.includes("cuid-secreto-abc123"));
|
||||
check(`${nombre} SI incluye la refPartida`, msg.includes("P01"));
|
||||
}
|
||||
|
||||
console.log(fallas === 0 ? "\ntodo paso\n" : `\n${fallas} fallas\n`);
|
||||
process.exit(fallas === 0 ? 0 : 1);
|
||||
@@ -0,0 +1,94 @@
|
||||
import { hechosSchema, diagnosticoSchema, redaccionSchema, aJsonSchema } from "@/lib/propuesta/schemas";
|
||||
|
||||
let fallas = 0;
|
||||
function check(n: string, ok: boolean, d = "") {
|
||||
console.log(`${ok ? " OK " : " FALLA"} | ${n}${d ? " -> " + d : ""}`);
|
||||
if (!ok) fallas++;
|
||||
}
|
||||
|
||||
// ── P1 por construccion: ningun schema declara un campo de dinero de E3 ──
|
||||
const todos = JSON.stringify([
|
||||
aJsonSchema(hechosSchema),
|
||||
aJsonSchema(diagnosticoSchema),
|
||||
aJsonSchema(redaccionSchema),
|
||||
]);
|
||||
for (const prohibido of ["precio", "total", "subtotal", "iva", "montoMinimo", "tarifaHora", "descuento"]) {
|
||||
check(`ningun schema declara la propiedad "${prohibido}"`, !todos.includes(`"${prohibido}"`));
|
||||
}
|
||||
// montoAnualMXN si debe existir: es el costo del problema del cliente, no un precio nuestro.
|
||||
check("montoAnualMXN si existe (costo del problema del cliente)", todos.includes("montoAnualMXN"));
|
||||
|
||||
// ── Formato de las claves ──
|
||||
const redaccionBase = {
|
||||
hero: { titulo: "Titulo de prueba", subtitulo: "x".repeat(25) },
|
||||
citaDestacadaId: "C01",
|
||||
alcance: [{ refPartida: "P01", descripcionResultado: "x".repeat(25) }],
|
||||
beneficios: [],
|
||||
exclusiones: [{ texto: "x".repeat(20), razon: "porque si" }],
|
||||
backlogEvolucion: [],
|
||||
notasInternas: [],
|
||||
};
|
||||
check("una redaccion bien formada valida", redaccionSchema.safeParse(redaccionBase).success);
|
||||
check("refPartida en minuscula se rechaza",
|
||||
!redaccionSchema.safeParse({ ...redaccionBase, alcance: [{ refPartida: "p01", descripcionResultado: "x".repeat(25) }] }).success);
|
||||
check("refPartida sin ceros se rechaza",
|
||||
!redaccionSchema.safeParse({ ...redaccionBase, alcance: [{ refPartida: "P1", descripcionResultado: "x".repeat(25) }] }).success);
|
||||
check("citaDestacadaId con otro prefijo se rechaza",
|
||||
!redaccionSchema.safeParse({ ...redaccionBase, citaDestacadaId: "H01" }).success);
|
||||
check("exige al menos una exclusion",
|
||||
!redaccionSchema.safeParse({ ...redaccionBase, exclusiones: [] }).success);
|
||||
check("rechaza propiedades desconocidas (strict)",
|
||||
!redaccionSchema.safeParse({ ...redaccionBase, precioTotal: 99999 }).success);
|
||||
|
||||
// ── El calculo del valor debe venir desglosado ──
|
||||
const diagBase = {
|
||||
hallazgos: [{ id: "D01", urgencia: "rojo", titulo: "Titulo del hallazgo", descripcion: "x".repeat(25), confianza: "confirmado", citas: [], hechos: [] }],
|
||||
valorProblema: {
|
||||
dimensiones: [{
|
||||
tipo: "tiempo", descripcion: "x".repeat(12),
|
||||
factores: [{ nombre: "a", valor: 8, confianza: "confirmado" }, { nombre: "b", valor: 52, confianza: "estimado" }], montoAnualMXN: 416,
|
||||
confianza: "estimado", hechos: [],
|
||||
}],
|
||||
notaMetodologia: "n",
|
||||
},
|
||||
resultados: [],
|
||||
};
|
||||
check("un diagnostico bien formado valida", diagnosticoSchema.safeParse(diagBase).success,
|
||||
JSON.stringify(diagnosticoSchema.safeParse(diagBase).error?.issues?.[0] ?? ""));
|
||||
check("con monto, exige al menos 2 factores",
|
||||
!diagnosticoSchema.safeParse({ ...diagBase, valorProblema: { ...diagBase.valorProblema, dimensiones: [{ ...diagBase.valorProblema.dimensiones[0], factores: [{ nombre: "a", valor: 1, confianza: "estimado" }], montoAnualMXN: 1 }] } }).success);
|
||||
check("sin monto, factores vacio es lo correcto",
|
||||
diagnosticoSchema.safeParse({ ...diagBase, valorProblema: { ...diagBase.valorProblema, dimensiones: [{ ...diagBase.valorProblema.dimensiones[0], factores: [], montoAnualMXN: null }] } }).success);
|
||||
// Una dimension SIN la clave montoAnualMXN: es lo que manda el modelo cuando no tiene
|
||||
// cifras, y por eso el campo lleva .default(null) en vez de solo .nullable().
|
||||
const dimSinMonto = { tipo: "tiempo", descripcion: "x".repeat(12), factores: [], confianza: "por_validar", hechos: [] };
|
||||
const sinMonto = { ...diagBase, valorProblema: { ...diagBase.valorProblema, dimensiones: [dimSinMonto] } };
|
||||
check("omitir montoAnualMXN se tolera", diagnosticoSchema.safeParse(sinMonto).success,
|
||||
JSON.stringify(diagnosticoSchema.safeParse(sinMonto).error?.issues?.[0] ?? ""));
|
||||
check("al omitirlo, Zod lo rellena con null",
|
||||
diagnosticoSchema.parse(sinMonto).valorProblema.dimensiones[0].montoAnualMXN === null);
|
||||
check("la dimension quedo plana: sin nivel `calculo`",
|
||||
!JSON.stringify(aJsonSchema(diagnosticoSchema)).includes('"calculo"'));
|
||||
check("un factor sin confianza se rechaza",
|
||||
!diagnosticoSchema.safeParse({ ...diagBase, valorProblema: { ...diagBase.valorProblema, dimensiones: [{ ...diagBase.valorProblema.dimensiones[0], factores: [{ nombre: "a", valor: 1 }, { nombre: "b", valor: 2 }], montoAnualMXN: 2 }] } }).success);
|
||||
|
||||
check("exige al menos un hallazgo",
|
||||
!diagnosticoSchema.safeParse({ ...diagBase, hallazgos: [] }).success);
|
||||
check("urgencia fuera del semaforo se rechaza",
|
||||
!diagnosticoSchema.safeParse({ ...diagBase, hallazgos: [{ ...diagBase.hallazgos[0], urgencia: "morado" }] }).success);
|
||||
|
||||
// ── Hechos ──
|
||||
check("una cita corta se rechaza",
|
||||
!hechosSchema.safeParse({ citas: [{ id: "C01", textoLiteral: "hola", quienLoDijo: "x" }], hechos: [], materialesPendientes: [], decisionesPendientes: [], mencionesFueraDeAlcance: [], redFlags: [] }).success);
|
||||
check("hechos vacios son validos (material pobre)",
|
||||
hechosSchema.safeParse({ citas: [], hechos: [], materialesPendientes: [], decisionesPendientes: [], mencionesFueraDeAlcance: [], redFlags: [] }).success);
|
||||
|
||||
// ── Conversion a JSON Schema ──
|
||||
const js = aJsonSchema(redaccionSchema);
|
||||
check("el JSON Schema no lleva $schema", !("$schema" in js));
|
||||
check("conserva additionalProperties", JSON.stringify(js).includes("additionalProperties"));
|
||||
check("conserva las descripciones para el modelo", JSON.stringify(js).includes("description"));
|
||||
check("el JSON Schema es serializable", typeof JSON.stringify(js) === "string" && JSON.stringify(js).length > 200);
|
||||
|
||||
console.log(fallas === 0 ? "\ntodo paso\n" : `\n${fallas} fallas\n`);
|
||||
process.exit(fallas === 0 ? 0 : 1);
|
||||
@@ -0,0 +1,123 @@
|
||||
import { validarPropuesta, normalizar, hayBloqueantes, type Aviso } from "@/lib/propuesta/validacion";
|
||||
import type { PropuestaConsultiva } from "@/lib/propuesta/schemas";
|
||||
import type { DatosEconomicos } from "@/lib/propuesta/economia";
|
||||
|
||||
let fallas = 0;
|
||||
function check(n: string, ok: boolean, d = "") {
|
||||
console.log(`${ok ? " OK " : " FALLA"} | ${n}${d ? " -> " + d : ""}`);
|
||||
if (!ok) fallas++;
|
||||
}
|
||||
const tiene = (a: Aviso[], regla: string) => a.some((x) => x.regla === regla);
|
||||
|
||||
const CITA = "no llevamos control de quien contesta el whatsapp el fin de semana";
|
||||
|
||||
const econ: DatosEconomicos = {
|
||||
partidas: [{ refPartida: "P01", servicioCotizadoId: "c1", nombre: "Sitio web", fase: 1, tipoPago: "unico", precio: 12000, tiempoEntrega: "2 semanas", modeloCobro: "fijo", horas: null, tarifaHora: null, entregables: [] }],
|
||||
totales: { subtotalUnico: 12000, subtotalMensual: 0, ivaUnico: 1920, ivaMensual: 0, totalUnico: 13920, totalMensual: 0, totalPrimerAnio: 13920, incluyeIva: true },
|
||||
moneda: "MXN",
|
||||
planBucefalo: null,
|
||||
};
|
||||
|
||||
const base = (): PropuestaConsultiva => ({
|
||||
hechos: {
|
||||
citas: [{ id: "C01", textoLiteral: CITA, quienLoDijo: "el socio" }],
|
||||
hechos: [{ id: "H01", enunciado: "No hay control de la atencion", confianza: "confirmado", citas: ["C01"] }],
|
||||
materialesPendientes: [{ texto: "Accesos al dominio", bloqueaEntrega: true }],
|
||||
decisionesPendientes: [{ texto: "Definir responsable de atencion", quienDecide: "el socio" }],
|
||||
mencionesFueraDeAlcance: [],
|
||||
redFlags: [],
|
||||
},
|
||||
diagnostico: {
|
||||
hallazgos: [{ id: "D01", urgencia: "rojo", titulo: "Prospectos sin seguimiento", descripcion: "Los mensajes del fin de semana se pierden.", confianza: "confirmado", citas: ["C01"], hechos: ["H01"] }],
|
||||
valorProblema: {
|
||||
dimensiones: [{ tipo: "tiempo", descripcion: "Horas perdidas de atencion", factores: [{ nombre: "horas por semana", valor: 8, confianza: "confirmado" }, { nombre: "semanas", valor: 52, confianza: "confirmado" }, { nombre: "costo por hora", valor: 400, confianza: "estimado" }], montoAnualMXN: 166400, confianza: "estimado", hechos: ["H01"] }],
|
||||
notaMetodologia: "Ocho horas por semana a costo cargado.",
|
||||
},
|
||||
resultados: [{ enunciado: "Ningun mensaje sin respuesta en mas de 24 horas", metrica: "tiempo de respuesta", lineaBase: null, periodoMedicion: "mensual" }],
|
||||
},
|
||||
redaccion: {
|
||||
hero: { titulo: "Propuesta de digitalizacion", subtitulo: "Ordenar la atencion para dejar de perder prospectos." },
|
||||
citaDestacadaId: "C01",
|
||||
alcance: [{ refPartida: "P01", descripcionResultado: "Un lugar a donde mandar a los prospectos que llegan de los anuncios." }],
|
||||
beneficios: [{ etiqueta: "Respuesta", texto: "Cada mensaje queda registrado y con responsable.", hallazgoId: "D01" }],
|
||||
exclusiones: [{ texto: "No incluye migrar el historico de pedidos de los ultimos 4 anos.", razon: "Se evalua en fase 2." }],
|
||||
backlogEvolucion: [],
|
||||
notasInternas: ["El socio es quien decide."],
|
||||
},
|
||||
});
|
||||
|
||||
const fuentes = { textoCliente: `El socio dijo: ${CITA}. Nada mas.`, textoInterno: "" };
|
||||
|
||||
check("normalizar quita acentos y puntuacion", normalizar("¿Como estas, Juan?") === "como estas juan");
|
||||
check("normalizar colapsa espacios", normalizar(" a b ") === "a b");
|
||||
|
||||
const limpia = validarPropuesta(base(), econ, fuentes);
|
||||
check("una propuesta valida no produce bloqueantes", !hayBloqueantes(limpia), JSON.stringify(limpia.slice(0, 2)));
|
||||
|
||||
let p = base(); p.redaccion.alcance[0].refPartida = "P99";
|
||||
check("R2 detecta una partida inventada", tiene(validarPropuesta(p, econ, fuentes), "R2"));
|
||||
|
||||
p = base(); p.redaccion.alcance = [];
|
||||
check("R2b avisa de una partida cotizada y no descrita", tiene(validarPropuesta(p, econ, fuentes), "R2b"));
|
||||
|
||||
p = base(); p.redaccion.citaDestacadaId = "C09";
|
||||
check("R3 detecta una cita inexistente", tiene(validarPropuesta(p, econ, fuentes), "R3"));
|
||||
|
||||
p = base(); p.hechos.citas[0].textoLiteral = "esto nunca lo dijo nadie en la reunion";
|
||||
check("R3 detecta una cita no verificable", tiene(validarPropuesta(p, econ, fuentes), "R3"));
|
||||
|
||||
p = base(); p.hechos.citas[0].textoLiteral = "NO LLEVAMOS CONTROL, de quien contesta... el WhatsApp el fin de semana!";
|
||||
check("R3 tolera acentos, mayusculas y puntuacion", !tiene(validarPropuesta(p, econ, fuentes), "R3"));
|
||||
|
||||
p = base(); p.diagnostico.hallazgos[0].citas = []; p.diagnostico.hallazgos[0].hechos = [];
|
||||
check("R4 degrada un confirmado sin evidencia", tiene(validarPropuesta(p, econ, fuentes), "R4"));
|
||||
|
||||
p = base(); p.diagnostico.valorProblema.dimensiones[0].montoAnualMXN = 999999;
|
||||
check("R5 detecta aritmetica que no cuadra", tiene(validarPropuesta(p, econ, fuentes), "R5"));
|
||||
|
||||
p = base(); p.diagnostico.valorProblema.dimensiones[0].montoAnualMXN = null; p.diagnostico.valorProblema.dimensiones[0].factores = [];
|
||||
check("R5 no se queja si no hay cifra", !tiene(validarPropuesta(p, econ, fuentes), "R5"));
|
||||
|
||||
p = base();
|
||||
p.diagnostico.valorProblema.dimensiones[0].factores = p.diagnostico.valorProblema.dimensiones[0].factores.map((f) => ({ ...f, confianza: "estimado" as const }));
|
||||
check("R5b avisa si el valor anual no tiene ni un factor confirmado", tiene(validarPropuesta(p, econ, fuentes), "R5b"));
|
||||
check("R5b no avisa si hay al menos un confirmado", !tiene(validarPropuesta(base(), econ, fuentes), "R5b"));
|
||||
|
||||
p = base(); p.redaccion.beneficios[0].hallazgoId = "D99";
|
||||
check("R6 detecta un beneficio colgante", tiene(validarPropuesta(p, econ, fuentes), "R6"));
|
||||
|
||||
p = base(); p.redaccion.beneficios[0].texto = "Lo integramos con HubSpot sin problema alguno.";
|
||||
check("MARCA detecta otro CRM", tiene(validarPropuesta(p, econ, fuentes), "MARCA"));
|
||||
|
||||
p = base(); p.redaccion.hero.subtitulo = "Una inversion de 1,800 USD al mes para tu negocio.";
|
||||
check("MONEDA detecta USD", tiene(validarPropuesta(p, econ, fuentes), "MONEDA"));
|
||||
|
||||
p = base(); p.redaccion.beneficios[0].texto = "Te garantizamos la posicion numero uno en Google.";
|
||||
check("GARANTIA detecta la promesa", tiene(validarPropuesta(p, econ, fuentes), "GARANTIA"));
|
||||
|
||||
p = base(); p.redaccion.hero.subtitulo = "El sueldo de quien atiende sale muy caro hoy en dia.";
|
||||
check("PII advierte sobre tema salarial", tiene(validarPropuesta(p, econ, fuentes), "PII"));
|
||||
check("PII es advertencia, no bloqueante",
|
||||
validarPropuesta(p, econ, fuentes).filter((a) => a.regla === "PII").every((a) => a.severidad === "advertencia"));
|
||||
|
||||
// ── R0: la fuga de notas internas, que es la razon de que exista ──
|
||||
const interno = "el socio pidio descuento antes de entender el alcance del proyecto completo";
|
||||
p = base(); p.redaccion.hero.subtitulo = `Contexto del proyecto: ${interno}.`;
|
||||
check("R0 detecta la fuga de notas internas", tiene(validarPropuesta(p, econ, { ...fuentes, textoInterno: interno }), "R0"));
|
||||
check("R0 es bloqueante",
|
||||
validarPropuesta(p, econ, { ...fuentes, textoInterno: interno }).filter((a) => a.regla === "R0").every((a) => a.severidad === "bloqueante"));
|
||||
check("R0 no dispara si no hay fuga", !tiene(validarPropuesta(base(), econ, { ...fuentes, textoInterno: interno }), "R0"));
|
||||
check("R0 sin notas internas no hace nada", !tiene(validarPropuesta(base(), econ, fuentes), "R0"));
|
||||
|
||||
// La fuga tambien se detecta en un hallazgo, no solo en el hero.
|
||||
p = base(); p.diagnostico.hallazgos[0].descripcion = `Observado: ${interno}.`;
|
||||
check("R0 mira todos los campos visibles, no solo el hero",
|
||||
tiene(validarPropuesta(p, econ, { ...fuentes, textoInterno: interno }), "R0"));
|
||||
|
||||
// Las notasInternas del propio objeto NO deben disparar R0: no se imprimen.
|
||||
p = base(); p.redaccion.notasInternas = [interno];
|
||||
check("R0 no se queja de notasInternas (no se imprimen)",
|
||||
!tiene(validarPropuesta(p, econ, { ...fuentes, textoInterno: interno }), "R0"));
|
||||
|
||||
console.log(fallas === 0 ? "\ntodo paso\n" : `\n${fallas} fallas\n`);
|
||||
process.exit(fallas === 0 ? 0 : 1);
|
||||
@@ -45,6 +45,7 @@ export default async function EditarCotizacionPage({
|
||||
incluirBonos: cot.incluirBonos,
|
||||
incluirFinanciamiento: cot.incluirFinanciamiento,
|
||||
observaciones: cot.observaciones || "",
|
||||
observacionesInternas: cot.observacionesInternas || "",
|
||||
planBucefaloNivel: cot.planBucefalo?.nivel || null,
|
||||
esDoble: cot.esDoble,
|
||||
opciones: (cot.opcionesMetadata as { "1"?: object; "2"?: object } | null) ?? {},
|
||||
|
||||
@@ -17,6 +17,7 @@ import { DeleteCotizacionButton } from "./DeleteButton";
|
||||
import { CambiarEstadoButtons } from "./CambiarEstadoButtons";
|
||||
import { PreciosEditables } from "./PreciosEditables";
|
||||
import { RegistroHorasPanel } from "./RegistroHorasPanel";
|
||||
import PropuestaIAPanel from "@/components/PropuestaIAPanel";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
@@ -226,10 +227,31 @@ export default async function CotizacionDetailPage({
|
||||
|
||||
{cot.observaciones && (
|
||||
<div className="bg-card-bg rounded-xl border border-border p-5">
|
||||
<h3 className="font-semibold mb-2">Observaciones</h3>
|
||||
<h3 className="font-semibold mb-2 flex items-center gap-2">
|
||||
Observaciones
|
||||
<span className="text-[11px] font-semibold uppercase tracking-wide px-2 py-0.5 rounded-full bg-primary-light text-primary">
|
||||
Las ve el cliente
|
||||
</span>
|
||||
</h3>
|
||||
<p className="text-sm text-muted whitespace-pre-wrap">{cot.observaciones}</p>
|
||||
</div>
|
||||
)}
|
||||
|
||||
<PropuestaIAPanel cotizacionId={cot.id} numero={cot.numero} />
|
||||
|
||||
{/* Unico lugar donde se muestran las notas internas. No van a ningun
|
||||
exportador: ni CotizacionPDFData ni ExcelData declaran el campo. */}
|
||||
{cot.observacionesInternas && (
|
||||
<div className="rounded-xl border border-amber-300 bg-amber-50 p-5">
|
||||
<h3 className="font-semibold mb-2 flex items-center gap-2 text-amber-900">
|
||||
Notas internas
|
||||
<span className="text-[11px] font-semibold uppercase tracking-wide px-2 py-0.5 rounded-full bg-amber-200 text-amber-900">
|
||||
No sale de la app
|
||||
</span>
|
||||
</h3>
|
||||
<p className="text-sm text-amber-900/80 whitespace-pre-wrap">{cot.observacionesInternas}</p>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
@@ -100,6 +100,7 @@ export async function PUT(
|
||||
esDoble,
|
||||
opciones,
|
||||
observaciones,
|
||||
observacionesInternas,
|
||||
cliente,
|
||||
servicios,
|
||||
planBucefalo,
|
||||
@@ -158,6 +159,7 @@ export async function PUT(
|
||||
...(esDoble !== undefined && { esDoble }),
|
||||
...(esDoble !== undefined && { opcionesMetadata: esDoble ? opciones ?? {} : undefined }),
|
||||
...(observaciones !== undefined && { observaciones }),
|
||||
...(observacionesInternas !== undefined && { observacionesInternas }),
|
||||
...(estado && ESTADOS_COTIZACION.includes(estado as typeof ESTADOS_COTIZACION[number]) && { estado }),
|
||||
},
|
||||
});
|
||||
|
||||
@@ -26,6 +26,7 @@ export async function POST(request: NextRequest) {
|
||||
esDoble,
|
||||
opciones,
|
||||
observaciones,
|
||||
observacionesInternas,
|
||||
cliente,
|
||||
asesorId,
|
||||
servicios,
|
||||
@@ -81,6 +82,7 @@ export async function POST(request: NextRequest) {
|
||||
esDoble: esDoble ?? false,
|
||||
opcionesMetadata: esDoble ? opciones ?? {} : undefined,
|
||||
observaciones: observaciones || null,
|
||||
observacionesInternas: observacionesInternas || null,
|
||||
clienteId: clienteIdFinal,
|
||||
asesorId,
|
||||
estado: "borrador",
|
||||
|
||||
@@ -17,7 +17,12 @@ export async function GET(
|
||||
include: {
|
||||
cliente: true,
|
||||
asesor: true,
|
||||
servicios: { include: { servicioCatalogo: true } },
|
||||
// Mismo orderBy que el PDF: los dos documentos van en el mismo correo y
|
||||
// deben listar las partidas en el mismo orden.
|
||||
servicios: {
|
||||
include: { servicioCatalogo: true },
|
||||
orderBy: [{ fase: "asc" }, { createdAt: "asc" }],
|
||||
},
|
||||
planBucefalo: true,
|
||||
},
|
||||
}),
|
||||
@@ -67,6 +72,9 @@ export async function GET(
|
||||
planBucefaloPrecio: cot.planBucefalo?.precio ?? null,
|
||||
colorPrimario: branding.colorPrimario || "#2563eb",
|
||||
colorSecundario: branding.colorSecundario || "#1e293b",
|
||||
incluirIva: cot.incluirIva,
|
||||
// El Excel es un documento del cliente: solo el texto del cliente.
|
||||
observaciones: cot.observaciones,
|
||||
};
|
||||
|
||||
const buffer = await buildCotizacionExcel(data);
|
||||
|
||||
@@ -80,6 +80,7 @@ export async function POST(request: NextRequest) {
|
||||
planBucefaloNivel: draft.planBucefaloNivel,
|
||||
colorPrimario: branding.colorPrimario || "#2563eb",
|
||||
colorSecundario: branding.colorSecundario || "#1e293b",
|
||||
observaciones: draft.observaciones,
|
||||
};
|
||||
|
||||
const buffer = await buildCotizacionExcel(data);
|
||||
|
||||
@@ -10,18 +10,25 @@ export async function GET(
|
||||
) {
|
||||
try {
|
||||
const { id } = await params;
|
||||
const [cot, config, branding] = await Promise.all([
|
||||
const [cot, config, branding, bonos] = await Promise.all([
|
||||
prisma.cotizacion.findUnique({
|
||||
where: { id },
|
||||
include: {
|
||||
cliente: true,
|
||||
asesor: true,
|
||||
servicios: { include: { servicioCatalogo: true } },
|
||||
// orderBy explicito: drawSection abre un encabezado de fase nuevo cada vez
|
||||
// que cambia serv.fase, o sea que asume el array agrupado. Sin esto el orden
|
||||
// lo decide Postgres y el PDF puede salir distinto del Excel del mismo envio.
|
||||
servicios: {
|
||||
include: { servicioCatalogo: true },
|
||||
orderBy: [{ fase: "asc" }, { createdAt: "asc" }],
|
||||
},
|
||||
planBucefalo: true,
|
||||
},
|
||||
}),
|
||||
getConfigBancaria(),
|
||||
getConfigBranding(),
|
||||
prisma.bono.findMany({ where: { activo: true }, orderBy: { numero: "asc" } }),
|
||||
]);
|
||||
|
||||
if (!cot) {
|
||||
@@ -61,6 +68,10 @@ export async function GET(
|
||||
planBucefaloNivel: cot.planBucefalo?.nivel || null,
|
||||
planBucefaloPrecio: cot.planBucefalo?.precio || 0,
|
||||
incluirBonos: cot.incluirBonos,
|
||||
bonos,
|
||||
incluirIva: cot.incluirIva,
|
||||
// Solo el texto del cliente. observacionesInternas no se pasa nunca.
|
||||
observaciones: cot.observaciones,
|
||||
configBancaria: config,
|
||||
...branding,
|
||||
});
|
||||
|
||||
@@ -1,7 +1,8 @@
|
||||
import { NextRequest, NextResponse } from "next/server";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { generateCotizacionPDF } from "@/lib/pdf-generator";
|
||||
import { calcularVigencia, bucefaloPrecio, sanitizeFilename } from "@/lib/calculators";
|
||||
import { getConfigBranding } from "@/lib/config-helpers";
|
||||
import { getConfigBranding, getConfigBancaria } from "@/lib/config-helpers";
|
||||
|
||||
export async function POST(request: NextRequest) {
|
||||
try {
|
||||
@@ -42,7 +43,14 @@ export async function POST(request: NextRequest) {
|
||||
const fechaCot = new Date(draft.fecha);
|
||||
const vigencia = calcularVigencia(fechaCot);
|
||||
|
||||
const branding = await getConfigBranding();
|
||||
// El borrador leia solo el branding, asi que imprimia los datos bancarios
|
||||
// hardcodeados del generador en vez de los configurados. El Excel de borrador
|
||||
// si leia ambos: esto empareja los dos.
|
||||
const [branding, configBancaria, bonos] = await Promise.all([
|
||||
getConfigBranding(),
|
||||
getConfigBancaria(),
|
||||
prisma.bono.findMany({ where: { activo: true }, orderBy: { numero: "asc" } }),
|
||||
]);
|
||||
const empresa = draft.clienteEmpresa || draft.clienteNombre;
|
||||
const nombre = `${sanitizeFilename(empresa)} - ${sanitizeFilename(draft.clienteNombre)} - BORRADOR`;
|
||||
|
||||
@@ -63,6 +71,10 @@ export async function POST(request: NextRequest) {
|
||||
planBucefaloNivel: draft.planBucefaloNivel,
|
||||
planBucefaloPrecio: draft.planBucefaloNivel ? bucefaloPrecio(draft.planBucefaloNivel) : 0,
|
||||
incluirBonos: draft.incluirBonos,
|
||||
bonos,
|
||||
// El cliente ya mandaba observaciones en el body; el generador nunca las recibia.
|
||||
observaciones: draft.observaciones,
|
||||
configBancaria,
|
||||
...branding,
|
||||
});
|
||||
|
||||
|
||||
@@ -0,0 +1,78 @@
|
||||
import { NextRequest, NextResponse } from "next/server";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { getConfigBranding } from "@/lib/config-helpers";
|
||||
import { sanitizeFilename } from "@/lib/calculators";
|
||||
import { cargarEconomia } from "@/lib/propuesta/economia";
|
||||
import { generarPropuestaPDF, generarAnexoInternoPDF } from "@/lib/propuesta/pdf";
|
||||
import { hayBloqueantes, type Aviso } from "@/lib/propuesta/validacion";
|
||||
import type { PropuestaConsultiva } from "@/lib/propuesta/schemas";
|
||||
|
||||
/** GET /api/propuesta-ia/:id/pdf -> documento del cliente
|
||||
* GET /api/propuesta-ia/:id/pdf?anexo=1 -> anexo interno (archivo aparte, a proposito) */
|
||||
export async function GET(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
|
||||
try {
|
||||
const { id } = await params;
|
||||
const anexo = request.nextUrl.searchParams.get("anexo") === "1";
|
||||
|
||||
const [cot, fila, branding] = await Promise.all([
|
||||
prisma.cotizacion.findUnique({ where: { id }, include: { cliente: true, asesor: true } }),
|
||||
prisma.propuestaIA.findFirst({ where: { cotizacionId: id }, orderBy: { createdAt: "desc" } }),
|
||||
getConfigBranding(),
|
||||
]);
|
||||
|
||||
if (!cot) return NextResponse.json({ error: "Cotizacion no encontrada" }, { status: 404 });
|
||||
if (!fila) return NextResponse.json({ error: "Todavia no se ha generado la propuesta" }, { status: 404 });
|
||||
|
||||
// Los avisos bloqueantes tienen que bloquear DE VERDAD el documento del cliente.
|
||||
// Antes esta ruta ni siquiera leia `avisos`: la severidad "bloqueante" era
|
||||
// decorativa y el PDF se descargaba igual con una fuga de notas internas o un
|
||||
// monto en USD dentro. El anexo interno SI se permite: es justamente el que el
|
||||
// asesor necesita para entender que hay que corregir.
|
||||
const avisos = Array.isArray(fila.avisos) ? (fila.avisos as unknown as Aviso[]) : [];
|
||||
if (!anexo && hayBloqueantes(avisos)) {
|
||||
const cuales = avisos
|
||||
.filter((a) => a.severidad === "bloqueante")
|
||||
.map((a) => `${a.regla}${a.ruta ? ` (${a.ruta})` : ""}: ${a.mensaje}`);
|
||||
return NextResponse.json(
|
||||
{
|
||||
error:
|
||||
"La propuesta tiene avisos bloqueantes sin resolver. Corrigelos en el panel y guarda antes de descargar el documento del cliente.",
|
||||
bloqueantes: cuales,
|
||||
},
|
||||
{ status: 409 }
|
||||
);
|
||||
}
|
||||
|
||||
const propuesta = (fila.contenidoEditado ?? fila.contenidoIA) as unknown as PropuestaConsultiva;
|
||||
const economia = await cargarEconomia(id);
|
||||
|
||||
const datos = {
|
||||
propuesta,
|
||||
economia,
|
||||
cliente: cot.cliente.nombre,
|
||||
empresa: cot.cliente.empresa || "",
|
||||
asesor: cot.asesor.name,
|
||||
numero: cot.numero,
|
||||
fecha: cot.fecha,
|
||||
vigencia: cot.vigencia,
|
||||
proyecto: cot.proyecto,
|
||||
branding,
|
||||
};
|
||||
|
||||
const buffer = anexo ? await generarAnexoInternoPDF(datos) : await generarPropuestaPDF(datos);
|
||||
const empresa = cot.cliente.empresa || cot.cliente.nombre;
|
||||
const nombre = anexo
|
||||
? `${sanitizeFilename(empresa)} - ${cot.numero} - INTERNO NO ENVIAR`
|
||||
: `${sanitizeFilename(empresa)} - ${cot.numero} - Propuesta consultiva`;
|
||||
|
||||
return new NextResponse(new Uint8Array(buffer), {
|
||||
headers: {
|
||||
"Content-Type": "application/pdf",
|
||||
"Content-Disposition": `attachment; filename="${nombre}.pdf"`,
|
||||
},
|
||||
});
|
||||
} catch (error: unknown) {
|
||||
const msg = error instanceof Error ? error.message : "Error interno";
|
||||
return NextResponse.json({ error: msg }, { status: 500 });
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,154 @@
|
||||
import { NextRequest, NextResponse } from "next/server";
|
||||
import { z } from "zod";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { cargarEconomia } from "@/lib/propuesta/economia";
|
||||
import { generarPropuesta } from "@/lib/propuesta/pipeline";
|
||||
import { validarPropuesta } from "@/lib/propuesta/validacion";
|
||||
import { propuestaCompletaSchema, type PropuestaConsultiva } from "@/lib/propuesta/schemas";
|
||||
|
||||
/** Reune el contexto humano de la cotizacion. Distingue lo que ve el cliente de lo
|
||||
* interno: el interno se manda al modelo (necesita el contexto) pero R0 comprueba
|
||||
* despues que no se haya colado a la salida. */
|
||||
async function contextoDe(cotizacionId: string) {
|
||||
const cot = await prisma.cotizacion.findUnique({
|
||||
where: { id: cotizacionId },
|
||||
include: { cliente: true, asesor: true, servicios: true },
|
||||
});
|
||||
if (!cot) return null;
|
||||
const notasPartidas = cot.servicios
|
||||
.map((s) => s.notas)
|
||||
.filter((n): n is string => Boolean(n && n.trim()))
|
||||
.join("\n");
|
||||
return { cot, notasPartidas };
|
||||
}
|
||||
|
||||
export async function POST(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
|
||||
try {
|
||||
const { id } = await params;
|
||||
const body = await request.json().catch(() => ({}));
|
||||
const transcripcion: string = typeof body.transcripcion === "string" ? body.transcripcion : "";
|
||||
|
||||
const ctx = await contextoDe(id);
|
||||
if (!ctx) return NextResponse.json({ error: "Cotizacion no encontrada" }, { status: 404 });
|
||||
const { cot, notasPartidas } = ctx;
|
||||
|
||||
// La doble propuesta todavia no esta soportada en el documento consultivo: su
|
||||
// estructura asume UNA lista de alcance y UNA caja de totales, asi que sumaria las
|
||||
// dos opciones —que son alternativas excluyentes— y mostraria un total inflado.
|
||||
// Mejor no generar nada que generar un documento con un total que no existe.
|
||||
if (cot.esDoble) {
|
||||
return NextResponse.json(
|
||||
{
|
||||
error:
|
||||
"Esta cotizacion es de doble propuesta y el documento consultivo todavia no las soporta: sumaria las dos opciones como si fueran una sola. Genera la propuesta desde una cotizacion de opcion unica.",
|
||||
},
|
||||
{ status: 400 }
|
||||
);
|
||||
}
|
||||
|
||||
const economia = await cargarEconomia(id);
|
||||
if (!economia.partidas.length) {
|
||||
return NextResponse.json(
|
||||
{ error: "La cotizacion no tiene partidas seleccionadas. Agrega servicios antes de generar la propuesta." },
|
||||
{ status: 400 }
|
||||
);
|
||||
}
|
||||
|
||||
const { propuesta, traza } = await generarPropuesta({
|
||||
entrada: {
|
||||
transcripcion,
|
||||
notas: notasPartidas,
|
||||
observaciones: cot.observaciones || "",
|
||||
cliente: cot.cliente.nombre,
|
||||
empresa: cot.cliente.empresa || "",
|
||||
proyecto: cot.proyecto,
|
||||
},
|
||||
economia,
|
||||
});
|
||||
|
||||
const avisos = validarPropuesta(propuesta, economia, {
|
||||
textoCliente: [transcripcion, cot.observaciones || "", notasPartidas].join("\n"),
|
||||
textoInterno: cot.observacionesInternas || "",
|
||||
});
|
||||
|
||||
const fila = await prisma.propuestaIA.create({
|
||||
data: {
|
||||
cotizacionId: id,
|
||||
contenidoIA: propuesta as unknown as object,
|
||||
traza: traza as unknown as object,
|
||||
avisos: avisos as unknown as object,
|
||||
modelo: traza.modelo,
|
||||
transcripcion: transcripcion || null,
|
||||
},
|
||||
});
|
||||
|
||||
return NextResponse.json({ id: fila.id, propuesta, avisos, traza });
|
||||
} catch (error: unknown) {
|
||||
const msg = error instanceof Error ? error.message : "Error interno";
|
||||
return NextResponse.json({ error: msg }, { status: 500 });
|
||||
}
|
||||
}
|
||||
|
||||
export async function GET(_request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
|
||||
try {
|
||||
const { id } = await params;
|
||||
const fila = await prisma.propuestaIA.findFirst({
|
||||
where: { cotizacionId: id },
|
||||
orderBy: { createdAt: "desc" },
|
||||
});
|
||||
if (!fila) return NextResponse.json({ propuesta: null });
|
||||
return NextResponse.json({
|
||||
id: fila.id,
|
||||
propuesta: fila.contenidoEditado ?? fila.contenidoIA,
|
||||
editada: fila.contenidoEditado !== null,
|
||||
avisos: fila.avisos,
|
||||
traza: fila.traza,
|
||||
createdAt: fila.createdAt,
|
||||
});
|
||||
} catch (error: unknown) {
|
||||
const msg = error instanceof Error ? error.message : "Error interno";
|
||||
return NextResponse.json({ error: msg }, { status: 500 });
|
||||
}
|
||||
}
|
||||
|
||||
export async function PATCH(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
|
||||
try {
|
||||
const { id } = await params;
|
||||
const body = await request.json();
|
||||
const parsed = propuestaCompletaSchema.safeParse(body.propuesta);
|
||||
if (!parsed.success) {
|
||||
return NextResponse.json({ error: z.prettifyError(parsed.error) }, { status: 400 });
|
||||
}
|
||||
|
||||
const fila = await prisma.propuestaIA.findFirst({
|
||||
where: { cotizacionId: id },
|
||||
orderBy: { createdAt: "desc" },
|
||||
});
|
||||
if (!fila) return NextResponse.json({ error: "No hay propuesta generada para esta cotizacion" }, { status: 404 });
|
||||
|
||||
// La edicion del asesor se revalida: pudo introducir una fuga, un USD o una
|
||||
// promesa de resultado sin darse cuenta.
|
||||
//
|
||||
// Se incluye la transcripcion GUARDADA con la propuesta. Antes solo vivia en
|
||||
// memoria durante la peticion de generacion, asi que al editar R3 se quedaba sin
|
||||
// fuente contra la cual comprobar la cita literal y el aviso desaparecia solo.
|
||||
const [economia, ctx] = await Promise.all([cargarEconomia(id), contextoDe(id)]);
|
||||
const avisos = validarPropuesta(parsed.data as PropuestaConsultiva, economia, {
|
||||
textoCliente: [fila.transcripcion || "", ctx?.cot.observaciones || "", ctx?.notasPartidas || ""].join("\n"),
|
||||
textoInterno: ctx?.cot.observacionesInternas || "",
|
||||
});
|
||||
|
||||
await prisma.propuestaIA.update({
|
||||
where: { id: fila.id },
|
||||
data: {
|
||||
contenidoEditado: parsed.data as unknown as object,
|
||||
avisos: avisos as unknown as object,
|
||||
},
|
||||
});
|
||||
|
||||
return NextResponse.json({ ok: true, avisos });
|
||||
} catch (error: unknown) {
|
||||
const msg = error instanceof Error ? error.message : "Error interno";
|
||||
return NextResponse.json({ error: msg }, { status: 500 });
|
||||
}
|
||||
}
|
||||
@@ -17,6 +17,8 @@ import {
|
||||
Clock,
|
||||
Plus,
|
||||
Trash2,
|
||||
Eye,
|
||||
Lock,
|
||||
} from "lucide-react";
|
||||
import clsx from "clsx";
|
||||
import {
|
||||
@@ -82,6 +84,7 @@ export interface ExistingData {
|
||||
incluirBonos: boolean;
|
||||
incluirFinanciamiento: boolean;
|
||||
observaciones: string;
|
||||
observacionesInternas?: string;
|
||||
planBucefaloNivel: string | null;
|
||||
estado: string;
|
||||
servicios: ServicioSeleccionado[];
|
||||
@@ -165,6 +168,7 @@ export function CotizacionForm({
|
||||
store.setField("incluirBonos", existingData.incluirBonos);
|
||||
store.setField("incluirFinanciamiento", existingData.incluirFinanciamiento);
|
||||
store.setField("observaciones", existingData.observaciones);
|
||||
store.setField("observacionesInternas", existingData.observacionesInternas ?? "");
|
||||
store.setField("planBucefaloNivel", existingData.planBucefaloNivel);
|
||||
store.setField("esDoble", existingData.esDoble ?? false);
|
||||
store.setField("opciones", existingData.opciones ?? {});
|
||||
@@ -333,6 +337,7 @@ export function CotizacionForm({
|
||||
esDoble: store.draft.esDoble,
|
||||
opciones: store.draft.esDoble ? store.draft.opciones : undefined,
|
||||
observaciones: store.draft.observaciones,
|
||||
observacionesInternas: store.draft.observacionesInternas,
|
||||
cliente: {
|
||||
nombre: store.draft.clienteNombre,
|
||||
empresa: store.draft.clienteEmpresa,
|
||||
@@ -1217,19 +1222,51 @@ export function CotizacionForm({
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div className="bg-card-bg rounded-xl border border-border p-5">
|
||||
<label className="block text-sm font-medium text-muted mb-1">
|
||||
Observaciones
|
||||
</label>
|
||||
<textarea
|
||||
value={store.draft.observaciones}
|
||||
onChange={(e) =>
|
||||
store.setField("observaciones", e.target.value)
|
||||
}
|
||||
rows={3}
|
||||
placeholder="Notas adicionales para la cotizacion..."
|
||||
className={INPUT_CLS}
|
||||
/>
|
||||
{/* Dos campos deliberadamente distintos. El de arriba se imprime en el PDF y
|
||||
el Excel que recibe el cliente; el de abajo no sale de la aplicacion.
|
||||
La diferencia visual es la barrera contra escribir en el equivocado. */}
|
||||
<div className="bg-card-bg rounded-xl border border-border p-5 space-y-5">
|
||||
<div>
|
||||
<label className="flex items-center gap-2 text-sm font-medium mb-1">
|
||||
<Eye className="w-4 h-4 text-primary" />
|
||||
Observaciones
|
||||
<span className="text-[11px] font-semibold uppercase tracking-wide px-2 py-0.5 rounded-full bg-primary-light text-primary">
|
||||
Las ve el cliente
|
||||
</span>
|
||||
</label>
|
||||
<p className="text-xs text-muted mb-2">
|
||||
Se imprime en el PDF y en el Excel que le envias. Condiciones, supuestos y
|
||||
aclaraciones del acuerdo.
|
||||
</p>
|
||||
<textarea
|
||||
value={store.draft.observaciones}
|
||||
onChange={(e) => store.setField("observaciones", e.target.value)}
|
||||
rows={3}
|
||||
placeholder="Ej: El anticipo es del 50%. El avance queda condicionado a la entrega de accesos."
|
||||
className={INPUT_CLS}
|
||||
/>
|
||||
</div>
|
||||
|
||||
<div className="rounded-lg border border-amber-300 bg-amber-50 p-4">
|
||||
<label className="flex items-center gap-2 text-sm font-medium mb-1 text-amber-900">
|
||||
<Lock className="w-4 h-4" />
|
||||
Notas internas
|
||||
<span className="text-[11px] font-semibold uppercase tracking-wide px-2 py-0.5 rounded-full bg-amber-200 text-amber-900">
|
||||
No sale de la app
|
||||
</span>
|
||||
</label>
|
||||
<p className="text-xs text-amber-800 mb-2">
|
||||
Contexto de la reunion, con quien hablar, riesgos, recordatorios. No se imprime
|
||||
en ningun documento ni se expone por el API.
|
||||
</p>
|
||||
<textarea
|
||||
value={store.draft.observacionesInternas}
|
||||
onChange={(e) => store.setField("observacionesInternas", e.target.value)}
|
||||
rows={3}
|
||||
placeholder="Ej: El que decide es el socio, no el que vino a la reunion. Pidio descuento antes de ver el alcance."
|
||||
className={INPUT_CLS}
|
||||
/>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
|
||||
@@ -0,0 +1,590 @@
|
||||
"use client";
|
||||
|
||||
import { useCallback, useEffect, useState } from "react";
|
||||
import { Sparkles, Download, Save, AlertTriangle, Info, Lock, RefreshCw, ChevronDown, ChevronRight } from "lucide-react";
|
||||
import { useToast, useConfirm } from "@/components/ui/DialogProvider";
|
||||
|
||||
// Panel de la propuesta consultiva: generar, revisar, editar y descargar.
|
||||
//
|
||||
// Regla de diseno deliberada: los avisos van ARRIBA de los botones de descarga.
|
||||
// El objetivo es que revisar sea mas facil que aprobar, no al reves.
|
||||
|
||||
type Confianza = "confirmado" | "estimado" | "por_validar";
|
||||
type Urgencia = "rojo" | "ambar" | "azul" | "verde";
|
||||
|
||||
interface Aviso {
|
||||
regla: string;
|
||||
severidad: "bloqueante" | "advertencia";
|
||||
mensaje: string;
|
||||
ruta?: string;
|
||||
}
|
||||
|
||||
interface Propuesta {
|
||||
hechos: {
|
||||
citas: { id: string; textoLiteral: string; quienLoDijo: string }[];
|
||||
hechos: { id: string; enunciado: string; confianza: Confianza; citas: string[] }[];
|
||||
materialesPendientes: { texto: string; bloqueaEntrega: boolean }[];
|
||||
decisionesPendientes: { texto: string; quienDecide: string }[];
|
||||
mencionesFueraDeAlcance: string[];
|
||||
redFlags: { senal: string; severidad: string }[];
|
||||
};
|
||||
diagnostico: {
|
||||
hallazgos: { id: string; urgencia: Urgencia; titulo: string; descripcion: string; confianza: Confianza; citas: string[]; hechos: string[] }[];
|
||||
valorProblema: {
|
||||
dimensiones: { tipo: string; descripcion: string; calculo: { factores: { nombre: string; valor: number }[]; montoAnualMXN: number | null }; confianza: Confianza; hechos: string[] }[];
|
||||
notaMetodologia: string;
|
||||
};
|
||||
resultados: { enunciado: string; metrica: string; lineaBase: string | null; periodoMedicion: string }[];
|
||||
};
|
||||
redaccion: {
|
||||
hero: { titulo: string; subtitulo: string };
|
||||
citaDestacadaId: string;
|
||||
alcance: { refPartida: string; descripcionResultado: string }[];
|
||||
beneficios: { etiqueta: string; texto: string; hallazgoId: string }[];
|
||||
exclusiones: { texto: string; razon: string }[];
|
||||
backlogEvolucion: { problema: string; momentoSugerido: string }[];
|
||||
notasInternas: string[];
|
||||
};
|
||||
}
|
||||
|
||||
const COLOR_URGENCIA: Record<Urgencia, string> = {
|
||||
rojo: "bg-red-500",
|
||||
ambar: "bg-amber-500",
|
||||
azul: "bg-blue-500",
|
||||
verde: "bg-green-500",
|
||||
};
|
||||
const ETIQUETA_URGENCIA: Record<Urgencia, string> = {
|
||||
rojo: "Problema critico",
|
||||
ambar: "Area de mejora",
|
||||
azul: "Oportunidad",
|
||||
verde: "Ventaja existente",
|
||||
};
|
||||
|
||||
const INPUT = "w-full px-3 py-2 border border-border rounded-lg text-sm focus:outline-none focus:ring-1 focus:ring-primary";
|
||||
|
||||
export default function PropuestaIAPanel({ cotizacionId }: { cotizacionId: string; numero?: string }) {
|
||||
const toast = useToast();
|
||||
const confirm = useConfirm();
|
||||
|
||||
const [abierto, setAbierto] = useState(false);
|
||||
const [cargando, setCargando] = useState(true);
|
||||
const [generando, setGenerando] = useState(false);
|
||||
const [guardando, setGuardando] = useState(false);
|
||||
const [transcripcion, setTranscripcion] = useState("");
|
||||
const [propuesta, setPropuesta] = useState<Propuesta | null>(null);
|
||||
const [avisos, setAvisos] = useState<Aviso[]>([]);
|
||||
const [editada, setEditada] = useState(false);
|
||||
const [sucio, setSucio] = useState(false);
|
||||
|
||||
const cargar = useCallback(async () => {
|
||||
try {
|
||||
const r = await fetch(`/api/propuesta-ia/${cotizacionId}`);
|
||||
const d = await r.json();
|
||||
if (d.propuesta) {
|
||||
setPropuesta(d.propuesta);
|
||||
setAvisos(Array.isArray(d.avisos) ? d.avisos : []);
|
||||
setEditada(Boolean(d.editada));
|
||||
setAbierto(true);
|
||||
}
|
||||
} finally {
|
||||
setCargando(false);
|
||||
}
|
||||
}, [cotizacionId]);
|
||||
|
||||
useEffect(() => {
|
||||
void cargar();
|
||||
}, [cargar]);
|
||||
|
||||
async function generar() {
|
||||
if (propuesta) {
|
||||
const ok = await confirm({
|
||||
title: "Regenerar la propuesta",
|
||||
message: "Se generara una propuesta nueva. La version actual y tus ediciones quedaran reemplazadas.",
|
||||
confirmText: "Regenerar",
|
||||
danger: true,
|
||||
});
|
||||
if (!ok) return;
|
||||
}
|
||||
setGenerando(true);
|
||||
try {
|
||||
const r = await fetch(`/api/propuesta-ia/${cotizacionId}`, {
|
||||
method: "POST",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify({ transcripcion }),
|
||||
});
|
||||
const d = await r.json();
|
||||
if (!r.ok) {
|
||||
toast(d.error || "No se pudo generar la propuesta", "error");
|
||||
return;
|
||||
}
|
||||
setPropuesta(d.propuesta);
|
||||
setAvisos(Array.isArray(d.avisos) ? d.avisos : []);
|
||||
setEditada(false);
|
||||
setSucio(false);
|
||||
setAbierto(true);
|
||||
const bloqueantes = (d.avisos as Aviso[]).filter((a) => a.severidad === "bloqueante").length;
|
||||
toast(
|
||||
bloqueantes > 0
|
||||
? `Propuesta generada con ${bloqueantes} aviso(s) que debes resolver antes de enviarla.`
|
||||
: "Propuesta generada. Revisala antes de enviarla.",
|
||||
bloqueantes > 0 ? "error" : "success"
|
||||
);
|
||||
} catch (e) {
|
||||
toast(e instanceof Error ? e.message : "Error al generar", "error");
|
||||
} finally {
|
||||
setGenerando(false);
|
||||
}
|
||||
}
|
||||
|
||||
async function guardar() {
|
||||
if (!propuesta) return;
|
||||
setGuardando(true);
|
||||
try {
|
||||
const r = await fetch(`/api/propuesta-ia/${cotizacionId}`, {
|
||||
method: "PATCH",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify({ propuesta }),
|
||||
});
|
||||
const d = await r.json();
|
||||
if (!r.ok) {
|
||||
toast(typeof d.error === "string" ? d.error : "No se pudo guardar", "error");
|
||||
return;
|
||||
}
|
||||
setAvisos(Array.isArray(d.avisos) ? d.avisos : []);
|
||||
setEditada(true);
|
||||
setSucio(false);
|
||||
toast("Cambios guardados y revalidados.", "success");
|
||||
} finally {
|
||||
setGuardando(false);
|
||||
}
|
||||
}
|
||||
|
||||
/** Aplica un cambio al objeto y marca el panel como sucio. */
|
||||
function editar(fn: (p: Propuesta) => void) {
|
||||
setPropuesta((prev) => {
|
||||
if (!prev) return prev;
|
||||
const copia = structuredClone(prev) as Propuesta;
|
||||
fn(copia);
|
||||
return copia;
|
||||
});
|
||||
setSucio(true);
|
||||
}
|
||||
|
||||
const bloqueantes = avisos.filter((a) => a.severidad === "bloqueante");
|
||||
const advertencias = avisos.filter((a) => a.severidad === "advertencia");
|
||||
const citaDestacada = propuesta?.hechos.citas.find((c) => c.id === propuesta.redaccion.citaDestacadaId);
|
||||
|
||||
if (cargando) {
|
||||
return (
|
||||
<div className="bg-card-bg rounded-xl border border-border p-5">
|
||||
<p className="text-sm text-muted">Cargando propuesta consultiva...</p>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
return (
|
||||
<div className="bg-card-bg rounded-xl border border-border overflow-hidden">
|
||||
<button
|
||||
onClick={() => setAbierto((v) => !v)}
|
||||
className="w-full flex items-center justify-between px-5 py-4 hover:bg-gray-50"
|
||||
>
|
||||
<span className="flex items-center gap-2 font-semibold">
|
||||
<Sparkles className="w-4 h-4 text-primary" />
|
||||
Propuesta consultiva con IA
|
||||
{editada && (
|
||||
<span className="text-[11px] font-medium px-2 py-0.5 rounded-full bg-primary-light text-primary">
|
||||
editada por ti
|
||||
</span>
|
||||
)}
|
||||
</span>
|
||||
{abierto ? <ChevronDown className="w-4 h-4" /> : <ChevronRight className="w-4 h-4" />}
|
||||
</button>
|
||||
|
||||
{abierto && (
|
||||
<div className="px-5 pb-5 space-y-5 border-t border-border pt-5">
|
||||
{/* ── Entrada ── */}
|
||||
<div>
|
||||
<label className="block text-sm font-medium mb-1">Transcripcion de la reunion (opcional)</label>
|
||||
<p className="text-xs text-muted mb-2">
|
||||
Pega aqui lo que se dijo en la reunion de discovery. Sin transcripcion, la IA trabaja
|
||||
solo con las observaciones y notas de la cotizacion, y marcara mas cosas por validar.
|
||||
</p>
|
||||
<textarea
|
||||
value={transcripcion}
|
||||
onChange={(e) => setTranscripcion(e.target.value)}
|
||||
rows={4}
|
||||
placeholder="Pega la transcripcion..."
|
||||
className={INPUT}
|
||||
/>
|
||||
<button
|
||||
onClick={generar}
|
||||
disabled={generando}
|
||||
className="mt-3 flex items-center gap-2 px-4 py-2 rounded-lg text-sm text-white bg-primary hover:opacity-90 disabled:opacity-50"
|
||||
>
|
||||
{generando ? <RefreshCw className="w-4 h-4 animate-spin" /> : <Sparkles className="w-4 h-4" />}
|
||||
{generando ? "Generando (tarda un par de minutos)..." : propuesta ? "Regenerar" : "Generar propuesta"}
|
||||
</button>
|
||||
</div>
|
||||
|
||||
{propuesta && (
|
||||
<>
|
||||
{/* ── Avisos: van ARRIBA de las descargas a proposito ── */}
|
||||
{bloqueantes.length > 0 && (
|
||||
<div className="rounded-lg border border-red-300 bg-red-50 p-4">
|
||||
<p className="flex items-center gap-2 text-sm font-semibold text-red-800 mb-2">
|
||||
<AlertTriangle className="w-4 h-4" />
|
||||
{bloqueantes.length} aviso(s) que debes resolver antes de enviar
|
||||
</p>
|
||||
<ul className="space-y-1">
|
||||
{bloqueantes.map((a, i) => (
|
||||
<li key={i} className="text-xs text-red-800">
|
||||
<span className="font-mono font-semibold">{a.regla}</span>
|
||||
{a.ruta && <span className="text-red-600"> · {a.ruta}</span>} — {a.mensaje}
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
</div>
|
||||
)}
|
||||
{advertencias.length > 0 && (
|
||||
<div className="rounded-lg border border-amber-300 bg-amber-50 p-4">
|
||||
<p className="flex items-center gap-2 text-sm font-semibold text-amber-900 mb-2">
|
||||
<Info className="w-4 h-4" />
|
||||
{advertencias.length} cosa(s) que conviene revisar
|
||||
</p>
|
||||
<ul className="space-y-1">
|
||||
{advertencias.map((a, i) => (
|
||||
<li key={i} className="text-xs text-amber-900">
|
||||
<span className="font-mono font-semibold">{a.regla}</span>
|
||||
{a.ruta && <span className="opacity-70"> · {a.ruta}</span>} — {a.mensaje}
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
</div>
|
||||
)}
|
||||
{avisos.length === 0 && (
|
||||
<div className="rounded-lg border border-green-300 bg-green-50 p-3">
|
||||
<p className="text-sm text-green-800">Sin avisos de validacion. Revisa el contenido de todas formas.</p>
|
||||
</div>
|
||||
)}
|
||||
|
||||
{/* ── Edicion ── */}
|
||||
<div className="space-y-4">
|
||||
<div>
|
||||
<label className="block text-xs font-semibold uppercase tracking-wide text-muted mb-1">Titulo</label>
|
||||
<input
|
||||
value={propuesta.redaccion.hero.titulo}
|
||||
onChange={(e) => editar((p) => { p.redaccion.hero.titulo = e.target.value; })}
|
||||
className={INPUT}
|
||||
/>
|
||||
</div>
|
||||
<div>
|
||||
<label className="block text-xs font-semibold uppercase tracking-wide text-muted mb-1">Subtitulo</label>
|
||||
<textarea
|
||||
value={propuesta.redaccion.hero.subtitulo}
|
||||
onChange={(e) => editar((p) => { p.redaccion.hero.subtitulo = e.target.value; })}
|
||||
rows={2}
|
||||
className={INPUT}
|
||||
/>
|
||||
</div>
|
||||
|
||||
<div>
|
||||
<label className="block text-xs font-semibold uppercase tracking-wide text-muted mb-2">
|
||||
Hallazgos del diagnostico
|
||||
</label>
|
||||
<div className="space-y-3">
|
||||
{propuesta.diagnostico.hallazgos.map((h, i) => (
|
||||
<div key={h.id} className="border border-border rounded-lg p-3">
|
||||
<div className="flex items-center gap-2 mb-2">
|
||||
<span className={`w-2.5 h-2.5 rounded-full ${COLOR_URGENCIA[h.urgencia]}`} />
|
||||
<span className="text-[11px] text-muted">
|
||||
{ETIQUETA_URGENCIA[h.urgencia]} · {h.confianza.replace("_", " ")}
|
||||
</span>
|
||||
</div>
|
||||
<input
|
||||
value={h.titulo}
|
||||
onChange={(e) => editar((p) => { p.diagnostico.hallazgos[i].titulo = e.target.value; })}
|
||||
className={`${INPUT} mb-2 font-medium`}
|
||||
/>
|
||||
<textarea
|
||||
value={h.descripcion}
|
||||
onChange={(e) => editar((p) => { p.diagnostico.hallazgos[i].descripcion = e.target.value; })}
|
||||
rows={2}
|
||||
className={INPUT}
|
||||
/>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div>
|
||||
<label className="block text-xs font-semibold uppercase tracking-wide text-muted mb-2">
|
||||
Alcance (la descripcion; los precios los pone el sistema)
|
||||
</label>
|
||||
<div className="space-y-2">
|
||||
{propuesta.redaccion.alcance.map((a, i) => (
|
||||
<div key={a.refPartida} className="flex gap-2 items-start">
|
||||
<span className="text-xs font-mono text-muted mt-2.5 shrink-0">{a.refPartida}</span>
|
||||
<textarea
|
||||
value={a.descripcionResultado}
|
||||
onChange={(e) => editar((p) => { p.redaccion.alcance[i].descripcionResultado = e.target.value; })}
|
||||
rows={2}
|
||||
className={INPUT}
|
||||
/>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div>
|
||||
<label className="block text-xs font-semibold uppercase tracking-wide text-muted mb-2">Exclusiones</label>
|
||||
<div className="space-y-2">
|
||||
{propuesta.redaccion.exclusiones.map((ex, i) => (
|
||||
<textarea
|
||||
key={i}
|
||||
value={ex.texto}
|
||||
onChange={(e) => editar((p) => { p.redaccion.exclusiones[i].texto = e.target.value; })}
|
||||
rows={2}
|
||||
className={INPUT}
|
||||
/>
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div>
|
||||
<label className="block text-xs font-semibold uppercase tracking-wide text-muted mb-2">
|
||||
Por que tiene sentido
|
||||
</label>
|
||||
<div className="space-y-2">
|
||||
{propuesta.redaccion.beneficios.map((b, i) => (
|
||||
<div key={i} className="flex gap-2 items-start">
|
||||
<input
|
||||
value={b.etiqueta}
|
||||
onChange={(e) => editar((p) => { p.redaccion.beneficios[i].etiqueta = e.target.value; })}
|
||||
className={`${INPUT} max-w-[9rem] shrink-0`}
|
||||
/>
|
||||
<textarea
|
||||
value={b.texto}
|
||||
onChange={(e) => editar((p) => { p.redaccion.beneficios[i].texto = e.target.value; })}
|
||||
rows={2}
|
||||
className={INPUT}
|
||||
/>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
|
||||
{/* Los grupos de abajo tambien se imprimen al cliente, asi que tambien
|
||||
pueden disparar un aviso bloqueante. Si no fueran editables, un
|
||||
bloqueante ahi no tendria mas salida que regenerar la propuesta. */}
|
||||
|
||||
{citaDestacada && (
|
||||
<div>
|
||||
<label className="block text-xs font-semibold uppercase tracking-wide text-muted mb-1">
|
||||
Cita destacada
|
||||
</label>
|
||||
<p className="text-xs text-muted mb-2">
|
||||
Se imprime literal. Editala solo para quitar un dato sensible, nunca para
|
||||
mejorarle la redaccion al cliente.
|
||||
</p>
|
||||
<textarea
|
||||
value={citaDestacada.textoLiteral}
|
||||
onChange={(e) =>
|
||||
editar((p) => {
|
||||
const c = p.hechos.citas.find((x) => x.id === p.redaccion.citaDestacadaId);
|
||||
if (c) c.textoLiteral = e.target.value;
|
||||
})
|
||||
}
|
||||
rows={2}
|
||||
className={`${INPUT} mb-2`}
|
||||
/>
|
||||
<input
|
||||
value={citaDestacada.quienLoDijo}
|
||||
onChange={(e) =>
|
||||
editar((p) => {
|
||||
const c = p.hechos.citas.find((x) => x.id === p.redaccion.citaDestacadaId);
|
||||
if (c) c.quienLoDijo = e.target.value;
|
||||
})
|
||||
}
|
||||
placeholder="Quien lo dijo (usa el rol, no el nombre)"
|
||||
className={INPUT}
|
||||
/>
|
||||
</div>
|
||||
)}
|
||||
|
||||
{propuesta.diagnostico.valorProblema.dimensiones.length > 0 && (
|
||||
<div>
|
||||
<label className="block text-xs font-semibold uppercase tracking-wide text-muted mb-2">
|
||||
Lo que cuesta no resolverlo
|
||||
</label>
|
||||
<div className="space-y-2">
|
||||
{propuesta.diagnostico.valorProblema.dimensiones.map((dim, i) => (
|
||||
<div key={i} className="flex gap-2 items-start">
|
||||
<span className="text-xs text-muted mt-2.5 shrink-0 w-20">{dim.tipo}</span>
|
||||
<textarea
|
||||
value={dim.descripcion}
|
||||
onChange={(e) => editar((p) => { p.diagnostico.valorProblema.dimensiones[i].descripcion = e.target.value; })}
|
||||
rows={2}
|
||||
className={INPUT}
|
||||
/>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
<textarea
|
||||
value={propuesta.diagnostico.valorProblema.notaMetodologia}
|
||||
onChange={(e) => editar((p) => { p.diagnostico.valorProblema.notaMetodologia = e.target.value; })}
|
||||
rows={2}
|
||||
placeholder="Nota de metodologia"
|
||||
className={`${INPUT} mt-2`}
|
||||
/>
|
||||
</div>
|
||||
)}
|
||||
|
||||
{propuesta.diagnostico.resultados.length > 0 && (
|
||||
<div>
|
||||
<label className="block text-xs font-semibold uppercase tracking-wide text-muted mb-2">
|
||||
Resultados a lograr
|
||||
</label>
|
||||
<div className="space-y-2">
|
||||
{propuesta.diagnostico.resultados.map((r, i) => (
|
||||
<div key={i} className="space-y-1">
|
||||
<textarea
|
||||
value={r.enunciado}
|
||||
onChange={(e) => editar((p) => { p.diagnostico.resultados[i].enunciado = e.target.value; })}
|
||||
rows={2}
|
||||
className={INPUT}
|
||||
/>
|
||||
<div className="flex gap-2">
|
||||
<input
|
||||
value={r.metrica}
|
||||
onChange={(e) => editar((p) => { p.diagnostico.resultados[i].metrica = e.target.value; })}
|
||||
placeholder="Metrica"
|
||||
className={INPUT}
|
||||
/>
|
||||
<input
|
||||
value={r.periodoMedicion}
|
||||
onChange={(e) => editar((p) => { p.diagnostico.resultados[i].periodoMedicion = e.target.value; })}
|
||||
placeholder="Periodo"
|
||||
className={INPUT}
|
||||
/>
|
||||
</div>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
)}
|
||||
|
||||
{(propuesta.hechos.materialesPendientes.length > 0 ||
|
||||
propuesta.hechos.decisionesPendientes.length > 0) && (
|
||||
<div>
|
||||
<label className="block text-xs font-semibold uppercase tracking-wide text-muted mb-2">
|
||||
Que necesitamos de ustedes
|
||||
</label>
|
||||
<div className="space-y-2">
|
||||
{propuesta.hechos.materialesPendientes.map((m, i) => (
|
||||
<input
|
||||
key={`mat-${i}`}
|
||||
value={m.texto}
|
||||
onChange={(e) => editar((p) => { p.hechos.materialesPendientes[i].texto = e.target.value; })}
|
||||
className={INPUT}
|
||||
/>
|
||||
))}
|
||||
{propuesta.hechos.decisionesPendientes.map((dd, i) => (
|
||||
<div key={`dec-${i}`} className="flex gap-2">
|
||||
<textarea
|
||||
value={dd.texto}
|
||||
onChange={(e) => editar((p) => { p.hechos.decisionesPendientes[i].texto = e.target.value; })}
|
||||
rows={1}
|
||||
className={INPUT}
|
||||
/>
|
||||
<input
|
||||
value={dd.quienDecide}
|
||||
onChange={(e) => editar((p) => { p.hechos.decisionesPendientes[i].quienDecide = e.target.value; })}
|
||||
placeholder="Quien decide"
|
||||
className={`${INPUT} max-w-[11rem] shrink-0`}
|
||||
/>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
)}
|
||||
|
||||
{propuesta.redaccion.backlogEvolucion.length > 0 && (
|
||||
<div>
|
||||
<label className="block text-xs font-semibold uppercase tracking-wide text-muted mb-2">
|
||||
Registrado para mas adelante
|
||||
</label>
|
||||
<div className="space-y-2">
|
||||
{propuesta.redaccion.backlogEvolucion.map((b, i) => (
|
||||
<div key={i} className="flex gap-2">
|
||||
<textarea
|
||||
value={b.problema}
|
||||
onChange={(e) => editar((p) => { p.redaccion.backlogEvolucion[i].problema = e.target.value; })}
|
||||
rows={1}
|
||||
className={INPUT}
|
||||
/>
|
||||
<input
|
||||
value={b.momentoSugerido}
|
||||
onChange={(e) => editar((p) => { p.redaccion.backlogEvolucion[i].momentoSugerido = e.target.value; })}
|
||||
placeholder="Cuando"
|
||||
className={`${INPUT} max-w-[11rem] shrink-0`}
|
||||
/>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
|
||||
<div className="flex flex-wrap items-center gap-2 pt-2 border-t border-border">
|
||||
<button
|
||||
onClick={guardar}
|
||||
disabled={!sucio || guardando}
|
||||
className="flex items-center gap-2 px-4 py-2 rounded-lg text-sm text-white bg-primary hover:opacity-90 disabled:opacity-40"
|
||||
>
|
||||
<Save className="w-4 h-4" />
|
||||
{guardando ? "Guardando..." : sucio ? "Guardar cambios" : "Sin cambios"}
|
||||
</button>
|
||||
|
||||
{/* El servidor devuelve 409 si hay bloqueantes; aqui se refleja para no
|
||||
invitar a un clic que va a fallar. La descarga del anexo interno
|
||||
sigue disponible: es la que ayuda a entender que corregir. */}
|
||||
{bloqueantes.length > 0 ? (
|
||||
<span
|
||||
className="flex items-center gap-2 px-4 py-2 border border-border rounded-lg text-sm text-muted bg-gray-50 cursor-not-allowed"
|
||||
title="Resuelve los avisos bloqueantes y guarda para habilitar la descarga"
|
||||
>
|
||||
<Download className="w-4 h-4" />
|
||||
Propuesta consultiva (PDF) — bloqueada
|
||||
</span>
|
||||
) : (
|
||||
<a
|
||||
href={`/api/propuesta-ia/${cotizacionId}/pdf`}
|
||||
className="flex items-center gap-2 px-4 py-2 border border-border rounded-lg text-sm hover:bg-gray-50"
|
||||
>
|
||||
<Download className="w-4 h-4" />
|
||||
Propuesta consultiva (PDF)
|
||||
</a>
|
||||
)}
|
||||
|
||||
<a
|
||||
href={`/api/propuesta-ia/${cotizacionId}/pdf?anexo=1`}
|
||||
className="flex items-center gap-2 px-4 py-2 rounded-lg text-sm border border-red-300 bg-red-50 text-red-800 hover:bg-red-100"
|
||||
title="Contiene ponderacion, red flags y notas internas"
|
||||
>
|
||||
<Lock className="w-4 h-4" />
|
||||
Anexo interno — NO ENVIAR
|
||||
</a>
|
||||
|
||||
{sucio && (
|
||||
<span className="text-xs text-amber-700">
|
||||
Tienes cambios sin guardar. El PDF se genera con lo ultimo guardado.
|
||||
</span>
|
||||
)}
|
||||
</div>
|
||||
</>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -112,6 +112,69 @@ export function calcularTotalesOpcion(
|
||||
};
|
||||
}
|
||||
|
||||
// ----- Totales de una cotizacion: FUENTE DE VERDAD UNICA -----
|
||||
// Antes este calculo estaba duplicado a mano con .filter().reduce() en siete
|
||||
// consumidores (PDF, Excel, detalle, PreciosEditables, formulario, lista y dashboard),
|
||||
// con criterios que no coincidian, y el IVA estaba hardcodeado como * 1.16 en los dos
|
||||
// exportadores ignorando IVA_RATE y el flag incluirIva. Toda comparacion de totales
|
||||
// (y cualquier documento que deba coincidir con el PDF) debe pasar por aqui.
|
||||
//
|
||||
// Nota: los subtotales son SIN IVA, que es como los exportadores presentan hoy los
|
||||
// totales de una cotizacion simple ("los precios no incluyen IVA" en la nota al pie).
|
||||
export interface TotalesCotizacion {
|
||||
subtotalUnico: number;
|
||||
subtotalMensual: number;
|
||||
ivaUnico: number;
|
||||
ivaMensual: number;
|
||||
totalUnico: number;
|
||||
totalMensual: number;
|
||||
/** Desembolso real a 12 meses: unico + mensual x 12, con IVA si aplica.
|
||||
* Es la base del ratio precio/valor de la propuesta consultiva. */
|
||||
totalPrimerAnio: number;
|
||||
incluyeIva: boolean;
|
||||
}
|
||||
|
||||
export function calcularTotalesCotizacion(
|
||||
servicios: Array<{ tipoPago: string; precio: number; seleccionado?: boolean }>,
|
||||
opciones?: { incluirIva?: boolean }
|
||||
): TotalesCotizacion {
|
||||
const incluyeIva = opciones?.incluirIva !== false;
|
||||
const activos = servicios.filter((s) => s.seleccionado !== false);
|
||||
|
||||
const suma = (tipo: string) =>
|
||||
r2(activos.filter((s) => s.tipoPago === tipo).reduce((a, s) => a + (s.precio || 0), 0));
|
||||
|
||||
const subtotalUnico = suma("unico");
|
||||
const subtotalMensual = suma("mensual");
|
||||
|
||||
const ivaUnico = incluyeIva ? r2(subtotalUnico * IVA_RATE) : 0;
|
||||
const ivaMensual = incluyeIva ? r2(subtotalMensual * IVA_RATE) : 0;
|
||||
|
||||
const totalUnico = r2(subtotalUnico + ivaUnico);
|
||||
const totalMensual = r2(subtotalMensual + ivaMensual);
|
||||
|
||||
return {
|
||||
subtotalUnico,
|
||||
subtotalMensual,
|
||||
ivaUnico,
|
||||
ivaMensual,
|
||||
totalUnico,
|
||||
totalMensual,
|
||||
totalPrimerAnio: r2(totalUnico + totalMensual * 12),
|
||||
incluyeIva,
|
||||
};
|
||||
}
|
||||
|
||||
function r2(n: number): number {
|
||||
return Math.round(n * 100) / 100;
|
||||
}
|
||||
|
||||
/** Aplica IVA a un monto respetando el flag de la cotizacion.
|
||||
* Sustituye a los `* 1.16` hardcodeados que habia en pdf-generator y excel-builder. */
|
||||
export function conIva(monto: number, incluirIva: boolean = true): number {
|
||||
return r2((monto || 0) * (incluirIva ? 1 + IVA_RATE : 1));
|
||||
}
|
||||
|
||||
export const FASES: Record<number, string> = {
|
||||
0: "FASE 0 - Auditoria / Acompanamiento",
|
||||
1: "FASE 1 - Setup e Infraestructura",
|
||||
|
||||
+29
-11
@@ -1,5 +1,5 @@
|
||||
import ExcelJS from "exceljs";
|
||||
import { bucefaloPrecio, describirRetainer, formatCurrency, calcularTotalesOpcion, type MetaOpcion } from "@/lib/calculators";
|
||||
import { bucefaloPrecio, conIva, detalleModelo as detalleModeloCanonico, formatCurrency, calcularTotalesOpcion, type MetaOpcion } from "@/lib/calculators";
|
||||
|
||||
// ─────────────────────────────────────────────────────────────────────────────
|
||||
// Forma normalizada de los datos que necesita el Excel. Tanto la ruta de borrador
|
||||
@@ -44,6 +44,11 @@ export interface ExcelData {
|
||||
planBucefaloPrecio?: number | null;
|
||||
colorPrimario: string;
|
||||
colorSecundario: string;
|
||||
incluirIva?: boolean;
|
||||
/** Texto que SI ve el cliente. El Excel es un documento del cliente (lleva razon
|
||||
* social, "En atencion a:", domicilio fiscal y nota legal), no una herramienta
|
||||
* interna: por eso `observacionesInternas` NO se declara aqui. */
|
||||
observaciones?: string | null;
|
||||
}
|
||||
|
||||
// Convierte "#RRGGBB" a ARGB de 8 caracteres. `alpha` es el canal alfa (2 hex):
|
||||
@@ -54,15 +59,10 @@ function argb(hex: string, alpha = "FF"): string {
|
||||
return alpha + h.toUpperCase();
|
||||
}
|
||||
|
||||
// Texto de desglose por modelo de cobro (horas / retainer) para mostrar junto al servicio.
|
||||
// Delega en la version canonica de calculators.ts. La copia local que habia aqui
|
||||
// omitia la rama "demanda", igual que la del PDF.
|
||||
function detalleModelo(serv: ExcelServicio): string {
|
||||
if (serv.modeloCobro === "retainer") {
|
||||
return describirRetainer(serv.montoMinimo ?? 0, serv.horasIncluidas ?? 0, serv.tarifaHora ?? 0);
|
||||
}
|
||||
if ((serv.modeloCobro === "horas" || serv.esPersonalizado) && serv.horas && serv.tarifaHora) {
|
||||
return `${serv.horas} h x ${formatCurrency(serv.tarifaHora)}/hr`;
|
||||
}
|
||||
return "";
|
||||
return detalleModeloCanonico(serv);
|
||||
}
|
||||
|
||||
function applyThinBorder(cell: ExcelJS.Cell, color?: string) {
|
||||
@@ -374,8 +374,10 @@ export async function buildCotizacionExcel(data: ExcelData): Promise<Buffer> {
|
||||
row++;
|
||||
};
|
||||
compRow("Concepto", `Opcion 1${t1Tit ? " - " + t1Tit : ""}`, `Opcion 2${t2Tit ? " - " + t2Tit : ""}`, boldFont);
|
||||
compRow("Total unico (c/IVA)", formatCurrency(t1.totalUnico * 1.16), formatCurrency(t2.totalUnico * 1.16), valueFont);
|
||||
compRow("Total mensual (c/IVA)", formatCurrency(t1.totalMensual * 1.16), formatCurrency(t2.totalMensual * 1.16), valueFont);
|
||||
// IVA via conIva() y no `* 1.16`: respeta Cotizacion.incluirIva y usa IVA_RATE.
|
||||
const ivaLbl = data.incluirIva === false ? "" : " (c/IVA)";
|
||||
compRow(`Total unico${ivaLbl}`, formatCurrency(conIva(t1.totalUnico, data.incluirIva)), formatCurrency(conIva(t2.totalUnico, data.incluirIva)), valueFont);
|
||||
compRow(`Total mensual${ivaLbl}`, formatCurrency(conIva(t1.totalMensual, data.incluirIva)), formatCurrency(conIva(t2.totalMensual, data.incluirIva)), valueFont);
|
||||
compRow("Horas estimadas", `${t1.horas} h`, `${t2.horas} h`, valueFont);
|
||||
row++;
|
||||
} else {
|
||||
@@ -402,6 +404,22 @@ export async function buildCotizacionExcel(data: ExcelData): Promise<Buffer> {
|
||||
ws.getCell(`B${row}`).font = smallFont;
|
||||
setWrapped(ws, row, "B", notaResumen, mergedWidth(ws, "B", "K"), { fontSize: 9 });
|
||||
|
||||
// Observaciones del cliente. Solo este campo: el Excel lleva razon social,
|
||||
// "En atencion a:" y domicilio fiscal, o sea que es un documento que el cliente
|
||||
// recibe. observacionesInternas no existe en ExcelData a proposito.
|
||||
if (data.observaciones && data.observaciones.trim()) {
|
||||
row += 2;
|
||||
ws.mergeCells(`B${row}:K${row}`);
|
||||
ws.getCell(`B${row}`).value = "OBSERVACIONES";
|
||||
ws.getCell(`B${row}`).font = { ...boldFont, color: { argb: PRIMARY } };
|
||||
row++;
|
||||
ws.mergeCells(`B${row}:K${row}`);
|
||||
const texto = data.observaciones.trim();
|
||||
ws.getCell(`B${row}`).value = texto;
|
||||
ws.getCell(`B${row}`).font = smallFont;
|
||||
setWrapped(ws, row, "B", texto, mergedWidth(ws, "B", "K"), { fontSize: 9 });
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
// HOJAS DETALLADAS POR SERVICIO
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
|
||||
+64
-19
@@ -1,5 +1,5 @@
|
||||
import PDFDocument from "pdfkit";
|
||||
import { FASES_SHORT as FASES, describirRetainer, formatCurrency, calcularTotalesOpcion, type MetaOpcion } from "./calculators";
|
||||
import { FASES_SHORT as FASES, conIva, detalleModelo, calcularTotalesOpcion, type MetaOpcion } from "./calculators";
|
||||
|
||||
interface ServicioPDF {
|
||||
nombre: string;
|
||||
@@ -18,14 +18,11 @@ interface ServicioPDF {
|
||||
}
|
||||
|
||||
// Texto de desglose por modelo de cobro (horas / retainer) para la sub-linea del servicio.
|
||||
// Delega en la version canonica de calculators.ts. La copia local que habia aqui
|
||||
// omitia la rama "demanda", asi que esa partida se imprimia sin desglose y con
|
||||
// precio $0, sin explicar que se factura segun consumo.
|
||||
function detalleModeloPDF(serv: ServicioPDF): string {
|
||||
if (serv.modeloCobro === "retainer") {
|
||||
return describirRetainer(serv.montoMinimo ?? 0, serv.horasIncluidas ?? 0, serv.tarifaHora ?? 0);
|
||||
}
|
||||
if ((serv.modeloCobro === "horas" || serv.esPersonalizado) && serv.horas && serv.tarifaHora) {
|
||||
return `${serv.horas} h x ${formatCurrency(serv.tarifaHora)}/hr`;
|
||||
}
|
||||
return "";
|
||||
return detalleModelo(serv);
|
||||
}
|
||||
|
||||
interface CotizacionPDFData {
|
||||
@@ -45,6 +42,13 @@ interface CotizacionPDFData {
|
||||
planBucefaloNivel: string | null;
|
||||
planBucefaloPrecio: number;
|
||||
incluirBonos: boolean;
|
||||
/** Bonos desde la tabla Bono. Si no se pasan, se usa la lista de respaldo. */
|
||||
bonos?: { numero: number; descripcion: string }[];
|
||||
incluirIva?: boolean;
|
||||
/** Texto que SI ve el cliente. `observacionesInternas` NO se declara aqui a
|
||||
* proposito: si el generador no puede verlo, no puede filtrarlo. La garantia
|
||||
* es estructural, no depende de la disciplina de quien dibuje. */
|
||||
observaciones?: string | null;
|
||||
configBancaria?: Record<string, string>;
|
||||
colorPrimario?: string;
|
||||
colorSecundario?: string;
|
||||
@@ -324,9 +328,11 @@ export async function generateCotizacionPDF(data: CotizacionPDFData): Promise<Bu
|
||||
doc.text(`Opcion 1${t1Tit ? " - " + t1Tit : ""}`, cOp1, y + 4, { width: W * 0.27 - 4 });
|
||||
doc.text(`Opcion 2${t2Tit ? " - " + t2Tit : ""}`, cOp2, y + 4, { width: W * 0.28 - 4 });
|
||||
y += 18;
|
||||
// IVA via conIva() y no `* 1.16`: respeta Cotizacion.incluirIva y usa IVA_RATE.
|
||||
const ivaLbl = data.incluirIva === false ? "" : " (c/IVA)";
|
||||
const filas: [string, string, string][] = [
|
||||
["Total unico (c/IVA)", fmt(t1.totalUnico * 1.16), fmt(t2.totalUnico * 1.16)],
|
||||
["Total mensual (c/IVA)", fmt(t1.totalMensual * 1.16), fmt(t2.totalMensual * 1.16)],
|
||||
[`Total unico${ivaLbl}`, fmt(conIva(t1.totalUnico, data.incluirIva)), fmt(conIva(t2.totalUnico, data.incluirIva))],
|
||||
[`Total mensual${ivaLbl}`, fmt(conIva(t1.totalMensual, data.incluirIva)), fmt(conIva(t2.totalMensual, data.incluirIva))],
|
||||
["Horas estimadas", `${t1.horas} h`, `${t2.horas} h`],
|
||||
];
|
||||
for (const [lab, v1, v2] of filas) {
|
||||
@@ -374,21 +380,60 @@ export async function generateCotizacionPDF(data: CotizacionPDFData): Promise<Bu
|
||||
doc.rect(L, y, 3, 10).fill(PRIMARY);
|
||||
doc.font("Helvetica-Bold").fontSize(9).fillColor(DARK).text("Bonos (Pago en una exhibicion)", L + 10, y);
|
||||
y += 16;
|
||||
const bonos = [
|
||||
"Bono 1: 30 min mensuales en servicios Centinela (Sitio Web)",
|
||||
"Bono 2: Workshop Estrategico de Buyer Persona",
|
||||
"Bono 3: Workshop de Propuestas de Valor y Oferta Irresistible",
|
||||
"Bono 4: 1 ano de Membresia Premium",
|
||||
"Bono 5: Un mes gratis de Bucefalo CRM",
|
||||
"Bono 6: Script de Ventas con mas de 100 complementos",
|
||||
];
|
||||
// Fuente de verdad: la tabla Bono. La lista de abajo es solo respaldo por si
|
||||
// la consulta no trajo nada; antes estaba hardcodeada aqui y su texto ya no
|
||||
// coincidia con el del seed (bono 5).
|
||||
const RESPALDO = [
|
||||
"30 min mensuales en servicios Centinela (Sitio Web)",
|
||||
"Workshop Estrategico de Buyer Persona",
|
||||
"Workshop de Propuestas de Valor y Oferta Irresistible",
|
||||
"1 ano de Membresia Premium",
|
||||
"Un mes gratis de Bucefalo CRM, Marketing y Ventas",
|
||||
"Script de Ventas con mas de 100 complementos",
|
||||
].map((d, i) => `Bono ${i + 1}: ${d}`);
|
||||
|
||||
const bonos = data.bonos?.length
|
||||
? data.bonos.map((b) => `Bono ${b.numero}: ${b.descripcion}`)
|
||||
: RESPALDO;
|
||||
|
||||
for (const b of bonos) {
|
||||
y = need(11, y);
|
||||
doc.font("Helvetica").fontSize(7).fillColor(DARK).text(`\u2713 ${b}`, L + 8, y, { width: W - 16 });
|
||||
// Vinneta "\u2022" y no la palomita "\u2713": en las fuentes estandar de PDFKit
|
||||
// la palomita mide 0pt de ancho, o sea que hoy salia como dos espacios.
|
||||
doc.font("Helvetica").fontSize(7).fillColor(DARK).text(`\u2022 ${b}`, L + 8, y, { width: W - 16 });
|
||||
y += 11;
|
||||
}
|
||||
}
|
||||
|
||||
// ── OBSERVACIONES (solo el texto del cliente) ──
|
||||
// Va al final de la Hoja Resumen, junto a los totales y antes de T&C, que es
|
||||
// donde el cliente espera leer un mensaje del asesor. Nunca imprime
|
||||
// observacionesInternas: ese campo ni siquiera existe en CotizacionPDFData.
|
||||
if (data.observaciones && data.observaciones.trim()) {
|
||||
y = sectionTitle("Observaciones", y);
|
||||
const usable = maxY - m.top;
|
||||
const parrafos = data.observaciones
|
||||
.split(/\r?\n/)
|
||||
.map((p) => p.trim())
|
||||
.filter(Boolean);
|
||||
|
||||
for (const p of parrafos) {
|
||||
const h = txtHeight(p, W - 4, 7.5);
|
||||
if (h > usable) {
|
||||
// Parrafo mas alto que una pagina entera: need() no sabe partir, asi que
|
||||
// se deja fluir a pdfkit y se resincroniza el contador con doc.y.
|
||||
y = need(20, y);
|
||||
doc.font("Helvetica").fontSize(7.5).fillColor(DARK).text(p, L + 2, y, { width: W - 4 });
|
||||
y = doc.y + 4;
|
||||
} else {
|
||||
y = need(h + 4, y);
|
||||
doc.font("Helvetica").fontSize(7.5).fillColor(DARK).text(p, L + 2, y, { width: W - 4 });
|
||||
y += h + 4;
|
||||
}
|
||||
}
|
||||
y += 4;
|
||||
}
|
||||
|
||||
// ── T&C PAGE ──────────────────────────────────
|
||||
doc.addPage();
|
||||
y = m.top;
|
||||
|
||||
@@ -0,0 +1,234 @@
|
||||
import Anthropic from "@anthropic-ai/sdk";
|
||||
import { z } from "zod";
|
||||
import { aJsonSchema } from "./schemas";
|
||||
|
||||
/**
|
||||
* Cliente del proveedor de IA (MiniMax-M3 via su endpoint compatible con Anthropic)
|
||||
* y runner que fuerza el contrato con tool-calling.
|
||||
*
|
||||
* MiniMax NO soporta structured outputs (`output_config` / `json_schema`), asi que
|
||||
* el `input_schema` de la herramienta ES el contrato, y Zod valida siempre del lado
|
||||
* del codigo. `tool_choice` no se envia: no esta documentado en MiniMax, y fijarlo
|
||||
* solo en el reintento le daria al reintento un prefijo distinto — se pagaria el
|
||||
* contexto completo justo cuando es mas grande.
|
||||
*/
|
||||
|
||||
export interface UsoTokens {
|
||||
entrada: number;
|
||||
salida: number;
|
||||
cacheLectura: number;
|
||||
cacheEscritura: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Normaliza rarezas observadas en las respuestas de MiniMax antes de validar.
|
||||
*
|
||||
* Observado contra la API real, sobre datos de produccion: a veces envuelve los
|
||||
* elementos de un array en un objeto `{item: {...}}` en vez de emitir el objeto
|
||||
* directamente. Zod lo rechaza con `Unrecognized keys: "item"` y se gasta un
|
||||
* reintento en algo que se puede corregir aqui sin ambiguedad.
|
||||
*
|
||||
* Solo desenvuelve cuando `item` es la UNICA clave: si el objeto trae mas cosas,
|
||||
* podria ser un campo legitimo y no se toca.
|
||||
*/
|
||||
export function normalizarRespuesta(v: unknown): unknown {
|
||||
if (Array.isArray(v)) return v.map(normalizarRespuesta);
|
||||
if (v && typeof v === "object") {
|
||||
const o = v as Record<string, unknown>;
|
||||
const claves = Object.keys(o);
|
||||
if (claves.length === 1 && claves[0] === "item") return normalizarRespuesta(o.item);
|
||||
const salida: Record<string, unknown> = {};
|
||||
for (const k of claves) salida[k] = normalizarRespuesta(o[k]);
|
||||
return salida;
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
export function crearCliente(): Anthropic {
|
||||
const apiKey = process.env.MINIMAX_API_KEY;
|
||||
if (!apiKey) {
|
||||
throw new Error(
|
||||
"Falta MINIMAX_API_KEY. Definela en .env. No uses ANTHROPIC_API_KEY: el SDK la " +
|
||||
"leeria por su cuenta y mandaria la clave de MiniMax a api.anthropic.com."
|
||||
);
|
||||
}
|
||||
// apiKey y baseURL explicitos. Si se dejan al SDK, toma las ANTHROPIC_* del shell
|
||||
// y la clave termina en el proveedor equivocado.
|
||||
return new Anthropic({
|
||||
apiKey,
|
||||
baseURL: process.env.MINIMAX_BASE_URL || "https://api.minimax.io/anthropic",
|
||||
});
|
||||
}
|
||||
|
||||
export function modelo(): string {
|
||||
return process.env.MINIMAX_MODEL || "MiniMax-M3";
|
||||
}
|
||||
|
||||
export interface BloqueSystem {
|
||||
texto: string;
|
||||
cachear: boolean;
|
||||
}
|
||||
|
||||
/**
|
||||
* ¿El fallo es del proveedor y vale la pena reintentar?
|
||||
*
|
||||
* Motivacion: en produccion aparecio un "unexpected doc type" que NO se pudo reproducir
|
||||
* en seis corridas completas del pipeline contra los mismos datos, y la generacion que
|
||||
* lo siguio completo sin problema. Todo apunta a un fallo transitorio del proveedor.
|
||||
* En vez de adivinar un arreglo para un error que no se puede reproducir, se reintenta
|
||||
* esa clase de fallo con espera creciente.
|
||||
*/
|
||||
function esTransitorio(e: unknown): boolean {
|
||||
const err = e as { status?: number; message?: string };
|
||||
if (typeof err?.status === "number") {
|
||||
// 408 timeout, 409 conflicto, 429 rate limit, 5xx y el 529 de sobrecarga.
|
||||
if ([408, 409, 429].includes(err.status) || err.status >= 500) return true;
|
||||
// 400 con mensaje que no describe un problema de nuestro payload: el proveedor
|
||||
// devuelve errores de parseo internos con 400. Se reintenta una vez por si acaso.
|
||||
if (err.status === 400 && /unexpected|internal|parse|unknown/i.test(err.message ?? "")) return true;
|
||||
}
|
||||
// Fallos de red sin status.
|
||||
if (!err?.status && /ECONN|ETIMEDOUT|socket|network|fetch failed/i.test(err?.message ?? "")) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
const esperar = (ms: number) => new Promise((r) => setTimeout(r, ms));
|
||||
|
||||
/** Llama al proveedor reintentando SOLO los fallos transitorios. Los errores de
|
||||
* nuestro payload no se reintentan aqui: los corrige el bucle de schema. */
|
||||
async function crearMensajeConReintentos(
|
||||
cliente: Anthropic,
|
||||
cuerpo: Anthropic.MessageCreateParamsNonStreaming,
|
||||
maxTransitorios = 3
|
||||
): Promise<Anthropic.Message> {
|
||||
let ultimo: unknown;
|
||||
for (let i = 1; i <= maxTransitorios; i++) {
|
||||
try {
|
||||
return await cliente.messages.create(cuerpo);
|
||||
} catch (e) {
|
||||
ultimo = e;
|
||||
if (!esTransitorio(e) || i === maxTransitorios) throw e;
|
||||
await esperar(1000 * 2 ** (i - 1)); // 1s, 2s
|
||||
}
|
||||
}
|
||||
throw ultimo;
|
||||
}
|
||||
|
||||
interface OpcionesLlamada {
|
||||
system: BloqueSystem[];
|
||||
mensajeUsuario: string;
|
||||
herramienta: { nombre: string; descripcion: string; schema: z.ZodType };
|
||||
maxIntentos: number;
|
||||
maxTokens: number;
|
||||
}
|
||||
|
||||
export async function llamarConHerramienta<T>(
|
||||
opts: OpcionesLlamada
|
||||
): Promise<{ datos: T; uso: UsoTokens; intentos: number }> {
|
||||
const cliente = crearCliente();
|
||||
|
||||
const tools = [
|
||||
{
|
||||
name: opts.herramienta.nombre,
|
||||
description: opts.herramienta.descripcion,
|
||||
input_schema: aJsonSchema(opts.herramienta.schema) as Anthropic.Tool["input_schema"],
|
||||
},
|
||||
];
|
||||
|
||||
const system = opts.system.map((b) => ({
|
||||
type: "text" as const,
|
||||
text: b.texto,
|
||||
...(b.cachear ? { cache_control: { type: "ephemeral" as const } } : {}),
|
||||
}));
|
||||
|
||||
const mensajes: Anthropic.MessageParam[] = [{ role: "user", content: opts.mensajeUsuario }];
|
||||
const uso: UsoTokens = { entrada: 0, salida: 0, cacheLectura: 0, cacheEscritura: 0 };
|
||||
let ultimoError = "";
|
||||
|
||||
for (let intento = 1; intento <= opts.maxIntentos; intento++) {
|
||||
const res = await crearMensajeConReintentos(cliente, {
|
||||
model: modelo(),
|
||||
max_tokens: opts.maxTokens,
|
||||
system,
|
||||
tools,
|
||||
messages: mensajes,
|
||||
});
|
||||
|
||||
const u = res.usage as {
|
||||
input_tokens?: number;
|
||||
output_tokens?: number;
|
||||
cache_read_input_tokens?: number;
|
||||
cache_creation_input_tokens?: number;
|
||||
};
|
||||
uso.entrada += u.input_tokens ?? 0;
|
||||
uso.salida += u.output_tokens ?? 0;
|
||||
uso.cacheLectura += u.cache_read_input_tokens ?? 0;
|
||||
uso.cacheEscritura += u.cache_creation_input_tokens ?? 0;
|
||||
|
||||
const bloquesTool = res.content.filter(
|
||||
(b): b is Anthropic.ToolUseBlock => b.type === "tool_use"
|
||||
);
|
||||
// El modelo a veces emite DOS tool_use en una misma respuesta (observado contra la
|
||||
// API real). Se prueban todos los candidatos y gana el primero que valide, en vez
|
||||
// de quedarse con el primero a secas y desperdiciar un reintento.
|
||||
const candidatos = bloquesTool.filter((b) => b.name === opts.herramienta.nombre);
|
||||
|
||||
let correcto: Anthropic.ToolUseBlock | undefined;
|
||||
for (const c of candidatos) {
|
||||
const intentoParse = opts.herramienta.schema.safeParse(normalizarRespuesta(c.input));
|
||||
if (intentoParse.success) {
|
||||
return { datos: intentoParse.data as T, uso, intentos: intento };
|
||||
}
|
||||
// Se guarda el primero para reportar su error si ninguno valida.
|
||||
if (!correcto) {
|
||||
correcto = c;
|
||||
ultimoError = z.prettifyError(intentoParse.error);
|
||||
}
|
||||
}
|
||||
|
||||
if (correcto) {
|
||||
// Hubo tool_use: la API exige un tool_result por CADA uno antes de continuar.
|
||||
// Un turno de usuario plano despues de un tool_use devuelve 400.
|
||||
mensajes.push(
|
||||
{ role: "assistant", content: res.content },
|
||||
{
|
||||
role: "user",
|
||||
content: [
|
||||
...bloquesTool.map((b) => ({
|
||||
type: "tool_result" as const,
|
||||
tool_use_id: b.id,
|
||||
is_error: true,
|
||||
content:
|
||||
b.id === correcto.id
|
||||
? ultimoError
|
||||
: `Herramienta inesperada. Usa ${opts.herramienta.nombre}.`,
|
||||
})),
|
||||
{
|
||||
type: "text" as const,
|
||||
text:
|
||||
`La llamada no cumple el schema. Corrige EXACTAMENTE estos errores y vuelve a ` +
|
||||
`llamar a ${opts.herramienta.nombre}:\n\n${ultimoError}\n\n` +
|
||||
`Revisa que cada objeto este en el array que le corresponde y que no falte ` +
|
||||
`ningun campo obligatorio. No agregues campos que el schema no declara.`,
|
||||
},
|
||||
],
|
||||
}
|
||||
);
|
||||
continue;
|
||||
}
|
||||
|
||||
// No llamo a ninguna herramienta: aqui si va un turno de usuario plano.
|
||||
ultimoError = "El modelo respondio con prosa en vez de llamar a la herramienta.";
|
||||
mensajes.push(
|
||||
{ role: "assistant", content: res.content },
|
||||
{
|
||||
role: "user",
|
||||
content: `Debes responder llamando a la herramienta ${opts.herramienta.nombre}. No escribas prosa suelta.`,
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
throw new Error(
|
||||
`El paso "${opts.herramienta.nombre}" agoto ${opts.maxIntentos} intentos.\nUltimo error:\n${ultimoError}`
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,113 @@
|
||||
import { prisma } from "@/lib/db";
|
||||
import { calcularTotalesCotizacion, type TotalesCotizacion } from "@/lib/calculators";
|
||||
|
||||
/**
|
||||
* Capa de datos economicos de la propuesta consultiva.
|
||||
*
|
||||
* Existe para que el dinero viva en UN solo sitio y nunca cruce hacia el prompt.
|
||||
* El pipeline de IA recibe de aqui unicamente `refPartida` y `nombre`; los importes
|
||||
* los inyecta el renderizador. Asi el principio "la IA no toca los numeros" lo
|
||||
* garantiza el compilador y no una regla que alguien pueda olvidar validar.
|
||||
*/
|
||||
|
||||
export interface PartidaCanonica {
|
||||
/** P01, P02... Es lo unico que identifica una partida ante el modelo. */
|
||||
refPartida: string;
|
||||
/** cuid real de ServicioCotizado. NUNCA sale hacia el proveedor: no es estable
|
||||
* entre ediciones, porque el PUT hace deleteMany + createMany. */
|
||||
servicioCotizadoId: string;
|
||||
nombre: string;
|
||||
fase: number;
|
||||
tipoPago: string;
|
||||
precio: number;
|
||||
tiempoEntrega: string;
|
||||
modeloCobro: string;
|
||||
horas: number | null;
|
||||
tarifaHora: number | null;
|
||||
entregables: string[];
|
||||
}
|
||||
|
||||
export interface DatosEconomicos {
|
||||
partidas: PartidaCanonica[];
|
||||
totales: TotalesCotizacion;
|
||||
moneda: string;
|
||||
/** Plan Bucefalo contratado, si lo hay. Se cobra mensual y aparece en el PDF
|
||||
* economico y en el Excel; tiene que aparecer tambien en el consultivo o el
|
||||
* cliente recibe dos documentos con alcances distintos. */
|
||||
planBucefalo: { nivel: string; precio: number } | null;
|
||||
}
|
||||
|
||||
export async function cargarEconomia(cotizacionId: string): Promise<DatosEconomicos> {
|
||||
const cot = await prisma.cotizacion.findUnique({
|
||||
where: { id: cotizacionId },
|
||||
include: {
|
||||
servicios: {
|
||||
include: { servicioCatalogo: true },
|
||||
// Mismo orden que los exportadores: los tres documentos van en el mismo
|
||||
// correo y deben listar las partidas igual.
|
||||
orderBy: [{ fase: "asc" }, { createdAt: "asc" }],
|
||||
},
|
||||
planBucefalo: true,
|
||||
},
|
||||
});
|
||||
if (!cot) throw new Error(`Cotizacion ${cotizacionId} no encontrada`);
|
||||
|
||||
const activos = cot.servicios.filter((s) => s.seleccionado);
|
||||
const partidas: PartidaCanonica[] = activos.map((s, i) => ({
|
||||
refPartida: `P${String(i + 1).padStart(2, "0")}`,
|
||||
servicioCotizadoId: s.id,
|
||||
nombre: s.servicioCatalogo?.nombre || s.nombre || "Servicio",
|
||||
fase: s.fase,
|
||||
tipoPago: s.tipoPago,
|
||||
precio: s.precio,
|
||||
tiempoEntrega: s.tiempoEntrega,
|
||||
modeloCobro: s.modeloCobro,
|
||||
horas: s.horas,
|
||||
tarifaHora: s.tarifaHora,
|
||||
entregables: Array.isArray(s.entregables) ? (s.entregables as string[]) : [],
|
||||
}));
|
||||
|
||||
const plan =
|
||||
cot.planBucefalo && cot.planBucefalo.seleccionado
|
||||
? { nivel: cot.planBucefalo.nivel, precio: cot.planBucefalo.precio }
|
||||
: null;
|
||||
|
||||
// El plan Bucefalo se cobra mensual: entra a los totales como una partida mensual
|
||||
// mas, igual que en el PDF economico.
|
||||
const paraTotales = plan
|
||||
? [...activos, { tipoPago: "mensual", precio: plan.precio, seleccionado: true }]
|
||||
: activos;
|
||||
|
||||
return {
|
||||
partidas,
|
||||
totales: calcularTotalesCotizacion(paraTotales, { incluirIva: cot.incluirIva }),
|
||||
moneda: cot.moneda,
|
||||
planBucefalo: plan,
|
||||
};
|
||||
}
|
||||
|
||||
export type LecturaRatio = "subcotizado" | "en_rango" | "alto" | "objecion_probable";
|
||||
|
||||
/**
|
||||
* Ratio precio/valor para el anexo interno.
|
||||
*
|
||||
* Base: el desembolso real del primer ano CON IVA (unico + mensual x 12). Se eligio
|
||||
* asi para que el numerador y el denominador tengan las mismas unidades: comparar un
|
||||
* pago inicial contra un valor ANUAL del problema daria una lectura optimista falsa.
|
||||
*/
|
||||
export function calcularRatio(
|
||||
totalPrimerAnio: number,
|
||||
valorAnual: number | null
|
||||
): { ratio: number; lectura: LecturaRatio } | null {
|
||||
if (!valorAnual || valorAnual <= 0) return null;
|
||||
const ratio = totalPrimerAnio / valorAnual;
|
||||
const lectura: LecturaRatio =
|
||||
ratio < 0.1
|
||||
? "subcotizado"
|
||||
: ratio <= 0.25
|
||||
? "en_rango"
|
||||
: ratio <= 0.4
|
||||
? "alto"
|
||||
: "objecion_probable";
|
||||
return { ratio: Math.round(ratio * 1000) / 1000, lectura };
|
||||
}
|
||||
@@ -0,0 +1,551 @@
|
||||
import PDFDocument from "pdfkit";
|
||||
import { formatCurrency, formatDate } from "@/lib/calculators";
|
||||
import { calcularRatio, type DatosEconomicos } from "./economia";
|
||||
import type { PropuestaConsultiva } from "./schemas";
|
||||
|
||||
/**
|
||||
* Generador del documento consultivo.
|
||||
*
|
||||
* Sigue la arquitectura argumental de la plantilla de referencia (hero, diagnostico con
|
||||
* semaforo, valor del problema, resultados, alcance, beneficios, exclusiones, pendientes,
|
||||
* backlog) pero en tema claro y con PDFKit, como el resto del sistema: la plantilla
|
||||
* original es de tema oscuro, y eso en impresion depende de una casilla del navegador
|
||||
* que viene desactivada — el cliente recibiria texto crema sobre papel blanco.
|
||||
*
|
||||
* El anexo interno va en SU PROPIO archivo, nunca como seccion oculta del documento del
|
||||
* cliente. Un display:none o una pagina extra se envian por error; un archivo con otro
|
||||
* nombre, no.
|
||||
*/
|
||||
|
||||
export interface DatosPropuestaPDF {
|
||||
propuesta: PropuestaConsultiva;
|
||||
economia: DatosEconomicos;
|
||||
cliente: string;
|
||||
empresa: string;
|
||||
asesor: string;
|
||||
numero: string;
|
||||
fecha: Date;
|
||||
vigencia: Date;
|
||||
proyecto: string;
|
||||
branding: {
|
||||
colorPrimario?: string;
|
||||
colorSecundario?: string;
|
||||
logoBase64?: string;
|
||||
logoMime?: string;
|
||||
};
|
||||
}
|
||||
|
||||
const COLOR_SEMAFORO: Record<string, string> = {
|
||||
rojo: "#dc2626",
|
||||
ambar: "#d97706",
|
||||
azul: "#2563eb",
|
||||
verde: "#16a34a",
|
||||
};
|
||||
const ETIQUETA_SEMAFORO: Record<string, string> = {
|
||||
rojo: "Problema critico",
|
||||
ambar: "Area de mejora",
|
||||
azul: "Oportunidad",
|
||||
verde: "Ventaja existente",
|
||||
};
|
||||
const ETIQUETA_CONFIANZA: Record<string, string> = {
|
||||
confirmado: "Confirmado",
|
||||
estimado: "Estimado",
|
||||
por_validar: "Por validar",
|
||||
};
|
||||
|
||||
/** `PUT /api/configuracion` filtra las claves permitidas pero NO valida los valores,
|
||||
* asi que aqui no se confia en ellos. */
|
||||
function hexSeguro(v: string | undefined, porDefecto: string): string {
|
||||
return v && /^#[0-9a-fA-F]{6}$/.test(v) ? v : porDefecto;
|
||||
}
|
||||
|
||||
/** Respaldo cuando la IA no describio una partida: se arma con los datos del
|
||||
* catalogo, para que la partida nunca desaparezca del documento. */
|
||||
function detalleDePartida(p: { tiempoEntrega: string; entregables: string[]; tipoPago: string }): string {
|
||||
const trozos: string[] = [];
|
||||
if (p.entregables.length) trozos.push(p.entregables.slice(0, 4).join(" · "));
|
||||
if (p.tiempoEntrega) trozos.push(`Entrega: ${p.tiempoEntrega}`);
|
||||
if (p.tipoPago === "mensual") trozos.push("Servicio mensual");
|
||||
return trozos.join(" | ");
|
||||
}
|
||||
|
||||
interface Lienzo {
|
||||
doc: PDFKit.PDFDocument;
|
||||
W: number;
|
||||
L: number;
|
||||
ph: number;
|
||||
maxY: number;
|
||||
mTop: number;
|
||||
}
|
||||
|
||||
function crearLienzo(): { lienzo: Lienzo; listo: Promise<Buffer> } {
|
||||
const doc = new PDFDocument({
|
||||
size: "LETTER",
|
||||
margins: { top: 50, bottom: 55, left: 50, right: 50 },
|
||||
bufferPages: true,
|
||||
});
|
||||
const chunks: Buffer[] = [];
|
||||
doc.on("data", (c: Buffer) => chunks.push(c));
|
||||
const listo = new Promise<Buffer>((res) => doc.on("end", () => res(Buffer.concat(chunks))));
|
||||
const m = doc.page.margins;
|
||||
return {
|
||||
lienzo: {
|
||||
doc,
|
||||
W: doc.page.width - m.left - m.right,
|
||||
L: m.left,
|
||||
ph: doc.page.height,
|
||||
maxY: doc.page.height - m.bottom - 5,
|
||||
mTop: m.top,
|
||||
},
|
||||
listo,
|
||||
};
|
||||
}
|
||||
|
||||
export async function generarPropuestaPDF(d: DatosPropuestaPDF): Promise<Buffer> {
|
||||
const PRIMARY = hexSeguro(d.branding.colorPrimario, "#2563eb");
|
||||
const DARK = hexSeguro(d.branding.colorSecundario, "#1e293b");
|
||||
const MUTED = "#64748b";
|
||||
const BORDER = "#e2e8f0";
|
||||
|
||||
const { lienzo, listo } = crearLienzo();
|
||||
const { doc, W, L, ph, maxY, mTop } = lienzo;
|
||||
let y = mTop;
|
||||
|
||||
const need = (h: number, yy: number) => (yy + h > maxY ? (doc.addPage(), mTop) : yy);
|
||||
const txtH = (s: string, w: number, size: number) =>
|
||||
doc.font("Helvetica").fontSize(size).heightOfString(s, { width: w });
|
||||
|
||||
function titulo(t: string) {
|
||||
y = need(26, y);
|
||||
doc.rect(L, y, 3, 10).fill(PRIMARY);
|
||||
doc.font("Helvetica-Bold").fontSize(10).fillColor(DARK).text(t.toUpperCase(), L + 10, y);
|
||||
y += 20;
|
||||
}
|
||||
function parrafo(t: string, size = 9, color = DARK) {
|
||||
for (const p of t.split(/\r?\n/).map((x) => x.trim()).filter(Boolean)) {
|
||||
const h = txtH(p, W, size);
|
||||
y = need(h + 4, y);
|
||||
doc.font("Helvetica").fontSize(size).fillColor(color).text(p, L, y, { width: W });
|
||||
y += h + 4;
|
||||
}
|
||||
}
|
||||
|
||||
// ── HERO ──
|
||||
if (d.branding.logoBase64) {
|
||||
try {
|
||||
doc.image(Buffer.from(d.branding.logoBase64, "base64"), L, y, { height: 26 });
|
||||
y += 34;
|
||||
} catch {
|
||||
/* logo invalido: se omite, no se rompe el documento */
|
||||
}
|
||||
}
|
||||
doc.font("Helvetica-Bold").fontSize(8.5).fillColor(PRIMARY).text("PROPUESTA CONSULTIVA", L, y);
|
||||
y += 16;
|
||||
const hTit = txtH(d.propuesta.redaccion.hero.titulo, W, 20);
|
||||
doc.font("Helvetica-Bold").fontSize(20).fillColor(DARK).text(d.propuesta.redaccion.hero.titulo, L, y, { width: W });
|
||||
y += hTit + 8;
|
||||
parrafo(d.propuesta.redaccion.hero.subtitulo, 10, MUTED);
|
||||
y += 8;
|
||||
const meta = `${d.empresa || d.cliente} · ${d.numero} · ${formatDate(d.fecha)} · Vigencia ${formatDate(d.vigencia)} · ${d.asesor}`;
|
||||
const hMeta = txtH(meta, W, 8);
|
||||
doc.font("Helvetica").fontSize(8).fillColor(MUTED).text(meta, L, y, { width: W });
|
||||
y += hMeta + 12;
|
||||
doc.moveTo(L, y).lineTo(L + W, y).strokeColor(BORDER).lineWidth(0.5).stroke();
|
||||
y += 18;
|
||||
|
||||
// ── DIAGNOSTICO ──
|
||||
titulo("Diagnostico");
|
||||
const cita = d.propuesta.hechos.citas.find((c) => c.id === d.propuesta.redaccion.citaDestacadaId);
|
||||
if (cita) {
|
||||
const texto = `"${cita.textoLiteral}"`;
|
||||
const h = doc.font("Helvetica-Oblique").fontSize(11).heightOfString(texto, { width: W - 22 });
|
||||
y = need(h + 22, y);
|
||||
doc.rect(L, y - 3, 2.5, h + 10).fill(PRIMARY);
|
||||
doc.font("Helvetica-Oblique").fontSize(11).fillColor(DARK).text(texto, L + 12, y, { width: W - 22 });
|
||||
y += h + 4;
|
||||
doc.font("Helvetica").fontSize(7.5).fillColor(MUTED).text(`— ${cita.quienLoDijo}`, L + 12, y);
|
||||
y += 18;
|
||||
}
|
||||
for (const hal of d.propuesta.diagnostico.hallazgos) {
|
||||
const cuerpo = `${hal.titulo} — ${hal.descripcion}`;
|
||||
const h = txtH(cuerpo, W - 24, 9);
|
||||
y = need(h + 14, y);
|
||||
doc.circle(L + 4.5, y + 4.5, 3.2).fill(COLOR_SEMAFORO[hal.urgencia] || MUTED);
|
||||
doc.font("Helvetica").fontSize(9).fillColor(DARK).text(cuerpo, L + 16, y, { width: W - 24 });
|
||||
y += h + 1;
|
||||
doc
|
||||
.font("Helvetica")
|
||||
.fontSize(7)
|
||||
.fillColor(MUTED)
|
||||
.text(`${ETIQUETA_SEMAFORO[hal.urgencia] ?? ""} · ${ETIQUETA_CONFIANZA[hal.confianza] ?? ""}`, L + 16, y);
|
||||
y += 13;
|
||||
}
|
||||
y += 8;
|
||||
|
||||
// ── VALOR DEL PROBLEMA ──
|
||||
const dims = d.propuesta.diagnostico.valorProblema.dimensiones;
|
||||
if (dims.length) {
|
||||
titulo("Lo que cuesta no resolverlo");
|
||||
for (const dim of dims) {
|
||||
const monto = dim.montoAnualMXN;
|
||||
const linea = `${dim.descripcion} — ${monto !== null ? `${formatCurrency(monto)} al ano` : "sin cuantificar"}`;
|
||||
const h = txtH(linea, W - 14, 9);
|
||||
y = need(h + 14, y);
|
||||
doc.font("Helvetica").fontSize(9).fillColor(DARK).text(linea, L + 6, y, { width: W - 14 });
|
||||
y += h + 1;
|
||||
doc.font("Helvetica").fontSize(7).fillColor(MUTED).text(ETIQUETA_CONFIANZA[dim.confianza] ?? "", L + 6, y);
|
||||
y += 13;
|
||||
}
|
||||
if (d.propuesta.diagnostico.valorProblema.notaMetodologia.trim()) {
|
||||
y += 2;
|
||||
parrafo(d.propuesta.diagnostico.valorProblema.notaMetodologia, 8, MUTED);
|
||||
}
|
||||
y += 8;
|
||||
}
|
||||
|
||||
// ── RESULTADOS ──
|
||||
if (d.propuesta.diagnostico.resultados.length) {
|
||||
titulo("Resultados a lograr");
|
||||
for (const r of d.propuesta.diagnostico.resultados) {
|
||||
const t = `• ${r.enunciado} (${r.metrica}, ${r.periodoMedicion})`;
|
||||
const h = txtH(t, W - 8, 9);
|
||||
y = need(h + 6, y);
|
||||
doc.font("Helvetica").fontSize(9).fillColor(DARK).text(t, L + 4, y, { width: W - 8 });
|
||||
y += h + 6;
|
||||
}
|
||||
y += 8;
|
||||
}
|
||||
|
||||
// ── ALCANCE ──
|
||||
// Se recorren las partidas de la COTIZACION, no las que la IA alcanzo a describir.
|
||||
// Motivo: el schema acota `alcance` y una cotizacion con mas partidas que ese tope
|
||||
// dejaria servicios cotizados fuera del documento del cliente, en silencio.
|
||||
// Verificado con UJ2606UR001: 58 partidas, la IA describio 40, faltaban 18.
|
||||
// La completitud la manda la base de datos; la IA solo aporta la prosa.
|
||||
titulo("Alcance de la inversion");
|
||||
const descPorRef = new Map(d.propuesta.redaccion.alcance.map((a) => [a.refPartida, a.descripcionResultado]));
|
||||
for (const p of d.economia.partidas) {
|
||||
const descripcion = descPorRef.get(p.refPartida);
|
||||
const hNombre = txtH(p.nombre, W * 0.68, 9.5);
|
||||
const hDesc = descripcion ? txtH(descripcion, W * 0.68, 8) : 0;
|
||||
y = need(hNombre + hDesc + 14, y);
|
||||
doc.font("Helvetica-Bold").fontSize(9.5).fillColor(DARK).text(p.nombre, L, y, { width: W * 0.68 });
|
||||
doc
|
||||
.font("Helvetica-Bold")
|
||||
.fontSize(9.5)
|
||||
.fillColor(PRIMARY)
|
||||
.text(formatCurrency(p.precio), L + W * 0.7, y, { width: W * 0.3, align: "right" });
|
||||
y += hNombre + 2;
|
||||
if (descripcion) {
|
||||
doc.font("Helvetica").fontSize(8).fillColor(MUTED).text(descripcion, L, y, { width: W * 0.68 });
|
||||
y += hDesc + 10;
|
||||
} else {
|
||||
// Sin prosa de la IA: la partida SI aparece, con su detalle del catalogo.
|
||||
const respaldo = detalleDePartida(p);
|
||||
if (respaldo) {
|
||||
const hR = txtH(respaldo, W * 0.68, 8);
|
||||
doc.font("Helvetica").fontSize(8).fillColor(MUTED).text(respaldo, L, y, { width: W * 0.68 });
|
||||
y += hR + 10;
|
||||
} else {
|
||||
y += 8;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// El plan Bucefalo es una partida mas del acuerdo: si no se imprime aqui, el
|
||||
// cliente recibe un documento consultivo con menos alcance que su cotizacion.
|
||||
if (d.economia.planBucefalo) {
|
||||
const nivel = d.economia.planBucefalo.nivel;
|
||||
const etiqueta = `CRM Bucefalo — plan ${nivel.charAt(0).toUpperCase() + nivel.slice(1)}`;
|
||||
const hE = txtH(etiqueta, W * 0.68, 9.5);
|
||||
y = need(hE + 22, y);
|
||||
doc.font("Helvetica-Bold").fontSize(9.5).fillColor(DARK).text(etiqueta, L, y, { width: W * 0.68 });
|
||||
doc
|
||||
.font("Helvetica-Bold")
|
||||
.fontSize(9.5)
|
||||
.fillColor(PRIMARY)
|
||||
.text(`${formatCurrency(d.economia.planBucefalo.precio)} / mes`, L + W * 0.7, y, { width: W * 0.3, align: "right" });
|
||||
y += hE + 2;
|
||||
doc.font("Helvetica").fontSize(8).fillColor(MUTED).text("Servicio mensual", L, y, { width: W * 0.68 });
|
||||
y += 20;
|
||||
}
|
||||
|
||||
y = need(58, y);
|
||||
doc.moveTo(L, y).lineTo(L + W, y).strokeColor(BORDER).lineWidth(0.5).stroke();
|
||||
y += 10;
|
||||
// ── CAJA DE TOTALES ──
|
||||
// Desglose completo (subtotal / IVA / total), como la plantilla autorizada.
|
||||
//
|
||||
// Antes se imprimia cada partida a su precio SIN IVA y debajo un unico total CON
|
||||
// IVA, rematado con la leyenda "Importes con IVA incluido": las lineas no sumaban
|
||||
// el total, la leyenda contradecia a sus propias lineas, y el PDF economico que va
|
||||
// en el MISMO correo dice "los precios no incluyen IVA" sobre las mismas cifras.
|
||||
// Ahora las lineas siguen siendo sin IVA —igual que el otro documento— y el IVA
|
||||
// aparece como renglon propio.
|
||||
const t = d.economia.totales;
|
||||
const fila = (etiqueta: string, valor: string, fuerte = false) => {
|
||||
y = need(fuerte ? 18 : 15, y);
|
||||
doc
|
||||
.font(fuerte ? "Helvetica-Bold" : "Helvetica")
|
||||
.fontSize(fuerte ? 10.5 : 9)
|
||||
.fillColor(fuerte ? DARK : MUTED)
|
||||
.text(etiqueta, L, y);
|
||||
doc
|
||||
.font("Helvetica-Bold")
|
||||
.fontSize(fuerte ? 10.5 : 9)
|
||||
.fillColor(fuerte ? PRIMARY : DARK)
|
||||
.text(valor, L + W * 0.6, y, { width: W * 0.4, align: "right" });
|
||||
y += fuerte ? 18 : 15;
|
||||
};
|
||||
|
||||
if (t.subtotalUnico > 0) {
|
||||
fila("Subtotal pago unico", formatCurrency(t.subtotalUnico));
|
||||
if (t.incluyeIva) fila("IVA 16%", formatCurrency(t.ivaUnico));
|
||||
fila(t.incluyeIva ? "Total pago unico" : "Total pago unico (sin IVA)", formatCurrency(t.totalUnico), true);
|
||||
}
|
||||
if (t.subtotalMensual > 0) {
|
||||
if (t.subtotalUnico > 0) y += 4;
|
||||
fila("Subtotal mensual", formatCurrency(t.subtotalMensual));
|
||||
if (t.incluyeIva) fila("IVA 16%", formatCurrency(t.ivaMensual));
|
||||
fila(t.incluyeIva ? "Total mensual" : "Total mensual (sin IVA)", formatCurrency(t.totalMensual), true);
|
||||
}
|
||||
|
||||
y = need(16, y);
|
||||
doc
|
||||
.font("Helvetica")
|
||||
.fontSize(7.5)
|
||||
.fillColor(MUTED)
|
||||
.text(
|
||||
t.incluyeIva
|
||||
? "Los precios por partida son en Moneda Nacional (MXN) y no incluyen IVA; el IVA se desglosa arriba. Facturacion CFDI."
|
||||
: "Los precios son en Moneda Nacional (MXN) y no incluyen IVA. Facturacion CFDI.",
|
||||
L,
|
||||
y,
|
||||
{ width: W }
|
||||
);
|
||||
y += 24;
|
||||
|
||||
// ── BENEFICIOS ──
|
||||
if (d.propuesta.redaccion.beneficios.length) {
|
||||
titulo("Por que tiene sentido");
|
||||
for (const b of d.propuesta.redaccion.beneficios) {
|
||||
const hEt = txtH(b.etiqueta, W * 0.24, 9);
|
||||
const hTx = txtH(b.texto, W * 0.72, 8.5);
|
||||
const h = Math.max(hEt, hTx);
|
||||
y = need(h + 9, y);
|
||||
doc.font("Helvetica-Bold").fontSize(9).fillColor(DARK).text(b.etiqueta, L, y, { width: W * 0.24 });
|
||||
doc.font("Helvetica").fontSize(8.5).fillColor(MUTED).text(b.texto, L + W * 0.27, y, { width: W * 0.72 });
|
||||
y += h + 9;
|
||||
}
|
||||
y += 8;
|
||||
}
|
||||
|
||||
// ── EXCLUSIONES ──
|
||||
titulo("Que no incluye esta propuesta");
|
||||
for (const e of d.propuesta.redaccion.exclusiones) {
|
||||
const t2 = `✕ ${e.texto}`;
|
||||
const h = txtH(t2, W - 8, 8.5);
|
||||
y = need(h + 6, y);
|
||||
doc.font("Helvetica").fontSize(8.5).fillColor(DARK).text(t2, L + 4, y, { width: W - 8 });
|
||||
y += h + 6;
|
||||
}
|
||||
y += 10;
|
||||
|
||||
// ── PENDIENTES: el canal de honestidad del documento ──
|
||||
const mats = d.propuesta.hechos.materialesPendientes;
|
||||
const decs = d.propuesta.hechos.decisionesPendientes;
|
||||
if (mats.length || decs.length) {
|
||||
titulo("Que necesitamos de ustedes");
|
||||
for (const mm of mats) {
|
||||
const t2 = `○ ${mm.texto}${mm.bloqueaEntrega ? " (el avance queda condicionado a esto)" : ""}`;
|
||||
const h = txtH(t2, W - 8, 8.5);
|
||||
y = need(h + 6, y);
|
||||
doc.font("Helvetica").fontSize(8.5).fillColor(DARK).text(t2, L + 4, y, { width: W - 8 });
|
||||
y += h + 6;
|
||||
}
|
||||
for (const dd of decs) {
|
||||
const t2 = `· ${dd.texto} (decide: ${dd.quienDecide})`;
|
||||
const h = txtH(t2, W - 8, 8.5);
|
||||
y = need(h + 6, y);
|
||||
doc.font("Helvetica").fontSize(8.5).fillColor(MUTED).text(t2, L + 4, y, { width: W - 8 });
|
||||
y += h + 6;
|
||||
}
|
||||
y += 10;
|
||||
}
|
||||
|
||||
// ── BACKLOG ──
|
||||
if (d.propuesta.redaccion.backlogEvolucion.length) {
|
||||
titulo("Registrado para mas adelante");
|
||||
y = need(14, y);
|
||||
doc.font("Helvetica-Oblique").fontSize(7.5).fillColor(MUTED).text("No comprometido en esta propuesta.", L, y);
|
||||
y += 14;
|
||||
for (const b of d.propuesta.redaccion.backlogEvolucion) {
|
||||
const t2 = `· ${b.problema} (${b.momentoSugerido})`;
|
||||
const h = txtH(t2, W - 8, 8.5);
|
||||
y = need(h + 6, y);
|
||||
doc.font("Helvetica").fontSize(8.5).fillColor(DARK).text(t2, L + 4, y, { width: W - 8 });
|
||||
y += h + 6;
|
||||
}
|
||||
}
|
||||
|
||||
// ── FOOTERS ──
|
||||
// margins.bottom = 0 temporal: sin eso, escribir en el margen inferior dispara el
|
||||
// auto-page-break de pdfkit y se generan paginas vacias.
|
||||
const savedBottom = doc.page.margins.bottom;
|
||||
const rango = doc.bufferedPageRange();
|
||||
for (let i = rango.start; i < rango.start + rango.count; i++) {
|
||||
doc.switchToPage(i);
|
||||
doc.page.margins.bottom = 0;
|
||||
doc.moveTo(L, ph - 42).lineTo(L + W, ph - 42).strokeColor(BORDER).lineWidth(0.5).stroke();
|
||||
doc
|
||||
.font("Helvetica")
|
||||
.fontSize(7)
|
||||
.fillColor(MUTED)
|
||||
.text(`${d.numero} · Propuesta consultiva · ${d.empresa || d.cliente}`, L, ph - 35, { lineBreak: false });
|
||||
doc
|
||||
.font("Helvetica")
|
||||
.fontSize(7)
|
||||
.fillColor(MUTED)
|
||||
.text(`${i - rango.start + 1} / ${rango.count}`, L, ph - 35, { width: W, align: "right", lineBreak: false });
|
||||
doc.page.margins.bottom = savedBottom;
|
||||
}
|
||||
|
||||
doc.end();
|
||||
return listo;
|
||||
}
|
||||
|
||||
/** Anexo interno. Archivo SEPARADO y visualmente inconfundible: el riesgo de que una
|
||||
* seccion oculta llegue al cliente es demasiado alto para un display:none. */
|
||||
export async function generarAnexoInternoPDF(d: DatosPropuestaPDF): Promise<Buffer> {
|
||||
const { lienzo, listo } = crearLienzo();
|
||||
const { doc, W, L, maxY, mTop } = lienzo;
|
||||
let y = mTop;
|
||||
const DARK = "#1e293b";
|
||||
const MUTED = "#64748b";
|
||||
const need = (h: number, yy: number) => (yy + h > maxY ? (doc.addPage(), mTop) : yy);
|
||||
const txtH = (s: string, w: number, size: number) =>
|
||||
doc.font("Helvetica").fontSize(size).heightOfString(s, { width: w });
|
||||
|
||||
doc.rect(0, 0, doc.page.width, 36).fill("#b91c1c");
|
||||
doc.font("Helvetica-Bold").fontSize(13).fillColor("#ffffff").text("USO INTERNO — NO ENVIAR AL CLIENTE", L, 11);
|
||||
y = 56;
|
||||
|
||||
doc.font("Helvetica").fontSize(9).fillColor(MUTED).text(`${d.numero} · ${d.empresa || d.cliente} · ${d.asesor}`, L, y);
|
||||
y += 24;
|
||||
|
||||
const valorAnual =
|
||||
d.propuesta.diagnostico.valorProblema.dimensiones.reduce((a, x) => a + (x.montoAnualMXN ?? 0), 0) || null;
|
||||
const r = calcularRatio(d.economia.totales.totalPrimerAnio, valorAnual);
|
||||
|
||||
const seccion = (t: string) => {
|
||||
y = need(24, y);
|
||||
doc.font("Helvetica-Bold").fontSize(11).fillColor(DARK).text(t, L, y);
|
||||
y += 18;
|
||||
};
|
||||
const linea = (k: string, v: string) => {
|
||||
y = need(15, y);
|
||||
doc.font("Helvetica").fontSize(9).fillColor(MUTED).text(k, L, y);
|
||||
doc.font("Helvetica-Bold").fontSize(9).fillColor(DARK).text(v, L + W * 0.5, y, { width: W * 0.5, align: "right" });
|
||||
y += 15;
|
||||
};
|
||||
|
||||
seccion("Ponderacion de la cotizacion");
|
||||
linea("Inversion del primer ano", formatCurrency(d.economia.totales.totalPrimerAnio));
|
||||
linea("Valor anual del problema", valorAnual ? formatCurrency(valorAnual) : "sin cuantificar");
|
||||
linea("Ratio precio / valor", r ? `${(r.ratio * 100).toFixed(1)}% — ${r.lectura.replace(/_/g, " ")}` : "no calculable");
|
||||
linea("Hallazgos en el diagnostico", String(d.propuesta.diagnostico.hallazgos.length));
|
||||
linea("Cifras confirmadas", String(d.propuesta.diagnostico.hallazgos.filter((h) => h.confianza === "confirmado").length));
|
||||
linea("Exclusiones definidas", String(d.propuesta.redaccion.exclusiones.length));
|
||||
linea("Materiales pendientes", String(d.propuesta.hechos.materialesPendientes.length));
|
||||
linea("Decisiones pendientes", String(d.propuesta.hechos.decisionesPendientes.length));
|
||||
linea("Red flags detectadas", String(d.propuesta.hechos.redFlags.length));
|
||||
y += 6;
|
||||
|
||||
// Desglose del valor anual. Va aqui porque es el denominador del ratio: si esa cifra
|
||||
// esta inflada, el ratio miente y el asesor toma una decision de precio con un dato
|
||||
// malo. Verificado en produccion que el modelo puede omitir un factor (una tasa de
|
||||
// conversion) y aun asi cuadrar la aritmetica.
|
||||
if (d.propuesta.diagnostico.valorProblema.dimensiones.length) {
|
||||
seccion("De donde sale el valor anual");
|
||||
for (const dim of d.propuesta.diagnostico.valorProblema.dimensiones) {
|
||||
const monto = dim.montoAnualMXN;
|
||||
const cab = `${dim.tipo}: ${monto !== null ? formatCurrency(monto) : "sin cifra"}`;
|
||||
y = need(14, y);
|
||||
doc.font("Helvetica-Bold").fontSize(9).fillColor(DARK).text(cab, L, y);
|
||||
y += 13;
|
||||
if (dim.factores.length) {
|
||||
const desglose = dim.factores.map((f) => `${f.nombre} = ${f.valor} (${f.confianza})`).join(" x ");
|
||||
const h = txtH(desglose, W - 10, 8);
|
||||
y = need(h + 8, y);
|
||||
doc.font("Helvetica").fontSize(8).fillColor(MUTED).text(desglose, L + 6, y, { width: W - 10 });
|
||||
y += h + 8;
|
||||
}
|
||||
}
|
||||
const sinConfirmar = d.propuesta.diagnostico.valorProblema.dimensiones.some(
|
||||
(dim) => dim.montoAnualMXN !== null && !dim.factores.some((f) => f.confianza === "confirmado")
|
||||
);
|
||||
if (sinConfirmar) {
|
||||
const alerta =
|
||||
"Ojo: hay una cifra que descansa entera en factores estimados. Antes de fiarte del ratio, " +
|
||||
"revisa que no falte un factor — la aritmetica puede cuadrar y aun asi estar inflada.";
|
||||
const h = txtH(alerta, W, 8.5);
|
||||
y = need(h + 12, y);
|
||||
doc.font("Helvetica-Bold").fontSize(8.5).fillColor("#b91c1c").text(alerta, L, y, { width: W });
|
||||
y += h + 14;
|
||||
}
|
||||
y += 4;
|
||||
}
|
||||
|
||||
if (r) {
|
||||
const nota =
|
||||
r.lectura === "subcotizado"
|
||||
? "La inversion es menos del 10% de lo que el problema le cuesta al cliente cada ano. Probablemente subcotizaste."
|
||||
: r.lectura === "objecion_probable"
|
||||
? "La inversion supera el 40% del valor anual del problema. Prepara la conversacion de precio: se responde con alcance, no con descuento."
|
||||
: r.lectura === "alto"
|
||||
? "La inversion esta en la banda alta. Justificable, pero conviene anclar bien el valor antes de dar el numero."
|
||||
: "La inversion cae en el rango de referencia (15-25% del valor anual).";
|
||||
const h = txtH(nota, W, 8.5);
|
||||
y = need(h + 12, y);
|
||||
doc.font("Helvetica-Oblique").fontSize(8.5).fillColor(MUTED).text(nota, L, y, { width: W });
|
||||
y += h + 16;
|
||||
}
|
||||
|
||||
if (d.propuesta.hechos.redFlags.length) {
|
||||
seccion("Red flags");
|
||||
for (const rf of d.propuesta.hechos.redFlags) {
|
||||
const t = `· [${rf.severidad}] ${rf.senal}`;
|
||||
const h = txtH(t, W - 8, 9);
|
||||
y = need(h + 6, y);
|
||||
doc.font("Helvetica").fontSize(9).fillColor(DARK).text(t, L + 4, y, { width: W - 8 });
|
||||
y += h + 6;
|
||||
}
|
||||
y += 10;
|
||||
}
|
||||
|
||||
if (d.propuesta.redaccion.notasInternas.length) {
|
||||
seccion("Notas para el asesor");
|
||||
for (const n of d.propuesta.redaccion.notasInternas) {
|
||||
const t = `· ${n}`;
|
||||
const h = txtH(t, W - 8, 9);
|
||||
y = need(h + 6, y);
|
||||
doc.font("Helvetica").fontSize(9).fillColor(DARK).text(t, L + 4, y, { width: W - 8 });
|
||||
y += h + 6;
|
||||
}
|
||||
y += 10;
|
||||
}
|
||||
|
||||
if (d.propuesta.hechos.mencionesFueraDeAlcance.length) {
|
||||
seccion("Se menciono y quedo fuera");
|
||||
for (const m of d.propuesta.hechos.mencionesFueraDeAlcance) {
|
||||
const t = `· ${m}`;
|
||||
const h = txtH(t, W - 8, 9);
|
||||
y = need(h + 6, y);
|
||||
doc.font("Helvetica").fontSize(9).fillColor(DARK).text(t, L + 4, y, { width: W - 8 });
|
||||
y += h + 6;
|
||||
}
|
||||
}
|
||||
|
||||
doc.end();
|
||||
return listo;
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
import { llamarConHerramienta, modelo, type UsoTokens, type BloqueSystem } from "./cliente-ia";
|
||||
import {
|
||||
hechosSchema,
|
||||
diagnosticoSchema,
|
||||
redaccionSchema,
|
||||
type Hechos,
|
||||
type Diagnostico,
|
||||
type Redaccion,
|
||||
type PropuestaConsultiva,
|
||||
} from "./schemas";
|
||||
import { SYSTEM_BASE, mensajePaso1, mensajePaso2, mensajePaso3, type ContextoEntrada } from "./prompts";
|
||||
import type { DatosEconomicos } from "./economia";
|
||||
|
||||
/**
|
||||
* Pipeline de tres pasos.
|
||||
*
|
||||
* Se separa en tres porque un solo prompt monolitico produce un documento mediocre en
|
||||
* todas sus partes: la extraccion determina la calidad de todo lo demas y merece su
|
||||
* propia pasada. Ademas permite corregir los hechos antes de que se propaguen.
|
||||
*/
|
||||
|
||||
export interface Traza {
|
||||
modelo: string;
|
||||
pasos: { paso: string; intentos: number; uso: UsoTokens }[];
|
||||
totalUso: UsoTokens;
|
||||
}
|
||||
|
||||
// Un solo breakpoint de cache, al final de la capa estable. El pipeline hace tres
|
||||
// llamadas seguidas con el mismo prefijo, asi que el TTL de 5 minutos de MiniMax
|
||||
// alcanza de sobra y las llamadas 2 y 3 deberian leer del cache.
|
||||
const SYSTEM: BloqueSystem[] = [{ texto: SYSTEM_BASE, cachear: true }];
|
||||
|
||||
export async function generarPropuesta(opts: {
|
||||
entrada: ContextoEntrada;
|
||||
economia: DatosEconomicos;
|
||||
}): Promise<{ propuesta: PropuestaConsultiva; traza: Traza }> {
|
||||
const pasos: Traza["pasos"] = [];
|
||||
const total: UsoTokens = { entrada: 0, salida: 0, cacheLectura: 0, cacheEscritura: 0 };
|
||||
const acumular = (u: UsoTokens) => {
|
||||
total.entrada += u.entrada;
|
||||
total.salida += u.salida;
|
||||
total.cacheLectura += u.cacheLectura;
|
||||
total.cacheEscritura += u.cacheEscritura;
|
||||
};
|
||||
|
||||
const r1 = await llamarConHerramienta<Hechos>({
|
||||
system: SYSTEM,
|
||||
mensajeUsuario: mensajePaso1(opts.entrada),
|
||||
herramienta: {
|
||||
nombre: "registrar_hechos",
|
||||
descripcion:
|
||||
"Registra las citas literales, los hechos, los pendientes y las red flags extraidos del material de la reunion.",
|
||||
schema: hechosSchema,
|
||||
},
|
||||
// 5 intentos: verificado contra la API real que MiniMax se equivoca de array de
|
||||
// vez en cuando con schemas anidados (mete campos de "hechos" dentro de "citas").
|
||||
// Es el paso fundacional; si falla, no hay documento. El cache abarata el reintento.
|
||||
maxIntentos: 5,
|
||||
maxTokens: 8000,
|
||||
});
|
||||
pasos.push({ paso: "extraccion", intentos: r1.intentos, uso: r1.uso });
|
||||
acumular(r1.uso);
|
||||
|
||||
const r2 = await llamarConHerramienta<Diagnostico>({
|
||||
system: SYSTEM,
|
||||
mensajeUsuario: mensajePaso2(opts.entrada, r1.datos, opts.economia),
|
||||
herramienta: {
|
||||
nombre: "registrar_diagnostico",
|
||||
descripcion:
|
||||
"Registra los hallazgos con su semaforo de urgencia, el valor anual del problema y los resultados de negocio a lograr.",
|
||||
schema: diagnosticoSchema,
|
||||
},
|
||||
maxIntentos: 4,
|
||||
maxTokens: 8000,
|
||||
});
|
||||
pasos.push({ paso: "diagnostico", intentos: r2.intentos, uso: r2.uso });
|
||||
acumular(r2.uso);
|
||||
|
||||
// El paso 3 recibe un intento extra: es el mas largo y el que atraviesa mas
|
||||
// compuertas de validacion, asi que es donde mas probable es agotar el presupuesto.
|
||||
const r3 = await llamarConHerramienta<Redaccion>({
|
||||
system: SYSTEM,
|
||||
mensajeUsuario: mensajePaso3(opts.entrada, r1.datos, r2.datos, opts.economia),
|
||||
herramienta: {
|
||||
nombre: "registrar_propuesta",
|
||||
descripcion: "Registra la redaccion final de la propuesta consultiva para el cliente.",
|
||||
schema: redaccionSchema,
|
||||
},
|
||||
maxIntentos: 4,
|
||||
maxTokens: 12000,
|
||||
});
|
||||
pasos.push({ paso: "redaccion", intentos: r3.intentos, uso: r3.uso });
|
||||
acumular(r3.uso);
|
||||
|
||||
return {
|
||||
propuesta: { hechos: r1.datos, diagnostico: r2.datos, redaccion: r3.datos },
|
||||
traza: { modelo: modelo(), pasos, totalUso: total },
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,244 @@
|
||||
import type { DatosEconomicos } from "./economia";
|
||||
import type { Hechos, Diagnostico } from "./schemas";
|
||||
|
||||
/**
|
||||
* Prompts en capas, ordenados por estabilidad.
|
||||
*
|
||||
* SYSTEM_BASE es la capa 1: identica en toda cotizacion, y por eso es la unica que
|
||||
* se marca como cacheable. NADA dinamico puede entrar aqui — ni fechas, ni numeros
|
||||
* de cotizacion, ni nombres de cliente. Un solo byte que cambie invalida el cache
|
||||
* de todo lo que viene despues, y el sintoma es solo la factura.
|
||||
*/
|
||||
export const SYSTEM_BASE = `
|
||||
# QUIEN ERES
|
||||
|
||||
Consultor senior de digitalizacion de negocios para PyMEs mexicanas. Redactas la parte
|
||||
narrativa de las propuestas de Consultoria E3 (Queretaro, Mexico). No eres vendedor: eres
|
||||
diagnosticador. Tu trabajo es explicar por que la inversion tiene sentido, nunca decidir
|
||||
cuanto cuesta.
|
||||
|
||||
El documento que produces acompana a otro que ya existe: la cotizacion economica que el
|
||||
asesor armo a mano. Ese documento manda en todo lo que sea dinero. El tuyo manda en el
|
||||
porque.
|
||||
|
||||
# LOS PRINCIPIOS QUE NO SE NEGOCIAN
|
||||
|
||||
P1. NO TOCAS LOS NUMEROS. No calculas, propones ni mencionas precios, totales, IVA ni
|
||||
descuentos de E3. Ni siquiera los ves. Para referirte a una partida usa su
|
||||
refPartida (P01, P02...). El sistema inyecta los importes despues de ti.
|
||||
Si escribes una cifra en pesos, solo puede ser el costo del problema DEL CLIENTE:
|
||||
lo que le cuesta hoy no resolverlo. Nunca un precio nuestro.
|
||||
|
||||
P2. TODA AFIRMACION ES TRAZABLE. Cada cosa que digas sobre el cliente apunta a una cita
|
||||
(C01...) o a un hecho (H01...). Si no tiene origen, no se escribe. No hay excepciones
|
||||
y no importa lo razonable que suene.
|
||||
|
||||
P3. ETIQUETAS LA CERTEZA, y la diferencia importa:
|
||||
- confirmado: el cliente lo dijo textualmente, o hay un dato duro.
|
||||
- estimado: lo derivaste con un calculo explicito que puedes mostrar.
|
||||
- por_validar: es hipotesis tuya y nadie la ha confirmado.
|
||||
Presentar un estimado como confirmado es la forma mas rapida de perder una reunion:
|
||||
basta que el cliente refute una cifra para que dude de todo el documento.
|
||||
|
||||
P4. LAS PALABRAS DEL CLIENTE SON SAGRADAS. Las citas van textuales, con sus muletillas si
|
||||
hace falta. No las pulas ni les arregles la gramatica.
|
||||
Bien: "se nos van los clientes porque nadie contesta el WhatsApp el fin de semana"
|
||||
Mal: "oportunidades de mejora en la gestion omnicanal de la comunicacion"
|
||||
|
||||
P5. VENDES RESULTADO, NO HERRAMIENTA. Traduce toda capacidad tecnica a dinero, tiempo,
|
||||
riesgo evitado o tranquilidad operativa.
|
||||
Mal: "Configuracion de Google Ads con estructura SKAG y scripts de puja."
|
||||
Bien: "Cada peso de pauta se dirige a las busquedas que si compran, en lugar de
|
||||
repartirse entre terminos que solo generan clics."
|
||||
|
||||
P6. LO QUE NO INCLUYE VALE TANTO COMO LO QUE SI. Las exclusiones son especificas de ESTE
|
||||
proyecto, sacadas de lo que se menciono en la reunion.
|
||||
Mal: "No incluye servicios no mencionados."
|
||||
Bien: "No incluye migrar el historico de 4 anos de pedidos que mencionaron; eso se
|
||||
evalua como fase 2 cuando el sistema base este operando."
|
||||
|
||||
P7. LA INCERTIDUMBRE SE DECLARA, NO SE RELLENA. Si falta un dato, va a pendientes con su
|
||||
etiqueta. Jamas lo inventas. Una propuesta con ocho pendientes honestos cierra mejor
|
||||
que una con ocho cifras inventadas: el dia que el cliente refute un dato inventado, el
|
||||
costo no lo paga el modelo, lo paga la marca.
|
||||
|
||||
P8. NO PROPONES SERVICIOS QUE EL ASESOR NO ELIGIO. Si detectas una necesidad que nuestro
|
||||
catalogo cubre y no esta cotizada, va a notasInternas. Nunca al documento del cliente.
|
||||
|
||||
# EL SEMAFORO DEL DIAGNOSTICO
|
||||
|
||||
Cada hallazgo se clasifica por urgencia, y la clasificacion es parte del mensaje:
|
||||
- rojo: problema critico. Le esta costando dinero hoy.
|
||||
- ambar: area de mejora. Funciona, pero por debajo de lo que podria.
|
||||
- azul: oportunidad. Algo que no esta haciendo y podria.
|
||||
- verde: ventaja existente. Algo que el cliente YA hace bien.
|
||||
|
||||
El verde no es relleno ni cortesia: reconocer lo que el cliente hizo bien es lo que
|
||||
convierte una propuesta en una conversacion entre pares en lugar de un regano. Buscalo
|
||||
de verdad. Pero si no hay evidencia de alguno de los cuatro, omitelo antes que inventarlo.
|
||||
|
||||
# REGLAS DE CONTENIDO Y DE MARCA
|
||||
|
||||
1. Espanol de Mexico. Tono cercano y profesional. Tutea al cliente.
|
||||
2. Prohibido el lenguaje corporativo vacio: sinergias, holistico, stakeholders,
|
||||
ecosistema, disruptivo, robusto, potenciar, empoderar, solucion integral.
|
||||
3. El CRM se llama Bucefalo. No menciones ningun otro CRM, por ningun motivo, aunque el
|
||||
cliente haya nombrado uno en la reunion.
|
||||
4. E3 ofrece UNICAMENTE servicios digitales. Si en la reunion pidieron marketing
|
||||
tradicional, impresos o diseno para imprenta, va a exclusiones aclarando que no es un
|
||||
servicio de E3.
|
||||
5. Moneda MXN, IVA 16%, facturacion CFDI. Jamas montos en dolares ni en USD.
|
||||
6. No prometas resultados garantizados de mercado: ni ventas, ni posicion numero uno en
|
||||
Google, ni cantidad de prospectos. Prometes entregables, procesos y metricas de
|
||||
seguimiento. La palabra "garantizado" no aparece sobre resultados de mercado.
|
||||
7. No prometas soporte ilimitado ni mantenimiento gratuito indefinido.
|
||||
8. No incluyas nombres de empleados del cliente, sueldos, ni temas legales, laborales o de
|
||||
salud. Si la reunion los toco, se omiten del documento; si el asesor debe saberlo, va a
|
||||
notasInternas.
|
||||
|
||||
# QUE HACES CUANDO EL MATERIAL ES POBRE
|
||||
|
||||
Este es el caso mas importante y el que peor se suele resolver.
|
||||
|
||||
Si la transcripcion es corta, vaga, o no tiene una sola cifra: NO inventas para rellenar.
|
||||
Produces un documento honesto — pocos hallazgos, varios marcados por_validar, montos en
|
||||
null, y una lista larga y util de materiales y decisiones pendientes.
|
||||
|
||||
Ese documento es un exito, no un fracaso. Le dice al cliente exactamente que hace falta
|
||||
para avanzar, y transfiere la responsabilidad del retraso a donde corresponde. Un hueco de
|
||||
informacion declarado con claridad deja de ser un defecto y se vuelve contenido de valor.
|
||||
|
||||
Lo que NUNCA haces con material pobre: inventar una cifra plausible, atribuir al cliente
|
||||
una frase que no dijo, o describir un dolor generico de la industria como si fuera suyo.
|
||||
`.trim();
|
||||
|
||||
export interface ContextoEntrada {
|
||||
transcripcion: string;
|
||||
notas: string;
|
||||
observaciones: string;
|
||||
cliente: string;
|
||||
empresa: string;
|
||||
proyecto: string;
|
||||
}
|
||||
|
||||
/** Capa 3: volatil. Cambia por cotizacion, nunca se cachea. */
|
||||
export function bloqueContexto(e: ContextoEntrada): string {
|
||||
const partes = [
|
||||
`Cliente: ${e.cliente}${e.empresa ? ` (${e.empresa})` : ""}`,
|
||||
`Proyecto: ${e.proyecto}`,
|
||||
];
|
||||
if (e.observaciones.trim()) {
|
||||
partes.push(`\n## Observaciones que el asesor escribio para el cliente\n${e.observaciones.trim()}`);
|
||||
}
|
||||
if (e.notas.trim()) {
|
||||
partes.push(`\n## Notas por partida\n${e.notas.trim()}`);
|
||||
}
|
||||
if (e.transcripcion.trim()) {
|
||||
partes.push(`\n## Transcripcion de la reunion\n${e.transcripcion.trim()}`);
|
||||
} else {
|
||||
partes.push(
|
||||
`\n## Transcripcion de la reunion\n(No se entrego transcripcion. Trabaja solo con lo de arriba, se generoso marcando por_validar, y puebla bien los pendientes.)`
|
||||
);
|
||||
}
|
||||
return partes.join("\n");
|
||||
}
|
||||
|
||||
export function mensajePaso1(e: ContextoEntrada): string {
|
||||
return `${bloqueContexto(e)}
|
||||
|
||||
---
|
||||
|
||||
Extrae los hechos de este material y llama a registrar_hechos.
|
||||
|
||||
Reglas de este paso:
|
||||
- Las citas van TEXTUALES. Copialas del material, no las reescribas. Si no hay nada
|
||||
citable, devuelve el array vacio en vez de inventar una cita.
|
||||
- Numera las citas C01, C02... y los hechos H01, H02...
|
||||
- Cada hecho apunta a las citas que lo sostienen. Un hecho sin ninguna cita solo puede
|
||||
ser "por_validar".
|
||||
- En quienLoDijo usa el ROL ("el socio", "quien atiende el WhatsApp"), no el nombre
|
||||
propio, salvo que sea el interlocutor comercial.
|
||||
- Si de alguna de estas listas no hay NADA que decir, devuelvela VACIA. Un array vacio
|
||||
es la respuesta correcta; no metas "N/A", "ninguno" ni un guion para rellenar.
|
||||
- En redFlags anota lo que deberia preocuparle al asesor: que pidan descuento antes de
|
||||
entender el alcance, que no este presente quien decide, que no haya ninguna cifra del
|
||||
problema, o un "hagan todo y luego vemos".`;
|
||||
}
|
||||
|
||||
export function mensajePaso2(e: ContextoEntrada, hechos: Hechos, econ: DatosEconomicos): string {
|
||||
const partidas = econ.partidas
|
||||
.map((p) => `- ${p.refPartida}: ${p.nombre} (fase ${p.fase}, pago ${p.tipoPago})`)
|
||||
.join("\n");
|
||||
return `${bloqueContexto(e)}
|
||||
|
||||
## Hechos extraidos en el paso anterior
|
||||
${JSON.stringify(hechos, null, 2)}
|
||||
|
||||
## Partidas que el asesor ya eligio
|
||||
${partidas || "(ninguna)"}
|
||||
|
||||
(Las partidas van sin precio a proposito: tu no los necesitas y no debes mencionarlos.)
|
||||
|
||||
---
|
||||
|
||||
Diagnostica y llama a registrar_diagnostico.
|
||||
|
||||
Reglas de este paso:
|
||||
- Reformula al problema de NEGOCIO. El cliente describe sintomas ("quiero una pagina
|
||||
web"); tu nombras la enfermedad ("pierden prospectos porque no tienen a donde mandarlos
|
||||
desde los anuncios").
|
||||
- Intenta cubrir el semaforo completo, incluido al menos un verde. Si no hay evidencia de
|
||||
algun color, omitelo: es mejor un semaforo incompleto que un hallazgo inventado.
|
||||
- En valorProblema, si declaras un montoAnualMXN tienes que mostrar al menos dos
|
||||
factores que lo expliquen, y la aritmetica debe cuadrar: el monto es el producto o la
|
||||
suma de sus factores. Cada factor lleva su propia confianza — si uno de ellos te lo
|
||||
estas inventando (una tasa de conversion tipica, por ejemplo), marcalo por_validar
|
||||
aunque los demas sean confirmados. Un solo factor inventado puede sostener toda la
|
||||
cifra, y el asesor necesita saber cual es.
|
||||
- Si NO tienes cifras para una dimension, OMITE montoAnualMXN y deja factores vacio.
|
||||
No inventes factores de relleno para llenar el hueco: un array vacio dice la verdad,
|
||||
"herramienta_actual=0 x canal=1" no dice nada.
|
||||
- Recuerda P1: montoAnualMXN es lo que el problema le cuesta AL CLIENTE cada ano. No es
|
||||
un precio de E3 ni tiene relacion con lo que cotizamos.
|
||||
- Los resultados a lograr son de negocio y medibles. "Mejorar la presencia digital" no es
|
||||
un resultado; "ningun mensaje sin respuesta en mas de 24 horas" si lo es.`;
|
||||
}
|
||||
|
||||
export function mensajePaso3(
|
||||
e: ContextoEntrada,
|
||||
hechos: Hechos,
|
||||
diag: Diagnostico,
|
||||
econ: DatosEconomicos
|
||||
): string {
|
||||
const partidas = econ.partidas
|
||||
.map(
|
||||
(p) => `- ${p.refPartida}: ${p.nombre} (fase ${p.fase}, pago ${p.tipoPago}, entrega ${p.tiempoEntrega})`
|
||||
)
|
||||
.join("\n");
|
||||
return `## Hechos
|
||||
${JSON.stringify(hechos, null, 2)}
|
||||
|
||||
## Diagnostico
|
||||
${JSON.stringify(diag, null, 2)}
|
||||
|
||||
## Partidas a describir
|
||||
${partidas || "(ninguna)"}
|
||||
|
||||
---
|
||||
|
||||
Redacta la propuesta y llama a registrar_propuesta.
|
||||
|
||||
Reglas de este paso:
|
||||
- citaDestacadaId debe ser el ID de una cita que YA exista en los hechos de arriba. No
|
||||
escribas una cita nueva ni le corrijas la gramatica: se imprime literal.
|
||||
- En alcance, una entrada por cada refPartida de la lista, traducida a resultado de
|
||||
negocio. No menciones importes ni plazos de pago: el sistema los inyecta.
|
||||
- Cada beneficio apunta al hallazgoId que resuelve. Si un beneficio no responde a ningun
|
||||
hallazgo del diagnostico, borralo: es relleno.
|
||||
- Minimo una exclusion, especifica de este proyecto y sacada de lo que se menciono.
|
||||
- El backlog es lo que quedo fuera y merece registrarse. Va con la etiqueta de que NO
|
||||
esta comprometido en esta propuesta.
|
||||
- notasInternas es lo unico que el cliente no vera. Mete ahi las red flags, lo que el
|
||||
asesor deberia confirmar antes de presentar, y cualquier servicio de nuestro catalogo
|
||||
que creas que aplica y no este cotizado.`;
|
||||
}
|
||||
@@ -0,0 +1,231 @@
|
||||
import { z } from "zod";
|
||||
|
||||
/**
|
||||
* Contrato con el modelo. MiniMax no soporta structured outputs, asi que estos
|
||||
* schemas viajan como `input_schema` de una herramienta y Zod valida la respuesta.
|
||||
*
|
||||
* REGLA ESTRUCTURAL: ningun schema de aqui contiene un campo de dinero DE E3.
|
||||
* El modelo devuelve `refPartida` y prosa; los precios, totales e IVA los inyecta
|
||||
* el codigo al renderizar. `montoAnualMXN` si existe, pero es lo que el problema
|
||||
* le cuesta AL CLIENTE cada ano — no un precio nuestro.
|
||||
*/
|
||||
|
||||
const REF_PARTIDA = /^P\d{2}$/;
|
||||
const ID_CITA = /^C\d{2}$/;
|
||||
const ID_HECHO = /^H\d{2}$/;
|
||||
const ID_HALLAZGO = /^D\d{2}$/;
|
||||
|
||||
export const CONFIANZA = ["confirmado", "estimado", "por_validar"] as const;
|
||||
export const URGENCIA = ["rojo", "ambar", "azul", "verde"] as const;
|
||||
export const DIMENSION_COSTO = ["dinero", "tiempo", "oportunidad", "error"] as const;
|
||||
|
||||
// ───────────────────── Paso 1: extraccion de hechos ─────────────────────
|
||||
export const hechosSchema = z
|
||||
.object({
|
||||
citas: z
|
||||
.array(
|
||||
z.object({
|
||||
id: z.string().regex(ID_CITA, "El id de cita debe ser C01, C02..."),
|
||||
textoLiteral: z
|
||||
.string()
|
||||
.min(10)
|
||||
.describe("Cita TEXTUAL del cliente, palabra por palabra. Nunca parafraseada ni corregida."),
|
||||
quienLoDijo: z
|
||||
.string()
|
||||
.describe("Rol del interlocutor comercial ('el socio', 'quien atiende el WhatsApp'). No nombres de empleados."),
|
||||
})
|
||||
)
|
||||
.max(30),
|
||||
hechos: z
|
||||
.array(
|
||||
z.object({
|
||||
id: z.string().regex(ID_HECHO, "El id de hecho debe ser H01, H02..."),
|
||||
enunciado: z.string().min(10),
|
||||
confianza: z.enum(CONFIANZA),
|
||||
citas: z.array(z.string().regex(ID_CITA)).describe("IDs de las citas que sostienen este hecho."),
|
||||
})
|
||||
)
|
||||
.max(40),
|
||||
materialesPendientes: z
|
||||
.array(z.object({ texto: z.string().min(3), bloqueaEntrega: z.boolean() }))
|
||||
.max(15),
|
||||
decisionesPendientes: z
|
||||
.array(z.object({ texto: z.string().min(3), quienDecide: z.string() }))
|
||||
.max(15),
|
||||
mencionesFueraDeAlcance: z.array(z.string().min(3)).max(15),
|
||||
redFlags: z
|
||||
.array(z.object({ senal: z.string().min(3), severidad: z.enum(["baja", "media", "alta"]) }))
|
||||
.max(10),
|
||||
})
|
||||
.strict();
|
||||
|
||||
// ─────────────── Paso 2: diagnostico y valoracion del problema ───────────────
|
||||
export const diagnosticoSchema = z
|
||||
.object({
|
||||
hallazgos: z
|
||||
.array(
|
||||
z.object({
|
||||
id: z.string().regex(ID_HALLAZGO, "El id de hallazgo debe ser D01, D02..."),
|
||||
urgencia: z
|
||||
.enum(URGENCIA)
|
||||
.describe("rojo=problema critico, ambar=area de mejora, azul=oportunidad, verde=ventaja que el cliente YA tiene"),
|
||||
// 140 y no 80: con 80 el modelo se pasaba y gastaba un reintento. Observado
|
||||
// en 2 de 6 corridas contra datos reales.
|
||||
titulo: z.string().min(3).max(140),
|
||||
descripcion: z.string().min(20),
|
||||
confianza: z.enum(CONFIANZA),
|
||||
citas: z.array(z.string().regex(ID_CITA)),
|
||||
hechos: z.array(z.string().regex(ID_HECHO)),
|
||||
})
|
||||
)
|
||||
.min(1)
|
||||
.max(12),
|
||||
valorProblema: z.object({
|
||||
dimensiones: z
|
||||
.array(
|
||||
z
|
||||
.object({
|
||||
tipo: z.enum(DIMENSION_COSTO),
|
||||
descripcion: z.string().min(10),
|
||||
// Antes esto vivia dentro de un objeto `calculo`. Se aplano porque ese
|
||||
// nivel extra no aportaba nada semantico y era donde el modelo se perdia:
|
||||
// devolvia {item: {...}, notaMetodologia} y quemaba reintentos. Observado
|
||||
// en 3 de 6 corridas contra datos reales.
|
||||
//
|
||||
// Sin min(2) fijo: exigir dos factores cuando no hay cifra obliga al
|
||||
// modelo a inventar relleno. La exigencia se aplica solo si hay monto.
|
||||
factores: z
|
||||
.array(
|
||||
z.object({
|
||||
nombre: z.string(),
|
||||
valor: z.number(),
|
||||
// Sin este campo el modelo metia la incertidumbre dentro del nombre
|
||||
// ("tasa_conversion (por_validar)=0.1"). Mejor dato que convencion.
|
||||
confianza: z.enum(CONFIANZA),
|
||||
})
|
||||
)
|
||||
.max(6),
|
||||
// .default(null) y no solo .nullable(): verificado contra la API real que
|
||||
// el modelo OMITE el campo en vez de mandar null, que es lo natural para
|
||||
// un LLM. Exigirlo presente quemaba los tres intentos.
|
||||
montoAnualMXN: z
|
||||
.number()
|
||||
.nullable()
|
||||
.default(null)
|
||||
.describe("Costo ANUAL del problema DEL CLIENTE. No es un precio de E3. Omitelo si no hay cifras."),
|
||||
confianza: z.enum(CONFIANZA),
|
||||
hechos: z.array(z.string().regex(ID_HECHO)),
|
||||
})
|
||||
.superRefine((d, ctx) => {
|
||||
if (d.montoAnualMXN !== null && d.factores.length < 2) {
|
||||
ctx.addIssue({
|
||||
code: "custom",
|
||||
path: ["factores"],
|
||||
message: "Si declaras montoAnualMXN, muestra al menos 2 factores que lo expliquen.",
|
||||
});
|
||||
}
|
||||
})
|
||||
)
|
||||
.max(4),
|
||||
notaMetodologia: z.string().describe("Como se llego a las cifras, en una o dos frases."),
|
||||
}),
|
||||
resultados: z
|
||||
.array(
|
||||
z.object({
|
||||
enunciado: z.string().min(15),
|
||||
metrica: z.string(),
|
||||
lineaBase: z.string().nullable(),
|
||||
periodoMedicion: z.string(),
|
||||
})
|
||||
)
|
||||
.max(5),
|
||||
})
|
||||
.strict();
|
||||
|
||||
// ───────────────────────── Paso 3: redaccion final ─────────────────────────
|
||||
export const redaccionSchema = z
|
||||
.object({
|
||||
hero: z.object({
|
||||
titulo: z.string().min(5).max(90),
|
||||
subtitulo: z.string().min(20).max(400),
|
||||
}),
|
||||
citaDestacadaId: z
|
||||
.string()
|
||||
.regex(ID_CITA)
|
||||
.describe("ID de una cita YA extraida en el paso 1. Se imprime literal; no la reescribas."),
|
||||
alcance: z
|
||||
.array(
|
||||
z.object({
|
||||
refPartida: z.string().regex(REF_PARTIDA, "Debe ser P01, P02..."),
|
||||
descripcionResultado: z
|
||||
.string()
|
||||
.min(20)
|
||||
.describe("La partida traducida a resultado de negocio. Sin jerga tecnica y SIN mencionar importes."),
|
||||
})
|
||||
)
|
||||
// 120 y no 40: una cotizacion real (UJ2606UR001) tiene 58 partidas, asi que el
|
||||
// tope de 40 garantizaba un rechazo de Zod y un reintento desperdiciado en cada
|
||||
// corrida. Observado en 6 de 6. El tope solo esta para acotar una respuesta
|
||||
// desbocada; la completitud del documento ya no depende de este array, porque el
|
||||
// generador recorre las partidas de la cotizacion.
|
||||
.max(120),
|
||||
beneficios: z
|
||||
.array(
|
||||
z.object({
|
||||
// 70 y no 40: se pasaba en 2 de 3 vueltas contra datos reales.
|
||||
etiqueta: z.string().min(3).max(70),
|
||||
texto: z.string().min(20),
|
||||
hallazgoId: z
|
||||
.string()
|
||||
.regex(ID_HALLAZGO)
|
||||
.describe("El hallazgo que este beneficio resuelve. Si no responde a ninguno, no lo incluyas."),
|
||||
})
|
||||
)
|
||||
.max(8),
|
||||
exclusiones: z
|
||||
.array(
|
||||
z.object({
|
||||
texto: z.string().min(15).describe("Especifica de ESTE proyecto, nunca generica."),
|
||||
razon: z.string().min(5),
|
||||
})
|
||||
)
|
||||
.min(1)
|
||||
.max(10),
|
||||
backlogEvolucion: z
|
||||
.array(z.object({ problema: z.string().min(10), momentoSugerido: z.string() }))
|
||||
.max(8),
|
||||
notasInternas: z
|
||||
.array(z.string().min(5))
|
||||
.max(10)
|
||||
.describe("SOLO para el asesor. Nunca se imprime en el documento del cliente."),
|
||||
})
|
||||
.strict();
|
||||
|
||||
export type Hechos = z.infer<typeof hechosSchema>;
|
||||
export type Diagnostico = z.infer<typeof diagnosticoSchema>;
|
||||
export type Redaccion = z.infer<typeof redaccionSchema>;
|
||||
|
||||
/** El objeto completo que se persiste, se edita y se renderiza. */
|
||||
export interface PropuestaConsultiva {
|
||||
hechos: Hechos;
|
||||
diagnostico: Diagnostico;
|
||||
redaccion: Redaccion;
|
||||
}
|
||||
|
||||
/** Schema del objeto completo, para validar lo que el asesor edita a mano. */
|
||||
export const propuestaCompletaSchema = z.object({
|
||||
hechos: hechosSchema,
|
||||
diagnostico: diagnosticoSchema,
|
||||
redaccion: redaccionSchema,
|
||||
});
|
||||
|
||||
/**
|
||||
* Zod -> JSON Schema para el `input_schema` de la herramienta.
|
||||
* zod 4.3.6 trae `z.toJSONSchema` nativo: no hace falta `zod-to-json-schema`.
|
||||
* Se borra `$schema` porque el endpoint no lo espera.
|
||||
*/
|
||||
export function aJsonSchema(schema: z.ZodType): Record<string, unknown> {
|
||||
const js = z.toJSONSchema(schema, { io: "input" }) as Record<string, unknown>;
|
||||
delete js.$schema;
|
||||
return js;
|
||||
}
|
||||
@@ -0,0 +1,252 @@
|
||||
import type { PropuestaConsultiva } from "./schemas";
|
||||
import type { DatosEconomicos } from "./economia";
|
||||
|
||||
/**
|
||||
* Validacion post-generacion. Corre en codigo, nunca en la IA.
|
||||
*
|
||||
* R0 existe porque ninguna otra regla la cubre: las notas internas del asesor son una
|
||||
* ENTRADA que el modelo recibe en el prompt y puede copiar literalmente en cualquier
|
||||
* campo de prosa. Comparar el bloque interno que produjo el modelo contra la salida
|
||||
* no detecta eso.
|
||||
*/
|
||||
|
||||
export interface Aviso {
|
||||
regla: string;
|
||||
severidad: "bloqueante" | "advertencia";
|
||||
mensaje: string;
|
||||
ruta?: string;
|
||||
}
|
||||
|
||||
/** Normaliza para comparar citas contra las fuentes: sin acentos, en minusculas, sin
|
||||
* puntuacion y con espacios colapsados. Laxa a proposito, para sobrevivir al ruido de
|
||||
* transcripcion automatica sin volverse inutil. */
|
||||
export function normalizar(s: string): string {
|
||||
return s
|
||||
.normalize("NFD")
|
||||
.replace(/[̀-ͯ]/g, "")
|
||||
.toLowerCase()
|
||||
.replace(/[^\p{L}\p{N}\s]/gu, " ")
|
||||
.replace(/\s+/g, " ")
|
||||
.trim();
|
||||
}
|
||||
|
||||
const OTRO_CRM = /\b(hubspot|salesforce|pipedrive|zoho|go\s*high\s*level|gohighlevel|clientify|kommo|monday\s*crm)\b/i;
|
||||
const PROMESA_GARANTIA = /\bgarantiza(mos|do|da|r|remos)?\b|\baseguramos\s+(ventas|resultados|posici)/i;
|
||||
const MONTO_USD = /\b(usd|d[oó]lares|dlls?)\b|\$\s*[\d,.]+\s*(usd|dls)\b/i;
|
||||
const TEMA_SENSIBLE = /\b(sueldo|salario|n[oó]mina|despido|demanda laboral|incapacidad|embarazo|enfermedad)\b/i;
|
||||
|
||||
/**
|
||||
* TODO el texto que termina impreso en el documento del cliente.
|
||||
*
|
||||
* Esta lista tiene que cubrir exactamente lo que dibuja `generarPropuestaPDF`. Es la
|
||||
* unica fuente de los filtros de marca, moneda, garantias y PII: un campo que se
|
||||
* imprime y no esta aqui llega al cliente sin que nadie lo mire.
|
||||
*
|
||||
* Faltaban seis, todos impresos: el texto y el autor de la cita destacada, la metrica
|
||||
* y el periodo de cada resultado, quien decide cada pendiente, y el momento sugerido
|
||||
* del backlog. Si agregas algo al PDF, agregalo aqui en el mismo cambio.
|
||||
*/
|
||||
export function textoVisible(p: PropuestaConsultiva): { ruta: string; texto: string }[] {
|
||||
const out: { ruta: string; texto: string }[] = [
|
||||
{ ruta: "hero.titulo", texto: p.redaccion.hero.titulo },
|
||||
{ ruta: "hero.subtitulo", texto: p.redaccion.hero.subtitulo },
|
||||
{ ruta: "valorProblema.notaMetodologia", texto: p.diagnostico.valorProblema.notaMetodologia },
|
||||
];
|
||||
// La cita destacada se imprime literal, con su autor (pdf.ts, seccion Diagnostico).
|
||||
const destacada = p.hechos.citas.find((c) => c.id === p.redaccion.citaDestacadaId);
|
||||
if (destacada) {
|
||||
out.push({ ruta: `citas.${destacada.id}.textoLiteral`, texto: destacada.textoLiteral });
|
||||
out.push({ ruta: `citas.${destacada.id}.quienLoDijo`, texto: destacada.quienLoDijo });
|
||||
}
|
||||
p.diagnostico.hallazgos.forEach((h, i) => {
|
||||
out.push({ ruta: `hallazgos[${i}].titulo`, texto: h.titulo });
|
||||
out.push({ ruta: `hallazgos[${i}].descripcion`, texto: h.descripcion });
|
||||
});
|
||||
p.diagnostico.valorProblema.dimensiones.forEach((d, i) =>
|
||||
out.push({ ruta: `valorProblema.dimensiones[${i}]`, texto: d.descripcion })
|
||||
);
|
||||
p.diagnostico.resultados.forEach((r, i) => {
|
||||
out.push({ ruta: `resultados[${i}].enunciado`, texto: r.enunciado });
|
||||
out.push({ ruta: `resultados[${i}].metrica`, texto: r.metrica });
|
||||
out.push({ ruta: `resultados[${i}].periodoMedicion`, texto: r.periodoMedicion });
|
||||
});
|
||||
p.redaccion.alcance.forEach((a, i) => out.push({ ruta: `alcance[${i}]`, texto: a.descripcionResultado }));
|
||||
p.redaccion.beneficios.forEach((b, i) =>
|
||||
out.push({ ruta: `beneficios[${i}]`, texto: `${b.etiqueta} ${b.texto}` })
|
||||
);
|
||||
p.redaccion.exclusiones.forEach((e, i) => out.push({ ruta: `exclusiones[${i}]`, texto: e.texto }));
|
||||
p.redaccion.backlogEvolucion.forEach((b, i) => {
|
||||
out.push({ ruta: `backlog[${i}].problema`, texto: b.problema });
|
||||
out.push({ ruta: `backlog[${i}].momentoSugerido`, texto: b.momentoSugerido });
|
||||
});
|
||||
p.hechos.materialesPendientes.forEach((m, i) => out.push({ ruta: `materiales[${i}]`, texto: m.texto }));
|
||||
p.hechos.decisionesPendientes.forEach((d, i) => {
|
||||
out.push({ ruta: `decisiones[${i}].texto`, texto: d.texto });
|
||||
out.push({ ruta: `decisiones[${i}].quienDecide`, texto: d.quienDecide });
|
||||
});
|
||||
return out;
|
||||
}
|
||||
|
||||
function ngramas(texto: string, n: number): Set<string> {
|
||||
const palabras = normalizar(texto).split(" ").filter(Boolean);
|
||||
const out = new Set<string>();
|
||||
for (let i = 0; i + n <= palabras.length; i++) out.add(palabras.slice(i, i + n).join(" "));
|
||||
return out;
|
||||
}
|
||||
|
||||
export function validarPropuesta(
|
||||
p: PropuestaConsultiva,
|
||||
econ: DatosEconomicos,
|
||||
fuentes: { textoCliente: string; textoInterno: string }
|
||||
): Aviso[] {
|
||||
const avisos: Aviso[] = [];
|
||||
const visible = textoVisible(p);
|
||||
|
||||
// ── R0 (bloqueante): el texto interno del asesor no puede aparecer en el documento
|
||||
// del cliente. Es entrada, no salida; ninguna otra regla lo mira.
|
||||
if (fuentes.textoInterno.trim()) {
|
||||
const internos = ngramas(fuentes.textoInterno, 7);
|
||||
if (internos.size) {
|
||||
for (const { ruta, texto } of visible) {
|
||||
for (const g of ngramas(texto, 7)) {
|
||||
if (internos.has(g)) {
|
||||
avisos.push({
|
||||
regla: "R0",
|
||||
severidad: "bloqueante",
|
||||
ruta,
|
||||
mensaje: `Texto de las notas internas aparece en el documento del cliente: "${g}"`,
|
||||
});
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ── R2 (bloqueante): ninguna partida inventada.
|
||||
const refsReales = new Set(econ.partidas.map((x) => x.refPartida));
|
||||
for (const a of p.redaccion.alcance) {
|
||||
if (!refsReales.has(a.refPartida)) {
|
||||
avisos.push({
|
||||
regla: "R2",
|
||||
severidad: "bloqueante",
|
||||
ruta: `alcance ${a.refPartida}`,
|
||||
mensaje: `La partida ${a.refPartida} no existe en la cotizacion.`,
|
||||
});
|
||||
}
|
||||
}
|
||||
// Advertencia si el modelo se salto partidas reales.
|
||||
const refsUsadas = new Set(p.redaccion.alcance.map((a) => a.refPartida));
|
||||
for (const real of econ.partidas) {
|
||||
if (!refsUsadas.has(real.refPartida)) {
|
||||
avisos.push({
|
||||
regla: "R2b",
|
||||
severidad: "advertencia",
|
||||
ruta: real.refPartida,
|
||||
mensaje: `La partida "${real.nombre}" (${real.refPartida}) esta cotizada pero no aparece descrita.`,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// ── R3 (bloqueante): la cita destacada existe y es literal.
|
||||
const cita = p.hechos.citas.find((c) => c.id === p.redaccion.citaDestacadaId);
|
||||
if (!cita) {
|
||||
avisos.push({
|
||||
regla: "R3",
|
||||
severidad: "bloqueante",
|
||||
mensaje: `citaDestacadaId ${p.redaccion.citaDestacadaId} no corresponde a ninguna cita extraida.`,
|
||||
});
|
||||
} else if (fuentes.textoCliente.trim()) {
|
||||
if (!normalizar(fuentes.textoCliente).includes(normalizar(cita.textoLiteral))) {
|
||||
avisos.push({
|
||||
regla: "R3",
|
||||
severidad: "bloqueante",
|
||||
ruta: cita.id,
|
||||
mensaje: `La cita destacada no aparece literal en las fuentes: "${cita.textoLiteral.slice(0, 70)}..."`,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// ── R4 (advertencia): un hallazgo "confirmado" necesita respaldo.
|
||||
p.diagnostico.hallazgos.forEach((h, i) => {
|
||||
if (h.confianza === "confirmado" && h.citas.length + h.hechos.length === 0) {
|
||||
avisos.push({
|
||||
regla: "R4",
|
||||
severidad: "advertencia",
|
||||
ruta: `hallazgos[${i}]`,
|
||||
mensaje: `"${h.titulo}" se declara confirmado sin citas ni hechos. Deberia ser por_validar.`,
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
// ── R5 (bloqueante): la aritmetica del valor tiene que cuadrar.
|
||||
p.diagnostico.valorProblema.dimensiones.forEach((d, i) => {
|
||||
const m = d.montoAnualMXN;
|
||||
if (m === null) return;
|
||||
const producto = d.factores.reduce((a, f) => a * f.valor, 1);
|
||||
const suma = d.factores.reduce((a, f) => a + f.valor, 0);
|
||||
const base = Math.max(Math.abs(m), 1);
|
||||
const cuadra = Math.abs(producto - m) / base < 0.02 || Math.abs(suma - m) / base < 0.02;
|
||||
if (!cuadra) {
|
||||
avisos.push({
|
||||
regla: "R5",
|
||||
severidad: "bloqueante",
|
||||
ruta: `valorProblema.dimensiones[${i}]`,
|
||||
mensaje: `montoAnualMXN ${m} no cuadra con sus factores (producto ${producto}, suma ${suma}).`,
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
// ── R5b (advertencia): el valor anual manda sobre el ratio precio/valor, y ese ratio
|
||||
// es el que te dice si subcotizaste. Una cifra que descansa solo en factores
|
||||
// estimados puede estar inflada un orden de magnitud sin que R5 lo note: R5 verifica
|
||||
// que los factores multipliquen al monto, no que no FALTE un factor.
|
||||
// Observado contra la API real: el modelo produjo 3,120,000 omitiendo la tasa de
|
||||
// conversion (asumio que cada mensaje sin contestar era un cliente perdido), y la
|
||||
// aritmetica cuadraba. El ratio habria dicho "subcotizado" por un factor de 10.
|
||||
p.diagnostico.valorProblema.dimensiones.forEach((d, i) => {
|
||||
if (d.montoAnualMXN === null) return;
|
||||
const confirmados = d.factores.filter((f) => f.confianza === "confirmado").length;
|
||||
if (confirmados === 0) {
|
||||
avisos.push({
|
||||
regla: "R5b",
|
||||
severidad: "advertencia",
|
||||
ruta: `valorProblema.dimensiones[${i}]`,
|
||||
mensaje:
|
||||
`La cifra de ${d.montoAnualMXN} no tiene ni un factor confirmado: descansa entera en estimaciones. ` +
|
||||
`Revisa el desglose antes de fiarte del ratio precio/valor.`,
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
// ── R6 (advertencia): referencias colgantes entre pasos.
|
||||
const idsHallazgo = new Set(p.diagnostico.hallazgos.map((h) => h.id));
|
||||
p.redaccion.beneficios.forEach((b, i) => {
|
||||
if (!idsHallazgo.has(b.hallazgoId)) {
|
||||
avisos.push({
|
||||
regla: "R6",
|
||||
severidad: "advertencia",
|
||||
ruta: `beneficios[${i}]`,
|
||||
mensaje: `El beneficio apunta al hallazgo ${b.hallazgoId}, que no existe.`,
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
// ── Filtro de contenido sobre lo visible ──
|
||||
for (const { ruta, texto } of visible) {
|
||||
if (OTRO_CRM.test(texto))
|
||||
avisos.push({ regla: "MARCA", severidad: "bloqueante", ruta, mensaje: "Menciona un CRM que no es Bucefalo." });
|
||||
if (MONTO_USD.test(texto))
|
||||
avisos.push({ regla: "MONEDA", severidad: "bloqueante", ruta, mensaje: "Contiene un monto o referencia en USD." });
|
||||
if (PROMESA_GARANTIA.test(texto))
|
||||
avisos.push({ regla: "GARANTIA", severidad: "bloqueante", ruta, mensaje: "Promete un resultado garantizado." });
|
||||
if (TEMA_SENSIBLE.test(texto))
|
||||
avisos.push({ regla: "PII", severidad: "advertencia", ruta, mensaje: "Menciona un tema laboral, salarial o de salud. Revisalo antes de enviar." });
|
||||
}
|
||||
|
||||
return avisos;
|
||||
}
|
||||
|
||||
export function hayBloqueantes(avisos: Aviso[]): boolean {
|
||||
return avisos.some((a) => a.severidad === "bloqueante");
|
||||
}
|
||||
@@ -43,6 +43,7 @@ export const cotizacionPostSchema = z.object({
|
||||
esDoble: z.boolean().optional(),
|
||||
opciones: opcionesSchema,
|
||||
observaciones: z.string(),
|
||||
observacionesInternas: z.string().optional(),
|
||||
asesorId: z.string().min(1),
|
||||
cliente: z.object({
|
||||
nombre: z.string().min(1, "Cliente nombre es requerido"),
|
||||
@@ -73,6 +74,7 @@ export const cotizacionPutSchema = z.object({
|
||||
esDoble: z.boolean().optional(),
|
||||
opciones: opcionesSchema,
|
||||
observaciones: z.string(),
|
||||
observacionesInternas: z.string().optional(),
|
||||
cliente: z.object({
|
||||
nombre: z.string().min(1, "Cliente nombre es requerido"),
|
||||
empresa: z.string(),
|
||||
|
||||
@@ -42,6 +42,7 @@ export interface CotizacionDraft {
|
||||
planBucefaloNivel: string | null;
|
||||
servicios: ServicioSeleccionado[];
|
||||
observaciones: string;
|
||||
observacionesInternas: string;
|
||||
// Doble propuesta: dos opciones comparables dentro de una misma cotizacion.
|
||||
esDoble: boolean;
|
||||
opciones: { "1"?: MetaOpcion; "2"?: MetaOpcion };
|
||||
@@ -79,6 +80,7 @@ const initialDraft: CotizacionDraft = {
|
||||
planBucefaloNivel: null,
|
||||
servicios: [],
|
||||
observaciones: "",
|
||||
observacionesInternas: "",
|
||||
esDoble: false,
|
||||
opciones: {},
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user