graphmark 0.8.0__tar.gz → 0.9.0__tar.gz

{graphmark-0.8.0 → graphmark-0.9.0}/CHANGELOG.md

@@ -1,6 +1,89 @@
 # CHANGELOG
 
 
+## v0.9.0 (2026-07-26)
+
+### Bug Fixes
+
+- **graph**: Normalize path-qualified links component-wise (#146)
+  ([#162](https://github.com/cdcoonce/graphmark/pull/162),
+  [`a6cc158`](https://github.com/cdcoonce/graphmark/commit/a6cc1587cdbcf28a6b5360e2bec627a8df8f20c1))
+
+Bare resolution went through `_normalize` — NFC, lowercase, punctuation and symbols folded — while
+  path resolution went through `_fold_case`, which folds only case and Unicode form. So `[[Q1 -
+  Review]]` found `Q1 — Review.md` but `[[notes/Q1 - Review]]` did not: the same title reachable or
+  not depending on whether the writer happened to qualify the link with a folder.
+
+Both branches now compare **path components**, each through the one normalizer: the display's
+  components must be a suffix of the candidate's. That subsumes #136's boundary rule rather than
+  restating it — a suffix over lists cannot match mid-component — while letting every punctuation
+  equivalence `_normalize` already absorbs work in both branches.
+
+The trap: `/` is structural. `[[a/b]]` must never reach `a-b.md`, even though `a/b` and `a-b`
+  normalize alike once a separator is folded. Components are normalized individually and the
+  separator is never one of them. Tested in both directions, and those tests passed BEFORE the
+  change — they are the guard, not the feature.
+
+The index now buckets by normalized final component and caches each path's components, so
+  per-component normalization runs once per note rather than once per link.
+
+Reference vault A/B'd on one snapshot: byte-identical (6230 resolved, 3725 edges, 0 unresolved).
+  blue-book markdown counts identical; build 267 -> 393 ms, still 7x better than the 2718 ms this
+  session started from.
+
+### Features
+
+- **graph**: Add the markdown-autolinks dialect (#156)
+  ([#163](https://github.com/cdcoonce/graphmark/pull/163),
+  [`5ccf527`](https://github.com/cdcoonce/graphmark/commit/5ccf527576037915bd12485d205f2c7bf63b1c7f))
+
+A markdown link is a relative path, but the widely-used mkdocs-autolinks plugin resolves a BARE
+  filename anywhere in the tree. blue-book runs it: 5.8% of its links resolve strictly, 92.7% by
+  name, 1.5% by neither.
+
+Added as an explicit fourth `link_syntax` value, NOT a fallback. Trying a second rule when the first
+  fails is the shape of #136 — a quiet extra rule producing an edge to a note the link does not name
+  — and the 1.5% that match neither dialect show a fallback would not even have been complete. The
+  vault owner states which renderer they use, exactly as they already state their scope.
+
+Only BARE targets take the plugin's rule; a target containing "/" keeps the relative rule in this
+  mode too, so a wrong qualified path is never rescued by a filename match elsewhere. Bare names go
+  through the existing catalog lookup, so ambiguity is refused exactly as it always was — no dialect
+  may invent a resolution.
+
+blue-book, markdown -> markdown-autolinks: resolved 591 (5.8%) -> 10,001 (98.5%), edges 430 -> 4878,
+  orphans 790 -> 106, ambiguous 0, missing 9558 -> 148. Also faster (356 -> 234 ms): a bare name
+  hits the catalog dict instead of the path index.
+
+
+## v0.8.1 (2026-07-26)
+
+### Performance Improvements
+
+- **graph**: Index path resolution by filename instead of scanning (#157)
+  ([#160](https://github.com/cdcoonce/graphmark/pull/160),
+  [`84cdd29`](https://github.com/cdcoonce/graphmark/commit/84cdd297a665d93ffa3cbb988c18550ea57f5c94))
+
+Every path-qualified display flattened the catalog and compared against every rel_path. That ceiling
+  was documented and accepted while the branch was rare — most wikilink displays are bare names
+  hitting a dict — but #152 made it the only branch, since every markdown link is path-qualified by
+  construction. blue-book (1120 notes, 10,149 markdown links) took 2.7 s against 0.25 s for the same
+  vault read as wikilinks.
+
+A legal suffix match must consume whole path components, so a candidate's last component always
+  equals the display's last plus ".md". Bucketing by that filename is exactly equivalent to scanning
+  — same matches, same order, same verdicts.
+
+The first attempt was no faster, and profiling rather than guessing found why: `_diagnose` consults
+  the in-scope catalog AND the out-of-scope one for the same display, so a single-slot cache
+  alternated and missed every time — 29,265 index rebuilds for 10,149 links. The cache is now
+  bounded-multi-slot, and it holds each catalog rather than just its id(), so a freed dict cannot
+  have its address reused under a stale index.
+
+blue-book markdown: 2718 ms -> 267 ms (10.2x), now level with wikilink mode. Reference vault 195 ->
+  181 ms. All link counts byte-identical in every mode.
+
+
 ## v0.8.0 (2026-07-26)
 
 ### Documentation

{graphmark-0.8.0 → graphmark-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphmark
-Version: 0.8.0
+Version: 0.9.0
 Summary: Deterministic knowledge-graph analysis for markdown / [[wikilink]] vaults.
 Project-URL: Homepage, https://github.com/cdcoonce/graphmark
 Project-URL: Repository, https://github.com/cdcoonce/graphmark
@@ -119,7 +119,7 @@ graph, so set `link_syntax`:
 
 ```toml
 root = "."
-link_syntax = "both"   # "wikilink" (default) | "markdown" | "both"
+link_syntax = "both"   # "wikilink" (default) | "markdown" | "both" | "markdown-autolinks"
 ```
 
 The two resolve differently, and the difference is not cosmetic:
@@ -129,6 +129,12 @@ The two resolve differently, and the difference is not cosmetic:
 - a **markdown** link is a path **relative to the linking note** — `[x](../other/b.md)` means that
   file and nothing else, so the same filename in two folders is not ambiguous at all.
 
+`markdown-autolinks` is `markdown` with the [mkdocs-autolinks](https://github.com/zachhannum/mkdocs-autolinks-plugin)
+plugin's rule for **bare** targets: `[tdd](tdd.md)` names a note anywhere in the tree, not a sibling
+file. Set it only if your site actually runs that plugin — it is never applied as a fallback, because
+a second rule tried after the first fails is how a link ends up pointing at a note it does not name.
+A target that contains `/` keeps the relative rule in this mode too.
+
 If your links are in a syntax graphmark is not reading, it says so on stderr rather than reporting a
 confidently empty graph:
 

{graphmark-0.8.0 → graphmark-0.9.0}/README.md

@@ -91,7 +91,7 @@ graph, so set `link_syntax`:
 
 ```toml
 root = "."
-link_syntax = "both"   # "wikilink" (default) | "markdown" | "both"
+link_syntax = "both"   # "wikilink" (default) | "markdown" | "both" | "markdown-autolinks"
 ```
 
 The two resolve differently, and the difference is not cosmetic:
@@ -101,6 +101,12 @@ The two resolve differently, and the difference is not cosmetic:
 - a **markdown** link is a path **relative to the linking note** — `[x](../other/b.md)` means that
   file and nothing else, so the same filename in two folders is not ambiguous at all.
 
+`markdown-autolinks` is `markdown` with the [mkdocs-autolinks](https://github.com/zachhannum/mkdocs-autolinks-plugin)
+plugin's rule for **bare** targets: `[tdd](tdd.md)` names a note anywhere in the tree, not a sibling
+file. Set it only if your site actually runs that plugin — it is never applied as a fallback, because
+a second rule tried after the first fails is how a link ends up pointing at a note it does not name.
+A target that contains `/` keeps the relative rule in this mode too.
+
 If your links are in a syntax graphmark is not reading, it says so on stderr rather than reporting a
 confidently empty graph:
 

{graphmark-0.8.0 → graphmark-0.9.0}/docs/ROADMAP.md

@@ -243,7 +243,7 @@ Evaluated against the ecosystem and dropped for zero consumer pull; do not re-li
   10,149 of them and zero extracted edges. Config-gated (`link_syntax`), default unchanged,
   `Resolver` untouched. Note what it did *not* do: blue-book resolves 5.8% by strict relative path
   and 92.7% by basename-anywhere (it runs `mkdocs-autolinks`), and no fallback was slipped in —
-  silently trying a second rule when the first fails is the shape of #136. The dialect is #156.
+  silently trying a second rule when the first fails is the shape of #136. The dialect shipped too (#156), as an explicit fourth value rather than a fallback: blue-book goes from 5.8% to **98.5%** resolved, 430 to 4878 edges, 790 to 106 orphans, with ambiguity still refused at 0.
 - Re-platforming (no swapping networkx; no async/parallel rewrites).
 - Performance work without a benchmark showing pain (the live consumer is a ~340-note vault). The
   known ceilings — O(L·N) path-suffix resolution, O(A·(V+E)) `siloed_notes`, per-metric graph

{graphmark-0.8.0 → graphmark-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "graphmark"
-version = "0.8.0"
+version = "0.9.0"
 description = "Deterministic knowledge-graph analysis for markdown / [[wikilink]] vaults."
 readme = "README.md"
 requires-python = ">=3.11"

{graphmark-0.8.0 → graphmark-0.9.0}/src/graphmark/config.py

@@ -13,7 +13,7 @@ from pathlib import Path
 
 #: Every value ``VaultConfig.link_syntax`` accepts. A consumer may switch on these, so the set is
 #: part of the config contract.
-LINK_SYNTAXES = frozenset({"wikilink", "markdown", "both"})
+LINK_SYNTAXES = frozenset({"wikilink", "markdown", "both", "markdown-autolinks"})
 
 
 @dataclass(frozen=True)
@@ -55,7 +55,10 @@ class VaultConfig:
     #: what every frozen fixture encodes, so the default keeps existing behavior byte-identical.
     #: ``"markdown"`` reads ``[text](note.md)``, the syntax non-Obsidian markdown vaults use — added
     #: on demand after a corpus vault turned out to have 11,198 of them and zero extracted edges.
-    #: ``"both"`` reads each, which is what Obsidian itself accepts.
+    #: ``"both"`` reads each, which is what Obsidian itself accepts. ``"markdown-autolinks"`` is
+    #: ``"markdown"`` with the widely-used mkdocs plugin's rule for **bare** targets: a filename
+    #: with no ``/`` names a note anywhere in the tree rather than a sibling file. Stated by the
+    #: vault owner, never guessed — see the note on ``_resolve_markdown_target``.
     link_syntax: str = "wikilink"
     check: CheckPolicy = field(default_factory=CheckPolicy)
 

{graphmark-0.8.0 → graphmark-0.9.0}/src/graphmark/graph.py

@@ -110,22 +110,36 @@ def _targets_non_note_file(display: str) -> bool:
     return bool(match) and match.group(0).lower() != ".md"
 
 
-def _matches_path_suffix(rel_path: str, suffix: str) -> bool:
-    """True when ``rel_path`` ends with ``suffix`` **on a path-component boundary**.
+def _path_components(name: str) -> tuple[str, ...]:
+    """A path split on ``/``, each component through ``_normalize``, ``.md`` dropped.
+
+    This is what makes path-qualified links normalize like bare ones. They used to fold only case
+    and Unicode form, so ``[[Q1 - Review]]`` found ``Q1 — Review.md`` while
+    ``[[notes/Q1 - Review]]`` did not — the same title reachable or not depending on whether the
+    writer happened to qualify it with a folder.
+
+    Components are normalized **individually** and the separator is never one of them, which is what
+    keeps ``/`` structural: ``[[a/b]]`` yields ``("a", "b")`` and can never reach ``a-b.md``, whose
+    single component is ``"a b"``. That distinction is the whole reason this is a tuple rather than
+    a normalized string.
+
+    A component that normalizes to empty — a trailing slash, or pure punctuation — is kept as
+    ``""``. No real path component ever normalizes to empty, so such a display matches nothing,
+    which is the conservative answer.
+    """
+    name = name[: -len(".md")] if name.lower().endswith(".md") else name
+    return tuple(_normalize(part) for part in name.split("/"))
+
 
-    ``suffix`` is a lowercased ``folder/note.md``. A raw ``str.endswith`` is not enough: it accepts
-    ``homework/Tasks.md`` for ``[[work/Tasks]]``, because nothing requires the character before the
-    match to be a separator. That produced an edge to the wrong note — silently, since the link then
-    counts as ``resolved`` — and, when the real folder also existed, a spurious second match that
-    made the resolver decline a correct link.
+def _names_path(candidate: tuple[str, ...], display: tuple[str, ...]) -> bool:
+    """True when ``display``'s components are a suffix of ``candidate``'s.
 
-    The match is legal only when it consumes the whole rel_path or is preceded by ``/``.
+    Subsumes the boundary rule #136 added: a suffix over *lists* cannot match mid-component, so
+    ``[[work/Tasks]]`` cannot reach ``homework/Tasks.md`` — ``("homework", "tasks")`` does not end
+    with ``("work", "tasks")``. The string-suffix version accepted it, silently producing an edge
+    to the wrong note.
     """
-    lowered = _fold_case(rel_path)
-    if not lowered.endswith(suffix):
-        return False
-    rest = len(lowered) - len(suffix)
-    return rest == 0 or lowered[rest - 1] == "/"
+    return bool(display) and "" not in display and candidate[-len(display) :] == display
 
 
 def candidates_for(display: str, catalog: dict[str, list[str]]) -> list[str]:
@@ -143,13 +157,7 @@ def candidates_for(display: str, catalog: dict[str, list[str]]) -> list[str]:
     if not target:
         return []
     if "/" in target:
-        suffix = _fold_case(target) + ".md"
-        return sorted(
-            path
-            for paths in catalog.values()
-            for path in paths
-            if _matches_path_suffix(path, suffix)
-        )
+        return sorted(_path_matches(target, catalog, _CANDIDATE_INDEX))
     return list(catalog.get(_normalize(target), ()))
 
 
@@ -217,25 +225,85 @@ def build_catalog(docs: list[Document]) -> dict[str, list[str]]:
     return catalog
 
 
+#: A normalized final component → the paths ending with it, each paired with its precomputed
+#: components. Precomputing means the per-component normalization runs once per note, not per link.
+_Buckets = dict[str, list[tuple[str, tuple[str, ...]]]]
+
+
+class _FilenameIndex:
+    """Catalog paths bucketed by normalized final component, so a path link scans a bucket.
+
+    A match requires the display's components to be a suffix of the candidate's
+    (``_names_path``), so a candidate's **last** component always equals the display's last.
+    Bucketing by it is therefore *exactly* equivalent to scanning every path — same matches, same
+    order — while turning an O(N) sweep into a dict lookup over a bucket almost always one deep.
+
+    Components are cached alongside each path, so the per-component normalization happens once per
+    note rather than once per link.
+
+    This mattered little while path-qualified links were rare: most wikilink displays are bare names
+    hitting the catalog dict directly, which is why the ``O(L·N)`` ceiling was documented and
+    accepted. #152 changed which branch is hot — every markdown link is path-qualified by
+    construction — and a 1120-note vault with 10,149 of them took 2.9 s against 0.3 s for the same
+    vault read as wikilinks.
+
+    Keyed by catalog identity, which is safe because a catalog is invariant for a whole
+    ``VaultGraph.build()``. Each catalog is **held**, not just its ``id()``: without a reference the
+    dict could be freed and a new one allocated at the same address, and the stale index would then
+    answer for it.
+
+    Several slots, not one, and that is load-bearing rather than defensive. ``_diagnose`` consults
+    two different mappings for the same display — the in-scope ``catalog`` and the ``out_of_scope``
+    one — so a single slot alternates between them and misses *every* time. Measured: a single-slot
+    version rebuilt the index 29,265 times for 10,149 links and was no faster than the scan it
+    replaced. The cap keeps this from growing without bound if a caller cycles through catalogs.
+    """
+
+    #: Enough for the two mappings a build alternates between, with room to spare. Small on purpose:
+    #: this holds catalogs alive, so it must not become an unbounded retainer.
+    _MAX_SLOTS = 4
+
+    def __init__(self) -> None:
+        # Insertion-ordered, so the oldest entry is the one evicted.
+        self._slots: dict[int, tuple[dict[str, list[str]], _Buckets]] = {}
+
+    def for_catalog(self, catalog: dict[str, list[str]]) -> _Buckets:
+        cached = self._slots.get(id(catalog))
+        if cached is not None and cached[0] is catalog:
+            return cached[1]
+
+        buckets: _Buckets = {}
+        for paths in catalog.values():
+            for path in paths:
+                components = _path_components(path)
+                buckets.setdefault(components[-1], []).append((path, components))
+
+        if len(self._slots) >= self._MAX_SLOTS:
+            del self._slots[next(iter(self._slots))]
+        self._slots[id(catalog)] = (catalog, buckets)
+        return buckets
+
+
+def _path_matches(target: str, catalog: dict[str, list[str]], index: _FilenameIndex) -> list[str]:
+    """Every rel_path that a path-qualified ``target`` names, in catalog order."""
+    display = _path_components(target)
+    if not display or "" in display:
+        return []
+    bucket = index.for_catalog(catalog).get(display[-1], ())
+    return [path for path, components in bucket if _names_path(components, display)]
+
+
+#: Shared by ``candidates_for``, which takes a catalog rather than a resolver and so cannot reach
+#: the resolver's own index. One index per process is enough — both callers see the same catalog
+#: object for the length of a build, and a different catalog simply re-keys it.
+_CANDIDATE_INDEX = _FilenameIndex()
+
+
 class NormalizeResolver:
     """Resolves wikilink displays via normalized basename, with path-suffix fallback."""
 
     def __init__(self) -> None:
-        # Cache the flattened path list per catalog identity. catalog is invariant for a whole
-        # VaultGraph.build(), so folder-style links reuse one flatten instead of rebuilding it
-        # on every call. Keyed by id() and single-slot: a new catalog evicts the previous.
-        self._flat_cache_id: int | None = None
-        self._flat_cache: list[str] | None = None
-
-    @staticmethod
-    def _compute_flat(catalog: dict[str, list[str]]) -> list[str]:
-        return [p for paths in catalog.values() for p in paths]
-
-    def _flatten_paths(self, catalog: dict[str, list[str]]) -> list[str]:
-        if self._flat_cache_id != id(catalog) or self._flat_cache is None:
-            self._flat_cache = self._compute_flat(catalog)
-            self._flat_cache_id = id(catalog)
-        return self._flat_cache
+        self._index = _FilenameIndex()
 
     def resolve(self, display: str, catalog: dict[str, list[str]]) -> str | None:
         # Alias ("Note|alias"), anchor ("Note#Section") and an explicit ".md" extension all name
@@ -244,10 +312,10 @@ class NormalizeResolver:
         display = _strip_display(display)
 
         if "/" in display:
-            # Path-suffix resolution: find unique rel_path ending with "display.md"
-            suffix = _fold_case(display) + ".md"
-            all_paths = self._flatten_paths(catalog)
-            matches = [p for p in all_paths if _matches_path_suffix(p, suffix)]
+            # Path-suffix resolution: find unique rel_path ending with "display.md". Note that an
+            # exact whole-path hit cannot short-circuit — "work/Tasks" names both "work/Tasks.md"
+            # and "a/work/Tasks.md", and the honest answer there is to decline.
+            matches = _path_matches(display, catalog, self._index)
             return matches[0] if len(matches) == 1 else None
 
         # Bare-link resolution: normalize and look up in catalog
@@ -465,8 +533,20 @@ def diagnose(graph: VaultGraph, display: str, *, suggest: int = 0) -> LinkDiagno
     return diagnosis
 
 
-def resolve_relative_target(target: str, source_rel_path: str) -> str | None:
-    """Turn a markdown link's relative target into a vault-relative path, or ``None``.
+def resolve_markdown_target(
+    target: str, source_rel_path: str, *, autolinks: bool = False
+) -> str | None:
+    """Turn a markdown link's target into something the resolver can match, or ``None``.
+
+    With ``autolinks``, a **bare** target — a filename with no ``/`` — is handed through unchanged
+    so the ordinary name-based rule finds it anywhere in the tree. That is the `mkdocs-autolinks`
+    plugin's behavior, and it is **opt-in rather than a fallback**: trying a second rule when the
+    first fails is the shape of #136, where a quiet extra rule produced an edge to a note the link
+    did not name. A target that *is* path-qualified keeps the relative rule even in this mode, so
+    a wrong qualified path is never rescued by a filename match elsewhere.
+
+    Measured on `lyz-code/blue-book`, which runs the plugin: 5.8% of its links resolve strictly,
+    92.7% by name, 1.5% by neither — so a fallback would not even have been complete.
 
     A markdown target is a **path**, not a name: ``[x](../other/b.md)`` means "the file at that
     location relative to me". That is the first resolution rule in this package that depends on
@@ -484,10 +564,13 @@ def resolve_relative_target(target: str, source_rel_path: str) -> str | None:
     is a separate decision, not a fallback to slip in here — silently trying a second rule when the
     first fails is how a link resolves to the wrong note.
 
-    ``None`` for a target that escapes the vault root. That is not an error and not a resolution —
+    Without ``autolinks``, or for any target containing ``/``: ``None`` when the target escapes the
+    vault root. That is not an error and not a resolution —
     a link out of the vault names no note in the graph, so it is reported ``missing`` like any other
     target that is not there.
     """
+    if autolinks and "/" not in target:
+        return target
     combined = PurePosixPath(source_rel_path).parent / target
     normalized = posixpath.normpath(str(combined))
     # normpath leaves leading "..", which is the only way to express "above the root".
@@ -627,14 +710,15 @@ class VaultGraph:
         # pre-processing: a wikilink display is a *name*, a markdown target is a *path relative to
         # the linking note*, and only the latter can be normalized once the source note is known.
         read_wikilinks = config.link_syntax in ("wikilink", "both")
-        read_markdown = config.link_syntax in ("markdown", "both")
+        read_markdown = config.link_syntax in ("markdown", "both", "markdown-autolinks")
+        autolinks = config.link_syntax == "markdown-autolinks"
         md_extractor = MarkdownLinkExtractor() if read_markdown else None
 
         for doc in docs:
             displays = list(extractor.extract(doc.text)) if read_wikilinks else []
             if md_extractor is not None:
                 for target in md_extractor.extract(doc.text):
-                    resolved = resolve_relative_target(target, doc.rel_path)
+                    resolved = resolve_markdown_target(target, doc.rel_path, autolinks=autolinks)
                     # A target above the vault root names no note here. Kept in the stream as the
                     # raw target so it is counted and reported `missing`, never silently dropped —
                     # the conservation law holds for every syntax that is read.

graphmark-0.9.0/tests/test_autolinks.py

@@ -0,0 +1,130 @@
+"""The mkdocs-autolinks dialect: a bare markdown target resolves by name (#156).
+
+A markdown link is a *relative path* — `[tdd](tdd.md)` from `docs/architecture/x.md` means
+`docs/architecture/tdd.md` and nothing else. But the widely-used `mkdocs-autolinks` plugin resolves
+a bare filename **anywhere in the tree**, so the same link reaches `docs/coding/tdd.md`. Measured on
+`lyz-code/blue-book`, which runs that plugin: 5.8% of its links resolve strictly, 92.7% by name.
+
+This is an explicit fourth `link_syntax` value, **not a fallback**. Trying a second rule when the
+first fails is the shape of #136 — a rule that quietly produces an edge to a note the link does not
+name — and the 1.5% that match neither dialect show a fallback would not even be complete. The vault
+owner states which renderer they use, exactly as they already state their scope.
+
+A bare name goes to the *existing* wikilink rule, so ambiguity is refused the same way it
+always was: no dialect may invent a resolution.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from graphmark.config import VaultConfig
+from graphmark.graph import NormalizeResolver, VaultGraph
+from graphmark.parse import WikilinkExtractor
+
+
+def _write(root: Path, rel: str, text: str = "") -> None:
+    path = root / rel
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text, encoding="utf-8")
+
+
+def _build(root: Path, **kw) -> VaultGraph:
+    return VaultGraph.build(VaultConfig(root=root, **kw), WikilinkExtractor(), NormalizeResolver())
+
+
+class TestBareTargetsResolveByName:
+    def test_a_bare_target_reaches_a_note_elsewhere_in_the_tree(self, tmp_path):
+        # blue-book's shape: [tdd](tdd.md) from docs/architecture/ reaching docs/coding/tdd.md.
+        _write(tmp_path, "docs/coding/tdd.md")
+        _write(tmp_path, "docs/architecture/x.md", "[tdd](tdd.md)\n")
+        graph = _build(tmp_path, link_syntax="markdown-autolinks")
+        assert graph.out_links["docs/architecture/x.md"] == {"docs/coding/tdd.md"}
+        assert graph.link_counts["missing"] == 0
+
+    def test_strict_markdown_still_reports_that_link_missing(self, tmp_path):
+        _write(tmp_path, "docs/coding/tdd.md")
+        _write(tmp_path, "docs/architecture/x.md", "[tdd](tdd.md)\n")
+        assert _build(tmp_path, link_syntax="markdown").link_counts["missing"] == 1
+
+    def test_a_sibling_target_still_resolves(self, tmp_path):
+        _write(tmp_path, "docs/b.md")
+        _write(tmp_path, "docs/a.md", "[b](b.md)\n")
+        assert _build(tmp_path, link_syntax="markdown-autolinks").out_links["docs/a.md"] == {
+            "docs/b.md"
+        }
+
+    def test_the_name_normalizes_like_any_other(self, tmp_path):
+        _write(tmp_path, "docs/coding/Q1 — Review.md")
+        _write(tmp_path, "x.md", "[q](Q1%20-%20Review.md)\n")
+        assert _build(tmp_path, link_syntax="markdown-autolinks").unresolved == {}
+
+
+class TestAmbiguityIsStillRefused:
+    def test_a_name_claimed_by_two_notes_is_ambiguous(self, tmp_path):
+        # The rule this dialect must not break: no dialect may invent a resolution.
+        _write(tmp_path, "one/note.md")
+        _write(tmp_path, "two/note.md")
+        _write(tmp_path, "x.md", "[n](note.md)\n")
+        graph = _build(tmp_path, link_syntax="markdown-autolinks")
+        assert graph.link_counts["ambiguous"] == 1
+        assert graph.out_links["x.md"] == set()
+
+    def test_a_name_that_exists_nowhere_is_missing(self, tmp_path):
+        _write(tmp_path, "x.md", "[gone](nowhere.md)\n")
+        assert _build(tmp_path, link_syntax="markdown-autolinks").link_counts["missing"] == 1
+
+
+class TestPathQualifiedTargetsStayRelative:
+    def test_a_target_with_a_slash_uses_the_relative_rule(self, tmp_path):
+        # Only *bare* names get the plugin's behavior; a qualified target still means what it says.
+        _write(tmp_path, "docs/deep/other/b.md")
+        _write(tmp_path, "docs/deep/a.md", "[b](other/b.md)\n")
+        assert _build(tmp_path, link_syntax="markdown-autolinks").out_links["docs/deep/a.md"] == {
+            "docs/deep/other/b.md"
+        }
+
+    def test_a_qualified_target_that_is_wrong_is_not_rescued_by_name(self, tmp_path):
+        # The anti-fallback assertion: "elsewhere/b.md" names no note here, and the fact that a
+        # b.md exists somewhere must NOT rescue it. That rescue is exactly the #136 shape.
+        _write(tmp_path, "docs/coding/b.md")
+        _write(tmp_path, "docs/a.md", "[b](elsewhere/b.md)\n")
+        graph = _build(tmp_path, link_syntax="markdown-autolinks")
+        assert graph.link_counts["missing"] == 1
+        assert graph.out_links["docs/a.md"] == set()
+
+    def test_a_parent_relative_target_still_resolves(self, tmp_path):
+        _write(tmp_path, "docs/other/b.md")
+        _write(tmp_path, "docs/deep/a.md", "[b](../other/b.md)\n")
+        assert _build(tmp_path, link_syntax="markdown-autolinks").out_links["docs/deep/a.md"] == {
+            "docs/other/b.md"
+        }
+
+
+class TestOtherModesUnchanged:
+    def test_wikilinks_are_not_read_in_this_mode(self, tmp_path):
+        _write(tmp_path, "b.md")
+        _write(tmp_path, "a.md", "[[b]]\n")
+        assert _build(tmp_path, link_syntax="markdown-autolinks").out_links["a.md"] == set()
+
+    def test_the_default_is_still_wikilink(self, tmp_path):
+        _write(tmp_path, "b.md")
+        _write(tmp_path, "a.md", "[b](b.md)\n[[b]]\n")
+        graph = _build(tmp_path)
+        assert graph.link_counts["resolved"] == 1
+
+
+class TestConfig:
+    def test_it_is_an_accepted_syntax(self, tmp_path):
+        from graphmark.config import LINK_SYNTAXES
+
+        assert "markdown-autolinks" in LINK_SYNTAXES
+
+    def test_it_loads_from_toml(self, tmp_path):
+        from graphmark.config import load_config
+
+        cfg = tmp_path / "v.toml"
+        cfg.write_text(
+            f'root = "{tmp_path}"\nlink_syntax = "markdown-autolinks"\n', encoding="utf-8"
+        )
+        assert load_config(cfg).link_syntax == "markdown-autolinks"

{graphmark-0.8.0 → graphmark-0.9.0}/tests/test_graph.py

@@ -91,19 +91,15 @@ class TestNormalizeResolver:
         assert self.resolver.resolve("brain/alpha", catalog) == "brain/alpha.md"
         assert self.resolver.resolve("work/gamma", catalog) == "work/gamma.md"
 
-    def test_flatten_runs_once_per_catalog(self, monkeypatch):
+    def test_the_path_index_is_built_once_per_catalog(self):
+        # Was written against the flatten this replaced (#157); the property is the same one and
+        # still worth holding — the O(n) precompute must not run per link.
         catalog = self._catalog("brain/alpha.md", "personal/beta.md")
-        calls = {"n": 0}
-        real_compute = NormalizeResolver._compute_flat
-
-        def counting_compute(cat):
-            calls["n"] += 1
-            return real_compute(cat)
-
-        monkeypatch.setattr(self.resolver, "_compute_flat", counting_compute)
+        self.resolver.resolve("brain/alpha", catalog)
+        buckets = self.resolver._index.for_catalog(catalog)
         for _ in range(5):
             self.resolver.resolve("brain/alpha", catalog)
-        assert calls["n"] == 1  # the O(n) flatten runs once, reused for the rest
+        assert self.resolver._index.for_catalog(catalog) is buckets
 
     def test_new_catalog_triggers_reflatten(self):
         cat1 = self._catalog("brain/alpha.md")