@equilateral_ai/mindmeld 3.5.3 → 4.0.1

package/src/core/DeprecationScheduler.js

@@ -1,183 +0,0 @@
-/**
- * DeprecationScheduler.js - Scheduled Deprecation Management
- *
- * Handles the scheduled deprecation workflow for standards:
- *   1. scheduleDeprecation - Marks a standard as deprecated with a grace period
- *   2. processScheduledDeprecations - Deletes standards past their grace period
- *   3. cancelDeprecation - Restores a deprecated standard back to active
- *
- * Called by scheduled Lambda / EventBridge for automatic cleanup,
- * or directly by handlers for user-initiated actions.
- */
-
-const { executeQuery } = require('../handlers/helpers/dbOperations');
-const { StandardLifecycle, STATES } = require('./StandardLifecycle');
-
-class DeprecationScheduler {
-    constructor(config = {}) {
-        this.config = {
-            defaultGracePeriodDays: config.defaultGracePeriodDays || 30,
-            ...config
-        };
-
-        this.lifecycle = config.lifecycle || new StandardLifecycle();
-    }
-
-    /**
-     * Schedule a standard for deprecation with a grace period
-     *
-     * Sets deprecated_at and deprecation_reason on the standard,
-     * transitions state to 'deprecated', and records in audit trail.
-     *
-     * @param {string} standardId - The standard identifier
-     * @param {number} gracePeriodDays - Days before automatic deletion
-     * @param {string} userId - Email of the user scheduling deprecation
-     * @param {string} reason - Reason for deprecation
-     * @returns {Promise<Object>} Deprecation result
-     */
-    async scheduleDeprecation(standardId, gracePeriodDays, userId, reason) {
-        const days = gracePeriodDays || this.config.defaultGracePeriodDays;
-
-        // Execute the lifecycle transition to deprecated
-        const transitionResult = await this.lifecycle.transition(
-            standardId,
-            'deprecate',
-            userId,
-            reason
-        );
-
-        // Set deprecation metadata on the standard
-        const deprecatedAt = new Date();
-        const deletionDate = new Date(deprecatedAt.getTime() + (days * 24 * 60 * 60 * 1000));
-
-        await executeQuery(`
-            UPDATE rapport.patterns
-            SET
-                deprecated_at = $2,
-                deprecation_reason = $3
-            WHERE pattern_id = $1
-        `, [standardId, deprecatedAt, reason]);
-
-        console.log(
-            `[DeprecationScheduler] Scheduled ${standardId} for deletion on ${deletionDate.toISOString()} ` +
-            `(${days} day grace period)`
-        );
-
-        return {
-            standard_id: standardId,
-            old_state: transitionResult.old_state,
-            new_state: transitionResult.new_state,
-            deprecated_at: deprecatedAt.toISOString(),
-            grace_period_days: days,
-            scheduled_deletion: deletionDate.toISOString(),
-            reason: reason,
-            audit_entry: transitionResult.audit_entry
-        };
-    }
-
-    /**
-     * Process all standards that have passed their grace period
-     *
-     * Finds deprecated standards where deprecated_at + grace period < now,
-     * and transitions them to 'deleted'.
-     *
-     * Intended to be called by a scheduled Lambda / EventBridge rule.
-     *
-     * @returns {Promise<Object>} Processing results
-     */
-    async processScheduledDeprecations() {
-        const gracePeriodDays = this.config.defaultGracePeriodDays;
-
-        // Find standards past their grace period
-        const result = await executeQuery(`
-            SELECT pattern_id, deprecated_at, deprecation_reason
-            FROM rapport.patterns
-            WHERE lifecycle_state = $1
-                AND deprecated_at IS NOT NULL
-                AND deprecated_at + ($2 || ' days')::INTERVAL < NOW()
-        `, [STATES.DEPRECATED, gracePeriodDays]);
-
-        const standards = result.rows;
-
-        console.log(`[DeprecationScheduler] Found ${standards.length} standards past grace period`);
-
-        const processed = [];
-        const errors = [];
-
-        for (const standard of standards) {
-            try {
-                const transitionResult = await this.lifecycle.transition(
-                    standard.pattern_id,
-                    'delete',
-                    'system@mindmeld.dev',
-                    `Automatic deletion after ${gracePeriodDays}-day grace period. ` +
-                    `Original reason: ${standard.deprecation_reason || 'Not specified'}`
-                );
-
-                processed.push({
-                    standard_id: standard.pattern_id,
-                    deprecated_at: standard.deprecated_at,
-                    deleted_at: new Date().toISOString()
-                });
-
-                console.log(`[DeprecationScheduler] Deleted ${standard.pattern_id} (deprecated ${standard.deprecated_at})`);
-            } catch (error) {
-                console.error(`[DeprecationScheduler] Failed to delete ${standard.pattern_id}:`, error.message);
-                errors.push({
-                    standard_id: standard.pattern_id,
-                    error: error.message
-                });
-            }
-        }
-
-        return {
-            total_found: standards.length,
-            processed: processed.length,
-            errors: errors.length,
-            deleted: processed,
-            failed: errors
-        };
-    }
-
-    /**
-     * Cancel a scheduled deprecation and restore to active
-     *
-     * Transitions the standard back to 'active', clears deprecated_at
-     * and deprecation_reason, and records in audit trail.
-     *
-     * @param {string} standardId - The standard identifier
-     * @param {string} userId - Email of the user cancelling deprecation
-     * @param {string} reason - Reason for cancelling deprecation
-     * @returns {Promise<Object>} Cancellation result
-     */
-    async cancelDeprecation(standardId, userId, reason) {
-        // Execute the lifecycle transition back to active
-        const transitionResult = await this.lifecycle.transition(
-            standardId,
-            'cancel_deprecation',
-            userId,
-            reason
-        );
-
-        // Clear deprecation metadata
-        await executeQuery(`
-            UPDATE rapport.patterns
-            SET
-                deprecated_at = NULL,
-                deprecation_reason = NULL
-            WHERE pattern_id = $1
-        `, [standardId]);
-
-        console.log(`[DeprecationScheduler] Cancelled deprecation for ${standardId} by ${userId}`);
-
-        return {
-            standard_id: standardId,
-            old_state: transitionResult.old_state,
-            new_state: transitionResult.new_state,
-            reason: reason,
-            audit_entry: transitionResult.audit_entry
-        };
-    }
-}
-
-module.exports = { DeprecationScheduler };

package/src/core/LoadBearingDetector.js

@@ -1,242 +0,0 @@
-/**
- * Load-Bearing Detector
- *
- * Detects context elements that correlate with handoff success/failure.
- * Load-bearing context = context that must be present for successful handoffs.
- *
- * Algorithm:
- * 1. Track context elements present in each handoff
- * 2. Correlate presence/absence with success/failure
- * 3. Elements with high correlation to success = load-bearing
- *
- * Based on: Phase 6 Multi-Agent Integration
- */
-
-class LoadBearingDetector {
-  constructor(config = {}) {
-    this.config = {
-      correlationThreshold: config.correlationThreshold || 0.7,
-      minObservations: config.minObservations || 5,
-      ...config
-    };
-
-    // Track context elements and their correlation with outcomes
-    this.contextElements = new Map();  // key -> { element, observations, presentAndSuccess, presentAndFailure, totalPresent }
-
-    // Track handoff analysis history
-    this.handoffAnalysis = [];
-  }
-
-  /**
-   * Analyze a handoff and update correlations
-   *
-   * @param {Object} handoff - The handoff context
-   * @param {Object} outcome - The outcome { success: boolean, metrics: {} }
-   * @returns {Object} Analysis result
-   */
-  analyzeHandoff(handoff, outcome) {
-    const elements = this.extractContextElements(handoff);
-    const success = outcome.success;
-
-    // Update statistics for each element
-    for (const element of elements) {
-      this.updateElementStats(element, success);
-    }
-
-    // Record handoff
-    this.handoffAnalysis.push({
-      timestamp: new Date().toISOString(),
-      elements: elements.map(e => e.key),
-      success,
-      metrics: outcome.metrics || {}
-    });
-
-    return {
-      elements,
-      success,
-      loadBearing: this.getLoadBearing()
-    };
-  }
-
-  /**
-   * Extract context elements from handoff
-   */
-  extractContextElements(handoff) {
-    const elements = [];
-
-    // Extract constraints
-    if (handoff.constraints) {
-      for (const constraint of handoff.constraints) {
-        elements.push({
-          type: 'constraint',
-          key: `constraint:${constraint}`,
-          value: constraint
-        });
-      }
-    }
-
-    // Extract context keys
-    if (handoff.context) {
-      for (const [key, value] of Object.entries(handoff.context)) {
-        elements.push({
-          type: 'context_key',
-          key: `context:${key}`,
-          value: key,
-          hasValue: value !== null && value !== undefined
-        });
-      }
-    }
-
-    // Extract missing context (for correlation with failure)
-    if (handoff.missing) {
-      for (const key of handoff.missing) {
-        elements.push({
-          type: 'missing',
-          key: `missing:${key}`,
-          value: key
-        });
-      }
-    }
-
-    return elements;
-  }
-
-  /**
-   * Update statistics for an element
-   */
-  updateElementStats(element, success) {
-    const key = element.key;
-
-    if (!this.contextElements.has(key)) {
-      this.contextElements.set(key, {
-        element,
-        observations: 0,
-        presentAndSuccess: 0,
-        presentAndFailure: 0,
-        totalPresent: 0
-      });
-    }
-
-    const stats = this.contextElements.get(key);
-    stats.observations++;
-    stats.totalPresent++;
-
-    if (success) {
-      stats.presentAndSuccess++;
-    } else {
-      stats.presentAndFailure++;
-    }
-  }
-
-  /**
-   * Get load-bearing elements
-   */
-  getLoadBearing() {
-    const loadBearing = [];
-
-    for (const [key, stats] of this.contextElements.entries()) {
-      if (stats.observations < this.config.minObservations) {
-        continue;
-      }
-
-      const correlation = stats.totalPresent > 0
-        ? stats.presentAndSuccess / stats.totalPresent
-        : 0;
-
-      if (correlation >= this.config.correlationThreshold) {
-        loadBearing.push({
-          element: stats.element,
-          correlation,
-          observations: stats.observations,
-          recommendation: 'LOAD_BEARING'
-        });
-      }
-    }
-
-    return loadBearing.sort((a, b) => b.correlation - a.correlation);
-  }
-
-  /**
-   * Apply recommendations to a decision frame
-   */
-  applyRecommendations(decisionFrame, recommendations) {
-    const applied = [];
-
-    for (const rec of recommendations) {
-      if (rec.type === 'mark_constraint_load_bearing') {
-        applied.push({
-          action: 'marked_load_bearing',
-          constraint: rec.constraint,
-          reason: rec.reason
-        });
-      }
-
-      if (rec.type === 'always_include_context') {
-        applied.push({
-          action: 'required_context',
-          key: rec.key,
-          reason: rec.reason
-        });
-      }
-
-      if (rec.type === 'prevent_missing_context') {
-        applied.push({
-          action: 'prevent_missing',
-          key: rec.key,
-          reason: rec.reason
-        });
-      }
-    }
-
-    return {
-      decisionFrame,
-      appliedRecommendations: applied
-    };
-  }
-
-  /**
-   * Get summary statistics
-   */
-  getSummary() {
-    const totalHandoffs = this.handoffAnalysis.length;
-    const successfulHandoffs = this.handoffAnalysis.filter(h => h.success).length;
-
-    return {
-      totalHandoffs,
-      successfulHandoffs,
-      successRate: totalHandoffs > 0 ? successfulHandoffs / totalHandoffs : 0,
-      loadBearingDetected: this.getLoadBearing().length,
-      trackedElements: this.contextElements.size
-    };
-  }
-
-  /**
-   * Export data for persistence
-   */
-  exportData() {
-    return {
-      handoffAnalysis: this.handoffAnalysis,
-      contextElements: Array.from(this.contextElements.entries()).map(([key, stats]) => ({
-        key,
-        ...stats
-      }))
-    };
-  }
-
-  /**
-   * Import data from persistence
-   */
-  importData(data) {
-    if (data.handoffAnalysis) {
-      this.handoffAnalysis = data.handoffAnalysis;
-    }
-
-    if (data.contextElements) {
-      for (const elem of data.contextElements) {
-        this.contextElements.set(elem.key, elem);
-      }
-    }
-  }
-}
-
-module.exports = LoadBearingDetector;