0xray 4.0.12 → 4.0.13

package/dist/mcps/registry.json

@@ -1,109 +0,0 @@
-{
-  "description": "0xRay Community MCPs Registry - curated API-focused MCP servers",
-  "sources": [
-    {
-      "name": "xmcp",
-      "url": "https://github.com/xdevplatform/xmcp",
-      "description": "X (Twitter) API MCP server - post tweets, read timeline, manage DMs",
-      "license": "MIT",
-      "category": "social",
-      "env": ["X_BEARER_TOKEN", "X_API_KEY"]
-    },
-    {
-      "name": "github-mcp",
-      "url": "https://github.com/divyanshvn/github-mcp-server",
-      "description": "GitHub API - issues, PRs, repos, code security",
-      "license": "MIT",
-      "category": "development",
-      "env": ["GITHUB_TOKEN"]
-    },
-    {
-      "name": "discord-mcp",
-      "url": "https://github.com/PaSympa/discord-mcp",
-      "description": "Discord API - messages, channels, roles, moderation (90+ tools)",
-      "license": "MIT",
-      "category": "social",
-      "env": ["DISCORD_TOKEN"]
-    },
-    {
-      "name": "sentry-mcp",
-      "url": "https://github.com/getsentry/sentry-mcp",
-      "description": "Sentry error monitoring - issues, events, releases",
-      "license": "MIT",
-      "category": "monitoring",
-      "env": ["SENTRY_AUTH_TOKEN"]
-    },
-    {
-      "name": "vercel-mcp",
-      "url": "https://github.com/vercel/vercel-mcp",
-      "description": "Vercel deployment - projects, deployments, aliases",
-      "license": "MIT",
-      "category": "deployment",
-      "env": ["VERCEL_TOKEN"]
-    },
-    {
-      "name": "notion-mcp",
-      "url": "https://github.com/makenotion/notion-mcp",
-      "description": "Notion API - pages, databases, search",
-      "license": "MIT",
-      "category": "productivity",
-      "env": ["NOTION_TOKEN"]
-    },
-    {
-      "name": "telegram-mcp",
-      "url": "https://github.com/chigwell/telegram-mcp",
-      "description": "Telegram API - messages, chats, bots",
-      "license": "MIT",
-      "category": "social",
-      "env": ["TELEGRAM_BOT_TOKEN"]
-    },
-    {
-      "name": "gmail-mcp",
-      "url": "https://github.com/chatanywhere/gmail-mcp",
-      "description": "Gmail API - send, read, manage emails",
-      "license": "MIT",
-      "category": "productivity",
-      "env": ["GOOGLE_CLIENT_ID", "GOOGLE_CLIENT_SECRET"]
-    },
-    {
-      "name": "slack-mcp",
-      "url": "https://github.com/slackapi/slack-mcp",
-      "description": "Slack API - messages, channels, apps",
-      "license": "MIT",
-      "category": "team",
-      "env": ["SLACK_BOT_TOKEN"]
-    },
-    {
-      "name": "jira-mcp",
-      "url": "https://github.com/atlassian/jira-mcp",
-      "description": "Jira API - issues, projects, sprints (Atlassian)",
-      "license": "MIT",
-      "category": "project-management",
-      "env": ["JIRA_TOKEN", "JIRA_URL"]
-    },
-    {
-      "name": "confluent-mcp",
-      "url": "https://github.com/confluentinc/mcp",
-      "description": "Confluent Kafka - topics, producers, consumers",
-      "license": "MIT",
-      "category": "data",
-      "env": ["CONFLUENT_API_KEY", "CONFLUENT_API_SECRET"]
-    },
-    {
-      "name": "wazuh-mcp",
-      "url": "https://github.com/gensecaihq/wazuh-mcp-server",
-      "description": "Wazuh SIEM - security operations, threat detection",
-      "license": "MIT",
-      "category": "security",
-      "env": ["WAZUH_API_KEY", "WAZUH_URL"]
-    },
-    {
-      "name": "stripe-mcp",
-      "url": "https://github.com/stripe/stripe-mcp",
-      "description": "Stripe payments - charges, customers, subscriptions",
-      "license": "MIT",
-      "category": "payments",
-      "env": ["STRIPE_SECRET_KEY"]
-    }
-  ]
-}

package/dist/mcps/researcher-confidence.d.ts

@@ -1,21 +0,0 @@
-import type { MemoryRoutingContext, MemoryTaskConfidence } from '../memory-routing/types.js';
-export interface ResearcherMemoryContext {
-    providerId: string;
-    confidence: MemoryTaskConfidence;
-    matchedSignals: string[];
-    recommendedAgent: string | null;
-    triggeredBy: 'trap-language' | 'high-confidence-primitives';
-}
-export declare function shouldQueryRepertoireConfidence(description: string, proposalType?: string): boolean;
-export declare function hasHighConfidencePrimitiveMatch(routingContext: MemoryRoutingContext, minConfidence?: number): boolean;
-/**
- * Resolve Repertoire task confidence for researcher proposal analysis.
- * Triggered by ontological-trap language or high-confidence primitive matches.
- */
-export declare function resolveResearcherMemoryContext(input: {
-    proposalTitle?: string;
-    proposalDescription?: string;
-    proposalType?: string;
-}): Promise<ResearcherMemoryContext | null>;
-export declare function buildMemoryRoutingEvidence(context: ResearcherMemoryContext): string[];
-export declare function formatMemoryRoutingBlock(context: ResearcherMemoryContext): string;

package/dist/mcps/researcher-confidence.js

@@ -1,92 +0,0 @@
-import { frameworkLogger } from '../core/framework-logger.js';
-import { getMemoryRoutingProvider } from '../memory-routing/index.js';
-const TRAP_LANGUAGE = /TYPE:\s*ontological-trap|ontological[- ]trap/i;
-const DEFAULT_MIN_CONFIDENCE_GATE = 0.55;
-export function shouldQueryRepertoireConfidence(description, proposalType = '') {
-    const text = `${description} ${proposalType}`.trim();
-    return TRAP_LANGUAGE.test(text);
-}
-export function hasHighConfidencePrimitiveMatch(routingContext, minConfidence = DEFAULT_MIN_CONFIDENCE_GATE) {
-    const confidences = routingContext.signalConfidences ?? {};
-    return Object.values(confidences).some((confidence) => confidence >= minConfidence);
-}
-function buildTaskText(proposalTitle, proposalDescription, proposalType) {
-    return [proposalTitle, proposalDescription, proposalType].filter(Boolean).join('\n');
-}
-/**
- * Resolve Repertoire task confidence for researcher proposal analysis.
- * Triggered by ontological-trap language or high-confidence primitive matches.
- */
-export async function resolveResearcherMemoryContext(input) {
-    const proposalTitle = input.proposalTitle ?? '';
-    const proposalDescription = input.proposalDescription ?? '';
-    const proposalType = input.proposalType ?? '';
-    const taskText = buildTaskText(proposalTitle, proposalDescription, proposalType);
-    const provider = await getMemoryRoutingProvider();
-    if (provider.id === 'null' || !provider.getTaskConfidence) {
-        return null;
-    }
-    const trapLanguageDetected = shouldQueryRepertoireConfidence(proposalDescription, proposalType);
-    const routingContext = provider.buildRoutingContext(taskText);
-    const primitiveMatchDetected = hasHighConfidencePrimitiveMatch(routingContext);
-    if (!trapLanguageDetected && !primitiveMatchDetected) {
-        return null;
-    }
-    const confidence = provider.getTaskConfidence({
-        id: 'researcher-proposal',
-        description: taskText,
-        type: proposalType || 'governance',
-    });
-    const matchedSignals = confidence.matchedSignals.length > 0
-        ? confidence.matchedSignals
-        : routingContext.matchedSignals;
-    const context = {
-        providerId: provider.id,
-        confidence,
-        matchedSignals,
-        recommendedAgent: confidence.recommendedAgent,
-        triggeredBy: trapLanguageDetected ? 'trap-language' : 'high-confidence-primitives',
-    };
-    if (confidence.highConfidenceTrapPresent) {
-        frameworkLogger.log('mcps/researcher', 'repertoire-trap-detected', 'info', {
-            providerId: provider.id,
-            matchedSignals,
-            complexityBoost: confidence.complexityBoost,
-            recommendedAgent: confidence.recommendedAgent,
-            triggeredBy: context.triggeredBy,
-        });
-    }
-    return context;
-}
-export function buildMemoryRoutingEvidence(context) {
-    const { confidence, matchedSignals, recommendedAgent } = context;
-    const signalSummary = confidence.signals
-        .map((entry) => `${entry.name} (${entry.confidence.toFixed(2)})`)
-        .join(', ');
-    const lines = [
-        `Repertoire memory routing (${context.providerId}, trigger: ${context.triggeredBy})`,
-        `Matched signals: ${matchedSignals.join(', ') || 'none'}`,
-        `Signal confidences: ${signalSummary || 'none'}`,
-        `High-confidence trap present: ${confidence.highConfidenceTrapPresent}`,
-        `Complexity boost: ${confidence.complexityBoost}`,
-    ];
-    if (recommendedAgent) {
-        lines.push(`Recommended agent for trap handling: ${recommendedAgent}`);
-    }
-    return lines;
-}
-export function formatMemoryRoutingBlock(context) {
-    const { confidence, matchedSignals, recommendedAgent } = context;
-    const lines = [
-        'MEMORY_ROUTING:',
-        `  provider: ${context.providerId}`,
-        `  trigger: ${context.triggeredBy}`,
-        `  matchedSignals: ${matchedSignals.join(', ') || 'none'}`,
-        `  highConfidenceTrapPresent: ${confidence.highConfidenceTrapPresent}`,
-        `  complexityBoost: ${confidence.complexityBoost}`,
-    ];
-    if (recommendedAgent) {
-        lines.push(`  recommendedAgent: ${recommendedAgent}`);
-    }
-    return lines.join('\n');
-}

package/dist/mcps/researcher.server.d.ts

@@ -1,29 +0,0 @@
-/**
- * 0xRay Librarian MCP Server
- *
- * Knowledge skill for codebase documentation lookup, implementation examples,
- * and multi-repo analysis - serves as the universal documentation reference
- *
- * NOTE: Class is named XrayLibrarianServer but the MCP server name is
- * "researcher" for backwards compatibility with existing tool references.
- */
-import { type CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
-interface AnalyzeProposalArgs {
-    proposalTitle?: string;
-    proposalDescription?: string;
-    evidence?: string[];
-    proposalType?: string;
-}
-declare class XrayLibrarianServer extends XrayKnowledgeSkillBase {
-    constructor();
-    private searchCodebase;
-    private findImplementation;
-    private getDocumentation;
-    /**
-     * Governance-oriented proposal analysis from the researcher / librarian perspective.
-     * Uses corpus patterns, historical recurrence, and architecture knowledge.
-     */
-    analyzeProposal(args: AnalyzeProposalArgs): Promise<CallToolResult>;
-}
-export { XrayLibrarianServer };

package/dist/mcps/researcher.server.js

@@ -1,419 +0,0 @@
-/**
- * 0xRay Librarian MCP Server
- *
- * Knowledge skill for codebase documentation lookup, implementation examples,
- * and multi-repo analysis - serves as the universal documentation reference
- *
- * NOTE: Class is named XrayLibrarianServer but the MCP server name is
- * "researcher" for backwards compatibility with existing tool references.
- */
-import * as fs from "fs";
-import * as path from "path";
-import { frameworkLogger } from "../core/framework-logger.js";
-import { isGovernanceLlmConfigured, tryLLMGovernance, } from "../governance/llm-governance-provider.js";
-import { formatGovernanceVoteText, localConferVote } from "../governance/local-confer.js";
-import { initializeMemoryRouting } from "../memory-routing/index.js";
-import { buildMemoryRoutingEvidence, formatMemoryRoutingBlock, resolveResearcherMemoryContext, } from "./researcher-confidence.js";
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
-class XrayLibrarianServer extends XrayKnowledgeSkillBase {
-    constructor() {
-        super("researcher", "3.1.0");
-        // Kick off MemoryRoutingProvider load so trap routing is ready in MCP subprocess mode.
-        initializeMemoryRouting();
-        this.tools = [
-            {
-                name: "search_codebase",
-                description: "Search the codebase for specific patterns, functions, or implementations",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        query: {
-                            type: "string",
-                            description: "Search query (function name, pattern, keyword)",
-                        },
-                        fileExtension: {
-                            type: "string",
-                            description: "File extension to search (e.g., '.ts', '.js')",
-                            default: ".ts",
-                        },
-                        maxResults: {
-                            type: "number",
-                            description: "Maximum number of results to return",
-                            default: 10,
-                        },
-                    },
-                    required: ["query"],
-                },
-            },
-            {
-                name: "find_implementation",
-                description: "Find implementation examples for a specific pattern or feature",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        feature: {
-                            type: "string",
-                            description: "Feature name to find implementations for",
-                        },
-                        context: {
-                            type: "string",
-                            description: "Additional context (e.g., 'MCP', 'testing', 'agent')",
-                        },
-                    },
-                    required: ["feature"],
-                },
-            },
-            {
-                name: "get_documentation",
-                description: "Get documentation for a specific module, class, or function",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        target: {
-                            type: "string",
-                            description: "Module, class, or function name",
-                        },
-                        includeExamples: {
-                            type: "boolean",
-                            description: "Include usage examples",
-                            default: true,
-                        },
-                    },
-                    required: ["target"],
-                },
-            },
-            {
-                name: "analyze_proposal",
-                description: "Analyze an inference proposal from a researcher / project-librarian perspective using corpus patterns, historical evidence, and architecture knowledge",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        proposalTitle: { type: "string" },
-                        proposalDescription: { type: "string" },
-                        evidence: { type: "array", items: { type: "string" } },
-                        proposalType: { type: "string" },
-                    },
-                    required: ["proposalTitle", "proposalDescription"],
-                },
-            },
-        ];
-        this.handlers = {
-            "search_codebase": async (args) => this.searchCodebase(args),
-            "find_implementation": async (args) => this.findImplementation(args),
-            "get_documentation": async (args) => this.getDocumentation(args),
-            "analyze_proposal": async (args) => this.analyzeProposal(args),
-        };
-        this.setupToolHandlers();
-    }
-    async searchCodebase(args) {
-        const { query, fileExtension = ".ts", maxResults = 10 } = args;
-        try {
-            const searchDir = process.cwd();
-            const results = [];
-            // Simple recursive search
-            const searchFiles = (dir, depth = 0) => {
-                if (depth > 5 || results.length >= maxResults)
-                    return;
-                if (!fs.existsSync(dir))
-                    return;
-                let entries;
-                try {
-                    entries = fs.readdirSync(dir, { withFileTypes: true });
-                }
-                catch (err) {
-                    frameworkLogger.log("mcps/researcher", "searchCodebase", "warning", { message: `Failed to read directory: ${dir}`, error: String(err) });
-                    return;
-                }
-                for (const entry of entries) {
-                    if (results.length >= maxResults)
-                        break;
-                    const fullPath = path.join(dir, entry.name);
-                    // Skip certain directories
-                    if (entry.name.startsWith(".") ||
-                        entry.name === "node_modules" ||
-                        entry.name === "dist" ||
-                        entry.name === "coverage") {
-                        continue;
-                    }
-                    if (entry.isDirectory()) {
-                        searchFiles(fullPath, depth + 1);
-                    }
-                    else if (entry.isFile() && entry.name.endsWith(fileExtension)) {
-                        let content;
-                        try {
-                            content = fs.readFileSync(fullPath, "utf-8");
-                        }
-                        catch (err) {
-                            frameworkLogger.log("mcps/researcher", "searchCodebase", "warning", { message: `Failed to read file: ${fullPath}`, error: String(err) });
-                            continue;
-                        }
-                        const lines = content.split("\n");
-                        const matches = [];
-                        const lineNumbers = [];
-                        lines.forEach((line, index) => {
-                            if (line.toLowerCase().includes(query.toLowerCase())) {
-                                matches.push(line.trim().substring(0, 100));
-                                lineNumbers.push(index + 1);
-                            }
-                        });
-                        if (matches.length > 0) {
-                            results.push({
-                                file: fullPath,
-                                matches: matches.slice(0, 5),
-                                lineNumbers: lineNumbers.slice(0, 5),
-                            });
-                        }
-                    }
-                }
-            };
-            searchFiles(searchDir);
-            if (results.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `No matches found for "${query}" in ${fileExtension} files.`,
-                        },
-                    ],
-                };
-            }
-            const output = results
-                .slice(0, maxResults)
-                .map((r) => {
-                const relPath = r.file.replace(searchDir + "/", "");
-                const matchList = r.matches
-                    .map((m, i) => `  Line ${r.lineNumbers[i]}: ${m}`)
-                    .join("\n");
-                return `📄 ${relPath}\n${matchList}`;
-            })
-                .join("\n\n");
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Search Results for "${query}":\n\n${output}\n\nTotal: ${results.length} files found`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error searching codebase: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    async findImplementation(args) {
-        const { feature, context } = args;
-        try {
-            // Search for implementations
-            const searchDir = process.cwd();
-            const implementations = [];
-            const searchIn = (dir, depth = 0) => {
-                if (depth > 5 || implementations.length >= 5)
-                    return;
-                if (!fs.existsSync(dir))
-                    return;
-                let entries;
-                try {
-                    entries = fs.readdirSync(dir, { withFileTypes: true });
-                }
-                catch (err) {
-                    frameworkLogger.log("mcps/researcher", "findImplementation", "warning", { message: `Failed to read directory: ${dir}`, error: String(err) });
-                    return;
-                }
-                for (const entry of entries) {
-                    if (implementations.length >= 5)
-                        break;
-                    const fullPath = path.join(dir, entry.name);
-                    if (entry.name.startsWith(".") ||
-                        entry.name === "node_modules" ||
-                        entry.name === "dist") {
-                        continue;
-                    }
-                    if (entry.isDirectory()) {
-                        searchIn(fullPath, depth + 1);
-                    }
-                    else if (entry.isFile() &&
-                        (entry.name.endsWith(".ts") || entry.name.endsWith(".js"))) {
-                        let content;
-                        try {
-                            content = fs.readFileSync(fullPath, "utf-8");
-                        }
-                        catch (err) {
-                            frameworkLogger.log("mcps/researcher", "findImplementation", "warning", { message: `Failed to read file: ${fullPath}`, error: String(err) });
-                            continue;
-                        }
-                        // Look for the feature in content
-                        if (content.toLowerCase().includes(feature.toLowerCase())) {
-                            const lines = content.split("\n");
-                            // Find a relevant snippet
-                            for (let i = 0; i < lines.length; i++) {
-                                const line = lines[i];
-                                if (line &&
-                                    line.toLowerCase().includes(feature.toLowerCase())) {
-                                    const snippet = lines
-                                        .slice(Math.max(0, i - 2), i + 3)
-                                        .join("\n");
-                                    implementations.push({
-                                        file: fullPath.replace(searchDir + "/", ""),
-                                        snippet: snippet.substring(0, 300),
-                                    });
-                                    break;
-                                }
-                            }
-                        }
-                    }
-                }
-            };
-            searchIn(searchDir);
-            if (implementations.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `No implementations found for "${feature}".`,
-                        },
-                    ],
-                };
-            }
-            const output = implementations
-                .map((impl, i) => `${i + 1}. ${impl.file}\n\`\`\`\n${impl.snippet}\n\`\`\``)
-                .join("\n\n");
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Implementation Examples for "${feature}":\n\n${output}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error finding implementation: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    async getDocumentation(args) {
-        const { target, includeExamples = true } = args;
-        try {
-            // Search for documentation in the codebase
-            const searchDir = process.cwd();
-            let documentation = "";
-            // Search for documentation - any .md files in project root and docs/ directory
-            const docSearchDirs = [searchDir, path.join(searchDir, "docs")];
-            const docFiles = [];
-            for (const docDir of docSearchDirs) {
-                try {
-                    if (!fs.existsSync(docDir))
-                        continue;
-                    const entries = fs.readdirSync(docDir, { withFileTypes: true });
-                    for (const entry of entries) {
-                        if (entry.isFile() && entry.name.endsWith(".md")) {
-                            docFiles.push(path.join(docDir, entry.name));
-                        }
-                    }
-                }
-                catch (err) {
-                    frameworkLogger.log("mcps/researcher", "getDocumentation", "warning", { message: `Failed to scan docs directory: ${docDir}`, error: String(err) });
-                }
-            }
-            for (const docPath of docFiles) {
-                let content;
-                try {
-                    content = fs.readFileSync(docPath, "utf-8");
-                }
-                catch (err) {
-                    frameworkLogger.log("mcps/researcher", "getDocumentation", "warning", { message: `Failed to read doc file: ${docPath}`, error: String(err) });
-                    continue;
-                }
-                // Look for target in docs
-                const lines = content.split("\n");
-                const targetLines = lines.filter((line) => line.toLowerCase().includes(target.toLowerCase()));
-                if (targetLines.length > 0) {
-                    documentation = targetLines.slice(0, 10).join("\n");
-                    break;
-                }
-            }
-            if (!documentation) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Documentation for "${target}":\n\n` +
-                                `No specific documentation found. Try using search_codebase or find_implementation tools.`,
-                        },
-                    ],
-                };
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Documentation for "${target}":\n\n${documentation}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error getting documentation: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    /**
-     * Governance-oriented proposal analysis from the researcher / librarian perspective.
-     * Uses corpus patterns, historical recurrence, and architecture knowledge.
-     */
-    async analyzeProposal(args) {
-        const { proposalTitle = "", proposalDescription = "", evidence = [], proposalType = "" } = args || {};
-        const memoryContext = await resolveResearcherMemoryContext({
-            proposalTitle,
-            proposalDescription,
-            proposalType,
-        });
-        const enrichedEvidence = [...(evidence || [])];
-        if (memoryContext?.confidence.highConfidenceTrapPresent) {
-            enrichedEvidence.push(...buildMemoryRoutingEvidence(memoryContext));
-        }
-        const vote = (await tryLLMGovernance("researcher", proposalTitle || "", proposalDescription || "", enrichedEvidence, proposalType || "")) ??
-            localConferVote({
-                role: "researcher",
-                llmConfigured: isGovernanceLlmConfigured(),
-                highConfidenceTrapPresent: memoryContext?.confidence.highConfidenceTrapPresent,
-                recommendedAgent: memoryContext?.recommendedAgent,
-            });
-        const memoryRoutingBlock = memoryContext?.confidence.highConfidenceTrapPresent
-            ? `\n${formatMemoryRoutingBlock(memoryContext)}`
-            : "";
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: formatGovernanceVoteText(vote, memoryRoutingBlock),
-                },
-            ],
-        };
-    }
-}
-// Run the server if this file is executed directly
-if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
-    const server = new XrayLibrarianServer();
-    server.run().catch((error) => frameworkLogger.log("mcps/researcher", "run", "error", { error: String(error) }));
-}
-export { XrayLibrarianServer };