@gmickel/gno 1.2.1 → 1.3.0

package/src/cli/program.ts

@@ -311,6 +311,7 @@ function wireSearchCommands(program: Command): void {
     .action(async (queryText: string, cmdOpts: Record<string, unknown>) => {
       const format = getFormat(cmdOpts);
       assertFormatSupported(CMD.search, format);
+      const globals = getGlobals();
 
       // Validate empty query
       if (!queryText.trim()) {
@@ -348,6 +349,8 @@ function wireSearchCommands(program: Command): void {
 
       const { search, formatSearch } = await import("./commands/search");
       const result = await search(queryText, {
+        configPath: globals.config,
+        indexName: globals.index,
         limit,
         minScore,
         collection: cmdOpts.collection as string | undefined,
@@ -425,6 +428,7 @@ function wireSearchCommands(program: Command): void {
     .action(async (queryText: string, cmdOpts: Record<string, unknown>) => {
       const format = getFormat(cmdOpts);
       assertFormatSupported(CMD.vsearch, format);
+      const globals = getGlobals();
 
       // Validate empty query
       if (!queryText.trim()) {
@@ -462,6 +466,8 @@ function wireSearchCommands(program: Command): void {
 
       const { vsearch, formatVsearch } = await import("./commands/vsearch");
       const result = await vsearch(queryText, {
+        configPath: globals.config,
+        indexName: globals.index,
         limit,
         minScore,
         collection: cmdOpts.collection as string | undefined,
@@ -631,6 +637,8 @@ function wireSearchCommands(program: Command): void {
 
       const { query, formatQuery } = await import("./commands/query");
       const result = await query(queryText, {
+        configPath: globals.config,
+        indexName: globals.index,
         limit,
         minScore,
         collection: cmdOpts.collection as string | undefined,
@@ -885,6 +893,8 @@ function wireOnboardingCommands(program: Command): void {
         const globals = getGlobals();
         const { index, formatIndex } = await import("./commands/index-cmd");
         const opts = {
+          configPath: globals.config,
+          indexName: globals.index,
           collection,
           noEmbed: cmdOpts.embed === false,
           gitPull: Boolean(cmdOpts.gitPull),
@@ -911,7 +921,12 @@ function wireOnboardingCommands(program: Command): void {
       assertFormatSupported(CMD.status, format);
 
       const { status, formatStatus } = await import("./commands/status");
-      const result = await status({ json: format === "json" });
+      const globals = getGlobals();
+      const result = await status({
+        configPath: globals.config,
+        indexName: globals.index,
+        json: format === "json",
+      });
 
       if (!result.success) {
         throw new CliError("RUNTIME", result.error ?? "Status failed");
@@ -969,6 +984,7 @@ function wireRetrievalCommands(program: Command): void {
       const { get, formatGet } = await import("./commands/get");
       const result = await get(ref, {
         configPath: globals.config,
+        indexName: globals.index,
         from: cmdOpts.from as number | undefined,
         limit: cmdOpts.limit as number | undefined,
         lineNumbers: Boolean(cmdOpts.lineNumbers),
@@ -1014,6 +1030,7 @@ function wireRetrievalCommands(program: Command): void {
       const { multiGet, formatMultiGet } = await import("./commands/multi-get");
       const result = await multiGet(refs, {
         configPath: globals.config,
+        indexName: globals.index,
         maxBytes: cmdOpts.maxBytes as number | undefined,
         lineNumbers: Boolean(cmdOpts.lineNumbers),
         json: format === "json",
@@ -1515,6 +1532,8 @@ function wireManagementCommands(program: Command): void {
       const globals = getGlobals();
       const { update, formatUpdate } = await import("./commands/update");
       const opts = {
+        configPath: globals.config,
+        indexName: globals.index,
         gitPull: Boolean(cmdOpts.gitPull),
         verbose: globals.verbose,
       };
@@ -1548,6 +1567,8 @@ function wireManagementCommands(program: Command): void {
         const collection =
           collectionArg ?? (cmdOpts.collection as string | undefined);
         const opts = {
+          configPath: globals.config,
+          indexName: globals.index,
           collection,
           model: cmdOpts.model as string | undefined,
           batchSize: parsePositiveInt("batch-size", cmdOpts.batchSize),

package/src/ingestion/chunker.ts

@@ -372,6 +372,12 @@ export class MarkdownChunker implements ChunkerPort {
           // Find a good prose break point
           findBreakPoint(markdown, targetEnd, windowSize);
       }
+      if (endPos <= pos) {
+        endPos = Math.min(markdown.length, pos + maxChars);
+      }
+      if (endPos - pos > maxChars + windowSize) {
+        endPos = Math.min(markdown.length, pos + maxChars);
+      }
 
       // Extract chunk text - preserve exactly (no trim!)
       // This maintains accurate pos/line mappings and Markdown semantics

package/src/llm/cache.ts

@@ -13,6 +13,7 @@ import { isAbsolute, join } from "node:path";
 // node:url: fileURLToPath for proper file:// URL handling
 import { fileURLToPath } from "node:url";
 
+import type { LlmError } from "./errors";
 import type { DownloadPolicy } from "./policy";
 import type {
   DownloadProgress,
@@ -26,8 +27,10 @@ import { getModelsCachePath } from "../app/constants";
 import {
   autoDownloadDisabledError,
   downloadFailedError,
+  invalidModelFileError,
   invalidUriError,
   lockFailedError,
+  modelDownloadInterceptedError,
   modelNotCachedError,
   modelNotFoundError,
 } from "./errors";
@@ -40,6 +43,67 @@ import { getLockPath, getManifestLockPath, withLock } from "./lockfile";
 // Regex patterns for URI parsing (top-level for performance)
 const HF_QUANT_PATTERN = /^([^/]+)\/([^/:]+):(\w+)$/;
 const HF_PATH_PATTERN = /^([^/]+)\/([^/]+)\/(.+\.gguf)$/;
+const GGUF_MAGIC = new Uint8Array([0x47, 0x47, 0x55, 0x46]);
+
+type ModelFileOwner = "cache" | "user";
+
+type ValidatedCachedPath =
+  | { ok: true; path: string }
+  | { ok: false; kind: "missing" }
+  | { ok: false; kind: "invalid"; error: LlmError };
+
+function looksLikeHtml(bytes: Uint8Array): boolean {
+  const text = new TextDecoder("utf-8", { fatal: false })
+    .decode(bytes)
+    .toLowerCase();
+  return (
+    text.includes("<!doctype") ||
+    text.includes("<html") ||
+    text.includes("<head") ||
+    text.includes("<body") ||
+    (text.includes("huggingface") && text.includes("<"))
+  );
+}
+
+function hasGgufMagic(bytes: Uint8Array): boolean {
+  return GGUF_MAGIC.every((value, index) => bytes[index] === value);
+}
+
+export async function validateGgufFile(
+  path: string,
+  uri: string,
+  owner: ModelFileOwner
+): Promise<LlmResult<void>> {
+  const file = Bun.file(path);
+  const exists = await file.exists();
+  if (!exists) {
+    return {
+      ok: false,
+      error: modelNotFoundError(uri, `File not found: ${path}`),
+    };
+  }
+
+  const bytes = new Uint8Array(await file.slice(0, 512).arrayBuffer());
+  if (hasGgufMagic(bytes)) {
+    return { ok: true, value: undefined };
+  }
+
+  if (looksLikeHtml(bytes)) {
+    return {
+      ok: false,
+      error: modelDownloadInterceptedError(uri, path, owner),
+    };
+  }
+
+  return {
+    ok: false,
+    error: invalidModelFileError(
+      uri,
+      path,
+      bytes.length === 0 ? "empty file" : "missing GGUF magic header"
+    ),
+  };
+}
 
 async function computeSha256(path: string): Promise<string> {
   const hasher = new Bun.CryptoHasher("sha256");
@@ -233,13 +297,20 @@ export class ModelCache {
           ),
         };
       }
+      const validation = await validateGgufFile(parsed.value.file, uri, "user");
+      if (!validation.ok) {
+        return validation;
+      }
       return { ok: true, value: parsed.value.file };
     }
 
     // HF models: check cache
-    const cached = await this.getCachedPath(uri);
-    if (cached) {
-      return { ok: true, value: cached };
+    const cached = await this.getValidatedCachedPath(uri);
+    if (cached.ok) {
+      return { ok: true, value: cached.path };
+    }
+    if (cached.kind === "invalid") {
+      return { ok: false, error: cached.error };
     }
 
     return { ok: false, error: modelNotCachedError(uri, type) };
@@ -272,6 +343,10 @@ export class ModelCache {
           ),
         };
       }
+      const validation = await validateGgufFile(parsed.value.file, uri, "user");
+      if (!validation.ok) {
+        return validation;
+      }
       return { ok: true, value: parsed.value.file };
     }
 
@@ -326,6 +401,14 @@ export class ModelCache {
           : undefined,
       });
 
+      const validation = await validateGgufFile(resolvedPath, uri, "cache");
+      if (!validation.ok) {
+        await rm(resolvedPath, { force: true }).catch(() => {
+          // Ignore deletion errors
+        });
+        return validation;
+      }
+
       // Update manifest
       await this.addToManifest(uri, type, resolvedPath);
 
@@ -351,9 +434,12 @@ export class ModelCache {
     onProgress?: ProgressCallback
   ): Promise<LlmResult<string>> {
     // Fast path: check if already cached
-    const cached = await this.getCachedPath(uri);
-    if (cached) {
-      return { ok: true, value: cached };
+    const cached = await this.getValidatedCachedPath(uri);
+    if (cached.ok) {
+      return { ok: true, value: cached.path };
+    }
+    if (cached.kind === "invalid") {
+      return { ok: false, error: cached.error };
     }
 
     // Parse and validate URI
@@ -374,6 +460,10 @@ export class ModelCache {
           ),
         };
       }
+      const validation = await validateGgufFile(parsed.value.file, uri, "user");
+      if (!validation.ok) {
+        return validation;
+      }
       return { ok: true, value: parsed.value.file };
     }
 
@@ -397,9 +487,12 @@ export class ModelCache {
 
     const result = await withLock(lockPath, async () => {
       // Double-check: another process may have downloaded while we waited
-      const cachedNow = await this.getCachedPath(uri);
-      if (cachedNow) {
-        return { ok: true as const, value: cachedNow };
+      const cachedNow = await this.getValidatedCachedPath(uri);
+      if (cachedNow.ok) {
+        return { ok: true as const, value: cachedNow.path };
+      }
+      if (cachedNow.kind === "invalid") {
+        return { ok: false as const, error: cachedNow.error };
       }
 
       // Download with progress
@@ -433,26 +526,12 @@ export class ModelCache {
     // Handle file: URIs directly (check filesystem, not manifest)
     const parsed = parseModelUri(uri);
     if (parsed.ok && parsed.value.scheme === "file") {
-      const exists = await this.fileExists(parsed.value.file);
-      return exists ? parsed.value.file : null;
+      const validation = await validateGgufFile(parsed.value.file, uri, "user");
+      return validation.ok ? parsed.value.file : null;
     }
 
-    // HF URIs: check manifest
-    const manifest = await this.loadManifest();
-    const entry = manifest.models.find((m) => m.uri === uri);
-    if (!entry) {
-      return null;
-    }
-
-    // Verify file still exists
-    const exists = await this.fileExists(entry.path);
-    if (!exists) {
-      // Remove stale entry
-      await this.removeFromManifest(uri);
-      return null;
-    }
-
-    return entry.path;
+    const cached = await this.getValidatedCachedPath(uri);
+    return cached.ok ? cached.path : null;
   }
 
   /**
@@ -514,6 +593,33 @@ export class ModelCache {
     }
   }
 
+  private async getValidatedCachedPath(
+    uri: string
+  ): Promise<ValidatedCachedPath> {
+    const manifest = await this.loadManifest();
+    const entry = manifest.models.find((m) => m.uri === uri);
+    if (!entry) {
+      return { ok: false, kind: "missing" };
+    }
+
+    const exists = await this.fileExists(entry.path);
+    if (!exists) {
+      await this.removeFromManifest(uri);
+      return { ok: false, kind: "missing" };
+    }
+
+    const validation = await validateGgufFile(entry.path, uri, "cache");
+    if (validation.ok) {
+      return { ok: true, path: entry.path };
+    }
+
+    await rm(entry.path, { force: true }).catch(() => {
+      // Ignore deletion errors
+    });
+    await this.removeFromManifest(uri);
+    return { ok: false, kind: "invalid", error: validation.error };
+  }
+
   private async loadManifest(): Promise<Manifest> {
     if (this.manifest) {
       return this.manifest;

package/src/llm/errors.ts

@@ -15,6 +15,8 @@ export type LlmErrorCode =
   | "MODEL_DOWNLOAD_FAILED"
   | "MODEL_LOAD_FAILED"
   | "MODEL_CORRUPTED"
+  | "INVALID_MODEL_FILE"
+  | "MODEL_DOWNLOAD_INTERCEPTED"
   | "INFERENCE_FAILED"
   | "TIMEOUT"
   | "OUT_OF_MEMORY"
@@ -160,6 +162,36 @@ export function corruptedError(uri: string, cause?: unknown): LlmError {
   });
 }
 
+export function invalidModelFileError(
+  uri: string,
+  path: string,
+  details?: string
+): LlmError {
+  return llmError("INVALID_MODEL_FILE", {
+    message: `Model file is not a GGUF file: ${path}${details ? ` (${details})` : ""}`,
+    modelUri: uri,
+    retryable: false,
+    suggestion: "Remove the file or run: gno models pull --force",
+  });
+}
+
+export function modelDownloadInterceptedError(
+  uri: string,
+  path: string,
+  owner: "cache" | "user"
+): LlmError {
+  return llmError("MODEL_DOWNLOAD_INTERCEPTED", {
+    message:
+      `Model file looks like HTML instead of GGUF: ${path}. ` +
+      `A proxy, firewall, or captive portal likely intercepted the download.` +
+      (owner === "cache" ? " The cached file was removed." : ""),
+    modelUri: uri,
+    retryable: false,
+    suggestion:
+      "Check network access to Hugging Face, then run: gno models pull --force",
+  });
+}
+
 export function inferenceFailedError(uri: string, cause?: unknown): LlmError {
   return llmError("INFERENCE_FAILED", {
     message: `Inference failed for model: ${uri}`,

package/src/llm/nodeLlamaCpp/embedding.ts

@@ -31,6 +31,12 @@ interface EmbeddingWorker {
   pending: number;
 }
 
+interface TokenizingModel {
+  trainContextSize?: number;
+  tokenize(text: string): readonly number[];
+  detokenize(tokens: readonly number[]): string;
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Constants
 // ─────────────────────────────────────────────────────────────────────────────
@@ -51,6 +57,9 @@ export class NodeLlamaCppEmbedding implements EmbeddingPort {
     null;
   private lifecycleVersion = 0;
   private dims: number | null = null;
+  private llamaModel: TokenizingModel | null = null;
+  private warnedSingleTruncation = false;
+  private warnedBatchTruncation = false;
   private readonly manager: ModelManager;
   readonly modelUri: string;
   private readonly modelPath: string;
@@ -76,8 +85,12 @@ export class NodeLlamaCppEmbedding implements EmbeddingPort {
     }
 
     try {
+      const prepared = this.truncateForEmbedding(text, "single");
+      if (!prepared.ok) {
+        return { ok: false, error: prepared.error };
+      }
       const embedding = await this.runOnWorker((worker) =>
-        worker.context.getEmbeddingFor(text)
+        worker.context.getEmbeddingFor(prepared.value.text)
       );
       const vector = Array.from(embedding.vector) as number[];
 
@@ -103,6 +116,15 @@ export class NodeLlamaCppEmbedding implements EmbeddingPort {
     }
 
     try {
+      const preparedTexts: string[] = [];
+      for (const text of texts) {
+        const prepared = this.truncateForEmbedding(text, "batch");
+        if (!prepared.ok) {
+          return { ok: false, error: prepared.error };
+        }
+        preparedTexts.push(prepared.value.text);
+      }
+
       const allResults = Array.from(
         { length: texts.length },
         () => [] as number[]
@@ -114,14 +136,14 @@ export class NodeLlamaCppEmbedding implements EmbeddingPort {
           while (true) {
             const index = nextIndex;
             nextIndex += 1;
-            if (index >= texts.length) {
+            if (index >= preparedTexts.length) {
               return;
             }
 
             const embedding = await this.runOnSpecificWorker(
               worker,
               (current) =>
-                current.context.getEmbeddingFor(texts[index] as string)
+                current.context.getEmbeddingFor(preparedTexts[index] as string)
             );
             allResults[index] = Array.from(embedding.vector) as number[];
           }
@@ -263,6 +285,7 @@ export class NodeLlamaCppEmbedding implements EmbeddingPort {
 
     try {
       const llamaModel = model.value.model as LlamaModel;
+      this.llamaModel = llamaModel as TokenizingModel;
       const llama = await this.manager.getLlama();
       const lifecycleVersion = this.lifecycleVersion;
       const targetPoolSize = this.resolveTargetPoolSize(llama);
@@ -321,4 +344,47 @@ export class NodeLlamaCppEmbedding implements EmbeddingPort {
       return { ok: false, error: inferenceFailedError(this.modelUri, e) };
     }
   }
+
+  private truncateForEmbedding(
+    text: string,
+    mode: "single" | "batch"
+  ): LlmResult<{ text: string }> {
+    const model = this.llamaModel;
+    const rawLimit =
+      typeof model?.trainContextSize === "number" &&
+      Number.isFinite(model.trainContextSize) &&
+      model.trainContextSize > 0
+        ? Math.floor(model.trainContextSize)
+        : undefined;
+    if (!model || rawLimit === undefined) {
+      return { ok: true, value: { text } };
+    }
+
+    const limit = Math.max(1, rawLimit - 4);
+    try {
+      const tokens = model.tokenize(text);
+      if (tokens.length <= limit) {
+        return { ok: true, value: { text } };
+      }
+
+      const truncatedText = model.detokenize(tokens.slice(0, limit));
+      const shouldWarn =
+        mode === "single"
+          ? !this.warnedSingleTruncation
+          : !this.warnedBatchTruncation;
+      if (shouldWarn) {
+        if (mode === "single") {
+          this.warnedSingleTruncation = true;
+        } else {
+          this.warnedBatchTruncation = true;
+        }
+        console.warn(
+          `[llama] Truncated embedding input from ${tokens.length} to ${limit} tokens`
+        );
+      }
+      return { ok: true, value: { text: truncatedText } };
+    } catch (error) {
+      return { ok: false, error: inferenceFailedError(this.modelUri, error) };
+    }
+  }
 }

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,