@llm-dev-ops/agentics-cli 1.4.25 → 1.4.27

package/dist/bundled-agents/policy-engine-agents/dist/functions/core/primitives/pii-detector.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * PII (Personally Identifiable Information) Detector
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PIIDetector = void 0;
+var PIIDetector = /** @class */ (function () {
+    function PIIDetector() {
+        // Regex patterns for PII detection
+        this.patterns = {
+            email: /[\p{L}\p{N}._%+-]+@[\p{L}\p{N}.-]+\.[\p{L}]{2,}/gu,
+            phone: /(\+?\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}/g,
+            ssn: /\b\d{3}-\d{2}-\d{4}\b/g,
+            credit_card: /\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b/g,
+            ip_address: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g,
+            name: /\b[A-Z][a-z]+ [A-Z][a-z]+\b/g, // Simple name pattern (First Last)
+            address: /\b\d+\s+[A-Za-z]+\s+(?:Street|St|Avenue|Ave|Road|Rd|Boulevard|Blvd|Lane|Ln|Drive|Dr|Court|Ct|Circle|Cir)\b/gi,
+            date_of_birth: /\b(?:\d{1,2}[-/]\d{1,2}[-/]\d{2,4})|(?:\d{2,4}[-/]\d{1,2}[-/]\d{1,2})\b/g,
+        };
+    }
+    /**
+     * Detect PII in text
+     */
+    PIIDetector.prototype.detectPII = function (text) {
+        var matches = [];
+        for (var _i = 0, _a = Object.entries(this.patterns); _i < _a.length; _i++) {
+            var _b = _a[_i], type = _b[0], pattern = _b[1];
+            var regex = new RegExp(pattern.source, pattern.flags);
+            var match = void 0;
+            while ((match = regex.exec(text)) !== null) {
+                matches.push({
+                    type: type,
+                    value: match[0],
+                    start: match.index,
+                    end: match.index + match[0].length,
+                    confidence: this.getConfidence(type, match[0]),
+                });
+            }
+        }
+        return matches;
+    };
+    /**
+     * Check if text contains PII
+     */
+    PIIDetector.prototype.containsPII = function (text) {
+        return this.detectPII(text).length > 0;
+    };
+    /**
+     * Redact PII from text
+     */
+    PIIDetector.prototype.redactPII = function (text, redactionChar) {
+        if (redactionChar === void 0) { redactionChar = '*'; }
+        var matches = this.detectPII(text)
+            .sort(function (a, b) { return b.start - a.start; }); // Sort in reverse order to maintain indices
+        var redactedText = text;
+        for (var _i = 0, matches_1 = matches; _i < matches_1.length; _i++) {
+            var match = matches_1[_i];
+            var redaction = redactionChar.repeat(match.value.length);
+            redactedText =
+                redactedText.substring(0, match.start) +
+                    redaction +
+                    redactedText.substring(match.end);
+        }
+        return redactedText;
+    };
+    /**
+     * Redact PII with type labels
+     */
+    PIIDetector.prototype.redactPIIWithLabels = function (text) {
+        var matches = this.detectPII(text)
+            .sort(function (a, b) { return b.start - a.start; });
+        var redactedText = text;
+        for (var _i = 0, matches_2 = matches; _i < matches_2.length; _i++) {
+            var match = matches_2[_i];
+            var redaction = "[".concat(match.type.toUpperCase(), "_REDACTED]");
+            redactedText =
+                redactedText.substring(0, match.start) +
+                    redaction +
+                    redactedText.substring(match.end);
+        }
+        return redactedText;
+    };
+    /**
+     * Get confidence level for a match
+     */
+    PIIDetector.prototype.getConfidence = function (type, value) {
+        switch (type) {
+            case 'email':
+                return value.includes('@') && value.includes('.') ? 'high' : 'medium';
+            case 'phone':
+                return value.replace(/\D/g, '').length === 10 || value.replace(/\D/g, '').length === 11
+                    ? 'high'
+                    : 'medium';
+            case 'ssn':
+                return value.match(/^\d{3}-\d{2}-\d{4}$/) ? 'high' : 'medium';
+            case 'credit_card':
+                return this.luhnCheck(value.replace(/\D/g, '')) ? 'high' : 'low';
+            case 'ip_address':
+                return this.isValidIP(value) ? 'high' : 'low';
+            case 'name':
+                return 'low'; // Name patterns are less reliable
+            case 'address':
+                return 'medium';
+            case 'date_of_birth':
+                return 'medium';
+            default:
+                return 'low';
+        }
+    };
+    /**
+     * Luhn algorithm for credit card validation
+     */
+    PIIDetector.prototype.luhnCheck = function (cardNumber) {
+        var sum = 0;
+        var isEven = false;
+        for (var i = cardNumber.length - 1; i >= 0; i--) {
+            var digit = parseInt(cardNumber[i], 10);
+            if (isEven) {
+                digit *= 2;
+                if (digit > 9) {
+                    digit -= 9;
+                }
+            }
+            sum += digit;
+            isEven = !isEven;
+        }
+        return sum % 10 === 0;
+    };
+    /**
+     * Validate IP address
+     */
+    PIIDetector.prototype.isValidIP = function (ip) {
+        var parts = ip.split('.');
+        if (parts.length !== 4)
+            return false;
+        return parts.every(function (part) {
+            var num = parseInt(part, 10);
+            return num >= 0 && num <= 255;
+        });
+    };
+    return PIIDetector;
+}());
+exports.PIIDetector = PIIDetector;

package/dist/bundled-agents/policy-engine-agents/dist/functions/core/primitives/token-counter.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Token Counter for LLM requests
+ * Provides estimates for different providers and models
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenCounter = void 0;
+var TokenCounter = /** @class */ (function () {
+    function TokenCounter() {
+    }
+    /**
+     * Estimate tokens for text using simple heuristic (4 chars per token)
+     * This is a rough estimate. In production, use tiktoken or provider-specific APIs
+     */
+    TokenCounter.prototype.estimateTokens = function (text, model) {
+        if (!text) {
+            return { tokens: 0, method: 'exact' };
+        }
+        // Simple heuristic: ~4 characters per token (works reasonably well for English)
+        var estimatedTokens = Math.ceil(text.length / 4);
+        // Model-specific adjustments
+        var tokens = estimatedTokens;
+        if (model) {
+            // GPT-4, GPT-3.5 typically average ~4 chars/token
+            if (model.includes('gpt-4') || model.includes('gpt-3.5')) {
+                tokens = estimatedTokens;
+            }
+            // Claude models typically average ~4 chars/token
+            else if (model.includes('claude')) {
+                tokens = estimatedTokens;
+            }
+            // PaLM models typically average ~4.5 chars/token
+            else if (model.includes('palm') || model.includes('gemini')) {
+                tokens = Math.ceil(text.length / 4.5);
+            }
+        }
+        return { tokens: tokens, method: 'estimate' };
+    };
+    /**
+     * Estimate tokens for a conversation (array of messages)
+     */
+    TokenCounter.prototype.estimateConversationTokens = function (messages, model) {
+        var totalTokens = 0;
+        for (var _i = 0, messages_1 = messages; _i < messages_1.length; _i++) {
+            var message = messages_1[_i];
+            var tokens = this.estimateTokens(message.content, model).tokens;
+            totalTokens += tokens;
+            // Add overhead for message formatting (role, separators, etc.)
+            totalTokens += 4; // Approximate overhead per message
+        }
+        // Add overhead for conversation formatting
+        totalTokens += 3; // Approximate base overhead
+        return { tokens: totalTokens, method: 'estimate' };
+    };
+    /**
+     * Calculate maximum tokens for a request
+     */
+    TokenCounter.prototype.calculateMaxTokens = function (promptTokens, modelMaxTokens, completionTokens) {
+        var maxCompletion = completionTokens || modelMaxTokens;
+        var available = modelMaxTokens - promptTokens;
+        return Math.min(maxCompletion, Math.max(0, available));
+    };
+    /**
+     * Get model context window size
+     */
+    TokenCounter.prototype.getModelMaxTokens = function (model) {
+        // Common model context windows
+        var modelLimits = {
+            'gpt-4-turbo': 128000,
+            'gpt-4': 8192,
+            'gpt-4-32k': 32768,
+            'gpt-3.5-turbo': 4096,
+            'gpt-3.5-turbo-16k': 16384,
+            'claude-3-opus': 200000,
+            'claude-3-sonnet': 200000,
+            'claude-3-haiku': 200000,
+            'claude-2.1': 200000,
+            'claude-2': 100000,
+            'claude-instant': 100000,
+            'gemini-pro': 32768,
+            'gemini-ultra': 32768,
+            'palm-2': 8192,
+        };
+        // Find matching model (case-insensitive, partial match)
+        // Sort keys by length descending to match most specific model first
+        var modelKey = Object.keys(modelLimits)
+            .sort(function (a, b) { return b.length - a.length; })
+            .find(function (key) { return model.toLowerCase().includes(key.toLowerCase()); });
+        return modelKey ? modelLimits[modelKey] : 4096; // Default to 4096 if unknown
+    };
+    return TokenCounter;
+}());
+exports.TokenCounter = TokenCounter;

package/dist/bundled-agents/policy-engine-agents/dist/functions/db/client.js

@@ -0,0 +1,204 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.db = void 0;
+/**
+ * Database client using pg (PostgreSQL)
+ */
+var pg_1 = require("pg");
+var config_1 = require("../utils/config");
+var logger_1 = __importDefault(require("../utils/logger"));
+var errors_1 = require("../utils/errors");
+var DatabaseClient = /** @class */ (function () {
+    function DatabaseClient() {
+        var _this = this;
+        this.isConnected = false;
+        this.pool = new pg_1.Pool({
+            connectionString: config_1.config.database.url,
+            min: config_1.config.database.poolMin,
+            max: config_1.config.database.poolMax,
+            ssl: config_1.config.database.ssl ? { rejectUnauthorized: false } : false,
+            idleTimeoutMillis: 30000,
+            connectionTimeoutMillis: 2000,
+        });
+        this.pool.on('error', function (err) {
+            logger_1.default.error({ error: err }, 'Unexpected database pool error');
+        });
+        this.pool.on('connect', function () {
+            if (!_this.isConnected) {
+                logger_1.default.info('Database pool connected');
+                _this.isConnected = true;
+            }
+        });
+    }
+    /**
+     * Execute a query
+     */
+    DatabaseClient.prototype.query = function (text, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var start, result, duration, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        start = Date.now();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.pool.query(text, params)];
+                    case 2:
+                        result = _a.sent();
+                        duration = Date.now() - start;
+                        logger_1.default.debug({ text: text, duration: duration, rows: result.rowCount }, 'Query executed');
+                        return [2 /*return*/, result];
+                    case 3:
+                        error_1 = _a.sent();
+                        logger_1.default.error({ text: text, params: params, error: error_1 }, 'Query failed');
+                        throw new errors_1.DatabaseError("Query failed: ".concat(error_1 instanceof Error ? error_1.message : String(error_1)), { query: text, params: params });
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get a client from the pool for transactions
+     */
+    DatabaseClient.prototype.getClient = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var client, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.pool.connect()];
+                    case 1:
+                        client = _a.sent();
+                        return [2 /*return*/, client];
+                    case 2:
+                        error_2 = _a.sent();
+                        throw new errors_1.DatabaseError("Failed to get database client: ".concat(error_2 instanceof Error ? error_2.message : String(error_2)));
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Execute a transaction
+     */
+    DatabaseClient.prototype.transaction = function (callback) {
+        return __awaiter(this, void 0, void 0, function () {
+            var client, result, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getClient()];
+                    case 1:
+                        client = _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 6, 8, 9]);
+                        return [4 /*yield*/, client.query('BEGIN')];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, callback(client)];
+                    case 4:
+                        result = _a.sent();
+                        return [4 /*yield*/, client.query('COMMIT')];
+                    case 5:
+                        _a.sent();
+                        return [2 /*return*/, result];
+                    case 6:
+                        error_3 = _a.sent();
+                        return [4 /*yield*/, client.query('ROLLBACK')];
+                    case 7:
+                        _a.sent();
+                        throw error_3;
+                    case 8:
+                        client.release();
+                        return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Check database connection
+     */
+    DatabaseClient.prototype.ping = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.query('SELECT 1')];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, true];
+                    case 2:
+                        error_4 = _a.sent();
+                        logger_1.default.error({ error: error_4 }, 'Database ping failed');
+                        return [2 /*return*/, false];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Close database connection
+     */
+    DatabaseClient.prototype.close = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.pool.end()];
+                    case 1:
+                        _a.sent();
+                        this.isConnected = false;
+                        logger_1.default.info('Database pool closed');
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return DatabaseClient;
+}());
+// Export singleton instance
+exports.db = new DatabaseClient();
+exports.default = exports.db;