@gmickel/gno 0.16.0 → 0.17.0

package/src/pipeline/vsearch.ts

@@ -15,6 +15,13 @@ import { err, ok } from "../store/types";
 import { createChunkLookup } from "./chunk-lookup";
 import { formatQueryForEmbedding } from "./contextual";
 import { detectQueryLanguage } from "./query-language";
+import {
+  resolveRecencyTimestamp,
+  isWithinTemporalRange,
+  resolveTemporalRange,
+  shouldSortByRecency,
+  type TemporalRange,
+} from "./temporal";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Score Normalization
@@ -58,6 +65,13 @@ export async function searchVectorWithEmbedding(
   const { store, vectorIndex } = deps;
   const limit = options.limit ?? 20;
   const minScore = options.minScore ?? 0;
+  const recencySort = shouldSortByRecency(query);
+  const retrievalLimit = recencySort ? limit * 3 : limit;
+  const temporalRange = resolveTemporalRange(
+    query,
+    options.since,
+    options.until
+  );
 
   // Detect query language for metadata (DOES NOT affect retrieval filtering)
   const detection = detectQueryLanguage(query);
@@ -72,15 +86,20 @@ export async function searchVectorWithEmbedding(
   }
 
   // Search nearest neighbors
-  const searchResult = await vectorIndex.searchNearest(queryEmbedding, limit, {
-    minScore,
-  });
+  const searchResult = await vectorIndex.searchNearest(
+    queryEmbedding,
+    retrievalLimit,
+    {
+      minScore,
+    }
+  );
 
   if (!searchResult.ok) {
     return err("QUERY_FAILED", searchResult.error.message);
   }
 
   const vecResults = searchResult.value;
+  const uniqueHashes = [...new Set(vecResults.map((v) => v.mirrorHash))];
 
   // Get collection paths for absPath resolution
   const collectionsResult = await store.getCollections();
@@ -96,10 +115,14 @@ export async function searchVectorWithEmbedding(
     collection: options.collection,
     tagsAll: options.tagsAll,
     tagsAny: options.tagsAny,
+    since: temporalRange.since,
+    until: temporalRange.until,
+    categories: options.categories,
+    author: options.author,
+    mirrorHashes: uniqueHashes,
   });
 
   // Pre-fetch all chunks in one batch query (eliminates N+1)
-  const uniqueHashes = [...new Set(vecResults.map((v) => v.mirrorHash))];
   const chunksMapResult = await store.getChunksBatch(uniqueHashes);
   if (!chunksMapResult.ok) {
     return err("QUERY_FAILED", chunksMapResult.error.message);
@@ -178,6 +201,7 @@ export async function searchVectorWithEmbedding(
         mime: doc.sourceMime,
         ext: doc.sourceExt,
         modifiedAt: doc.sourceMtime,
+        documentDate: doc.frontmatterDate ?? undefined,
         sizeBytes: doc.sourceSize,
         sourceHash: doc.sourceHash,
       },
@@ -223,6 +247,7 @@ export async function searchVectorWithEmbedding(
           mime: doc.sourceMime,
           ext: doc.sourceExt,
           modifiedAt: doc.sourceMtime,
+          documentDate: doc.frontmatterDate ?? undefined,
           sizeBytes: doc.sourceSize,
           sourceHash: doc.sourceHash,
         },
@@ -237,15 +262,38 @@ export async function searchVectorWithEmbedding(
     }
   }
 
+  if (recencySort) {
+    results.sort((a, b) => {
+      const aTs = resolveRecencyTimestamp(
+        a.source.documentDate,
+        a.source.modifiedAt
+      );
+      const bTs = resolveRecencyTimestamp(
+        b.source.documentDate,
+        b.source.modifiedAt
+      );
+      if (aTs !== bTs) {
+        return bTs - aTs;
+      }
+      return b.score - a.score;
+    });
+  }
+
+  const finalResults = results.slice(0, limit);
+
   return ok({
-    results,
+    results: finalResults,
     meta: {
       query,
       mode: "vector",
       vectorsUsed: true,
-      totalResults: results.length,
+      totalResults: finalResults.length,
       collection: options.collection,
       lang: options.lang,
+      since: temporalRange.since,
+      until: temporalRange.until,
+      categories: options.categories,
+      author: options.author,
       queryLanguage,
     },
   });
@@ -305,6 +353,7 @@ interface DocumentInfo {
   sourceMime: string;
   sourceExt: string;
   sourceMtime: string;
+  frontmatterDate?: string | null;
   sourceSize: number;
   mirrorHash: string | null;
   converterId: string | null;
@@ -319,6 +368,25 @@ interface DocumentMapOptions {
   collection?: string;
   tagsAll?: string[];
   tagsAny?: string[];
+  since?: string;
+  until?: string;
+  categories?: string[];
+  author?: string;
+  mirrorHashes?: string[];
+}
+
+function matchesCategoryFilter(
+  doc: { contentType?: string | null; categories?: string[] | null },
+  categories?: string[]
+): boolean {
+  if (!categories || categories.length === 0) {
+    return true;
+  }
+  const allowed = new Set(categories.map((c) => c.toLowerCase()));
+  if (doc.contentType && allowed.has(doc.contentType.toLowerCase())) {
+    return true;
+  }
+  return (doc.categories ?? []).some((c) => allowed.has(c.toLowerCase()));
 }
 
 async function buildDocumentMap(
@@ -327,13 +395,29 @@ async function buildDocumentMap(
 ): Promise<Map<string, DocumentInfo>> {
   const result = new Map<string, DocumentInfo>();
 
-  const docs = await store.listDocuments(options.collection);
+  if (options.mirrorHashes && options.mirrorHashes.length === 0) {
+    return result;
+  }
+
+  const docs = options.mirrorHashes
+    ? await store.getDocumentsByMirrorHashes(options.mirrorHashes, {
+        collection: options.collection,
+        activeOnly: true,
+      })
+    : await store.listDocuments(options.collection);
   if (!docs.ok) {
     return result;
   }
 
-  // Filter active docs with mirrorHash
-  const activeDocs = docs.value.filter((d) => d.mirrorHash && d.active);
+  // Filter docs with mirrorHash.
+  // listDocuments path still needs explicit active filter.
+  const activeDocs = options.mirrorHashes
+    ? docs.value.filter((d) => d.mirrorHash)
+    : docs.value.filter((d) => d.mirrorHash && d.active);
+  const temporalRange: TemporalRange = {
+    since: options.since,
+    until: options.until,
+  };
 
   // Apply tag filters if specified (batch fetch to avoid N+1)
   const needsTagFilter = options.tagsAll?.length || options.tagsAny?.length;
@@ -370,6 +454,19 @@ async function buildDocumentMap(
   }
 
   for (const doc of activeDocs) {
+    if (!isWithinTemporalRange(doc.sourceMtime, temporalRange)) {
+      continue;
+    }
+    if (!matchesCategoryFilter(doc, options.categories)) {
+      continue;
+    }
+    if (
+      options.author &&
+      !doc.author?.toLowerCase().includes(options.author.toLowerCase())
+    ) {
+      continue;
+    }
+
     // Skip if tag filter excluded this doc
     if (allowedDocIds !== null && !allowedDocIds.has(doc.id)) {
       continue;
@@ -385,6 +482,7 @@ async function buildDocumentMap(
       sourceMime: doc.sourceMime,
       sourceExt: doc.sourceExt,
       sourceMtime: doc.sourceMtime,
+      frontmatterDate: doc.frontmatterDate,
       sourceSize: doc.sourceSize,
       mirrorHash: doc.mirrorHash,
       converterId: doc.converterId,

package/src/serve/public/app.tsx

@@ -58,8 +58,6 @@ function App() {
     }
     window.history.pushState({}, "", to);
     setLocation(to);
-    // Dispatch event for components that need to react to URL changes
-    window.dispatchEvent(new CustomEvent("locationchange", { detail: to }));
   }, []);
 
   // Global keyboard shortcuts (single-key, GitHub/Gmail pattern)
@@ -98,7 +96,7 @@ function App() {
     <CaptureModalProvider>
       <div className="flex min-h-screen flex-col">
         <div className="flex-1">
-          <Page navigate={navigate} />
+          <Page key={location} navigate={navigate} />
         </div>
         <footer className="border-t border-border/50 bg-background/80 py-4 text-center text-muted-foreground text-sm">
           <div className="flex items-center justify-center gap-4">