@jpoly1219/context-extractor 0.2.8 → 0.2.10

package/dist/src/runner.js

@@ -1,15 +1,118 @@
 "use strict";
+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 });
 const main_1 = require("./main");
-const types_1 = require("./types");
+const pprof = __importStar(require("pprof"));
+const fs = __importStar(require("fs"));
 // extract("/home/jacob/projects/context-extractor/targets/todo/sketch.ts").then(r => console.log("todo\n", r));
 // extract("/home/jacob/projects/context-extractor/targets/playlist/sketch.ts").then(r => console.log("playlist\n", r));
 // extract("/home/jacob/projects/context-extractor/targets/passwords/sketch.ts").then(r => console.log("passwords\n", r));
 // extract("/home/jacob/projects/context-extractor/targets/booking/sketch.ts").then(r => console.log("booking\n", r));
 // extract("/home/jacob/projects/context-extractor/targets/emojipaint/sketch.ts").then(r => console.log("emojipaint\n", r));
 (async () => {
+    const profile = await pprof.time.start(10000); // Collect for 10s
     try {
         let x;
+        x = await (0, main_1.extractContext)("typescript", "/home/jacob/projects/context-extractor/targets/booking/sketch.ts", "/home/jacob/projects/context-extractor/targets/booking/", "standalone", { line: 3, character: 56 });
+        console.dir(x, { depth: null });
+    }
+    catch (err) {
+        console.log("top level err: ", err);
+    }
+    finally {
+        const buf = await pprof.encode(profile());
+        fs.writeFile('wall.pb.gz', buf, (err) => {
+            if (err)
+                throw err;
+        });
+    }
+})();
+(async () => {
+    // try {
+    const app = (0, main_1.spawnApp)("typescript", 
+    // "/home/jacob/projects/context-extractor/targets/vscode/src/main.ts",
+    // "/home/jacob/projects/context-extractor/targets/vscode/",
+    "/home/jacob/projects/context-extractor/targets/booking/sketch.ts", "/home/jacob/projects/context-extractor/targets/booking/", "standalone", { line: 3, character: 56 });
+    const x = await (0, main_1.extractContextWithReuse)(app, 0);
+    console.dir(x, { depth: null });
+    // for (let i = 0; i < 11; ++i) {
+    //
+    //   await (async (ms: number) => new Promise((r) => setTimeout(r, ms)))(2000)
+    //
+    //   try {
+    //     console.log(`loop ${i}`)
+    //     let start = performance.now();
+    //     const x = await extractContextWithReuse(app, i);
+    //     let end = performance.now();
+    //     console.log(end - start);
+    //     // console.dir(x, { depth: null })
+    //   } catch (err) {
+    //     console.log("error!")
+    //     continue;
+    //   }
+    //
+    // }
+    app.close();
+    // } catch (err) {
+    //   console.error(err)
+    // }
+});
+(async () => {
+    // const profile = await pprof.time.start(10000); // Collect for 10s
+    try {
+        let x;
+        // x = await extractContext(
+        //   Language.TypeScript,
+        //   "/home/jacob/projects/context-extractor/targets/vscode/src/main.ts",
+        //   "/home/jacob/projects/context-extractor/targets/vscode/",
+        //   IDE.Standalone
+        // )
+        // console.dir(x, { depth: null })
+        // x = await extractContext(
+        //   Language.TypeScript,
+        //   "/home/jacob/projects/context-extractor/targets/angular/packages/elements/src/utils.ts",
+        //   "/home/jacob/projects/context-extractor/targets/angular/",
+        // )
+        // console.dir(x, { depth: null })
+        // x = await extractContext(
+        //   Language.TypeScript,
+        //   "/home/jacob/projects/context-extractor/targets/ionic-framework/core/src/components/img/img.tsx",
+        //   "/home/jacob/projects/context-extractor/targets/ionic-framework/",
+        // )
+        // console.dir(x, { depth: null })
+        //
         // x = await extractContext(
         //   Language.TypeScript,
         //   "/home/jacob/projects/context-extractor/targets/todo/sketch.ts",
@@ -30,14 +133,22 @@ const types_1 = require("./types");
         //   "/home/jacob/projects/context-extractor/targets/passwords/",
         // )
         // console.dir(x, { depth: null })
-        x = await (0, main_1.extractContext)(types_1.Language.TypeScript, "/home/jacob/projects/context-extractor/targets/booking/sketch.ts", "/home/jacob/projects/context-extractor/targets/booking/");
+        //
+        x = await (0, main_1.extractContext)("typescript", "/home/jacob/projects/context-extractor/targets/booking/sketch.ts", "/home/jacob/projects/context-extractor/targets/booking/", "standalone", { line: 3, character: 56 });
         console.dir(x, { depth: null });
+        //
         // x = await extractContext(
         //   Language.TypeScript,
         //   "/home/jacob/projects/context-extractor/targets/emojipaint/sketch.ts",
         //   "/home/jacob/projects/context-extractor/targets/emojipaint/",
         // )
         // console.dir(x, { depth: null })
+        // x = await extractContext(
+        //   Language.TypeScript,
+        //   "/home/jacob/projects/continue/manual-testing-sandbox/booking/sketch.ts",
+        //   "/home/jacob/projects/continue/manual-testing-sandbox/booking",
+        // )
+        // console.dir(x, { depth: null })
         // const y = await completeWithLLM(
         //   x!,
         //   Language.TypeScript,
@@ -66,7 +177,11 @@ const types_1 = require("./types");
         // }
         // process.exit(0);
     }
-})();
+    // const buf = await pprof.encode(profile());
+    // fs.writeFile('wall.pb.gz', buf, (err) => {
+    //   if (err) throw err;
+    // });
+});
 // extractWithNew(Language.TypeScript, "/home/jacob/projects/context-extractor/targets/playlist/sketch.ts", "/home/jacob/projects/context-extractor/credentials.json").then(r => console.log("playlist\n", r));
 // extractWithNew(Language.TypeScript, "/home/jacob/projects/context-extractor/targets/passwords/sketch.ts", "/home/jacob/projects/context-extractor/credentials.json").then(r => console.log("passwords\n", r));
 // extractWithNew(Language.TypeScript, "/home/jacob/projects/context-extractor/targets/booking/sketch.ts", "/home/jacob/projects/context-extractor/credentials.json").then(r => console.log("booking\n", r));

package/dist/src/tree-sitter-files/queries/hole-queries/typescript.scm

@@ -0,0 +1,36 @@
+;; Capture the variable/function name
+(variable_declarator
+  name: (identifier) @function.name
+  type: (type_annotation
+    (function_type) @function.type))
+
+;; Capture the full parameter list
+(function_type
+  parameters: (formal_parameters) @function.params)
+
+;; Capture the type identifiers used in the parameters
+(formal_parameters
+  (required_parameter
+    type: (type_annotation
+      (type_identifier) @param.type))
+  (required_parameter
+    type: (type_annotation
+      (type_identifier) @param.type)))
+
+;; Capture the return type of the function
+(function_type
+  return_type: (type_identifier) @return.type)
+
+;; Capture any parse errors (e.g., the `??`)
+(ERROR) @error.node
+
+;; Capture the entire function declaration line
+(lexical_declaration) @function.decl
+
+;; Matches import declarations like: import { A, B } from "module";
+(import_statement
+  (import_clause
+    (named_imports
+      (import_specifier
+        name: (identifier) @import.name)))
+  source: (string) @import.source)

package/dist/src/tree-sitter-files/queries/relevant-headers-queries/typescript-get-toplevel-headers.scm

@@ -0,0 +1,22 @@
+;; Match top-level `var`, `let`, or `const` declarations
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @top.var.name
+    type: (type_annotation
+            (_) @top.var.type))) @top.var.decl
+
+(variable_declaration
+  (variable_declarator
+    name: (identifier) @top.var.name
+    type: (type_annotation
+            (_) @top.var.type))) @top.var.decl
+
+;; Match function declarations
+(function_declaration
+  name: (identifier) @top.fn.name
+  parameters: (formal_parameters
+    (required_parameter
+      pattern: (identifier) @top.fn.param.name
+      type: (type_annotation (_) @top.fn.param.type)))*
+
+  return_type: (type_annotation (_) @top.fn.type)?) @top.fn.decl

package/dist/src/tree-sitter-files/queries/relevant-types-queries/typescript-extract-identifiers.scm

@@ -0,0 +1,10 @@
+;; Capture the type alias name (left-hand side)
+; (type_alias_declaration
+;   name: (type_identifier) @type.name)
+
+;; Capture all identifiers on the right-hand side (value), recursively
+; (type_alias_declaration
+;   value: (_) @type.value)
+
+;; Match all identifiers inside the type value — deeply nested
+(type_identifier) @type.identifier

package/dist/src/tree-sitter-files/queries/relevant-types-queries/typescript-find-typedecl-given-typeidentifier.scm

@@ -0,0 +1,11 @@
+(type_alias_declaration
+  name: (type_identifier) @type.identifier
+  value: (_) @type.value)
+
+(interface_declaration
+  name: (type_identifier) @type.identifier
+  body: (_) @type.value)
+
+(enum_declaration
+  name: (type_identifier) @type.identifier
+  body: (_) @type.value)

package/dist/src/tree-sitter.d.ts

@@ -0,0 +1,40 @@
+import Parser from "web-tree-sitter";
+import { SymbolWithRange } from "./types";
+export declare enum LanguageName {
+    TYPESCRIPT = "typescript",
+    OCAML = "ocaml"
+}
+export declare const supportedLanguages: {
+    [key: string]: LanguageName;
+};
+export declare const IGNORE_PATH_PATTERNS: Partial<Record<LanguageName, RegExp[]>>;
+export declare function getParserForFile(filepath: string): Promise<Parser | undefined>;
+export declare function getLanguageForFile(filepath: string): Promise<Parser.Language | undefined>;
+export declare const getFullLanguageName: (filepath: string) => LanguageName;
+export declare function getQueryForFile(filepath: string, queryPath: string): Promise<Parser.Query | undefined>;
+export declare function getSymbolsForFile(filepath: string, contents: string): Promise<SymbolWithRange[] | undefined>;
+export declare function findTypeDeclarationGivenIdentifier(captures: Parser.QueryCapture[], typeIdentifier: string): {
+    name: Parser.SyntaxNode;
+    value: Parser.SyntaxNode | undefined;
+    kind: string | undefined;
+} | null;
+interface TypeDeclarationResult {
+    name: string;
+    fullText: string;
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+    kind: string;
+}
+export declare function findEnclosingTypeDeclaration(sourceCode: string, cursorLine: number, cursorColumn: number, ast: Parser.Tree): TypeDeclarationResult | null;
+export declare function extractTopLevelDecls(currentFile: string): Promise<Parser.QueryMatch[]>;
+export declare function extractTopLevelDeclsWithFormatting(currentFile: string): Promise<{
+    declaration: string;
+    nodeType: string;
+    name: string;
+    declaredType: string;
+    returnType?: string;
+}[]>;
+export declare function extractFunctionTypeFromDecl(match: Parser.QueryMatch): string;
+export {};

package/dist/src/tree-sitter.js

@@ -0,0 +1,334 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFullLanguageName = exports.IGNORE_PATH_PATTERNS = exports.supportedLanguages = exports.LanguageName = void 0;
+exports.getParserForFile = getParserForFile;
+exports.getLanguageForFile = getLanguageForFile;
+exports.getQueryForFile = getQueryForFile;
+exports.getSymbolsForFile = getSymbolsForFile;
+exports.findTypeDeclarationGivenIdentifier = findTypeDeclarationGivenIdentifier;
+exports.findEnclosingTypeDeclaration = findEnclosingTypeDeclaration;
+exports.extractTopLevelDecls = extractTopLevelDecls;
+exports.extractTopLevelDeclsWithFormatting = extractTopLevelDeclsWithFormatting;
+exports.extractFunctionTypeFromDecl = extractFunctionTypeFromDecl;
+const fs_1 = __importDefault(require("fs"));
+const web_tree_sitter_1 = __importDefault(require("web-tree-sitter"));
+const utils_1 = require("./utils");
+const ast_1 = require("./ast");
+var LanguageName;
+(function (LanguageName) {
+    LanguageName["TYPESCRIPT"] = "typescript";
+    LanguageName["OCAML"] = "ocaml";
+})(LanguageName || (exports.LanguageName = LanguageName = {}));
+exports.supportedLanguages = {
+    ts: LanguageName.TYPESCRIPT,
+    mts: LanguageName.TYPESCRIPT,
+    cts: LanguageName.TYPESCRIPT,
+    ocaml: LanguageName.OCAML,
+    ml: LanguageName.OCAML,
+    mli: LanguageName.OCAML,
+};
+exports.IGNORE_PATH_PATTERNS = {
+    [LanguageName.TYPESCRIPT]: [/.*node_modules/],
+};
+async function getParserForFile(filepath) {
+    try {
+        await web_tree_sitter_1.default.init();
+        const parser = new web_tree_sitter_1.default();
+        const language = await getLanguageForFile(filepath);
+        if (!language) {
+            return undefined;
+        }
+        parser.setLanguage(language);
+        return parser;
+    }
+    catch (e) {
+        console.debug("Unable to load language for file", filepath, e);
+        return undefined;
+    }
+}
+// Loading the wasm files to create a Language object is an expensive operation and with
+// sufficient number of files can result in errors, instead keep a map of language name
+// to Language object
+const nameToLanguage = new Map();
+async function getLanguageForFile(filepath) {
+    try {
+        await web_tree_sitter_1.default.init();
+        const extension = (0, utils_1.getUriFileExtension)(filepath);
+        const languageName = exports.supportedLanguages[extension];
+        if (!languageName) {
+            return undefined;
+        }
+        let language = nameToLanguage.get(languageName);
+        if (!language) {
+            language = await loadLanguageForFileExt(extension);
+            nameToLanguage.set(languageName, language);
+        }
+        return language;
+    }
+    catch (e) {
+        console.debug("Unable to load language for file", filepath, e);
+        return undefined;
+    }
+}
+const getFullLanguageName = (filepath) => {
+    const extension = (0, utils_1.getUriFileExtension)(filepath);
+    return exports.supportedLanguages[extension];
+};
+exports.getFullLanguageName = getFullLanguageName;
+async function getQueryForFile(filepath, queryPath) {
+    const language = await getLanguageForFile(filepath);
+    if (!language) {
+        return undefined;
+    }
+    if (!fs_1.default.existsSync(queryPath)) {
+        return undefined;
+    }
+    const querySource = fs_1.default.readFileSync(queryPath).toString();
+    const query = language.query(querySource);
+    return query;
+}
+async function loadLanguageForFileExt(fileExtension) {
+    const wasmPath = require.resolve(`./tree-sitter-files/wasms/tree-sitter-${exports.supportedLanguages[fileExtension]}.wasm`);
+    // const wasmPath = path.join(
+    //   __dirname,
+    //   "tree-sitter-files",
+    //   "wasms",
+    //   `tree-sitter-${supportedLanguages[fileExtension]}.wasm`
+    // );
+    return await web_tree_sitter_1.default.Language.load(wasmPath);
+}
+const GET_SYMBOLS_FOR_NODE_TYPES = [
+    "class_declaration",
+    "class_definition",
+    "function_item", // function name = first "identifier" child
+    "function_definition",
+    "method_declaration", // method name = first "identifier" child
+    "method_definition",
+    "generator_function_declaration",
+    // property_identifier
+    // field_declaration
+    // "arrow_function",
+];
+async function getSymbolsForFile(filepath, contents) {
+    const parser = await getParserForFile(filepath);
+    if (!parser) {
+        return;
+    }
+    let tree;
+    try {
+        tree = parser.parse(contents);
+        if (!tree) {
+            throw new Error("tree parsing failed");
+        }
+    }
+    catch (e) {
+        console.log(`Error parsing file: ${filepath}`);
+        return;
+    }
+    // console.log(`file: ${filepath}`);
+    // Function to recursively find all named nodes (classes and functions)
+    const symbols = [];
+    function findNamedNodesRecursive(node) {
+        if (!node) {
+            return;
+        }
+        // console.log(`node: ${node.type}, ${node.text}`);
+        if (GET_SYMBOLS_FOR_NODE_TYPES.includes(node.type)) {
+            // console.log(`parent: ${node.type}, ${node.text.substring(0, 200)}`);
+            // node.children.forEach((child) => {
+            //   console.log(`child: ${child.type}, ${child.text}`);
+            // });
+            // Empirically, the actual name is the last identifier in the node
+            // Especially with languages where return type is declared before the name
+            // TODO use findLast in newer version of node target
+            let identifier = undefined;
+            for (let i = node.children.length - 1; i >= 0; i--) {
+                if (node.children[i] &&
+                    (node.children[i].type === "identifier" ||
+                        node.children[i].type === "property_identifier")) {
+                    identifier = node.children[i];
+                    break;
+                }
+            }
+            if (identifier === null || identifier === void 0 ? void 0 : identifier.text) {
+                symbols.push({
+                    filepath,
+                    type: node.type,
+                    name: identifier.text,
+                    range: {
+                        start: {
+                            character: node.startPosition.column,
+                            line: node.startPosition.row,
+                        },
+                        end: {
+                            character: node.endPosition.column + 1,
+                            line: node.endPosition.row + 1,
+                        },
+                    },
+                    content: node.text,
+                });
+            }
+        }
+        node.children.forEach(findNamedNodesRecursive);
+    }
+    findNamedNodesRecursive(tree.rootNode);
+    return symbols;
+}
+function findTypeDeclarationGivenIdentifier(captures, typeIdentifier) {
+    for (let i = 0; i < captures.length; i++) {
+        const cap = captures[i];
+        if (cap.name === "type.identifier" && cap.node.text === typeIdentifier) {
+            const parent = cap.node.parent;
+            const value = captures.find((c) => c.name === "type.value" && c.node.parent === parent);
+            return { name: cap.node, value: value === null || value === void 0 ? void 0 : value.node, kind: parent === null || parent === void 0 ? void 0 : parent.type };
+        }
+    }
+    return null;
+}
+function findEnclosingTypeDeclaration(sourceCode, cursorLine, cursorColumn, ast) {
+    var _a;
+    const point = { row: cursorLine, column: cursorColumn };
+    let node = ast.rootNode.descendantForPosition(point);
+    while (node &&
+        ![
+            "type_alias_declaration",
+            "interface_declaration",
+            "enum_declaration",
+        ].includes(node.type)) {
+        if (!node.parent)
+            return null;
+        node = node.parent;
+    }
+    if (!node)
+        return null;
+    const nameNode = node.childForFieldName("name");
+    const name = (_a = nameNode === null || nameNode === void 0 ? void 0 : nameNode.text) !== null && _a !== void 0 ? _a : "<anonymous>";
+    const fullText = sourceCode.slice(node.startIndex, node.endIndex);
+    return {
+        name,
+        fullText,
+        startLine: node.startPosition.row,
+        startColumn: node.startPosition.column,
+        endLine: node.endPosition.row,
+        endColumn: node.endPosition.column,
+        kind: node.type,
+    };
+}
+async function extractTopLevelDecls(currentFile) {
+    const ast = await (0, ast_1.getAst)(currentFile, fs_1.default.readFileSync(currentFile, "utf8"));
+    if (!ast) {
+        throw new Error(`failed to get ast for file ${currentFile}`);
+    }
+    const language = (0, exports.getFullLanguageName)(currentFile);
+    const queryPath = require.resolve(`./tree-sitter-files/queries/relevant-headers-queries/${language}-get-toplevel-headers.scm`);
+    const query = await getQueryForFile(currentFile, queryPath
+    // path.join(
+    //   __dirname,
+    //   "tree-sitter-files",
+    //   "queries",
+    //   "relevant-headers-queries",
+    //   `${language}-get-toplevel-headers.scm`
+    // )
+    );
+    if (!query) {
+        throw new Error(`failed to get query for file ${currentFile} and language ${language}`);
+    }
+    return query.matches(ast.rootNode);
+}
+async function extractTopLevelDeclsWithFormatting(currentFile) {
+    var _a;
+    const ast = await (0, ast_1.getAst)(currentFile, fs_1.default.readFileSync(currentFile, "utf8"));
+    if (!ast) {
+        throw new Error(`failed to get ast for file ${currentFile}`);
+    }
+    const language = (0, exports.getFullLanguageName)(currentFile);
+    const queryPath = require.resolve(`./tree-sitter-files/queries/relevant-headers-queries/${language}-get-toplevel-headers.scm`);
+    const query = await getQueryForFile(currentFile, queryPath
+    // path.join(
+    //   __dirname,
+    //   "tree-sitter-files",
+    //   "queries",
+    //   "relevant-headers-queries",
+    //   `${language}-get-toplevel-headers.scm`
+    // )
+    );
+    if (!query) {
+        throw new Error(`failed to get query for file ${currentFile} and language ${language}`);
+    }
+    const matches = query.matches(ast.rootNode);
+    const results = [];
+    for (const match of matches) {
+        const item = {
+            declaration: "",
+            nodeType: "",
+            name: "",
+            declaredType: "",
+        };
+        for (const { name, node } of match.captures) {
+            if (name === "top.var.decl") {
+                item.nodeType = "variable";
+                item.declaration = node.text;
+                // Attempt to get the declared type (e.g., const x: string = ...)
+                const typeNode = node.descendantsOfType("type_annotation")[0];
+                if (typeNode) {
+                    item.declaredType = typeNode.text.replace(/^:\s*/, "");
+                }
+            }
+            else if (name === "top.var.name" || name === "top.fn.name") {
+                item.name = node.text;
+            }
+            else if (name === "top.fn.decl") {
+                item.nodeType = "function";
+                item.declaration = node.text;
+                // Get the return type (e.g., function foo(): string)
+                const returnTypeNode = node.childForFieldName("return_type");
+                if (returnTypeNode) {
+                    item.returnType = returnTypeNode.text.replace(/^:\s*/, "");
+                }
+                // Get declaredType if needed (TypeScript style)
+                const nameNode = node.childForFieldName("name");
+                if (nameNode && ((_a = nameNode.nextSibling) === null || _a === void 0 ? void 0 : _a.type) === "type_annotation") {
+                    item.declaredType = nameNode.nextSibling.text.replace(/^:\s*/, "");
+                }
+            }
+        }
+        if (item.name && item.declaration) {
+            results.push(item);
+        }
+    }
+    return results;
+}
+function extractFunctionTypeFromDecl(match) {
+    let paramsNode;
+    let returnNode;
+    for (const capture of match.captures) {
+        if (capture.name === "top.fn.param.type") {
+            paramsNode = capture.node;
+        }
+        else if (capture.name === "top.fn.type") {
+            returnNode = capture.node;
+        }
+    }
+    return `${paramsNode.text} => ${returnNode.text}`;
+}
+// export async function getSymbolsForManyFiles(
+//   uris: string[],
+//   ide: IDE,
+// ): Promise<FileSymbolMap> {
+//   const filesAndSymbols = await Promise.all(
+//     uris.map(async (uri): Promise<[string, SymbolWithRange[]]> => {
+//       const contents = await ide.readFile(uri);
+//       let symbols = undefined;
+//       try {
+//         symbols = await getSymbolsForFile(uri, contents);
+//       } catch (e) {
+//         console.error(`Failed to get symbols for ${uri}:`, e);
+//       }
+//       return [uri, symbols ?? []];
+//     }),
+//   );
+//   return Object.fromEntries(filesAndSymbols);
+// }