wiki-graph-core 0.4.0 → 0.4.1

package/dist/index.cjs

@@ -9623,6 +9623,15 @@ async function resolveWikiGraphLibrary(target) {
     async (database) => await requireLibraryRecordByPublicId(database, target.publicId)
   );
 }
+async function resolveWikiGraphLibraryForScan(target) {
+  if (!target.isDefault) {
+    return await resolveWikiGraphLibrary(target);
+  }
+  const existing = await withLibraryRegistryDatabase(
+    async (database) => await readDefaultLibraryRecord(database)
+  );
+  return existing ?? await ensureDefaultWikiGraphLibrary();
+}
 async function resolveWikiGraphLibraryById(id) {
   return await withLibraryRegistryDatabase(
     async (database) => await requireLibraryRecordById(database, id)
@@ -10515,41 +10524,53 @@ async function readWikiGraphArchiveSchemaVersion(archivePath) {
 async function upgradeWikiGraphArchiveSchema(archivePath) {
   const resolvedArchivePath = (0, import_path33.resolve)(archivePath);
   const schemaVersion = await readWikiGraphArchiveSchemaVersion(resolvedArchivePath);
-  if (schemaVersion === CURRENT_ARCHIVE_SCHEMA_VERSION) {
-    return;
-  }
   if (schemaVersion > CURRENT_ARCHIVE_SCHEMA_VERSION) {
     throw new Error(
       `Unsupported Wiki Graph archive schema version: ${schemaVersion}.`
     );
   }
-  await ensureWikiGraphHomeSchemaCurrent();
-  const archiveKey = createArchiveKey(resolvedArchivePath);
-  await assertArchiveUpgradeSafe(archiveKey);
-  const temporaryPath = (0, import_path33.join)(
-    (0, import_path33.dirname)(resolvedArchivePath),
-    `.${getArchiveBasename(resolvedArchivePath)}.${process.pid}.${(0, import_crypto10.randomUUID)()}.upgrade.tmp`
-  );
   const temporaryDirectories = [];
   try {
     const tocOverlay = await createChapterTocUpgradeOverlay(
       resolvedArchivePath,
       temporaryDirectories
     );
+    const schemaChanged = schemaVersion < CURRENT_ARCHIVE_SCHEMA_VERSION;
+    if (!schemaChanged && tocOverlay === void 0) {
+      return {
+        changed: false,
+        repairedToc: false,
+        schemaChanged: false
+      };
+    }
+    await ensureWikiGraphHomeSchemaCurrent();
+    const archiveKey = createArchiveKey(resolvedArchivePath);
+    await assertArchiveUpgradeSafe(archiveKey);
+    const temporaryPath = (0, import_path33.join)(
+      (0, import_path33.dirname)(resolvedArchivePath),
+      `.${getArchiveBasename(resolvedArchivePath)}.${process.pid}.${(0, import_crypto10.randomUUID)()}.upgrade.tmp`
+    );
     await writeWikgArchiveWithOverlays(
       resolvedArchivePath,
       temporaryPath,
       [
-        {
-          entryPath: SEARCH_INDEX_DATABASE_PATH2,
-          kind: "deleted"
-        },
+        ...schemaChanged ? [
+          {
+            entryPath: SEARCH_INDEX_DATABASE_PATH2,
+            kind: "deleted"
+          }
+        ] : [],
         ...tocOverlay === void 0 ? [] : [tocOverlay]
       ],
       { preserveMutationToken: true }
     );
     await (0, import_promises21.rename)(temporaryPath, resolvedArchivePath);
     await cleanupArchiveDerivedData(archiveKey);
+    return {
+      changed: true,
+      repairedToc: tocOverlay !== void 0,
+      schemaChanged
+    };
   } finally {
     await Promise.all(
       temporaryDirectories.map(async (path) => {
@@ -15319,7 +15340,7 @@ function getSearchBucket(type) {
     case "chapter-tree":
     case "meta":
     case "fragment":
-      throw new Error(`Unsupported search result bucket type: ${type}`);
+      return 4;
   }
 }
 var init_sort = __esm({
@@ -40257,7 +40278,7 @@ var init_search_index3 = __esm({
 
 // src/library/membership.ts
 async function scanWikiGraphLibrary(target) {
-  const library = await resolveWikiGraphLibrary(target);
+  const library = await resolveWikiGraphLibraryForScan(target);
   return await withWikiGraphLibraryLock(library.id, "write", async () => {
     const result = await scanWikiGraphLibraryUnlocked(target, library, {
       pathIdentity: "trusted"
@@ -40325,18 +40346,16 @@ async function scanWikiGraphLibraryUnlocked(target, library, options) {
           status: matchingTokenArchives.length === 0 || file.mutationToken === void 0 ? "present" : "conflict"
         });
       }
-      const now = (/* @__PURE__ */ new Date()).toISOString();
       for (const archive of existing) {
         if (seenArchiveIds.has(archive.id) || options.pathIdentity === "trusted" && currentPaths.has(archive.relativePath)) {
           continue;
         }
         await database.run(
           `
-            UPDATE library_archives
-            SET status = 'missing', updated_at = ?, last_scanned_at = ?
+            DELETE FROM library_archives
             WHERE id = ?
           `,
-          [now, now, archive.id]
+          [archive.id]
         );
       }
     });
@@ -40770,6 +40789,7 @@ function archivePathMatchRank(archive) {
   return 2;
 }
 async function listWikgFiles(root) {
+  await assertLibraryFolderExists(root);
   const relativePaths = [];
   await walkLibraryDirectory(root, root, relativePaths);
   const files = [];
@@ -40783,6 +40803,19 @@ async function listWikgFiles(root) {
   }
   return files;
 }
+async function assertLibraryFolderExists(root) {
+  try {
+    const rootStat = await (0, import_promises53.stat)(root);
+    if (!rootStat.isDirectory()) {
+      throw new Error(`Wiki Graph library folder is not a directory: ${root}`);
+    }
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      throw new Error(`Wiki Graph library folder is missing: ${root}`);
+    }
+    throw error;
+  }
+}
 async function ensureLibraryArchiveFileHasNoSearchIndexAndInspect(root, relativePath) {
   await ensureLibraryManagedArchiveHasNoSearchIndex((0, import_path67.join)(root, relativePath));
   return await inspectLibraryArchiveFile(root, relativePath);
@@ -41491,12 +41524,46 @@ async function findWikiGraphLibraryObjects(target, query, options = {}) {
   }
   return createFindResult(query, hits, options, result.terms);
 }
+async function findWikiGraphLibraryArchiveMembers(target, query, options = {}) {
+  const terms = createLibraryArchiveMemberSearchTerms(query);
+  const archives = await listWikiGraphLibraryArchives(target);
+  const hits = archives.map(formatLibraryArchiveMemberHit).filter((hit) => matchesLibraryArchiveMemberSearch(hit, terms));
+  return createFindResult(query, hits, options, terms, "typed");
+}
 function createLibraryQueryIndexHitLimit(options) {
   return Math.max(
     (options.limit ?? DEFAULT_LIBRARY_PAGE_LIMIT) * LIBRARY_QUERY_INDEX_LIMIT_MULTIPLIER,
     LIBRARY_QUERY_INDEX_MIN_LIMIT
   );
 }
+function createLibraryArchiveMemberSearchTerms(query) {
+  return query.trim().toLocaleLowerCase().split(/\s+/u).filter((term) => term !== "");
+}
+function matchesLibraryArchiveMemberSearch(hit, terms) {
+  if (terms.length === 0) {
+    return true;
+  }
+  const haystack = `${hit.id}
+${hit.title}
+${hit.snippet}`.toLocaleLowerCase();
+  return terms.every((term) => haystack.includes(term));
+}
+function formatLibraryArchiveMemberHit(archive) {
+  const details = [
+    archive.relativePath,
+    archive.status,
+    archive.exists ? "exists" : "missing-file"
+  ].join("  ");
+  return {
+    archiveId: archive.id,
+    field: "metadata",
+    id: archive.uri,
+    libraryArchiveUri: archive.uri,
+    snippet: details,
+    title: archive.relativePath,
+    type: "meta"
+  };
+}
 async function listWikiGraphLibraryObjects(target, options = {}) {
   const hits = [];
   const result = await listWikiGraphLibrarySearchIndex(target, {
@@ -41524,6 +41591,14 @@ async function listWikiGraphLibraryObjects(target, options = {}) {
   }
   return createCollectionResult(hits, options);
 }
+async function listWikiGraphLibraryArchiveMembers(target, options = {}) {
+  return createCollectionResult(
+    (await listWikiGraphLibraryArchives(target)).map(
+      formatLibraryArchiveMemberHit
+    ),
+    options
+  );
+}
 async function readWikiGraphLibraryPage(target, objectUri, options = {}) {
   const pages = await readIndexedArchiveResults(
     target,
@@ -41938,6 +42013,7 @@ __export(src_exports, {
   ensureWikiGraphHomeSchemaCurrent: () => ensureWikiGraphHomeSchemaCurrent,
   finalizeWikiGraphLibraryArchiveWrite: () => finalizeWikiGraphLibraryArchiveWrite,
   findArchiveObjects: () => findArchiveObjects,
+  findWikiGraphLibraryArchiveMembers: () => findWikiGraphLibraryArchiveMembers,
   findWikiGraphLibraryObjects: () => findWikiGraphLibraryObjects,
   formatChapterId: () => formatChapterId,
   formatChapterUri: () => formatChapterUri,
@@ -41983,6 +42059,7 @@ __export(src_exports, {
   listRelatedArchiveObjects: () => listRelatedArchiveObjects,
   listRelatedWikiGraphLibraryObjects: () => listRelatedWikiGraphLibraryObjects,
   listWikiGraphLibraries: () => listWikiGraphLibraries,
+  listWikiGraphLibraryArchiveMembers: () => listWikiGraphLibraryArchiveMembers,
   listWikiGraphLibraryArchives: () => listWikiGraphLibraryArchives,
   listWikiGraphLibraryEvidence: () => listWikiGraphLibraryEvidence,
   listWikiGraphLibraryIndexArchiveIdsForObject: () => listWikiGraphLibraryIndexArchiveIdsForObject,
@@ -43105,14 +43182,14 @@ async function upgradeWikiGraphMaintenanceTarget(target, options = {}) {
   }
   const archivePath = resolveArchiveUpgradeTarget(target);
   const schemaVersionBefore = await readWikiGraphArchiveSchemaVersion(archivePath);
-  await upgradeWikiGraphArchiveSchema(archivePath);
+  const upgradeResult = await upgradeWikiGraphArchiveSchema(archivePath);
   const schemaVersionAfter = await readWikiGraphArchiveSchemaVersion(archivePath);
   return {
     kind: "archive",
     path: archivePath,
     schemaVersionBefore,
     schemaVersionAfter,
-    status: schemaVersionBefore === schemaVersionAfter ? "already-current" : "upgraded"
+    status: upgradeResult.changed ? "upgraded" : "already-current"
   };
 }
 async function assertWikiGraphLibrarySchemaCurrent(target) {
@@ -43151,18 +43228,23 @@ async function upgradeWikiGraphLibrarySchema(target) {
       const schemaVersionBefore = await readWikiGraphArchiveSchemaVersion(
         archive.path
       );
-      if (schemaVersionBefore === CURRENT_ARCHIVE_SCHEMA_VERSION) {
-        skipped.push({
+      try {
+        const upgradeResult = await upgradeWikiGraphArchiveSchema(archive.path);
+        const schemaVersionAfter = await readWikiGraphArchiveSchemaVersion(
+          archive.path
+        );
+        const item = {
           path: archive.path,
           publicId: archive.publicId,
-          schemaVersionAfter: schemaVersionBefore,
+          schemaVersionAfter,
           schemaVersionBefore,
           uri: archive.uri
-        });
-        continue;
-      }
-      try {
-        await upgradeWikiGraphArchiveSchema(archive.path);
+        };
+        if (upgradeResult.changed) {
+          upgraded.push(item);
+        } else {
+          skipped.push(item);
+        }
       } catch (error) {
         return {
           failed: {
@@ -43178,15 +43260,6 @@ async function upgradeWikiGraphLibrarySchema(target) {
           upgraded
         };
       }
-      upgraded.push({
-        path: archive.path,
-        publicId: archive.publicId,
-        schemaVersionAfter: await readWikiGraphArchiveSchemaVersion(
-          archive.path
-        ),
-        schemaVersionBefore,
-        uri: archive.uri
-      });
     }
     return {
       kind: "lib",
@@ -43332,6 +43405,7 @@ init_object_stream();
   ensureWikiGraphHomeSchemaCurrent,
   finalizeWikiGraphLibraryArchiveWrite,
   findArchiveObjects,
+  findWikiGraphLibraryArchiveMembers,
   findWikiGraphLibraryObjects,
   formatChapterId,
   formatChapterUri,
@@ -43377,6 +43451,7 @@ init_object_stream();
   listRelatedArchiveObjects,
   listRelatedWikiGraphLibraryObjects,
   listWikiGraphLibraries,
+  listWikiGraphLibraryArchiveMembers,
   listWikiGraphLibraryArchives,
   listWikiGraphLibraryEvidence,
   listWikiGraphLibraryIndexArchiveIdsForObject,