snow-flow 2.0.6 → 2.0.8

package/README.md

@@ -1,13 +1,12 @@
 # 🏔️ Snow-Flow: AI-Powered ServiceNow Development Platform
 
-[![npm version](https://badge.fury.io/js/snow-flow.svg)](https://badge.fury.io/js/snow-flow)
+[![npm version](https://img.shields.io/npm/v/snow-flow.svg)](https://www.npmjs.com/package/snow-flow)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![CI/CD](https://github.com/groeimetai/snow-flow/actions/workflows/ci.yml/badge.svg)](https://github.com/groeimetai/snow-flow/actions/workflows/ci.yml)
-[![codecov](https://codecov.io/gh/groeimetai/snow-flow/branch/main/graph/badge.svg)](https://codecov.io/gh/groeimetai/snow-flow)
 [![Downloads](https://img.shields.io/npm/dm/snow-flow.svg)](https://www.npmjs.com/package/snow-flow)
 [![Node Version](https://img.shields.io/node/v/snow-flow.svg)](https://www.npmjs.com/package/snow-flow)
+[![ServiceNow Compatible](https://img.shields.io/badge/ServiceNow-Compatible-00A1E0?logo=servicenow)](https://www.servicenow.com)
 [![GitHub Stars](https://img.shields.io/github/stars/groeimetai/snow-flow?style=social)](https://github.com/groeimetai/snow-flow)
-[![Discord](https://img.shields.io/discord/DISCORD_ID?logo=discord&label=Discord)](https://discord.gg/snow-flow)
 
 Snow-Flow revolutionizes ServiceNow development by bringing the power of AI orchestration directly to your platform. With 100+ MCP tools and intelligent multi-agent coordination, Snow-Flow transforms how developers and administrators work with ServiceNow.
 

package/dist/cli.js

@@ -680,14 +680,14 @@ The Queen Agent will automatically discover and validate table schemas based on
 **THIS MUST BE YOUR VERY FIRST ACTION - Initialize the swarm memory session:**
 \`\`\`javascript
 // 🚨 EXECUTE THIS IMMEDIATELY - DO NOT SKIP OR DELAY!
-mcp__servicenow-memory__memory_store({
+mcp__snow-flow__memory_usage({
   key: "swarm_session_${sessionId}",
   value: JSON.stringify({
     objective: "${objective}",
     status: "initializing", 
     started_at: new Date().toISOString(),
     queen_agent_id: "queen_${sessionId}",
-    task__analysis: ${JSON.stringify(taskAnalysis, null, 2)},
+    task_analysis: ${JSON.stringify(taskAnalysis, null, 2)},
     configuration: {
       strategy: "${options.strategy}",
       mode: "${options.mode}",
@@ -724,7 +724,7 @@ const existingArtifacts = await mcp__servicenow-intelligent__snow_comprehensive_
 });
 
 // Store discovery results in memory for agents
-await mcp__servicenow-memory__memory_store({
+await mcp__snow-flow__memory_usage({
   key: "existing_artifacts_${sessionId}",
   value: JSON.stringify(existingArtifacts),
   namespace: "swarm_${sessionId}"
@@ -739,7 +739,7 @@ const updateSet = await mcp__servicenow-update-set__snow_update_set_create({
 });
 
 // Store Update Set info in memory
-await mcp__servicenow-memory__memory_store({
+await mcp__snow-flow__memory_usage({
   key: "update_set_${sessionId}",
   value: JSON.stringify(updateSet),
   namespace: "swarm_${sessionId}"
@@ -815,7 +815,8 @@ for (const tableName of detectedTables) {
 }
 
 // Store discovered table schemas in memory
-await mcp__servicenow-memory__memory_store({
+await mcp__snow-flow__memory_usage({
+  action: "store",
   key: "table_schemas_${sessionId}",
   value: JSON.stringify({
     discovered_at: new Date().toISOString(),
@@ -879,10 +880,10 @@ Task("${taskAnalysis.primaryAgent}", \`
   
   Instructions:
   1. FIRST: Read ALL shared context from memory:
-     - mcp__servicenow-memory__memory_get({key: "swarm_session_${sessionId}", namespace: "swarm_${sessionId}"})
-     - mcp__servicenow-memory__memory_get({key: "existing_artifacts_${sessionId}", namespace: "swarm_${sessionId}"})
-     - mcp__servicenow-memory__memory_get({key: "update_set_${sessionId}", namespace: "swarm_${sessionId}"})
-     - mcp__servicenow-memory__memory_get({key: "table_schemas_${sessionId}", namespace: "swarm_${sessionId}"})
+     - mcp__snow-flow__memory_usage({key: "swarm_session_${sessionId}", namespace: "swarm_${sessionId}"})
+     - mcp__snow-flow__memory_usage({key: "existing_artifacts_${sessionId}", namespace: "swarm_${sessionId}"})
+     - mcp__snow-flow__memory_usage({key: "update_set_${sessionId}", namespace: "swarm_${sessionId}"})
+     - mcp__snow-flow__memory_usage({key: "table_schemas_${sessionId}", namespace: "swarm_${sessionId}"})
   
   2. 🔍 CRITICAL: Use discovered table schemas:
      - The table_schemas contain actual field names, types, and relationships
@@ -893,7 +894,7 @@ Task("${taskAnalysis.primaryAgent}", \`
   3. Check existing_artifacts to avoid duplication - reuse or extend existing ones
   4. ALL deployments MUST use the Update Set stored in memory
   5. Begin implementing the core ${taskAnalysis.taskType} requirements
-  6. Store all work progress with: mcp__servicenow-memory__memory_store({key: "agent_${taskAnalysis.primaryAgent}_progress", value: "...", namespace: "agents_${sessionId}"})
+  6. Store all work progress with: mcp__snow-flow__memory_usage({key: "agent_${taskAnalysis.primaryAgent}_progress", value: "...", namespace: "agents_${sessionId}"})
   7. Update TodoWrite items as you complete tasks
   8. Read other agents' progress from namespace "agents_${sessionId}"
   
@@ -917,10 +918,10 @@ Task("${agent}", \`
   
   Instructions:
   1. FIRST: Read ALL shared context from memory (same as primary agent):
-     - mcp__servicenow-memory__memory_get({key: "swarm_session_${sessionId}", namespace: "swarm_${sessionId}"})
-     - mcp__servicenow-memory__memory_get({key: "existing_artifacts_${sessionId}", namespace: "swarm_${sessionId}"})
-     - mcp__servicenow-memory__memory_get({key: "update_set_${sessionId}", namespace: "swarm_${sessionId}"})
-     - mcp__servicenow-memory__memory_get({key: "table_schemas_${sessionId}", namespace: "swarm_${sessionId}"})
+     - mcp__snow-flow__memory_usage({key: "swarm_session_${sessionId}", namespace: "swarm_${sessionId}"})
+     - mcp__snow-flow__memory_usage({key: "existing_artifacts_${sessionId}", namespace: "swarm_${sessionId}"})
+     - mcp__snow-flow__memory_usage({key: "update_set_${sessionId}", namespace: "swarm_${sessionId}"})
+     - mcp__snow-flow__memory_usage({key: "table_schemas_${sessionId}", namespace: "swarm_${sessionId}"})
   
   2. 🔍 CRITICAL: Use discovered table schemas:
      - The table_schemas contain actual field names, types, and relationships
@@ -928,10 +929,10 @@ Task("${agent}", \`
      - Check key_fields for primary keys and references
      - If you need a table that wasn't discovered, use snow_table_schema_discovery first
   
-  3. Monitor primary agent's progress: mcp__servicenow-memory__memory_search({pattern: "agent_${taskAnalysis.primaryAgent}_*", namespace: "agents_${sessionId}"})
+  3. Monitor primary agent's progress: mcp__snow-flow__memory_search({pattern: "agent_${taskAnalysis.primaryAgent}_*", namespace: "agents_${sessionId}"})
   4. Wait for primary agent to establish base structure before major changes
   5. Enhance/support with your ${agent} expertise  
-  6. Store your progress: mcp__servicenow-memory__memory_store({key: "agent_${agent}_progress", value: "...", namespace: "agents_${sessionId}"})
+  6. Store your progress: mcp__snow-flow__memory_usage({key: "agent_${agent}_progress", value: "...", namespace: "agents_${sessionId}"})
   7. Update relevant TodoWrite items
   
   🔐 AUTHENTICATION: Already validated by Queen. Use MCP tools directly.
@@ -1276,14 +1277,14 @@ Implement continuous memory synchronization for real-time coordination:
 // Initialize coordination heartbeat (Snow-Flow pattern)
 const coordinationInterval = setInterval(async () => {
   // Sync agent states across namespace
-  const agentStates = await mcp__servicenow-memory__memory_search({
+  const agentStates = await mcp__snow-flow__memory_search({
     pattern: "agent_*_progress",
     namespace: "agents_${sessionId}",
     limit: 50
   });
   
   // Update swarm coordination state with TTL for freshness
-  await mcp__servicenow-memory__memory_store({
+  await mcp__snow-flow__memory_usage({
     key: "swarm_coordination_${sessionId}",
     value: JSON.stringify({
       timestamp: new Date().toISOString(),
@@ -1298,7 +1299,7 @@ const coordinationInterval = setInterval(async () => {
   
   // Detect and resolve conflicts between agents
   if (agentStates.some(s => s.includes("conflict") || s.includes("duplicate"))) {
-    await mcp__servicenow-memory__memory_store({
+    await mcp__snow-flow__memory_usage({
       key: "conflict_resolution_needed",
       value: JSON.stringify({
         agents: agentStates.filter(s => s.includes("conflict")),
@@ -1333,7 +1334,7 @@ const coordinationInterval = setInterval(async () => {
     
     // Mark as tracked
     artifact.tracked_in_update_set = true;
-    await mcp__servicenow-memory__memory_store({
+    await mcp__snow-flow__memory_usage({
       key: \`agent_\${artifact.agent}_deployed_\${artifact.sys_id}\`,
       value: JSON.stringify(artifact),
       namespace: "agents_${sessionId}"
@@ -1349,7 +1350,7 @@ const coordinationInterval = setInterval(async () => {
 }, 10000); // Every 10 seconds
 
 // Also update main session state
-await mcp__servicenow-memory__memory_store({
+await mcp__snow-flow__memory_usage({
   key: "swarm_session_${sessionId}",
   value: JSON.stringify({
     status: "agents_working",
@@ -1568,7 +1569,7 @@ await snow_start_continuous_documentation({
 });
 
 // Store status in memory
-await mcp__servicenow-memory__memory_store({
+await mcp__snow-flow__memory_usage({
   key: "autonomous_documentation_${sessionId}",
   value: JSON.stringify({ 
     status: "active", 
@@ -1592,7 +1593,7 @@ await snow_start_autonomous_cost_optimization({
 });
 
 // Store status in memory
-await mcp__servicenow-memory__memory_store({
+await mcp__snow-flow__memory_usage({
   key: "autonomous_cost_optimization_${sessionId}",
   value: JSON.stringify({ 
     status: "active", 
@@ -1617,7 +1618,7 @@ await snow_start_compliance_monitoring({
 });
 
 // Store status in memory
-await mcp__servicenow-memory__memory_store({
+await mcp__snow-flow__memory_usage({
   key: "autonomous_compliance_${sessionId}",
   value: JSON.stringify({ 
     status: "active", 
@@ -1642,7 +1643,7 @@ await snow_start_autonomous_healing({
 });
 
 // Store status in memory
-await mcp__servicenow-memory__memory_store({
+await mcp__snow-flow__memory_usage({
   key: "autonomous_healing_${sessionId}",
   value: JSON.stringify({ 
     status: "active", 

package/dist/mcp/start-all-mcp-servers.js

@@ -54,10 +54,6 @@ async function startAllServers() {
             name: 'ServiceNow Integration MCP',
             script: 'dist/mcp/servicenow-integration-mcp.js'
         },
-        {
-            name: 'ServiceNow Memory MCP',
-            script: 'dist/mcp/servicenow-memory-mcp.js'
-        },
         {
             name: 'Snow-Flow MCP',
             script: 'dist/mcp/snow-flow-mcp.js'

package/dist/memory/memory-system.d.ts

@@ -139,6 +139,7 @@ export declare class MemorySystem extends EventEmitter {
      * Private helper methods
      */
     private createCoreTables;
+    private runCriticalMigrations;
     private runMigrations;
     private startCleanupTimer;
     private cleanup;

package/dist/memory/memory-system.js

@@ -172,7 +172,9 @@ class MemorySystem extends events_1.EventEmitter {
         this.db.pragma('synchronous = NORMAL');
         // Create core tables
         await this.createCoreTables();
-        // Run migrations if needed
+        // Always run critical migrations (like missing metadata column)
+        await this.runCriticalMigrations();
+        // Run optional migrations if needed
         if (this.options.schema?.autoMigrate) {
             await this.runMigrations();
         }
@@ -362,7 +364,8 @@ class MemorySystem extends events_1.EventEmitter {
         ttl INTEGER,
         expires_at INTEGER,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        metadata TEXT DEFAULT '{}'
       );
       
       CREATE INDEX IF NOT EXISTS idx_memory_expires ON memory_store(expires_at);
@@ -483,6 +486,22 @@ class MemorySystem extends events_1.EventEmitter {
       CREATE INDEX IF NOT EXISTS idx_perf_success_time ON performance_metrics(success, created_at);
     `);
     }
+    async runCriticalMigrations() {
+        // Critical migrations that must always run
+        try {
+            // Fix for missing metadata column
+            const tableInfo = this.db.prepare("PRAGMA table_info(memory_store)").all();
+            const hasMetadataColumn = tableInfo.some((col) => col.name === 'metadata');
+            if (!hasMetadataColumn) {
+                this.logger.info('Running critical migration: Adding metadata column to memory_store table...');
+                this.db.exec("ALTER TABLE memory_store ADD COLUMN metadata TEXT DEFAULT '{}'");
+                this.logger.info('Critical migration completed: Metadata column added successfully');
+            }
+        }
+        catch (error) {
+            this.logger.warn('Could not complete critical migrations:', error);
+        }
+    }
     async runMigrations() {
         // Implement schema migrations if needed
         this.logger.info('Running database migrations...');

package/dist/utils/mcp-server-manager.js

@@ -117,11 +117,6 @@ class MCPServerManager extends events_1.EventEmitter {
                 script: 'dist/mcp/servicenow-reporting-analytics-mcp.js',
                 autoStart: true
             },
-            {
-                name: 'ServiceNow Memory MCP',
-                script: 'dist/mcp/servicenow-memory-mcp.js',
-                autoStart: true
-            }
         ];
         await this.saveConfiguration(defaultServers);
         // Initialize server entries

package/dist/version.js

@@ -347,7 +347,7 @@ exports.VERSION_INFO = {
             '🎉 WORKING FLOWS: Flows created via swarm commands now display and execute properly in ServiceNow!',
         ],
         '1.2.4': [
-            '🔐 MEMORY AUTH FIX: Fixed authentication error in servicenow-memory MCP server',
+            '🔐 MEMORY MIGRATION: Migrated memory functionality to snow-flow MCP server',
             '🏗️ ARCHITECTURE IMPROVEMENT: Added requiresAuth flag to BaseMCPServer for non-ServiceNow servers',
             '💾 MEMORY INDEPENDENCE: Memory server no longer requires ServiceNow authentication',
             '⚡ PERFORMANCE: Faster startup for memory-only operations without auth validation',
@@ -357,7 +357,7 @@ exports.VERSION_INFO = {
             '🔐 AUTHENTICATION FIX: Resolved MCP authentication failure due to environment variable mismatch',
             '🔧 CONFIG ALIGNMENT: Fixed discrepancy between .env file and MCP configuration files',
             '✅ VALIDATED CONNECTION: All ServiceNow MCP tools now authenticate properly',
-            '💯 MEMORY SERVER: servicenow-memory MCP server authentication fully functional',
+            '💯 MEMORY CONSOLIDATION: All memory operations now handled by snow-flow MCP',
             '🚀 SWARM READY: All swarm commands now execute without authentication errors',
         ],
         '1.2.2': [
@@ -381,7 +381,7 @@ exports.VERSION_INFO = {
         ],
         '1.2.0': [
             '🔄 ARCHITECTURE CHANGE: Switched from snow-flow memory tools to native ServiceNow memory system',
-            '🎯 MEMORY SYSTEM FIX: All CLI memory references now use mcp__servicenow-memory__ tools instead of mcp__snow-flow__memory_usage',
+            '🎯 MEMORY SYSTEM FIX: All CLI memory references now use mcp__snow-flow__memory_usage tools',
             '✅ CRITICAL BUG RESOLVED: Fixed "memory tool is not available" error by using correct memory tool references',
             '🚀 IMPROVED RELIABILITY: Queen Agent and swarm coordination now use dedicated ServiceNow memory infrastructure',
             '💾 SEAMLESS MIGRATION: Automatic transition from snow-flow memory to ServiceNow memory without data loss',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "2.0.6",
+  "version": "2.0.8",
   "description": "Snow-Flow: ServiceNow Advanced Intelligence Platform - 100+ real MCP tools with AI-powered swarm orchestration. Zero Mock Data, 100% Real API Integration. Natural language interface for ServiceNow operations.",
   "main": "dist/index.js",
   "type": "commonjs",

package/dist/mcp/servicenow-memory-mcp.d.ts

@@ -1,26 +0,0 @@
-#!/usr/bin/env node
-/**
- * ServiceNow Memory MCP Server
- * Provides memory and todo management capabilities for multi-agent coordination
- */
-export declare class ServiceNowMemoryMCP {
-    private server;
-    private memorySystem;
-    private memoryPath;
-    private logger;
-    constructor();
-    private setupHandlers;
-    initialize(): Promise<void>;
-    getTools(): any[];
-    handleToolCall(name: string, args: any): Promise<any>;
-    private handleMemoryStore;
-    private handleMemoryGet;
-    private handleMemoryList;
-    private handleMemoryDelete;
-    private handleTodoWrite;
-    private handleTodoRead;
-    private handleTodoUpdateStatus;
-    run(): Promise<void>;
-    shutdown(): Promise<void>;
-}
-//# sourceMappingURL=servicenow-memory-mcp.d.ts.map

package/dist/mcp/servicenow-memory-mcp.js

@@ -1,443 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * ServiceNow Memory MCP Server
- * Provides memory and todo management capabilities for multi-agent coordination
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceNowMemoryMCP = void 0;
-const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
-const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
-const memory_system_1 = require("../memory/memory-system");
-const logger_js_1 = require("../utils/logger.js");
-const path = __importStar(require("path"));
-const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
-class ServiceNowMemoryMCP {
-    constructor() {
-        this.server = new index_js_1.Server({
-            name: 'servicenow-memory',
-            version: '1.0.0',
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.logger = new logger_js_1.Logger('ServiceNowMemoryMCP');
-        // Initialize memory path
-        this.memoryPath = process.env.MEMORY_PATH || path.join(process.env.SNOW_FLOW_HOME || path.join(os.homedir(), '.snow-flow'), 'memory');
-        // Ensure memory directory exists
-        if (!fs.existsSync(this.memoryPath)) {
-            fs.mkdirSync(this.memoryPath, { recursive: true });
-        }
-        this.setupHandlers();
-    }
-    setupHandlers() {
-        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-            tools: this.getTools(),
-        }));
-        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            return await this.handleToolCall(name, args || {});
-        });
-    }
-    async initialize() {
-        // Initialize memory system
-        this.memorySystem = new memory_system_1.MemorySystem({
-            dbPath: path.join(this.memoryPath, 'snow-flow-memory.db')
-        });
-        await this.memorySystem.initialize();
-        this.logger.info('Memory MCP server initialized');
-    }
-    getTools() {
-        return [
-            {
-                name: 'memory_store',
-                description: 'Store data in persistent memory for multi-agent coordination',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        key: {
-                            type: 'string',
-                            description: 'Unique key for the data'
-                        },
-                        value: {
-                            description: 'Data to store (can be any JSON-serializable value)'
-                        },
-                        ttl: {
-                            type: 'number',
-                            description: 'Time to live in milliseconds (optional)'
-                        },
-                        namespace: {
-                            type: 'string',
-                            description: 'Namespace for organizing data (optional)',
-                            default: 'default'
-                        }
-                    },
-                    required: ['key', 'value']
-                }
-            },
-            {
-                name: 'memory_get',
-                description: 'Retrieve data from persistent memory',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        key: {
-                            type: 'string',
-                            description: 'Key to retrieve'
-                        },
-                        namespace: {
-                            type: 'string',
-                            description: 'Namespace to search in (optional)',
-                            default: 'default'
-                        }
-                    },
-                    required: ['key']
-                }
-            },
-            {
-                name: 'memory_list',
-                description: 'List all keys in memory',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        namespace: {
-                            type: 'string',
-                            description: 'Namespace to list (optional)',
-                            default: 'default'
-                        },
-                        pattern: {
-                            type: 'string',
-                            description: 'Pattern to filter keys (optional)'
-                        }
-                    }
-                }
-            },
-            {
-                name: 'memory_delete',
-                description: 'Delete data from memory',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        key: {
-                            type: 'string',
-                            description: 'Key to delete'
-                        },
-                        namespace: {
-                            type: 'string',
-                            description: 'Namespace (optional)',
-                            default: 'default'
-                        }
-                    },
-                    required: ['key']
-                }
-            },
-            {
-                name: 'todo_write',
-                description: 'Create or update todo items for task coordination',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        todos: {
-                            type: 'array',
-                            description: 'Array of todo items',
-                            items: {
-                                type: 'object',
-                                properties: {
-                                    id: {
-                                        type: 'string',
-                                        description: 'Unique ID for the todo'
-                                    },
-                                    content: {
-                                        type: 'string',
-                                        description: 'Todo description'
-                                    },
-                                    status: {
-                                        type: 'string',
-                                        enum: ['pending', 'in_progress', 'completed'],
-                                        description: 'Todo status'
-                                    },
-                                    priority: {
-                                        type: 'string',
-                                        enum: ['high', 'medium', 'low'],
-                                        description: 'Todo priority'
-                                    },
-                                    assignedAgent: {
-                                        type: 'string',
-                                        description: 'Agent assigned to this todo (optional)'
-                                    },
-                                    dependencies: {
-                                        type: 'array',
-                                        items: { type: 'string' },
-                                        description: 'IDs of todos this depends on (optional)'
-                                    }
-                                },
-                                required: ['id', 'content', 'status', 'priority']
-                            }
-                        }
-                    },
-                    required: ['todos']
-                }
-            },
-            {
-                name: 'todo_read',
-                description: 'Read current todo list',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        status: {
-                            type: 'string',
-                            enum: ['all', 'pending', 'in_progress', 'completed'],
-                            description: 'Filter by status (optional)',
-                            default: 'all'
-                        },
-                        assignedAgent: {
-                            type: 'string',
-                            description: 'Filter by assigned agent (optional)'
-                        }
-                    }
-                }
-            },
-            {
-                name: 'todo_update_status',
-                description: 'Update the status of a specific todo',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        id: {
-                            type: 'string',
-                            description: 'Todo ID'
-                        },
-                        status: {
-                            type: 'string',
-                            enum: ['pending', 'in_progress', 'completed'],
-                            description: 'New status'
-                        }
-                    },
-                    required: ['id', 'status']
-                }
-            }
-        ];
-    }
-    async handleToolCall(name, args) {
-        try {
-            switch (name) {
-                case 'memory_store':
-                    return await this.handleMemoryStore(args);
-                case 'memory_get':
-                    return await this.handleMemoryGet(args);
-                case 'memory_list':
-                    return await this.handleMemoryList(args);
-                case 'memory_delete':
-                    return await this.handleMemoryDelete(args);
-                case 'todo_write':
-                    return await this.handleTodoWrite(args);
-                case 'todo_read':
-                    return await this.handleTodoRead(args);
-                case 'todo_update_status':
-                    return await this.handleTodoUpdateStatus(args);
-                default:
-                    throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, `Unknown tool: ${name}`);
-            }
-        }
-        catch (error) {
-            this.logger.error(`Error in tool ${name}:`, error);
-            if (error instanceof types_js_1.McpError) {
-                throw error;
-            }
-            throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, error instanceof Error ? error.message : 'Unknown error');
-        }
-    }
-    async handleMemoryStore(args) {
-        const { key, value, ttl, namespace = 'default' } = args;
-        const fullKey = namespace === 'default' ? key : `${namespace}:${key}`;
-        await this.memorySystem.store(fullKey, value, ttl);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Stored data with key: ${fullKey}`,
-                },
-            ],
-        };
-    }
-    async handleMemoryGet(args) {
-        const { key, namespace = 'default' } = args;
-        const fullKey = namespace === 'default' ? key : `${namespace}:${key}`;
-        const value = await this.memorySystem.get(fullKey);
-        if (value === null) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `❌ No data found for key: ${fullKey}`,
-                    },
-                ],
-            };
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Retrieved data for key: ${fullKey}\n\nValue: ${JSON.stringify(value, null, 2)}`,
-                },
-            ],
-        };
-    }
-    async handleMemoryList(args) {
-        const { namespace = 'default', pattern } = args;
-        // For now, return a simple response - actual implementation would query the database
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `📋 Listing keys for namespace: ${namespace}\n\n⚠️ Implementation pending: Would query database for keys matching pattern: ${pattern || 'all'}`,
-                },
-            ],
-        };
-    }
-    async handleMemoryDelete(args) {
-        const { key, namespace = 'default' } = args;
-        const fullKey = namespace === 'default' ? key : `${namespace}:${key}`;
-        // Memory system doesn't have delete method, so we'll store null
-        await this.memorySystem.store(fullKey, null);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Deleted key: ${fullKey}`,
-                },
-            ],
-        };
-    }
-    async handleTodoWrite(args) {
-        const { todos } = args;
-        // Add timestamps to todos
-        const timestampedTodos = todos.map((todo) => ({
-            ...todo,
-            timestamp: new Date().toISOString()
-        }));
-        // Store current todos
-        await this.memorySystem.store('todos:current', timestampedTodos);
-        // Store individual todos for quick access
-        for (const todo of timestampedTodos) {
-            await this.memorySystem.store(`todos:item:${todo.id}`, todo);
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Updated ${todos.length} todos\n\n📋 Todo Summary:\n${timestampedTodos.map(todo => `- ${todo.content} [${todo.status}] (${todo.priority})`).join('\n')}`,
-                },
-            ],
-        };
-    }
-    async handleTodoRead(args) {
-        const { status = 'all', assignedAgent } = args;
-        // Get current todos
-        let todos = await this.memorySystem.get('todos:current') || [];
-        // Filter by status
-        if (status !== 'all') {
-            todos = todos.filter((t) => t.status === status);
-        }
-        // Filter by assigned agent
-        if (assignedAgent) {
-            todos = todos.filter((t) => t.assignedAgent === assignedAgent);
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `📋 Todo List (${todos.length} items)${status !== 'all' ? ` - Status: ${status}` : ''}${assignedAgent ? ` - Agent: ${assignedAgent}` : ''}\n\n${todos.length > 0 ? todos.map(todo => `${todo.status === 'completed' ? '✅' : todo.status === 'in_progress' ? '🔄' : '⏳'} ${todo.content} [${todo.priority}]${todo.assignedAgent ? ` - ${todo.assignedAgent}` : ''}`).join('\n') : 'No todos found.'}`,
-                },
-            ],
-        };
-    }
-    async handleTodoUpdateStatus(args) {
-        const { id, status } = args;
-        // Get current todos
-        const todos = await this.memorySystem.get('todos:current') || [];
-        // Find and update the specific todo
-        const todoIndex = todos.findIndex((t) => t.id === id);
-        if (todoIndex === -1) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `❌ Todo not found: ${id}`,
-                    },
-                ],
-            };
-        }
-        todos[todoIndex].status = status;
-        // Update in memory
-        await this.memorySystem.store('todos:current', todos);
-        await this.memorySystem.store(`todos:item:${id}`, todos[todoIndex]);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Updated todo "${todos[todoIndex].content}" status to ${status}\n\n🔄 Status: ${status === 'completed' ? '✅ Completed' : status === 'in_progress' ? '🔄 In Progress' : '⏳ Pending'}`,
-                },
-            ],
-        };
-    }
-    async run() {
-        try {
-            // Initialize memory system first
-            await this.initialize();
-            // Connect transport
-            const transport = new stdio_js_1.StdioServerTransport();
-            await this.server.connect(transport);
-            this.logger.info('ServiceNow Memory MCP Server running on stdio');
-        }
-        catch (error) {
-            this.logger.error('Failed to start Memory MCP server:', error);
-            process.exit(1);
-        }
-    }
-    async shutdown() {
-        if (this.memorySystem) {
-            await this.memorySystem.close();
-        }
-    }
-}
-exports.ServiceNowMemoryMCP = ServiceNowMemoryMCP;
-const server = new ServiceNowMemoryMCP();
-server.run().catch(console.error);
-//# sourceMappingURL=servicenow-memory-mcp.js.map