graphify releases

Bug Fixes

• #811 Unicode identifiers (CJK, Cyrillic, Arabic, accented Latin) no longer collapse to a bare file stem — _make_id now uses [^\w]+ with re.UNICODE to preserve non-ASCII word chars. Added NFKC normalization so composed/decomposed forms of the same character produce the same ID. Switched to casefold() for correct locale-sensitive lowercasing. _normalize_id in build.py kept in sync.
• #803 Dedup edge remap uses explicit key-presence check instead of or so empty-string source isn't silently swapped for the from fallback. Stale from/to keys are now popped after remapping so they can't leak into edge attributes in graph.json.
• #801 --update merge block in skill.md now calls build_merge() directly instead of an inline NetworkX round-trip that re-introduced the direction-flip bug from #760. Dict merge ordering fixed so explicit source/target always win over stale attrs. Hyperedges pulled from G.graph (full merged set) rather than just the new extraction.
• #808 Subagent prompts now receive an absolute CHUNK_PATH derived from graphify-out/.graphify_root at dispatch time — chunk files no longer silently land in the wrong directory due to undefined subagent cwd.
• Skill version mismatch warning suppressed during hook-check (runs on every editor tool use, must be silent) and routed to stderr for all other commands.

Upgrade

pip install -U graphifyy

What's new

Fixes

• Ollama VRAM exhaustion (#798): num_ctx is now derived from the actual chunk size instead of hardcoded 131072. With --token-budget 8192, the old value forced Ollama to allocate 128k KV-cache slots on a 31B model — 4×128k slots by chunk 4 caused OOM. New formula: min(input_tokens + output_cap + 2000, 131072) so an 8k chunk gets ~26k instead.
• Hollow-response warning improved: now mentions VRAM pressure and points to GRAPHIFY_OLLAMA_NUM_CTX / GRAPHIFY_OLLAMA_KEEP_ALIVE env vars as tuning knobs.

Features

• graphify export callflow-html (#797): generates a self-contained Mermaid architecture/call-flow HTML page from graphify-out/graph.json — community sections, interactive flowcharts with zoom/pan, call detail tables, and graph report highlights.
• Living architecture diagram (#800): callflow HTML now auto-regenerates on every --watch rebuild and post-commit hook if the file already exists. Run once, stays current forever.

Upgrade

uv tool upgrade graphifyy
# or: pip install --upgrade graphifyy

What's changed

• Fix: MultiGraph crash in explain/path — G.edges[u, v] crashed on graphs with multigraph: true. New edge_data()/edge_datas() helpers in build.py handle all graph types; all 8 production call sites and 30 skill-file heredocs updated (#796)
• Fix: hollow Ollama response drops chunk — when a local model is overwhelmed and returns empty/null content, chunks were silently dropped instead of retrying. Now rerouted into the existing bisection path via _response_is_hollow() (#792)
• Fix: hook OOM on concurrent commits — per-repo fcntl.flock lock prevents unbounded parallel rebuilds; changed_paths wired through so only modified files re-extract; stale nodes evicted on deletion; GRAPHIFY_REBUILD_TIMEOUT watchdog (#791)
• Fix: Antigravity .agent → .agents — corrected folder name in platform config, paths, workflow body, and help text (#453)
• Fix: Antigravity rules frontmatter — trigger: always_on YAML frontmatter added so Antigravity recognises the rules file (#785)
• Feat: graphify extract tuning flags — --max-workers, --token-budget, --max-concurrency, --api-timeout; hard 8-worker cap removed; ollama API key gate skipped for loopback URLs (#792)
• Feat: Pascal/Delphi/Lazarus — regex fallback extractor works without tree-sitter-pascal; covers .pas .pp .dpr .dpk .lpr .inc .dfm .lfm .lpk (#781)
• Feat: /graphify --help — all 12 skill files now print the Usage block and stop instead of running the pipeline (#795)
• README: 35 languages — updated language count and extension list

Upgrading

uv tool upgrade graphifyy
# or
pip install --upgrade graphifyy

What's changed

• Fix: context-window retry — API calls that fail with context_length_exceeded now automatically bisect the file chunk and retry, up to 6 levels deep. No more hard failures on large files. (#789)
• Fix: Windows pipeline — three fixes shipped together: print_benchmark() falls back to ASCII on cp1252 consoles; BrokenProcessPool (spawn mode without __main__ guard) now falls back to sequential extraction instead of crashing; Windows skill file rewrites all python -c "..." blocks as PowerShell heredocs to fix quote-escaping failures. (#788)
• Fix: reversed calls edges after --update — build_merge() now reads saved JSON directly instead of round-tripping through NetworkX, which was silently reversing edge direction on reload. (#760)
• Fix: atomic SKILL.md install — temp-file + os.replace() prevents half-installed empty skill directories; version-stamp guard and warning added for missing installs. (#725)
• Feat: graphify uninstall — removes skill files from all platforms in one shot; --purge also deletes graphify-out/.
• Feat: SQL ALTER TABLE FK extraction — ADD CONSTRAINT ... FOREIGN KEY and ADD FOREIGN KEY DDL now emit references edges; schema-qualified table names resolved correctly. (#779)

Upgrading

uv tool upgrade graphifyy
# or
pip install --upgrade graphifyy

What's new

• Fix: .tsx files now use language_tsx grammar for JSX-aware parsing -- previously language_typescript was used, silently dropping all JSX-specific nodes from .tsx files (#766)
• Fix: edges key in saved graph JSON now normalised to links before loading -- prevents KeyError: 'links' on graphs written by older NetworkX versions in query, path, explain, and serve (#768)
• Fix: Google Workspace gws export drops unsupported resourceKey query param -- Drive API requires it as an HTTP header; sending it as a query param was a silent no-op (#772)
• Security: eleven hardening fixes -- Cypher escape strips C0 control chars and \n/\r; YAML frontmatter escapes U+2028, U+2029, tabs, and C0; MCP sanitize_label applied to all LLM-derived fields; C preprocessor blocked from #include exfiltration via -nostdinc -I /dev/null; merge-driver 50 MB file size cap and 100k node cap; detect_backend() places Ollama last so paid API keys take precedence over ambient OLLAMA_BASE_URL; Neo4j --password reads from NEO4J_PASSWORD env var by default; hooks exception handling narrowed to (configparser.Error, OSError)
• Refactor: skill YAML descriptions rewritten to be trigger-oriented -- describe what invokes the skill rather than its internal pipeline (#774)
• Refactor: generated CLAUDE.md / AGENTS.md / GEMINI.md templates strengthened with ALWAYS/NEVER/IF ... EXISTS graph-first directives (#775)

Install / upgrade

pip install -U graphifyy

What's new

• Feat: TypeScript extraction parity -- interface, enum, type alias, and module-level const nodes extracted; new_expression emits calls edges; parity with Java/C# class_types (#708)
• Feat: Quarto (.qmd) file support -- routed through existing Markdown extractor (#761)
• Feat: optional Google Workspace shortcut export -- graphify extract ./docs --google-workspace converts .gdoc, .gsheet, and .gslides files into Markdown sidecars via the gws CLI; account email pseudonymized via SHA256 hash; [google] extra adds Sheets table rendering support (#752)
• Feat: AWS Bedrock backend -- graphify extract ./docs --backend bedrock; credentials via standard AWS provider chain (AWS_PROFILE, AWS_REGION, IAM roles, SSO); model via GRAPHIFY_BEDROCK_MODEL (default anthropic.claude-3-5-sonnet-20241022-v2:0); [bedrock] extra adds boto3 (#757)
• Security: SSRF guard extended to block RFC 6598 CGN range 100.64.0.0/10 on Python <3.11

Install / upgrade

pip install -U graphifyy

What's new

• Gemini + OpenAI backends — graphify extract ./docs --backend gemini (GEMINI_API_KEY / GOOGLE_API_KEY) or --backend openai (OPENAI_API_KEY); pip install graphifyy[gemini] / graphifyy[openai]
• Groovy + Spock support — .groovy and .gradle via tree-sitter-groovy; Spock def "feature"() syntax handled via regex fallback
• Luau support — .luau (Roblox Luau) extracted using the Lua parser
• Markdown structural extraction — headings, code blocks, and nesting hierarchy extracted as graph nodes from .md/.mdx files (zero new deps)
• collect_files() extension sync — 18 extensions (.sql, .vue, .svelte, .jsx, .ex, .jl, etc.) were silently skipped in skill-mode extraction; now auto-syncs with _DISPATCH
• TS import resolution — bare-path, .svelte.ts, .svelte.js, index.ts directory, and multi-dot imports now resolve correctly

Bug fixes

• cluster-only now loads and saves .graphify_labels.json — human labels survive re-clustering (#744)
• graphify export wiki fails fast (exit 1) when .graphify_analysis.json is missing — prevents silent wiki deletion (#746)
• detect_incremental forwards follow_symlinks — symlinked subtrees no longer vanish on --update (#736)
• Ollama import error now says "Ollama" and points to pip install openai (#750)
• hooks.py path execution validates scripts are within repo root — closes supply-chain attack vector (#747)

Upgrade

uv tool upgrade graphifyy
pip install --upgrade graphifyy

What's new

• Ollama backend — graphify extract ./docs --backend ollama; auto-detected when OLLAMA_BASE_URL is set; defaults to qwen2.5-coder:7b; zero cost; pip install graphifyy[ollama]
• Cross-project global graph — graphify global add/remove/list/path registers multiple project graphs at ~/.graphify/global.json with <repo>::<id> prefixed node IDs preventing silent collisions
• --global --as <tag> flag on graphify extract — registers into the global graph in one step
• merge-graphs collision safety — inputs are now prefix-relabeled before composing, preventing silent node ID collisions

Bug fixes

• deduplicate_entities raises ValueError if called with nodes spanning multiple repos (cross-project dedup disabled by design)
• --dedup-llm flag now correctly threads through to both fresh and incremental extract paths
• graphify antigravity install writes to .agent/ (not .agents/)
• Pi skill YAML frontmatter parse error fixed
• merge-graphs now accepts both edges and links keys in graph.json

Upgrade

uv tool upgrade graphifyy
pip install --upgrade graphifyy

Bug Fixes

• cluster-only --graph flag (#724) — graphify cluster-only now accepts --graph <path> to specify a non-default graph.json location; positional path and flags can appear in any order
• _is_sensitive() false positives (#718) — word boundaries on the keyword pattern prevent legitimate source files like tokenizer.py, password_verification.py, SecretManager.java from being silently dropped
• max_tokens truncation cascade (#730) — headless graphify extract --backend claude/kimi now defaults to 16384 output tokens (was 8192), eliminating the recursive split cascade on dense doc corpora; override with GRAPHIFY_MAX_OUTPUT_TOKENS env var
• Prune message clarity (#539) — --update now clearly distinguishes "N nodes pruned from M deleted files" from "M deletions detected but graph already clean"
• Svelte stub node source_file (#712) — stub nodes created for imported .svelte files now carry the resolved import path as source_file instead of the importer's path
• Svelte static imports (#713) — extract_svelte() now catches static import X from './foo.svelte' via a dedicated regex pass over <script> block content; previously tree-sitter's JS parser silently dropped all static imports
• Manifest on full rebuild (#538) — graphify extract (full rebuild path) now saves manifest.json on every successful run; previously only --update saved it, causing stale-manifest drift
• Antigravity install paths (#704) — graphify antigravity install now writes to .agent/ (no trailing s) matching Antigravity's actual config paths
• Pi skill YAML parse error (#737) — Pi skill frontmatter description simplified to avoid "nested mappings" error on Pi startup
• --dedup-llm wiring — flag now correctly threads LLM backend through to deduplicate_entities in both fresh and incremental extract paths; fresh extract path now also runs dedup (previously bypassed it entirely)

0.7.5

• Feat: graphify extract now runs incrementally — auto-detects prior manifest.json and re-extracts only changed/new files; semantic results cached by content hash so unchanged docs cost zero LLM tokens on repeat runs (#698)
• Feat: Entity deduplication pipeline runs on every build — entropy gate + MinHash/LSH blocking + Jaro-Winkler verification + same-community boost collapses near-duplicate entities (typos, spacing, plurals) before clustering
• Feat: --dedup-llm flag for graphify extract — optional LLM tiebreaker for ambiguous entity pairs (~$0.01 for 10k-node graphs), off by default
• Fix: graphify hook install rebuild now preserves human-readable community labels from .graphify_labels.json instead of resetting to generic "Community N" names on every commit (#705)
• Fix: graphify install --platform gemini now works correctly (#706)
• Deps: datasketch and rapidfuzz added as base dependencies

What's new

Fix: tsconfig JSONC parsing (#700)

_read_tsconfig_aliases() now handles the format every TypeScript tool generates — // comments, /* */ block comments, trailing commas. Previously json.loads threw JSONDecodeError which was silently swallowed, causing alias resolution to return {} for essentially every real TS project (SvelteKit, NestJS, T3, Astro, Vite, Nx). The extends-following logic from v0.7.1 was correct all along — it was just unreachable. Both now work together.

Fix: Svelte dynamic import edges (#701)

Two bugs in the extract_svelte() regex fallback that caused 100% of generated edges to be dropped:

• Bug A: Aliased imports ($lib/..., $partials/..., @/...) were skipped by a .startswith('.') filter — now resolved via the tsconfig alias map
• Bug B: Synthetic node IDs used the wrong _make_id signature so both endpoints were phantom nodes; fixed to match _extract_generic and _import_js conventions

For a real 1,870-file SvelteKit app: 4,246 $lib/... + 478 $partials/... imports now resolve correctly, recovering ~150 previously orphaned .svelte files.

What's new

graphify extract — headless semantic extraction for CI (#698)

Docs-only and mixed corpora can now run full LLM extraction without Claude Code:

pip install --upgrade graphifyy

export MOONSHOT_API_KEY=...    # or ANTHROPIC_API_KEY
graphify extract ./docs

What it does: detect → AST extract on code files → semantic LLM extract on docs/papers/images → merge → cluster → write graph.json + .graphify_analysis.json.

Flags:

• --backend kimi|claude — explicit backend (auto-detected from env if omitted)
• --out DIR — output root (default: <path>/graphify-out/)
• --no-cluster — skip community detection, write raw extraction only

Supported backends: Anthropic (ANTHROPIC_API_KEY) and Kimi (MOONSHOT_API_KEY). When using the /graphify skill interactively, any model your IDE session runs is used instead.

Also in this release

• Export/query/path/explain CLI subcommands (from 0.7.2) now have full integration test coverage
• skill.md reduced from 63KB to 47KB (#696)

What's new

Fortran support (26th language)

• Parses .f, .F, .f90, .F90, .f95, .F95, .f03, .F03, .f08, .F08 files
• Extracts modules, subroutines, functions, programs, use statements, and calls
• Capital-F extensions (*.F, *.F90, etc.) are preprocessed with cpp -w -P before parsing to handle #ifdef/#define directives

Export CLI subcommands

New graphify export <format> subcommands replace the Python snippet workflow:

graphify export html          # interactive graph.html
graphify export obsidian      # Obsidian vault (--dir PATH)
graphify export wiki          # wiki/ markdown articles
graphify export svg           # static SVG
graphify export graphml       # GraphML for Gephi/yEd
graphify export neo4j         # cypher.txt (or --push URI for live import)

Also available: graphify query, graphify path, graphify explain

skill.md size reduction

Reduced from 63KB to 47KB by replacing multi-line Python heredocs with single-line CLI calls. Fixes #696.

Large graph aggregation

to_html() now accepts node_limit — when exceeded, automatically renders a community meta-graph instead of the full graph.

Requires: pip install tree-sitter-fortran for Fortran support (added as base dependency in this release)

Three bug fixes for edge cases that were causing silent failures or broken outputs.

What's fixed

Obsidian tags with special characters (#690)

Community labels containing ., &, (, ) were producing invalid Obsidian tags that broke Dataview queries. Tags are now sanitized to [a-zA-Z0-9_\-/] only before being written to the vault.

SvelteKit / Nuxt / NestJS path aliases (#691)

tsconfig.json path aliases defined in extended configs (via the `extends` field) were silently dropped. The alias resolver now follows the full extends chain, so `@/components` resolves correctly even when the alias lives in a base config two levels up.

Svelte template-layer dynamic imports (#692)

Tree-sitter only parses the script block of .svelte files. Markup-level dynamic imports like `{#await import('./Modal.svelte')}` in the template were invisible to the graph. A regex pass now runs after AST extraction to catch these.

Recursion crash on large codebases (#695)

Files with deeply nested AST trees (generated code, minified output, some auto-generated schemas) could hit Python's default 1000-frame recursion limit and crash the whole extraction run. The limit is now raised to 10,000 at startup and in each worker process. A `_safe_extract` wrapper catches any file that still overflows and skips it with a clear warning — the rest of the run completes normally.

How to get it

pip install --upgrade graphifyy

or

uvx graphifyy

Hey everyone,

One of the most common pain points I kept hearing about: graphify works great on a solo project, but once you have multiple people committing, things get messy. graph.json ends up with conflict markers, two devs rebuild from the same code and get different community IDs, renamed files blow away the cache. This release fixes all of that.

What's new

No more merge conflicts in graph.json

Run graphify hook install once in your repo. It now sets up a git merge driver that union-merges two graph.json files automatically. When two teammates commit at the same time and git tries to merge their graphs, it just combines the nodes and edges from both sides. No conflict markers, no manual resolution, nothing to think about.

It also writes the right .gitattributes entry and registers the driver in .git/config for you.

Deterministic community IDs

Leiden community detection is now seeded. Before this, two people rebuilding the graph from identical code could get different community numbers, which meant a 500-node diff for a 2-line code change. Now parallel rebuilds produce the same output.

Renamed files reuse their cache

The file hash used to include the file path, so renaming utils.py to helpers.py would invalidate the cache and re-extract the whole file. Now it's content-only. Rename 50 files in a refactor and the cache still hits.

Graph freshness signal

graph.json now records which git commit it was built from. GRAPH_REPORT.md shows the short hash so your AI assistant (or you) can compare against git rev-parse HEAD and know if the graph is stale before answering architecture questions.

Mixed code/doc commits handled correctly

If a commit touched both Python files and markdown docs, watch mode used to skip the code rebuild entirely. Now it rebuilds the code immediately and queues the docs for LLM re-extraction separately.

How to get it

pip install --upgrade graphifyy

or

uvx graphifyy

Then run graphify hook install in your repo to set up the merge driver and post-commit hooks.

0.6.9 (2026-05-03)

• Fix: source_file path separators normalized to forward slashes at graph ingestion — same physical file emitted with backslashes (Windows AST extractor) and forward slashes (semantic subagents) now merges into one node instead of splitting into two disconnected components (#683)
• Fix: two-phase cohesion re-clustering — communities with cohesion < 0.05 and ≥ 50 nodes are re-split, preventing doc-hub nodes (e.g. CLAUDE.md) from merging unrelated subsystems into one giant community (#683)
• Fix: VS Code Copilot instructions rewritten to be prescriptive — agent's first tool call must read GRAPH_REPORT.md, explicit trigger list, narrow allowlist for raw source reads (#688)
• Feat: GRAPHIFY_OUT env var overrides the output directory — accepts a relative name or absolute path, wires through cache.py, watch.py, and the CLI; useful for sharing one graph across multiple git worktrees (#686)
• Fix: graphify antigravity install now auto-updates stale rules and workflow files on re-run instead of silently skipping them (#652)
• Docs: README simplified — less dense, plain language; technical pipeline details moved to docs/how-it-works.md

0.6.8 (2026-05-03)

• Fix: .graphifyignore negation patterns (!src/**) now work correctly — when any ! pattern is present, directory pruning is deferred to per-file checks so negated files inside ignored directories are reached (#676)
• Fix: Antigravity slash command /graphify now appears in the command dropdown — workflow file now includes YAML frontmatter with name: graphify required for Antigravity discovery (#678)
• Fix: Gemini CLI BeforeTool hook replaced [ -f ... ] && echo (bash-only) with cross-platform python -c using json.dumps — fixes hook failure on Windows CMD and Git Bash (#681)
• Fix: Codex hook-check exits silently — resolves additionalContext rejection on Codex Desktop PreToolUse (#651)
• Fix: graphify install --platform codex now writes absolute path to graphify executable — fixes PATH resolution in VS Code extension on Windows (#651)
• Fix: thin communities (fewer than 3 concept nodes) are now omitted from the Communities section in GRAPH_REPORT.md by default; report header shows (N total, M thin omitted) and Knowledge Gaps collapses thin communities to one summary line (#664)

What's new

Features

• graphify tree — self-contained D3 v7 collapsible-tree HTML view of graph.json; expand/collapse controls, depth-based colours, hover inspector (#557)
• Token-aware chunking — split-and-retry on output truncation; chunk size adapts to token budget instead of static file count (#625)
• MCP context filters — query_graph tool now accepts context_filter for cross-language edge filtering (#573)
• Dynamic import() extraction — JS/TS dynamic imports now appear as imports_from edges (#579)

Bug fixes

• Fix: save_semantic_cache crashed with IsADirectoryError when a node's source_file was a directory — changed p.exists() to p.is_file() (#655)
• Fix: sanitize_label(None) raised TypeError, crashing to_html on graphs with rationale nodes that have null source_file (#656)
• Fix: chunk-extraction prompt omitted rationale from valid file_type values — model hallucinated concept on every doc/paper run; all skill variants updated (#657)
• Fix: cost.json always reported 0 tokens — added explicit chunk-merge step that globs and sums real token counts across all skill variants (#658)

Install / upgrade

pip install --upgrade graphifyy
uvx graphifyy install

What's new

New platform: Pi coding agent (#661)

• graphify pi install / graphify pi uninstall — installs skill to ~/.pi/agent/skills/graphify/SKILL.md
• graphify install --platform pi also supported

Bug fixes

• Windows skill (skill-windows.md) — complete rewrite from PowerShell to bash. Claude Code on Windows uses git-bash, so PowerShell syntax (\$null, \$LASTEXITCODE, Select-Object, Remove-Item) caused exit code 49 failures. Now mirrors skill.md exactly, with python added as fallback after python3 for Windows Conda environments (#39)
• Wiki stale clearing — to_wiki() now clears old .md files before regenerating, preventing orphan article accumulation across runs (#558)
• Windows filenames in wiki — _safe_filename() now strips all Windows-reserved characters (< > : " / \ | ? *) and caps length at 200 chars (#594)
• Rationale node leakage — rationale nodes were leaking into cross-file INFERRED call resolution, inflating god_node rankings with spurious edges. Filtered in 3 places in extract.py (#576)
• Edge direction in exports — calls and rationale_for edges were being flipped in graph.json and graph.html due to NetworkX undirected storage canonicalizing endpoint order. True direction now restored from _src/_tgt metadata stashed by build.py (#576)
• skill-trae.md SyntaxError — stray colon in --cluster-only block caused install failures (#603)

Security fixes

• MD5 hash in detect.py marked usedforsecurity=False (used for file change detection only, not cryptography)
• SHA1 hash in transcribe.py marked usedforsecurity=False (used for filename generation only)

Packaging fix

• pyproject.toml: tightened wheel packaging to only include the graphify package — wheel drops from 1.7MB to 285KB

New features

• .graphifyinclude hidden path allowlist — opt specific hidden files/dirs into traversal (e.g. .hermes/plans/) (#583)
• --no-viz flag now works in cluster-only path — removes stale graph.html when passed (#565)
• GRAPHIFY_VIZ_NODE_LIMIT env var — override the 5000-node HTML threshold (set to 0 to disable viz entirely, useful for CI) (#565)

Skill updates

• INFERRED confidence score guidance changed to discrete rubric (0.55 / 0.65 / 0.75 / 0.85 / 0.95) — continuous ranges were collapsing to a bimodal distribution (>50% at 0.5, >40% at 0.85+) (#546)
• --update prune output now splits into drift-detected vs no-drift cases for clarity (#544)
• --update merge step now calls save_manifest to prevent deleted files reappearing as ghost nodes on subsequent runs (#545)

Install / upgrade

pip install graphifyy==0.6.6
# or
uv tool install graphifyy

Changes

• Fix: Codex PreToolUse hook on Windows (#651, #522) — replaced python3 -c "..." (breaks on Conda, broken by PowerShell JSON parsing) with graphify hook-check, a new shell-agnostic subcommand. Re-run graphify codex install to regenerate the hook.
• Fix: Kotlin zero calls edges (#659) — call-walker now accepts both simple_identifier and identifier node types across grammar versions
• Feat: graphify update --force (#639) — bypass node-count safety check after refactors that legitimately shrink the graph; also GRAPHIFY_FORCE=1 env var
• Feat: checkbox multi-select for community sidebar (#647) — replaces show/hide buttons with checkboxes + indeterminate select-all state

Upgrade

pip install --upgrade graphifyy

Windows Codex users: also re-run graphify codex install after upgrading to regenerate the hook.

Bug Fix

• Codex PreToolUse hook fails on Windows (#651) — the hook used [ -f graphify-out/graph.json ] which is bash-only and crashes on cmd.exe. Replaced with a cross-platform Python one-liner (pathlib.Path.exists()) that works on Windows, Linux, and macOS.

Upgrade

pip install --upgrade graphifyy
# or
uvx graphifyy install

After upgrading, re-run graphify codex install to regenerate the hook with the fixed command.

Bug Fixes

• Incremental rebuild drops semantic nodes (#653) — graphify update and post-commit hooks now preserve INFERRED/AMBIGUOUS nodes by ID membership rather than file_type, so LLM-extracted call/data-flow edges survive code-only rebuilds
• Git hooks block commit for hours (#650) — post-commit and post-checkout rebuilds now detach via nohup & disown, git returns in ~100ms, rebuild log at ~/.cache/graphify-rebuild.log
• Common names inflate god_nodes (#543) — cross-file INFERRED calls now skips any callee resolving to 2+ candidates (ambiguous short names like log, execute, find no longer accumulate hundreds of spurious edges)
• cluster-only crashes on large graphs (#541) — to_html in cluster command now guarded with try/except ValueError matching the watch/hook path

Upgrade

pip install --upgrade graphifyy
# or
uvx graphifyy install

Highlights

• Query exact-match: graphify query "MyFunction" now returns the actual function first, not hub modules
• Kimi K2.6 fixed: reasoning mode was eating all tokens leaving graphs empty — disabled on Moonshot calls
• Smarter --update: mtime bumps from sync tools (Obsidian, Nextcloud) no longer trigger re-extraction — content hash verified first
• License cleanup: replaced html2text (GPL-3.0) with markdownify (MIT) — no more copyleft in a MIT project
• R language support + extensionless shell scripts via shebang detection

All fixes

• Fix: Kimi K2.6 thinking mode consumed entire token budget — disabled on Moonshot calls (#623)
• Fix: graphify update never persisted manifest — every run re-extracted everything (#621)
• Fix: inline comments in .graphifyignore (vendor/ # legacy) now stripped correctly (#605)
• Fix: exact-match query boost — queried symbol renders first, not degree-sorted hubs (#638)
• Fix: concurrent extractors raced on shared .tmp cache file — unique tempfile per writer (#589)
• Fix: branch names starting with - could inject git flags in _clone_repo (#589)
• Fix: replaced html2text (GPL-3.0) with markdownify (MIT) (#586)
• Fix: content hash check before re-extracting mtime-bumped files (#593)
• Fix: cross-language INFERRED calls no longer surface as top surprising connections (#630)
• Fix: cluster-only CLI flipped directed graphs to undirected (#590)
• Fix: Windows UNC paths normalize to consistent cache keys (#629)
• Fix: .graphifyignore negation patterns (!pattern) now work with last-match-wins (#628)
• Feat: R language (.r) support via LLM semantic extraction (#617)
• Feat: extensionless shell scripts detected via shebang (#619)

Upgrade

pip install --upgrade graphifyy

What's fixed

• Correct gitignore semantics: outer rules load first so inner (closer) rules always win via last-match-wins — matching standard gitignore behavior exactly (#643)
• Hermetic non-VCS scan: without a VCS root, .graphifyignore discovery stops at the scan folder — no leakage across sibling projects in a shared workspace (#643)
• Anchored patterns: leading / patterns in a parent .graphifyignore now apply only relative to their own directory, not the scan root (#643)
• Trailing space spec: unescaped trailing spaces are stripped, vendor\ (escaped) is preserved per gitignore spec (#643)

Upgrade

```
pip install --upgrade graphifyy
```

What's new in v0.6.0

SQL AST extraction

.sql files are now processed deterministically via tree-sitter — no LLM needed, no tokens spent.

graphify extracts:

• CREATE TABLE → table nodes
• CREATE VIEW → view nodes
• CREATE FUNCTION / CREATE PROCEDURE → function nodes
• REFERENCES constraints → foreign key edges (EXTRACTED confidence)
• FROM / JOIN clauses → reads_from edges (EXTRACTED confidence)

This means your entire backend — application code + database schema — maps into one graph. Tables, views, stored functions, and their relationships are first-class nodes just like Python classes or Go structs.

Supports standard SQL, PostgreSQL, Snowflake, and any dialect the tree-sitter-sql grammar covers.

Setup:
```
pip install 'graphifyy[sql]'
/graphify .
```

YAML indexing (v0.5.7)

.yaml and .yml files are now picked up for semantic extraction. Kubernetes manifests, Kustomize overlays, Helm values, and any YAML config are indexed automatically — no extra setup needed.

Bug fixes (v0.5.6 / v0.5.7)

• Fixed NameError: _os is not defined crash after graphify update
• Fixed Kimi K2.6 400 error — temperature param now omitted for Kimi backends
• Fixed community labels deleted on cleanup — .graphify_labels.json now persists across re-clusters
• Removed Python upper bound — now supports Python 3.14+
• Fixed SyntaxWarning in shell glob pattern

Install / upgrade

```
pip install --upgrade graphifyy
pip install 'graphifyy[sql]' # for SQL support
```

What's new in v0.5.5

• Kimi K2.6 backend — pip install 'graphifyy[kimi]' then set MOONSHOT_API_KEY to route semantic extraction through Kimi K2.6 instead of Claude subagents. 3-6x richer relation extraction at ~3x lower cost. Claude remains the default; Kimi is opt-in. A tip is printed when the key is not set so users discover it naturally.
• Phantom god node fix (#598) — member-call callees (this.logger.log() → log) are no longer cross-file resolved. Go package-qualified calls (pkg.Func()) are correctly preserved. Affects JS/TS, Go, Rust, Swift, Kotlin, Scala, PHP, C++, C#, Zig, Elixir.
• concept file_type fix (#601) — nodes with file_type: concept no longer produce validation warnings.
• graphify update remembers scan root — saves root to graphify-out/.graphify_root so graphify update with no args finds the right directory automatically.

Fixes #598, #601.

What's new in v0.5.4

• SSRF DNS rebinding fix — safe_fetch now patches socket.getaddrinfo for the entire duration of each HTTP request so a DNS rebinding attack cannot swap a public IP (returned during validation) for a private one during the actual connection. DNS lookup failures now also raise an error instead of silently skipping the IP check.
• yt-dlp SSRF bypass fix — download_audio now runs validate_url before handing the URL to yt-dlp, blocking private IPs and disallowed schemes on the video/audio ingest path.

Fixes #591, #592.

Fixes graphify update broken on mixed code+docs corpora (#582)

AST and semantic cache entries now live in separate cache/ast/ and cache/semantic/ subdirectories. Previously both wrote to the same flat cache/ directory — semantic results silently overwrote AST entries for code files, causing the shrink guard to fire on every subsequent graphify update run.

Existing flat cache entries are read as a migration fallback so no cache is lost on upgrade.

Upgrade: pip install --upgrade graphifyy

Hotfix for Claude Code v2.1.117+

The PreToolUse hook installed by graphify claude install was silently broken on Claude Code v2.1.117+ because dedicated Grep and Glob tools were removed — searches now go through Bash. The hook never fired, meaning the graph context reminder was never injected.

Fix: Hook matcher changed from Glob|Grep to Bash. The hook now reads the tool input JSON from stdin and pattern-matches on the command string, firing only on search-like calls (grep, rg, find, fd etc.) — not on every shell command.

Upgrade: pip install --upgrade graphifyy && graphify claude install

Closes #578

6 bug fixes shipped in this release:

• Node ID collisions — files with the same name in different directories (e.g. two utils.py files) now get unique node IDs via parent-directory-qualified stems
• Portable source_file paths — extract() relativizes all paths before returning; graph.json is now portable across machines and git worktrees
• Desync guard — to_json() returns a boolean; graphify update only writes GRAPH_REPORT.md and graph.html if the JSON write succeeded (shrink guard fired = no stale report)
• TypeScript path aliases — @/ and other compilerOptions.paths aliases in tsconfig.json now resolve to real file nodes instead of being dropped as external packages
• Show All / Hide All — community panel in the HTML visualization now has bulk-toggle buttons
• Skill prompt corrections — rationale stored as a node attribute (not a spurious fragment node); calls edge direction explicitly enforced (caller → callee)

Also includes tooling fixes from the v0.5.0 patch: ~ expansion in core.hooksPath, correct .gitignore inline comment placement, # nosec annotations on file write sinks.

What's new

Clone any GitHub repo directly

graphify clone https://github.com/karpathy/nanoGPT

Clones to ~/.graphify/repos/<owner>/<repo>, reuses existing clones on repeat runs. Supports --branch and --out.

Cross-repo knowledge graphs

graphify merge-graphs repo1/graphify-out/graph.json repo2/graphify-out/graph.json

Every node carries a repo tag so you can filter by origin.

Data-loss protection on --update
graphify now refuses to overwrite graph.json with a smaller graph. New build_merge() library function for safe incremental updates that only ever grows the graph.

Duplicate node deduplication
Chunk-suffix contamination (_c2, _c4) blocked at the prompt level. Post-merge deduplication pass catches any stragglers.

Bug fixes

• CLAUDE_CONFIG_DIR env var respected on install (#527)
• graphify-out/ excluded from source scanning (#524)
• Louder field-drift warning with edge count (#479)

Full announcement: https://github.com/safishamsi/graphify/discussions/528

What's fixed

#520 — /graphify <path> now respects the specified directory

The skill was placing graphify-out/ in the current working directory instead of inside the target path. Fixed by adding cd INPUT_PATH as the very first command in Step 1, and changing detect(Path('INPUT_PATH')) → detect(Path('.')) so all relative paths resolve correctly from the target directory. Applied to both skill.md and skill-opencode.md.

#516 — git hook install/uninstall works from worktree checkouts

_hooks_dir() was using git config core.hooksPath which doesn't resolve the shared hooks directory for worktree checkouts. Now uses git rev-parse --path-format=absolute --git-path hooks which git resolves correctly for both normal repos and worktrees. Includes regression tests for install/uninstall from a worktree.

#517 — GitHub dependency graph (no code change needed)

pyproject.toml already points to the correct repository. GitHub's dependency graph cache will update itself.

Features & Fixes

• #488 Legacy edge/node schema canonicalization — source→source_file on nodes, from/to→source/target on edges now handled before validation
• #482 Java inheritance — extends, implements, and interface-extends edges now extracted from AST; two-pass cross-file import resolver emits real imports edges instead of silently dropping them
• #472 Aggregated HTML view for large graphs — corpora >5000 nodes now get a community meta-graph in graph.html instead of no output at all; updated in both skill.md and skill-opencode.md
• #490 graphify check-update <path> — cron-safe CLI subcommand that checks for pending semantic updates and notifies without running LLM extraction

441 tests passing.

Fixes

• #513 Windows hook null byte warning — hook now skips head -1 for .exe binaries, goes straight to python3 fallback
• #514 to_canvas() hardcoded graphify/obsidian/ path — file refs are now vault-root-relative ({fname}.md), canvas opens correctly regardless of where the vault lives

Tests

• Added test_to_canvas_file_paths_relative_to_vault — would have caught the hardcoded path bug
• Added test_hook_skips_head_on_exe — verifies the Windows fix is present in the hook script

Fix

• #504 Garbled Chinese (CJK) output on Windows — added export PYTHONUTF8=1 to Step 1 of skill-opencode.md so all Python subprocesses run in UTF-8 mode on Windows, preventing garbled non-ASCII characters in terminal output and intermediate files

Fixes

• #498 OpenCode install bugs (3 sub-issues)
  • opencode.json now written to .opencode/opencode.json instead of project root — consistent with OpenCode's config directory
  • All intermediate temp files (.graphify_detect.json, .graphify_extract.json, etc.) in skill-opencode.md now correctly use graphify-out/ prefix instead of leaking to project root
  • Added missing --wiki step (Step 6b) to skill-opencode.md, matching all other platform skills

Fixes

• analyze.py (#499): Add seed=42 to betweenness_centrality() — GRAPH_REPORT.md is now byte-identical across runs on graphs >1000 nodes, eliminating infinite commit churn from the post-commit hook
• extract.py (#502): Fix common-root inference to stop at first diverging path segment (not sum of all matching segments); resolve root to absolute path; post-process file node IDs to project-relative after extraction so graph.json edge endpoints are stable across machines

Fixes

• wiki.py (#496): Add encoding="utf-8" to all write_text() calls — fixes crash on Windows cp1252 when articles contain Unicode characters like →
• wiki.py (#497): Deduplicate wiki filenames with _unique_slug() — prevents silent article overwrites when two communities get the same label
• hooks.py (#485): Skip post-commit and post-checkout hooks during git rebase, git merge, and git cherry-pick — prevents unstaged changes blocking --continue
• detect.py (#495): Resolve root path at detect() entry — fixes .graphifyignore patterns from parent directories not matching when graphify is run with a relative path like ./raw
• README.md (#369): Document manifest.json and cost.json gitignore recommendations; add .graphifyignore example for platform install files

Fixes

• report.py: Complete empty-community fix — Community Hubs navigation now skips empty-community entries, Summary line reflects non-empty community count, Knowledge Gaps excludes zero-node clustering artifacts (extends the Communities section fix from v0.4.24)
• main.py: Added graph-query CLI rule to CLAUDE.md, AGENTS.md, and GEMINI.md install sections — agents now know to prefer `graphify query`, `graphify path`, and `graphify explain` over grep for cross-module questions; added MCP CLI fallback line to Antigravity rules

Bug fixes

• cache: skip directory source_file in save_cached — prevents IsADirectoryError crash on NestJS/TS monorepos (#448)
• report: skip structural-only communities with no real nodes — removes empty Nodes (0): sections from reports (#443)
• hooks: allow @ in python path allowlist — fixes silent git hook failures on macOS with Homebrew Python (#473)
• watch: keep source_file paths project-relative after code rebuild — fixes absolute paths leaking into graph.json (#434)
• skill: clean up .graphify_chunk_*.json temp files at end of run (#464)

Translations

• Added 17 new language translations (Italian, Polish, Dutch, Turkish, Ukrainian, Vietnamese, Indonesian, Swedish, Greek, Romanian, Czech, Finnish, Danish, Norwegian, Hungarian, Thai, Traditional Chinese)
• All 28 translations moved to translations/ subdirectory

What's fixed

• #178 — Stale skill version warning persists after graphify install when multiple platforms were previously installed. graphify install now refreshes .graphify_version in all known skill dirs so the warning clears across the board.
• #260 — .html files silently skipped during detection. Added .html to DOC_EXTENSIONS — HTML pages, docs, and web content now indexed.
• #432 — _rebuild_code (watch/update/git hook) failed entirely on graphs > 5000 nodes because to_html raised ValueError. Wrapped in its own try/except so graph.json and GRAPH_REPORT.md always land; stale graph.html from a previous smaller run is removed.
• #431 — Go stdlib imports (e.g. "context") produced imports_from edges pointing at local files of the same basename, creating false cycle-dependency pairs. Go import node IDs now prefixed go_pkg_ using the full import path.

Upgrade

pip install --upgrade graphifyy

What's fixed

• #429 — AST cache written to src/graphify-out/cache/ instead of project root when all code files share a common prefix (e.g. src/). extract() now called with explicit cache_root in _rebuild_code and the Codex skill AST step.
• #428 — .mdx files silently skipped during detection. Added .mdx to DOC_EXTENSIONS — Next.js, Docusaurus, and Astro corpora now indexed correctly.

Upgrade

pip install --upgrade graphifyy

What's fixed

• #422 — graphify cluster-only crashed with KeyError: 'total_files' in report.py. Cluster-only skips detection so the stats dict was empty — now passes a warning key so the report skips the file-stats section gracefully.
• #423 — /graphify --update dropped all existing graph nodes. The merge block built a correct in-memory merged graph but never wrote it back to .graphify_extract.json, so Step 4 rebuilt from the new-extraction-only file. Merged result is now serialized back before Step 4 runs.

Upgrade

pip install --upgrade graphifyy

What's fixed

• #414 — JS/MJS imports_from edges silently dropped for files using ../subdir/file.mjs style imports. Path.parent / raw left .." segments unnormalized so the target ID didn't match the actual file node. Fixed with os.path.normpath`.
• #418 — graphify update . and graphify cluster-only now generate graph.html alongside graph.json and GRAPH_REPORT.md. Previously only the skill generated the interactive HTML viewer.
• #374 — graphify vscode install returning unknown command 'vscode' is fixed as of v0.4.19 (command was missing from the published wheel). Upgrade to resolve.

Upgrade

pip install --upgrade graphifyy

What's fixed

• #390 — AST/semantic node ID mismatch: edges were dropped when the LLM generated slightly different casing or punctuation than the AST extractor. build_from_json now normalises IDs before dropping edges.
• #298 — Cross-file call resolution extended to Go, Rust, Zig, PowerShell, and Elixir. Unresolved callees are saved as raw_calls and resolved globally in a post-pass.
• #410 — Windows graphify-out/graphify-out nesting bug. cache_dir and _rebuild_code now call .resolve() on the root path.
• #401 — graphify hook install now respects core.hooksPath git config (Husky and similar tools).
• #385 — Kiro skill YAML description field now quoted — fixes parse error in Kiro's YAML loader.

Docs

• Windows PATH tip and macOS pipx ensurepath tip added to install section (#413)
• Team workflow section: committing graphify-out/, .graphifyignore usage, recommended .gitignore additions (#369)

Upgrade

pip install --upgrade graphifyy

• Cross-file call resolution for Go, Rust, Zig, PowerShell, and Elixir (raw_calls saved and resolved globally)
• Fix semantic/AST node ID mismatch: build.py now reconciles mismatched IDs so LLM-generated edges survive the merge
• skill.md: explicit node ID generation rules with example to reduce LLM ID drift

What's new

• VS Code Copilot Chat — graphify vscode install configures VS Code Copilot Chat with a Python-only skill (works on Windows PowerShell) and writes .github/copilot-instructions.md for always-on graph context (#206)
• Fix: OpenCode plugin path used backslashes on Windows causing duplicate opencode.json entries — fixed via .as_posix() (#378)
• Fix: Gemini CLI on Windows now installs skill to ~/.agents/skills/ (correct higher-priority path) instead of ~/.gemini/skills/ (#368)
• Fix: .mjs and .ejs files now recognised by the AST extractor as JavaScript (#365)
• Fix: god_nodes() return field renamed edges → degree for clarity
• Fix: graphify watch on macOS now uses PollingObserver by default to avoid missed events with FSEvents (#373)

Upgrade

pip install --upgrade graphifyy

What's new

Cross-file call resolution for all languages

AST extraction now emits cross-file calls edges for Swift, Go, Rust, Java, C#, Kotlin, Scala, Ruby, PHP, and every other supported language. Previously only Python had this. Unresolved call sites are saved per file and resolved against a global label map after all files are processed. Cross-file edges are marked INFERRED with confidence 0.8.

PHP static method calls and constant references

Two node types were missing from the PHP extractor. scoped_call_expression (static calls like Helper::format()) now emits calls edges. class_constant_access_expression (enum and constant references like Status::ACTIVE) now emits references_constant edges.

Wiki flag implemented

--wiki now actually runs. Step 6b added to the skill pipeline (before the cleanup step so community labels are still available). Calls to_wiki() and writes graphify-out/wiki/ with index.md and one article per community and god node.

Performance: betweenness centrality on large graphs

edge_betweenness_centrality now returns early for graphs over 5000 nodes. betweenness_centrality in suggest_questions uses k=100 approximate sampling for graphs over 1000 nodes. Eliminates hangs on large repos.

OpenCode plugin installed on both install paths

graphify install --platform opencode now also writes .opencode/plugins/graphify.js and registers it in opencode.json. Previously only graphify opencode install did this.

Cache root fix for subdirectory runs

extract() accepts an explicit cache_root parameter. When graphify narrows to a subdirectory on a large repo, the cache stays at ./graphify-out/cache/ instead of /graphify-out/cache/.

Windows stability

os.replace in the cache writer falls back to shutil.copy2 on PermissionError (WinError 5). graphify update exits with code 1 when rebuild fails instead of silently returning. All generated config files now use graphify update . instead of a hardcoded python3 invocation.

Kiro package data

skill-kiro.md was missing from pyproject.toml package-data, causing graphify kiro install to fail on fresh pip installs. Fixed.

Upgrade

pip install -U graphifyy

Fixes

• Watch semantic edge loss — watch was silently dropping all semantic edges on every rebuild because graph.json uses the links key but code read edges. Now reads both (#269)
• OpenClaw install path — graphify claw install now correctly writes to .openclaw/skills/graphify/ (#208)
• Blade template support — .blade.php files now extracted: @include, <livewire:\> components, and wire:click bindings (#242)
• WSL/Linux MCP docs — added note covering graphifyy package name, venv setup, and full path in .mcp.json (#250)

PyPI: https://pypi.org/project/graphifyy/0.4.7/

What's new

Google Antigravity support

graphify now works with Google Antigravity — the agent-first IDE built on Gemini.

pip install --upgrade graphifyy
graphify antigravity install

This writes:

• .agent/rules/graphify.md — always-on rules (Antigravity reads these every session)
• .agent/workflows/graphify.md — registers /graphify as a slash command

Then open Antigravity and type /graphify .

Full changelog: https://github.com/safishamsi/graphify/blob/v4/CHANGELOG.md

PyPI: https://pypi.org/project/graphifyy/0.4.6/

If graphify has been useful, consider sponsoring — we're closing in on 100k PyPI downloads and every bit of support helps keep the project moving.

Bug fixes — 8 issues addressed.

Bug fixes (our commits)

• #211 Same-basename files produced colliding node IDs — now uses full path
• #216 Edges using from/to keys were silently dropped — now normalized
• #217 Empty graphs caused ZeroDivisionError during visualization — guarded
• #222 Post-commit hook silently skipped .tsx, .jsx etc — removed stale CODE_EXTS filter

Community fixes (cherry-picked)

• #212 NetworkX ≤3.1 serialises edges as links — now accepted alongside edges
• #220 Version warning fired during install/uninstall and duplicated on shared paths — fixed
• #204 All file IO now uses encoding="utf-8" — prevents crashes on Windows CJK/emoji corpora; hook writes use newline="\n" to prevent CRLF shebang breakage
• #221 Obsidian: node labels ending in .md produced .md.md filenames; GRAPH_REPORT.md now links to community hub files so the vault stays in one connected component

Upgrade

pip install --upgrade graphifyy

Video and audio files are now first-class corpus inputs.

Drop .mp4, .mp3, .wav, .mov, .webm, .m4a, .ogg, .mkv, .avi, or .m4v files into any folder and graphify transcribes them locally with faster-whisper before extraction. Transcripts are cached in graphify-out/transcripts/ so re-runs skip already-transcribed files.

You can also add YouTube links directly:

/graphify add https://www.youtube.com/watch?v=...

yt-dlp downloads audio-only (no video stream, much smaller) and the same Whisper pipeline picks it up from there.

The Whisper prompt is built from your corpus automatically. The coding agent reads the top god nodes from your non-video files and writes a one-sentence domain hint for Whisper itself. No separate API call, no configuration needed.

To use:

pip install 'graphifyy[video]'

This installs faster-whisper and yt-dlp. The default Whisper model is base. Pass --whisper-model medium or --whisper-model large-v3 for higher accuracy.

Audio never leaves your machine. Transcription runs fully locally.

What's new

• Add: Gemini CLI support — graphify gemini install writes a GEMINI.md section and a BeforeTool hook in .gemini/settings.json that fires before file-read tool calls (#105)
• Add: sponsor nudge at pipeline completion — all skill files now print a one-line sponsor link after a fresh build (not on --update runs)

Install / upgrade

pip install --upgrade graphifyy
graphify gemini install   # Gemini CLI users

Full changelog: CHANGELOG.md

What's new

• Add: Cursor support — graphify cursor install writes .cursor/rules/graphify.mdc with alwaysApply: true; graphify cursor uninstall removes it (#137)
• Fix: _rebuild_code() KeyError — git hooks were silently failing on every commit because detected[FileType.CODE] didn't match detect()'s actual return shape (#148)
• Fix: crash on NetworkX 3.2.x — node_link_data() now falls back gracefully on older NetworkX, same shim already used everywhere else (#149)
• Fix: official package clarification in README — graphifyy is the only official PyPI package (#129)

Install / upgrade

pip install --upgrade graphifyy

Re-run graphify hook install to get the fixed git hooks.

Full changelog: CHANGELOG.md

Fixes

• Watch + .graphifyignore: --watch mode now respects .graphifyignore — _rebuild_code was calling collect_files() directly instead of detect(), bypassing ignore patterns (#120)
• Codex PreToolUse hook: now uses systemMessage instead of additionalContext — Codex does not support additionalContext and was returning an error (#121)
• Trae link: corrected from trae.com to trae.ai across all READMEs (#122)
• HTML graph click detection: hover-tracking (hoveredNodeId) replaces unreliable vis.js click params — small/dense nodes now reliably selectable (#82)
• .graphify_python persistence: mkdir -p graphify-out runs before writing .graphify_python; file no longer deleted in Step 9 cleanup — pipx users no longer hit ModuleNotFoundError on follow-up commands (#93)
• Trae skill packaging: skill-trae.md added to pyproject.toml package-data — Trae users were getting ModuleNotFoundError after pip install (#102)
• Extension drift: analyze.py and watch.py now import extension sets from detect.py instead of local copies — Swift, Lua, Zig, PowerShell, Elixir, JSX, Julia, Objective-C files were being misclassified as documents (#109)

Additions

• graphify save-result CLI subcommand — saves Q&A results to memory dir; replaces inline Python blocks in all 6 skill files (#114)
• Korean README added (README.ko-KR.md) (#112)
• Interpreter guard section in skill.md for when graphify-out/ is deleted before follow-up commands (#93)

Refactors

• Dead build_graph() function removed from cluster.py (#109)

Install

pip install graphifyy==0.3.18 && graphify install

• Add: Julia (.jl) support — modules, structs, abstract types, functions, short functions, using/import, call edges, inherits edges (#98)
• Fix: Semantic extraction chunks now group files by directory — reduces missed cross-chunk relationships (#65)
• Fix: `tree-sitter>=0.21` now pinned — prevents silent empty AST output on older tree-sitter versions (#52)
• Add: Progress output every 100 files during AST extraction on large projects (#52)

0.3.12

• Fix: sanitize_label was double-encoding HTML entities in the interactive graph (< instead of <) — removed html.escape() from sanitize_label; callers that inject directly into HTML now call html.escape() themselves (#66)
• Fix: --wiki flag missing from skill.md usage table (#55)

What's new

Fix: Windows Unicode crash (#47)

• Replaced arrow character with -> in all print statements — fixes UnicodeEncodeError on cp1252/Windows consoles

Add: Skill staleness warning (#46)

• graphify install now writes a version stamp alongside the skill file
• Every graphify command checks all platform skill locations and warns if the installed skill is from an older version
• Works across Claude Code, Windows, Codex, OpenCode, OpenClaw, Factory Droid

What's new

Symlink support (#33)

• detect() and collect_files() now accept follow_symlinks=True to traverse symlinked files and directories
• Circular symlink cycle detection prevents infinite recursion
• watch.py now uses collect_files() for consistency

Docs

• Codex skill trigger is $graphify . not /graphify . (#36)

Tests

• 367 tests passing (up from 362)

What's new

C# inheritance extraction (#45)

• DataProcessor : IProcessor now emits inherits edges
• Handles both simple bases (identifier) and generic bases (IList<T> → generic_name)
• Zero false positives — tested on 6,100-file Unity/VaM codebase producing 3,957 edges

graphify query CLI command (#43)

• Query the knowledge graph without Claude Code:

  graphify query "what connects attention to the optimizer?"
  graphify query "what is CfgNode?" --dfs
  graphify query "show auth flow" --budget 500 --graph path/to/graph.json
  

• BFS by default, --dfs for path tracing, --budget N to cap output tokens

Tests

• 362 tests passing (up from 360)

What's new

• Elixir language support — .ex and .exs files now go through AST extraction. Extracts defmodule, def/defp, alias/import/require/use, and the call graph between functions. Same EXTRACTED/INFERRED tagging as every other language.

What's new

• .docx and .xlsx support — Office documents now work in graphify. Install the optional extra:

  pip install graphifyy[office]
  

  • .docx: converted to markdown via python-docx (headings, lists, tables preserved)
  • .xlsx: each sheet converted to a markdown table via openpyxl
  • Converted files are saved to graphify-out/converted/ as .md sidecars — Claude reads them as normal documents
  • Graceful fallback if [office] is not installed: file is skipped with an install hint

What's new

• Windows support — graphify install now auto-detects Windows and installs a PowerShell-compatible skill variant (skill-windows.md). All bash-specific commands replaced: which/head/tr → Python detection, rm -f → Remove-Item, mkdir -p → New-Item, python3 → python
• Manual override: graphify install --platform windows on any platform

What's new in v0.2.0

Mine the "why"

Code comments and docstrings are now first-class graph nodes. Module, class, and function docstrings are extracted automatically. Inline comments tagged # NOTE:, # IMPORTANT:, # HACK:, # WHY:, # RATIONALE:, # TODO:, # FIXME: become rationale_for nodes connected to the code entity they explain. Doc files now extract design rationale and architectural decisions too - not just structure, but why things were built that way.

Confidence scores on every edge

Every INFERRED edge now carries a confidence_score (0.0-1.0). EXTRACTED edges are always 1.0. INFERRED edges score 0.4-0.9 based on how certain the model was. AMBIGUOUS edges score 0.1-0.3. You know not just what was guessed but how confident.

Semantic similarity edges

Cross-file conceptual links with no structural connection. Two functions solving the same problem without calling each other, a class in code and a concept in a paper describing the same algorithm. Tagged semantically_similar_to with a confidence score.

Hyperedges

Group relationships connecting 3+ nodes that pairwise edges cannot express. All classes implementing a shared protocol, all functions in an auth flow, all concepts from a paper section forming one coherent idea. Stored in a top-level hyperedges array in graph.json.

Git hooks - post-checkout added

graphify hook install now installs both post-commit (existing) and post-checkout (new). The graph rebuilds automatically when you switch branches, not just when you commit.

Claude Code PreToolUse hook

graphify claude install now also writes a .claude/settings.json hook that fires before every Glob and Grep call. If a graphify knowledge graph exists, Claude is reminded to check it before searching raw files. Ensures the graph is actually used during research, not bypassed.

Obsidian output opt-in

Obsidian vault generation (--obsidian) is now opt-in. Default output is graph.html + graph.json + GRAPH_REPORT.md. Large repos were generating thousands of files by default.

Upgrade

pip install --upgrade graphifyy
graphify install

First stable release.

What's in v1

• Knowledge graph from any mix of code, papers, docs, and images
• Leiden community detection with cohesion scores
• God nodes and surprising connections ranked by composite score
• Honest audit trail: every edge tagged EXTRACTED, INFERRED, or AMBIGUOUS
• Interactive HTML visualization
• Obsidian vault export with graph.canvas
• Wiki export (--wiki): Wikipedia-style articles per community for agent navigation
• GraphRAG-ready graph.json persistent across sessions
• SHA256 cache: re-runs only process changed files
• --watch: auto-rebuilds graph on code changes without LLM
• git commit hook: graphify hook install for per-commit rebuilds
• MCP stdio server (--mcp)
• Neo4j export (--neo4j)
• SVG and GraphML export

Install

pip install graphifyy && graphify install

Then in Claude Code: /graphify .

Worked examples

Reproducible benchmarks with input files and real output in worked/:

• worked/httpx/ - 6-file Python library
• worked/mixed-corpus/ - code + paper
• worked/karpathy-repos/ - 52-file corpus, 71.5x token reduction

v2 plans

• Hypergraph support (hyper-edges connecting more than 2 nodes)
• Poincare ball embeddings for hierarchical corpora
• Deeper agentic workflow integration