snow-flow 3.0.8 → 3.0.10

package/dist/mcp/singleton-check.js

@@ -1,31 +0,0 @@
-
-const fs = require('fs');
-const path = require('path');
-
-const lockFile = path.join(process.env.HOME, '.claude', 'mcp-singleton.lock');
-const pid = process.pid;
-
-// Check if lock exists
-if (fs.existsSync(lockFile)) {
-  const existingPid = fs.readFileSync(lockFile, 'utf8');
-  try {
-    // Check if process is still running
-    process.kill(existingPid, 0);
-    console.error('MCP servers already running with PID:', existingPid);
-    process.exit(1);
-  } catch (e) {
-    // Process not running, remove stale lock
-    fs.unlinkSync(lockFile);
-  }
-}
-
-// Create lock
-fs.mkdirSync(path.dirname(lockFile), { recursive: true });
-fs.writeFileSync(lockFile, pid.toString());
-
-// Clean up on exit
-process.on('exit', () => {
-  try {
-    fs.unlinkSync(lockFile);
-  } catch (e) {}
-});

package/dist/mcp/test-simple-mcp.d.ts

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-/**
- * Simple Test MCP Server - minimal implementation for Claude Code compatibility
- */
-export {};
-//# sourceMappingURL=test-simple-mcp.d.ts.map

package/dist/mcp/test-simple-mcp.js

@@ -1,63 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * Simple Test MCP Server - minimal implementation for Claude Code compatibility
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-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");
-class SimpleTestMCP {
-    constructor() {
-        this.server = new index_js_1.Server({
-            name: 'simple-test',
-            version: '1.0.0',
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.setupHandlers();
-    }
-    setupHandlers() {
-        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-            tools: [
-                {
-                    name: 'test_tool',
-                    description: 'A simple test tool',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            message: { type: 'string', description: 'Test message' }
-                        },
-                        required: ['message'],
-                    },
-                },
-            ],
-        }));
-        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            if (name === 'test_tool') {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Test tool called with message: ${args?.message || 'no message'}`,
-                        },
-                    ],
-                };
-            }
-            throw new Error(`Unknown tool: ${name}`);
-        });
-    }
-    async start() {
-        const transport = new stdio_js_1.StdioServerTransport();
-        await this.server.connect(transport);
-    }
-}
-// Start the server
-const server = new SimpleTestMCP();
-server.start().catch((error) => {
-    console.error('Failed to start Simple Test MCP:', error);
-    process.exit(1);
-});

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

@@ -1,90 +0,0 @@
-/**
- * Hierarchical Memory System for Snow-Flow
- * Extends base MemorySystem with ServiceNow-specific patterns
- */
-import { MemorySystem, MemoryOptions } from './memory-system';
-export interface HierarchicalMemoryEntry {
-    key: string;
-    value: any;
-    namespace: string;
-    type: string;
-    metadata?: {
-        created: string;
-        updated: string;
-        version: number;
-        tags: string[];
-        relationships?: Record<string, string[]>;
-        dependencies?: Record<string, string[]>;
-    };
-    ttl?: number;
-}
-export interface MemorySearchOptions {
-    namespace?: string;
-    type?: string;
-    tags?: string[];
-    pattern?: string;
-    limit?: number;
-    includeExpired?: boolean;
-}
-export declare class HierarchicalMemorySystem extends MemorySystem {
-    private namespaceIndex;
-    private typeIndex;
-    private tagIndex;
-    constructor(options: MemoryOptions);
-    /**
-     * Initialize with enhanced tables for hierarchical storage
-     */
-    initialize(): Promise<void>;
-    /**
-     * Create additional tables for hierarchical organization
-     */
-    private createHierarchicalTables;
-    /**
-     * Store with hierarchical organization
-     */
-    storeHierarchical(entry: Partial<HierarchicalMemoryEntry>): Promise<void>;
-    /**
-     * Get with full hierarchical metadata
-     */
-    getHierarchical(key: string): Promise<HierarchicalMemoryEntry | null>;
-    /**
-     * Search with hierarchical patterns
-     */
-    search(options: MemorySearchOptions): Promise<HierarchicalMemoryEntry[]>;
-    /**
-     * Create relationship between entries
-     */
-    createRelationship(sourceKey: string, targetKey: string, relationshipType: string, metadata?: any): Promise<void>;
-    /**
-     * Get related entries
-     */
-    getRelated(key: string, relationshipType?: string): Promise<HierarchicalMemoryEntry[]>;
-    /**
-     * Associate memory with agent
-     */
-    associateWithAgent(agentId: string, memoryKey: string, accessType: 'read' | 'write' | 'owner'): Promise<void>;
-    /**
-     * Get agent's memory entries
-     */
-    getAgentMemory(agentId: string, accessType?: string): Promise<HierarchicalMemoryEntry[]>;
-    /**
-     * Track access pattern for learning
-     */
-    trackAccessPattern(patternType: string, metadata?: any): Promise<void>;
-    /**
-     * Get namespace statistics
-     */
-    getNamespaceStats(): Promise<Record<string, number>>;
-    /**
-     * Helper methods
-     */
-    private updateTags;
-    private getTags;
-    private updateLocalIndexes;
-    private buildIndexes;
-    /**
-     * Cleanup expired entries
-     */
-    cleanupExpired(): Promise<number>;
-}
-//# sourceMappingURL=hierarchical-memory-system.d.ts.map

package/dist/memory/hierarchical-memory-system.js

@@ -1,400 +0,0 @@
-"use strict";
-/**
- * Hierarchical Memory System for Snow-Flow
- * Extends base MemorySystem with ServiceNow-specific patterns
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HierarchicalMemorySystem = void 0;
-const memory_system_1 = require("./memory-system");
-class HierarchicalMemorySystem extends memory_system_1.MemorySystem {
-    constructor(options) {
-        super(options);
-        this.namespaceIndex = new Map();
-        this.typeIndex = new Map();
-        this.tagIndex = new Map();
-    }
-    /**
-     * Initialize with enhanced tables for hierarchical storage
-     */
-    async initialize() {
-        await super.initialize();
-        await this.createHierarchicalTables();
-        await this.buildIndexes();
-    }
-    /**
-     * Create additional tables for hierarchical organization
-     */
-    async createHierarchicalTables() {
-        const tables = [
-            // Enhanced memory store with namespace and type
-            `CREATE TABLE IF NOT EXISTS hierarchical_memory (
-        key TEXT PRIMARY KEY,
-        namespace TEXT NOT NULL,
-        type TEXT NOT NULL,
-        value TEXT NOT NULL,
-        metadata TEXT,
-        ttl INTEGER,
-        created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),
-        updated_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),
-        expires_at INTEGER,
-        version INTEGER DEFAULT 1
-      )`,
-            // Tag associations
-            `CREATE TABLE IF NOT EXISTS memory_tags (
-        key TEXT NOT NULL,
-        tag TEXT NOT NULL,
-        PRIMARY KEY (key, tag),
-        FOREIGN KEY (key) REFERENCES hierarchical_memory(key) ON DELETE CASCADE
-      )`,
-            // Relationships between memory entries
-            `CREATE TABLE IF NOT EXISTS memory_relationships (
-        source_key TEXT NOT NULL,
-        target_key TEXT NOT NULL,
-        relationship_type TEXT NOT NULL,
-        metadata TEXT,
-        created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),
-        PRIMARY KEY (source_key, target_key, relationship_type),
-        FOREIGN KEY (source_key) REFERENCES hierarchical_memory(key) ON DELETE CASCADE,
-        FOREIGN KEY (target_key) REFERENCES hierarchical_memory(key) ON DELETE CASCADE
-      )`,
-            // Agent memory associations
-            `CREATE TABLE IF NOT EXISTS agent_memory (
-        agent_id TEXT NOT NULL,
-        memory_key TEXT NOT NULL,
-        access_type TEXT NOT NULL, -- 'read', 'write', 'owner'
-        accessed_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),
-        PRIMARY KEY (agent_id, memory_key),
-        FOREIGN KEY (memory_key) REFERENCES hierarchical_memory(key) ON DELETE CASCADE
-      )`,
-            // Memory access patterns for learning
-            `CREATE TABLE IF NOT EXISTS memory_access_patterns (
-        pattern_id TEXT PRIMARY KEY,
-        pattern_type TEXT NOT NULL,
-        frequency INTEGER DEFAULT 1,
-        last_accessed INTEGER DEFAULT (strftime('%s', 'now') * 1000),
-        metadata TEXT
-      )`,
-        ];
-        for (const table of tables) {
-            await this.execute(table);
-        }
-        // Create indexes for performance
-        const indexes = [
-            'CREATE INDEX IF NOT EXISTS idx_namespace ON hierarchical_memory(namespace)',
-            'CREATE INDEX IF NOT EXISTS idx_type ON hierarchical_memory(type)',
-            'CREATE INDEX IF NOT EXISTS idx_expires ON hierarchical_memory(expires_at)',
-            'CREATE INDEX IF NOT EXISTS idx_tags ON memory_tags(tag)',
-            'CREATE INDEX IF NOT EXISTS idx_relationships ON memory_relationships(relationship_type)',
-            'CREATE INDEX IF NOT EXISTS idx_agent_memory ON agent_memory(agent_id)',
-        ];
-        for (const index of indexes) {
-            await this.execute(index);
-        }
-    }
-    /**
-     * Store with hierarchical organization
-     */
-    async storeHierarchical(entry) {
-        if (!entry.key)
-            throw new Error('Key is required');
-        // Extract namespace and type from key pattern
-        const keyParts = entry.key.split('/');
-        const namespace = entry.namespace || keyParts[0] || 'default';
-        const type = entry.type || keyParts[1] || 'general';
-        const metadata = {
-            created: new Date().toISOString(),
-            updated: new Date().toISOString(),
-            version: 1,
-            tags: entry.metadata?.tags || [],
-            relationships: entry.metadata?.relationships || {},
-            dependencies: entry.metadata?.dependencies || {},
-            ...entry.metadata,
-        };
-        const ttl = entry.ttl || 86400000 * 7; // 7 days default
-        const expiresAt = Date.now() + ttl;
-        // Check if exists for versioning
-        const existing = await this.getHierarchical(entry.key);
-        if (existing) {
-            metadata.version = (existing.metadata?.version || 0) + 1;
-            metadata.created = existing.metadata?.created || metadata.created;
-        }
-        // Store in hierarchical table
-        await this.execute(`
-      INSERT OR REPLACE INTO hierarchical_memory 
-      (key, namespace, type, value, metadata, ttl, expires_at, version, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `, [
-            entry.key,
-            namespace,
-            type,
-            JSON.stringify(entry.value),
-            JSON.stringify(metadata),
-            ttl,
-            expiresAt,
-            metadata.version,
-            Date.now()
-        ]);
-        // Update tags
-        if (metadata.tags.length > 0) {
-            await this.updateTags(entry.key, metadata.tags);
-        }
-        // Update indexes
-        this.updateLocalIndexes(entry.key, namespace, type, metadata.tags);
-        // Store in base system for compatibility
-        await super.store(entry.key, entry.value, ttl);
-        this.emit('memory:hierarchical:stored', { key: entry.key, namespace, type });
-    }
-    /**
-     * Get with full hierarchical metadata
-     */
-    async getHierarchical(key) {
-        const result = await this.query(`
-      SELECT * FROM hierarchical_memory 
-      WHERE key = ? AND expires_at > ?
-    `, [key, Date.now()]);
-        if (!result || result.length === 0)
-            return null;
-        const row = result[0];
-        const tags = await this.getTags(key);
-        return {
-            key: row.key,
-            namespace: row.namespace,
-            type: row.type,
-            value: JSON.parse(row.value),
-            metadata: {
-                ...JSON.parse(row.metadata || '{}'),
-                tags,
-            },
-            ttl: row.ttl,
-        };
-    }
-    /**
-     * Search with hierarchical patterns
-     */
-    async search(options) {
-        let sql = 'SELECT DISTINCT h.* FROM hierarchical_memory h';
-        const params = [];
-        const conditions = [];
-        // Join with tags if needed
-        if (options.tags && options.tags.length > 0) {
-            sql += ' INNER JOIN memory_tags t ON h.key = t.key';
-            conditions.push(`t.tag IN (${options.tags.map(() => '?').join(',')})`);
-            params.push(...options.tags);
-        }
-        // Add namespace filter
-        if (options.namespace) {
-            conditions.push('h.namespace = ?');
-            params.push(options.namespace);
-        }
-        // Add type filter
-        if (options.type) {
-            conditions.push('h.type = ?');
-            params.push(options.type);
-        }
-        // Add pattern matching
-        if (options.pattern) {
-            conditions.push('h.key LIKE ?');
-            params.push(`%${options.pattern}%`);
-        }
-        // Add expiration filter
-        if (!options.includeExpired) {
-            conditions.push('h.expires_at > ?');
-            params.push(Date.now());
-        }
-        // Combine conditions
-        if (conditions.length > 0) {
-            sql += ' WHERE ' + conditions.join(' AND ');
-        }
-        // Add ordering and limit
-        sql += ' ORDER BY h.updated_at DESC';
-        if (options.limit) {
-            sql += ' LIMIT ?';
-            params.push(options.limit);
-        }
-        const results = await this.query(sql, params);
-        // Fetch tags and format results
-        const entries = [];
-        for (const row of results) {
-            const tags = await this.getTags(row.key);
-            entries.push({
-                key: row.key,
-                namespace: row.namespace,
-                type: row.type,
-                value: JSON.parse(row.value),
-                metadata: {
-                    ...JSON.parse(row.metadata || '{}'),
-                    tags,
-                },
-                ttl: row.ttl,
-            });
-        }
-        return entries;
-    }
-    /**
-     * Create relationship between entries
-     */
-    async createRelationship(sourceKey, targetKey, relationshipType, metadata) {
-        await this.execute(`
-      INSERT OR REPLACE INTO memory_relationships 
-      (source_key, target_key, relationship_type, metadata)
-      VALUES (?, ?, ?, ?)
-    `, [sourceKey, targetKey, relationshipType, JSON.stringify(metadata || {})]);
-        this.emit('memory:relationship:created', { sourceKey, targetKey, relationshipType });
-    }
-    /**
-     * Get related entries
-     */
-    async getRelated(key, relationshipType) {
-        let sql = `
-      SELECT DISTINCT h.* 
-      FROM hierarchical_memory h
-      INNER JOIN memory_relationships r ON (h.key = r.target_key OR h.key = r.source_key)
-      WHERE (r.source_key = ? OR r.target_key = ?) AND h.key != ?
-    `;
-        const params = [key, key, key];
-        if (relationshipType) {
-            sql += ' AND r.relationship_type = ?';
-            params.push(relationshipType);
-        }
-        const results = await this.query(sql, params);
-        const entries = [];
-        for (const row of results) {
-            const entry = await this.getHierarchical(row.key);
-            if (entry)
-                entries.push(entry);
-        }
-        return entries;
-    }
-    /**
-     * Associate memory with agent
-     */
-    async associateWithAgent(agentId, memoryKey, accessType) {
-        await this.execute(`
-      INSERT OR REPLACE INTO agent_memory (agent_id, memory_key, access_type)
-      VALUES (?, ?, ?)
-    `, [agentId, memoryKey, accessType]);
-    }
-    /**
-     * Get agent's memory entries
-     */
-    async getAgentMemory(agentId, accessType) {
-        let sql = `
-      SELECT h.* FROM hierarchical_memory h
-      INNER JOIN agent_memory a ON h.key = a.memory_key
-      WHERE a.agent_id = ?
-    `;
-        const params = [agentId];
-        if (accessType) {
-            sql += ' AND a.access_type = ?';
-            params.push(accessType);
-        }
-        const results = await this.query(sql, params);
-        const entries = [];
-        for (const row of results) {
-            const entry = await this.getHierarchical(row.key);
-            if (entry)
-                entries.push(entry);
-        }
-        return entries;
-    }
-    /**
-     * Track access pattern for learning
-     */
-    async trackAccessPattern(patternType, metadata) {
-        const patternId = `${patternType}_${Date.now()}`;
-        await this.execute(`
-      INSERT INTO memory_access_patterns (pattern_id, pattern_type, metadata)
-      VALUES (?, ?, ?)
-      ON CONFLICT(pattern_id) DO UPDATE SET
-        frequency = frequency + 1,
-        last_accessed = strftime('%s', 'now') * 1000
-    `, [patternId, patternType, JSON.stringify(metadata || {})]);
-    }
-    /**
-     * Get namespace statistics
-     */
-    async getNamespaceStats() {
-        const results = await this.query(`
-      SELECT namespace, COUNT(*) as count
-      FROM hierarchical_memory
-      WHERE expires_at > ?
-      GROUP BY namespace
-    `, [Date.now()]);
-        const stats = {};
-        for (const row of results) {
-            stats[row.namespace] = row.count;
-        }
-        return stats;
-    }
-    /**
-     * Helper methods
-     */
-    async updateTags(key, tags) {
-        // Remove existing tags
-        await this.execute('DELETE FROM memory_tags WHERE key = ?', [key]);
-        // Insert new tags
-        for (const tag of tags) {
-            await this.execute('INSERT INTO memory_tags (key, tag) VALUES (?, ?)', [key, tag]);
-        }
-    }
-    async getTags(key) {
-        const results = await this.query('SELECT tag FROM memory_tags WHERE key = ?', [key]);
-        return results.map(r => r.tag);
-    }
-    updateLocalIndexes(key, namespace, type, tags) {
-        // Update namespace index
-        if (!this.namespaceIndex.has(namespace)) {
-            this.namespaceIndex.set(namespace, new Set());
-        }
-        this.namespaceIndex.get(namespace).add(key);
-        // Update type index
-        if (!this.typeIndex.has(type)) {
-            this.typeIndex.set(type, new Set());
-        }
-        this.typeIndex.get(type).add(key);
-        // Update tag index
-        for (const tag of tags) {
-            if (!this.tagIndex.has(tag)) {
-                this.tagIndex.set(tag, new Set());
-            }
-            this.tagIndex.get(tag).add(key);
-        }
-    }
-    async buildIndexes() {
-        // Build indexes from existing data
-        const results = await this.query(`
-      SELECT key, namespace, type FROM hierarchical_memory 
-      WHERE expires_at > ?
-    `, [Date.now()]);
-        for (const row of results) {
-            const tags = await this.getTags(row.key);
-            this.updateLocalIndexes(row.key, row.namespace, row.type, tags);
-        }
-    }
-    /**
-     * Cleanup expired entries
-     */
-    async cleanupExpired() {
-        const result = await this.query(`
-      DELETE FROM hierarchical_memory 
-      WHERE expires_at <= ?
-      RETURNING key
-    `, [Date.now()]);
-        // Update local indexes
-        for (const row of result) {
-            // Remove from indexes
-            for (const [namespace, keys] of this.namespaceIndex) {
-                keys.delete(row.key);
-            }
-            for (const [type, keys] of this.typeIndex) {
-                keys.delete(row.key);
-            }
-            for (const [tag, keys] of this.tagIndex) {
-                keys.delete(row.key);
-            }
-        }
-        return result.length;
-    }
-}
-exports.HierarchicalMemorySystem = HierarchicalMemorySystem;
-//# sourceMappingURL=hierarchical-memory-system.js.map

package/dist/memory/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * Snow-Flow Memory System Exports
- * Centralized exports for the SQLite memory system
- */
-export { SwarmMemory, SwarmMemoryConfig, AgentCoordination, ServiceNowArtifactRecord, AgentMessage, SharedContext, DeploymentHistory, AgentDependency, PerformanceMetric } from './swarm-memory.js';
-export { MemoryOperations, AgentCoordinationUpdate, ArtifactSearchOptions, MessageSearchOptions, PerformanceQuery } from './memory-operations.js';
-export { MemoryClient, MemoryClientConfig, MemoryStoreOptions, MemoryRetrieveOptions, ArtifactInfo, AgentHandoff, PerformanceTracker } from './memory-client.js';
-export { ServiceNowArtifactIndexer, ServiceNowArtifact, FlowArtifact, WidgetArtifact, IndexedArtifact, ArtifactStructure, ArtifactContext, ArtifactRelationships, ModificationPoint, EditHistory } from './servicenow-artifact-indexer.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/memory/index.js

@@ -1,20 +0,0 @@
-"use strict";
-/**
- * Snow-Flow Memory System Exports
- * Centralized exports for the SQLite memory system
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceNowArtifactIndexer = exports.MemoryClient = exports.MemoryOperations = exports.SwarmMemory = void 0;
-// Core memory system
-var swarm_memory_js_1 = require("./swarm-memory.js");
-Object.defineProperty(exports, "SwarmMemory", { enumerable: true, get: function () { return swarm_memory_js_1.SwarmMemory; } });
-// Memory operations
-var memory_operations_js_1 = require("./memory-operations.js");
-Object.defineProperty(exports, "MemoryOperations", { enumerable: true, get: function () { return memory_operations_js_1.MemoryOperations; } });
-// Memory client API
-var memory_client_js_1 = require("./memory-client.js");
-Object.defineProperty(exports, "MemoryClient", { enumerable: true, get: function () { return memory_client_js_1.MemoryClient; } });
-// Existing artifact indexer (for compatibility)
-var servicenow_artifact_indexer_js_1 = require("./servicenow-artifact-indexer.js");
-Object.defineProperty(exports, "ServiceNowArtifactIndexer", { enumerable: true, get: function () { return servicenow_artifact_indexer_js_1.ServiceNowArtifactIndexer; } });
-//# sourceMappingURL=index.js.map

package/dist/memory/mcp-integration-example.d.ts

@@ -1,6 +0,0 @@
-/**
- * Snow-Flow Memory System MCP Integration Example
- * Shows how MCP tools integrate with the memory system
- */
-export {};
-//# sourceMappingURL=mcp-integration-example.d.ts.map