@ai-pip/csl 0.1.0 → 0.1.3

package/package.json

@@ -1,38 +1,25 @@
 {
   "name": "@ai-pip/csl",
-  "version": "0.1.0",
-  "description": "SDK oficial para la capa de segmentación de contexto (CSL) del protocolo AI-PIP. Proporciona herramientas para clasificar, etiquetar y aislar contenido según origen, confiabilidad y riesgo operacional, protegiendo aplicaciones contra prompt injection y otros ataques de seguridad en LLM.",
+  "version": "0.1.3",
+  "description": "SDK oficial de la capa Context Segmentation Layer (CSL) del protocolo AI-PIP.",
   "type": "module",
-  "types": "./index.ts",
   "exports": {
     ".": {
-      "types": "./index.ts",
-      "import": "./index.ts"
+      "types": "./src/index.ts",
+      "import": "./src/index.ts"
     }
   },
   "files": [
-    "index.ts",
+    "src",
     "README.md",
-    "layers"
+    "package.json"
   ],
+  "dependencies": {
+    "@ai-pip/csl-layer": "0.0.0"
+  },
   "engines": {
     "node": ">=22.6.0"
   },
-  "keywords": [
-    "ai-pip",
-    "csl",
-    "context-segmentation",
-    "prompt-security",
-    "llm-security",
-    "prompt-injection",
-    "ai-safety",
-    "content-classification",
-    "trust-levels",
-    "anomaly-detection",
-    "typescript",
-    "browser-extension",
-    "ai-protocol"
-  ],
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -41,10 +28,5 @@
     "type": "git",
     "url": "https://github.com/MasliahDev99/AI-PIP.git",
     "directory": "src/sdk/csl"
-  },
-  "homepage": "https://github.com/MasliahDev99/AI-PIP",
-  "bugs": {
-    "url": "https://github.com/MasliahDev99/AI-PIP/issues"
-  },
-  "scripts": {}
+  }
 }

package/src/index.test.ts

@@ -0,0 +1,429 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import {
+  createCSLService,
+  CSLService,
+  type CreateCSLServiceOptions,
+  type LoggerPort,
+  type HashGeneratorPort,
+  type TimeStampProviderPort,
+  InMemoryPolicyRepository,
+  PolicyRule,
+  SegmentationError,
+} from './index'
+
+describe('@ai-pip/csl SDK', () => {
+  beforeEach(() => {
+    // Limpiar el body antes de cada test
+    document.body.innerHTML = ''
+  })
+
+  describe('createCSLService', () => {
+    it('debe crear un servicio con configuración por defecto', () => {
+      const service = createCSLService()
+      
+      expect(service).toBeInstanceOf(CSLService)
+    })
+
+    it('debe crear un servicio con configuración personalizada', () => {
+      const options: CreateCSLServiceOptions = {
+        enablePolicyValidation: false,
+        enableLineageTracking: false,
+        hashAlgorithm: 'sha512',
+      }
+
+      const service = createCSLService(options)
+      
+      expect(service).toBeInstanceOf(CSLService)
+    })
+
+    it('debe aceptar dependencias personalizadas', () => {
+      const customLogger: LoggerPort = {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      }
+
+      const customHashGenerator: HashGeneratorPort = {
+        generate: vi.fn().mockResolvedValue('mock-hash'),
+        compare: vi.fn().mockResolvedValue(true),
+        generateHMAC: vi.fn().mockResolvedValue('mock-hmac'),
+        compareHMAC: vi.fn().mockResolvedValue(true),
+      }
+
+      const customTimestampProvider: TimeStampProviderPort = {
+        now: vi.fn().mockReturnValue(1234567890),
+      }
+
+      const customPolicyRepository = new InMemoryPolicyRepository()
+
+      const service = createCSLService({
+        logger: customLogger,
+        hashGenerator: customHashGenerator,
+        timestampProvider: customTimestampProvider,
+        policyRepository: customPolicyRepository,
+      })
+
+      expect(service).toBeInstanceOf(CSLService)
+    })
+
+    it('debe usar implementaciones por defecto cuando no se proporcionan', () => {
+      const service = createCSLService()
+      
+      expect(service).toBeInstanceOf(CSLService)
+      // El servicio debe estar creado correctamente con todas las dependencias
+    })
+  })
+
+  describe('CSLService.segment', () => {
+    it('debe procesar un elemento DOM simple', async () => {
+      const body = document.body
+      
+      // Crear contenido simple
+      const div = document.createElement('div')
+      div.textContent = 'Hello, world!'
+      body.appendChild(div)
+
+      const service = createCSLService({
+        enablePolicyValidation: false,
+        enableLineageTracking: false,
+      })
+
+      const result = await service.segment(body)
+
+      expect(result).toBeDefined()
+      expect(result.segments).toBeDefined()
+      expect(Array.isArray(result.segments)).toBe(true)
+      expect(result.metadata).toBeDefined()
+      expect(result.metadata.total_segments).toBeGreaterThanOrEqual(0)
+    })
+
+    it('debe procesar múltiples segmentos', async () => {
+      const body = document.body
+      
+      // Crear múltiples elementos
+      const div1 = document.createElement('div')
+      div1.textContent = 'Primer segmento'
+      body.appendChild(div1)
+
+      const div2 = document.createElement('div')
+      div2.textContent = 'Segundo segmento'
+      body.appendChild(div2)
+
+      const service = createCSLService({
+        enablePolicyValidation: false,
+        enableLineageTracking: false,
+      })
+
+      const result = await service.segment(body)
+
+      expect(result.segments.length).toBeGreaterThanOrEqual(2)
+    })
+
+    it('debe retornar metadatos correctos', async () => {
+      const body = document.body
+      
+      const div = document.createElement('div')
+      div.textContent = 'Test content'
+      body.appendChild(div)
+
+      const service = createCSLService({
+        enablePolicyValidation: false,
+        enableLineageTracking: false,
+      })
+
+      const result = await service.segment(body)
+
+      expect(result.metadata).toHaveProperty('total_segments')
+      expect(result.metadata).toHaveProperty('trust_distribution')
+      expect(result.metadata).toHaveProperty('anomaly_score')
+      expect(result.metadata).toHaveProperty('blocked_segments')
+      expect(result.metadata).toHaveProperty('processing_time_ms')
+      expect(typeof result.metadata.processing_time_ms).toBe('number')
+    })
+
+    it('debe calcular la distribución de confianza correctamente', async () => {
+      const body = document.body
+      
+      const div = document.createElement('div')
+      div.textContent = 'Content for testing'
+      body.appendChild(div)
+
+      const service = createCSLService({
+        enablePolicyValidation: false,
+        enableLineageTracking: false,
+      })
+
+      const result = await service.segment(body)
+
+      expect(result.metadata.trust_distribution).toHaveProperty('TC')
+      expect(result.metadata.trust_distribution).toHaveProperty('STC')
+      expect(result.metadata.trust_distribution).toHaveProperty('UC')
+      expect(
+        result.metadata.trust_distribution.TC +
+        result.metadata.trust_distribution.STC +
+        result.metadata.trust_distribution.UC
+      ).toBe(result.metadata.total_segments)
+    })
+
+    it('debe manejar elementos vacíos', async () => {
+      const body = document.body
+      
+      // Body vacío
+
+      const service = createCSLService({
+        enablePolicyValidation: false,
+        enableLineageTracking: false,
+      })
+
+      const result = await service.segment(body)
+
+      expect(result.segments).toEqual([])
+      expect(result.metadata.total_segments).toBe(0)
+    })
+
+    it('debe procesar el documento completo', async () => {
+      const div = document.createElement('div')
+      div.textContent = 'Document content'
+      document.body.appendChild(div)
+
+      const service = createCSLService({
+        enablePolicyValidation: false,
+        enableLineageTracking: false,
+      })
+
+      const result = await service.segment(document)
+
+      expect(result).toBeDefined()
+      expect(result.segments.length).toBeGreaterThanOrEqual(0)
+    })
+  })
+
+  describe('CSLService con políticas', () => {
+    it('debe validar políticas cuando está habilitado', async () => {
+      const body = document.body
+      
+      const div = document.createElement('div')
+      div.textContent = 'Test content'
+      body.appendChild(div)
+
+      const policyRepository = new InMemoryPolicyRepository()
+      const policy = new PolicyRule(
+        '1.0',
+        [],
+        [],
+        { protectedRoles: [], immutableInstructions: [] },
+        { enabled: false, blockMetadataExposure: false, sanitizeInternalReferences: false }
+      )
+      await policyRepository.savePolicy(policy)
+
+      const service = createCSLService({
+        policyRepository,
+        enablePolicyValidation: true,
+        enableLineageTracking: false,
+      })
+
+      const result = await service.segment(body)
+
+      expect(result).toBeDefined()
+      expect(result.segments).toBeDefined()
+    })
+  })
+
+  describe('CSLService con linaje', () => {
+    it('debe trackear linaje cuando está habilitado', async () => {
+      const body = document.body
+      
+      const div = document.createElement('div')
+      div.textContent = 'Test content for lineage'
+      body.appendChild(div)
+
+      const service = createCSLService({
+        enablePolicyValidation: false,
+        enableLineageTracking: true,
+      })
+
+      const result = await service.segment(body)
+
+      expect(result.lineage).toBeDefined()
+      expect(Array.isArray(result.lineage)).toBe(true)
+    })
+
+    it('no debe trackear linaje cuando está deshabilitado', async () => {
+      const body = document.body
+      
+      const div = document.createElement('div')
+      div.textContent = 'Test content'
+      body.appendChild(div)
+
+      const service = createCSLService({
+        enablePolicyValidation: false,
+        enableLineageTracking: false,
+      })
+
+      const result = await service.segment(body)
+
+      // El linaje puede estar vacío pero debe existir
+      expect(result.lineage).toBeDefined()
+    })
+  })
+
+  describe('Manejo de errores', () => {
+    it('debe lanzar SegmentationError en caso de error', async () => {
+      const service = createCSLService({
+        enablePolicyValidation: false,
+        enableLineageTracking: false,
+      })
+
+      // Intentar procesar un elemento inválido debería causar error
+      await expect(async () => {
+        await service.segment(null as any)
+      }).rejects.toThrow(SegmentationError)
+    })
+  })
+
+  describe('CSLResult', () => {
+    it('debe tener método getBlockedCount', async () => {
+      const body = document.body
+      
+      const div = document.createElement('div')
+      div.textContent = 'Test content'
+      body.appendChild(div)
+
+      const service = createCSLService({
+        enablePolicyValidation: false,
+        enableLineageTracking: false,
+      })
+
+      const result = await service.segment(body)
+
+      expect(typeof result.getBlockedCount).toBe('function')
+      const blockedCount = result.getBlockedCount()
+      expect(typeof blockedCount).toBe('number')
+      expect(blockedCount).toBeGreaterThanOrEqual(0)
+    })
+
+    it('debe tener método getTrustDistribution', async () => {
+      const body = document.body
+      
+      const div = document.createElement('div')
+      div.textContent = 'Test content'
+      body.appendChild(div)
+
+      const service = createCSLService({
+        enablePolicyValidation: false,
+        enableLineageTracking: false,
+      })
+
+      const result = await service.segment(body)
+
+      expect(result.metadata.trust_distribution).toHaveProperty('TC')
+      expect(result.metadata.trust_distribution).toHaveProperty('STC')
+      expect(result.metadata.trust_distribution).toHaveProperty('UC')
+    })
+  })
+
+  describe('Segmentos', () => {
+    it('debe crear segmentos con propiedades correctas', async () => {
+      const body = document.body
+      
+      const div = document.createElement('div')
+      div.textContent = 'Test segment content'
+      body.appendChild(div)
+
+      const service = createCSLService({
+        enablePolicyValidation: false,
+        enableLineageTracking: false,
+      })
+
+      const result = await service.segment(body)
+
+      if (result.segments.length > 0) {
+        const segment = result.segments[0]
+        
+        expect(segment).toHaveProperty('id')
+        expect(segment).toHaveProperty('content')
+        expect(segment).toHaveProperty('origin')
+        expect(segment).toHaveProperty('mime')
+        expect(segment).toHaveProperty('timestamp')
+        expect(segment).toHaveProperty('source')
+        expect(typeof segment?.id).toBe('string')
+        expect(typeof segment?.content).toBe('string')
+        expect(typeof segment?.shouldBlock).toBe('function')
+      }
+    })
+
+    it('debe detectar si un segmento debe ser bloqueado', async () => {
+      const body = document.body
+      
+      const div = document.createElement('div')
+      div.textContent = 'Normal content'
+      body.appendChild(div)
+
+      const service = createCSLService({
+        enablePolicyValidation: false,
+        enableLineageTracking: false,
+      })
+
+      const result = await service.segment(body)
+
+      expect(result.segments.length).toBeGreaterThan(0)
+      const segment = result.segments[0]
+      expect(segment).toBeDefined()
+      if (!segment) return // Type guard
+      const shouldBlock = segment.shouldBlock()
+      expect(typeof shouldBlock).toBe('boolean')
+    })
+  })
+
+  describe('Configuración de hash algorithm', () => {
+    it('debe usar sha256 por defecto', async () => {
+      const body = document.body
+      
+      const div = document.createElement('div')
+      div.textContent = 'Test content'
+      body.appendChild(div)
+
+      const service = createCSLService({
+        enablePolicyValidation: false,
+        enableLineageTracking: false,
+      })
+
+      const result = await service.segment(body)
+
+      // Verificar que los segmentos tienen hash
+      expect(result.segments.length).toBeGreaterThan(0)
+      const segment = result.segments[0]
+      expect(segment).toBeDefined()
+      if (!segment) return // Type guard
+      if (segment.hash) {
+        expect(segment.hash.algorithm).toBe('sha256')
+      }
+    })
+
+    it('debe usar sha512 cuando se configura', async () => {
+      const body = document.body
+      
+      const div = document.createElement('div')
+      div.textContent = 'Test content'
+      body.appendChild(div)
+
+      const service = createCSLService({
+        hashAlgorithm: 'sha512',
+        enablePolicyValidation: false,
+        enableLineageTracking: false,
+      })
+
+      const result = await service.segment(body)
+
+      // Verificar que los segmentos tienen hash con sha512
+      expect(result.segments.length).toBeGreaterThan(0)
+      const segment = result.segments[0]
+      expect(segment).toBeDefined()
+      if (!segment) return // Type guard
+      if (segment.hash) {
+        expect(segment.hash.algorithm).toBe('sha512')
+      }
+    })
+  })
+})