testeranto 0.203.0 → 0.205.0

package/dist/common/src/testeranto.js

@@ -0,0 +1,223 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ansi_colors_1 = __importDefault(require("ansi-colors"));
+const fs_1 = __importDefault(require("fs"));
+const readline_1 = __importDefault(require("readline"));
+const buildTemplates_1 = require("./utils/buildTemplates");
+const pitonoBuild_1 = require("./PM/pitonoBuild");
+const utils_1 = require("./app/backend/utils");
+const { GolingvuBuild } = await Promise.resolve().then(() => __importStar(require("./PM/golingvuBuild")));
+// 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_1.default.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";
+Promise.resolve(`${configFilePath}`).then(s => __importStar(require(s))).then(async (module) => {
+    const pckge = (await Promise.resolve(`${`${process.cwd()}/package.json`}`).then(s => __importStar(require(s)))).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_1.default.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(ansi_colors_1.default.inverse("Press 'q' to initiate a graceful shutdown."));
+    console.log(ansi_colors_1.default.inverse("Press 'x' to quit forcefully."));
+    process.stdin.on("keypress", (str, key) => {
+        if (key.name === "x") {
+            console.log(ansi_colors_1.default.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 Promise.resolve().then(() => __importStar(require("./app/backend/main")));
+    pm = new PM_Main(config, testName, mode);
+    await pm.start();
+    fs_1.default.writeFileSync(`${process.cwd()}/testeranto/index.html`, (0, buildTemplates_1.AppHtml)());
+    Object.keys(bigConfig.projects).forEach((projectName) => {
+        // console.log(`testeranto/reports/${projectName}`);
+        if (!fs_1.default.existsSync(`testeranto/reports/${projectName}`)) {
+            fs_1.default.mkdirSync(`testeranto/reports/${projectName}`);
+        }
+        fs_1.default.writeFileSync(`testeranto/reports/${projectName}/config.json`, JSON.stringify(config, null, 2));
+    });
+    // const getSecondaryEndpointsPoints = (runtime?: IRunTime): string[] => {
+    //   const meta = (ts: ITestTypes[], st: Set<string>): Set<string> => {
+    //     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, } = (0, utils_1.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_1.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_1.default.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/common/src/utils/buildTemplates.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppHtml = void 0;
+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>
+`;
+const AppHtml = () => `
+  ${getBaseHtml("Testeranto")}
+  
+  <link rel="stylesheet" href="App.css" />
+  <script src="App.js"></script>
+</head>
+<body>
+  <div id="root"></div>
+</body>
+</html>
+`;
+exports.AppHtml = AppHtml;

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

@@ -0,0 +1,157 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGolingvuMetafile = generateGolingvuMetafile;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const helpers_1 = require("./golingvuMetafile/helpers");
+const fileDiscovery_1 = require("./golingvuMetafile/fileDiscovery");
+const importParser_1 = require("./golingvuMetafile/importParser");
+let generationQueue = null;
+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_1.default.isAbsolute(entryPoint)) {
+                resolvedPath = path_1.default.join(process.cwd(), entryPoint);
+            }
+            if (!fs_1.default.existsSync(resolvedPath)) {
+                console.warn(`Entry point does not exist: ${resolvedPath}`);
+                continue;
+            }
+            if (!fs_1.default.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_1.default.isAbsolute(entryPoint)) {
+                resolvedPath = path_1.default.join(process.cwd(), entryPoint);
+            }
+            if (!fs_1.default.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 = (0, fileDiscovery_1.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_1.default.statSync(dep).size;
+                const imports = (0, importParser_1.parseGoImports)(dep);
+                // Check if this is a test file
+                const isTestFile = path_1.default.basename(dep).includes("_test.go") ||
+                    path_1.default.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 = (0, helpers_1.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_1.default.relative(projectRoot, path_1.default.dirname(firstEntryPoint));
+            // Get the base name without extension
+            const baseName = path_1.default.basename(firstEntryPoint, ".go");
+            // Construct the output key
+            // Ensure relativePath is not empty
+            const outputPath = relativePath === "" ? baseName : path_1.default.join(relativePath, baseName);
+            outputKey = `golang/${path_1.default.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/common/src/utils/golingvuMetafile/fileDiscovery.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectGoDependencies = collectGoDependencies;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("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"));
+// }
+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_1.default.dirname(filePath);
+    // Always include other .go files in the same directory
+    try {
+        const files = fs_1.default.readdirSync(dir);
+        for (const file of files) {
+            if (file.endsWith(".go") && file !== path_1.default.basename(filePath)) {
+                const fullPath = path_1.default.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_1.default.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_1.default.join(process.cwd(), "vendor", importPath),
+            path_1.default.join(currentDir, importPath),
+            path_1.default.join(process.cwd(), importPath),
+            path_1.default.join(process.cwd(), "src", importPath),
+        ];
+        for (const potentialPath of potentialPaths) {
+            // Check if it's a directory with .go files
+            if (fs_1.default.existsSync(potentialPath) &&
+                fs_1.default.statSync(potentialPath).isDirectory()) {
+                try {
+                    const files = fs_1.default.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_1.default.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_1.default.existsSync(goFilePath) && fs_1.default.statSync(goFilePath).isFile()) {
+                // Ensure it's a .go file
+                if (goFilePath.endsWith(".go")) {
+                    dependencies.push(...collectGoDependencies(goFilePath, visited));
+                    break;
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGoList = runGoList;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+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_1.default.existsSync(pattern)) {
+            const stat = fs_1.default.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 = (0, child_process_1.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_1.default.dirname(pattern);
+            }
+        }
+        // Try to run go list with the processed pattern
+        const output = (0, child_process_1.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;
+}