← All tests

Graphify — sausalito-3d code graph

Slate 3: code graph of the sausalito-3d repo, real navigation questions

2026-11-20FINDS - TESTSFind #13 (Graphify)

Try it

Demo — live-index.html

Report

Graphify (find #13) on sausalito-3d — FINDS - TESTS slate 3, test 3

Date: 2026-11-20 · Tester: FINDS - TESTS subagent · All sources read-only; nothing outside this test folder was modified.

Subject & provenance

  • Find #13 = Graphify-Labs/graphify — confirmed against the Finds Library record ("Graphify — Graphify-Labs/graphify", creator Graphify-Labs) and the project's own site: Graphify Labs' code knowledge graph for AI agents; open-source CLI on PyPI as graphifyy (double-y), hosted product at graphify.com. The brief's repo name was correct.
  • Upkeep (checked 2026-11-20): repo created 2026-04-03; ~151k stars, ~14.5k forks; Apache-2.0 (relicensed from MIT in July 2026); last push 2026-11-20 (same day as this test); installed/tested version graphifyy 0.9.113. Extremely active — the opposite of abandonware.
  • Install note: git clone of the repo failed twice in this sandbox (pack corruption over the proxy); the documented PyPI install (pip install graphifyy) worked and is what was tested. Extraction ran fully locally: graphify extract src --code-only (tree-sitter AST, no API key, no LLM). The optional LLM semantic pass was not run (no API key in the sandbox) — a stated limitation; it might add data-flow edges the AST pass lacks.

Source hunt & adaptation

The GitHub repo irostyslav/sausalito-3d is private and the sandbox has no GitHub auth, but the full source was on disk: ~/workspace/isometric-sausalito/sausalito-3d-repo/ — the project's local repo, whose index.html is byte-identical to the live site (fetched https://sausalito-3d.pages.dev on 2026-11-20; both 3,696,975 bytes, MD5 f855a0d5663de791368d4b25cfd6d8ba). The app is a single self-contained HTML file by design ("No build step", per its README), so the fallback adaptation and the primary source coincide: the file's scripts were extracted verbatim into src/:

Extracted file Origin Size Lines What it is
src/main.js inline <script> 83.8 KB 894 The application code — one async __init() containing everything
src/vendor-three.js base64 src= blob 865 KB 4,680 Minified three.js + OrbitControls bundle
src/data-buildings.js base64 src= blob 1.81 MB 1 Generated data: window.SAUS — terrain height grid (315×397), 4,212 buildings, 2,105 roads
src/data-labels.js base64 src= blob 24.5 KB 2 Generated data: window.SAUS_LABELS — street names/numbers

(The page also has 5.5 KB of CSS and the HTML shell; neither is code Graphify models.) Reconciliation: building/road counts match the deck.gl test's independent extraction (4,212 / 2,105); the 894-line main script matches the known size of the live app's hand-written code.

Graph build (Graphify's own method)

graphify extract src --code-only → 33 s, zero token cost. Then graphify cluster-only src --no-label for the report/viz. Outputs (as produced) copied to graphify-out/: graph.json, GRAPH_REPORT.md, graph.html.

Graph stats — full corpus (src/): 1,334 nodes · 2,572 edges · 104 communities. - Nodes are files and functions (no classes in this codebase; no variable/data nodes at all). By file: vendor-three.js 1,288 · main.js 44 · data files 1 each. - Edges: contains 1,196 · calls 1,181 · indirect_call 190 · method 5. Provenance: 2,382 EXTRACTED · 190 INFERRED (the indirect calls, avg confidence 0.85). - The two data files yielded no symbols (Graphify warns about this honestly at extract time). - God nodes are useless at this scope: constructor() 92 edges, ge() 57, then __init() 42 — 9 of the top 10 are minified three.js internals.

Graph stats — app-only scope (supplementary run, mainonly/): extracting main.js alone gives 44 nodes · 67 edges · 8 communities, and god nodes instantly become the real architecture: __init() 42, refreshTimeTarget() 8, frame() 5, tickTime()/updateFerry()/elevAt() 4. Scoping is the single biggest quality lever (exclude vendor + generated data, e.g. via .graphifyignore).

What the graph holds for main.js: 43 of 49 declared named functions are nodes. The 6 missing ones are exactly the six IIFE blocks — (function buildTerrain(){})() L93, buildWindows L261, buildRoads L312, buildLamps L344, buildTrees L504, hero L570 — Graphify creates no node for an immediately-invoked function expression, although plain declarations nested inside them (ribbon, quad, alongRoad) are captured. Only 24 calls edges exist among main.js functions; calls made from inside IIFE bodies or __init's inline code are unattributed or lost, and there are zero edges from main.js code into the data files (data is read via the window.SAUS global, which is not modelled).

Navigation Q&A — results

Full protocol (graph answer first, ground truth second, per-question evidence) in qa/qa-scoring.md; raw tool outputs in qa/*.txt.

# Question Score
Q1 Where does day/night switching live and what does it touch? Partially correct — call chain exact; effects (sun/sky/fog/glow materials) invisible, no variable nodes
Q2 What builds the road geometry? Wrong — buildRoads is an IIFE, not a node; query misleads toward three.js addGeometry()
Q3 Where do building heights come from? Unanswerable — heights are data (b.h in the generated data file); graph has no data edges
Q4 What reads the heightmap? Partially correct — elevAt + 3 of 5 caller blocks; both misses inside IIFEs; direct D.heights read invisible
Q5 Which code runs at startup in what order? Unanswerable — query matched vendor order(); contains-edges give membership, never sequence
Q6 What moves the ferry and the cars? Partially correct — ferry wiring exact; addCars is an orphan node with no call edges
Q7 How do street labels get drawn and updated? Partially correct — right names (streetMat→canvasTex, frame→updateLabels); creation block and mechanism invisible

Tally: 0 correct · 4 partially correct · 1 wrong · 2 unanswerable.

Pattern: every question whose answer is a call chain between named functions scored well; every question whose answer lives in data, variables, IIFE bodies, or execution order failed. Those four categories are precisely where a single-file, procedural, vibe-coded app keeps its logic.

Effort log (2026-11-20)

  • Source hunt + live-site identity check: ~10 min (local repo found at step 2 of the hunt order).
  • Script extraction + inventory: ~5 min (scripted, verbatim).
  • Graphify install (pip) + docs: ~10 min (incl. two failed git clones, ~4 min wasted).
  • Extraction + clustering: 33 s compute; stats analysis ~10 min.
  • Q&A protocol (13 graph tool calls + ground-truth reading of ~10 code sections): ~35 min.
  • Total ≈ 1 h 10 min, of which Graphify itself needed ~1 minute of compute.

Draft verdict

Reuse later — with a scoping rule, not as-is. Graphify is a real, well-kept tool (same-day commits, honest provenance tags, zero-cost local AST pass, query/path/explain/affected tooling that works exactly as documented), and on app-only scope its god-node list is a genuine architecture summary. But on Ros's flagship vibe-coded project it answered 0 of 7 navigation questions fully: the codebase's style — one file, everything inside one __init, build steps as IIFEs, behaviour driven by baked data files — sits exactly in Graphify's blind spots, and the unscoped graph is 97% minified-vendor noise. It earns a place for modular codebases (multi-file TS/Python projects — e.g. the upstream isometric-nyc tree in this same workspace, or the Finds Library app), run scoped to app files with vendor/generated data ignored, where its call-graph answers are fast and trustworthy. For single-file apps like sausalito-3d, a grep + the repo's own CLAUDE.md still beats it. Re-test if Graphify adds IIFE/variable/data-flow coverage or if a modular Ros project needs navigation help.

Test-record block (for Finds Library find #13)

  • Subject: Graphify (Graphify-Labs/graphify), CLI graphifyy v0.9.113, Apache-2.0.
  • What ran: 2026-11-20 — local AST extraction (--code-only) over the extracted source of sausalito-3d (byte-identical to the live site), full-corpus and app-only scopes; 7 navigation questions answered graph-first via explain/query/affected, then scored against code ground truth.
  • Outcome: Graph built cleanly (1,334 nodes / 2,572 edges full; 44 / 67 app-only). Q&A: 0 correct, 4 partially, 1 wrong, 2 unanswerable. Blind spots: IIFEs (6 build blocks missing incl. buildRoads), no variable/data nodes, no execution order, vendor noise unscoped.
  • Output reference: ~/workspace/finds-tests/graphify-sausalito-2026-11-20/ — report.md, graphify-out/ (graph.json, GRAPH_REPORT.md, graph.html), qa/qa-scoring.md + raw outputs, src/ (extracted source).
  • Reuse proposal: Reuse later — scoped to app files, for modular codebases; not recommended for single-file/procedural apps. Not a standing tool for sausalito-3d itself.