@nekzus/liop 1.3.0-alpha.1 → 2.0.0-alpha.2

package/dist/server/pii.d.ts

@@ -1,40 +0,0 @@
-/**
- * LIOP Professional PII Engine (The Shield V2 - Tier-1 Military Edition)
- * Implements high-fidelity detection based on NIST and OWASP standards.
- * Features Multi-Layer Verification (Regex + Algorithmic Validators).
- */
-export type PiiRuleDefinition = {
-    name: string;
-    pattern: string | RegExp;
-    validator?: (match: string) => boolean;
-};
-export type PiiRule = string | RegExp | PiiRuleDefinition;
-export declare const PII_PATTERNS: {
-    EMAIL: PiiRuleDefinition;
-    CREDIT_CARD: PiiRuleDefinition;
-    IP_ADDRESS: PiiRuleDefinition;
-    PHONE: PiiRuleDefinition;
-    SSN: PiiRuleDefinition;
-    IBAN: PiiRuleDefinition;
-    PASSPORT_MRZ: PiiRuleDefinition;
-};
-/**
- * Regional and Cultural Security Presets for Out-Of-The-Box compliance.
- * Developers can override, merge, or omit these based on local laws.
- */
-export declare const PII_PRESETS: {
-    GLOBAL_STRICT: PiiRuleDefinition[];
-    US_COMPLIANT: PiiRuleDefinition[];
-    EU_GDPR: PiiRuleDefinition[];
-};
-export declare class PiiScanner {
-    private patterns;
-    private forbiddenKeysSet;
-    constructor(patterns?: PiiRule[], forbiddenKeys?: string[]);
-    /**
-     * Scans any input (string, object, array) for PII violations.
-     * Returns the pattern/rule name that triggered the violation, or null if safe.
-     */
-    scan(input: unknown, seen?: WeakSet<object>): string | null;
-    private checkString;
-}

package/dist/server/pii.js

@@ -1,266 +0,0 @@
-/**
- * LIOP Professional PII Engine (The Shield V2 - Tier-1 Military Edition)
- * Implements high-fidelity detection based on NIST and OWASP standards.
- * Features Multi-Layer Verification (Regex + Algorithmic Validators).
- */
-/**
- * Validates a credit card number using the Luhn algorithm.
- * Prevents false positives from random 16-digit IDs.
- */
-function isLuhnValid(cardNumber) {
-    const digits = cardNumber.replace(/\D/g, "");
-    if (digits.length < 13 || digits.length > 19)
-        return false;
-    let sum = 0;
-    let isEven = false;
-    for (let i = digits.length - 1; i >= 0; i--) {
-        let digit = parseInt(digits.charAt(i), 10);
-        if (isEven) {
-            digit *= 2;
-            if (digit > 9) {
-                digit -= 9;
-            }
-        }
-        sum += digit;
-        isEven = !isEven;
-    }
-    return sum % 10 === 0;
-}
-/**
- * Validates an International Bank Account Number (IBAN) using ISO 7064 Modulo 97.
- * Uses BigInt algebra to avoid JS floating point truncation with 30-digit numbers.
- */
-function isIbanValid(iban) {
-    const sanitized = iban.replace(/\s+/g, "").toUpperCase();
-    if (!/^[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}$/.test(sanitized))
-        return false;
-    const rearranged = sanitized.substring(4) + sanitized.substring(0, 4);
-    let numericString = "";
-    for (let i = 0; i < rearranged.length; i++) {
-        const charCode = rearranged.charCodeAt(i);
-        if (charCode >= 65 && charCode <= 90) {
-            numericString += (charCode - 55).toString();
-        }
-        else if (charCode >= 48 && charCode <= 57) {
-            numericString += rearranged.charAt(i);
-        }
-        else {
-            return false;
-        }
-    }
-    try {
-        return BigInt(numericString) % 97n === 1n;
-    }
-    catch (_e) {
-        return false;
-    }
-}
-export const PII_PATTERNS = {
-    EMAIL: {
-        name: "EMAIL",
-        pattern: /\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b/gi,
-        validator: (match) => !match.endsWith("@example.com") && !match.endsWith("@test.com"),
-    },
-    CREDIT_CARD: {
-        name: "CREDIT_CARD",
-        pattern: /\b(?:\d[ -]*?){13,16}\b/g,
-        validator: isLuhnValid,
-    },
-    IP_ADDRESS: {
-        name: "IP_ADDRESS",
-        pattern: /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g,
-        validator: (match) => {
-            const safeIps = ["127.0.0.1", "0.0.0.0", "255.255.255.255"];
-            if (safeIps.includes(match))
-                return false;
-            // Validate valid IPv4 ranges
-            const parts = match.split(".").map(Number);
-            return parts.every((p) => p >= 0 && p <= 255);
-        },
-    },
-    PHONE: {
-        name: "PHONE",
-        // Strict boundary to avoid matching long numeric IDs wrapped in symbols
-        pattern: /(?:(?:\+?\d{1,3}[-. ]?)?\(?\d{3}\)?[-. ]?\d{3}[-. ]?\d{4})\b/g,
-        validator: (match) => {
-            const digits = match.replace(/\D/g, "");
-            if (digits.length < 7 || digits.length > 15)
-                return false;
-            // Reject fake test numbers like 0000000000 or 1234567890
-            if (/^(\d)\1+$/.test(digits))
-                return false;
-            if (digits === "1234567890")
-                return false;
-            return true;
-        },
-    },
-    SSN: {
-        name: "SSN",
-        pattern: /\b\d{3}[- ]?\d{2}[- ]?\d{4}\b/g,
-        validator: (match) => {
-            const digits = match.replace(/\D/g, "");
-            if (digits.length !== 9)
-                return false;
-            const area = parseInt(digits.substring(0, 3), 10);
-            if (area === 0 || area === 666 || area >= 900)
-                return false;
-            const group = parseInt(digits.substring(3, 5), 10);
-            if (group === 0)
-                return false;
-            const serial = parseInt(digits.substring(5, 9), 10);
-            if (serial === 0)
-                return false;
-            if (/^(\d)\1+$/.test(digits) || digits === "123456789")
-                return false;
-            return true;
-        },
-    },
-    IBAN: {
-        name: "IBAN",
-        pattern: /\b[A-Z]{2}[0-9]{2}[A-Z0-9]{1,30}\b/gi,
-        validator: isIbanValid,
-    },
-    PASSPORT_MRZ: {
-        name: "PASSPORT_MRZ",
-        // Machina Readable Zone line match for standard international passports
-        pattern: /\bP[A-Z<][A-Z<]{3}[A-Z0-9<]{39}(?:\b|\s|$)/g,
-    },
-};
-/**
- * Regional and Cultural Security Presets for Out-Of-The-Box compliance.
- * Developers can override, merge, or omit these based on local laws.
- */
-export const PII_PRESETS = {
-    GLOBAL_STRICT: [
-        PII_PATTERNS.EMAIL,
-        PII_PATTERNS.CREDIT_CARD,
-        PII_PATTERNS.IP_ADDRESS,
-        PII_PATTERNS.PHONE,
-        PII_PATTERNS.PASSPORT_MRZ,
-        PII_PATTERNS.IBAN,
-    ],
-    US_COMPLIANT: [
-        PII_PATTERNS.EMAIL,
-        PII_PATTERNS.CREDIT_CARD,
-        PII_PATTERNS.IP_ADDRESS,
-        PII_PATTERNS.PHONE,
-        PII_PATTERNS.SSN,
-        PII_PATTERNS.PASSPORT_MRZ,
-    ],
-    EU_GDPR: [
-        PII_PATTERNS.EMAIL,
-        PII_PATTERNS.CREDIT_CARD,
-        PII_PATTERNS.IP_ADDRESS,
-        PII_PATTERNS.PHONE,
-        PII_PATTERNS.IBAN,
-        PII_PATTERNS.PASSPORT_MRZ,
-    ],
-};
-export class PiiScanner {
-    patterns;
-    forbiddenKeysSet;
-    constructor(patterns = [], forbiddenKeys = []) {
-        this.patterns = patterns;
-        // Optimizes large recursive evaluations using O(1) continuous key lookup
-        this.forbiddenKeysSet = new Set(forbiddenKeys.map((k) => k.toLowerCase()));
-    }
-    /**
-     * Scans any input (string, object, array) for PII violations.
-     * Returns the pattern/rule name that triggered the violation, or null if safe.
-     */
-    scan(input, seen = new WeakSet()) {
-        if (input === null || input === undefined)
-            return null;
-        // 1. String Scan (Direct Regex/String/Definition check)
-        if (typeof input === "string") {
-            // SECURITY PATCH: JSON Deep-Parsing Recursion (Fortification V2)
-            // Defeats Double JSON Encoding bypasses by forcefully parsing stringified JSON back into objects.
-            const trimmed = input.trim();
-            if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
-                (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
-                try {
-                    const parsed = JSON.parse(trimmed);
-                    // Successfully parsed JSON string. Recursively scan the unescaped object.
-                    const violation = this.scan(parsed, seen);
-                    if (violation)
-                        return violation;
-                }
-                catch (_e) {
-                    // Silent fallback: It looked like JSON but wasn't valid. Proceed with raw string check.
-                }
-            }
-            // Fallback: Check the raw string
-            return this.checkString(input);
-        }
-        // 2. Recursive Objects/Arrays Scan
-        if (typeof input === "object") {
-            // Protection against circular references
-            if (seen.has(input))
-                return null;
-            seen.add(input);
-            if (Array.isArray(input)) {
-                for (const element of input) {
-                    const violation = this.scan(element, seen);
-                    if (violation)
-                        return violation;
-                }
-            }
-            else {
-                for (const [key, value] of Object.entries(input)) {
-                    // Check Keys using O(1) Constant Time Memory Evaluation
-                    if (this.forbiddenKeysSet.has(key.toLowerCase())) {
-                        return `Forbidden Key: ${key}`;
-                    }
-                    // Recurse into values
-                    const violation = this.scan(value, seen);
-                    if (violation)
-                        return violation;
-                }
-            }
-        }
-        return null;
-    }
-    checkString(text) {
-        for (const rule of this.patterns) {
-            if (typeof rule === "string") {
-                if (text.toLowerCase().includes(rule.toLowerCase())) {
-                    return rule;
-                }
-            }
-            else if (rule instanceof RegExp) {
-                if (rule.global)
-                    rule.lastIndex = 0;
-                if (rule.test(text)) {
-                    return rule.source;
-                }
-            }
-            else if (typeof rule === "object" && rule !== null) {
-                // PiiRuleDefinition (Military Grade Multi-layer)
-                const def = rule;
-                if (typeof def.pattern === "string") {
-                    if (text.toLowerCase().includes(def.pattern.toLowerCase())) {
-                        if (!def.validator || def.validator(def.pattern)) {
-                            return def.name;
-                        }
-                    }
-                }
-                else if (def.pattern instanceof RegExp) {
-                    if (def.pattern.global)
-                        def.pattern.lastIndex = 0;
-                    // Use matchAll or exec to get the specific match for the validator
-                    let match = def.pattern.exec(text);
-                    while (match !== null) {
-                        const matchedText = match[0];
-                        if (!def.validator || def.validator(matchedText)) {
-                            return def.name;
-                        }
-                        if (!def.pattern.global)
-                            break; // Break if not global
-                        match = def.pattern.exec(text);
-                    }
-                }
-            }
-        }
-        return null;
-    }
-}

package/dist/utils/logger.d.ts

@@ -1,21 +0,0 @@
-export type LogLevel = "silent" | "error" | "warn" | "info" | "debug";
-/**
- * LiopLogger - Structured Logging Abstraction
- * Configurable via `process.env.LIOP_LOG_LEVEL`.
- * Emits strictly to stderr to comply with MCP stdio protocols.
- */
-export declare class LiopLogger {
-    private static instance;
-    private level;
-    private constructor();
-    static getInstance(): LiopLogger;
-    private setLevelFromEnv;
-    setLevel(level: LogLevel): void;
-    private shouldLog;
-    private formatMessage;
-    error(message: string, ...args: unknown[]): void;
-    warn(message: string, ...args: unknown[]): void;
-    info(message: string, ...args: unknown[]): void;
-    debug(message: string, ...args: unknown[]): void;
-}
-export declare const log: LiopLogger;

package/dist/utils/logger.js

@@ -1,70 +0,0 @@
-/**
- * LiopLogger - Structured Logging Abstraction
- * Configurable via `process.env.LIOP_LOG_LEVEL`.
- * Emits strictly to stderr to comply with MCP stdio protocols.
- */
-export class LiopLogger {
-    static instance;
-    level = "info";
-    constructor() {
-        this.setLevelFromEnv();
-    }
-    static getInstance() {
-        if (!LiopLogger.instance) {
-            LiopLogger.instance = new LiopLogger();
-        }
-        return LiopLogger.instance;
-    }
-    setLevelFromEnv() {
-        const envLevel = process.env.LIOP_LOG_LEVEL?.toLowerCase();
-        if (envLevel === "silent" ||
-            envLevel === "error" ||
-            envLevel === "warn" ||
-            envLevel === "info" ||
-            envLevel === "debug") {
-            this.level = envLevel;
-        }
-        else {
-            // Default level: info
-            this.level = "info";
-        }
-    }
-    setLevel(level) {
-        this.level = level;
-    }
-    shouldLog(targetLevel) {
-        const levels = {
-            silent: 0,
-            error: 1,
-            warn: 2,
-            info: 3,
-            debug: 4,
-        };
-        return levels[this.level] >= levels[targetLevel];
-    }
-    formatMessage(level, message) {
-        const ts = new Date().toISOString();
-        return `[${ts}] [${level}] ${message}`;
-    }
-    error(message, ...args) {
-        if (this.shouldLog("error")) {
-            console.error(this.formatMessage("ERROR", message), ...args);
-        }
-    }
-    warn(message, ...args) {
-        if (this.shouldLog("warn")) {
-            console.error(this.formatMessage("WARN", message), ...args);
-        }
-    }
-    info(message, ...args) {
-        if (this.shouldLog("info")) {
-            console.error(this.formatMessage("INFO", message), ...args);
-        }
-    }
-    debug(message, ...args) {
-        if (this.shouldLog("debug")) {
-            console.error(this.formatMessage("DEBUG", message), ...args);
-        }
-    }
-}
-export const log = LiopLogger.getInstance();

package/dist/utils/mcpCompact.d.ts

@@ -1,11 +0,0 @@
-/**
- * MCP UX: optional compact tool descriptions for clients (e.g. cloud models)
- * that over-trigger on long "envelope / injection" wording in tools/list.
- *
- * Full LIOP payload format remains in prompts/get → liop_blind_analyst.
- */
-export declare function mcpCompactToolDescriptions(): boolean;
-/**
- * Removes SDK-appended LIOP specification blocks from a registered tool description.
- */
-export declare function stripVerboseLiopToolDescription(description: string): string;

package/dist/utils/mcpCompact.js

@@ -1,29 +0,0 @@
-/**
- * MCP UX: optional compact tool descriptions for clients (e.g. cloud models)
- * that over-trigger on long "envelope / injection" wording in tools/list.
- *
- * Full LIOP payload format remains in prompts/get → liop_blind_analyst.
- */
-export function mcpCompactToolDescriptions() {
-    const v = process.env.LIOP_MCP_COMPACT_TOOL_DESCRIPTIONS?.toLowerCase().trim();
-    return v === "1" || v === "true" || v === "yes";
-}
-/**
- * Removes SDK-appended LIOP specification blocks from a registered tool description.
- */
-export function stripVerboseLiopToolDescription(description) {
-    let d = description;
-    const markers = [
-        "\n\n[LIOP-PROTO-V1:",
-        "\r\n\r\n[LIOP-PROTO-V1:",
-        "\n[LIOP-PROTO-V1:", // rare
-    ];
-    for (const m of markers) {
-        const i = d.indexOf(m);
-        if (i !== -1) {
-            d = d.slice(0, i);
-            break;
-        }
-    }
-    return d.trimEnd();
-}