3 Commits

Include renames

Author	SHA1	Message	Date
Colby McHenry	2a0c6dc58f	feat(ui): the type hierarchy — what a type is built on, and what dispatches through it (CG-58) ... A vertical tree above the members outline for classes, interfaces, structs, traits, protocols, enums, unions and type aliases: ancestors above (the whole chain, not just the direct parent), the focus in accent, subtypes below indented per level. `extends` draws solid, `implements` dashed; a synthesized edge — Go's implicit interface satisfaction — draws dashed wider and carries the site it was wired at, so a relation the resolver inferred never reads like one the source wrote down. For an interface the fan below IS the set of runtime targets a call can land on, and a type with eight or more implementers leads with that in a sentence. Members that redeclare an ancestor's are marked in the outline. The walk lives in `src/graph/type-hierarchy.ts`, following CG-50/CG-51: shared computation in `src/graph/`, presentation in the caller. Its `countImplementers` is now also what `ToolHandler.buildPolymorphicBoundaries` counts with, so "N types implement X" is the same N whether an agent reads it or a person does. `/api/node` carries the block as `hierarchy` rather than a second endpoint — it is part of the Symbol view's first paint, and gated to types, so a function costs one kind test. Layout is arithmetic (24px rows, 22px indent, orthogonal connectors computed from the two): no ResizeObserver, same payload → same picture. The header's `extends X` / `implemented by …` chips are suppressed while the tree is on screen — two renderings of one relation in one column is how a reader ends up trusting neither. `TypeHierarchy` is exported from `@colbymchenry/codegraph-ui` and takes its data as a prop, so a host holding a `WireSymbolPayload` renders it without a second read.	2026-08-27 07:14:55 -05:00
Colby McHenryandClaude Opus 5	5cecaabfc2	feat(ui): the Symbol view — callers, gutter-ported source, line-anchored callee rail (CG-44) ... The core screen of `codegraph ui`: who calls a symbol on the left, its verbatim body in the middle with a port on every line that has an outgoing edge, and what it calls on the right — each callee row placed beside the line that makes the call, with a hairline connector between them. The callee rail is the part that is not a list. A row wants to sit at the centre of its first call-site line and is pushed down only when that would collide with the row above, so the rail keeps source order; the connector still runs to the real line, so the displacement is visible rather than silent. Positions come from measuring the laid-out DOM, so they are recomputed on resize, on font load and whenever a fold opens. Honesty is carried in the drawing, not in a footnote: a filled port means the resolver matched something on that line and a hollow one means it only guessed; uncertain connectors are dashed and their targets fold away behind their count; synthesized edges are dashed differently and tagged with the mechanism that made them; references that leave the index are text with a soft underline rather than links to nowhere, and they are counted. Long bodies keep their head plus a window round every call site — windowed on graph edges only, since a function calling `console.log` two hundred times would otherwise window round every line and buy nothing. Containers over 80 lines show a members outline with per-member fan-in/fan-out instead of 700 lines of braces. Two small additions to the read-only API this needed: * `/api/node` gives every outline member its own fanIn/fanOut (two batched queries for the whole outline). A class's own fan-out is nearly always zero because its methods do the calling, so without these the outline cannot say which member carries weight. * `/api/stats` gains `blastScale` — the denominator the blast bar is drawn against, so one symbol's radius reads as wide or narrow *for this repo*. It is measured across the index's 24 most-depended-on symbols (found with a new `getTopDependedOn`, distinct dependents rather than edges), memoised against the index stamp, and reported as sampled; a symbol wider than the sample becomes the scale instead of overflowing the track. Verified against a real index in a real browser: parity with the prototype on `CodeGraph.sync` (259 lines, 27 callee rows, no overlaps), `GraphTraverser` (20-member outline), a 773-line function (26 windows, 78 connectors), light and dark, hover linking in both directions, keyboard-only navigation, and reflow on resize and on fold toggles. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-08-27 00:09:47 -05:00
Colby McHenryandClaude Opus 5	951ba3678a	feat(ui): read-only JSON API over the index for the viewer (CG-42) ... Six endpoints under `/api/`, one per screen, each answering in a single round-trip in the spirit of `codegraph_explore` — the viewer should never have to ask a follow-up question to finish drawing a pane: /api/stats index state, graph counts, frameworks /api/search?q= ranked, kind-grouped symbol search /api/node/<id> rails, members, tests, blast radius /api/source?file=&from=&to= verbatim source + a drift verdict /api/file/<path> outline and import rails /api/routes URL -> handler, when there is one It is a reader of the existing schema: no extraction or resolution changes. It mounts on the `api` seam `startUiServer` already exposed, so it sits behind the CG-41 loopback boundary — Host allowlist, no CORS headers, GET/HEAD only — and every read out of the repository goes through `resolveProjectFile`, ahead of the index lookup so a traversal is refused as a traversal rather than reported as "not indexed". Three properties the endpoints are built around: - No N+1. The engine's busiest symbol has 545 incoming edges; resolving those one `getNode` at a time is 545 queries. Every edge list is resolved with one batched lookup, which needed four additive read-only query methods (`getNodesByIds`/`getFanIn`/`getFanOut` on `CodeGraph`, plus batched outgoing/incoming edge fetches and unresolved-reference reads). `/api/node` on `LRUCache.get` answers in ~10 ms. - Capped lists, honest totals. 545 callers cannot all be rows, so caller groups cap at 300 — but `total` is always the real number, and the ordering puts the useful end first (same file, then production code, then tests). Every count in the payload is the length of a list the same payload returns, so a badge and its rail cannot disagree. - Nothing overclaims. Source that drifted on disk since the last index sync is omitted rather than sliced at line ranges that may now point at a different symbol; calls that leave the index are counted instead of silently shortening the callee rail; imports that never resolved are named; and a test-coverage claim reports whether its search actually finished. `/api/routes` says a project simply is not routed, and refuses a `limit` below three because the engine's manifest would answer that question wrongly. Tests: 45 against a real indexed fixture over a real loopback server, covering every endpoint's shape, the drift verdict in all three places it surfaces, search ranking and the filter grammar, the refusals, and the capping/latency behaviour at 500 callers. The issue's own acceptance case — `lru-cache.ts` `get` under 100 ms — runs against this repo's index when one is present. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-08-26 23:33:30 -05:00