graphmark 0.1.0__py3-none-any.whl

graphmark/__init__.py

@@ -0,0 +1,3 @@
+"""graphmark — deterministic knowledge-graph analysis for markdown/wikilink vaults."""
+
+__version__ = "0.1.0"

graphmark/cli.py

@@ -0,0 +1,101 @@
+"""Command-line interface for graphmark."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from graphmark.config import VaultConfig, load_config
+from graphmark.export import to_dot, to_json
+from graphmark.graph import NormalizeResolver, VaultGraph
+from graphmark.metrics import (
+    bridges,
+    clusters,
+    gaps,
+    hubs,
+    neighborhood,
+    orphans,
+    pagerank,
+    siloed_notes,
+    stats,
+)
+from graphmark.parse import WikilinkExtractor
+
+
+def _load(args: argparse.Namespace) -> tuple[VaultGraph, VaultConfig]:
+    if args.config is not None:
+        config = load_config(Path(args.config))
+        if args.root is not None:
+            config.root = Path(args.root)
+    elif args.root is not None:
+        config = VaultConfig(root=Path(args.root))
+    else:
+        print("error: --config or --root required", file=sys.stderr)
+        sys.exit(1)
+    graph = VaultGraph.build(config, WikilinkExtractor(), NormalizeResolver())
+    return graph, config
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="graphmark")
+    parser.add_argument("--config", metavar="PATH", help="TOML config file")
+    parser.add_argument("--root", metavar="PATH", help="Vault root (overrides --config root)")
+
+    sub = parser.add_subparsers(dest="command")
+
+    sub.add_parser("stats")
+    sub.add_parser("orphans")
+
+    hubs_p = sub.add_parser("hubs")
+    hubs_p.add_argument("--n", type=int, default=10)
+
+    sub.add_parser("clusters")
+    sub.add_parser("bridges")
+    sub.add_parser("siloed")
+
+    nb_p = sub.add_parser("neighborhood")
+    nb_p.add_argument("--note", required=True)
+    nb_p.add_argument("--depth", type=int, default=1)
+
+    pr_p = sub.add_parser("pagerank")
+    pr_p.add_argument("--n", type=int, default=10)
+    pr_p.add_argument("--alpha", type=float, default=0.85)
+
+    exp_p = sub.add_parser("export")
+    exp_p.add_argument("format", choices=["dot"])
+
+    sub.add_parser("gaps")
+
+    args = parser.parse_args()
+
+    if args.command is None:
+        parser.print_help()
+        sys.exit(1)
+
+    graph, config = _load(args)
+
+    if args.command == "stats":
+        print(to_json(stats(graph)))
+    elif args.command == "orphans":
+        print(to_json(orphans(graph, config)))
+    elif args.command == "hubs":
+        print(to_json(hubs(graph, n=args.n)))
+    elif args.command == "clusters":
+        print(to_json(clusters(graph)))
+    elif args.command == "bridges":
+        print(to_json(bridges(graph)))
+    elif args.command == "siloed":
+        print(to_json(siloed_notes(graph)))
+    elif args.command == "neighborhood":
+        print(to_json(neighborhood(graph, args.note, depth=args.depth)))
+    elif args.command == "pagerank":
+        print(to_json(pagerank(graph, n=args.n, alpha=args.alpha)))
+    elif args.command == "export" and args.format == "dot":
+        print(to_dot(graph))
+    elif args.command == "gaps":
+        print(to_json(gaps(graph, lambda _rel, _k: [])))
+
+
+if __name__ == "__main__":
+    main()

graphmark/config.py

@@ -0,0 +1,44 @@
+"""Vault configuration — the domain seam that makes the engine general.
+
+``VaultConfig`` holds every vault-specific policy the engine consults. ``load_config`` (TOML →
+VaultConfig) is intentionally left unimplemented; wiring config through the engine is afk Issue #3.
+Fixture tests may construct ``VaultConfig`` directly.
+"""
+
+from __future__ import annotations
+
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class VaultConfig:
+    """All vault-specific behavior, parametrized."""
+
+    root: Path
+    scoped_folders: list[str] = field(default_factory=list)
+    excluded_dirs: list[str] = field(default_factory=list)
+    rules_files: list[str] = field(default_factory=lambda: ["CLAUDE.md", "CLAUDE.local.md"])
+    wikilink_pattern: str = r"\[\[(.+?)\]\]"
+    orphan_min_chars: int = 300
+    transient_prefixes: tuple[str, ...] = ()
+
+
+def load_config(path: Path) -> VaultConfig:
+    """Load a VaultConfig from a TOML file."""
+    with open(path, "rb") as f:
+        data = tomllib.load(f)
+
+    toml_dir = path.parent
+    root = toml_dir / data["root"]
+
+    return VaultConfig(
+        root=root,
+        scoped_folders=data.get("scoped_folders", []),
+        excluded_dirs=data.get("excluded_dirs", []),
+        rules_files=data.get("rules_files", ["CLAUDE.md", "CLAUDE.local.md"]),
+        wikilink_pattern=data.get("wikilink_pattern", r"\[\[(.+?)\]\]"),
+        orphan_min_chars=data.get("orphan_min_chars", 300),
+        transient_prefixes=tuple(data.get("transient_prefixes", [])),
+    )

graphmark/dismiss.py

@@ -0,0 +1,59 @@
+"""Dismissal store with content-hash staleness for weaklink suggestions."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+_DEFAULT_PATH = ".claude/data/connect-dismissed.json"
+
+
+def weaklink_sig(a: str, b: str) -> str:
+    return "weaklink|" + "|".join(sorted([a, b]))
+
+
+def content_hash(path: Path) -> str:
+    return hashlib.sha1(path.read_bytes()).hexdigest()
+
+
+def record_dismissal(root: Path, a: str, b: str, *, path: str = _DEFAULT_PATH) -> None:
+    dismissed_file = root / path
+    dismissed_file.parent.mkdir(parents=True, exist_ok=True)
+    existing = {}
+    if dismissed_file.exists():
+        try:
+            existing = json.loads(dismissed_file.read_text())
+        except (json.JSONDecodeError, OSError):
+            existing = {}
+    sig = weaklink_sig(a, b)
+    existing[sig] = {
+        "a": a,
+        "a_hash": content_hash(root / a),
+        "b": b,
+        "b_hash": content_hash(root / b),
+    }
+    dismissed_file.write_text(json.dumps(existing, indent=2))
+
+
+def load_dismissed(root: Path, *, path: str = _DEFAULT_PATH) -> dict:
+    dismissed_file = root / path
+    if not dismissed_file.exists():
+        return {}
+    return json.loads(dismissed_file.read_text())
+
+
+def active_dismissed_sigs(root: Path, *, path: str = _DEFAULT_PATH) -> set[str]:
+    dismissed = load_dismissed(root, path=path)
+    active: set[str] = set()
+    for sig, record in dismissed.items():
+        a_path = root / record["a"]
+        b_path = root / record["b"]
+        if (
+            a_path.exists()
+            and b_path.exists()
+            and content_hash(a_path) == record["a_hash"]
+            and content_hash(b_path) == record["b_hash"]
+        ):
+            active.add(sig)
+    return active

graphmark/export.py

@@ -0,0 +1,24 @@
+"""Export helpers: JSON serialisation and Graphviz DOT output."""
+
+from __future__ import annotations
+
+import json
+
+from graphmark.graph import VaultGraph
+
+
+def to_json(obj) -> str:
+    """Serialise any JSON-serialisable object to a string."""
+    return json.dumps(obj)
+
+
+def to_dot(graph: VaultGraph) -> str:
+    """Emit a Graphviz digraph containing every node and directed edge."""
+    lines = ["digraph G {"]
+    for node in sorted(graph.nodes):
+        lines.append(f'    "{node}";')
+    for src in sorted(graph.out_links):
+        for dst in sorted(graph.out_links[src]):
+            lines.append(f'    "{src}" -> "{dst}";')
+    lines.append("}")
+    return "\n".join(lines)

graphmark/graph.py

@@ -0,0 +1,107 @@
+"""Graph construction: catalog building, link resolution, and VaultGraph."""
+
+from __future__ import annotations
+
+import string
+from pathlib import Path
+
+from graphmark.config import VaultConfig
+from graphmark.interfaces import LinkExtractor, Resolver
+from graphmark.model import Document
+from graphmark.parse import parse_document
+
+_PUNCT_TABLE = str.maketrans(string.punctuation, " " * len(string.punctuation))
+
+
+def _normalize(text: str) -> str:
+    """Lowercase, replace punctuation with spaces, collapse whitespace."""
+    return " ".join(text.lower().translate(_PUNCT_TABLE).split())
+
+
+def build_catalog(docs: list[Document]) -> dict[str, list[str]]:
+    """Map normalized stem → list of rel_paths (len > 1 means ambiguous)."""
+    catalog: dict[str, list[str]] = {}
+    for doc in docs:
+        key = _normalize(Path(doc.rel_path).stem)
+        catalog.setdefault(key, []).append(doc.rel_path)
+    return catalog
+
+
+class NormalizeResolver:
+    """Resolves wikilink displays via normalized basename, with path-suffix fallback."""
+
+    def resolve(self, display: str, catalog: dict[str, list[str]]) -> str | None:
+        # Strip alias: "Note|alias" → "Note"
+        display = display.split("|")[0]
+        # Strip anchor: "Note#Section" → "Note"
+        display = display.split("#")[0]
+
+        if "/" in display:
+            # Path-suffix resolution: find unique rel_path ending with "display.md"
+            suffix = display.lower() + ".md"
+            all_paths = [p for paths in catalog.values() for p in paths]
+            matches = [p for p in all_paths if p.lower().endswith(suffix)]
+            return matches[0] if len(matches) == 1 else None
+
+        # Bare-link resolution: normalize and look up in catalog
+        key = _normalize(display)
+        paths = catalog.get(key)
+        if paths is None or len(paths) != 1:
+            return None
+        return paths[0]
+
+
+class VaultGraph:
+    """Built graph: all nodes plus resolved out/back adjacency."""
+
+    def __init__(
+        self,
+        nodes: dict[str, Document],
+        out_links: dict[str, set[str]],
+        back_links: dict[str, set[str]],
+    ) -> None:
+        self.nodes = nodes
+        self.out_links = out_links
+        self.back_links = back_links
+
+    @classmethod
+    def build(
+        cls,
+        config: VaultConfig,
+        extractor: LinkExtractor,
+        resolver: Resolver,
+    ) -> VaultGraph:
+        root = config.root
+        excluded = set(config.excluded_dirs)
+        rules = set(config.rules_files)
+
+        scoped = set(config.scoped_folders)
+        md_files: list[Path] = []
+        for path in sorted(root.rglob("*.md")):
+            rel_parts = path.relative_to(root).parts
+            if scoped and rel_parts[0] not in scoped:
+                continue
+            if any(p in excluded for p in rel_parts[:-1]):
+                continue
+            if path.name in rules:
+                continue
+            md_files.append(path)
+
+        docs = [parse_document(p, root) for p in md_files]
+        nodes = {doc.rel_path: doc for doc in docs}
+        catalog = build_catalog(docs)
+
+        out_links: dict[str, set[str]] = {rel: set() for rel in nodes}
+        back_links: dict[str, set[str]] = {rel: set() for rel in nodes}
+
+        for doc in docs:
+            for display in extractor.extract(doc.text):
+                target = resolver.resolve(display, catalog)
+                if target is not None and target != doc.rel_path:
+                    out_links[doc.rel_path].add(target)
+
+        for src, targets in out_links.items():
+            for dst in targets:
+                back_links[dst].add(src)
+
+        return cls(nodes, out_links, back_links)

graphmark/interfaces.py

@@ -0,0 +1,33 @@
+"""Pluggable interfaces — the generality seams.
+
+Only the default wikilink/normalize implementations are required now; these Protocols exist so
+alternate link syntaxes and resolution strategies can be added later without touching the engine.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol
+
+
+class LinkExtractor(Protocol):
+    """Extracts raw link displays from note text."""
+
+    def extract(self, text: str) -> list[str]:
+        """Return raw link displays found in ``text``, excluding links inside code spans.
+
+        A "display" is the inner text of a link before resolution, e.g. ``[[Note|alias]]`` yields
+        ``"Note|alias"`` (alias/anchor stripping happens in the Resolver).
+        """
+        ...
+
+
+class Resolver(Protocol):
+    """Resolves a link display to a target note."""
+
+    def resolve(self, display: str, catalog: dict[str, list[str]]) -> str | None:
+        """Resolve ``display`` to a target rel_path, or ``None`` if unresolved/ambiguous.
+
+        ``catalog`` maps a normalized note key to the list of rel_paths sharing that key (length > 1
+        means a collision → a bare link to it is ambiguous and must not resolve).
+        """
+        ...

graphmark/metrics.py

@@ -0,0 +1,211 @@
+"""Structural metrics computed over a VaultGraph.
+
+All outputs reproduce the reference engine (brain_map.py) exactly — shape,
+ordering, and tie-breaking are pinned by tests/fixtures/simple/expected.json.
+"""
+
+from __future__ import annotations
+
+import networkx as nx
+
+from graphmark.config import VaultConfig
+from graphmark.graph import VaultGraph
+
+
+def _undirected(graph: VaultGraph) -> nx.Graph:
+    G: nx.Graph = nx.Graph()
+    G.add_nodes_from(graph.nodes.keys())
+    for src, targets in graph.out_links.items():
+        for dst in targets:
+            G.add_edge(src, dst)
+    return G
+
+
+def stats(graph: VaultGraph) -> dict:
+    """Return aggregate vault stats matching the oracle schema."""
+    G = _undirected(graph)
+    notes = len(graph.nodes)
+    edges = sum(len(v) for v in graph.out_links.values())
+    n_orphans = sum(1 for n in G.nodes if G.degree(n) == 0)
+    n_clusters = sum(1 for c in nx.connected_components(G) if len(c) > 1)
+    density = round(edges / notes, 2) if notes > 0 else 0.0
+    return {
+        "notes": notes,
+        "edges": edges,
+        "orphans": n_orphans,
+        "clusters": n_clusters,
+        "density": density,
+    }
+
+
+def orphans(graph: VaultGraph, config: VaultConfig) -> list[str]:
+    """Return degree-0 nodes, excluding those matching transient_prefixes, sorted."""
+    G = _undirected(graph)
+    result = []
+    for node in G.nodes:
+        if G.degree(node) != 0:
+            continue
+        if any(node.startswith(prefix) for prefix in config.transient_prefixes):
+            continue
+        result.append(node)
+    return sorted(result)
+
+
+def hubs(graph: VaultGraph, n: int = 10) -> list[list]:
+    """Return top-n nodes by undirected degree (degree > 0), ties broken by path order."""
+    G = _undirected(graph)
+    degree_pairs = [(node, G.degree(node)) for node in G.nodes if G.degree(node) > 0]
+    degree_pairs.sort(key=lambda x: (-x[1], x[0]))
+    return [[path, degree] for path, degree in degree_pairs[:n]]
+
+
+def clusters(graph: VaultGraph) -> list[list[str]]:
+    """Return connected components with >1 node, size-desc, members sorted."""
+    G = _undirected(graph)
+    components = [sorted(c) for c in nx.connected_components(G) if len(c) > 1]
+    components.sort(key=lambda c: -len(c))
+    return components
+
+
+def bridges(graph: VaultGraph) -> list[str]:
+    """Return articulation points of the undirected graph, sorted."""
+    G = _undirected(graph)
+    return sorted(nx.articulation_points(G))
+
+
+def siloed_notes(graph: VaultGraph) -> list[str]:
+    """Return notes reachable from the mainland only through a single articulation point.
+
+    For each bridge b: remove b, find connected components sorted size-desc; every
+    component except the largest (mainland) is an island. Collect all island nodes
+    (including degree-0 orphans that become singleton islands). Return sorted unique list.
+    """
+    G = _undirected(graph)
+    island_nodes: set[str] = set()
+    for bridge in nx.articulation_points(G):
+        H = G.copy()
+        H.remove_node(bridge)
+        components = sorted(nx.connected_components(H), key=lambda c: -len(c))
+        for component in components[1:]:
+            island_nodes.update(component)
+    return sorted(island_nodes)
+
+
+def pagerank(graph: VaultGraph, n: int = 10, alpha: float = 0.85) -> list[list]:
+    """Pure-python power iteration PageRank (matches networkx _pagerank_python).
+
+    Dangling nodes (no out-edges) redistribute mass uniformly across all nodes.
+    Returns top-n [path, score] pairs sorted score-desc then path-asc.
+    """
+    nodes = list(graph.nodes.keys())
+    N = len(nodes)
+    if N == 0:
+        return []
+
+    out_links = {node: graph.out_links.get(node, set()) for node in nodes}
+    dangling = [node for node in nodes if not out_links[node]]
+    dangling_weight = 1.0 / N
+
+    x: dict[str, float] = {node: 1.0 / N for node in nodes}
+
+    for _ in range(100):
+        xlast = x
+        x = dict.fromkeys(xlast, 0.0)
+        danglesum = alpha * sum(xlast[node] for node in dangling)
+
+        for src in nodes:
+            out = out_links[src]
+            if out:
+                share = alpha * xlast[src] / len(out)
+                for dst in out:
+                    x[dst] += share
+
+        for node in nodes:
+            x[node] += danglesum * dangling_weight + (1.0 - alpha) * dangling_weight
+
+        err = sum(abs(x[node] - xlast[node]) for node in nodes)
+        if err < N * 1e-6:
+            break
+
+    pairs = sorted(x.items(), key=lambda kv: (-kv[1], kv[0]))
+    return [[path, score] for path, score in pairs[:n]]
+
+
+def gaps(
+    graph: VaultGraph,
+    similar_fn,
+    threshold: float = 0.0,
+    k: int = 5,
+    note: str | None = None,
+    dismissed: set | frozenset = frozenset(),
+    exclude_prefixes: tuple = (),
+    max_score: float | None = None,
+    hub_degree: int | None = None,
+    targets: list | None = None,
+) -> list[dict]:
+    """Return link-gap suggestions ranked by novelty (non-hub, cross-folder, score-desc)."""
+    if note is not None:
+        target_list = [note]
+    elif targets is not None:
+        target_list = targets
+    else:
+        target_list = list(graph.nodes.keys())
+
+    G = _undirected(graph)
+
+    def _hub(r: str) -> bool:
+        return hub_degree is not None and G.degree(r) >= hub_degree
+
+    dedup_map: dict = {}
+
+    for rel in target_list:
+        if any(rel.startswith(p) for p in exclude_prefixes):
+            continue
+
+        linked = graph.out_links.get(rel, set()) | graph.back_links.get(rel, set())
+
+        for other, score in similar_fn(rel, k):
+            if other == rel:
+                continue
+            if other in linked:
+                continue
+            if score < threshold:
+                continue
+            if any(other.startswith(p) for p in exclude_prefixes):
+                continue
+            if max_score is not None and score > max_score:
+                continue
+
+            sig = "weaklink|" + "|".join(sorted([rel, other]))
+            if sig in dismissed:
+                continue
+
+            key = frozenset({rel, other})
+            if key not in dedup_map or score > dedup_map[key][2]:
+                dedup_map[key] = (rel, other, score, sig)
+
+    def _rank_key(item):
+        a, b, score, _sig = item
+        hubby = _hub(a) or _hub(b)
+        cross = a.split("/", 1)[0] != b.split("/", 1)[0]
+        return (hubby, not cross, -score, a, b)
+
+    candidates = sorted(dedup_map.values(), key=_rank_key)
+    return [{"a": a, "b": b, "score": round(s, 4), "sig": sig} for a, b, s, sig in candidates]
+
+
+def neighborhood(graph: VaultGraph, note: str, depth: int = 1) -> dict:
+    """Return out/back neighbors (and two_hop when depth>=2) for a note."""
+    out = sorted(graph.out_links.get(note, set()))
+    back = sorted(graph.back_links.get(note, set()))
+    result: dict = {"note": note, "out": out, "back": back}
+    if depth >= 2:
+        one_hop = set(out) | set(back)
+        two_hop: set[str] = set()
+        for neighbor in one_hop:
+            two_hop |= set(graph.out_links.get(neighbor, set()))
+            two_hop |= set(graph.back_links.get(neighbor, set()))
+        two_hop -= one_hop
+        two_hop.discard(note)
+        result["two_hop"] = sorted(two_hop)
+    return result

graphmark/model.py

@@ -0,0 +1,44 @@
+"""Core data model for graphmark.
+
+These dataclasses are the seeded boundaries the engine is built against. Do not rename
+their types or fields; implement the engine modules to produce and consume them.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Document:
+    """A single note in the vault."""
+
+    rel_path: str  # posix rel-path from vault root, e.g. "brain/North Star.md"
+    text: str
+    frontmatter: dict
+
+
+@dataclass(frozen=True)
+class Edge:
+    """A resolved directed link from one note to another."""
+
+    src: str  # rel_path
+    dst: str  # rel_path
+
+
+@dataclass
+class Graph:
+    """The built graph: nodes plus resolved out/back adjacency."""
+
+    nodes: dict[str, Document]  # rel_path -> Document
+    out_links: dict[str, set[str]]  # rel_path -> resolved target rel_paths
+    back_links: dict[str, set[str]]  # inverted out_links
+
+
+@dataclass(frozen=True)
+class Finding:
+    """A health finding (used by health checks)."""
+
+    kind: str  # "orphan" | "broken_link" | "missing_frontmatter"
+    note: str  # rel_path
+    detail: str = ""

graphmark/parse.py

@@ -0,0 +1,72 @@
+"""Note parsing: document splitting and wikilink extraction."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from graphmark.model import Document
+
+_FM_RE = re.compile(r"^---\n(.+?\n)---\n", re.DOTALL)
+_WIKILINK_RE = re.compile(r"\[\[(.+?)\]\]")
+_INLINE_CODE_RE = re.compile(r"`[^`\n]+`")
+_FENCE_OPEN_RE = re.compile(r"^(`{3,}|~{3,})")
+
+
+def _strip_fenced_blocks(text: str) -> str:
+    """Remove fenced code block contents so wikilinks inside them are ignored."""
+    lines = text.splitlines(keepends=True)
+    out: list[str] = []
+    fence_char: str | None = None
+    for line in lines:
+        ls = line.lstrip()
+        if fence_char is None:
+            m = _FENCE_OPEN_RE.match(ls)
+            if m:
+                fence_char = ls[0]
+            else:
+                out.append(line)
+        else:
+            if _FENCE_OPEN_RE.match(ls) and ls[0] == fence_char:
+                fence_char = None
+    return "".join(out)
+
+
+def _parse_frontmatter(raw: str) -> dict:
+    """Minimal YAML-like frontmatter parser covering scalar, quoted-string, inline-list."""
+    result: dict = {}
+    for line in raw.splitlines():
+        if ":" not in line:
+            continue
+        key, _, value = line.partition(":")
+        key = key.strip()
+        value = value.strip()
+        if value.startswith("[") and value.endswith("]"):
+            items = [v.strip().strip("\"'") for v in value[1:-1].split(",")]
+            result[key] = [i for i in items if i]
+        else:
+            result[key] = value.strip("\"'")
+    return result
+
+
+class WikilinkExtractor:
+    """Extracts raw wikilink displays from note text, excluding code spans."""
+
+    def extract(self, text: str) -> list[str]:
+        text = _strip_fenced_blocks(text)
+        text = _INLINE_CODE_RE.sub("", text)
+        return _WIKILINK_RE.findall(text)
+
+
+def parse_document(path: Path, root: Path) -> Document:
+    """Parse a markdown note into a Document, splitting YAML frontmatter from body."""
+    raw = path.read_text(encoding="utf-8")
+    rel_path = path.relative_to(root).as_posix()
+    m = _FM_RE.match(raw)
+    if m:
+        frontmatter = _parse_frontmatter(m.group(1))
+        body = raw[m.end() :]
+    else:
+        frontmatter = {}
+        body = raw
+    return Document(rel_path=rel_path, text=body, frontmatter=frontmatter)

graphmark-0.1.0.dist-info/METADATA

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: graphmark
+Version: 0.1.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
+Project-URL: Issues, https://github.com/cdcoonce/graphmark/issues
+Author-email: Charles Coonce <charlescoonce@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: graph,knowledge-graph,markdown,obsidian,pagerank,wikilink
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Requires-Python: >=3.11
+Requires-Dist: networkx>=3.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# graphmark
+
+Deterministic knowledge-graph analysis for markdown / `[[wikilink]]` vaults — orphans, hubs,
+clusters, bridges, neighborhoods, and PageRank over your notes, driven by a small config so it works
+on any Obsidian-family vault.
+
+> Status: **early**. Engine modules are being built against a differential oracle (a proven
+> reference implementation's frozen outputs). See `CLAUDE.md` for the architecture and the
+> reference-parity contract.
+
+## Install (dev)
+
+```bash
+uv pip install -e ".[dev]"
+```
+
+## Test
+
+```bash
+uv run --extra dev ruff check . && uv run --extra dev ruff format --check . && uv run --extra dev pytest -q
+```
+
+## Usage (once built)
+
+```bash
+graphmark stats     --config configs/my-brain.toml --root /path/to/vault
+graphmark orphans   --config configs/my-brain.toml --root /path/to/vault
+graphmark hubs 10   --config configs/my-brain.toml --root /path/to/vault
+graphmark pagerank  --config configs/my-brain.toml --root /path/to/vault
+graphmark export dot --config configs/my-brain.toml --root /path/to/vault > graph.dot
+```

graphmark-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+graphmark/__init__.py,sha256=sXSYDxvThezeRGUxh83J9jcfEKSE_FHxX7zKq3cKylE,112
+graphmark/cli.py,sha256=_hCi9T0DYIo8UNsW_8thDxMl9ZQgUtbq9r2Ka95OrHY,2998
+graphmark/config.py,sha256=btPGhf2kp_8-J_DPnn2QysxIeem0mL5xa9LAgs9Qu_s,1542
+graphmark/dismiss.py,sha256=wJUf5BaN5q72ySyxDNC33nq-eTn3gbr8a6nzwu92NV0,1752
+graphmark/export.py,sha256=z3rluLRcRzQeKqM7ALABf0O3JOOpHgs412X7ypVpUZw,682
+graphmark/graph.py,sha256=hrw4sbjD2gJlo6f3erdSEl0qDtSBDAqt-igLez3bY2o,3677
+graphmark/interfaces.py,sha256=a4R_z1Jo15lSH-jSaoBH-kou_ovLS_BUuYOJLqVZZ7k,1198
+graphmark/metrics.py,sha256=TYe9_YnIvC6T-1NEfZ9cU7sC3toI73hvr2VfSa0v3Fw,7229
+graphmark/model.py,sha256=ylxXvnCn0gAu86aW4V3at-3FBhNWBrHdbmFzb8tlRNc,1115
+graphmark/parse.py,sha256=W2EstjIUVD0itb-4CRj2aQICujEad6X16gVuj3a9mAA,2326
+graphmark-0.1.0.dist-info/METADATA,sha256=U28g8NLrWkEAv9kHWbOt7cSmDSbPuHLfaLFA7-D0mro,2163
+graphmark-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+graphmark-0.1.0.dist-info/entry_points.txt,sha256=sqDtlC7NtKyCUXw6Vn-147PHjhAK2V1hZQSbzP2qyEw,49
+graphmark-0.1.0.dist-info/licenses/LICENSE,sha256=MZbypT-lLCt1Re77foXUp-nevCglz-FNlObDyoL_DXU,1071
+graphmark-0.1.0.dist-info/RECORD,,

graphmark-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

graphmark-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+graphmark = graphmark.cli:main

graphmark-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Charles Coonce
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.