@gmickel/gno 1.2.0 → 1.3.0

package/src/llm/nodeLlamaCpp/lifecycle.ts

@@ -16,6 +16,7 @@ import { loadFailedError, outOfMemoryError, timeoutError } from "../errors";
 
 type Llama = Awaited<ReturnType<typeof import("node-llama-cpp").getLlama>>;
 type LlamaModel = Awaited<ReturnType<Llama["loadModel"]>>;
+export type LlamaGpuMode = "auto" | "metal" | "vulkan" | "cuda" | false;
 
 interface CachedModel {
   uri: string;
@@ -24,6 +25,40 @@ interface CachedModel {
   loadedAt: number;
 }
 
+let invalidGpuModeWarned = false;
+let gpuFallbackWarned = false;
+
+export function resolveLlamaGpuMode(
+  env: NodeJS.ProcessEnv = process.env
+): LlamaGpuMode {
+  const raw = (env.GNO_LLAMA_GPU ?? env.NODE_LLAMA_CPP_GPU ?? "auto")
+    .trim()
+    .toLowerCase();
+  if (!raw || raw === "auto") {
+    return "auto";
+  }
+  if (raw === "metal" || raw === "vulkan" || raw === "cuda") {
+    return raw;
+  }
+  if (
+    raw === "false" ||
+    raw === "off" ||
+    raw === "none" ||
+    raw === "disable" ||
+    raw === "disabled" ||
+    raw === "0"
+  ) {
+    return false;
+  }
+  if (!invalidGpuModeWarned) {
+    invalidGpuModeWarned = true;
+    console.warn(
+      `[llama] Invalid GNO_LLAMA_GPU/NODE_LLAMA_CPP_GPU value "${raw}", using auto`
+    );
+  }
+  return "auto";
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // ModelManager
 // ─────────────────────────────────────────────────────────────────────────────
@@ -48,11 +83,32 @@ export class ModelManager {
   async getLlama(): Promise<Llama> {
     if (!this.llama) {
       const { getLlama, LlamaLogLevel } = await import("node-llama-cpp");
+      const gpu = resolveLlamaGpuMode();
       // Suppress model loading warnings (vocab tokens, pooling type)
-      this.llama = await getLlama({
-        build: "autoAttempt",
-        logLevel: LlamaLogLevel.error,
-      });
+      try {
+        this.llama = await getLlama({
+          build: "autoAttempt",
+          gpu,
+          logLevel: LlamaLogLevel.error,
+        });
+      } catch (error) {
+        if (gpu === "auto" || gpu === false) {
+          throw error;
+        }
+        if (!gpuFallbackWarned) {
+          gpuFallbackWarned = true;
+          console.warn(
+            `[llama] GPU backend "${gpu}" failed, retrying with CPU: ${
+              error instanceof Error ? error.message : String(error)
+            }`
+          );
+        }
+        this.llama = await getLlama({
+          build: "autoAttempt",
+          gpu: false,
+          logLevel: LlamaLogLevel.error,
+        });
+      }
     }
     return this.llama;
   }

package/src/mcp/resources/index.ts

@@ -13,7 +13,12 @@ import { join as pathJoin } from "node:path";
 import type { DocumentRow, TagCount } from "../../store/types";
 import type { ToolContext } from "../server";
 
-import { buildUri, parseUri, URI_PREFIX } from "../../app/constants";
+import {
+  buildUri,
+  decorateUriForIndex,
+  parseUri,
+  URI_PREFIX,
+} from "../../app/constants";
 import { MCP_ERRORS } from "../../core/errors";
 import { normalizeTag, validateTag } from "../../core/tags";
 import { normalizeCollectionName } from "../../core/validation";
@@ -64,7 +69,8 @@ function formatResourceContent(
   const langLine = doc.languageHint
     ? `\n     language: ${doc.languageHint}`
     : "";
-  const header = `<!-- ${doc.uri}
+  const displayUri = decorateUriForIndex(doc.uri, ctx.indexName);
+  const header = `<!-- ${displayUri}
      docid: ${doc.docid}
      source: ${absPath}
      mime: ${doc.sourceMime}${langLine}
@@ -94,7 +100,7 @@ export function registerResources(server: McpServer, ctx: ToolContext): void {
 
       return {
         resources: listResult.value.map((doc) => ({
-          uri: doc.uri,
+          uri: decorateUriForIndex(doc.uri, ctx.indexName),
           name: doc.relPath,
           mimeType: doc.sourceMime || "text/markdown",
           description: doc.title ?? undefined,
@@ -160,7 +166,10 @@ export function registerResources(server: McpServer, ctx: ToolContext): void {
       const formattedContent = formatResourceContent(doc, content, ctx);
 
       // Build canonical URI
-      const canonicalUri = buildUri(collection, path);
+      const canonicalUri = decorateUriForIndex(
+        buildUri(collection, path),
+        parsed.indexName ?? ctx.indexName
+      );
 
       return {
         contents: [

package/src/mcp/server.ts

@@ -57,6 +57,7 @@ export interface ToolContext {
   config: Config;
   collections: Collection[];
   actualConfigPath: string;
+  indexName?: string;
   toolMutex: Mutex;
   jobManager: JobManager;
   serverInstanceId: string;
@@ -164,6 +165,7 @@ export async function startMcpServer(options: McpServerOptions): Promise<void> {
     config,
     collections,
     actualConfigPath,
+    indexName: options.indexName,
     toolMutex,
     jobManager,
     serverInstanceId,

package/src/mcp/tools/get.ts

@@ -9,7 +9,7 @@ import { join as pathJoin } from "node:path";
 import type { DocumentRow, StorePort } from "../../store/types";
 import type { ToolContext } from "../server";
 
-import { parseUri } from "../../app/constants";
+import { decorateUriForIndex, parseUri } from "../../app/constants";
 import { parseRef } from "../../cli/commands/ref-parser";
 import {
   getDocumentCapabilities,
@@ -196,7 +196,12 @@ export function handleGet(
 
       const response: GetResponse = {
         docid: doc.docid,
-        uri: doc.uri,
+        uri: decorateUriForIndex(
+          doc.uri,
+          parsed.type === "uri"
+            ? (parseUri(parsed.value)?.indexName ?? ctx.indexName)
+            : ctx.indexName
+        ),
         title: doc.title ?? undefined,
         content,
         totalLines,

package/src/mcp/tools/multi-get.ts

@@ -9,7 +9,7 @@ import { join as pathJoin } from "node:path";
 import type { DocumentRow, StorePort } from "../../store/types";
 import type { ToolContext } from "../server";
 
-import { parseUri } from "../../app/constants";
+import { decorateUriForIndex, parseUri } from "../../app/constants";
 import { parseRef } from "../../cli/commands/ref-parser";
 import { runTool, type ToolResult } from "./index";
 
@@ -232,7 +232,7 @@ export function handleMultiGet(
 
         documents.push({
           docid: doc.docid,
-          uri: doc.uri,
+          uri: decorateUriForIndex(doc.uri, ctx.indexName),
           title: doc.title ?? undefined,
           content,
           totalLines: (contentResult.value ?? "").split("\n").length,

package/src/mcp/tools/query.ts

@@ -18,7 +18,7 @@ import type {
 } from "../../pipeline/types";
 import type { ToolContext } from "../server";
 
-import { parseUri } from "../../app/constants";
+import { decorateUriForIndex, parseUri } from "../../app/constants";
 import { createNonTtyProgressRenderer } from "../../cli/progress";
 import { resolveDepthPolicy } from "../../core/depth-policy";
 import { normalizeStructuredQueryInput } from "../../core/structured-query";
@@ -76,6 +76,7 @@ function enrichWithAbsPath(
 
     return {
       ...r,
+      uri: decorateUriForIndex(r.uri, ctx.indexName),
       source: {
         ...r.source,
         absPath: pathJoin(collection.path, r.source.relPath),

package/src/mcp/tools/search.ts

@@ -9,7 +9,7 @@ import { join as pathJoin } from "node:path";
 import type { SearchResult, SearchResults } from "../../pipeline/types";
 import type { ToolContext } from "../server";
 
-import { parseUri } from "../../app/constants";
+import { decorateUriForIndex, parseUri } from "../../app/constants";
 import { searchBm25 } from "../../pipeline/search";
 import { normalizeTagFilters, runTool, type ToolResult } from "./index";
 
@@ -51,6 +51,7 @@ function enrichWithAbsPath(
 
     return {
       ...r,
+      uri: decorateUriForIndex(r.uri, ctx.indexName),
       source: {
         ...r.source,
         absPath: pathJoin(collection.path, r.source.relPath),

package/src/mcp/tools/vsearch.ts

@@ -9,7 +9,7 @@ import { join as pathJoin } from "node:path";
 import type { SearchResult, SearchResults } from "../../pipeline/types";
 import type { ToolContext } from "../server";
 
-import { parseUri } from "../../app/constants";
+import { decorateUriForIndex, parseUri } from "../../app/constants";
 import { createNonTtyProgressRenderer } from "../../cli/progress";
 import { LlmAdapter } from "../../llm/nodeLlamaCpp/adapter";
 import { resolveDownloadPolicy } from "../../llm/policy";
@@ -60,6 +60,7 @@ function enrichWithAbsPath(
 
     return {
       ...r,
+      uri: decorateUriForIndex(r.uri, ctx.indexName),
       source: {
         ...r.source,
         absPath: pathJoin(collection.path, r.source.relPath),

package/src/pipeline/explain.ts

@@ -122,9 +122,19 @@ export function explainBm25(count: number): ExplainLine {
   return { stage: "bm25", message: `${count} candidates` };
 }
 
-export function explainVector(count: number, available: boolean): ExplainLine {
+export function explainVector(
+  count: number,
+  available: boolean,
+  unavailableReason?: string,
+  guidance?: string
+): ExplainLine {
   if (!available) {
-    return { stage: "vector", message: "unavailable (sqlite-vec not loaded)" };
+    const detail = unavailableReason ? `: ${unavailableReason}` : "";
+    const hint = guidance ? `; ${guidance}` : "";
+    return {
+      stage: "vector",
+      message: `unavailable (sqlite-vec not loaded${detail})${hint}`,
+    };
   }
   return { stage: "vector", message: `${count} candidates` };
 }

package/src/pipeline/hybrid.ts

@@ -528,7 +528,14 @@ export async function searchHybrid(
   }
   timings.vectorMs = performance.now() - vectorStartedAt;
 
-  explainLines.push(explainVector(vecCount, vectorAvailable));
+  explainLines.push(
+    explainVector(
+      vecCount,
+      vectorAvailable,
+      vectorIndex?.loadError,
+      vectorIndex?.guidance
+    )
+  );
 
   // ─────────────────────────────────────────────────────────────────────────
   // 3. RRF Fusion
@@ -800,6 +807,7 @@ export async function searchHybrid(
       score: candidate.blendedScore,
       uri: doc.uri,
       title: doc.title ?? undefined,
+      line: snippetChunk.startLine,
       snippet,
       snippetLanguage: chunk.language ?? undefined,
       snippetRange,

package/src/pipeline/search.ts

@@ -15,6 +15,7 @@ import type {
   SearchResults,
 } from "./types";
 
+import { getContentBatch } from "../store/content-batch";
 import { err, ok } from "../store/types";
 import { createChunkLookup } from "./chunk-lookup";
 import { matchesExcludedChunks, matchesExcludedText } from "./exclude";
@@ -116,6 +117,7 @@ function buildSearchResult(ctx: BuildResultContext): SearchResult {
     score: fts.score, // Raw score, normalized later as batch
     uri: fts.uri ?? "",
     title: fts.title,
+    line: chunk?.startLine,
     snippet,
     snippetLanguage: chunk?.language ?? undefined,
     snippetRange,
@@ -277,14 +279,21 @@ export async function searchBm25(
     const sortedEntries = [...bestByDocid.values()].sort(
       (a, b) => a.score - b.score
     );
+    const fullContentResult = await getContentBatch(
+      store,
+      sortedEntries
+        .map(({ fts }) => fts.mirrorHash)
+        .filter((mirrorHash): mirrorHash is string => Boolean(mirrorHash))
+    );
+    if (!fullContentResult.ok) {
+      return err("QUERY_FAILED", fullContentResult.error.message);
+    }
+    const fullContentByHash = fullContentResult.value;
+
     for (const { fts, chunk } of sortedEntries) {
-      let fullContent: string | undefined;
-      if (fts.mirrorHash) {
-        const contentResult = await store.getContent(fts.mirrorHash);
-        if (contentResult.ok && contentResult.value) {
-          fullContent = contentResult.value;
-        }
-      }
+      const fullContent = fts.mirrorHash
+        ? fullContentByHash.get(fts.mirrorHash)
+        : undefined;
       const collectionPath = fts.collection
         ? collectionPaths.get(fts.collection)
         : undefined;

package/src/pipeline/types.ts

@@ -43,6 +43,8 @@ export interface SearchResult {
   score: number;
   uri: string;
   title?: string;
+  /** Best source line for editor/agent anchors (1-indexed) */
+  line?: number;
   snippet: string;
   snippetLanguage?: string;
   snippetRange?: SnippetRange;

package/src/pipeline/vsearch.ts

@@ -11,6 +11,7 @@ import type { StorePort } from "../store/types";
 import type { VectorIndexPort } from "../store/vector/types";
 import type { SearchOptions, SearchResult, SearchResults } from "./types";
 
+import { getContentBatch } from "../store/content-batch";
 import { err, ok } from "../store/types";
 import { createChunkLookup } from "./chunk-lookup";
 import { formatQueryForEmbedding } from "./contextual";
@@ -49,6 +50,16 @@ export interface VectorSearchDeps {
   config: Config;
 }
 
+function vectorUnavailableMessage(vectorIndex: VectorIndexPort): string {
+  const reason = vectorIndex.loadError
+    ? ` Reason: ${vectorIndex.loadError}`
+    : "";
+  const guidance = vectorIndex.guidance
+    ? ` ${vectorIndex.guidance}`
+    : " Run: gno doctor";
+  return `Vector search unavailable.${reason}${guidance}`;
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Search Function (with pre-computed embedding)
 // ─────────────────────────────────────────────────────────────────────────────
@@ -81,10 +92,7 @@ export async function searchVectorWithEmbedding(
 
   // Check if vector search is available
   if (!vectorIndex.searchAvailable) {
-    return err(
-      "VEC_SEARCH_UNAVAILABLE",
-      "Vector search requires sqlite-vec. Run: gno embed"
-    );
+    return err("VEC_SEARCH_UNAVAILABLE", vectorUnavailableMessage(vectorIndex));
   }
 
   // Search nearest neighbors
@@ -219,6 +227,7 @@ export async function searchVectorWithEmbedding(
       score,
       uri: doc.uri,
       title: doc.title ?? undefined,
+      line: chunk.startLine,
       snippet: chunk.text,
       snippetLanguage: chunk.language ?? undefined,
       snippetRange: {
@@ -249,14 +258,21 @@ export async function searchVectorWithEmbedding(
 
   // For --full, fetch full content and build results
   if (options.full) {
+    const fullContentResult = await getContentBatch(
+      store,
+      [...bestByDocid.values()]
+        .map(({ doc }) => doc.mirrorHash)
+        .filter((mirrorHash): mirrorHash is string => Boolean(mirrorHash))
+    );
+    if (!fullContentResult.ok) {
+      return err("QUERY_FAILED", fullContentResult.error.message);
+    }
+    const fullContentByHash = fullContentResult.value;
+
     for (const { doc, chunk, score } of bestByDocid.values()) {
-      let fullContent: string | undefined;
-      if (doc.mirrorHash) {
-        const contentResult = await store.getContent(doc.mirrorHash);
-        if (contentResult.ok && contentResult.value) {
-          fullContent = contentResult.value;
-        }
-      }
+      const fullContent = doc.mirrorHash
+        ? fullContentByHash.get(doc.mirrorHash)
+        : undefined;
 
       const collectionPath = collectionPaths.get(doc.collection);
 
@@ -265,6 +281,7 @@ export async function searchVectorWithEmbedding(
         score,
         uri: doc.uri,
         title: doc.title ?? undefined,
+        line: chunk.startLine,
         snippet: fullContent ?? chunk.text,
         snippetLanguage: chunk.language ?? undefined,
         // --full: no snippetRange (full doc content)
@@ -346,10 +363,7 @@ export async function searchVector(
 
   // Check if vector search is available
   if (!vectorIndex.searchAvailable) {
-    return err(
-      "VEC_SEARCH_UNAVAILABLE",
-      "Vector search requires sqlite-vec. Run: gno embed"
-    );
+    return err("VEC_SEARCH_UNAVAILABLE", vectorUnavailableMessage(vectorIndex));
   }
 
   // Embed query with contextual formatting

package/src/publish/export-service.ts

@@ -9,6 +9,7 @@ import type { DocumentRow, StorePort, TagRow } from "../store/types";
 
 import { parseRef } from "../cli/commands/ref-parser";
 import { parseFrontmatter } from "../ingestion/frontmatter";
+import { getContentBatch } from "../store/content-batch";
 import {
   buildEncryptedPublishArtifact,
   buildPublishArtifact,
@@ -155,16 +156,40 @@ async function exportCollectionArtifact(
     throw new Error(`Collection "${collection.name}" has no active documents`);
   }
 
+  const contentResult = await getContentBatch(
+    store,
+    activeDocs
+      .map((doc) => doc.mirrorHash)
+      .filter((mirrorHash): mirrorHash is string => Boolean(mirrorHash))
+  );
+  if (!contentResult.ok) {
+    throw new Error(contentResult.error.message);
+  }
+
+  const tagsResult = await store.getTagsBatch(activeDocs.map((doc) => doc.id));
+  if (!tagsResult.ok) {
+    throw new Error(tagsResult.error.message);
+  }
+
+  const contentByHash = contentResult.value;
+  const tagsByDocId = tagsResult.value;
+
   const notes: PublishArtifactNote[] = [];
   for (const doc of activeDocs) {
-    const rawMarkdown = await loadDocumentMarkdown(store, doc);
+    if (!doc.mirrorHash) {
+      throw new Error(`Document has no converted content: ${doc.uri}`);
+    }
+    const rawMarkdown = contentByHash.get(doc.mirrorHash);
+    if (rawMarkdown === undefined) {
+      throw new Error(`Unable to load content for ${doc.uri}`);
+    }
     if (isPublishDisabledByFrontmatter(rawMarkdown)) {
       continue;
     }
     const sanitized = sanitizeObsidianMarkdown(rawMarkdown);
     warnings.push(...sanitized.warnings);
     const markdown = sanitized.markdown;
-    const tags = await loadDocumentTags(store, doc);
+    const tags = tagsByDocId.get(doc.id) ?? [];
     const frontmatter = parseFrontmatter(markdown).metadata;
     const title = deriveExportedTitle(doc);
     notes.push({

package/src/sdk/client.ts

@@ -37,7 +37,11 @@ import type {
   GnoVectorSearchOptions,
 } from "./types";
 
-import { getIndexDbPath } from "../app/constants";
+import {
+  decorateUriForIndex,
+  getIndexDbPath,
+  parseUri,
+} from "../app/constants";
 import { ConfigSchema, loadConfig } from "../config";
 import {
   atomicWrite,
@@ -88,6 +92,7 @@ interface OpenedClientState {
   store: SqliteAdapter;
   llm: LlmAdapter;
   downloadPolicy: DownloadPolicy;
+  indexName?: string;
 }
 
 interface RuntimePorts {
@@ -158,6 +163,7 @@ async function resolveClientState(
     llm: new LlmAdapter(config, options.cacheDir),
     downloadPolicy:
       options.downloadPolicy ?? resolveDownloadPolicy(process.env, {}),
+    indexName: options.indexName,
   };
 }
 
@@ -170,6 +176,7 @@ class GnoClientImpl implements GnoClient {
   private readonly store: SqliteAdapter;
   private readonly llm: LlmAdapter;
   private readonly downloadPolicy: DownloadPolicy;
+  private readonly indexName?: string;
   private closed = false;
 
   constructor(state: OpenedClientState) {
@@ -180,6 +187,7 @@ class GnoClientImpl implements GnoClient {
     this.store = state.store;
     this.llm = state.llm;
     this.downloadPolicy = state.downloadPolicy;
+    this.indexName = state.indexName;
   }
 
   isOpen(): boolean {
@@ -371,12 +379,24 @@ class GnoClientImpl implements GnoClient {
     }
   }
 
+  private decorateSearchResults(results: SearchResults): SearchResults {
+    return {
+      ...results,
+      results: results.results.map((result) => ({
+        ...result,
+        uri: decorateUriForIndex(result.uri, this.indexName),
+      })),
+    };
+  }
+
   async search(
     query: string,
     options: import("../pipeline/types").SearchOptions = {}
   ): Promise<SearchResults> {
     this.assertOpen();
-    return unwrapStore(await searchBm25(this.store, query, options));
+    return this.decorateSearchResults(
+      unwrapStore(await searchBm25(this.store, query, options))
+    );
   }
 
   async vsearch(
@@ -409,17 +429,19 @@ class GnoClientImpl implements GnoClient {
         });
       }
 
-      return unwrapStore(
-        await searchVectorWithEmbedding(
-          {
-            store: this.store,
-            vectorIndex: ports.vectorIndex,
-            embedPort: ports.embedPort,
-            config: this.config,
-          },
-          query,
-          new Float32Array(queryEmbedResult.value),
-          options
+      return this.decorateSearchResults(
+        unwrapStore(
+          await searchVectorWithEmbedding(
+            {
+              store: this.store,
+              vectorIndex: ports.vectorIndex,
+              embedPort: ports.embedPort,
+              config: this.config,
+            },
+            query,
+            new Float32Array(queryEmbedResult.value),
+            options
+          )
         )
       );
     } finally {
@@ -461,18 +483,20 @@ class GnoClientImpl implements GnoClient {
     });
 
     try {
-      return unwrapStore(
-        await searchHybrid(
-          {
-            store: this.store,
-            config: this.config,
-            vectorIndex: ports.vectorIndex,
-            embedPort: ports.embedPort,
-            expandPort: ports.expandPort,
-            rerankPort: ports.rerankPort,
-          },
-          query,
-          options
+      return this.decorateSearchResults(
+        unwrapStore(
+          await searchHybrid(
+            {
+              store: this.store,
+              config: this.config,
+              vectorIndex: ports.vectorIndex,
+              embedPort: ports.embedPort,
+              expandPort: ports.expandPort,
+              rerankPort: ports.rerankPort,
+            },
+            query,
+            options
+          )
         )
       );
     } finally {
@@ -606,17 +630,48 @@ class GnoClientImpl implements GnoClient {
 
   async get(ref: string, options: GnoGetOptions = {}) {
     this.assertOpen();
-    return getDocumentByRef(this.store, this.config, ref, options);
+    const explicitIndex = ref.startsWith("gno://")
+      ? parseUri(ref)?.indexName
+      : undefined;
+    const result = await getDocumentByRef(
+      this.store,
+      this.config,
+      ref,
+      options
+    );
+    return {
+      ...result,
+      uri: decorateUriForIndex(result.uri, explicitIndex ?? this.indexName),
+    };
   }
 
   async multiGet(refs: string[], options: GnoMultiGetOptions = {}) {
     this.assertOpen();
-    return multiGetDocuments(this.store, this.config, refs, options);
+    const result = await multiGetDocuments(
+      this.store,
+      this.config,
+      refs,
+      options
+    );
+    return {
+      ...result,
+      documents: result.documents.map((doc) => ({
+        ...doc,
+        uri: decorateUriForIndex(doc.uri, this.indexName),
+      })),
+    };
   }
 
   async list(options: GnoListOptions = {}) {
     this.assertOpen();
-    return listDocuments(this.store, options);
+    const result = await listDocuments(this.store, options);
+    return {
+      ...result,
+      documents: result.documents.map((doc) => ({
+        ...doc,
+        uri: decorateUriForIndex(doc.uri, this.indexName),
+      })),
+    };
   }
 
   async status(): Promise<IndexStatus> {