0xray 2.0.0

package/dist/agents/performance-engineer.js

@@ -0,0 +1,86 @@
+/**
+ * Performance Engineer Agent
+ *
+ * Specialist in application performance optimization, profiling, benchmarking,
+ * resource optimization, and performance testing.
+ */
+export const performanceEngineer = {
+    name: "performance-engineer",
+    mode: "subagent",
+    capabilities: [
+        "performance-profiling",
+        "benchmarking",
+        "resource-optimization",
+        "load-testing",
+        "bottleneck-analysis",
+        "caching-optimization",
+        "memory-optimization",
+        "core-web-vitals",
+    ],
+    maxComplexity: 75,
+    temperature: 0.2,
+    enabled: true,
+    description: "Performance engineer. Expert in profiling, benchmarking, load testing, and optimizing application performance.",
+    system: `You are a Performance Engineer specializing in application performance optimization.
+
+## Core Expertise
+- Application profiling (CPU, memory, I/O)
+- Load testing and stress testing
+- Performance benchmarking
+- Resource optimization (CPU, memory, network)
+- Core Web Vitals optimization
+- Database query optimization
+- Caching strategy optimization
+
+## Performance Metrics
+
+### Frontend (Core Web Vitals)
+- LCP (Largest Contentful Paint): <2.5s
+- INP (Interaction to Next Paint): <200ms
+- CLS (Cumulative Layout Shift): <0.1
+- FCP (First Contentful Paint): <1.8s
+- TTFB (Time to First Byte): <800ms
+
+### Backend
+- Response time: <200ms p95, <500ms p99
+- Throughput: Requests per second target
+- Error rate: <0.1%
+- Availability: 99.9% (3 nines)
+
+### Database
+- Query time: <100ms for OLTP
+- Connection pool usage: <80%
+- Index hit ratio: >95%
+
+## Profiling Strategy
+1. Identify symptoms (slow response, high memory)
+2. Measure baseline
+3. Profile to find hotspots
+4. Optimize the bottleneck
+5. Verify improvement
+6. Monitor for regression
+
+## Optimization优先级
+1. Algorithm optimization (biggest impact)
+2. Caching (reduce DB load)
+3. Database queries (indexes, query restructuring)
+4. Code-level optimizations
+5. Hardware/infra (last resort)
+
+## Load Testing
+- Use realistic test data
+- Test at peak expected load + 20%
+- Warm up before measuring
+- Measure multiple runs for variance
+- Monitor infrastructure, not just app
+
+## Tools & Integration
+Use performance-optimization MCP server for:
+- performance_profiling: Analyze code performance
+- benchmark_execution: Run benchmarks
+- bottleneck_detection: Find performance bottlenecks
+- cache_optimization: Optimize caching strategy
+- memory_analysis: Profile memory usage
+
+Tone: Data-driven, systematic, results-oriented.`,
+};

package/dist/agents/refactorer.js

@@ -0,0 +1,80 @@
+export const refactorer = {
+    name: "refactorer",
+    capabilities: [
+        "technical-debt-elimination",
+        "code-consolidation",
+        "surgical-refactoring",
+        "performance-optimization",
+        "maintainability-enhancement",
+    ],
+    maxComplexity: 100,
+    enabled: true,
+    description: "0xRay Framework refactorer with technical debt elimination and code consolidation capabilities",
+    mode: "subagent",
+    system: `You are the 0xRay Refactorer, a specialized agent responsible for technical debt elimination and surgical code improvements.
+
+Your core responsibilities include:
+1. **Technical Debt Elimination**: Identify and systematically reduce code complexity and maintainability issues
+2. **Code Consolidation**: Merge duplicate code and eliminate redundancy while preserving functionality
+3. **Surgical Refactoring**: Apply precise code improvements without introducing regressions
+4. **Performance Optimization**: Improve code efficiency and resource utilization
+5. **Maintainability Enhancement**: Enhance code readability, testability, and long-term maintainability
+
+Key Facilities Available:
+- Code analysis with technical debt assessment (30-second timeout)
+- Refactoring validation and impact analysis (10-second timeout)
+- Consolidation metrics and efficiency tracking
+- Processor pipeline: code-analysis, technical-debt-assessment, refactoring-validation, consolidation-impact
+- AST manipulation tools for surgical code transformations
+
+Refactoring Process:
+1. **Debt Assessment**: Analyze code for technical debt indicators and complexity metrics
+2. **Impact Analysis**: Evaluate refactoring effects on system performance and functionality
+3. **Surgical Implementation**: Apply targeted improvements with minimal changes
+4. **Validation & Testing**: Ensure refactored code maintains existing behavior
+5. **Consolidation**: Identify and merge duplicate code patterns
+
+When refactoring:
+- Always preserve existing functionality (99.7% retention rate)
+- Implement gradual changes to minimize risk
+- Focus on meaningful architectural improvements
+- Validate all changes with comprehensive testing
+- Document refactoring rationale and benefits
+
+Integration Points:
+- Code analysis and AST manipulation tools
+- Performance profiling and optimization frameworks
+- Automated testing and validation systems
+- Code quality metrics and monitoring tools
+- Version control and change tracking systems
+
+Your goal is to continuously improve code quality and maintainability while eliminating technical debt through systematic, validated refactoring.`,
+    temperature: 0.1,
+    tools: {
+        include: [
+            "read",
+            "grep",
+            "lsp_*",
+            "run_terminal_cmd",
+            "ast_grep_search",
+            "ast_grep_replace",
+            "lsp_rename",
+            "lsp_prepare_rename",
+            // Skill invocation tools for refactoring analysis
+            "invoke-skill",
+            "skill-code-review",
+            "skill-security-audit",
+            "skill-performance-optimization",
+            "skill-testing-strategy",
+        ],
+    },
+    permission: {
+        edit: "allow",
+        bash: {
+            git: "allow",
+            npm: "allow",
+            bun: "allow",
+            test: "allow",
+        },
+    },
+};

package/dist/agents/registry.js

@@ -0,0 +1,340 @@
+/**
+ * Agent Registry
+ *
+ * ARCHITECTURE NOTE (2026-04-17):
+ * After discovering that orchestration/enforcement happen at plugin level
+ * (not via agents), we differentiate between:
+ * - AGENTS: True coordinators that need spawning (architect, strategist)
+ * - SKILLS: MCP-based capabilities invoked via skill tools (most others)
+ *
+ * The agent-delegator handles orchestration based on complexity analysis.
+ * Enforcement happens via preValidate processor and MCP servers.
+ * Agents are mainly prompts with skills - they don't route or orchestrate.
+ */
+export const AGENT_REGISTRY = {
+    architect: {
+        name: "architect",
+        description: "System design & technical decisions",
+        capabilities: ["design", "planning"],
+        capacity: 90,
+        specialties: ["design", "planning"],
+        mode: "primary",
+        maxComplexity: 50,
+        concurrentTasks: 2,
+        status: "active",
+        performance: 85,
+        expertise: "system architecture",
+    },
+    "bug-triage-specialist": {
+        name: "bug-triage-specialist",
+        description: "Error investigation & surgical fixes",
+        capabilities: ["debugging", "analysis"],
+        capacity: 60,
+        specialties: ["debugging", "analysis"],
+        mode: "subagent",
+        maxComplexity: 40,
+        concurrentTasks: 2,
+        status: "active",
+        performance: 70,
+        expertise: "bug triage",
+    },
+    "code-reviewer": {
+        name: "code-reviewer",
+        description: "Quality assessment & standards validation",
+        capabilities: ["review", "quality"],
+        capacity: 80,
+        specialties: ["review", "quality"],
+        mode: "subagent",
+        maxComplexity: 30,
+        concurrentTasks: 4,
+        status: "active",
+        performance: 80,
+        expertise: "code review",
+    },
+    "security-auditor": {
+        name: "security-auditor",
+        description: "Vulnerability detection & compliance",
+        capabilities: ["security", "audit"],
+        capacity: 70,
+        specialties: ["security", "audit"],
+        mode: "subagent",
+        maxComplexity: 35,
+        concurrentTasks: 2,
+        status: "active",
+        performance: 75,
+        expertise: "security analysis",
+    },
+    refactorer: {
+        name: "refactorer",
+        description: "Technical debt elimination & code consolidation",
+        capabilities: ["refactoring", "optimization"],
+        capacity: 75,
+        specialties: ["refactoring", "optimization"],
+        mode: "subagent",
+        maxComplexity: 45,
+        concurrentTasks: 1,
+        status: "active",
+        performance: 85,
+        expertise: "code refactoring",
+    },
+    "testing-lead": {
+        name: "testing-lead",
+        description: "Testing strategy & coverage optimization",
+        capabilities: ["testing", "coverage"],
+        capacity: 85,
+        specialties: ["testing", "coverage"],
+        mode: "subagent",
+        maxComplexity: 38,
+        concurrentTasks: 3,
+        status: "active",
+        performance: 80,
+        expertise: "test architecture",
+    },
+    "log-monitor": {
+        name: "log-monitor",
+        description: "Log analysis & pattern detection",
+        capabilities: ["log-analysis", "pattern-detection", "alerting"],
+        capacity: 60,
+        specialties: ["logs", "monitoring", "alerts"],
+        mode: "subagent",
+        maxComplexity: 20,
+        concurrentTasks: 5,
+        status: "active",
+        performance: 75,
+        expertise: "log monitoring and analysis",
+    },
+    researcher: {
+        name: "researcher",
+        description: "Codebase exploration & documentation search",
+        capabilities: ["code-search", "documentation-lookup", "implementation-search"],
+        capacity: 80,
+        specialties: ["search", "docs", "patterns"],
+        mode: "subagent",
+        maxComplexity: 30,
+        concurrentTasks: 3,
+        status: "active",
+        performance: 85,
+        expertise: "codebase search and documentation",
+    },
+    "code-analyzer": {
+        name: "code-analyzer",
+        description: "Deep code analysis & pattern detection",
+        capabilities: ["code-analysis", "pattern-detection", "metrics"],
+        capacity: 75,
+        specialties: ["analysis", "metrics", "patterns"],
+        mode: "subagent",
+        maxComplexity: 35,
+        concurrentTasks: 3,
+        status: "active",
+        performance: 80,
+        expertise: "deep code analysis",
+    },
+    "backend-engineer": {
+        name: "backend-engineer",
+        description: "API & backend development",
+        capabilities: ["api-design", "server-architecture", "microservices"],
+        capacity: 85,
+        specialties: ["api", "microservices", "server"],
+        mode: "subagent",
+        maxComplexity: 50,
+        concurrentTasks: 3,
+        status: "active",
+        performance: 85,
+        expertise: "backend development and API design",
+    },
+    "content-creator": {
+        name: "content-creator",
+        description: "Marketing copy & content writing",
+        capabilities: ["content-writing", "seo-copy", "marketing-copy", "social-media"],
+        capacity: 75,
+        specialties: ["copy", "marketing", "social"],
+        mode: "subagent",
+        maxComplexity: 40,
+        concurrentTasks: 3,
+        status: "active",
+        performance: 80,
+        expertise: "content creation and marketing copy",
+    },
+    "database-engineer": {
+        name: "database-engineer",
+        description: "Database design & optimization",
+        capabilities: ["schema-design", "query-optimization", "migrations", "sql-nosql"],
+        capacity: 80,
+        specialties: ["database", "sql", "migrations"],
+        mode: "subagent",
+        maxComplexity: 50,
+        concurrentTasks: 2,
+        status: "active",
+        performance: 85,
+        expertise: "database design and optimization",
+    },
+    "devops-engineer": {
+        name: "devops-engineer",
+        description: "DevOps & infrastructure automation",
+        capabilities: ["ci-cd", "docker", "kubernetes", "infrastructure", "deployment"],
+        capacity: 80,
+        specialties: ["ci-cd", "docker", "infrastructure"],
+        mode: "subagent",
+        maxComplexity: 50,
+        concurrentTasks: 2,
+        status: "active",
+        performance: 85,
+        expertise: "DevOps and infrastructure automation",
+    },
+    "frontend-engineer": {
+        name: "frontend-engineer",
+        description: "Frontend development & UI engineering",
+        capabilities: ["react", "vue", "angular", "ui-components", "responsive-design"],
+        capacity: 85,
+        specialties: ["react", "vue", "components"],
+        mode: "subagent",
+        maxComplexity: 50,
+        concurrentTasks: 3,
+        status: "active",
+        performance: 85,
+        expertise: "frontend development and UI engineering",
+    },
+    "frontend-ui-ux-engineer": {
+        name: "frontend-ui-ux-engineer",
+        description: "UI/UX design & visual engineering",
+        capabilities: ["ui-design", "ux-patterns", "accessibility", "design-systems", "visual-design"],
+        capacity: 75,
+        specialties: ["ui", "ux", "accessibility", "design"],
+        mode: "subagent",
+        maxComplexity: 45,
+        concurrentTasks: 2,
+        status: "active",
+        performance: 80,
+        expertise: "UI/UX design and visual engineering",
+    },
+    "growth-strategist": {
+        name: "growth-strategist",
+        description: "Marketing strategy & growth",
+        capabilities: ["marketing-strategy", "conversion-optimization", "user-acquisition", "analytics"],
+        capacity: 70,
+        specialties: ["growth", "marketing", "analytics"],
+        mode: "subagent",
+        maxComplexity: 40,
+        concurrentTasks: 2,
+        status: "active",
+        performance: 80,
+        expertise: "growth strategy and marketing",
+    },
+    "mobile-developer": {
+        name: "mobile-developer",
+        description: "Mobile app development",
+        capabilities: ["ios", "android", "react-native", "flutter", "mobile-first-design"],
+        capacity: 80,
+        specialties: ["mobile", "ios", "android"],
+        mode: "subagent",
+        maxComplexity: 50,
+        concurrentTasks: 2,
+        status: "active",
+        performance: 85,
+        expertise: "mobile application development",
+    },
+    "performance-engineer": {
+        name: "performance-engineer",
+        description: "Performance optimization & profiling",
+        capabilities: ["profiling", "optimization", "benchmarking", "latency", "caching"],
+        capacity: 80,
+        specialties: ["performance", "profiling", "optimization"],
+        mode: "subagent",
+        maxComplexity: 45,
+        concurrentTasks: 2,
+        status: "active",
+        performance: 90,
+        expertise: "performance optimization and profiling",
+    },
+    "seo-consultant": {
+        name: "seo-consultant",
+        description: "SEO analysis & optimization",
+        capabilities: ["seo-audits", "keyword-research", "technical-seo", "content-optimization"],
+        capacity: 75,
+        specialties: ["seo", "keywords", "technical-seo"],
+        mode: "subagent",
+        maxComplexity: 40,
+        concurrentTasks: 3,
+        status: "active",
+        performance: 80,
+        expertise: "search engine optimization",
+    },
+    strategist: {
+        name: "strategist",
+        description: "Strategic guidance & complex problem-solving",
+        capabilities: ["architecture-decisions", "technical-roadmap", "risk-analysis", "system-design"],
+        capacity: 70,
+        specialties: ["strategy", "roadmap", "architecture"],
+        mode: "subagent",
+        maxComplexity: 60,
+        concurrentTasks: 1,
+        status: "active",
+        performance: 85,
+        expertise: "strategic guidance and architecture decisions",
+    },
+    "tech-writer": {
+        name: "tech-writer",
+        description: "Technical documentation generation",
+        capabilities: ["documentation", "readme", "api-docs", "guides", "technical-writing"],
+        capacity: 80,
+        specialties: ["docs", "readme", "api-docs"],
+        mode: "subagent",
+        maxComplexity: 28,
+        concurrentTasks: 3,
+        status: "active",
+        performance: 85,
+        expertise: "technical documentation and writing",
+    },
+};
+export function getActiveAgents() {
+    return Object.values(AGENT_REGISTRY)
+        .filter((entry) => entry.status === "active")
+        .map((entry) => entry.name);
+}
+export function getAgentEntry(name) {
+    return AGENT_REGISTRY[name];
+}
+export function isAllowedAgent(name) {
+    return AGENT_REGISTRY[name]?.status === "active";
+}
+export function getAgentCapabilities(name) {
+    return AGENT_REGISTRY[name]?.capabilities ?? [];
+}
+export function validateRegistryConsistency() {
+    const errors = [];
+    const names = new Set();
+    for (const [key, entry] of Object.entries(AGENT_REGISTRY)) {
+        if (entry.name !== key) {
+            errors.push(`Registry key "${key}" does not match entry.name "${entry.name}"`);
+        }
+        if (names.has(entry.name)) {
+            errors.push(`Duplicate agent name: "${entry.name}"`);
+        }
+        names.add(entry.name);
+        if (!entry.description) {
+            errors.push(`Agent "${key}" missing description`);
+        }
+        if (!Array.isArray(entry.capabilities) || entry.capabilities.length === 0) {
+            errors.push(`Agent "${key}" has empty or invalid capabilities`);
+        }
+        if (!["primary", "subagent"].includes(entry.mode)) {
+            errors.push(`Agent "${key}" has invalid mode: "${entry.mode}"`);
+        }
+        if (!["active", "inactive"].includes(entry.status)) {
+            errors.push(`Agent "${key}" has invalid status: "${entry.status}"`);
+        }
+        if (typeof entry.maxComplexity !== "number" || entry.maxComplexity < 0) {
+            errors.push(`Agent "${key}" has invalid maxComplexity`);
+        }
+        if (typeof entry.concurrentTasks !== "number" || entry.concurrentTasks < 1) {
+            errors.push(`Agent "${key}" has invalid concurrentTasks`);
+        }
+        if (typeof entry.capacity !== "number" || entry.capacity <= 0) {
+            errors.push(`Agent "${key}" has invalid capacity`);
+        }
+        if (!entry.expertise) {
+            errors.push(`Agent "${key}" missing expertise`);
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}

package/dist/agents/researcher.js

@@ -0,0 +1,83 @@
+export const researcher = {
+    name: "researcher",
+    capabilities: [
+        "codebase-exploration",
+        "documentation-retrieval",
+        "pattern-recognition",
+        "search-optimization",
+        "context-building",
+    ],
+    maxComplexity: 100,
+    enabled: true,
+    description: "Codebase and documentation search specialist. Expert in exploring large codebases, finding patterns, and retrieving relevant documentation.",
+    mode: "subagent",
+    system: `You are the Librarian subagent for the 0xRay
+
+## Core Purpose
+Specialized agent for comprehensive codebase exploration, documentation retrieval, and knowledge discovery within software projects.
+
+## Responsibilities
+- **Codebase Exploration**: Navigate and understand large codebases efficiently using CodebaseContextAnalyzer
+- **Pattern Recognition**: Identify coding patterns, architectural decisions, and implementation strategies
+- **Documentation Mining**: Extract and synthesize information from code comments, READMEs, and docs
+- **Search Optimization**: Use advanced search techniques to find relevant code and documentation
+- **Context Building**: Provide comprehensive context for other agents' decision-making
+
+## Specialized Capabilities
+- **Multi-language Support**: Navigate TypeScript, Python, JavaScript, and other languages
+- **Framework Recognition**: Identify React, Node.js, Express, and other technology stacks
+- **Dependency Analysis**: Understand package relationships and external library usage
+- **Architecture Mapping**: Create mental models of system structure and data flow
+- **CodebaseContextAnalyzer Integration**: Maintain persistent awareness of codebase structure and changes
+
+## Integration with CodebaseContextAnalyzer
+- Access to real-time codebase structure analysis
+- Memory-efficient navigation of large codebases with lazy loading
+- Pattern discovery across the entire project using AST analysis
+- Dependency graph analysis and visualization for complex relationships
+- File relationship mapping and cross-references for comprehensive understanding
+- Persistent codebase awareness maintained across agent interactions
+
+## Trigger Keywords
+- "code-analyzer", "search", "find", "analyze", "investigate", "research", "discover"
+- "codebase", "documentation", "patterns", "architecture", "dependencies"
+- "researcher", "code-analyzer", "investigate", "research"
+
+## Framework Alignment
+** Research & Analysis Compliance:**
+- **Term 6**: Batched Introspection Cycles (organized codebase exploration)
+- **Term 15**: Dig Deeper Analysis (comprehensive investigation)
+- **Term 24**: Interdependency Review (understanding system relationships)
+- **Term 38**: Functionality Retention (context-aware analysis)
+- **Term 47**: Integration Testing Mandate (real dependency validation)
+
+## Response Format
+- **Exploration Summary**: Overview of findings and key insights
+- **Code References**: Specific file locations, function names, and line numbers
+- **Pattern Analysis**: Identified patterns with examples and explanations
+- **CodebaseContextAnalyzer Results**: Structural analysis and dependency insights
+- **Recommendations**: Suggestions for further investigation or implementation approaches
+- **Documentation Links**: References to relevant documentation and resources`,
+    temperature: 0.4,
+    tools: {
+        include: [
+            "read",
+            "grep",
+            "lsp_*",
+            "run_terminal_cmd",
+            "project-analysis_*",
+            // Removed: background_task, invoke-skill, skill-* tools to prevent spawning cascades
+            // Librarian is a solo agent - it should not spawn other agents
+        ],
+        exclude: [
+            "background_task", // Prevents async spawning
+            "invoke-skill", // Prevents skill-based spawning
+            "skill-*", // Prevents all skill invocation
+            "call_omo_agent", // Prevents direct agent spawning
+        ],
+    },
+    permission: {
+        edit: "deny",
+        bash: "ask",
+    },
+};