cognitive-core 0.1.2 → 0.2.1

package/tests/feature-toggles.test.ts

@@ -0,0 +1,275 @@
+/**
+ * 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

@@ -0,0 +1,210 @@
+/**
+ * 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',
+  });
+}

package/tests/gap-fixes.test.ts

@@ -24,6 +24,7 @@ import type { Playbook } from '../src/types/index.js';
 // Memory
 import { createMemorySystem, type MemorySystem } from '../src/memory/system.js';
 import { MetaMemory } from '../src/memory/meta.js';
+import { createSqlitePersistence } from '../src/persistence/index.js';
 
 // Learning
 import { MetaLearner, createMetaLearner } from '../src/learning/meta-learner.js';
@@ -209,7 +210,7 @@ describe('Gap 1: LLMPlaybookExtractor deletion', () => {
     expect('PlaybookExtractor' in learningExports).toBe(true);
     expect('MetaLearner' in learningExports).toBe(true);
     expect('PlaybookUsageInference' in learningExports).toBe(true);
-    expect('LearningPipeline' in learningExports).toBe(true);
+    expect('UnifiedLearningPipeline' in learningExports).toBe(true);
     expect('LearningEffectivenessTracker' in learningExports).toBe(true);
   });
 });
@@ -283,15 +284,19 @@ describe('Gap 4: MetaLearner.recordFromReflection', () => {
   let tempDir: string;
   let metaMemory: MetaMemory;
   let metaLearner: MetaLearner;
+  let persistence: any;
 
   beforeEach(async () => {
     tempDir = await mkdtemp(join(tmpdir(), 'meta-learner-test-'));
-    metaMemory = new MetaMemory(tempDir);
+    persistence = createSqlitePersistence({ baseDir: tempDir });
+    await persistence.init();
+    metaMemory = new MetaMemory(persistence);
     await metaMemory.init();
     metaLearner = createMetaLearner(metaMemory);
   });
 
   afterEach(async () => {
+    persistence.close();
     await rm(tempDir, { recursive: true, force: true });
   });
 
@@ -538,10 +543,13 @@ describe('Gap 5a: SolutionEvaluator.setTaskRunner', () => {
   let tempDir: string;
   let memory: MemorySystem;
   let agentManager: AgentManager;
+  let persistence: any;
 
   beforeEach(async () => {
     tempDir = await mkdtemp(join(tmpdir(), 'evaluator-test-'));
-    memory = createMemorySystem(tempDir);
+    persistence = createSqlitePersistence({ baseDir: tempDir });
+    await persistence.init();
+    memory = createMemorySystem(persistence, tempDir);
     await memory.init();
     agentManager = createAgentManager(memory);
     const mockBackend = createMockBackend({ success: true, result: 'ok', durationMs: 10 });
@@ -550,6 +558,7 @@ describe('Gap 5a: SolutionEvaluator.setTaskRunner', () => {
 
   afterEach(async () => {
     await memory.close();
+    persistence.close();
     await rm(tempDir, { recursive: true, force: true });
   });
 
@@ -686,10 +695,13 @@ describe('Gap 5b: RefinementLoop.setTaskRunner', () => {
   let memory: MemorySystem;
   let agentManager: AgentManager;
   let mockBackend: MockBackend;
+  let persistence: any;
 
   beforeEach(async () => {
     tempDir = await mkdtemp(join(tmpdir(), 'refine-runner-test-'));
-    memory = createMemorySystem(tempDir);
+    persistence = createSqlitePersistence({ baseDir: tempDir });
+    await persistence.init();
+    memory = createMemorySystem(persistence, tempDir);
     await memory.init();
     agentManager = createAgentManager(memory);
     mockBackend = createMockBackend({
@@ -702,6 +714,7 @@ describe('Gap 5b: RefinementLoop.setTaskRunner', () => {
 
   afterEach(async () => {
     await memory.close();
+    persistence.close();
     await rm(tempDir, { recursive: true, force: true });
   });