@gmickel/gno 1.31.0 → 1.33.0

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

@@ -0,0 +1,47 @@
+/**
+ * Shared inventory token types and caps for reference-safe refactors.
+ *
+ * @module src/core/link-inventory-types
+ */
+
+import type {
+  FileRefactorReasonCode,
+  FileRefactorReferenceClassification,
+  FileRefactorReferenceKind,
+} from "./file-refactor-contract";
+import type { LinkEncodingStyle } from "./link-destination-parse";
+
+/** Hard caps — callers must fail closed when truncated. */
+export const LINK_INVENTORY_CAPS = {
+  maxContentChars: 1_000_000,
+  maxTokensPerDocument: 2_000,
+} as const;
+
+export interface LinkInventoryToken {
+  kind: FileRefactorReferenceKind;
+  classification?: FileRefactorReferenceClassification;
+  reasonCode?: FileRefactorReasonCode;
+  raw: string;
+  originalDestination: string;
+  destinationStart: number;
+  destinationEnd: number;
+  startOffset: number;
+  endOffset: number;
+  startLine: number;
+  startCol: number;
+  endLine: number;
+  endCol: number;
+  targetRef: string;
+  targetAnchor?: string;
+  targetCollection?: string;
+  targetQuery?: string;
+  hadLeadingDotSlash: boolean;
+  encodingStyle: LinkEncodingStyle;
+}
+
+export interface LinkInventoryResult {
+  tokens: LinkInventoryToken[];
+  truncated: boolean;
+  /** True when destination spans overlap after inventory. */
+  overlapping: boolean;
+}

package/src/core/link-inventory.ts

@@ -0,0 +1,182 @@
+/**
+ * Parser-backed link inventory for reference-safe file refactors.
+ *
+ * Produces exact UTF-16 destination token spans plus conservative opaque /
+ * malformed detections. Does not mutate disk or change parseLinks behavior.
+ *
+ * @module src/core/link-inventory
+ */
+
+import type { ExcludedRange } from "../ingestion/strip";
+import type {
+  LinkInventoryResult,
+  LinkInventoryToken,
+} from "./link-inventory-types";
+
+import { getExcludedRanges } from "../ingestion/strip";
+import {
+  inventoryInlineMarkdown,
+  inventoryReferenceDefinitions,
+  inventoryWikiLinks,
+} from "./link-inventory-markdown";
+import {
+  buildLineOffsets,
+  inventoryEmbeds,
+  inventoryHtmlHrefs,
+  inventoryMalformedWiki,
+} from "./link-inventory-opaque";
+import { LINK_INVENTORY_CAPS } from "./link-inventory-types";
+
+export {
+  LINK_INVENTORY_CAPS,
+  type LinkInventoryResult,
+  type LinkInventoryToken,
+} from "./link-inventory-types";
+export {
+  buildContentPrefilterNeedles,
+  buildSourceRelevanceKeys,
+  isRelevantDestination,
+} from "./link-relevance";
+
+/**
+ * Destination identity for inventory dedupe.
+ * Kind is intentionally omitted so identical spans from overlapping scanners
+ * collapse to the first (scanner-precedence) token.
+ */
+export function inventoryDestinationKey(token: {
+  destinationStart: number;
+  destinationEnd: number;
+  originalDestination: string;
+}): string {
+  return `${token.destinationStart}:${token.destinationEnd}:${token.originalDestination}`;
+}
+
+/**
+ * Dedupe identical destination spans (regardless of scanner kind) and detect
+ * true partial overlaps. First token wins — callers should push in scanner order.
+ */
+export function dedupeInventoryDestinationTokens(
+  tokens: LinkInventoryToken[]
+): {
+  tokens: LinkInventoryToken[];
+  overlapping: boolean;
+} {
+  const seen = new Set<string>();
+  const unique: LinkInventoryToken[] = [];
+  for (const token of tokens) {
+    const key = inventoryDestinationKey(token);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(token);
+  }
+  unique.sort((a, b) => {
+    if (a.destinationStart !== b.destinationStart) {
+      return a.destinationStart - b.destinationStart;
+    }
+    return a.destinationEnd - b.destinationEnd;
+  });
+  let overlapping = false;
+  for (let i = 1; i < unique.length; i += 1) {
+    const prev = unique[i - 1]!;
+    const cur = unique[i]!;
+    if (cur.destinationStart < prev.destinationEnd) {
+      overlapping = true;
+      break;
+    }
+  }
+  unique.sort((a, b) => {
+    if (a.startLine !== b.startLine) return a.startLine - b.startLine;
+    if (a.startCol !== b.startCol) return a.startCol - b.startCol;
+    return a.destinationStart - b.destinationStart;
+  });
+  return { tokens: unique, overlapping };
+}
+
+/**
+ * Inventory all relevant rewrite / opaque reference tokens in one document.
+ */
+export function inventoryDocumentLinks(
+  markdown: string,
+  options: {
+    sourceKeys: ReadonlySet<string>;
+    excludedRanges?: ExcludedRange[];
+  }
+): LinkInventoryResult {
+  const truncated = { value: false };
+  if (markdown.length > LINK_INVENTORY_CAPS.maxContentChars) {
+    return { tokens: [], truncated: true, overlapping: false };
+  }
+
+  const excluded = options.excludedRanges ?? getExcludedRanges(markdown);
+  const lineOffsets = buildLineOffsets(markdown);
+  const tokens: LinkInventoryToken[] = [];
+  const consumed = new Set<number>();
+  const sourceKeys = options.sourceKeys;
+
+  const ok =
+    inventoryEmbeds(
+      markdown,
+      lineOffsets,
+      sourceKeys,
+      excluded,
+      tokens,
+      truncated,
+      consumed
+    ) &&
+    inventoryHtmlHrefs(
+      markdown,
+      lineOffsets,
+      sourceKeys,
+      excluded,
+      tokens,
+      truncated,
+      consumed
+    ) &&
+    inventoryMalformedWiki(
+      markdown,
+      lineOffsets,
+      sourceKeys,
+      excluded,
+      tokens,
+      truncated,
+      consumed
+    ) &&
+    inventoryWikiLinks(
+      markdown,
+      lineOffsets,
+      sourceKeys,
+      excluded,
+      tokens,
+      truncated,
+      consumed
+    ) &&
+    inventoryReferenceDefinitions(
+      markdown,
+      lineOffsets,
+      sourceKeys,
+      excluded,
+      tokens,
+      truncated,
+      consumed
+    ) &&
+    inventoryInlineMarkdown(
+      markdown,
+      lineOffsets,
+      sourceKeys,
+      excluded,
+      tokens,
+      truncated,
+      consumed
+    );
+
+  if (!ok) {
+    return { tokens, truncated: true, overlapping: false };
+  }
+
+  const finalized = dedupeInventoryDestinationTokens(tokens);
+  return {
+    tokens: finalized.tokens,
+    truncated: truncated.value,
+    overlapping: finalized.overlapping,
+  };
+}

package/src/core/link-relevance.ts

@@ -0,0 +1,150 @@
+/**
+ * Conservative destination relevance for reference-safe file refactors.
+ *
+ * Uses exact token/path/basename equality after stripping query/fragment,
+ * safe decoding, NFC normalization, and syntax delimiters. No fuzzy
+ * substring matching — unrelated `other-note.md` must not match `note.md`.
+ *
+ * @module src/core/link-relevance
+ */
+
+// node:path/posix — no Bun path utils
+import { posix as pathPosix } from "node:path";
+
+import {
+  stripAngleBracketDestination,
+  unescapeCommonMarkDestination,
+} from "./link-destination-parse";
+import { normalizeWikiName, stripWikiMdExt } from "./links";
+
+function safeDecodeForRelevance(value: string): string {
+  return value
+    .replaceAll("%20", " ")
+    .replaceAll("%28", "(")
+    .replaceAll("%29", ")");
+}
+
+function stripQueryAndFragment(value: string): string {
+  const hash = value.indexOf("#");
+  const withoutHash = hash >= 0 ? value.slice(0, hash) : value;
+  const query = withoutHash.indexOf("?");
+  return query >= 0 ? withoutHash.slice(0, query) : withoutHash;
+}
+
+function addKey(keys: Set<string>, value: string): void {
+  const trimmed = value.trim();
+  if (!trimmed) return;
+  keys.add(normalizeWikiName(trimmed));
+  keys.add(normalizeWikiName(stripWikiMdExt(trimmed)));
+  keys.add(trimmed.toLowerCase());
+  keys.add(stripWikiMdExt(trimmed).toLowerCase());
+  const base = pathPosix.basename(trimmed);
+  keys.add(normalizeWikiName(base));
+  keys.add(normalizeWikiName(stripWikiMdExt(base)));
+  keys.add(base.toLowerCase());
+  keys.add(stripWikiMdExt(base).toLowerCase());
+}
+
+/** Build lookup keys used to decide whether a destination is about the source. */
+export function buildSourceRelevanceKeys(input: {
+  relPath: string;
+  title: string | null | undefined;
+}): Set<string> {
+  const keys = new Set<string>();
+  addKey(keys, input.relPath);
+  addKey(keys, input.relPath.normalize("NFC"));
+  addKey(keys, input.relPath.normalize("NFD"));
+  if (input.title) {
+    addKey(keys, input.title);
+    addKey(keys, input.title.normalize("NFC"));
+    addKey(keys, input.title.normalize("NFD"));
+  }
+  return keys;
+}
+
+/**
+ * Normalize a destination token into candidate equality keys (exact only).
+ */
+export function destinationRelevanceCandidates(destination: string): string[] {
+  const trimmed = destination.trim();
+  if (!trimmed) return [];
+
+  const { path: withoutAngles } = stripAngleBracketDestination(trimmed);
+  const unescaped = unescapeCommonMarkDestination(withoutAngles);
+  const withoutQueryFrag = stripQueryAndFragment(unescaped);
+  const decoded = safeDecodeForRelevance(withoutQueryFrag);
+
+  const forms = [
+    trimmed,
+    withoutAngles,
+    unescaped,
+    withoutQueryFrag,
+    decoded,
+    withoutQueryFrag.normalize("NFC"),
+    withoutQueryFrag.normalize("NFD"),
+    decoded.normalize("NFC"),
+    decoded.normalize("NFD"),
+  ];
+
+  const keys = new Set<string>();
+  for (const form of forms) {
+    addKey(keys, form);
+  }
+  return [...keys];
+}
+
+/**
+ * Exact-token relevance: true only when a normalized destination key equals a
+ * source key. Malformed prefixes may still match when the prefix token itself
+ * equals a source key (bounded exact equality, not substring).
+ */
+export function isRelevantDestination(
+  destination: string,
+  sourceKeys: ReadonlySet<string>
+): boolean {
+  const candidates = destinationRelevanceCandidates(destination);
+  return candidates.some((key) => sourceKeys.has(key));
+}
+
+/**
+ * Content-prefilter needle strings for SQL LIKE (caller escapes wildcards).
+ * Conservative: source path/title identities and common escape encodings.
+ */
+export function buildContentPrefilterNeedles(input: {
+  relPath: string;
+  title: string | null | undefined;
+}): string[] {
+  const needles = new Set<string>();
+  const add = (value: string): void => {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.length < 2) return;
+    needles.add(trimmed);
+    needles.add(trimmed.normalize("NFC"));
+    needles.add(trimmed.normalize("NFD"));
+    needles.add(trimmed.replaceAll(" ", "%20"));
+    needles.add(
+      trimmed
+        .replaceAll(" ", "%20")
+        .replaceAll("(", "%28")
+        .replaceAll(")", "%29")
+    );
+    needles.add(trimmed.replaceAll("(", "%28").replaceAll(")", "%29"));
+    needles.add(
+      trimmed
+        .replaceAll(" ", "\\ ")
+        .replaceAll("(", "\\(")
+        .replaceAll(")", "\\)")
+    );
+    needles.add(trimmed.replaceAll("(", "\\(").replaceAll(")", "\\)"));
+  };
+
+  add(input.relPath);
+  add(pathPosix.basename(input.relPath));
+  add(stripWikiMdExt(pathPosix.basename(input.relPath)));
+  add(stripWikiMdExt(input.relPath));
+  if (input.title) {
+    add(input.title);
+    add(`${input.title}.md`);
+  }
+  return [...needles].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+}

package/src/ingestion/strip.ts

@@ -3,7 +3,7 @@
  *
  * Identifies regions to exclude from link/tag extraction:
  * - YAML frontmatter
- * - Fenced code blocks
+ * - Fenced code blocks (CommonMark backtick and tilde fences)
  * - Inline code
  * - HTML comments
  *
@@ -39,15 +39,153 @@ export interface ExcludedRange {
 /** Frontmatter at start of file (YAML between --- delimiters) */
 const FRONTMATTER_REGEX = /^---\r?\n[\s\S]*?(?:\r?\n)?---(?:\r?\n|$)/;
 
-/** Fenced code blocks (``` with optional language) */
-const FENCED_CODE_REGEX = /^```[^\n]*\n[\s\S]*?^```/gm;
+/** CommonMark fence opener: 0–3 spaces, then 3+ backticks or tildes + info. */
+const FENCE_OPEN_REGEX = /^ {0,3}(`{3,}|~{3,})(.*)$/u;
 
-/** Inline code (backticks, non-greedy) */
-const INLINE_CODE_REGEX = /`[^`\n]+`/g;
+/** CommonMark fence closer: matching character, length ≥ opener, trailing space/tabs only. */
+const FENCE_CLOSE_REGEX = /^ {0,3}(`{3,}|~{3,})[\t ]*$/u;
 
 /** HTML comments */
 const HTML_COMMENT_REGEX = /<!--[\s\S]*?-->/g;
 
+interface OpenFence {
+  marker: "`" | "~";
+  length: number;
+  start: number;
+}
+
+/**
+ * Collect CommonMark fenced code ranges (backtick and tilde). A closer must
+ * use the same character and be at least as long as the opener; when omitted,
+ * CommonMark extends the fenced block through end of input.
+ */
+const collectFencedCodeRanges = (markdown: string): ExcludedRange[] => {
+  const ranges: ExcludedRange[] = [];
+  let offset = 0;
+  let open: OpenFence | null = null;
+
+  while (offset <= markdown.length) {
+    const nextNl = markdown.indexOf("\n", offset);
+    const lineEnd = nextNl === -1 ? markdown.length : nextNl;
+    const rawLine = markdown.slice(offset, lineEnd);
+    const logical = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+
+    if (open) {
+      const closeRun = FENCE_CLOSE_REGEX.exec(logical)?.[1];
+      if (
+        closeRun &&
+        closeRun[0] === open.marker &&
+        closeRun.length >= open.length
+      ) {
+        const end = nextNl === -1 ? markdown.length : nextNl + 1;
+        ranges.push({ start: open.start, end, kind: "fenced_code" });
+        open = null;
+      }
+    } else {
+      const openMatch = FENCE_OPEN_REGEX.exec(logical);
+      const run = openMatch?.[1];
+      const suffix = openMatch?.[2] ?? "";
+      // Backtick info strings cannot contain backticks (CommonMark).
+      if (run && !(run[0] === "`" && suffix.includes("`"))) {
+        open = {
+          marker: run[0] as OpenFence["marker"],
+          length: run.length,
+          start: offset,
+        };
+      }
+    }
+
+    if (nextNl === -1) break;
+    offset = nextNl + 1;
+  }
+
+  if (open) {
+    ranges.push({
+      start: open.start,
+      end: markdown.length,
+      kind: "fenced_code",
+    });
+  }
+
+  return ranges;
+};
+
+interface BacktickRun {
+  end: number;
+  length: number;
+  start: number;
+}
+
+/** CommonMark code spans close only on a backtick run of equal length. */
+const collectInlineCodeRanges = (
+  markdown: string,
+  excludedRanges: ExcludedRange[]
+): ExcludedRange[] => {
+  const runs: BacktickRun[] = [];
+  let cursor = 0;
+  let excludedIndex = 0;
+  while (cursor < markdown.length) {
+    while (
+      excludedRanges[excludedIndex] &&
+      excludedRanges[excludedIndex]!.end <= cursor
+    ) {
+      excludedIndex += 1;
+    }
+    const excluded = excludedRanges[excludedIndex];
+    if (excluded && cursor >= excluded.start && cursor < excluded.end) {
+      cursor = excluded.end;
+      continue;
+    }
+    if (markdown[cursor] !== "`") {
+      cursor += 1;
+      continue;
+    }
+    const start = cursor;
+    while (markdown[cursor] === "`") cursor += 1;
+    let backslashes = 0;
+    for (let i = start - 1; i >= 0 && markdown[i] === "\\"; i -= 1) {
+      backslashes += 1;
+    }
+    if (backslashes % 2 === 0) {
+      runs.push({ start, end: cursor, length: cursor - start });
+    }
+  }
+
+  const nextMatchingRun = Array.from<number | undefined>({
+    length: runs.length,
+  });
+  const latestByLength = new Map<number, number>();
+  for (let index = runs.length - 1; index >= 0; index -= 1) {
+    const run = runs[index];
+    if (!run) continue;
+    nextMatchingRun[index] = latestByLength.get(run.length);
+    latestByLength.set(run.length, index);
+  }
+
+  const ranges: ExcludedRange[] = [];
+  let index = 0;
+  while (index < runs.length) {
+    const closeIndex = nextMatchingRun[index];
+    const opener = runs[index];
+    if (closeIndex === undefined || !opener) {
+      index += 1;
+      continue;
+    }
+    const closer = runs[closeIndex];
+    if (!closer) {
+      index += 1;
+      continue;
+    }
+    ranges.push({
+      start: opener.start,
+      end: closer.end,
+      kind: "inline_code",
+    });
+    index = closeIndex + 1;
+  }
+  return ranges;
+};
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Main Functions
 // ─────────────────────────────────────────────────────────────────────────────
@@ -70,29 +208,12 @@ export function getExcludedRanges(markdown: string): ExcludedRange[] {
     });
   }
 
-  // 2. Fenced code blocks
-  FENCED_CODE_REGEX.lastIndex = 0;
-  let match: RegExpExecArray | null;
-  while ((match = FENCED_CODE_REGEX.exec(markdown)) !== null) {
-    ranges.push({
-      start: match.index,
-      end: match.index + match[0].length,
-      kind: "fenced_code",
-    });
-  }
-
-  // 3. Inline code
-  INLINE_CODE_REGEX.lastIndex = 0;
-  while ((match = INLINE_CODE_REGEX.exec(markdown)) !== null) {
-    ranges.push({
-      start: match.index,
-      end: match.index + match[0].length,
-      kind: "inline_code",
-    });
-  }
+  // 2. Fenced code blocks (backtick + tilde, CommonMark matching rules)
+  ranges.push(...collectFencedCodeRanges(markdown));
 
-  // 4. HTML comments
+  // 3. HTML comments
   HTML_COMMENT_REGEX.lastIndex = 0;
+  let match: RegExpExecArray | null;
   while ((match = HTML_COMMENT_REGEX.exec(markdown)) !== null) {
     ranges.push({
       start: match.index,
@@ -101,6 +222,11 @@ export function getExcludedRanges(markdown: string): ExcludedRange[] {
     });
   }
 
+  // 4. Inline code. Pair delimiters only in visible prose so unmatched
+  // backticks inside already-excluded blocks cannot consume later content.
+  ranges.sort((a, b) => a.start - b.start);
+  ranges.push(...collectInlineCodeRanges(markdown, ranges));
+
   // Sort by start position for efficient lookup
   ranges.sort((a, b) => a.start - b.start);
 

package/src/mcp/tools/index.ts

@@ -95,6 +95,10 @@ import {
   handleDuplicateNote,
   handleMoveNote,
   handleRenameNote,
+  MOVE_NOTE_MCP_ANNOTATIONS,
+  moveNoteInputSchema,
+  RENAME_NOTE_MCP_ANNOTATIONS,
+  renameNoteInputSchema,
 } from "./workspace-write";
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -398,17 +402,6 @@ const createFolderInputSchema = z.object({
   parentPath: z.string().optional(),
 });
 
-const renameNoteInputSchema = z.object({
-  ref: z.string().min(1, "ref cannot be empty"),
-  name: z.string().min(1, "name cannot be empty"),
-});
-
-const moveNoteInputSchema = z.object({
-  ref: z.string().min(1, "ref cannot be empty"),
-  folderPath: z.string().min(1, "folderPath cannot be empty"),
-  name: z.string().optional(),
-});
-
 const duplicateNoteInputSchema = z.object({
   ref: z.string().min(1, "ref cannot be empty"),
   folderPath: z.string().optional(),
@@ -1351,17 +1344,25 @@ export function registerTools(server: McpServer, ctx: ToolContext): void {
       (args) => handleCreateFolder(args, ctx)
     );
 
-    server.tool(
+    server.registerTool(
       "gno_rename_note",
-      "Rename an editable note in place.",
-      renameNoteInputSchema.shape,
+      {
+        description:
+          'Preview or apply a reference-safe rename of an editable note. Use action=preview first, then action=apply with the exact planDigest, confirmation="apply", confirm=true, and schemaVersion="1.0". Annotations are hints only; --enable-write remains authoritative.',
+        inputSchema: renameNoteInputSchema,
+        annotations: RENAME_NOTE_MCP_ANNOTATIONS,
+      },
       (args) => handleRenameNote(args, ctx)
     );
 
-    server.tool(
+    server.registerTool(
       "gno_move_note",
-      "Move an editable note to another folder in the same collection.",
-      moveNoteInputSchema.shape,
+      {
+        description:
+          'Preview or apply a reference-safe same-collection move of an editable note. Use action=preview first, then action=apply with the exact planDigest, confirmation="apply", confirm=true, and schemaVersion="1.0". Annotations are hints only; --enable-write remains authoritative.',
+        inputSchema: moveNoteInputSchema,
+        annotations: MOVE_NOTE_MCP_ANNOTATIONS,
+      },
       (args) => handleMoveNote(args, ctx)
     );