@gmickel/gno 1.12.2 → 1.12.3

package/README.md

@@ -197,7 +197,7 @@ Manage the detached process with `gno daemon --status` and `gno daemon --stop`.
 
 ### Install GNO
 
-Requires [Bun](https://bun.sh/) >= 1.0.0.
+Requires [Bun](https://bun.sh/) >= 1.3.0.
 
 ```bash
 bun install -g @gmickel/gno

package/assets/skill/SKILL.md

@@ -227,7 +227,9 @@ gno graph --from gno://notes/a.md --to gno://notes/b.md
 ```
 
 Non-default index search results may include `?index=<name>` on `gno://` URIs.
-Keep that query string when passing the URI to `gno get`.
+Keep that query string when passing the URI to `gno get`, SDK `get()`, MCP
+`gno_get`, or an MCP resource read: it selects the named database. Batch reads
+must contain refs for one index; split mixed-index results before `multi-get`.
 
 ## Important: Embedding After Changes
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmickel/gno",
-  "version": "1.12.2",
+  "version": "1.12.3",
   "description": "Local semantic search for your documents. Index Markdown, PDF, and Office files with hybrid BM25 + vector search.",
   "keywords": [
     "embeddings",
@@ -71,6 +71,7 @@
     "eval:hybrid:baseline": "bun scripts/hybrid-benchmark.ts --write",
     "eval:hybrid:delta": "bun scripts/hybrid-benchmark.ts --delta",
     "bench:ast-chunking": "bun scripts/ast-chunking-benchmark.ts",
+    "smoke:serve-shutdown": "bun scripts/serve-shutdown-smoke.ts",
     "bench:code-embeddings": "bun scripts/code-embedding-benchmark.ts",
     "bench:code-embeddings:write": "bun scripts/code-embedding-benchmark.ts --write",
     "bench:general-embeddings": "bun scripts/general-embedding-benchmark.ts",

package/src/core/indexed-reference.ts

@@ -0,0 +1,68 @@
+import { DEFAULT_INDEX_NAME, parseUri } from "../app/constants";
+import { parseRef } from "./ref-parser";
+
+export interface EffectiveIndexResolution {
+  indexName?: string;
+}
+
+function normalizeIndexName(indexName?: string): string {
+  const normalized = indexName?.trim();
+  return normalized || DEFAULT_INDEX_NAME;
+}
+
+export function indexesMatch(left?: string, right?: string): boolean {
+  return normalizeIndexName(left) === normalizeIndexName(right);
+}
+
+export function getExplicitRefIndex(ref: string): string | undefined {
+  const parsed = parseRef(ref);
+  if ("error" in parsed || parsed.type !== "uri") {
+    return;
+  }
+  return parseUri(parsed.value)?.indexName;
+}
+
+export function resolveEffectiveIndex(
+  refs: string[],
+  activeIndexName?: string
+):
+  | { ok: true; value: EffectiveIndexResolution }
+  | { ok: false; error: string } {
+  const explicitIndexes = new Set<string>();
+  let hasUnindexedRef = false;
+
+  for (const ref of refs) {
+    const explicitIndex = getExplicitRefIndex(ref);
+    if (explicitIndex) {
+      explicitIndexes.add(explicitIndex);
+    } else {
+      hasUnindexedRef = true;
+    }
+  }
+
+  if (explicitIndexes.size > 1) {
+    return {
+      ok: false,
+      error: `References cannot mix explicit indexes: ${[...explicitIndexes]
+        .sort()
+        .join(", ")}`,
+    };
+  }
+
+  const explicitIndex = [...explicitIndexes][0];
+  if (
+    explicitIndex &&
+    hasUnindexedRef &&
+    !indexesMatch(explicitIndex, activeIndexName)
+  ) {
+    return {
+      ok: false,
+      error: `References cannot mix indexed refs (${explicitIndex}) with unindexed refs while the active index is ${normalizeIndexName(activeIndexName)}`,
+    };
+  }
+
+  return {
+    ok: true,
+    value: { indexName: explicitIndex ?? activeIndexName },
+  };
+}

package/src/core/ref-parser.ts

@@ -141,5 +141,10 @@ export function splitRefs(refs: string[]): string[] {
  * Check if a ref contains glob characters.
  */
 export function isGlobPattern(ref: string): boolean {
-  return GLOB_PATTERN.test(ref);
+  const queryIndex = ref.indexOf("?");
+  const globCandidate =
+    ref.startsWith("gno://") && queryIndex >= 0
+      ? ref.slice(0, queryIndex)
+      : ref;
+  return GLOB_PATTERN.test(globCandidate);
 }

package/src/index.ts

@@ -20,8 +20,17 @@ async function cleanupAndExit(code: number): Promise<never> {
   process.exit(code);
 }
 
-// SIGINT handler for graceful shutdown
+let interruptExitCode: 0 | 130 = 0;
+
+// Long-running commands install their own SIGINT handler and must finish their
+// resource teardown before this bootstrap exits. Short-lived commands have no
+// owner, so retain the immediate interrupt behavior for them.
 process.on("SIGINT", () => {
+  if (process.listenerCount("SIGINT") > 1) {
+    return;
+  }
+
+  interruptExitCode = 130;
   process.stderr.write("\nInterrupted\n");
   cleanupAndExit(130).catch(() => {
     // Ignore cleanup errors on exit
@@ -30,7 +39,7 @@ process.on("SIGINT", () => {
 
 // Run CLI and exit
 runCli(process.argv)
-  .then((code) => cleanupAndExit(code))
+  .then((code) => cleanupAndExit(interruptExitCode || code))
   .catch((err) => {
     process.stderr.write(
       `Fatal error: ${err instanceof Error ? err.message : String(err)}\n`

package/src/ingestion/sync.ts

@@ -75,6 +75,7 @@ const MAX_CONCURRENCY = 16;
 export const INGEST_VERSION = 6;
 const EMPTY_CONTENT_TYPE_RULES_FINGERPRINT = fingerprintContentTypeRules([]);
 const RELATION_EDGE_TYPE_PATTERN = /^[a-z][a-z0-9_]*$/;
+const PROJECTION_YIELD_INTERVAL = 25;
 const NON_RETRYABLE_CONVERSION_ERROR_CODES = new Set([
   "CORRUPT",
   "PERMISSION",
@@ -1000,19 +1001,83 @@ export class SyncService {
     relPaths: string[],
     options: SyncOptions = {}
   ): Promise<FileSyncResult[]> {
+    const result = await this.syncPaths(collection, store, relPaths, options);
+    return result.files ?? [];
+  }
+
+  async syncPaths(
+    collection: Collection,
+    store: StorePort,
+    relPaths: string[],
+    options: SyncOptions = {}
+  ): Promise<CollectionSyncResult> {
+    const startedAt = Date.now();
+    const syncOptions: SyncOptions = {
+      ...options,
+      contentTypeRules: options.contentTypeRules ?? [],
+      contentTypeRulesFingerprint:
+        options.contentTypeRulesFingerprint ??
+        fingerprintContentTypeRules(options.contentTypeRules ?? []),
+    };
     const results: FileSyncResult[] = [];
+    const projectionSourceIds = new Set<number>();
+    let markedInactive = 0;
 
     for (const relPath of relPaths) {
+      const existingResult = await store.getDocument(collection.name, relPath);
+      const existingDoc = existingResult.ok ? existingResult.value : null;
+      if (existingDoc) {
+        await this.collectProjectionSourceIds(
+          store,
+          existingDoc.id,
+          projectionSourceIds
+        );
+      }
+
       const absPath = join(collection.path, relPath);
       let stats: Awaited<ReturnType<typeof stat>>;
       try {
         stats = await stat(absPath);
-      } catch {
+      } catch (error) {
+        const errorCode =
+          error && typeof error === "object" && "code" in error
+            ? String(error.code)
+            : undefined;
+        if (errorCode !== "ENOENT") {
+          results.push({
+            relPath,
+            status: "error",
+            errorCode: "STAT_FAILED",
+            errorMessage:
+              error instanceof Error ? error.message : "Failed to stat file",
+          });
+          continue;
+        }
+        if (existingDoc?.active) {
+          const inactiveResult = await store.markInactive(collection.name, [
+            relPath,
+          ]);
+          if (!inactiveResult.ok) {
+            results.push({
+              relPath,
+              status: "error",
+              errorCode: inactiveResult.error.code,
+              errorMessage: inactiveResult.error.message,
+            });
+            continue;
+          }
+          markedInactive += inactiveResult.value;
+          results.push({
+            relPath,
+            status: "updated",
+            docid: existingDoc.docid,
+          });
+          continue;
+        }
         results.push({
           relPath,
-          status: "error",
-          errorCode: "NOT_FOUND",
-          errorMessage: "File not found",
+          status: existingDoc ? "unchanged" : "skipped",
+          docid: existingDoc?.docid,
         });
         continue;
       }
@@ -1035,24 +1100,91 @@ export class SyncService {
         ctime: (stats.birthtime ?? stats.ctime ?? stats.mtime).toISOString(),
       };
 
-      const result = await this.processFile(collection, entry, store, options);
+      const result = await this.processFile(
+        collection,
+        entry,
+        store,
+        syncOptions
+      );
       results.push(result);
+      const currentResult = await store.getDocument(collection.name, relPath);
+      const currentDoc = currentResult.ok ? currentResult.value : null;
+      if (currentDoc?.active) {
+        await this.collectProjectionSourceIds(
+          store,
+          currentDoc.id,
+          projectionSourceIds
+        );
+      }
     }
 
-    await this.projectTypedEdges(collection, store, options);
+    const errors =
+      syncOptions.projectTypedEdges === false
+        ? []
+        : await this.projectTypedEdges(store, syncOptions, projectionSourceIds);
+    const added = results.filter((result) => result.status === "added").length;
+    const updated = results.filter(
+      (result) => result.status === "updated"
+    ).length;
+    const unchanged = results.filter(
+      (result) => result.status === "unchanged"
+    ).length;
+    const errored = results.filter(
+      (result) => result.status === "error"
+    ).length;
+    const skipped = results.filter(
+      (result) => result.status === "skipped"
+    ).length;
 
-    return results;
+    return {
+      collection: collection.name,
+      filesProcessed: results.length,
+      filesAdded: added,
+      filesUpdated: updated,
+      filesUnchanged: unchanged,
+      filesErrored: errored,
+      filesSkipped: skipped,
+      filesMarkedInactive: markedInactive,
+      durationMs: Date.now() - startedAt,
+      files: results,
+      errors,
+    };
+  }
+
+  private async collectProjectionSourceIds(
+    store: StorePort,
+    documentId: number,
+    sourceIds: Set<number>
+  ): Promise<void> {
+    sourceIds.add(documentId);
+    const [linkBacklinks, edgeBacklinks] = await Promise.all([
+      store.getBacklinksForDoc(documentId),
+      store.getEdgeBacklinksForDoc(documentId),
+    ]);
+    if (linkBacklinks.ok) {
+      for (const backlink of linkBacklinks.value) {
+        sourceIds.add(backlink.sourceDocId);
+      }
+    }
+    if (edgeBacklinks.ok) {
+      for (const backlink of edgeBacklinks.value) {
+        sourceIds.add(backlink.sourceDocId);
+      }
+    }
   }
 
   private async projectTypedEdges(
-    collection: Collection,
     store: StorePort,
-    options: SyncOptions
+    options: SyncOptions,
+    sourceDocumentIds?: Set<number>
   ): Promise<Array<{ relPath: string; code: string; message: string }>> {
     const errors: Array<{ relPath: string; code: string; message: string }> =
       [];
 
-    const backfillResult = await store.backfillDocEdges();
+    const selectedSourceIds = sourceDocumentIds
+      ? [...sourceDocumentIds]
+      : undefined;
+    const backfillResult = await store.backfillDocEdges(selectedSourceIds);
     if (!backfillResult.ok) {
       return [
         {
@@ -1075,8 +1207,22 @@ export class SyncService {
     }
 
     const activeDocs = docsResult.value.filter((doc) => doc.active);
+    const activeIds = new Set(activeDocs.map((doc) => doc.id));
+    if (selectedSourceIds) {
+      for (const documentId of selectedSourceIds) {
+        if (!activeIds.has(documentId)) {
+          await store.setDocEdges(documentId, [], "frontmatter-relation");
+        }
+      }
+    }
+    const projectedDocs = sourceDocumentIds
+      ? activeDocs.filter((doc) => sourceDocumentIds.has(doc.id))
+      : activeDocs;
 
-    for (const doc of activeDocs) {
+    for (const [docIndex, doc] of projectedDocs.entries()) {
+      if (docIndex > 0 && docIndex % PROJECTION_YIELD_INTERVAL === 0) {
+        await Bun.sleep(0);
+      }
       if (!doc.mirrorHash) {
         continue;
       }
@@ -1193,6 +1339,14 @@ export class SyncService {
     return errors;
   }
 
+  /** Run an exact global typed-edge reconciliation with cooperative yields. */
+  reconcileTypedEdges(
+    store: StorePort,
+    options: SyncOptions = {}
+  ): Promise<Array<{ relPath: string; code: string; message: string }>> {
+    return this.projectTypedEdges(store, options);
+  }
+
   /**
    * Sync a single collection.
    */
@@ -1419,9 +1573,9 @@ export class SyncService {
       }
     }
 
-    errors.push(
-      ...(await this.projectTypedEdges(collection, store, syncOptions))
-    );
+    if (syncOptions.projectTypedEdges !== false) {
+      errors.push(...(await this.projectTypedEdges(store, syncOptions)));
+    }
 
     return {
       collection: collection.name,
@@ -1448,12 +1602,25 @@ export class SyncService {
   ): Promise<SyncResult> {
     const startTime = Date.now();
     const results: CollectionSyncResult[] = [];
+    const deferredProjectionOptions: SyncOptions = {
+      ...options,
+      projectTypedEdges: false,
+    };
 
     for (const collection of collections) {
-      const result = await this.syncCollection(collection, store, options);
+      const result = await this.syncCollection(
+        collection,
+        store,
+        deferredProjectionOptions
+      );
       results.push(result);
     }
 
+    if (results.length > 0) {
+      const projectionErrors = await this.projectTypedEdges(store, options);
+      results.at(-1)?.errors.push(...projectionErrors);
+    }
+
     // Aggregate totals
     const totals = results.reduce(
       (acc, r) => ({

package/src/ingestion/types.ts

@@ -137,6 +137,8 @@ export interface SyncOptions {
   contentTypeRules?: NormalizedContentTypeRule[];
   /** Stable hash of the normalized content type rules, used for re-derivation. */
   contentTypeRulesFingerprint?: string;
+  /** Internal orchestration flag: defer graph projection to an outer sync. */
+  projectTypedEdges?: boolean;
 }
 
 export type ContentTypeSource =

package/src/mcp/resources/index.ts

@@ -20,8 +20,10 @@ import {
   URI_PREFIX,
 } from "../../app/constants";
 import { MCP_ERRORS } from "../../core/errors";
+import { resolveEffectiveIndex } from "../../core/indexed-reference";
 import { normalizeTag, validateTag } from "../../core/tags";
 import { normalizeCollectionName } from "../../core/validation";
+import { openScopedIndexStore } from "../../store/sqlite/scoped-index";
 
 // Tags resource URI prefix
 const TAGS_URI = `${URI_PREFIX}tags`;
@@ -51,7 +53,8 @@ function formatTagsContent(
 function formatResourceContent(
   doc: DocumentRow,
   content: string,
-  ctx: ToolContext
+  ctx: ToolContext,
+  indexName = ctx.indexName
 ): string {
   // Find collection for absPath
   const uriParsed = parseUri(doc.uri);
@@ -69,7 +72,7 @@ function formatResourceContent(
   const langLine = doc.languageHint
     ? `\n     language: ${doc.languageHint}`
     : "";
-  const displayUri = decorateUriForIndex(doc.uri, ctx.indexName);
+  const displayUri = decorateUriForIndex(doc.uri, indexName);
   const header = `<!-- ${displayUri}
      docid: ${doc.docid}
      source: ${absPath}
@@ -125,61 +128,82 @@ export function registerResources(server: McpServer, ctx: ToolContext): void {
         throw new Error(`Invalid gno:// URI: ${uri.href}`);
       }
 
-      const { collection, path } = parsed;
-
-      // Validate collection exists
-      const collectionExists = ctx.collections.some(
-        (c) => c.name === collection
-      );
-      if (!collectionExists) {
-        throw new Error(`Collection not found: ${collection}`);
+      const resolution = resolveEffectiveIndex([uri.href], ctx.indexName);
+      if (!resolution.ok) {
+        throw new Error(resolution.error);
       }
+      const scoped = await openScopedIndexStore({
+        activeStore: ctx.store,
+        activeIndexName: ctx.indexName,
+        requestedIndexName: resolution.value.indexName,
+        config: ctx.config,
+        configPath: ctx.actualConfigPath,
+      });
+
+      try {
+        const { collection, path } = parsed;
 
-      // Look up document (path is properly decoded by parseUri)
-      const docResult = await ctx.store.getDocument(collection, path);
-      if (!docResult.ok) {
-        throw new Error(
-          `Failed to lookup document: ${docResult.error.message}`
+        // Validate collection exists
+        const collectionExists = ctx.collections.some(
+          (c) => c.name === collection
         );
-      }
+        if (!collectionExists) {
+          throw new Error(`Collection not found: ${collection}`);
+        }
 
-      const doc = docResult.value;
-      if (!doc) {
-        throw new Error(`Document not found: ${uri.href}`);
-      }
+        // Look up document (path is properly decoded by parseUri)
+        const docResult = await scoped.store.getDocument(collection, path);
+        if (!docResult.ok) {
+          throw new Error(
+            `Failed to lookup document: ${docResult.error.message}`
+          );
+        }
 
-      // Get content
-      if (!doc.mirrorHash) {
-        throw new Error(`Document has no indexed content: ${uri.href}`);
-      }
+        const doc = docResult.value;
+        if (!doc) {
+          throw new Error(`Document not found: ${uri.href}`);
+        }
 
-      const contentResult = await ctx.store.getContent(doc.mirrorHash);
-      if (!contentResult.ok) {
-        throw new Error(
-          `Failed to read content: ${contentResult.error.message}`
-        );
-      }
+        // Get content
+        if (!doc.mirrorHash) {
+          throw new Error(`Document has no indexed content: ${uri.href}`);
+        }
 
-      const content = contentResult.value ?? "";
+        const contentResult = await scoped.store.getContent(doc.mirrorHash);
+        if (!contentResult.ok) {
+          throw new Error(
+            `Failed to read content: ${contentResult.error.message}`
+          );
+        }
 
-      // Format with header and line numbers
-      const formattedContent = formatResourceContent(doc, content, ctx);
+        const content = contentResult.value ?? "";
 
-      // Build canonical URI
-      const canonicalUri = decorateUriForIndex(
-        buildUri(collection, path),
-        parsed.indexName ?? ctx.indexName
-      );
+        // Format with header and line numbers
+        const formattedContent = formatResourceContent(
+          doc,
+          content,
+          ctx,
+          scoped.indexName
+        );
 
-      return {
-        contents: [
-          {
-            uri: canonicalUri,
-            mimeType: "text/markdown",
-            text: formattedContent,
-          },
-        ],
-      };
+        // Build canonical URI
+        const canonicalUri = decorateUriForIndex(
+          buildUri(collection, path),
+          scoped.indexName
+        );
+
+        return {
+          contents: [
+            {
+              uri: canonicalUri,
+              mimeType: "text/markdown",
+              text: formattedContent,
+            },
+          ],
+        };
+      } finally {
+        await scoped.close();
+      }
     } finally {
       release();
     }