// @ts-nocheck
import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
// Mock semantic analyzer
jest.mock('../src/semantic-analyzer', () => ({
semanticAnalyzer: {
initialize: jest.fn(async () => {}),
computeSimilarityMatrix: jest.fn(async (texts) => {
const n = texts.length;
return Array(n)
.fill()
.map((_, i) =>
Array(n)
.fill()
.map((_, j) => (i === j ? 1.0 : Math.random() * 0.5 + 0.5))
);
}),
calculateSemanticSimilarity: jest.fn(async () => ({
similarity: 0.8,
confidence: 0.9,
reasoning: 'Mock similarity',
})),
isReady: jest.fn(() => true),
},
}));
import { Sentinel } from '../src/sentinel';
import { CognitiveTrace, SentinelConfig } from '../src/types';
describe('Sentinel', () => {
let sentinel: Sentinel;
let config: Partial<SentinelConfig>;
beforeEach(() => {
config = {
progress_indicators: ['success', 'found', 'completed'],
min_actions_for_detection: 3,
alternating_threshold: 0.4,
repetition_threshold: 0.3,
progress_threshold_adjustment: 0.1,
statistical_analysis: {
entropy_threshold: 0.6,
variance_threshold: 0.1,
trend_threshold: 0.1,
cyclicity_threshold: 0.3,
},
};
sentinel = new Sentinel(config);
});
afterEach(() => {
sentinel.reset();
jest.clearAllMocks();
});
describe('edge cases and error handling', () => {
it('should handle empty action sequences', async () => {
const trace: CognitiveTrace & { recent_actions: string[] } = {
last_action: '',
goal: 'test goal',
recent_actions: [],
};
const result = await sentinel.detectLoop(trace, 'pattern', 5);
expect(result.detected).toBe(false);
});
it('should handle single action sequences', async () => {
const trace: CognitiveTrace & { recent_actions: string[] } = {
last_action: 'single_action',
goal: 'test goal',
recent_actions: ['single_action'],
};
const result = await sentinel.detectLoop(trace, 'pattern', 5);
expect(result.detected).toBe(false);
});
it('should handle very long action sequences without performance issues', async () => {
const longActionSequence = Array(1000)
.fill()
.map((_, i) => `action_${i % 10}`);
const trace: CognitiveTrace & { recent_actions: string[] } = {
last_action: 'action_9',
goal: 'performance test',
recent_actions: longActionSequence,
};
const start = Date.now();
const result = await sentinel.detectLoop(trace, 'hybrid', 50);
const duration = Date.now() - start;
expect(result).toBeDefined();
expect(duration).toBeLessThan(5000); // Should complete within 5 seconds
});
it('should handle invalid window sizes gracefully', async () => {
const trace: CognitiveTrace & { recent_actions: string[] } = {
last_action: 'test_action',
goal: 'test goal',
recent_actions: ['action1', 'action2', 'action3'],
};
// Test negative window size
const result1 = await sentinel.detectLoop(trace, 'pattern', -1);
expect(result1.detected).toBe(false);
// Test zero window size
const result2 = await sentinel.detectLoop(trace, 'pattern', 0);
expect(result2.detected).toBe(false);
// Test extremely large window size
const result3 = await sentinel.detectLoop(trace, 'pattern', 1000000);
expect(result3.detected).toBe(false);
});
it('should handle malformed traces gracefully', async () => {
const malformedTrace: any = {
last_action: null,
goal: undefined,
recent_actions: null,
};
// Should not throw but return no detection
const result = await sentinel.detectLoop(malformedTrace, 'pattern', 5);
expect(result.detected).toBe(false);
});
it('should handle actions with special characters', async () => {
const specialActions = [
'action_with_underscore',
'action-with-dash',
'action.with.dots',
'action with spaces',
'action@with#symbols$',
'中文_action',
'émoji_🚀_action',
];
const trace: CognitiveTrace & { recent_actions: string[] } = {
last_action: specialActions[0],
goal: 'special chars test',
recent_actions: specialActions,
};
const result = await sentinel.detectLoop(trace, 'pattern', 10);
expect(result).toBeDefined();
expect(typeof result.detected).toBe('boolean');
});
it('should maintain consistent behavior across multiple resets', async () => {
const actions = ['reset_test_1', 'reset_test_2', 'reset_test_1', 'reset_test_2'];
for (let i = 0; i < 3; i++) {
sentinel.reset();
const trace: CognitiveTrace & { recent_actions: string[] } = {
last_action: actions[actions.length - 1],
goal: `reset iteration ${i}`,
recent_actions: actions,
};
const result = await sentinel.detectLoop(trace, 'pattern', 5);
expect(result).toBeDefined();
expect(typeof result.confidence).toBe('number');
expect(result.confidence).toBeGreaterThanOrEqual(0);
expect(result.confidence).toBeLessThanOrEqual(1);
}
});
it('should handle concurrent detection requests', async () => {
const traces = Array(5)
.fill()
.map((_, i) => ({
last_action: `concurrent_action_${i}`,
goal: `concurrent goal ${i}`,
recent_actions: [`action_${i}`, `action_${i}`, `action_${i}`],
}));
const promises = traces.map((trace) =>
sentinel.detectLoop(trace as CognitiveTrace & { recent_actions: string[] }, 'hybrid', 5)
);
const results = await Promise.all(promises);
expect(results).toHaveLength(5);
results.forEach((result) => {
expect(result).toBeDefined();
expect(typeof result.detected).toBe('boolean');
});
});
it('should handle detection method case variations', async () => {
const trace: CognitiveTrace & { recent_actions: string[] } = {
last_action: 'test_action',
goal: 'case test',
recent_actions: ['action1', 'action2'],
};
// Test with different method variations
const methods = ['statistical', 'pattern', 'hybrid'];
for (const method of methods) {
const result = await sentinel.detectLoop(trace, method as any, 5);
expect(result).toBeDefined();
expect(typeof result.detected).toBe('boolean');
}
});
});
describe('initialization', () => {
it('should initialize with default configuration', () => {
const defaultSentinel = new Sentinel({});
expect(defaultSentinel).toBeDefined();
});
it('should initialize with custom configuration', () => {
const customConfig = {
min_actions_for_detection: 7,
alternating_threshold: 0.6,
};
const customSentinel = new Sentinel(customConfig);
expect(customSentinel).toBeDefined();
});
it('should handle repeated initialization', () => {
// Sentinel doesn't have initialize method, just test construction
const sentinel1 = new Sentinel(config);
const sentinel2 = new Sentinel(config); // Should not throw
expect(sentinel1).toBeDefined();
expect(sentinel2).toBeDefined();
});
});
describe('updateConfig', () => {
it('should update configuration parameters', () => {
const newConfig = {
min_actions_for_detection: 10,
alternating_threshold: 0.8,
repetition_threshold: 0.7,
};
sentinel.updateConfig(newConfig);
// Test that the update doesn't throw and subsequent operations work
expect(() => sentinel.updateConfig(newConfig)).not.toThrow();
});
it('should handle partial configuration updates', () => {
const partialConfig = {
min_actions_for_detection: 5,
};
expect(() => sentinel.updateConfig(partialConfig)).not.toThrow();
});
it('should handle empty configuration', () => {
expect(() => sentinel.updateConfig({})).not.toThrow();
});
it('should handle undefined configuration', () => {
expect(() => sentinel.updateConfig(undefined as any)).not.toThrow();
});
});
describe('detectLoop - statistical method', () => {
it('should detect loops using statistical analysis', async () => {
const trace: CognitiveTrace = {
recent_actions: ['scroll_down', 'scroll_down', 'scroll_down', 'scroll_down'],
current_context: 'Scrolling repeatedly',
goal: 'Find target element',
};
const result = await sentinel.detectLoop(trace, 'statistical');
expect(result).toBeDefined();
expect(result.detected).toBeDefined();
expect(typeof result.confidence).toBe('number');
expect(result.statistical_metrics).toBeDefined();
expect(result.details).toBeDefined();
});
it('should calculate entropy correctly for repetitive actions', async () => {
const trace: CognitiveTrace = {
recent_actions: ['action1', 'action1', 'action1', 'action1'],
current_context: 'Repetitive context',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'statistical');
expect(result.statistical_metrics?.entropy_score).toBeDefined();
expect(result.statistical_metrics!.entropy_score!).toBeLessThan(1); // Low entropy for repetitive actions
});
it('should calculate entropy correctly for diverse actions', async () => {
const trace: CognitiveTrace = {
recent_actions: ['action1', 'action2', 'action3', 'action4'],
current_context: 'Diverse context',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'statistical');
expect(result.statistical_metrics?.entropy_score).toBeDefined();
expect(result.statistical_metrics!.entropy_score!).toBeGreaterThan(0);
});
it('should calculate variance for action contexts', async () => {
const trace: CognitiveTrace = {
recent_actions: ['click', 'scroll', 'click', 'scroll'],
current_context: 'Variable context',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'statistical');
expect(result.statistical_metrics?.variance_score).toBeDefined();
expect(result.statistical_metrics!.variance_score!).toBeGreaterThanOrEqual(0);
});
it('should detect trends in action sequences', async () => {
const trace: CognitiveTrace = {
recent_actions: ['action1', 'action2', 'action3', 'action4', 'action5'],
current_context: 'Progressive context',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'statistical');
expect(result.statistical_metrics?.trend_score).toBeDefined();
});
it('should handle short action sequences', async () => {
const trace: CognitiveTrace = {
recent_actions: ['action1'],
current_context: 'Single action',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'statistical');
expect(result.detected).toBe(false);
expect(result.confidence).toBe(0);
});
it('should handle empty action sequences', async () => {
const trace: CognitiveTrace = {
recent_actions: [],
current_context: 'No actions',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'statistical');
expect(result.detected).toBe(false);
expect(result.confidence).toBe(0);
});
});
describe('detectLoop - pattern method', () => {
it('should detect action repetition patterns', async () => {
const trace: CognitiveTrace = {
recent_actions: ['click', 'click', 'click', 'click', 'click'],
current_context: 'Clicking repeatedly',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'pattern');
expect(result).toBeDefined();
expect(typeof result.detected).toBe('boolean');
expect(typeof result.confidence).toBe('number');
if (result.detected) {
expect(result.type).toBeDefined();
}
});
it('should detect alternating patterns', async () => {
const trace: CognitiveTrace = {
recent_actions: ['scroll_up', 'scroll_down', 'scroll_up', 'scroll_down', 'scroll_up'],
current_context: 'Scrolling back and forth',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'pattern');
expect(result).toBeDefined();
if (result.detected) {
expect(['action_repetition', 'progress_stagnation']).toContain(result.type);
}
});
it('should detect state invariance', async () => {
const trace: CognitiveTrace = {
recent_actions: ['action1', 'action2', 'action1', 'action2'],
current_context: 'same_context',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'pattern');
expect(result).toBeDefined();
if (result.detected) {
expect(result.type).toBeDefined();
}
});
it('should handle progress indicators', async () => {
const trace: CognitiveTrace = {
recent_actions: ['click', 'success', 'click', 'completed'],
current_context: 'Making progress',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'pattern');
// Should be less likely to detect loop with progress indicators
expect(result).toBeDefined();
});
it('should adjust thresholds for progress indicators', async () => {
const trace: CognitiveTrace = {
recent_actions: ['action1', 'found', 'action1', 'success'],
current_context: 'Progress being made',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'pattern');
// Progress indicators should reduce likelihood of detecting false loops
expect(result).toBeDefined();
});
});
describe('detectLoop - hybrid method', () => {
it('should combine statistical and pattern detection', async () => {
const trace: CognitiveTrace = {
recent_actions: ['scroll_down', 'scroll_down', 'scroll_down', 'click', 'scroll_down'],
current_context: 'Mixed behavior',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'hybrid');
expect(result).toBeDefined();
expect(result.details).toBeDefined();
expect(typeof result.confidence).toBe('number');
if (result.details.dominant_method) {
expect(typeof result.details.dominant_method).toBe('string');
}
});
it('should provide detailed metrics in hybrid mode', async () => {
const trace: CognitiveTrace = {
recent_actions: ['action1', 'action2', 'action1', 'action2', 'action1'],
current_context: 'Alternating pattern',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'hybrid');
expect(result.statistical_metrics).toBeDefined();
expect(result.details.metrics).toBeDefined();
});
it('should handle conflicting detection results', async () => {
const trace: CognitiveTrace = {
recent_actions: ['unique1', 'unique2', 'unique3', 'unique4'],
current_context: 'Diverse actions',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'hybrid');
expect(result).toBeDefined();
expect(typeof result.confidence).toBe('number');
});
});
describe('semantic analysis integration', () => {
it('should use semantic similarity for context analysis', async () => {
const trace: CognitiveTrace = {
recent_actions: ['click_button', 'press_button', 'tap_button'],
current_context: 'Similar actions with different names',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'hybrid');
expect(result).toBeDefined();
// Should recognize semantic similarity between actions
});
it('should handle semantic analysis errors gracefully', async () => {
const { semanticAnalyzer } = await import('../src/semantic-analyzer');
const originalMethod = semanticAnalyzer.computeSimilarityMatrix;
// Mock the method to throw an error
(semanticAnalyzer.computeSimilarityMatrix as jest.MockedFunction<any>) = jest
.fn()
.mockRejectedValue(new Error('Semantic analysis failed'));
const trace: CognitiveTrace = {
recent_actions: ['action1', 'action2'],
current_context: 'Test context',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'hybrid');
// Restore the original method
(semanticAnalyzer.computeSimilarityMatrix as any) = originalMethod;
expect(result).toBeDefined();
expect(typeof result.detected).toBe('boolean');
});
});
describe('state history and convergence', () => {
it('should manage state history size limit', async () => {
// Create traces that will exceed maxHistorySize (20)
for (let i = 0; i < 25; i++) {
const trace: CognitiveTrace = {
recent_actions: [`action_${i}`],
current_context: `context_${i}`,
goal: 'Test goal',
};
await sentinel.detectLoop(trace, 'pattern');
}
// The state history should have been trimmed
const config = sentinel.getConfig();
expect(config).toBeDefined();
});
it('should detect state convergence with high convergence score', async () => {
// Create trace with repeated context to trigger convergence
const trace: CognitiveTrace = {
recent_actions: ['action1', 'action2', 'action1', 'action2', 'action1'],
current_context: 'same_context',
goal: 'Test goal',
};
// Run multiple times with same context to build history
for (let i = 0; i < 5; i++) {
await sentinel.detectLoop(trace, 'pattern');
}
const result = await sentinel.detectLoop(trace, 'pattern');
expect(result).toBeDefined();
if (result.detected && result.type === 'state_invariance') {
expect(result.actions_involved).toBeDefined();
expect(Array.isArray(result.actions_involved)).toBe(true);
}
});
it('should handle context with extractable features', async () => {
const trace: CognitiveTrace = {
recent_actions: ['click', 'scroll', 'click'],
current_context: 'page_url=test.com status=loading user=admin progress=50%',
goal: 'Navigate test page',
};
const result = await sentinel.detectLoop(trace, 'pattern');
expect(result).toBeDefined();
expect(typeof result.confidence).toBe('number');
});
});
describe('edge cases and error handling', () => {
it('should handle null or undefined trace', async () => {
// Create an invalid trace that mimics null behavior
const invalidTrace = {
recent_actions: null,
current_context: null,
goal: null,
} as any;
const result = await sentinel.detectLoop(invalidTrace, 'hybrid');
expect(result.detected).toBe(false);
expect(result.confidence).toBe(0);
});
it('should handle trace with missing properties', async () => {
const incompleteTrace: any = {
recent_actions: ['action1', 'action2'],
// Missing current_context and goal
};
const result = await sentinel.detectLoop(incompleteTrace, 'hybrid');
expect(result).toBeDefined();
});
it('should handle very long action sequences', async () => {
const longActions = Array(1000)
.fill('action')
.map((_, i) => `action_${i % 10}`);
const trace: CognitiveTrace = {
recent_actions: longActions,
current_context: 'Very long sequence',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'hybrid');
expect(result).toBeDefined();
});
it('should handle special characters in actions', async () => {
const trace: CognitiveTrace = {
recent_actions: ['@#$%', '中文', '🎉', 'normal_action'],
current_context: 'Special characters',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'hybrid');
expect(result).toBeDefined();
});
it('should handle numeric action names', async () => {
const trace: CognitiveTrace = {
recent_actions: ['123', '456', '123', '456'],
current_context: 'Numeric actions',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'hybrid');
expect(result).toBeDefined();
});
it('should handle empty string actions', async () => {
const trace: CognitiveTrace = {
recent_actions: ['', 'action', '', 'action'],
current_context: 'Empty string actions',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'hybrid');
expect(result).toBeDefined();
});
it('should handle whitespace-only actions', async () => {
const trace: CognitiveTrace = {
recent_actions: [' ', '\t\t', '\n\n', 'action'],
current_context: 'Whitespace actions',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'hybrid');
expect(result).toBeDefined();
});
});
describe('performance and optimization', () => {
it('should process large traces efficiently', async () => {
const largeTrace: CognitiveTrace = {
recent_actions: Array(500)
.fill('action')
.map((_, i) => `action_${i % 20}`),
current_context: 'Large trace test',
goal: 'Performance test',
};
const start = Date.now();
const result = await sentinel.detectLoop(largeTrace, 'hybrid');
const duration = Date.now() - start;
expect(result).toBeDefined();
expect(duration).toBeLessThan(5000); // Should complete within 5 seconds
});
it('should handle multiple concurrent detections', async () => {
const traces = Array(10)
.fill(null)
.map((_, i) => ({
recent_actions: [`action_${i}`, `action_${i}`, `action_${i}`],
current_context: `Context ${i}`,
goal: `Goal ${i}`,
}));
const promises = traces.map((trace) => sentinel.detectLoop(trace, 'hybrid'));
const results = await Promise.all(promises);
expect(results).toHaveLength(10);
results.forEach((result) => {
expect(result).toBeDefined();
expect(typeof result.confidence).toBe('number');
});
});
});
describe('configuration-based behavior', () => {
it('should respect minimum actions threshold', async () => {
const shortTrace: CognitiveTrace = {
recent_actions: ['action1', 'action1'], // Below min_actions_for_detection (3)
current_context: 'Short trace',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(shortTrace, 'pattern');
expect(result.detected).toBe(false);
expect(result.confidence).toBe(0);
});
it('should use custom thresholds', async () => {
const strictConfig = {
min_actions_for_detection: 3,
alternating_threshold: 0.1, // Very strict
repetition_threshold: 0.1, // Very strict
};
const strictSentinel = new Sentinel(strictConfig);
const trace: CognitiveTrace = {
recent_actions: ['action1', 'action2', 'action1'],
current_context: 'Strict test',
goal: 'Test goal',
};
const result = await strictSentinel.detectLoop(trace, 'pattern');
expect(result).toBeDefined();
// Should be more likely to detect with strict thresholds
});
it('should adjust behavior with progress indicators', async () => {
const progressTrace: CognitiveTrace = {
recent_actions: ['action1', 'success', 'action1', 'completed'],
current_context: 'Progress being made',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(progressTrace, 'pattern');
expect(result).toBeDefined();
// Progress indicators should reduce loop detection likelihood
});
});
describe('actions involved detection', () => {
it('should detect actions for different loop types', async () => {
// Test action_repetition case
const repetitionTrace: CognitiveTrace = {
recent_actions: ['click', 'click', 'click', 'scroll', 'scroll'],
current_context: 'Repetition test',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(repetitionTrace, 'hybrid');
if (result.detected) {
expect(result.actions_involved).toBeDefined();
expect(Array.isArray(result.actions_involved)).toBe(true);
}
});
it('should handle cyclical pattern actions', async () => {
const cyclicalTrace: CognitiveTrace = {
recent_actions: ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b'],
current_context: 'Cyclical test',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(cyclicalTrace, 'pattern');
expect(result).toBeDefined();
if (result.detected) {
expect(result.actions_involved).toBeDefined();
}
});
it('should handle oscillation pattern actions', async () => {
const oscillationTrace: CognitiveTrace = {
recent_actions: ['up', 'down', 'up', 'down', 'up', 'down'],
current_context: 'Oscillation test',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(oscillationTrace, 'pattern');
expect(result).toBeDefined();
if (result.detected) {
expect(result.actions_involved).toBeDefined();
}
});
it('should handle alternating pattern actions', async () => {
const alternatingTrace: CognitiveTrace = {
recent_actions: ['left', 'right', 'left', 'right', 'left'],
current_context: 'Alternating test',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(alternatingTrace, 'pattern');
expect(result).toBeDefined();
if (result.detected) {
expect(result.actions_involved).toBeDefined();
}
});
it('should fall back to default cluster for unknown loop types', async () => {
// This will test the default case in getActionsInvolvedInLoop
const unknownTrace: CognitiveTrace = {
recent_actions: ['action1', 'action2', 'action3', 'action1', 'action2'],
current_context: 'Unknown pattern test',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(unknownTrace, 'statistical');
expect(result).toBeDefined();
expect(Array.isArray(result.actions_involved)).toBe(true);
});
});
describe('statistical calculations', () => {
it('should calculate cyclicity score', async () => {
const cyclicTrace: CognitiveTrace = {
recent_actions: ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b'],
current_context: 'Cyclic pattern',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(cyclicTrace, 'statistical');
expect(result.statistical_metrics?.cyclicity_score).toBeDefined();
expect(result.statistical_metrics!.cyclicity_score!).toBeGreaterThan(0);
});
it('should handle autocorrelation calculations', async () => {
const trace: CognitiveTrace = {
recent_actions: ['1', '2', '3', '1', '2', '3', '1', '2'],
current_context: 'Pattern test',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'statistical');
expect(result.statistical_metrics).toBeDefined();
expect(result.details.metrics).toBeDefined();
});
it('should normalize entropy scores', async () => {
const trace: CognitiveTrace = {
recent_actions: ['a', 'b', 'c', 'd', 'e'],
current_context: 'Entropy test',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'statistical');
expect(result.statistical_metrics?.entropy_score).toBeDefined();
expect(result.statistical_metrics!.entropy_score!).toBeGreaterThanOrEqual(0);
expect(result.statistical_metrics!.entropy_score!).toBeLessThanOrEqual(1);
});
it('should calculate moving averages', async () => {
const trace: CognitiveTrace = {
recent_actions: Array(20)
.fill('action')
.map((_, i) => `action_${i}`),
current_context: 'Moving average test',
goal: 'Test goal',
};
const result = await sentinel.detectLoop(trace, 'statistical');
expect(result.statistical_metrics?.trend_score).toBeDefined();
});
});
describe('basic functionality', () => {
it('should be properly constructed', () => {
expect(sentinel).toBeDefined();
expect(typeof sentinel.detectLoop).toBe('function');
expect(typeof sentinel.updateConfig).toBe('function');
});
it('should have configuration accessible', () => {
const config = sentinel.getConfig();
expect(config).toBeDefined();
expect(config.min_actions_for_detection).toBe(3);
});
});
describe('toString', () => {
it('should return a string representation', () => {
const str = sentinel.toString();
expect(typeof str).toBe('string');
expect(str.length).toBeGreaterThan(0);
});
it('should include configuration information', () => {
const str = sentinel.toString();
expect(typeof str).toBe('string');
expect(str.length).toBeGreaterThan(0);
});
});
});
