swarmdo 1.4.8 → 1.5.0

package/v3/@swarmdo/testing/dist/fixtures/memory-entries.d.ts

@@ -1,159 +0,0 @@
-/**
- * V3 Swarmdo Memory Entry Fixtures
- *
- * Test data for memory and AgentDB testing
- * Following London School principle of explicit test data
- */
-/**
- * Memory entry interface
- */
-export interface MemoryEntry {
-    key: string;
-    value: unknown;
-    metadata: MemoryMetadata;
-    embedding?: number[];
-    createdAt: Date;
-    updatedAt: Date;
-    expiresAt?: Date;
-}
-/**
- * Memory metadata interface
- */
-export interface MemoryMetadata {
-    type: 'short-term' | 'long-term' | 'semantic' | 'episodic';
-    tags: string[];
-    source?: string;
-    confidence?: number;
-    ttl?: number;
-}
-/**
- * Vector search query interface
- */
-export interface VectorQuery {
-    embedding: number[];
-    topK: number;
-    threshold?: number;
-    filters?: Record<string, unknown>;
-}
-/**
- * Search result interface
- */
-export interface SearchResult {
-    key: string;
-    value: unknown;
-    score: number;
-    metadata: MemoryMetadata;
-}
-/**
- * Pre-defined memory entries for testing
- */
-export declare const memoryEntries: Record<string, MemoryEntry>;
-/**
- * Pre-defined search results for testing
- */
-export declare const searchResults: Record<string, SearchResult[]>;
-/**
- * Generate mock embedding vector
- * Creates deterministic embeddings based on seed string
- */
-export declare function generateMockEmbedding(dimensions: number, seed: string): number[];
-/**
- * Factory function to create memory entry with overrides
- */
-export declare function createMemoryEntry(base: keyof typeof memoryEntries, overrides?: Partial<MemoryEntry>): MemoryEntry;
-/**
- * Factory function to create vector query
- */
-export declare function createVectorQuery(overrides?: Partial<VectorQuery>): VectorQuery;
-/**
- * Create batch of memory entries for performance testing
- */
-export declare function createMemoryBatch(count: number, type?: MemoryMetadata['type']): MemoryEntry[];
-/**
- * Invalid memory entries for error testing
- */
-export declare const invalidMemoryEntries: {
-    emptyKey: {
-        key: string;
-        value: {
-            data: string;
-        };
-        metadata: {
-            type: "short-term";
-            tags: never[];
-        };
-        createdAt: Date;
-        updatedAt: Date;
-    };
-    nullValue: {
-        key: string;
-        value: null;
-        metadata: {
-            type: "short-term";
-            tags: never[];
-        };
-        createdAt: Date;
-        updatedAt: Date;
-    };
-    invalidEmbeddingDimension: {
-        key: string;
-        value: {
-            data: string;
-        };
-        metadata: {
-            type: "semantic";
-            tags: never[];
-        };
-        embedding: number[];
-        createdAt: Date;
-        updatedAt: Date;
-    };
-    expiredEntry: {
-        key: string;
-        value: {
-            data: string;
-        };
-        metadata: {
-            type: "short-term";
-            tags: never[];
-            ttl: number;
-        };
-        createdAt: Date;
-        updatedAt: Date;
-        expiresAt: Date;
-    };
-};
-/**
- * AgentDB specific test data
- */
-export declare const agentDBTestData: {
-    hnswConfig: {
-        M: number;
-        efConstruction: number;
-        efSearch: number;
-        dimensions: number;
-    };
-    performanceTargets: {
-        searchSpeedupMin: number;
-        searchSpeedupMax: number;
-        memoryReduction: number;
-        insertionTime: number;
-        searchTime: number;
-    };
-    quantizationConfigs: {
-        scalar4bit: {
-            bits: number;
-            compressionRatio: number;
-        };
-        scalar8bit: {
-            bits: number;
-            compressionRatio: number;
-        };
-        product: {
-            subvectors: number;
-            bits: number;
-            compressionRatio: number;
-        };
-    };
-};
-//# sourceMappingURL=memory-entries.d.ts.map

package/v3/@swarmdo/testing/dist/fixtures/memory-entries.js

@@ -1,262 +0,0 @@
-/**
- * V3 Swarmdo Memory Entry Fixtures
- *
- * Test data for memory and AgentDB testing
- * Following London School principle of explicit test data
- */
-/**
- * Pre-defined memory entries for testing
- */
-export const memoryEntries = {
-    agentPattern: {
-        key: 'pattern:agent:queen-coordinator',
-        value: {
-            pattern: 'orchestration',
-            successRate: 0.95,
-            avgDuration: 150,
-        },
-        metadata: {
-            type: 'semantic',
-            tags: ['agent', 'pattern', 'queen'],
-            source: 'learning-module',
-            confidence: 0.92,
-        },
-        embedding: generateMockEmbedding(384, 'orchestration'),
-        createdAt: new Date('2024-01-01T00:00:00Z'),
-        updatedAt: new Date('2024-01-15T12:00:00Z'),
-    },
-    securityRule: {
-        key: 'rule:security:path-traversal',
-        value: {
-            rule: 'block-path-traversal',
-            patterns: ['../', '~/', '/etc/'],
-            severity: 'critical',
-        },
-        metadata: {
-            type: 'long-term',
-            tags: ['security', 'rule', 'validation'],
-            source: 'security-module',
-            confidence: 1.0,
-        },
-        embedding: generateMockEmbedding(384, 'security'),
-        createdAt: new Date('2024-01-01T00:00:00Z'),
-        updatedAt: new Date('2024-01-01T00:00:00Z'),
-    },
-    taskMemory: {
-        key: 'task:memory:impl-001',
-        value: {
-            taskId: 'impl-001',
-            context: 'implementing security module',
-            decisions: ['use argon2 for hashing', 'implement path validation'],
-        },
-        metadata: {
-            type: 'episodic',
-            tags: ['task', 'implementation', 'security'],
-            ttl: 86400000, // 24 hours
-        },
-        embedding: generateMockEmbedding(384, 'implementation'),
-        createdAt: new Date('2024-01-15T10:00:00Z'),
-        updatedAt: new Date('2024-01-15T10:00:00Z'),
-        expiresAt: new Date('2024-01-16T10:00:00Z'),
-    },
-    sessionContext: {
-        key: 'session:context:session-001',
-        value: {
-            sessionId: 'session-001',
-            user: 'developer',
-            activeAgents: ['queen-coordinator', 'coder'],
-            currentTask: 'security-implementation',
-        },
-        metadata: {
-            type: 'short-term',
-            tags: ['session', 'context'],
-            ttl: 3600000, // 1 hour
-        },
-        createdAt: new Date('2024-01-15T14:00:00Z'),
-        updatedAt: new Date('2024-01-15T14:30:00Z'),
-        expiresAt: new Date('2024-01-15T15:30:00Z'),
-    },
-    learningTrajectory: {
-        key: 'learning:trajectory:traj-001',
-        value: {
-            trajectoryId: 'traj-001',
-            steps: [
-                { action: 'analyze', result: 'success', reward: 0.8 },
-                { action: 'implement', result: 'success', reward: 0.9 },
-                { action: 'test', result: 'success', reward: 1.0 },
-            ],
-            totalReward: 2.7,
-        },
-        metadata: {
-            type: 'long-term',
-            tags: ['learning', 'trajectory', 'reinforcement'],
-            source: 'reasoningbank',
-            confidence: 0.88,
-        },
-        embedding: generateMockEmbedding(384, 'learning'),
-        createdAt: new Date('2024-01-10T00:00:00Z'),
-        updatedAt: new Date('2024-01-15T00:00:00Z'),
-    },
-};
-/**
- * Pre-defined search results for testing
- */
-export const searchResults = {
-    securityPatterns: [
-        {
-            key: 'pattern:security:input-validation',
-            value: { pattern: 'validate all inputs', effectiveness: 0.99 },
-            score: 0.95,
-            metadata: { type: 'semantic', tags: ['security', 'pattern'] },
-        },
-        {
-            key: 'pattern:security:output-encoding',
-            value: { pattern: 'encode all outputs', effectiveness: 0.97 },
-            score: 0.88,
-            metadata: { type: 'semantic', tags: ['security', 'pattern'] },
-        },
-        {
-            key: 'pattern:security:least-privilege',
-            value: { pattern: 'minimal permissions', effectiveness: 0.95 },
-            score: 0.82,
-            metadata: { type: 'semantic', tags: ['security', 'pattern'] },
-        },
-    ],
-    agentPatterns: [
-        {
-            key: 'pattern:agent:coordination',
-            value: { pattern: 'hierarchical coordination', successRate: 0.92 },
-            score: 0.91,
-            metadata: { type: 'semantic', tags: ['agent', 'pattern'] },
-        },
-        {
-            key: 'pattern:agent:communication',
-            value: { pattern: 'async messaging', successRate: 0.89 },
-            score: 0.85,
-            metadata: { type: 'semantic', tags: ['agent', 'pattern'] },
-        },
-    ],
-    emptyResults: [],
-};
-/**
- * Generate mock embedding vector
- * Creates deterministic embeddings based on seed string
- */
-export function generateMockEmbedding(dimensions, seed) {
-    const seedHash = hashString(seed);
-    return Array.from({ length: dimensions }, (_, i) => {
-        const value = Math.sin(seedHash + i * 0.1) * 0.5 + 0.5;
-        return Math.round(value * 10000) / 10000; // 4 decimal places
-    });
-}
-/**
- * Simple string hash function for deterministic embeddings
- */
-function hashString(str) {
-    let hash = 0;
-    for (let i = 0; i < str.length; i++) {
-        hash = ((hash << 5) - hash + str.charCodeAt(i)) | 0;
-    }
-    return hash;
-}
-/**
- * Factory function to create memory entry with overrides
- */
-export function createMemoryEntry(base, overrides) {
-    return {
-        ...memoryEntries[base],
-        ...overrides,
-        key: overrides?.key ?? memoryEntries[base].key,
-        createdAt: overrides?.createdAt ?? new Date(),
-        updatedAt: overrides?.updatedAt ?? new Date(),
-    };
-}
-/**
- * Factory function to create vector query
- */
-export function createVectorQuery(overrides) {
-    return {
-        embedding: overrides?.embedding ?? generateMockEmbedding(384, 'query'),
-        topK: overrides?.topK ?? 10,
-        threshold: overrides?.threshold ?? 0.7,
-        filters: overrides?.filters,
-    };
-}
-/**
- * Create batch of memory entries for performance testing
- */
-export function createMemoryBatch(count, type = 'semantic') {
-    return Array.from({ length: count }, (_, i) => ({
-        key: `batch:entry:${i}`,
-        value: { index: i, data: `test data ${i}` },
-        metadata: {
-            type,
-            tags: [`batch`, `entry-${i}`],
-        },
-        embedding: generateMockEmbedding(384, `batch-${i}`),
-        createdAt: new Date(),
-        updatedAt: new Date(),
-    }));
-}
-/**
- * Invalid memory entries for error testing
- */
-export const invalidMemoryEntries = {
-    emptyKey: {
-        key: '',
-        value: { data: 'test' },
-        metadata: { type: 'short-term', tags: [] },
-        createdAt: new Date(),
-        updatedAt: new Date(),
-    },
-    nullValue: {
-        key: 'valid-key',
-        value: null,
-        metadata: { type: 'short-term', tags: [] },
-        createdAt: new Date(),
-        updatedAt: new Date(),
-    },
-    invalidEmbeddingDimension: {
-        key: 'valid-key',
-        value: { data: 'test' },
-        metadata: { type: 'semantic', tags: [] },
-        embedding: [0.1, 0.2], // Wrong dimension
-        createdAt: new Date(),
-        updatedAt: new Date(),
-    },
-    expiredEntry: {
-        key: 'expired-key',
-        value: { data: 'expired' },
-        metadata: { type: 'short-term', tags: [], ttl: -1000 },
-        createdAt: new Date('2024-01-01T00:00:00Z'),
-        updatedAt: new Date('2024-01-01T00:00:00Z'),
-        expiresAt: new Date('2024-01-01T00:01:00Z'),
-    },
-};
-/**
- * AgentDB specific test data
- */
-export const agentDBTestData = {
-    // HNSW index configuration
-    hnswConfig: {
-        M: 16,
-        efConstruction: 200,
-        efSearch: 50,
-        dimensions: 384,
-    },
-    // Expected performance metrics
-    performanceTargets: {
-        searchSpeedupMin: 150,
-        searchSpeedupMax: 12500,
-        memoryReduction: 0.50,
-        insertionTime: 1, // ms
-        searchTime: 0.1, // ms for 1M vectors
-    },
-    // Quantization configurations
-    quantizationConfigs: {
-        scalar4bit: { bits: 4, compressionRatio: 8 },
-        scalar8bit: { bits: 8, compressionRatio: 4 },
-        product: { subvectors: 8, bits: 8, compressionRatio: 32 },
-    },
-};
-//# sourceMappingURL=memory-entries.js.map

package/v3/@swarmdo/testing/dist/fixtures/memory-fixtures.d.ts

@@ -1,290 +0,0 @@
-/**
- * @swarmdo/testing - Memory Fixtures
- *
- * Comprehensive mock memory entries and backend configurations for testing.
- * Supports AgentDB, HNSW indexing, vector search, and ReasoningBank patterns.
- *
- * Based on ADR-006 (Unified Memory Service) and ADR-009 (Hybrid Memory Backend).
- */
-import { type Mock } from 'vitest';
-/**
- * Memory entry types
- */
-export type MemoryType = 'short-term' | 'long-term' | 'semantic' | 'episodic' | 'procedural';
-/**
- * Memory backend types
- */
-export type MemoryBackendType = 'sqlite' | 'agentdb' | 'hybrid' | 'redis' | 'memory';
-/**
- * Memory entry interface
- */
-export interface MemoryEntry {
-    key: string;
-    value: unknown;
-    metadata: MemoryMetadata;
-    embedding?: number[];
-    createdAt: Date;
-    updatedAt: Date;
-    expiresAt?: Date;
-    accessCount?: number;
-}
-/**
- * Memory metadata interface
- */
-export interface MemoryMetadata {
-    type: MemoryType;
-    tags: string[];
-    source?: string;
-    confidence?: number;
-    ttl?: number;
-    agentId?: string;
-    sessionId?: string;
-}
-/**
- * Vector query interface
- */
-export interface VectorQuery {
-    embedding: number[];
-    topK: number;
-    threshold?: number;
-    filters?: Record<string, unknown>;
-    includeMetadata?: boolean;
-    rerank?: boolean;
-}
-/**
- * Search result interface
- */
-export interface SearchResult {
-    key: string;
-    value: unknown;
-    score: number;
-    metadata: MemoryMetadata;
-    distance?: number;
-}
-/**
- * HNSW index configuration
- */
-export interface HNSWConfig {
-    M: number;
-    efConstruction: number;
-    efSearch: number;
-    dimensions: number;
-    metric: 'cosine' | 'euclidean' | 'dot';
-}
-/**
- * Quantization configuration
- */
-export interface QuantizationConfig {
-    enabled: boolean;
-    bits: 4 | 8 | 16;
-    type: 'scalar' | 'product';
-    compressionRatio?: number;
-}
-/**
- * Memory backend configuration
- */
-export interface MemoryBackendConfig {
-    type: MemoryBackendType;
-    path?: string;
-    maxSize?: number;
-    ttlMs?: number;
-    vectorDimensions?: number;
-    hnswConfig?: HNSWConfig;
-    quantization?: QuantizationConfig;
-    caching?: {
-        enabled: boolean;
-        maxSize: number;
-        ttl: number;
-        strategy: 'lru' | 'lfu' | 'arc';
-    };
-}
-/**
- * Learned pattern interface (for ReasoningBank)
- */
-export interface LearnedPattern {
-    id: string;
-    sessionId: string;
-    task: string;
-    input: string;
-    output: string;
-    reward: number;
-    success: boolean;
-    critique?: string;
-    tokensUsed?: number;
-    latencyMs?: number;
-    createdAt: Date;
-    embedding?: number[];
-}
-/**
- * Generate deterministic mock embedding vector
- */
-export declare function generateMockEmbedding(dimensions: number, seed: string): number[];
-/**
- * Pre-defined memory entries for testing
- */
-export declare const memoryEntries: Record<string, MemoryEntry>;
-/**
- * Pre-defined search results for testing
- */
-export declare const searchResults: Record<string, SearchResult[]>;
-/**
- * Pre-defined learned patterns for ReasoningBank testing
- */
-export declare const learnedPatterns: Record<string, LearnedPattern>;
-/**
- * Pre-defined HNSW configurations
- */
-export declare const hnswConfigs: Record<string, HNSWConfig>;
-/**
- * Pre-defined quantization configurations
- */
-export declare const quantizationConfigs: Record<string, QuantizationConfig>;
-/**
- * Pre-defined memory backend configurations
- */
-export declare const memoryBackendConfigs: Record<string, MemoryBackendConfig>;
-/**
- * Performance targets from V3 specifications
- */
-export declare const performanceTargets: {
-    searchSpeedupMin: number;
-    searchSpeedupMax: number;
-    memoryReduction: number;
-    insertionTime: number;
-    searchTime: number;
-    flashAttentionSpeedup: number[];
-};
-/**
- * Factory function to create memory entry with overrides
- */
-export declare function createMemoryEntry(base: keyof typeof memoryEntries, overrides?: Partial<MemoryEntry>): MemoryEntry;
-/**
- * Factory function to create vector query
- */
-export declare function createVectorQuery(overrides?: Partial<VectorQuery>): VectorQuery;
-/**
- * Factory function to create learned pattern
- */
-export declare function createLearnedPattern(base: keyof typeof learnedPatterns, overrides?: Partial<LearnedPattern>): LearnedPattern;
-/**
- * Factory function to create HNSW config
- */
-export declare function createHNSWConfig(base?: keyof typeof hnswConfigs, overrides?: Partial<HNSWConfig>): HNSWConfig;
-/**
- * Factory function to create memory backend config
- */
-export declare function createMemoryBackendConfig(base?: keyof typeof memoryBackendConfigs, overrides?: Partial<MemoryBackendConfig>): MemoryBackendConfig;
-/**
- * Create batch of memory entries for performance testing
- */
-export declare function createMemoryBatch(count: number, type?: MemoryType, dimensions?: number): MemoryEntry[];
-/**
- * Create embeddings batch for vector index testing
- */
-export declare function createEmbeddingsBatch(count: number, dimensions?: number): {
-    id: string;
-    embedding: number[];
-}[];
-/**
- * Invalid memory entries for error testing
- */
-export declare const invalidMemoryEntries: {
-    emptyKey: {
-        key: string;
-        value: {
-            data: string;
-        };
-        metadata: {
-            type: "short-term";
-            tags: never[];
-        };
-        createdAt: Date;
-        updatedAt: Date;
-    };
-    nullValue: {
-        key: string;
-        value: null;
-        metadata: {
-            type: "short-term";
-            tags: never[];
-        };
-        createdAt: Date;
-        updatedAt: Date;
-    };
-    invalidEmbeddingDimension: {
-        key: string;
-        value: {
-            data: string;
-        };
-        metadata: {
-            type: "semantic";
-            tags: never[];
-        };
-        embedding: number[];
-        createdAt: Date;
-        updatedAt: Date;
-    };
-    expiredEntry: {
-        key: string;
-        value: {
-            data: string;
-        };
-        metadata: {
-            type: "short-term";
-            tags: never[];
-            ttl: number;
-        };
-        createdAt: Date;
-        updatedAt: Date;
-        expiresAt: Date;
-    };
-    invalidTags: {
-        key: string;
-        value: {
-            data: string;
-        };
-        metadata: {
-            type: "short-term";
-            tags: string[];
-        };
-        createdAt: Date;
-        updatedAt: Date;
-    };
-};
-/**
- * Mock memory service interface
- */
-export interface MockMemoryService {
-    store: Mock<(key: string, value: unknown, metadata?: MemoryMetadata) => Promise<void>>;
-    retrieve: Mock<(key: string) => Promise<unknown>>;
-    search: Mock<(query: VectorQuery) => Promise<SearchResult[]>>;
-    delete: Mock<(key: string) => Promise<void>>;
-    clear: Mock<() => Promise<void>>;
-    getStats: Mock<() => Promise<{
-        totalEntries: number;
-        sizeBytes: number;
-    }>>;
-}
-/**
- * Create a mock memory service
- */
-export declare function createMockMemoryService(): MockMemoryService;
-/**
- * Mock AgentDB interface
- */
-export interface MockAgentDB {
-    insert: Mock<(id: string, embedding: number[], metadata?: unknown) => Promise<void>>;
-    search: Mock<(embedding: number[], k: number) => Promise<SearchResult[]>>;
-    delete: Mock<(id: string) => Promise<void>>;
-    update: Mock<(id: string, embedding: number[], metadata?: unknown) => Promise<void>>;
-    getStats: Mock<() => Promise<{
-        vectorCount: number;
-        indexSize: number;
-    }>>;
-    rebuildIndex: Mock<() => Promise<void>>;
-}
-/**
- * Create a mock AgentDB instance
- */
-export declare function createMockAgentDB(): MockAgentDB;
-//# sourceMappingURL=memory-fixtures.d.ts.map