@ai-pip/csl 0.1.1 → 0.1.3

package/package.json

@@ -1,38 +1,25 @@
 {
   "name": "@ai-pip/csl",
-  "version": "0.1.1",
-  "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')
+      }
+    })
+  })
+})

package/{index.ts → src/index.ts}

@@ -28,103 +28,106 @@
 // ============================================================================
 
 // Servicio principal
-export { CSLService, type CSLServiceConfig } from './layers/csl/services/CSLService'
+export { CSLService, type CSLServiceConfig } from '@ai-pip/csl-layer'
 
 // ============================================================================
 // PORTS (Interfaces públicas)
 // ============================================================================
 
 // Input ports (interfaces que CSL expone)
-export type { SegmentationPort } from './layers/csl/ports/input/SegmentationPort'
-export type { ClassificationPort } from './layers/csl/ports/input/ClassificationPort'
+export type { SegmentationPort } from '@ai-pip/csl-layer'
+export type { ClassificationPort } from '@ai-pip/csl-layer'
 
 // Output ports (interfaces que CSL necesita)
-export type { LoggerPort } from './layers/csl/ports/output/Logger'
-export type { HashGeneratorPort } from './layers/csl/ports/output/HashGenerator'
-export type { TimeStampProviderPort } from './layers/csl/ports/output/TimeStampProvider'
-export type { PolicyRepositoryPort } from './layers/csl/ports/output/PolicyRepository'
-export type { SegmentClassified } from './layers/csl/ports/output/SegmentClassified'
+export type { LoggerPort } from '@ai-pip/csl-layer'
+export type { HashGeneratorPort } from '@ai-pip/csl-layer'
+export type { TimeStampProviderPort } from '@ai-pip/csl-layer'
+export type { PolicyRepositoryPort } from '@ai-pip/csl-layer'
+export type { SegmentClassified } from '@ai-pip/csl-layer'
 
 // ============================================================================
 // ENTIDADES
 // ============================================================================
 
-export { CSLResult } from './layers/csl/domain/entities/CSLResult'
-export { Segment } from './layers/csl/domain/entities/Segment'
+export { CSLResult } from '@ai-pip/csl-layer'
+export { Segment } from '@ai-pip/csl-layer'
 
 // ============================================================================
 // VALUE OBJECTS
 // ============================================================================
 
-export { Origin } from './layers/csl/domain/value-objects/Origin'
-export { TrustLevel } from './layers/csl/domain/value-objects/TrustLevel'
-export { AnomalyScore } from './layers/csl/domain/value-objects/AnomalyScore'
-export { ContentHash } from './layers/csl/domain/value-objects/ContentHash'
-export { LineageEntry } from './layers/csl/domain/value-objects/LineageEntry'
-export { PiDetection } from './layers/csl/domain/value-objects/PiDetection'
-export { PiDetectionResult } from './layers/csl/domain/value-objects/PiDetectionResult'
-export { PolicyRule } from './layers/csl/domain/value-objects/PolicyRule'
-export { Pattern } from './layers/csl/domain/value-objects/Pattern'
+export { Origin } from '@ai-pip/csl-layer'
+export { TrustLevel } from '@ai-pip/csl-layer'
+export { AnomalyScore } from '@ai-pip/csl-layer'
+export { ContentHash } from '@ai-pip/csl-layer'
+export { LineageEntry } from '@ai-pip/csl-layer'
+export { PiDetection } from '@ai-pip/csl-layer'
+export { PiDetectionResult } from '@ai-pip/csl-layer'
+export { PolicyRule } from '@ai-pip/csl-layer'
+export { Pattern } from '@ai-pip/csl-layer'
 
 // ============================================================================
 // SERVICIOS DE DOMINIO
 // ============================================================================
 
-export { NormalizationService } from './layers/csl/domain/services/NormalizationService'
-export { OriginClassificationService } from './layers/csl/domain/services/OriginClassificationService'
-export { PiDetectionService } from './layers/csl/domain/services/PiDetectionService'
-export { AnomalyService } from './layers/csl/domain/services/AnomalyService'
-export { PolicyService } from './layers/csl/domain/services/PolicyService'
-export { LineageService } from './layers/csl/domain/services/LineageService'
-export { SerializationService } from './layers/csl/domain/services/SerializationService'
+export { NormalizationService } from '@ai-pip/csl-layer'
+export { OriginClassificationService } from '@ai-pip/csl-layer'
+export { PiDetectionService } from '@ai-pip/csl-layer'
+export { AnomalyService } from '@ai-pip/csl-layer'
+export { PolicyService } from '@ai-pip/csl-layer'
+export { LineageService } from '@ai-pip/csl-layer'
+export { SerializationService } from '@ai-pip/csl-layer'
 
 // ============================================================================
 // ADAPTERS (Implementaciones por defecto)
 // ============================================================================
 
 // Input adapters
-export { DOMAdapter } from './layers/csl/adapters/input/DOMAdapter'
+export { DOMAdapter } from '@ai-pip/csl-layer'
 
 // Output adapters
-export { ConsoleLogger } from './layers/csl/adapters/output/ConsoleLogger'
-export { CryptoHashGenerator } from './layers/csl/adapters/output/CryptoHashGenerator'
-export { SystemTimestamProvider } from './layers/csl/adapters/output/SystemTimestampProvider'
-export { InMemoryPolicyRepository } from './layers/csl/adapters/output/InMemoryPolicyRepository'
+export { ConsoleLogger } from '@ai-pip/csl-layer'
+export { CryptoHashGenerator } from '@ai-pip/csl-layer'
+export { SystemTimestamProvider } from '@ai-pip/csl-layer'
+export { InMemoryPolicyRepository } from '@ai-pip/csl-layer'
 
 // ============================================================================
 // EXCEPCIONES
 // ============================================================================
 
-export { SegmentationError } from './layers/csl/domain/exceptions/SegmentationError'
-export { ClassificationError } from './layers/csl/domain/exceptions/ClassificationError'
+export { SegmentationError } from '@ai-pip/csl-layer'
+export { ClassificationError } from '@ai-pip/csl-layer'
 
 // ============================================================================
 // TIPOS
 // ============================================================================
 
-export type * from './layers/csl/types'
+export type * from '@ai-pip/csl-layer'
 // Exportar enums y valores (no solo tipos)
-export { OriginType } from './layers/csl/types/value-objects-types'
+export { OriginType } from '@ai-pip/csl-layer'
 
 // ============================================================================
 // FACTORY FUNCTION - Creación fácil del servicio
 // ============================================================================
 
-import { CSLService, type CSLServiceConfig } from './layers/csl/services/CSLService'
-import { DOMAdapter } from './layers/csl/adapters/input/DOMAdapter'
-import { OriginClassificationService } from './layers/csl/domain/services/OriginClassificationService'
-import { PiDetectionService } from './layers/csl/domain/services/PiDetectionService'
-import { AnomalyService } from './layers/csl/domain/services/AnomalyService'
-import { PolicyService } from './layers/csl/domain/services/PolicyService'
-import { LineageService } from './layers/csl/domain/services/LineageService'
-import { CryptoHashGenerator } from './layers/csl/adapters/output/CryptoHashGenerator'
-import { ConsoleLogger } from './layers/csl/adapters/output/ConsoleLogger'
-import { SystemTimestamProvider } from './layers/csl/adapters/output/SystemTimestampProvider'
-import { InMemoryPolicyRepository } from './layers/csl/adapters/output/InMemoryPolicyRepository'
-import type { PolicyRepositoryPort } from './layers/csl/ports/output/PolicyRepository'
-import type { LoggerPort } from './layers/csl/ports/output/Logger'
-import type { HashGeneratorPort } from './layers/csl/ports/output/HashGenerator'
-import type { TimeStampProviderPort } from './layers/csl/ports/output/TimeStampProvider'
+import { 
+  CSLService, 
+  type CSLServiceConfig,
+  DOMAdapter,
+  OriginClassificationService,
+  PiDetectionService,
+  AnomalyService,
+  PolicyService,
+  LineageService,
+  CryptoHashGenerator,
+  ConsoleLogger,
+  SystemTimestamProvider,
+  InMemoryPolicyRepository,
+  type PolicyRepositoryPort,
+  type LoggerPort,
+  type HashGeneratorPort,
+  type TimeStampProviderPort
+} from '@ai-pip/csl-layer'
 
 /**
  * Opciones para crear el servicio CSL