@ai-pip/core 0.1.3 → 0.1.5

package/src/csl/lineage.ts

@@ -1,40 +0,0 @@
-import { createLineageEntry as createEntry } from './value-objects/LineageEntry'
-import type { LineageEntry } from './value-objects/LineageEntry'
-import type { CSLSegment } from './types'
-
-/**
- * Inicializa el linaje para un segmento - función pura
- * 
- * @remarks
- * Crea la entrada inicial de linaje cuando se crea un segmento en CSL.
- * El core solo registra step y timestamp, sin notes.
- * 
- * @param segment - El segmento para el cual inicializar el linaje
- * @returns Array con la entrada inicial de linaje
- * 
- * @example
- * ```typescript
- * const lineage = initLineage(segment)
- * // Returns: [{ step: 'CSL', timestamp: ... }]
- * ```
- */
-export function initLineage(_segment: CSLSegment): LineageEntry[] {
-  return [
-    createEntry('CSL', Date.now())
-  ]
-}
-
-/**
- * Crea una entrada de linaje - función pura
- * 
- * @remarks
- * El core solo registra step y timestamp.
- * Notes y metadata van en el SDK para observabilidad.
- * 
- * @param step - Nombre del paso de procesamiento
- * @returns Nueva entrada de linaje
- */
-export function createLineageEntry(step: string): LineageEntry {
-  return createEntry(step, Date.now())
-}
-

package/src/csl/segment.ts

@@ -1,100 +0,0 @@
-import type { CSLInput, CSLResult, CSLSegment } from './types'
-import { classifySource } from './classify'
-import { initLineage } from './lineage'
-import { generateId, splitByContextRules } from './utils'
-import { SegmentationError } from './exceptions'
-
-/**
- * Segmenta input en segmentos semánticos - función pura principal de CSL
- * 
- * @remarks
- * Esta es la función principal de CSL. Segmenta el contenido, clasifica
- * por origen, e inicializa el linaje. Todo de forma pura y determinista.
- * 
- * **Invariantes preservados:**
- * - El contenido original nunca se pierde
- * - El orden de segmentos es estable
- * - Todo segmento tiene linaje inicial
- * - CSL es determinista
- * 
- * @param input - Input con contenido y source
- * @returns CSLResult con segmentos clasificados y linaje inicializado
- * 
- * @throws {SegmentationError} Si la segmentación falla
- * 
- * @example
- * ```typescript
- * const result = segment({
- *   content: 'Hello\nWorld',
- *   source: 'UI',
- *   metadata: {}
- * })
- * 
- * // result.segments contiene 2 segmentos, cada uno con:
- * // - content original
- * // - trust level clasificado
- * // - lineage inicializado
- * ```
- */
-export function segment(input: CSLInput): CSLResult {
-  try {
-    // 1. Validar input
-    if (!input.content || typeof input.content !== 'string') {
-      throw new SegmentationError('CSLInput content must be a non-empty string')
-    }
-
-    if (!input.source) {
-      throw new SegmentationError('CSLInput source is required')
-    }
-
-    // 2. Dividir contenido en segmentos estructurales (función pura)
-    // CSL solo segmenta por estructura, no por intención semántica
-    const contentSegments = splitByContextRules(input.content)
-
-    // 3. Si no hay contenido, retornar resultado vacío
-    if (contentSegments.length === 0) {
-      return {
-        segments: Object.freeze([]),
-        lineage: Object.freeze([])
-      }
-    }
-
-    // 4. Clasificar source una vez (determinista)
-    const trust = classifySource(input.source)
-
-    // 5. Crear segmentos con clasificación y linaje
-    const segments: CSLSegment[] = contentSegments.map((content) => {
-      // Crear segmento temporal para inicializar linaje
-      const tempSegment: CSLSegment = {
-        id: generateId(),
-        content,                    // ✅ Original preservado
-        source: input.source,       // ✅ Origen preservado
-        trust,                      // ✅ Clasificación determinista
-        lineage: [],                // Se inicializa después
-        ...(input.metadata && { metadata: input.metadata })
-      }
-      
-      // Inicializar linaje
-      const lineage = initLineage(tempSegment)
-      
-      // Retornar segmento completo
-      return {
-        ...tempSegment,
-        lineage                      // ✅ Linaje inicializado
-      }
-    })
-
-    // 6. Recolectar todo el linaje
-    const allLineage = segments.flatMap(s => s.lineage)
-
-    // 7. Retornar resultado puro
-    return {
-      segments: Object.freeze(segments),
-      lineage: Object.freeze(allLineage)
-    }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : 'Unknown error during segmentation'
-    throw new SegmentationError(`Failed to segment content: ${errorMessage}`, error)
-  }
-}
-

package/src/csl/types.ts

@@ -1,113 +0,0 @@
-/**
- * Types for CSL (Context Segmentation Layer) - Core Semántico
- * 
- * Solo tipos esenciales para CSL. Tipos relacionados con detección,
- * anomalías y políticas van a ISL.
- */
-
-/**
- * OriginType represents the deterministic source of a content segment.
- */
-export enum OriginType {
-  /**
-   * Direct user input from UI controls
-   * Always classified as UC (Untrusted Content) for security.
-   */
-  USER = 'USER',
-  
-  /**
-   * Content from visible DOM elements
-   * Classified as STC (Semi-Trusted Content) because user can verify it.
-   */
-  DOM_VISIBLE = 'DOM_VISIBLE',
-  
-  /**
-   * Content from hidden DOM elements
-   * Classified as UC (Untrusted Content) - potential attack vector.
-   */
-  DOM_HIDDEN = 'DOM_HIDDEN',
-  
-  /**
-   * Content from DOM attributes (data-*, aria-*, etc.)
-   * Classified as STC (Semi-Trusted Content) - visible in source.
-   */
-  DOM_ATTRIBUTE = 'DOM_ATTRIBUTE',
-  
-  /**
-   * Content injected by scripts (dynamically generated)
-   * Classified as UC (Untrusted Content) - can be manipulated.
-   */
-  SCRIPT_INJECTED = 'SCRIPT_INJECTED',
-  
-  /**
-   * Content fetched from network (API calls, external resources)
-   * Classified as UC (Untrusted Content) - external source, not verified.
-   */
-  NETWORK_FETCHED = 'NETWORK_FETCHED',
-  
-  /**
-   * System-generated content (instructions, system prompts, etc.)
-   * Classified as TC (Trusted Content) - system controls this content.
-   */
-  SYSTEM_GENERATED = 'SYSTEM_GENERATED',
-  
-  /**
-   * Origin cannot be determined
-   * Classified as UC (Untrusted Content) - unknown is untrusted by default.
-   */
-  UNKNOWN = 'UNKNOWN',
-}
-
-/**
- * TrustLevelType represents the trust level of content
- */
-export enum TrustLevelType {
-  TC = 'TC',   // Trusted Content
-  STC = 'STC', // Semi-Trusted Content
-  UC = 'UC',   // Untrusted Content
-}
-
-/**
- * HashAlgorithm for ContentHash (opcional, para trazabilidad)
- */
-export type HashAlgorithm = 'sha256' | 'sha512'
-
-/**
- * Source type for CSL input
- */
-export type Source = 'DOM' | 'UI' | 'SYSTEM' | 'API'
-
-/**
- * CSLInput - Input para la función segment()
- */
-export interface CSLInput {
-  readonly content: string
-  readonly source: Source
-  readonly metadata?: Record<string, unknown>
-}
-
-// Importar tipos de value objects para usar en interfaces
-import type { ContentHash, LineageEntry, TrustLevel } from './value-objects'
-
-/**
- * CSLSegment - Segmento puro, solo datos semánticos
- */
-export interface CSLSegment {
-  readonly id: string
-  readonly content: string              // Original, sin modificar
-  readonly source: Source
-  readonly trust: TrustLevel            // Clasificado por origen
-  readonly lineage: LineageEntry[]     // Inicializado en CSL
-  readonly hash?: ContentHash           // Opcional, para trazabilidad
-  readonly metadata?: Record<string, unknown>
-}
-
-/**
- * CSLResult - Resultado puro, solo datos
- */
-export interface CSLResult {
-  readonly segments: readonly CSLSegment[]
-  readonly lineage: readonly LineageEntry[]
-  readonly processingTimeMs?: number    // Opcional, para métricas
-}
-

package/src/csl/utils.ts

@@ -1,30 +0,0 @@
-/**
- * Utility functions for CSL - funciones puras
- */
-
-/**
- * Generates a unique ID for a segment
- */
-export function generateId(): string {
-  return `seg-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`
-}
-
-/**
- * Splits content by context rules - función pura de segmentación
- * 
- * @remarks
- * Segmentación básica por líneas. Sin normalización agresiva
- * (la normalización va a ISL).
- */
-export function splitByContextRules(content: string): string[] {
-  if (content.length === 0) {
-    return []
-  }
-  
-  // Segmentación básica por líneas
-  return content
-    .split(/\n+/)
-    .map(line => line.trim())
-    .filter(line => line.length > 0)
-}
-

package/src/csl/value-objects/ContentHash.ts

@@ -1,48 +0,0 @@
-import type { HashAlgorithm } from '../types'
-
-/**
- * ContentHash - tipo puro
- */
-export type ContentHash = {
-  readonly value: string
-  readonly algorithm: HashAlgorithm
-}
-
-/**
- * Crea un ContentHash - función pura
- */
-export function createContentHash(value: string, algorithm: HashAlgorithm = 'sha256'): ContentHash {
-  if (!value || typeof value !== 'string') {
-    throw new Error('ContentHash value must be a non-empty string')
-  }
-
-  if (!['sha256', 'sha512'].includes(algorithm)) {
-    throw new Error(`Invalid HashAlgorithm: ${algorithm}. Must be 'sha256' or 'sha512'`)
-  }
-
-  const hexPattern = /^[a-f0-9]+$/i
-  if (!hexPattern.test(value)) {
-    throw new Error('ContentHash value must be a valid hexadecimal string')
-  }
-
-  const expectedLength = algorithm === 'sha256' ? 64 : 128
-  if (value.length !== expectedLength) {
-    throw new Error(`ContentHash value length must be ${expectedLength} characters for ${algorithm}`)
-  }
-
-  return {
-    value: value.toLowerCase(),
-    algorithm
-  }
-}
-
-/**
- * Funciones puras para ContentHash
- */
-export function isSha256(hash: ContentHash): boolean {
-  return hash.algorithm === 'sha256'
-}
-
-export function isSha512(hash: ContentHash): boolean {
-  return hash.algorithm === 'sha512'
-}

package/src/csl/value-objects/LineageEntry.ts

@@ -1,33 +0,0 @@
-/**
- * LineageEntry - tipo puro
- * 
- * @remarks
- * El core semántico solo preserva linaje estructural.
- * Notes libres son para observabilidad (SDK), no core.
- */
-export type LineageEntry = {
-  readonly step: string
-  readonly timestamp: number
-}
-
-/**
- * Crea un LineageEntry - función pura
- * 
- * @remarks
- * El core solo registra step y timestamp.
- * Notes y metadata van en el SDK para observabilidad.
- */
-export function createLineageEntry(step: string, timestamp: number): LineageEntry {
-  if (!step || typeof step !== 'string' || step.trim().length === 0) {
-    throw new Error('LineageEntry step must be a non-empty string')
-  }
-
-  if (typeof timestamp !== 'number' || timestamp < 0 || !Number.isFinite(timestamp)) {
-    throw new Error('LineageEntry timestamp must be a valid positive number')
-  }
-
-  return {
-    step: step.trim(),
-    timestamp
-  }
-}

package/src/csl/value-objects/Origin-map.ts

@@ -1,51 +0,0 @@
-import { OriginType, TrustLevelType } from '../types'
-
-/**
- * originMap is the deterministic mapping from OriginType to TrustLevelType.
- * 
- * @remarks
- * This map defines the **deterministic classification rules** for content segments.
- * The mapping is based solely on the origin type, not on content analysis.
- * 
- * **Key Principles:**
- * - 100% deterministic: same origin → same trust level, always
- * - No heuristics or content analysis
- * - All OriginType values must be present in this map
- */
-export const originMap = new Map<OriginType, TrustLevelType>([
-  // User origins - always untrusted (security by default)
-  [OriginType.USER, TrustLevelType.UC],
-  
-  // DOM origins - trust based on visibility
-  [OriginType.DOM_VISIBLE, TrustLevelType.STC],
-  [OriginType.DOM_HIDDEN, TrustLevelType.UC],
-  [OriginType.DOM_ATTRIBUTE, TrustLevelType.STC],
-  
-  // External origins - always untrusted
-  [OriginType.SCRIPT_INJECTED, TrustLevelType.UC],
-  [OriginType.NETWORK_FETCHED, TrustLevelType.UC],
-  
-  // System origins - trusted (system controls)
-  [OriginType.SYSTEM_GENERATED, TrustLevelType.TC],
-  
-  // Unknown - untrusted by default (fail-secure)
-  [OriginType.UNKNOWN, TrustLevelType.UC],
-])
-
-/**
- * Validates that all OriginType values are mapped in originMap.
- * 
- * @throws {Error} If any OriginType is not present in originMap
- */
-export function validateOriginMap(): void {
-  const allOriginTypes = Object.values(OriginType)
-  const missingTypes = allOriginTypes.filter(type => !originMap.has(type))
-  
-  if (missingTypes.length > 0) {
-    throw new Error(
-      `Missing origin mappings: ${missingTypes.join(', ')}. ` +
-      `All OriginType values must be mapped in originMap.`
-    )
-  }
-}
-

package/src/csl/value-objects/Origin.ts

@@ -1,52 +0,0 @@
-import { OriginType } from '../types'
-
-/**
- * Origin - tipo puro
- */
-export type Origin = {
-  readonly type: OriginType
-}
-
-/**
- * Crea un Origin - función pura
- */
-export function createOrigin(type: OriginType): Origin {
-  if (!Object.values(OriginType).includes(type)) {
-    throw new Error(`Invalid Origin type: ${type}`)
-  }
-  return { type }
-}
-
-/**
- * Funciones puras para Origin
- */
-export function isDom(origin: Origin): boolean {
-  return origin.type === OriginType.DOM_HIDDEN ||
-         origin.type === OriginType.DOM_VISIBLE ||
-         origin.type === OriginType.DOM_ATTRIBUTE
-}
-
-export function isUser(origin: Origin): boolean {
-  return origin.type === OriginType.USER
-}
-
-export function isSystem(origin: Origin): boolean {
-  return origin.type === OriginType.SYSTEM_GENERATED
-}
-
-export function isInjected(origin: Origin): boolean {
-  return origin.type === OriginType.SCRIPT_INJECTED
-}
-
-export function isUnknown(origin: Origin): boolean {
-  return origin.type === OriginType.UNKNOWN
-}
-
-export function isNetworkFetched(origin: Origin): boolean {
-  return origin.type === OriginType.NETWORK_FETCHED
-}
-
-export function isExternal(origin: Origin): boolean {
-  return origin.type === OriginType.NETWORK_FETCHED ||
-         origin.type === OriginType.SCRIPT_INJECTED
-}

package/src/csl/value-objects/TrustLevel.ts

@@ -1,33 +0,0 @@
-import { TrustLevelType } from '../types'
-
-/**
- * TrustLevel - tipo puro
- */
-export type TrustLevel = {
-  readonly value: TrustLevelType
-}
-
-/**
- * Crea un TrustLevel - función pura
- */
-export function createTrustLevel(value: TrustLevelType): TrustLevel {
-  if (!Object.values(TrustLevelType).includes(value)) {
-    throw new Error(`Invalid TrustLevel: ${value}`)
-  }
-  return { value }
-}
-
-/**
- * Funciones puras para TrustLevel
- */
-export function isTrusted(trust: TrustLevel): boolean {
-  return trust.value === TrustLevelType.TC
-}
-
-export function isSemiTrusted(trust: TrustLevel): boolean {
-  return trust.value === TrustLevelType.STC
-}
-
-export function isUntrusted(trust: TrustLevel): boolean {
-  return trust.value === TrustLevelType.UC
-}

package/src/csl/value-objects/index.ts

@@ -1,14 +0,0 @@
-// Tipos
-export type { TrustLevel } from './TrustLevel'
-export type { Origin } from './Origin'
-export type { LineageEntry } from './LineageEntry'
-export type { ContentHash } from './ContentHash'
-
-// Funciones de creación
-export { createTrustLevel, isTrusted, isSemiTrusted, isUntrusted } from './TrustLevel'
-export { createOrigin, isDom, isUser, isSystem, isInjected, isUnknown, isNetworkFetched, isExternal } from './Origin'
-export { createLineageEntry } from './LineageEntry'
-export { createContentHash, isSha256, isSha512 } from './ContentHash'
-
-// Origin-map
-export { originMap, validateOriginMap } from './Origin-map'

package/src/index.ts

@@ -1,20 +0,0 @@
-/**
- * @ai-pip/core - Core implementation of the AI-PIP protocol
- * 
- * @remarks
- * Main entry point that re-exports all layers (CSL, ISL, Shared)
- * 
- * You can also import specific layers:
- * - import { segment } from '@ai-pip/core/csl'
- * - import { sanitize } from '@ai-pip/core/isl'
- * - import { addLineageEntry } from '@ai-pip/core/shared'
- * - import { envelope } from '@ai-pip/core/cpe'
- */
-
-// Re-export all layers
-export * from './csl'
-export * from './isl'
-export * from './shared'
-export * from './cpe'
-
-

package/src/isl/exceptions/SanitizationError.ts

@@ -1,14 +0,0 @@
-/**
- * SanitizationError is thrown when sanitization fails.
- */
-export class SanitizationError extends Error {
-  constructor(
-    message: string,
-    public readonly cause?: unknown
-  ) {
-    super(message)
-    this.name = 'SanitizationError'
-    Object.setPrototypeOf(this, SanitizationError.prototype)
-  }
-}
-

package/src/isl/exceptions/index.ts

@@ -1,2 +0,0 @@
-export * from './SanitizationError'
-

package/src/isl/index.ts

@@ -1,20 +0,0 @@
-/**
- * ISL (Instruction Sanitization Layer) - Core Semántico
- * 
- * @remarks
- * ISL sanitiza instrucciones maliciosas recibidas de CSL,
- * aplicando diferentes niveles de sanitización según el nivel de confianza.
- */
-
-// Funciones puras principales
-export { sanitize } from './sanitize'
-
-// Value objects
-export * from './value-objects'
-
-// Exceptions
-export * from './exceptions'
-
-// Types
-export * from './types'
-

package/src/isl/sanitize.ts

@@ -1,93 +0,0 @@
-import type { CSLResult } from '../csl/types'
-import type { ISLResult, ISLSegment, RemovedInstruction } from './types'
-import { createLineageEntry } from '../csl/value-objects'
-import { addLineageEntry } from '../shared/lineage'
-import type { TrustLevel } from '../csl/value-objects'
-import { TrustLevelType } from '../csl/types'
-
-/**
- * Sanitiza contenido según nivel de confianza - función pura
- * 
- * @remarks
- * ISL aplica sanitización diferenciada según el trust level:
- * - TC: Sanitización mínima
- * - STC: Sanitización moderada
- * - UC: Sanitización agresiva
- */
-export function sanitize(cslResult: CSLResult): ISLResult {
-  const segments: ISLSegment[] = []
-  let allLineage: typeof cslResult.lineage = [...cslResult.lineage]
-  const blockedCount = 0
-  let instructionsRemovedCount = 0
-
-  for (const cslSegment of cslResult.segments) {
-    // Determinar nivel de sanitización según trust level
-    const sanitizationLevel = getSanitizationLevel(cslSegment.trust)
-
-    // Sanitizar contenido según nivel
-    const sanitized = sanitizeContent(
-      cslSegment.content,
-      sanitizationLevel
-    )
-
-    // Detectar instrucciones removidas (esto se implementará con detección de PI)
-    const removedInstructions: RemovedInstruction[] = []
-
-    // Crear segmento sanitizado
-    const islSegment: ISLSegment = {
-      id: cslSegment.id,
-      originalContent: cslSegment.content,  // ✅ Preservar original
-      sanitizedContent: sanitized.content,
-      trust: cslSegment.trust,
-      lineage: addLineageEntry(
-        cslSegment.lineage,
-        createLineageEntry('ISL', Date.now())
-      ),
-      instructionsRemoved: removedInstructions,
-      sanitizationLevel
-    }
-
-    segments.push(islSegment)
-    const lastLineageEntry = islSegment.lineage.at(-1)
-    if (lastLineageEntry) {
-      allLineage = addLineageEntry(allLineage, lastLineageEntry)
-    }
-    instructionsRemovedCount += removedInstructions.length
-  }
-
-  return {
-    segments: Object.freeze(segments),
-    lineage: Object.freeze(allLineage),
-    metadata: {
-      totalSegments: segments.length,
-      sanitizedSegments: segments.length,
-      blockedSegments: blockedCount,
-      instructionsRemoved: instructionsRemovedCount
-    }
-  }
-}
-
-/**
- * Determina nivel de sanitización según trust level - función pura
- */
-function getSanitizationLevel(trust: TrustLevel): 'minimal' | 'moderate' | 'aggressive' {
-  if (trust.value === TrustLevelType.TC) return 'minimal'
-  if (trust.value === TrustLevelType.STC) return 'moderate'
-  return 'aggressive'  // UC
-}
-
-/**
- * Sanitiza contenido según nivel - función pura
- */
-function sanitizeContent(
-  content: string,
-  _level: 'minimal' | 'moderate' | 'aggressive'
-): { content: string; removed: RemovedInstruction[] } {
-  // Por ahora retorna el contenido sin cambios
-  // La lógica de sanitización real se implementará después
-  return {
-    content,
-    removed: []
-  }
-}
-