0xray 4.0.13 → 4.0.14

package/dist/utils/import-resolver.js

@@ -0,0 +1,189 @@
+/**
+ * Import Resolver Utility
+ * Dynamically resolves module imports across different environments
+ *
+ * This solves the systemic path resolution issue where hardcoded paths
+ * break between development, built, and deployed environments.
+ */
+import { fileURLToPath } from "url";
+import { dirname, join, resolve } from "path";
+import { frameworkLogger } from "../core/framework-logger.js";
+export class ImportResolver {
+    static instance;
+    currentDir;
+    projectRoot;
+    isDevelopment;
+    isBuilt;
+    isInstalled;
+    isTesting;
+    constructor() {
+        this.currentDir = this.getCurrentDirectory();
+        this.projectRoot = this.findProjectRoot();
+        this.isDevelopment = this.detectDevelopment();
+        this.isBuilt = this.detectBuilt();
+        this.isInstalled = this.detectInstalled();
+        this.isTesting = this.detectTesting();
+    }
+    static getInstance() {
+        if (!ImportResolver.instance) {
+            ImportResolver.instance = new ImportResolver();
+        }
+        return ImportResolver.instance;
+    }
+    getCurrentDirectory() {
+        try {
+            const currentFile = fileURLToPath(import.meta.url);
+            return dirname(currentFile);
+        }
+        catch (error) {
+            return process.cwd();
+        }
+    }
+    findProjectRoot() {
+        let dir = this.currentDir;
+        const maxDepth = 10;
+        for (let i = 0; i < maxDepth; i++) {
+            if (this.fileExists(join(dir, "package.json"))) {
+                return dir;
+            }
+            const parent = dirname(dir);
+            if (parent === dir)
+                break; // Reached root
+            dir = parent;
+        }
+        return process.cwd(); // Fallback
+    }
+    fileExists(filePath) {
+        try {
+            require.resolve(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    detectDevelopment() {
+        return (this.currentDir.includes("/src/") ||
+            this.currentDir.includes("\\src\\") ||
+            process.env.NODE_ENV === "development" ||
+            this.fileExists(join(this.projectRoot, "tsconfig.json")));
+    }
+    detectBuilt() {
+        return (this.currentDir.includes("/dist/") ||
+            this.currentDir.includes("\\dist\\") ||
+            this.currentDir.includes("node_modules") ||
+            !this.fileExists(join(this.projectRoot, "src")));
+    }
+    detectInstalled() {
+        return (this.currentDir.includes("/node_modules/") ||
+            this.currentDir.includes("\\node_modules\\") ||
+            (this.currentDir.includes("xray") &&
+                !this.currentDir.includes(this.projectRoot)));
+    }
+    detectTesting() {
+        return (process.env.NODE_ENV === "test" ||
+            process.env.VITEST === "true" ||
+            this.currentDir.includes("/__tests__/") ||
+            this.currentDir.includes("\\__tests__\\"));
+    }
+    /**
+     * Resolve module import path for any module
+     */
+    resolveModulePath(moduleName, subPath = "") {
+        const fullModuleName = subPath ? `${subPath}/${moduleName}` : moduleName;
+        if (this.isTesting) {
+            return join(this.currentDir, "..", `${fullModuleName}.js`);
+        }
+        else if (this.isDevelopment) {
+            return join(this.currentDir, "..", `${fullModuleName}.ts`);
+        }
+        else if (this.isBuilt || this.isInstalled) {
+            return join(this.currentDir, "..", `${fullModuleName}.js`);
+        }
+        else {
+            return join(this.currentDir, "..", `${fullModuleName}.js`);
+        }
+    }
+    /**
+     * Resolve agent import path (special case for agents)
+     */
+    resolveAgentPath(agentName) {
+        if (this.isDevelopment) {
+            return `./agents/${agentName}.js`;
+        }
+        else if (this.isBuilt || this.isInstalled) {
+            return `../agents/${agentName}.js`;
+        }
+        else {
+            return `../agents/${agentName}.js`;
+        }
+    }
+    /**
+     * Dynamic import with comprehensive environment resolution
+     */
+    async importModule(moduleName, subPath = "") {
+        const primaryPath = this.resolveModulePath(moduleName, subPath);
+        // Try primary path first
+        try {
+            return await import(primaryPath);
+        }
+        catch (error) {
+            frameworkLogger.log("ImportResolver", "resolve-import", "warning", { message: `⚠️ Failed to import ${moduleName} from primary path: ${primaryPath}` });
+            // Try alternative paths based on environment
+            const altPaths = this.generateAlternativePaths(moduleName, subPath);
+            for (const altPath of altPaths) {
+                try {
+                    return await import(altPath);
+                }
+                catch (altError) {
+                    continue;
+                }
+            }
+            // Final fallback - try to resolve from project root
+            try {
+                const rootPath = join(this.projectRoot, "dist", subPath, `${moduleName}.js`);
+                return await import(rootPath);
+            }
+            catch (rootError) {
+                throw new Error(`Cannot import module ${moduleName} from any path. Primary: ${primaryPath}, Alternatives tried: ${altPaths.length}`);
+            }
+        }
+    }
+    /**
+     * Generate alternative import paths for fallback
+     */
+    generateAlternativePaths(moduleName, subPath) {
+        const fullModuleName = subPath ? `${subPath}/${moduleName}` : moduleName;
+        const paths = [];
+        if (this.isDevelopment) {
+            paths.push(join(this.currentDir, "..", `${fullModuleName}.js`), join(this.currentDir, "..", `${fullModuleName}.ts`), `./${fullModuleName}.ts`);
+        }
+        else {
+            paths.push(join(this.currentDir, "..", `${fullModuleName}.ts`), join(this.currentDir, "..", `${fullModuleName}.js`), `./${fullModuleName}.js`);
+        }
+        // Add absolute paths as last resort
+        try {
+            const absPath = resolve(this.projectRoot, "dist", subPath, `${moduleName}.js`);
+            paths.push(absPath);
+        }
+        catch {
+            // Ignore absolute path generation errors
+        }
+        return [...new Set(paths)]; // Remove duplicates
+    }
+    /**
+     * Get comprehensive environment information
+     */
+    getEnvironmentInfo() {
+        return {
+            currentDir: this.currentDir,
+            projectRoot: this.projectRoot,
+            isDevelopment: this.isDevelopment,
+            isBuilt: this.isBuilt,
+            isInstalled: this.isInstalled,
+            isTesting: this.isTesting,
+            nodeEnv: process.env.NODE_ENV,
+        };
+    }
+}
+export const importResolver = ImportResolver.getInstance();

package/dist/utils/language-detector.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Language Detector Utility
+ *
+ * Detects project language and test framework from project files.
+ * Supports: TypeScript, JavaScript, Python, Go, Rust, Java, C++, Ruby, PHP
+ *
+ * @since 2026-02-25
+ */
+export interface ProjectLanguage {
+    language: string;
+    testFramework: string;
+    testCommand: string;
+    testFilePattern: string;
+    configFiles: string[];
+}
+export interface LanguageConfig {
+    language: string;
+    extensions: string[];
+    testFrameworks: {
+        name: string;
+        patterns: string[];
+        testCommands: string[];
+        configFiles: string[];
+    }[];
+}
+export declare const LANGUAGE_CONFIGS: LanguageConfig[];
+/**
+ * Detect the project language from directory contents
+ */
+export declare function detectProjectLanguage(cwd: string): ProjectLanguage | null;
+/**
+ * Get the test file path for a given source file
+ */
+export declare function getTestFilePath(sourceFilePath: string, projectLanguage: ProjectLanguage): string;
+/**
+ * Build the test command for running specific tests
+ */
+export declare function buildTestCommand(projectLanguage: ProjectLanguage, testFilePath?: string): string;
+export declare const languageDetector: {
+    detect: typeof detectProjectLanguage;
+    getTestFilePath: typeof getTestFilePath;
+    buildTestCommand: typeof buildTestCommand;
+};

package/dist/utils/language-detector.js

@@ -0,0 +1,382 @@
+/**
+ * Language Detector Utility
+ *
+ * Detects project language and test framework from project files.
+ * Supports: TypeScript, JavaScript, Python, Go, Rust, Java, C++, Ruby, PHP
+ *
+ * @since 2026-02-25
+ */
+import * as fs from "fs";
+import * as path from "path";
+// Supported languages and their configurations
+export const LANGUAGE_CONFIGS = [
+    {
+        language: "TypeScript",
+        extensions: [".ts", ".tsx"],
+        testFrameworks: [
+            {
+                name: "Vitest",
+                patterns: ["*.test.ts", "*.spec.ts", "**/*.test.ts", "**/*.spec.ts"],
+                testCommands: ["vitest run", "npx vitest run", "npm test"],
+                configFiles: [
+                    "vitest.config.ts",
+                    "vitest.config.js",
+                    "vitest.config.mts",
+                ],
+            },
+            {
+                name: "Jest",
+                patterns: ["*.test.ts", "*.spec.ts", "*.test.js", "*.spec.js"],
+                testCommands: ["jest", "npx jest", "npm test"],
+                configFiles: ["jest.config.js", "jest.config.ts", "jest.config.json"],
+            },
+            {
+                name: "Mocha",
+                patterns: ["*.test.ts", "*.spec.ts", "*.test.js"],
+                testCommands: ["mocha", "npx mocha"],
+                configFiles: [".mocharc.json", ".mocharc.js", "mocha.opts"],
+            },
+        ],
+    },
+    {
+        language: "JavaScript",
+        extensions: [".js", ".jsx", ".mjs"],
+        testFrameworks: [
+            {
+                name: "Jest",
+                patterns: ["*.test.js", "*.spec.js", "*.test.jsx", "*.spec.jsx"],
+                testCommands: ["jest", "npx jest", "npm test"],
+                configFiles: ["jest.config.js", "jest.config.json"],
+            },
+            {
+                name: "Mocha",
+                patterns: ["*.test.js", "*.spec.js"],
+                testCommands: ["mocha", "npx mocha"],
+                configFiles: [".mocharc.json", ".mocharc.js"],
+            },
+            {
+                name: "Vitest",
+                patterns: ["*.test.js", "*.spec.js"],
+                testCommands: ["vitest run", "npx vitest run"],
+                configFiles: ["vitest.config.js"],
+            },
+        ],
+    },
+    {
+        language: "Python",
+        extensions: [".py"],
+        testFrameworks: [
+            {
+                name: "pytest",
+                patterns: ["test_*.py", "*_test.py", "**/test_*.py"],
+                testCommands: ["pytest", "python -m pytest", "python3 -m pytest"],
+                configFiles: [
+                    "pytest.ini",
+                    "pyproject.toml",
+                    "setup.cfg",
+                    "conftest.py",
+                ],
+            },
+            {
+                name: "unittest",
+                patterns: ["test_*.py", "*_test.py"],
+                testCommands: ["python -m unittest", "python3 -m unittest"],
+                configFiles: [],
+            },
+            {
+                name: "nose",
+                patterns: ["test_*.py", "*_test.py"],
+                testCommands: ["nosetests", "python -m nose"],
+                configFiles: ["nose.cfg"],
+            },
+        ],
+    },
+    {
+        language: "Go",
+        extensions: [".go"],
+        testFrameworks: [
+            {
+                name: "testing",
+                patterns: ["*_test.go"],
+                testCommands: ["go test", "go test -v", "go test ./..."],
+                configFiles: ["go.mod"],
+            },
+        ],
+    },
+    {
+        language: "Rust",
+        extensions: [".rs"],
+        testFrameworks: [
+            {
+                name: "cargo test",
+                patterns: ["**/tests/**/*.rs", "**/*_test.rs", "**/src/**/*_test.rs"],
+                testCommands: ["cargo test", "cargo test --lib", "cargo test --all"],
+                configFiles: ["Cargo.toml"],
+            },
+        ],
+    },
+    {
+        language: "Java",
+        extensions: [".java"],
+        testFrameworks: [
+            {
+                name: "JUnit",
+                patterns: ["**/test/**/*.java", "**/*Test.java", "**/*Tests.java"],
+                testCommands: ["mvn test", "gradle test", "./gradlew test"],
+                configFiles: ["pom.xml", "build.gradle", "build.gradle.kts"],
+            },
+            {
+                name: "TestNG",
+                patterns: ["**/test/**/*.java", "**/*TestNG.java"],
+                testCommands: ["mvn test", "gradle test"],
+                configFiles: ["testng.xml", "pom.xml"],
+            },
+        ],
+    },
+    {
+        language: "C#",
+        extensions: [".cs"],
+        testFrameworks: [
+            {
+                name: "xUnit",
+                patterns: ["**/*Test.cs", "**/*Tests.cs"],
+                testCommands: ["dotnet test", "dotnet test --verbosity normal"],
+                configFiles: ["*.csproj", "*.sln"],
+            },
+            {
+                name: "NUnit",
+                patterns: ["**/*Test.cs", "**/*Tests.cs"],
+                testCommands: ["dotnet test", "nunit3-console"],
+                configFiles: ["*.csproj", "packages.config"],
+            },
+            {
+                name: "MSTest",
+                patterns: ["**/*Test.cs"],
+                testCommands: ["dotnet test"],
+                configFiles: ["*.csproj"],
+            },
+        ],
+    },
+    {
+        language: "Ruby",
+        extensions: [".rb"],
+        testFrameworks: [
+            {
+                name: "RSpec",
+                patterns: ["**/*_spec.rb", "spec/**/*.rb"],
+                testCommands: ["rspec", "bundle exec rspec"],
+                configFiles: [".rspec", "Gemfile", "rspec.yml"],
+            },
+            {
+                name: "Minitest",
+                patterns: ["test/**/*.rb", "**/*_test.rb"],
+                testCommands: ["rake test", "ruby -Itest"],
+                configFiles: ["Rakefile"],
+            },
+        ],
+    },
+    {
+        language: "PHP",
+        extensions: [".php"],
+        testFrameworks: [
+            {
+                name: "PHPUnit",
+                patterns: ["**/test/**/*.php", "**/*Test.php", "**/*Tests.php"],
+                testCommands: ["phpunit", "./vendor/bin/phpunit", "composer test"],
+                configFiles: ["phpunit.xml", "phpunit.xml.dist", "composer.json"],
+            },
+            {
+                name: "Codeception",
+                patterns: ["**/tests/**/*.php"],
+                testCommands: ["codecept run", "./vendor/bin/codecept run"],
+                configFiles: ["codeception.yml"],
+            },
+        ],
+    },
+    {
+        language: "Shell",
+        extensions: [".sh", ".bash", ".zsh"],
+        testFrameworks: [
+            {
+                name: "bats",
+                patterns: ["**/*.bats", "test/**/*.sh"],
+                testCommands: ["bats", "bats test/", "npx bats"],
+                configFiles: [".batsrc"],
+            },
+        ],
+    },
+];
+/**
+ * Detect the project language from directory contents
+ */
+export function detectProjectLanguage(cwd) {
+    // Check for package.json (TypeScript/JavaScript)
+    if (fs.existsSync(path.join(cwd, "package.json"))) {
+        const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf-8"));
+        // Check for TypeScript
+        if (fs.existsSync(path.join(cwd, "tsconfig.json")) ||
+            pkg.devDependencies?.typescript ||
+            pkg.dependencies?.typescript) {
+            return detectTestFramework(cwd, "TypeScript");
+        }
+        // Check for JavaScript
+        return detectTestFramework(cwd, "JavaScript");
+    }
+    // Check for go.mod (Go)
+    if (fs.existsSync(path.join(cwd, "go.mod"))) {
+        return detectTestFramework(cwd, "Go");
+    }
+    // Check for Cargo.toml (Rust)
+    if (fs.existsSync(path.join(cwd, "Cargo.toml"))) {
+        return detectTestFramework(cwd, "Rust");
+    }
+    // Check for pom.xml or build.gradle (Java)
+    if (fs.existsSync(path.join(cwd, "pom.xml")) ||
+        fs.existsSync(path.join(cwd, "build.gradle")) ||
+        fs.existsSync(path.join(cwd, "build.gradle.kts"))) {
+        return detectTestFramework(cwd, "Java");
+    }
+    // Check for *.csproj or *.sln (C#)
+    const csprojFiles = fs.readdirSync(cwd).filter((f) => f.endsWith(".csproj"));
+    if (csprojFiles.length > 0 || fs.existsSync(path.join(cwd, "*.sln"))) {
+        return detectTestFramework(cwd, "C#");
+    }
+    // Check for Gemfile (Ruby)
+    if (fs.existsSync(path.join(cwd, "Gemfile"))) {
+        return detectTestFramework(cwd, "Ruby");
+    }
+    // Check for composer.json (PHP)
+    if (fs.existsSync(path.join(cwd, "composer.json"))) {
+        return detectTestFramework(cwd, "PHP");
+    }
+    // Check for pytest.ini, setup.py, or pyproject.toml (Python)
+    if (fs.existsSync(path.join(cwd, "pytest.ini")) ||
+        fs.existsSync(path.join(cwd, "setup.py")) ||
+        fs.existsSync(path.join(cwd, "pyproject.toml"))) {
+        return detectTestFramework(cwd, "Python");
+    }
+    return null;
+}
+/**
+ * Detect the test framework for a given language
+ */
+function detectTestFramework(cwd, language) {
+    const config = LANGUAGE_CONFIGS.find((c) => c.language === language);
+    if (!config) {
+        return {
+            language,
+            testFramework: "unknown",
+            testCommand: "npm test",
+            testFilePattern: "*.test.*",
+            configFiles: [],
+        };
+    }
+    // Check each test framework's config files
+    for (const framework of config.testFrameworks) {
+        for (const configFile of framework.configFiles) {
+            if (fs.existsSync(path.join(cwd, configFile))) {
+                return {
+                    language,
+                    testFramework: framework.name,
+                    testCommand: framework.testCommands[0] || "npm test",
+                    testFilePattern: framework.patterns[0] || "*.test.*",
+                    configFiles: framework.configFiles,
+                };
+            }
+        }
+    }
+    // Default to first framework if no config found
+    const defaultFramework = config.testFrameworks[0];
+    if (!defaultFramework) {
+        return {
+            language,
+            testFramework: "unknown",
+            testCommand: "npm test",
+            testFilePattern: "*.test.*",
+            configFiles: [],
+        };
+    }
+    return {
+        language,
+        testFramework: defaultFramework.name,
+        testCommand: defaultFramework.testCommands[0] || "npm test",
+        testFilePattern: defaultFramework.patterns[0] || "*.test.*",
+        configFiles: [],
+    };
+}
+/**
+ * Get the test file path for a given source file
+ */
+export function getTestFilePath(sourceFilePath, projectLanguage) {
+    const dir = path.dirname(sourceFilePath);
+    const basename = path.basename(sourceFilePath);
+    const ext = path.extname(sourceFilePath);
+    const nameWithoutExt = basename.replace(ext, "");
+    switch (projectLanguage.language) {
+        case "TypeScript":
+        case "JavaScript":
+            if (dir.includes("/src/")) {
+                return path.join(dir.replace("/src/", "/src/__tests__/"), `${nameWithoutExt}.test${ext}`);
+            }
+            if (dir.startsWith("src/") || dir.startsWith("src\\")) {
+                return path.join(dir.replace(/^src[\\/]/, "src/__tests__/"), `${nameWithoutExt}.test${ext}`);
+            }
+            return path.join(dir, "__tests__", `${nameWithoutExt}.test${ext}`);
+        case "Python":
+            // src/utils/helper.py -> tests/test_helper.py
+            return path.join(dir.replace("/src/", "/tests/"), `test_${nameWithoutExt}.py`);
+        case "Go":
+            // internal/utils/helper.go -> internal/utils/helper_test.go
+            return path.join(dir, `${nameWithoutExt}_test.go`);
+        case "Rust":
+            // src/utils/helper.rs -> src/utils/helper_test.rs
+            return path.join(dir, `${nameWithoutExt}_test.rs`);
+        case "Java":
+            // src/com/pkg/Util.java -> test/com/pkg/UtilTest.java
+            return path.join(dir.replace("/src/", "/test/"), `${nameWithoutExt}Test.java`);
+        case "C#":
+            // src/Util.cs -> tests/UtilTest.cs
+            return path.join(dir.replace("/src/", "/tests/"), `${nameWithoutExt}Test.cs`);
+        case "Ruby":
+            // lib/helper.rb -> spec/lib/helper_spec.rb
+            return path.join(dir.replace("/lib/", "/spec/"), `${nameWithoutExt}_spec.rb`);
+        case "PHP":
+            // src/Util.php -> tests/UtilTest.php
+            return path.join(dir.replace("/src/", "/tests/"), `${nameWithoutExt}Test.php`);
+        default:
+            return path.join(dir, `${nameWithoutExt}.test${ext}`);
+    }
+}
+/**
+ * Build the test command for running specific tests
+ */
+export function buildTestCommand(projectLanguage, testFilePath) {
+    const { testCommand, language } = projectLanguage;
+    if (!testFilePath) {
+        return testCommand;
+    }
+    // Language-specific test file targeting
+    switch (language) {
+        case "TypeScript":
+        case "JavaScript":
+            return `npx vitest run "${testFilePath}"`;
+        case "Python":
+            return `pytest "${testFilePath}"`;
+        case "Go":
+            return `go test -v ${testFilePath}`;
+        case "Rust":
+            return `cargo test --lib ${path.basename(testFilePath, ".rs")}`;
+        case "Java":
+            return `mvn test -Dtest=${path.basename(testFilePath, ".java")}`;
+        case "C#":
+            return `dotnet test --filter "FullyQualifiedName~${path.basename(testFilePath, ".cs")}"`;
+        default:
+            return `${testCommand} "${testFilePath}"`;
+    }
+}
+// Export singleton for easy use
+export const languageDetector = {
+    detect: detectProjectLanguage,
+    getTestFilePath,
+    buildTestCommand,
+};

package/dist/utils/path-resolver.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Path Resolution Utility for 0xRay Framework
+ * Resolves import paths that work across development, build, and installed environments
+ */
+export declare class PathResolver {
+    private static instance;
+    private currentDir;
+    private isDevelopment;
+    private isBuilt;
+    private isInstalled;
+    private constructor();
+    static getInstance(): PathResolver;
+    /**
+     * Get current working directory
+     */
+    private getCurrentDirectory;
+    /**
+     * Detect if we're running in development environment (src/ directory)
+     */
+    private detectDevelopment;
+    /**
+     * Detect if we're running in built environment (dist/ directory)
+     */
+    private detectBuilt;
+    /**
+     * Detect if we're running in installed package environment
+     */
+    private detectInstalled;
+    /**
+     * Resolve agent import path for current environment
+     */
+    resolveAgentPath(agentName: string): string;
+    /**
+     * Resolve any module path for current environment
+     */
+    resolveModulePath(modulePath: string): string;
+    /**
+     * Get environment information for debugging
+     */
+    getEnvironmentInfo(): {
+        currentDir: string;
+        isDevelopment: boolean;
+        isBuilt: boolean;
+        isInstalled: boolean;
+        nodeEnv: string | undefined;
+    };
+}
+export declare const pathResolver: PathResolver;