proffesor-for-testing__agentic-qe/tests/code-intelligence/integration/BaseAgent-codeIntelligence.test.ts

/**
 * Integration Tests for BaseAgent Code Intelligence
 *
 * Wave 6: Verifies KnowledgeGraphContextBuilder integration into BaseAgent.
 * Tests the context enrichment flow for agent tasks.
 */

import { describe, it, expect, beforeAll, afterAll, jest } from '@jest/globals';
import { EventEmitter } from 'events';
import { HybridSearchEngine } from '../../../src/code-intelligence/search/HybridSearchEngine.js';
import { GraphBuilder } from '../../../src/code-intelligence/graph/GraphBuilder.js';
import type { SearchResponse } from '../../../src/code-intelligence/search/types.js';

// Mock concrete agent for testing (extends BaseAgent)
class TestAgent {
  private codeIntelligenceContextBuilder: any = null;
  private agentId = { id: 'test-agent-1', type: 'test-generator' as any, created: new Date() };
  private codeIntelligenceConfig: any;

  constructor(config: { codeIntelligence?: any }) {
    this.codeIntelligenceConfig = config.codeIntelligence;
  }

  async initialize(): Promise<void> {
    await this.initializeCodeIntelligence();
  }

  private async initializeCodeIntelligence(): Promise<void> {
    if (!this.codeIntelligenceConfig?.enabled) {
      return;
    }

    if (!this.codeIntelligenceConfig.searchEngine || !this.codeIntelligenceConfig.graphBuilder) {
      console.warn(`[${this.agentId.id}] Code Intelligence requires both searchEngine and graphBuilder`);
      return;
    }

    // Dynamic import to match BaseAgent behavior
    const { KnowledgeGraphContextBuilder } = await import('../../../src/agents/context/KnowledgeGraphContextBuilder.js');

    this.codeIntelligenceContextBuilder = new KnowledgeGraphContextBuilder({
      searchEngine: this.codeIntelligenceConfig.searchEngine,
      graphBuilder: this.codeIntelligenceConfig.graphBuilder,
      enableCache: true,
      cacheSize: 100,
    });
  }

  hasCodeIntelligence(): boolean {
    return this.codeIntelligenceContextBuilder !== null;
  }

  async getCodeIntelligenceContext(query: any, options?: any): Promise<any> {
    if (!this.codeIntelligenceContextBuilder) {
      return null;
    }

    const queryWithAgent = {
      ...query,
      agentType: query.agentType || this.agentId.type,
    };

    return await this.codeIntelligenceContextBuilder.buildContext(queryWithAgent, options);
  }

  getCodeIntelligenceStats(): any {
    if (!this.codeIntelligenceContextBuilder) {
      return { enabled: false };
    }

    return {
      enabled: true,
      cacheStats: this.codeIntelligenceContextBuilder.getCacheStats(),
    };
  }
}

describe('BaseAgent Code Intelligence Integration', () => {
  let mockSearchEngine: jest.Mocked<HybridSearchEngine>;
  let graphBuilder: GraphBuilder;

  beforeAll(() => {
    // Create real GraphBuilder with test data
    graphBuilder = new GraphBuilder({ rootDir: '/test' });

    // Add test nodes
    graphBuilder.addNode({
      id: 'file-test',
      type: 'file',
      label: 'TestFile.ts',
      filePath: '/test/TestFile.ts',
      startLine: 1,
      endLine: 50,
      language: 'typescript',
      properties: {},
    });

    graphBuilder.addNode({
      id: 'class-test',
      type: 'class',
      label: 'TestClass',
      filePath: '/test/TestFile.ts',
      startLine: 5,
      endLine: 45,
      language: 'typescript',
      properties: {},
    });

    // Create mock search engine
    mockSearchEngine = {
      search: jest.fn<() => Promise<SearchResponse>>().mockResolvedValue({
        results: [
          {
            id: 'chunk-1',
            filePath: '/test/TestFile.ts',
            content: 'class TestClass { }',
            score: 0.95,
            startLine: 5,
            endLine: 45,
            entityName: 'TestClass',
            entityType: 'class',
          },
        ],
        metadata: {
          totalResults: 1,
          searchTimeMs: 10,
          strategy: 'hybrid',
        },
      }),
      initialize: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
      shutdown: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
    } as any;
  });

  afterAll(() => {
    graphBuilder.clear();
  });

  describe('Initialization', () => {
    it('should not initialize code intelligence when disabled', async () => {
      const agent = new TestAgent({
        codeIntelligence: { enabled: false },
      });

      await agent.initialize();

      expect(agent.hasCodeIntelligence()).toBe(false);
    });

    it('should not initialize without searchEngine', async () => {
      const agent = new TestAgent({
        codeIntelligence: {
          enabled: true,
          graphBuilder,
          // Missing searchEngine
        },
      });

      await agent.initialize();

      expect(agent.hasCodeIntelligence()).toBe(false);
    });

    it('should not initialize without graphBuilder', async () => {
      const agent = new TestAgent({
        codeIntelligence: {
          enabled: true,
          searchEngine: mockSearchEngine,
          // Missing graphBuilder
        },
      });

      await agent.initialize();

      expect(agent.hasCodeIntelligence()).toBe(false);
    });

    it('should initialize with both dependencies', async () => {
      const agent = new TestAgent({
        codeIntelligence: {
          enabled: true,
          searchEngine: mockSearchEngine,
          graphBuilder,
        },
      });

      await agent.initialize();

      expect(agent.hasCodeIntelligence()).toBe(true);
    });
  });

  describe('Context Retrieval', () => {
    let agent: TestAgent;

    beforeAll(async () => {
      agent = new TestAgent({
        codeIntelligence: {
          enabled: true,
          searchEngine: mockSearchEngine,
          graphBuilder,
        },
      });
      await agent.initialize();
    });

    it('should return null when code intelligence is disabled', async () => {
      const disabledAgent = new TestAgent({
        codeIntelligence: { enabled: false },
      });
      await disabledAgent.initialize();

      const context = await disabledAgent.getCodeIntelligenceContext({
        query: 'test query',
      });

      expect(context).toBeNull();
    });

    it('should retrieve context for a query', async () => {
      const context = await agent.getCodeIntelligenceContext({
        query: 'TestClass implementation',
      });

      expect(context).not.toBeNull();
      expect(context.metadata.query).toBe('TestClass implementation');
      expect(context.metadata.agentType).toBe('test-generator');
      expect(context.searchResults.length).toBeGreaterThan(0);
    });

    it('should include token reduction metadata', async () => {
      const context = await agent.getCodeIntelligenceContext({
        query: 'test query',
      });

      expect(context).not.toBeNull();
      expect(context.metadata.tokenEstimate).toBeDefined();
      expect(typeof context.metadata.tokenEstimate).toBe('number');
    });

    it('should cache repeated queries', async () => {
      // Reset mock
      mockSearchEngine.search.mockClear();

      // First query
      await agent.getCodeIntelligenceContext({
        query: 'cached query test',
      });

      // Second identical query
      const secondContext = await agent.getCodeIntelligenceContext({
        query: 'cached query test',
      });

      expect(secondContext).not.toBeNull();
      expect(secondContext.metadata.cacheHit).toBe(true);

      // Search should only be called once due to caching
      expect(mockSearchEngine.search).toHaveBeenCalledTimes(1);
    });
  });

  describe('Statistics', () => {
    it('should return disabled stats when not initialized', async () => {
      const agent = new TestAgent({
        codeIntelligence: { enabled: false },
      });
      await agent.initialize();

      const stats = agent.getCodeIntelligenceStats();

      expect(stats.enabled).toBe(false);
      expect(stats.cacheStats).toBeUndefined();
    });

    it('should return cache stats when enabled', async () => {
      const agent = new TestAgent({
        codeIntelligence: {
          enabled: true,
          searchEngine: mockSearchEngine,
          graphBuilder,
        },
      });
      await agent.initialize();

      // Make a query to populate cache
      await agent.getCodeIntelligenceContext({
        query: 'stats test query',
      });

      const stats = agent.getCodeIntelligenceStats();

      expect(stats.enabled).toBe(true);
      expect(stats.cacheStats).toBeDefined();
      expect(stats.cacheStats.size).toBeGreaterThan(0);
    });
  });

  describe('Error Handling', () => {
    it('should handle search engine errors gracefully', async () => {
      const failingSearchEngine = {
        search: jest.fn<() => Promise<SearchResponse>>().mockRejectedValue(new Error('Search failed')),
        initialize: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
        shutdown: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
      } as any;

      const agent = new TestAgent({
        codeIntelligence: {
          enabled: true,
          searchEngine: failingSearchEngine,
          graphBuilder,
        },
      });
      await agent.initialize();

      // Should not throw, but return null or handle gracefully
      const context = await agent.getCodeIntelligenceContext({
        query: 'failing query',
      }).catch(() => null);

      // Either returns null or throws - both are acceptable error handling
      expect(context === null || context !== undefined).toBe(true);
    });
  });
});

describe('KnowledgeGraphContextBuilder Direct Tests', () => {
  let searchEngine: jest.Mocked<HybridSearchEngine>;
  let graphBuilder: GraphBuilder;

  beforeAll(() => {
    graphBuilder = new GraphBuilder({ rootDir: '/test' });

    graphBuilder.addNode({
      id: 'file-main',
      type: 'file',
      label: 'main.ts',
      filePath: '/test/main.ts',
      startLine: 1,
      endLine: 100,
      language: 'typescript',
      properties: {},
    });

    graphBuilder.addNode({
      id: 'class-app',
      type: 'class',
      label: 'App',
      filePath: '/test/main.ts',
      startLine: 10,
      endLine: 90,
      language: 'typescript',
      properties: {},
    });

    graphBuilder.addNode({
      id: 'file-utils',
      type: 'file',
      label: 'utils.ts',
      filePath: '/test/utils.ts',
      startLine: 1,
      endLine: 50,
      language: 'typescript',
      properties: {},
    });

    graphBuilder.addEdge({
      id: 'edge-imports',
      source: 'file-main',
      target: 'file-utils',
      type: 'imports',
      weight: 1.0,
      properties: {},
    });

    searchEngine = {
      search: jest.fn<() => Promise<SearchResponse>>().mockResolvedValue({
        results: [
          {
            id: 'chunk-1',
            filePath: '/test/main.ts',
            content: 'class App extends BaseApp { }',
            score: 0.9,
            startLine: 10,
            endLine: 90,
            entityName: 'App',
            entityType: 'class',
          },
        ],
        metadata: { totalResults: 1, searchTimeMs: 5, strategy: 'hybrid' },
      }),
      initialize: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
      shutdown: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
    } as any;
  });

  afterAll(() => {
    graphBuilder.clear();
  });

  it('should build context with search and graph expansion', async () => {
    const { KnowledgeGraphContextBuilder } = await import('../../../src/agents/context/KnowledgeGraphContextBuilder.js');

    const builder = new KnowledgeGraphContextBuilder({
      searchEngine,
      graphBuilder,
      enableCache: true,
    });

    const context = await builder.buildContext({
      query: 'App class implementation',
    });

    expect(context).toBeDefined();
    expect(context.searchResults.length).toBeGreaterThan(0);
    expect(context.metadata.totalTimeMs).toBeGreaterThanOrEqual(0); // Can be 0 if execution is fast
    expect(context.formatted).toBeDefined();
  });

  it('should build file context', async () => {
    const { KnowledgeGraphContextBuilder } = await import('../../../src/agents/context/KnowledgeGraphContextBuilder.js');

    const builder = new KnowledgeGraphContextBuilder({
      searchEngine,
      graphBuilder,
    });

    const context = await builder.buildFileContext('/test/main.ts');

    expect(context).toBeDefined();
    expect(context.metadata.query).toContain('main.ts');
  });

  it('should build entity context', async () => {
    const { KnowledgeGraphContextBuilder } = await import('../../../src/agents/context/KnowledgeGraphContextBuilder.js');

    const builder = new KnowledgeGraphContextBuilder({
      searchEngine,
      graphBuilder,
    });

    const context = await builder.buildEntityContext('/test/main.ts', 'App');

    expect(context).toBeDefined();
    expect(context.metadata.query).toContain('App');
  });

  it('should calculate token reduction percentage', async () => {
    const { KnowledgeGraphContextBuilder } = await import('../../../src/agents/context/KnowledgeGraphContextBuilder.js');

    const builder = new KnowledgeGraphContextBuilder({
      searchEngine,
      graphBuilder,
      baselineTokens: 10000, // Baseline for comparison
    });

    const context = await builder.buildContext({
      query: 'test query',
    });

    expect(context.metadata.tokenReduction).toBeDefined();
    expect(typeof context.metadata.tokenReduction).toBe('number');
    // Should achieve positive token reduction
    expect(context.metadata.tokenReduction).toBeGreaterThan(0);
  });

  it('should provide cache statistics', async () => {
    const { KnowledgeGraphContextBuilder } = await import('../../../src/agents/context/KnowledgeGraphContextBuilder.js');

    const builder = new KnowledgeGraphContextBuilder({
      searchEngine,
      graphBuilder,
      enableCache: true,
    });

    // Make some queries
    await builder.buildContext({ query: 'query 1' });
    await builder.buildContext({ query: 'query 2' });
    await builder.buildContext({ query: 'query 1' }); // Cache hit

    const stats = builder.getCacheStats();

    expect(stats.size).toBeGreaterThan(0);
    expect(stats.hits).toBeGreaterThan(0);
  });
});