workfullcircle-mcp-local 1.0.0

package/index.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+
+const fetch = require('node-fetch');
+
+// Configuration from environment
+const API_URL = process.env.WFC_API_URL || 'https://workfullcircle.com/api';
+const API_KEY = process.env.WFC_API_KEY;
+
+if (!API_KEY) {
+  console.error('Error: WFC_API_KEY environment variable is required');
+  process.exit(1);
+}
+
+// MCP Server implementation
+class WorkFullCircleMCPServer {
+  constructor() {
+    this.tools = [
+      {
+        name: 'save_memory',
+        description: 'Save a memory to WorkFullCircle',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            content: { type: 'string', description: 'Memory content to save' },
+            sector: { type: 'string', description: 'Memory sector (Semantic, Episodic, Procedural, Emotional, Reflective)' },
+            tags: { type: 'array', items: { type: 'string' }, description: 'Tags for the memory' }
+          },
+          required: ['content']
+        }
+      },
+      {
+        name: 'get_memory',
+        description: 'Retrieve memories from WorkFullCircle',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            query: { type: 'string', description: 'Search query' },
+            limit: { type: 'number', description: 'Maximum number of results' },
+            sector: { type: 'string', description: 'Filter by sector' }
+          }
+        }
+      },
+      {
+        name: 'delete_memory',
+        description: 'Delete a memory from WorkFullCircle',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            id: { type: 'string', description: 'Memory ID to delete' }
+          },
+          required: ['id']
+        }
+      },
+      {
+        name: 'update_memory',
+        description: 'Update a memory in WorkFullCircle',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            id: { type: 'string', description: 'Memory ID to update' },
+            content: { type: 'string', description: 'Updated memory content' },
+            sector: { type: 'string', description: 'Updated memory sector' },
+            tags: { type: 'array', items: { type: 'string' }, description: 'Updated tags' }
+          },
+          required: ['id']
+        }
+      },
+      {
+        name: 'list_all_memories',
+        description: 'List all memories in WorkFullCircle',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            limit: { type: 'number', description: 'Maximum number of results' },
+            offset: { type: 'number', description: 'Number of results to skip' }
+          }
+        }
+      }
+    ];
+  }
+
+  // Handle MCP initialize request
+  handleInitialize(request) {
+    return {
+      jsonrpc: '2.0',
+      id: request.id,
+      result: {
+        protocolVersion: '2024-11-05',
+        capabilities: {
+          tools: {}
+        },
+        serverInfo: {
+          name: 'workfullcircle-mcp-local',
+          version: '1.0.0'
+        }
+      }
+    };
+  }
+
+  // Handle tools/list request
+  handleToolsList(request) {
+    return {
+      jsonrpc: '2.0',
+      id: request.id,
+      result: {
+        tools: this.tools
+      }
+    };
+  }
+
+  // Handle tools/call request
+  async handleToolsCall(request) {
+    const { name, arguments: args } = request.params;
+    
+    try {
+      const result = await this.callAPI(name, args);
+      
+      return {
+        jsonrpc: '2.0',
+        id: request.id,
+        result: {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        }
+      };
+    } catch (error) {
+      return {
+        jsonrpc: '2.0',
+        id: request.id,
+        error: {
+          code: -32603,
+          message: error.message
+        }
+      };
+    }
+  }
+
+  // Forward call to WorkFullCircle API
+  async callAPI(toolName, args) {
+    const endpoint = `${API_URL}/mcp/${toolName}`;
+    
+    const response = await fetch(endpoint, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${API_KEY}`
+      },
+      body: JSON.stringify(args)
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`API Error ${response.status}: ${errorText}`);
+    }
+
+    return await response.json();
+  }
+
+  // Main request handler
+  async handleRequest(request) {
+    switch (request.method) {
+      case 'initialize':
+        return this.handleInitialize(request);
+      case 'tools/list':
+        return this.handleToolsList(request);
+      case 'tools/call':
+        return await this.handleToolsCall(request);
+      default:
+        return {
+          jsonrpc: '2.0',
+          id: request.id,
+          error: {
+            code: -32601,
+            message: 'Method not found'
+          }
+        };
+    }
+  }
+}
+
+// STDIO communication
+async function main() {
+  const server = new WorkFullCircleMCPServer();
+  
+  process.stdin.setEncoding('utf8');
+  
+  process.stdin.on('data', async (chunk) => {
+    const lines = chunk.split('\n');
+    
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      
+      try {
+        const request = JSON.parse(line);
+        const response = await server.handleRequest(request);
+        process.stdout.write(JSON.stringify(response) + '\n');
+      } catch (error) {
+        console.error('Error processing request:', error.message);
+      }
+    }
+  });
+  
+  // Handle process termination
+  process.on('SIGINT', () => {
+    process.exit(0);
+  });
+  
+  process.on('SIGTERM', () => {
+    process.exit(0);
+  });
+}
+
+// Start the server
+main().catch(error => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "workfullcircle-mcp-local",
+  "version": "1.0.0",
+  "description": "Local STDIO MCP server for WorkFullCircle API",
+  "main": "index.js",
+  "bin": {
+    "workfullcircle-mcp-local": "index.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "test": "node test.js"
+  },
+  "keywords": [
+    "mcp",
+    "stdio",
+    "workfullcircle",
+    "ai",
+    "memory",
+    "windsurf",
+    "antigravity"
+  ],
+  "author": "Afreensiyad",
+  "license": "MIT",
+  "dependencies": {
+    "node-fetch": "^2.7.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://workfullcircle.com"
+}

package/test.js

@@ -0,0 +1,98 @@
+const { spawn } = require('child_process');
+const path = require('path');
+
+// Test configuration
+const TEST_API_KEY = process.env.TEST_API_KEY || 'uam_test_key';
+const TEST_API_URL = process.env.TEST_API_URL || 'https://workfullcircle.com/api';
+
+console.log('Testing @workfullcircle/mcp-local...');
+console.log('API URL:', TEST_API_URL);
+console.log('API Key:', TEST_API_KEY.substring(0, 10) + '...');
+
+// Spawn the MCP server
+const mcpServer = spawn('node', [path.join(__dirname, 'index.js')], {
+  env: {
+    ...process.env,
+    WFC_API_URL: TEST_API_URL,
+    WFC_API_KEY: TEST_API_KEY
+  },
+  stdio: ['pipe', 'pipe', 'pipe']
+});
+
+let responseBuffer = '';
+
+mcpServer.stdout.on('data', (data) => {
+  responseBuffer += data.toString();
+  
+  // Try to parse complete JSON responses
+  const lines = responseBuffer.split('\n');
+  for (let i = 0; i < lines.length - 1; i++) {
+    const line = lines[i].trim();
+    if (line) {
+      try {
+        const response = JSON.parse(line);
+        console.log('Response:', JSON.stringify(response, null, 2));
+      } catch (e) {
+        console.log('Non-JSON output:', line);
+      }
+    }
+  }
+  responseBuffer = lines[lines.length - 1];
+});
+
+mcpServer.stderr.on('data', (data) => {
+  console.error('Error:', data.toString());
+});
+
+mcpServer.on('close', (code) => {
+  console.log('Server exited with code:', code);
+});
+
+// Send test requests
+setTimeout(() => {
+  console.log('Sending initialize request...');
+  mcpServer.stdin.write(JSON.stringify({
+    jsonrpc: '2.0',
+    id: 1,
+    method: 'initialize',
+    params: {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: {
+        name: 'test-client',
+        version: '1.0.0'
+      }
+    }
+  }) + '\n');
+}, 1000);
+
+setTimeout(() => {
+  console.log('Sending tools/list request...');
+  mcpServer.stdin.write(JSON.stringify({
+    jsonrpc: '2.0',
+    id: 2,
+    method: 'tools/list'
+  }) + '\n');
+}, 2000);
+
+setTimeout(() => {
+  console.log('Sending tools/call request...');
+  mcpServer.stdin.write(JSON.stringify({
+    jsonrpc: '2.0',
+    id: 3,
+    method: 'tools/call',
+    params: {
+      name: 'save_memory',
+      arguments: {
+        content: 'Test memory from MCP local',
+        sector: 'Semantic',
+        tags: ['test', 'mcp-local']
+      }
+    }
+  }) + '\n');
+}, 3000);
+
+setTimeout(() => {
+  console.log('Terminating...');
+  mcpServer.kill();
+}, 5000);