Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

16.4 KB
Raw Blame
import { describe, it, expect, vi, beforeEach } from 'vitest';
import express from 'express';
import { request } from '../lib/testHelper.js';
import learningRoutes from './cosLearningRoutes.js';

vi.mock('../services/taskLearning.js', () => ({
  getLearningInsights: vi.fn(),
  getAllTaskDurations: vi.fn(),
  backfillFromHistory: vi.fn(),
  getSkippedTaskTypes: vi.fn(),
  resetTaskTypeLearning: vi.fn(),
  getAdaptiveCooldownMultiplier: vi.fn(),
  getRoutingAccuracy: vi.fn(),
  getPerformanceSummary: vi.fn(),
  getLearningSummary: vi.fn(),
  getRecentInsights: vi.fn(),
  recordLearningInsight: vi.fn(),
  getAllPromptRecommendations: vi.fn(),
  getPromptImprovementRecommendations: vi.fn(),
  recalculateDurationStats: vi.fn(),
  getConfidenceLevels: vi.fn(),
  getTaskTypeConfidence: vi.fn(),
  getDismissedRecommendations: vi.fn(),
  dismissRecommendation: vi.fn(),
  restoreRecommendation: vi.fn(),
  clearDismissedRecommendations: vi.fn()
}));

vi.mock('../services/weeklyDigest.js', () => ({
  getWeeklyDigest: vi.fn(),
  listWeeklyDigests: vi.fn(),
  getCurrentWeekProgress: vi.fn(),
  generateTextSummary: vi.fn(),
  generateWeeklyDigest: vi.fn(),
  compareWeeks: vi.fn()
}));

vi.mock('../services/cosState.js', () => ({
  loadState: vi.fn().mockResolvedValue({ config: { confidenceAutoApproval: {} } })
}));

import * as taskLearning from '../services/taskLearning.js';
import * as weeklyDigest from '../services/weeklyDigest.js';

describe('CoS Learning Routes', () => {
  let app;

  beforeEach(() => {
    app = express();
    app.use(express.json());
    app.use('/api/cos', learningRoutes);
    vi.clearAllMocks();
  });

  describe('GET /api/cos/learning', () => {
    it('should return learning insights', async () => {
      taskLearning.getLearningInsights.mockResolvedValue({ taskTypes: {}, skippedTypes: [] });

      const response = await request(app).get('/api/cos/learning');

      expect(response.status).toBe(200);
      expect(response.body).toHaveProperty('taskTypes');
    });
  });

  describe('GET /api/cos/learning/durations', () => {
    it('should return task durations', async () => {
      taskLearning.getAllTaskDurations.mockResolvedValue({ 'app-improve': { avg: 300 } });

      const response = await request(app).get('/api/cos/learning/durations');

      expect(response.status).toBe(200);
    });
  });

  describe('POST /api/cos/learning/backfill', () => {
    it('should backfill learning data', async () => {
      taskLearning.backfillFromHistory.mockResolvedValue(15);

      const response = await request(app).post('/api/cos/learning/backfill');

      expect(response.status).toBe(200);
      expect(response.body.backfilledCount).toBe(15);
    });
  });

  describe('GET /api/cos/learning/skipped', () => {
    it('should return skipped task types', async () => {
      taskLearning.getSkippedTaskTypes.mockResolvedValue([{ type: 'deploy', rate: 0.2 }]);

      const response = await request(app).get('/api/cos/learning/skipped');

      expect(response.status).toBe(200);
      expect(response.body.skippedCount).toBe(1);
    });

    it('should return message when no types skipped', async () => {
      taskLearning.getSkippedTaskTypes.mockResolvedValue([]);

      const response = await request(app).get('/api/cos/learning/skipped');

      expect(response.status).toBe(200);
      expect(response.body.skippedCount).toBe(0);
      expect(response.body.message).toContain('No task types');
    });
  });

  describe('POST /api/cos/learning/reset/:taskType', () => {
    it('should reset learning data for task type', async () => {
      taskLearning.resetTaskTypeLearning.mockResolvedValue({ reset: true });

      const response = await request(app).post('/api/cos/learning/reset/deploy');

      expect(response.status).toBe(200);
      expect(response.body.reset).toBe(true);
    });

    it('should return 404 if task type not found', async () => {
      taskLearning.resetTaskTypeLearning.mockResolvedValue({ reset: false });

      const response = await request(app).post('/api/cos/learning/reset/unknown');

      expect(response.status).toBe(404);
    });
  });

  describe('GET /api/cos/learning/cooldown/:taskType', () => {
    it('should return cooldown info', async () => {
      taskLearning.getAdaptiveCooldownMultiplier.mockResolvedValue({ multiplier: 1.5, reason: 'low success' });

      const response = await request(app).get('/api/cos/learning/cooldown/deploy');

      expect(response.status).toBe(200);
      expect(response.body.taskType).toBe('deploy');
      expect(response.body.multiplier).toBe(1.5);
    });
  });

  describe('GET /api/cos/learning/routing', () => {
    it('should return routing accuracy', async () => {
      taskLearning.getRoutingAccuracy.mockResolvedValue({ accuracy: 0.85 });

      const response = await request(app).get('/api/cos/learning/routing');

      expect(response.status).toBe(200);
    });
  });

  describe('GET /api/cos/learning/performance', () => {
    it('should return performance summary', async () => {
      taskLearning.getPerformanceSummary.mockResolvedValue({ overall: 0.75 });

      const response = await request(app).get('/api/cos/learning/performance');

      expect(response.status).toBe(200);
    });
  });

  describe('GET /api/cos/learning/summary', () => {
    it('should return learning health summary', async () => {
      taskLearning.getLearningSummary.mockResolvedValue({ healthy: true });

      const response = await request(app).get('/api/cos/learning/summary');

      expect(response.status).toBe(200);
    });
  });

  describe('GET /api/cos/learning/insights', () => {
    it('should return recent insights with default limit', async () => {
      taskLearning.getRecentInsights.mockResolvedValue([{ message: 'insight 1' }]);

      const response = await request(app).get('/api/cos/learning/insights');

      expect(response.status).toBe(200);
      expect(response.body.count).toBe(1);
      expect(taskLearning.getRecentInsights).toHaveBeenCalledWith(10);
    });

    it('should respect custom limit', async () => {
      taskLearning.getRecentInsights.mockResolvedValue([]);

      const response = await request(app).get('/api/cos/learning/insights?limit=5');

      expect(response.status).toBe(200);
      expect(taskLearning.getRecentInsights).toHaveBeenCalledWith(5);
    });
  });

  describe('POST /api/cos/learning/insights', () => {
    it('should record a learning insight', async () => {
      taskLearning.recordLearningInsight.mockResolvedValue({ id: 'i1', message: 'test' });

      const response = await request(app)
        .post('/api/cos/learning/insights')
        .send({ message: 'test insight', type: 'discovery' });

      expect(response.status).toBe(200);
      expect(response.body.success).toBe(true);
    });

    it('should return 400 if message is missing', async () => {
      const response = await request(app)
        .post('/api/cos/learning/insights')
        .send({ type: 'observation' });

      expect(response.status).toBe(400);
    });
  });

  describe('GET /api/cos/learning/recommendations', () => {
    it('should return prompt recommendations with summary', async () => {
      taskLearning.getAllPromptRecommendations.mockResolvedValue([
        { status: 'critical', taskType: 'deploy' },
        { status: 'good', taskType: 'review' }
      ]);

      const response = await request(app).get('/api/cos/learning/recommendations');

      expect(response.status).toBe(200);
      expect(response.body.count).toBe(2);
      expect(response.body.summary.critical).toBe(1);
      expect(response.body.summary.good).toBe(1);
    });
  });

  describe('GET /api/cos/learning/recommendations/:taskType', () => {
    it('should return recommendations for specific task type', async () => {
      taskLearning.getPromptImprovementRecommendations.mockResolvedValue({ suggestions: [] });

      const response = await request(app).get('/api/cos/learning/recommendations/deploy');

      expect(response.status).toBe(200);
      expect(taskLearning.getPromptImprovementRecommendations).toHaveBeenCalledWith('deploy');
    });
  });

  describe('GET /api/cos/learning/recommendations/dismissed', () => {
    it('should return dismissed recommendations list', async () => {
      taskLearning.getDismissedRecommendations.mockResolvedValue([
        { id: 'error-pattern:unknown', dismissedAt: '2026-05-07T00:00:00.000Z', snapshot: { kind: 'count', value: 74 } }
      ]);

      const response = await request(app).get('/api/cos/learning/recommendations/dismissed');

      expect(response.status).toBe(200);
      expect(response.body.count).toBe(1);
      expect(response.body.dismissed[0].id).toBe('error-pattern:unknown');
    });

    it('should not be intercepted by the :taskType handler', async () => {
      taskLearning.getDismissedRecommendations.mockResolvedValue([]);

      await request(app).get('/api/cos/learning/recommendations/dismissed');

      expect(taskLearning.getDismissedRecommendations).toHaveBeenCalled();
      expect(taskLearning.getPromptImprovementRecommendations).not.toHaveBeenCalled();
    });
  });

  describe('POST /api/cos/learning/recommendations/dismiss', () => {
    it('should dismiss a recommendation by id and snapshot', async () => {
      taskLearning.dismissRecommendation.mockResolvedValue({ id: 'error-pattern:unknown', dismissed: true });

      const response = await request(app)
        .post('/api/cos/learning/recommendations/dismiss')
        .send({ id: 'error-pattern:unknown', snapshot: { kind: 'count', value: 74 } });

      expect(response.status).toBe(200);
      expect(response.body.dismissed).toBe(true);
      expect(taskLearning.dismissRecommendation).toHaveBeenCalledWith('error-pattern:unknown', { kind: 'count', value: 74 });
    });

    it('should return 400 when id is missing', async () => {
      const response = await request(app)
        .post('/api/cos/learning/recommendations/dismiss')
        .send({});

      expect(response.status).toBe(400);
    });
  });

  describe('POST /api/cos/learning/recommendations/restore', () => {
    it('should restore a dismissed recommendation', async () => {
      taskLearning.restoreRecommendation.mockResolvedValue({ id: 'error-pattern:unknown', restored: true });

      const response = await request(app)
        .post('/api/cos/learning/recommendations/restore')
        .send({ id: 'error-pattern:unknown' });

      expect(response.status).toBe(200);
      expect(response.body.restored).toBe(true);
    });

    it('should return 400 when id is missing', async () => {
      const response = await request(app)
        .post('/api/cos/learning/recommendations/restore')
        .send({});

      expect(response.status).toBe(400);
    });
  });

  describe('POST /api/cos/learning/recommendations/clear-dismissed', () => {
    it('should clear all dismissed recommendations', async () => {
      taskLearning.clearDismissedRecommendations.mockResolvedValue({ cleared: true });

      const response = await request(app).post('/api/cos/learning/recommendations/clear-dismissed');

      expect(response.status).toBe(200);
      expect(response.body.cleared).toBe(true);
    });
  });

  describe('POST /api/cos/learning/recalculate-durations', () => {
    it('should recalculate duration stats', async () => {
      taskLearning.recalculateDurationStats.mockResolvedValue({ recalculated: 3 });

      const response = await request(app).post('/api/cos/learning/recalculate-durations');

      expect(response.status).toBe(200);
      expect(response.body.success).toBe(true);
    });
  });

  describe('GET /api/cos/learning/confidence', () => {
    it('should return confidence levels', async () => {
      taskLearning.getConfidenceLevels.mockResolvedValue({ levels: {} });

      const response = await request(app).get('/api/cos/learning/confidence');

      expect(response.status).toBe(200);
    });
  });

  describe('GET /api/cos/learning/confidence/:taskType', () => {
    it('should return confidence for specific task type', async () => {
      taskLearning.getTaskTypeConfidence.mockResolvedValue({ level: 'high', score: 0.9 });

      const response = await request(app).get('/api/cos/learning/confidence/review');

      expect(response.status).toBe(200);
    });
  });

  // ============================================================
  // Weekly Digest Routes
  // ============================================================

  describe('GET /api/cos/digest', () => {
    it('should return current week digest', async () => {
      weeklyDigest.getWeeklyDigest.mockResolvedValue({ weekId: '2026-W14', stats: {} });

      const response = await request(app).get('/api/cos/digest');

      expect(response.status).toBe(200);
      expect(response.body.weekId).toBe('2026-W14');
    });
  });

  describe('GET /api/cos/digest/list', () => {
    it('should list weekly digests', async () => {
      weeklyDigest.listWeeklyDigests.mockResolvedValue(['2026-W14', '2026-W13']);

      const response = await request(app).get('/api/cos/digest/list');

      expect(response.status).toBe(200);
      expect(response.body.digests).toHaveLength(2);
    });
  });

  describe('GET /api/cos/digest/progress', () => {
    it('should return current week progress', async () => {
      weeklyDigest.getCurrentWeekProgress.mockResolvedValue({ completed: 5, total: 10 });

      const response = await request(app).get('/api/cos/digest/progress');

      expect(response.status).toBe(200);
    });
  });

  describe('GET /api/cos/digest/text', () => {
    it('should return text summary', async () => {
      weeklyDigest.generateTextSummary.mockResolvedValue('Weekly summary text');

      const response = await request(app).get('/api/cos/digest/text');

      expect(response.status).toBe(200);
      expect(response.text).toContain('Weekly summary text');
    });
  });

  describe('GET /api/cos/digest/:weekId', () => {
    it('should return digest for specific week', async () => {
      weeklyDigest.getWeeklyDigest.mockResolvedValue({ weekId: '2026-W13', stats: {} });

      const response = await request(app).get('/api/cos/digest/2026-W13');

      expect(response.status).toBe(200);
    });

    it('should return 400 for invalid weekId format', async () => {
      const response = await request(app).get('/api/cos/digest/bad-format');

      expect(response.status).toBe(400);
    });

    it('should return 404 if digest not found', async () => {
      weeklyDigest.getWeeklyDigest.mockResolvedValue(null);

      const response = await request(app).get('/api/cos/digest/2020-W01');

      expect(response.status).toBe(404);
    });
  });

  describe('POST /api/cos/digest/generate', () => {
    it('should force generate digest', async () => {
      weeklyDigest.generateWeeklyDigest.mockResolvedValue({ weekId: '2026-W14' });

      const response = await request(app)
        .post('/api/cos/digest/generate')
        .send({ weekId: '2026-W14' });

      expect(response.status).toBe(200);
    });

    it('rejects a weekId that is not an ISO week id before it can name a file', async () => {
      weeklyDigest.generateWeeklyDigest.mockClear();

      const response = await request(app)
        .post('/api/cos/digest/generate')
        .send({ weekId: '../../brain/memory' });

      expect(response.status).toBe(400);
      expect(weeklyDigest.generateWeeklyDigest).not.toHaveBeenCalled();
    });

    it('should generate for current week if weekId not provided', async () => {
      weeklyDigest.generateWeeklyDigest.mockResolvedValue({ weekId: '2026-W14' });

      const response = await request(app)
        .post('/api/cos/digest/generate')
        .send({});

      expect(response.status).toBe(200);
      expect(weeklyDigest.generateWeeklyDigest).toHaveBeenCalledWith(null);
    });
  });

  describe('GET /api/cos/digest/compare', () => {
    it('should return 400 when week params are missing', async () => {
      const response = await request(app).get('/api/cos/digest/compare');
      expect(response.status).toBe(400);
    });

    it('should return comparison for two weeks', async () => {
      weeklyDigest.compareWeeks.mockResolvedValue({ week1: '2026-W01', week2: '2026-W02', changes: [] });
      const response = await request(app).get('/api/cos/digest/compare?week1=2026-W01&week2=2026-W02');
      expect(response.status).toBe(200);
      expect(weeklyDigest.compareWeeks).toHaveBeenCalledWith('2026-W01', '2026-W02');
    });

    it('should return 404 when weeks not found', async () => {
      weeklyDigest.compareWeeks.mockResolvedValue(null);
      const response = await request(app).get('/api/cos/digest/compare?week1=2026-W01&week2=2026-W02');
      expect(response.status).toBe(404);
    });
  });
});