@gmickel/gno 0.35.0 → 0.37.0

package/src/serve/public/globals.css

@@ -158,6 +158,53 @@ mark {
   outline: none;
 }
 
+/* Command palette: own focus + selection treatment; do not inherit global rings */
+[cmdk-input] {
+  outline: none !important;
+  box-shadow: none !important;
+}
+
+[cmdk-input]:focus,
+[cmdk-input]:focus-visible,
+[cmdk-root] [data-slot="command-input-wrapper"],
+[cmdk-root] [data-slot="command-input-wrapper"]:focus-within {
+  outline: none !important;
+  box-shadow: none !important;
+}
+
+[cmdk-root] [data-slot="command-input-wrapper"] {
+  border-bottom: 1px solid hsl(var(--border) / 0.7);
+  background: hsl(var(--muted) / 0.2);
+}
+
+[cmdk-root] [data-slot="command-input-wrapper"]:focus-within {
+  border-bottom-color: hsl(var(--primary) / 0.45);
+  background: hsl(var(--card) / 0.96);
+}
+
+[cmdk-root] [cmdk-item] {
+  border: 1px solid transparent;
+  transition:
+    background-color 140ms ease,
+    border-color 140ms ease,
+    color 140ms ease,
+    box-shadow 140ms ease;
+}
+
+[cmdk-root] [cmdk-item][data-selected="true"] {
+  background: hsl(var(--primary) / 0.18);
+  border-color: hsl(var(--primary) / 0.38);
+  color: hsl(var(--foreground));
+  box-shadow:
+    inset 3px 0 0 hsl(var(--primary)),
+    inset 0 0 0 1px hsl(var(--primary) / 0.18);
+}
+
+[cmdk-root] [cmdk-item][data-selected="true"] svg,
+[cmdk-root] [cmdk-item][data-selected="true"] [data-slot="command-shortcut"] {
+  color: hsl(var(--primary));
+}
+
 /* Custom scrollbar */
 ::-webkit-scrollbar {
   width: 8px;

package/src/serve/public/lib/browse.ts

@@ -7,6 +7,7 @@ export interface BrowseDocument {
   collection: string;
   relPath: string;
   sourceExt: string;
+  updatedAt?: string;
 }
 
 export interface DocsResponse {

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

@@ -306,6 +306,10 @@ export default function DocView({ navigate }: PageProps) {
     []
   );
   const currentUri = currentTarget.uri;
+  const currentHash = useMemo(
+    () => window.location.hash.replace(/^#/u, ""),
+    []
+  );
   const highlightedLines = useMemo(() => {
     if (!currentTarget.lineStart) return [];
     const end = currentTarget.lineEnd ?? currentTarget.lineStart;
@@ -420,6 +424,19 @@ export default function DocView({ navigate }: PageProps) {
     }
   }, [currentTarget.lineStart, currentTarget.view]);
 
+  useEffect(() => {
+    if (!currentHash || showRawView || loading) {
+      return;
+    }
+
+    requestAnimationFrame(() => {
+      document
+        .getElementById(currentHash)
+        ?.scrollIntoView({ behavior: "smooth", block: "start" });
+      setActiveSectionAnchor(currentHash);
+    });
+  }, [currentHash, loading, showRawView]);
+
   const breadcrumbs = doc ? parseBreadcrumbs(doc.collection, doc.relPath) : [];
   const sections = useMemo(
     () => extractSections(parsedContent.body),
@@ -802,9 +819,8 @@ export default function DocView({ navigate }: PageProps) {
     setTimeout(() => setTagSaveSuccess(false), 2000);
   }, [doc, editedTags]);
 
-  /** Slim left rail — archival catalogue style, no Card chrome */
-  const renderDocumentFactsRail = () => (
-    <nav aria-label="Document facts" className="space-y-0">
+  const renderPropertiesPathRail = () => (
+    <nav aria-label="Document properties" className="space-y-0">
       {/* Section: Properties */}
       <div className="px-3 pb-3">
         <div className="mb-2.5 font-mono text-[10px] text-muted-foreground/50 uppercase tracking-[0.15em]">
@@ -883,11 +899,15 @@ export default function DocView({ navigate }: PageProps) {
           </button>
         </div>
       </div>
+    </nav>
+  );
 
-      {/* Divider + Frontmatter/Tags */}
+  /** Left rail — metadata + outline */
+  const renderDocumentFactsRail = () => (
+    <nav aria-label="Document facts" className="space-y-0">
+      {/* Frontmatter + tags */}
       {(hasFrontmatter || showStandaloneTags) && (
         <>
-          <div className="mx-3 border-border/20 border-t" />
           <div className="px-3 py-3">
             <div className="mb-2 flex items-center justify-between">
               <span className="font-mono text-[10px] text-muted-foreground/50 uppercase tracking-[0.15em]">
@@ -1372,10 +1392,12 @@ export default function DocView({ navigate }: PageProps) {
       </header>
 
       <div className="mx-auto flex max-w-[1800px] gap-5 px-6 xl:px-8">
-        {/* Left rail — document facts, only on ultra-wide */}
+        {/* Left rail — metadata + outline */}
         {doc && (
           <aside className="hidden w-[200px] shrink-0 border-border/15 border-r pr-2 py-6 lg:block">
-            <div className="sticky top-24">{renderDocumentFactsRail()}</div>
+            <div className="sticky top-24 max-h-[calc(100vh-7rem)] overflow-y-auto pr-1">
+              {renderDocumentFactsRail()}
+            </div>
           </aside>
         )}
 
@@ -1538,10 +1560,11 @@ export default function DocView({ navigate }: PageProps) {
           )}
         </main>
 
-        {/* Right rail — relationships */}
+        {/* Right rail — properties/path + relationships */}
         {doc && (
-          <aside className="hidden w-[240px] min-w-0 shrink-0 overflow-hidden border-border/15 border-l pl-2 py-6 lg:block">
-            <div className="sticky top-24 min-w-0 space-y-1 overflow-hidden">
+          <aside className="hidden w-[250px] min-w-0 shrink-0 overflow-hidden border-border/15 border-l pl-2 pt-2 pb-6 lg:block">
+            <div className="sticky top-18 min-w-0 max-h-[calc(100vh-5.5rem)] space-y-1 overflow-y-auto overflow-x-hidden pr-1">
+              {renderPropertiesPathRail()}
               <BacklinksPanel
                 docId={doc.docid}
                 onNavigate={(uri) =>

package/src/store/sqlite/adapter.ts

@@ -53,23 +53,172 @@ import { loadFts5Snowball } from "./fts5-snowball";
 
 /** Whitespace regex for splitting FTS5 tokens */
 const WHITESPACE_REGEX = /\s+/;
+const SINGLE_LINE_QUERY_PATTERN = /[\r\n]/;
+const DOUBLE_QUOTE_PATTERN = /"/g;
+const FTS5_FIELD_WEIGHTS = {
+  filepath: 1.5,
+  title: 4.0,
+  body: 1.0,
+} as const;
+
+function sanitizeFts5Term(term: string): string {
+  return term.replace(/[^\p{L}\p{N}'_]/gu, "").toLowerCase();
+}
+
+function isCompoundToken(token: string): boolean {
+  return /^[\p{L}\p{N}][\p{L}\p{N}'+-]*[-+][\p{L}\p{N}][\p{L}\p{N}'+-]*$/u.test(
+    token
+  );
+}
+
+function sanitizeCompoundTerm(term: string): string {
+  return term
+    .split(/[-+]/)
+    .map((part) => sanitizeFts5Term(part))
+    .filter((part) => part.length > 0)
+    .join(" ");
+}
+
+type FtsQueryBuildResult =
+  | { ok: true; query: string }
+  | { ok: false; error: string };
 
 /**
- * Escape a query string for safe FTS5 MATCH.
- * Wraps each token in double quotes to treat as literal terms.
- * Handles special chars: ? * - + ( ) " : ^ etc.
+ * Narrow lexical grammar for BM25/FTS queries.
+ *
+ * Supported:
+ * - plain terms -> prefix match
+ * - quoted phrases -> phrase match
+ * - negation with at least one positive term
+ * - hyphenated compounds handled intentionally
  */
-function escapeFts5Query(query: string): string {
-  // Split on whitespace, filter empty, quote each token
-  return query
-    .split(WHITESPACE_REGEX)
-    .filter((t) => t.length > 0)
-    .map((token) => {
-      // Escape internal double quotes by doubling them
-      const escaped = token.replace(/"/g, '""');
-      return `"${escaped}"`;
-    })
-    .join(" ");
+function buildFts5Query(query: string): FtsQueryBuildResult {
+  const trimmed = query.trim();
+  if (!trimmed) {
+    return { ok: false, error: "Search query cannot be empty" };
+  }
+
+  if (SINGLE_LINE_QUERY_PATTERN.test(trimmed)) {
+    return {
+      ok: false,
+      error: "Lexical query must be a single line. Remove newline characters.",
+    };
+  }
+
+  const quoteCount = (trimmed.match(DOUBLE_QUOTE_PATTERN) ?? []).length;
+  if (quoteCount % 2 === 1) {
+    return {
+      ok: false,
+      error:
+        'Lexical query has an unmatched double quote ("). Add the closing quote or remove it.',
+    };
+  }
+
+  const positive: string[] = [];
+  const negative: string[] = [];
+  let i = 0;
+
+  while (i < trimmed.length) {
+    while (i < trimmed.length && /\s/.test(trimmed[i]!)) {
+      i += 1;
+    }
+    if (i >= trimmed.length) {
+      break;
+    }
+
+    const negated = trimmed[i] === "-";
+    if (negated) {
+      i += 1;
+    }
+
+    if (i < trimmed.length && trimmed[i] === '"') {
+      const start = i + 1;
+      i += 1;
+      while (i < trimmed.length && trimmed[i] !== '"') {
+        i += 1;
+      }
+      const phrase = trimmed.slice(start, i).trim();
+      i += 1;
+
+      if (!phrase) {
+        continue;
+      }
+
+      const sanitized = phrase
+        .split(WHITESPACE_REGEX)
+        .map((token) =>
+          isCompoundToken(token)
+            ? sanitizeCompoundTerm(token)
+            : sanitizeFts5Term(token)
+        )
+        .filter((token) => token.length > 0)
+        .join(" ");
+      if (!sanitized) {
+        continue;
+      }
+
+      const ftsPhrase = `"${sanitized}"`;
+      if (negated) {
+        negative.push(ftsPhrase);
+      } else {
+        positive.push(ftsPhrase);
+      }
+      continue;
+    }
+
+    const start = i;
+    while (i < trimmed.length && !/[\s"]/.test(trimmed[i]!)) {
+      i += 1;
+    }
+    const token = trimmed.slice(start, i);
+    if (!token) {
+      continue;
+    }
+
+    if (isCompoundToken(token)) {
+      const sanitized = sanitizeCompoundTerm(token);
+      if (!sanitized) {
+        continue;
+      }
+      const ftsPhrase = `"${sanitized}"`;
+      if (negated) {
+        negative.push(ftsPhrase);
+      } else {
+        positive.push(ftsPhrase);
+      }
+      continue;
+    }
+
+    const sanitized = sanitizeFts5Term(token);
+    if (!sanitized) {
+      continue;
+    }
+    const ftsTerm = `"${sanitized}"*`;
+    if (negated) {
+      negative.push(ftsTerm);
+    } else {
+      positive.push(ftsTerm);
+    }
+  }
+
+  if (positive.length === 0 && negative.length === 0) {
+    return { ok: false, error: "Search query has no searchable terms" };
+  }
+
+  if (positive.length === 0) {
+    return {
+      ok: false,
+      error:
+        "Negation requires at least one positive search term in lexical queries.",
+    };
+  }
+
+  let ftsQuery = positive.join(" AND ");
+  for (const negation of negative) {
+    ftsQuery = `${ftsQuery} NOT ${negation}`;
+  }
+
+  return { ok: true, query: ftsQuery };
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -114,28 +263,28 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
       this.db.exec("PRAGMA foreign_keys = ON");
       this.db.exec("PRAGMA busy_timeout = 5000");
 
-      // CI mode: trade durability for speed (no fsync, memory journal)
-      // Safe for tests since we don't need crash recovery
+      // Keep WAL everywhere so readers can continue while a writer is active.
+      // CI still relaxes fsync/temp-store for speed, but MEMORY journal mode
+      // breaks the cross-process read/write behavior we rely on in CLI tests.
+      try {
+        const journalMode = this.db
+          .query<{ journal_mode: string }, []>("PRAGMA journal_mode")
+          .get()?.journal_mode;
+        if (journalMode?.toLowerCase() !== "wal") {
+          this.db.exec("PRAGMA journal_mode = WAL");
+        }
+      } catch (cause) {
+        if (!isDatabaseLockedError(cause)) {
+          throw cause;
+        }
+        // Another process may be switching journal mode or holding a write
+        // lock during startup. In that case we keep the connection usable and
+        // rely on the existing DB journal mode instead of failing open().
+      }
+
       if (process.env.CI) {
-        this.db.exec("PRAGMA journal_mode = MEMORY");
         this.db.exec("PRAGMA synchronous = OFF");
         this.db.exec("PRAGMA temp_store = MEMORY");
-      } else {
-        try {
-          const journalMode = this.db
-            .query<{ journal_mode: string }, []>("PRAGMA journal_mode")
-            .get()?.journal_mode;
-          if (journalMode?.toLowerCase() !== "wal") {
-            this.db.exec("PRAGMA journal_mode = WAL");
-          }
-        } catch (cause) {
-          if (!isDatabaseLockedError(cause)) {
-            throw cause;
-          }
-          // Another process may be switching journal mode or holding a write
-          // lock during startup. In that case we keep the connection usable and
-          // rely on the existing DB journal mode instead of failing open().
-        }
       }
 
       // Load fts5-snowball extension if using snowball tokenizer
@@ -1028,10 +1177,14 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
     try {
       const db = this.ensureOpen();
       const limit = options.limit ?? 20;
+      const builtQuery = buildFts5Query(query);
+      if (!builtQuery.ok) {
+        return err("INVALID_INPUT", builtQuery.error);
+      }
 
       // Build tag filter conditions using EXISTS subqueries
       const tagConditions: string[] = [];
-      const params: (string | number)[] = [escapeFts5Query(query)];
+      const params: (string | number)[] = [];
 
       // tagsAny: document has at least one of these tags
       if (options.tagsAny && options.tagsAny.length > 0) {
@@ -1075,17 +1228,35 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
       if (options.collection) {
         params.push(options.collection);
       }
+
+      const hasOuterFilters =
+        tagConditions.length > 0 || Boolean(options.collection);
+      const ftsLimit = hasOuterFilters ? limit * 10 : limit;
       params.push(limit);
 
-      // Document-level FTS search using documents_fts
-      // Uses bm25() for relevance ranking (more negative = better match)
-      // Snippet from body column (index 2) with highlight markers
+      // Document-level FTS search using an FTS-first CTE to keep collection and
+      // metadata filters from degrading the query plan into a broad scan.
       const sql = `
+        WITH fts_matches AS (
+          SELECT
+            rowid,
+            ${options.snippet ? "snippet(documents_fts, 2, '<mark>', '</mark>', '...', 32) as snippet," : ""}
+            bm25(
+              documents_fts,
+              ${FTS5_FIELD_WEIGHTS.filepath},
+              ${FTS5_FIELD_WEIGHTS.title},
+              ${FTS5_FIELD_WEIGHTS.body}
+            ) as score
+          FROM documents_fts
+          WHERE documents_fts MATCH ?
+          ORDER BY score
+          LIMIT ?
+        )
         SELECT
           d.mirror_hash,
           0 as seq,
-          bm25(documents_fts) as score,
-          ${options.snippet ? "snippet(documents_fts, 2, '<mark>', '</mark>', '...', 32) as snippet," : ""}
+          fm.score as score,
+          ${options.snippet ? "fm.snippet as snippet," : ""}
           d.docid,
           d.uri,
           d.title,
@@ -1097,12 +1268,12 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
           d.frontmatter_date,
           d.source_size,
           d.source_hash
-        FROM documents_fts fts
-        JOIN documents d ON d.id = fts.rowid AND d.active = 1
-        WHERE documents_fts MATCH ?
+        FROM fts_matches fm
+        JOIN documents d ON d.id = fm.rowid AND d.active = 1
+        WHERE 1 = 1
         ${tagConditions.length > 0 ? `AND ${tagConditions.join(" AND ")}` : ""}
         ${options.collection ? "AND d.collection = ?" : ""}
-        ORDER BY bm25(documents_fts)
+        ORDER BY fm.score
         LIMIT ?
       `;
 
@@ -1124,7 +1295,10 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
         source_hash: string | null;
       }
 
-      const rows = db.query<FtsRow, (string | number)[]>(sql).all(...params);
+      const queryParams = [builtQuery.query, ftsLimit, ...params];
+      const rows = db
+        .query<FtsRow, (string | number)[]>(sql)
+        .all(...queryParams);
 
       return ok(
         rows.map((r) => ({