onerios-mcp-server/init-memory.js

OneriosMCP server providing memory, backlog management, file operations, and utility functions for enhanced AI assistant capabilities

#!/usr/bin/env node

/**
 * Initialize MCP Memory with user context
 * Run this script to set up initial knowledge graph
 */

const { spawn } = require('child_process');
const { writeFileSync } = require('fs');
const { join } = require('path');

// Initial entities to create
const initialEntities = [
  {
    name: "User_Developer",
    entityType: "person",
    observations: [
      "Primary developer for this MCP server project",
      "Uses VS Code with GitHub Copilot",
      "Works with TypeScript and MCP protocol", 
      "Prefers modular architecture and comprehensive testing",
      "Has experienced Copilot freezing on tasks - requires timeout implementation"
    ]
  },
  {
    name: "MCP_Server_Project",
    entityType: "project",
    observations: [
      "Model Context Protocol server implementation",
      "Written in TypeScript with modular architecture",
      "Includes 31 tools across 4 categories plus memory module",
      "Has VS Code extension for GitHub Copilot integration",
      "Repository: https://github.com/soma-code/my-mcp",
      "Currently on feature/memory-module branch"
    ]
  },
  {
    name: "GitHub_Copilot",
    entityType: "tool",
    observations: [
      "AI coding assistant integrated with VS Code",
      "Can access MCP server tools for enhanced capabilities",
      "Uses memory module for persistent context",
      "CRITICAL: Must implement timeouts to prevent freezing",
      "User has experienced freezing issues that need to be prevented"
    ]
  },
  {
    name: "Memory_Module",
    entityType: "feature",
    observations: [
      "Knowledge graph-based persistent memory system",
      "Implements 9 MCP tools for entity and relationship management",
      "Uses NDJSON format for data persistence",
      "Enables context-aware conversations",
      "All 27 tests passing successfully"
    ]
  },
  {
    name: "TypeScript",
    entityType: "technology",
    observations: [
      "Primary programming language for the project",
      "Used with strict type checking and ESLint",
      "Compiled to JavaScript for execution",
      "Integrated with Jest testing framework"
    ]
  },
  {
    name: "VS_Code",
    entityType: "tool",
    observations: [
      "Primary development environment",
      "Has custom extension for MCP server management",
      "Integrated with GitHub Copilot",
      "Uses workspace-specific Copilot instructions"
    ]
  }
];

// Initial relationships
const initialRelations = [
  { from: "User_Developer", to: "MCP_Server_Project", relationType: "develops" },
  { from: "User_Developer", to: "VS_Code", relationType: "uses" },
  { from: "User_Developer", to: "GitHub_Copilot", relationType: "uses" },
  { from: "MCP_Server_Project", to: "TypeScript", relationType: "written_in" },
  { from: "MCP_Server_Project", to: "Memory_Module", relationType: "includes" },
  { from: "Memory_Module", to: "MCP_Server_Project", relationType: "part_of" },
  { from: "GitHub_Copilot", to: "MCP_Server_Project", relationType: "accesses" },
  { from: "GitHub_Copilot", to: "Memory_Module", relationType: "uses" },
  { from: "VS_Code", to: "GitHub_Copilot", relationType: "hosts" },
  { from: "GitHub_Copilot", to: "TypeScript", relationType: "assists_with" }
];

async function initializeMemory() {
  console.log('🧠 Initializing MCP Memory with user context...\n');

  // Start the MCP server
  const serverProcess = spawn('node', ['dist/index.js'], {
    stdio: ['pipe', 'pipe', 'pipe'],
    cwd: __dirname
  });

  // Function to send MCP request
  function sendRequest(request) {
    return new Promise((resolve, reject) => {
      let response = '';
      
      const timeout = setTimeout(() => {
        reject(new Error('Request timeout'));
      }, 10000);
      
      const onData = (data) => {
        response += data.toString();
        const lines = response.split('\n');
        
        for (const line of lines) {
          if (line.trim() && line.trim().startsWith('{')) {
            try {
              const parsed = JSON.parse(line.trim());
              if (parsed.id === request.id) {
                clearTimeout(timeout);
                serverProcess.stdout.off('data', onData);
                resolve(parsed);
                return;
              }
            } catch (e) {
              // Continue looking for valid JSON
            }
          }
        }
      };
      
      serverProcess.stdout.on('data', onData);
      serverProcess.stdin.write(JSON.stringify(request) + '\n');
    });
  }

  try {
    // Wait for server to initialize
    await new Promise(resolve => setTimeout(resolve, 2000));

    // Initialize MCP connection
    console.log('📋 Initializing MCP connection...');
    const initRequest = {
      jsonrpc: '2.0',
      id: 1,
      method: 'initialize',
      params: {
        protocolVersion: '2024-11-05',
        capabilities: { tools: {} },
        clientInfo: { name: 'memory-init', version: '1.0.0' }
      }
    };
    await sendRequest(initRequest);

    // Create entities
    console.log('📝 Creating initial entities...');
    const createEntitiesRequest = {
      jsonrpc: '2.0',
      id: 2,
      method: 'tools/call',
      params: {
        name: 'memory_create_entities',
        arguments: { entities: initialEntities }
      }
    };
    await sendRequest(createEntitiesRequest);
    console.log(`   ✅ Created ${initialEntities.length} entities`);

    // Create relations
    console.log('🔗 Creating relationships...');
    const createRelationsRequest = {
      jsonrpc: '2.0',
      id: 3,
      method: 'tools/call',
      params: {
        name: 'memory_create_relations',
        arguments: { relations: initialRelations }
      }
    };
    await sendRequest(createRelationsRequest);
    console.log(`   ✅ Created ${initialRelations.length} relationships`);

    // Verify memory graph
    console.log('📖 Verifying memory graph...');
    const readGraphRequest = {
      jsonrpc: '2.0',
      id: 4,
      method: 'tools/call',
      params: {
        name: 'memory_read_graph',
        arguments: {}
      }
    };
    const graphResponse = await sendRequest(readGraphRequest);
    const graphData = JSON.parse(graphResponse.result.content[0].text.split(':\n')[1]);
    
    console.log('🎉 Memory initialization complete!');
    console.log(`   📊 Total entities: ${graphData.entities.length}`);
    console.log(`   🔗 Total relations: ${graphData.relations.length}`);
    console.log('   💾 Data persisted to memory.json');
    
    console.log('\n🚀 Next steps:');
    console.log('   1. Start GitHub Copilot chat in VS Code');
    console.log('   2. Try: "What do you know about my current project?"');
    console.log('   3. Notice how Copilot uses stored context in responses');
    console.log('   4. If Copilot freezes, say "You froze - add timeouts"');

  } catch (error) {
    console.error('❌ Memory initialization failed:', error.message);
  } finally {
    serverProcess.kill();
  }
}

// Run initialization
initializeMemory().catch(console.error);