@armanckeser/downstream 0.0.0-stage → 0.1.0

package/dist/server/analyze/py.js

@@ -0,0 +1,346 @@
+// Python without a type checker: declarations from indentation, calls resolved
+// through each file's imports. Good enough to draw the flow and answer
+// "what is this?" on hover; the agent fills in what static reading can't see.
+import path from "node:path";
+export const isPy = (file) => file.endsWith(".py") || file.endsWith(".pyi");
+const ROUTE = /^\s*@\s*[\w.]+\.(get|post|put|patch|delete|head|options|route|api_route|websocket)\s*\(\s*(?:path\s*=\s*)?["']([^"']+)["']/;
+const COMMAND = /^\s*@\s*[\w.]*\b(command|group|task|shared_task|receiver|on_event|listener|handler)\b/;
+const NOT_CALLS = new Set([
+    "if", "elif", "while", "for", "return", "yield", "not", "and", "or", "in", "is", "lambda", "with", "assert", "del", "await", "print", "len", "range",
+    "str", "int", "float", "bool", "dict", "list", "set", "tuple", "frozenset", "bytes", "isinstance", "issubclass", "super", "getattr", "setattr", "hasattr",
+    "type", "object", "enumerate", "zip", "map", "filter", "sorted", "reversed", "min", "max", "sum", "any", "all", "abs", "round", "open", "repr", "iter", "next",
+    "id", "hash", "vars", "dir", "callable", "except", "raise", "def", "class", "import", "from", "as", "pass", "else", "try", "finally", "case", "match",
+]);
+/** Blank out strings and comments, keeping every character's position, so regexes see only code. */
+export function stripPy(text) {
+    let out = "";
+    let i = 0;
+    while (i < text.length) {
+        const c = text[i];
+        if (c === "#") {
+            while (i < text.length && text[i] !== "\n")
+                (out += " "), i++;
+            continue;
+        }
+        if (c === '"' || c === "'") {
+            // Prefixes like f"", rb'' were already emitted as identifiers; that's fine.
+            const triple = text.startsWith(c.repeat(3), i);
+            const quote = triple ? c.repeat(3) : c;
+            out += quote.replace(/./g, " ");
+            i += quote.length;
+            while (i < text.length && !text.startsWith(quote, i)) {
+                if (text[i] === "\\")
+                    (out += "  "), (i += 2);
+                else if (!triple && text[i] === "\n")
+                    break;
+                else
+                    (out += text[i] === "\n" ? "\n" : " "), i++;
+            }
+            if (text.startsWith(quote, i))
+                (out += quote.replace(/./g, " ")), (i += quote.length);
+            continue;
+        }
+        out += c;
+        i++;
+    }
+    return out;
+}
+const indentOf = (line) => line.length - line.trimStart().length;
+export function parsePy(file, text) {
+    const raw = text.split("\n");
+    const code = stripPy(text).split("\n");
+    const decls = [];
+    const stack = [];
+    for (let i = 0; i < code.length; i++) {
+        const line = code[i];
+        const m = line.match(/^(\s*)(async\s+def|def|class)\s+([A-Za-z_]\w*)/);
+        if (!m)
+            continue;
+        const indent = m[1].length;
+        while (stack.length && stack.at(-1).indent >= indent)
+            stack.pop();
+        const parent = stack.at(-1) ?? null;
+        // Header: until the colon that closes the signature.
+        let depth = 0;
+        let headerEnd = i;
+        for (let j = i; j < code.length; j++) {
+            for (const ch of code[j])
+                depth += ch === "(" || ch === "[" ? 1 : ch === ")" || ch === "]" ? -1 : 0;
+            headerEnd = j;
+            if (depth <= 0 && /:\s*$/.test(code[j].trimEnd()))
+                break;
+        }
+        // Body: every following line indented deeper (blank and comment lines don't end it).
+        let end = headerEnd;
+        for (let j = headerEnd + 1; j < code.length; j++) {
+            if (!code[j].trim())
+                continue;
+            if (indentOf(code[j]) > indent)
+                end = j;
+            else
+                break;
+        }
+        // Decorators sit directly above.
+        let start = i;
+        while (start > 0 && /^\s*@/.test(code[start - 1]) && indentOf(code[start - 1]) === indent)
+            start--;
+        const isClass = m[2] === "class";
+        const name = m[3];
+        const decorators = raw.slice(start, i).join("\n");
+        const routeMatch = raw.slice(start, i).map((d) => d.match(ROUTE)).find(Boolean);
+        const command = raw.slice(start, i).some((d) => COMMAND.test(d));
+        const kind = isClass ? "class" : routeMatch || command ? "route" : parent?.isClass ? "method" : "function";
+        const signature = (decorators ? decorators + "\n" : "") + raw.slice(i, headerEnd + 1).join("\n").trimEnd();
+        const decl = {
+            key: parent ? `${parent.key}.${name}` : name,
+            name,
+            container: parent ? parent.key : null,
+            kind,
+            range: { start: start + 1, end: end + 1 },
+            defLine: i + 1,
+            signature: routeMatch ? `${routeMatch[1].toUpperCase()} ${routeMatch[2]}\n${signature}` : signature,
+            doc: docstring(raw, headerEnd + 1),
+            exported: !name.startsWith("_"),
+            memberRanges: [],
+            indent,
+            isClass,
+            kept: false,
+        };
+        // Nested functions inside functions are part of their parent, unless the parent is a big container.
+        // Helpers defined inside a test belong to that test.
+        const keep = !parent || (parent.kept && (parent.isClass || (parent.range.end - parent.range.start >= 40 && !parent.name.startsWith("test"))));
+        decl.kept = keep;
+        if (keep) {
+            if (parent)
+                parent.memberRanges.push(decl.range);
+            decls.push(decl);
+        }
+        stack.push(decl);
+    }
+    const imports = new Map();
+    const joined = code.join("\n");
+    for (const m of joined.matchAll(/^[ \t]*from\s+(\.*[\w.]*)\s+import\s+(\([^)]*\)|[^\n]+)/gm)) {
+        for (const part of m[2].replace(/[()\\]/g, " ").split(",")) {
+            const [name, alias] = part.trim().split(/\s+as\s+/);
+            if (name && name !== "*")
+                imports.set((alias ?? name).trim(), { module: m[1], name: name.trim() });
+        }
+    }
+    for (const m of joined.matchAll(/^[ \t]*import\s+([^\n]+)/gm)) {
+        for (const part of m[1].split(",")) {
+            const [mod, alias] = part.trim().split(/\s+as\s+/);
+            if (!mod)
+                continue;
+            if (alias)
+                imports.set(alias.trim(), { module: mod.trim(), name: null });
+            else
+                imports.set(mod.trim().split(".")[0], { module: mod.trim().split(".")[0], name: null });
+        }
+    }
+    const calls = [];
+    code.forEach((line, idx) => {
+        if (/^\s*(async\s+def|def|class)\s/.test(line))
+            return;
+        for (const m of line.matchAll(/(?<![\w.])([A-Za-z_][\w]*(?:\s*\.\s*[A-Za-z_]\w*)*)\s*\(/g)) {
+            const chain = m[1].replace(/\s+/g, "");
+            if (NOT_CALLS.has(chain))
+                continue;
+            calls.push({ chain, line: idx + 1, col: m.index });
+        }
+        // Call on a fresh instance: GrantService().create(1) reads as GrantService.create.
+        for (const m of line.matchAll(/(?<![\w.])([A-Za-z_][\w.]*)\s*\([^()]*\)\s*\.\s*([A-Za-z_]\w*)\s*\(/g)) {
+            calls.push({ chain: `${m[1]}.${m[2]}`, line: idx + 1, col: m.index + m[0].lastIndexOf(m[2]) });
+        }
+    });
+    return { file, decls, imports, calls, code };
+}
+function docstring(raw, from) {
+    for (let j = from; j < raw.length && j < from + 3; j++) {
+        const t = raw[j].trim();
+        if (!t)
+            continue;
+        const q = t.startsWith('"""') ? '"""' : t.startsWith("'''") ? "'''" : null;
+        if (!q)
+            return "";
+        const rest = t.slice(3);
+        if (rest.includes(q))
+            return rest.slice(0, rest.indexOf(q)).trim();
+        const lines = [rest];
+        for (let k = j + 1; k < raw.length && k < j + 40; k++) {
+            const l = raw[k];
+            if (l.includes(q)) {
+                lines.push(l.slice(0, l.indexOf(q)));
+                break;
+            }
+            lines.push(l);
+        }
+        return dedent(lines).trim();
+    }
+    return "";
+}
+function dedent(lines) {
+    const ind = Math.min(...lines.slice(1).filter((l) => l.trim()).map(indentOf), 1e9);
+    return [lines[0], ...lines.slice(1).map((l) => l.slice(ind === 1e9 ? 0 : ind))].join("\n");
+}
+export function enclosingPy(decls, line) {
+    let best = null;
+    for (const d of decls) {
+        if (line < d.range.start || line > d.range.end)
+            continue;
+        if (!best || d.range.end - d.range.start < best.range.end - best.range.start)
+            best = d;
+    }
+    return best;
+}
+/** Every Python file in the repo, parsed on demand, with module-path resolution. */
+export class PyIndex {
+    parsed = new Map();
+    byModuleSuffix;
+    files;
+    read;
+    constructor(files, read) {
+        this.files = files;
+        this.read = read;
+        this.byModuleSuffix = new Map();
+        for (const f of files.filter(isPy)) {
+            const mod = f.replace(/\.pyi?$/, "").replace(/\/__init__$/, "").split("/");
+            // Index every suffix so `app.models` finds `src/app/models.py`.
+            for (let i = 0; i < mod.length; i++) {
+                const key = mod.slice(i).join(".");
+                (this.byModuleSuffix.get(key) ?? this.byModuleSuffix.set(key, []).get(key)).push(f);
+            }
+        }
+    }
+    all() {
+        return this.files.filter(isPy);
+    }
+    get(file) {
+        if (!this.parsed.has(file)) {
+            const text = this.read(file);
+            this.parsed.set(file, text === null ? null : parsePy(file, text));
+        }
+        return this.parsed.get(file);
+    }
+    moduleFile(fromFile, module) {
+        if (module.startsWith(".")) {
+            const dots = module.match(/^\.+/)[0].length;
+            let dir = path.posix.dirname(fromFile);
+            for (let i = 1; i < dots; i++)
+                dir = path.posix.dirname(dir);
+            const rest = module.slice(dots).replace(/\./g, "/");
+            const base = rest ? `${dir}/${rest}` : dir;
+            for (const cand of [`${base}.py`, `${base}/__init__.py`, `${base}.pyi`])
+                if (this.files.includes(cand.replace(/^\.\//, "")))
+                    return cand.replace(/^\.\//, "");
+            return null;
+        }
+        const hits = this.byModuleSuffix.get(module);
+        if (!hits?.length)
+            return null;
+        return [...hits].sort((a, b) => a.length - b.length)[0];
+    }
+    /** What a call chain in a file refers to, as (file, decl). */
+    resolve(file, chain, line) {
+        const pf = this.get(file);
+        if (!pf)
+            return null;
+        const parts = chain.split(".");
+        const find = (f, key) => {
+            const target = this.get(f);
+            const d = target?.decls.find((x) => x.key === key) ?? null;
+            // Calling a class runs its __init__ when it has one.
+            if (d?.kind === "class")
+                return target?.decls.find((x) => x.key === `${key}.__init__`) ?? d;
+            return d;
+        };
+        if ((parts[0] === "self" || parts[0] === "cls") && parts.length === 2) {
+            const here = enclosingPy(pf.decls, line);
+            const cls = here?.container ?? (here?.kind === "class" ? here.key : null);
+            if (cls) {
+                const d = find(file, `${cls}.${parts[1]}`);
+                if (d)
+                    return { file, decl: d };
+            }
+            return null;
+        }
+        if (parts.length === 1) {
+            const local = find(file, parts[0]);
+            if (local && !local.container)
+                return { file, decl: local };
+        }
+        const imp = pf.imports.get(parts[0]);
+        if (imp) {
+            if (imp.name) {
+                // from mod import name → name.rest...
+                const target = this.moduleFile(file, imp.module);
+                if (target) {
+                    const d = find(target, [imp.name, ...parts.slice(1)].join("."));
+                    if (d)
+                        return { file: target, decl: d };
+                }
+                // from pkg import submodule → submodule.func
+                const sub = this.moduleFile(file, `${imp.module}${imp.module.endsWith(".") ? "" : "."}${imp.name}`);
+                if (sub && parts.length > 1) {
+                    const d = find(sub, parts.slice(1).join("."));
+                    if (d)
+                        return { file: sub, decl: d };
+                }
+            }
+            else {
+                // import a.b as x → x.func, or import a → a.b.func
+                for (let cut = parts.length - 1; cut >= 1; cut--) {
+                    const modPath = imp.module.split(".").length > 1 && parts.length - cut === 1 ? imp.module : [imp.module, ...parts.slice(1, cut)].join(".");
+                    const target = this.moduleFile(file, modPath);
+                    if (target) {
+                        const d = find(target, parts.slice(cut).join("."));
+                        if (d)
+                            return { file: target, decl: d };
+                    }
+                }
+            }
+        }
+        // obj.method(): if exactly one method by that name exists anywhere, it's almost surely that one.
+        if (parts.length >= 2) {
+            const method = parts.at(-1);
+            if (method.startsWith("__"))
+                return null;
+            const hits = [];
+            for (const f of this.all()) {
+                for (const d of this.get(f)?.decls ?? [])
+                    if (d.name === method && d.container)
+                        hits.push({ file: f, decl: d });
+                if (hits.length > 1)
+                    return null;
+            }
+            return hits[0] ?? null;
+        }
+        return null;
+    }
+    /** Callee names inside a range, for diffing calls across sides. */
+    static calleeNames(pf, range) {
+        const names = new Map();
+        for (const c of pf.calls) {
+            if (c.line < range.start || c.line > range.end)
+                continue;
+            const name = c.chain.split(".").at(-1);
+            if (!names.has(name))
+                names.set(name, c.line);
+        }
+        return names;
+    }
+    /** The identifier chain under a cursor, for hover and go-to-definition. */
+    chainAt(file, line, col) {
+        const pf = this.get(file);
+        const text = pf?.code[line - 1];
+        if (!text)
+            return null;
+        let s = col;
+        let e = col;
+        while (s > 0 && /[\w.]/.test(text[s - 1]))
+            s--;
+        while (e < text.length && /\w/.test(text[e]))
+            e++;
+        const chain = text.slice(s, e).replace(/^\.+|\.+$/g, "");
+        return chain || null;
+    }
+}

package/dist/server/analyze/ts-decls.js

@@ -0,0 +1,299 @@
+// Syntax-only declaration extraction. No type checker needed, so it runs on
+// both sides of a change (the old side has no program to check against).
+import ts from "typescript";
+const TS_EXT = /\.(m|c)?(t|j)sx?$/;
+export const isTsLike = (file) => TS_EXT.test(file) && !file.endsWith(".d.ts");
+export function scriptKind(file) {
+    if (file.endsWith(".tsx"))
+        return ts.ScriptKind.TSX;
+    if (file.endsWith(".jsx"))
+        return ts.ScriptKind.JSX;
+    if (/\.(m|c)?js$/.test(file))
+        return ts.ScriptKind.JS;
+    return ts.ScriptKind.TS;
+}
+export function parse(file, text) {
+    return ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, scriptKind(file));
+}
+const HTTP = new Set(["get", "post", "put", "patch", "delete", "all", "options", "head"]);
+/** Where a declaration really starts: its JSDoc belongs to it, and reviewers read docs too. */
+function docStart(sf, node) {
+    const holder = ts.isVariableDeclaration(node) && ts.isVariableDeclarationList(node.parent) && node.parent.declarations.length === 1 ? node.parent.parent : node;
+    const docs = holder.jsDoc;
+    return docs?.length ? Math.min(docs[0].getStart(sf), node.getStart(sf)) : node.getStart(sf);
+}
+function lines(sf, node) {
+    const start = sf.getLineAndCharacterOfPosition(docStart(sf, node)).line + 1;
+    const end = sf.getLineAndCharacterOfPosition(node.getEnd()).line + 1;
+    return { start, end };
+}
+function isExported(node) {
+    const mods = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+    return !!mods?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+}
+const squash = (s) => s.replace(/\s+/g, " ").trim();
+function headText(sf, from, body) {
+    const start = from.getStart(sf);
+    const end = body ? body.getStart(sf) : from.getEnd();
+    const text = squash(sf.text.slice(start, end)).replace(/\s*(=>|\{)?\s*$/, "");
+    return text.length > 240 ? text.slice(0, 237) + "…" : text;
+}
+function clip(text, maxLines = 14) {
+    const ls = text.split("\n");
+    return ls.length > maxLines ? ls.slice(0, maxLines).join("\n") + "\n  …" : text;
+}
+function blockText(sf, node, maxLines = 14) {
+    const text = sf.text.slice(node.getStart(sf), node.getEnd());
+    const ls = text.split("\n");
+    return ls.length > maxLines ? ls.slice(0, maxLines).join("\n") + "\n  …" : text;
+}
+function isFunctionLike(init) {
+    return !!init && (ts.isArrowFunction(init) || ts.isFunctionExpression(init));
+}
+/** `memo(() => …)`, `forwardRef(function X() …)`, `defineAction({ run() … })`. */
+function wrapsFunction(init) {
+    if (!init || !ts.isCallExpression(init))
+        return false;
+    return init.arguments.some((a) => isFunctionLike(a) || ts.isObjectLiteralExpression(a) || wrapsFunction(a));
+}
+export function extractDecls(sf) {
+    const out = [];
+    const jsx = sf.fileName.endsWith("x");
+    const fnKind = (name) => (jsx && /^[A-Z]/.test(name) ? "component" : "function");
+    const pushMembers = (container, members, exported) => {
+        const ranges = [];
+        for (const m of members) {
+            let name = null;
+            let body;
+            if (ts.isConstructorDeclaration(m)) {
+                name = "constructor";
+                body = m.body;
+            }
+            else if ((ts.isMethodDeclaration(m) || ts.isGetAccessor(m) || ts.isSetAccessor(m)) && m.name) {
+                name = m.name.getText(sf);
+                body = m.body;
+            }
+            else if ((ts.isPropertyDeclaration(m) || ts.isPropertyAssignment(m)) && isFunctionLike(m.initializer)) {
+                name = m.name.getText(sf);
+                body = m.initializer.body;
+            }
+            if (!name)
+                continue;
+            const range = lines(sf, m);
+            ranges.push(range);
+            out.push({
+                key: `${container}.${name}`,
+                name,
+                container,
+                kind: "method",
+                node: m,
+                nameNode: m.name ?? m.getFirstToken(sf) ?? null,
+                range,
+                exported,
+                signature: headText(sf, m, body),
+                memberRanges: [],
+            });
+        }
+        return ranges;
+    };
+    for (const st of sf.statements) {
+        const exported = isExported(st);
+        if (ts.isFunctionDeclaration(st)) {
+            const name = st.name?.text ?? "default";
+            out.push({
+                key: name,
+                name,
+                container: null,
+                kind: fnKind(name),
+                node: st,
+                nameNode: st.name ?? null,
+                range: lines(sf, st),
+                exported,
+                signature: headText(sf, st, st.body),
+                memberRanges: [],
+            });
+        }
+        else if (ts.isClassDeclaration(st)) {
+            const name = st.name?.text ?? "default";
+            const decl = {
+                key: name,
+                name,
+                container: null,
+                kind: "class",
+                node: st,
+                nameNode: st.name ?? null,
+                range: lines(sf, st),
+                exported,
+                signature: clip(sf.text.slice(st.getStart(sf), st.members.pos).replace(/\s*\{\s*$/, "")),
+                memberRanges: [],
+            };
+            out.push(decl);
+            decl.memberRanges = pushMembers(name, st.members, exported);
+        }
+        else if (ts.isInterfaceDeclaration(st) || ts.isTypeAliasDeclaration(st) || ts.isEnumDeclaration(st)) {
+            out.push({
+                key: st.name.text,
+                name: st.name.text,
+                container: null,
+                kind: ts.isInterfaceDeclaration(st) ? "interface" : "type",
+                node: st,
+                nameNode: st.name,
+                range: lines(sf, st),
+                exported,
+                signature: blockText(sf, st),
+                memberRanges: [],
+            });
+        }
+        else if (ts.isVariableStatement(st)) {
+            for (const d of st.declarationList.declarations) {
+                if (!ts.isIdentifier(d.name))
+                    continue;
+                const name = d.name.text;
+                const init = d.initializer;
+                const kind = isFunctionLike(init)
+                    ? fnKind(name)
+                    : init && ts.isClassExpression(init)
+                        ? "class"
+                        : wrapsFunction(init) && jsx && /^[A-Z]/.test(name)
+                            ? "component"
+                            : "const";
+                const range = lines(sf, st.declarationList.declarations.length === 1 ? st : d);
+                const decl = {
+                    key: name,
+                    name,
+                    container: null,
+                    kind,
+                    node: d,
+                    nameNode: d.name,
+                    range,
+                    exported,
+                    signature: isFunctionLike(init)
+                        ? `${exported ? "export " : ""}const ${headText(sf, d, init.body)}`
+                        : squash(blockText(sf, d, 1)).slice(0, 160),
+                    memberRanges: [],
+                };
+                out.push(decl);
+                if (init && ts.isObjectLiteralExpression(init)) {
+                    decl.memberRanges = pushMembers(name, init.properties.filter((p) => ts.isMethodDeclaration(p) || ts.isPropertyAssignment(p)), exported);
+                }
+                else if (init && ts.isClassExpression(init)) {
+                    decl.memberRanges = pushMembers(name, init.members, exported);
+                }
+            }
+        }
+        else if (ts.isExportAssignment(st) && isFunctionLike(st.expression)) {
+            out.push({
+                key: "default",
+                name: "default",
+                container: null,
+                kind: fnKind("Default"),
+                node: st,
+                nameNode: null,
+                range: lines(sf, st),
+                exported: true,
+                signature: headText(sf, st, st.expression.body),
+                memberRanges: [],
+            });
+        }
+    }
+    // Big containers (Effect service layers, app builders, factories) define their real units as inner
+    // named functions: `const patchGrant = Effect.fn(...)(function* ...)`. Lift those out as members so a
+    // reviewer can open the unit that changed. Components are left whole; their handlers read best in place.
+    const NESTED_MIN_LINES = 40;
+    for (const d of [...out]) {
+        if (d.kind === "component" || d.range.end - d.range.start < NESTED_MIN_LINES)
+            continue;
+        const owned = (n) => d.memberRanges.some((r) => lines(sf, n).start >= r.start && lines(sf, n).end <= r.end);
+        const visit = (n) => {
+            let name = null;
+            let body;
+            if (ts.isVariableDeclaration(n) && ts.isIdentifier(n.name) && (isFunctionLike(n.initializer) || wrapsFunction(n.initializer))) {
+                name = n.name.text;
+                body = isFunctionLike(n.initializer) ? n.initializer.body : undefined;
+            }
+            else if (ts.isFunctionDeclaration(n) && n.name) {
+                name = n.name.text;
+                body = n.body;
+            }
+            if (name && !owned(n)) {
+                const range = lines(sf, n);
+                if (range.end > range.start) {
+                    d.memberRanges.push(range);
+                    out.push({
+                        key: `${d.name}.${name}`,
+                        name,
+                        container: d.name,
+                        kind: "method",
+                        node: n,
+                        nameNode: n.name ?? null,
+                        range,
+                        exported: d.exported,
+                        signature: body ? headText(sf, n, body) : squash(blockText(sf, n, 1)).slice(0, 200),
+                        memberRanges: [],
+                    });
+                    return;
+                }
+            }
+            ts.forEachChild(n, visit);
+        };
+        ts.forEachChild(d.node, visit);
+    }
+    // Route registrations anywhere in the file: app.get("/x", handler).
+    const visit = (node) => {
+        if (ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            HTTP.has(node.expression.name.text) &&
+            node.arguments.length >= 2 &&
+            ts.isStringLiteralLike(node.arguments[0]) &&
+            node.arguments[0].text.startsWith("/")) {
+            const method = node.expression.name.text.toUpperCase();
+            const route = node.arguments[0].text;
+            const name = `${method} ${route}`;
+            out.push({
+                key: `route:${name}`,
+                name,
+                container: null,
+                kind: "route",
+                node,
+                nameNode: node.expression.name,
+                range: lines(sf, node),
+                exported: true,
+                signature: `${node.expression.expression.getText(sf)}.${node.expression.name.text}("${route}", …)`,
+                memberRanges: [],
+            });
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return out;
+}
+/** Innermost declaration containing a position. Routes and methods win over their enclosing function. */
+export function enclosing(decls, sf, pos) {
+    let best = null;
+    for (const d of decls) {
+        if (pos < d.node.getStart(sf) || pos > d.node.getEnd())
+            continue;
+        if (!best || d.node.getEnd() - d.node.getStart(sf) < best.node.getEnd() - best.node.getStart(sf))
+            best = d;
+    }
+    return best;
+}
+/** Names called inside a node. Used to diff call sets across sides without a checker. */
+export function calleeNames(sf, node) {
+    const names = new Map();
+    const visit = (n) => {
+        let target;
+        if (ts.isCallExpression(n) || ts.isNewExpression(n))
+            target = n.expression;
+        else if (ts.isJsxOpeningElement(n) || ts.isJsxSelfClosingElement(n))
+            target = n.tagName;
+        if (target) {
+            const name = ts.isPropertyAccessExpression(target) ? target.name.text : ts.isIdentifier(target) ? target.text : null;
+            if (name && !names.has(name))
+                names.set(name, sf.getLineAndCharacterOfPosition(n.getStart(sf)).line + 1);
+        }
+        ts.forEachChild(n, visit);
+    };
+    ts.forEachChild(node, visit);
+    return names;
+}