0xray 4.0.12 → 4.0.13

package/dist/utils/import-resolver.js

@@ -1,189 +0,0 @@
-/**
- * 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

@@ -1,43 +0,0 @@
-/**
- * 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

@@ -1,382 +0,0 @@
-/**
- * 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

@@ -1,48 +0,0 @@
-/**
- * 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;