@gmickel/gno 2.8.0 → 2.8.2

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

@@ -0,0 +1,243 @@
+/**
+ * Existence-only classification of unresolved workspace wiki links and
+ * relative Markdown links whose target is a file inside the link workspace
+ * that is not an indexed document (an attachment, a script beside a note, or
+ * a note in an unindexed or excluded folder). Obsidian
+ * resolves such links, so the link audit reports them as `outside-index`
+ * instead of unresolved. Only file names are listed: no file is opened,
+ * indexed, or returned, and no graph edge is created.
+ *
+ * @module src/core/audit-outside-index
+ */
+
+import type { Database } from "bun:sqlite";
+
+// node:fs/promises readdir/realpath/stat: directory enumeration and symlink
+// resolution; Bun has no equivalent that can skip an unreadable folder
+// instead of failing the scan.
+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 {
+  createWorkspaceFileMatcher,
+  loadLinkWorkspaceMemberships,
+} from "../store/sqlite/workspace-link-resolver";
+import { pathContains, placeDocument } from "./link-workspace";
+
+/** Path identity for exact-path matching: NFC, case-insensitive. */
+const pathKey = (path: string): string => path.normalize("NFC").toLowerCase();
+
+/** Upper bound of files listed per workspace; beyond it the listing is partial. */
+export const WORKSPACE_FILE_LISTING_MAX_FILES = 200_000;
+
+export interface WorkspaceFileListing {
+  /** Workspace-relative POSIX paths (NFC) of every non-hidden file. */
+  files: string[];
+  /** False when a folder could not be read or the file bound was reached. */
+  complete: boolean;
+}
+
+interface WorkspaceDirectoryEntry {
+  name: string;
+  isFile(): boolean;
+  isDirectory(): boolean;
+  isSymbolicLink(): boolean;
+}
+
+/** Filesystem reads the listing needs; injectable for tests. */
+export interface WorkspaceFileSystem {
+  readDirectory(path: string): Promise<WorkspaceDirectoryEntry[]>;
+  realPath(path: string): Promise<string>;
+  isRegularFile(path: string): Promise<boolean>;
+}
+
+const nodeWorkspaceFileSystem: WorkspaceFileSystem = {
+  readDirectory: (path) => readdir(path, { withFileTypes: true }),
+  realPath: (path) => realpath(path),
+  isRegularFile: async (path) => (await stat(path)).isFile(),
+};
+
+/** A symlink target that does not exist (or loops) is not a file, not an error. */
+const MISSING_TARGET_CODES = new Set(["ENOENT", "ENOTDIR", "ELOOP"]);
+
+/**
+ * A symlink counts as a file only when it resolves to an existing regular
+ * file inside the workspace. Dangling links, links to folders and links that
+ * leave the workspace are not files. Other errors are reported as such.
+ */
+const symlinkIsWorkspaceFile = async (
+  fs: WorkspaceFileSystem,
+  realRoot: string,
+  path: string
+): Promise<"file" | "not-file" | "error"> => {
+  try {
+    const target = await fs.realPath(path);
+    if (!pathContains(realRoot, target)) return "not-file";
+    return (await fs.isRegularFile(target)) ? "file" : "not-file";
+  } catch (cause) {
+    const code = (cause as NodeJS.ErrnoException | undefined)?.code;
+    return code !== undefined && MISSING_TARGET_CODES.has(code)
+      ? "not-file"
+      : "error";
+  }
+};
+
+/**
+ * List every file below a workspace root once. Hidden files and folders
+ * (`.obsidian`, `.trash`, `.git`) are skipped, as Obsidian does; symlinked
+ * folders are not descended. Filesystem calls use the names as stored on
+ * disk; only the returned paths are NFC-normalized for matching. An
+ * unreadable folder is skipped and marks the listing incomplete, so links
+ * into it stay unresolved.
+ */
+export const listWorkspaceFiles = async (
+  root: string,
+  options: {
+    maxFiles?: number;
+    signal?: AbortSignal;
+    fileSystem?: WorkspaceFileSystem;
+  } = {}
+): Promise<WorkspaceFileListing> => {
+  const maxFiles = options.maxFiles ?? WORKSPACE_FILE_LISTING_MAX_FILES;
+  const fs = options.fileSystem ?? nodeWorkspaceFileSystem;
+  const files: string[] = [];
+  let complete = true;
+  let realRoot: string;
+  try {
+    realRoot = await fs.realPath(root);
+  } catch {
+    return { files, complete: false };
+  }
+  // Each folder keeps its on-disk segments; matching uses the NFC path.
+  const queue: string[][] = [[]];
+  for (let head = 0; head < queue.length; head += 1) {
+    options.signal?.throwIfAborted();
+    const segments = queue[head] as string[];
+    let entries;
+    try {
+      entries = await fs.readDirectory(join(root, ...segments));
+    } catch {
+      complete = false;
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      const entrySegments = [...segments, entry.name];
+      let isFile = entry.isFile();
+      if (entry.isDirectory()) {
+        queue.push(entrySegments);
+        continue;
+      }
+      if (entry.isSymbolicLink()) {
+        const kind = await symlinkIsWorkspaceFile(
+          fs,
+          realRoot,
+          join(root, ...entrySegments)
+        );
+        if (kind === "error") complete = false;
+        isFile = kind === "file";
+      }
+      if (!isFile) continue;
+      if (files.length >= maxFiles) return { files, complete: false };
+      files.push(entrySegments.join("/").normalize("NFC"));
+    }
+  }
+  return { files, complete };
+};
+
+/**
+ * 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
+ * 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.
+ */
+export const markOutsideIndexLinks = async (
+  db: Database,
+  snapshot: AuditLinkSnapshot,
+  options: { maxFiles?: number; signal?: AbortSignal } = {}
+): Promise<AuditLinkSnapshot> => {
+  const audited = snapshot.auditedDocumentIds
+    ? new Set(snapshot.auditedDocumentIds)
+    : null;
+  const candidates = snapshot.links
+    .map((link, index) => ({ link, index }))
+    .filter(
+      ({ link }) =>
+        link.resolved === null &&
+        (link.linkType === "markdown" ||
+          (link.linkType === "wiki" && link.explicitCollection !== true)) &&
+        (audited === null || audited.has(link.sourceId))
+    );
+  if (candidates.length === 0) return snapshot;
+  const memberships = loadLinkWorkspaceMemberships(db);
+  const documentRelPaths = new Map(
+    snapshot.documents.map((document) => [document.id, document.relPath])
+  );
+  type PlacedLink = {
+    link: AuditLinkSnapshot["links"][number];
+    index: number;
+    key: string;
+  } & ({ sourcePath: string } | { targetPath: string });
+  const placed = candidates.flatMap(({ link, index }): PlacedLink[] => {
+    const membership = memberships.get(link.sourceCollection);
+    const placement = placeDocument(
+      membership,
+      documentRelPaths.get(link.sourceId) ?? link.sourceRelPath
+    );
+    if (placement.key === null) return [];
+    if (link.linkType === "wiki") {
+      return [{ link, index, key: placement.key, sourcePath: placement.path }];
+    }
+    // A Markdown target is stored collection-relative; place it the same way.
+    const target = placeDocument(membership, link.targetRefNorm);
+    return target.key === placement.key
+      ? [{ link, index, key: placement.key, targetPath: target.path }]
+      : [];
+  });
+  if (placed.length === 0) return snapshot;
+  const listings = new Map<
+    string,
+    {
+      matches: ReturnType<typeof createWorkspaceFileMatcher>;
+      paths: Set<string>;
+    }
+  >();
+  const maxFiles = options.maxFiles ?? WORKSPACE_FILE_LISTING_MAX_FILES;
+  let incomplete = 0;
+  for (const key of new Set(placed.map((entry) => entry.key))) {
+    const listing = await listWorkspaceFiles(key, {
+      maxFiles,
+      signal: options.signal,
+    });
+    if (!listing.complete) incomplete += 1;
+    listings.set(key, {
+      matches: createWorkspaceFileMatcher(listing.files),
+      paths: new Set(listing.files.map(pathKey)),
+    });
+  }
+  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
+        : listing?.matches(entry.link.targetRefNorm, entry.sourcePath) === true;
+    if (exists) {
+      links[entry.index] = { ...entry.link, outsideIndex: true };
+    }
+  }
+  return {
+    ...snapshot,
+    links,
+    ...(incomplete > 0
+      ? {
+          outsideIndexDiagnostic: `The file listing of ${incomplete} link workspace${incomplete === 1 ? " was" : "s were"} incomplete (an unreadable folder or link, or more than ${maxFiles} files); links to files it missed stay unresolved`,
+        }
+      : {}),
+  };
+};

package/src/core/audit-workspace.ts

@@ -32,6 +32,7 @@ import {
 } from "./audit";
 import { evaluateFreshnessAudit } from "./audit-freshness";
 import { evaluateLinkAudit } from "./audit-links";
+import { markOutsideIndexLinks } from "./audit-outside-index";
 import { evaluateProvenanceAudit } from "./audit-provenance";
 import {
   extractCaptureSourceFromFrontmatter,
@@ -429,15 +430,20 @@ const loadWorkspaceSnapshot = async (
       ? captureAuditLinkSnapshot(options.store.getRawDb())
       : emptyLinkSnapshot();
   const selectedIds = new Set(selected.documents.map(({ id }) => id));
+  const links = filterLinkSnapshot(
+    rawLinks,
+    selectedIds,
+    selected.documents,
+    selected.truncated,
+    filters.collections
+  );
   return {
     documents: observed,
-    links: filterLinkSnapshot(
-      rawLinks,
-      selectedIds,
-      selected.documents,
-      selected.truncated,
-      filters.collections
-    ),
+    links: options.categories.includes("links")
+      ? await markOutsideIndexLinks(options.store.getRawDb(), links, {
+          signal: options.signal,
+        })
+      : links,
     truncated: selected.truncated,
   };
 };

package/src/core/audit.ts

@@ -226,8 +226,16 @@ const materializeRule = (
     )
     .sort(compareAuditFindings);
 
+  // Only warning/error findings fail a passing rule; info findings of an
+  // informational rule (links.outside-index) leave it passing.
   let status = contribution.status;
-  if (findings.length > 0 && status === "pass") {
+  if (
+    status === "pass" &&
+    findings.some(
+      (finding) =>
+        finding.severity === "error" || finding.severity === "warning"
+    )
+  ) {
     status = "fail";
   }
 

package/src/core/change-diff.ts

@@ -12,7 +12,7 @@ import type {
 
 import { parseFrontmatter } from "../ingestion/frontmatter";
 import { buildLineOffsets } from "../ingestion/position";
-import { getExcludedRanges } from "../ingestion/strip";
+import { type ExcludedRange, getExcludedRanges } from "../ingestion/strip";
 import { normalizeMarkdownPath, normalizeWikiName, parseLinks } from "./links";
 import { extractSections } from "./sections";
 
@@ -107,9 +107,9 @@ const extractTypedEdges = (markdown: string): string[] => {
 export const extractDocumentStructure = (
   markdown: string,
   relPath: string,
-  dateFields: Readonly<Record<string, string>> | null | undefined
+  dateFields: Readonly<Record<string, string>> | null | undefined,
+  excludedRanges: ExcludedRange[] = getExcludedRanges(markdown)
 ): DocumentStructureSnapshot => {
-  const excludedRanges = getExcludedRanges(markdown);
   const links = parseLinks(markdown, buildLineOffsets(markdown), excludedRanges)
     .map((link) => linkSummary(link, relPath))
     .filter((value): value is string => value !== null);

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

@@ -23,7 +23,7 @@ import {
   pushInventoryToken,
 } from "./link-inventory-opaque";
 import { isRelevantDestination } from "./link-relevance";
-import { parseTargetParts } from "./links";
+import { parseTargetParts, splitWikiLinkContent } from "./links";
 
 const EXTERNAL_URL_REGEX = /^[a-z][a-z0-9+.-]*:/i;
 
@@ -51,8 +51,7 @@ export function inventoryWikiLinks(
     }
 
     const content = match[1] ?? "";
-    const pipeIndex = content.indexOf("|");
-    const targetPart = pipeIndex >= 0 ? content.slice(0, pipeIndex) : content;
+    const targetPart = splitWikiLinkContent(content).target;
     const trimmedTarget = targetPart.trim();
     if (!trimmedTarget) continue;
     const leadingWs = targetPart.length - targetPart.trimStart().length;

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

@@ -81,7 +81,9 @@ export function findExcludedKind(
 export function codeContextReason(
   kind: ExcludedRange["kind"] | null
 ): "code_fence_context" | "inline_code_context" | null {
-  if (kind === "fenced_code") return "code_fence_context";
+  if (kind === "fenced_code" || kind === "indented_code") {
+    return "code_fence_context";
+  }
   if (kind === "inline_code") return "inline_code_context";
   return null;
 }

package/src/core/links.ts

@@ -88,6 +88,8 @@ const LOGSEQ_EMBED_REGEX =
  * Markdown inline link: [text](url)
  * Captures: 1=text, 2=url (path and optional anchor)
  * Negative lookbehind to avoid image links ![]()
+ * Link text may contain balanced square brackets one level deep
+ * (`[see [1]](note.md)`), as CommonMark allows.
  *
  * SCOPE LIMITATIONS:
  * - Only matches simple inline links [text](url)
@@ -95,7 +97,10 @@ const LOGSEQ_EMBED_REGEX =
  * - 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 = /(?<!!)\[((?:[^[\]]|\[[^[\]]*\])*)\]\(([^)]+)\)/g;
+
+/** Square brackets in a destination mean the text was split, not a path. */
+const BRACKET_IN_DESTINATION_REGEX = /[[\]]/;
 
 /** External URL pattern (http:// https:// mailto: etc.) */
 const EXTERNAL_URL_REGEX = /^[a-z][a-z0-9+.-]*:/i;
@@ -144,6 +149,26 @@ export function extractWikiBasename(ref: string): string {
   return stripWikiMdExt(base);
 }
 
+/**
+ * Split the content of a wiki link into target and alias. Obsidian also reads
+ * `\|` (the pipe escaped inside a Markdown table) as the alias separator,
+ * so `[[Note\|Alias]]` targets `Note`, not `Note\`.
+ */
+export function splitWikiLinkContent(content: string): {
+  target: string;
+  alias?: string;
+} {
+  const pipeIndex = content.indexOf("|");
+  if (pipeIndex < 0) {
+    return { target: content };
+  }
+  const escaped = pipeIndex > 0 && content[pipeIndex - 1] === "\\";
+  return {
+    target: content.slice(0, escaped ? pipeIndex - 1 : pipeIndex),
+    alias: content.slice(pipeIndex + 1),
+  };
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Path Normalization
 // ─────────────────────────────────────────────────────────────────────────────
@@ -338,22 +363,14 @@ export function parseLinks(
     const content = match[1];
     if (!content) continue;
 
-    // Parse [[target|alias]] format
-    const pipeIndex = content.indexOf("|");
-    let targetPart: string;
-    let displayText: string | undefined;
-
-    if (pipeIndex >= 0) {
-      targetPart = content.slice(0, pipeIndex);
-      const aliasText = content.slice(pipeIndex + 1);
-      // Only set displayText if different from target
-      displayText =
-        aliasText !== targetPart
-          ? truncateText(aliasText, MAX_DISPLAY_TEXT_GRAPHEMES)
-          : undefined;
-    } else {
-      targetPart = content;
-    }
+    // Parse [[target|alias]] (and table-escaped [[target\|alias]]) format
+    const { target: targetPart, alias: aliasText } =
+      splitWikiLinkContent(content);
+    // Only set displayText if different from target
+    const displayText =
+      aliasText !== undefined && aliasText !== targetPart
+        ? truncateText(aliasText, MAX_DISPLAY_TEXT_GRAPHEMES)
+        : undefined;
 
     const trimmedTarget = targetPart.trim();
     if (!trimmedTarget) {
@@ -427,6 +444,12 @@ export function parseLinks(
       continue;
     }
 
+    // Brackets in the destination come from link text split at an
+    // unbalanced bracket (`[a [b](c](d)`): unparseable, not a missing target.
+    if (BRACKET_IN_DESTINATION_REGEX.test(url)) {
+      continue;
+    }
+
     // Skip URLs that look like protocol-relative (//example.com)
     if (url.startsWith("//")) {
       continue;