@weavelogic/knowledge-graph-agent 0.2.0 → 0.4.0

package/dist/vector/config.js

@@ -0,0 +1,124 @@
+const DEFAULT_HNSW_CONFIG = {
+  m: 16,
+  efConstruction: 200,
+  efSearch: 100
+};
+const DEFAULT_INDEX_CONFIG = {
+  dimensions: 1536,
+  distanceMetric: "cosine",
+  indexType: "hnsw",
+  hnswConfig: DEFAULT_HNSW_CONFIG
+};
+function createRuVectorConfig() {
+  const backend = process.env.RUVECTOR_BACKEND || "memory";
+  const dimensions = parseInt(process.env.RUVECTOR_DIMENSIONS || "384", 10);
+  const baseConfig = {
+    backend,
+    index: {
+      ...DEFAULT_INDEX_CONFIG,
+      dimensions
+    },
+    enableSona: process.env.RUVECTOR_ENABLE_SONA === "true",
+    enableTrajectoryTracking: process.env.RUVECTOR_ENABLE_TRAJECTORY === "true"
+  };
+  switch (backend) {
+    case "postgres":
+      return {
+        ...baseConfig,
+        postgres: {
+          connectionString: process.env.DATABASE_URL || "postgres://localhost:5432/kg_agent",
+          schema: process.env.RUVECTOR_SCHEMA || "ruvector"
+        }
+      };
+    case "cloud":
+      return {
+        ...baseConfig,
+        cloud: {
+          url: process.env.RUVECTOR_CLOUD_URL || "",
+          apiKey: process.env.RUVECTOR_API_KEY
+        }
+      };
+    case "standalone":
+      return {
+        ...baseConfig,
+        standalone: {
+          dataDir: process.env.RUVECTOR_DATA_DIR || ".ruvector"
+        }
+      };
+    default:
+      return baseConfig;
+  }
+}
+function validateRuVectorConfig(config) {
+  const errors = [];
+  const warnings = [];
+  if (config.index.dimensions < 1) {
+    errors.push("Dimensions must be at least 1");
+  }
+  if (config.index.dimensions > 4096) {
+    warnings.push("Dimensions > 4096 may impact performance");
+  }
+  if (!Number.isInteger(config.index.dimensions)) {
+    errors.push("Vector dimensions must be an integer");
+  }
+  if (config.backend === "postgres" && !config.postgres?.connectionString) {
+    errors.push("PostgreSQL connection string required for postgres backend");
+  }
+  if (config.backend === "cloud" && !config.cloud?.url) {
+    errors.push("Cloud URL required for cloud backend");
+  }
+  if (config.backend === "standalone" && !config.standalone?.dataDir) {
+    errors.push("Data directory required for standalone backend");
+  }
+  if (config.index.indexType === "hnsw" && config.index.hnswConfig) {
+    const { m, efConstruction, efSearch } = config.index.hnswConfig;
+    if (m < 2 || m > 100) {
+      errors.push("HNSW m must be between 2 and 100");
+    }
+    if (efConstruction < m) {
+      warnings.push("efConstruction should be >= m for good index quality");
+    }
+    if (efSearch < 10) {
+      warnings.push("efSearch < 10 may result in poor recall");
+    }
+  }
+  if (config.cache?.enabled) {
+    if (config.cache.maxSize < 1) {
+      errors.push("Cache maxSize must be at least 1");
+    }
+    if (config.cache.ttlSeconds < 1) {
+      errors.push("Cache TTL must be at least 1 second");
+    }
+  }
+  if (config.performance) {
+    if (config.performance.batchSize < 1) {
+      errors.push("Batch size must be at least 1");
+    }
+    if (config.performance.maxConcurrency < 1) {
+      errors.push("Max concurrency must be at least 1");
+    }
+    if (config.performance.memoryLimitMb && config.performance.memoryLimitMb < 64) {
+      warnings.push("Memory limit < 64MB may cause issues");
+    }
+  }
+  if (config.hybrid?.enabled && !config.hybrid.graphConnection) {
+    warnings.push("Hybrid search enabled but no graph connection configured");
+  }
+  const validMetrics = ["cosine", "euclidean", "dotProduct", "manhattan"];
+  if (!validMetrics.includes(config.index.distanceMetric)) {
+    errors.push(`Invalid distance metric: ${config.index.distanceMetric}`);
+  }
+  const validIndexTypes = ["hnsw", "flat", "ivf", "pq"];
+  if (!validIndexTypes.includes(config.index.indexType)) {
+    errors.push(`Invalid index type: ${config.index.indexType}`);
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+createRuVectorConfig();
+export {
+  DEFAULT_HNSW_CONFIG,
+  DEFAULT_INDEX_CONFIG,
+  createRuVectorConfig,
+  validateRuVectorConfig
+};
+//# sourceMappingURL=config.js.map

package/dist/vector/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sources":["../../src/vector/config.ts"],"sourcesContent":["/**\n * Vector Configuration\n *\n * Configuration types and defaults for RuVector-compatible vector storage.\n * Supports multiple backends (memory, postgres, standalone) with HNSW indexing.\n *\n * @module vector/config\n */\n\nimport type { DistanceMetric, IndexType, VectorIndexConfig } from './types.js';\n\n/**\n * Backend storage type for vectors\n */\nexport type VectorBackend = 'memory' | 'postgres' | 'standalone' | 'sqlite' | 'cloud';\n\n/**\n * HNSW (Hierarchical Navigable Small World) index configuration\n *\n * HNSW provides fast approximate nearest neighbor search with\n * configurable accuracy/speed tradeoffs.\n */\nexport interface HNSWConfig {\n  /**\n   * Maximum number of connections per layer\n   * Higher values improve recall but increase memory usage\n   * @default 16\n   */\n  m: number;\n\n  /**\n   * Size of dynamic candidate list for construction\n   * Higher values improve index quality but slow down construction\n   * @default 200\n   */\n  efConstruction: number;\n\n  /**\n   * Size of dynamic candidate list for search\n   * Higher values improve recall but slow down search\n   * @default 100\n   */\n  efSearch: number;\n}\n\n/**\n * Re-export VectorIndexConfig from types for convenience\n */\nexport type { VectorIndexConfig } from './types.js';\n\n/**\n * PostgreSQL backend configuration\n */\nexport interface PostgresBackendConfig {\n  /**\n   * PostgreSQL connection string\n   * @example 'postgres://user:pass@localhost:5432/dbname'\n   */\n  connectionString: string;\n\n  /**\n   * Database schema for vector tables\n   * @default 'ruvector'\n   */\n  schema: string;\n}\n\n/**\n * Cloud backend configuration\n */\nexport interface CloudBackendConfig {\n  /**\n   * Cloud vector database endpoint URL\n   */\n  url: string;\n\n  /**\n   * API key for authentication\n   */\n  apiKey?: string;\n}\n\n/**\n * Standalone backend configuration\n */\nexport interface StandaloneBackendConfig {\n  /**\n   * Directory for vector data storage\n   * @default '.ruvector'\n   */\n  dataDir: string;\n}\n\n/**\n * RuVector configuration\n *\n * Main configuration interface for the vector database system.\n */\nexport interface RuVectorConfig {\n  /**\n   * Storage backend type\n   */\n  backend: VectorBackend;\n\n  /**\n   * Vector index configuration\n   */\n  index: VectorIndexConfig;\n\n  /**\n   * PostgreSQL connection configuration\n   * Required when backend is 'postgres'\n   */\n  postgres?: PostgresBackendConfig;\n\n  /**\n   * Cloud endpoint configuration\n   * Required when backend is 'cloud'\n   */\n  cloud?: CloudBackendConfig;\n\n  /**\n   * Standalone file path configuration\n   * Required when backend is 'standalone'\n   */\n  standalone?: StandaloneBackendConfig;\n\n  /**\n   * Enable self-learning SONA (Self-Optimizing Neural Architecture) engine\n   * When enabled, the system learns from agent trajectories to improve performance\n   * @default false\n   */\n  enableSona?: boolean;\n\n  /**\n   * Enable trajectory tracking for agents\n   * Records agent actions for analysis and learning\n   * @default false\n   */\n  enableTrajectoryTracking?: boolean;\n\n  /**\n   * Cache configuration\n   */\n  cache?: {\n    /** Enable result caching */\n    enabled: boolean;\n    /** Maximum cache size in entries */\n    maxSize: number;\n    /** Cache TTL in seconds */\n    ttlSeconds: number;\n  };\n\n  /**\n   * Performance tuning\n   */\n  performance?: {\n    /** Batch size for bulk operations */\n    batchSize: number;\n    /** Enable parallel processing */\n    parallelProcessing: boolean;\n    /** Maximum concurrent operations */\n    maxConcurrency: number;\n    /** Memory limit in MB for index */\n    memoryLimitMb?: number;\n  };\n\n  /**\n   * Hybrid search configuration\n   */\n  hybrid?: {\n    /** Enable hybrid search */\n    enabled: boolean;\n    /** Default vector weight (0-1) */\n    defaultVectorWeight: number;\n    /** Graph database connection (for Cypher queries) */\n    graphConnection?: {\n      type: 'neo4j' | 'memgraph' | 'sqlite';\n      uri?: string;\n      database?: string;\n      auth?: {\n        user: string;\n        password: string;\n      };\n    };\n  };\n\n  /**\n   * Namespace configuration for multi-tenant support\n   */\n  namespace?: {\n    /** Default namespace */\n    defaultNamespace: string;\n    /** Namespace isolation level */\n    isolation: 'soft' | 'hard';\n  };\n}\n\n/**\n * Default HNSW configuration\n * Balanced settings for most use cases\n */\nexport const DEFAULT_HNSW_CONFIG: HNSWConfig = {\n  m: 16,\n  efConstruction: 200,\n  efSearch: 100,\n};\n\n/**\n * Default vector index configuration\n * Optimized for OpenAI/Claude embeddings (1536 dimensions)\n */\nexport const DEFAULT_INDEX_CONFIG: VectorIndexConfig = {\n  dimensions: 1536,\n  distanceMetric: 'cosine',\n  indexType: 'hnsw',\n  hnswConfig: DEFAULT_HNSW_CONFIG,\n};\n\n/**\n * Default cache configuration\n */\nexport const DEFAULT_CACHE_CONFIG = {\n  enabled: true,\n  maxSize: 1000,\n  ttlSeconds: 300, // 5 minutes\n} as const;\n\n/**\n * Default performance configuration\n */\nexport const DEFAULT_PERFORMANCE_CONFIG = {\n  batchSize: 100,\n  parallelProcessing: true,\n  maxConcurrency: 4,\n} as const;\n\n/**\n * Create RuVector configuration from environment variables\n *\n * Reads configuration from the following environment variables:\n * - RUVECTOR_BACKEND: Storage backend type (default: 'memory')\n * - RUVECTOR_DIMENSIONS: Vector dimensions (default: 384)\n * - RUVECTOR_ENABLE_SONA: Enable SONA learning (default: false)\n * - RUVECTOR_ENABLE_TRAJECTORY: Enable trajectory tracking (default: false)\n * - DATABASE_URL: PostgreSQL connection string (for postgres backend)\n * - RUVECTOR_SCHEMA: PostgreSQL schema (default: 'ruvector')\n * - RUVECTOR_CLOUD_URL: Cloud endpoint URL (for cloud backend)\n * - RUVECTOR_API_KEY: Cloud API key (for cloud backend)\n * - RUVECTOR_DATA_DIR: Data directory (for standalone backend)\n *\n * @returns RuVectorConfig configured from environment\n *\n * @example\n * ```typescript\n * // Set environment variables\n * process.env.RUVECTOR_BACKEND = 'postgres';\n * process.env.DATABASE_URL = 'postgres://localhost:5432/mydb';\n *\n * // Create configuration\n * const config = createRuVectorConfig();\n * ```\n */\nexport function createRuVectorConfig(): RuVectorConfig {\n  const backend = (process.env.RUVECTOR_BACKEND || 'memory') as VectorBackend;\n  const dimensions = parseInt(process.env.RUVECTOR_DIMENSIONS || '384', 10);\n\n  const baseConfig: RuVectorConfig = {\n    backend,\n    index: {\n      ...DEFAULT_INDEX_CONFIG,\n      dimensions,\n    },\n    enableSona: process.env.RUVECTOR_ENABLE_SONA === 'true',\n    enableTrajectoryTracking: process.env.RUVECTOR_ENABLE_TRAJECTORY === 'true',\n  };\n\n  switch (backend) {\n    case 'postgres':\n      return {\n        ...baseConfig,\n        postgres: {\n          connectionString:\n            process.env.DATABASE_URL || 'postgres://localhost:5432/kg_agent',\n          schema: process.env.RUVECTOR_SCHEMA || 'ruvector',\n        },\n      };\n    case 'cloud':\n      return {\n        ...baseConfig,\n        cloud: {\n          url: process.env.RUVECTOR_CLOUD_URL || '',\n          apiKey: process.env.RUVECTOR_API_KEY,\n        },\n      };\n    case 'standalone':\n      return {\n        ...baseConfig,\n        standalone: {\n          dataDir: process.env.RUVECTOR_DATA_DIR || '.ruvector',\n        },\n      };\n    default:\n      return baseConfig;\n  }\n}\n\n/**\n * Validation result for RuVector configuration\n */\nexport interface ConfigValidationResult {\n  /**\n   * Whether the configuration is valid\n   */\n  valid: boolean;\n\n  /**\n   * List of validation errors (empty if valid)\n   */\n  errors: string[];\n\n  /**\n   * List of validation warnings\n   */\n  warnings: string[];\n}\n\n/**\n * Legacy alias for backwards compatibility\n */\nexport type ValidationResult = ConfigValidationResult;\n\n/**\n * Validate RuVector configuration\n *\n * Checks that all required fields are present and valid based on\n * the selected backend type.\n *\n * @param config - Configuration to validate\n * @returns Validation result with errors if invalid\n *\n * @example\n * ```typescript\n * const config = createRuVectorConfig();\n * const result = validateRuVectorConfig(config);\n *\n * if (!result.valid) {\n *   console.error('Configuration errors:', result.errors);\n *   process.exit(1);\n * }\n * ```\n */\nexport function validateRuVectorConfig(config: RuVectorConfig): ConfigValidationResult {\n  const errors: string[] = [];\n  const warnings: string[] = [];\n\n  // Validate dimensions\n  if (config.index.dimensions < 1) {\n    errors.push('Dimensions must be at least 1');\n  }\n  if (config.index.dimensions > 4096) {\n    warnings.push('Dimensions > 4096 may impact performance');\n  }\n\n  if (!Number.isInteger(config.index.dimensions)) {\n    errors.push('Vector dimensions must be an integer');\n  }\n\n  // Validate backend-specific configuration\n  if (config.backend === 'postgres' && !config.postgres?.connectionString) {\n    errors.push('PostgreSQL connection string required for postgres backend');\n  }\n\n  if (config.backend === 'cloud' && !config.cloud?.url) {\n    errors.push('Cloud URL required for cloud backend');\n  }\n\n  if (config.backend === 'standalone' && !config.standalone?.dataDir) {\n    errors.push('Data directory required for standalone backend');\n  }\n\n  // Validate HNSW configuration\n  if (config.index.indexType === 'hnsw' && config.index.hnswConfig) {\n    const { m, efConstruction, efSearch } = config.index.hnswConfig;\n\n    if (m < 2 || m > 100) {\n      errors.push('HNSW m must be between 2 and 100');\n    }\n\n    if (efConstruction < m) {\n      warnings.push('efConstruction should be >= m for good index quality');\n    }\n\n    if (efSearch < 10) {\n      warnings.push('efSearch < 10 may result in poor recall');\n    }\n  }\n\n  // Validate cache config\n  if (config.cache?.enabled) {\n    if (config.cache.maxSize < 1) {\n      errors.push('Cache maxSize must be at least 1');\n    }\n    if (config.cache.ttlSeconds < 1) {\n      errors.push('Cache TTL must be at least 1 second');\n    }\n  }\n\n  // Validate performance config\n  if (config.performance) {\n    if (config.performance.batchSize < 1) {\n      errors.push('Batch size must be at least 1');\n    }\n    if (config.performance.maxConcurrency < 1) {\n      errors.push('Max concurrency must be at least 1');\n    }\n    if (config.performance.memoryLimitMb && config.performance.memoryLimitMb < 64) {\n      warnings.push('Memory limit < 64MB may cause issues');\n    }\n  }\n\n  // Validate hybrid config\n  if (config.hybrid?.enabled && !config.hybrid.graphConnection) {\n    warnings.push('Hybrid search enabled but no graph connection configured');\n  }\n\n  // Validate distance metric\n  const validMetrics: DistanceMetric[] = ['cosine', 'euclidean', 'dotProduct', 'manhattan'];\n  if (!validMetrics.includes(config.index.distanceMetric)) {\n    errors.push(`Invalid distance metric: ${config.index.distanceMetric}`);\n  }\n\n  // Validate index type\n  const validIndexTypes = ['hnsw', 'flat', 'ivf', 'pq'];\n  if (!validIndexTypes.includes(config.index.indexType)) {\n    errors.push(`Invalid index type: ${config.index.indexType}`);\n  }\n\n  return { valid: errors.length === 0, errors, warnings };\n}\n\n/**\n * Default configuration instance\n * Created from environment variables at module load time\n */\nexport const defaultConfig = createRuVectorConfig();\n\n/**\n * Create configuration for high-performance scenarios\n *\n * Optimized for large-scale deployments with many vectors\n */\nexport function createHighPerformanceConfig(\n  dimensions: number = 1536\n): RuVectorConfig {\n  return {\n    ...createRuVectorConfig(),\n    backend: 'memory',\n    index: {\n      dimensions,\n      indexType: 'hnsw',\n      distanceMetric: 'cosine',\n      hnswConfig: {\n        m: 32, // More connections for better recall\n        efConstruction: 400, // Higher quality index\n        efSearch: 200, // Better search accuracy\n      },\n    },\n    cache: {\n      enabled: true,\n      maxSize: 10000,\n      ttlSeconds: 600,\n    },\n    performance: {\n      batchSize: 500,\n      parallelProcessing: true,\n      maxConcurrency: 8,\n    },\n  };\n}\n\n/**\n * Create configuration for memory-constrained environments\n *\n * Optimized for minimal memory usage\n */\nexport function createLowMemoryConfig(\n  dimensions: number = 1536\n): RuVectorConfig {\n  return {\n    ...createRuVectorConfig(),\n    backend: 'memory',\n    index: {\n      dimensions,\n      indexType: 'hnsw',\n      distanceMetric: 'cosine',\n      hnswConfig: {\n        m: 8, // Fewer connections\n        efConstruction: 100, // Faster construction\n        efSearch: 50, // Faster search\n      },\n    },\n    cache: {\n      enabled: false,\n      maxSize: 100,\n      ttlSeconds: 60,\n    },\n    performance: {\n      batchSize: 50,\n      parallelProcessing: false,\n      maxConcurrency: 2,\n      memoryLimitMb: 256,\n    },\n  };\n}\n\n/**\n * Create configuration for hybrid search with graph integration\n */\nexport function createHybridSearchConfig(\n  dimensions: number = 1536,\n  graphType: 'neo4j' | 'memgraph' | 'sqlite' = 'sqlite'\n): RuVectorConfig {\n  return {\n    ...createRuVectorConfig(),\n    backend: 'memory',\n    index: {\n      dimensions,\n      indexType: 'hnsw',\n      distanceMetric: 'cosine',\n      hnswConfig: DEFAULT_HNSW_CONFIG,\n    },\n    hybrid: {\n      enabled: true,\n      defaultVectorWeight: 0.7,\n      graphConnection: {\n        type: graphType,\n      },\n    },\n  };\n}\n\n/**\n * Get recommended configuration based on vector count\n *\n * @param estimatedVectorCount - Estimated number of vectors to store\n * @param dimensions - Vector dimensions\n * @returns Recommended configuration\n */\nexport function getRecommendedConfig(\n  estimatedVectorCount: number,\n  dimensions: number = 1536\n): RuVectorConfig {\n  if (estimatedVectorCount < 1000) {\n    // Small scale - flat index is fine\n    return createLowMemoryConfig(dimensions);\n  } else if (estimatedVectorCount < 100000) {\n    // Medium scale - standard HNSW\n    return {\n      ...createRuVectorConfig(),\n      index: { ...DEFAULT_INDEX_CONFIG, dimensions },\n    };\n  } else {\n    // Large scale - optimized HNSW\n    return createHighPerformanceConfig(dimensions);\n  }\n}\n"],"names":[],"mappings":"AA0MO,MAAM,sBAAkC;AAAA,EAC7C,GAAG;AAAA,EACH,gBAAgB;AAAA,EAChB,UAAU;AACZ;AAMO,MAAM,uBAA0C;AAAA,EACrD,YAAY;AAAA,EACZ,gBAAgB;AAAA,EAChB,WAAW;AAAA,EACX,YAAY;AACd;AA8CO,SAAS,uBAAuC;AACrD,QAAM,UAAW,QAAQ,IAAI,oBAAoB;AACjD,QAAM,aAAa,SAAS,QAAQ,IAAI,uBAAuB,OAAO,EAAE;AAExE,QAAM,aAA6B;AAAA,IACjC;AAAA,IACA,OAAO;AAAA,MACL,GAAG;AAAA,MACH;AAAA,IAAA;AAAA,IAEF,YAAY,QAAQ,IAAI,yBAAyB;AAAA,IACjD,0BAA0B,QAAQ,IAAI,+BAA+B;AAAA,EAAA;AAGvE,UAAQ,SAAA;AAAA,IACN,KAAK;AACH,aAAO;AAAA,QACL,GAAG;AAAA,QACH,UAAU;AAAA,UACR,kBACE,QAAQ,IAAI,gBAAgB;AAAA,UAC9B,QAAQ,QAAQ,IAAI,mBAAmB;AAAA,QAAA;AAAA,MACzC;AAAA,IAEJ,KAAK;AACH,aAAO;AAAA,QACL,GAAG;AAAA,QACH,OAAO;AAAA,UACL,KAAK,QAAQ,IAAI,sBAAsB;AAAA,UACvC,QAAQ,QAAQ,IAAI;AAAA,QAAA;AAAA,MACtB;AAAA,IAEJ,KAAK;AACH,aAAO;AAAA,QACL,GAAG;AAAA,QACH,YAAY;AAAA,UACV,SAAS,QAAQ,IAAI,qBAAqB;AAAA,QAAA;AAAA,MAC5C;AAAA,IAEJ;AACE,aAAO;AAAA,EAAA;AAEb;AA+CO,SAAS,uBAAuB,QAAgD;AACrF,QAAM,SAAmB,CAAA;AACzB,QAAM,WAAqB,CAAA;AAG3B,MAAI,OAAO,MAAM,aAAa,GAAG;AAC/B,WAAO,KAAK,+BAA+B;AAAA,EAC7C;AACA,MAAI,OAAO,MAAM,aAAa,MAAM;AAClC,aAAS,KAAK,0CAA0C;AAAA,EAC1D;AAEA,MAAI,CAAC,OAAO,UAAU,OAAO,MAAM,UAAU,GAAG;AAC9C,WAAO,KAAK,sCAAsC;AAAA,EACpD;AAGA,MAAI,OAAO,YAAY,cAAc,CAAC,OAAO,UAAU,kBAAkB;AACvE,WAAO,KAAK,4DAA4D;AAAA,EAC1E;AAEA,MAAI,OAAO,YAAY,WAAW,CAAC,OAAO,OAAO,KAAK;AACpD,WAAO,KAAK,sCAAsC;AAAA,EACpD;AAEA,MAAI,OAAO,YAAY,gBAAgB,CAAC,OAAO,YAAY,SAAS;AAClE,WAAO,KAAK,gDAAgD;AAAA,EAC9D;AAGA,MAAI,OAAO,MAAM,cAAc,UAAU,OAAO,MAAM,YAAY;AAChE,UAAM,EAAE,GAAG,gBAAgB,SAAA,IAAa,OAAO,MAAM;AAErD,QAAI,IAAI,KAAK,IAAI,KAAK;AACpB,aAAO,KAAK,kCAAkC;AAAA,IAChD;AAEA,QAAI,iBAAiB,GAAG;AACtB,eAAS,KAAK,sDAAsD;AAAA,IACtE;AAEA,QAAI,WAAW,IAAI;AACjB,eAAS,KAAK,yCAAyC;AAAA,IACzD;AAAA,EACF;AAGA,MAAI,OAAO,OAAO,SAAS;AACzB,QAAI,OAAO,MAAM,UAAU,GAAG;AAC5B,aAAO,KAAK,kCAAkC;AAAA,IAChD;AACA,QAAI,OAAO,MAAM,aAAa,GAAG;AAC/B,aAAO,KAAK,qCAAqC;AAAA,IACnD;AAAA,EACF;AAGA,MAAI,OAAO,aAAa;AACtB,QAAI,OAAO,YAAY,YAAY,GAAG;AACpC,aAAO,KAAK,+BAA+B;AAAA,IAC7C;AACA,QAAI,OAAO,YAAY,iBAAiB,GAAG;AACzC,aAAO,KAAK,oCAAoC;AAAA,IAClD;AACA,QAAI,OAAO,YAAY,iBAAiB,OAAO,YAAY,gBAAgB,IAAI;AAC7E,eAAS,KAAK,sCAAsC;AAAA,IACtD;AAAA,EACF;AAGA,MAAI,OAAO,QAAQ,WAAW,CAAC,OAAO,OAAO,iBAAiB;AAC5D,aAAS,KAAK,0DAA0D;AAAA,EAC1E;AAGA,QAAM,eAAiC,CAAC,UAAU,aAAa,cAAc,WAAW;AACxF,MAAI,CAAC,aAAa,SAAS,OAAO,MAAM,cAAc,GAAG;AACvD,WAAO,KAAK,4BAA4B,OAAO,MAAM,cAAc,EAAE;AAAA,EACvE;AAGA,QAAM,kBAAkB,CAAC,QAAQ,QAAQ,OAAO,IAAI;AACpD,MAAI,CAAC,gBAAgB,SAAS,OAAO,MAAM,SAAS,GAAG;AACrD,WAAO,KAAK,uBAAuB,OAAO,MAAM,SAAS,EAAE;AAAA,EAC7D;AAEA,SAAO,EAAE,OAAO,OAAO,WAAW,GAAG,QAAQ,SAAA;AAC/C;AAM6B,qBAAA;"}

package/dist/vector/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Vector Module
+ *
+ * Exports all vector-related functionality for the knowledge-graph-agent.
+ * This module provides configuration, types, services, and utilities for working
+ * with vector embeddings, similarity search, and agent trajectory tracking.
+ *
+ * @module vector
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   createRuVectorConfig,
+ *   validateRuVectorConfig,
+ *   createVectorStore,
+ *   createTrajectoryTracker,
+ *   type VectorEntry,
+ *   type SearchResult,
+ *   type HybridSearchQuery,
+ * } from './vector/index.js';
+ *
+ * // Create and validate configuration
+ * const config = createRuVectorConfig();
+ * const validation = validateRuVectorConfig(config);
+ *
+ * if (!validation.valid) {
+ *   throw new Error(`Invalid config: ${validation.errors.join(', ')}`);
+ * }
+ *
+ * // Create a trajectory tracker for agent operations
+ * const tracker = createTrajectoryTracker({
+ *   maxTrajectories: 1000,
+ *   enableAutoLearning: true,
+ * });
+ *
+ * // Track agent operations
+ * const trajectoryId = tracker.startTrajectory('agent-1');
+ * tracker.addStep(trajectoryId, {
+ *   action: 'search',
+ *   state: { query: 'example' },
+ *   outcome: 'success',
+ *   duration: 100
+ * });
+ * tracker.finalizeTrajectory(trajectoryId, { success: true });
+ * ```
+ */
+export { createRuVectorConfig, createHighPerformanceConfig, createLowMemoryConfig, createHybridSearchConfig, validateRuVectorConfig, getRecommendedConfig, DEFAULT_HNSW_CONFIG, DEFAULT_INDEX_CONFIG, DEFAULT_CACHE_CONFIG, DEFAULT_PERFORMANCE_CONFIG, defaultConfig, type RuVectorConfig, type VectorBackend, type ConfigValidationResult, type ValidationResult, type HNSWConfig, type PostgresBackendConfig, type CloudBackendConfig, type StandaloneBackendConfig, } from './config.js';
+export type { DistanceMetric, IndexType, SearchSource, VectorEntry, SearchResult, HybridSearchQuery, HybridSearchResult, BatchInsertEntry, BatchInsertOperation, BatchInsertResult, VectorIndexStats, VectorSearchOptions, VectorIndexConfig, VectorStoreEvent, VectorStoreEventListener, IVectorStore, TrajectoryStep, AgentTrajectory, SonaLearningRecord, GraphNode, GraphEdge, CypherQueryResult, VectorUpdateOperation, VectorDeleteOperation, VectorDeleteResult, VectorNamespace, } from './types.js';
+export { EnhancedVectorStore, createVectorStore, TrajectoryTracker, createTrajectoryTracker, type TrajectoryTrackerConfig, type DetectedPattern, } from './services/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/vector/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/vector/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAGH,OAAO,EACL,oBAAoB,EACpB,2BAA2B,EAC3B,qBAAqB,EACrB,wBAAwB,EACxB,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,0BAA0B,EAC1B,aAAa,EACb,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACrB,KAAK,UAAU,EACf,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,uBAAuB,GAC7B,MAAM,aAAa,CAAC;AAGrB,YAAY,EACV,cAAc,EACd,SAAS,EACT,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,wBAAwB,EACxB,YAAY,EACZ,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,SAAS,EACT,SAAS,EACT,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,eAAe,GAChB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,uBAAuB,EACvB,KAAK,uBAAuB,EAC5B,KAAK,eAAe,GACrB,MAAM,qBAAqB,CAAC"}

package/dist/vector/services/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Vector Services
+ *
+ * Exports all vector service modules for the knowledge-graph-agent.
+ * Includes:
+ * - Vector store for HNSW-based similarity search
+ * - Trajectory tracker for agent operation logging and self-learning
+ *
+ * @module vector/services
+ */
+export { EnhancedVectorStore, createVectorStore } from './vector-store.js';
+export { TrajectoryTracker, createTrajectoryTracker, type TrajectoryTrackerConfig, type DetectedPattern, } from './trajectory-tracker.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/vector/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/vector/services/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3E,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,KAAK,uBAAuB,EAC5B,KAAK,eAAe,GACrB,MAAM,yBAAyB,CAAC"}

package/dist/vector/services/trajectory-tracker.d.ts

@@ -0,0 +1,405 @@
+/**
+ * Trajectory Tracker
+ *
+ * Records agent operation sequences for pattern learning.
+ * Integrates with the SONA (Self-Optimizing Neural Architecture) engine.
+ *
+ * The trajectory tracker provides:
+ * - Recording of agent operation trajectories
+ * - Pattern detection from historical trajectories
+ * - Learning records for SONA integration
+ * - Success/failure analysis
+ * - Recommendations based on learned patterns
+ *
+ * @module vector/services/trajectory-tracker
+ *
+ * @example
+ * ```typescript
+ * import { createTrajectoryTracker } from './trajectory-tracker.js';
+ *
+ * const tracker = createTrajectoryTracker({
+ *   maxTrajectories: 1000,
+ *   enableAutoLearning: true,
+ * });
+ *
+ * // Start a new trajectory
+ * const trajectoryId = tracker.startTrajectory('agent-1', 'workflow-1');
+ *
+ * // Add steps as the agent works
+ * tracker.addStep(trajectoryId, {
+ *   action: 'analyze_document',
+ *   state: { documentId: 'doc-123', status: 'processing' },
+ *   outcome: 'success',
+ *   duration: 1500,
+ * });
+ *
+ * // Finalize when done
+ * tracker.finalizeTrajectory(trajectoryId, { success: true });
+ *
+ * // Get recommendations for future actions
+ * const recommendations = tracker.getRecommendedActions('analyze_document');
+ * ```
+ */
+import type { TrajectoryStep, AgentTrajectory, SonaLearningRecord } from '../types.js';
+/**
+ * Trajectory tracker configuration
+ *
+ * @property maxTrajectories - Maximum number of trajectories to keep in memory
+ * @property maxStepsPerTrajectory - Maximum steps per trajectory
+ * @property enableAutoLearning - Enable auto-learning from successful trajectories
+ * @property minSuccessRateForLearning - Minimum success rate to learn from
+ * @property patternThreshold - Number of occurrences before pattern is learned
+ */
+export interface TrajectoryTrackerConfig {
+    /** Maximum number of trajectories to keep in memory */
+    maxTrajectories?: number;
+    /** Maximum steps per trajectory */
+    maxStepsPerTrajectory?: number;
+    /** Enable auto-learning from successful trajectories */
+    enableAutoLearning?: boolean;
+    /** Minimum success rate to learn from */
+    minSuccessRateForLearning?: number;
+    /** Pattern extraction threshold */
+    patternThreshold?: number;
+}
+/**
+ * Pattern detected from trajectories
+ *
+ * Represents a sequence of actions that has been observed multiple times
+ * and can be used to predict or recommend future actions.
+ */
+export interface DetectedPattern {
+    /** Unique identifier for this pattern */
+    id: string;
+    /** Type of pattern (success, failure, or optimization opportunity) */
+    type: 'success' | 'failure' | 'optimization';
+    /** Sequence of actions in this pattern */
+    actions: string[];
+    /** Number of times this pattern has been observed */
+    frequency: number;
+    /** Average duration of trajectories with this pattern */
+    avgDuration: number;
+    /** Success rate of trajectories with this pattern */
+    successRate: number;
+    /** Confidence level in this pattern (0-1) */
+    confidence: number;
+    /** Additional metadata about the pattern */
+    metadata: Record<string, unknown>;
+}
+/**
+ * Trajectory Tracker class
+ *
+ * Provides comprehensive tracking and learning from agent operation sequences.
+ * This is a core component for the SONA (Self-Optimizing Neural Architecture)
+ * system, enabling agents to learn from past experiences and improve over time.
+ *
+ * Key capabilities:
+ * - **Recording**: Track agent operations as trajectories
+ * - **Pattern Detection**: Identify recurring action sequences
+ * - **Learning**: Create learning records from successful patterns
+ * - **Recommendations**: Suggest next actions based on patterns
+ * - **Analytics**: Provide statistics on trajectory performance
+ *
+ * @example
+ * ```typescript
+ * const tracker = new TrajectoryTracker({
+ *   maxTrajectories: 500,
+ *   enableAutoLearning: true,
+ *   patternThreshold: 5,
+ * });
+ *
+ * // Use throughout agent lifecycle
+ * const id = tracker.startTrajectory('my-agent');
+ * tracker.addStep(id, { action: 'step1', outcome: 'success' });
+ * tracker.addStep(id, { action: 'step2', outcome: 'success' });
+ * const trajectory = tracker.finalizeTrajectory(id, { success: true });
+ *
+ * // Analyze patterns
+ * const patterns = tracker.getPatterns({ minConfidence: 0.8 });
+ * ```
+ */
+export declare class TrajectoryTracker {
+    private config;
+    private activeTrajectories;
+    private completedTrajectories;
+    private learningRecords;
+    private detectedPatterns;
+    /**
+     * Create a new TrajectoryTracker instance
+     *
+     * @param config - Configuration options for the tracker
+     */
+    constructor(config?: TrajectoryTrackerConfig);
+    /**
+     * Start a new trajectory for an agent
+     *
+     * Creates a new trajectory record that will track the agent's operations.
+     * The trajectory must be finalized with `finalizeTrajectory` when complete.
+     *
+     * @param agentId - Unique identifier for the agent
+     * @param workflowId - Optional workflow this trajectory belongs to
+     * @param metadata - Optional additional metadata
+     * @returns The unique trajectory ID for tracking
+     *
+     * @example
+     * ```typescript
+     * const trajectoryId = tracker.startTrajectory(
+     *   'researcher-agent-1',
+     *   'research-workflow-123',
+     *   { priority: 'high', source: 'user-request' }
+     * );
+     * ```
+     */
+    startTrajectory(agentId: string, workflowId?: string, metadata?: Record<string, unknown>): string;
+    /**
+     * Add a step to an active trajectory
+     *
+     * Records a single operation/action taken by the agent as part of
+     * the trajectory. Steps are added in order and include timing information.
+     *
+     * @param trajectoryId - The trajectory to add the step to
+     * @param step - The step data (timestamp is auto-added)
+     *
+     * @example
+     * ```typescript
+     * tracker.addStep(trajectoryId, {
+     *   action: 'analyze_document',
+     *   state: { documentId: 'doc-123', status: 'processing', progress: 0.5 },
+     *   outcome: 'success',
+     *   duration: 2500,
+     *   metadata: { model: 'claude-3-opus' }
+     * });
+     * ```
+     */
+    addStep(trajectoryId: string, step: Omit<TrajectoryStep, 'timestamp'>): void;
+    /**
+     * Finalize a trajectory
+     *
+     * Marks a trajectory as complete, calculates total duration, and
+     * optionally triggers pattern learning if auto-learning is enabled.
+     *
+     * @param trajectoryId - The trajectory to finalize
+     * @param options - Finalization options including success status
+     * @returns The finalized trajectory, or null if not found
+     *
+     * @example
+     * ```typescript
+     * const trajectory = tracker.finalizeTrajectory(trajectoryId, {
+     *   success: true,
+     *   metadata: { finalScore: 0.95 }
+     * });
+     *
+     * if (trajectory) {
+     *   console.log(`Completed in ${trajectory.totalDuration}ms`);
+     * }
+     * ```
+     */
+    finalizeTrajectory(trajectoryId: string, options: {
+        success: boolean;
+        metadata?: Record<string, unknown>;
+    }): AgentTrajectory | null;
+    /**
+     * Learn patterns from a successful trajectory
+     *
+     * Extracts action sequences from the trajectory and updates pattern
+     * frequency and confidence metrics. Creates learning records when
+     * patterns exceed the configured threshold.
+     *
+     * @param trajectory - The trajectory to learn from
+     * @internal
+     */
+    private learnFromTrajectory;
+    /**
+     * Generate a pattern ID from action sequence
+     *
+     * Creates a unique identifier for a pattern by joining action names.
+     *
+     * @param actions - Array of action names
+     * @returns Pattern identifier string
+     * @internal
+     */
+    private generatePatternId;
+    /**
+     * Get recommended actions based on current state
+     *
+     * Analyzes detected patterns to suggest the most likely next actions
+     * based on the current action being performed.
+     *
+     * @param currentAction - The action currently being performed
+     * @param context - Optional context for more targeted recommendations
+     * @returns Array of recommended actions sorted by confidence
+     *
+     * @example
+     * ```typescript
+     * const recommendations = tracker.getRecommendedActions('analyze_document');
+     *
+     * for (const rec of recommendations) {
+     *   console.log(`Suggested: ${rec.action} (${rec.confidence.toFixed(2)} confidence)`);
+     * }
+     * ```
+     */
+    getRecommendedActions(currentAction: string, context?: Record<string, unknown>): Array<{
+        action: string;
+        confidence: number;
+        basedOn: string;
+    }>;
+    /**
+     * Get trajectory by ID
+     *
+     * Retrieves a trajectory from either active or completed trajectories.
+     *
+     * @param trajectoryId - The trajectory ID to look up
+     * @returns The trajectory if found, null otherwise
+     */
+    getTrajectory(trajectoryId: string): AgentTrajectory | null;
+    /**
+     * Get all trajectories for an agent
+     *
+     * Retrieves all completed trajectories that were executed by a specific agent.
+     *
+     * @param agentId - The agent ID to filter by
+     * @returns Array of trajectories for the agent
+     */
+    getAgentTrajectories(agentId: string): AgentTrajectory[];
+    /**
+     * Get trajectories for a workflow
+     *
+     * Retrieves all completed trajectories that belong to a specific workflow.
+     *
+     * @param workflowId - The workflow ID to filter by
+     * @returns Array of trajectories for the workflow
+     */
+    getWorkflowTrajectories(workflowId: string): AgentTrajectory[];
+    /**
+     * Get detected patterns
+     *
+     * Retrieves patterns that have been detected from trajectory analysis,
+     * optionally filtered by confidence level or pattern type.
+     *
+     * @param options - Filter options
+     * @returns Array of patterns sorted by confidence
+     *
+     * @example
+     * ```typescript
+     * // Get high-confidence success patterns
+     * const patterns = tracker.getPatterns({
+     *   minConfidence: 0.8,
+     *   type: 'success'
+     * });
+     * ```
+     */
+    getPatterns(options?: {
+        minConfidence?: number;
+        type?: 'success' | 'failure' | 'optimization';
+    }): DetectedPattern[];
+    /**
+     * Get learning records
+     *
+     * Retrieves SONA learning records, optionally filtered by pattern ID
+     * or time range.
+     *
+     * @param options - Filter options
+     * @returns Array of learning records
+     *
+     * @example
+     * ```typescript
+     * // Get recent learning records
+     * const records = tracker.getLearningRecords({
+     *   since: new Date(Date.now() - 24 * 60 * 60 * 1000) // Last 24 hours
+     * });
+     * ```
+     */
+    getLearningRecords(options?: {
+        patternId?: string;
+        since?: Date;
+    }): SonaLearningRecord[];
+    /**
+     * Get statistics about trajectory tracking
+     *
+     * Provides aggregate statistics about trajectories, patterns,
+     * and learning performance.
+     *
+     * @returns Statistics object with counts and rates
+     *
+     * @example
+     * ```typescript
+     * const stats = tracker.getStats();
+     * console.log(`Success rate: ${(stats.successRate * 100).toFixed(1)}%`);
+     * console.log(`Patterns detected: ${stats.detectedPatterns}`);
+     * ```
+     */
+    getStats(): {
+        activeTrajectories: number;
+        completedTrajectories: number;
+        detectedPatterns: number;
+        learningRecords: number;
+        successRate: number;
+        avgDuration: number;
+    };
+    /**
+     * Clear all trajectory data
+     *
+     * Removes all active trajectories, completed trajectories, learning records,
+     * and detected patterns. Use with caution as this is irreversible.
+     */
+    clear(): void;
+    /**
+     * Export data for persistence
+     *
+     * Serializes all trajectory data for storage or transfer.
+     * Use with `import()` to restore data.
+     *
+     * @returns Exportable data object
+     *
+     * @example
+     * ```typescript
+     * const data = tracker.export();
+     * await fs.writeFile('trajectories.json', JSON.stringify(data));
+     * ```
+     */
+    export(): {
+        trajectories: AgentTrajectory[];
+        patterns: DetectedPattern[];
+        learningRecords: SonaLearningRecord[];
+    };
+    /**
+     * Import data from persistence
+     *
+     * Restores trajectory data from a previous export.
+     *
+     * @param data - Previously exported data object
+     *
+     * @example
+     * ```typescript
+     * const data = JSON.parse(await fs.readFile('trajectories.json', 'utf-8'));
+     * tracker.import(data);
+     * ```
+     */
+    import(data: {
+        trajectories?: AgentTrajectory[];
+        patterns?: DetectedPattern[];
+        learningRecords?: SonaLearningRecord[];
+    }): void;
+}
+/**
+ * Create a trajectory tracker instance
+ *
+ * Factory function for creating a TrajectoryTracker with the specified
+ * configuration.
+ *
+ * @param config - Optional configuration options
+ * @returns New TrajectoryTracker instance
+ *
+ * @example
+ * ```typescript
+ * import { createTrajectoryTracker } from './trajectory-tracker.js';
+ *
+ * const tracker = createTrajectoryTracker({
+ *   maxTrajectories: 500,
+ *   enableAutoLearning: true,
+ *   patternThreshold: 5,
+ * });
+ * ```
+ */
+export declare function createTrajectoryTracker(config?: TrajectoryTrackerConfig): TrajectoryTracker;
+//# sourceMappingURL=trajectory-tracker.d.ts.map

package/dist/vector/services/trajectory-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trajectory-tracker.d.ts","sourceRoot":"","sources":["../../../src/vector/services/trajectory-tracker.ts"],"names":[],"mappings":"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"}