/**
 * Unit Tests for AI Enrichment Module
 *
 * Tests the enrichment logic, env toggle, fallback behavior,
 * parseAIResponse, buildExtractionPrompt, and mock CLI flow.
 *
 * @module @agentkits/memory/hooks/__tests__/ai-enrichment
 */

import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import {
  enrichWithAI,
  isAIEnrichmentAvailable,
  isAIEnrichmentEnabled,
  resetAIEnrichmentCache,
  parseAIResponse,
  buildExtractionPrompt,
  parseSummaryResponse,
  buildSummaryPrompt,
  enrichSummaryWithAI,
  buildCompressionPrompt,
  parseCompressionResponse,
  compressObservationWithAI,
  buildSessionDigestPrompt,
  parseSessionDigestResponse,
  generateSessionDigestWithAI,
  _setRunClaudePrintMockForTesting,
  _setCliAvailableForTesting,
  setAIProviderConfig,
} from '../ai-enrichment.js';

describe('AI Enrichment Module', () => {
  const originalEnv = process.env.AGENTKITS_AI_ENRICHMENT;

  beforeEach(() => {
    resetAIEnrichmentCache();
  });

  afterEach(() => {
    if (originalEnv === undefined) {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
    } else {
      process.env.AGENTKITS_AI_ENRICHMENT = originalEnv;
    }
    resetAIEnrichmentCache();
  });

  describe('environment variable control', () => {
    it('should return null when AGENTKITS_AI_ENRICHMENT=false', async () => {
      process.env.AGENTKITS_AI_ENRICHMENT = 'false';
      const result = await enrichWithAI('Read', '{"file_path":"test.ts"}', '{}');
      expect(result).toBeNull();
    });

    it('should return null when AGENTKITS_AI_ENRICHMENT=0', async () => {
      process.env.AGENTKITS_AI_ENRICHMENT = '0';
      const result = await enrichWithAI('Read', '{"file_path":"test.ts"}', '{}');
      expect(result).toBeNull();
    });

    it('should attempt enrichment when AGENTKITS_AI_ENRICHMENT=true', async () => {
      process.env.AGENTKITS_AI_ENRICHMENT = 'true';
      resetAIEnrichmentCache();
      _setCliAvailableForTesting(true);
      _setRunClaudePrintMockForTesting(() => JSON.stringify({
        subtitle: 'Mock subtitle',
        narrative: 'Mock narrative text.',
        facts: ['Fact 1'],
        concepts: ['concept1'],
      }));
      const result = await enrichWithAI('Read', '{"file_path":"test.ts"}', '{}');
      // With CLI available and mock set, should return enriched data
      expect(result).not.toBeNull();
      expect(typeof result!.subtitle).toBe('string');
      expect(typeof result!.narrative).toBe('string');
      expect(Array.isArray(result!.facts)).toBe(true);
      expect(Array.isArray(result!.concepts)).toBe(true);
    });

    it('should auto-detect when env not set', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      resetAIEnrichmentCache();
      _setCliAvailableForTesting(true);
      _setRunClaudePrintMockForTesting(() => JSON.stringify({
        subtitle: 'Mock subtitle',
        narrative: 'Mock narrative text.',
        facts: ['Fact 1'],
        concepts: ['concept1'],
      }));
      const result = await enrichWithAI('Read', '{"file_path":"test.ts"}', '{}');
      // With CLI available, mock set, and env not set, should still enrich
      expect(result).not.toBeNull();
      expect(typeof result!.subtitle).toBe('string');
      expect(typeof result!.narrative).toBe('string');
    });

    it('should handle AGENTKITS_AI_ENRICHMENT=1', async () => {
      process.env.AGENTKITS_AI_ENRICHMENT = '1';
      resetAIEnrichmentCache();
      _setCliAvailableForTesting(true);
      _setRunClaudePrintMockForTesting(() => JSON.stringify({
        subtitle: 'Mock subtitle',
        narrative: 'Mock narrative text.',
        facts: ['Fact 1'],
        concepts: ['concept1'],
      }));
      const result = await enrichWithAI('Read', '{}', '{}');
      // With CLI available and mock set, should return enriched data
      expect(result).not.toBeNull();
      expect(typeof result!.subtitle).toBe('string');
    });
  });

  describe('isAIEnrichmentEnabled (sync)', () => {
    it.each([
      ['false', false],
      ['0', false],
      ['true', true],
      ['1', true],
    ])('should return %s when env=%s', (envValue, expected) => {
      process.env.AGENTKITS_AI_ENRICHMENT = envValue;
      expect(isAIEnrichmentEnabled()).toBe(expected);
    });

    it('should return true when env not set (auto-detect optimistic)', () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      expect(isAIEnrichmentEnabled()).toBe(true);
    });
  });

  describe('isAIEnrichmentAvailable', () => {
    it('should return false when env disabled', async () => {
      process.env.AGENTKITS_AI_ENRICHMENT = 'false';
      const available = await isAIEnrichmentAvailable();
      expect(available).toBe(false);
    });

    it('should return boolean when auto-detecting', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      const available = await isAIEnrichmentAvailable();
      expect(typeof available).toBe('boolean');
    });

    it('should return true when CLI available mock is set', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      _setCliAvailableForTesting(true);
      const available = await isAIEnrichmentAvailable();
      expect(available).toBe(true);
    });
  });

  describe('resetAIEnrichmentCache', () => {
    it('should reset cached state', async () => {
      // First call with env=false should return null
      process.env.AGENTKITS_AI_ENRICHMENT = 'false';
      _setCliAvailableForTesting(false);
      resetAIEnrichmentCache();
      const disabledResult = await enrichWithAI('Read', '{}', '{}');
      expect(disabledResult).toBeNull();

      // Reset cache and enable CLI with mock
      resetAIEnrichmentCache();
      _setCliAvailableForTesting(true);
      _setRunClaudePrintMockForTesting(() => JSON.stringify({
        subtitle: 'Mock subtitle',
        narrative: 'Mock narrative text.',
        facts: ['Fact 1'],
        concepts: ['concept1'],
      }));

      // Now with auto-detect, CLI available, and mock set, should return enriched data
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      const result = await enrichWithAI('Read', '{}', '{}');
      expect(result).not.toBeNull();
      expect(typeof result!.subtitle).toBe('string');
    });
  });

  describe('buildExtractionPrompt', () => {
    it('should include tool name, input, and response', () => {
      const prompt = buildExtractionPrompt('Read', '{"file_path":"src/index.ts"}', 'file content here');
      expect(prompt).toContain('Tool: Read');
      expect(prompt).toContain('Input: {"file_path":"src/index.ts"}');
      expect(prompt).toContain('Response: file content here');
    });

    it('should truncate long input to 2000 chars', () => {
      const longInput = 'x'.repeat(5000);
      const prompt = buildExtractionPrompt('Read', longInput, 'short');
      expect(prompt).toContain('Input: ' + 'x'.repeat(2000));
      expect(prompt).not.toContain('x'.repeat(2001));
    });

    it('should truncate long response to 2000 chars', () => {
      const longResponse = 'y'.repeat(5000);
      const prompt = buildExtractionPrompt('Read', 'short', longResponse);
      expect(prompt).toContain('Response: ' + 'y'.repeat(2000));
      expect(prompt).not.toContain('y'.repeat(2001));
    });

    it('should include JSON structure instructions', () => {
      const prompt = buildExtractionPrompt('Bash', 'ls', 'output');
      expect(prompt).toContain('"subtitle"');
      expect(prompt).toContain('"narrative"');
      expect(prompt).toContain('"facts"');
      expect(prompt).toContain('"concepts"');
    });
  });

  describe('parseAIResponse', () => {
    it('should parse valid JSON', () => {
      const json = JSON.stringify({
        subtitle: 'Test subtitle',
        narrative: 'Test narrative sentence.',
        facts: ['Fact 1', 'Fact 2'],
        concepts: ['concept1', 'concept2'],
      });
      const result = parseAIResponse(json);
      expect(result).not.toBeNull();
      expect(result!.subtitle).toBe('Test subtitle');
      expect(result!.narrative).toBe('Test narrative sentence.');
      expect(result!.facts).toEqual(['Fact 1', 'Fact 2']);
      expect(result!.concepts).toEqual(['concept1', 'concept2']);
    });

    it('should strip ```json code fences', () => {
      const json = '```json\n{"subtitle":"Test","narrative":"Test.","facts":["f"],"concepts":["c"]}\n```';
      const result = parseAIResponse(json);
      expect(result).not.toBeNull();
      expect(result!.subtitle).toBe('Test');
    });

    it('should strip ``` code fences without json tag', () => {
      const json = '```\n{"subtitle":"Test","narrative":"Test.","facts":["f"],"concepts":["c"]}\n```';
      const result = parseAIResponse(json);
      expect(result).not.toBeNull();
      expect(result!.subtitle).toBe('Test');
    });

    it('should handle whitespace around JSON', () => {
      const json = '  \n  {"subtitle":"Test","narrative":"Test.","facts":[],"concepts":[]}  \n  ';
      const result = parseAIResponse(json);
      expect(result).not.toBeNull();
      expect(result!.subtitle).toBe('Test');
    });

    it('should return null for invalid JSON', () => {
      const result = parseAIResponse('not json at all');
      expect(result).toBeNull();
    });

    it('should return null for empty string', () => {
      const result = parseAIResponse('');
      expect(result).toBeNull();
    });

    it.each([
      ['subtitle', { subtitle: 123, narrative: 'Test.', facts: [], concepts: [] }],
      ['narrative', { subtitle: 'Test', narrative: null, facts: [], concepts: [] }],
      ['facts', { subtitle: 'Test', narrative: 'Test.', facts: 'not array', concepts: [] }],
      ['concepts', { subtitle: 'Test', narrative: 'Test.', facts: [], concepts: 'not array' }],
    ])('should return null when %s has invalid type', (_field, obj) => {
      const json = JSON.stringify(obj);
      const result = parseAIResponse(json);
      expect(result).toBeNull();
    });

    it.each([
      ['subtitle', 200, { subtitle: 'A'.repeat(300), narrative: 'Test.', facts: [], concepts: [] }],
      ['narrative', 500, { subtitle: 'Test', narrative: 'B'.repeat(600), facts: [], concepts: [] }],
    ])('should truncate %s to %d chars', (field, maxLen, obj) => {
      const json = JSON.stringify(obj);
      const result = parseAIResponse(json);
      expect(result).not.toBeNull();
      expect((result as any)[field].length).toBe(maxLen);
    });

    it.each([
      ['facts', 5, { subtitle: 'Test', narrative: 'Test.', facts: ['f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7'], concepts: [] }],
      ['concepts', 8, { subtitle: 'Test', narrative: 'Test.', facts: [], concepts: ['c1', 'c2', 'c3', 'c4', 'c5', 'c6', 'c7', 'c8', 'c9', 'c10'] }],
    ])('should limit %s to %d items', (field, maxItems, obj) => {
      const json = JSON.stringify(obj);
      const result = parseAIResponse(json);
      expect(result).not.toBeNull();
      expect((result as any)[field].length).toBe(maxItems);
    });

    it('should compute confidence score from AI-reported value', () => {
      const json = JSON.stringify({
        subtitle: 'Examining auth module',
        narrative: 'Read the auth module for login flow.',
        facts: ['File has 200 lines'],
        concepts: ['authentication'],
        confidence: 0.92,
      });
      const result = parseAIResponse(json);
      expect(result).not.toBeNull();
      expect(result!.confidence).toBeCloseTo(0.92, 1);
    });

    it('should default confidence to 0.5 when not provided', () => {
      const json = JSON.stringify({
        subtitle: 'Examining auth module',
        narrative: 'Read the auth module for login flow.',
        facts: ['Fact 1'],
        concepts: ['auth'],
      });
      const result = parseAIResponse(json);
      expect(result).not.toBeNull();
      expect(result!.confidence).toBeCloseTo(0.5, 1);
    });

    it('should penalize confidence for very short subtitle', () => {
      const json = JSON.stringify({
        subtitle: 'Hi',
        narrative: 'Read the auth module for login flow.',
        facts: ['Fact 1'],
        concepts: ['auth'],
        confidence: 0.9,
      });
      const result = parseAIResponse(json);
      expect(result).not.toBeNull();
      expect(result!.confidence).toBeLessThan(0.9);
    });

    it('should penalize confidence for empty facts', () => {
      const json = JSON.stringify({
        subtitle: 'Examining auth module',
        narrative: 'Read the auth module for login flow.',
        facts: [],
        concepts: ['auth'],
        confidence: 0.9,
      });
      const result = parseAIResponse(json);
      expect(result).not.toBeNull();
      expect(result!.confidence).toBeLessThan(0.9);
    });

    it('should clamp confidence to 0-1 range', () => {
      const json = JSON.stringify({
        subtitle: 'Examining auth module',
        narrative: 'Read the auth module for login flow.',
        facts: ['Fact'],
        concepts: ['auth'],
        confidence: 1.5,
      });
      const result = parseAIResponse(json);
      expect(result).not.toBeNull();
      expect(result!.confidence).toBeLessThanOrEqual(1);
      expect(result!.confidence).toBeGreaterThanOrEqual(0);
    });

    it('should truncate individual fact strings to 200 chars', () => {
      const json = JSON.stringify({
        subtitle: 'Test',
        narrative: 'Test.',
        facts: ['C'.repeat(300)],
        concepts: [],
      });
      const result = parseAIResponse(json);
      expect(result).not.toBeNull();
      expect(result!.facts[0].length).toBe(200);
    });

    it('should truncate individual concept strings to 50 chars', () => {
      const json = JSON.stringify({
        subtitle: 'Test',
        narrative: 'Test.',
        facts: [],
        concepts: ['D'.repeat(100)],
      });
      const result = parseAIResponse(json);
      expect(result).not.toBeNull();
      expect(result!.concepts[0].length).toBe(50);
    });

    it('should convert non-string fact values to strings', () => {
      const json = JSON.stringify({
        subtitle: 'Test',
        narrative: 'Test.',
        facts: [42, true, null],
        concepts: [],
      });
      const result = parseAIResponse(json);
      expect(result).not.toBeNull();
      expect(result!.facts).toEqual(['42', 'true', 'null']);
    });

    it('should convert non-string concept values to strings', () => {
      const json = JSON.stringify({
        subtitle: 'Test',
        narrative: 'Test.',
        facts: [],
        concepts: [42, false],
      });
      const result = parseAIResponse(json);
      expect(result).not.toBeNull();
      expect(result!.concepts).toEqual(['42', 'false']);
    });
  });

  describe('enrichWithAI with mock CLI', () => {
    afterEach(() => {
      _setRunClaudePrintMockForTesting(null);
    });

    it('should return enriched observation on success', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      const validResponse = JSON.stringify({
        subtitle: 'Examining auth module',
        narrative: 'Read the auth module to understand login flow.',
        facts: ['File has 200 lines', 'Uses JWT tokens'],
        concepts: ['authentication', 'jwt', 'typescript'],
      });
      _setRunClaudePrintMockForTesting(() => validResponse);

      const result = await enrichWithAI('Read', '{"file_path":"auth.ts"}', 'export class Auth {}');
      expect(result).not.toBeNull();
      expect(result!.subtitle).toBe('Examining auth module');
      expect(result!.facts).toHaveLength(2);
      expect(result!.concepts).toContain('jwt');
    });

    it('should return null when CLI returns empty result', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      _setRunClaudePrintMockForTesting(() => null);

      const result = await enrichWithAI('Read', '{}', '{}');
      expect(result).toBeNull();
    });

    it('should return null when CLI returns invalid JSON', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      _setRunClaudePrintMockForTesting(() => 'not valid json');

      const result = await enrichWithAI('Read', '{}', '{}');
      expect(result).toBeNull();
    });

    it('should return null when CLI returns incomplete structure', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      _setRunClaudePrintMockForTesting(() => '{"subtitle":"test"}');

      const result = await enrichWithAI('Read', '{}', '{}');
      expect(result).toBeNull();
    });

    it('should return null when mock returns empty string', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      _setRunClaudePrintMockForTesting(() => '');

      const result = await enrichWithAI('Read', '{}', '{}');
      expect(result).toBeNull();
    });

    it('should return null when mock throws', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      _setRunClaudePrintMockForTesting(() => { throw new Error('CLI error'); });

      const result = await enrichWithAI('Read', '{}', '{}');
      expect(result).toBeNull();
    });

    it('should work with AGENTKITS_AI_ENRICHMENT=true and mock', async () => {
      process.env.AGENTKITS_AI_ENRICHMENT = 'true';
      const validResponse = JSON.stringify({
        subtitle: 'Running tests',
        narrative: 'Executed test suite.',
        facts: ['5 tests passed'],
        concepts: ['testing'],
      });
      _setRunClaudePrintMockForTesting(() => validResponse);

      const result = await enrichWithAI('Bash', 'npm test', '5 passed');
      expect(result).not.toBeNull();
      expect(result!.subtitle).toBe('Running tests');
    });

    it('should still return null when env=false even with mock set', async () => {
      process.env.AGENTKITS_AI_ENRICHMENT = 'false';
      _setRunClaudePrintMockForTesting(() => '{"subtitle":"Test","narrative":"Test.","facts":[],"concepts":[]}');

      const result = await enrichWithAI('Read', '{}', '{}');
      expect(result).toBeNull();
    });

    it('should parse markdown-fenced response from mock CLI', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      const fencedResponse =
        '```json\n{"subtitle":"Fenced","narrative":"Fenced response.","facts":["f1"],"concepts":["c1"]}\n```';
      _setRunClaudePrintMockForTesting(() => fencedResponse);

      const result = await enrichWithAI('Read', '{}', '{}');
      expect(result).not.toBeNull();
      expect(result!.subtitle).toBe('Fenced');
    });

    it('should pass prompt to mock', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      let capturedPrompt = '';
      _setRunClaudePrintMockForTesting((prompt) => {
        capturedPrompt = prompt;
        return JSON.stringify({
          subtitle: 'Test',
          narrative: 'Test.',
          facts: [],
          concepts: [],
        });
      });

      await enrichWithAI('Read', '{"file_path":"test.ts"}', 'content');
      expect(capturedPrompt).toContain('Tool: Read');
      expect(capturedPrompt).toContain('test.ts');
    });
  });

  describe('parseSummaryResponse', () => {
    it('should parse valid summary JSON', () => {
      const json = JSON.stringify({
        completed: 'Fixed a bug in the parser.',
        nextSteps: 'Run integration tests.',
      });
      const result = parseSummaryResponse(json);
      expect(result).not.toBeNull();
      expect(result!.completed).toBe('Fixed a bug in the parser.');
      expect(result!.nextSteps).toBe('Run integration tests.');
    });

    it('should accept nextSteps as array', () => {
      const json = JSON.stringify({
        completed: 'Fixed a bug.',
        nextSteps: ['Run tests', 'Deploy to staging'],
      });
      const result = parseSummaryResponse(json);
      expect(result).not.toBeNull();
      expect(result!.nextSteps).toBe('Run tests; Deploy to staging');
    });

    it('should default nextSteps to None when missing', () => {
      const json = JSON.stringify({
        completed: 'All done.',
      });
      const result = parseSummaryResponse(json);
      expect(result).not.toBeNull();
      expect(result!.nextSteps).toBe('None');
    });

    it('should return null when completed is not a string', () => {
      const json = JSON.stringify({
        completed: 123,
        nextSteps: 'Test',
      });
      const result = parseSummaryResponse(json);
      expect(result).toBeNull();
    });

    it('should truncate completed to 1000 chars', () => {
      const json = JSON.stringify({
        completed: 'A'.repeat(1500),
        nextSteps: 'Test',
      });
      const result = parseSummaryResponse(json);
      expect(result).not.toBeNull();
      expect(result!.completed.length).toBe(1000);
    });

    it('should truncate nextSteps to 500 chars', () => {
      const json = JSON.stringify({
        completed: 'Done.',
        nextSteps: 'B'.repeat(600),
      });
      const result = parseSummaryResponse(json);
      expect(result).not.toBeNull();
      expect(result!.nextSteps.length).toBe(500);
    });

    it('should strip markdown fences', () => {
      const json = '```json\n{"completed":"Done.","nextSteps":"None"}\n```';
      const result = parseSummaryResponse(json);
      expect(result).not.toBeNull();
      expect(result!.completed).toBe('Done.');
    });

    it('should strip plain ``` markdown fences (without json suffix)', () => {
      const json = '```\n{"completed":"Done.","nextSteps":"None"}\n```';
      const result = parseSummaryResponse(json);
      expect(result).not.toBeNull();
      expect(result!.completed).toBe('Done.');
    });

    it('should return null for invalid JSON', () => {
      expect(parseSummaryResponse('not json')).toBeNull();
    });

    it('should parse decisions array', () => {
      const json = JSON.stringify({
        completed: 'Fixed the bug.',
        nextSteps: 'None',
        decisions: ['Used mutex for thread safety', 'Chose retry pattern over circuit breaker'],
      });
      const result = parseSummaryResponse(json);
      expect(result).not.toBeNull();
      expect(result!.decisions).toHaveLength(2);
      expect(result!.decisions[0]).toBe('Used mutex for thread safety');
    });

    it('should default to empty decisions when not provided', () => {
      const json = JSON.stringify({
        completed: 'Done.',
        nextSteps: 'None',
      });
      const result = parseSummaryResponse(json);
      expect(result).not.toBeNull();
      expect(result!.decisions).toEqual([]);
    });

    it('should cap decisions at 5 items', () => {
      const json = JSON.stringify({
        completed: 'Done.',
        nextSteps: 'None',
        decisions: Array.from({ length: 10 }, (_, i) => `Decision ${i}`),
      });
      const result = parseSummaryResponse(json);
      expect(result).not.toBeNull();
      expect(result!.decisions).toHaveLength(5);
    });

    it('should filter out non-string decisions', () => {
      const json = JSON.stringify({
        completed: 'Done.',
        nextSteps: 'None',
        decisions: ['Valid', 123, null, '', 'Also valid'],
      });
      const result = parseSummaryResponse(json);
      expect(result).not.toBeNull();
      expect(result!.decisions).toEqual(['Valid', 'Also valid']);
    });
  });

  describe('buildSummaryPrompt', () => {
    it('should include template summary and assistant message', () => {
      const prompt = buildSummaryPrompt('Request: Fix bug', 'I fixed the bug.');
      expect(prompt).toContain('Template Summary');
      expect(prompt).toContain('Request: Fix bug');
      expect(prompt).toContain('Last Assistant Message');
      expect(prompt).toContain('I fixed the bug.');
    });

    it('should truncate long inputs', () => {
      const longTemplate = 'T'.repeat(5000);
      const longMessage = 'M'.repeat(5000);
      const prompt = buildSummaryPrompt(longTemplate, longMessage);
      // Should contain truncated versions (3000 chars each)
      expect(prompt.length).toBeLessThan(10000);
    });

    it('should ask for decisions in prompt', () => {
      const prompt = buildSummaryPrompt('Request: Fix auth', 'Fixed the auth flow.');
      expect(prompt).toContain('decisions');
      expect(prompt).toContain('WHY');
    });
  });

  describe('enrichSummaryWithAI with mock CLI', () => {
    afterEach(() => {
      _setRunClaudePrintMockForTesting(null);
    });

    it('should return enriched summary on success', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      const validResponse = JSON.stringify({
        completed: 'Fixed the parser bug and verified with tests.',
        nextSteps: 'None',
      });
      _setRunClaudePrintMockForTesting(() => validResponse);

      const result = await enrichSummaryWithAI('Request: Fix bug', 'I fixed the parser.');
      expect(result).not.toBeNull();
      expect(result!.completed).toBe('Fixed the parser bug and verified with tests.');
      expect(result!.nextSteps).toBe('None');
    });

    it('should return null when CLI unavailable', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      _setCliAvailableForTesting(false);

      const result = await enrichSummaryWithAI('Request: Fix bug', 'I fixed it.');
      expect(result).toBeNull();
    });

    it('should return null when CLI returns invalid response', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      _setRunClaudePrintMockForTesting(() => 'not json');

      const result = await enrichSummaryWithAI('Request: Fix bug', 'I fixed it.');
      expect(result).toBeNull();
    });

    it('should return null when runClaudePrint throws (catch block)', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      _setRunClaudePrintMockForTesting(() => { throw new Error('Unexpected CLI error'); });

      const result = await enrichSummaryWithAI('Request: Fix bug', 'I fixed it.');
      expect(result).toBeNull();
    });

    it('should return null when runClaudePrint returns null', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      _setRunClaudePrintMockForTesting(() => null as unknown as string);

      const result = await enrichSummaryWithAI('Request: Fix bug', 'I fixed it.');
      expect(result).toBeNull();
    });
  });

  describe('buildCompressionPrompt', () => {
    it('should include tool name and input/response', () => {
      const prompt = buildCompressionPrompt('Read', '{"file_path":"test.ts"}', 'file content');
      expect(prompt).toContain('Tool: Read');
      expect(prompt).toContain('Input: {"file_path":"test.ts"}');
      expect(prompt).toContain('Response: file content');
      expect(prompt).toContain('compressed_summary');
    });

    it('should include context hints when provided', () => {
      const prompt = buildCompressionPrompt('Read', '{}', '{}', 'Examining config', 'Read config file.');
      expect(prompt).toContain('Context: Examining config | Read config file.');
    });

    it('should omit context line when no hints', () => {
      const prompt = buildCompressionPrompt('Read', '{}', '{}');
      expect(prompt).not.toContain('Context:');
    });

    it('should truncate long input to 1000 chars', () => {
      const longInput = 'x'.repeat(3000);
      const prompt = buildCompressionPrompt('Read', longInput, 'short');
      expect(prompt).toContain('x'.repeat(1000));
      expect(prompt).not.toContain('x'.repeat(1001));
    });

    it('should truncate long response to 1000 chars', () => {
      const longResponse = 'y'.repeat(3000);
      const prompt = buildCompressionPrompt('Read', 'short', longResponse);
      expect(prompt).toContain('y'.repeat(1000));
      expect(prompt).not.toContain('y'.repeat(1001));
    });
  });

  describe('parseCompressionResponse', () => {
    it('should parse valid compression JSON', () => {
      const json = JSON.stringify({ compressed_summary: 'Read auth.ts to check login flow' });
      const result = parseCompressionResponse(json);
      expect(result).not.toBeNull();
      expect(result!.compressed_summary).toBe('Read auth.ts to check login flow');
    });

    it('should strip markdown fences', () => {
      const json = '```json\n{"compressed_summary":"Test summary"}\n```';
      const result = parseCompressionResponse(json);
      expect(result).not.toBeNull();
      expect(result!.compressed_summary).toBe('Test summary');
    });

    it('should strip plain ``` fences', () => {
      const json = '```\n{"compressed_summary":"Test summary"}\n```';
      const result = parseCompressionResponse(json);
      expect(result).not.toBeNull();
      expect(result!.compressed_summary).toBe('Test summary');
    });

    it('should return null for invalid JSON', () => {
      expect(parseCompressionResponse('not json')).toBeNull();
    });

    it('should return null when compressed_summary is missing', () => {
      const json = JSON.stringify({ other: 'field' });
      expect(parseCompressionResponse(json)).toBeNull();
    });

    it('should return null when compressed_summary is empty', () => {
      const json = JSON.stringify({ compressed_summary: '' });
      expect(parseCompressionResponse(json)).toBeNull();
    });

    it('should return null when compressed_summary is not a string', () => {
      const json = JSON.stringify({ compressed_summary: 123 });
      expect(parseCompressionResponse(json)).toBeNull();
    });

    it('should truncate to 200 chars', () => {
      const json = JSON.stringify({ compressed_summary: 'A'.repeat(300) });
      const result = parseCompressionResponse(json);
      expect(result).not.toBeNull();
      expect(result!.compressed_summary.length).toBe(200);
    });
  });

  describe('compressObservationWithAI with mock CLI', () => {
    afterEach(() => {
      _setRunClaudePrintMockForTesting(null);
    });

    it('should return compressed observation on success', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      _setRunClaudePrintMockForTesting(() =>
        JSON.stringify({ compressed_summary: 'Read auth module for login flow' })
      );

      const result = await compressObservationWithAI('Read', '{"file_path":"auth.ts"}', 'export class Auth {}', 'Examining auth', 'Read auth module.');
      expect(result).not.toBeNull();
      expect(result!.compressed_summary).toBe('Read auth module for login flow');
    });

    it('should return null when CLI unavailable', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      _setCliAvailableForTesting(false);

      const result = await compressObservationWithAI('Read', '{}', '{}');
      expect(result).toBeNull();
    });

    it('should return null when CLI returns invalid response', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      _setRunClaudePrintMockForTesting(() => 'not json');

      const result = await compressObservationWithAI('Read', '{}', '{}');
      expect(result).toBeNull();
    });

    it('should return null when CLI throws', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      _setRunClaudePrintMockForTesting(() => { throw new Error('Error'); });

      const result = await compressObservationWithAI('Read', '{}', '{}');
      expect(result).toBeNull();
    });

    it('should return null when env=false', async () => {
      process.env.AGENTKITS_AI_ENRICHMENT = 'false';
      _setRunClaudePrintMockForTesting(() =>
        JSON.stringify({ compressed_summary: 'Should not reach here' })
      );

      const result = await compressObservationWithAI('Read', '{}', '{}');
      expect(result).toBeNull();
    });
  });

  describe('buildSessionDigestPrompt', () => {
    it('should include request, observations, and completion', () => {
      const prompt = buildSessionDigestPrompt(
        'Fix auth bug',
        ['Read auth.ts', 'Edited login handler', 'Ran tests'],
        'Fixed authentication',
        ['src/auth.ts']
      );
      expect(prompt).toContain('Request: Fix auth bug');
      expect(prompt).toContain('Read auth.ts');
      expect(prompt).toContain('Edited login handler');
      expect(prompt).toContain('Completed: Fixed authentication');
      expect(prompt).toContain('Files modified: src/auth.ts');
      expect(prompt).toContain('"digest"');
    });

    it('should omit files line when no files modified', () => {
      const prompt = buildSessionDigestPrompt('Test', ['obs1'], 'Done', []);
      expect(prompt).not.toContain('Files modified:');
    });

    it('should limit observation summaries to 30', () => {
      const obs = Array.from({ length: 50 }, (_, i) => `Obs ${i}`);
      const prompt = buildSessionDigestPrompt('Test', obs, 'Done', []);
      // Should contain obs 0-29 but not 30+
      expect(prompt).toContain('Obs 29');
      expect(prompt).not.toContain('Obs 30');
    });
  });

  describe('parseSessionDigestResponse', () => {
    it('should parse valid digest JSON', () => {
      const json = JSON.stringify({ digest: 'Session fixed auth bug in 3 files.' });
      const result = parseSessionDigestResponse(json);
      expect(result).not.toBeNull();
      expect(result!.digest).toBe('Session fixed auth bug in 3 files.');
    });

    it('should strip markdown fences', () => {
      const json = '```json\n{"digest":"Test digest"}\n```';
      const result = parseSessionDigestResponse(json);
      expect(result).not.toBeNull();
      expect(result!.digest).toBe('Test digest');
    });

    it('should return null for invalid JSON', () => {
      expect(parseSessionDigestResponse('not json')).toBeNull();
    });

    it('should return null when digest is missing', () => {
      expect(parseSessionDigestResponse(JSON.stringify({ other: 'x' }))).toBeNull();
    });

    it('should return null when digest is empty', () => {
      expect(parseSessionDigestResponse(JSON.stringify({ digest: '' }))).toBeNull();
    });

    it('should return null when digest is not a string', () => {
      expect(parseSessionDigestResponse(JSON.stringify({ digest: 42 }))).toBeNull();
    });

    it('should truncate to 600 chars', () => {
      const json = JSON.stringify({ digest: 'D'.repeat(800) });
      const result = parseSessionDigestResponse(json);
      expect(result).not.toBeNull();
      expect(result!.digest.length).toBe(600);
    });
  });

  describe('generateSessionDigestWithAI with mock CLI', () => {
    afterEach(() => {
      _setRunClaudePrintMockForTesting(null);
    });

    it('should return digest on success', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      _setRunClaudePrintMockForTesting(() =>
        JSON.stringify({ digest: 'Fixed auth bug by patching JWT validation.' })
      );

      const result = await generateSessionDigestWithAI(
        'Fix auth', ['Read auth.ts', 'Edit auth.ts'], 'Fixed JWT', ['auth.ts']
      );
      expect(result).not.toBeNull();
      expect(result!.digest).toBe('Fixed auth bug by patching JWT validation.');
    });

    it('should return null when CLI unavailable', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      _setCliAvailableForTesting(false);

      const result = await generateSessionDigestWithAI('Test', [], 'Done', []);
      expect(result).toBeNull();
    });

    it('should return null when CLI returns null', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      _setRunClaudePrintMockForTesting(() => null as unknown as string);

      const result = await generateSessionDigestWithAI('Test', [], 'Done', []);
      expect(result).toBeNull();
    });
  });

  describe('error handling', () => {
    it('should return null when CLI is not available with invalid input', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      _setCliAvailableForTesting(false);
      resetAIEnrichmentCache();
      // Should gracefully handle any input without throwing
      const result = await enrichWithAI('InvalidTool', 'not json', 'not json');
      expect(result).toBeNull();
    });

    it('should not throw on enrichment failure when CLI is available', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      _setCliAvailableForTesting(true);
      resetAIEnrichmentCache();
      // Should gracefully handle invalid input without throwing
      const result = await enrichWithAI('InvalidTool', 'not json', 'not json');
      // Result must be either null (graceful failure) or a valid enriched object
      // This is a strict assertion - exactly one of these conditions must be true
      const isNull = result === null;
      const isValidObject = result !== null &&
        typeof result.subtitle === 'string' &&
        typeof result.narrative === 'string';
      expect(isNull || isValidObject).toBe(true);
    });

    it('should respect timeout (returns null on slow response)', async () => {
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      const start = Date.now();
      const result = await enrichWithAI('Read', '{}', '{}', 100);
      const elapsed = Date.now() - start;
      expect(result).toBeNull();
      expect(elapsed).toBeLessThan(5000);
    });
  });

  // ===== Provider Config =====

  describe('setAIProviderConfig', () => {
    it('should accept provider config without error', () => {
      expect(() => setAIProviderConfig({ provider: 'openai', apiKey: 'test' })).not.toThrow();
    });

    it('should accept undefined to reset config', () => {
      setAIProviderConfig({ provider: 'gemini', apiKey: 'key' });
      expect(() => setAIProviderConfig(undefined)).not.toThrow();
    });

    it('should force re-resolution so next enrichment uses new provider', async () => {
      // Set to openai with no API key → provider unavailable → enrichment returns null
      setAIProviderConfig({ provider: 'openai' });
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      const result = await enrichWithAI('Read', '{}', '{}');
      expect(result).toBeNull();
    });

    it('should not affect mock-based testing', async () => {
      setAIProviderConfig({ provider: 'openai', apiKey: 'test' });
      _setRunClaudePrintMockForTesting(() => JSON.stringify({
        subtitle: 'Test subtitle',
        narrative: 'Test narrative about something.',
        facts: ['Fact 1'],
        concepts: ['concept1'],
        confidence: 0.9,
      }));
      delete process.env.AGENTKITS_AI_ENRICHMENT;
      const result = await enrichWithAI('Read', '{"file_path":"test.ts"}', 'content');
      expect(result).not.toBeNull();
      expect(result!.subtitle).toBe('Test subtitle');
    });

    it('should be cleared by resetAIEnrichmentCache', () => {
      setAIProviderConfig({ provider: 'gemini', apiKey: 'key' });
      resetAIEnrichmentCache();
      // After reset, should use default provider (claude-cli)
      // No error should occur
      expect(() => enrichWithAI('Read', '{}', '{}')).not.toThrow();
    });
  });
});