agentic-qe
Version:
Agentic Quality Engineering Fleet System - AI-driven quality management platform
216 lines • 8.47 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.EnhancedSwarmMemoryManager = void 0;
const SwarmMemoryManager_1 = require("./SwarmMemoryManager");
const VersionHistory_1 = require("./VersionHistory");
const EncryptionManager_1 = require("./EncryptionManager");
const CompressionManager_1 = require("./CompressionManager");
const crypto = __importStar(require("crypto"));
/**
* EnhancedSwarmMemoryManager - Extends SwarmMemoryManager with advanced features
*
* Additional Features:
* - Version history (last 10 versions)
* - Encryption (AES-256-GCM)
* - Compression (gzip/deflate)
* - Checksum validation
*/
class EnhancedSwarmMemoryManager extends SwarmMemoryManager_1.SwarmMemoryManager {
constructor(dbPath = ':memory:') {
super(dbPath);
this.versionHistory = new VersionHistory_1.VersionHistory(this);
this.encryption = new EncryptionManager_1.EncryptionManager();
this.compression = new CompressionManager_1.CompressionManager();
}
/**
* Store with advanced features: encryption, compression, versioning
*/
async storeEnhanced(key, value, options = {}) {
let processedValue = JSON.stringify(value);
const enhancedMetadata = { ...options.metadata };
// Compression
if (options.compress) {
const threshold = options.compressionThreshold || 1024;
if (this.compression.shouldCompress(processedValue, threshold)) {
processedValue = await this.compression.compress(processedValue);
enhancedMetadata.compressed = true;
enhancedMetadata.compressionAlgorithm = 'gzip';
}
}
// Encryption
if (options.encrypt && options.encryptionKey) {
processedValue = await this.encryption.encrypt(processedValue, options.encryptionKey);
enhancedMetadata.encrypted = true;
enhancedMetadata.encryptionAlgorithm = 'aes-256-gcm';
}
// Checksum
const checksum = crypto.createHash('sha256').update(processedValue).digest('hex');
enhancedMetadata.checksum = checksum;
// Store with base implementation
await this.store(key, processedValue, {
...options,
metadata: enhancedMetadata
});
// Version history
if (options.enableVersioning) {
await this.versionHistory.store(key, value, {
partition: options.partition,
ttl: options.ttl,
metadata: enhancedMetadata
});
}
}
/**
* Retrieve with advanced features: decryption, decompression, checksum validation
*/
async retrieveEnhanced(key, options = {}) {
// Get raw value from base implementation
const rawValue = await this.retrieve(key, options);
if (!rawValue) {
return null;
}
// If value is already parsed object (not string), return as-is
if (typeof rawValue !== 'string') {
return rawValue;
}
let processedValue = rawValue;
// Get metadata to determine processing steps
const partition = options.partition || 'default';
const metadataQuery = `SELECT metadata FROM memory_entries WHERE key = ? AND partition = ?`;
const row = await this.get(metadataQuery, [key, partition]);
const metadata = row?.metadata ? JSON.parse(row.metadata) : {};
// Checksum validation
if (options.validateChecksum && metadata.checksum) {
const calculatedChecksum = crypto.createHash('sha256').update(processedValue).digest('hex');
if (calculatedChecksum !== metadata.checksum) {
throw new Error(`Checksum validation failed for key: ${key}`);
}
}
// Decryption
if (metadata.encrypted && options.encryptionKey) {
processedValue = await this.encryption.decrypt(processedValue, options.encryptionKey);
}
// Decompression
if (metadata.compressed) {
processedValue = await this.compression.decompress(processedValue);
}
return JSON.parse(processedValue);
}
/**
* Get version history for a key
*/
async getHistory(key, options) {
return this.versionHistory.getHistory(key, options);
}
/**
* Rollback to a specific version
*/
async rollbackToVersion(key, timestamp, options) {
return this.versionHistory.rollback(key, timestamp, options);
}
/**
* Get latest version
*/
async getLatestVersion(key, options) {
return this.versionHistory.getLatest(key, options);
}
/**
* Validate data integrity
*/
async validateIntegrity(key, options) {
const partition = options?.partition || 'default';
const metadataQuery = `SELECT metadata, value FROM memory_entries WHERE key = ? AND partition = ?`;
const row = await this.get(metadataQuery, [key, partition]);
if (!row || !row.metadata) {
return false;
}
const metadata = JSON.parse(row.metadata);
if (!metadata.checksum) {
return false;
}
const calculatedChecksum = crypto.createHash('sha256').update(row.value).digest('hex');
return calculatedChecksum === metadata.checksum;
}
/**
* Batch store with advanced features
*/
async batchStoreEnhanced(entries) {
for (const entry of entries) {
await this.storeEnhanced(entry.key, entry.value, entry.options);
}
}
/**
* Batch retrieve with advanced features
*/
async batchRetrieveEnhanced(keys, options) {
const results = [];
for (const key of keys) {
const value = await this.retrieveEnhanced(key, options);
results.push({ key, value });
}
return results;
}
/**
* Get comprehensive statistics including advanced features
*/
async getEnhancedStats() {
const baseStats = await this.stats();
// Count entries with advanced features
const advancedQuery = `SELECT metadata FROM memory_entries WHERE metadata IS NOT NULL`;
const rows = await this.all(advancedQuery);
let compressed = 0;
let encrypted = 0;
const compressionRatios = [];
for (const row of rows) {
try {
const metadata = JSON.parse(row.metadata);
if (metadata.compressed)
compressed++;
if (metadata.encrypted)
encrypted++;
if (metadata.compressionRatio) {
compressionRatios.push(metadata.compressionRatio);
}
}
catch {
// Ignore parse errors
}
}
const versionedCount = await this.versionHistory.getVersionCount('*');
const averageCompressionRatio = compressionRatios.length > 0
? compressionRatios.reduce((a, b) => a + b, 0) / compressionRatios.length
: undefined;
return {
...baseStats,
compressed,
encrypted,
versioned: versionedCount,
averageCompressionRatio
};
}
}
exports.EnhancedSwarmMemoryManager = EnhancedSwarmMemoryManager;
//# sourceMappingURL=EnhancedSwarmMemoryManager.js.map