@zenti/sdk 0.1.0

package/.gitattributes

@@ -0,0 +1,6 @@
+* text=auto eol=lf
+*.ts text eol=lf
+*.json text eol=lf
+*.yaml text eol=lf
+*.zenti text eol=lf
+*.md text eol=lf

package/README.md

@@ -0,0 +1,211 @@
+# @zenti/sdk
+
+[![npm version](https://img.shields.io/npm/v/@zenti/sdk.svg)](https://www.npmjs.com/package/@zenti/sdk)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+SDK open source en TypeScript para capturar, almacenar y deployar personalidades de agentes IA de forma portable entre modelos — GPT, Claude, Gemini, Llama.
+
+Define tu agente **una vez** en un archivo `.zenti` y despliégalo en cualquier LLM sin reescribir el system prompt.
+
+---
+
+## Instalación
+
+```bash
+# npm
+npm install @zenti/sdk
+
+# yarn
+yarn add @zenti/sdk
+
+# Global (para el CLI)
+npm install -g @zenti/sdk
+```
+
+---
+
+## Uso básico
+
+```typescript
+import { PersonaLayer } from '@zenti/sdk';
+
+const persona = PersonaLayer.load('./sofia.zenti');
+
+// Despliega en Claude
+const { system } = persona.deploy('claude');
+
+// Despliega en OpenAI
+const { system: openaiSystem, messages } = persona.deploy('openai');
+
+// Despliega en Gemini
+const { systemInstruction, contents } = persona.deploy('gemini');
+```
+
+---
+
+## Formato `.zenti`
+
+El archivo de personalidad usa YAML con 4 capas obligatorias:
+
+```yaml
+version: "1.0"
+name: "Sofia"
+
+# Capa 1 — Núcleo psicológico (Big Five, valores 0.0 a 1.0)
+core:
+  openness: 0.7           # Creatividad y apertura a nuevas ideas
+  conscientiousness: 0.9  # Meticulosidad y organización
+  extraversion: 0.4       # Sociabilidad (< 0.5 = reservado)
+  agreeableness: 0.8      # Empatía y cooperación
+  neuroticism: 0.2        # Estabilidad emocional (0 = muy estable)
+
+# Capa 2 — Identidad narrativa
+identity:
+  role: "Asistente de soporte de TechCorp"
+  backstory: "Experta técnica con 5 años de experiencia, paciente y directa"
+  communication_style: "profesional con calidez, respuestas concisas"
+
+# Capa 3 — Few-shot examples
+examples:
+  on_brand:
+    - user: "no funciona"
+      agent: "Entiendo tu frustración. Cuéntame qué error ves."
+  off_brand:
+    - user: "no funciona"
+      agent: "No sé, prueba reiniciando."
+
+# Capa 4 — Guardrails
+guardrails:
+  always:
+    - "Reconocer el problema antes de dar solución"
+  never:
+    - "Decir 'no puedo' sin ofrecer alternativa"
+  escalate_if:
+    - "El usuario menciona cancelación"
+```
+
+### Referencia de campos
+
+| Campo | Tipo | Descripción |
+|-------|------|-------------|
+| `version` | `string` | Versión del formato (actualmente `"1.0"`) |
+| `name` | `string` | Nombre del agente |
+| `core.*` | `number` | Valores Big Five entre `0.0` y `1.0` |
+| `identity.role` | `string` | Título o función del agente |
+| `identity.backstory` | `string` | Perfil y experiencia del agente |
+| `identity.communication_style` | `string` | Cómo se expresa el agente |
+| `examples.on_brand` | `array` | Ejemplos de respuestas correctas |
+| `examples.off_brand` | `array` | Ejemplos de respuestas a evitar |
+| `guardrails.always` | `array` | Reglas que siempre deben cumplirse |
+| `guardrails.never` | `array` | Comportamientos prohibidos |
+| `guardrails.escalate_if` | `array` | Condiciones que activan escalación |
+
+### Traducción Big Five → lenguaje natural
+
+El compilador traduce automáticamente los valores numéricos a descriptores en el system prompt:
+
+| Condición | Descripción generada |
+|-----------|---------------------|
+| `openness > 0.6` | creativo y curioso, abierto a explorar soluciones nuevas |
+| `conscientiousness > 0.7` | metódico y confiable, siempre sigue los pasos correctos |
+| `extraversion < 0.5` | reservado pero atento, responde con precisión sin ser efusivo |
+| `agreeableness > 0.7` | empático y colaborativo, prioriza la satisfacción del usuario |
+| `neuroticism < 0.3` | calmado bajo presión, mantiene tono estable ante usuarios frustrados |
+
+---
+
+## CLI
+
+### `zenti init`
+Crea un archivo `persona.zenti` con template vacío en el directorio actual.
+
+```bash
+zenti init
+zenti init --output ./agents/mi-agente.zenti
+```
+
+### `zenti validate [archivo]`
+Parsea y valida un archivo `.zenti`, mostrando errores o confirmación.
+
+```bash
+zenti validate
+zenti validate ./sofia.zenti
+```
+
+### `zenti test`
+Carga el `.zenti` del directorio actual y abre un chat interactivo en la terminal usando Claude.
+
+```bash
+zenti test
+zenti test --file ./sofia.zenti
+zenti test --key sk-ant-...
+# O establece ANTHROPIC_API_KEY en tu entorno
+```
+
+### `zenti diff <archivo1> <archivo2>`
+Compara dos archivos `.zenti` y muestra qué cambió entre versiones.
+
+```bash
+zenti diff sofia-v1.zenti sofia-v2.zenti
+```
+
+---
+
+## Uso programático avanzado
+
+```typescript
+import { PersonaLayer, toClaude, toOpenAI, toGemini, parseZenti } from '@zenti/sdk';
+
+// Desde un string YAML (útil para tests o almacenamiento en DB)
+const persona = PersonaLayer.fromString(yamlString);
+
+// Acceder al objeto de personalidad directamente
+const raw = persona.getPersona();
+console.log(raw.core.openness);
+
+// Compilar manualmente sin PersonaLayer
+import * as fs from 'fs';
+import { parseZenti } from '@zenti/sdk';
+
+const zentiData = parseZenti(fs.readFileSync('sofia.zenti', 'utf-8'));
+const claudePrompt = toClaude(zentiData);
+const openaiConfig = toOpenAI(zentiData);
+const geminiConfig = toGemini(zentiData);
+```
+
+---
+
+## Desarrollo
+
+```bash
+git clone https://github.com/tu-org/zenti-sdk.git
+cd zenti-sdk
+npm install
+npm run build   # Compila TypeScript
+npm test        # Ejecuta los tests
+npm run lint    # Type-check sin emitir archivos
+```
+
+---
+
+## Documentación
+
+Documentación completa en: [docs.zenti.dev](https://docs.zenti.dev) *(próximamente)*
+
+---
+
+## Contribuciones
+
+Las contribuciones son bienvenidas. Por favor abre un issue primero para discutir cambios mayores.
+
+1. Fork el repositorio
+2. Crea tu branch: `git checkout -b feature/mi-feature`
+3. Commit tus cambios: `git commit -m 'feat: agregar soporte para X'`
+4. Push: `git push origin feature/mi-feature`
+5. Abre un Pull Request
+
+---
+
+## Licencia
+
+MIT — ver [LICENSE](LICENSE) para más detalles.

package/dist/PersonaLayer.d.ts

@@ -0,0 +1,28 @@
+import { ZentiPersona } from './parser';
+import { ClaudeOutput } from './compiler/toClaude';
+import { OpenAIOutput } from './compiler/toOpenAI';
+import { GeminiOutput } from './compiler/toGemini';
+export type DeployTarget = 'claude' | 'openai' | 'gemini';
+export type DeployOutput<T extends DeployTarget> = T extends 'claude' ? ClaudeOutput : T extends 'openai' ? OpenAIOutput : GeminiOutput;
+export declare class PersonaLayer {
+    private readonly persona;
+    private constructor();
+    /**
+     * Loads and validates a .zenti file from disk.
+     */
+    static load(filePath: string): PersonaLayer;
+    /**
+     * Parses a .zenti file from a YAML string (useful for testing or in-memory use).
+     */
+    static fromString(yamlContent: string): PersonaLayer;
+    getPersona(): ZentiPersona;
+    getName(): string;
+    /**
+     * Compiles the persona into the target model's native format.
+     *
+     * @param target - 'claude' | 'openai' | 'gemini'
+     * @returns The compiled output ready to pass to the model's API
+     */
+    deploy<T extends DeployTarget>(target: T): DeployOutput<T>;
+}
+//# sourceMappingURL=PersonaLayer.d.ts.map

package/dist/PersonaLayer.js

@@ -0,0 +1,89 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersonaLayer = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const parser_1 = require("./parser");
+const toClaude_1 = require("./compiler/toClaude");
+const toOpenAI_1 = require("./compiler/toOpenAI");
+const toGemini_1 = require("./compiler/toGemini");
+class PersonaLayer {
+    constructor(persona) {
+        this.persona = persona;
+    }
+    /**
+     * Loads and validates a .zenti file from disk.
+     */
+    static load(filePath) {
+        const absolutePath = path.resolve(filePath);
+        const content = fs.readFileSync(absolutePath, 'utf-8');
+        const persona = (0, parser_1.parseZenti)(content);
+        return new PersonaLayer(persona);
+    }
+    /**
+     * Parses a .zenti file from a YAML string (useful for testing or in-memory use).
+     */
+    static fromString(yamlContent) {
+        const persona = (0, parser_1.parseZenti)(yamlContent);
+        return new PersonaLayer(persona);
+    }
+    getPersona() {
+        return this.persona;
+    }
+    getName() {
+        return this.persona.name;
+    }
+    /**
+     * Compiles the persona into the target model's native format.
+     *
+     * @param target - 'claude' | 'openai' | 'gemini'
+     * @returns The compiled output ready to pass to the model's API
+     */
+    deploy(target) {
+        switch (target) {
+            case 'claude':
+                return (0, toClaude_1.toClaude)(this.persona);
+            case 'openai':
+                return (0, toOpenAI_1.toOpenAI)(this.persona);
+            case 'gemini':
+                return (0, toGemini_1.toGemini)(this.persona);
+            default:
+                throw new Error(`Target desconocido: ${target}`);
+        }
+    }
+}
+exports.PersonaLayer = PersonaLayer;
+//# sourceMappingURL=PersonaLayer.js.map

package/dist/cli/commands/diff.d.ts

@@ -0,0 +1,2 @@
+export declare function diffCommand(file1: string, file2: string): void;
+//# sourceMappingURL=diff.d.ts.map

package/dist/cli/commands/diff.js

@@ -0,0 +1,129 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffCommand = diffCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const parser_1 = require("../../parser");
+function diffCommand(file1, file2) {
+    const path1 = path.resolve(file1);
+    const path2 = path.resolve(file2);
+    if (!fs.existsSync(path1)) {
+        console.error(`Error: No se encontró: ${path1}`);
+        process.exit(1);
+    }
+    if (!fs.existsSync(path2)) {
+        console.error(`Error: No se encontró: ${path2}`);
+        process.exit(1);
+    }
+    const p1 = (0, parser_1.parseZenti)(fs.readFileSync(path1, 'utf-8'));
+    const p2 = (0, parser_1.parseZenti)(fs.readFileSync(path2, 'utf-8'));
+    const changes = [];
+    // Top-level scalars
+    if (p1.name !== p2.name) {
+        changes.push(`  name: "${p1.name}" → "${p2.name}"`);
+    }
+    if (p1.version !== p2.version) {
+        changes.push(`  version: "${p1.version}" → "${p2.version}"`);
+    }
+    // Core (Big Five)
+    const coreKeys = [
+        'openness',
+        'conscientiousness',
+        'extraversion',
+        'agreeableness',
+        'neuroticism',
+    ];
+    coreKeys.forEach((key) => {
+        if (p1.core[key] !== p2.core[key]) {
+            changes.push(`  core.${key}: ${p1.core[key]} → ${p2.core[key]}`);
+        }
+    });
+    // Identity
+    const identityKeys = ['role', 'backstory', 'communication_style'];
+    identityKeys.forEach((key) => {
+        if (p1.identity[key] !== p2.identity[key]) {
+            changes.push(`  identity.${key}: "${p1.identity[key]}" → "${p2.identity[key]}"`);
+        }
+    });
+    // Guardrails (set diff)
+    const guardrailKeys = ['always', 'never', 'escalate_if'];
+    guardrailKeys.forEach((key) => {
+        const a1 = p1.guardrails[key];
+        const a2 = p2.guardrails[key];
+        a2
+            .filter((x) => !a1.includes(x))
+            .forEach((x) => changes.push(`  + guardrails.${key}: "${x}"`));
+        a1
+            .filter((x) => !a2.includes(x))
+            .forEach((x) => changes.push(`  - guardrails.${key}: "${x}"`));
+    });
+    // Examples (positional diff)
+    const exampleKeys = ['on_brand', 'off_brand'];
+    exampleKeys.forEach((key) => {
+        const ex1 = p1.examples[key];
+        const ex2 = p2.examples[key];
+        const maxLen = Math.max(ex1.length, ex2.length);
+        for (let i = 0; i < maxLen; i++) {
+            if (i >= ex1.length) {
+                changes.push(`  + examples.${key}[${i}]: { user: "${ex2[i].user}", agent: "${ex2[i].agent}" }`);
+            }
+            else if (i >= ex2.length) {
+                changes.push(`  - examples.${key}[${i}]: { user: "${ex1[i].user}", agent: "${ex1[i].agent}" }`);
+            }
+            else if (ex1[i].user !== ex2[i].user || ex1[i].agent !== ex2[i].agent) {
+                changes.push(`  ~ examples.${key}[${i}]:`);
+                if (ex1[i].user !== ex2[i].user) {
+                    changes.push(`      user:  "${ex1[i].user}" → "${ex2[i].user}"`);
+                }
+                if (ex1[i].agent !== ex2[i].agent) {
+                    changes.push(`      agent: "${ex1[i].agent}" → "${ex2[i].agent}"`);
+                }
+            }
+        }
+    });
+    // Output
+    console.log(`Comparando ${file1} → ${file2}`);
+    console.log('');
+    if (changes.length === 0) {
+        console.log('Sin diferencias — los archivos son idénticos en contenido.');
+    }
+    else {
+        console.log(`CAMBIOS (${changes.length} diferencias):`);
+        console.log('');
+        changes.forEach((c) => console.log(c));
+    }
+}
+//# sourceMappingURL=diff.js.map

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,4 @@
+export declare function initCommand(options: {
+    output?: string;
+}): void;
+//# sourceMappingURL=init.d.ts.map

package/dist/cli/commands/init.js

@@ -0,0 +1,88 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const TEMPLATE = `version: "1.0"
+name: "MiAgente"
+
+# ── Capa 1: Núcleo psicológico (Big Five, valores 0.0 a 1.0) ──────────────
+core:
+  openness: 0.5           # creatividad y apertura a nuevas ideas
+  conscientiousness: 0.5  # meticulosidad y organización
+  extraversion: 0.5       # sociabilidad y energía
+  agreeableness: 0.5      # empatía y cooperación
+  neuroticism: 0.5        # estabilidad emocional (0 = muy estable)
+
+# ── Capa 2: Identidad narrativa ───────────────────────────────────────────
+identity:
+  role: "Describe el rol de tu agente aquí"
+  backstory: "Describe el perfil y experiencia de tu agente"
+  communication_style: "Describe el estilo de comunicación"
+
+# ── Capa 3: Few-shot examples ─────────────────────────────────────────────
+examples:
+  on_brand:
+    - user: "Ejemplo de mensaje del usuario"
+      agent: "Ejemplo de respuesta correcta del agente"
+  off_brand:
+    - user: "Ejemplo de mensaje del usuario"
+      agent: "Ejemplo de respuesta incorrecta (para evitar)"
+
+# ── Capa 4: Guardrails ────────────────────────────────────────────────────
+guardrails:
+  always:
+    - "Siempre hacer esto"
+  never:
+    - "Nunca hacer esto"
+  escalate_if:
+    - "Condición que requiere escalar la conversación"
+`;
+function initCommand(options) {
+    const outputPath = path.resolve(options.output ?? path.join(process.cwd(), 'persona.zenti'));
+    if (fs.existsSync(outputPath)) {
+        console.error(`Error: El archivo ya existe: ${outputPath}`);
+        process.exit(1);
+    }
+    fs.writeFileSync(outputPath, TEMPLATE, 'utf-8');
+    console.log(`✓ Archivo creado: ${outputPath}`);
+    console.log('');
+    console.log('Próximos pasos:');
+    console.log('  1. Edita el archivo con la personalidad de tu agente');
+    console.log('  2. Valida con: zenti validate');
+    console.log('  3. Prueba en terminal con: zenti test');
+}
+//# sourceMappingURL=init.js.map

package/dist/cli/commands/test.d.ts

@@ -0,0 +1,5 @@
+export declare function testCommand(options: {
+    file?: string;
+    key?: string;
+}): Promise<void>;
+//# sourceMappingURL=test.d.ts.map

package/dist/cli/commands/test.js

@@ -0,0 +1,121 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testCommand = testCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const parser_1 = require("../../parser");
+const toClaude_1 = require("../../compiler/toClaude");
+const MODEL = 'claude-sonnet-4-6';
+function findZentiFile() {
+    const files = fs.readdirSync(process.cwd()).filter((f) => f.endsWith('.zenti'));
+    return files.length > 0 ? files[0] : null;
+}
+function question(rl, prompt) {
+    return new Promise((resolve) => rl.question(prompt, resolve));
+}
+async function testCommand(options) {
+    // ── Resolve .zenti file ──────────────────────────────────────────────────
+    const filePath = options.file ?? findZentiFile();
+    if (!filePath) {
+        console.error('Error: No se encontró ningún archivo .zenti en el directorio actual.');
+        console.error('Usa --file <ruta> para especificar uno manualmente.');
+        process.exit(1);
+    }
+    const resolved = path.resolve(filePath);
+    if (!fs.existsSync(resolved)) {
+        console.error(`Error: No se encontró el archivo: ${resolved}`);
+        process.exit(1);
+    }
+    // ── Load and compile persona ─────────────────────────────────────────────
+    const content = fs.readFileSync(resolved, 'utf-8');
+    const persona = (0, parser_1.parseZenti)(content);
+    const { system } = (0, toClaude_1.toClaude)(persona);
+    console.log(`\nPersonalidad cargada: ${persona.name}`);
+    console.log(`Rol: ${persona.identity.role}`);
+    console.log(`Modelo: ${MODEL}\n`);
+    // ── Resolve API key ──────────────────────────────────────────────────────
+    let apiKey = options.key ?? process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        apiKey = (await question(rl, 'ANTHROPIC_API_KEY: ')).trim();
+        rl.close();
+        if (!apiKey) {
+            console.error('Error: Se requiere una API key.');
+            process.exit(1);
+        }
+    }
+    const client = new sdk_1.default({ apiKey });
+    const messages = [];
+    console.log(`Chat con ${persona.name} iniciado. Escribe "exit" para salir.`);
+    console.log('─'.repeat(60));
+    // ── Interactive chat loop ────────────────────────────────────────────────
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const loop = async () => {
+        const input = (await question(rl, '\nTú: ')).trim();
+        if (input.toLowerCase() === 'exit' || input.toLowerCase() === 'quit') {
+            console.log('\n¡Hasta luego!');
+            rl.close();
+            return;
+        }
+        if (!input) {
+            return loop();
+        }
+        messages.push({ role: 'user', content: input });
+        try {
+            const response = await client.messages.create({
+                model: MODEL,
+                max_tokens: 1024,
+                system,
+                messages,
+            });
+            const assistantText = response.content[0].type === 'text' ? response.content[0].text : '';
+            messages.push({ role: 'assistant', content: assistantText });
+            console.log(`\n${persona.name}: ${assistantText}`);
+        }
+        catch (e) {
+            const msg = e.message;
+            console.error(`\nError al contactar la API: ${msg}`);
+        }
+        return loop();
+    };
+    await loop();
+}
+//# sourceMappingURL=test.js.map