snow-flow 3.0.8 → 3.0.10

package/dist/memory/memory-test.js

@@ -1,161 +0,0 @@
-"use strict";
-/**
- * Snow-Flow Memory System Test
- * Demonstrates and tests the SQLite memory system functionality
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const memory_client_js_1 = require("./memory-client.js");
-const logger_js_1 = require("../utils/logger.js");
-const logger = new logger_js_1.Logger('MemoryTest');
-async function testMemorySystem() {
-    logger.info('Starting memory system tests');
-    // Create a test session
-    const sessionId = `test_session_${Date.now()}`;
-    // Create memory clients for different agents
-    const widgetAgent = memory_client_js_1.MemoryClient.forAgent('widget_creator_001', 'widget-creator', sessionId);
-    const uiAgent = memory_client_js_1.MemoryClient.forAgent('ui_specialist_001', 'ui-specialist', sessionId);
-    const testAgent = memory_client_js_1.MemoryClient.forAgent('test_agent_001', 'tester', sessionId);
-    try {
-        logger.info('Test 1: Agent Registration and Coordination');
-        // Register agents
-        await widgetAgent.register(['create_incident_widget']);
-        await uiAgent.register(['style_widget', 'add_responsiveness']);
-        await testAgent.register(['test_widget_functionality']);
-        // Update progress
-        await widgetAgent.updateProgress(25, 'analyzing_requirements');
-        await widgetAgent.updateProgress(50, 'creating_template');
-        await widgetAgent.updateProgress(75, 'implementing_server_script');
-        logger.info('Test 2: Shared Context Storage');
-        // Store widget requirements in shared context
-        await widgetAgent.store({
-            key: 'widget_requirements',
-            value: {
-                name: 'incident_dashboard',
-                features: ['real-time updates', 'chart visualization', 'filters'],
-                data_sources: ['incident', 'problem'],
-                priority: 'high'
-            }
-        });
-        // UI agent retrieves requirements
-        const requirements = await uiAgent.retrieve({ key: 'widget_requirements' });
-        logger.info('UI Agent retrieved requirements', requirements);
-        logger.info('Test 3: Artifact Management');
-        // Widget agent creates artifact
-        await widgetAgent.storeArtifact({
-            sys_id: 'widget_12345',
-            type: 'widget',
-            name: 'Incident Dashboard Widget',
-            description: 'Real-time incident monitoring dashboard',
-            status: 'created',
-            metadata: {
-                template_size: '5KB',
-                has_client_script: true,
-                has_server_script: true
-            }
-        });
-        // Update artifact status
-        await widgetAgent.updateArtifactStatus('widget_12345', 'tested');
-        logger.info('Test 4: Agent Communication');
-        // Widget agent hands off to UI specialist
-        await widgetAgent.handoff({
-            to_agent: 'ui_specialist_001',
-            artifact_reference: 'widget_12345',
-            data: {
-                template_ready: true,
-                styling_requirements: {
-                    theme: 'dark',
-                    responsive: true,
-                    accessibility: 'WCAG 2.1'
-                }
-            }
-        });
-        // UI agent checks for handoffs
-        const handoffs = await uiAgent.checkHandoffs();
-        logger.info('UI Agent received handoffs', handoffs);
-        // UI agent reports dependency ready to test agent
-        await uiAgent.reportDependencyReady('test_agent_001', 'widget_12345');
-        logger.info('Test 5: Performance Tracking');
-        // Track widget creation operation
-        const tracker = widgetAgent.trackOperation('create_widget_template');
-        // Simulate operation
-        await new Promise(resolve => setTimeout(resolve, 100));
-        // Complete tracking
-        await tracker.complete(true, undefined, { lines_of_code: 250 });
-        // Get performance stats
-        const stats = await widgetAgent.getPerformanceStats('create_widget_template');
-        logger.info('Performance stats', stats);
-        logger.info('Test 6: Deployment History');
-        // Record deployment events
-        await widgetAgent.recordDeployment('widget_12345', 'create', true);
-        await uiAgent.recordDeployment('widget_12345', 'update', true);
-        await testAgent.recordDeployment('widget_12345', 'test', true);
-        await widgetAgent.recordDeployment('widget_12345', 'verify', true);
-        // Get deployment history
-        const history = await widgetAgent.getDeploymentHistory('widget_12345');
-        logger.info('Deployment history', history);
-        logger.info('Test 7: Session State Management');
-        // Mark agents as completed
-        await widgetAgent.complete();
-        await uiAgent.complete();
-        await testAgent.complete();
-        // Get complete session state
-        const sessionState = await widgetAgent.getSessionState();
-        logger.info('Session state', {
-            activeAgents: sessionState.agents.length,
-            artifacts: sessionState.artifacts.length,
-            pendingMessages: sessionState.pendingMessages,
-            contextKeys: sessionState.activeContext.map(c => c.context_key),
-            performanceSummary: sessionState.performanceSummary
-        });
-        logger.info('Test 8: Memory Statistics');
-        const stats2 = widgetAgent.getStats();
-        logger.info('Memory statistics', stats2);
-        logger.info('Test 9: Query Performance');
-        // Test query performance (should be <100ms as per requirements)
-        const startTime = Date.now();
-        // Run multiple queries
-        await Promise.all([
-            widgetAgent.findSessionArtifacts(),
-            widgetAgent.getSessionData(),
-            widgetAgent.getPerformanceStats('create_widget_template'),
-            uiAgent.checkHandoffs(),
-            testAgent.checkDependencies()
-        ]);
-        const queryTime = Date.now() - startTime;
-        logger.info(`Query performance: ${queryTime}ms (requirement: <100ms)`);
-        logger.info('Test 10: Concurrent Operations');
-        // Test thread-safe concurrent operations
-        const concurrentOps = [];
-        for (let i = 0; i < 10; i++) {
-            concurrentOps.push(widgetAgent.store({
-                key: `concurrent_test_${i}`,
-                value: `value_${i}`
-            }));
-        }
-        await Promise.all(concurrentOps);
-        logger.info('Concurrent operations completed successfully');
-        // Cleanup
-        await widgetAgent.cleanup();
-        logger.info('All tests completed successfully!');
-    }
-    catch (error) {
-        logger.error('Test failed', error);
-        throw error;
-    }
-    finally {
-        // Shutdown memory system
-        memory_client_js_1.MemoryClient.shutdown();
-    }
-}
-// Run tests if called directly
-if (require.main === module) {
-    testMemorySystem()
-        .then(() => {
-        logger.info('Memory system test completed');
-        process.exit(0);
-    })
-        .catch((error) => {
-        logger.error('Memory system test failed', error);
-        process.exit(1);
-    });
-}

package/dist/memory/snow-flow-memory-patterns.d.ts

@@ -1,213 +0,0 @@
-/**
- * Snow-Flow Memory Patterns
- * Hierarchical memory organization for ServiceNow development
- */
-export interface SnowFlowMemoryPatterns {
-    patterns: {
-        'specs/requirements': 'Store user stories and requirements';
-        'specs/acceptance-criteria': 'Acceptance criteria for features';
-        'specs/business-rules': 'Business logic specifications';
-        'architecture/decisions': 'Architecture choices and rationale';
-        'architecture/data-model': 'ServiceNow table relationships';
-        'architecture/integrations': 'Integration points and APIs';
-        'architecture/security': 'Security model and ACLs';
-        'artifacts/widgets/[name]': 'Service Portal widgets';
-        'artifacts/flows/[name]': 'Flow Designer flows';
-        'artifacts/scripts/[name]': 'Script Includes and Business Rules';
-        'artifacts/tables/[name]': 'Custom table definitions';
-        'artifacts/ui-pages/[name]': 'UI Pages and interfaces';
-        'code/client-scripts/[name]': 'Client-side scripts';
-        'code/server-scripts/[name]': 'Server-side scripts';
-        'code/rest-apis/[endpoint]': 'REST API implementations';
-        'code/scheduled-jobs/[name]': 'Scheduled job scripts';
-        'tests/unit/[module]': 'Unit test results';
-        'tests/integration/[flow]': 'Integration test outcomes';
-        'tests/atf/[suite]': 'Automated Test Framework results';
-        'tests/performance/[metric]': 'Performance benchmarks';
-        'docs/api/[endpoint]': 'API documentation';
-        'docs/user-guide/[feature]': 'User documentation';
-        'docs/admin-guide/[config]': 'Admin configuration guides';
-        'docs/runbooks/[procedure]': 'Operational procedures';
-        'deploy/update-sets/[name]': 'Update Set tracking';
-        'deploy/instances/[env]': 'Instance-specific configs';
-        'deploy/migrations/[version]': 'Data migration scripts';
-        'patterns/successful/[type]': 'Successful implementation patterns';
-        'patterns/anti/[type]': 'Anti-patterns to avoid';
-        'patterns/reusable/[component]': 'Reusable components';
-    };
-}
-export declare class SnowFlowMemoryOrganizer {
-    /**
-     * Generate hierarchical key for ServiceNow artifacts
-     */
-    static generateKey(category: string, type: string, name: string): string;
-    /**
-     * Store widget information with metadata
-     */
-    static getWidgetMemoryStructure(widgetName: string): {
-        key: string;
-        metadata: {
-            type: string;
-            created: string;
-            tags: string[];
-        };
-        searchableFields: string[];
-    };
-    /**
-     * Store flow information with relationships
-     */
-    static getFlowMemoryStructure(flowName: string): {
-        key: string;
-        metadata: {
-            type: string;
-            created: string;
-            tags: string[];
-        };
-        relationships: {
-            triggers: any[];
-            actions: any[];
-            subflows: any[];
-            tables: any[];
-        };
-    };
-    /**
-     * Store script information with dependencies
-     */
-    static getScriptMemoryStructure(scriptName: string, scriptType: string): {
-        key: string;
-        metadata: {
-            type: string;
-            created: string;
-            tags: string[];
-        };
-        dependencies: {
-            tables: any[];
-            scriptIncludes: any[];
-            glideRecords: any[];
-            apis: any[];
-        };
-    };
-    /**
-     * Store test results with coverage
-     */
-    static getTestMemoryStructure(testName: string, testType: string): {
-        key: string;
-        metadata: {
-            type: string;
-            executed: string;
-            tags: string[];
-        };
-        results: {
-            passed: number;
-            failed: number;
-            skipped: number;
-            coverage: number;
-            duration: number;
-        };
-    };
-    /**
-     * Store deployment information
-     */
-    static getDeploymentMemoryStructure(updateSetName: string): {
-        key: string;
-        metadata: {
-            type: string;
-            created: string;
-            tags: string[];
-        };
-        contents: {
-            artifacts: any[];
-            dependencies: any[];
-            conflicts: any[];
-            targetInstance: string;
-        };
-    };
-}
-/**
- * Agent capability mappings for ServiceNow development
- */
-export declare const SNOW_FLOW_AGENT_CAPABILITIES: {
-    'widget-developer': string[];
-    'ui-designer': string[];
-    'flow-builder': string[];
-    'integration-specialist': string[];
-    'script-developer': string[];
-    'client-scripter': string[];
-    'data-architect': string[];
-    'security-engineer': string[];
-    'test-engineer': string[];
-    'quality-analyst': string[];
-    'technical-writer': string[];
-    'solution-architect': string[];
-};
-/**
- * Coordination patterns for Snow-Flow agents
- */
-export interface SnowFlowCoordinationPatterns {
-    spawnPatterns: {
-        widgetDevelopment: {
-            agents: ['widget-developer', 'ui-designer', 'test-engineer'];
-            coordination: 'parallel-with-sync-points';
-        };
-        flowDevelopment: {
-            agents: ['flow-builder', 'integration-specialist', 'test-engineer'];
-            coordination: 'sequential-with-validation';
-        };
-        fullStackFeature: {
-            agents: ['data-architect', 'script-developer', 'widget-developer', 'flow-builder'];
-            coordination: 'hierarchical-with-dependencies';
-        };
-    };
-    memorySync: {
-        sharedSpecs: 'specs/*';
-        architectureDecisions: 'architecture/decisions/*';
-        codeArtifacts: 'code/**/*';
-        testResults: 'tests/**/latest';
-    };
-    progressTracking: {
-        phases: ['design', 'development', 'testing', 'deployment'];
-        checkpoints: ['spec-approved', 'code-complete', 'tests-passed', 'deployed'];
-        metrics: ['velocity', 'quality', 'coverage', 'performance'];
-    };
-}
-/**
- * Example usage patterns for ServiceNow development
- */
-export declare class SnowFlowWorkflowExamples {
-    /**
-     * Example: Create incident dashboard widget
-     */
-    static createIncidentDashboard(): Promise<void>;
-    /**
-     * Example: Create approval workflow
-     */
-    static createApprovalFlow(): Promise<void>;
-}
-/**
- * Monitoring patterns for Snow-Flow
- */
-export interface SnowFlowMonitoringPatterns {
-    swarmMonitor: {
-        activeAgents: number;
-        taskProgress: Map<string, number>;
-        memoryUsage: {
-            artifacts: number;
-            specs: number;
-            tests: number;
-            total: number;
-        };
-        performance: {
-            avgTaskTime: number;
-            successRate: number;
-            activeErrors: string[];
-        };
-    };
-    statusReport: {
-        phase: string;
-        completedTasks: string[];
-        pendingTasks: string[];
-        blockers: string[];
-        nextSteps: string[];
-    };
-}
-//# sourceMappingURL=snow-flow-memory-patterns.d.ts.map

package/dist/memory/snow-flow-memory-patterns.js

@@ -1,200 +0,0 @@
-"use strict";
-/**
- * Snow-Flow Memory Patterns
- * Hierarchical memory organization for ServiceNow development
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SnowFlowWorkflowExamples = exports.SNOW_FLOW_AGENT_CAPABILITIES = exports.SnowFlowMemoryOrganizer = void 0;
-class SnowFlowMemoryOrganizer {
-    /**
-     * Generate hierarchical key for ServiceNow artifacts
-     */
-    static generateKey(category, type, name) {
-        const sanitizedName = name.toLowerCase().replace(/\s+/g, '_').replace(/[^a-z0-9_]/g, '');
-        return `${category}/${type}/${sanitizedName}`;
-    }
-    /**
-     * Store widget information with metadata
-     */
-    static getWidgetMemoryStructure(widgetName) {
-        return {
-            key: this.generateKey('artifacts', 'widgets', widgetName),
-            metadata: {
-                type: 'service_portal_widget',
-                created: new Date().toISOString(),
-                tags: ['widget', 'ui', 'service-portal'],
-            },
-            searchableFields: ['name', 'title', 'description', 'template', 'script'],
-        };
-    }
-    /**
-     * Store flow information with relationships
-     */
-    static getFlowMemoryStructure(flowName) {
-        return {
-            key: this.generateKey('artifacts', 'flows', flowName),
-            metadata: {
-                type: 'flow_designer',
-                created: new Date().toISOString(),
-                tags: ['flow', 'automation', 'workflow'],
-            },
-            relationships: {
-                triggers: [],
-                actions: [],
-                subflows: [],
-                tables: [],
-            },
-        };
-    }
-    /**
-     * Store script information with dependencies
-     */
-    static getScriptMemoryStructure(scriptName, scriptType) {
-        return {
-            key: this.generateKey('code', `${scriptType}-scripts`, scriptName),
-            metadata: {
-                type: scriptType,
-                created: new Date().toISOString(),
-                tags: ['script', scriptType],
-            },
-            dependencies: {
-                tables: [],
-                scriptIncludes: [],
-                glideRecords: [],
-                apis: [],
-            },
-        };
-    }
-    /**
-     * Store test results with coverage
-     */
-    static getTestMemoryStructure(testName, testType) {
-        return {
-            key: this.generateKey('tests', testType, testName),
-            metadata: {
-                type: `${testType}_test`,
-                executed: new Date().toISOString(),
-                tags: ['test', testType],
-            },
-            results: {
-                passed: 0,
-                failed: 0,
-                skipped: 0,
-                coverage: 0,
-                duration: 0,
-            },
-        };
-    }
-    /**
-     * Store deployment information
-     */
-    static getDeploymentMemoryStructure(updateSetName) {
-        return {
-            key: this.generateKey('deploy', 'update-sets', updateSetName),
-            metadata: {
-                type: 'update_set',
-                created: new Date().toISOString(),
-                tags: ['deployment', 'update-set'],
-            },
-            contents: {
-                artifacts: [],
-                dependencies: [],
-                conflicts: [],
-                targetInstance: '',
-            },
-        };
-    }
-}
-exports.SnowFlowMemoryOrganizer = SnowFlowMemoryOrganizer;
-/**
- * Agent capability mappings for ServiceNow development
- */
-exports.SNOW_FLOW_AGENT_CAPABILITIES = {
-    // UI Development
-    'widget-developer': ['html', 'css', 'javascript', 'angular', 'service-portal-api'],
-    'ui-designer': ['ui-builder', 'themes', 'branding', 'responsive-design'],
-    // Flow Development
-    'flow-builder': ['flow-designer', 'triggers', 'actions', 'subflows', 'approvals'],
-    'integration-specialist': ['rest-api', 'soap', 'mid-server', 'integration-hub'],
-    // Scripting
-    'script-developer': ['glide-api', 'business-rules', 'script-includes', 'scheduled-jobs'],
-    'client-scripter': ['client-scripts', 'ui-policies', 'catalog-client-scripts'],
-    // Data & Configuration
-    'data-architect': ['tables', 'relationships', 'acls', 'data-policies'],
-    'security-engineer': ['security-rules', 'authentication', 'encryption', 'audit'],
-    // Testing & Quality
-    'test-engineer': ['atf', 'unit-testing', 'regression-testing', 'performance-testing'],
-    'quality-analyst': ['code-review', 'best-practices', 'performance-optimization'],
-    // Documentation & Training
-    'technical-writer': ['api-docs', 'user-guides', 'runbooks', 'knowledge-articles'],
-    'solution-architect': ['architecture-docs', 'design-patterns', 'roadmaps'],
-};
-/**
- * Example usage patterns for ServiceNow development
- */
-class SnowFlowWorkflowExamples {
-    /**
-     * Example: Create incident dashboard widget
-     */
-    static async createIncidentDashboard() {
-        // 1. Store requirements
-        // await memory.store('specs/requirements/incident-dashboard', {
-        //   title: 'Incident Dashboard Widget',
-        //   features: ['real-time updates', 'priority filtering', 'assignment groups'],
-        //   acceptance: ['shows active incidents', 'updates every 30s', 'filterable'],
-        // });
-        // 2. Spawn specialized agents
-        const agents = await Promise.all([
-        // agentSpawn({ type: 'widget-developer', capabilities: SNOW_FLOW_AGENT_CAPABILITIES['widget-developer'] }),
-        // agentSpawn({ type: 'ui-designer', capabilities: SNOW_FLOW_AGENT_CAPABILITIES['ui-designer'] }),
-        // agentSpawn({ type: 'test-engineer', capabilities: SNOW_FLOW_AGENT_CAPABILITIES['test-engineer'] }),
-        ]);
-        // 3. Coordinate work
-        // await agentCommunicate({ 
-        //   to: agents[0].id, 
-        //   message: 'Create widget structure based on specs/requirements/incident-dashboard' 
-        // });
-        // await agentCommunicate({ 
-        //   to: agents[1].id, 
-        //   message: 'Design responsive layout for incident data visualization' 
-        // });
-        // 4. Store artifacts
-        // await memory.store('artifacts/widgets/incident-dashboard', {
-        //   html: '<!-- widget template -->',
-        //   css: '/* widget styles */',
-        //   clientScript: '// client controller',
-        //   serverScript: '// server script',
-        // });
-        // 5. Track progress
-        // await taskUpdate({ taskId: 'incident-dashboard', progress: 100 });
-    }
-    /**
-     * Example: Create approval workflow
-     */
-    static async createApprovalFlow() {
-        // 1. Store flow design
-        // await memory.store('architecture/decisions/approval-flow', {
-        //   pattern: 'multi-level-approval',
-        //   levels: ['manager', 'director', 'vp'],
-        //   escalation: 'time-based',
-        // });
-        // 2. Spawn flow specialists
-        // const flowBuilder = await agentSpawn({ 
-        //   type: 'flow-builder', 
-        //   capabilities: SNOW_FLOW_AGENT_CAPABILITIES['flow-builder'] 
-        // });
-        // 3. Build flow with memory reference
-        // await agentCommunicate({ 
-        //   to: flowBuilder.id, 
-        //   message: 'Build approval flow using architecture/decisions/approval-flow pattern' 
-        // });
-        // 4. Store flow artifact
-        // await memory.store('artifacts/flows/equipment-approval', {
-        //   trigger: 'record.inserted',
-        //   actions: ['lookup-manager', 'send-approval', 'wait-response', 'update-record'],
-        //   table: 'x_company_equipment',
-        // });
-    }
-}
-exports.SnowFlowWorkflowExamples = SnowFlowWorkflowExamples;
-//# sourceMappingURL=snow-flow-memory-patterns.js.map

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

@@ -1,54 +0,0 @@
-import { MemoryEntry } from '../types/snow-flow.types.js';
-export interface SnowMemoryOptions {
-    namespace?: string;
-    dbPath?: string;
-    enableCompression?: boolean;
-    maxEntries?: number;
-    cleanupInterval?: number;
-}
-export interface StoreOptions {
-    namespace?: string;
-    ttl?: number;
-    metadata?: Record<string, any>;
-}
-export interface SearchOptions {
-    namespace?: string;
-    pattern?: string;
-    limit?: number;
-    offset?: number;
-    orderBy?: 'created' | 'updated' | 'accessed';
-    order?: 'asc' | 'desc';
-}
-export declare class SnowMemory {
-    private db;
-    private namespace;
-    private dbPath;
-    private cleanupTimer?;
-    private options;
-    constructor(options?: SnowMemoryOptions);
-    initialize(): Promise<void>;
-    store(key: string, value: any, options?: StoreOptions): Promise<void>;
-    retrieve(key: string, namespace?: string): Promise<any>;
-    delete(key: string, namespace?: string): Promise<void>;
-    search(options?: SearchOptions): Promise<MemoryEntry[]>;
-    list(namespace?: string): Promise<string[]>;
-    exists(key: string, namespace?: string): Promise<boolean>;
-    clear(namespace?: string): Promise<void>;
-    cleanup(): Promise<number>;
-    enforceMaxEntries(): Promise<void>;
-    getStats(): Promise<{
-        totalEntries: number;
-        namespaces: string[];
-        totalSize: number;
-        oldestEntry: Date | null;
-        newestEntry: Date | null;
-        mostAccessed: {
-            key: string;
-            count: number;
-        } | null;
-    }>;
-    export(filePath: string, namespace?: string): Promise<void>;
-    import(filePath: string): Promise<number>;
-    close(): Promise<void>;
-}
-//# sourceMappingURL=snow-memory.d.ts.map