codegraph-java 0.1.0

package/dist/ui-server/api/stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../../../src/ui-server/api/stats.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAqB7C,MAAM,WAAW,cAAc;IAC7B,+EAA+E;IAC/E,SAAS,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAC;IAChB,iFAAiF;IACjF,SAAS,EAAE,OAAO,CAAC;CACpB;AAWD,wBAAgB,aAAa,CAC3B,EAAE,EAAE,SAAS,EACb,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAChB,cAAc,CA6BhB;AAED,+EAA+E;AAC/E,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED,wBAAgB,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAsDtE"}

package/dist/ui-server/api/stats.js

@@ -0,0 +1,164 @@
+"use strict";
+/**
+ * `GET /api/stats` — what this index is, and how much to trust it.
+ *
+ * The viewer's top bar shows a couple of numbers from here, but the reason the
+ * endpoint carries more than that is honesty: an index can be truncated
+ * (`state: "indexing"` after a killed run), built by an older extractor, or
+ * simply old. A reader that draws confident graphs over a half-built index is
+ * the failure mode worth designing against, so the state travels with the
+ * counts rather than being something the UI has to ask for separately.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blastScaleFor = blastScaleFor;
+exports.resetBlastScaleCache = resetBlastScaleCache;
+exports.buildStats = buildStats;
+const path = __importStar(require("path"));
+const wire_1 = require("./wire");
+/**
+ * How many of the index's most-depended-on symbols the blast scale measures.
+ *
+ * The Symbol view's blast bar is a comparison — "wide for this repo, or
+ * narrow?" — so it needs a denominator, and the honest one is the widest
+ * radius in the index. Measuring all of them means a depth-3 traversal per
+ * symbol, which on a large repo is minutes. Measuring the most-depended-on
+ * ones costs 24 traversals and finds the widest radius in practice: a radius
+ * is grown by dependents, so the symbol with the widest one is very nearly
+ * always near the top of that list.
+ *
+ * "Very nearly always" is not "always" — a symbol with three dependents that
+ * each have three hundred can beat them — so the scale is a floor, not a
+ * claim: {@link blastScaleFor} reports it as `sampled`, and the viewer raises
+ * it whenever the symbol on screen exceeds it rather than drawing past 100%.
+ */
+const BLAST_SCALE_SAMPLE = 24;
+/**
+ * The denominator for the Symbol view's blast bar.
+ *
+ * Computed once per process and cached against the index's build stamp: it is
+ * a property of the whole graph, every Symbol view needs it, and re-deriving it
+ * per request would put 24 traversals in front of every screen.
+ */
+let cachedScale = null;
+function blastScaleFor(cg, projectRoot, edgeCount) {
+    // Keyed on the project AND the index's stamp AND its edge count, so a
+    // re-index (or a sync that only moved edges) invalidates it and two indexes
+    // opened by one process cannot share a denominator. A stale one would
+    // silently rescale every bar in the app.
+    const key = `${projectRoot}\u0000${cg.getLastIndexedAt() ?? 0}:${edgeCount}`;
+    if (cachedScale?.key === key)
+        return cachedScale.value;
+    const top = cg.getTopDependedOn(BLAST_SCALE_SAMPLE);
+    let maxWithinHops = 0;
+    for (const candidate of top) {
+        try {
+            const subgraph = cg.getImpactRadius(candidate.nodeId, wire_1.BLAST_DEPTH);
+            maxWithinHops = Math.max(maxWithinHops, subgraph.nodes.size - 1);
+        }
+        catch {
+            // A candidate that cannot be traversed (a node the edge table names but
+            // the node table lost) narrows the sample; it must not fail the screen.
+        }
+    }
+    const value = {
+        maxDirect: top[0]?.dependents ?? 0,
+        maxWithinHops,
+        hops: wire_1.BLAST_DEPTH,
+        sampled: top.length,
+        estimated: true,
+    };
+    cachedScale = { key, value };
+    return value;
+}
+/** Drop the memoised scale — for tests, which build a fresh index per case. */
+function resetBlastScaleCache() {
+    cachedScale = null;
+}
+function buildStats(cg, projectRoot) {
+    const stats = cg.getStats();
+    const build = cg.getIndexBuildInfo();
+    return {
+        project: {
+            root: projectRoot,
+            name: path.basename(projectRoot) || projectRoot,
+        },
+        index: {
+            /**
+             * `complete` is the only good value. `indexing` means a run was killed
+             * part-way and the graph on disk is a truncated one; `partial`/`failed`
+             * mean the run finished but dropped files. `null` predates the marker.
+             */
+            state: cg.getIndexState(),
+            lastIndexedAt: cg.getLastIndexedAt(),
+            /** Built by an older extractor — a re-index would add data no migration can. */
+            stale: cg.isIndexStale(),
+            version: build.version,
+            extractionVersion: build.extractionVersion,
+            backend: cg.getBackend(),
+            journalMode: cg.getJournalMode(),
+            /** References still waiting to resolve; > 0 means edges are still missing. */
+            pendingReferences: cg.getPendingReferenceCount(),
+            generatedFiles: cg.getGeneratedFileCount(),
+            watching: cg.isWatching(),
+            watcherDegraded: cg.isWatcherDegraded(),
+        },
+        graph: {
+            nodes: stats.nodeCount,
+            edges: stats.edgeCount,
+            files: stats.fileCount,
+            nodesByKind: stats.nodesByKind,
+            edgesByKind: stats.edgesByKind,
+            filesByLanguage: stats.filesByLanguage,
+            dbSizeBytes: stats.dbSizeBytes,
+            walSizeBytes: stats.walSizeBytes,
+        },
+        frameworks: cg.getDetectedFrameworks(),
+        /**
+         * The thresholds the API itself applied, so the viewer's copy ("hub · N",
+         * "confidence < 0.6") stays in step with the data instead of hard-coding a
+         * second copy of the same numbers.
+         */
+        thresholds: { hub: wire_1.HUB_THRESHOLD, uncertainBelow: wire_1.UNCERTAIN_BELOW },
+        /**
+         * The denominator the Symbol view's blast bar is drawn against, so one
+         * symbol's radius reads as wide or narrow *for this repo* instead of as a
+         * bare number. See {@link blastScaleFor} for what "sampled" costs and
+         * concedes.
+         */
+        blastScale: blastScaleFor(cg, projectRoot, stats.edgeCount),
+    };
+}
+//# sourceMappingURL=stats.js.map

package/dist/ui-server/api/stats.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats.js","sourceRoot":"","sources":["../../../src/ui-server/api/stats.ts"],"names":[],"mappings":"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"}

package/dist/ui-server/api/steps.d.ts

@@ -0,0 +1,274 @@
+/**
+ * `GET /api/steps` — what happens from here: a screen, a handler or any
+ * symbol as the ANCHOR, and everything it sets in motion drawn as typed steps.
+ *
+ * The Screens view (`screens.ts`) is already a picture of steps with one step
+ * type: it folds `HomeScreen → ItemsGrid → ItemCard → openObjectDetail` into
+ * one arrow labelled with its condition, because the reader wants the
+ * transition, not the plumbing. This endpoint keeps that fold and widens the
+ * set of things worth a box. Walking FORWARD from the anchor over calls,
+ * renders, handler bindings and navigations, a node is a step when it is:
+ *
+ * - a **screen** (a route reached over a `navigates` edge),
+ * - a **trigger** — a function wired as a value (`onPress={handleX}`,
+ *   `addListener('x', handleX)`), the user's or the platform's way in,
+ * - a **bridge** call — the language changes under the call, JS → native
+ *   (the React Native bridge resolver's edges, or any family crossing),
+ * - a native **event** landing back in JS (`sendEvent(withName:)` → the
+ *   listener, via the RN event channel),
+ * - a **store** action — a function in a store file, the state it writes,
+ * - an **effect** — a call that leaves the index into the network, storage,
+ *   the device or telemetry, drawn as its own box beside the function that
+ *   makes it.
+ *
+ * Everything else — hooks, helpers, services, the components between a
+ * screen and its handlers — is `via`: listed on the link, never a box. The
+ * branch conditions along the folded chain join into the link's `when`, read
+ * from the source at request time exactly as the Screens view reads them.
+ *
+ * The picture is finite because it is ANCHORED and CAPPED, not because the
+ * graph is small: a bounded depth in steps, a bounded fan-out per node, a
+ * bounded number of nodes folded per step, and hubs and shared chrome (a top
+ * bar rendered on ten screens) are dead ends rather than paths. Every cap
+ * that fired is reported on the step it fired at, so a short picture never
+ * reads as "nothing else happens here".
+ *
+ * Read from the graph at request time, never cached: the `when` labels and
+ * the effect sites are read from the source as it stands.
+ */
+import type CodeGraph from '../../index';
+import type { Language, Node } from '../../types';
+import type { SiteTrigger } from '../../graph/branch-guards';
+import { type WireProgram } from './program';
+import { type WireNodeRef } from './wire';
+export type WireStepKind = 'anchor' | 'screen' | 'trigger' | 'bridge' | 'event' | 'store' | 'effect';
+export type WireStepLinkKind = 'calls' | 'navigates' | 'handler' | 'bridge' | 'event' | 'store' | 'effect';
+export interface WireStepSite {
+    file: string;
+    line: number;
+    /** `push /capture`, `calls`, `client.post` — what the site does, in a word or two. */
+    text: string;
+    /**
+     * What the site passes, as written and abbreviated: `'userEmail',
+     * values.email`, `'/auth/login', { email, password }`. '' for an empty
+     * argument list; absent when the source could not be read.
+     */
+    args?: string;
+    /**
+     * The conditions THIS site runs under — the whole chain's, joined; '' when
+     * unconditional. A link with several sites is several scenarios (four
+     * early returns that each go home), and the viewer lists them as rows with
+     * the clauses they share factored out; the link's own `when` is only the
+     * summary of all of them.
+     */
+    when: string;
+    /** What fires THIS site, when it differs from the link's first. */
+    trigger?: WireStepTrigger;
+    /** For a response site: the status code it sends, when literal (`res.status(404)`, `throw new NotFoundException`). */
+    status?: number;
+    /**
+     * The decision the site's INNERMOST condition belongs to, when one was
+     * read. Two sites that agree on `branch` and disagree on `arm` are the two
+     * ways of one fork — which a joined condition string can never say, however
+     * exactly one reads as the other's negation. It is what lets a picture draw
+     * `resolvePostLoginRoute → /home` and `→ /welcome` as one choice with two
+     * answers instead of two lines that each carry the whole predicate.
+     */
+    decision?: WireStepDecision;
+}
+/** One arm of one decision, as the site that runs under it records it. */
+export interface WireStepDecision {
+    /** Where the branching construct starts (`line:column`) — the fork's identity. */
+    branch: string;
+    /** The decision as a reader says it, always positive: `await hasSeenWelcome(…)`. */
+    on: string;
+    /** THIS arm's own condition — an `if` and its `else` differ here and nowhere else. */
+    arm: string;
+    form: 'if' | 'switch' | 'ternary' | 'try';
+    /** The arm taken when the condition does NOT hold — the `else` side. */
+    not?: true;
+}
+/** What fires a step or a link: the event it is written under, and the function that writes it there. */
+export interface WireStepTrigger extends SiteTrigger {
+    /** The function the binding is written in — `LoginButton` for its `onPress`. */
+    in: string;
+}
+export interface WireStep {
+    /** The node's id, or `effect:<function id>:<api>` for a call leaving the index. */
+    id: string;
+    kind: WireStepKind;
+    /** The step the picture starts from. A screen anchor keeps `kind: 'screen'`. */
+    anchor: boolean;
+    /** Null only for an effect, which is a call site rather than a symbol. */
+    node: WireNodeRef | null;
+    /** `/capture/review`, `handleApproveAllImages`, `client.post`. */
+    label: string;
+    /** The component for a screen, the file for a symbol, the category and caller for an effect. */
+    sub: string;
+    /** Steps from the anchor: the row. */
+    depth: number;
+    /**
+     * Why the walk did not go on from this step, when it did not: a cap it hit
+     * (`depth`, `fan-out`, `folded`, `steps`), or `screen` — another screen, or
+     * an endpoint reached across a tier, is a chapter of its own, drawn but not
+     * entered unless `through` asks.
+     */
+    cut: 'depth' | 'fan-out' | 'folded' | 'steps' | 'screen' | 'component' | null;
+    /** The event name a native event step arrived on (`onZipComplete`) — the first, when several land here. */
+    event?: string;
+    /** Every event that lands on this step, in the order the walk met them. */
+    events?: string[];
+    /** For a handler: what fires it — the first binding the walk met. */
+    trigger?: WireStepTrigger;
+    /**
+     * The step's place in its row, in the code's order: by the position of the
+     * hop that first reached it, a hop written inside another site's arguments
+     * counting before that site. The viewer lays the row out in it.
+     */
+    order?: number;
+    /**
+     * For a SCREEN anchor's picture: the region of the screen this step belongs
+     * to — the top-level component (or hook) of the screen's tree the walk first
+     * reached it through, the screen's own component for a call written in the
+     * screen body, and the first-reaching parent's region for everything deeper.
+     * The viewer lays a screen's picture out by these: a screen is a set of
+     * handlers with no order between them, so distance alone put ninety boxes on
+     * one row. Absent for an endpoint's or a function's picture, whose rows
+     * already read in the code's order.
+     */
+    region?: {
+        id: string;
+        label: string;
+    };
+    /**
+     * For a screen or an endpoint: its path and the symbol that serves it — the
+     * component a screen renders, the handler an endpoint runs. `endpoint` when
+     * the route leads with an HTTP verb (`POST /users`); `inline` when the
+     * handler is an anonymous function at the registration site, so the route
+     * itself stands in for it and `component` is null.
+     */
+    screen?: {
+        path: string;
+        component: WireNodeRef | null;
+        endpoint: boolean;
+        inline: boolean;
+    };
+    /**
+     * For an effect: the calls one function makes into one category — `api` is
+     * the first, `apis` all of them — and the function that makes them. A
+     * database call also says the model / table it touches when the call
+     * names one, and whether it reads or writes; a response box lists the
+     * status codes its sites send.
+     */
+    effect?: {
+        api: string;
+        apis: string[];
+        category: string;
+        by: WireNodeRef;
+        line: number;
+        model?: string;
+        access?: 'read' | 'write';
+        statuses?: number[];
+    };
+}
+export interface WireStepLink {
+    id: string;
+    from: string;
+    to: string;
+    kind: WireStepLinkKind;
+    /** The symbols folded between the two steps, in order. */
+    via: WireNodeRef[];
+    /** Conditions along the whole chain, joined; '' when unconditional. */
+    when: string;
+    /** How the last hop was established when it was not a plain call — `via rn-event-channel · registered at file:line`. */
+    label: string;
+    /** The call the first hop is written inside the arguments of — `res.json` for a token signed while building the reply. */
+    within?: string;
+    synthesized: boolean;
+    uncertain: boolean;
+    sites: WireStepSite[];
+    /** What fires the first site, when something binds it to an event. */
+    trigger?: WireStepTrigger;
+}
+export interface WireStepsPayload {
+    anchor: WireNodeRef;
+    /** Other symbols that share the anchor's name, when it was given by name. */
+    ambiguous: WireNodeRef[];
+    /**
+     * What the index is a picture of, decided from its routes: an `app` of
+     * screens, an `api` of endpoints, or a `web` app with both. The viewer's
+     * words (screen / endpoint, store action / data) follow it.
+     */
+    project: 'app' | 'api' | 'web';
+    steps: WireStep[];
+    links: WireStepLink[];
+    /**
+     * The same walk read in the code's ORDER: the anchor's body as a rail that
+     * forks where the code forks. Built from the same records the links are, so
+     * the two readings hold the same steps; null when the anchor has no body to
+     * read (nothing was recorded).
+     */
+    program: WireProgram | null;
+    /**
+     * Which reading to open with: the code's order for a handler, an endpoint or
+     * any function; the tree for a screen, where handlers fire on events and
+     * have no order between them. The URL's `view` overrides it.
+     */
+    defaultView: 'order' | 'tree';
+    depth: number;
+    limit: number;
+    /** Screens reached from the anchor were entered rather than drawn as boundaries. */
+    through: boolean;
+    truncated: {
+        /** Steps not added because the picture reached `limit`. */
+        steps: number;
+        /** Folded walks that stopped at a hub (fan-in ≥ the hub threshold). */
+        hubs: number;
+        /** Folded walks that stopped at shared chrome (a component rendered by several screens). */
+        chrome: number;
+    };
+    index: {
+        lastIndexedAt: number | null;
+        edges: number;
+        files: number;
+    };
+    timing: {
+        elapsedMs: number;
+    };
+}
+export declare const DEFAULT_DEPTH = 8;
+export declare const MAX_DEPTH = 14;
+export declare const DEFAULT_LIMIT = 120;
+export declare const MAX_LIMIT = 400;
+/**
+ * JS → native is a bridge call; native → JS is an event. Anything else is one
+ * family — unless the edge itself says which way it crosses: a synthesized
+ * channel (`resolution/tier-synthesizer.ts`) marks a client's request onto its
+ * own route `client→server`, a socket message back `server→client`, and a
+ * queue job or a bus event as a `channel` whose landing is an arrival; a
+ * server action called from a client file is marked `client→server` at
+ * request time, by its directive.
+ */
+export declare function crossing(from: Language, to: Language, meta?: Record<string, unknown>): 'bridge' | 'event' | null;
+/**
+ * A file that holds state: a store, a slice, a reducer. The graph has no
+ * "store" kind — a Zustand action is an ordinary function node — so the file
+ * is the evidence, and the legend says so.
+ */
+export declare const STORE_FILE: RegExp;
+export declare function isStoreFile(file: string): boolean;
+/**
+ * What a call is when it leaves the index, by the reference text alone — the
+ * mobile app's table, kept for callers that have no language in hand. The
+ * Steps walk itself classifies on the call AS WRITTEN with the language and
+ * the project kind (`effects.ts`).
+ */
+export declare function effectCategory(referenceName: string): string | null;
+export declare function buildSteps(cg: CodeGraph, projectRoot: string, query: URLSearchParams): Promise<WireStepsPayload>;
+/**
+ * What kind of project the picture is of, by what its routes are: endpoints
+ * (`POST /users`) make an API; screens with navigation between them make an
+ * app; both — pages and the endpoints behind them — make a web app.
+ */
+export declare function projectKind(routes: readonly Node[], navigates: number): 'app' | 'api' | 'web';
+//# sourceMappingURL=steps.d.ts.map

package/dist/ui-server/api/steps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"steps.d.ts","sourceRoot":"","sources":["../../../src/ui-server/api/steps.ts"],"names":[],"mappings":"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"}