0xray 4.0.11 → 4.0.13

package/dist/processors/implementations/test-auto-creation-processor.js

@@ -1,483 +0,0 @@
-/**
- * Test Auto-Creation Processor
- *
- * Automatically generates test files when new source files are created.
- * Supports multiple languages: TypeScript, JavaScript, Python, Go, Rust, Java, C#
- * Uses direct skill calls (no MCP overhead) for instant test generation.
- *
- * @since 2026-02-15
- */
-import * as fs from "fs";
-import * as path from "path";
-import { frameworkLogger } from "../../core/framework-logger.js";
-import { getTestFilePath, LANGUAGE_CONFIGS, } from "../../utils/language-detector.js";
-import { testAutoGenerationMonitor } from "../../monitoring/test-auto-generation-monitor.js";
-/**
- * Find the most recently modified TypeScript file in a directory
- * This is used as a fallback when filePath is not provided in the hook context
- * OPTIMIZED: Added caching to reduce expensive directory scans
- */
-// Cache for recent file scans (30 second TTL)
-const fileScanCache = new Map();
-const SCAN_CACHE_TTL_MS = 30000; // 30 seconds
-function findRecentlyModifiedTsFile(dir, maxAgeSeconds = 60) {
-    // Check cache first
-    const cacheKey = `${dir}:${maxAgeSeconds}`;
-    const cached = fileScanCache.get(cacheKey);
-    if (cached && Date.now() < cached.expires) {
-        return cached.file;
-    }
-    try {
-        // Recursive walk to find all .ts files
-        const files = [];
-        function walkSync(dirPath) {
-            try {
-                const items = fs.readdirSync(dirPath);
-                for (const item of items) {
-                    const fullPath = path.join(dirPath, item);
-                    try {
-                        const stat = fs.statSync(fullPath);
-                        if (stat.isDirectory()) {
-                            // Skip node_modules, dist, etc.
-                            if (!item.startsWith(".") &&
-                                item !== "node_modules" &&
-                                item !== "dist") {
-                                walkSync(fullPath);
-                            }
-                        }
-                        else if (item.endsWith(".ts") &&
-                            !item.endsWith(".test.ts") &&
-                            !item.endsWith(".spec.ts")) {
-                            files.push(fullPath);
-                        }
-                    }
-                    catch {
-                        // Skip files we can't stat
-                    }
-                }
-            }
-            catch {
-                // Skip directories we can't read
-            }
-        }
-        walkSync(dir);
-        // Find most recently modified
-        let mostRecent = null;
-        for (const filePath of files) {
-            try {
-                const stats = fs.statSync(filePath);
-                // Get relative path
-                const relPath = path.relative(dir, filePath);
-                if (!mostRecent || stats.mtimeMs > mostRecent.mtime) {
-                    mostRecent = { path: relPath, mtime: stats.mtimeMs };
-                }
-            }
-            catch {
-                // Skip files we can't stat
-            }
-        }
-        const result = mostRecent?.path || null;
-        // Cache the result
-        fileScanCache.set(cacheKey, {
-            file: result,
-            expires: Date.now() + SCAN_CACHE_TTL_MS,
-        });
-        return result;
-    }
-    catch {
-        return null;
-    }
-}
-export const testAutoCreationProcessor = {
-    name: "testAutoCreation",
-    priority: 30,
-    enabled: true,
-    async execute(context) {
-        const startTime = Date.now();
-        try {
-            // Handle both direct context and context.data (from ProcessorManager)
-            // ProcessorManager passes: { operation, data: { directory, filePath, ... }, preResults }
-            const innerContext = context.data || context;
-            const { tool, args, directory, filePath: contextFilePath, operation, } = innerContext;
-            // Also check the outer context for backward compatibility
-            const outerFilePath = context.filePath || contextFilePath;
-            const outerDirectory = context.directory || directory;
-            // SIMPLIFIED: Clear filePath resolution with explicit priority
-            // Priority 1: args.filePath (explicit argument)
-            // Priority 2: context.filePath (from ProcessorManager)
-            // Priority 3: Scan for recent files (fallback)
-            let filePath;
-            let resolutionSource;
-            // Priority 1: Explicit args.filePath
-            if (args?.filePath) {
-                filePath = args.filePath;
-                resolutionSource = "args.filePath";
-            }
-            // Priority 2: Context filePath from ProcessorManager
-            else if (outerFilePath) {
-                filePath = outerFilePath;
-                resolutionSource = "context.filePath";
-            }
-            // Priority 3: Fallback - scan for recent files
-            else {
-                const srcDir = path.join(process.cwd(), "src");
-                const rootDir = process.cwd();
-                // Try src first, then root
-                let recentFile = findRecentlyModifiedTsFile(srcDir, 60);
-                if (!recentFile) {
-                    recentFile = findRecentlyModifiedTsFile(rootDir, 60);
-                }
-                if (recentFile) {
-                    const isFromSrc = recentFile.startsWith(srcDir);
-                    filePath = isFromSrc
-                        ? path.relative(process.cwd(), recentFile)
-                        : recentFile;
-                    resolutionSource = "file-scan-fallback";
-                }
-                else {
-                    resolutionSource = "none-found";
-                }
-            }
-            await frameworkLogger.log("test-auto-creation", "filepath-resolution", "info", {
-                message: `Resolved filePath: ${filePath || "UNDEFINED"} (source: ${resolutionSource})`,
-            });
-            if (!filePath) {
-                await frameworkLogger.log("test-auto-creation", "skipped-no-filepath", "info", {
-                    message: `Skipped: no filePath found in context`,
-                    contextKeys: Object.keys(context),
-                });
-                return {
-                    success: true,
-                    processorName: "testAutoCreation",
-                    duration: Date.now() - startTime,
-                };
-            }
-            // Check if this looks like a write operation based on context
-            const isWriteOperation = tool === "write" || tool === "edit" || operation === "tool_execution";
-            if (!isWriteOperation) {
-                await frameworkLogger.log("test-auto-creation", "skipped-not-write", "info", { message: `Skipped: not a write operation`, tool, operation });
-                return {
-                    success: true,
-                    processorName: "testAutoCreation",
-                    duration: Date.now() - startTime,
-                };
-            }
-            // Support multiple file types: .ts, .js, .py, .go, .rs, .java, .cs
-            const supportedExtensions = [
-                ".ts",
-                ".js",
-                ".tsx",
-                ".jsx",
-                ".py",
-                ".go",
-                ".rs",
-                ".java",
-                ".cs",
-            ];
-            const ext = path.extname(filePath);
-            const isTestFile = filePath.endsWith(".test.ts") || filePath.endsWith(".spec.ts");
-            if (!supportedExtensions.includes(ext) || isTestFile) {
-                return {
-                    success: true,
-                    processorName: "testAutoCreation",
-                    duration: Date.now() - startTime,
-                };
-            }
-            // Get language config for this extension
-            const langConfig = LANGUAGE_CONFIGS.find((c) => c.extensions.includes(ext));
-            // Resolve directory with fallback
-            // Extract directory from filePath if not provided (handles absolute paths from OpenCode)
-            const resolvedDirectory = directory || (filePath.includes("/") ? path.dirname(filePath) : process.cwd());
-            const testFilePath = getTestFilePath(filePath, langConfig?.language || "TypeScript");
-            // getTestFilePath returns full path, no need to join
-            const fullTestPath = testFilePath;
-            if (fs.existsSync(fullTestPath)) {
-                await frameworkLogger.log("test-auto-creation", "test-exists", "info", {
-                    message: `Test file already exists: ${testFilePath}`,
-                });
-                // Record skipped to monitor
-                testAutoGenerationMonitor.recordEvent({
-                    type: "skipped",
-                    filePath,
-                    testFile: testFilePath,
-                    timestamp: Date.now(),
-                    reason: "Test file already exists",
-                });
-                return {
-                    success: true,
-                    processorName: "testAutoCreation",
-                    duration: Date.now() - startTime,
-                };
-            }
-            // Read source file to analyze exports
-            const resolvedSourceDir = directory || process.cwd();
-            const fullSourcePath = path.resolve(resolvedSourceDir, filePath);
-            const checkDir = path.resolve(resolvedSourceDir);
-            if (!fullSourcePath.startsWith(checkDir + path.sep) && fullSourcePath !== checkDir) {
-                await frameworkLogger.log("test-auto-creation", "skipped-path-traversal", "warning", {
-                    message: `Skipped: resolved path "${fullSourcePath}" escapes expected directory "${checkDir}"`,
-                    directory: resolvedSourceDir,
-                    filePath,
-                });
-                return {
-                    success: false,
-                    processorName: "testAutoCreation",
-                    duration: Date.now() - startTime,
-                    error: `Path traversal detected: resolved path escapes expected directory`,
-                };
-            }
-            if (!fs.existsSync(fullSourcePath)) {
-                await frameworkLogger.log("test-auto-creation", "skipped-source-not-found", "info", {
-                    message: `Skipped: source file not found`,
-                    fullSourcePath,
-                    directory,
-                    filePath,
-                });
-                return {
-                    success: false,
-                    processorName: "testAutoCreation",
-                    duration: Date.now() - startTime,
-                };
-            }
-            const sourceContent = fs.readFileSync(fullSourcePath, "utf8");
-            // Extract exports to test
-            const exports = extractExports(sourceContent);
-            if (exports.length === 0) {
-                // Record skipped to monitor
-                testAutoGenerationMonitor.recordEvent({
-                    type: "skipped",
-                    filePath,
-                    testFile: null,
-                    timestamp: Date.now(),
-                    reason: "No exports found",
-                });
-                return {
-                    success: true,
-                    processorName: "testAutoCreation",
-                    duration: Date.now() - startTime,
-                };
-            }
-            await frameworkLogger.log("test-auto-creation", "generating-tests", "info", {
-                message: `Auto-generating tests for ${filePath}`,
-                exports: exports.map((e) => e.name),
-                testFile: testFilePath,
-            });
-            // Use direct test generation (no MCP - instant!)
-            await createBasicTestStub(fullTestPath, filePath, exports);
-            await frameworkLogger.log("test-auto-creation", "test-stub-created", "success", {
-                message: `Test stub created for ${filePath}`,
-                testFile: testFilePath,
-                exportsCount: exports.length,
-            });
-            return {
-                success: true,
-                processorName: "testAutoCreation",
-                duration: Date.now() - startTime,
-                data: {
-                    testFile: testFilePath,
-                    exports: exports.map((e) => e.name),
-                },
-            };
-        }
-        catch (error) {
-            await frameworkLogger.log("test-auto-creation", "error", "error", {
-                message: `Test auto-creation failed: ${error instanceof Error ? error.message : String(error)}`,
-            });
-            // Record failure to monitor
-            testAutoGenerationMonitor.recordEvent({
-                type: "failed",
-                filePath: "unknown",
-                testFile: null,
-                timestamp: Date.now(),
-                reason: error instanceof Error ? error.message : String(error),
-            });
-            return {
-                success: false,
-                processorName: "testAutoCreation",
-                duration: Date.now() - startTime,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    },
-};
-/**
- * Extract exports from source file content with function signatures
- */
-function extractExports(content) {
-    const exports = [];
-    // Match exported functions with their full signatures
-    const functionRegex = /export\s+(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)\s*(?::\s*(\w+))?/g;
-    let match;
-    while ((match = functionRegex.exec(content)) !== null) {
-        exports.push({
-            name: match[1] || "anonymous",
-            type: "function",
-            params: match[2]?.trim() || "",
-            returnType: match[3]?.trim() || "void",
-        });
-    }
-    // Match exported classes
-    const classMatches = content.match(/export\s+class\s+(\w+)/g);
-    if (classMatches) {
-        classMatches.forEach((m) => {
-            const name = m.replace(/export\s+class\s+/, "").trim();
-            exports.push({ name, type: "class", params: "", returnType: "" });
-        });
-    }
-    // Match exported const/let arrow functions
-    const arrowFunctionRegex = /export\s+const\s+(\w+)\s*=\s*(?:async\s+)?\(([^)]*)\)\s*(?::\s*(\w+))?\s*=>\s*/g;
-    while ((match = arrowFunctionRegex.exec(content)) !== null) {
-        exports.push({
-            name: match[1] || "",
-            type: "function",
-            params: match[2]?.trim() || "",
-            returnType: match[3]?.trim() || "void",
-        });
-    }
-    // Match exported const/let with type annotations
-    const constRegex = /export\s+const\s+(\w+)\s*:\s*([^;]+)/g;
-    while ((match = constRegex.exec(content)) !== null) {
-        exports.push({
-            name: match[1] || "",
-            type: "const",
-            params: "",
-            returnType: match[2]?.trim() || "",
-        });
-    }
-    // Match default exports
-    const defaultMatch = content.match(/export\s+default\s+(?:class|function)?\s*(\w+)/);
-    if (defaultMatch) {
-        exports.push({
-            name: defaultMatch[1] || "default",
-            type: "default",
-            params: "",
-            returnType: "",
-        });
-    }
-    return exports;
-}
-/**
- * Create a basic test stub as fallback
- */
-async function createBasicTestStub(testFilePath, sourceFile, exports) {
-    const testDir = path.dirname(testFilePath);
-    // Ensure test directory exists
-    if (!fs.existsSync(testDir)) {
-        fs.mkdirSync(testDir, { recursive: true });
-    }
-    const relativeSourcePath = path.relative(testDir, sourceFile.replace(/\.ts$/, ""));
-    const importPath = relativeSourcePath.startsWith(".")
-        ? relativeSourcePath
-        : `./${relativeSourcePath}`;
-    const testContent = generateTestStub(importPath, exports, sourceFile);
-    fs.writeFileSync(testFilePath, testContent, "utf8");
-}
-/**
- * Generate test stub content with better test cases based on function signatures
- */
-function generateTestStub(importPath, exports, sourceFile) {
-    const imports = exports.map((e) => e.name).join(", ");
-    const testCases = exports
-        .map((exp) => {
-        if (exp.type === "function") {
-            // Generate sample arguments based on params
-            const sampleArgs = generateSampleArgs(exp.params);
-            const returnCheck = generateReturnCheck(exp.returnType);
-            return `
-  describe("${exp.name}", () => {
-    it("should be defined", () => {
-      expect(typeof ${exp.name}).toBe("function");
-    });
-
-    it("should handle basic case", async () => {
-      const result = await ${exp.name}(${sampleArgs});
-      ${returnCheck}
-    });
-  });`;
-        }
-        else if (exp.type === "class") {
-            return `
-  describe("${exp.name}", () => {
-    it("should instantiate", () => {
-      const instance = new ${exp.name}();
-      expect(instance).toBeInstanceOf(${exp.name});
-    });
-  });`;
-        }
-        else {
-            return `
-  describe("${exp.name}", () => {
-    it("should be defined", () => {
-      expect(${exp.name}).toBeDefined();
-    });
-  });`;
-        }
-    })
-        .join("\n");
-    return `/**
- * Auto-generated test file for ${sourceFile}
- * Generated by 0xRay TestAutoCreationProcessor
- * @generated
- */
-
-import { describe, it, expect } from "vitest";
-import { ${imports} } from "${importPath}";
-
-describe("${path.basename(sourceFile, ".ts")}", () => {${testCases}
-});
-`;
-}
-/**
- * Generate sample arguments based on function parameters
- */
-function generateSampleArgs(params) {
-    if (!params.trim())
-        return "";
-    const paramList = params.split(",").map((p) => p.trim());
-    const sampleValues = paramList.map((param) => {
-        // Extract parameter name (before type annotation if present)
-        const parts = param.split(":");
-        const paramName = (parts[0] || "").trim();
-        const paramType = (parts[1] || "any").trim();
-        // Generate sample value based on type
-        if (paramType.includes("string"))
-            return `"test"`;
-        if (paramType.includes("number"))
-            return "1";
-        if (paramType.includes("boolean"))
-            return "true";
-        if (paramType.includes("array") || paramType.includes("[]"))
-            return "[]";
-        if (paramType.includes("object"))
-            return "{}";
-        if (paramType.includes("Promise"))
-            return "Promise.resolve(undefined)";
-        return "undefined";
-    });
-    return sampleValues.join(", ");
-}
-/**
- * Generate return value check based on return type
- */
-function generateReturnCheck(returnType) {
-    if (!returnType || returnType === "void" || returnType === "undefined") {
-        return "expect(result).toBeUndefined();";
-    }
-    if (returnType.includes("Promise")) {
-        return "expect(result).toBeDefined();";
-    }
-    if (returnType.includes("number")) {
-        return "expect(typeof result).toBe('number');";
-    }
-    if (returnType.includes("string")) {
-        return "expect(typeof result).toBe('string');";
-    }
-    if (returnType.includes("boolean")) {
-        return "expect(typeof result).toBe('boolean');";
-    }
-    if (returnType.includes("array") || returnType.includes("[]")) {
-        return "expect(Array.isArray(result)).toBe(true);";
-    }
-    return "expect(result).toBeDefined();";
-}
-export default testAutoCreationProcessor;

package/dist/processors/implementations/test-execution-processor.d.ts

@@ -1,11 +0,0 @@
-import { PreProcessor } from "../processor-interfaces.js";
-import type { ProcessorContext } from "../processor-types.js";
-export declare class TestExecutionProcessor extends PreProcessor {
-    readonly name = "testExecution";
-    readonly priority = 10;
-    protected run(context: ProcessorContext): Promise<Record<string, unknown>>;
-    private executeTypeScriptTests;
-    private executeGenericTests;
-    private runTestCommand;
-    private parseTestOutput;
-}

package/dist/processors/implementations/test-execution-processor.js

@@ -1,132 +0,0 @@
-import { PreProcessor } from "../processor-interfaces.js";
-import { frameworkLogger } from "../../core/framework-logger.js";
-import { detectProjectLanguage, getTestFilePath, buildTestCommand, } from "../../utils/language-detector.js";
-import { exec } from "child_process";
-import { promisify } from "util";
-const execAsync = promisify(exec);
-export class TestExecutionProcessor extends PreProcessor {
-    name = "testExecution";
-    priority = 10;
-    async run(context) {
-        frameworkLogger.log("test-execution-processor", "executing", "info", {
-            message: "Running auto-generated tests...",
-        });
-        try {
-            const cwd = context.directory || process.cwd();
-            const projectLanguage = detectProjectLanguage(cwd);
-            if (!projectLanguage) {
-                frameworkLogger.log("test-execution-processor", "language-detection-failed", "info", {
-                    message: "Could not detect project language, falling back to TypeScript",
-                });
-                return this.executeTypeScriptTests(context, cwd);
-            }
-            frameworkLogger.log("test-execution-processor", "language-detected", "info", {
-                language: projectLanguage.language,
-                testFramework: projectLanguage.testFramework,
-            });
-            if (projectLanguage.language === "TypeScript" || projectLanguage.language === "JavaScript") {
-                return this.executeTypeScriptTests(context, cwd);
-            }
-            return this.executeGenericTests(context, cwd, projectLanguage);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            frameworkLogger.log("test-execution-processor", "error", "error", {
-                message: `Test execution failed: ${errorMessage}`,
-            });
-            return { testsExecuted: 0, passed: 0, failed: 0, error: errorMessage, success: false };
-        }
-    }
-    async executeTypeScriptTests(context, cwd) {
-        let testPattern = "";
-        if (context.filePath) {
-            const testFilePath = context.filePath
-                .replace(/\/src\//, "/src/__tests__/")
-                .replace(/\.ts$/, ".test.ts");
-            const fs = await import("fs");
-            if (fs.existsSync(testFilePath)) {
-                testPattern = testFilePath;
-            }
-        }
-        const command = testPattern ? `npx vitest run "${testPattern}"` : `npx vitest run`;
-        frameworkLogger.log("test-execution-processor", "running-tests", "info", { command, cwd });
-        return this.runTestCommand(command, cwd);
-    }
-    async executeGenericTests(context, cwd, projectLanguage) {
-        let testFilePath;
-        if (context.filePath) {
-            testFilePath = getTestFilePath(context.filePath, projectLanguage);
-            const fs = await import("fs");
-            if (!fs.existsSync(testFilePath)) {
-                frameworkLogger.log("test-execution-processor", "test-file-not-found", "info", {
-                    sourceFile: context.filePath,
-                });
-                testFilePath = undefined;
-            }
-        }
-        const command = buildTestCommand(projectLanguage, testFilePath);
-        frameworkLogger.log("test-execution-processor", "running-generic-tests", "info", {
-            command,
-            cwd,
-            language: projectLanguage.language,
-        });
-        return this.runTestCommand(command, cwd);
-    }
-    async runTestCommand(command, cwd) {
-        let stdout = "";
-        let stderr = "";
-        let exitCode = 0;
-        try {
-            const result = await execAsync(command, { cwd, timeout: 120000 });
-            stdout = result.stdout;
-            stderr = result.stderr;
-        }
-        catch (execError) {
-            exitCode = execError.code || 1;
-            stdout = execError.stdout || "";
-            stderr = execError.stderr || "";
-        }
-        const actualPassed = this.parseTestOutput(stdout, "passed");
-        const actualFailed = this.parseTestOutput(stdout, "failed");
-        const result = {
-            testsExecuted: actualPassed + actualFailed,
-            passed: actualPassed,
-            failed: actualFailed,
-            exitCode,
-            output: stdout.substring(0, 2000),
-            success: exitCode === 0,
-        };
-        frameworkLogger.log("test-execution-processor", "completed", result.success ? "success" : "error", result);
-        return result;
-    }
-    parseTestOutput(output, type) {
-        const patterns = [
-            new RegExp(`(\\d+)\\s+${type}`, "gi"),
-            new RegExp(`Tests?:\\s+\\d+\\s+passed,\\s+(\\d+)\\s+failed`, "gi"),
-            new RegExp(`(\\d+)\\s+passed,\\s+(\\d+)\\s+failed`, "gi"),
-            new RegExp(`tests="(\\d+)"\\s+failures="(\\d+)"`, "gi"),
-        ];
-        for (const pattern of patterns) {
-            const match = output.match(pattern);
-            if (match) {
-                if (type === "passed") {
-                    if (match[0].includes("passed") && match[0].includes("failed")) {
-                        const passedMatch = match[0].match(/(\d+)\s+passed/);
-                        return passedMatch ? parseInt(passedMatch[1] || "0") : 0;
-                    }
-                    const count = match[0].match(/(\d+)/);
-                    return count ? parseInt(count[1] || "0") : 0;
-                }
-                else {
-                    if (match[0].includes("passed") && match[0].includes("failed")) {
-                        const failedMatch = match[0].match(/(\d+)\s+failed/);
-                        return failedMatch ? parseInt(failedMatch[1] || "0") : 0;
-                    }
-                    const count = match[0].match(/failures="(\d+)"/);
-                    return count ? parseInt(count[1] || "0") : 0;
-                }
-            }
-        }
-        return 0;
-    }
-}

package/dist/processors/implementations/typescript-compilation-processor.d.ts

@@ -1,37 +0,0 @@
-/**
- * TypeScript Compilation Processor
- *
- * Runs `tsc --noEmit` to catch type errors before writes land.
- * Parses TypeScript error lines from stderr and returns structured results.
- * Gracefully skips when no tsconfig.json exists.
- *
- * @since 2026-03-28
- */
-export interface TypeScriptCompilationResult {
-    success: boolean;
-    errors: string[];
-    duration: number;
-    fileCount: number;
-    errorCount?: number;
-    skipped?: boolean;
-    reason?: string;
-}
-/**
- * Parse TypeScript error lines from stderr output.
- * Filters for lines containing "error TS" which is the standard TypeScript error format.
- */
-export declare function parseTypeScriptErrors(stderr: string): string[];
-/**
- * Run TypeScript compilation check (tsc --noEmit).
- *
- * @param cwd - Working directory for the command (defaults to process.cwd())
- * @param timeout - Maximum execution time in milliseconds (default 30000)
- * @returns Structured result with success status, errors, and timing
- */
-export declare function runTypeScriptCompilation(cwd?: string, timeout?: number): TypeScriptCompilationResult;
-export declare const typescriptCompilationProcessor: {
-    name: string;
-    priority: number;
-    enabled: boolean;
-    execute(context: Record<string, unknown>): Promise<TypeScriptCompilationResult>;
-};