@gmickel/gno 1.29.4 → 1.29.6

package/README.md

@@ -2,7 +2,7 @@
 
 **Search finds. GNO proves.**
 
-A local knowledge engine for your notes, code, PDFs, and Office docs — that hands agents evidence with exact line spans and content hashes, and stops when the evidence stops.
+A local knowledge engine for your notes, code, PDFs, and Office docs. Hybrid search, a browsable workspace with graph and editor, CLI, SDK, REST API, and MCP for ten AI clients — plus retrieval that can show its work.
 
 [![npm](./assets/badges/npm.svg)](https://www.npmjs.com/package/@gmickel/gno)
 [![MIT License](./assets/badges/license.svg)](./LICENSE)
@@ -18,6 +18,12 @@ gno setup ~/notes --name notes     # returns only after retrieval actually works
 gno mcp install --target cursor    # or claude-code, claude-desktop, zed, ...
 ```
 
+## What you get
+
+BM25 and vector retrieval fused and reranked over Markdown, code, PDFs, Office files, and exported mail, calendar and transcripts. A web workspace with cross-collection browse, a knowledge graph, a markdown editor and provenance-carrying capture. A fast CLI, a TypeScript SDK, a REST API, a headless daemon, and one-command install into ten agent clients. Optional hosted publishing when a slice needs a URL.
+
+That is the table stakes. Here is the part that is harder to find elsewhere.
+
 ## Why not just another local RAG tool
 
 Most retrieval tools return a ranked list and leave the rest to optimism. Four things here are different, and each one is measurable rather than adjectival:
@@ -101,7 +107,7 @@ gno daemon --detach  # headless indexing + resident MCP gateway
 
 <!-- public-truth:current-version -->
 
-> Current release: **v1.29.4** — see [CHANGELOG.md](./CHANGELOG.md)
+> Current release: **v1.29.6** — see [CHANGELOG.md](./CHANGELOG.md)
 
 <!-- /public-truth -->
 

package/browser-extension/artifacts/gno-browser-clipper-v1.29.6.zip.sha256

@@ -0,0 +1 @@
+c1fc560d5f77022b3123d36c0f488b0e662883b0b67e6e40fe7476674d70e085  gno-browser-clipper-v1.29.6.zip

package/browser-extension/dist/manifest.json

@@ -21,5 +21,5 @@
   "content_security_policy": {
     "extension_pages": "script-src 'self'; object-src 'none'; connect-src http://127.0.0.1:*"
   },
-  "version": "1.29.4"
+  "version": "1.29.6"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmickel/gno",
-  "version": "1.29.4",
+  "version": "1.29.6",
   "description": "Local semantic search for your documents. Index Markdown, PDF, and Office files with hybrid BM25 + vector search.",
   "keywords": [
     "embeddings",

package/src/ingestion/index.ts

@@ -31,4 +31,4 @@ export type {
 } from "./types";
 export { collectionToWalkConfig, DEFAULT_CHUNK_PARAMS } from "./types";
 // Walker
-export { defaultWalker, FileWalker } from "./walker";
+export { defaultWalker, FileWalker, matchesWalkPath } from "./walker";

package/src/ingestion/walker.ts

@@ -174,6 +174,50 @@ function matchesInclude(
   });
 }
 
+type PathEligibilityConfig = Pick<
+  WalkConfig,
+  "additionalDefaultExtensions" | "exclude" | "include" | "pattern"
+>;
+
+/**
+ * Check collection-relative path eligibility without touching the filesystem.
+ * This intentionally remains usable for deleted paths so incremental sync can
+ * mark previously indexed documents inactive.
+ */
+export function matchesWalkPath(
+  relPath: string,
+  config: PathEligibilityConfig
+): boolean {
+  const normalizedPath = relPath.replaceAll("\\", "/");
+  if (
+    isAbsolute(normalizedPath) ||
+    DANGEROUS_PATTERN_REGEX.test(normalizedPath) ||
+    isRecordVirtualPath(normalizedPath)
+  ) {
+    return false;
+  }
+
+  let matchesPattern = false;
+  try {
+    matchesPattern = new Bun.Glob(config.pattern).match(normalizedPath);
+  } catch {
+    return false;
+  }
+  if (!matchesPattern) {
+    return false;
+  }
+
+  if (matchesCollectionExclusion(normalizedPath, config.exclude)) {
+    return false;
+  }
+
+  return matchesInclude(
+    normalizedPath,
+    config.include,
+    config.additionalDefaultExtensions ?? []
+  );
+}
+
 /**
  * File walker implementation using Bun.Glob.
  *
@@ -228,29 +272,7 @@ export class FileWalker implements WalkerPort {
       }
       const { absPath, relPath } = safePath;
 
-      if (isRecordVirtualPath(relPath)) {
-        skipped.push({ absPath, relPath, reason: "EXCLUDED" });
-        continue;
-      }
-
-      // Check exclude patterns
-      if (matchesCollectionExclusion(relPath, config.exclude)) {
-        skipped.push({
-          absPath,
-          relPath,
-          reason: "EXCLUDED",
-        });
-        continue;
-      }
-
-      // Check include extensions
-      if (
-        !matchesInclude(
-          relPath,
-          config.include,
-          config.additionalDefaultExtensions ?? []
-        )
-      ) {
+      if (!matchesWalkPath(relPath, config)) {
         skipped.push({
           absPath,
           relPath,

package/src/serve/watch-service.ts

@@ -7,7 +7,11 @@ import type { SqliteAdapter } from "../store/sqlite/adapter";
 import type { DocumentEvent, DocumentEventBus } from "./doc-events";
 import type { EmbedScheduler } from "./embed-scheduler";
 
-import { defaultSyncService } from "../ingestion";
+import {
+  collectionToWalkConfig,
+  defaultSyncService,
+  matchesWalkPath,
+} from "../ingestion";
 
 export interface CollectionWatchState {
   expectedCollections: string[];
@@ -45,6 +49,41 @@ interface CollectionWatchServiceOptions {
   watchFactory?: typeof watch;
 }
 
+function watcherCollectionFingerprint(
+  collection: Collection,
+  syncOptions: SyncOptions
+): string {
+  return JSON.stringify({
+    path: normalize(collection.path),
+    pattern: collection.pattern,
+    include: collection.include,
+    exclude: collection.exclude,
+    languageHint: collection.languageHint ?? null,
+    recordAdapters: collection.recordAdapters ?? null,
+    limits: syncOptions.limits ?? null,
+    concurrency: syncOptions.concurrency ?? null,
+    contentTypeRules: syncOptions.contentTypeRules ?? null,
+    contentTypeRulesFingerprint:
+      syncOptions.contentTypeRulesFingerprint ?? null,
+    projectTypedEdges: syncOptions.projectTypedEdges ?? null,
+  });
+}
+
+function changedPaths(
+  result: CollectionSyncResult,
+  fallbackPaths: string[] = []
+): string[] {
+  if (result.files) {
+    return result.files
+      .filter((file) => file.status === "added" || file.status === "updated")
+      .map((file) => file.relPath);
+  }
+  return result.filesAdded + result.filesUpdated + result.filesMarkedInactive >
+    0
+    ? fallbackPaths
+    : [];
+}
+
 export class CollectionWatchService {
   #collections: Collection[];
   readonly #store: SqliteAdapter;
@@ -53,12 +92,18 @@ export class CollectionWatchService {
   readonly #callbacks: CollectionWatchCallbacks | null;
   #syncOptions: SyncOptions;
   readonly #watchers = new Map<string, FSWatcher>();
+  readonly #watchRoots = new Map<string, string>();
+  readonly #collectionGenerations = new Map<string, number>();
+  readonly #collectionFingerprints = new Map<string, string>();
   readonly #pendingByCollection = new Map<string, Set<string>>();
   readonly #timers = new Map<string, ReturnType<typeof setTimeout>>();
   readonly #syncing = new Set<string>();
+  readonly #inFlightSyncs = new Set<Promise<void>>();
   readonly #suppressedPaths = new Map<string, number>();
   readonly #watchFactory: typeof watch;
   readonly #failedCollections = new Map<string, string>();
+  #nextCollectionGeneration = 0;
+  #disposed = false;
   #lastEventAt: string | null = null;
   #lastSyncAt: string | null = null;
 
@@ -73,6 +118,9 @@ export class CollectionWatchService {
   }
 
   start(): void {
+    if (this.#disposed) {
+      return;
+    }
     this.updateCollections(this.#collections);
   }
 
@@ -80,16 +128,28 @@ export class CollectionWatchService {
     collections: Collection[],
     syncOptions?: SyncOptions
   ): void {
-    this.#collections = collections;
+    if (this.#disposed) {
+      return;
+    }
     if (syncOptions) {
       this.#syncOptions = syncOptions;
     }
-    const nextNames = new Set(collections.map((collection) => collection.name));
+    const nextByName = new Map(
+      collections.map((collection) => [collection.name, collection])
+    );
 
     for (const [collectionName, watcher] of this.#watchers) {
-      if (!nextNames.has(collectionName)) {
+      const nextCollection = nextByName.get(collectionName);
+      const nextRoot = nextCollection
+        ? normalize(nextCollection.path)
+        : undefined;
+      if (
+        nextRoot === undefined ||
+        nextRoot !== this.#watchRoots.get(collectionName)
+      ) {
         watcher.close();
         this.#watchers.delete(collectionName);
+        this.#watchRoots.delete(collectionName);
         this.#failedCollections.delete(collectionName);
         this.#pendingByCollection.delete(collectionName);
         const timer = this.#timers.get(collectionName);
@@ -97,7 +157,31 @@ export class CollectionWatchService {
           clearTimeout(timer);
           this.#timers.delete(collectionName);
         }
-        this.#syncing.delete(collectionName);
+      }
+    }
+
+    for (const collectionName of this.#collectionFingerprints.keys()) {
+      if (!nextByName.has(collectionName)) {
+        this.#collectionFingerprints.delete(collectionName);
+        this.#collectionGenerations.set(
+          collectionName,
+          ++this.#nextCollectionGeneration
+        );
+      }
+    }
+
+    this.#collections = collections;
+    for (const collection of collections) {
+      const fingerprint = watcherCollectionFingerprint(
+        collection,
+        this.#syncOptions
+      );
+      if (this.#collectionFingerprints.get(collection.name) !== fingerprint) {
+        this.#collectionFingerprints.set(collection.name, fingerprint);
+        this.#collectionGenerations.set(
+          collection.name,
+          ++this.#nextCollectionGeneration
+        );
       }
     }
 
@@ -106,13 +190,27 @@ export class CollectionWatchService {
         continue;
       }
       try {
+        const watchedRoot = normalize(collection.path);
         const watcher = this.#watchFactory(
           collection.path,
           { recursive: true },
           (_eventType, filename) => {
-            if (!filename) return;
+            if (this.#disposed || !filename) return;
             const relPath = filename.toString().replaceAll("\\", "/");
-            const fullPath = normalize(join(collection.path, relPath));
+            const currentCollection = this.#collections.find(
+              (entry) => entry.name === collection.name
+            );
+            if (
+              !currentCollection ||
+              normalize(currentCollection.path) !== watchedRoot ||
+              !matchesWalkPath(
+                relPath,
+                collectionToWalkConfig(currentCollection, 0)
+              )
+            ) {
+              return;
+            }
+            const fullPath = normalize(join(watchedRoot, relPath));
             const suppressedUntil = this.#suppressedPaths.get(fullPath);
             if (suppressedUntil && suppressedUntil > Date.now()) {
               return;
@@ -122,6 +220,7 @@ export class CollectionWatchService {
           }
         );
         this.#watchers.set(collection.name, watcher);
+        this.#watchRoots.set(collection.name, watchedRoot);
         this.#failedCollections.delete(collection.name);
       } catch (error) {
         this.#failedCollections.set(
@@ -136,7 +235,11 @@ export class CollectionWatchService {
     this.#suppressedPaths.set(normalize(absPath), Date.now() + ms);
   }
 
-  dispose(): void {
+  async dispose(): Promise<void> {
+    if (this.#disposed) {
+      return;
+    }
+    this.#disposed = true;
     for (const timer of this.#timers.values()) {
       clearTimeout(timer);
     }
@@ -145,7 +248,12 @@ export class CollectionWatchService {
     }
     this.#timers.clear();
     this.#watchers.clear();
+    this.#watchRoots.clear();
+    this.#collectionGenerations.clear();
+    this.#collectionFingerprints.clear();
+    this.#collections = [];
     this.#pendingByCollection.clear();
+    await Promise.allSettled(this.#inFlightSyncs);
     this.#syncing.clear();
   }
 
@@ -168,6 +276,9 @@ export class CollectionWatchService {
   }
 
   #queueChange(collectionName: string, relPath: string): void {
+    if (this.#disposed) {
+      return;
+    }
     const pending =
       this.#pendingByCollection.get(collectionName) ?? new Set<string>();
     pending.add(relPath);
@@ -180,12 +291,28 @@ export class CollectionWatchService {
     this.#timers.set(
       collectionName,
       setTimeout(() => {
-        void this.#flushCollection(collectionName);
+        this.#startFlush(collectionName);
       }, 300)
     );
   }
 
+  #startFlush(collectionName: string): void {
+    if (this.#disposed) {
+      return;
+    }
+    const sync = this.#flushCollection(collectionName);
+    this.#inFlightSyncs.add(sync);
+    void sync
+      .finally(() => {
+        this.#inFlightSyncs.delete(sync);
+      })
+      .catch(() => undefined);
+  }
+
   async #flushCollection(collectionName: string): Promise<void> {
+    if (this.#disposed) {
+      return;
+    }
     const pending = this.#pendingByCollection.get(collectionName);
     if (!pending || pending.size === 0) {
       return;
@@ -202,8 +329,15 @@ export class CollectionWatchService {
       return;
     }
 
-    const relPaths = [...pending];
+    const relPaths = [...pending].filter((relPath) =>
+      matchesWalkPath(relPath, collectionToWalkConfig(collection, 0))
+    );
+    let syncGeneration = this.#collectionGenerations.get(collectionName) ?? 0;
     this.#pendingByCollection.set(collectionName, new Set<string>());
+    if (relPaths.length === 0) {
+      this.#notifySettledIfIdle();
+      return;
+    }
     this.#syncing.add(collectionName);
 
     try {
@@ -211,7 +345,7 @@ export class CollectionWatchService {
         collection: collection.name,
         relPaths,
       });
-      const result = await defaultSyncService.syncPaths(
+      let result = await defaultSyncService.syncPaths(
         collection,
         this.#store,
         relPaths,
@@ -220,13 +354,67 @@ export class CollectionWatchService {
           runUpdateCmd: false,
         }
       );
+      if (this.#disposed) {
+        return;
+      }
       this.#callbacks?.onSyncComplete?.({
         collection: collection.name,
         relPaths,
         result,
       });
-      this.#afterSync(collection, relPaths);
+
+      let completionCollection = collection;
+      let completionPaths = changedPaths(result, relPaths);
+      while (true) {
+        const currentCollection = this.#collections.find(
+          (entry) => entry.name === collectionName
+        );
+        if (!currentCollection) {
+          break;
+        }
+        const currentGeneration =
+          this.#collectionGenerations.get(collectionName) ?? 0;
+        if (currentGeneration === syncGeneration) {
+          const currentRelPaths =
+            normalize(currentCollection.path) ===
+            normalize(completionCollection.path)
+              ? completionPaths.filter((relPath) =>
+                  matchesWalkPath(
+                    relPath,
+                    collectionToWalkConfig(currentCollection, 0)
+                  )
+                )
+              : [];
+          if (currentRelPaths.length > 0) {
+            this.#afterSync(currentCollection, currentRelPaths);
+          }
+          break;
+        }
+
+        result = await defaultSyncService.syncCollection(
+          currentCollection,
+          this.#store,
+          {
+            ...this.#syncOptions,
+            runUpdateCmd: false,
+          }
+        );
+        if (this.#disposed) {
+          return;
+        }
+        completionCollection = currentCollection;
+        completionPaths = changedPaths(result);
+        syncGeneration = currentGeneration;
+        this.#callbacks?.onSyncComplete?.({
+          collection: currentCollection.name,
+          relPaths: completionPaths,
+          result,
+        });
+      }
     } catch (error) {
+      if (this.#disposed) {
+        return;
+      }
       this.#callbacks?.onSyncError?.({
         collection: collection.name,
         relPaths,
@@ -235,22 +423,30 @@ export class CollectionWatchService {
       throw error;
     } finally {
       this.#syncing.delete(collectionName);
-      const remaining = this.#pendingByCollection.get(collectionName);
-      if (remaining && remaining.size > 0) {
-        void this.#flushCollection(collectionName);
-      } else if (
-        this.#syncing.size === 0 &&
-        ![...this.#pendingByCollection.values()].some(
-          (relPaths) => relPaths.size > 0
-        )
-      ) {
-        this.#callbacks?.onSettled?.();
+      if (!this.#disposed) {
+        const remaining = this.#pendingByCollection.get(collectionName);
+        if (remaining && remaining.size > 0) {
+          this.#startFlush(collectionName);
+        } else {
+          this.#notifySettledIfIdle();
+        }
       }
     }
   }
 
+  #notifySettledIfIdle(): void {
+    if (
+      this.#syncing.size === 0 &&
+      ![...this.#pendingByCollection.values()].some(
+        (relPaths) => relPaths.size > 0
+      )
+    ) {
+      this.#callbacks?.onSettled?.();
+    }
+  }
+
   #afterSync(collection: Collection, relPaths: string[]): void {
-    if (relPaths.length === 0) {
+    if (this.#disposed || relPaths.length === 0) {
       return;
     }
 

package/browser-extension/artifacts/gno-browser-clipper-v1.29.4.zip.sha256

@@ -1 +0,0 @@
-b639ecf7ff5ebd7aeacf1bad0fe3fe2f471a60c96bdf047d873b6bf932995161  gno-browser-clipper-v1.29.4.zip