@jpoly1219/context-extractor 0.2.7 → 0.2.9

package/dist/src/app.d.ts

@@ -1,4 +1,4 @@
-import { Language, Context } from "./types";
+import { Language, Context, IDE, Position } from "./types";
 export declare class App {
     private language;
     private languageDriver;
@@ -7,10 +7,13 @@ export declare class App {
     private sketchPath;
     private repoPath;
     private result;
-    private timeout;
-    constructor(language: Language, sketchPath: string, repoPath: string);
+    private logStream;
+    private ide;
+    private cursorPosition;
+    constructor(language: Language, sketchPath: string, repoPath: string, ide: IDE, cursorPosition: Position);
     init(): Promise<void>;
-    run(): Promise<void>;
+    run2(version: number): Promise<void>;
+    run(version: number): Promise<void>;
     close(): void;
     getSavedResult(): Context | null;
 }

package/dist/src/app.js

@@ -15,136 +15,337 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+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;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CompletionEngine = exports.App = void 0;
-const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const child_process_2 = require("child_process");
 const openai_1 = __importDefault(require("openai"));
 const main_1 = require("../ts-lsp-client-dist/src/main");
-// import { LspClient, JSONRPCEndpoint } from "ts-lsp-client";
-const types_1 = require("./types");
 // TODO: Bundle the drivers as barrel exports.
 const typescript_driver_1 = require("./typescript-driver");
 const ocaml_driver_1 = require("./ocaml-driver");
 const utils_1 = require("./utils");
+// import * as pprof from "pprof";
 class App {
-    constructor(language, sketchPath, repoPath) {
-        // private result: {
-        //   hole: string;
-        //   relevantTypes: string[];
-        //   relevantHeaders: string[];
-        // } | null = null;
+    constructor(language, sketchPath, repoPath, ide, cursorPosition) {
+        this.languageServer = null;
+        this.lspClient = null;
         this.result = null;
-        // Optional timeout for forced termination
-        this.timeout = setTimeout(() => {
-            if (!this.languageServer.killed) {
-                console.log('Forcibly killing the process...');
-                this.languageServer.kill('SIGKILL');
-            }
-        }, 5000);
         this.language = language;
         this.sketchPath = sketchPath;
         this.repoPath = repoPath;
-        const r = (() => {
-            switch (language) {
-                case types_1.Language.TypeScript: {
-                    this.languageDriver = new typescript_driver_1.TypeScriptDriver();
-                    return (0, child_process_1.spawn)("typescript-language-server", ["--stdio"], { stdio: ["pipe", "pipe", "pipe"] });
-                }
-                case types_1.Language.OCaml: {
-                    this.languageDriver = new ocaml_driver_1.OcamlDriver();
-                    try {
-                        (0, child_process_2.execSync)(`eval $(opam env --switch=. --set-switch)`, { shell: "/bin/bash" });
-                        // execSync("opam switch .", { shell: "/bin/bash" })
-                        const currDir = __dirname;
-                        process.chdir(path.dirname(sketchPath));
-                        // execSync("which dune", { shell: "/bin/bash" })
-                        (0, child_process_1.spawn)("dune", ["build", "-w"]);
-                        process.chdir(currDir);
-                    }
-                    catch (err) {
-                        console.log("ERROR:", err);
+        this.ide = ide;
+        this.cursorPosition = cursorPosition;
+        switch (ide) {
+            case "vscode": {
+                // Most things will be done via vscode's command api
+                this.languageServer = null;
+                this.lspClient = null;
+                this.logStream = null;
+            }
+            case "standalone": {
+                const r = (() => {
+                    switch (language) {
+                        case "typescript": {
+                            const sources = (0, utils_1.getAllTSFiles)(this.repoPath);
+                            this.languageDriver = new typescript_driver_1.TypeScriptDriver(this.ide, sources, repoPath);
+                            // PERF: 6ms
+                            // return spawn("typescript-language-server", ["--stdio", "--log-level", "3"], { stdio: ["pipe", "pipe", "pipe"] });
+                            return (0, child_process_1.spawn)("node", ["/home/jacob/projects/typescript-language-server/lib/cli.mjs", "--stdio", "--log-level", "4"], { stdio: ["pipe", "pipe", "pipe"] });
+                        }
+                        case "ocaml": {
+                            this.languageDriver = new ocaml_driver_1.OcamlDriver();
+                            try {
+                                (0, child_process_2.execSync)(`eval $(opam env --switch=. --set-switch)`, { shell: "/bin/bash" });
+                                // execSync("opam switch .", { shell: "/bin/bash" })
+                                const currDir = __dirname;
+                                process.chdir(path.dirname(sketchPath));
+                                // execSync("which dune", { shell: "/bin/bash" })
+                                (0, child_process_1.spawn)("dune", ["build", "-w"]);
+                                process.chdir(currDir);
+                            }
+                            catch (err) {
+                                console.log("ERROR:", err);
+                            }
+                            // TODO: Spawn a dune build -w on sketch directory.
+                            // try {
+                            //   execSync("which dune", { shell: "/bin/bash" })
+                            //   spawn("dune", ["build", "-w"]);
+                            // } catch (err) {
+                            //   console.log("ERROR:", err)
+                            // }
+                            // process.chdir(currDir);
+                            return (0, child_process_1.spawn)("ocamllsp", ["--stdio"]);
+                        }
                     }
-                    // TODO: Spawn a dune build -w on sketch directory.
-                    // try {
-                    //   execSync("which dune", { shell: "/bin/bash" })
-                    //   spawn("dune", ["build", "-w"]);
-                    // } catch (err) {
-                    //   console.log("ERROR:", err)
-                    // }
-                    // process.chdir(currDir);
-                    return (0, child_process_1.spawn)("ocamllsp", ["--stdio"]);
+                })();
+                const e = new main_1.JSONRPCEndpoint(r.stdin, r.stdout);
+                const c = new main_1.LspClient(e);
+                this.languageServer = r;
+                this.lspClient = c;
+                const sources = (0, utils_1.getAllTSFiles)(this.repoPath);
+                this.languageDriver = new typescript_driver_1.TypeScriptDriver(this.ide, sources, repoPath);
+                // Logging tsserver output
+                const logStream = fs.createWriteStream(`tsserver-${(0, utils_1.getTimestampForFilename)()}.log`, { flags: "w" });
+                this.logStream = logStream;
+                // r.stdout.pipe(this.logStream);
+                // r.stderr.pipe(this.logStream);
+                // Helper function to prepend timestamps
+                const logWithTimestamp = (data) => {
+                    var _a;
+                    const timestamp = new Date().toISOString();
+                    // console.log(timestamp)
+                    // console.log(timestamp, data.toString())
+                    (_a = this.logStream) === null || _a === void 0 ? void 0 : _a.write(`\n\n=*=*=*=*=*=[${timestamp}] ${data.toString()}\n\n`);
+                };
+                // Capture and log stdout and stderr with timestamps
+                // r.stdout.on("data", logWithTimestamp);
+                // r.stderr.on("data", logWithTimestamp);
+                // console.log(r.pid)
+                // this.languageServer.on('close', (code) => {
+                //   if (code !== 0) {
+                //     console.log(`ls process exited with code ${code}`);
+                //   }
+                // });
+                // // Clear timeout once the process exits
+                // this.languageServer.on('exit', () => {
+                //   // clearTimeout(this.timeout);
+                //   this.logStream?.close();
+                //   console.log('Process terminated cleanly.');
+                // });
+                // const logFile = fs.createWriteStream("log.txt");
+                // r.stdout.on('data', (d) => logFile.write(d));
+                this.languageDriver.init(this.lspClient, this.sketchPath);
+                // this.languageDriver.injectHole(this.sketchPath)
+            }
+        }
+    }
+    async init() {
+        await this.languageDriver.init(this.lspClient, this.sketchPath);
+    }
+    async run2(version) {
+        if (this.lspClient) {
+            const files = (0, utils_1.getAllTSFiles)(this.repoPath);
+            files.map(filepath => {
+                var _a;
+                if (fs.lstatSync(filepath).isFile()) {
+                    (_a = this.lspClient) === null || _a === void 0 ? void 0 : _a.didOpen({
+                        textDocument: {
+                            uri: `file://${filepath}`,
+                            languageId: "typescript",
+                            text: fs.readFileSync(filepath).toString("ascii"),
+                            version: version
+                        }
+                    });
                 }
+            });
+        }
+        // console.time("getHoleContext");
+        // PERF: 801ms
+        // const holeContext = await this.languageDriver.getHoleContext(
+        //   this.lspClient,
+        //   this.sketchPath,
+        //   this.logStream
+        // );
+        // const holeContext = await this.languageDriver.getHoleContextWithCompilerAPI(
+        //   this.sketchPath,
+        //   this.logStream
+        // );
+        // this.cursorPosition = { line: 3, character: 56 };
+        const holeContext = await this.languageDriver.getHoleContextWithTreesitter(this.sketchPath, this.cursorPosition, this.logStream);
+        // console.timeEnd("getHoleContext");
+        // console.dir(holeContext, { depth: null })
+        // console.time("extractRelevantTypes");
+        const relevantTypes = await this.languageDriver.extractRelevantTypesWithTreesitter(this.lspClient, holeContext.fullHoverResult, holeContext.functionName, holeContext.range.start.line, 
+        // holeContext.range.start.character,
+        new Map(), holeContext.source, new Map(), this.logStream);
+        // console.timeEnd("extractRelevantTypes");
+        // console.dir(relevantTypes, { depth: null })
+        // console.time("extractRelevantHeaders")
+        let repo = [];
+        if (this.language === "typescript") {
+            repo = (0, utils_1.getAllTSFiles)(this.repoPath);
+        }
+        else if (this.language === "ocaml") {
+            repo = (0, utils_1.getAllOCamlFiles)(this.repoPath);
+        }
+        const relevantHeaders = await this.languageDriver.extractRelevantHeadersWithTreesitter(this.lspClient, repo, relevantTypes, holeContext.functionTypeSpan, holeContext.functionName, this.repoPath);
+        // console.dir(relevantHeaders, { depth: null })
+        // console.timeEnd("extractRelevantHeaders")
+        const relevantTypesToReturn = new Map();
+        relevantTypes.forEach(({ typeSpan: v, sourceFile: src }, _) => {
+            if (relevantTypesToReturn.has(src)) {
+                const updated = relevantTypesToReturn.get(src);
+                updated.push(v);
+                relevantTypesToReturn.set(src, updated);
             }
-        })();
-        const e = new main_1.JSONRPCEndpoint(r.stdin, r.stdout);
-        const c = new main_1.LspClient(e);
-        this.languageServer = r;
-        this.lspClient = c;
-        this.languageServer.on('close', (code) => {
-            if (code !== 0) {
-                console.log(`ls process exited with code ${code}`);
+            else {
+                relevantTypesToReturn.set(src, [v]);
             }
         });
-        // Clear timeout once the process exits
-        this.languageServer.on('exit', () => {
-            clearTimeout(this.timeout);
-            console.log('Process terminated cleanly.');
+        const relevantHeadersToReturn = new Map();
+        relevantHeaders.forEach(({ typeSpan: v, sourceFile: src }) => {
+            // console.log(v, src)
+            if (relevantHeadersToReturn.has(src)) {
+                const updated = relevantHeadersToReturn.get(src);
+                if (!updated.includes(v)) {
+                    updated.push(v);
+                }
+                relevantHeadersToReturn.set(src, updated);
+            }
+            else {
+                relevantHeadersToReturn.set(src, [v]);
+            }
         });
-        // const logFile = fs.createWriteStream("log.txt");
-        // r.stdout.on('data', (d) => logFile.write(d));
-    }
-    async init() {
-        await this.languageDriver.init(this.lspClient, this.sketchPath);
+        this.result = {
+            holeType: holeContext.functionTypeSpan,
+            relevantTypes: relevantTypesToReturn,
+            relevantHeaders: relevantHeadersToReturn
+        };
     }
-    async run() {
+    async run(version) {
+        // const profile = await pprof.time.start(10000); // Collect for 10s
         // const outputFile = fs.createWriteStream("output.txt");
         try {
-            await this.init();
-            const holeContext = await this.languageDriver.getHoleContext(this.lspClient, this.sketchPath);
-            const relevantTypes = await this.languageDriver.extractRelevantTypes(this.lspClient, holeContext.fullHoverResult, holeContext.functionName, holeContext.range.start.line, holeContext.range.end.line, new Map(), holeContext.source);
-            // Postprocess the map.
-            if (this.language === types_1.Language.TypeScript) {
-                relevantTypes.delete("_()");
-                for (const [k, { typeSpan: v, sourceFile: src }] of relevantTypes.entries()) {
-                    relevantTypes.set(k, { typeSpan: v.slice(0, -1), sourceFile: src });
-                }
-            }
-            else if (this.language === types_1.Language.OCaml) {
-                relevantTypes.delete("_");
+            // PERF: 94ms
+            // await this.init();
+            if (this.lspClient) {
+                const files = (0, utils_1.getAllTSFiles)(this.repoPath);
+                files.map(filepath => {
+                    var _a;
+                    if (fs.lstatSync(filepath).isFile()) {
+                        (_a = this.lspClient) === null || _a === void 0 ? void 0 : _a.didOpen({
+                            textDocument: {
+                                uri: `file://${filepath}`,
+                                languageId: "typescript",
+                                text: fs.readFileSync(filepath).toString("ascii"),
+                                version: version
+                            }
+                        });
+                    }
+                });
             }
-            // console.log(relevantTypes)
+            console.time("getHoleContext");
+            // PERF: 801ms
+            // const holeContext = await this.languageDriver.getHoleContext(
+            //   this.lspClient,
+            //   this.sketchPath,
+            //   this.logStream
+            // );
+            const holeContext = await this.languageDriver.getHoleContextWithCompilerAPI(this.sketchPath, this.logStream);
+            // console.dir(holeContext, { depth: null })
+            console.timeEnd("getHoleContext");
+            // console.time("extractRelevantTypes");
+            // await this.lspClient.documentSymbol({
+            //   textDocument: {
+            //     uri: `file://${this.repoPath}prelude.ts`,
+            //   }
+            // });
+            // await this.lspClient.documentSymbol({
+            //   textDocument: {
+            //     uri: `file://${this.repoPath}injected_sketch.ts`,
+            //   }
+            // });
+            // let start = performance.now()
+            // await this.lspClient.typeDefinition({
+            //   textDocument: {
+            //     uri: `file://${this.repoPath}injected_sketch.ts`,
+            //   },
+            //   position: {
+            //     character: 35,
+            //     line: 1
+            //   }
+            // });
+            // let end = performance.now()
+            // console.log("elapsed:", end - start)
+            console.time("extractRelevantTypes");
+            // const relevantTypes = await this.languageDriver.extractRelevantTypes(
+            //   this.lspClient,
+            //   // NOTE: sometimes fullHoverResult isn't representative of the actual file contents, especially with generic functions.
+            //   holeContext.trueHoleFunction ? holeContext.trueHoleFunction : holeContext.fullHoverResult,
+            //   holeContext.functionName,
+            //   holeContext.range.start.line, // NOTE: this could just default to 0, because we inject the true declaration at the top
+            //   new Map<string, TypeSpanAndSourceFile>(),
+            //   holeContext.source,
+            //   new Map<string, string>(),
+            //   this.logStream
+            // );
+            const relevantTypes = await this.languageDriver.extractRelevantTypesWithCompilerAPI(holeContext.trueHoleFunction ? holeContext.trueHoleFunction : holeContext.fullHoverResult, holeContext.functionName, holeContext.range.start.line, // NOTE: this could just default to 0, because we inject the true declaration at the top
+            holeContext.range.start.character, new Map(), holeContext.source, new Map(), this.logStream);
+            console.timeEnd("extractRelevantTypes");
+            // this.logStream.write(`\n\n=*=*=*=*=*=[begin extracting relevant headers][${new Date().toISOString()}]\n\n`);
+            // const sleep = (ms: number) => new Promise<void>(resolve => setTimeout(resolve, ms));
+            // (async () => {
+            //   console.log("Waiting...");
+            //   await sleep(2000);
+            //   console.log("Done!");
+            // })();
+            // console.timeEnd("extractRelevantTypes");
+            // console.dir(relevantTypes, { depth: null })
+            // Postprocess the map.
+            // console.time("extractRelevantTypes postprocess");
+            // if (this.language === Language.TypeScript) {
+            //   relevantTypes.delete("_()");
+            //   for (const [k, { typeSpan: v, sourceFile: src }] of relevantTypes.entries()) {
+            //     relevantTypes.set(k, { typeSpan: v.slice(0, -1), sourceFile: src });
+            //   }
+            // } else if (this.language === Language.OCaml) {
+            //   relevantTypes.delete("_");
+            // }
+            // console.timeEnd("extractRelevantTypes postprocess");
+            // console.time("extractRelevantHeaders repo");
             let repo = [];
-            if (this.language === types_1.Language.TypeScript) {
+            if (this.language === "typescript") {
                 repo = (0, utils_1.getAllTSFiles)(this.repoPath);
             }
-            else if (this.language === types_1.Language.OCaml) {
+            else if (this.language === "ocaml") {
                 repo = (0, utils_1.getAllOCamlFiles)(this.repoPath);
             }
-            const relevantHeaders = await this.languageDriver.extractRelevantHeaders(this.lspClient, repo, relevantTypes, holeContext.functionTypeSpan);
+            // console.timeEnd("extractRelevantHeaders repo");
+            // console.time("extractRelevantHeaders");
+            console.time("extractRelevantHeaders");
+            const relevantHeaders = await this.languageDriver.extractRelevantHeaders(this.lspClient, repo, relevantTypes, holeContext.functionTypeSpan, this.repoPath);
+            console.timeEnd("extractRelevantHeaders");
+            // const relevantHeaders: { typeSpan: string, sourceFile: string }[] = []
+            // console.timeEnd("extractRelevantHeaders");
             // console.log(relevantHeaders)
+            // console.log(relevantHeaders.size)
+            // console.dir(relevantHeaders, { depth: null })
             // Postprocess the map.
-            if (this.language === types_1.Language.TypeScript) {
-                relevantTypes.delete("");
-                for (const [k, { typeSpan: v, sourceFile: src }] of relevantTypes.entries()) {
-                    relevantTypes.set(k, { typeSpan: v + ";", sourceFile: src });
-                }
-                for (const obj of relevantHeaders) {
-                    obj.typeSpan += ";";
-                }
-            }
+            // console.time("extractRelevantHaders postprocess");
+            // if (this.language === Language.TypeScript) {
+            //   relevantTypes.delete("");
+            //   for (const [k, { typeSpan: v, sourceFile: src }] of relevantTypes.entries()) {
+            //     relevantTypes.set(k, { typeSpan: v + ";", sourceFile: src });
+            //   }
+            //   for (const obj of relevantHeaders) {
+            //     obj.typeSpan += ";";
+            //   }
+            // }
+            // console.timeEnd("extractRelevantHeaders postprocess");
+            // console.time("toReturn");
             const relevantTypesToReturn = new Map();
             relevantTypes.forEach(({ typeSpan: v, sourceFile: src }, _) => {
                 if (relevantTypesToReturn.has(src)) {
@@ -158,6 +359,7 @@ class App {
             });
             const relevantHeadersToReturn = new Map();
             relevantHeaders.forEach(({ typeSpan: v, sourceFile: src }) => {
+                // console.log(v, src)
                 if (relevantHeadersToReturn.has(src)) {
                     const updated = relevantHeadersToReturn.get(src);
                     if (!updated.includes(v)) {
@@ -169,11 +371,25 @@ class App {
                     relevantHeadersToReturn.set(src, [v]);
                 }
             });
+            // console.timeEnd("toReturn");
             this.result = {
                 holeType: holeContext.functionTypeSpan,
                 relevantTypes: relevantTypesToReturn,
                 relevantHeaders: relevantHeadersToReturn
             };
+            if (this.lspClient) {
+                const files = (0, utils_1.getAllTSFiles)(this.repoPath);
+                files.map(filepath => {
+                    var _a;
+                    if (fs.lstatSync(filepath).isFile()) {
+                        (_a = this.lspClient) === null || _a === void 0 ? void 0 : _a.didClose({
+                            textDocument: {
+                                uri: `file://${filepath}`,
+                            }
+                        });
+                    }
+                });
+            }
         }
         catch (err) {
             console.error("Error during execution:", err);
@@ -182,17 +398,23 @@ class App {
         finally {
             // outputFile.end();
         }
+        // const buf = await pprof.encode(profile());
+        // fs.writeFile('wall.pb.gz', buf, (err) => {
+        //   if (err) throw err;
+        // });
     }
     close() {
+        var _a;
         // TODO:
         try {
-            this.lspClient.exit();
+            (_a = this.lspClient) === null || _a === void 0 ? void 0 : _a.exit();
         }
         catch (err) {
             console.log(err);
         }
     }
     getSavedResult() {
+        // console.dir(this.result, { depth: null })
         return this.result;
     }
 }
@@ -238,10 +460,10 @@ class CompletionEngine {
     generateTypesAndHeadersPrompt(sketchFileContent, holeType, relevantTypes, relevantHeaders) {
         let holeConstruct = "";
         switch (this.language) {
-            case types_1.Language.TypeScript: {
+            case "typescript": {
                 holeConstruct = "_()";
             }
-            case types_1.Language.OCaml: {
+            case "ocaml": {
                 holeConstruct = "_";
             }
         }

package/dist/src/ast.d.ts

@@ -0,0 +1,6 @@
+import Parser from "web-tree-sitter";
+import { RangeInFileWithContents } from "./types";
+export type AstPath = Parser.SyntaxNode[];
+export declare function getAst(filepath: string, fileContents: string): Promise<Parser.Tree | undefined>;
+export declare function getTreePathAtCursor(ast: Parser.Tree, cursorIndex: number): Promise<AstPath>;
+export declare function getScopeAroundRange(range: RangeInFileWithContents): Promise<RangeInFileWithContents | undefined>;

package/dist/src/ast.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAst = getAst;
+exports.getTreePathAtCursor = getTreePathAtCursor;
+exports.getScopeAroundRange = getScopeAroundRange;
+const tree_sitter_1 = require("./tree-sitter");
+async function getAst(filepath, fileContents) {
+    const parser = await (0, tree_sitter_1.getParserForFile)(filepath);
+    if (!parser) {
+        return undefined;
+    }
+    try {
+        const ast = parser.parse(fileContents);
+        if (!ast) {
+            return undefined;
+        }
+        return ast;
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+async function getTreePathAtCursor(ast, cursorIndex) {
+    const path = [ast.rootNode];
+    while (path[path.length - 1].childCount > 0) {
+        let foundChild = false;
+        for (const child of path[path.length - 1].children) {
+            if (child && child.startIndex <= cursorIndex && child.endIndex >= cursorIndex) {
+                path.push(child);
+                foundChild = true;
+                break;
+            }
+        }
+        if (!foundChild) {
+            break;
+        }
+    }
+    return path;
+}
+async function getScopeAroundRange(range) {
+    var _a, _b, _c, _d;
+    const ast = await getAst(range.filepath, range.contents);
+    if (!ast) {
+        return undefined;
+    }
+    const { start: s, end: e } = range.range;
+    const lines = range.contents.split("\n");
+    const startIndex = lines.slice(0, s.line).join("\n").length +
+        ((_b = (_a = lines[s.line]) === null || _a === void 0 ? void 0 : _a.slice(s.character).length) !== null && _b !== void 0 ? _b : 0);
+    const endIndex = lines.slice(0, e.line).join("\n").length +
+        ((_d = (_c = lines[e.line]) === null || _c === void 0 ? void 0 : _c.slice(0, e.character).length) !== null && _d !== void 0 ? _d : 0);
+    let node = ast.rootNode;
+    while (node.childCount > 0) {
+        let foundChild = false;
+        for (const child of node.children) {
+            if (child && child.startIndex < startIndex && child.endIndex > endIndex) {
+                node = child;
+                foundChild = true;
+                break;
+            }
+        }
+        if (!foundChild) {
+            break;
+        }
+    }
+    return {
+        contents: node.text,
+        filepath: range.filepath,
+        range: {
+            start: {
+                line: node.startPosition.row,
+                character: node.startPosition.column,
+            },
+            end: {
+                line: node.endPosition.row,
+                character: node.endPosition.column,
+            },
+        },
+    };
+}

package/dist/src/codeql.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+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.getRelevantHeaders4 = exports.getRelevantHeaders3 = exports.getRelevantHeaders = exports.extractTypesAndLocations = exports.extractRelevantContextWithCodeQL = exports.extractHeadersWithCodeQL = exports.extractRelevantTypesWithCodeQL = exports.extractHoleType = exports.createDatabaseWithCodeQL = void 0;
 const fs = __importStar(require("fs"));