0xray 4.0.35 → 4.0.37

package/dist/delegation/codebase-context-analyzer.js

@@ -1,6 +1,60 @@
+import { createHash } from "crypto";
 import * as fs from "fs";
 import * as path from "path";
 import { frameworkLogger } from "../core/framework-logger.js";
+function bytesHash(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+const JS_IMPORT_PATTERNS = [
+    /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g,
+    /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+    /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+];
+const JS_EXPORT_PATTERNS = [
+    /export\s+(?:const|let|var|function|class|interface|type)\s+(\w+)/g,
+    /export\s+{\s*([^}]+)\s*}/g,
+    /export\s+default/g,
+];
+const PY_IMPORT_PATTERNS = [/from\s+([^\s]+)\s+import/g, /import\s+([^\s]+)/g];
+const JAVA_IMPORT_PATTERN = /^import\s+([^;]+);/gm;
+const JAVA_EXPORT_PATTERN = /(?:public\s+)?(?:class|interface|enum)\s+(\w+)/g;
+const CONFIG_FILE_PATTERNS = [
+    /package\.json$/,
+    /tsconfig\.json$/,
+    /webpack\.config\./,
+    /\.eslintrc/,
+    /\.prettierrc/,
+    /Dockerfile/,
+    /docker-compose\.yml/,
+    /\.env/,
+];
+const IMPORT_EXTENSIONS = ["", ".ts", ".tsx", ".js", ".jsx", ".py", ".java"];
+const FRAMEWORK_NEEDLES = [
+    ["react", "React"],
+    ["vue", "Vue.js"],
+    ["angular", "Angular"],
+    ["svelte", "Svelte"],
+    ["express", "Express.js"],
+    ["nestjs", "NestJS"],
+    ["nextjs", "Next.js"],
+    ["nuxt", "Nuxt.js"],
+];
+function countLines(content) {
+    let lines = 1;
+    for (let i = 0; i < content.length; i++) {
+        if (content.charCodeAt(i) === 10)
+            lines++;
+    }
+    return lines;
+}
+function resetAndCollect(pattern, content, into) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+        if (match[1])
+            into.push(match[1]);
+    }
+}
 export class CodebaseContextAnalyzer {
     projectRoot;
     memoryConfig;
@@ -135,9 +189,18 @@ export class CodebaseContextAnalyzer {
         if (filePath) {
             try {
                 const currentStats = fs.statSync(filePath);
-                const cachedMtime = cached.lastModified?.getTime() || 0;
-                if (currentStats.mtime.getTime() !== cachedMtime) {
-                    // File has changed, invalidate cache
+                const cachedMtime = cached.lastModified?.getTime();
+                const sameMeta = cachedMtime !== undefined &&
+                    currentStats.mtime.getTime() === cachedMtime &&
+                    cached.size !== undefined &&
+                    currentStats.size === cached.size;
+                if (!sameMeta) {
+                    this.analysisCache.delete(cacheKey);
+                    return null;
+                }
+                // mtime and size collided. Identity includes the bytes.
+                const hash = bytesHash(fs.readFileSync(filePath, "utf8"));
+                if (cached.contentHash !== hash) {
                     this.analysisCache.delete(cacheKey);
                     return null;
                 }
@@ -172,29 +235,37 @@ export class CodebaseContextAnalyzer {
      * Extract file path from cache key for validation
      */
     extractFilePathFromCacheKey(cacheKey) {
-        const match = cacheKey.match(/^file:(.+?:\d+)$/);
-        if (match && match[1]) {
-            const parts = match[1].split(":");
-            return parts[0] || null;
-        }
-        return null;
+        if (!cacheKey.startsWith("file:"))
+            return null;
+        const rest = cacheKey.slice("file:".length);
+        const colon = rest.lastIndexOf(":");
+        if (colon <= 0)
+            return null;
+        const mtime = rest.slice(colon + 1);
+        if (!/^\d+$/.test(mtime))
+            return null;
+        return rest.slice(0, colon);
     }
     /**
      * Stream file content for large files to reduce memory usage
      */
     async streamFileContent(filePath) {
         return new Promise((resolve, reject) => {
-            let content = "";
+            const chunks = [];
+            let size = 0;
             const stream = fs.createReadStream(filePath, { encoding: "utf8" });
             stream.on("data", (chunk) => {
-                content += chunk;
+                const text = typeof chunk === "string" ? chunk : String(chunk);
+                size += text.length;
                 // Prevent excessive memory usage during streaming
-                if (content.length > this.memoryConfig.maxFileSizeBytes) {
+                if (size > this.memoryConfig.maxFileSizeBytes) {
                     stream.destroy();
                     reject(new Error("File too large for streaming"));
+                    return;
                 }
+                chunks.push(text);
             });
-            stream.on("end", () => resolve(content));
+            stream.on("end", () => resolve(chunks.join("")));
             stream.on("error", reject);
         });
     }
@@ -206,9 +277,15 @@ export class CodebaseContextAnalyzer {
         const modules = new Map();
         const dependencyGraph = new Map();
         const languages = new Map();
-        const scanDirectory = async (dirPath, relativePath = "") => {
+        const scanDirectory = async (dirPath, relativePath = "", checkModule = false) => {
             try {
                 const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+                // Names decide module vs tree. Do not walk this snapshot.
+                if (checkModule && this.isModuleNames(entries.map((entry) => entry.name))) {
+                    const moduleInfo = await this.analyzeModule(dirPath, relativePath, jobId);
+                    modules.set(relativePath, moduleInfo);
+                    return;
+                }
                 // Process files in batches to control memory usage
                 const fileEntries = [];
                 const dirEntries = [];
@@ -221,11 +298,9 @@ export class CodebaseContextAnalyzer {
                         continue;
                     }
                     if (entry.isDirectory()) {
-                        const isModule = this.isModuleDirectory(entryPath);
                         dirEntries.push({
                             path: entryPath,
                             relativePath: entryRelativePath,
-                            isModule,
                         });
                     }
                     else if (entry.isFile()) {
@@ -237,13 +312,7 @@ export class CodebaseContextAnalyzer {
                 }
                 // Process directories first (may contain modules)
                 for (const dirEntry of dirEntries) {
-                    if (dirEntry.isModule) {
-                        const moduleInfo = await this.analyzeModule(dirEntry.path, dirEntry.relativePath, jobId);
-                        modules.set(dirEntry.relativePath, moduleInfo);
-                    }
-                    else {
-                        await scanDirectory(dirEntry.path, dirEntry.relativePath);
-                    }
+                    await scanDirectory(dirEntry.path, dirEntry.relativePath, true);
                 }
                 // Process files with concurrent processing for better performance
                 const concurrencyLimit = this.memoryConfig.enableConcurrentProcessing
@@ -341,8 +410,8 @@ export class CodebaseContextAnalyzer {
             let imports = [];
             let exports = [];
             try {
-                // Check cache first for performance
-                const cacheKey = `file:${relativePath}:${stats.mtime.getTime()}`;
+                // Same path and mtime still miss when size or bytes change.
+                const cacheKey = `file:${filePath}:${stats.mtime.getTime()}`;
                 const cached = this.getCachedAnalysis(cacheKey);
                 if (cached) {
                     return {
@@ -365,7 +434,7 @@ export class CodebaseContextAnalyzer {
                     this.memoryConfig.enableStreaming && stats.size > 100 * 1024
                         ? await this.streamFileContent(filePath)
                         : fs.readFileSync(filePath, "utf8");
-                linesOfCode = content.split("\n").length;
+                linesOfCode = countLines(content);
                 const importExportData = await this.extractImportsExports(content, language, jobId);
                 imports = importExportData.imports;
                 exports = importExportData.exports;
@@ -376,6 +445,9 @@ export class CodebaseContextAnalyzer {
                         imports,
                         exports,
                         content,
+                        lastModified: stats.mtime,
+                        size: stats.size,
+                        contentHash: bytesHash(content),
                         timestamp: Date.now(),
                     });
                 }
@@ -427,6 +499,7 @@ export class CodebaseContextAnalyzer {
         const dependents = new Set();
         const scanModuleFiles = async (modulePath, moduleRelativePath) => {
             try {
+                // List at the walk so a file created after classification is included.
                 const entries = fs.readdirSync(modulePath, { withFileTypes: true });
                 for (const entry of entries) {
                     const entryPath = path.join(modulePath, entry.name);
@@ -499,27 +572,13 @@ export class CodebaseContextAnalyzer {
     extractJsTsImportsExports(content) {
         const imports = [];
         const exports = [];
-        // Import patterns
-        const importPatterns = [
-            /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g,
-            /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
-            /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
-        ];
-        importPatterns.forEach((pattern) => {
-            let match;
-            while ((match = pattern.exec(content)) !== null) {
-                if (match[1]) {
-                    imports.push(match[1]);
-                }
-            }
-        });
+        for (const pattern of JS_IMPORT_PATTERNS) {
+            resetAndCollect(pattern, content, imports);
+        }
         // Export patterns
-        const exportPatterns = [
-            /export\s+(?:const|let|var|function|class|interface|type)\s+(\w+)/g,
-            /export\s+{\s*([^}]+)\s*}/g,
-            /export\s+default/g,
-        ];
+        const exportPatterns = JS_EXPORT_PATTERNS;
         exportPatterns.forEach((pattern) => {
+            pattern.lastIndex = 0;
             let match;
             while ((match = pattern.exec(content)) !== null) {
                 if (match[1]) {
@@ -546,16 +605,9 @@ export class CodebaseContextAnalyzer {
     extractPythonImportsExports(content) {
         const imports = [];
         const exports = [];
-        // Import patterns
-        const importPatterns = [/from\s+([^\s]+)\s+import/g, /import\s+([^\s]+)/g];
-        importPatterns.forEach((pattern) => {
-            let match;
-            while ((match = pattern.exec(content)) !== null) {
-                if (match[1]) {
-                    imports.push(match[1]);
-                }
-            }
-        });
+        for (const pattern of PY_IMPORT_PATTERNS) {
+            resetAndCollect(pattern, content, imports);
+        }
         // Export patterns (Python doesn't have explicit exports, but __all__ can indicate public API)
         const allMatch = content.match(/__all__\s*=\s*\[([^\]]+)\]/);
         if (allMatch && allMatch[1]) {
@@ -573,21 +625,8 @@ export class CodebaseContextAnalyzer {
     extractJavaImportsExports(content) {
         const imports = [];
         const exports = [];
-        // Import patterns
-        const importPattern = /^import\s+([^;]+);/gm;
-        let match;
-        while ((match = importPattern.exec(content)) !== null) {
-            if (match[1]) {
-                imports.push(match[1]);
-            }
-        }
-        // Export patterns (public classes/interfaces)
-        const exportPattern = /(?:public\s+)?(?:class|interface|enum)\s+(\w+)/g;
-        while ((match = exportPattern.exec(content)) !== null) {
-            if (match[1]) {
-                exports.push(match[1]);
-            }
-        }
+        resetAndCollect(JAVA_IMPORT_PATTERN, content, imports);
+        resetAndCollect(JAVA_EXPORT_PATTERN, content, exports);
         return {
             imports: Array.from(new Set(imports)),
             exports: Array.from(new Set(exports)),
@@ -597,7 +636,16 @@ export class CodebaseContextAnalyzer {
      * Build dependency graph between files
      */
     async buildDependencyGraph(fileGraph, dependencyGraph) {
-        for (const [filePath, fileInfo] of Array.from(fileGraph)) {
+        const existsCache = new Map();
+        const fileExists = (absPath) => {
+            const cached = existsCache.get(absPath);
+            if (cached !== undefined)
+                return cached;
+            const found = fs.existsSync(absPath);
+            existsCache.set(absPath, found);
+            return found;
+        };
+        for (const [filePath, fileInfo] of fileGraph) {
             const dependencies = new Set();
             for (const importPath of fileInfo.imports) {
                 // Resolve relative imports
@@ -605,21 +653,11 @@ export class CodebaseContextAnalyzer {
                     try {
                         const resolvedPath = path.resolve(path.dirname(fileInfo.path), importPath);
                         const resolvedRelative = path.relative(this.projectRoot, resolvedPath);
-                        // Check for file extensions
-                        const possibleExtensions = [
-                            "",
-                            ".ts",
-                            ".tsx",
-                            ".js",
-                            ".jsx",
-                            ".py",
-                            ".java",
-                        ];
                         let foundFile = null;
-                        for (const ext of possibleExtensions) {
+                        for (const ext of IMPORT_EXTENSIONS) {
                             const testPath = resolvedRelative + ext;
                             if (fileGraph.has(testPath) ||
-                                fs.existsSync(path.join(this.projectRoot, testPath))) {
+                                fileExists(path.join(this.projectRoot, testPath))) {
                                 foundFile = testPath;
                                 break;
                             }
@@ -648,34 +686,61 @@ export class CodebaseContextAnalyzer {
         const patterns = [];
         let structure = "monolithic";
         const entryPoints = [];
-        // Framework detection
-        if (this.hasFramework(fileGraph, "react"))
-            frameworks.push("React");
-        if (this.hasFramework(fileGraph, "vue"))
-            frameworks.push("Vue.js");
-        if (this.hasFramework(fileGraph, "angular"))
-            frameworks.push("Angular");
-        if (this.hasFramework(fileGraph, "svelte"))
-            frameworks.push("Svelte");
-        if (this.hasFramework(fileGraph, "express"))
-            frameworks.push("Express.js");
-        if (this.hasFramework(fileGraph, "nestjs"))
-            frameworks.push("NestJS");
-        if (this.hasFramework(fileGraph, "nextjs"))
-            frameworks.push("Next.js");
-        if (this.hasFramework(fileGraph, "nuxt"))
-            frameworks.push("Nuxt.js");
-        // Pattern detection
-        if (this.detectMVCPattern(fileGraph))
+        const foundFrameworks = new Set();
+        let hasControllers = false;
+        let hasModels = false;
+        let hasViews = false;
+        let hasRepository = false;
+        let hasFactory = false;
+        let hasObserver = false;
+        let hasMicroservices = false;
+        // One pass over paths and file text. Same booleans as the per-needle scans.
+        for (const [filePath, fileInfo] of fileGraph) {
+            if (!hasControllers && filePath.includes("controller"))
+                hasControllers = true;
+            if (!hasModels && filePath.includes("model"))
+                hasModels = true;
+            if (!hasViews && filePath.includes("view"))
+                hasViews = true;
+            if (!hasRepository && filePath.includes("repository"))
+                hasRepository = true;
+            if (!hasFactory && filePath.includes("factory"))
+                hasFactory = true;
+            if (!hasMicroservices &&
+                (filePath.includes("docker") ||
+                    filePath.includes("kubernetes") ||
+                    filePath.includes("service"))) {
+                hasMicroservices = true;
+            }
+            const content = fileInfo.content;
+            if (!content)
+                continue;
+            if (!hasObserver && (content.includes("subscribe") || content.includes("observe"))) {
+                hasObserver = true;
+            }
+            if (foundFrameworks.size === FRAMEWORK_NEEDLES.length)
+                continue;
+            const lower = content.toLowerCase();
+            for (const [needle, label] of FRAMEWORK_NEEDLES) {
+                if (!foundFrameworks.has(label) && lower.includes(needle)) {
+                    foundFrameworks.add(label);
+                }
+            }
+        }
+        for (const [, label] of FRAMEWORK_NEEDLES) {
+            if (foundFrameworks.has(label))
+                frameworks.push(label);
+        }
+        if (hasControllers && hasModels && hasViews)
             patterns.push("MVC");
-        if (this.detectRepositoryPattern(fileGraph))
+        if (hasRepository)
             patterns.push("Repository");
-        if (this.detectObserverPattern(fileGraph))
+        if (hasObserver)
             patterns.push("Observer");
-        if (this.detectFactoryPattern(fileGraph))
+        if (hasFactory)
             patterns.push("Factory");
         // Structure detection
-        if (modules.size > 5 && this.hasMicroservicesIndicators(fileGraph)) {
+        if (modules.size > 5 && hasMicroservices) {
             structure = "microservices";
         }
         else if (modules.size > 0) {
@@ -895,33 +960,26 @@ export class CodebaseContextAnalyzer {
         return risks;
     }
     // Helper methods
-    isModuleDirectory(dirPath) {
-        try {
-            const entries = fs.readdirSync(dirPath);
-            return (entries.some((entry) => {
-                const ext = path.extname(entry);
-                return this.supportedLanguages[ext];
-            }) &&
-                entries.some((entry) => entry === "package.json" ||
-                    entry === "index.ts" ||
-                    entry === "index.js"));
-        }
-        catch {
-            return false;
+    isModuleNames(names) {
+        let hasSource = false;
+        let hasMarker = false;
+        for (const entry of names) {
+            const ext = path.extname(entry);
+            if (this.supportedLanguages[ext]) {
+                hasSource = true;
+            }
+            if (entry === "package.json" ||
+                entry === "index.ts" ||
+                entry === "index.js") {
+                hasMarker = true;
+            }
+            if (hasSource && hasMarker)
+                return true;
         }
+        return false;
     }
     isConfigFile(filePath) {
-        const configPatterns = [
-            /package\.json$/,
-            /tsconfig\.json$/,
-            /webpack\.config\./,
-            /\.eslintrc/,
-            /\.prettierrc/,
-            /Dockerfile/,
-            /docker-compose\.yml/,
-            /\.env/,
-        ];
-        return configPatterns.some((pattern) => pattern.test(filePath));
+        return CONFIG_FILE_PATTERNS.some((pattern) => pattern.test(filePath));
     }
     classifyModule(relativePath, files) {
         if (relativePath.includes("test") || relativePath.includes("spec")) {
@@ -957,35 +1015,6 @@ export class CodebaseContextAnalyzer {
         const sourceFile = files.find((f) => f.isSourceCode);
         return sourceFile?.relativePath;
     }
-    hasFramework(fileGraph, framework) {
-        for (const file of Array.from(fileGraph.values())) {
-            if (file.content?.toLowerCase().includes(framework.toLowerCase())) {
-                return true;
-            }
-        }
-        return false;
-    }
-    detectMVCPattern(fileGraph) {
-        const hasControllers = Array.from(fileGraph.keys()).some((path) => path.includes("controller"));
-        const hasModels = Array.from(fileGraph.keys()).some((path) => path.includes("model"));
-        const hasViews = Array.from(fileGraph.keys()).some((path) => path.includes("view"));
-        return hasControllers && hasModels && hasViews;
-    }
-    detectRepositoryPattern(fileGraph) {
-        return Array.from(fileGraph.keys()).some((path) => path.includes("repository"));
-    }
-    detectObserverPattern(fileGraph) {
-        return Array.from(fileGraph.values()).some((file) => file.content?.includes("subscribe") ||
-            file.content?.includes("observe"));
-    }
-    detectFactoryPattern(fileGraph) {
-        return Array.from(fileGraph.keys()).some((path) => path.includes("factory"));
-    }
-    hasMicroservicesIndicators(fileGraph) {
-        return Array.from(fileGraph.keys()).some((path) => path.includes("docker") ||
-            path.includes("kubernetes") ||
-            path.includes("service"));
-    }
     isEntryPoint(filePath, fileInfo) {
         const entryIndicators = [
             "index.ts",

package/dist/delegation/session-coordinator.js

@@ -296,9 +296,10 @@ export class SessionCoordinator {
                 resolved = expertItem ? expertItem.value : sharedData[0]?.value;
                 break;
             case "consensus":
-                // All values must be the same
+                // All values must be the same. Stringify the anchor once.
                 const firstValue = sharedData[0]?.value;
-                const allSame = sharedData.every((item) => JSON.stringify(item.value) === JSON.stringify(firstValue));
+                const firstKey = JSON.stringify(firstValue);
+                const allSame = sharedData.every((item) => JSON.stringify(item.value) === firstKey);
                 resolved = allSame ? firstValue : undefined;
                 break;
         }

package/dist/enforcement/loaders/codex-loader.js

@@ -323,21 +323,25 @@ export class CodexLoader extends BaseLoader {
             }
             // Term 19: Small, Focused Functions - check function size
             if (termNum === 19) {
-                // Match actual function declarations and arrow functions (not variable declarations)
+                // Match actual function declarations and arrow functions (not variable declarations).
+                // exec indexes the first hit of each match text; indexOf(text) is that same span,
+                // and a repeated text rechecks it. Do not copy the tail on every hit.
                 const functionRegex = /(?:^|\n)(?:function\s+\w+|async\s+function\s+\w+|(?:\([^)]*\)|[^=])=>\s*\{)/g;
-                const matches = newCode.match(functionRegex);
-                if (matches) {
-                    for (const match of matches) {
-                        const startIdx = newCode.indexOf(match);
-                        const afterMatch = newCode.substring(startIdx + match.length);
-                        const closingIdx = afterMatch.indexOf('}');
-                        if (closingIdx > 0) {
-                            const functionBody = afterMatch.substring(0, closingIdx);
-                            const lines = functionBody.split('\n').filter(l => l.trim().length > 0);
-                            if (lines.length > 30) {
-                                violations.push(`Function with ${lines.length} lines - consider splitting into smaller functions (max 30)`);
-                                break;
-                            }
+                const seen = new Set();
+                let match;
+                while ((match = functionRegex.exec(newCode)) !== null) {
+                    const text = match[0];
+                    if (seen.has(text))
+                        continue;
+                    seen.add(text);
+                    const bodyStart = match.index + text.length;
+                    const closingIdx = newCode.indexOf('}', bodyStart);
+                    if (closingIdx > bodyStart) {
+                        const functionBody = newCode.substring(bodyStart, closingIdx);
+                        const lines = functionBody.split('\n').filter(l => l.trim().length > 0);
+                        if (lines.length > 30) {
+                            violations.push(`Function with ${lines.length} lines - consider splitting into smaller functions (max 30)`);
+                            break;
                         }
                     }
                 }