@jpoly1219/context-extractor 0.2.7 → 0.2.9

package/dist/src/typescript-type-checker.d.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { TypeChecker, TypeAnalysis } from "./types";
+import { TypeChecker, TypeAnalysis, VarFuncDecls } from "./types";
 export declare class TypeScriptTypeChecker implements TypeChecker {
     getIdentifierFromDecl(typeDecl: string): string;
     getTypeContextFromDecl(typeDecl: string): {
@@ -52,7 +52,7 @@ export declare class TypeScriptTypeChecker implements TypeChecker {
     parseTypeArrayString(typeStr: string): string[];
     handleMembers(members: ts.NodeArray<ts.TypeElement> | ts.NodeArray<ts.ClassElement>, checker: ts.TypeChecker): TypeAnalysis[];
     analyzeTypeNode(typeNode: ts.TypeNode, checker: ts.TypeChecker): TypeAnalysis;
-    analyzeTypeString(typeString: string, program?: ts.Program): TypeAnalysis;
+    analyzeTypeString(typeString: string, program: ts.Program | undefined, checker: ts.TypeChecker): TypeAnalysis;
     createProgramFromSource(content: string): ts.Program;
     isPrimitive2(typeAnalysisResult: TypeAnalysis): RegExpMatchArray | null;
     isFunction2(typeAnalysisResult: TypeAnalysis): boolean;
@@ -61,4 +61,24 @@ export declare class TypeScriptTypeChecker implements TypeChecker {
     isUnion2(typeAnalysisResult: TypeAnalysis): boolean;
     isArray2(typeAnalysisResult: TypeAnalysis): boolean;
     isTypeAlias2(typeAnalysisResult: TypeAnalysis): boolean;
+    extractIdentifiers(code: string): {
+        name: string;
+        start: number;
+        end: number;
+        line: number;
+        column: number;
+    }[];
+    extractIdentifiersHelper(node: ts.Node, identifiers: Set<string>): void;
+    extractIdentifiersWithPosHelper(sourceFile: ts.SourceFile, node: ts.Node, identifiers: {
+        name: string;
+        start: number;
+        end: number;
+        line: number;
+        column: number;
+    }[]): void;
+    findDeclarationForIdentifier(sourceCode: string, targetLine: number, targetCharStart: number, targetCharEnd: number): string | null;
+    findTopLevelDeclarations(program: ts.Program, checker: ts.TypeChecker, fileName: string): VarFuncDecls[];
+    createTsCompilerProgram(repo: string[], projectRoot: string): ts.Program;
+    getCompilerOptionsFromTsconfig(projectRoot: string): ts.ParsedCommandLine | null;
+    replaceTypeAnnotationColonWithArrow(typeStr: string): string;
 }

package/dist/src/typescript-type-checker.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.TypeScriptTypeChecker = void 0;
 const ts = __importStar(require("typescript"));
@@ -386,6 +396,9 @@ class TypeScriptTypeChecker {
                             type: this.analyzeTypeNode(element.type, checker)
                         };
                     }
+                    else if (ts.isNamedTupleMember(element)) {
+                        return this.analyzeTypeNode(element.type, checker);
+                    }
                     else {
                         return this.analyzeTypeNode(element, checker);
                     }
@@ -464,7 +477,7 @@ class TypeScriptTypeChecker {
             text: typeNode.getText()
         };
     }
-    analyzeTypeString(typeString, program = this.createProgramFromSource("")) {
+    analyzeTypeString(typeString, program = this.createProgramFromSource(""), checker) {
         const sourceFile = ts.createSourceFile('temp.ts', `type T = ${typeString};`, ts.ScriptTarget.Latest, true);
         let typeNode;
         ts.forEachChild(sourceFile, node => {
@@ -475,7 +488,7 @@ class TypeScriptTypeChecker {
         if (!typeNode) {
             throw new Error('Failed to parse type string');
         }
-        const checker = program.getTypeChecker();
+        // const checker = program.getTypeChecker();
         return this.analyzeTypeNode(typeNode, checker);
     }
     createProgramFromSource(content) {
@@ -508,5 +521,273 @@ class TypeScriptTypeChecker {
     isTypeAlias2(typeAnalysisResult) {
         return typeAnalysisResult.kind === "TypeReference";
     }
+    // Extract identifiers from a given code string.
+    // For example:
+    // type Model = [BookingFormData, Booking[], BookingID];
+    // [
+    //   { name: 'Model', start: 5, end: 10, line: 1, column: 6 },
+    //   { name: 'BookingFormData', start: 14, end: 29, line: 1, column: 15 },
+    //   { name: 'Booking', start: 31, end: 38, line: 1, column: 32 },
+    //   { name: 'BookingID', start: 42, end: 51, line: 1, column: 43 }
+    // ]
+    extractIdentifiers(code) {
+        const sourceFile = ts.createSourceFile("sample.ts", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+        const identifiers = [];
+        this.extractIdentifiersWithPosHelper(sourceFile, sourceFile, identifiers);
+        return identifiers;
+    }
+    extractIdentifiersHelper(node, identifiers) {
+        if (ts.isIdentifier(node)) {
+            // console.log(node.kind, node.text)
+            if (ts.isTypeReferenceNode(node.parent) ||
+                ts.isTypeAliasDeclaration(node.parent) ||
+                ts.isInterfaceDeclaration(node.parent) ||
+                ts.isClassDeclaration(node.parent) ||
+                ts.isFunctionTypeNode(node.parent)) {
+                identifiers.add(node.getText());
+            }
+        }
+        node.forEachChild(child => this.extractIdentifiersHelper(child, identifiers));
+    }
+    extractIdentifiersWithPosHelper(sourceFile, node, identifiers) {
+        // console.log(`iter on ${node.getText()} =*= ${node.kind}`)
+        if (ts.isIdentifier(node)) {
+            if (ts.isTypeReferenceNode(node.parent) ||
+                ts.isTypeAliasDeclaration(node.parent) ||
+                ts.isInterfaceDeclaration(node.parent) ||
+                ts.isClassDeclaration(node.parent) ||
+                ts.isFunctionTypeNode(node.parent)) {
+                const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+                identifiers.push({
+                    name: node.getText(),
+                    start: node.getStart(),
+                    end: node.getEnd(),
+                    line: line + 1, // Convert 0-based to 1-based
+                    column: character + 1 // Convert 0-based to 1-based
+                });
+            }
+        }
+        else if (
+        // Handle keywords such as SyntaxKind.BooleanKeyword (boolean)
+        node.kind == ts.SyntaxKind.BooleanKeyword ||
+            node.kind == ts.SyntaxKind.StringKeyword ||
+            node.kind == ts.SyntaxKind.NumberKeyword ||
+            node.kind == ts.SyntaxKind.UndefinedKeyword ||
+            node.kind == ts.SyntaxKind.NullKeyword
+        // NOTE: this might be too all-encompassing.
+        // node.kind >= 83 && node.kind <= 165
+        ) {
+            const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+            identifiers.push({
+                name: node.getText(),
+                start: node.getStart(),
+                end: node.getEnd(),
+                line: line + 1, // Convert 0-based to 1-based
+                column: character + 1 // Convert 0-based to 1-based
+            });
+        }
+        node.forEachChild(child => this.extractIdentifiersWithPosHelper(sourceFile, child, identifiers));
+    }
+    // Find Declaration given an identifier.
+    //
+    // For example:
+    // Decl: type Booking = [Time, User, BookingID]; || Identifier: Booking
+    findDeclarationForIdentifier(sourceCode, targetLine, targetCharStart, targetCharEnd) {
+        const sourceFile = ts.createSourceFile("sample.ts", sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+        function findDeclarationForIdentifierHelper(node) {
+            if (ts.isTypeAliasDeclaration(node)) {
+                const identifier = node.name;
+                // Get start and end positions for identifier
+                const startPos = sourceFile.getLineAndCharacterOfPosition(identifier.getStart());
+                const endPos = sourceFile.getLineAndCharacterOfPosition(identifier.getEnd());
+                // Match the identifier position
+                if (startPos.line === targetLine &&
+                    startPos.character === targetCharStart &&
+                    endPos.character === targetCharEnd) {
+                    // Extract full declaration text from source code
+                    return sourceCode.slice(node.getStart(), node.getEnd());
+                }
+            }
+            return ts.forEachChild(node, findDeclarationForIdentifierHelper) || null;
+        }
+        const declarationText = findDeclarationForIdentifierHelper(sourceFile);
+        // console.log(`declarationText: ${declarationText}`)
+        if (declarationText) {
+            return declarationText;
+        }
+        else {
+            return null;
+        }
+    }
+    // findTopLevelDeclarations(sourceCode: string, fileName = "temp.ts") {
+    findTopLevelDeclarations(program, checker, fileName) {
+        // const compilerOptions: ts.CompilerOptions = { target: ts.ScriptTarget.ESNext };
+        // NOTE: This is only necessary when you are passing the code string only.
+        // This is a nifty trick to create a temporary file to store your code string literal.
+        // In this case the function should accept (sourceCode: string, fileName = "temp.ts").
+        // If you know what file you need to read, then there is no need for this.
+        // const host = ts.createCompilerHost(compilerOptions);
+        // host.getSourceFile = (fileName, languageVersion) =>
+        //   ts.createSourceFile(fileName, sourceCode, languageVersion, true);
+        // const program = ts.createProgram([fileName], compilerOptions, host);
+        // const program = ts.createProgram([fileName], compilerOptions);
+        const sourceFile = program.getSourceFile(fileName);
+        // const checker = program.getTypeChecker();
+        const results = [];
+        function getLineChar(pos) {
+            const { line, character } = sourceFile.getLineAndCharacterOfPosition(pos);
+            return { line: line + 1, character: character + 1 }; // 1-based
+        }
+        function visit(node) {
+            var _a;
+            // Only look at top-level nodes
+            if (node.parent && node.parent.kind !== ts.SyntaxKind.SourceFile)
+                return;
+            if (ts.isFunctionDeclaration(node) && node.name) {
+                // const symbol = checker.getSymbolAtLocation(node.name);
+                // const type = symbol && checker.getTypeOfSymbolAtLocation(symbol, node);
+                // const typeString = type ? checker.typeToString(type) : "unknown";
+                const signature = checker.getSignatureFromDeclaration(node);
+                const signatureString = signature ? checker.signatureToString(signature) : "unknown";
+                const returnType = signature ? checker.typeToString(signature.getReturnType()) : null;
+                let result = {
+                    kind: "function",
+                    name: node.name.text,
+                    type: signatureString,
+                    position: getLineChar(node.getStart()),
+                    declarationText: node.getText(sourceFile),
+                    sourceFile: fileName
+                };
+                if (returnType) {
+                    result = Object.assign(Object.assign({}, result), { returnType: returnType });
+                }
+                results.push(result);
+            }
+            if (ts.isVariableStatement(node)) {
+                for (const decl of node.declarationList.declarations) {
+                    if (!ts.isIdentifier(decl.name))
+                        continue;
+                    const name = decl.name.text;
+                    const type = checker.getTypeAtLocation(decl);
+                    let kind = "variable";
+                    let returnType = null;
+                    if (decl.initializer && ts.isArrowFunction(decl.initializer)) {
+                        kind =
+                            decl.initializer && ts.isArrowFunction(decl.initializer)
+                                ? "arrowFunction"
+                                : "variable";
+                        const arrowFunc = decl.initializer;
+                        const signature = checker.getSignatureFromDeclaration(arrowFunc);
+                        if (signature) {
+                            const returnTypeSymbol = checker.getReturnTypeOfSignature(signature);
+                            // NOTE: debugging
+                            // console.log(">=>", name)
+                            // console.log(ts.TypeFlags[returnTypeSymbol.flags]);
+                            // const apparent = checker.getApparentType(returnTypeSymbol);
+                            // const returnTypeApparent = checker.typeToString(apparent);
+                            // NOTE: debugging
+                            // console.log(returnTypeApparent)
+                            // console.log(returnTypeSymbol.getSymbol()?.getName());
+                            // NOTE: debugging
+                            // console.log({
+                            //   isArray: checker.isArrayType(returnTypeSymbol),
+                            //   symbol: returnTypeSymbol.symbol?.name,
+                            // });
+                            if (checker.isArrayType(returnTypeSymbol)) {
+                                // NOTE: debugging
+                                // console.log(">=>", name, "isArrayType")
+                                const elementType = (_a = returnTypeSymbol.typeArguments) === null || _a === void 0 ? void 0 : _a[0];
+                                const inner = elementType ? checker.typeToString(elementType) : 'unknown';
+                                returnType = `${inner}[]`;
+                            }
+                            else {
+                                returnType = checker.typeToString(returnTypeSymbol);
+                            }
+                        }
+                    }
+                    let result = {
+                        kind,
+                        name,
+                        type: checker.typeToString(type),
+                        position: getLineChar(decl.getStart()),
+                        declarationText: decl.getText(sourceFile),
+                        sourceFile: fileName
+                    };
+                    if (returnType) {
+                        result = Object.assign(Object.assign({}, result), { returnType: returnType });
+                    }
+                    results.push(result);
+                }
+            }
+            if (ts.isClassDeclaration(node) && node.name) {
+                for (const member of node.members) {
+                    if (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name)) {
+                        const symbol = checker.getSymbolAtLocation(member.name);
+                        const type = symbol && checker.getTypeOfSymbolAtLocation(symbol, member);
+                        results.push({
+                            kind: "classMethod",
+                            name: `${node.name.text}.${member.name.text}`,
+                            type: type ? checker.typeToString(type) : "unknown",
+                            position: getLineChar(member.getStart()),
+                            declarationText: member.getText(sourceFile),
+                            sourceFile: fileName
+                        });
+                    }
+                }
+            }
+        }
+        ts.forEachChild(sourceFile, visit);
+        return results;
+    }
+    createTsCompilerProgram(repo, projectRoot) {
+        // NOTE: This was an attempt to use an existing TS type system.
+        const existingConfig = this.getCompilerOptionsFromTsconfig(projectRoot);
+        // NOTE: debugging
+        // console.log(existingConfig)
+        if (existingConfig) {
+            const program = ts.createProgram({
+                rootNames: existingConfig.fileNames,
+                options: existingConfig.options
+            });
+            // NOTE: debugging
+            // console.log(program.getSourceFiles().map(f => f.fileName));
+            return program;
+        }
+        const compilerOptions = {
+            target: ts.ScriptTarget.ESNext,
+            module: ts.ModuleKind.CommonJS,
+            moduleResolution: ts.ModuleResolutionKind.NodeJs,
+            esModuleInterop: true,
+            strict: true,
+            skipLibCheck: true,
+            baseUrl: projectRoot, // Optional but useful for consistent resolution
+            paths: { "*": ["node_modules/*"] }, // Optional fallback
+        };
+        const program = ts.createProgram(repo, compilerOptions);
+        return program;
+    }
+    getCompilerOptionsFromTsconfig(projectRoot) {
+        const configPath = ts.findConfigFile(projectRoot, ts.sys.fileExists, "tsconfig.json");
+        // NOTE: debugging
+        // console.log(configPath)
+        if (!configPath)
+            return null;
+        const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+        const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, 
+        // path.dirname(configPath)
+        projectRoot);
+        return parsedConfig;
+    }
+    replaceTypeAnnotationColonWithArrow(typeStr) {
+        const regex = /^([\(\[][^)]*\)?)(?:\s*:\s*)(.*)$/;
+        const match = typeStr.match(regex);
+        if (!match) {
+            console.log('Invalid function type signature');
+            return "";
+        }
+        const params = match[1].trim();
+        const returnType = match[2].trim();
+        return `${params} => ${returnType}`;
+    }
 }
 exports.TypeScriptTypeChecker = TypeScriptTypeChecker;

package/dist/src/utils.d.ts

@@ -1,4 +1,5 @@
 import { relevantTypeObject, varsObject, typesObject, typesQueryResult, varsQueryResult, relevantTypeQueryResult, typesAndLocationsQueryResult, Language } from "./types";
+declare const isUri: (str: string) => boolean;
 declare const indexOfRegexGroup: (match: RegExpMatchArray, n: number) => number;
 declare const formatTypeSpan: (typeSpan: string) => string;
 declare const extractSnippet: (documentContent: string, start: {
@@ -37,4 +38,13 @@ declare const isQLIdentifier: (typeQLClass: string) => boolean;
 declare const supportsHole: (lang: Language) => boolean;
 declare const getAllTSFiles: (dirPath: string, arrayOfFiles?: string[]) => string[];
 declare const getAllOCamlFiles: (dirPath: string, arrayOfFiles?: string[]) => string[];
-export { indexOfRegexGroup, formatTypeSpan, extractSnippet, isTuple, isUnion, isArray, isObject, isFunction, isPrimitive, isTypeAlias, escapeQuotes, parseTypeArrayString, removeLines, parseCodeQLRelevantTypes, parseCodeQLVars, parseCodeQLTypes, parseCodeQLLocationsAndTypes, parseCodeQLTypesAndLocations, isQLFunction, isQLTuple, isQLUnion, isQLArray, isQLInterface, isQLLocalTypeAccess, isQLPredefined, isQLLiteral, isQLKeyword, isQLLabel, isQLIdentifier, supportsHole, getAllTSFiles, getAllOCamlFiles };
+declare const getTimestampForFilename: () => string;
+declare const insertAtPosition: (contents: string, cursorPosition: {
+    line: number;
+    character: number;
+}, insertText: string) => string;
+declare function getCleanUriPath(uri: string): string;
+declare function getUriPathBasename(uri: string): string;
+declare function getFileExtensionFromBasename(basename: string): string;
+declare function getUriFileExtension(uri: string): string;
+export { isUri, indexOfRegexGroup, formatTypeSpan, extractSnippet, isTuple, isUnion, isArray, isObject, isFunction, isPrimitive, isTypeAlias, escapeQuotes, parseTypeArrayString, removeLines, parseCodeQLRelevantTypes, parseCodeQLVars, parseCodeQLTypes, parseCodeQLLocationsAndTypes, parseCodeQLTypesAndLocations, isQLFunction, isQLTuple, isQLUnion, isQLArray, isQLInterface, isQLLocalTypeAccess, isQLPredefined, isQLLiteral, isQLKeyword, isQLLabel, isQLIdentifier, supportsHole, getAllTSFiles, getAllOCamlFiles, getTimestampForFilename, insertAtPosition, getCleanUriPath, getUriPathBasename, getFileExtensionFromBasename, getUriFileExtension, };

package/dist/src/utils.js

@@ -15,18 +15,42 @@ 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.getAllOCamlFiles = exports.getAllTSFiles = exports.supportsHole = exports.isQLIdentifier = exports.isQLLabel = exports.isQLKeyword = exports.isQLLiteral = exports.isQLPredefined = exports.isQLLocalTypeAccess = exports.isQLInterface = exports.isQLArray = exports.isQLUnion = exports.isQLTuple = exports.isQLFunction = exports.parseCodeQLTypesAndLocations = exports.parseCodeQLLocationsAndTypes = exports.parseCodeQLTypes = exports.parseCodeQLVars = exports.parseCodeQLRelevantTypes = exports.removeLines = exports.parseTypeArrayString = exports.escapeQuotes = exports.isTypeAlias = exports.isPrimitive = exports.isFunction = exports.isObject = exports.isArray = exports.isUnion = exports.isTuple = exports.extractSnippet = exports.formatTypeSpan = exports.indexOfRegexGroup = void 0;
+exports.insertAtPosition = exports.getTimestampForFilename = exports.getAllOCamlFiles = exports.getAllTSFiles = exports.supportsHole = exports.isQLIdentifier = exports.isQLLabel = exports.isQLKeyword = exports.isQLLiteral = exports.isQLPredefined = exports.isQLLocalTypeAccess = exports.isQLInterface = exports.isQLArray = exports.isQLUnion = exports.isQLTuple = exports.isQLFunction = exports.parseCodeQLTypesAndLocations = exports.parseCodeQLLocationsAndTypes = exports.parseCodeQLTypes = exports.parseCodeQLVars = exports.parseCodeQLRelevantTypes = exports.removeLines = exports.parseTypeArrayString = exports.escapeQuotes = exports.isTypeAlias = exports.isPrimitive = exports.isFunction = exports.isObject = exports.isArray = exports.isUnion = exports.isTuple = exports.extractSnippet = exports.formatTypeSpan = exports.indexOfRegexGroup = exports.isUri = void 0;
+exports.getCleanUriPath = getCleanUriPath;
+exports.getUriPathBasename = getUriPathBasename;
+exports.getFileExtensionFromBasename = getFileExtensionFromBasename;
+exports.getUriFileExtension = getUriFileExtension;
+const URI = __importStar(require("uri-js"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const types_1 = require("./types");
+const isUri = (str) => {
+    try {
+        const url = new URL(str);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+};
+exports.isUri = isUri;
 const indexOfRegexGroup = (match, n) => {
     return match.reduce((acc, curr, i) => {
         if (i < 1 || i >= n)
@@ -316,11 +340,14 @@ const isQLIdentifier = (typeQLClass) => {
 };
 exports.isQLIdentifier = isQLIdentifier;
 const supportsHole = (lang) => {
-    const supportedLangs = [types_1.Language.OCaml];
+    const supportedLangs = ["ocaml"];
     return supportedLangs.includes(lang);
 };
 exports.supportsHole = supportsHole;
 const getAllTSFiles = (dirPath, arrayOfFiles = []) => {
+    if (dirPath.slice(0, 7) === "file://") {
+        dirPath = dirPath.slice(7);
+    }
     const files = fs.readdirSync(dirPath);
     files.forEach((file) => {
         const filePath = path.join(dirPath, file);
@@ -348,3 +375,53 @@ const getAllOCamlFiles = (dirPath, arrayOfFiles = []) => {
     return arrayOfFiles;
 };
 exports.getAllOCamlFiles = getAllOCamlFiles;
+const getTimestampForFilename = () => {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, "0"); // Months are 0-based
+    const day = String(now.getDate()).padStart(2, "0");
+    const hours = String(now.getHours()).padStart(2, "0");
+    const minutes = String(now.getMinutes()).padStart(2, "0");
+    const seconds = String(now.getSeconds()).padStart(2, "0");
+    return `${year}${month}${day}_${hours}${minutes}${seconds}`;
+};
+exports.getTimestampForFilename = getTimestampForFilename;
+const insertAtPosition = (contents, cursorPosition, insertText) => {
+    const lines = contents.split(/\r?\n/); // Handle both LF and CRLF line endings
+    const { line, character } = cursorPosition;
+    if (line < 0 || line >= lines.length) {
+        throw new Error("Invalid line number");
+    }
+    const targetLine = lines[line];
+    if (character < 0 || character > targetLine.length) {
+        throw new Error("Invalid character index");
+    }
+    // Insert the text
+    lines[line] = targetLine.slice(0, character) + insertText + targetLine.slice(character);
+    return lines.join("\n"); // Reconstruct the file
+};
+exports.insertAtPosition = insertAtPosition;
+function getCleanUriPath(uri) {
+    var _a;
+    const path = (_a = URI.parse(uri).path) !== null && _a !== void 0 ? _a : "";
+    let clean = path.replace(/^\//, ""); // remove start slash
+    clean = clean.replace(/\/$/, ""); // remove end slash
+    return clean;
+}
+function getUriPathBasename(uri) {
+    const path = getCleanUriPath(uri);
+    const basename = path.split("/").pop() || "";
+    return decodeURIComponent(basename);
+}
+function getFileExtensionFromBasename(basename) {
+    var _a;
+    const parts = basename.split(".");
+    if (parts.length < 2) {
+        return "";
+    }
+    return ((_a = parts.slice(-1)[0]) !== null && _a !== void 0 ? _a : "").toLowerCase();
+}
+function getUriFileExtension(uri) {
+    const baseName = getUriPathBasename(uri);
+    return getFileExtensionFromBasename(baseName);
+}

package/dist/src/vscode-ide.d.ts

@@ -0,0 +1,29 @@
+export declare namespace VsCode {
+    interface Hover {
+        text: string;
+    }
+    interface DocumentSymbol extends RangeInFile {
+        name: string;
+        selectionRange: Range;
+    }
+    interface RangeInFile {
+        filepath: string;
+        range: Range;
+    }
+    interface Range {
+        start: Position;
+        end: Position;
+    }
+    interface Location {
+        filepath: string;
+        position: Position;
+    }
+    interface Position {
+        line: number;
+        character: number;
+    }
+    export function hover(location: Location): Promise<Hover>;
+    export function gotoTypeDefinition(location: Location): Promise<RangeInFile[]>;
+    export function getDocumentSymbols(location: Omit<Location, "position">): Promise<DocumentSymbol[]>;
+    export {};
+}