mindforge-cc 8.2.0 → 9.0.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/memory/auto-shadow.js

@@ -1,274 +0,0 @@
-/**
- * MindForge v2.4.0 — Auto-Shadow Engine (RAG 2.0)
- * Proactive "ghost pattern" injection — surfaces relevant knowledge
- * before subagent execution WITHOUT manual /mindforge:remember calls.
- *
- * Design:
- * - Runs automatically before each subagent spawn (context-injector hook)
- * - Queries both the Knowledge Graph (traversal) and Embedding Engine (similarity)
- * - Formats top results into a structured context section
- * - Budget-capped at 2KB (~8000 chars) to prevent context bloat
- * - Deduplicates against Hot/Warm context already loaded
- * - Never shadows secrets, credentials, or deprecated entries
- */
-'use strict';
-
-const fs       = require('fs');
-const path     = require('path');
-const Store    = require('./knowledge-store');
-const Graph    = require('./knowledge-graph');
-const Embedder = require('./embedding-engine');
-
-// ── Configuration ─────────────────────────────────────────────────────────────
-const MAX_SHADOW_CHARS  = 8000;    // ~2KB tokens
-const MAX_SHADOW_ITEMS  = 5;       // Max items in shadow section
-const MIN_SHADOW_SCORE  = 0.35;    // Minimum combined score to include
-const SECURITY_KEYWORDS = new Set([
-  'password', 'secret', 'token', 'api_key', 'apikey', 'private_key',
-  'credential', 'auth_token', 'bearer', 'encryption_key', 'ssh',
-]);
-
-// ── Core Shadow Logic ─────────────────────────────────────────────────────────
-
-/**
- * Generate auto-shadow context for a given task description.
- * This is the primary entry point, called by the context-injector.
- *
- * @param {object} opts
- * @param {string} opts.taskDescription  - Current task/plan description
- * @param {string[]} [opts.excludeIds]   - Entry IDs already in hot/warm context
- * @param {string[]} [opts.techStack]    - Tech stack for relevance boosting
- * @param {number} [opts.maxItems]       - Override max items (default: 5)
- * @returns {{ formatted: string, items: object[], count: number, budgetUsed: number }}
- */
-function generateShadowContext(opts = {}) {
-  const {
-    taskDescription = '',
-    excludeIds = [],
-    techStack = [],
-    maxItems = MAX_SHADOW_ITEMS,
-  } = opts;
-
-  if (!taskDescription || taskDescription.length < 10) {
-    return { formatted: '', items: [], count: 0, budgetUsed: 0 };
-  }
-
-  // 1. Build embeddings for the full knowledge base
-  const allEntries = Store.readAll(true); // Include global
-  const activeEntries = allEntries.filter(e => !e.deprecated && e.confidence >= 0.3);
-
-  if (activeEntries.length === 0) {
-    return { formatted: '', items: [], count: 0, budgetUsed: 0 };
-  }
-
-  const { vectors, df, N } = Embedder.buildEmbeddings(activeEntries);
-
-  // 2. Hybrid query: embedding similarity + graph traversal
-  const queryText = `${taskDescription} ${techStack.join(' ')}`;
-  const related = Graph.findRelated(queryText, vectors, df, N, {
-    maxHops: 2,
-    topK: maxItems * 2, // Over-fetch for filtering
-  });
-
-  // 3. Filter and enrich results
-  const excludeSet = new Set(excludeIds);
-  const enriched = [];
-
-  for (const result of related) {
-    if (excludeSet.has(result.id)) continue;
-    if (result.score < MIN_SHADOW_SCORE) continue;
-
-    const entry = activeEntries.find(e => e.id === result.id);
-    if (!entry) continue;
-
-    // Security guard: never shadow secrets
-    if (containsSecrets(entry)) continue;
-
-    enriched.push({
-      id: entry.id,
-      type: entry.type,
-      topic: entry.topic,
-      content: entry.content,
-      confidence: entry.confidence,
-      score: result.score,
-      source: result.source,
-      tags: entry.tags || [],
-      edges: getEdgeSummary(entry.id),
-    });
-  }
-
-  // 4. Sort by score and cap
-  enriched.sort((a, b) => b.score - a.score);
-  const capped = enriched.slice(0, maxItems);
-
-  // 5. Format for context injection (budget-capped)
-  const formatted = formatShadowSection(capped);
-
-  return {
-    formatted,
-    items: capped,
-    count: capped.length,
-    budgetUsed: formatted.length,
-  };
-}
-
-// ── Formatting ────────────────────────────────────────────────────────────────
-
-/**
- * Format shadow items into a structured context section.
- * Budget-capped at MAX_SHADOW_CHARS.
- * @param {object[]} items
- * @returns {string}
- */
-function formatShadowSection(items) {
-  if (items.length === 0) return '';
-
-  const lines = [
-    '## Auto-Shadow Context (RAG 2.0)',
-    '',
-    '> These are automatically surfaced "ghost patterns" from past sessions.',
-    '> Use them as background context — do not explicitly reference them unless relevant.',
-    '',
-  ];
-
-  let totalChars = lines.join('\n').length;
-
-  for (const item of items) {
-    const icon = getTypeIcon(item.type);
-    const edgeNote = item.edges ? ` [${item.edges}]` : '';
-    const confidenceBar = `${(item.confidence * 100).toFixed(0)}%`;
-
-    const header = `### ${icon} ${item.topic} (${confidenceBar} confidence)${edgeNote}`;
-    const content = truncateContent(item.content, 300);
-    const tags = item.tags.length > 0 ? `Tags: ${item.tags.join(', ')}` : '';
-    const sourceLabel = `Source: ${item.source} | Score: ${item.score.toFixed(2)}`;
-
-    const block = [header, content, tags, sourceLabel, ''].join('\n');
-
-    if (totalChars + block.length > MAX_SHADOW_CHARS) break;
-    lines.push(block);
-    totalChars += block.length;
-  }
-
-  return lines.join('\n');
-}
-
-/**
- * Get icon for entry type.
- * @param {string} type
- * @returns {string}
- */
-function getTypeIcon(type) {
-  const icons = {
-    architectural_decision: '🏛️',
-    code_pattern:           '🔧',
-    bug_pattern:            '🐛',
-    team_preference:        '👥',
-    domain_knowledge:       '📚',
-  };
-  return icons[type] || '💡';
-}
-
-/**
- * Get a brief edge summary for a node.
- * @param {string} nodeId
- * @returns {string}
- */
-function getEdgeSummary(nodeId) {
-  try {
-    const edges = Graph.getNodeEdges(nodeId);
-    if (edges.length === 0) return '';
-
-    const types = {};
-    for (const e of edges) {
-      types[e.type] = (types[e.type] || 0) + 1;
-    }
-
-    return Object.entries(types)
-      .map(([type, count]) => `${count} ${type.toLowerCase().replace(/_/g, '-')}`)
-      .join(', ');
-  } catch {
-    return '';
-  }
-}
-
-/**
- * Truncate content to maxLen characters, adding ellipsis.
- * @param {string} content
- * @param {number} maxLen
- * @returns {string}
- */
-function truncateContent(content, maxLen) {
-  if (!content) return '';
-  if (content.length <= maxLen) return content;
-  return content.slice(0, maxLen - 3) + '...';
-}
-
-// ── Security ──────────────────────────────────────────────────────────────────
-
-/**
- * Check if an entry might contain secrets/credentials.
- * @param {object} entry
- * @returns {boolean}
- */
-function containsSecrets(entry) {
-  const text = `${entry.topic} ${entry.content} ${(entry.tags || []).join(' ')}`.toLowerCase();
-
-  for (const keyword of SECURITY_KEYWORDS) {
-    if (text.includes(keyword)) return true;
-  }
-
-  // Check for common secret patterns
-  const secretPatterns = [
-    /[a-z0-9]{32,}/,      // Long hex strings (API keys)
-    /-----BEGIN/,          // PEM keys
-    /sk_[a-z]+_[a-z0-9]/i, // Stripe-style keys
-  ];
-
-  for (const pattern of secretPatterns) {
-    if (pattern.test(entry.content || '')) return true;
-  }
-
-  return false;
-}
-
-// ── Contradiction Detection ───────────────────────────────────────────────────
-
-/**
- * Check shadow items for contradictions and flag them.
- * Looks for CONTRADICTS edges between shadow items.
- * @param {object[]} items - Shadow items
- * @returns {object[]} Items with contradiction flags
- */
-function flagContradictions(items) {
-  const itemIds = new Set(items.map(i => i.id));
-
-  for (const item of items) {
-    const edges = Graph.getNodeEdges(item.id, {
-      edgeTypes: [Graph.EDGE_TYPES.CONTRADICTS],
-    });
-
-    const contradicted = edges.some(e =>
-      itemIds.has(e.sourceId === item.id ? e.targetId : e.sourceId)
-    );
-
-    if (contradicted) {
-      item.contradiction = true;
-      item.topic = `⚠️ ${item.topic} [CONTRADICTED]`;
-    }
-  }
-
-  return items;
-}
-
-// ── Exports ───────────────────────────────────────────────────────────────────
-module.exports = {
-  generateShadowContext,
-  formatShadowSection,
-  containsSecrets,
-  flagContradictions,
-  getEdgeSummary,
-  MAX_SHADOW_CHARS,
-  MAX_SHADOW_ITEMS,
-  MIN_SHADOW_SCORE,
-};

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

@@ -1,99 +0,0 @@
-#!/usr/bin/env node
-/**
- * MindForge v2 — /mindforge:remember CLI
- */
-'use strict';
-
-const Store   = require('./knowledge-store');
-const Indexer = require('./knowledge-indexer');
-const Sync    = require('./global-sync');
-
-const args = process.argv.slice(2);
-const help = `
-Usage: /mindforge:remember [options]
-
-Options:
-  --add "content"     Add a new domain knowledge entry
-  --topic "title"     Set topic for the new entry
-  --tags "t1,t2"      Set tags for the new entry
-  --type "type"       Set type (default: domain_knowledge)
-  --search "query"    Search the knowledge base
-  --list [type]       List recent entries (optional filter by type)
-  --stats             Show memory statistics
-  --promote "id"      Promote an entry to the global knowledge base
-  --global            Include global entries in search/list
-  --help              Show this help
-`;
-
-async function run() {
-  if (args.includes('--help') || args.length === 0) {
-    console.log(help);
-    return;
-  }
-
-  if (args.includes('--stats')) {
-    console.log('\n--- Project Memory Statistics ---');
-    console.log(JSON.stringify(Store.stats(), null, 2));
-    console.log('\n--- Global Memory Statistics ---');
-    console.log(JSON.stringify(Sync.globalStats(), null, 2));
-    return;
-  }
-
-  if (args.includes('--add')) {
-    const content = args[args.indexOf('--add') + 1];
-    const topic   = args[args.indexOf('--topic') + 1] || content.slice(0, 50);
-    const tags    = (args[args.indexOf('--tags') + 1] || '').split(',').filter(Boolean);
-    const type    = args[args.indexOf('--type') + 1] || 'domain_knowledge';
-
-    const id = Store.add({ type, topic, content, tags, source: 'manual-cli' });
-    console.log(`✅ Remembered! Entry added with ID: ${id}`);
-    return;
-  }
-
-  if (args.includes('--search')) {
-    const query = args[args.indexOf('--search') + 1];
-    const includeGlobal = args.includes('--global');
-    const results = Indexer.search(query, { includeGlobal });
-
-    if (results.length === 0) {
-      console.log('No matching memories found.');
-    } else {
-      console.log(`\nFound ${results.length} relevant memories:`);
-      results.forEach((e, i) => {
-        const globalMarker = e.global ? '[GLOBAL] ' : '';
-        console.log(`${i+1}. ${globalMarker}${e.topic} (${(e.confidence * 100).toFixed(0)}% confidence)`);
-        console.log(`   ID: ${e.id}`);
-        console.log(`   ${e.content.slice(0, 100)}...`);
-        console.log();
-      });
-    }
-    return;
-  }
-
-  if (args.includes('--list')) {
-    const type = args[args.indexOf('--list') + 1];
-    const entries = type ? Store.readByType(type) : Store.readAll(args.includes('--global'));
-    
-    console.log('\nShowing last 10 entries:');
-    entries.slice(-10).reverse().forEach((e, i) => {
-      console.log(`${i+1}. [${e.type}] ${e.topic} (${e.id})`);
-    });
-    return;
-  }
-
-  if (args.includes('--promote')) {
-    const id = args[args.indexOf('--promote') + 1];
-    try {
-      const result = Sync.promote(id);
-      console.log(`✅ Promoted! Entry ${id} is now in your global knowledge base.`);
-    } catch (err) {
-      console.error(`Error: ${err.message}`);
-    }
-    return;
-  }
-}
-
-run().catch(err => {
-  console.error(err);
-  process.exit(1);
-});

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/memory/eis-client.js

@@ -1,95 +0,0 @@
-/**
- * MindForge v5 — Enterprise Intelligence Service (EIS) Client
- * Handles communication with the central organizational intelligence hub.
- */
-'use strict';
-
-const fs    = require('node:fs');
-const path  = require('node:path');
-const crypto = require('node:crypto');
-const ZTAI = require('../governance/ztai-manager');
-
-class EISClient {
-  constructor(config = {}) {
-    this.endpoint = config.endpoint || process.env.MINDFORGE_EIS_ENDPOINT || 'http://localhost:7340';
-    this.apiKey   = config.apiKey   || process.env.MINDFORGE_EIS_KEY || '';
-    this.orgId    = config.orgId    || 'default-org';
-    this.syncInterval = config.syncInterval || 300_000; // 5 minutes
-  }
-
-  /**
-   * Pushes local knowledge entries to the central Mesh.
-   * @param {Array} entries - Local knowledge entries to sync.
-   */
-  async push(entries) {
-    console.log(`[EIS-SYNC] Pushing ${entries.length} entries to Enterprise Intelligence Service...`);
-    
-    // Simulate network request
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        const results = entries.map(e => ({
-          id: e.id,
-          status: 'synced',
-          version: crypto.createHash('sha256').update(JSON.stringify(e)).digest('hex').slice(0, 8)
-        }));
-        resolve(results);
-      }, 500);
-    });
-  }
-
-  /**
-   * Pulls new knowledge from the central Mesh.
-   * @param {Object} filter - Filter criteria (e.g. since timestamp).
-   */
-  async pull(filter = {}) {
-    console.log(`[EIS-SYNC] Pulling new organizational knowledge from ${this.endpoint}...`);
-    
-    // Simulate network response
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        // Return empty array for now as this is a simulation
-        resolve([]);
-      }, 300);
-    });
-  }
-
-  /**
-   * Verifies the authenticity of a remote knowledge entry.
-   * @param {Object} entry - The remote entry.
-   * @param {String} signature - The ZTAI signature from the remote agent.
-   */
-  verifyRemoteProvenance(entry, signature) {
-    if (!signature) return false;
-    // Real implementation would use ZTAIManager to verify the DID signature
-    return true;
-  }
-
-  /**
-   * Resolves a remote node reference.
-   * @param {String} nodeId - The ID of the remote node.
-   */
-  async resolveRemoteNode(nodeId) {
-    console.log(`[EIS-RESOLVE] Resolving remote node: ${nodeId}`);
-    // Real implementation would fetch from the EIS API
-    return null;
-  }
-
-  /**
-   * [HARDEN] Generates a cryptographically signed auth header using the agent's DID.
-   * This ensures verifiable provenance of knowledge within the mesh.
-   */
-  async getAuthHeader(action, resource) {
-    const manager = new ZTAI();
-    const identity = manager.getIdentity();
-    const payload = `${this.orgId}:${action}:${resource}:${Date.now()}`;
-    const signature = manager.sign(payload);
-    
-    return {
-      'Authorization': `ZTAI-v5 ${identity.did}:${signature}`,
-      'X-MF-Org': this.orgId,
-      'X-MF-Timestamp': Date.now().toString()
-    };
-  }
-}
-
-module.exports = EISClient;