Add a node. Returns an error if a node with the same `id` already exists.

Add an edge between two nodes identified by their string IDs.

Line number (1-based) where a regex capture starts in `source`.

Extract graph nodes and edges from a single source file.

Iterate over all node IDs.

Generate a deterministic ID from string parts. Matches the Python `_make_id` implementation exactly: ```python def _make_id(*parts: str) -> str: comb

Merge multiple extraction results into one graph. Later extractions override earlier ones for same node IDs (first-write-wins via `add_node` which re

Search for nodes matching any of the given terms. Each term is tokenized and matched against the index using **exact** and prefix** matching. Scores

Get the degree (number of edges) for a node by id.

Collect all nodes as a Vec.

Validate a URL: must be http/https, must not resolve to private/localhost IPs. Note: this is a static check only. It does not protect against DNS reb

Run community detection on the graph. Returns `{community_id: [node_ids]}`. Uses the Leiden algorithm: greedy modularity optimization (Louvain phase)

Iterate over all edge weights.

Iterate over all edges as `(source_id, target_id, &GraphEdge)`.

Find the most-connected nodes, excluding file-level hubs and method stubs. Returns up to `top_n` nodes sorted by degree descending. Generic labels li

Resolve cross-file imports for JS/TS, Go, and Rust. For each `imports` edge, tries to match the imported module name to a file stem and then creates

Split `input` on camelCase boundaries, `_`, `.`, `::`, `/`, `\`, `-`, and whitespace. Returns all-lowercase, non-empty tokens. # Examples (implicit,

Run Pass 1 extraction on a set of file paths. Dispatches each file to the appropriate regex-based extractor, collects all nodes and edges, deduplicat

1-based end line of `source` at byte offset of the next capture's start, or end of file if this is the last capture.

Simple call-graph inference: for each function body, look for occurrences of other known function names.

Helper: run the full pipeline on a temp dir and return the graph + output dir.

BFS traversal from start nodes up to a maximum depth. Returns `(visited_nodes, edges_traversed)` where edges are `(source, target)` pairs.

Walk `root` and return a [`DetectResult`] with all discovered files.

Default numeric score for each confidence level.

Like [`load_cached`] but with an explicit cache directory.

Build a [`KnowledgeGraph`] from a single extraction result. All nodes are added first; edges that reference unknown source/target nodes are silently

Deduplicate nodes within a single file's [`ExtractionResult`]. Retains the **first** occurrence of each node ID and each `(source, target, relation)`

Export graph to `graph.json` in NetworkX `node_link_data` format. Uses streaming serialization via `BufWriter` to avoid building the entire JSON stri

Install graphify git hooks in the repository at `repo_root`. Installs post-commit and post-checkout hooks. If the hook files already exist, the graph

Merge edges from a CodeGraph SQLite database into an existing [`KnowledgeGraph`]. Looks for `.codegraph/codegraph.db` under `project_root`. If not fo

Get neighbor IDs as strings.

Compute PageRank importance scores for all nodes. Returns the top `top_n` nodes sorted by PageRank score descending. Uses the power iteration method

Resolve a dot-separated import (Java, C#, Kotlin, Scala, Swift). Import labels like `"java.util.List"` or `"System.Collections.Generic"`. Handles ali

Find all simple paths between `source` and `target` up to `max_length` edges. Returns a vec of paths, each path being a vec of node IDs. Limits to at

Detect dependency cycles using Tarjan's algorithm for strongly connected components. Only considers directional edges (imports, uses, calls) to find

Compare two graph snapshots and return a summary of changes.

Is this a file-level hub node?

Run the full pipeline: detect -> extract -> build -> cluster -> analyze -> export. When `changed_files` is provided, only those files have their cach

Generate graph-aware questions based on structural patterns. Categories: 1. AMBIGUOUS edges → unresolved relationship questions 2. Bridge nodes (high

Serialize to the NetworkX `node_link_data` JSON format.

Append a section to a file if the marker is not already present.

Cohesion score: ratio of actual intra-community edges to maximum possible. Returns a value in `[0.0, 1.0]` rounded to two decimal places.

Dijkstra shortest path using edge weights. Cost = 1.0 / edge.weight (higher weight = shorter distance). Optionally filters edges below `min_confidenc

Export the graph as Cypher CREATE statements for Neo4j.

Export an interactive HTML visualization of the knowledge graph. For large graphs (> `max_nodes` nodes), automatically prunes to the most important n

Export graph as an Obsidian vault (folder of `.md` files with `[[wikilinks]]`). Each node becomes a markdown file with YAML frontmatter and a **Conne

Export a simple static SVG with circular layout.

Compute the SHA256 hex digest of a file's content. Returns `None` if the file cannot be read.

Remove a section from a file identified by a marker line. Removes from the marker line until the next `##` heading or end of file.

Derive cross-file "calls" edges from "uses" edges created by import resolution. If function A in file X uses entity B from file Y (via import resolut

Like [`save_cached`] but with an explicit cache directory.

Compute cohesion scores for all communities.

Strip all HTML tags from a string.

Strip the graphify marker block from hook content. Removes everything between (and including) the start and end markers, plus any surrounding blank l

Convert a subgraph (set of nodes and edges) to a text representation suitable for LLM context windows. Respects a `token_budget` (approximate: 1 toke

Find surprising connections that span different communities or source files. A connection is "surprising" if: - the two endpoints belong to different

Validate a graph file path: must have a `.json` extension.