@vue-skuilder/db 0.1.25 → 0.1.27

package/dist/impl/static/index.js

@@ -102,12 +102,28 @@ var init_SyncStrategy = __esm({
 });
 
 // src/core/types/types-legacy.ts
-var GuestUsername, DocTypePrefixes;
+var GuestUsername, DocType, DocTypePrefixes;
 var init_types_legacy = __esm({
   "src/core/types/types-legacy.ts"() {
     "use strict";
     init_logger();
     GuestUsername = "sk-guest-";
+    DocType = /* @__PURE__ */ ((DocType3) => {
+      DocType3["DISPLAYABLE_DATA"] = "DISPLAYABLE_DATA";
+      DocType3["CARD"] = "CARD";
+      DocType3["DATASHAPE"] = "DATASHAPE";
+      DocType3["QUESTIONTYPE"] = "QUESTION";
+      DocType3["VIEW"] = "VIEW";
+      DocType3["PEDAGOGY"] = "PEDAGOGY";
+      DocType3["CARDRECORD"] = "CARDRECORD";
+      DocType3["SCHEDULED_CARD"] = "SCHEDULED_CARD";
+      DocType3["TAG"] = "TAG";
+      DocType3["NAVIGATION_STRATEGY"] = "NAVIGATION_STRATEGY";
+      DocType3["STRATEGY_STATE"] = "STRATEGY_STATE";
+      DocType3["USER_OUTCOME"] = "USER_OUTCOME";
+      DocType3["STRATEGY_LEARNING_STATE"] = "STRATEGY_LEARNING_STATE";
+      return DocType3;
+    })(DocType || {});
     DocTypePrefixes = {
       ["CARD" /* CARD */]: "c",
       ["DISPLAYABLE_DATA" /* DISPLAYABLE_DATA */]: "dd",
@@ -1529,7 +1545,7 @@ var init_hierarchyDefinition = __esm({
       /**
        * CardFilter.transform implementation.
        *
-       * Apply prerequisite gating to cards. Cards with locked tags receive score: 0.
+       * Apply prerequisite gating to cards. Cards with locked tags receive score * 0.01.
        */
       async transform(cards, context) {
         const masteredTags = await this.getMasteredTags(context);
@@ -1542,7 +1558,8 @@ var init_hierarchyDefinition = __esm({
             unlockedTags,
             masteredTags
           );
-          const finalScore = isUnlocked ? card.score : 0;
+          const LOCKED_PENALTY = 0.01;
+          const finalScore = isUnlocked ? card.score : card.score * LOCKED_PENALTY;
           const action = isUnlocked ? "passed" : "penalized";
           gated.push({
             ...card,
@@ -4173,7 +4190,13 @@ var init_common = __esm({
 });
 
 // src/factory.ts
-var NOT_SET, ENV;
+function getDataLayer() {
+  if (!dataLayerInstance) {
+    throw new Error("Data layer not initialized. Call initializeDataLayer first.");
+  }
+  return dataLayerInstance;
+}
+var NOT_SET, ENV, dataLayerInstance;
 var init_factory = __esm({
   "src/factory.ts"() {
     "use strict";
@@ -4186,6 +4209,7 @@ var init_factory = __esm({
       COUCHDB_SERVER_URL: NOT_SET,
       LOCAL_STORAGE_PREFIX: ""
     };
+    dataLayerInstance = null;
   }
 });
 
@@ -4296,6 +4320,335 @@ var init_bulkImport = __esm({
   }
 });
 
+// src/core/UserDBDebugger.ts
+function getUserDB() {
+  try {
+    const provider = getDataLayer();
+    return provider.getUserDB();
+  } catch {
+    logger.info("[UserDB Debug] Data layer not initialized yet.");
+    return null;
+  }
+}
+function getRawDB() {
+  const userDB = getUserDB();
+  if (!userDB) return null;
+  const rawDB = userDB.localDB;
+  if (!rawDB) {
+    logger.info("[UserDB Debug] Unable to access raw database instance.");
+    return null;
+  }
+  return rawDB;
+}
+function formatTimestamp(isoString) {
+  const date = new Date(isoString);
+  return date.toLocaleString();
+}
+function mountUserDBDebugger() {
+  if (typeof window === "undefined") return;
+  const win = window;
+  win.skuilder = win.skuilder || {};
+  win.skuilder.userdb = userDBDebugAPI;
+}
+var userDBDebugAPI;
+var init_UserDBDebugger = __esm({
+  "src/core/UserDBDebugger.ts"() {
+    "use strict";
+    init_logger();
+    init_factory();
+    init_types_legacy();
+    init_userDBHelpers();
+    userDBDebugAPI = {
+      /**
+       * Show current user information
+       */
+      showUser() {
+        const userDB = getUserDB();
+        if (!userDB) return;
+        console.group("\u{1F464} User Information");
+        logger.info(`Username: ${userDB.getUsername()}`);
+        logger.info(`Logged in: ${userDB.isLoggedIn() ? "Yes \u2705" : "No (Guest) \u274C"}`);
+        userDB.getConfig().then((config) => {
+          logger.info("Configuration:");
+          logger.info(JSON.stringify(config, null, 2));
+        }).catch((err) => {
+          logger.info(`Error loading config: ${err.message}`);
+        }).finally(() => {
+          console.groupEnd();
+        });
+      },
+      /**
+       * Show scheduled reviews
+       */
+      async showScheduledReviews(courseId) {
+        const userDB = getUserDB();
+        if (!userDB) return;
+        try {
+          const reviews = await userDB.getPendingReviews(courseId);
+          console.group(`\u{1F4C5} Scheduled Reviews${courseId ? ` (${courseId})` : ""}`);
+          logger.info(`Total: ${reviews.length}`);
+          if (reviews.length > 0) {
+            const byCourse = /* @__PURE__ */ new Map();
+            for (const review of reviews) {
+              if (!byCourse.has(review.courseId)) {
+                byCourse.set(review.courseId, []);
+              }
+              byCourse.get(review.courseId).push(review);
+            }
+            for (const [course, courseReviews] of byCourse) {
+              console.group(`Course: ${course} (${courseReviews.length} reviews)`);
+              const sorted = courseReviews.sort((a, b) => {
+                const timeA = typeof a.reviewTime === "string" ? a.reviewTime : a.reviewTime.toISOString();
+                const timeB = typeof b.reviewTime === "string" ? b.reviewTime : b.reviewTime.toISOString();
+                return new Date(timeA).getTime() - new Date(timeB).getTime();
+              });
+              for (const review of sorted.slice(0, 10)) {
+                const reviewTimeStr = typeof review.reviewTime === "string" ? review.reviewTime : review.reviewTime.toISOString();
+                logger.info(
+                  `  ${review.cardId.slice(0, 12)}... @ ${formatTimestamp(reviewTimeStr)} [${review.scheduledFor}/${review.schedulingAgentId}]`
+                );
+              }
+              if (sorted.length > 10) {
+                logger.info(`  ... and ${sorted.length - 10} more`);
+              }
+              console.groupEnd();
+            }
+          }
+          console.groupEnd();
+        } catch (err) {
+          logger.info(`Error loading scheduled reviews: ${err.message}`);
+        }
+      },
+      /**
+       * Show course registrations
+       */
+      async showCourseRegistrations() {
+        const userDB = getUserDB();
+        if (!userDB) return;
+        try {
+          const registrations = await userDB.getActiveCourses();
+          console.group("\u{1F4DA} Course Registrations");
+          logger.info(`Total: ${registrations.length}`);
+          if (registrations.length > 0) {
+            console.table(
+              registrations.map((reg) => ({
+                courseId: reg.courseID,
+                status: reg.status || "active",
+                elo: typeof reg.elo === "number" ? reg.elo.toFixed(0) : reg.elo?.global?.score?.toFixed(0) || "N/A"
+              }))
+            );
+          }
+          console.groupEnd();
+        } catch (err) {
+          logger.info(`Error loading course registrations: ${err.message}`);
+        }
+      },
+      /**
+       * Show card history for a specific card
+       */
+      async showCardHistory(cardId) {
+        const rawDB = getRawDB();
+        if (!rawDB) return;
+        try {
+          const result = await filterAllDocsByPrefix(rawDB, DocTypePrefixes["CARDRECORD" /* CARDRECORD */]);
+          const cardHistories = result.rows.filter((row) => row.doc && row.doc.cardID === cardId).map((row) => row.doc);
+          console.group(`\u{1F3B4} Card History: ${cardId}`);
+          logger.info(`Total interactions: ${cardHistories.length}`);
+          if (cardHistories.length > 0) {
+            const sorted = cardHistories.sort(
+              (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+            );
+            console.table(
+              sorted.slice(0, 20).map((doc) => ({
+                time: formatTimestamp(doc.timestamp),
+                outcome: doc.outcome || "N/A",
+                duration: doc.duration ? `${(doc.duration / 1e3).toFixed(1)}s` : "N/A",
+                courseId: doc.courseId
+              }))
+            );
+            if (sorted.length > 20) {
+              logger.info(`... and ${sorted.length - 20} more interactions`);
+            }
+          }
+          console.groupEnd();
+        } catch (err) {
+          logger.info(`Error loading card history: ${err.message}`);
+        }
+      },
+      /**
+       * Query documents by type
+       */
+      async queryByType(docType, limit = 50) {
+        const rawDB = getRawDB();
+        if (!rawDB) return;
+        try {
+          const prefix = DocTypePrefixes[DocType[docType]];
+          if (!prefix) {
+            logger.info(`Unknown document type: ${docType}`);
+            return;
+          }
+          const result = await filterAllDocsByPrefix(rawDB, prefix);
+          console.group(`\u{1F4C4} Documents: ${docType}`);
+          logger.info(`Total: ${result.rows.length}`);
+          logger.info(`Prefix: ${prefix}`);
+          if (result.rows.length > 0) {
+            logger.info("Sample documents:");
+            const samples = result.rows.slice(0, Math.min(limit, result.rows.length));
+            for (const row of samples) {
+              logger.info(`
+${row.id}:`);
+              logger.info(JSON.stringify(row.doc, null, 2));
+            }
+            if (result.rows.length > limit) {
+              logger.info(`
+... and ${result.rows.length - limit} more documents`);
+            }
+          }
+          console.groupEnd();
+        } catch (err) {
+          logger.info(`Error querying documents: ${err.message}`);
+        }
+      },
+      /**
+       * Show database info and statistics
+       */
+      async dbInfo() {
+        const rawDB = getRawDB();
+        if (!rawDB) return;
+        try {
+          const info = await rawDB.info();
+          console.group("\u2139\uFE0F Database Information");
+          logger.info(`Database name: ${info.db_name}`);
+          logger.info(`Total documents: ${info.doc_count}`);
+          logger.info(`Update sequence: ${info.update_seq}`);
+          if ("disk_size" in info) {
+            logger.info(`Disk size: ${(info.disk_size || 0) / 1024 / 1024} MB`);
+          }
+          logger.info("\nDocument counts by type:");
+          const allDocs = await rawDB.allDocs({ include_docs: false });
+          const typeCounts = /* @__PURE__ */ new Map();
+          for (const row of allDocs.rows) {
+            let prefix = "other";
+            for (const [type, typePrefix] of Object.entries(DocTypePrefixes)) {
+              if (row.id.startsWith(typePrefix)) {
+                prefix = type;
+                break;
+              }
+            }
+            typeCounts.set(prefix, (typeCounts.get(prefix) || 0) + 1);
+          }
+          console.table(
+            Array.from(typeCounts.entries()).sort((a, b) => b[1] - a[1]).map(([type, count]) => ({ type, count }))
+          );
+          console.groupEnd();
+        } catch (err) {
+          logger.info(`Error getting database info: ${err.message}`);
+        }
+      },
+      /**
+       * List all document types
+       */
+      listDocTypes() {
+        console.group("\u{1F4CB} Available Document Types");
+        logger.info("Use with queryByType(type):");
+        for (const [type, prefix] of Object.entries(DocTypePrefixes)) {
+          logger.info(`  ${type.padEnd(30)} \u2192 prefix: "${prefix}"`);
+        }
+        console.groupEnd();
+      },
+      /**
+       * Export database contents (limited, for debugging)
+       */
+      async export(includeContent = false) {
+        const rawDB = getRawDB();
+        const userDB = getUserDB();
+        if (!rawDB || !userDB) return "{}";
+        try {
+          const data = {
+            username: userDB.getUsername(),
+            loggedIn: userDB.isLoggedIn(),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          if (includeContent) {
+            const allDocs = await rawDB.allDocs({ include_docs: true });
+            data.documents = allDocs.rows.map((row) => ({
+              id: row.id,
+              doc: row.doc
+            }));
+            data.totalDocs = allDocs.rows.length;
+          } else {
+            const allDocs = await rawDB.allDocs({ include_docs: false });
+            data.totalDocs = allDocs.rows.length;
+            const typeCounts = /* @__PURE__ */ new Map();
+            for (const row of allDocs.rows) {
+              let prefix = "other";
+              for (const [type, typePrefix] of Object.entries(DocTypePrefixes)) {
+                if (row.id.startsWith(typePrefix)) {
+                  prefix = type;
+                  break;
+                }
+              }
+              typeCounts.set(prefix, (typeCounts.get(prefix) || 0) + 1);
+            }
+            data.docCounts = Object.fromEntries(typeCounts);
+          }
+          const json = JSON.stringify(data, null, 2);
+          logger.info("[UserDB Debug] Database info exported. Copy the returned string or use:");
+          logger.info("  copy(window.skuilder.userdb.export())");
+          if (!includeContent) {
+            logger.info("  For full content export: window.skuilder.userdb.export(true)");
+          }
+          return json;
+        } catch (err) {
+          logger.info(`Error exporting database: ${err.message}`);
+          return "{}";
+        }
+      },
+      /**
+       * Execute raw PouchDB query
+       */
+      async raw(queryFn) {
+        const rawDB = getRawDB();
+        if (!rawDB) return;
+        try {
+          const result = await queryFn(rawDB);
+          logger.info("[UserDB Debug] Query result:");
+          logger.info(result);
+        } catch (err) {
+          logger.info(`[UserDB Debug] Query error: ${err.message}`);
+        }
+      },
+      /**
+       * Show help
+       */
+      help() {
+        logger.info(`
+\u{1F527} UserDB Debug API
+
+Commands:
+  .showUser()                           Show current user info and config
+  .showScheduledReviews(courseId?)      Show scheduled reviews (optionally filter by course)
+  .showCourseRegistrations()            Show all course registrations
+  .showCardHistory(cardId)              Show interaction history for a card
+  .queryByType(docType, limit?)         Query documents by type (e.g., 'SCHEDULED_CARD')
+  .listDocTypes()                       List all available document types
+  .dbInfo()                             Show database info and statistics
+  .export(includeContent?)              Export database info (true = include all docs)
+  .raw(queryFn)                         Execute raw PouchDB query
+  .help()                               Show this help message
+
+Examples:
+  window.skuilder.userdb.showUser()
+  window.skuilder.userdb.showScheduledReviews('course123')
+  window.skuilder.userdb.queryByType('SCHEDULED_CARD', 10)
+  window.skuilder.userdb.raw(db => db.allDocs({ limit: 5 }))
+`);
+      }
+    };
+    mountUserDBDebugger();
+  }
+});
+
 // src/core/index.ts
 var init_core = __esm({
   "src/core/index.ts"() {
@@ -4310,6 +4663,7 @@ var init_core = __esm({
     init_navigators();
     init_bulkImport();
     init_orchestration();
+    init_UserDBDebugger();
   }
 });