snow-flow 2.0.4 → 2.0.6

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

@@ -0,0 +1,213 @@
+/**
+ * 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

@@ -0,0 +1,200 @@
+"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

@@ -0,0 +1,54 @@
+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