@agentic-qe/v3 3.0.0-alpha.3

package/src/domains/learning-optimization/services/transfer-specialist.ts

@@ -0,0 +1,723 @@
+/**
+ * Agentic QE v3 - Transfer Specialist Service
+ * Handles knowledge transfer between projects and domains
+ */
+
+import { v4 as uuidv4 } from 'uuid';
+import { Result, ok, err, DomainName, AgentId } from '../../../shared/types/index.js';
+import { MemoryBackend } from '../../../kernel/interfaces.js';
+import {
+  Knowledge,
+  KnowledgeType,
+  KnowledgeContent,
+  KnowledgeQuery,
+  IKnowledgeSynthesisService,
+  PatternContext,
+} from '../interfaces.js';
+
+/**
+ * Configuration for the transfer specialist
+ */
+export interface TransferSpecialistConfig {
+  maxKnowledgeItems: number;
+  relevanceThreshold: number;
+  transferDecayFactor: number;
+  crossDomainBoost: number;
+}
+
+const DEFAULT_CONFIG: TransferSpecialistConfig = {
+  maxKnowledgeItems: 1000,
+  relevanceThreshold: 0.5,
+  transferDecayFactor: 0.1,
+  crossDomainBoost: 0.2,
+};
+
+/**
+ * Transfer result for tracking transfer operations
+ */
+export interface TransferResult {
+  knowledgeId: string;
+  sourceDomain: DomainName;
+  targetDomain: DomainName;
+  originalRelevance: number;
+  transferredRelevance: number;
+  adaptations: string[];
+}
+
+/**
+ * Transfer Specialist Service
+ * Implements knowledge transfer and synthesis across domains
+ */
+export class TransferSpecialistService implements IKnowledgeSynthesisService {
+  private readonly config: TransferSpecialistConfig;
+
+  constructor(
+    private readonly memory: MemoryBackend,
+    config: Partial<TransferSpecialistConfig> = {}
+  ) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+
+  // ============================================================================
+  // IKnowledgeSynthesisService Implementation
+  // ============================================================================
+
+  /**
+   * Share knowledge with target agents
+   */
+  async shareKnowledge(
+    knowledge: Knowledge,
+    targetAgents: AgentId[]
+  ): Promise<Result<void>> {
+    try {
+      // Store knowledge in shared namespace
+      await this.memory.set(
+        `learning:knowledge:shared:${knowledge.id}`,
+        knowledge,
+        { namespace: 'learning-optimization', persist: true }
+      );
+
+      // Create access records for each target agent
+      for (const agent of targetAgents) {
+        await this.memory.set(
+          `learning:knowledge:access:${agent.value}:${knowledge.id}`,
+          {
+            knowledgeId: knowledge.id,
+            agentId: agent.value,
+            sharedAt: new Date(),
+            accessed: false,
+          },
+          { namespace: 'learning-optimization', ttl: 86400 * 7 }
+        );
+      }
+
+      // Record sharing event
+      await this.recordSharingEvent(knowledge, targetAgents);
+
+      return ok(undefined);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Query knowledge base
+   */
+  async queryKnowledge(query: KnowledgeQuery): Promise<Result<Knowledge[]>> {
+    try {
+      const results: Knowledge[] = [];
+
+      // Search by domain if specified
+      let keys: string[];
+      if (query.domain) {
+        keys = await this.memory.search(
+          `learning:knowledge:*:${query.domain}:*`,
+          query.limit || 100
+        );
+      } else {
+        keys = await this.memory.search('learning:knowledge:shared:*', query.limit || 100);
+      }
+
+      for (const key of keys) {
+        const knowledge = await this.memory.get<Knowledge>(key);
+        if (knowledge && this.matchesQuery(knowledge, query)) {
+          results.push(knowledge);
+        }
+      }
+
+      // Sort by relevance score
+      results.sort((a, b) => b.relevanceScore - a.relevanceScore);
+
+      // Apply semantic search if embedding provided
+      if (query.embedding && query.embedding.length > 0) {
+        const vectorResults = await this.memory.vectorSearch(
+          query.embedding,
+          query.limit || 10
+        );
+
+        for (const vr of vectorResults) {
+          const knowledge = await this.memory.get<Knowledge>(vr.key);
+          if (
+            knowledge &&
+            !results.some((r) => r.id === knowledge.id) &&
+            this.matchesQuery(knowledge, query)
+          ) {
+            results.push(knowledge);
+          }
+        }
+      }
+
+      return ok(results.slice(0, query.limit || 100));
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Synthesize knowledge from multiple sources
+   */
+  async synthesizeKnowledge(knowledgeIds: string[]): Promise<Result<Knowledge>> {
+    try {
+      if (knowledgeIds.length < 2) {
+        return err(new Error('Need at least 2 knowledge items to synthesize'));
+      }
+
+      const items: Knowledge[] = [];
+      for (const id of knowledgeIds) {
+        const knowledge = await this.getKnowledgeById(id);
+        if (knowledge) {
+          items.push(knowledge);
+        }
+      }
+
+      if (items.length < 2) {
+        return err(new Error('Not enough valid knowledge items found'));
+      }
+
+      // Determine synthesized type and domain
+      const synthesizedType = this.determineSynthesizedType(items);
+      const synthesizedDomain = this.determineSynthesizedDomain(items);
+
+      // Merge content
+      const synthesizedContent = this.mergeKnowledgeContent(items);
+
+      // Calculate combined relevance
+      const avgRelevance =
+        items.reduce((sum, k) => sum + k.relevanceScore, 0) / items.length;
+
+      // Boost relevance for successful synthesis
+      const boostedRelevance = Math.min(
+        1,
+        avgRelevance + this.config.crossDomainBoost
+      );
+
+      // Create synthesized knowledge
+      const synthesized: Knowledge = {
+        id: uuidv4(),
+        type: synthesizedType,
+        domain: synthesizedDomain,
+        content: synthesizedContent,
+        sourceAgentId: items[0].sourceAgentId,
+        targetDomains: this.mergeTargetDomains(items),
+        relevanceScore: boostedRelevance,
+        version: 1,
+        createdAt: new Date(),
+      };
+
+      // Store synthesized knowledge
+      await this.storeKnowledge(synthesized);
+
+      // Record synthesis event
+      await this.recordSynthesisEvent(synthesized, knowledgeIds);
+
+      return ok(synthesized);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Transfer knowledge to a different domain
+   */
+  async transferKnowledge(
+    knowledge: Knowledge,
+    targetDomain: DomainName
+  ): Promise<Result<Knowledge>> {
+    try {
+      if (knowledge.domain === targetDomain) {
+        return err(new Error('Cannot transfer knowledge to the same domain'));
+      }
+
+      // Calculate transferred relevance with decay
+      const transferredRelevance = this.calculateTransferredRelevance(
+        knowledge,
+        targetDomain
+      );
+
+      if (transferredRelevance < this.config.relevanceThreshold) {
+        return err(
+          new Error(
+            `Transferred relevance ${transferredRelevance} below threshold ${this.config.relevanceThreshold}`
+          )
+        );
+      }
+
+      // Adapt content for target domain
+      const adaptedContent = await this.adaptContentForDomain(
+        knowledge.content,
+        knowledge.domain,
+        targetDomain
+      );
+
+      // Create transferred knowledge
+      const transferred: Knowledge = {
+        id: uuidv4(),
+        type: knowledge.type,
+        domain: targetDomain,
+        content: adaptedContent,
+        sourceAgentId: knowledge.sourceAgentId,
+        targetDomains: [targetDomain],
+        relevanceScore: transferredRelevance,
+        version: knowledge.version + 1,
+        createdAt: new Date(),
+      };
+
+      // Store transferred knowledge
+      await this.storeKnowledge(transferred);
+
+      // Record transfer event
+      await this.recordTransferEvent(knowledge, transferred);
+
+      return ok(transferred);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Validate knowledge relevance for a context
+   */
+  async validateRelevance(
+    knowledge: Knowledge,
+    context: PatternContext
+  ): Promise<Result<number>> {
+    try {
+      let relevance = knowledge.relevanceScore;
+
+      // Adjust based on context match
+      if (context.language && knowledge.content.metadata?.language === context.language) {
+        relevance += 0.1;
+      }
+      if (context.framework && knowledge.content.metadata?.framework === context.framework) {
+        relevance += 0.1;
+      }
+      if (context.tags.length > 0 && knowledge.content.metadata?.tags) {
+        const knowledgeTags = knowledge.content.metadata.tags as string[];
+        const matchingTags = context.tags.filter((t) =>
+          knowledgeTags.includes(t)
+        );
+        relevance += (matchingTags.length / context.tags.length) * 0.2;
+      }
+
+      // Apply age decay
+      const ageMs = Date.now() - knowledge.createdAt.getTime();
+      const ageDays = ageMs / (1000 * 60 * 60 * 24);
+      const ageDecay = Math.exp(-this.config.transferDecayFactor * ageDays / 30);
+      relevance *= ageDecay;
+
+      // Check expiry
+      if (knowledge.expiresAt && new Date() > knowledge.expiresAt) {
+        relevance *= 0.5;
+      }
+
+      return ok(Math.min(1, Math.max(0, relevance)));
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  // ============================================================================
+  // Additional Public Methods
+  // ============================================================================
+
+  /**
+   * Create new knowledge item
+   */
+  async createKnowledge(
+    type: KnowledgeType,
+    domain: DomainName,
+    content: unknown,
+    sourceAgent: AgentId,
+    targetDomains: DomainName[] = [],
+    metadata?: Record<string, unknown>
+  ): Promise<Result<Knowledge>> {
+    try {
+      const knowledge: Knowledge = {
+        id: uuidv4(),
+        type,
+        domain,
+        content: {
+          format: this.inferContentFormat(content),
+          data: content,
+          metadata,
+        },
+        sourceAgentId: sourceAgent,
+        targetDomains,
+        relevanceScore: 1.0,
+        version: 1,
+        createdAt: new Date(),
+      };
+
+      await this.storeKnowledge(knowledge);
+
+      // Store vector embedding if applicable
+      if (type === 'embedding' && Array.isArray(content)) {
+        await this.memory.storeVector(
+          `learning:knowledge:vector:${knowledge.id}`,
+          content as number[],
+          { knowledgeId: knowledge.id }
+        );
+      }
+
+      return ok(knowledge);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Get knowledge by ID
+   */
+  async getKnowledgeById(id: string): Promise<Knowledge | null> {
+    const knowledge = await this.memory.get<Knowledge>(
+      `learning:knowledge:shared:${id}`
+    );
+    return knowledge || null;
+  }
+
+  /**
+   * Bulk transfer knowledge between projects
+   */
+  async bulkTransfer(
+    sourceProject: string,
+    targetProject: string,
+    filter?: { types?: KnowledgeType[]; minRelevance?: number }
+  ): Promise<Result<TransferResult[]>> {
+    try {
+      const keys = await this.memory.search(
+        `learning:knowledge:project:${sourceProject}:*`,
+        500
+      );
+      const results: TransferResult[] = [];
+
+      for (const key of keys) {
+        const knowledge = await this.memory.get<Knowledge>(key);
+        if (!knowledge) continue;
+
+        // Apply filter
+        if (filter?.types && !filter.types.includes(knowledge.type)) {
+          continue;
+        }
+        if (
+          filter?.minRelevance &&
+          knowledge.relevanceScore < filter.minRelevance
+        ) {
+          continue;
+        }
+
+        // Transfer to target project
+        const adaptedContent = await this.adaptContentForProject(
+          knowledge.content,
+          sourceProject,
+          targetProject
+        );
+
+        const transferred: Knowledge = {
+          ...knowledge,
+          id: uuidv4(),
+          content: adaptedContent,
+          relevanceScore: knowledge.relevanceScore * (1 - this.config.transferDecayFactor),
+          version: knowledge.version + 1,
+          createdAt: new Date(),
+        };
+
+        await this.memory.set(
+          `learning:knowledge:project:${targetProject}:${transferred.id}`,
+          transferred,
+          { namespace: 'learning-optimization', persist: true }
+        );
+
+        results.push({
+          knowledgeId: transferred.id,
+          sourceDomain: knowledge.domain,
+          targetDomain: knowledge.domain,
+          originalRelevance: knowledge.relevanceScore,
+          transferredRelevance: transferred.relevanceScore,
+          adaptations: ['project-context-adapted'],
+        });
+      }
+
+      return ok(results);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  // ============================================================================
+  // Private Helper Methods
+  // ============================================================================
+
+  private async storeKnowledge(knowledge: Knowledge): Promise<void> {
+    // Store in shared namespace
+    await this.memory.set(
+      `learning:knowledge:shared:${knowledge.id}`,
+      knowledge,
+      { namespace: 'learning-optimization', persist: true }
+    );
+
+    // Index by domain
+    await this.memory.set(
+      `learning:knowledge:domain:${knowledge.domain}:${knowledge.id}`,
+      knowledge.id,
+      { namespace: 'learning-optimization', persist: true }
+    );
+
+    // Index by type
+    await this.memory.set(
+      `learning:knowledge:type:${knowledge.type}:${knowledge.id}`,
+      knowledge.id,
+      { namespace: 'learning-optimization', persist: true }
+    );
+  }
+
+  private matchesQuery(knowledge: Knowledge, query: KnowledgeQuery): boolean {
+    if (query.type && knowledge.type !== query.type) {
+      return false;
+    }
+    if (query.domain && knowledge.domain !== query.domain) {
+      return false;
+    }
+    if (
+      query.minRelevance !== undefined &&
+      knowledge.relevanceScore < query.minRelevance
+    ) {
+      return false;
+    }
+    if (query.tags && query.tags.length > 0) {
+      const knowledgeTags = (knowledge.content.metadata?.tags as string[]) || [];
+      const hasMatchingTag = query.tags.some((tag) =>
+        knowledgeTags.includes(tag)
+      );
+      if (!hasMatchingTag) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private determineSynthesizedType(items: Knowledge[]): KnowledgeType {
+    const typeCounts: Map<KnowledgeType, number> = new Map();
+    for (const item of items) {
+      typeCounts.set(item.type, (typeCounts.get(item.type) || 0) + 1);
+    }
+
+    let maxType: KnowledgeType = items[0].type;
+    let maxCount = 0;
+    for (const [type, count] of typeCounts) {
+      if (count > maxCount) {
+        maxCount = count;
+        maxType = type;
+      }
+    }
+
+    return maxType;
+  }
+
+  private determineSynthesizedDomain(items: Knowledge[]): DomainName {
+    // Use the domain that appears most frequently
+    const domainCounts: Map<DomainName, number> = new Map();
+    for (const item of items) {
+      domainCounts.set(item.domain, (domainCounts.get(item.domain) || 0) + 1);
+    }
+
+    let maxDomain: DomainName = items[0].domain;
+    let maxCount = 0;
+    for (const [domain, count] of domainCounts) {
+      if (count > maxCount) {
+        maxCount = count;
+        maxDomain = domain;
+      }
+    }
+
+    return maxDomain;
+  }
+
+  private mergeKnowledgeContent(items: Knowledge[]): KnowledgeContent {
+    // Merge metadata
+    const mergedMetadata: Record<string, unknown> = {};
+    const mergedData: unknown[] = [];
+
+    for (const item of items) {
+      mergedData.push(item.content.data);
+      if (item.content.metadata) {
+        for (const [key, value] of Object.entries(item.content.metadata)) {
+          if (Array.isArray(value)) {
+            const existing = (mergedMetadata[key] as unknown[]) || [];
+            mergedMetadata[key] = [...new Set([...existing, ...value])];
+          } else {
+            mergedMetadata[key] = value;
+          }
+        }
+      }
+    }
+
+    return {
+      format: 'json',
+      data: { synthesized: true, sources: mergedData },
+      metadata: {
+        ...mergedMetadata,
+        synthesizedFrom: items.map((i) => i.id),
+        synthesizedAt: new Date().toISOString(),
+      },
+    };
+  }
+
+  private mergeTargetDomains(items: Knowledge[]): DomainName[] {
+    const allDomains = new Set<DomainName>();
+    for (const item of items) {
+      allDomains.add(item.domain);
+      for (const target of item.targetDomains) {
+        allDomains.add(target);
+      }
+    }
+    return Array.from(allDomains);
+  }
+
+  private calculateTransferredRelevance(
+    knowledge: Knowledge,
+    targetDomain: DomainName
+  ): number {
+    let relevance = knowledge.relevanceScore;
+
+    // Apply transfer decay
+    relevance *= 1 - this.config.transferDecayFactor;
+
+    // Check if target domain is compatible
+    const domainCompatibility = this.getDomainCompatibility(
+      knowledge.domain,
+      targetDomain
+    );
+    relevance *= domainCompatibility;
+
+    // Boost if explicitly targeted
+    if (knowledge.targetDomains.includes(targetDomain)) {
+      relevance += this.config.crossDomainBoost;
+    }
+
+    return Math.min(1, Math.max(0, relevance));
+  }
+
+  private getDomainCompatibility(
+    source: DomainName,
+    target: DomainName
+  ): number {
+    // Define domain compatibility matrix (simplified)
+    const relatedDomains: Record<DomainName, DomainName[]> = {
+      'test-generation': ['test-execution', 'coverage-analysis'],
+      'test-execution': ['test-generation', 'coverage-analysis', 'quality-assessment'],
+      'coverage-analysis': ['test-generation', 'test-execution', 'quality-assessment'],
+      'quality-assessment': ['test-execution', 'coverage-analysis', 'defect-intelligence'],
+      'defect-intelligence': ['quality-assessment', 'code-intelligence'],
+      'requirements-validation': ['test-generation', 'quality-assessment'],
+      'code-intelligence': ['defect-intelligence', 'security-compliance'],
+      'security-compliance': ['code-intelligence', 'quality-assessment'],
+      'contract-testing': ['test-generation', 'test-execution'],
+      'visual-accessibility': ['quality-assessment'],
+      'chaos-resilience': ['test-execution', 'quality-assessment'],
+      'learning-optimization': [
+        'test-generation',
+        'test-execution',
+        'coverage-analysis',
+        'quality-assessment',
+        'defect-intelligence',
+      ],
+    };
+
+    if (source === target) return 1.0;
+    if (relatedDomains[source]?.includes(target)) return 0.8;
+    return 0.5;
+  }
+
+  private async adaptContentForDomain(
+    content: KnowledgeContent,
+    sourceDomain: DomainName,
+    targetDomain: DomainName
+  ): Promise<KnowledgeContent> {
+    // Add adaptation metadata
+    return {
+      ...content,
+      metadata: {
+        ...(content.metadata || {}),
+        adaptedFrom: sourceDomain,
+        adaptedTo: targetDomain,
+        adaptedAt: new Date().toISOString(),
+      },
+    };
+  }
+
+  private async adaptContentForProject(
+    content: KnowledgeContent,
+    sourceProject: string,
+    targetProject: string
+  ): Promise<KnowledgeContent> {
+    return {
+      ...content,
+      metadata: {
+        ...(content.metadata || {}),
+        sourceProject,
+        targetProject,
+        transferredAt: new Date().toISOString(),
+      },
+    };
+  }
+
+  private inferContentFormat(
+    content: unknown
+  ): 'text' | 'json' | 'embedding' | 'model' {
+    if (typeof content === 'string') return 'text';
+    if (Array.isArray(content) && content.every((v) => typeof v === 'number')) {
+      return 'embedding';
+    }
+    return 'json';
+  }
+
+  private async recordSharingEvent(
+    knowledge: Knowledge,
+    targetAgents: AgentId[]
+  ): Promise<void> {
+    await this.memory.set(
+      `learning:knowledge:events:share:${knowledge.id}:${Date.now()}`,
+      {
+        type: 'share',
+        knowledgeId: knowledge.id,
+        targetAgents: targetAgents.map((a) => a.value),
+        timestamp: new Date(),
+      },
+      { namespace: 'learning-optimization', ttl: 86400 * 30 }
+    );
+  }
+
+  private async recordSynthesisEvent(
+    synthesized: Knowledge,
+    sourceIds: string[]
+  ): Promise<void> {
+    await this.memory.set(
+      `learning:knowledge:events:synthesis:${synthesized.id}`,
+      {
+        type: 'synthesis',
+        synthesizedId: synthesized.id,
+        sourceIds,
+        timestamp: new Date(),
+      },
+      { namespace: 'learning-optimization', ttl: 86400 * 30 }
+    );
+  }
+
+  private async recordTransferEvent(
+    original: Knowledge,
+    transferred: Knowledge
+  ): Promise<void> {
+    await this.memory.set(
+      `learning:knowledge:events:transfer:${transferred.id}`,
+      {
+        type: 'transfer',
+        originalId: original.id,
+        transferredId: transferred.id,
+        originalDomain: original.domain,
+        targetDomain: transferred.domain,
+        timestamp: new Date(),
+      },
+      { namespace: 'learning-optimization', ttl: 86400 * 30 }
+    );
+  }
+}