cognitive-core 0.2.4 → 0.3.1

package/tests/feature-toggles.test.ts

@@ -1,275 +0,0 @@
-/**
- * Tests that ruvector-inspired features are individually toggleable
- * via config.features without breaking the system.
- */
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { Atlas, createAtlas } from '../src/atlas.js';
-import { createDefaultConfig, type AtlasConfig } from '../src/types/config.js';
-import { InstantLoop } from '../src/learning/instant-loop.js';
-import { MemorySystem } from '../src/memory/system.js';
-import { UnifiedLearningPipeline } from '../src/learning/unified-pipeline.js';
-import {
-  createTrajectory,
-  type Trajectory,
-} from '../src/types/trajectory.js';
-import { createTask } from '../src/types/task.js';
-import { createStep } from '../src/types/step.js';
-import { successOutcome, failureOutcome } from '../src/types/outcome.js';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { createSqlitePersistence } from '../src/persistence/index.js';
-
-function makeTrajectory(overrides?: {
-  success?: boolean;
-  domain?: string;
-  errorInfo?: string;
-}): Trajectory {
-  const success = overrides?.success ?? true;
-  return createTrajectory({
-    task: createTask({
-      description: 'Fix the typescript import error',
-      domain: overrides?.domain ?? 'typescript',
-    }),
-    steps: [
-      createStep({
-        thought: 'Let me check the imports',
-        action: 'ReadFile src/index.ts',
-        observation: 'File content: import { foo } from "./bar"',
-      }),
-    ],
-    outcome: success
-      ? successOutcome('Fixed import path')
-      : failureOutcome(overrides?.errorInfo ?? 'Could not resolve import'),
-    agentId: 'test-agent',
-  });
-}
-
-describe('Feature Toggles', () => {
-  describe('config defaults', () => {
-    it('should default all feature toggles to true', () => {
-      const config = createDefaultConfig();
-      expect(config.features.instantLoop).toBe(true);
-      expect(config.features.reflexion).toBe(true);
-      expect(config.features.coherenceChecking).toBe(true);
-      expect(config.features.reasoningBank).toBe(true);
-      expect(config.features.causalExtraction).toBe(true);
-      expect(config.features.temporalCompression).toBe(true);
-    });
-
-    it('should allow disabling individual features', () => {
-      const config = createDefaultConfig({
-        features: {
-          instantLoop: false,
-          reflexion: false,
-          coherenceChecking: false,
-          reasoningBank: false,
-          causalExtraction: false,
-          temporalCompression: false,
-        },
-      });
-      expect(config.features.instantLoop).toBe(false);
-      expect(config.features.reflexion).toBe(false);
-      expect(config.features.coherenceChecking).toBe(false);
-      expect(config.features.reasoningBank).toBe(false);
-      expect(config.features.causalExtraction).toBe(false);
-      expect(config.features.temporalCompression).toBe(false);
-    });
-
-    it('should allow partial feature overrides', () => {
-      const config = createDefaultConfig({
-        features: { instantLoop: false },
-      });
-      expect(config.features.instantLoop).toBe(false);
-      // Others remain true
-      expect(config.features.reflexion).toBe(true);
-      expect(config.features.causalExtraction).toBe(true);
-    });
-  });
-
-  describe('Atlas with features disabled', () => {
-    let tempDir: string;
-
-    beforeEach(async () => {
-      tempDir = await mkdtemp(join(tmpdir(), 'atlas-feature-toggle-test-'));
-    });
-
-    afterEach(async () => {
-      await rm(tempDir, { recursive: true, force: true });
-    });
-
-    it('should expose unified learning pipeline', async () => {
-      const atlas = createAtlas({
-        storage: { baseDir: tempDir },
-      });
-      await atlas.init();
-
-      expect(atlas.getLearning()).toBeDefined();
-      expect(atlas.getLearning().getAccumulatedCount()).toBe(0);
-      await atlas.close();
-    });
-
-    it('should processTrajectory and return ImmediateResult', async () => {
-      const atlas = createAtlas({
-        storage: { baseDir: tempDir },
-        features: { reflexion: false, causalExtraction: false },
-      });
-      await atlas.init();
-
-      const trajectory = makeTrajectory();
-      const result = await atlas.processTrajectory(trajectory);
-      expect(result.instantLoop).toBeDefined();
-      expect(result.instantLoop.experienceId).toBeDefined();
-      expect(result.batchTriggered).toBe(false);
-
-      await atlas.close();
-    });
-
-    it('should work with all features disabled', async () => {
-      const atlas = createAtlas({
-        storage: { baseDir: tempDir },
-        features: {
-          instantLoop: false,
-          reflexion: false,
-          coherenceChecking: false,
-          reasoningBank: false,
-          causalExtraction: false,
-          temporalCompression: false,
-        },
-      });
-      await atlas.init();
-
-      const trajectory = makeTrajectory();
-      const result = await atlas.processTrajectory(trajectory);
-      expect(result.instantLoop).toBeDefined();
-      expect(result.instantLoop.experienceId).toBeDefined();
-
-      await atlas.close();
-    });
-  });
-
-  describe('InstantLoop toggles', () => {
-    let tempDir: string;
-    let memory: MemorySystem;
-    let persistence: any;
-
-    beforeEach(async () => {
-      tempDir = await mkdtemp(join(tmpdir(), 'atlas-il-toggle-test-'));
-      persistence = createSqlitePersistence({ baseDir: tempDir });
-      await persistence.init();
-      memory = new MemorySystem(persistence, tempDir);
-      await memory.init();
-    });
-
-    afterEach(async () => {
-      await memory.close();
-      persistence.close();
-      await rm(tempDir, { recursive: true, force: true });
-    });
-
-    it('should skip reflexion when enableReflexion is false', async () => {
-      const loop = new InstantLoop(memory, { enableReflexion: false });
-      const trajectory = makeTrajectory();
-      const result = await loop.process(trajectory);
-
-      expect(result.reflexionEpisodeId).toBeUndefined();
-      expect(result.experienceId).toBeDefined();
-    });
-
-    it('should generate reflexion by default', async () => {
-      const loop = new InstantLoop(memory);
-      const trajectory = makeTrajectory();
-      const result = await loop.process(trajectory);
-
-      expect(result.reflexionEpisodeId).toBeDefined();
-    });
-
-    it('should skip causal extraction when enableCausalExtraction is false', async () => {
-      const loop = new InstantLoop(memory, { enableCausalExtraction: false });
-      const trajectory = makeTrajectory();
-      const result = await loop.process(trajectory);
-
-      expect(result.causalEdgesExtracted).toBe(0);
-      expect(result.experienceId).toBeDefined();
-    });
-
-    it('should extract causal edges by default', async () => {
-      const loop = new InstantLoop(memory);
-      const trajectory = makeTrajectory();
-      const result = await loop.process(trajectory);
-
-      expect(result.causalEdgesExtracted).toBeGreaterThan(0);
-    });
-  });
-
-  describe('UnifiedLearningPipeline toggles', () => {
-    let tempDir: string;
-    let memory: MemorySystem;
-    let persistence: any;
-
-    beforeEach(async () => {
-      tempDir = await mkdtemp(join(tmpdir(), 'atlas-lp-toggle-test-'));
-      persistence = createSqlitePersistence({ baseDir: tempDir });
-      await persistence.init();
-      memory = new MemorySystem(persistence, tempDir);
-      await memory.init();
-    });
-
-    afterEach(async () => {
-      await memory.close();
-      persistence.close();
-      await rm(tempDir, { recursive: true, force: true });
-    });
-
-    it('should skip temporal compression when disabled', async () => {
-      const pipeline = new UnifiedLearningPipeline(memory, {
-        features: { temporalCompression: false, reasoningBank: true },
-        batch: { learning: { minTrajectories: 10 }, energy: { countThreshold: 100 } },
-      }, persistence);
-      await pipeline.init();
-
-      // Process enough trajectories, then force batch
-      for (let i = 0; i < 10; i++) {
-        await pipeline.processTrajectory(makeTrajectory({ domain: 'test' }));
-      }
-
-      const result = await pipeline.runBatch();
-      // Compression fields should be zero when disabled
-      expect(result.experiencesCompressed.promoted).toBe(0);
-      expect(result.experiencesCompressed.demoted).toBe(0);
-      expect(result.experiencesCompressed.evicted).toBe(0);
-    });
-
-    it('should skip reasoning bank clustering when disabled', async () => {
-      const pipeline = new UnifiedLearningPipeline(memory, {
-        features: { temporalCompression: true, reasoningBank: false },
-        batch: { learning: { minTrajectories: 10 }, energy: { countThreshold: 100 } },
-      }, persistence);
-      await pipeline.init();
-
-      for (let i = 0; i < 10; i++) {
-        await pipeline.processTrajectory(makeTrajectory({ domain: 'test' }));
-      }
-
-      // Should not throw even without reasoning bank
-      const result = await pipeline.runBatch();
-      expect(result.trajectoriesProcessed).toBe(10);
-    });
-
-    it('should work with both disabled', async () => {
-      const pipeline = new UnifiedLearningPipeline(memory, {
-        features: { temporalCompression: false, reasoningBank: false },
-        batch: { learning: { minTrajectories: 10 }, energy: { countThreshold: 100 } },
-      }, persistence);
-      await pipeline.init();
-
-      for (let i = 0; i < 10; i++) {
-        await pipeline.processTrajectory(makeTrajectory({ domain: 'test' }));
-      }
-
-      const result = await pipeline.runBatch();
-      expect(result.trajectoriesProcessed).toBe(10);
-      expect(result.experiencesCompressed.evicted).toBe(0);
-    });
-  });
-});

package/tests/fixtures/behavioral-trajectories.ts

@@ -1,210 +0,0 @@
-/**
- * Story-based trajectory fixtures for behavioral tests.
- *
- * Each factory produces a realistic trajectory with semantically meaningful
- * steps — the kind of thing an agent actually does when solving a task.
- */
-
-import { createTrajectory, type Trajectory } from '../../src/types/trajectory.js';
-import { createTask } from '../../src/types/task.js';
-import { createStep } from '../../src/types/step.js';
-import { successOutcome, failureOutcome } from '../../src/types/outcome.js';
-
-/**
- * Successful "fix broken TypeScript import" trajectory.
- * Steps: read file → identify wrong path → edit import → run tsc → pass.
- */
-export function makeTypescriptImportFix(variant: number): Trajectory {
-  const files = ['routes.ts', 'utils.ts', 'handler.ts', 'service.ts', 'controller.ts', 'middleware.ts'];
-  const file = files[variant % files.length];
-  return createTrajectory({
-    task: createTask({
-      domain: 'typescript',
-      description: `Fix broken TypeScript import in src/${file}`,
-    }),
-    steps: [
-      createStep({
-        thought: `Check the import statements in ${file}`,
-        action: `ReadFile src/${file}`,
-        observation: `import { UserService } from "./services/user"\n// TS2307: Cannot find module './services/user'`,
-      }),
-      createStep({
-        thought: 'The import path is missing the .js extension required by ESM',
-        action: `EditFile src/${file}`,
-        observation: `Updated: import { UserService } from "./services/user.js"`,
-      }),
-      createStep({
-        thought: 'Verify the fix compiles',
-        action: 'Bash tsc --noEmit',
-        observation: 'Compilation successful. No errors found.',
-      }),
-    ],
-    outcome: successOutcome(`Fixed ESM import extension in src/${file}`),
-    agentId: 'test-agent',
-  });
-}
-
-/**
- * Successful "fix Python type error" trajectory.
- * Steps: read traceback → identify wrong type → edit function → run pytest → pass.
- */
-export function makePythonTypeFix(variant: number): Trajectory {
-  const files = ['api.py', 'models.py', 'views.py', 'serializers.py', 'utils.py'];
-  const file = files[variant % files.length];
-  return createTrajectory({
-    task: createTask({
-      domain: 'python',
-      description: `Fix Python type error in ${file}`,
-    }),
-    steps: [
-      createStep({
-        thought: `Read the failing file ${file}`,
-        action: `ReadFile ${file}`,
-        observation: `def process_items(items: list[str]) -> int:\n    return items.count`,
-      }),
-      createStep({
-        thought: 'The function returns the method reference instead of calling it',
-        action: `EditFile ${file}`,
-        observation: `Updated: return items.count()  # was missing parentheses`,
-      }),
-      createStep({
-        thought: 'Run the tests to verify',
-        action: 'Bash pytest -x',
-        observation: '5 passed in 0.3s',
-      }),
-    ],
-    outcome: successOutcome(`Fixed missing parentheses in ${file}`),
-    agentId: 'test-agent',
-  });
-}
-
-/**
- * Failed "fix authentication bypass" trajectory.
- * Steps: read auth code → attempt fix → tests still fail.
- */
-export function makeFailedAuthFix(errorDetail: string): Trajectory {
-  return createTrajectory({
-    task: createTask({
-      domain: 'security',
-      description: 'Fix authentication bypass vulnerability in auth middleware',
-    }),
-    steps: [
-      createStep({
-        thought: 'Read the auth middleware to understand the vulnerability',
-        action: 'ReadFile src/middleware/auth.ts',
-        observation: 'JWT token validation skips expiry check when token has admin role',
-      }),
-      createStep({
-        thought: 'Add expiry validation for all tokens regardless of role',
-        action: 'EditFile src/middleware/auth.ts',
-        observation: 'Added: if (isTokenExpired(token)) throw new AuthError("expired")',
-      }),
-      createStep({
-        thought: 'Run the security test suite',
-        action: 'Bash npm run test:security',
-        observation: `FAIL: ${errorDetail}`,
-      }),
-    ],
-    outcome: failureOutcome(errorDetail),
-    agentId: 'test-agent',
-  });
-}
-
-/**
- * Successful Kubernetes deployment — completely different domain.
- */
-export function makeKubernetesDeploy(): Trajectory {
-  return createTrajectory({
-    task: createTask({
-      domain: 'devops',
-      description: 'Deploy updated API service to Kubernetes staging cluster',
-    }),
-    steps: [
-      createStep({
-        thought: 'Check current deployment status',
-        action: 'Bash kubectl get pods -n staging',
-        observation: 'api-service-7f8d9c 1/1 Running 0 12h',
-      }),
-      createStep({
-        thought: 'Apply the new deployment manifest',
-        action: 'Bash kubectl apply -f k8s/api-service.yaml',
-        observation: 'deployment.apps/api-service configured',
-      }),
-      createStep({
-        thought: 'Wait for rollout to complete',
-        action: 'Bash kubectl rollout status deployment/api-service -n staging',
-        observation: 'deployment "api-service" successfully rolled out',
-      }),
-    ],
-    outcome: successOutcome('Deployed api-service v2.3.1 to staging'),
-    agentId: 'test-agent',
-  });
-}
-
-/**
- * Inefficient trajectory with many repeated read actions.
- * Useful for testing reflexion critique of wasted steps.
- */
-export function makeInefficient(stepCount: number): Trajectory {
-  const steps = [];
-  for (let i = 0; i < stepCount; i++) {
-    steps.push(
-      createStep({
-        thought: `Check config again (attempt ${i + 1})`,
-        action: 'ReadFile src/config.ts',
-        observation: 'export const config = { debug: false, port: 3000 }',
-      }),
-    );
-  }
-  // Finally do the actual fix
-  steps.push(
-    createStep({
-      thought: 'After re-reading many times, change the debug flag',
-      action: 'EditFile src/config.ts',
-      observation: 'Updated: debug: true',
-    }),
-  );
-
-  return createTrajectory({
-    task: createTask({
-      domain: 'typescript',
-      description: 'Enable debug mode in application config',
-    }),
-    steps,
-    outcome: failureOutcome('Timed out after too many read operations'),
-    agentId: 'test-agent',
-  });
-}
-
-/**
- * Successful trajectory with a specific solution description,
- * useful for verifying causal edge extraction.
- */
-export function makeSuccessfulWithSolution(
-  domain: string,
-  description: string,
-  solution: string,
-): Trajectory {
-  return createTrajectory({
-    task: createTask({ domain, description }),
-    steps: [
-      createStep({
-        thought: 'Analyze the problem',
-        action: 'ReadFile src/main.ts',
-        observation: 'Found the issue',
-      }),
-      createStep({
-        thought: 'Apply the fix',
-        action: 'EditFile src/main.ts',
-        observation: 'File updated',
-      }),
-      createStep({
-        thought: 'Verify',
-        action: 'Bash npm test',
-        observation: 'All tests passed',
-      }),
-    ],
-    outcome: successOutcome(solution),
-    agentId: 'test-agent',
-  });
-}