@gmickel/gno 1.12.2 → 1.12.3

package/src/mcp/tools/get.ts

@@ -14,7 +14,9 @@ import {
   getDocumentCapabilities,
   type DocumentCapabilities,
 } from "../../core/document-capabilities";
+import { resolveEffectiveIndex } from "../../core/indexed-reference";
 import { parseRef } from "../../core/ref-parser";
+import { openScopedIndexStore } from "../../store/sqlite/scoped-index";
 import { runTool, type ToolResult } from "./index";
 
 interface GetInput {
@@ -128,109 +130,122 @@ export function handleGet(
         throw new Error(parsed.error);
       }
 
-      // Lookup document
-      const doc = await lookupDocument(ctx.store, parsed);
-      if (!doc) {
-        throw new Error(`Document not found: ${args.ref}`);
+      const resolution = resolveEffectiveIndex([args.ref], 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 {
+        // Lookup document
+        const doc = await lookupDocument(scoped.store, parsed);
+        if (!doc) {
+          throw new Error(`Document not found: ${args.ref}`);
+        }
 
-      // Get content
-      if (!doc.mirrorHash) {
-        throw new Error("Document has no indexed content");
-      }
+        // Get content
+        if (!doc.mirrorHash) {
+          throw new Error("Document has no indexed content");
+        }
 
-      const contentResult = await ctx.store.getContent(doc.mirrorHash);
-      if (!contentResult.ok) {
-        throw new Error(contentResult.error.message);
-      }
+        const contentResult = await scoped.store.getContent(doc.mirrorHash);
+        if (!contentResult.ok) {
+          throw new Error(contentResult.error.message);
+        }
 
-      const fullContent = contentResult.value ?? "";
-      const contentLines = fullContent.split("\n");
-      const totalLines = contentLines.length;
-
-      // Apply line range if specified
-      let content = fullContent;
-      let returnedLines: { start: number; end: number } | undefined;
-
-      // lineNumbers defaults to true per spec
-      const showLineNumbers = args.lineNumbers !== false;
-
-      if (args.fromLine || args.lineCount) {
-        const startLine = args.fromLine ?? 1;
-        // Clamp startLine to valid range
-        if (startLine > totalLines) {
-          // Return empty content for out-of-range request
-          content = "";
-          returnedLines = undefined;
-        } else {
-          const count = args.lineCount ?? totalLines - startLine + 1;
-          const endLine = Math.min(startLine + count - 1, totalLines);
-
-          const slicedLines = contentLines.slice(startLine - 1, endLine);
-
-          if (showLineNumbers) {
-            content = slicedLines
-              .map((line, i) => `${startLine + i}: ${line}`)
-              .join("\n");
+        const fullContent = contentResult.value ?? "";
+        const contentLines = fullContent.split("\n");
+        const totalLines = contentLines.length;
+
+        // Apply line range if specified
+        let content = fullContent;
+        let returnedLines: { start: number; end: number } | undefined;
+
+        // lineNumbers defaults to true per spec
+        const showLineNumbers = args.lineNumbers !== false;
+
+        if (args.fromLine || args.lineCount) {
+          const startLine = args.fromLine ?? 1;
+          // Clamp startLine to valid range
+          if (startLine > totalLines) {
+            // Return empty content for out-of-range request
+            content = "";
+            returnedLines = undefined;
           } else {
-            content = slicedLines.join("\n");
-          }
+            const count = args.lineCount ?? totalLines - startLine + 1;
+            const endLine = Math.min(startLine + count - 1, totalLines);
 
-          returnedLines = { start: startLine, end: endLine };
+            const slicedLines = contentLines.slice(startLine - 1, endLine);
+
+            if (showLineNumbers) {
+              content = slicedLines
+                .map((line, i) => `${startLine + i}: ${line}`)
+                .join("\n");
+            } else {
+              content = slicedLines.join("\n");
+            }
+
+            returnedLines = { start: startLine, end: endLine };
+          }
+        } else if (showLineNumbers) {
+          content = contentLines
+            .map((line, i) => `${i + 1}: ${line}`)
+            .join("\n");
         }
-      } else if (showLineNumbers) {
-        content = contentLines.map((line, i) => `${i + 1}: ${line}`).join("\n");
-      }
 
-      // Build absPath
-      const uriParsed = parseUri(doc.uri);
-      let absPath: string | undefined;
-      if (uriParsed) {
-        const collection = ctx.collections.find(
-          (c) => c.name === uriParsed.collection
-        );
-        if (collection) {
-          absPath = pathJoin(collection.path, doc.relPath);
+        // Build absPath
+        const uriParsed = parseUri(doc.uri);
+        let absPath: string | undefined;
+        if (uriParsed) {
+          const collection = ctx.collections.find(
+            (c) => c.name === uriParsed.collection
+          );
+          if (collection) {
+            absPath = pathJoin(collection.path, doc.relPath);
+          }
         }
-      }
 
-      const response: GetResponse = {
-        docid: doc.docid,
-        uri: decorateUriForIndex(
-          doc.uri,
-          parsed.type === "uri"
-            ? (parseUri(parsed.value)?.indexName ?? ctx.indexName)
-            : ctx.indexName
-        ),
-        title: doc.title ?? undefined,
-        content,
-        totalLines,
-        returnedLines,
-        language: doc.languageHint ?? undefined,
-        source: {
-          absPath,
-          relPath: doc.relPath,
-          mime: doc.sourceMime,
-          ext: doc.sourceExt,
-          modifiedAt: doc.sourceMtime,
-          sizeBytes: doc.sourceSize,
-          sourceHash: doc.sourceHash,
-        },
-        conversion: doc.mirrorHash
-          ? {
-              converterId: doc.converterId ?? undefined,
-              converterVersion: doc.converterVersion ?? undefined,
-              mirrorHash: doc.mirrorHash,
-            }
-          : undefined,
-        capabilities: getDocumentCapabilities({
-          sourceExt: doc.sourceExt,
-          sourceMime: doc.sourceMime,
-          contentAvailable: doc.mirrorHash !== null,
-        }),
-      };
-
-      return response;
+        const response: GetResponse = {
+          docid: doc.docid,
+          uri: decorateUriForIndex(doc.uri, scoped.indexName),
+          title: doc.title ?? undefined,
+          content,
+          totalLines,
+          returnedLines,
+          language: doc.languageHint ?? undefined,
+          source: {
+            absPath,
+            relPath: doc.relPath,
+            mime: doc.sourceMime,
+            ext: doc.sourceExt,
+            modifiedAt: doc.sourceMtime,
+            sizeBytes: doc.sourceSize,
+            sourceHash: doc.sourceHash,
+          },
+          conversion: doc.mirrorHash
+            ? {
+                converterId: doc.converterId ?? undefined,
+                converterVersion: doc.converterVersion ?? undefined,
+                mirrorHash: doc.mirrorHash,
+              }
+            : undefined,
+          capabilities: getDocumentCapabilities({
+            sourceExt: doc.sourceExt,
+            sourceMime: doc.sourceMime,
+            contentAvailable: doc.mirrorHash !== null,
+          }),
+        };
+
+        return response;
+      } finally {
+        await scoped.close();
+      }
     },
     formatGetResponse
   );

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

@@ -10,7 +10,9 @@ import type { DocumentRow, StorePort } from "../../store/types";
 import type { ToolContext } from "../server";
 
 import { decorateUriForIndex, parseUri } from "../../app/constants";
+import { resolveEffectiveIndex } from "../../core/indexed-reference";
 import { parseRef } from "../../core/ref-parser";
+import { openScopedIndexStore } from "../../store/sqlite/scoped-index";
 import { runTool, type ToolResult } from "./index";
 
 interface MultiGetInput {
@@ -144,121 +146,136 @@ export function handleMultiGet(
       const skipped: Array<{ ref: string; reason: string }> = [];
 
       let refs: string[] = args.refs ?? [];
-
-      // Pattern-based lookup
-      if (args.pattern) {
-        // For pattern matching, list all documents and filter
-        const listResult = await ctx.store.listDocuments();
-        if (!listResult.ok) {
-          throw new Error(listResult.error.message);
-        }
-
-        // Safe glob-like pattern matching: escape regex metacharacters first
-        const pattern = args.pattern;
-        // Escape all regex metacharacters except * and ?
-        const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-        // Then convert glob wildcards to regex
-        const regexPattern = escaped.replace(/\*/g, ".*").replace(/\?/g, ".");
-        const regex = new RegExp(`^${regexPattern}$`);
-
-        refs = listResult.value
-          .filter((d) => regex.test(d.uri) || regex.test(d.relPath))
-          .map((d) => d.uri);
+      const resolution = resolveEffectiveIndex(refs, 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 {
+        // Pattern-based lookup
+        if (args.pattern) {
+          // For pattern matching, list all documents and filter
+          const listResult = await scoped.store.listDocuments();
+          if (!listResult.ok) {
+            throw new Error(listResult.error.message);
+          }
 
-      // Process each reference
-      for (const ref of refs) {
-        const parsed = parseRef(ref);
-        if ("error" in parsed) {
-          skipped.push({ ref, reason: parsed.error });
-          continue;
+          // Safe glob-like pattern matching: escape regex metacharacters first
+          const pattern = args.pattern;
+          // Escape all regex metacharacters except * and ?
+          const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+          // Then convert glob wildcards to regex
+          const regexPattern = escaped.replace(/\*/g, ".*").replace(/\?/g, ".");
+          const regex = new RegExp(`^${regexPattern}$`);
+
+          refs = listResult.value
+            .filter((d) => regex.test(d.uri) || regex.test(d.relPath))
+            .map((d) => d.uri);
         }
 
-        const doc = await lookupDocument(ctx.store, parsed);
-        if (!doc) {
-          skipped.push({ ref, reason: "Not found" });
-          continue;
-        }
+        // Process each reference
+        for (const ref of refs) {
+          const parsed = parseRef(ref);
+          if ("error" in parsed) {
+            skipped.push({ ref, reason: parsed.error });
+            continue;
+          }
 
-        if (!doc.mirrorHash) {
-          skipped.push({ ref, reason: "No indexed content" });
-          continue;
-        }
+          const doc = await lookupDocument(scoped.store, parsed);
+          if (!doc) {
+            skipped.push({ ref, reason: "Not found" });
+            continue;
+          }
 
-        // Get content
-        const contentResult = await ctx.store.getContent(doc.mirrorHash);
-        if (!contentResult.ok) {
-          skipped.push({ ref, reason: contentResult.error.message });
-          continue;
-        }
+          if (!doc.mirrorHash) {
+            skipped.push({ ref, reason: "No indexed content" });
+            continue;
+          }
 
-        let content = contentResult.value ?? "";
-        let truncated = false;
-
-        // Apply maxBytes truncation (actual UTF-8 bytes, not characters)
-        const contentBuffer = Buffer.from(content, "utf8");
-        if (contentBuffer.length > maxBytes) {
-          // Truncate by bytes, then decode safely (may cut mid-codepoint)
-          const truncatedBuffer = contentBuffer.subarray(0, maxBytes);
-          // Decode with replacement char for incomplete sequences
-          content = truncatedBuffer.toString("utf8");
-          // Remove potential trailing replacement char from cut codepoint
-          if (content.endsWith("\uFFFD")) {
-            content = content.slice(0, -1);
+          // Get content
+          const contentResult = await scoped.store.getContent(doc.mirrorHash);
+          if (!contentResult.ok) {
+            skipped.push({ ref, reason: contentResult.error.message });
+            continue;
           }
-          truncated = true;
-        }
 
-        const contentLines = content.split("\n");
+          let content = contentResult.value ?? "";
+          let truncated = false;
+
+          // Apply maxBytes truncation (actual UTF-8 bytes, not characters)
+          const contentBuffer = Buffer.from(content, "utf8");
+          if (contentBuffer.length > maxBytes) {
+            // Truncate by bytes, then decode safely (may cut mid-codepoint)
+            const truncatedBuffer = contentBuffer.subarray(0, maxBytes);
+            // Decode with replacement char for incomplete sequences
+            content = truncatedBuffer.toString("utf8");
+            // Remove potential trailing replacement char from cut codepoint
+            if (content.endsWith("\uFFFD")) {
+              content = content.slice(0, -1);
+            }
+            truncated = true;
+          }
 
-        // Apply line numbers (defaults to true per spec)
-        if (args.lineNumbers !== false) {
-          content = contentLines
-            .map((line, i) => `${i + 1}: ${line}`)
-            .join("\n");
-        }
+          const contentLines = content.split("\n");
 
-        // Build absPath
-        const uriParsed = parseUri(doc.uri);
-        let absPath: string | undefined;
-        if (uriParsed) {
-          const collection = ctx.collections.find(
-            (c) => c.name === uriParsed.collection
-          );
-          if (collection) {
-            absPath = pathJoin(collection.path, doc.relPath);
+          // Apply line numbers (defaults to true per spec)
+          if (args.lineNumbers !== false) {
+            content = contentLines
+              .map((line, i) => `${i + 1}: ${line}`)
+              .join("\n");
           }
+
+          // Build absPath
+          const uriParsed = parseUri(doc.uri);
+          let absPath: string | undefined;
+          if (uriParsed) {
+            const collection = ctx.collections.find(
+              (c) => c.name === uriParsed.collection
+            );
+            if (collection) {
+              absPath = pathJoin(collection.path, doc.relPath);
+            }
+          }
+
+          documents.push({
+            docid: doc.docid,
+            uri: decorateUriForIndex(doc.uri, scoped.indexName),
+            title: doc.title ?? undefined,
+            content,
+            totalLines: (contentResult.value ?? "").split("\n").length,
+            truncated,
+            source: {
+              absPath,
+              relPath: doc.relPath,
+              mime: doc.sourceMime,
+              ext: doc.sourceExt,
+              modifiedAt: doc.sourceMtime,
+              sizeBytes: doc.sourceSize,
+            },
+          });
         }
 
-        documents.push({
-          docid: doc.docid,
-          uri: decorateUriForIndex(doc.uri, ctx.indexName),
-          title: doc.title ?? undefined,
-          content,
-          totalLines: (contentResult.value ?? "").split("\n").length,
-          truncated,
-          source: {
-            absPath,
-            relPath: doc.relPath,
-            mime: doc.sourceMime,
-            ext: doc.sourceExt,
-            modifiedAt: doc.sourceMtime,
-            sizeBytes: doc.sourceSize,
+        const response: MultiGetResponse = {
+          documents,
+          skipped,
+          meta: {
+            requested: refs.length,
+            returned: documents.length,
+            skipped: skipped.length,
           },
-        });
-      }
+        };
 
-      const response: MultiGetResponse = {
-        documents,
-        skipped,
-        meta: {
-          requested: refs.length,
-          returned: documents.length,
-          skipped: skipped.length,
-        },
-      };
-
-      return response;
+        return response;
+      } finally {
+        await scoped.close();
+      }
     },
     formatMultiGetResponse
   );

package/src/sdk/client.ts

@@ -39,11 +39,7 @@ import type {
   GnoVectorSearchOptions,
 } from "./types";
 
-import {
-  decorateUriForIndex,
-  getIndexDbPath,
-  parseUri,
-} from "../app/constants";
+import { decorateUriForIndex, getIndexDbPath } from "../app/constants";
 import {
   ConfigSchema,
   loadConfig,
@@ -69,6 +65,7 @@ import {
   planMoveRefactor,
   planRenameRefactor,
 } from "../core/file-refactors";
+import { resolveEffectiveIndex } from "../core/indexed-reference";
 import { resolveNoteCreatePlan } from "../core/note-creation";
 import { resolveNotePreset } from "../core/note-presets";
 import { extractSections } from "../core/sections";
@@ -92,6 +89,7 @@ import { searchHybrid } from "../pipeline/hybrid";
 import { searchBm25 } from "../pipeline/search";
 import { searchVectorWithEmbedding } from "../pipeline/vsearch";
 import { SqliteAdapter } from "../store/sqlite/adapter";
+import { openScopedIndexStore } from "../store/sqlite/scoped-index";
 import { createVectorIndexPort } from "../store/vector";
 import {
   getDocumentByRef,
@@ -647,36 +645,63 @@ class GnoClientImpl implements GnoClient {
 
   async get(ref: string, options: GnoGetOptions = {}) {
     this.assertOpen();
-    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),
-    };
+    const resolution = resolveEffectiveIndex([ref], this.indexName);
+    if (!resolution.ok) {
+      throw sdkError("VALIDATION", resolution.error);
+    }
+    const scoped = await openScopedIndexStore({
+      activeStore: this.store,
+      activeIndexName: this.indexName,
+      requestedIndexName: resolution.value.indexName,
+      config: this.config,
+      configPath: this.configPath,
+    });
+    try {
+      const result = await getDocumentByRef(
+        scoped.store,
+        this.config,
+        ref,
+        options
+      );
+      return {
+        ...result,
+        uri: decorateUriForIndex(result.uri, scoped.indexName),
+      };
+    } finally {
+      await scoped.close();
+    }
   }
 
   async multiGet(refs: string[], options: GnoMultiGetOptions = {}) {
     this.assertOpen();
-    const result = await multiGetDocuments(
-      this.store,
-      this.config,
-      refs,
-      options
-    );
-    return {
-      ...result,
-      documents: result.documents.map((doc) => ({
-        ...doc,
-        uri: decorateUriForIndex(doc.uri, this.indexName),
-      })),
-    };
+    const resolution = resolveEffectiveIndex(refs, this.indexName);
+    if (!resolution.ok) {
+      throw sdkError("VALIDATION", resolution.error);
+    }
+    const scoped = await openScopedIndexStore({
+      activeStore: this.store,
+      activeIndexName: this.indexName,
+      requestedIndexName: resolution.value.indexName,
+      config: this.config,
+      configPath: this.configPath,
+    });
+    try {
+      const result = await multiGetDocuments(
+        scoped.store,
+        this.config,
+        refs,
+        options
+      );
+      return {
+        ...result,
+        documents: result.documents.map((doc) => ({
+          ...doc,
+          uri: decorateUriForIndex(doc.uri, scoped.indexName),
+        })),
+      };
+    } finally {
+      await scoped.close();
+    }
   }
 
   async list(options: GnoListOptions = {}) {

package/src/serve/public/components/AIModelSelector.tsx

@@ -128,6 +128,7 @@ function formatModelRole(uri: string | undefined): string {
 }
 
 export interface AIModelSelectorProps {
+  appStatus?: AppStatusResponse | null;
   onPresetChange?: (presetId: string) => void;
   showDetails?: boolean;
   showDownloadAction?: boolean;
@@ -139,6 +140,7 @@ function isCustomPreset(preset: Preset): boolean {
 }
 
 export function AIModelSelector({
+  appStatus,
   onPresetChange,
   showDetails = false,
   showDownloadAction = true,
@@ -164,6 +166,7 @@ export function AIModelSelector({
     null
   );
   const pollInterval = useRef<ReturnType<typeof setInterval> | null>(null);
+  const parentOwnsStatus = useRef(appStatus !== undefined);
   const containerRef = useRef<HTMLDivElement>(null);
   const menuRef = useRef<HTMLDivElement>(null);
   const triggerRef = useRef<HTMLButtonElement>(null);
@@ -274,13 +277,15 @@ export function AIModelSelector({
       setLoading(false);
     });
 
-    void apiFetch<AppStatusResponse>("/api/status").then(({ data }) => {
-      if (data) {
-        setModelsNeeded(
-          data.bootstrap.models.cachedCount < data.bootstrap.models.totalCount
-        );
-      }
-    });
+    if (!parentOwnsStatus.current) {
+      void apiFetch<AppStatusResponse>("/api/status").then(({ data }) => {
+        if (data) {
+          setModelsNeeded(
+            data.bootstrap.models.cachedCount < data.bootstrap.models.totalCount
+          );
+        }
+      });
+    }
 
     void apiFetch<DownloadStatus>("/api/models/status").then(({ data }) => {
       if (data?.active) {
@@ -290,6 +295,16 @@ export function AIModelSelector({
     });
   }, [checkCapabilities]);
 
+  useEffect(() => {
+    if (!appStatus) {
+      return;
+    }
+    setModelsNeeded(
+      appStatus.bootstrap.models.cachedCount <
+        appStatus.bootstrap.models.totalCount
+    );
+  }, [appStatus]);
+
   // Polling
   useEffect(() => {
     if (downloading && !pollInterval.current) {

package/src/serve/public/pages/Dashboard.tsx

@@ -396,7 +396,7 @@ export default function Dashboard({ navigate }: PageProps) {
             </div>
 
             <div className="flex flex-wrap items-center gap-3 md:justify-end">
-              <AIModelSelector showLabel={false} />
+              <AIModelSelector appStatus={status} showLabel={false} />
               <Button
                 disabled={syncing}
                 onClick={() => void handleSync()}