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 cloneof 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
graphifyyv0.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.