agentic-qe 2.3.2 → 2.3.4

package/dist/learning/scheduler/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * Learning Scheduler Module
+ *
+ * Provides scheduling infrastructure for the Nightly-Learner system:
+ * - IdleDetector: Monitor system idle state
+ * - SleepScheduler: Orchestrate learning cycles
+ * - SleepCycle: Execute learning phases
+ * - TimeBasedTrigger: Cron-like fallback scheduling
+ *
+ * @module src/learning/scheduler
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeBasedTrigger = exports.SleepCycle = exports.SleepScheduler = exports.IdleDetector = void 0;
+var IdleDetector_1 = require("./IdleDetector");
+Object.defineProperty(exports, "IdleDetector", { enumerable: true, get: function () { return IdleDetector_1.IdleDetector; } });
+var SleepScheduler_1 = require("./SleepScheduler");
+Object.defineProperty(exports, "SleepScheduler", { enumerable: true, get: function () { return SleepScheduler_1.SleepScheduler; } });
+var SleepCycle_1 = require("./SleepCycle");
+Object.defineProperty(exports, "SleepCycle", { enumerable: true, get: function () { return SleepCycle_1.SleepCycle; } });
+var TimeBasedTrigger_1 = require("./TimeBasedTrigger");
+Object.defineProperty(exports, "TimeBasedTrigger", { enumerable: true, get: function () { return TimeBasedTrigger_1.TimeBasedTrigger; } });
+//# sourceMappingURL=index.js.map

package/dist/learning/scheduler/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/learning/scheduler/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;;AAEH,+CAA6E;AAApE,4GAAA,YAAY,OAAA;AACrB,mDAM0B;AALxB,gHAAA,cAAc,OAAA;AAMhB,2CAMsB;AALpB,wGAAA,UAAU,OAAA;AAMZ,uDAI4B;AAH1B,oHAAA,gBAAgB,OAAA"}

package/dist/learning/synthesis/PatternSynthesis.d.ts

@@ -0,0 +1,162 @@
+/**
+ * PatternSynthesis - Identifies patterns from captured experiences
+ *
+ * Synthesizes actionable patterns from captured agent executions using
+ * clustering and analysis techniques.
+ *
+ * Part of the Nightly-Learner Phase 1 implementation.
+ *
+ * @version 1.0.0
+ * @module src/learning/synthesis/PatternSynthesis
+ */
+import { EventEmitter } from 'events';
+import { CapturedExperience } from '../capture/ExperienceCapture';
+export type PatternType = 'success_strategy' | 'failure_avoidance' | 'efficiency_optimization';
+export interface SynthesizedPattern {
+    id: string;
+    type: PatternType;
+    description: string;
+    conditions: string[];
+    actions: string[];
+    confidence: number;
+    supportingExperiences: string[];
+    effectiveness: number;
+    agentTypes: string[];
+    taskTypes: string[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface Cluster {
+    id: string;
+    experiences: CapturedExperience[];
+    centroid?: number[];
+    size: number;
+    averageQuality: number;
+    commonAgentTypes: string[];
+    commonTaskTypes: string[];
+}
+export interface SynthesisOptions {
+    /** Specific experience IDs to process */
+    experienceIds?: string[];
+    /** Minimum experiences to form pattern. Default: 3 */
+    minSupport?: number;
+    /** Minimum confidence threshold. Default: 0.7 */
+    minConfidence?: number;
+    /** Maximum patterns to generate. Default: 20 */
+    maxPatterns?: number;
+    /** Focus on specific agent types */
+    agentTypes?: string[];
+    /** Focus on specific task types */
+    taskTypes?: string[];
+}
+export interface SynthesisResult {
+    patterns: SynthesizedPattern[];
+    clustersAnalyzed: number;
+    experiencesProcessed: number;
+    duration: number;
+    stats: {
+        successStrategies: number;
+        failureAvoidances: number;
+        efficiencyOptimizations: number;
+        averageConfidence: number;
+    };
+}
+export interface PatternSynthesisConfig {
+    /** Database path. Default: .agentic-qe/memory.db */
+    dbPath?: string;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * PatternSynthesis identifies patterns from agent experiences
+ *
+ * @example
+ * ```typescript
+ * const synthesis = new PatternSynthesis();
+ *
+ * const result = await synthesis.synthesize({
+ *   minSupport: 3,
+ *   minConfidence: 0.7,
+ *   maxPatterns: 20,
+ * });
+ *
+ * console.log(`Discovered ${result.patterns.length} patterns`);
+ * ```
+ */
+export declare class PatternSynthesis extends EventEmitter {
+    private config;
+    private db;
+    private logger;
+    constructor(config?: PatternSynthesisConfig);
+    /**
+     * Initialize database schema for patterns
+     */
+    private initializeSchema;
+    /**
+     * Synthesize patterns from experiences
+     */
+    synthesize(options?: SynthesisOptions): Promise<SynthesisResult>;
+    /**
+     * Get stored patterns
+     */
+    getPatterns(options?: {
+        type?: PatternType;
+        minConfidence?: number;
+        agentType?: string;
+        limit?: number;
+    }): SynthesizedPattern[];
+    /**
+     * Get pattern by ID
+     */
+    getPattern(id: string): SynthesizedPattern | null;
+    /**
+     * Update pattern effectiveness based on new evidence
+     */
+    updateEffectiveness(patternId: string, success: boolean): void;
+    /**
+     * Get experiences for synthesis
+     */
+    private getExperiences;
+    /**
+     * Cluster experiences by similarity
+     */
+    private clusterExperiences;
+    /**
+     * Extract a pattern from a cluster
+     */
+    private extractPatternFromCluster;
+    /**
+     * Extract common conditions from experiences
+     */
+    private extractConditions;
+    /**
+     * Extract common actions from experiences
+     */
+    private extractActions;
+    /**
+     * Calculate confidence score for a cluster
+     */
+    private calculateConfidence;
+    /**
+     * Generate a human-readable description
+     */
+    private generateDescription;
+    /**
+     * Store patterns in database
+     */
+    private storePatterns;
+    /**
+     * Convert database row to experience
+     */
+    private rowToExperience;
+    /**
+     * Convert database row to pattern
+     */
+    private rowToPattern;
+    /**
+     * Close database connection
+     */
+    close(): void;
+}
+export default PatternSynthesis;
+//# sourceMappingURL=PatternSynthesis.d.ts.map

package/dist/learning/synthesis/PatternSynthesis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PatternSynthesis.d.ts","sourceRoot":"","sources":["../../../src/learning/synthesis/PatternSynthesis.ts"],"names":[],"mappings":"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"}

package/dist/learning/synthesis/PatternSynthesis.js

@@ -0,0 +1,479 @@
+"use strict";
+/**
+ * PatternSynthesis - Identifies patterns from captured experiences
+ *
+ * Synthesizes actionable patterns from captured agent executions using
+ * clustering and analysis techniques.
+ *
+ * Part of the Nightly-Learner Phase 1 implementation.
+ *
+ * @version 1.0.0
+ * @module src/learning/synthesis/PatternSynthesis
+ */
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatternSynthesis = void 0;
+const events_1 = require("events");
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const path = __importStar(require("path"));
+const Logger_1 = require("../../utils/Logger");
+const SecureRandom_1 = require("../../utils/SecureRandom");
+/**
+ * PatternSynthesis identifies patterns from agent experiences
+ *
+ * @example
+ * ```typescript
+ * const synthesis = new PatternSynthesis();
+ *
+ * const result = await synthesis.synthesize({
+ *   minSupport: 3,
+ *   minConfidence: 0.7,
+ *   maxPatterns: 20,
+ * });
+ *
+ * console.log(`Discovered ${result.patterns.length} patterns`);
+ * ```
+ */
+class PatternSynthesis extends events_1.EventEmitter {
+    constructor(config) {
+        super();
+        this.logger = Logger_1.Logger.getInstance();
+        this.config = {
+            dbPath: config?.dbPath || path.join(process.cwd(), '.agentic-qe', 'memory.db'),
+            debug: config?.debug ?? false,
+        };
+        this.db = new better_sqlite3_1.default(this.config.dbPath);
+        this.initializeSchema();
+    }
+    /**
+     * Initialize database schema for patterns
+     */
+    initializeSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS synthesized_patterns (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL,
+        description TEXT NOT NULL,
+        conditions TEXT NOT NULL,
+        actions TEXT NOT NULL,
+        confidence REAL NOT NULL,
+        supporting_experiences TEXT NOT NULL,
+        effectiveness REAL NOT NULL,
+        agent_types TEXT NOT NULL,
+        task_types TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_synth_type ON synthesized_patterns(type);
+      CREATE INDEX IF NOT EXISTS idx_synth_confidence ON synthesized_patterns(confidence);
+      CREATE INDEX IF NOT EXISTS idx_synth_effectiveness ON synthesized_patterns(effectiveness);
+    `);
+    }
+    /**
+     * Synthesize patterns from experiences
+     */
+    async synthesize(options = {}) {
+        const startTime = Date.now();
+        const { minSupport = 3, minConfidence = 0.7, maxPatterns = 20 } = options;
+        this.logger.info('[PatternSynthesis] Starting synthesis', { options });
+        // 1. Retrieve experiences
+        const experiences = await this.getExperiences(options);
+        this.logger.debug('[PatternSynthesis] Retrieved experiences', { count: experiences.length });
+        if (experiences.length < minSupport) {
+            this.logger.info('[PatternSynthesis] Insufficient experiences for synthesis', {
+                found: experiences.length,
+                required: minSupport,
+            });
+            return {
+                patterns: [],
+                clustersAnalyzed: 0,
+                experiencesProcessed: experiences.length,
+                duration: Date.now() - startTime,
+                stats: { successStrategies: 0, failureAvoidances: 0, efficiencyOptimizations: 0, averageConfidence: 0 },
+            };
+        }
+        // 2. Cluster experiences
+        const clusters = await this.clusterExperiences(experiences);
+        this.logger.debug('[PatternSynthesis] Created clusters', { count: clusters.length });
+        // 3. Extract patterns from clusters
+        const patterns = [];
+        for (const cluster of clusters) {
+            if (cluster.size < minSupport)
+                continue;
+            if (patterns.length >= maxPatterns)
+                break;
+            const pattern = this.extractPatternFromCluster(cluster);
+            if (pattern.confidence >= minConfidence) {
+                patterns.push(pattern);
+                this.emit('pattern:discovered', pattern);
+            }
+        }
+        // 4. Store patterns
+        await this.storePatterns(patterns);
+        // 5. Calculate stats
+        const result = {
+            patterns,
+            clustersAnalyzed: clusters.length,
+            experiencesProcessed: experiences.length,
+            duration: Date.now() - startTime,
+            stats: {
+                successStrategies: patterns.filter(p => p.type === 'success_strategy').length,
+                failureAvoidances: patterns.filter(p => p.type === 'failure_avoidance').length,
+                efficiencyOptimizations: patterns.filter(p => p.type === 'efficiency_optimization').length,
+                averageConfidence: patterns.length > 0
+                    ? patterns.reduce((sum, p) => sum + p.confidence, 0) / patterns.length
+                    : 0,
+            },
+        };
+        this.logger.info('[PatternSynthesis] Synthesis complete', {
+            patterns: result.patterns.length,
+            duration: result.duration,
+        });
+        this.emit('synthesis:complete', result);
+        return result;
+    }
+    /**
+     * Get stored patterns
+     */
+    getPatterns(options = {}) {
+        let query = 'SELECT * FROM synthesized_patterns WHERE 1=1';
+        const params = [];
+        if (options.type) {
+            query += ' AND type = ?';
+            params.push(options.type);
+        }
+        if (options.minConfidence) {
+            query += ' AND confidence >= ?';
+            params.push(options.minConfidence);
+        }
+        if (options.agentType) {
+            query += ' AND agent_types LIKE ?';
+            params.push(`%${options.agentType}%`);
+        }
+        query += ' ORDER BY effectiveness DESC, confidence DESC';
+        if (options.limit) {
+            query += ' LIMIT ?';
+            params.push(options.limit);
+        }
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map(row => this.rowToPattern(row));
+    }
+    /**
+     * Get pattern by ID
+     */
+    getPattern(id) {
+        const row = this.db.prepare('SELECT * FROM synthesized_patterns WHERE id = ?').get(id);
+        return row ? this.rowToPattern(row) : null;
+    }
+    /**
+     * Update pattern effectiveness based on new evidence
+     */
+    updateEffectiveness(patternId, success) {
+        const pattern = this.getPattern(patternId);
+        if (!pattern)
+            return;
+        // Exponential moving average
+        const alpha = 0.1;
+        const newEffectiveness = pattern.effectiveness * (1 - alpha) + (success ? 1 : 0) * alpha;
+        this.db.prepare(`
+      UPDATE synthesized_patterns
+      SET effectiveness = ?, updated_at = ?
+      WHERE id = ?
+    `).run(newEffectiveness, Date.now(), patternId);
+        this.logger.debug('[PatternSynthesis] Updated pattern effectiveness', {
+            patternId,
+            oldEffectiveness: pattern.effectiveness,
+            newEffectiveness,
+        });
+    }
+    /**
+     * Get experiences for synthesis
+     */
+    async getExperiences(options) {
+        let query = `
+      SELECT * FROM captured_experiences
+      WHERE processed = 0
+    `;
+        const params = [];
+        if (options.experienceIds && options.experienceIds.length > 0) {
+            const placeholders = options.experienceIds.map(() => '?').join(',');
+            query = `SELECT * FROM captured_experiences WHERE id IN (${placeholders})`;
+            params.push(...options.experienceIds);
+        }
+        else {
+            if (options.agentTypes && options.agentTypes.length > 0) {
+                const placeholders = options.agentTypes.map(() => '?').join(',');
+                query += ` AND agent_type IN (${placeholders})`;
+                params.push(...options.agentTypes);
+            }
+            if (options.taskTypes && options.taskTypes.length > 0) {
+                const placeholders = options.taskTypes.map(() => '?').join(',');
+                query += ` AND task_type IN (${placeholders})`;
+                params.push(...options.taskTypes);
+            }
+            query += ' ORDER BY created_at DESC LIMIT 1000';
+        }
+        try {
+            const rows = this.db.prepare(query).all(...params);
+            return rows.map(row => this.rowToExperience(row));
+        }
+        catch (error) {
+            this.logger.warn('[PatternSynthesis] Error fetching experiences, returning empty', { error });
+            return [];
+        }
+    }
+    /**
+     * Cluster experiences by similarity
+     */
+    async clusterExperiences(experiences) {
+        // Group by agent type and task type for simple clustering
+        const clusterMap = new Map();
+        for (const exp of experiences) {
+            // Cluster key: agentType + success/failure
+            const key = `${exp.agentType}:${exp.execution.success ? 'success' : 'failure'}`;
+            const existing = clusterMap.get(key) || [];
+            existing.push(exp);
+            clusterMap.set(key, existing);
+        }
+        // Convert to cluster objects
+        const clusters = [];
+        let clusterId = 0;
+        for (const [key, exps] of clusterMap) {
+            const qualities = exps.map(e => e.outcome.quality_score);
+            const agentTypes = [...new Set(exps.map(e => e.agentType))];
+            const taskTypes = [...new Set(exps.map(e => e.taskType))];
+            clusters.push({
+                id: `cluster-${clusterId++}`,
+                experiences: exps,
+                size: exps.length,
+                averageQuality: qualities.reduce((a, b) => a + b, 0) / qualities.length,
+                commonAgentTypes: agentTypes,
+                commonTaskTypes: taskTypes,
+            });
+        }
+        // Sort by size descending
+        clusters.sort((a, b) => b.size - a.size);
+        return clusters;
+    }
+    /**
+     * Extract a pattern from a cluster
+     */
+    extractPatternFromCluster(cluster) {
+        const now = new Date();
+        // Determine pattern type based on cluster characteristics
+        let type;
+        if (cluster.averageQuality > 0.7) {
+            type = 'success_strategy';
+        }
+        else if (cluster.averageQuality < 0.3) {
+            type = 'failure_avoidance';
+        }
+        else {
+            type = 'efficiency_optimization';
+        }
+        // Extract common conditions
+        const conditions = this.extractConditions(cluster.experiences);
+        // Extract common actions
+        const actions = this.extractActions(cluster.experiences);
+        // Calculate confidence based on cluster consistency
+        const confidence = this.calculateConfidence(cluster);
+        // Calculate effectiveness
+        const effectiveness = cluster.averageQuality;
+        return {
+            id: `pattern-${Date.now()}-${SecureRandom_1.SecureRandom.randomString(6, 'alphanumeric')}`,
+            type,
+            description: this.generateDescription(type, cluster),
+            conditions,
+            actions,
+            confidence,
+            supportingExperiences: cluster.experiences.map(e => e.id),
+            effectiveness,
+            agentTypes: cluster.commonAgentTypes,
+            taskTypes: cluster.commonTaskTypes,
+            createdAt: now,
+            updatedAt: now,
+        };
+    }
+    /**
+     * Extract common conditions from experiences
+     */
+    extractConditions(experiences) {
+        const conditions = [];
+        // Common agent type
+        const agentTypes = [...new Set(experiences.map(e => e.agentType))];
+        if (agentTypes.length === 1) {
+            conditions.push(`agent_type == '${agentTypes[0]}'`);
+        }
+        // Common task type
+        const taskTypes = [...new Set(experiences.map(e => e.taskType))];
+        if (taskTypes.length === 1) {
+            conditions.push(`task_type == '${taskTypes[0]}'`);
+        }
+        // Extract common context patterns
+        for (const exp of experiences) {
+            if (exp.context.patterns_used.length > 0) {
+                conditions.push(`patterns_available`);
+                break;
+            }
+        }
+        return [...new Set(conditions)];
+    }
+    /**
+     * Extract common actions from experiences
+     */
+    extractActions(experiences) {
+        const actions = [];
+        // Collect all decisions made
+        const allDecisions = experiences.flatMap(e => e.context.decisions_made);
+        const decisionCounts = new Map();
+        for (const decision of allDecisions) {
+            decisionCounts.set(decision, (decisionCounts.get(decision) || 0) + 1);
+        }
+        // Add frequent decisions as actions
+        for (const [decision, count] of decisionCounts) {
+            if (count >= experiences.length * 0.5) { // Present in at least 50% of experiences
+                actions.push(decision);
+            }
+        }
+        // Add generic actions based on outcomes
+        const successRate = experiences.filter(e => e.execution.success).length / experiences.length;
+        if (successRate > 0.8) {
+            actions.push('replicate_approach');
+        }
+        else if (successRate < 0.3) {
+            actions.push('avoid_approach');
+        }
+        return actions;
+    }
+    /**
+     * Calculate confidence score for a cluster
+     */
+    calculateConfidence(cluster) {
+        // Base confidence from cluster size
+        let confidence = Math.min(1, cluster.size / 10); // Max out at 10 experiences
+        // Bonus for consistent outcomes
+        const outcomes = cluster.experiences.map(e => e.execution.success);
+        const successRate = outcomes.filter(Boolean).length / outcomes.length;
+        const consistency = Math.abs(successRate - 0.5) * 2; // 0 = mixed, 1 = consistent
+        confidence = confidence * 0.6 + consistency * 0.4;
+        // Bonus for consistent agent types
+        if (cluster.commonAgentTypes.length === 1) {
+            confidence += 0.1;
+        }
+        return Math.min(1, confidence);
+    }
+    /**
+     * Generate a human-readable description
+     */
+    generateDescription(type, cluster) {
+        const agentTypes = cluster.commonAgentTypes.join(', ');
+        const taskTypes = cluster.commonTaskTypes.join(', ');
+        switch (type) {
+            case 'success_strategy':
+                return `Successful approach for ${agentTypes} when performing ${taskTypes}`;
+            case 'failure_avoidance':
+                return `Failure pattern to avoid for ${agentTypes} during ${taskTypes}`;
+            case 'efficiency_optimization':
+                return `Optimization opportunity for ${agentTypes} in ${taskTypes}`;
+            default:
+                return `Pattern for ${agentTypes}`;
+        }
+    }
+    /**
+     * Store patterns in database
+     */
+    async storePatterns(patterns) {
+        const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO synthesized_patterns
+      (id, type, description, conditions, actions, confidence, supporting_experiences,
+       effectiveness, agent_types, task_types, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        const insertMany = this.db.transaction((pats) => {
+            for (const p of pats) {
+                stmt.run(p.id, p.type, p.description, JSON.stringify(p.conditions), JSON.stringify(p.actions), p.confidence, JSON.stringify(p.supportingExperiences), p.effectiveness, JSON.stringify(p.agentTypes), JSON.stringify(p.taskTypes), p.createdAt.getTime(), p.updatedAt.getTime());
+            }
+        });
+        insertMany(patterns);
+        this.logger.info('[PatternSynthesis] Stored patterns', { count: patterns.length });
+    }
+    /**
+     * Convert database row to experience
+     */
+    rowToExperience(row) {
+        return {
+            id: row.id,
+            agentId: row.agent_id,
+            agentType: row.agent_type,
+            taskType: row.task_type,
+            execution: JSON.parse(row.execution),
+            context: JSON.parse(row.context),
+            outcome: JSON.parse(row.outcome),
+            timestamp: new Date(row.created_at),
+        };
+    }
+    /**
+     * Convert database row to pattern
+     */
+    rowToPattern(row) {
+        return {
+            id: row.id,
+            type: row.type,
+            description: row.description,
+            conditions: JSON.parse(row.conditions),
+            actions: JSON.parse(row.actions),
+            confidence: row.confidence,
+            supportingExperiences: JSON.parse(row.supporting_experiences),
+            effectiveness: row.effectiveness,
+            agentTypes: JSON.parse(row.agent_types),
+            taskTypes: JSON.parse(row.task_types),
+            createdAt: new Date(row.created_at),
+            updatedAt: new Date(row.updated_at),
+        };
+    }
+    /**
+     * Close database connection
+     */
+    close() {
+        this.db.close();
+    }
+}
+exports.PatternSynthesis = PatternSynthesis;
+exports.default = PatternSynthesis;
+//# sourceMappingURL=PatternSynthesis.js.map