testeranto 0.203.0 → 0.206.0

package/dist/module/src/testeranto.js

@@ -0,0 +1,174 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import ansiC from "ansi-colors";
+import fs from "fs";
+import readline from "readline";
+import { AppHtml } from "./utils/buildTemplates";
+import { PitonoBuild } from "./PM/pitonoBuild";
+import { getRunnables } from "./app/backend/utils";
+import path from "path";
+const { GolingvuBuild } = await import("./PM/golingvuBuild");
+import webHtmlFrame from "./web.html";
+// if (!process.env.GITHUB_CLIENT_ID) {
+//   console.error(`env var "GITHUB_CLIENT_ID" needs to be set!`);
+//   process.exit(-1);
+// }
+// if (!process.env.GITHUB_CLIENT_SECRET) {
+//   console.error(`env var "GITHUB_CLIENT_SECRET" needs to be set!`);
+//   process.exit(-1);
+// }
+readline.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY)
+    process.stdin.setRawMode(true);
+const testName = process.argv[2];
+const mode = process.argv[3];
+if (mode !== "once" && mode !== "dev") {
+    console.error(`The 3rd argument should be 'dev' or 'once', not '${mode}'.`);
+    process.exit(-1);
+}
+const configFilePath = process.cwd() + "/" + "testeranto.config.ts";
+import(configFilePath).then(async (module) => {
+    const pckge = (await import(`${process.cwd()}/package.json`)).default;
+    const bigConfig = module.default;
+    const project = bigConfig.projects[testName];
+    if (!project) {
+        console.error("no project found for", testName, "in testeranto.config.ts");
+        process.exit(-1);
+    }
+    try {
+        fs.writeFileSync(`${process.cwd()}/testeranto/projects.json`, JSON.stringify(Object.keys(bigConfig.projects), null, 2));
+    }
+    catch (e) {
+        console.error("there was a problem");
+        console.error(e);
+    }
+    const rawConfig = bigConfig.projects[testName];
+    if (!rawConfig) {
+        console.error(`Project "${testName}" does not exist in the configuration.`);
+        console.error("Available projects:", Object.keys(bigConfig.projects));
+        process.exit(-1);
+    }
+    if (!rawConfig.tests) {
+        console.error(testName, "appears to have no tests: ", configFilePath);
+        console.error(`here is the config:`);
+        console.log(JSON.stringify(rawConfig));
+        process.exit(-1);
+    }
+    const config = Object.assign(Object.assign({}, rawConfig), { buildDir: process.cwd() + "/testeranto/bundles/" + testName });
+    console.log(ansiC.inverse("Press 'q' to initiate a graceful shutdown."));
+    console.log(ansiC.inverse("Press 'x' to quit forcefully."));
+    process.stdin.on("keypress", (str, key) => {
+        if (key.name === "x") {
+            console.log(ansiC.inverse("Shutting down forcefully..."));
+            process.exit(-1);
+        }
+    });
+    //////////////////////////////////////////////////////////////////////////////////////////////////
+    let pm = null;
+    // Start PM_Main immediately - it will handle the build processes internally
+    const { PM_Main } = await import("./app/backend/main");
+    pm = new PM_Main(config, testName, mode);
+    await pm.start();
+    fs.writeFileSync(`${process.cwd()}/testeranto/index.html`, AppHtml());
+    Object.keys(bigConfig.projects).forEach((projectName) => {
+        // console.log(`testeranto/reports/${projectName}`);
+        if (!fs.existsSync(`testeranto/reports/${projectName}`)) {
+            fs.mkdirSync(`testeranto/reports/${projectName}`);
+        }
+        fs.writeFileSync(`testeranto/reports/${projectName}/config.json`, JSON.stringify(config, null, 2));
+    });
+    const getSecondaryEndpointsPoints = (runtime) => {
+        const meta = (ts, st) => {
+            ts.forEach((t) => {
+                if (t[1] === runtime) {
+                    st.add(t[0]);
+                }
+                if (Array.isArray(t[3])) {
+                    meta(t[3], st);
+                }
+            });
+            return st;
+        };
+        return Array.from(meta(config.tests, new Set()));
+    };
+    // Also handle pitono endpoints for HTML generation if needed
+    // [...getSecondaryEndpointsPoints("python")].forEach(async (sourceFilePath) => {
+    //   // You might want to generate specific files for pitono tests here
+    //   console.log(`Pitono test found: ${sourceFilePath}`);
+    // });
+    Promise.resolve(Promise.all([...getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
+        const sourceFileSplit = sourceFilePath.split("/");
+        const sourceDir = sourceFileSplit.slice(0, -1);
+        const sourceFileName = sourceFileSplit[sourceFileSplit.length - 1];
+        const sourceFileNameMinusJs = sourceFileName
+            .split(".")
+            .slice(0, -1)
+            .join(".");
+        const htmlFilePath = path.normalize(`${process.cwd()}/testeranto/bundles/web/${testName}/${sourceDir.join("/")}/${sourceFileNameMinusJs}.html`);
+        const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
+        const cssFilePath = `./${sourceFileNameMinusJs}.css`;
+        return fs.promises
+            .mkdir(path.dirname(htmlFilePath), { recursive: true })
+            .then((x) => fs.writeFileSync(htmlFilePath, webHtmlFrame(jsfilePath, htmlFilePath, cssFilePath)));
+    })));
+    const { nodeEntryPoints, nodeEntryPointSidecars, webEntryPoints, webEntryPointSidecars, pureEntryPoints, pureEntryPointSidecars, pythonEntryPoints, pythonEntryPointSidecars, golangEntryPoints, golangEntryPointSidecars, } = getRunnables(config.tests, testName);
+    // Debug logging to check if entry points are being found
+    console.log("Node entry points:", Object.keys(nodeEntryPoints));
+    console.log("Web entry points:", Object.keys(webEntryPoints));
+    console.log("Pure entry points:", Object.keys(pureEntryPoints));
+    // Handle golang tests using GolingvuBuild
+    const golangTests = config.tests.filter((test) => test[1] === "golang");
+    const hasGolangTests = golangTests.length > 0;
+    if (hasGolangTests) {
+        const golingvuBuild = new GolingvuBuild(config, testName);
+        const golangEntryPoints = await golingvuBuild.build();
+        golingvuBuild.onBundleChange(() => {
+            Object.keys(golangEntryPoints).forEach((entryPoint) => {
+                if (pm) {
+                    pm.addToQueue(entryPoint, "golang");
+                }
+            });
+        });
+    }
+    // Handle pitono (Python) tests by generating their metafiles
+    const pitonoTests = config.tests.filter((test) => test[1] === "python");
+    const hasPitonoTests = pitonoTests.length > 0;
+    if (hasPitonoTests) {
+        const pitonoBuild = new PitonoBuild(config, testName);
+        const pitonoEntryPoints = await pitonoBuild.build();
+        pitonoBuild.onBundleChange(() => {
+            Object.keys(pitonoEntryPoints).forEach((entryPoint) => {
+                if (pm) {
+                    pm.addToQueue(entryPoint, "python");
+                }
+            });
+        });
+    }
+    // create the necessary folders for all tests
+    [
+        ["pure", Object.keys(pureEntryPoints)],
+        ["node", Object.keys(nodeEntryPoints)],
+        ["web", Object.keys(webEntryPoints)],
+        ["python", Object.keys(pythonEntryPoints)],
+        ["golang", Object.keys(golangEntryPoints)],
+    ].forEach(async ([runtime, keys]) => {
+        keys.forEach(async (k) => {
+            fs.mkdirSync(`testeranto/reports/${testName}/${k
+                .split(".")
+                .slice(0, -1)
+                .join(".")}/${runtime}`, { recursive: true });
+        });
+    });
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    process.stdin.on("keypress", (str, key) => {
+        if (key.name === "q") {
+            console.log("Testeranto is shutting down gracefully...");
+            if (pm) {
+                pm.stop();
+            }
+            else {
+                process.exit();
+            }
+        }
+    });
+});

package/dist/module/src/utils/buildTemplates.js

@@ -0,0 +1,33 @@
+const getBaseHtml = (title) => `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta name="description" content="Webpage description goes here" />
+  <meta charset="utf-8" />
+  <title>${title} - testeranto</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="author" content="" />
+
+  <script>
+    function initApp() {
+      if (window.React && window.ReactDOM && window.App) {
+        const root = ReactDOM.createRoot(document.getElementById('root'));
+        root.render(React.createElement(App));
+      } else {
+        setTimeout(initApp, 100);
+      }
+    }
+    window.addEventListener('DOMContentLoaded', initApp);
+  </script>
+`;
+export const AppHtml = () => `
+  ${getBaseHtml("Testeranto")}
+  
+  <link rel="stylesheet" href="App.css" />
+  <script src="App.js"></script>
+</head>
+<body>
+  <div id="root"></div>
+</body>
+</html>
+`;

package/dist/module/src/utils/generateGolingvuMetafile.js

@@ -0,0 +1,151 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import path from "path";
+import fs from "fs";
+import { findProjectRoot } from "./golingvuMetafile/helpers";
+import { collectGoDependencies } from "./golingvuMetafile/fileDiscovery";
+import { parseGoImports } from "./golingvuMetafile/importParser";
+let generationQueue = null;
+export async function generateGolingvuMetafile(testName, entryPoints) {
+    // If there's already a generation in progress, wait for it to complete
+    if (generationQueue) {
+        return generationQueue;
+    }
+    generationQueue = (async () => {
+        const inputs = {};
+        const outputs = {};
+        const signature = Date.now().toString(36);
+        // If entry points are provided, use them directly
+        // For test generation, we want to include test files
+        const filteredEntryPoints = [];
+        for (const entryPoint of entryPoints) {
+            // Skip if it's not a .go file
+            if (!entryPoint.endsWith(".go")) {
+                console.warn(`Skipping non-Go file: ${entryPoint}`);
+                continue;
+            }
+            // Check if the file exists and is a file
+            let resolvedPath = entryPoint;
+            if (!path.isAbsolute(entryPoint)) {
+                resolvedPath = path.join(process.cwd(), entryPoint);
+            }
+            if (!fs.existsSync(resolvedPath)) {
+                console.warn(`Entry point does not exist: ${resolvedPath}`);
+                continue;
+            }
+            if (!fs.statSync(resolvedPath).isFile()) {
+                console.warn(`Entry point is not a file: ${resolvedPath}`);
+                continue;
+            }
+            // Add to filtered entry points - don't skip test files for test generation
+            filteredEntryPoints.push(resolvedPath);
+        }
+        entryPoints = filteredEntryPoints;
+        // If no valid entry points remain, try to find Go files automatically
+        // For test generation, include all files including test files
+        // if (entryPoints.length === 0) {
+        //   const allGoFiles = findGoFilesInProject();
+        //   // Don't filter out test files
+        //   entryPoints = allGoFiles.filter((file) => {
+        //     const fileName = path.basename(file);
+        //     // Only exclude our generated files
+        //     return (
+        //       !fileName.endsWith(".golingvu.test.go") &&
+        //       !fileName.endsWith(".golingvu.go")
+        //     );
+        //   });
+        //   if (entryPoints.length === 0) {
+        //     console.warn("No Go files found in the project");
+        //   } else {
+        //     console.log(`Found ${entryPoints.length} Go files:`, entryPoints);
+        //   }
+        // }
+        // Process all valid entry points to collect their dependencies
+        const allDependencies = new Set();
+        const validEntryPoints = [];
+        for (let i = 0; i < entryPoints.length; i++) {
+            let entryPoint = entryPoints[i];
+            // Resolve and validate the entry point path
+            let resolvedPath = entryPoint;
+            if (!path.isAbsolute(entryPoint)) {
+                resolvedPath = path.join(process.cwd(), entryPoint);
+            }
+            if (!fs.existsSync(resolvedPath)) {
+                console.warn(`Entry point ${entryPoint} does not exist at ${resolvedPath}`);
+                continue;
+            }
+            // Update the entry point to use the resolved path
+            entryPoints[i] = resolvedPath;
+            entryPoint = resolvedPath;
+            // Don't skip test files for test generation
+            validEntryPoints.push(entryPoint);
+            // Collect dependencies for this entry point
+            const entryPointDependencies = collectGoDependencies(entryPoint);
+            entryPointDependencies.forEach((dep) => allDependencies.add(dep));
+        }
+        // Process all dependencies to add to inputs
+        for (const dep of allDependencies) {
+            if (!inputs[dep]) {
+                const bytes = fs.statSync(dep).size;
+                const imports = parseGoImports(dep);
+                // Check if this is a test file
+                const isTestFile = path.basename(dep).includes("_test.go") ||
+                    path.basename(dep).includes(".golingvu.test.go");
+                inputs[dep] = Object.assign({ bytes,
+                    imports, format: "esm" }, (isTestFile ? { testeranto: { isTest: true } } : {}));
+            }
+        }
+        // Generate the output path based on the project structure
+        // Always use the project root as the base
+        const projectRoot = findProjectRoot();
+        let outputKey = "";
+        if (validEntryPoints.length > 0) {
+            const firstEntryPoint = validEntryPoints[0];
+            // Get the relative path from project root to the entry point
+            const relativePath = path.relative(projectRoot, path.dirname(firstEntryPoint));
+            // Get the base name without extension
+            const baseName = path.basename(firstEntryPoint, ".go");
+            // Construct the output key
+            // Ensure relativePath is not empty
+            const outputPath = relativePath === "" ? baseName : path.join(relativePath, baseName);
+            outputKey = `golang/${path.basename(projectRoot)}/${outputPath}.golingvu.go`;
+        }
+        else {
+            // Fallback if no valid entry points
+            outputKey = `golang/core/main.golingvu.go`;
+        }
+        // Calculate total bytes from all inputs
+        const inputBytes = {};
+        let totalBytes = 0;
+        for (const inputPath in inputs) {
+            const bytes = inputs[inputPath].bytes;
+            inputBytes[inputPath] = { bytesInOutput: bytes };
+            totalBytes += bytes;
+        }
+        // Store the first valid entry point for use in the wrapper generation
+        const firstEntryPoint = validEntryPoints.length > 0 ? validEntryPoints[0] : "";
+        outputs[outputKey] = {
+            imports: [],
+            exports: [],
+            entryPoint: firstEntryPoint,
+            inputs: inputBytes,
+            bytes: totalBytes,
+            signature,
+        };
+        // If no valid entry points were found, log a warning
+        if (validEntryPoints.length === 0) {
+            console.warn("No valid Go files found to process");
+        }
+        const result = {
+            errors: [],
+            warnings: [],
+            metafile: {
+                inputs,
+                outputs,
+            },
+        };
+        generationQueue = null;
+        return result;
+    })();
+    return generationQueue;
+}

package/dist/module/src/utils/golingvuMetafile/fileDiscovery.js

@@ -0,0 +1,136 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import fs from "fs";
+import path from "path";
+// import { runGoList } from "../golingvuMetafile/goList";
+// export function findGoFilesInProject(): string[] {
+//   // Use go list to find all Go files in the current module
+//   // const packages = runGoList("./...");
+//   const goFiles: string[] = [];
+//   for (const pkg of packages) {
+//     // Include all Go files including test files
+//     const fileTypes = [
+//       "GoFiles",
+//       "CgoFiles",
+//       "IgnoredGoFiles",
+//       "TestGoFiles",
+//       "XTestGoFiles",
+//     ];
+//     for (const fileType of fileTypes) {
+//       const files = (pkg as any)[fileType];
+//       if (files) {
+//         for (const file of files) {
+//           // Only include files with .go extension
+//           if (file.endsWith(".go")) {
+//             goFiles.push(path.join(pkg.Dir, file));
+//           }
+//         }
+//       }
+//     }
+//   }
+//   // Filter out any non-.go files that might have slipped through
+//   return goFiles.filter((file) => file.endsWith(".go"));
+// }
+export function collectGoDependencies(filePath, visited = new Set()) {
+    // Only process .go files
+    if (!filePath.endsWith(".go")) {
+        return [];
+    }
+    if (visited.has(filePath))
+        return [];
+    visited.add(filePath);
+    const dependencies = [filePath];
+    // Find the package this file belongs to by looking at the directory
+    const dir = path.dirname(filePath);
+    // Always include other .go files in the same directory
+    try {
+        const files = fs.readdirSync(dir);
+        for (const file of files) {
+            if (file.endsWith(".go") && file !== path.basename(filePath)) {
+                const fullPath = path.join(dir, file);
+                dependencies.push(fullPath);
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Could not read directory ${dir}:`, error);
+    }
+    // Parse imports from the file content to find local imports
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        const importRegex = /import\s*(?:\(\s*([\s\S]*?)\s*\)|"([^"]+)")/g;
+        let match;
+        while ((match = importRegex.exec(content)) !== null) {
+            if (match[2]) {
+                // Single import
+                const importPath = match[2].trim();
+                processImport(importPath, dir, dependencies, visited);
+            }
+            else if (match[1]) {
+                // Multi-line imports in parentheses
+                const importBlock = match[1];
+                const importLines = importBlock
+                    .split("\n")
+                    .map((line) => line.trim())
+                    .filter((line) => line.length > 0 && !line.startsWith("//"));
+                for (const line of importLines) {
+                    const lineMatch = line.match(/"([^"]+)"/);
+                    if (lineMatch) {
+                        const importPath = lineMatch[1].trim();
+                        processImport(importPath, dir, dependencies, visited);
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.warn(`Could not read file ${filePath} for import parsing:`, error);
+    }
+    return [...new Set(dependencies)];
+}
+function processImport(importPath, currentDir, dependencies, visited) {
+    // Check if it's a standard library import (no dots in first path element)
+    const firstPathElement = importPath.split("/")[0];
+    const isExternal = firstPathElement.includes(".");
+    // If it's not external, it's either standard library or local
+    // For local imports, they should be relative to the current module root
+    if (!isExternal) {
+        // Try to find the imported file locally
+        // Look in vendor directory first (common for Go projects)
+        const potentialPaths = [
+            path.join(process.cwd(), "vendor", importPath),
+            path.join(currentDir, importPath),
+            path.join(process.cwd(), importPath),
+            path.join(process.cwd(), "src", importPath),
+        ];
+        for (const potentialPath of potentialPaths) {
+            // Check if it's a directory with .go files
+            if (fs.existsSync(potentialPath) &&
+                fs.statSync(potentialPath).isDirectory()) {
+                try {
+                    const files = fs.readdirSync(potentialPath);
+                    for (const file of files) {
+                        // Only process .go files that aren't test files
+                        if (file.endsWith(".go") && !file.endsWith("_test.go")) {
+                            const fullPath = path.join(potentialPath, file);
+                            // Ensure we're only adding .go files
+                            dependencies.push(...collectGoDependencies(fullPath, visited));
+                        }
+                    }
+                    break;
+                }
+                catch (error) {
+                    console.warn(`Could not read directory ${potentialPath}:`, error);
+                }
+            }
+            // Check if it's a .go file directly
+            const goFilePath = potentialPath + ".go";
+            if (fs.existsSync(goFilePath) && fs.statSync(goFilePath).isFile()) {
+                // Ensure it's a .go file
+                if (goFilePath.endsWith(".go")) {
+                    dependencies.push(...collectGoDependencies(goFilePath, visited));
+                    break;
+                }
+            }
+        }
+    }
+}

package/dist/module/src/utils/golingvuMetafile/goList.js

@@ -0,0 +1,97 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+export function runGoList(pattern) {
+    try {
+        // Handle directory paths by using '.' for the current directory when appropriate
+        let processedPattern = pattern;
+        // If it's a directory that exists, try to use it as a package path
+        if (fs.existsSync(pattern)) {
+            const stat = fs.statSync(pattern);
+            if (stat.isDirectory()) {
+                // Change to that directory and use '.' to list the current package
+                // But this might not work if the directory isn't a valid Go package
+                // So we'll try to use the relative path from the module root
+                const cwd = process.cwd();
+                try {
+                    // Try to run go list from the target directory
+                    const output = execSync(`go list -mod=readonly -json .`, {
+                        encoding: "utf-8",
+                        cwd: pattern,
+                        stdio: ["pipe", "pipe", "pipe"],
+                    });
+                    return parseGoListOutput(output);
+                }
+                catch (error) {
+                    // If that fails, fall back to using the absolute path as a pattern
+                    processedPattern = pattern;
+                }
+            }
+            else if (stat.isFile() && pattern.endsWith(".go")) {
+                // For .go files, use their directory
+                processedPattern = path.dirname(pattern);
+            }
+        }
+        // Try to run go list with the processed pattern
+        const output = execSync(`go list -mod=readonly -json "${processedPattern}"`, {
+            encoding: "utf-8",
+            cwd: process.cwd(),
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        return parseGoListOutput(output);
+    }
+    catch (error) {
+        console.warn(`Error running 'go list -json ${pattern}':`, error);
+        // Return empty array instead of trying fallbacks that will likely also fail
+        return [];
+    }
+}
+// Helper function to parse the JSON output from go list
+function parseGoListOutput(output) {
+    // The output is a sequence of JSON objects, not a JSON array
+    // We need to split them and parse individually
+    const objects = [];
+    let buffer = "";
+    let depth = 0;
+    let inString = false;
+    let escapeNext = false;
+    for (const char of output) {
+        if (escapeNext) {
+            buffer += char;
+            escapeNext = false;
+            continue;
+        }
+        if (char === "\\") {
+            escapeNext = true;
+            buffer += char;
+            continue;
+        }
+        if (char === '"') {
+            inString = !inString;
+        }
+        if (!inString) {
+            if (char === "{") {
+                depth++;
+            }
+            else if (char === "}") {
+                depth--;
+                if (depth === 0) {
+                    try {
+                        objects.push(JSON.parse(buffer + char));
+                        buffer = "";
+                        continue;
+                    }
+                    catch (e) {
+                        console.warn("Failed to parse JSON object:", buffer + char);
+                        buffer = "";
+                    }
+                }
+            }
+        }
+        if (depth > 0 || buffer.length > 0) {
+            buffer += char;
+        }
+    }
+    return objects;
+}

package/dist/module/src/utils/golingvuMetafile/helpers.js

@@ -0,0 +1,59 @@
+import fs from "fs";
+import path from "path";
+export function findProjectRoot() {
+    // Start from current directory and walk up until we find package.json
+    let currentDir = process.cwd();
+    while (currentDir !== path.parse(currentDir).root) {
+        const packageJsonPath = path.join(currentDir, "package.json");
+        if (fs.existsSync(packageJsonPath)) {
+            return currentDir;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    // Fallback to current directory if package.json not found
+    return process.cwd();
+}
+// Helper function to find and parse go.mod file
+export function findAndParseGoMod(startDir) {
+    let currentDir = startDir;
+    while (currentDir !== path.parse(currentDir).root) {
+        const goModPath = path.join(currentDir, "go.mod");
+        if (fs.existsSync(goModPath)) {
+            try {
+                const goModContent = fs.readFileSync(goModPath, "utf-8");
+                const moduleMatch = goModContent.match(/^module\s+(\S+)/m);
+                if (moduleMatch && moduleMatch[1]) {
+                    return {
+                        root: currentDir,
+                        modulePath: moduleMatch[1],
+                    };
+                }
+            }
+            catch (error) {
+                console.warn(`Error reading go.mod at ${goModPath}:`, error);
+            }
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+}
+// Helper function to calculate import path from file path
+export function calculateImportPath(filePath) {
+    const goModInfo = findAndParseGoMod(path.dirname(filePath));
+    if (!goModInfo) {
+        return null;
+    }
+    const relativePath = path.relative(goModInfo.root, path.dirname(filePath));
+    if (relativePath && relativePath !== ".") {
+        return path.join(goModInfo.modulePath, relativePath).replace(/\\/g, "/");
+    }
+    return goModInfo.modulePath;
+}
+// Helper function to normalize import path
+export function normalizeImportPath(importPath) {
+    // Remove leading ./
+    if (importPath.startsWith("./")) {
+        return importPath.substring(2);
+    }
+    return importPath;
+}