@vue-skuilder/db 0.1.20 → 0.1.21

package/tests/core/navigators/navigators.test.ts

@@ -1,27 +1,23 @@
-import { describe, it, expect, beforeEach } from 'vitest';
+import { describe, it, expect } from 'vitest';
 import { ContentNavigator, WeightedCard, getCardOrigin } from '../../../src/core/navigators/index';
-import { StudySessionNewItem, StudySessionReviewItem } from '../../../src/core';
-import { ScheduledCard } from '../../../src/core/types/user';
 
-// Mock implementation of ContentNavigator for testing the default getWeightedCards
+// Mock implementation of ContentNavigator for testing base class behavior
 class MockNavigator extends ContentNavigator {
-  private mockNewCards: StudySessionNewItem[] = [];
-  private mockReviews: (StudySessionReviewItem & ScheduledCard)[] = [];
-
-  setMockNewCards(cards: StudySessionNewItem[]) {
-    this.mockNewCards = cards;
-  }
+  name: string = 'MockNavigator';
+  // Base class no longer has legacy methods - subclasses must implement getWeightedCards
+}
 
-  setMockReviews(reviews: (StudySessionReviewItem & ScheduledCard)[]) {
-    this.mockReviews = reviews;
-  }
+// Mock implementation that properly implements getWeightedCards
+class ProperMockNavigator extends ContentNavigator {
+  name: string = 'ProperMockNavigator';
+  private cards: WeightedCard[] = [];
 
-  async getNewCards(n?: number): Promise<StudySessionNewItem[]> {
-    return this.mockNewCards.slice(0, n);
+  setCards(cards: WeightedCard[]) {
+    this.cards = cards;
   }
 
-  async getPendingReviews(): Promise<(StudySessionReviewItem & ScheduledCard)[]> {
-    return this.mockReviews;
+  async getWeightedCards(limit: number): Promise<WeightedCard[]> {
+    return this.cards.slice(0, limit);
   }
 }
 
@@ -77,111 +73,97 @@ describe('WeightedCard', () => {
   });
 });
 
-describe('ContentNavigator.getWeightedCards', () => {
-  let navigator: MockNavigator;
+describe('ContentNavigator base class', () => {
+  it('should throw error when getWeightedCards is not implemented', async () => {
+    const navigator = new MockNavigator();
 
-  beforeEach(() => {
-    navigator = new MockNavigator();
+    await expect(navigator.getWeightedCards(10)).rejects.toThrow(
+      'must implement getWeightedCards()'
+    );
   });
 
-  it('should return empty array when no cards available', async () => {
-    navigator.setMockNewCards([]);
-    navigator.setMockReviews([]);
-
-    const result = await navigator.getWeightedCards(10);
+  it('should throw error mentioning legacy methods have been removed', async () => {
+    const navigator = new MockNavigator();
 
-    expect(result).toEqual([]);
-  });
-
-  it('should assign score=1.0 to all cards by default', async () => {
-    navigator.setMockNewCards([
-      {
-        cardID: 'card-1',
-        courseID: 'course-1',
-        contentSourceType: 'course',
-        contentSourceID: 'course-1',
-        status: 'new',
-      },
-      {
-        cardID: 'card-2',
-        courseID: 'course-1',
-        contentSourceType: 'course',
-        contentSourceID: 'course-1',
-        status: 'new',
-      },
-    ]);
-
-    const result = await navigator.getWeightedCards(10);
-
-    expect(result).toHaveLength(2);
-    expect(result[0].score).toBe(1.0);
-    expect(result[1].score).toBe(1.0);
-  });
-
-  it('should mark new cards with source="new"', async () => {
-    navigator.setMockNewCards([
-      {
-        cardID: 'card-1',
-        courseID: 'course-1',
-        contentSourceType: 'course',
-        contentSourceID: 'course-1',
-        status: 'new',
-      },
-    ]);
-
-    const result = await navigator.getWeightedCards(10);
-
-    expect(getCardOrigin(result[0])).toBe('new');
-    expect(result[0].provenance[0].reason).toContain('new');
+    await expect(navigator.getWeightedCards(10)).rejects.toThrow();
   });
+});
 
-  it('should mark reviews with origin="review"', async () => {
-    navigator.setMockReviews([
+describe('ContentNavigator.getWeightedCards with proper implementation', () => {
+  it('should return cards from implementation', async () => {
+    const navigator = new ProperMockNavigator();
+    navigator.setCards([
       {
-        cardID: 'review-1',
-        courseID: 'course-1',
-        contentSourceType: 'course',
-        contentSourceID: 'course-1',
-        status: 'review',
-        reviewID: 'review-id-1',
-        _id: 'scheduled-1',
-        cardId: 'review-1',
+        cardId: 'card-1',
         courseId: 'course-1',
-        scheduledFor: 'course',
-        schedulingAgentId: 'agent-1',
-        reviewTime: new Date(),
-        scheduledAt: new Date(),
-      } as unknown as StudySessionReviewItem & ScheduledCard,
+        score: 0.8,
+        provenance: [
+          {
+            strategy: 'test',
+            strategyName: 'Test',
+            strategyId: 'TEST',
+            action: 'generated',
+            score: 0.8,
+            reason: 'Test new card',
+          },
+        ],
+      },
     ]);
 
     const result = await navigator.getWeightedCards(10);
 
-    expect(getCardOrigin(result[0])).toBe('review');
-    expect(result[0].provenance[0].reason).toContain('review');
+    expect(result).toHaveLength(1);
+    expect(result[0].cardId).toBe('card-1');
+    expect(result[0].score).toBe(0.8);
   });
 
   it('should respect limit parameter', async () => {
-    navigator.setMockNewCards([
+    const navigator = new ProperMockNavigator();
+    navigator.setCards([
       {
-        cardID: 'card-1',
-        courseID: 'course-1',
-        contentSourceType: 'course',
-        contentSourceID: 'course-1',
-        status: 'new',
+        cardId: 'card-1',
+        courseId: 'course-1',
+        score: 0.9,
+        provenance: [
+          {
+            strategy: 'test',
+            strategyName: 'Test',
+            strategyId: 'TEST',
+            action: 'generated',
+            score: 0.9,
+            reason: 'Test new card',
+          },
+        ],
       },
       {
-        cardID: 'card-2',
-        courseID: 'course-1',
-        contentSourceType: 'course',
-        contentSourceID: 'course-1',
-        status: 'new',
+        cardId: 'card-2',
+        courseId: 'course-1',
+        score: 0.8,
+        provenance: [
+          {
+            strategy: 'test',
+            strategyName: 'Test',
+            strategyId: 'TEST',
+            action: 'generated',
+            score: 0.8,
+            reason: 'Test new card',
+          },
+        ],
       },
       {
-        cardID: 'card-3',
-        courseID: 'course-1',
-        contentSourceType: 'course',
-        contentSourceID: 'course-1',
-        status: 'new',
+        cardId: 'card-3',
+        courseId: 'course-1',
+        score: 0.7,
+        provenance: [
+          {
+            strategy: 'test',
+            strategyName: 'Test',
+            strategyId: 'TEST',
+            action: 'generated',
+            score: 0.7,
+            reason: 'Test new card',
+          },
+        ],
       },
     ]);
 
@@ -190,57 +172,42 @@ describe('ContentNavigator.getWeightedCards', () => {
     expect(result).toHaveLength(2);
   });
 
-  it('should combine new cards and reviews', async () => {
-    navigator.setMockNewCards([
-      {
-        cardID: 'new-1',
-        courseID: 'course-1',
-        contentSourceType: 'course',
-        contentSourceID: 'course-1',
-        status: 'new',
-      },
-    ]);
-    navigator.setMockReviews([
-      {
-        cardID: 'review-1',
-        courseID: 'course-1',
-        contentSourceType: 'course',
-        contentSourceID: 'course-1',
-        status: 'review',
-        reviewID: 'review-id-1',
-        _id: 'scheduled-1',
-        cardId: 'review-1',
-        courseId: 'course-1',
-        scheduledFor: 'course',
-        schedulingAgentId: 'agent-1',
-        reviewTime: new Date(),
-        scheduledAt: new Date(),
-      } as unknown as StudySessionReviewItem & ScheduledCard,
-    ]);
-
-    const result = await navigator.getWeightedCards(10);
-
-    expect(result).toHaveLength(2);
-    const origins = result.map((c) => getCardOrigin(c));
-    expect(origins).toContain('new');
-    expect(origins).toContain('review');
-  });
-
-  it('should correctly map cardID to cardId and courseID to courseId', async () => {
-    navigator.setMockNewCards([
-      {
-        cardID: 'CARD-123',
-        courseID: 'COURSE-456',
-        contentSourceType: 'course',
-        contentSourceID: 'COURSE-456',
-        status: 'new',
-      },
-    ]);
+  it('should correctly identify card origins from provenance', () => {
+    const newCard: WeightedCard = {
+      cardId: 'new-1',
+      courseId: 'course-1',
+      score: 1.0,
+      provenance: [
+        {
+          strategy: 'test',
+          strategyName: 'Test',
+          strategyId: 'TEST',
+          action: 'generated',
+          score: 1.0,
+          reason: 'ELO distance 50, new card',
+        },
+      ],
+    };
 
-    const result = await navigator.getWeightedCards(10);
+    const reviewCard: WeightedCard = {
+      cardId: 'review-1',
+      courseId: 'course-1',
+      score: 0.8,
+      reviewID: 'SCHEDULED_CARD-123',
+      provenance: [
+        {
+          strategy: 'srs',
+          strategyName: 'SRS',
+          strategyId: 'SRS',
+          action: 'generated',
+          score: 0.8,
+          reason: '48h overdue (interval: 72h), review',
+        },
+      ],
+    };
 
-    expect(result[0].cardId).toBe('CARD-123');
-    expect(result[0].courseId).toBe('COURSE-456');
+    expect(getCardOrigin(newCard)).toBe('new');
+    expect(getCardOrigin(reviewCard)).toBe('review');
   });
 });
 

package/src/core/navigators/hardcodedOrder.ts

@@ -1,163 +0,0 @@
-import type {
-  CourseDBInterface,
-  QualifiedCardID,
-  StudySessionNewItem,
-  StudySessionReviewItem,
-  UserDBInterface,
-} from '..';
-import type { ContentNavigationStrategyData } from '../types/contentNavigationStrategy';
-import type { ScheduledCard } from '../types/user';
-import { ContentNavigator } from './index';
-import type { WeightedCard } from './index';
-import type { CardGenerator, GeneratorContext } from './generators/types';
-import { logger } from '../../util/logger';
-
-// ============================================================================
-// HARDCODED ORDER NAVIGATOR
-// ============================================================================
-//
-// A generator strategy that presents cards in a fixed, author-defined order.
-//
-// Use case: When course authors want explicit control over content sequencing,
-// e.g., teaching letters in a specific pedagogical order.
-//
-// The order is defined in serializedData as a JSON array of card IDs.
-// Earlier positions in the array get higher scores.
-//
-// ============================================================================
-
-/**
- * A navigation strategy that presents cards in a fixed order.
- *
- * Implements CardGenerator for use in Pipeline architecture.
- * Also extends ContentNavigator for backward compatibility with legacy code.
- *
- * Scoring:
- * - Earlier cards in the sequence get higher scores
- * - Reviews get score 1.0 (highest priority)
- * - New cards scored by position: 1.0 - (position / total) * 0.5
- */
-export default class HardcodedOrderNavigator extends ContentNavigator implements CardGenerator {
-  /** Human-readable name for CardGenerator interface */
-  name: string;
-
-  private orderedCardIds: string[] = [];
-
-  constructor(
-    user: UserDBInterface,
-    course: CourseDBInterface,
-    strategyData: ContentNavigationStrategyData
-  ) {
-    super(user, course, strategyData);
-    this.name = strategyData.name || 'Hardcoded Order';
-
-    if (strategyData.serializedData) {
-      try {
-        this.orderedCardIds = JSON.parse(strategyData.serializedData);
-      } catch (e) {
-        logger.error('Failed to parse serializedData for HardcodedOrderNavigator', e);
-      }
-    }
-  }
-
-  async getPendingReviews(): Promise<(StudySessionReviewItem & ScheduledCard)[]> {
-    const reviews = await this.user.getPendingReviews(this.course.getCourseID());
-    return reviews.map((r) => {
-      return {
-        ...r,
-        contentSourceType: 'course',
-        contentSourceID: this.course.getCourseID(),
-        cardID: r.cardId,
-        courseID: r.courseId,
-        reviewID: r._id,
-        status: 'review',
-      };
-    });
-  }
-
-  async getNewCards(limit: number = 99): Promise<StudySessionNewItem[]> {
-    const activeCardIds = (await this.user.getActiveCards()).map((c: QualifiedCardID) => c.cardID);
-
-    const newCardIds = this.orderedCardIds.filter((cardId) => !activeCardIds.includes(cardId));
-
-    const cardsToReturn = newCardIds.slice(0, limit);
-
-    return cardsToReturn.map((cardId) => {
-      return {
-        cardID: cardId,
-        courseID: this.course.getCourseID(),
-        contentSourceType: 'course',
-        contentSourceID: this.course.getCourseID(),
-        status: 'new',
-      };
-    });
-  }
-
-  /**
-   * Get cards in hardcoded order with scores based on position.
-   *
-   * Earlier cards in the sequence get higher scores.
-   * Score formula: 1.0 - (position / totalCards) * 0.5
-   * This ensures scores range from 1.0 (first card) to 0.5+ (last card).
-   *
-   * This method supports both the legacy signature (limit only) and the
-   * CardGenerator interface signature (limit, context).
-   *
-   * @param limit - Maximum number of cards to return
-   * @param _context - Optional GeneratorContext (currently unused, but required for interface)
-   */
-  async getWeightedCards(limit: number, _context?: GeneratorContext): Promise<WeightedCard[]> {
-    const activeCardIds = (await this.user.getActiveCards()).map((c: QualifiedCardID) => c.cardID);
-    const reviews = await this.getPendingReviews();
-
-    // Filter out already-active cards
-    const newCardIds = this.orderedCardIds.filter((cardId) => !activeCardIds.includes(cardId));
-
-    const totalCards = newCardIds.length;
-
-    // Score new cards by position in sequence
-    const scoredNew: WeightedCard[] = newCardIds.slice(0, limit).map((cardId, index) => {
-      const position = index + 1;
-      const score = Math.max(0.5, 1.0 - (index / totalCards) * 0.5);
-
-      return {
-        cardId,
-        courseId: this.course.getCourseID(),
-        score,
-        provenance: [
-          {
-            strategy: 'hardcodedOrder',
-            strategyName: this.strategyName || this.name,
-            strategyId: this.strategyId || 'NAVIGATION_STRATEGY-hardcoded',
-            action: 'generated',
-            score,
-            reason: `Position ${position} of ${totalCards} in fixed sequence, new card`,
-          },
-        ],
-      };
-    });
-
-    // Score reviews at 1.0 (highest priority)
-    const scoredReviews: WeightedCard[] = reviews.map((r) => ({
-      cardId: r.cardID,
-      courseId: r.courseID,
-      score: 1.0,
-      provenance: [
-        {
-          strategy: 'hardcodedOrder',
-          strategyName: this.strategyName || this.name,
-          strategyId: this.strategyId || 'NAVIGATION_STRATEGY-hardcoded',
-          action: 'generated',
-          score: 1.0,
-          reason: 'Scheduled review, highest priority',
-        },
-      ],
-    }));
-
-    // Combine (reviews already sorted at top due to score=1.0)
-    const all = [...scoredReviews, ...scoredNew];
-    all.sort((a, b) => b.score - a.score);
-
-    return all.slice(0, limit);
-  }
-}

package/src/util/tuiLogger.ts

@@ -1,139 +0,0 @@
-// TUI-aware logging utility that redirects logs to file in Node.js
-import * as fs from 'fs';
-import * as path from 'path';
-import { getAppDataDirectory } from './dataDirectory';
-
-let logFile: string | null = null;
-let isNodeEnvironment = false;
-
-/**
- * Initialize TUI logging - redirect console logs to file in Node.js
- */
-export function initializeTuiLogging(): void {
-  // Detect Node.js environment
-  isNodeEnvironment = typeof window === 'undefined' && typeof process !== 'undefined';
-  
-  if (!isNodeEnvironment) {
-    return; // Browser environment - keep normal console logging
-  }
-
-  try {
-    // Set up log file path
-    logFile = path.join(getAppDataDirectory(), 'lastrun.log');
-    
-    // Clear previous log file
-    if (fs.existsSync(logFile)) {
-      fs.unlinkSync(logFile);
-    }
-    
-    // Create initial log entry
-    const startTime = new Date().toISOString();
-    fs.writeFileSync(logFile, `=== TUI Session Started: ${startTime} ===\n`);
-    
-    // Redirect console methods to file
-    const originalConsole = {
-      // eslint-disable-next-line no-console
-      log: console.log,
-      // eslint-disable-next-line no-console
-      error: console.error,
-      // eslint-disable-next-line no-console
-      warn: console.warn,
-      // eslint-disable-next-line no-console
-      info: console.info
-    };
-    
-    const writeToLog = (level: string, args: any[]) => {
-      const timestamp = new Date().toISOString();
-      const message = args.map(arg => 
-        typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)
-      ).join(' ');
-      
-      const logEntry = `[${timestamp}] ${level}: ${message}\n`;
-      
-      try {
-        fs.appendFileSync(logFile!, logEntry);
-      } catch (err) {
-        // Fallback to original console if file write fails
-        originalConsole.error('Failed to write to log file:', err);
-        originalConsole[level.toLowerCase() as keyof typeof originalConsole](...args);
-      }
-    };
-    
-    // Override console methods
-    // eslint-disable-next-line no-console
-    console.log = (...args) => writeToLog('INFO', args);
-    // eslint-disable-next-line no-console
-    console.info = (...args) => writeToLog('INFO', args);
-    // eslint-disable-next-line no-console
-    console.warn = (...args) => writeToLog('WARN', args);
-    // eslint-disable-next-line no-console
-    console.error = (...args) => writeToLog('ERROR', args);
-    
-    // Store original methods for potential restoration
-    (console as any)._originalMethods = originalConsole;
-    
-    // eslint-disable-next-line no-console
-    console.log('TUI logging initialized - logs redirected to', logFile);
-    
-  } catch (err) {
-    // eslint-disable-next-line no-console
-    console.error('Failed to initialize TUI logging:', err);
-  }
-}
-
-/**
- * Get the current log file path (for debugging)
- */
-export function getLogFilePath(): string | null {
-  return logFile;
-}
-
-/**
- * Show user-facing message (always visible in TUI)
- */
-export function showUserMessage(message: string): void {
-  if (isNodeEnvironment) {
-    // In Node.js, write directly to stdout to bypass log redirection
-    process.stdout.write(message + '\n');
-  } else {
-    // In browser, use normal console
-    // eslint-disable-next-line no-console
-    console.log(message);
-  }
-}
-
-/**
- * Show user-facing error (always visible in TUI)
- */
-export function showUserError(message: string): void {
-  if (isNodeEnvironment) {
-    // In Node.js, write directly to stderr to bypass log redirection
-    process.stderr.write('Error: ' + message + '\n');
-  } else {
-    // In browser, use normal console
-    // eslint-disable-next-line no-console
-    console.error(message);
-  }
-}
-
-/**
- * Logger object with standard log levels
- */
-export const logger = {
-  debug: (message: string, ...args: any[]) => {
-    // eslint-disable-next-line no-console
-    console.log(`[DEBUG] ${message}`, ...args);
-  },
-  info: (message: string, ...args: any[]) => {
-    // eslint-disable-next-line no-console
-    console.info(`[INFO] ${message}`, ...args);
-  },
-  warn: (message: string, ...args: any[]) => {
-    // eslint-disable-next-line no-console
-    console.warn(`[WARN] ${message}`, ...args);
-  },
-  error: (message: string, ...args: any[]) => {
-    // eslint-disable-next-line no-console
-    console.error(`[ERROR] ${message}`, ...args);
-  },
-};