0xray 2.1.4 → 2.2.1

package/dist/utils/token-manager.js

@@ -1,163 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { resolveConfigPath } from "../core/config-paths.js";
-export class TokenManager {
-    config;
-    constructor(configPath = resolveConfigPath("config.json") || path.join(process.cwd(), ".xray", "config.json")) {
-        this.config = this.loadConfig(configPath);
-    }
-    loadConfig(configPath) {
-        try {
-            const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-            return (config.token_management || {
-                maxPromptTokens: 20000,
-                warningThreshold: 15000,
-                modelLimits: {},
-                contextPruning: {
-                    enabled: true,
-                    aggressivePruning: true,
-                    preserveCriticalContext: true,
-                },
-            });
-        }
-        catch (error) {
-            // Fallback defaults if config loading fails
-            return {
-                maxPromptTokens: 20000,
-                warningThreshold: 15000,
-                modelLimits: {},
-                contextPruning: {
-                    enabled: true,
-                    aggressivePruning: true,
-                    preserveCriticalContext: true,
-                },
-            };
-        }
-    }
-    /**
-     * Estimate token count for text (rough approximation)
-     * Uses 4 characters per token as a conservative estimate
-     */
-    estimateTokens(text) {
-        return Math.ceil(text.length / 4);
-    }
-    /**
-     * Check if prompt exceeds limits
-     */
-    checkLimits(prompt, modelName) {
-        const currentTokens = this.estimateTokens(prompt);
-        const maxTokens = modelName
-            ? this.config.modelLimits[modelName] || this.config.maxPromptTokens
-            : this.config.maxPromptTokens;
-        const withinLimit = currentTokens <= maxTokens;
-        const needsPruning = currentTokens > this.config.maxPromptTokens;
-        const warning = currentTokens > this.config.warningThreshold;
-        return {
-            withinLimit,
-            currentTokens,
-            maxTokens,
-            needsPruning,
-            warning,
-        };
-    }
-    /**
-     * Prune context to fit within token limits
-     */
-    pruneContext(context, targetTokens = this.config.maxPromptTokens) {
-        if (!this.config.contextPruning.enabled) {
-            return context;
-        }
-        const currentTokens = this.estimateTokens(context);
-        if (currentTokens <= targetTokens) {
-            return context; // No pruning needed
-        }
-        // Preserve critical sections (AGENTS.md header, codex terms, etc.)
-        const criticalSections = this.extractCriticalSections(context);
-        const criticalTokens = this.estimateTokens(criticalSections.join("\n"));
-        // Calculate available tokens for non-critical content
-        const availableTokens = Math.max(targetTokens - criticalTokens, targetTokens * 0.3); // Reserve at least 30%
-        const nonCriticalContent = this.extractNonCriticalContent(context);
-        const prunedNonCritical = this.pruneNonCriticalContent(nonCriticalContent, availableTokens);
-        return `${criticalSections.join("\n")}\n\n${prunedNonCritical}`;
-    }
-    extractCriticalSections(context) {
-        const lines = context.split("\n");
-        const criticalSections = [];
-        // Always preserve codex terms and framework overview
-        const codexSection = this.extractSection(lines, "Universal Development Codex");
-        const frameworkSection = this.extractSection(lines, "0xRay Framework");
-        if (codexSection)
-            criticalSections.push(codexSection);
-        if (frameworkSection)
-            criticalSections.push(frameworkSection);
-        return criticalSections;
-    }
-    extractSection(lines, sectionTitle) {
-        const startIndex = lines.findIndex((line) => line.includes(sectionTitle));
-        if (startIndex === -1)
-            return null;
-        let endIndex = lines.length;
-        for (let i = startIndex + 1; i < lines.length; i++) {
-            const currentLine = lines[i];
-            if (currentLine &&
-                currentLine.startsWith("#") &&
-                currentLine !== lines[startIndex]) {
-                endIndex = i;
-                break;
-            }
-        }
-        return lines.slice(startIndex, endIndex).join("\n");
-    }
-    extractNonCriticalContent(context) {
-        const criticalSections = this.extractCriticalSections(context);
-        let result = context;
-        for (const section of criticalSections) {
-            result = result.replace(section, "");
-        }
-        return result.trim();
-    }
-    pruneNonCriticalContent(content, maxTokens) {
-        const lines = content.split("\n");
-        const result = [];
-        let currentTokens = 0;
-        for (const line of lines) {
-            const lineTokens = this.estimateTokens(line);
-            if (currentTokens + lineTokens <= maxTokens) {
-                result.push(line);
-                currentTokens += lineTokens;
-            }
-            else {
-                // Truncate line if too long
-                if (lineTokens > maxTokens * 0.1) {
-                    // If single line is >10% of limit
-                    const maxChars = maxTokens * 4 * 0.1; // Convert tokens to chars
-                    result.push(line.substring(0, maxChars) + "...[truncated]");
-                }
-                break;
-            }
-        }
-        return result.join("\n");
-    }
-    /**
-     * Generate warning message for token limits
-     */
-    generateWarning(limitCheck) {
-        if (limitCheck.withinLimit && !limitCheck.warning)
-            return "";
-        const messages = [];
-        if (limitCheck.warning) {
-            messages.push(`⚠️  Token usage warning: ${limitCheck.currentTokens.toLocaleString()} tokens (${((limitCheck.currentTokens / limitCheck.maxTokens) * 100).toFixed(1)}% of limit)`);
-        }
-        if (!limitCheck.withinLimit) {
-            messages.push(`🚨 Token limit exceeded: ${limitCheck.currentTokens.toLocaleString()} > ${limitCheck.maxTokens.toLocaleString()} tokens`);
-            messages.push("Context will be automatically pruned to fit within limits.");
-        }
-        return messages.join("\n");
-    }
-    /**
-     * Get current configuration
-     */
-    getConfig() {
-        return { ...this.config };
-    }
-}

package/src/mcps/knowledge-skills/testing-best-practices.server.test.ts

@@ -1,136 +0,0 @@
-/**
- * Integration tests for Testing Best Practices MCP Server
- */
-
-import { describe, it, expect, beforeEach } from "vitest";
-import { XrayTestingBestPracticesServer } from "./testing-best-practices.server";
-import * as fs from "fs";
-import * as path from "path";
-
-describe("testing-best-practices.server integration", () => {
-  describe("module exports", () => {
-    it("should export server class", () => {
-      expect(XrayTestingBestPracticesServer).toBeDefined();
-      expect(typeof XrayTestingBestPracticesServer).toBe("function");
-    });
-
-    it("should be able to instantiate the server", () => {
-      const server = new XrayTestingBestPracticesServer();
-      expect(server).toBeDefined();
-    });
-
-    it("should have run method", () => {
-      const server = new XrayTestingBestPracticesServer();
-      expect(typeof server.run).toBe("function");
-    });
-  });
-
-  describe("server structure", () => {
-    let server: XrayTestingBestPracticesServer;
-
-    beforeEach(() => {
-      server = new XrayTestingBestPracticesServer();
-    });
-
-    it("should instantiate correctly", () => {
-      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
-    });
-
-    it("should have run async method", () => {
-      expect(server.run).toBeInstanceOf(Function);
-    });
-  });
-
-  describe("test analysis capabilities", () => {
-    let server: XrayTestingBestPracticesServer;
-
-    beforeEach(() => {
-      server = new XrayTestingBestPracticesServer();
-    });
-
-    it("should analyze test coverage", () => {
-      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
-    });
-
-    it("should identify test gaps", () => {
-      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
-    });
-
-    it("should provide recommendations", () => {
-      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
-    });
-  });
-
-  describe("test strategy types", () => {
-    let server: XrayTestingBestPracticesServer;
-
-    beforeEach(() => {
-      server = new XrayTestingBestPracticesServer();
-    });
-
-    it("should support unit tests", () => {
-      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
-    });
-
-    it("should support integration tests", () => {
-      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
-    });
-
-    it("should support e2e tests", () => {
-      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
-    });
-
-    it("should support performance tests", () => {
-      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
-    });
-
-    it("should support security tests", () => {
-      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
-    });
-  });
-
-  describe("TDD/BDD implementation", () => {
-    let server: XrayTestingBestPracticesServer;
-
-    beforeEach(() => {
-      server = new XrayTestingBestPracticesServer();
-    });
-
-    it("should provide TDD guidance", () => {
-      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
-    });
-
-    it("should provide BDD guidance", () => {
-      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
-    });
-
-    it("should suggest test frameworks", () => {
-      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
-    });
-  });
-
-  describe("automation workflows", () => {
-    let server: XrayTestingBestPracticesServer;
-
-    beforeEach(() => {
-      server = new XrayTestingBestPracticesServer();
-    });
-
-    it("should calculate automation potential", () => {
-      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
-    });
-
-    it("should analyze test frameworks", () => {
-      const projectRoot = process.cwd();
-      const exists = fs.existsSync(projectRoot);
-      expect(exists).toBe(true);
-    });
-
-    it("should work with vitest", () => {
-      const projectRoot = process.cwd();
-      const packageJsonPath = path.join(projectRoot, "package.json");
-      const hasPackageJson = fs.existsSync(packageJsonPath);
-      expect(hasPackageJson).toBe(true);
-    });
-  });
-});