@gmickel/gno 0.26.0 → 0.27.1

package/assets/skill/SKILL.md

@@ -110,10 +110,15 @@ gno get gno://work/report.md --from 100 -l 20
 # With line numbers
 gno get gno://work/report.md --line-numbers
 
+# JSON output with capabilities metadata
+gno get gno://work/report.md --json
+
 # Multiple documents
 gno multi-get gno://work/doc1.md gno://work/doc2.md
 ```
 
+**Editable vs read-only**: `gno get --json` returns a `capabilities` field showing whether a document is editable at its source. Markdown and plain text files are editable in place. Converted documents (PDF, DOCX, XLSX) are read-only -- to edit their content, create a new markdown note instead of overwriting the binary source.
+
 ## Search Then Get (common pipeline)
 
 ```bash

package/package.json

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

package/src/cli/commands/get.ts

@@ -8,6 +8,10 @@
 import type { DocumentRow, StorePort, StoreResult } from "../../store/types";
 import type { ParsedRef } from "./ref-parser";
 
+import {
+  getDocumentCapabilities,
+  type DocumentCapabilities,
+} from "../../core/document-capabilities";
 import { parseRef } from "./ref-parser";
 import { initStore } from "./shared";
 
@@ -58,6 +62,7 @@ export interface GetResponse {
     converterVersion?: string;
     mirrorHash?: string;
   };
+  capabilities: DocumentCapabilities;
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -203,6 +208,7 @@ function buildResponse(ctx: BuildResponseContext): GetResult {
         language: doc.languageHint ?? undefined,
         source: buildSourceMeta(doc, config),
         conversion: buildConversionMeta(doc),
+        capabilities: buildCapabilities(doc),
       },
     };
   }
@@ -233,6 +239,7 @@ function buildResponse(ctx: BuildResponseContext): GetResult {
       language: doc.languageHint ?? undefined,
       source: buildSourceMeta(doc, config),
       conversion: buildConversionMeta(doc),
+      capabilities: buildCapabilities(doc),
     },
   };
 }
@@ -247,6 +254,7 @@ interface DocRow {
   sourceMime: string;
   sourceExt: string;
   sourceSize: number;
+  sourceMtime?: string;
   sourceHash: string;
 }
 
@@ -262,11 +270,24 @@ function buildSourceMeta(
     relPath: doc.relPath,
     mime: doc.sourceMime,
     ext: doc.sourceExt,
+    modifiedAt: doc.sourceMtime ?? undefined,
     sizeBytes: doc.sourceSize,
     sourceHash: doc.sourceHash,
   };
 }
 
+function buildCapabilities(doc: {
+  sourceExt: string;
+  sourceMime: string;
+  mirrorHash?: string | null;
+}): DocumentCapabilities {
+  return getDocumentCapabilities({
+    sourceExt: doc.sourceExt,
+    sourceMime: doc.sourceMime,
+    contentAvailable: doc.mirrorHash !== null,
+  });
+}
+
 interface ConversionDoc {
   converterId?: string | null;
   converterVersion?: string | null;

package/src/core/document-capabilities.ts

@@ -0,0 +1,113 @@
+// node:path has no Bun equivalent
+import { posix as pathPosix } from "node:path";
+
+export type DocumentCapabilityMode = "editable" | "read_only";
+
+export interface DocumentCapabilities {
+  editable: boolean;
+  tagsEditable: boolean;
+  tagsWriteback: boolean;
+  canCreateEditableCopy: boolean;
+  mode: DocumentCapabilityMode;
+  reason?: string;
+}
+
+const EDITABLE_EXTENSIONS = new Set([
+  ".md",
+  ".markdown",
+  ".mdx",
+  ".txt",
+  ".text",
+]);
+
+function isTextLikeMime(mime: string): boolean {
+  return mime.startsWith("text/");
+}
+
+export function getDocumentCapabilities(input: {
+  sourceExt: string;
+  sourceMime: string;
+  contentAvailable: boolean;
+}): DocumentCapabilities {
+  const ext = input.sourceExt.toLowerCase();
+  const editable =
+    EDITABLE_EXTENSIONS.has(ext) || isTextLikeMime(input.sourceMime);
+  const tagsWriteback = ext === ".md" || ext === ".markdown" || ext === ".mdx";
+
+  if (editable) {
+    return {
+      editable: true,
+      tagsEditable: true,
+      tagsWriteback,
+      canCreateEditableCopy: false,
+      mode: "editable",
+    };
+  }
+
+  return {
+    editable: false,
+    tagsEditable: true,
+    tagsWriteback: false,
+    canCreateEditableCopy: input.contentAvailable,
+    mode: "read_only",
+    reason:
+      "This document is derived from a source format that GNO cannot safely write back in place.",
+  };
+}
+
+export function deriveEditableCopyRelPath(
+  relPath: string,
+  existingRelPaths: Iterable<string> = []
+): string {
+  const parsed = pathPosix.parse(relPath);
+  const prefix = parsed.dir ? `${parsed.dir}/` : "";
+  const baseName = parsed.name || "copy";
+  const existing = new Set(existingRelPaths);
+
+  const baseCandidate =
+    parsed.ext.toLowerCase() === ".md" ||
+    parsed.ext.toLowerCase() === ".markdown" ||
+    parsed.ext.toLowerCase() === ".mdx"
+      ? `${prefix}${baseName}.copy.md`
+      : `${prefix}${baseName}.md`;
+
+  if (!existing.has(baseCandidate)) {
+    return baseCandidate;
+  }
+
+  let counter = 2;
+  while (true) {
+    const candidate = `${prefix}${baseName}.copy-${counter}.md`;
+    if (!existing.has(candidate)) {
+      return candidate;
+    }
+    counter += 1;
+  }
+}
+
+export function buildEditableCopyContent(input: {
+  title: string;
+  sourceDocid: string;
+  sourceUri: string;
+  sourceMime: string;
+  sourceExt: string;
+  content: string;
+  tags?: string[];
+}): string {
+  const frontmatterLines = [
+    `title: ${JSON.stringify(input.title)}`,
+    `gno_source_docid: ${JSON.stringify(input.sourceDocid)}`,
+    `gno_source_uri: ${JSON.stringify(input.sourceUri)}`,
+    `gno_source_mime: ${JSON.stringify(input.sourceMime)}`,
+    `gno_source_ext: ${JSON.stringify(input.sourceExt)}`,
+  ];
+
+  if (input.tags && input.tags.length > 0) {
+    frontmatterLines.push("tags:");
+    for (const tag of input.tags) {
+      frontmatterLines.push(`  - ${JSON.stringify(tag)}`);
+    }
+  }
+
+  return `---\n${frontmatterLines.join("\n")}\n---\n\n${input.content}`;
+}

package/src/mcp/tools/get.ts

@@ -11,6 +11,10 @@ import type { ToolContext } from "../server";
 
 import { parseUri } from "../../app/constants";
 import { parseRef } from "../../cli/commands/ref-parser";
+import {
+  getDocumentCapabilities,
+  type DocumentCapabilities,
+} from "../../core/document-capabilities";
 import { runTool, type ToolResult } from "./index";
 
 interface GetInput {
@@ -42,6 +46,7 @@ interface GetResponse {
     converterVersion?: string;
     mirrorHash?: string;
   };
+  capabilities: DocumentCapabilities;
 }
 
 /**
@@ -213,6 +218,11 @@ export function handleGet(
               mirrorHash: doc.mirrorHash,
             }
           : undefined,
+        capabilities: getDocumentCapabilities({
+          sourceExt: doc.sourceExt,
+          sourceMime: doc.sourceMime,
+          contentAvailable: doc.mirrorHash !== null,
+        }),
       };
 
       return response;

package/src/sdk/documents.ts

@@ -23,6 +23,7 @@ import type {
 } from "./types";
 
 import { isGlobPattern, parseRef, splitRefs } from "../cli/commands/ref-parser";
+import { getDocumentCapabilities } from "../core/document-capabilities";
 import { sdkError } from "./errors";
 
 const URI_PREFIX_PATTERN = /^gno:\/\/[^/]+\//;
@@ -53,6 +54,7 @@ function buildSourceMeta(
     mime: doc.sourceMime,
     ext: doc.sourceExt,
     sizeBytes: doc.sourceSize,
+    modifiedAt: doc.sourceMtime ?? undefined,
     sourceHash: doc.sourceHash,
   };
 }
@@ -122,6 +124,11 @@ export async function getDocumentByRef(
       language: doc.languageHint ?? undefined,
       source: buildSourceMeta(doc, config),
       conversion: buildConversionMeta(doc),
+      capabilities: getDocumentCapabilities({
+        sourceExt: doc.sourceExt,
+        sourceMime: doc.sourceMime,
+        contentAvailable: doc.mirrorHash !== null,
+      }),
     };
   }
 
@@ -144,6 +151,11 @@ export async function getDocumentByRef(
     language: doc.languageHint ?? undefined,
     source: buildSourceMeta(doc, config),
     conversion: buildConversionMeta(doc),
+    capabilities: getDocumentCapabilities({
+      sourceExt: doc.sourceExt,
+      sourceMime: doc.sourceMime,
+      contentAvailable: doc.mirrorHash !== null,
+    }),
   };
 }
 

package/src/serve/doc-events.ts

@@ -0,0 +1,69 @@
+export type DocumentEventOrigin = "watcher" | "save" | "create";
+
+export interface DocumentEvent {
+  type: "document-changed";
+  uri: string;
+  collection: string;
+  relPath: string;
+  origin: DocumentEventOrigin;
+  changedAt: string;
+}
+
+const encoder = new TextEncoder();
+
+export class DocumentEventBus {
+  readonly #controllers = new Set<
+    ReadableStreamDefaultController<Uint8Array>
+  >();
+
+  createResponse(): Response {
+    const controllers = this.#controllers;
+    let streamController: ReadableStreamDefaultController<Uint8Array> | null =
+      null;
+    const stream = new ReadableStream<Uint8Array>({
+      start(controller) {
+        streamController = controller;
+        controllers.add(controller);
+        controller.enqueue(encoder.encode(": connected\n\n"));
+      },
+      cancel() {
+        if (streamController) {
+          controllers.delete(streamController);
+        }
+      },
+    });
+
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+      },
+    });
+  }
+
+  emit(event: DocumentEvent): void {
+    const payload = encoder.encode(
+      `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`
+    );
+
+    for (const controller of this.#controllers) {
+      try {
+        controller.enqueue(payload);
+      } catch {
+        this.#controllers.delete(controller);
+      }
+    }
+  }
+
+  close(): void {
+    for (const controller of this.#controllers) {
+      try {
+        controller.close();
+      } catch {
+        // Best-effort shutdown.
+      }
+    }
+    this.#controllers.clear();
+  }
+}

package/src/serve/public/app.tsx

@@ -2,9 +2,11 @@ import { useCallback, useEffect, useMemo, useState } from "react";
 import { createRoot } from "react-dom/client";
 
 import { HelpButton } from "./components/HelpButton";
+import { QuickSwitcher, saveRecentDocument } from "./components/QuickSwitcher";
 import { ShortcutHelpModal } from "./components/ShortcutHelpModal";
-import { CaptureModalProvider } from "./hooks/useCaptureModal";
+import { CaptureModalProvider, useCaptureModal } from "./hooks/useCaptureModal";
 import { useKeyboardShortcuts } from "./hooks/useKeyboardShortcuts";
+import { parseDocumentDeepLink } from "./lib/deep-links";
 import Ask from "./pages/Ask";
 import Browse from "./pages/Browse";
 import Collections from "./pages/Collections";
@@ -36,37 +38,48 @@ const routes: Record<Route, React.ComponentType<{ navigate: Navigate }>> = {
   "/graph": GraphView,
 };
 
-function App() {
-  // Track full location (pathname + search) for proper query param handling
-  const [location, setLocation] = useState<string>(
-    window.location.pathname + window.location.search
-  );
-  const [shortcutHelpOpen, setShortcutHelpOpen] = useState(false);
+interface AppContentProps {
+  location: string;
+  navigate: Navigate;
+  shortcutHelpOpen: boolean;
+  setShortcutHelpOpen: (open: boolean) => void;
+}
+
+function AppContent({
+  location,
+  navigate,
+  shortcutHelpOpen,
+  setShortcutHelpOpen,
+}: AppContentProps) {
+  const { openCapture } = useCaptureModal();
+  const [quickSwitcherOpen, setQuickSwitcherOpen] = useState(false);
 
   useEffect(() => {
-    const handlePopState = () =>
-      setLocation(window.location.pathname + window.location.search);
-    window.addEventListener("popstate", handlePopState);
-    return () => window.removeEventListener("popstate", handlePopState);
-  }, []);
+    const basePath = location.split("?")[0];
+    if (basePath !== "/doc" && basePath !== "/edit") {
+      return;
+    }
 
-  const navigate = useCallback((to: string | number) => {
-    if (typeof to === "number") {
-      // Handle history.go(-1) style navigation
-      window.history.go(to);
+    const search = location.includes("?")
+      ? `?${location.split("?")[1] ?? ""}`
+      : "";
+    const target = parseDocumentDeepLink(search);
+    if (!target.uri) {
       return;
     }
-    window.history.pushState({}, "", to);
-    setLocation(to);
-  }, []);
 
-  // Global keyboard shortcuts (single-key, GitHub/Gmail pattern)
+    saveRecentDocument({
+      uri: target.uri,
+      href: location,
+      label: decodeURIComponent(target.uri.split("/").pop() ?? target.uri),
+    });
+  }, [location]);
+
   const shortcuts = useMemo(
     () => [
       {
         key: "/",
         action: () => {
-          // Focus search input on current page or navigate to search
           const searchInput = document.querySelector<HTMLInputElement>(
             'input[type="search"], input[placeholder*="Search"], input[id*="search"]'
           );
@@ -82,18 +95,22 @@ function App() {
         key: "?",
         action: () => setShortcutHelpOpen(true),
       },
+      {
+        key: "k",
+        meta: true,
+        action: () => setQuickSwitcherOpen(true),
+      },
     ],
-    [navigate]
+    [navigate, setShortcutHelpOpen]
   );
 
   useKeyboardShortcuts(shortcuts);
 
-  // Extract base path for routing (ignore query params)
   const basePath = location.split("?")[0] as Route;
   const Page = routes[basePath] || Dashboard;
 
   return (
-    <CaptureModalProvider>
+    <>
       <div className="flex min-h-screen flex-col">
         <div className="flex-1">
           <Page key={location} navigate={navigate} />
@@ -147,10 +164,50 @@ function App() {
         </footer>
       </div>
       <HelpButton onClick={() => setShortcutHelpOpen(true)} />
+      <QuickSwitcher
+        navigate={(to) => navigate(to)}
+        onCreateNote={openCapture}
+        onOpenChange={setQuickSwitcherOpen}
+        open={quickSwitcherOpen}
+      />
       <ShortcutHelpModal
         onOpenChange={setShortcutHelpOpen}
         open={shortcutHelpOpen}
       />
+    </>
+  );
+}
+
+function App() {
+  const [location, setLocation] = useState<string>(
+    window.location.pathname + window.location.search
+  );
+  const [shortcutHelpOpen, setShortcutHelpOpen] = useState(false);
+
+  useEffect(() => {
+    const handlePopState = () =>
+      setLocation(window.location.pathname + window.location.search);
+    window.addEventListener("popstate", handlePopState);
+    return () => window.removeEventListener("popstate", handlePopState);
+  }, []);
+
+  const navigate = useCallback((to: string | number) => {
+    if (typeof to === "number") {
+      window.history.go(to);
+      return;
+    }
+    window.history.pushState({}, "", to);
+    setLocation(to);
+  }, []);
+
+  return (
+    <CaptureModalProvider>
+      <AppContent
+        location={location}
+        navigate={navigate}
+        setShortcutHelpOpen={setShortcutHelpOpen}
+        shortcutHelpOpen={shortcutHelpOpen}
+      />
     </CaptureModalProvider>
   );
 }