@gmickel/gno 2.8.2 → 2.8.3

package/src/converters/registry.ts

@@ -10,7 +10,7 @@ import type {
   RecordAdapter,
 } from "./types";
 
-import { unsupportedError } from "./errors";
+import { adapterError, unsupportedError } from "./errors";
 
 export class ConverterRegistry {
   private readonly converters: Converter[] = [];
@@ -71,13 +71,48 @@ export class ConverterRegistry {
   }
 }
 
+/**
+ * Load an adapter module; if it cannot load in this runtime, stand in a
+ * converter that fails its file types with ADAPTER_FAILURE and the reason.
+ */
+export async function loadAdapter(
+  load: () => Promise<Converter>,
+  id: string,
+  extensions: readonly string[],
+  mimes: readonly string[]
+): Promise<Converter> {
+  try {
+    return await load();
+  } catch (cause) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    return {
+      id,
+      version: "unavailable",
+      // Same matching as the real adapter, so a sniffed MIME without an
+      // extension still reports ADAPTER_FAILURE, not UNSUPPORTED.
+      canHandle: (mime, ext) =>
+        extensions.includes(ext) || mimes.includes(mime),
+      convert: (input) =>
+        Promise.resolve({
+          ok: false,
+          error: adapterError(
+            input,
+            id,
+            `${id} is unavailable in this build: ${reason}`
+          ),
+        }),
+    };
+  }
+}
+
 /**
  * Create the default registry with all MVP converters.
  * Priority order per PRD §8.6:
  * 1. native/markdown - handles .md
  * 2. native/plaintext - handles .txt
- * 3. adapter/markitdown-ts - handles .pdf, .docx, .xlsx
- * 4. adapter/officeparser - handles .pptx
+ * 3. adapter/xlsx - handles .xlsx (linear SheetJS -> Markdown tables)
+ * 4. adapter/markitdown-ts - handles .pdf, .docx
+ * 5. adapter/officeparser - handles .pptx
  */
 export async function createDefaultRegistry(): Promise<ConverterRegistry> {
   const registry = new ConverterRegistry();
@@ -85,9 +120,29 @@ export async function createDefaultRegistry(): Promise<ConverterRegistry> {
   // Import converters dynamically to avoid circular deps
   const { markdownConverter } = await import("./native/markdown");
   const { plaintextConverter } = await import("./native/plaintext");
-  const { markitdownAdapter } = await import("./adapters/markitdownTs/adapter");
-  const { officeparserAdapter } =
-    await import("./adapters/officeparser/adapter");
+  const { xlsxAdapter } = await import("./adapters/xlsx/adapter");
+  // The PDF/Office adapters load pdf.js, which cannot initialize where its
+  // native canvas binding is missing (a standalone compiled executable). A
+  // failed adapter only fails its own file types.
+  const markitdownAdapter = await loadAdapter(
+    async () =>
+      (await import("./adapters/markitdownTs/adapter")).markitdownAdapter,
+    "adapter/markitdown-ts",
+    [".pdf", ".docx"],
+    [
+      "application/pdf",
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ]
+  );
+  const officeparserAdapter = await loadAdapter(
+    async () =>
+      (await import("./adapters/officeparser/adapter")).officeparserAdapter,
+    "adapter/officeparser",
+    [".pptx"],
+    [
+      "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ]
+  );
   const { jsonlAdapter } = await import("./adapters/jsonl/adapter");
   const { transcriptAdapter } = await import("./adapters/transcript/adapter");
   const { emailRecordAdapter } = await import("./adapters/email/adapter");
@@ -98,6 +153,7 @@ export async function createDefaultRegistry(): Promise<ConverterRegistry> {
   // Register in priority order
   registry.register(markdownConverter);
   registry.register(plaintextConverter);
+  registry.register(xlsxAdapter);
   registry.register(markitdownAdapter);
   registry.register(officeparserAdapter);
   registry.registerRecordAdapter(jsonlAdapter);

package/src/converters/versions.ts

@@ -18,5 +18,7 @@ export const NATIVE_VERSIONS = {
  */
 export const ADAPTER_VERSIONS = {
   "markitdown-ts": "0.0.10+xlsx.0.20.3",
+  /** Direct SheetJS -> Markdown tables (fn-198); output matches markitdown. */
+  xlsx: "sheetjs-0.20.3+md.1",
   officeparser: "7.8.0+pdfjs.6.3.289",
 } as const;

package/src/core/audit-freshness.ts

@@ -144,7 +144,7 @@ export const evaluateFreshnessAudit = (
           document,
           kind: "stale-indexed-revision",
           message: document.lastErrorCode
-            ? "The latest indexing attempt recorded an error"
+            ? `The latest indexing attempt recorded an error (${document.lastErrorCode})`
             : "The document has no indexed-at revision evidence",
           detail: {
             indexedAt: document.indexedAt,

package/src/core/audit-outside-index.ts

@@ -19,7 +19,10 @@ import { readdir, realpath, stat } from "node:fs/promises";
 // node:path join: platform path algebra; no Bun equivalent.
 import { join } from "node:path";
 
-import type { AuditLinkSnapshot } from "../store/sqlite/graph-link-resolver";
+import type {
+  AuditLinkSnapshot,
+  AuditLinkSnapshotLink,
+} from "../store/sqlite/graph-link-resolver";
 
 import {
   createWorkspaceFileMatcher,
@@ -30,6 +33,27 @@ import { pathContains, placeDocument } from "./link-workspace";
 /** Path identity for exact-path matching: NFC, case-insensitive. */
 const pathKey = (path: string): string => path.normalize("NFC").toLowerCase();
 
+/**
+ * A Markdown link names the file's exact path; as with wiki links, `.md` is
+ * optional, so `[x](Note)` matches an unindexed `Note.md`. An indexed
+ * `Note.md` is not outside the index, so that link keeps its status. Indexed
+ * paths are compared under the same key as listed files (NFC, Unicode
+ * lowercase), never SQLite's ASCII-only NOCASE.
+ */
+const markdownTargetExists = (
+  link: AuditLinkSnapshotLink,
+  targetPath: string,
+  paths: ReadonlySet<string> | undefined,
+  indexedKeys: (collection: string) => ReadonlySet<string>
+): boolean => {
+  const key = pathKey(targetPath);
+  if (paths?.has(key) === true) return true;
+  if (key.endsWith(".md") || paths?.has(`${key}.md`) !== true) return false;
+  return !indexedKeys(link.targetCollection).has(
+    pathKey(`${link.targetRefNorm}.md`)
+  );
+};
+
 /** Upper bound of files listed per workspace; beyond it the listing is partial. */
 export const WORKSPACE_FILE_LISTING_MAX_FILES = 200_000;
 
@@ -152,7 +176,7 @@ export const listWorkspaceFiles = async (
  * Mark unresolved plain wiki links and relative Markdown links of audited
  * documents inside a link workspace whose target exists as a workspace file.
  * A wiki link matches under workspace resolution rules; a Markdown link must
- * name the file's exact path (NFC, case-insensitive). Each involved workspace
+ * name the file's exact path (NFC, case-insensitive), `.md` optional. Each involved workspace
  * is listed once per call. A failed or partial listing never marks a link
  * that is not in it; the snapshot then carries one diagnostic.
  */
@@ -220,12 +244,33 @@ export const markOutsideIndexLinks = async (
       paths: new Set(listing.files.map(pathKey)),
     });
   }
+  const indexedByCollection = new Map<string, Set<string>>();
+  const indexedKeys = (collection: string): ReadonlySet<string> => {
+    let keys = indexedByCollection.get(collection);
+    if (!keys) {
+      keys = new Set(
+        db
+          .query<{ relPath: string }, [string]>(
+            "SELECT rel_path AS relPath FROM documents WHERE active = 1 AND collection = ?"
+          )
+          .all(collection)
+          .map(({ relPath }) => pathKey(relPath))
+      );
+      indexedByCollection.set(collection, keys);
+    }
+    return keys;
+  };
   const links = [...snapshot.links];
   for (const entry of placed) {
     const listing = listings.get(entry.key);
     const exists =
       "targetPath" in entry
-        ? listing?.paths.has(pathKey(entry.targetPath)) === true
+        ? markdownTargetExists(
+            entry.link,
+            entry.targetPath,
+            listing?.paths,
+            indexedKeys
+          )
         : listing?.matches(entry.link.targetRefNorm, entry.sourcePath) === true;
     if (exists) {
       links[entry.index] = { ...entry.link, outsideIndex: true };

package/src/core/change-diff.ts

@@ -104,15 +104,27 @@ const extractTypedEdges = (markdown: string): string[] => {
   return [...new Set(values)].sort();
 };
 
+export interface DocumentStructureOptions {
+  /** Only Markdown sources carry links (matches link extraction at sync). */
+  markdownSource: boolean;
+  excludedRanges?: ExcludedRange[];
+}
+
 export const extractDocumentStructure = (
   markdown: string,
   relPath: string,
   dateFields: Readonly<Record<string, string>> | null | undefined,
-  excludedRanges: ExcludedRange[] = getExcludedRanges(markdown)
+  { markdownSource, excludedRanges }: DocumentStructureOptions
 ): DocumentStructureSnapshot => {
-  const links = parseLinks(markdown, buildLineOffsets(markdown), excludedRanges)
-    .map((link) => linkSummary(link, relPath))
-    .filter((value): value is string => value !== null);
+  const links = markdownSource
+    ? parseLinks(
+        markdown,
+        buildLineOffsets(markdown),
+        excludedRanges ?? getExcludedRanges(markdown)
+      )
+        .map((link) => linkSummary(link, relPath))
+        .filter((value): value is string => value !== null)
+    : [];
 
   return {
     headings: withOccurrences(

package/src/core/link-destination-parse.ts

@@ -42,6 +42,19 @@ const COMMONMARK_ESCAPABLE = new Set([
   " ",
 ]);
 
+/**
+ * True when the character at `index` is backslash-escaped: preceded by an odd
+ * number of backslashes. An escaped `[` is literal text in CommonMark and
+ * cannot open a link.
+ */
+export function isBackslashEscaped(text: string, index: number): boolean {
+  let backslashes = 0;
+  for (let i = index - 1; i >= 0 && text[i] === "\\"; i -= 1) {
+    backslashes += 1;
+  }
+  return backslashes % 2 === 1;
+}
+
 export interface LinkEncodingStyle {
   spaces: "percent" | "backslash" | "raw";
   parens: "percent" | "backslash" | "raw";
@@ -220,10 +233,10 @@ export function parseParenthesizedDestination(
         i += 1;
         continue;
       }
-      if (
-        depth === 0 &&
-        (ch === " " || ch === "\t" || ch === "\n" || ch === "\r")
-      ) {
+      if (ch === " " || ch === "\t" || ch === "\n" || ch === "\r") {
+        // CommonMark: a bare destination has no unescaped whitespace, inside
+        // nested parentheses too (`(foo(bar baz).md)` is not a link).
+        if (depth > 0) return null;
         destEnd = i;
         break;
       }
@@ -262,6 +275,10 @@ export function parseParenthesizedDestination(
     close = j;
   }
 
+  // The destination and optional title must end at a real `)`:
+  // `[x](<note.md>` or `[x](<note.md>.` is not a link.
+  if (markdown[close] !== ")") return null;
+
   const destinationRaw = markdown.slice(destStart, destEnd);
   if (!destinationRaw) return null;
   return {

package/src/core/link-inventory-markdown.ts

@@ -11,6 +11,7 @@ import { offsetToPosition } from "../ingestion/position";
 import { rangeIntersectsExcluded } from "../ingestion/strip";
 import {
   detectEncodingStyle,
+  isBackslashEscaped,
   parseParenthesizedDestination,
   splitDestinationPath,
   stripAngleBracketDestination,
@@ -298,12 +299,31 @@ export function inventoryInlineMarkdown(
   while (searchFrom < markdown.length) {
     const labelOpen = markdown.indexOf("[", searchFrom);
     if (labelOpen < 0) break;
-    if (labelOpen > 0 && markdown[labelOpen - 1] === "!") {
+    if (
+      (labelOpen > 0 && markdown[labelOpen - 1] === "!") ||
+      isBackslashEscaped(markdown, labelOpen)
+    ) {
+      searchFrom = labelOpen + 1;
+      continue;
+    }
+    // Match link extraction: escaped brackets are literal label text, and
+    // nested brackets must balance (`[see [1]](note.md)` is one link).
+    let labelClose = -1;
+    let depth = 0;
+    for (let i = labelOpen + 1; i < markdown.length; i += 1) {
+      const ch = markdown[i];
+      if ((ch !== "]" && ch !== "[") || isBackslashEscaped(markdown, i))
+        continue;
+      if (ch === "[") depth += 1;
+      else if (depth === 0) {
+        labelClose = i;
+        break;
+      } else depth -= 1;
+    }
+    if (labelClose < 0) {
       searchFrom = labelOpen + 1;
       continue;
     }
-    const labelClose = markdown.indexOf("]", labelOpen + 1);
-    if (labelClose < 0) break;
     if (markdown[labelClose + 1] !== "(") {
       searchFrom = labelOpen + 1;
       continue;

package/src/core/links.ts

@@ -14,6 +14,12 @@ import type { ExcludedRange } from "../ingestion/strip";
 
 import { buildLineOffsets, offsetToPosition } from "../ingestion/position";
 import { rangeIntersectsExcluded } from "../ingestion/strip";
+import {
+  isBackslashEscaped,
+  parseParenthesizedDestination,
+  stripAngleBracketDestination,
+  unescapeCommonMarkDestination,
+} from "./link-destination-parse";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Types
@@ -85,19 +91,24 @@ const LOGSEQ_EMBED_REGEX =
   /\{\{\s*embed\s+(\[\[[^\]]+\]\]|\(\([^)]+\)\))\s*\}\}/gi;
 
 /**
- * Markdown inline link: [text](url)
- * Captures: 1=text, 2=url (path and optional anchor)
+ * Markdown inline link opener: `[text](`, up to and including the `(`.
+ * Captures: 1=text. The destination after `(` is read by
+ * parseParenthesizedDestination, as CommonMark reads it.
  * Negative lookbehind to avoid image links ![]()
  * Link text may contain balanced square brackets one level deep
- * (`[see [1]](note.md)`), as CommonMark allows.
+ * (`[see [1]](note.md)`), as CommonMark allows; a backslash-escaped bracket
+ * (`\]`, `\[`) in the text is literal and never opens or closes it.
  *
  * SCOPE LIMITATIONS:
  * - Only matches simple inline links [text](url)
  * - Does NOT match reference-style links [text][ref] or [text]
  * - Does NOT match autolinks <url> or bare URLs
- * - Parens in URLs not supported (use %28 %29 encoding)
  */
-const MARKDOWN_LINK_REGEX = /(?<!!)\[((?:[^[\]]|\[[^[\]]*\])*)\]\(([^)]+)\)/g;
+const MARKDOWN_LINK_REGEX =
+  /(?<!!)\[((?:\\[\s\S]|[^[\]\\]|\[(?:\\[\s\S]|[^[\]\\])*\])*)\]\(/g;
+
+/** Logseq alias destination at the `(`: `([[Target]])`. */
+const LOGSEQ_ALIAS_DESTINATION_REGEX = /\((\[\[[^)]*\]\])\)/y;
 
 /** Square brackets in a destination mean the text was split, not a path. */
 const BRACKET_IN_DESTINATION_REGEX = /[[\]]/;
@@ -287,6 +298,40 @@ export function parseTargetParts(target: string): TargetParts {
 // Link Parsing
 // ─────────────────────────────────────────────────────────────────────────────
 
+/**
+ * Read an inline link destination at the `(` after `[text]`, the way
+ * CommonMark reads it: optional title, balanced parentheses, and no
+ * unescaped whitespace unless wrapped in `<...>`. Returns the unescaped
+ * destination (angle brackets removed) and the offset after the closing `)`,
+ * or null when the text is not a link. A Logseq alias `([[Target]])` is
+ * returned verbatim.
+ */
+function readInlineDestination(
+  markdown: string,
+  parenOffset: number
+): { url: string; endOffset: number; logseqAlias: boolean } | null {
+  LOGSEQ_ALIAS_DESTINATION_REGEX.lastIndex = parenOffset;
+  const logseq = LOGSEQ_ALIAS_DESTINATION_REGEX.exec(markdown);
+  if (logseq) {
+    return {
+      url: logseq[1] ?? "",
+      endOffset: parenOffset + logseq[0].length,
+      logseqAlias: true,
+    };
+  }
+  const parsed = parseParenthesizedDestination(markdown, parenOffset);
+  if (!parsed || parsed.destinationRaw.includes("\n")) {
+    return null;
+  }
+  return {
+    url: unescapeCommonMarkDestination(
+      stripAngleBracketDestination(parsed.destinationRaw).path
+    ),
+    endOffset: parsed.closeParenOffset + 1,
+    logseqAlias: false,
+  };
+}
+
 /**
  * Parse all links from markdown content.
  * Skips links inside excluded ranges (code blocks, frontmatter, etc.).
@@ -409,32 +454,45 @@ export function parseLinks(
 
   while ((match = MARKDOWN_LINK_REGEX.exec(markdown)) !== null) {
     const startOffset = match.index;
-    const endOffset = startOffset + match[0].length;
+    const parenOffset = startOffset + match[0].length - 1;
+
+    // `\[` is literal text in CommonMark: it cannot open a link. A link
+    // may still start at a later `[` inside the text.
+    if (isBackslashEscaped(markdown, startOffset)) {
+      MARKDOWN_LINK_REGEX.lastIndex = startOffset + 1;
+      continue;
+    }
+
+    const destination = readInlineDestination(markdown, parenOffset);
+    // Not a link: a destination with an unescaped space outside `<...>`
+    // (`[x](my note.md)`) or no closing parenthesis. It is plain text; a link
+    // may still start at a later `[` inside the text.
+    if (!destination) {
+      MARKDOWN_LINK_REGEX.lastIndex = startOffset + 1;
+      continue;
+    }
+    const endOffset = destination.endOffset;
+    MARKDOWN_LINK_REGEX.lastIndex = endOffset;
 
     // Skip if inside excluded range
     if (rangeIntersectsExcluded(startOffset, endOffset, excludedRanges)) {
       continue;
     }
 
+    const raw = markdown.slice(startOffset, endOffset);
     const linkText = match[1] ?? "";
-    const url = match[2];
+    const { url } = destination;
     if (!url) continue;
 
     // Logseq alias syntax: [Display]([[Target]])
-    if (url.startsWith("[[") && url.endsWith("]]")) {
+    if (destination.logseqAlias) {
       const innerTarget = url.slice(2, -2).trim();
       if (innerTarget.length > 0) {
         const displayText =
           linkText && linkText !== innerTarget
             ? truncateText(linkText, MAX_DISPLAY_TEXT_GRAPHEMES)
             : undefined;
-        pushWikiLink(
-          match[0],
-          innerTarget,
-          startOffset,
-          endOffset,
-          displayText
-        );
+        pushWikiLink(raw, innerTarget, startOffset, endOffset, displayText);
       }
       continue;
     }
@@ -491,7 +549,7 @@ export function parseLinks(
 
     links.push({
       kind: "markdown",
-      raw: match[0],
+      raw,
       targetRef: parts.ref,
       targetAnchor: anchor ?? parts.anchor,
       targetCollection: parts.collection,

package/src/core/network-boundary-inventory.ts

@@ -305,6 +305,24 @@ export const NETWORK_BOUNDARY_INVENTORY = [
     action: null,
     enforcement: "local_process_only",
   },
+  {
+    // `ps` for the file processor child's resident memory (non-Linux Unix).
+    id: "file-processor-rss-probe",
+    key: "src/ingestion/file-processor.ts::child_process#1",
+    path: "src/ingestion/file-processor.ts",
+    primitive: "child_process",
+    action: null,
+    enforcement: "local_process_only",
+  },
+  {
+    // The same executable re-run as the file processor child (compiled builds).
+    id: "file-processor-child",
+    key: "src/ingestion/file-processor.ts::child_process#2",
+    path: "src/ingestion/file-processor.ts",
+    primitive: "child_process",
+    action: null,
+    enforcement: "local_process_only",
+  },
   {
     id: "http-mcp-tools",
     key: "logical::http-mcp-tools",

package/src/index.ts

@@ -7,6 +7,7 @@
  */
 
 import { runCli } from "./cli/run";
+import { FILE_PROCESSOR_CHILD_ENV } from "./ingestion/file-child-env";
 import { resetModelManager } from "./llm/nodeLlamaCpp/lifecycle";
 import { IMPORT_CHILD_ENV } from "./sessions/import-child-env";
 
@@ -78,6 +79,15 @@ if (process.env[IMPORT_CHILD_ENV] === "1") {
   await cleanupAndExit(0);
 }
 
+// A compiled executable re-run as the file processor child (see
+// src/ingestion/file-processor.ts) prepares files for its parent until the
+// parent disconnects.
+if (process.env[FILE_PROCESSOR_CHILD_ENV] === "1") {
+  const { runFileProcessorChild } = await import("./ingestion/file-child");
+  await runFileProcessorChild();
+  await cleanupAndExit(0);
+}
+
 // Await module completion so pending piped stdin keeps Windows Bun alive.
 await runCli(process.argv)
   .then((code) => cleanupAndExit(interruptExitCode || code))