import { encode, decode } from '@slim-format/core'

const data = {
  products: [
    { id: 1, name: 'Burger', price: 8500 },
    { id: 2, name: 'Salad', price: 6200 },
  ],
  sales: { total: 1250000, tickets: 87 },
}

// JSON -> SLIM
const slim = encode(data)
// products[2]{id,name,price}:
//   - 1, Burger, 8500
//   - 2, Salad, 6200
// sales:
//   total: 1250000
//   tickets: 87

// SLIM -> JSON
const restored = decode(slim)
// Lossless round-trip: restored === data

const slim = encode(data, {
  directives: {
    context: { tenant: 'store_alpha', env: 'prod' },
    budget: { tokens: 2000 },
    priority: { high: 'sales', low: 'history' },
  },
})
// @context tenant=store_alpha env=prod
// @budget tokens=2000
// @priority high=sales low=history
//
// products[2]{id,name,price}:
//   - 1, Burger, 8500
//   ...

import { SlimTemplate } from '@slim-format/core'

const template = SlimTemplate.define(`
@template sales-analysis
@model claude-sonnet
@budget tokens=4000

# Rol
Sos un analista de negocio retail.

# Datos de ventas
{{data:sales | priority=high}}

# Catalogo actual
{{data:products | priority=medium}}

# Pregunta
{{input:query}}
`)

const prompt = template.render({
  data: { sales: salesData, products: productsData },
  input: { query: 'Cual fue el producto mas rentable hoy?' },
})

prompt.text       // String listo para enviar al LLM
prompt.tokenCount // Tokens estimados
prompt.truncated  // Que se trunco por budget y por que

import { SlimSchema, slimParse, slimParseWithRetry } from '@slim-format/core'

const schema = SlimSchema.define({
  top_product: { type: 'string', required: true },
  amount: { type: 'number', required: true },
  recommendations: { type: 'array', items: { type: 'string' }, maxItems: 5 },
})

// Modo strict
const result = slimParse(llmResponse, schema, 'strict')
if (result.ok) {
  console.log(result.data) // Tipado
}

// Con retry automatico via LLM
const result = await slimParseWithRetry(llmResponse, schema, {
  llm: claudeClient,
  maxRetries: 2,
  strategy: 'correct', // Reenvia errores al LLM para que corrija
  includeErrors: true,
})

import Anthropic from '@anthropic-ai/sdk'
import { encode } from '@slim-format/core'

const client = new Anthropic()

const sales = await fetchSales() // Tu data
const slimPayload = encode(sales, {
  directives: { context: { tenant: 'store_alpha', date: '2026-04-07' } },
})

const response = await client.messages.create({
  model: 'claude-sonnet-4-20250514',
  max_tokens: 1024,
  messages: [
    {
      role: 'user',
      content: `Analiza estas ventas y dame el producto mas rentable:\n\n${slimPayload}`,
    },
  ],
})

import { GoogleGenerativeAI } from '@google/generative-ai'
import { encode, decode } from '@slim-format/core'

const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY!)
const model = genAI.getGenerativeModel({ model: 'gemini-2.5-flash' })

// Encodear data de inventario a SLIM antes de enviarla
const inventory = [
  { sku: 'WDG-001', product: 'Widget Standard', quantity: 45, minimum: 20 },
  { sku: 'GAD-003', product: 'Gadget Pro', quantity: 12, minimum: 15 },
  { sku: 'ACC-002', product: 'Accessory Pack', quantity: 8, minimum: 25 },
]

const slimData = encode({ inventory })
// inventory[3]{sku,product,quantity,minimum}:
//   - WDG-001, Widget Standard, 45, 20
//   - GAD-003, Gadget Pro, 12, 15
//   - ACC-002, Accessory Pack, 8, 25

const result = await model.generateContent(
  `Dado este inventario, que productos necesitan reposicion urgente?\n\n${slimData}`
)
console.log(result.response.text())
// "Accessory Pack (8 unidades, minimo 25) necesita reposicion urgente.
//  Gadget Pro (12 unidades, minimo 15) esta proximo al limite."

import { SlimTemplate } from '@slim-format/core'

const template = SlimTemplate.define(`
@template inventory-restock
@model gemini-2.5-flash
@budget tokens=2000

# Rol
Sos un gestor de inventario para una tienda retail.

# Stock actual
{{data:inventory | priority=high}}

# Historial de consumo
{{data:history | priority=low}}

# Instruccion
{{input:query}}
`)

const prompt = template.render({
  data: { inventory: inventoryData, history: historyData },
  input: { query: 'Genera una orden de compra para los proximos 3 dias' },
})

// Si el prompt excede 2000 tokens, SLIM trunca "history" (priority=low) primero
const result = await model.generateContent(prompt.text)

import OpenAI from 'openai'
import { encode } from '@slim-format/core'

const openai = new OpenAI()
const slimData = encode(orders) // Cualquier data estructurada

const completion = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [
    { role: 'system', content: 'Responde en espanol. Los datos vienen en formato SLIM.' },
    { role: 'user', content: `Resumi los pedidos del dia:\n\n${slimData}` },
  ],
})