@vue-skuilder/db 0.1.20 → 0.1.21

package/src/impl/couch/classroomDB.ts

@@ -1,15 +1,11 @@
-import {
-  StudyContentSource,
-  StudySessionNewItem,
-  StudySessionReviewItem,
-} from '@db/core/interfaces/contentSource';
+import { StudyContentSource } from '@db/core/interfaces/contentSource';
 import { WeightedCard } from '@db/core/navigators';
 import { ClassroomConfig } from '@vue-skuilder/common';
 import { ENV } from '@db/factory';
 import { logger } from '@db/util/logger';
 import moment from 'moment';
 import pouch from './pouchdb-setup';
-import { getCourseDB, getStartAndEndKeys, createPouchDBConfig, REVIEW_TIME_FORMAT } from '.';
+import { getStartAndEndKeys, createPouchDBConfig, REVIEW_TIME_FORMAT } from '.';
 import { CourseDB, getTag } from './courseDB';
 
 import { UserDBInterface } from '@db/core';
@@ -20,7 +16,6 @@ import {
   StudentClassroomDBInterface,
   TeacherClassroomDBInterface,
 } from '@db/core/interfaces/classroomDB';
-import { ScheduledCard } from '@db/core/types/user';
 
 const classroomLookupDBTitle = 'classdb-lookup';
 export const CLASSROOM_CONFIG = 'ClassroomConfig';
@@ -122,93 +117,30 @@ export class StudentClassroomDB
     void this.userMessages.on('change', f);
   }
 
-  public async getPendingReviews(): Promise<(StudySessionReviewItem & ScheduledCard)[]> {
-    const u = this._user;
-    return (await u.getPendingReviews())
-      .filter((r) => r.scheduledFor === 'classroom' && r.schedulingAgentId === this._id)
-      .map((r) => {
-        return {
-          ...r,
-          qualifiedID: `${r.courseId}-${r.cardId}`,
-          courseID: r.courseId,
-          cardID: r.cardId,
-          contentSourceType: 'classroom',
-          contentSourceID: this._id,
-          reviewID: r._id,
-          status: 'review',
-        };
-      });
-  }
-
-  public async getNewCards(): Promise<StudySessionNewItem[]> {
-    const activeCards = await this._user.getActiveCards();
-    const now = moment.utc();
-    const assigned = await this.getAssignedContent();
-    const due = assigned.filter((c) => now.isAfter(moment.utc(c.activeOn, REVIEW_TIME_FORMAT)));
-
-    logger.info(`Due content: ${JSON.stringify(due)}`);
-
-    let ret: StudySessionNewItem[] = [];
-
-    for (let i = 0; i < due.length; i++) {
-      const content = due[i];
-
-      if (content.type === 'course') {
-        const db = new CourseDB(content.courseID, async () => this._user);
-        ret = ret.concat(await db.getNewCards());
-      } else if (content.type === 'tag') {
-        const tagDoc = await getTag(content.courseID, content.tagID);
-
-        ret = ret.concat(
-          tagDoc.taggedCards.map((c) => {
-            return {
-              courseID: content.courseID,
-              cardID: c,
-              qualifiedID: `${content.courseID}-${c}`,
-              contentSourceType: 'classroom',
-              contentSourceID: this._id,
-              status: 'new',
-            };
-          })
-        );
-      } else if (content.type === 'card') {
-        // returning card docs - not IDs
-        ret.push(await getCourseDB(content.courseID).get(content.cardID));
-      }
-    }
-
-    logger.info(
-      `New Cards from classroom ${this._cfg.name}: ${ret.map((c) => `${c.courseID}-${c.cardID}`)}`
-    );
-
-    return ret.filter((c) => {
-      if (activeCards.some((ac) => c.cardID === ac.cardID)) {
-        // [ ] almost certainly broken after removing qualifiedID from StudySessionItem
-        return false;
-      } else {
-        return true;
-      }
-    });
-  }
-
   /**
    * Get cards with suitability scores for presentation.
    *
-   * This implementation wraps the legacy getNewCards/getPendingReviews methods,
-   * assigning score=1.0 to all cards. StudentClassroomDB does not currently
-   * support pluggable navigation strategies.
+   * Gathers new cards from assigned content (courses, tags, cards) and
+   * pending reviews scheduled for this classroom. Assigns score=1.0 to all.
    *
    * @param limit - Maximum number of cards to return
    * @returns Cards sorted by score descending (all scores = 1.0)
    */
   public async getWeightedCards(limit: number): Promise<WeightedCard[]> {
-    const [newCards, reviews] = await Promise.all([this.getNewCards(), this.getPendingReviews()]);
+    const weighted: WeightedCard[] = [];
+
+    // Get pending reviews for this classroom
+    const allUserReviews = await this._user.getPendingReviews();
+    const classroomReviews = allUserReviews.filter(
+      (r) => r.scheduledFor === 'classroom' && r.schedulingAgentId === this._id
+    );
 
-    const weighted: WeightedCard[] = [
-      ...newCards.map((c) => ({
-        cardId: c.cardID,
-        courseId: c.courseID,
+    for (const r of classroomReviews) {
+      weighted.push({
+        cardId: r.cardId,
+        courseId: r.courseId,
         score: 1.0,
+        reviewID: r._id,
         provenance: [
           {
             strategy: 'classroom',
@@ -216,29 +148,94 @@ export class StudentClassroomDB
             strategyId: 'CLASSROOM',
             action: 'generated' as const,
             score: 1.0,
-            reason: 'Classroom legacy getNewCards(), new card',
+            reason: 'Classroom scheduled review',
           },
         ],
-      })),
-      ...reviews.map((r) => ({
-        cardId: r.cardID,
-        courseId: r.courseID,
-        score: 1.0,
-        provenance: [
-          {
-            strategy: 'classroom',
-            strategyName: 'Classroom',
-            strategyId: 'CLASSROOM',
-            action: 'generated' as const,
+      });
+    }
+
+    // Get new cards from assigned content
+    const activeCards = await this._user.getActiveCards();
+    const activeCardIds = new Set(activeCards.map((ac) => ac.cardID));
+    const now = moment.utc();
+    const assigned = await this.getAssignedContent();
+    const due = assigned.filter((c) => now.isAfter(moment.utc(c.activeOn, REVIEW_TIME_FORMAT)));
+
+    logger.info(`[StudentClassroomDB] Due content: ${JSON.stringify(due)}`);
+
+    for (const content of due) {
+      if (content.type === 'course') {
+        // Get weighted cards from the course directly
+        const db = new CourseDB(content.courseID, async () => this._user);
+        const courseCards = await db.getWeightedCards(limit);
+        for (const card of courseCards) {
+          if (!activeCardIds.has(card.cardId)) {
+            weighted.push({
+              ...card,
+              provenance: [
+                ...card.provenance,
+                {
+                  strategy: 'classroom',
+                  strategyName: 'Classroom',
+                  strategyId: 'CLASSROOM',
+                  action: 'passed' as const,
+                  score: card.score,
+                  reason: `Assigned via classroom from course ${content.courseID}`,
+                },
+              ],
+            });
+          }
+        }
+      } else if (content.type === 'tag') {
+        const tagDoc = await getTag(content.courseID, content.tagID);
+
+        for (const cardId of tagDoc.taggedCards) {
+          if (!activeCardIds.has(cardId)) {
+            weighted.push({
+              cardId,
+              courseId: content.courseID,
+              score: 1.0,
+              provenance: [
+                {
+                  strategy: 'classroom',
+                  strategyName: 'Classroom',
+                  strategyId: 'CLASSROOM',
+                  action: 'generated' as const,
+                  score: 1.0,
+                  reason: `Classroom assigned tag: ${content.tagID}, new card`,
+                },
+              ],
+            });
+          }
+        }
+      } else if (content.type === 'card') {
+        if (!activeCardIds.has(content.cardID)) {
+          weighted.push({
+            cardId: content.cardID,
+            courseId: content.courseID,
             score: 1.0,
-            reason: 'Classroom legacy getPendingReviews(), review',
-          },
-        ],
-      })),
-    ];
+            provenance: [
+              {
+                strategy: 'classroom',
+                strategyName: 'Classroom',
+                strategyId: 'CLASSROOM',
+                action: 'generated' as const,
+                score: 1.0,
+                reason: 'Classroom assigned card, new card',
+              },
+            ],
+          });
+        }
+      }
+    }
+
+    logger.info(
+      `[StudentClassroomDB] New cards from classroom ${this._cfg.name}: ` +
+        `${weighted.length} total (reviews + new)`
+    );
 
-    // Sort by score descending (all 1.0 in this case) and limit
-    return weighted.slice(0, limit);
+    // Sort by score descending and limit
+    return weighted.sort((a, b) => b.score - a.score).slice(0, limit);
   }
 }
 

package/src/impl/couch/courseDB.ts

@@ -1,5 +1,4 @@
 import { CourseDBInterface, CourseInfo, CoursesDBInterface, UserDBInterface } from '@db/core';
-import { ScheduledCard } from '@db/core/types/user';
 import {
   CourseConfig,
   CourseElo,
@@ -12,12 +11,7 @@ import {
 
 import { filterAllDocsByPrefix, getCourseDB, getCourseDoc, getCourseDocs } from '.';
 import UpdateQueue from './updateQueue';
-import {
-  StudyContentSource,
-  StudySessionItem,
-  StudySessionNewItem,
-  StudySessionReviewItem,
-} from '../../core/interfaces/contentSource';
+import { StudySessionItem } from '../../core/interfaces/contentSource';
 import {
   CardData,
   DocType,
@@ -35,12 +29,8 @@ import { PouchError } from './types';
 import CourseLookup from './courseLookupDB';
 import { ContentNavigationStrategyData } from '@db/core/types/contentNavigationStrategy';
 import { ContentNavigator, Navigators, WeightedCard } from '@db/core/navigators';
-import { Pipeline } from '@db/core/navigators/Pipeline';
 import { PipelineAssembler } from '@db/core/navigators/PipelineAssembler';
-import CompositeGenerator from '@db/core/navigators/CompositeGenerator';
-import ELONavigator from '@db/core/navigators/elo';
-import SRSNavigator from '@db/core/navigators/srs';
-import { createEloDistanceFilter } from '@db/core/navigators/filters/eloDistance';
+import { createDefaultPipeline } from '@db/core/navigators/defaults';
 
 export class CoursesDB implements CoursesDBInterface {
   _courseIDs: string[] | undefined;
@@ -99,7 +89,7 @@ function randIntWeightedTowardZero(n: number) {
   return Math.floor(Math.random() * Math.random() * Math.random() * n);
 }
 
-export class CourseDB implements StudyContentSource, CourseDBInterface {
+export class CourseDB implements CourseDBInterface {
   // private log(msg: string): void {
   //   log(`CourseLog: ${this.id}\n  ${msg}`);
   // }
@@ -563,7 +553,7 @@ above:\n${above.rows.map((r) => `\t${r.id}-${r.key}\n`)}`;
         logger.debug(
           '[courseDB] No strategy documents found, using default Pipeline(Composite(ELO, SRS), [eloDistanceFilter])'
         );
-        return this.createDefaultPipeline(user);
+        return createDefaultPipeline(user, this);
       }
 
       // Use PipelineAssembler to build a Pipeline from strategy documents
@@ -583,7 +573,7 @@ above:\n${above.rows.map((r) => `\t${r.id}-${r.key}\n`)}`;
       if (!pipeline) {
         // Assembly failed - fall back to default
         logger.debug('[courseDB] Pipeline assembly failed, using default pipeline');
-        return this.createDefaultPipeline(user);
+        return createDefaultPipeline(user, this);
       }
 
       logger.debug(
@@ -596,48 +586,6 @@ above:\n${above.rows.map((r) => `\t${r.id}-${r.key}\n`)}`;
     }
   }
 
-  private makeDefaultEloStrategy(): ContentNavigationStrategyData {
-    return {
-      _id: 'NAVIGATION_STRATEGY-ELO-default',
-      docType: DocType.NAVIGATION_STRATEGY,
-      name: 'ELO (default)',
-      description: 'Default ELO-based navigation strategy for new cards',
-      implementingClass: Navigators.ELO,
-      course: this.id,
-      serializedData: '',
-    };
-  }
-
-  private makeDefaultSrsStrategy(): ContentNavigationStrategyData {
-    return {
-      _id: 'NAVIGATION_STRATEGY-SRS-default',
-      docType: DocType.NAVIGATION_STRATEGY,
-      name: 'SRS (default)',
-      description: 'Default SRS-based navigation strategy for reviews',
-      implementingClass: Navigators.SRS,
-      course: this.id,
-      serializedData: '',
-    };
-  }
-
-  /**
-   * Creates the default navigation pipeline for courses with no configured strategies.
-   *
-   * Default: Pipeline(Composite(ELO, SRS), [eloDistanceFilter])
-   * - ELO generator: scores new cards by skill proximity
-   * - SRS generator: scores reviews by overdueness and interval recency
-   * - ELO distance filter: penalizes cards far from user's current level
-   */
-  private createDefaultPipeline(user: UserDBInterface): Pipeline {
-    const eloNavigator = new ELONavigator(user, this, this.makeDefaultEloStrategy());
-    const srsNavigator = new SRSNavigator(user, this, this.makeDefaultSrsStrategy());
-
-    const compositeGenerator = new CompositeGenerator([eloNavigator, srsNavigator]);
-    const eloDistanceFilter = createEloDistanceFilter();
-
-    return new Pipeline(compositeGenerator, [eloDistanceFilter], user, this);
-  }
-
   ////////////////////////////////////
   // END NavigationStrategyManager implementation
   ////////////////////////////////////
@@ -646,30 +594,6 @@ above:\n${above.rows.map((r) => `\t${r.id}-${r.key}\n`)}`;
   // StudyContentSource implementation
   ////////////////////////////////////
 
-  public async getNewCards(limit: number = 99): Promise<StudySessionNewItem[]> {
-    const u = await this._getCurrentUser();
-
-    try {
-      const navigator = await this.createNavigator(u);
-      return navigator.getNewCards(limit);
-    } catch (e) {
-      logger.error(`[courseDB] Error in getNewCards: ${e}`);
-      throw e;
-    }
-  }
-
-  public async getPendingReviews(): Promise<(StudySessionReviewItem & ScheduledCard)[]> {
-    const u = await this._getCurrentUser();
-
-    try {
-      const navigator = await this.createNavigator(u);
-      return navigator.getPendingReviews();
-    } catch (e) {
-      logger.error(`[courseDB] Error in getPendingReviews: ${e}`);
-      throw e;
-    }
-  }
-
   /**
    * Get cards with suitability scores for presentation.
    *

package/src/impl/couch/pouchdb-setup.ts

@@ -6,6 +6,13 @@ import PouchDBAuth from '@nilock2/pouchdb-authentication';
 PouchDB.plugin(PouchDBFind);
 PouchDB.plugin(PouchDBAuth);
 
+// Disable PouchDB debug logging to prevent interference with CLI prompts
+// Debug logging (like DerivedLogger.emit) will still go to the TUI log file
+// if initializeTuiLogging() has been called, but won't clutter terminal output
+if (typeof PouchDB.debug !== 'undefined') {
+  PouchDB.debug.disable();
+}
+
 // Configure PouchDB globally
 PouchDB.defaults({
   // ajax: {

package/src/impl/static/StaticDataUnpacker.ts

@@ -95,6 +95,47 @@ export class StaticDataUnpacker {
     throw new Error(`Document ${id} not found in chunk ${chunk.id}`);
   }
 
+  /**
+   * Get all documents with IDs starting with a specific prefix.
+   *
+   * This method loads the relevant chunk(s) and returns all matching documents.
+   * Useful for querying documents by type (e.g., all NAVIGATION_STRATEGY documents).
+   *
+   * @param prefix - Document ID prefix to match (e.g., "NAVIGATION_STRATEGY")
+   * @returns Array of all documents with IDs starting with the prefix
+   */
+  async getAllDocumentsByPrefix(prefix: string): Promise<any[]> {
+    // Find all chunks that could contain documents with this prefix
+    // A chunk contains documents if the prefix falls within its startKey/endKey range
+    const relevantChunks = this.manifest.chunks.filter((chunk) => {
+      // Check if prefix could be in this chunk's range
+      // Prefix matches if it's >= startKey and <= endKey (for lexicographic ordering)
+      const prefixEnd = prefix + '\ufff0'; // High unicode character for range end
+      return chunk.startKey <= prefixEnd && chunk.endKey >= prefix;
+    });
+
+    if (relevantChunks.length === 0) {
+      logger.debug(`[StaticDataUnpacker] No chunks found for prefix: ${prefix}`);
+      return [];
+    }
+
+    // Load all relevant chunks
+    await Promise.all(relevantChunks.map((chunk) => this.loadChunk(chunk.id)));
+
+    // Filter documents from cache that match the prefix
+    const matchingDocs: any[] = [];
+    for (const [docId, doc] of this.documentCache.entries()) {
+      if (docId.startsWith(prefix)) {
+        matchingDocs.push(await this.hydrateAttachments(doc));
+      }
+    }
+
+    logger.debug(
+      `[StaticDataUnpacker] Found ${matchingDocs.length} documents with prefix: ${prefix}`
+    );
+    return matchingDocs;
+  }
+
   /**
    * Query cards by ELO score, returning card IDs sorted by ELO
    */
@@ -148,7 +189,15 @@ export class StaticDataUnpacker {
    * Get all tag names mapped to their card arrays
    */
   async getTagsIndex(): Promise<TagsIndex> {
-    return (await this.loadIndex('tags')) as TagsIndex;
+    try {
+      return (await this.loadIndex('tags')) as TagsIndex;
+    } catch {
+      // If no tags index exists, presume "no tagged cards"
+      return {
+        byCard: {},
+        byTag: {},
+      }
+    }
   }
 
   private getDocTypeFromId(id: string): DocType | undefined {

package/src/impl/static/courseDB.ts

@@ -4,8 +4,7 @@ import {
   CourseDBInterface,
   UserDBInterface,
   CourseInfo,
-  StudySessionNewItem,
-  StudySessionReviewItem,
+  StudySessionItem,
 } from '../../core/interfaces';
 import { StaticDataUnpacker } from './StaticDataUnpacker';
 import { StaticCourseManifest } from '../../util/packer/types';
@@ -16,12 +15,15 @@ import {
   DocType,
   SkuilderCourseData,
   QualifiedCardID,
+  DocTypePrefixes,
 } from '../../core/types/types-legacy';
 import { DataLayerResult } from '../../core/types/db';
 import { ContentNavigationStrategyData } from '../../core/types/contentNavigationStrategy';
-import { ScheduledCard } from '../../core/types/user';
-import { Navigators } from '../../core/navigators';
+
+import { ContentNavigator, WeightedCard } from '../../core/navigators';
 import { logger } from '../../util/logger';
+import { createDefaultPipeline } from '@db/core/navigators/defaults';
+import { PipelineAssembler } from '@db/core/navigators/PipelineAssembler';
 
 export class StaticCourseDB implements CourseDBInterface {
   constructor(
@@ -132,28 +134,10 @@ export class StaticCourseDB implements CourseDBInterface {
     return { ok: true, id: cardId, rev: '1-static' };
   }
 
-  async getNewCards(limit: number = 99): Promise<StudySessionNewItem[]> {
-    const activeCards = await this.userDB.getActiveCards();
-    return (
-      await this.getCardsCenteredAtELO({ limit: limit, elo: 'user' }, (c: QualifiedCardID) => {
-        if (activeCards.some((ac) => c.cardID === ac.cardID)) {
-          return false;
-        } else {
-          return true;
-        }
-      })
-    ).map((c) => {
-      return {
-        ...c,
-        status: 'new',
-      };
-    });
-  }
-
   async getCardsCenteredAtELO(
     options: { limit: number; elo: 'user' | 'random' | number },
     filter?: (id: QualifiedCardID) => boolean
-  ): Promise<StudySessionNewItem[]> {
+  ): Promise<StudySessionItem[]> {
     let targetElo = typeof options.elo === 'number' ? options.elo : 1000;
 
     if (options.elo === 'user') {
@@ -378,20 +362,24 @@ export class StaticCourseDB implements CourseDBInterface {
   }
 
   // Navigation Strategy Manager implementation
-  async getNavigationStrategy(_id: string): Promise<ContentNavigationStrategyData> {
-    return {
-      _id: 'NAVIGATION_STRATEGY-ELO',
-      docType: DocType.NAVIGATION_STRATEGY,
-      name: 'ELO',
-      description: 'ELO-based navigation strategy',
-      implementingClass: Navigators.ELO,
-      course: this.courseId,
-      serializedData: '',
-    };
+  async getNavigationStrategy(id: string): Promise<ContentNavigationStrategyData> {
+    try {
+      return await this.unpacker.getDocument(id);
+    } catch (error) {
+      logger.error(`[static/courseDB] Strategy ${id} not found: ${error}`);
+      throw error;
+    }
   }
 
   async getAllNavigationStrategies(): Promise<ContentNavigationStrategyData[]> {
-    return [await this.getNavigationStrategy('ELO')];
+    const prefix = DocTypePrefixes[DocType.NAVIGATION_STRATEGY];
+    try {
+      const docs = await this.unpacker.getAllDocumentsByPrefix(prefix);
+      return docs as ContentNavigationStrategyData[];
+    } catch (error) {
+      logger.warn(`[static/courseDB] Error loading navigation strategies: ${error}`);
+      return []; // Fall back to default pipeline
+    }
   }
 
   async addNavigationStrategy(_data: ContentNavigationStrategyData): Promise<void> {
@@ -402,10 +390,61 @@ export class StaticCourseDB implements CourseDBInterface {
     throw new Error('Cannot update navigation strategies in static mode');
   }
 
+  /**
+   * Create a ContentNavigator for this course.
+   *
+   * Loads navigation strategy documents from static data and uses PipelineAssembler
+   * to build a Pipeline. Falls back to default pipeline if no strategies found.
+   */
+  async createNavigator(user: UserDBInterface): Promise<ContentNavigator> {
+    try {
+      const allStrategies = await this.getAllNavigationStrategies();
+
+      if (allStrategies.length === 0) {
+        logger.debug(
+          '[static/courseDB] No strategy documents found, using default Pipeline(Composite(ELO, SRS), [eloDistanceFilter])'
+        );
+        return createDefaultPipeline(user, this);
+      }
+
+      // Use PipelineAssembler to build Pipeline from strategy documents
+      const assembler = new PipelineAssembler();
+      const { pipeline, generatorStrategies, filterStrategies, warnings } =
+        await assembler.assemble({
+          strategies: allStrategies,
+          user,
+          course: this,
+        });
+
+      // Log warnings
+      for (const warning of warnings) {
+        logger.warn(`[PipelineAssembler] ${warning}`);
+      }
+
+      if (!pipeline) {
+        logger.debug('[static/courseDB] Pipeline assembly failed, using default pipeline');
+        return createDefaultPipeline(user, this);
+      }
+
+      logger.debug(
+        `[static/courseDB] Using assembled pipeline with ${generatorStrategies.length} generator(s) and ${filterStrategies.length} filter(s)`
+      );
+      return pipeline;
+    } catch (e) {
+      logger.error(`[static/courseDB] Error creating navigator: ${e}`);
+      throw e;
+    }
+  }
+
   // Study Content Source implementation
-  async getPendingReviews(): Promise<(StudySessionReviewItem & ScheduledCard)[]> {
-    // In static mode, reviews would be stored locally
-    return [];
+  async getWeightedCards(limit: number): Promise<WeightedCard[]> {
+    try {
+      const navigator = await this.createNavigator(this.userDB);
+      return navigator.getWeightedCards(limit);
+    } catch (e) {
+      logger.error(`[static/courseDB] Error getting weighted cards: ${e}`);
+      throw e;
+    }
   }
 
   // Attachment helper methods (internal use, not part of interface)