monomind 2.7.12 → 2.7.14

package/packages/@monomind/cli/dist/src/memory/memory-initializer.js

@@ -1,431 +0,0 @@
-/**
- * Memory Initializer
- * Properly initializes the memory database with sql.js (WASM SQLite)
- * Includes pattern tables, vector embeddings, migration state tracking
- *
- * ADR-053: Routes through ControllerRegistry → SQLite-backed memory bridge
- * when available, falls back to raw sql.js for backwards compatibility.
- *
- * @module v1/cli/memory-initializer
- */
-import * as fs from 'fs';
-import * as path from 'path';
-/** Maximum SQLite database file size accepted before read (256 MB). */
-const MAX_DB_FILE_BYTES = 256 * 1024 * 1024;
-// ADR-053: Lazy import of SQLite-backed memory bridge
-let _bridge;
-async function getBridge() {
-    if (_bridge === null)
-        return null;
-    if (_bridge)
-        return _bridge;
-    try {
-        _bridge = await import('./memory-bridge.js');
-        return _bridge;
-    }
-    catch {
-        _bridge = null;
-        return null;
-    }
-}
-// ============================================================================
-// Re-exports from extracted modules (ARCH-4)
-// ============================================================================
-export { MEMORY_SCHEMA } from './memory-schema.js';
-export { getHNSWIndex, addToHNSWIndex, searchHNSWIndex, getHNSWStatus, clearHNSWIndex, rebuildSearchIndex, quantizeInt8, dequantizeInt8, quantizedCosineSim, getQuantizationStats, batchCosineSim, softmaxAttention, topKIndices, flashAttentionSearch, } from './hnsw-operations.js';
-export { ensureSchemaColumns, checkAndMigrateLegacy, } from './memory-migrations.js';
-export { loadEmbeddingModel, generateEmbedding, generateBatchEmbeddings, generateHashEmbedding, } from './embedding-operations.js';
-export { verifyMemoryInit, storeEntry, searchEntries, listEntries, getEntry, deleteEntry, } from './memory-crud.js';
-// ============================================================================
-// Local imports for use in this file
-// ============================================================================
-import { MEMORY_SCHEMA } from './memory-schema.js';
-import { checkAndMigrateLegacy, ensureSchemaColumns } from './memory-migrations.js';
-import { rebuildSearchIndex } from './hnsw-operations.js';
-import { verifyMemoryInit, storeEntry, searchEntries, listEntries, getEntry, deleteEntry, } from './memory-crud.js';
-import { loadEmbeddingModel, generateEmbedding, } from './embedding-operations.js';
-// ============================================================================
-// METADATA AND INITIALIZATION
-// ============================================================================
-/**
- * Initial metadata to insert after schema creation
- */
-export function getInitialMetadata(backend) {
-    const safeBackend = backend.replace(/'/g, "''");
-    return `
-INSERT OR REPLACE INTO metadata (key, value) VALUES
-  ('schema_version', '3.0.0'),
-  ('backend', '${safeBackend}'),
-  ('created_at', '${new Date().toISOString()}'),
-  ('sql_js', 'true'),
-  ('vector_embeddings', 'enabled'),
-  ('pattern_learning', 'enabled'),
-  ('temporal_decay', 'enabled'),
-  ('hnsw_indexing', 'enabled');
-
--- Create default vector index configuration
--- Dimensions match BRIDGE_EMBEDDING_DIMS=384 (Xenova/all-MiniLM-L6-v2).
-INSERT OR IGNORE INTO vector_indexes (id, name, dimensions) VALUES
-  ('default', 'default', 384),
-  ('patterns', 'patterns', 384);
-`;
-}
-/**
- * ADR-053: Activate ControllerRegistry so memory-backend controllers
- * (ReasoningBank, SkillLibrary, ExplainableRecall, etc.) are instantiated.
- *
- * Uses the memory-bridge's getControllerRegistry() which lazily creates
- * a singleton ControllerRegistry and initializes it with the given dbPath.
- * After this call, all enabled controllers are ready for immediate use.
- *
- * Failures are isolated: if @monomind/memory or the SQLite backend is not
- * available, this returns an empty result without throwing.
- */
-async function activateControllerRegistry(dbPath, verbose) {
-    const startTime = performance.now();
-    const activated = [];
-    const failed = [];
-    try {
-        const bridge = await getBridge();
-        if (!bridge) {
-            return { activated, failed, initTimeMs: performance.now() - startTime };
-        }
-        const registry = await bridge.getControllerRegistry(dbPath);
-        if (!registry) {
-            return { activated, failed, initTimeMs: performance.now() - startTime };
-        }
-        // Collect controller status from the registry
-        if (typeof registry.listControllers === 'function') {
-            const controllers = registry.listControllers();
-            for (const ctrl of controllers) {
-                if (ctrl.enabled) {
-                    activated.push(ctrl.name);
-                }
-                else {
-                    failed.push(ctrl.name);
-                }
-            }
-        }
-        if (verbose && activated.length > 0) {
-            console.log(`ControllerRegistry: ${activated.length} controllers activated`);
-        }
-    }
-    catch (e) {
-        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-            console.error('[activateControllers] ControllerRegistry activation failed:', e);
-    }
-    return { activated, failed, initTimeMs: performance.now() - startTime };
-}
-/**
- * Initialize the memory database properly using sql.js
- */
-export async function initializeMemoryDatabase(options) {
-    const { backend = 'hybrid', dbPath: customPath, force = false, verbose = false, migrate = true } = options;
-    const swarmDir = path.join(process.cwd(), '.swarm');
-    const dbPath = customPath || path.join(swarmDir, 'memory.db');
-    const dbDir = path.dirname(dbPath);
-    try {
-        // Create directory if needed
-        if (!fs.existsSync(dbDir)) {
-            fs.mkdirSync(dbDir, { recursive: true });
-        }
-        // Check for legacy installations
-        if (migrate) {
-            const legacyCheck = await checkAndMigrateLegacy({ dbPath, verbose });
-            if (legacyCheck.needsMigration && verbose) {
-                console.log(`Found legacy database (v${legacyCheck.legacyVersion}) with ${legacyCheck.legacyEntries} entries`);
-            }
-        }
-        // Check existing database
-        if (fs.existsSync(dbPath) && !force) {
-            return {
-                success: false,
-                backend,
-                dbPath,
-                schemaVersion: '3.0.0',
-                tablesCreated: [],
-                indexesCreated: [],
-                features: {
-                    vectorEmbeddings: false,
-                    patternLearning: false,
-                    temporalDecay: false,
-                    hnswIndexing: false,
-                    migrationTracking: false
-                },
-                error: 'Database already exists. Use --force to reinitialize.'
-            };
-        }
-        // Try to use sql.js (WASM SQLite)
-        let db;
-        let usedSqlJs = false;
-        try {
-            // Dynamic import of sql.js
-            const initSqlJs = (await import('sql.js')).default;
-            const SQL = await initSqlJs();
-            // Load existing database or create new
-            if (fs.existsSync(dbPath) && force) {
-                fs.unlinkSync(dbPath);
-            }
-            db = new SQL.Database();
-            usedSqlJs = true;
-        }
-        catch (e) {
-            // sql.js not available, fall back to writing schema file
-            if (verbose) {
-                console.log('sql.js not available, writing schema file for later initialization');
-            }
-        }
-        if (usedSqlJs && db) {
-            // Execute schema
-            db.run(MEMORY_SCHEMA);
-            // Insert initial metadata
-            db.run(getInitialMetadata(backend));
-            // Save to file atomically — direct writeFileSync to dbPath would corrupt
-            // the SQLite file if the process crashes mid-write. tmp+rename is atomic on POSIX.
-            const data = db.export();
-            const buffer = Buffer.from(data);
-            const dbTmp = dbPath + '.tmp';
-            fs.writeFileSync(dbTmp, buffer);
-            fs.renameSync(dbTmp, dbPath);
-            // Close database
-            db.close();
-            // Also create schema file for reference (atomic)
-            const schemaPath = path.join(dbDir, 'schema.sql');
-            const schemaTmp = schemaPath + '.tmp';
-            fs.writeFileSync(schemaTmp, MEMORY_SCHEMA + '\n' + getInitialMetadata(backend));
-            fs.renameSync(schemaTmp, schemaPath);
-            // ADR-053: Activate ControllerRegistry so controllers (ReasoningBank,
-            // SkillLibrary, ExplainableRecall, etc.) are instantiated during init
-            const controllerResult = await activateControllerRegistry(dbPath, verbose);
-            return {
-                success: true,
-                backend,
-                dbPath,
-                schemaVersion: '3.0.0',
-                tablesCreated: [
-                    'memory_entries',
-                    'patterns',
-                    'pattern_history',
-                    'trajectories',
-                    'trajectory_steps',
-                    'migration_state',
-                    'sessions',
-                    'vector_indexes',
-                    'metadata'
-                ],
-                indexesCreated: [
-                    'idx_memory_namespace',
-                    'idx_memory_key',
-                    'idx_memory_type',
-                    'idx_memory_status',
-                    'idx_memory_created',
-                    'idx_memory_accessed',
-                    'idx_memory_owner',
-                    'idx_patterns_type',
-                    'idx_patterns_confidence',
-                    'idx_patterns_status',
-                    'idx_patterns_last_matched',
-                    'idx_pattern_history_pattern',
-                    'idx_steps_trajectory'
-                ],
-                features: {
-                    vectorEmbeddings: true,
-                    patternLearning: true,
-                    temporalDecay: true,
-                    hnswIndexing: true,
-                    migrationTracking: true
-                },
-                controllers: controllerResult,
-            };
-        }
-        else {
-            // Fall back to schema file approach (atomic writes)
-            const schemaPath = path.join(dbDir, 'schema.sql');
-            const schemaTmpFb = schemaPath + '.tmp';
-            fs.writeFileSync(schemaTmpFb, MEMORY_SCHEMA + '\n' + getInitialMetadata(backend));
-            fs.renameSync(schemaTmpFb, schemaPath);
-            // Create minimal valid SQLite file
-            const sqliteHeader = Buffer.alloc(4096, 0);
-            // SQLite format 3 header
-            Buffer.from('SQLite format 3\0').copy(sqliteHeader, 0);
-            sqliteHeader[16] = 0x10; // page size high byte (4096)
-            sqliteHeader[17] = 0x00; // page size low byte
-            sqliteHeader[18] = 0x01; // file format write version
-            sqliteHeader[19] = 0x01; // file format read version
-            sqliteHeader[24] = 0x00; // max embedded payload
-            sqliteHeader[25] = 0x40;
-            sqliteHeader[26] = 0x20; // min embedded payload
-            sqliteHeader[27] = 0x20; // leaf payload
-            const dbTmpFb = dbPath + '.tmp';
-            fs.writeFileSync(dbTmpFb, sqliteHeader);
-            fs.renameSync(dbTmpFb, dbPath);
-            // ADR-053: Activate ControllerRegistry even on fallback path
-            const controllerResult = await activateControllerRegistry(dbPath, verbose);
-            return {
-                success: true,
-                backend,
-                dbPath,
-                schemaVersion: '3.0.0',
-                tablesCreated: [
-                    'memory_entries (pending)',
-                    'patterns (pending)',
-                    'pattern_history (pending)',
-                    'trajectories (pending)',
-                    'trajectory_steps (pending)',
-                    'migration_state (pending)',
-                    'sessions (pending)',
-                    'vector_indexes (pending)',
-                    'metadata (pending)'
-                ],
-                indexesCreated: [],
-                features: {
-                    vectorEmbeddings: true,
-                    patternLearning: true,
-                    temporalDecay: true,
-                    hnswIndexing: true,
-                    migrationTracking: true
-                },
-                controllers: controllerResult,
-            };
-        }
-    }
-    catch (error) {
-        return {
-            success: false,
-            backend,
-            dbPath,
-            schemaVersion: '3.0.0',
-            tablesCreated: [],
-            indexesCreated: [],
-            features: {
-                vectorEmbeddings: false,
-                patternLearning: false,
-                temporalDecay: false,
-                hnswIndexing: false,
-                migrationTracking: false
-            },
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
-}
-/**
- * Check if memory database is properly initialized
- */
-export async function checkMemoryInitialization(dbPath) {
-    const swarmDir = path.join(process.cwd(), '.swarm');
-    const path_ = dbPath || path.join(swarmDir, 'memory.db');
-    if (!fs.existsSync(path_)) {
-        return { initialized: false };
-    }
-    try {
-        // Try to load with sql.js
-        const initSqlJs = (await import('sql.js')).default;
-        const SQL = await initSqlJs();
-        // Guard against excessively large DB files to prevent OOM.
-        const checkStat = fs.statSync(path_);
-        if (checkStat.size > MAX_DB_FILE_BYTES) {
-            return { initialized: false };
-        }
-        const fileBuffer = fs.readFileSync(path_);
-        const db = new SQL.Database(fileBuffer);
-        // Check for metadata table
-        const tables = db.exec("SELECT name FROM sqlite_master WHERE type='table'");
-        const tableNames = tables[0]?.values?.map(v => v[0]) || [];
-        // Get version
-        let version = 'unknown';
-        let backend = 'unknown';
-        try {
-            const versionResult = db.exec("SELECT value FROM metadata WHERE key='schema_version'");
-            version = versionResult[0]?.values[0]?.[0] || 'unknown';
-            const backendResult = db.exec("SELECT value FROM metadata WHERE key='backend'");
-            backend = backendResult[0]?.values[0]?.[0] || 'unknown';
-        }
-        catch {
-            // Metadata table might not exist
-        }
-        db.close();
-        return {
-            initialized: true,
-            version,
-            backend,
-            features: {
-                vectorEmbeddings: tableNames.includes('vector_indexes'),
-                patternLearning: tableNames.includes('patterns'),
-                temporalDecay: tableNames.includes('pattern_history')
-            },
-            tables: tableNames
-        };
-    }
-    catch {
-        // Could not read database
-        return { initialized: false };
-    }
-}
-/**
- * Apply temporal decay to patterns
- * Reduces confidence of patterns that haven't been used recently
- */
-export async function applyTemporalDecay(dbPath) {
-    const swarmDir = path.join(process.cwd(), '.swarm');
-    const path_ = dbPath || path.join(swarmDir, 'memory.db');
-    try {
-        const initSqlJs = (await import('sql.js')).default;
-        const SQL = await initSqlJs();
-        // Guard against excessively large DB files to prevent OOM.
-        const decayStat = fs.statSync(path_);
-        if (decayStat.size > MAX_DB_FILE_BYTES) {
-            return { success: false, patternsDecayed: 0, error: `Database file too large: ${decayStat.size} bytes` };
-        }
-        const fileBuffer = fs.readFileSync(path_);
-        const db = new SQL.Database(fileBuffer);
-        // Apply decay: confidence *= exp(-decay_rate * days_since_last_use)
-        const now = Date.now();
-        const decayQuery = `
-      UPDATE patterns
-      SET
-        confidence = confidence * (1.0 - decay_rate * ((? - COALESCE(last_matched_at, created_at)) / 86400000.0)),
-        updated_at = ?
-      WHERE status = 'active'
-        AND confidence > 0.1
-        AND (? - COALESCE(last_matched_at, created_at)) > 86400000
-    `;
-        db.run(decayQuery, [now, now, now]);
-        const changes = db.getRowsModified();
-        // Save atomically
-        const data = db.export();
-        const dbTmpDecay = path_ + '.tmp';
-        fs.writeFileSync(dbTmpDecay, Buffer.from(data));
-        fs.renameSync(dbTmpDecay, path_);
-        db.close();
-        return {
-            success: true,
-            patternsDecayed: changes
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            patternsDecayed: 0,
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
-}
-export default {
-    initializeMemoryDatabase,
-    checkMemoryInitialization,
-    checkAndMigrateLegacy,
-    ensureSchemaColumns,
-    applyTemporalDecay,
-    loadEmbeddingModel,
-    generateEmbedding,
-    verifyMemoryInit,
-    storeEntry,
-    searchEntries,
-    listEntries,
-    getEntry,
-    deleteEntry,
-    rebuildSearchIndex,
-    MEMORY_SCHEMA,
-    getInitialMetadata
-};
-//# sourceMappingURL=memory-initializer.js.map

package/packages/@monomind/cli/dist/src/memory/memory-kg.d.ts

@@ -1,186 +0,0 @@
-/**
- * Memory Knowledge Graph — entities, relations, and rules distilled from
- * agent sessions and org runs (cognee-concept port, Phase 2 of
- * docs/mastermind/2026-07-19-cognee-port-plan.md).
- *
- * Storage rides store A (memory-bridge) rather than a dedicated SQLite DB:
- * nodes live in namespace `kg:nodes`, edges in `kg:edges`, distilled rules
- * additionally in `rules` (so existing knowledge/injection surfaces find them).
- * That buys embeddings, upsert, sql.js fallback, and the Phase 1
- * feedback/frequency weighting for free — KG node ranking improves with use
- * automatically.
- *
- * Identity is deterministic and NAME-ONLY (cognee's Entity.identity_fields):
- * the entry KEY is `n:<normalized-name>`, so the same entity extracted from
- * any session merges idempotently via upsert regardless of assigned type.
- * Every write carries `origin_refs` so a bad ingest can be rolled back per
- * run/session.
- *
- * // monolean: graph traversal is in-process over a full kg:edges list —
- * // fine to ~10k edges; upgrade path is a real SQLite edges table with
- * // indexed src/dst columns if orgs outgrow that.
- *
- * @module v1/cli/memory/memory-kg
- */
-export declare const KG_NODES_NS = "kg:nodes";
-export declare const KG_EDGES_NS = "kg:edges";
-export declare const RULES_NS = "rules";
-export interface KgNodeInput {
-    name: string;
-    /** Basic type, cognee-style ("Person", "Tool", "Service") — not over-specific. */
-    type?: string;
-    description?: string;
-    nodeSet?: string;
-}
-export interface KgEdgeInput {
-    source: string;
-    target: string;
-    /** snake_case relation name. */
-    relation: string;
-    /** One-sentence concrete fact using the endpoint names. */
-    description?: string;
-    sourceType?: string;
-    targetType?: string;
-}
-export interface KgIngestResult {
-    success: boolean;
-    nodesAdded: number;
-    nodesMerged: number;
-    edgesAdded: number;
-    edgesMerged: number;
-    error?: string;
-}
-/** cognee DataPoint normalization: lowercase, spaces→_, strip apostrophes. */
-export declare function normalizeName(name: string): string;
-/** Identity is NAME-ONLY (cognee's Entity.identity_fields = ["name"]) — type
- *  lives in metadata. Including type in the key forked the same entity when
- *  the LLM said "Module" and the heuristic said "entity". */
-export declare function nodeKey(_type: string, name: string): string;
-/** Idempotently merge extracted nodes/edges into the KG. Same-name entities
- *  collapse onto one node (deterministic key + upsert); origin_refs accumulate
- *  so rollback can undo a single run's contribution. */
-export declare function kgIngest(options: {
-    nodes: KgNodeInput[];
-    edges?: KgEdgeInput[];
-    /** Provenance: run id, session id, or doc hash this extraction came from. */
-    originRef: string;
-    dbPath?: string;
-}): Promise<KgIngestResult>;
-export interface RuleVerdict {
-    rule: string;
-    verdict: 'accepted' | 'already_known' | 'invalid';
-    similarTo?: string;
-}
-/** Stage-2 of cognee's curator/writer distillation: the CALLER (an LLM agent)
- *  proposes candidate rules; this accepts each unless a semantically
- *  near-identical rule exists (embedding dedup — deterministic keys can't
- *  collapse paraphrases). Accepted rules are stored both as KG nodes
- *  (node_set=rules) and as plain `rules`-namespace entries so the existing
- *  injection/search surfaces pick them up with zero new plumbing. */
-export declare function kgIngestRules(options: {
-    rules: {
-        rule: string;
-        context?: string;
-    }[];
-    originRef: string;
-    dbPath?: string;
-    /** Similarity above which a candidate is already_known (default 0.78 —
-     *  MiniLM paraphrases of the same rule commonly land 0.78-0.9; cognee's
-     *  equivalent control is prompt-injected LLM judgment, which we approximate). */
-    dedupThreshold?: number;
-}): Promise<{
-    success: boolean;
-    verdicts: RuleVerdict[];
-    accepted: number;
-    error?: string;
-}>;
-/** List stored rules (for injection or review). */
-export declare function kgListRules(options?: {
-    dbPath?: string;
-    limit?: number;
-}): Promise<{
-    rule: string;
-    key: string;
-}[]>;
-export interface KgSearchResult {
-    success: boolean;
-    /** Rendered triplet lines, best first. */
-    context: string;
-    triplets: {
-        source: string;
-        relation: string;
-        target: string;
-        fact: string;
-        score: number;
-    }[];
-    seeds: {
-        name: string;
-        type: string;
-        description: string;
-        score: number;
-        id: string;
-    }[];
-    error?: string;
-}
-/** Vector-seed → neighborhood → triplet ranking (cognee's brute-force triplet
- *  search, scaled down). Seed scores already carry the Phase 1 feedback blend. */
-export declare function kgSearch(options: {
-    query: string;
-    dbPath?: string;
-    limit?: number;
-    nodeSet?: string;
-}): Promise<KgSearchResult>;
-export declare function kgGlossary(options?: {
-    dbPath?: string;
-    limit?: number;
-}): Promise<string[]>;
-/** Delete every node/edge/rule whose ONLY origin is `originRef`. Elements with
- *  other origins survive (shared knowledge isn't destroyed by one bad run);
- *  their origin lists retain the ref — acceptable residue.
- *  // monolean: no origin-list rewrite — needs an update-by-id bridge API */
-export declare function kgRollback(options: {
-    originRef: string;
-    dbPath?: string;
-}): Promise<{
-    success: boolean;
-    deleted: number;
-    retained: number;
-    error?: string;
-}>;
-export interface ConsolidationCandidate {
-    name: string;
-    type: string;
-    description: string;
-    edgeCount: number;
-    /** Neighborhood facts to merge into one canonical description. */
-    neighborhood: string[];
-}
-/** Entities whose descriptions are stale relative to their connectivity —
- *  the LLM half runs in the LIVE agent: it rewrites each candidate's
- *  description from the neighborhood facts and resubmits via memory_kg_ingest
- *  (longer descriptions win on merge). No LLM here (fully local constraint). */
-export declare function kgConsolidateCandidates(options?: {
-    dbPath?: string;
-    /** Minimum edges for a node to qualify (default 3). */
-    minEdges?: number;
-    limit?: number;
-}): Promise<ConsolidationCandidate[]>;
-export declare function kgStats(options?: {
-    dbPath?: string;
-}): Promise<{
-    nodes: number;
-    edges: number;
-    rules: number;
-}>;
-/** Regex extraction for when no LLM is in the loop (memory-palace lineage):
- *  proper-noun phrases and `code identifiers` become entities, sentence
- *  co-occurrence becomes relates_to edges. Lower-trust by design — real
- *  entity/relation quality comes from the LLM path (memory_kg_ingest called
- *  by the live agent, or the org coordinator's org_learn tool). */
-export declare function heuristicExtract(text: string, opts?: {
-    sourceName?: string;
-}): {
-    nodes: KgNodeInput[];
-    edges: KgEdgeInput[];
-};
-//# sourceMappingURL=memory-kg.d.ts.map