@juspay/neurolink 11.13.0 → 11.13.2

package/dist/lib/utils/performance.d.ts

@@ -1,93 +0,0 @@
-/**
- * Performance measurement and memory management utilities
- * Part of Sub-phase 3.3.1-3.3.2 optimization efforts
- */
-import type { PerformanceMetrics } from "../types/index.js";
-/**
- * Performance measurement utility for tracking operations
- */
-export declare class PerformanceTracker {
-    private metrics;
-    /**
-     * Start tracking performance for an operation
-     */
-    start(operationName: string): void;
-    /**
-     * End tracking and calculate metrics
-     */
-    end(operationName: string): PerformanceMetrics | null;
-    /**
-     * Get metrics for an operation
-     */
-    getMetrics(operationName: string): PerformanceMetrics | null;
-    /**
-     * Clear all metrics
-     */
-    clear(): void;
-    /**
-     * Format metrics for display
-     */
-    formatMetrics(operationName: string): string;
-}
-/**
- * Global performance tracker instance
- */
-export declare const globalTracker: PerformanceTracker;
-/**
- * Memory management utilities
- */
-export declare class MemoryManager {
-    /**
-     * Force garbage collection if available
-     */
-    static forceGC(): boolean;
-    /**
-     * Get current memory usage in MB
-     */
-    static getMemoryUsageMB(): {
-        rss: number;
-        heapTotal: number;
-        heapUsed: number;
-        external: number;
-    };
-    /**
-     * Monitor memory usage and warn if it exceeds threshold
-     */
-    static monitorMemory(threshold?: number): boolean;
-    /**
-     * Clean up and optimize memory usage.
-     * Attempts to force garbage collection if available.
-     *
-     * @returns {object|null} Memory usage statistics if cleanup was performed, or null if not possible.
-     *   - If manual garbage collection is not available (i.e., Node.js not run with --expose-gc),
-     *     no cleanup is performed and null is returned.
-     *   - Clearing the require cache is not attempted due to potential side effects.
-     */
-    static cleanup(): {
-        beforeMB: number;
-        afterMB: number;
-        freedMB: number;
-    } | null;
-}
-/**
- * Decorator for tracking performance of async functions
- */
-export declare function trackPerformance(operationName: string): <T extends (...args: unknown[]) => Promise<unknown>>(_target: unknown, _propertyName: string, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T>;
-/**
- * Performance monitoring for CLI operations
- */
-export declare class CLIPerformanceMonitor {
-    private static instance;
-    private enabled;
-    static getInstance(): CLIPerformanceMonitor;
-    enable(): void;
-    disable(): void;
-    /**
-     * Monitor a CLI operation
-     */
-    monitorOperation<T>(operationName: string, operation: () => Promise<T>): Promise<T>;
-}
-/**
- * Export singleton monitor for easy access
- */
-export declare const cliMonitor: CLIPerformanceMonitor;

package/dist/lib/utils/performance.js

@@ -1,223 +0,0 @@
-/**
- * Performance measurement and memory management utilities
- * Part of Sub-phase 3.3.1-3.3.2 optimization efforts
- */
-import { logger } from "./logger.js";
-/**
- * Performance measurement utility for tracking operations
- */
-export class PerformanceTracker {
-    metrics = new Map();
-    /**
-     * Start tracking performance for an operation
-     */
-    start(operationName) {
-        this.metrics.set(operationName, {
-            startTime: Date.now(),
-            memoryStart: process.memoryUsage(),
-        });
-    }
-    /**
-     * End tracking and calculate metrics
-     */
-    end(operationName) {
-        const metric = this.metrics.get(operationName);
-        if (!metric) {
-            return null;
-        }
-        const endTime = Date.now();
-        const memoryEnd = process.memoryUsage();
-        const completedMetric = {
-            ...metric,
-            endTime,
-            duration: endTime - metric.startTime,
-            memoryEnd,
-            memoryDelta: {
-                rss: memoryEnd.rss - metric.memoryStart.rss,
-                heapTotal: memoryEnd.heapTotal - metric.memoryStart.heapTotal,
-                heapUsed: memoryEnd.heapUsed - metric.memoryStart.heapUsed,
-                external: memoryEnd.external - metric.memoryStart.external,
-            },
-        };
-        this.metrics.set(operationName, completedMetric);
-        return completedMetric;
-    }
-    /**
-     * Get metrics for an operation
-     */
-    getMetrics(operationName) {
-        return this.metrics.get(operationName) || null;
-    }
-    /**
-     * Clear all metrics
-     */
-    clear() {
-        this.metrics.clear();
-    }
-    /**
-     * Format metrics for display
-     */
-    formatMetrics(operationName) {
-        const metric = this.metrics.get(operationName);
-        if (!metric || !metric.duration) {
-            return `${operationName}: No metrics available`;
-        }
-        const memoryMB = (bytes) => (bytes / 1024 / 1024).toFixed(1);
-        if (!metric.memoryDelta) {
-            return [
-                `${operationName}:`,
-                `  Duration: ${metric.duration}ms`,
-                `  Memory Delta: Not available`,
-            ].join("\n");
-        }
-        const signHeap = metric.memoryDelta.heapUsed >= 0 ? "+" : "-";
-        const signRss = metric.memoryDelta.rss >= 0 ? "+" : "-";
-        return [
-            `${operationName}:`,
-            `  Duration: ${metric.duration}ms`,
-            `  Memory Delta: ${signHeap}${memoryMB(Math.abs(metric.memoryDelta.heapUsed))}MB heap`,
-            `  RSS Delta: ${signRss}${memoryMB(Math.abs(metric.memoryDelta.rss))}MB`,
-        ].join("\n");
-    }
-}
-/**
- * Global performance tracker instance
- */
-export const globalTracker = new PerformanceTracker();
-/**
- * Memory management utilities
- */
-export class MemoryManager {
-    /**
-     * Force garbage collection if available
-     */
-    static forceGC() {
-        if (typeof global !== "undefined" && global.gc) {
-            global.gc();
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Get current memory usage in MB
-     */
-    static getMemoryUsageMB() {
-        const usage = process.memoryUsage();
-        return {
-            rss: Math.round(usage.rss / 1024 / 1024),
-            heapTotal: Math.round(usage.heapTotal / 1024 / 1024),
-            heapUsed: Math.round(usage.heapUsed / 1024 / 1024),
-            external: Math.round(usage.external / 1024 / 1024),
-        };
-    }
-    /**
-     * Monitor memory usage and warn if it exceeds threshold
-     */
-    static monitorMemory(threshold = 100) {
-        const usage = this.getMemoryUsageMB();
-        if (usage.heapUsed > threshold) {
-            logger.warn(`⚠️ High memory usage: ${usage.heapUsed}MB heap (threshold: ${threshold}MB)`);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Clean up and optimize memory usage.
-     * Attempts to force garbage collection if available.
-     *
-     * @returns {object|null} Memory usage statistics if cleanup was performed, or null if not possible.
-     *   - If manual garbage collection is not available (i.e., Node.js not run with --expose-gc),
-     *     no cleanup is performed and null is returned.
-     *   - Clearing the require cache is not attempted due to potential side effects.
-     */
-    static cleanup() {
-        const before = this.getMemoryUsageMB();
-        const gcForced = this.forceGC();
-        if (!gcForced) {
-            // Manual garbage collection not available.
-            // No cleanup performed. Clearing require cache is dangerous and not attempted.
-            // Memory cleanup relies on Node.js natural garbage collection.
-            return null;
-        }
-        const after = this.getMemoryUsageMB();
-        return {
-            beforeMB: before.heapUsed,
-            afterMB: after.heapUsed,
-            freedMB: before.heapUsed - after.heapUsed,
-        };
-    }
-}
-/**
- * Decorator for tracking performance of async functions
- */
-export function trackPerformance(operationName) {
-    return function (_target, _propertyName, descriptor) {
-        const method = descriptor.value;
-        if (!method) {
-            throw new Error(`Method descriptor value is required for performance tracking`);
-        }
-        descriptor.value = async function (...args) {
-            globalTracker.start(operationName);
-            try {
-                const result = await method.apply(this, args);
-                globalTracker.end(operationName);
-                return result;
-            }
-            catch (error) {
-                globalTracker.end(operationName);
-                throw error;
-            }
-        };
-        return descriptor;
-    };
-}
-/**
- * Performance monitoring for CLI operations
- */
-export class CLIPerformanceMonitor {
-    static instance;
-    enabled = false;
-    static getInstance() {
-        if (!CLIPerformanceMonitor.instance) {
-            CLIPerformanceMonitor.instance = new CLIPerformanceMonitor();
-        }
-        return CLIPerformanceMonitor.instance;
-    }
-    enable() {
-        this.enabled = true;
-    }
-    disable() {
-        this.enabled = false;
-    }
-    /**
-     * Monitor a CLI operation
-     */
-    async monitorOperation(operationName, operation) {
-        if (!this.enabled) {
-            return operation();
-        }
-        globalTracker.start(operationName);
-        const startMemory = MemoryManager.getMemoryUsageMB();
-        try {
-            const result = await operation();
-            const metrics = globalTracker.end(operationName);
-            const endMemory = MemoryManager.getMemoryUsageMB();
-            if (metrics) {
-                logger.debug(`\n🔍 Performance: ${operationName}`);
-                logger.debug(`   Duration: ${metrics.duration}ms`);
-                logger.debug(`   Memory: ${startMemory.heapUsed}MB → ${endMemory.heapUsed}MB`);
-                logger.debug(`   Delta: +${endMemory.heapUsed - startMemory.heapUsed}MB`);
-            }
-            return result;
-        }
-        catch (error) {
-            globalTracker.end(operationName);
-            throw error;
-        }
-    }
-}
-/**
- * Export singleton monitor for easy access
- */
-export const cliMonitor = CLIPerformanceMonitor.getInstance();
-//# sourceMappingURL=performance.js.map

package/dist/lib/utils/piiDetector.d.ts

@@ -1,24 +0,0 @@
-/**
- * PII Detection Utility
- *
- * Standalone utility for detecting and redacting personally identifiable
- * information (PII) from text. Used by generate() and stream() directly.
- *
- * @module piiDetector
- */
-import type { PiiDetectionConfig, PiiDetectionResult } from "../types/index.js";
-/**
- * Detect and optionally redact PII from a text string.
- *
- * Detection runs per-field (each named segment scanned independently) so that
- * offset positions always refer to the correct field's text — not a concatenated
- * blob (Bug C3 fix).
- *
- * Custom patterns are validated before execution to prevent catastrophic
- * backtracking (Bug C10 fix).
- *
- * @param text - The input text to scan
- * @param config - PII detection configuration
- * @returns Detection result with (optionally) redacted text and found PII
- */
-export declare function detectAndRedactPII(text: string, config: PiiDetectionConfig): Promise<PiiDetectionResult>;

package/dist/lib/utils/piiDetector.js

@@ -1,221 +0,0 @@
-/**
- * PII Detection Utility
- *
- * Standalone utility for detecting and redacting personally identifiable
- * information (PII) from text. Used by generate() and stream() directly.
- *
- * @module piiDetector
- */
-import { logger } from "./logger.js";
-// ============================================================================
-// Built-in patterns
-// ============================================================================
-const PII_PATTERNS = {
-    email: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/gi,
-    phone: /\b(\+?1[-.\s]?)?(\(?\d{3}\)?[-.\s]?)?\d{3}[-.\s]?\d{4}\b/g,
-    ssn: /\b\d{3}[-\s]?\d{2}[-\s]?\d{4}\b/g,
-    creditCard: /\b(?:\d{4}[-\s]?){3}\d{4}\b/g,
-    ipAddress: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g,
-    address: /\b\d+\s+[\w\s]+(?:street|st|avenue|ave|road|rd|boulevard|blvd|drive|dr|lane|ln|court|ct)\b/gi,
-    name: /\b[A-Z][a-z]+\s+[A-Z][a-z]+\b/g,
-    dateOfBirth: /\b(?:0?[1-9]|1[0-2])[-/](?:0?[1-9]|[12]\d|3[01])[-/](?:19|20)\d{2}\b/g,
-    passport: /\b[A-Z]{1,2}\d{6,9}\b/g,
-    driversLicense: /\b[A-Z]{1,2}\d{5,8}\b/g,
-};
-const DEFAULT_PII_TYPES = ["email", "phone", "ssn", "creditCard"];
-// ============================================================================
-// Catastrophic backtracking detection (Bug C10)
-// ============================================================================
-/**
- * Heuristic check for patterns that can cause catastrophic backtracking.
- * Looks for nested quantifiers such as (a+)+ or (a*)* and similar structures.
- */
-function hasCatastrophicBacktracking(pattern) {
-    const src = pattern.source;
-    // Simple string-based check for nested quantifiers: (X+)+ (X*)+ etc.
-    // Avoids using a regex here (CodeQL flags polynomial regex on untrusted input).
-    for (let i = 0; i < src.length - 1; i++) {
-        if (src[i] === ")" && (src[i + 1] === "+" || src[i + 1] === "*")) {
-            // Found a closing group followed by a quantifier — check if the group
-            // itself contains a quantifier.
-            const groupEnd = i;
-            let depth = 1;
-            let j = groupEnd - 1;
-            while (j >= 0 && depth > 0) {
-                if (src[j] === ")") {
-                    depth++;
-                }
-                if (src[j] === "(") {
-                    depth--;
-                }
-                j--;
-            }
-            const groupStart = j + 1;
-            const groupBody = src.slice(groupStart + 1, groupEnd);
-            if (groupBody.includes("+") || groupBody.includes("*")) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-/**
- * Validate a custom RegExp before use (Bug C10).
- * Returns an error string if invalid, or null if safe.
- */
-function validateCustomPattern(pattern) {
-    if (!(pattern instanceof RegExp)) {
-        return "Custom pattern is not a RegExp instance";
-    }
-    if (hasCatastrophicBacktracking(pattern)) {
-        return `Custom pattern /${pattern.source}/ contains nested quantifiers that may cause catastrophic backtracking`;
-    }
-    return null;
-}
-// ============================================================================
-// Per-field detection helpers (Bug C3 fix)
-// ============================================================================
-/**
- * Scan a single field's text with one regex pattern.
- * Returns DetectedPII entries with field-local offsets.
- */
-function scanField(fieldText, fieldName, type, pattern) {
-    // Reset lastIndex to avoid cross-call state leaking between scans.
-    // We mutate the pattern's lastIndex directly rather than constructing a new
-    // RegExp from .source/.flags (which CodeQL flags as regex injection).
-    pattern.lastIndex = 0;
-    const regex = pattern;
-    const results = [];
-    let match = regex.exec(fieldText);
-    while (match !== null) {
-        results.push({
-            type,
-            value: match[0],
-            position: { start: match.index, end: match.index + match[0].length },
-            field: fieldName,
-        });
-        // Guard against zero-width matches causing infinite loops
-        if (match[0].length === 0) {
-            regex.lastIndex++;
-        }
-        match = regex.exec(fieldText);
-    }
-    return results;
-}
-/**
- * Apply redactions to a single field's text given its DetectedPII entries.
- * Redacts in reverse position order so earlier offsets stay valid.
- */
-function redactField(fieldText, hits, redactionText) {
-    // Sort descending by start position
-    const sorted = [...hits].sort((a, b) => b.position.start - a.position.start);
-    let result = fieldText;
-    for (const hit of sorted) {
-        result =
-            result.slice(0, hit.position.start) +
-                redactionText +
-                result.slice(hit.position.end);
-    }
-    return result;
-}
-// ============================================================================
-// Public API
-// ============================================================================
-/**
- * Detect and optionally redact PII from a text string.
- *
- * Detection runs per-field (each named segment scanned independently) so that
- * offset positions always refer to the correct field's text — not a concatenated
- * blob (Bug C3 fix).
- *
- * Custom patterns are validated before execution to prevent catastrophic
- * backtracking (Bug C10 fix).
- *
- * @param text - The input text to scan
- * @param config - PII detection configuration
- * @returns Detection result with (optionally) redacted text and found PII
- */
-export async function detectAndRedactPII(text, config) {
-    const { action, detectTypes = DEFAULT_PII_TYPES, customPatterns = [], allowList = [], redactionText = "[REDACTED]", } = config;
-    if (!text) {
-        return { text, detectedPII: [], action: "continue" };
-    }
-    // Validate custom patterns up-front (Bug C10)
-    const validatedCustomPatterns = [];
-    for (const pattern of customPatterns) {
-        const err = validateCustomPattern(pattern);
-        if (err) {
-            logger.warn(`piiDetector: skipping invalid custom pattern — ${err}`);
-            continue;
-        }
-        validatedCustomPatterns.push(pattern);
-    }
-    const allDetected = [];
-    // Scan built-in PII types (Bug C3: scan the field in isolation)
-    for (const piiType of detectTypes) {
-        if (allowList.includes(piiType)) {
-            continue;
-        }
-        const pattern = PII_PATTERNS[piiType];
-        if (!pattern) {
-            continue;
-        }
-        const hits = scanField(text, "text", piiType, pattern);
-        allDetected.push(...hits);
-    }
-    // Scan custom patterns
-    for (const pattern of validatedCustomPatterns) {
-        let hits = [];
-        try {
-            hits = scanField(text, "text", "custom", pattern);
-        }
-        catch (err) {
-            logger.warn(`piiDetector: custom pattern /${pattern.source}/ threw during execution — skipping`, err);
-        }
-        allDetected.push(...hits);
-    }
-    if (allDetected.length === 0) {
-        if (logger.shouldLog("debug")) {
-            logger.debug("piiDetector: no PII detected in input");
-        }
-        return { text, detectedPII: [], action: "continue" };
-    }
-    if (logger.shouldLog("debug")) {
-        logger.debug(`piiDetector: detected ${allDetected.length} PII occurrence(s) — action=${action}`);
-    }
-    // Summarise findings for feedback
-    const typeCounts = allDetected.reduce((acc, d) => {
-        acc[d.type] = (acc[d.type] ?? 0) + 1;
-        return acc;
-    }, {});
-    const summary = Object.entries(typeCounts)
-        .map(([t, n]) => `${t} (${n})`)
-        .join(", ");
-    if (action === "abort") {
-        return {
-            text,
-            detectedPII: allDetected,
-            action: "abort",
-            feedback: `PII detected: ${summary}. Request blocked for security.`,
-        };
-    }
-    if (action === "redact") {
-        // Redact per-field (Bug C3: field hits already carry field-local offsets)
-        const fieldHits = allDetected.filter((d) => d.field === "text");
-        const redactedText = redactField(text, fieldHits, redactionText);
-        return {
-            text: redactedText,
-            detectedPII: allDetected,
-            action: "continue",
-            feedback: `PII redacted: ${summary}.`,
-        };
-    }
-    // action === "warn"
-    return {
-        text,
-        detectedPII: allDetected,
-        action: "continue",
-        feedback: `PII detected (not redacted): ${summary}.`,
-    };
-}
-//# sourceMappingURL=piiDetector.js.map

package/dist/lib/utils/pricing.d.ts

@@ -1,26 +0,0 @@
-import type { TokenUsage } from "../types/index.js";
-/**
- * Calculate the dollar cost of a generate/stream call based on token usage.
- * Returns 0 if the provider/model combination is not in the pricing table.
- */
-export declare function calculateCost(provider: string, model: string, usage: TokenUsage): number;
-/**
- * Check if pricing is available for a provider/model combination.
- * Checks the rate table directly instead of computing a cost,
- * so even very cheap models (e.g. gemini-1.5-flash) are detected correctly.
- *
- * Zero-rate entries (the local-provider `_default` for lm-studio / llamacpp)
- * count as "no pricing" — those providers explicitly don't have an upstream
- * USD price, and any caller gated by `hasPricing()` should treat them as
- * non-billable rather than zero-cost-billable.
- */
-/**
- * Whether a model's rates came from an exact table entry or were inferred.
- *
- * `findRates` falls back to a longest-prefix match, so an unlisted model can
- * silently inherit a listed one's rates — e.g. "gpt-5.6-sol" matches the
- * "gpt-5" entry and is billed at its price. That is a guess, not a quote, and
- * a caller reporting spend needs to be able to say which it had.
- */
-export declare function isExactPricingMatch(provider: string, model: string): boolean;
-export declare function hasPricing(provider: string, model: string): boolean;