@veedubin/boomerang-v3 0.1.0

package/dist/memini-client/index.js

@@ -0,0 +1,560 @@
+/**
+ * Memini Client - TypeScript wrapper for memini-ai MCP server
+ *
+ * Communicates with the Python memini-ai FastMCP server via stdio.
+ * Provides the same interface as Super-Memory-TS MemorySystem.
+ *
+ * Uses persistent process architecture: ONE server process for all tool calls,
+ * with proper MCP JSON-RPC message framing over stdio.
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+// ============================================================================
+// MeminiClient - Persistent MCP stdio Client
+// ============================================================================
+/**
+ * Convert memini MemoryEntry to plugin MemoryEntry
+ */
+function toMemoryEntry(meminiEntry) {
+    return {
+        id: meminiEntry.id,
+        text: meminiEntry.text,
+        sourceType: meminiEntry.sourceType,
+        sourcePath: meminiEntry.sourcePath || '',
+        timestamp: new Date(meminiEntry.timestamp).getTime(),
+        metadataJson: meminiEntry.metadataJson || '{}',
+        sessionId: meminiEntry.sessionId,
+        score: meminiEntry.score,
+        trustScore: meminiEntry.trustScore,
+    };
+}
+/**
+ * Parse tool result content - FastMCP returns content array with text
+ */
+function parseToolResult(result) {
+    const res = result;
+    if (Array.isArray(res.content)) {
+        const textContent = res.content.find((c) => c.type === 'text');
+        if (textContent && typeof textContent.text === 'string') {
+            try {
+                return JSON.parse(textContent.text);
+            }
+            catch {
+                return textContent.text;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * MeminiClient - wraps memini-ai MCP server with MemorySystem-compatible API
+ *
+ * Uses persistent process architecture with proper MCP stdio transport.
+ */
+export class MeminiClient {
+    static instance = null;
+    _initialized = false;
+    _serverUrl = 'http://localhost:6333';
+    _mcpClient = null;
+    _transport = null;
+    constructor() { }
+    static getInstance() {
+        if (!MeminiClient.instance) {
+            MeminiClient.instance = new MeminiClient();
+        }
+        return MeminiClient.instance;
+    }
+    isInitialized() {
+        return this._initialized;
+    }
+    async initialize(serverUrl) {
+        if (this._initialized) {
+            return;
+        }
+        if (serverUrl) {
+            this._serverUrl = serverUrl;
+        }
+        try {
+            // Create stdio transport - SDK handles process spawning
+            this._transport = new StdioClientTransport({
+                command: 'python',
+                args: ['-m', 'memini_ai.server'],
+                env: { ...process.env, PYTHONUNBUFFERED: '1' },
+            });
+            // Create MCP client
+            this._mcpClient = new Client({
+                name: 'memini-ai-client',
+                version: '1.0.0',
+            }, {
+                capabilities: {},
+            });
+            // Connect client to transport
+            await this._mcpClient.connect(this._transport);
+            console.log('memini-ai MCP client connected');
+            // Verify connection with get_status
+            const status = await this._mcpClient.callTool({ name: 'get_status' });
+            if (status) {
+                console.log('memini-ai server initialized:', status);
+            }
+            this._initialized = true;
+        }
+        catch (err) {
+            console.warn('memini-ai server not available, operating in degraded mode:', err);
+            // Graceful degradation - mark as initialized to allow other operations
+            this._initialized = true;
+        }
+    }
+    /**
+     * Ensure MCP client is connected
+     */
+    ensureConnected() {
+        if (!this._mcpClient) {
+            throw new Error('MeminiClient not connected. Call initialize() first.');
+        }
+    }
+    /**
+     * Call MCP tool with arguments
+     */
+    async callTool(toolName, args) {
+        const result = await this._mcpClient.callTool({ name: toolName, arguments: args });
+        return parseToolResult(result);
+    }
+    async search(query, options) {
+        this.ensureConnected();
+        const topK = options?.topK || 10;
+        const strategy = options?.strategy || 'tiered';
+        try {
+            const result = await this.callTool('query_memories', {
+                query,
+                limit: topK,
+                strategy,
+            });
+            return result.memories.map((mem) => ({
+                entry: toMemoryEntry(mem),
+                score: mem.score || 0,
+            }));
+        }
+        catch (err) {
+            console.error('memini-ai query_memories failed:', err);
+            return [];
+        }
+    }
+    async addMemory(entry) {
+        this.ensureConnected();
+        const input = {
+            content: entry.text || '',
+            sourceType: entry.sourceType || 'boomerang',
+            sourcePath: entry.sourcePath || '',
+            metadata: entry.metadataJson ? JSON.parse(entry.metadataJson) : {},
+            sessionId: entry.sessionId || '',
+        };
+        try {
+            const result = await this.callTool('add_memory', input);
+            // Get the created memory
+            const memories = await this.search(input.content, { topK: 1 });
+            if (memories.length > 0) {
+                return memories[0].entry;
+            }
+            // Fallback: construct from input
+            return {
+                id: result.id,
+                text: input.content,
+                sourceType: input.sourceType,
+                sourcePath: input.sourcePath,
+                timestamp: Date.now(),
+                metadataJson: JSON.stringify(input.metadata),
+                sessionId: input.sessionId,
+            };
+        }
+        catch (err) {
+            console.error('memini-ai add_memory failed:', err);
+            throw err;
+        }
+    }
+    async saveContext(sessionId, context) {
+        return this.addMemory({
+            text: context,
+            sourceType: 'session',
+            sourcePath: `session://${sessionId}`,
+            metadataJson: JSON.stringify({ type: 'context' }),
+            sessionId,
+        });
+    }
+    async getTrustScore(memoryId) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('get_trust_score', { memory_id: memoryId });
+            return result?.trustScore ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async adjustTrust(memoryId, signal) {
+        try {
+            this.ensureConnected();
+            await this.callTool('adjust_trust', { memory_id: memoryId, signal });
+        }
+        catch (err) {
+            console.error('memini-ai adjust_trust failed:', err);
+        }
+    }
+    // =========================================================================
+    // Contradiction Methods
+    // =========================================================================
+    async findContradictions(query, limit = 10) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('find_contradictions', {
+                query: query || '',
+                limit,
+            });
+            return result.contradictions || [];
+        }
+        catch (err) {
+            console.error('memini-ai find_contradictions failed:', err);
+            return [];
+        }
+    }
+    async resolveContradiction(memoryIdA, memoryIdB) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('resolve_contradiction', {
+                memory_id_a: memoryIdA,
+                memory_id_b: memoryIdB,
+            });
+            return result.resolution;
+        }
+        catch (err) {
+            console.error('memini-ai resolve_contradiction failed:', err);
+            return null;
+        }
+    }
+    async getDialecticHistory(memoryId) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('get_dialectic_history', {
+                memory_id: memoryId,
+            });
+            return result.history || [];
+        }
+        catch (err) {
+            console.error('memini-ai get_dialectic_history failed:', err);
+            return [];
+        }
+    }
+    async challengeMemory(memoryId, challengeText) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('challenge_memory', {
+                memory_id: memoryId,
+                challenge_text: challengeText,
+            });
+            return result.challenge;
+        }
+        catch (err) {
+            console.error('memini-ai challenge_memory failed:', err);
+            return null;
+        }
+    }
+    // =========================================================================
+    // Relationship Methods
+    // =========================================================================
+    async findRelatedMemories(memoryId, relationshipType, limit = 10) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('find_related_memories', {
+                memoryId,
+                relationshipType: relationshipType || null,
+                limit,
+            });
+            return (result.memories || []).map(toMemoryEntry);
+        }
+        catch (err) {
+            console.error('memini-ai find_related_memories failed:', err);
+            return [];
+        }
+    }
+    async createRelationship(sourceId, targetId, relationshipType, confidence = 1.0) {
+        try {
+            this.ensureConnected();
+            await this.callTool('create_relationship', {
+                sourceId,
+                targetId,
+                relationshipType,
+                confidence,
+            });
+        }
+        catch (err) {
+            console.error('memini-ai create_relationship failed:', err);
+        }
+    }
+    async getRelationshipSummary(memoryId) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('get_relationship_summary', {
+                memoryId,
+            });
+            return result.summary;
+        }
+        catch (err) {
+            console.error('memini-ai get_relationship_summary failed:', err);
+            return null;
+        }
+    }
+    // =========================================================================
+    // Knowledge Graph Methods
+    // =========================================================================
+    async queryKG(query) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('query_kg', {
+                query: JSON.stringify(query),
+            });
+            return result.result;
+        }
+        catch (err) {
+            console.error('memini-ai query_kg failed:', err);
+            return null;
+        }
+    }
+    async extractEntities(memoryId) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('extract_entities', {
+                memory_id: memoryId,
+            });
+            return result.entities || [];
+        }
+        catch (err) {
+            console.error('memini-ai extract_entities failed:', err);
+            return [];
+        }
+    }
+    async getEntityGraph(entityId, depth = 1) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('get_entity_graph', {
+                entity_id: entityId,
+                depth,
+            });
+            return result.graph;
+        }
+        catch (err) {
+            console.error('memini-ai get_entity_graph failed:', err);
+            return null;
+        }
+    }
+    async getInferenceChain(startEntity, endEntity, maxDepth = 3) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('get_inference_chain', {
+                start_entity: startEntity,
+                end_entity: endEntity,
+                max_depth: maxDepth,
+            });
+            return result.paths || [];
+        }
+        catch (err) {
+            console.error('memini-ai get_inference_chain failed:', err);
+            return [];
+        }
+    }
+    async searchEntities(name, limit = 10) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('search_entities', {
+                name,
+                limit,
+            });
+            return result.entities || [];
+        }
+        catch (err) {
+            console.error('memini-ai search_entities failed:', err);
+            return [];
+        }
+    }
+    async getGraphVisualization(limit = 100) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('get_graph_visualization', {
+                limit,
+            });
+            return result.html || '';
+        }
+        catch (err) {
+            console.error('memini-ai get_graph_visualization failed:', err);
+            return '';
+        }
+    }
+    // =========================================================================
+    // Tiered Memory Methods
+    // =========================================================================
+    async getTier0Summary(forceRefresh = false) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('get_tier0_summary', {
+                force_refresh: forceRefresh,
+            });
+            return result.summary;
+        }
+        catch (err) {
+            console.error('memini-ai get_tier0_summary failed:', err);
+            return null;
+        }
+    }
+    async getTier1Summary(forceRefresh = false) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('get_tier1_summary', {
+                force_refresh: forceRefresh,
+            });
+            return result.summary;
+        }
+        catch (err) {
+            console.error('memini-ai get_tier1_summary failed:', err);
+            return null;
+        }
+    }
+    async triggerExtraction(conversation) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('trigger_extraction', {
+                conversation: conversation || null,
+            });
+            return result.memory_ids || [];
+        }
+        catch (err) {
+            console.error('memini-ai trigger_extraction failed:', err);
+            return [];
+        }
+    }
+    async preconpressExtraction(contextContent) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('preconpress_extraction', {
+                context_content: contextContent || null,
+            });
+            return result.result;
+        }
+        catch (err) {
+            console.error('memini-ai preconpress_extraction failed:', err);
+            return null;
+        }
+    }
+    // =========================================================================
+    // Trust/Decay Methods
+    // =========================================================================
+    async listArchived(limit = 50, offset = 0) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('list_archived', {
+                limit,
+                offset,
+            });
+            return (result.memories || []).map(toMemoryEntry);
+        }
+        catch (err) {
+            console.error('memini-ai list_archived failed:', err);
+            return [];
+        }
+    }
+    async getDecayStatus() {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('get_decay_status', {});
+            return result.status;
+        }
+        catch (err) {
+            console.error('memini-ai get_decay_status failed:', err);
+            return null;
+        }
+    }
+    async listFadingMemories(limit = 20) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('list_fading_memories', {
+                limit,
+            });
+            return (result.memories || []).map(toMemoryEntry);
+        }
+        catch (err) {
+            console.error('memini-ai list_fading_memories failed:', err);
+            return [];
+        }
+    }
+    async adjustDecayRate(memoryId, decayRate) {
+        try {
+            this.ensureConnected();
+            await this.callTool('adjust_decay_rate', {
+                memory_id: memoryId,
+                decay_rate: decayRate,
+            });
+        }
+        catch (err) {
+            console.error('memini-ai adjust_decay_rate failed:', err);
+        }
+    }
+    async triggerConsolidation(force = false) {
+        try {
+            this.ensureConnected();
+            const result = await this.callTool('trigger_consolidation', {
+                force,
+            });
+            return result.result;
+        }
+        catch (err) {
+            console.error('memini-ai trigger_consolidation failed:', err);
+            return null;
+        }
+    }
+    // =========================================================================
+    // Server Status / Query Aliases
+    // =========================================================================
+    async getStatus() {
+        try {
+            this.ensureConnected();
+            return await this.callTool('get_status', {});
+        }
+        catch (err) {
+            console.error('memini-ai get_status failed:', err);
+            return null;
+        }
+    }
+    async queryMemories(query, options) {
+        return this.search(query, options);
+    }
+    /**
+     * Shutdown the client and close the transport
+     */
+    async shutdown() {
+        if (this._mcpClient) {
+            await this._mcpClient.close();
+            this._mcpClient = null;
+        }
+        if (this._transport) {
+            await this._transport.close();
+            this._transport = null;
+        }
+        this._initialized = false;
+    }
+    ensureInitialized() {
+        if (!this._initialized) {
+            throw new Error('MeminiClient not initialized. Call initialize() first.');
+        }
+    }
+}
+// Singleton accessor
+let clientInstance = null;
+export function getClient() {
+    if (!clientInstance) {
+        clientInstance = MeminiClient.getInstance();
+    }
+    return clientInstance;
+}
+export async function initializeClient(pythonPath, serverModule) {
+    const client = getClient();
+    await client.initialize();
+    return client;
+}
+export { MeminiClient as MeminiMCPClient, MeminiClient as MemorySystem };

package/dist/memini-client/schema.js

@@ -0,0 +1,13 @@
+/**
+ * Memory Schema Definitions
+ *
+ * Shared types between memini-client and plugin.
+ */
+// Constants
+export const MEMORY_TABLE_NAME = 'memories';
+export const DEFAULT_SEARCH_OPTIONS = {
+    topK: 5,
+    strategy: 'TIERED',
+    threshold: 0.72,
+    filter: {},
+};

package/dist/memory/contradictions.js

@@ -0,0 +1,119 @@
+/**
+ * Contradiction detection integration for memini-ai
+ *
+ * Finds and resolves contradictory memory pairs using dialectic reasoning
+ */
+import { getClient } from '../memini-client/index.js';
+/**
+ * Find memory pairs that contradict each other
+ */
+export async function findContradictions(query, limit = 10, client) {
+    const mc = client ?? getClient();
+    const result = await mc.findContradictions(query, limit);
+    return result.map((c) => ({
+        memoryA: { id: c.memoryIdA, text: c.textA },
+        memoryB: { id: c.memoryIdB, text: c.textB },
+        contradictionType: c.contradictionType,
+        evidence: [],
+    }));
+}
+/**
+ * Resolve contradiction between two memories
+ *
+ * Generates dialectic resolution with pro/con arguments
+ */
+export async function resolveContradiction(memoryIdA, memoryIdB, client) {
+    const mc = client ?? getClient();
+    const result = await mc.resolveContradiction(memoryIdA, memoryIdB);
+    if (!result) {
+        return null;
+    }
+    return {
+        memoryAId: memoryIdA,
+        memoryBId: memoryIdB,
+        proArguments: [],
+        conArguments: [],
+        resolution: result.resolutionText,
+        winner: null,
+        reasoning: '',
+        confidence: result.confidence,
+        timestamp: new Date().toISOString(),
+    };
+}
+/**
+ * Get dialectic history for a memory
+ */
+export async function getDialecticHistory(memoryId, client) {
+    const mc = client ?? getClient();
+    const results = await mc.getDialecticHistory(memoryId);
+    if (results.length === 0) {
+        return {
+            memoryId,
+            notes: [],
+            challenges: [],
+            resolutions: [],
+        };
+    }
+    // Get the first history entry
+    const first = results[0];
+    return {
+        memoryId: first.memoryId,
+        notes: [],
+        challenges: [{
+                challengeText: first.challengeText,
+                response: first.responseText ?? '',
+                confidenceDelta: 0,
+                timestamp: first.timestamp,
+            }],
+        resolutions: [],
+    };
+}
+/**
+ * Challenge a memory with a counter-argument
+ */
+export async function challengeMemory(memoryId, challengeText, client) {
+    const mc = client ?? getClient();
+    const result = await mc.challengeMemory(memoryId, challengeText);
+    if (!result) {
+        return null;
+    }
+    return {
+        success: true,
+        memoryId: result.memoryId,
+        challengeText: result.challengeText,
+        response: '',
+        confidenceDelta: 0,
+        timestamp: result.timestamp,
+    };
+}
+/**
+ * Adapt a raw memory from memini-ai to our MemoryEntry type
+ */
+function adaptMemoryEntry(raw) {
+    let timestamp;
+    if (typeof raw.timestamp === 'number') {
+        timestamp = raw.timestamp;
+    }
+    else if (typeof raw.timestamp === 'string') {
+        timestamp = new Date(raw.timestamp).getTime();
+    }
+    else {
+        timestamp = Date.now();
+    }
+    return {
+        id: raw.id,
+        text: raw.text,
+        vector: raw.vector ?? [],
+        sourceType: raw.sourceType ?? 'manual',
+        sourcePath: raw.sourcePath ?? '',
+        timestamp,
+        contentHash: raw.contentHash,
+        metadataJson: raw.metadataJson,
+        sessionId: raw.sessionId,
+        projectId: raw.projectId,
+        score: raw.score,
+        trustScore: raw.trustScore,
+        retrievalCount: raw.retrievalCount,
+        isArchived: raw.isArchived,
+    };
+}