mindforge-cc 8.1.0 → 8.2.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/memory/knowledge-indexer.js

@@ -0,0 +1,172 @@
+/**
+ * MindForge v2 — Knowledge Indexer
+ * TF-IDF inspired relevance scoring for fast knowledge retrieval.
+ * Provides tag-based and text-based search across the knowledge graph.
+ *
+ * Design note: We use a simple in-memory index rebuilt on each query
+ * (not persisted) because the knowledge base stays small (< 10K entries
+ * for a typical project). Rebuild time < 50ms for 1K entries.
+ */
+'use strict';
+
+const Store = require('./knowledge-store');
+
+// ── Stopwords (excluded from TF-IDF scoring) ──────────────────────────────────
+const STOPWORDS = new Set([
+  'the', 'a', 'an', 'is', 'it', 'in', 'on', 'at', 'to', 'for', 'of', 'and',
+  'or', 'but', 'not', 'this', 'that', 'with', 'from', 'by', 'be', 'are',
+  'was', 'were', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would',
+  'could', 'should', 'may', 'might', 'can', 'use', 'using', 'used', 'when',
+  'where', 'which', 'what', 'how', 'why', 'who', 'all', 'any', 'some', 'we',
+  'our', 'they', 'their', 'we', 'you', 'your', 'my', 'its',
+]);
+
+// ── Tokenizer ─────────────────────────────────────────────────────────────────
+function tokenize(text) {
+  if (!text) return [];
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9\s_-]/g, ' ')
+    .split(/\s+/)
+    .filter(w => w.length > 2 && !STOPWORDS.has(w));
+}
+
+// ── Build in-memory index ─────────────────────────────────────────────────────
+function buildIndex(entries) {
+  const index = new Map(); // token → [{ id, count }]
+  const docTokenCounts = new Map(); // id → token count
+
+  for (const entry of entries) {
+    if (entry.deprecated) continue;
+
+    const text   = `${entry.topic} ${entry.content} ${(entry.tags || []).join(' ')}`;
+    const tokens = tokenize(text);
+    const counts = {};
+
+    for (const tok of tokens) {
+      counts[tok] = (counts[tok] || 0) + 1;
+    }
+
+    docTokenCounts.set(entry.id, tokens.length);
+
+    for (const [tok, count] of Object.entries(counts)) {
+      if (!index.has(tok)) index.set(tok, []);
+      index.get(tok).push({ id: entry.id, count });
+    }
+  }
+
+  return { index, docTokenCounts, N: entries.length };
+}
+
+// ── TF-IDF scoring ────────────────────────────────────────────────────────────
+function tfidfScore(queryTokens, entryId, index, docTokenCounts, N) {
+  let score = 0;
+  const docLen = docTokenCounts.get(entryId) || 1;
+
+  for (const qTok of queryTokens) {
+    const postings = index.get(qTok) || [];
+    const df       = postings.length; // Document frequency
+    if (df === 0) continue;
+
+    const posting  = postings.find(p => p.id === entryId);
+    if (!posting) continue;
+
+    const tf  = posting.count / docLen;              // Term frequency (normalized)
+    const idf = Math.log((N + 1) / (df + 1)) + 1;   // Smoothed IDF
+    score += tf * idf;
+  }
+
+  return score;
+}
+
+// ── Main search function ──────────────────────────────────────────────────────
+/**
+ * Search knowledge base with TF-IDF scoring.
+ * @param {string} queryText - Natural language query
+ * @param {object} filters   - Optional filters { type, tags, minConfidence }
+ * @param {number} limit     - Max results to return
+ * @returns {object[]} Ranked results
+ */
+function search(queryText, filters = {}, limit = 10) {
+  const allEntries = Store.readAll(filters.includeGlobal);
+  const active     = allEntries.filter(e => !e.deprecated);
+
+  // Apply filters
+  let candidates = active;
+  if (filters.type)          candidates = candidates.filter(e => e.type === filters.type);
+  if (filters.minConfidence) candidates = candidates.filter(e => e.confidence >= filters.minConfidence);
+  if (filters.tags?.length) {
+    const filterTags = filters.tags.map(t => t.toLowerCase());
+    candidates = candidates.filter(e =>
+      (e.tags || []).some(t => filterTags.includes(t.toLowerCase()))
+    );
+  }
+
+  if (candidates.length === 0) return [];
+
+  const queryTokens = tokenize(queryText);
+  if (queryTokens.length === 0) {
+    // No meaningful query tokens — return by confidence
+    return candidates
+      .sort((a, b) => b.confidence - a.confidence)
+      .slice(0, limit);
+  }
+
+  const { index, docTokenCounts, N } = buildIndex(candidates);
+
+  // Score each candidate
+  const scored = candidates.map(entry => {
+    const textScore = tfidfScore(queryTokens, entry.id, index, docTokenCounts, N);
+    // Combine TF-IDF score with confidence, but only if there's a text match
+    const finalScore = textScore > 0
+      ? textScore * 0.7 + entry.confidence * 0.3
+      : 0;
+    return { entry, score: finalScore };
+  });
+
+  return scored
+    .filter(s => s.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit)
+    .map(s => s.entry);
+}
+
+/**
+ * Load session context: retrieve the most relevant memories for the current session.
+ * @param {object} context - { techStack, phase, topic, project }
+ * @returns {object} Categorized memories for session start display
+ */
+function loadSessionContext(context = {}) {
+  const { techStack = [], phase, topic = '', project } = context;
+
+  const allEntries = Store.readAll(true); // Include global knowledge
+  const active     = allEntries.filter(e => !e.deprecated && e.confidence >= 0.5);
+
+  // Build query from context
+  const queryText = [
+    topic,
+    ...(techStack || []),
+  ].join(' ');
+
+  const { index, docTokenCounts, N } = buildIndex(active);
+  const queryTokens = tokenize(queryText);
+
+  // Score all active entries
+  const scored = active.map(e => ({
+    entry: e,
+    score: queryTokens.length > 0
+      ? tfidfScore(queryTokens, e.id, index, docTokenCounts, N) * 0.6 + e.confidence * 0.4
+      : e.confidence,
+  })).sort((a, b) => b.score - a.score);
+
+  // Bucket by type, top N per bucket
+  const preferences  = scored.filter(s => s.entry.type === 'team_preference').slice(0, 5).map(s => s.entry);
+  const decisions    = scored.filter(s => s.entry.type === 'architectural_decision').slice(0, 8).map(s => s.entry);
+  const bugPatterns  = scored.filter(s => s.entry.type === 'bug_pattern').slice(0, 5).map(s => s.entry);
+  const codePatterns = scored.filter(s => s.entry.type === 'code_pattern').slice(0, 5).map(s => s.entry);
+  const domain       = scored.filter(s => s.entry.type === 'domain_knowledge').slice(0, 3).map(s => s.entry);
+
+  return { preferences, decisions, bugPatterns, codePatterns, domain };
+}
+
+module.exports = { search, loadSessionContext, buildIndex, tfidfScore, tokenize };

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/memory/knowledge-store.js

@@ -0,0 +1,337 @@
+/**
+ * MindForge v2 — Knowledge Store
+ * Append-only JSONL knowledge base with CRUD-like operations.
+ *
+ * Philosophy:
+ * - NEVER delete entries — deprecate instead (audit trail)
+ * - NEVER update entries in-place — append new version, deprecate old
+ * - All writes are atomic (append to JSONL is atomic on POSIX)
+ * - Reads are always full scan + in-memory filter (files stay small)
+ */
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+const crypto = require('crypto');
+
+// ── Paths ─────────────────────────────────────────────────────────────────────
+let baseDir = process.cwd();
+let globalBaseDir = os.homedir();
+
+/**
+ * Configure the base directory for memory (useful for testing).
+ */
+function setBaseDir(dir) {
+  baseDir = dir;
+}
+
+/**
+ * Configure the global base directory (useful for testing).
+ */
+function setGlobalDir(dir) {
+  globalBaseDir = dir;
+}
+
+// Test-mode override: flat memory dir without .mindforge/ nesting
+let testMemoryDir = null;
+
+/**
+ * Set a flat memory directory for testing (bypasses .mindforge/memory/ nesting).
+ * This avoids macOS App Sandbox EPERM on dot-prefixed directories.
+ * @param {string|null} dir - Flat directory path, or null to reset
+ */
+function setTestMode(dir) {
+  testMemoryDir = dir;
+}
+
+function getPaths() {
+  const memoryDir = testMemoryDir || path.join(baseDir, '.mindforge', 'memory');
+  const globalDir = testMemoryDir || path.join(globalBaseDir, '.mindforge');
+  return {
+    MEMORY_DIR:       memoryDir,
+    GLOBAL_DIR:       globalDir,
+    KB_PATH:          path.join(memoryDir, 'knowledge-base.jsonl'),
+    GLOBAL_KB_PATH:   path.join(globalDir, 'global-knowledge-base.jsonl'),
+    DECISION_PATH:    path.join(memoryDir, 'decision-library.jsonl'),
+    PATTERN_PATH:     path.join(memoryDir, 'pattern-library.jsonl'),
+    PREFERENCES_PATH: path.join(memoryDir, 'team-preferences.jsonl'),
+  };
+}
+
+/**
+ * Generates a UUID v4.
+ */
+function generateId() {
+  return crypto.randomUUID();
+}
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function getFilePath(type) {
+  const paths = getPaths();
+  switch (type) {
+    case 'architectural_decision': return paths.DECISION_PATH;
+    case 'code_pattern':           return paths.PATTERN_PATH;
+    case 'team_preference':        return paths.PREFERENCES_PATH;
+    default:                       return paths.KB_PATH; // bug_pattern, domain_knowledge, all others
+  }
+}
+
+// ── Write operations ──────────────────────────────────────────────────────────
+
+/**
+ * Append a new knowledge entry.
+ * @param {object} entry - Entry data (without id, timestamp, times_referenced)
+ * @returns {string} The new entry's ID
+ */
+function add(entry) {
+  const paths = getPaths();
+  ensureDir(paths.MEMORY_DIR);
+
+  if (!entry.type)    throw new Error('Knowledge entry requires a "type" field');
+  if (!entry.topic)   throw new Error('Knowledge entry requires a "topic" field');
+  if (!entry.content) throw new Error('Knowledge entry requires a "content" field');
+
+  const id = entry.id || generateId();
+  const now = new Date().toISOString();
+
+  const full = {
+    id,
+    timestamp: now,
+    type:              entry.type,
+    topic:             entry.topic.slice(0, 80), // Enforce max topic length
+    content:           entry.content,
+    source:            entry.source || 'manual',
+    project:           entry.project || readProjectName(),
+    confidence:        Math.min(1.0, Math.max(0.0, entry.confidence ?? 0.7)),
+    tags:              Array.isArray(entry.tags) ? entry.tags : [],
+    linked_adrs:       Array.isArray(entry.linked_adrs) ? entry.linked_adrs : [],
+    times_referenced:  entry.times_referenced || 0,
+    last_referenced:   entry.last_referenced || null,
+    deprecated:        false,
+    deprecated_by:     null,
+    // Type-specific fields
+    ...(entry.decision     && { decision:     entry.decision }),
+    ...(entry.rationale    && { rationale:    entry.rationale }),
+    ...(entry.alternatives && { alternatives: entry.alternatives }),
+    ...(entry.adr_reference && { adr_reference: entry.adr_reference }),
+    ...(entry.pattern_type && { pattern_type: entry.pattern_type }),
+    ...(entry.language     && { language:     entry.language }),
+    ...(entry.example_good && { example_good: entry.example_good }),
+    ...(entry.example_bad  && { example_bad:  entry.example_bad }),
+    ...(entry.bug_category && { bug_category: entry.bug_category }),
+    ...(entry.root_cause   && { root_cause:   entry.root_cause }),
+    ...(entry.fix          && { fix:          entry.fix }),
+    ...(entry.preference   && { preference:   entry.preference }),
+    ...(entry.strength     && { strength:     entry.strength }),
+    ...(entry.domain       && { domain:       entry.domain }),
+    ...(entry.tech_stack   && { tech_stack:   entry.tech_stack }),
+    // MindForge v6: Architectural Health & Stability
+    ...(entry.req_id       && { req_id:       entry.req_id }),
+    ...(entry.efficacy_score && { efficacy_score: entry.efficacy_score }),
+    ...(entry.rsa_avg      && { rsa_avg:      entry.rsa_avg }),
+    ...(entry.idc_avg      && { idc_avg:      entry.idc_avg }),
+    ...(entry.ceg_avg      && { ceg_avg:      entry.ceg_avg }),
+  };
+
+  const filePath = getFilePath(entry.type);
+  fs.appendFileSync(filePath, JSON.stringify(full) + '\n');
+
+  // Also append to unified knowledge-base.jsonl for cross-type queries
+  if (filePath !== paths.KB_PATH) {
+    fs.appendFileSync(paths.KB_PATH, JSON.stringify(full) + '\n');
+  }
+
+  return id;
+}
+
+/**
+ * Deprecate an entry (never hard-delete).
+ */
+function deprecate(id, reason, supersededBy = null) {
+  const paths = getPaths();
+  const entries = readAll();
+  const entry   = entries.find(e => e.id === id);
+  if (!entry) throw new Error(`Knowledge entry not found: ${id}`);
+
+  // Append a deprecation marker (new entry with same id, deprecated=true)
+  const filePath = getFilePath(entry.type);
+  const deprecated = {
+    ...entry,
+    deprecated:        true,
+    deprecated_by:     supersededBy,
+    deprecated_reason: reason,
+    deprecated_at:     new Date().toISOString(),
+  };
+
+  fs.appendFileSync(filePath, JSON.stringify(deprecated) + '\n');
+  if (filePath !== paths.KB_PATH) {
+    fs.appendFileSync(paths.KB_PATH, JSON.stringify(deprecated) + '\n');
+  }
+
+  return id;
+}
+
+/**
+ * Reinforce an entry (increase confidence, increment reference count).
+ */
+function reinforce(id) {
+  const paths = getPaths();
+  const entries   = readAll();
+  const entry     = entries.find(e => e.id === id && !e.deprecated);
+  if (!entry) return;
+
+  const reinforced = {
+    ...entry,
+    confidence:       Math.min(1.0, entry.confidence + 0.05),
+    times_referenced: entry.times_referenced + 1,
+    last_referenced:  new Date().toISOString(),
+  };
+
+  const filePath = getFilePath(entry.type);
+  fs.appendFileSync(filePath, JSON.stringify(reinforced) + '\n');
+  if (filePath !== paths.KB_PATH) {
+    fs.appendFileSync(paths.KB_PATH, JSON.stringify(reinforced) + '\n');
+  }
+}
+
+// ── Read operations ───────────────────────────────────────────────────────────
+
+/**
+ * Read all entries from a JSONL file.
+ * Handles the append pattern: later entries with same ID supersede earlier ones.
+ */
+function readFile(filePath) {
+  if (!fs.existsSync(filePath)) return [];
+
+  const lines = fs.readFileSync(filePath, 'utf8').split('\n').filter(Boolean);
+  const byId  = new Map(); // Later entries (same ID) win
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      byId.set(entry.id, entry); // Last write wins
+    } catch {
+      // Skip malformed lines — never crash on corrupt JSONL
+    }
+  }
+
+  return [...byId.values()];
+}
+
+function readAll(includeGlobal = false) {
+  const paths = getPaths();
+  let entries = readFile(paths.KB_PATH);
+  if (includeGlobal && fs.existsSync(paths.GLOBAL_KB_PATH)) {
+    const globalEntries = readFile(paths.GLOBAL_KB_PATH).map(e => ({ ...e, global: true }));
+    entries = [...entries, ...globalEntries];
+  }
+  return entries;
+}
+
+function readByType(type) {
+  return readFile(getFilePath(type)).filter(e => e.type === type);
+}
+
+// ── Query operations ──────────────────────────────────────────────────────────
+
+/**
+ * Query the knowledge base.
+ * Returns entries sorted by relevance score (confidence × recency × tag overlap).
+ */
+function query(params = {}) {
+  const {
+    tags          = [],
+    topic,
+    type,
+    minConfidence = 0.3,
+    limit         = 20,
+    includeGlobal = false,
+    includeDeprecated = false,
+    project,
+  } = params;
+
+  let entries = readAll(includeGlobal);
+
+  // Filter
+  if (!includeDeprecated) entries = entries.filter(e => !e.deprecated);
+  if (type)               entries = entries.filter(e => e.type === type);
+  if (project)            entries = entries.filter(e => !e.project || e.project === project);
+  entries = entries.filter(e => e.confidence >= minConfidence);
+
+  // Score entries by relevance
+  const scored = entries.map(e => ({
+    entry: e,
+    score: scoreRelevance(e, { tags, topic }),
+  }));
+
+  return scored
+    .filter(s => s.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit)
+    .map(s => s.entry);
+}
+
+function scoreRelevance(entry, { tags = [], topic = '' }) {
+  let score = entry.confidence; // Base score from confidence
+
+  // Tag overlap
+  const entryTags = entry.tags || [];
+  const tagOverlap = tags.filter(t => entryTags.some(et => et.toLowerCase() === t.toLowerCase())).length;
+  score += tagOverlap * 0.2;
+
+  // Topic text match
+  if (topic) {
+    const topicWords = topic.toLowerCase().split(/\s+/);
+    const entryText  = `${entry.topic} ${entry.content}`.toLowerCase();
+    const wordMatches = topicWords.filter(w => w.length > 3 && entryText.includes(w)).length;
+    score += (wordMatches / Math.max(topicWords.length, 1)) * 0.3;
+  }
+
+  // Recency boost (entries referenced in last 30 days get a small boost)
+  if (entry.last_referenced) {
+    const daysSince = (Date.now() - new Date(entry.last_referenced).getTime()) / 86_400_000;
+    if (daysSince < 30) score += 0.1 * (1 - daysSince / 30);
+  }
+
+  // Penalty for very low reference count (may be noisy)
+  if (entry.times_referenced === 0) score *= 0.9;
+
+  return score;
+}
+
+// ── Project name helper ───────────────────────────────────────────────────────
+function readProjectName() {
+  const projectMd = path.join(process.cwd(), '.planning', 'PROJECT.md');
+  if (!fs.existsSync(projectMd)) return 'unknown';
+  const match = fs.readFileSync(projectMd, 'utf8').match(/^# (.+)/m);
+  return match?.[1]?.trim().slice(0, 50) || 'unknown';
+}
+
+// ── Statistics ────────────────────────────────────────────────────────────────
+function stats() {
+  const all    = readAll();
+  const active = all.filter(e => !e.deprecated);
+  const byType = {};
+  for (const e of active) {
+    byType[e.type] = (byType[e.type] || 0) + 1;
+  }
+  return {
+    total_entries:      all.length,
+    active_entries:     active.length,
+    deprecated_entries: all.length - active.length,
+    by_type:            byType,
+    avg_confidence:     active.length
+      ? active.reduce((s, e) => s + e.confidence, 0) / active.length
+      : 0,
+  };
+}
+
+module.exports = {
+  add, deprecate, reinforce,
+  readAll, readByType, readFile, query, stats,
+  setBaseDir, setGlobalDir, setTestMode, getPaths,
+};

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/memory/pillar-health-tracker.js

@@ -0,0 +1,63 @@
+/**
+ * MindForge v6.7.0 — Pillar Health Tracker
+ * Component: Architectural Health & Stability (Pillar XVIII)
+ * 
+ * Aggregates scores from RSA, SCS, and IDC pillars to track project 
+ * stability and identify requirement-stagnation patterns.
+ */
+'use strict';
+
+const fs = require('fs');
+
+class PillarHealthTracker {
+  /**
+   * Summarizes the health of a completed phase based on the audit trail.
+   * @param {string} auditPath - Path to AUDIT.jsonl
+   */
+  summarizePhase(auditPath) {
+    if (!fs.existsSync(auditPath)) return null;
+
+    const lines = fs.readFileSync(auditPath, 'utf8').trim().split('\n');
+    const events = lines.map(l => JSON.parse(l));
+
+    // 1. RSA (Mission Fidelity) Analysis
+    const rsaEvents = events.filter(e => e.type === 'mission_fidelity' || e.event === 'scs_homing_injected');
+    const avgRsa = rsaEvents.length > 0 
+      ? rsaEvents.reduce((s, e) => s + (e.alignment?.confidence || e.confidence || 0), 0) / rsaEvents.length 
+      : 1.0;
+
+    // 2. IDC (Intelligence Drift) Analysis
+    const idcEvents = events.filter(e => e.event === 'intelligence_upgrade_signalled');
+    const idcScore = idcEvents.length; // Count of upgrades as drift indicator
+
+    // 3. Extract Stability Patterns (Successful SCS Homing)
+    const stabilityPatterns = events
+      .filter(e => e.event === 'scs_homing_injected' && e.confidence > 0.6)
+      .map(e => ({
+        req_id: e.req_id,
+        instruction: e.instruction,
+        efficacy: e.confidence
+      }));
+
+    return {
+      avgRsa: parseFloat(avgRsa.toFixed(4)),
+      idcCount: idcScore,
+      stabilityPatterns
+    };
+  }
+
+  /**
+   * Aggregates stability patterns by requirement ID.
+   */
+  getHighEfficacyTemplates(stabilityPatterns) {
+    const byId = new Map();
+    for (const p of stabilityPatterns) {
+      if (!byId.has(p.req_id) || byId.get(p.req_id).efficacy < p.efficacy) {
+        byId.set(p.req_id, p);
+      }
+    }
+    return Array.from(byId.values());
+  }
+}
+
+module.exports = new PillarHealthTracker();