@mindrian_os/cli 1.13.0-beta.10 → 1.13.0-beta.43

package/lib/core/proactive-intelligence.cjs

@@ -1,528 +0,0 @@
-/**
- * MindrianOS Plugin -- Proactive Intelligence Persistence
- * Parses analyze-room output, persists insights with repeat suppression,
- * and tracks cross-room relationships.
- *
- * Exports: persistIntelligence, loadIntelligence, shouldSuppress, addCrossRoomRelationship
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-const INTELLIGENCE_FILE = '.proactive-intelligence.json';
-const SUPPRESS_THRESHOLD = 3;
-
-/**
- * Load existing intelligence from room directory.
- * @param {string} roomDir - Absolute path to room directory
- * @returns {{ insights: Array, cross_room: Array, updated: string }}
- */
-function loadIntelligence(roomDir) {
-  const filePath = path.join(roomDir, INTELLIGENCE_FILE);
-  try {
-    if (fs.existsSync(filePath)) {
-      const raw = fs.readFileSync(filePath, 'utf8');
-      const data = JSON.parse(raw);
-      return {
-        insights: Array.isArray(data.insights) ? data.insights : [],
-        cross_room: Array.isArray(data.cross_room) ? data.cross_room : [],
-        updated: data.updated || ''
-      };
-    }
-  } catch (_) {
-    // Corrupted file -- start fresh
-  }
-  return { insights: [], cross_room: [], updated: '' };
-}
-
-/**
- * Parse analyze-room stdout into structured insight objects.
- * Handles: GAP:STRUCTURAL, GAP:SEMANTIC, GAP:ADJACENT, CONVERGE, CONTRADICT lines.
- * @param {string} analyzeOutput - Raw stdout from analyze-room script
- * @returns {Array<{ type: string, section?: string, term?: string, message: string, confidence: string }>}
- */
-function parseAnalyzeOutput(analyzeOutput) {
-  if (!analyzeOutput || typeof analyzeOutput !== 'string') return [];
-
-  const insights = [];
-  const lines = analyzeOutput.split('\n');
-
-  for (const line of lines) {
-    const trimmed = line.trim();
-
-    // GAP:STRUCTURAL:{section}:{confidence}:{message}
-    // GAP:SEMANTIC:{section}:{confidence}:{message}
-    // GAP:ADJACENT:{section}:{confidence}:{message}
-    const gapMatch = trimmed.match(/^GAP:(STRUCTURAL|SEMANTIC|ADJACENT):([^:]+):([^:]+):(.+)$/);
-    if (gapMatch) {
-      insights.push({
-        type: 'gap',
-        subtype: gapMatch[1].toLowerCase(),
-        section: gapMatch[2],
-        confidence: gapMatch[3],
-        message: gapMatch[4]
-      });
-      continue;
-    }
-
-    // CONVERGE:{term}:{count}:{confidence}:{message}
-    const convergeMatch = trimmed.match(/^CONVERGE:([^:]+):(\d+):([^:]+):(.+)$/);
-    if (convergeMatch) {
-      insights.push({
-        type: 'convergence',
-        term: convergeMatch[1],
-        count: parseInt(convergeMatch[2], 10),
-        confidence: convergeMatch[3],
-        message: convergeMatch[4]
-      });
-      continue;
-    }
-
-    // CONTRADICT:{section1}:{section2}:{confidence}:{message}
-    const contradictMatch = trimmed.match(/^CONTRADICT:([^:]+):([^:]+):([^:]+):(.+)$/);
-    if (contradictMatch) {
-      insights.push({
-        type: 'contradiction',
-        section: contradictMatch[1],
-        section2: contradictMatch[2],
-        confidence: contradictMatch[3],
-        message: contradictMatch[4]
-      });
-      continue;
-    }
-  }
-
-  return insights;
-}
-
-/**
- * Match key for deduplication: type + section (for gaps/contradictions) or type + term (for convergence).
- * @param {{ type: string, section?: string, term?: string, section2?: string }} insight
- * @returns {string}
- */
-function insightKey(insight) {
-  if (insight.type === 'convergence') {
-    return `convergence:${insight.term || ''}`;
-  }
-  if (insight.type === 'contradiction') {
-    return `contradiction:${insight.section || ''}:${insight.section2 || ''}`;
-  }
-  return `gap:${insight.subtype || ''}:${insight.section || ''}`;
-}
-
-/**
- * Read recent semantic findings from the lazygraph and map them to insight
- * records that match parseAnalyzeOutput()'s shape exactly so insightKey()
- * dedup folds graph and bash-script findings together.
- *
- * Queries CONTRADICTS, CONVERGES, INVALIDATES edges with created_at
- * greater than sinceTimestamp, walks INFORMS edges to Stakeholder nodes,
- * and emits one insight per edge in the same shape as parseAnalyzeOutput.
- * Empty array on any failure path. Never throws.
- *
- * @param {string} roomDir - Absolute path to room directory
- * @param {number} sinceTimestamp - Unix ms; only edges with created_at greater than this
- * @returns {Array<object>} insights in parseAnalyzeOutput() shape
- */
-function readGraphFindings(roomDir, sinceTimestamp) {
-  try {
-    const lazygraph = require('./lazygraph-ops.cjs');
-    let handle;
-    try {
-      // Direct sync open of the room.db so we can run inside the cascade
-      // without await. If the file is missing, return empty findings.
-      const fsLocal = require('fs');
-      const pathLocal = require('path');
-      const { DatabaseSync } = require('node:sqlite');
-      const dbPath = pathLocal.join(pathLocal.resolve(roomDir), '.mindrian', 'room.db');
-      if (!fsLocal.existsSync(dbPath)) return [];
-      const db = new DatabaseSync(dbPath, { open: true, readOnly: true });
-      handle = { db, conn: db, _opened: 'sync' };
-    } catch (_) {
-      return [];
-    }
-
-    const db = handle.db || handle.conn;
-    // Reference lazygraph to silence linters and signal contract dependency
-    void lazygraph;
-    const sinceMs = typeof sinceTimestamp === 'number' ? sinceTimestamp : 0;
-    const insights = [];
-
-    let edges = [];
-    try {
-      edges = db.prepare(
-        `SELECT source, target, type, properties FROM edges
-         WHERE type IN ('CONTRADICTS', 'CONVERGES', 'INVALIDATES')
-         LIMIT 50`
-      ).all();
-    } catch (_) {
-      edges = [];
-    }
-
-    for (const edge of edges) {
-      // Filter by created_at when present in properties JSON
-      let createdAt = 0;
-      try {
-        const props = edge.properties ? JSON.parse(edge.properties) : {};
-        if (typeof props.created_at === 'number') createdAt = props.created_at;
-      } catch (_) {
-        createdAt = 0;
-      }
-      if (sinceMs > 0 && createdAt > 0 && createdAt <= sinceMs) continue;
-
-      // Resolve endpoint section names for shape-compatible insight keys
-      let sourceSection = '';
-      let targetSection = '';
-      try {
-        const srcNode = db.prepare("SELECT properties FROM nodes WHERE id = ?").get(edge.source);
-        const tgtNode = db.prepare("SELECT properties FROM nodes WHERE id = ?").get(edge.target);
-        if (srcNode && srcNode.properties) {
-          try { sourceSection = (JSON.parse(srcNode.properties).section) || edge.source.split('/')[0] || ''; } catch (_) { sourceSection = edge.source.split('/')[0] || ''; }
-        } else {
-          sourceSection = edge.source.split('/')[0] || '';
-        }
-        if (tgtNode && tgtNode.properties) {
-          try { targetSection = (JSON.parse(tgtNode.properties).section) || edge.target.split('/')[0] || ''; } catch (_) { targetSection = edge.target.split('/')[0] || ''; }
-        } else {
-          targetSection = edge.target.split('/')[0] || '';
-        }
-      } catch (_) {
-        sourceSection = edge.source.split('/')[0] || '';
-        targetSection = edge.target.split('/')[0] || '';
-      }
-
-      // Cap stakeholder context to 5 other claims to bound injection noise
-      let stakeholderContext = '';
-      try {
-        const stakeholders = lazygraph.findStakeholdersByClaim
-          ? db.prepare(
-              `SELECT s.id, s.name FROM stakeholders s
-               WHERE s.id IN (
-                 SELECT source FROM edges WHERE target = ? AND type = 'INFORMS'
-                 UNION
-                 SELECT target FROM edges WHERE source = ? AND type = 'INFORMS'
-               ) LIMIT 5`
-            ).all(edge.source, edge.source)
-          : [];
-        if (stakeholders && stakeholders.length > 0) {
-          stakeholderContext = ' (stakeholders: ' + stakeholders.map(s => s.name).join(', ') + ')';
-        }
-      } catch (_) {
-        stakeholderContext = '';
-      }
-
-      if (edge.type === 'CONTRADICTS') {
-        insights.push({
-          type: 'contradiction',
-          section: sourceSection,
-          section2: targetSection,
-          confidence: 'medium',
-          message: `Graph contradiction: ${edge.source} vs ${edge.target}${stakeholderContext}`
-        });
-      } else if (edge.type === 'CONVERGES') {
-        insights.push({
-          type: 'convergence',
-          term: `${sourceSection}+${targetSection}`,
-          count: 2,
-          confidence: 'medium',
-          message: `Graph convergence: ${edge.source} and ${edge.target}${stakeholderContext}`
-        });
-      } else if (edge.type === 'INVALIDATES') {
-        insights.push({
-          type: 'gap',
-          subtype: 'structural',
-          section: targetSection,
-          confidence: 'medium',
-          message: `Graph invalidation: ${edge.source} invalidates ${edge.target}${stakeholderContext}`
-        });
-      }
-    }
-
-    // Close the db handle if we opened it ourselves
-    try {
-      if (handle && handle._opened === 'sync' && handle.db) {
-        handle.db.close();
-      }
-    } catch (_) { /* ignore */ }
-
-    return insights;
-  } catch (_) {
-    return [];
-  }
-}
-
-/**
- * Persist intelligence from analyze-room output with repeat suppression.
- * Phase 84-05: also reads graph findings via readGraphFindings() and merges
- * them into the same insight stream before shouldSuppress() dedup.
- * @param {string} roomDir - Absolute path to room directory
- * @param {string} analyzeOutput - Raw stdout from analyze-room script
- * @returns {{ persisted: number, new: number, suppressed: number }}
- */
-function persistIntelligence(roomDir, analyzeOutput) {
-  const bashParsed = parseAnalyzeOutput(analyzeOutput);
-
-  // Phase 84-05: pull graph-sourced insights using the previous run's
-  // updated timestamp as the high-water mark. Failures fall through to [].
-  let graphParsed = [];
-  try {
-    const prior = loadIntelligence(roomDir);
-    let sinceMs = 0;
-    if (prior && prior.updated) {
-      const t = Date.parse(prior.updated);
-      if (!Number.isNaN(t)) sinceMs = t;
-    }
-    graphParsed = readGraphFindings(roomDir, sinceMs) || [];
-  } catch (_) {
-    graphParsed = [];
-  }
-
-  const parsed = bashParsed.concat(graphParsed);
-  if (parsed.length === 0) {
-    return { persisted: 0, new: 0, suppressed: 0 };
-  }
-
-  const data = loadIntelligence(roomDir);
-  const now = new Date().toISOString();
-
-  // Build lookup by key
-  const existingMap = new Map();
-  for (let i = 0; i < data.insights.length; i++) {
-    existingMap.set(insightKey(data.insights[i]), i);
-  }
-
-  let newCount = 0;
-  let suppressed = 0;
-
-  for (const insight of parsed) {
-    const key = insightKey(insight);
-    const existingIdx = existingMap.get(key);
-
-    if (existingIdx !== undefined) {
-      // Existing insight -- check for evidence changes, then increment times_shown
-      const existing = data.insights[existingIdx];
-      // Evidence-change detection: if confidence or message changed, reset suppression
-      const evidenceChanged = (existing.confidence !== insight.confidence) || (existing.message !== insight.message);
-      if (evidenceChanged && shouldSuppress(existing)) {
-        existing.times_shown = 0;
-        existing.confidence = insight.confidence;
-        existing.message = insight.message;
-      }
-      existing.times_shown = (existing.times_shown || 0) + 1;
-      existing.last_seen = now;
-      if (existing.times_shown >= SUPPRESS_THRESHOLD) {
-        suppressed++;
-      }
-    } else {
-      // New insight
-      const entry = {
-        ...insight,
-        first_seen: now,
-        last_seen: now,
-        times_shown: 0
-      };
-      data.insights.push(entry);
-      existingMap.set(key, data.insights.length - 1);
-      newCount++;
-    }
-  }
-
-  data.updated = now;
-
-  // Write atomically
-  const filePath = path.join(roomDir, INTELLIGENCE_FILE);
-  const tmpPath = filePath + '.tmp';
-  fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2), 'utf8');
-  fs.renameSync(tmpPath, filePath);
-
-  return { persisted: parsed.length, new: newCount, suppressed };
-}
-
-/**
- * Check if an insight should be suppressed (shown 3+ times).
- * @param {{ times_shown: number }} insight
- * @returns {boolean}
- */
-function shouldSuppress(insight) {
-  return (insight && typeof insight.times_shown === 'number' && insight.times_shown >= SUPPRESS_THRESHOLD);
-}
-
-/**
- * Add or update a cross-room relationship.
- * @param {string} roomDir - Absolute path to room directory
- * @param {string} sourceRoom - Source room name/path
- * @param {string} targetRoom - Target room name/path
- * @param {string[]} sharedConcepts - Array of shared concept strings
- */
-function addCrossRoomRelationship(roomDir, sourceRoom, targetRoom, sharedConcepts) {
-  const data = loadIntelligence(roomDir);
-  const now = new Date().toISOString();
-
-  // Find existing relationship (same source + target)
-  const existing = data.cross_room.find(
-    cr => cr.source_room === sourceRoom && cr.target_room === targetRoom
-  );
-
-  if (existing) {
-    // Union shared concepts
-    const conceptSet = new Set([...(existing.shared_concepts || []), ...sharedConcepts]);
-    existing.shared_concepts = [...conceptSet];
-    existing.detected = now;
-  } else {
-    data.cross_room.push({
-      source_room: sourceRoom,
-      target_room: targetRoom,
-      shared_concepts: [...sharedConcepts],
-      detected: now
-    });
-  }
-
-  data.updated = now;
-
-  // Write atomically
-  const filePath = path.join(roomDir, INTELLIGENCE_FILE);
-  const tmpPath = filePath + '.tmp';
-  fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2), 'utf8');
-  fs.renameSync(tmpPath, filePath);
-}
-
-/**
- * Get new or changed findings not previously seen by the user.
- * Compares current analyze-room insights against persisted intelligence.
- * Returns max 5 findings sorted by confidence descending.
- *
- * @param {string} roomDir - Absolute path to room directory
- * @param {Array<{ type: string, section?: string, term?: string, confidence: string, message: string }>} currentInsights - Parsed insights from current analyze-room run
- * @returns {Array<{ type: string, section?: string, term?: string, confidence: string, message: string, isNew: boolean }>}
- */
-function getNewFindings(roomDir, currentInsights) {
-  if (!Array.isArray(currentInsights) || currentInsights.length === 0) return [];
-
-  const data = loadIntelligence(roomDir);
-
-  // Build lookup of persisted insights by key
-  const persistedMap = new Map();
-  for (const insight of data.insights) {
-    persistedMap.set(insightKey(insight), insight);
-  }
-
-  const findings = [];
-
-  for (const insight of currentInsights) {
-    const key = insightKey(insight);
-    const existing = persistedMap.get(key);
-
-    // Skip insights that have been decided on
-    if (existing && existing.decided) continue;
-
-    // Skip suppressed insights (shown 3+ times)
-    if (existing && shouldSuppress(existing)) continue;
-
-    let isNew = false;
-    let include = false;
-
-    if (!existing) {
-      // Brand new insight
-      isNew = true;
-      include = true;
-    } else if (existing.confidence !== insight.confidence) {
-      // Confidence has changed -- updated finding
-      isNew = false;
-      include = true;
-    }
-
-    if (include) {
-      findings.push({
-        type: insight.type,
-        subtype: insight.subtype,
-        section: insight.section,
-        term: insight.term,
-        section2: insight.section2,
-        confidence: insight.confidence,
-        message: insight.message,
-        isNew
-      });
-    }
-  }
-
-  // Sort by confidence descending
-  findings.sort((a, b) => parseFloat(b.confidence || '0') - parseFloat(a.confidence || '0'));
-
-  // Return max 5
-  return findings.slice(0, 5);
-}
-
-/**
- * Record a user decision (approve/reject/defer) for an insight.
- * Persists to .proactive-intelligence.json and marks insight as decided.
- *
- * @param {string} roomDir - Absolute path to room directory
- * @param {string} key - Insight key (from insightKey())
- * @param {'approve'|'reject'|'defer'} decision - The user's decision
- * @param {string} reason - Reason for the decision (especially important for reject)
- * @returns {{ recorded: boolean, edgeType: string }}
- */
-function recordDecision(roomDir, key, decision, reason) {
-  const data = loadIntelligence(roomDir);
-  const now = new Date().toISOString();
-
-  // Initialize decisions array if not present
-  if (!Array.isArray(data.decisions)) {
-    data.decisions = [];
-  }
-
-  // Record the decision
-  const decisionEntry = {
-    insight_key: key,
-    decision,
-    reason: reason || '',
-    timestamp: now
-  };
-
-  // If rejection, store reason as separate field for graph enrichment (Decision #13)
-  if (decision === 'reject') {
-    decisionEntry.rejection_reason = reason || '';
-  }
-
-  data.decisions.push(decisionEntry);
-
-  // Mark the corresponding insight as decided so it won't be re-surfaced
-  for (const insight of data.insights) {
-    if (insightKey(insight) === key) {
-      insight.decided = true;
-      insight.decision_type = decision;
-      break;
-    }
-  }
-
-  data.updated = now;
-
-  // Write atomically (tmp + rename pattern)
-  const filePath = path.join(roomDir, INTELLIGENCE_FILE);
-  const tmpPath = filePath + '.tmp';
-  fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2), 'utf8');
-  fs.renameSync(tmpPath, filePath);
-
-  // Map decision to SQLite edge type
-  const edgeTypeMap = {
-    approve: 'INVALIDATES',
-    reject: 'CONFIRMS',
-    defer: 'DEFERRED'
-  };
-
-  return { recorded: true, edgeType: edgeTypeMap[decision] || 'DEFERRED' };
-}
-
-module.exports = {
-  persistIntelligence,
-  loadIntelligence,
-  shouldSuppress,
-  addCrossRoomRelationship,
-  parseAnalyzeOutput,
-  insightKey,
-  getNewFindings,
-  recordDecision,
-  readGraphFindings
-};