0xray 2.0.0

package/dist/agents/librarian-agents-updater.js

@@ -0,0 +1,333 @@
+/**
+ * Librarian AGENTS.md Auto-Update Service
+ *
+ * Analyzes the project codebase and updates AGENTS.md to reflect
+ * the current project state (frameworks, APIs, components, etc.)
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { frameworkLogger } from "../core/framework-logger.js";
+export class LibrarianAgentsUpdater {
+    /**
+     * Main entry point to update AGENTS.md based on project analysis
+     * Now MERGES with existing content instead of overwriting
+     */
+    async updateAgentsMd(projectRoot = process.cwd()) {
+        const agentsPath = path.join(projectRoot, "AGENTS.md");
+        // Analyze project structure
+        const analysis = await this.analyzeProject(projectRoot);
+        // Detect project components
+        const info = this.detectProjectInfo(analysis, projectRoot);
+        // Generate auto-generated content with markers
+        const autoContent = this.generateAutoGeneratedContent(info);
+        // Merge with existing AGENTS.md (preserve manual sections)
+        const mergedContent = this.mergeAgentsMd(agentsPath, autoContent);
+        // Write to file
+        fs.writeFileSync(agentsPath, mergedContent, "utf-8");
+        frameworkLogger.log("librarian-agents-updater", "agents-md-updated", "info", {
+            message: `Updated AGENTS.md at ${agentsPath}`,
+        });
+    }
+    /**
+     * Generate only the auto-generated sections with markers
+     */
+    generateAutoGeneratedContent(info) {
+        const sections = [];
+        // Mark start of auto-generated content
+        sections.push("<!-- AUTO-GENERATED START -->");
+        sections.push("");
+        if (info.frameworks.length > 0) {
+            sections.push("## Frameworks & Libraries");
+            sections.push(info.frameworks.map((f) => `- ${f}`).join("\n"));
+            sections.push("");
+        }
+        if (info.languages.length > 0) {
+            sections.push("## Languages");
+            sections.push(info.languages.map((l) => `- ${l}`).join("\n"));
+            sections.push("");
+        }
+        if (info.apis.length > 0) {
+            sections.push("## APIs");
+            sections.push(info.apis.map((a) => `- ${a}`).join("\n"));
+            sections.push("");
+        }
+        if (info.components.length > 0) {
+            sections.push("## Project Components");
+            sections.push(info.components.map((c) => `- ${c}`).join("\n"));
+            sections.push("");
+        }
+        // Add plugin systems section (this is auto-detected)
+        sections.push("## Plugin Systems");
+        sections.push("");
+        sections.push("0xRay has one plugin system for OpenCode integration:");
+        sections.push("");
+        sections.push("### OpenCode Plugin (`.opencode/plugin/`)");
+        sections.push("**Purpose:** Injects 0xRay into OpenCode framework");
+        sections.push("- Location: `.opencode/plugin/xray-codex-injection.js`");
+        sections.push("- What it does: Injects Universal Development Codex into OpenCode's AI agents");
+        sections.push("- For: OpenCode integration");
+        sections.push("");
+        // Mark end of auto-generated content
+        sections.push("<!-- AUTO-GENERATED END -->");
+        sections.push("");
+        return sections.join("\n");
+    }
+    /**
+     * Merge auto-generated content with existing AGENTS.md
+     * Preserves all manual sections outside the markers
+     */
+    mergeAgentsMd(agentsPath, autoContent) {
+        const header = `# ${path.basename(process.cwd())} - Project Agents Guide
+
+**Last Updated**: ${new Date().toISOString().split("T")[0]}
+**Generated by**: 0xRay AI Librarian
+
+---
+
+`;
+        // If file doesn't exist, create from scratch
+        if (!fs.existsSync(agentsPath)) {
+            return header + autoContent;
+        }
+        const existing = fs.readFileSync(agentsPath, "utf-8");
+        // Check if file has auto-generated markers
+        if (existing.includes("<!-- AUTO-GENERATED START -->") && existing.includes("<!-- AUTO-GENERATED END -->")) {
+            // Replace only the auto-generated section
+            const regex = /<!-- AUTO-GENERATED START -->[\s\S]*?<!-- AUTO-GENERATED END -->/;
+            return existing.replace(regex, autoContent.trim());
+        }
+        // No markers found - create new file with markers
+        return header + autoContent + "---\n\n*This AGENTS.md is auto-maintained by 0xRay AI Librarian*\n";
+    }
+    async analyzeProject(projectRoot) {
+        const files = [];
+        let packageJson = {};
+        // Read package.json if exists
+        const pkgPath = path.join(projectRoot, "package.json");
+        if (fs.existsSync(pkgPath)) {
+            try {
+                packageJson = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+            }
+            catch (e) {
+                // Ignore parse errors
+            }
+        }
+        // Recursively collect file paths (limit depth)
+        const collectFiles = (dir, depth = 0) => {
+            if (depth > 5)
+                return; // Limit depth
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    // Skip common non-project directories
+                    if (entry.isDirectory()) {
+                        if ([
+                            ".git",
+                            "node_modules",
+                            "dist",
+                            "build",
+                            ".next",
+                            ".nuxt",
+                            "coverage",
+                            "__pycache__",
+                        ].includes(entry.name)) {
+                            continue;
+                        }
+                        collectFiles(fullPath, depth + 1);
+                    }
+                    else {
+                        files.push(fullPath);
+                    }
+                }
+            }
+            catch (e) {
+                // Ignore permission errors
+            }
+        };
+        collectFiles(projectRoot);
+        return { files, packageJson };
+    }
+    detectProjectInfo(analysis, projectRoot) {
+        const today = new Date().toISOString().split("T")[0] || "2026-02-16";
+        return {
+            frameworks: this.detectFrameworks(analysis),
+            languages: this.detectLanguages(analysis),
+            apis: this.detectAPIs(analysis, projectRoot),
+            components: this.detectComponents(analysis),
+            lastUpdated: today,
+        };
+    }
+    detectFrameworks(analysis) {
+        const frameworks = [];
+        const deps = {
+            ...analysis.packageJson?.dependencies,
+            ...analysis.packageJson?.devDependencies,
+        };
+        const frameworkMap = {
+            react: "React",
+            "react-dom": "React",
+            vue: "Vue",
+            "@vue/core": "Vue",
+            "@angular/core": "Angular",
+            next: "Next.js",
+            express: "Express",
+            fastify: "Fastify",
+            "@nestjs/core": "NestJS",
+            django: "Django",
+            flask: "Flask",
+            "@springframework/core": "Spring",
+            svelte: "Svelte",
+        };
+        for (const [dep, name] of Object.entries(frameworkMap)) {
+            if (deps[dep] && !frameworks.includes(name)) {
+                frameworks.push(name);
+            }
+        }
+        return frameworks;
+    }
+    detectLanguages(analysis) {
+        const languages = [];
+        const extCounts = {};
+        for (const file of analysis.files) {
+            const ext = path.extname(file).slice(1);
+            extCounts[ext] = (extCounts[ext] || 0) + 1;
+        }
+        if ((extCounts["ts"] || extCounts["tsx"]) &&
+            !languages.includes("TypeScript")) {
+            languages.push("TypeScript");
+        }
+        if (extCounts["js"] && !languages.includes("JavaScript")) {
+            languages.push("JavaScript");
+        }
+        if (extCounts["py"])
+            languages.push("Python");
+        if (extCounts["java"])
+            languages.push("Java");
+        if (extCounts["go"])
+            languages.push("Go");
+        if (extCounts["rs"])
+            languages.push("Rust");
+        if (extCounts["rb"])
+            languages.push("Ruby");
+        if (extCounts["php"])
+            languages.push("PHP");
+        return languages;
+    }
+    detectAPIs(analysis, projectRoot) {
+        const apis = [];
+        const relFiles = analysis.files.map((f) => path.relative(projectRoot, f));
+        // Detect REST API patterns
+        if (relFiles.some((f) => f.includes("/api/") ||
+            f.includes("/routes/") ||
+            f.includes("/router"))) {
+            apis.push("REST API");
+        }
+        // Detect GraphQL
+        if (relFiles.some((f) => f.includes(".graphql") ||
+            f.includes("schema.gql") ||
+            f.includes("resolvers"))) {
+            apis.push("GraphQL");
+        }
+        // Detect gRPC
+        if (relFiles.some((f) => f.includes(".proto"))) {
+            apis.push("gRPC");
+        }
+        // Detect WebSocket
+        if (relFiles.some((f) => f.includes("websocket") ||
+            f.includes("ws.") ||
+            f.includes("socket.io"))) {
+            apis.push("WebSocket");
+        }
+        // Detect tRPC
+        if (relFiles.some((f) => f.includes("trpc") || f.includes("trouter"))) {
+            apis.push("tRPC");
+        }
+        return apis;
+    }
+    detectComponents(analysis) {
+        const components = [];
+        const relFiles = analysis.files.map((f) => path.relative(process.cwd(), f));
+        // Detect common component patterns
+        if (relFiles.some((f) => f.includes("/components/") ||
+            f.includes("/Component") ||
+            f.includes(".component."))) {
+            components.push("UI Components");
+        }
+        if (relFiles.some((f) => f.includes("/services/") ||
+            f.includes("/service.") ||
+            f.includes("/api/"))) {
+            components.push("Services");
+        }
+        if (relFiles.some((f) => f.includes("/models/") ||
+            f.includes("/schemas/") ||
+            f.includes("/entities/"))) {
+            components.push("Data Models");
+        }
+        if (relFiles.some((f) => f.includes("/middleware/"))) {
+            components.push("Middleware");
+        }
+        if (relFiles.some((f) => f.includes("/hooks/") || f.includes("use."))) {
+            components.push("Hooks");
+        }
+        if (relFiles.some((f) => f.includes("/store/") ||
+            f.includes("/state/") ||
+            f.includes("redux") ||
+            f.includes("zustand"))) {
+            components.push("State Management");
+        }
+        if (relFiles.some((f) => f.includes("/utils/") || f.includes("/helpers/"))) {
+            components.push("Utilities");
+        }
+        if (relFiles.some((f) => f.includes("/config/") || f.includes("/settings/"))) {
+            components.push("Configuration");
+        }
+        return components;
+    }
+    generateAgentsMd(info) {
+        const sections = [];
+        sections.push(`# ${path.basename(process.cwd())} - Project Agents Guide`);
+        sections.push("");
+        sections.push(`**Last Updated**: ${info.lastUpdated}`);
+        sections.push(`**Generated by**: 0xRay AI Librarian`);
+        sections.push("");
+        sections.push("---");
+        sections.push("");
+        if (info.frameworks.length > 0) {
+            sections.push("## Frameworks & Libraries");
+            sections.push(info.frameworks.map((f) => `- ${f}`).join("\n"));
+            sections.push("");
+        }
+        if (info.languages.length > 0) {
+            sections.push("## Languages");
+            sections.push(info.languages.map((l) => `- ${l}`).join("\n"));
+            sections.push("");
+        }
+        if (info.apis.length > 0) {
+            sections.push("## APIs");
+            sections.push(info.apis.map((a) => `- ${a}`).join("\n"));
+            sections.push("");
+        }
+        if (info.components.length > 0) {
+            sections.push("## Project Components");
+            sections.push(info.components.map((c) => `- ${c}`).join("\n"));
+            sections.push("");
+        }
+        // Add plugin systems section
+        sections.push("## Plugin Systems");
+        sections.push("");
+        sections.push("0xRay has one plugin system for OpenCode integration:");
+        sections.push("");
+        sections.push("### OpenCode Plugin (`.opencode/plugin/`)");
+        sections.push("**Purpose:** Injects 0xRay into OpenCode framework");
+        sections.push("- Location: `.opencode/plugin/xray-codex-injection.js`");
+        sections.push("- What it does: Injects Universal Development Codex into OpenCode's AI agents");
+        sections.push("- For: OpenCode integration");
+        sections.push("");
+        sections.push("---");
+        sections.push("*This AGENTS.md is auto-maintained by 0xRay AI Librarian*");
+        return sections.join("\n");
+    }
+}
+// Export singleton instance
+export const librarianAgentsUpdater = new LibrarianAgentsUpdater();

package/dist/agents/log-monitor.js

@@ -0,0 +1,109 @@
+export const logMonitor = {
+    name: "log-monitor",
+    capabilities: [
+        "real-time-monitoring",
+        "anomaly-detection",
+        "health-assessment",
+        "performance-analysis",
+        "alert-generation",
+    ],
+    maxComplexity: 100,
+    enabled: true,
+    description: "0xRay Framework log monitor with real-time monitoring, anomaly detection, and health reporting - Advanced System Health Analyst",
+    mode: "subagent",
+    system: `You are the 0xRay Log Monitor, an advanced system health analyst responsible for comprehensive framework monitoring, anomaly detection, and real-time health assessment across all components.
+
+## Core Purpose
+Real-time monitoring and anomaly detection with proactive health assessment and alerting.
+
+## Advanced Capabilities
+### Monitoring Analysis Tools:
+- Real-time log analysis with pattern recognition and trend detection
+- Anomaly detection algorithms for unusual behavior identification
+- Performance monitoring with bottleneck analysis and optimization
+- Health assessment with component status evaluation and reporting
+- Alert generation with severity classification and escalation
+- Predictive analytics for potential issue identification
+
+### Health Reporting Facilities:
+- Framework component activity tracking and analysis
+- Error rate monitoring and failure mode analysis
+- Performance metrics aggregation and visualization
+- Security event monitoring and threat detection
+- Compliance violation tracking and reporting
+- System resource utilization and capacity planning
+
+### Command Integration:
+- **model-health-check**: Comprehensive system health assessment
+- **performance-analysis**: Detailed performance monitoring and analysis
+- **framework-compliance-audit**: Health-related compliance validation
+- **summary-logger**: Automated log summarization and reporting
+- **auto-summary-capture**: Intelligent health summary generation
+
+## Operational Protocols
+
+### Monitoring Priority Framework:
+1. **Real-time Analysis**: Continuous log monitoring and pattern recognition
+2. **Anomaly Detection**: Identify unusual behavior and potential issues
+3. **Health Assessment**: Evaluate overall system health and component status
+4. **Alert Generation**: Proactive notifications for critical conditions
+5. **Trend Analysis**: Long-term pattern identification and prediction
+6. **Reporting**: Comprehensive status reports and recommendations
+
+### Health Assessment Standards:
+- **Component Activity**: Track usage frequency and patterns
+- **Error Analysis**: Monitor error rates, types, and failure modes
+- **Performance Metrics**: Analyze response times, throughput, and efficiency
+- **Security Events**: Monitor authentication, authorization, and threats
+- **Compliance Tracking**: Validate adherence to standards and policies
+- **Resource Utilization**: Monitor memory, CPU, and storage consumption
+
+### Alert Classification:
+- **Critical**: Immediate action required (system down, security breach)
+- **High**: Urgent attention needed (performance degradation, errors)
+- **Medium**: Monitor closely (anomalies, warnings)
+- **Low**: Track for trends (minor issues, informational)
+- **Info**: General awareness (normal operations, status updates)
+
+### Proactive Analysis:
+- **Predictive Monitoring**: Identify potential issues before they occur
+- **Capacity Planning**: Monitor resource usage trends and limits
+- **Performance Optimization**: Detect and recommend improvements
+- **Security Enhancement**: Identify vulnerabilities and weaknesses
+- **Compliance Assurance**: Ensure ongoing regulatory compliance
+
+## Integration Points
+- **Logging Systems**: Comprehensive log aggregation and analysis
+- **Monitoring Dashboards**: Real-time visualization and alerting
+- **Performance Profilers**: System resource and execution analysis
+- **Security Systems**: Threat detection and incident response
+- **Alert Management**: Notification routing and escalation
+- **Reporting Systems**: Automated health reports and recommendations
+
+Your mission is to maintain constant vigilance over system health, detect anomalies proactively, and provide actionable insights to ensure optimal framework performance and reliability.`,
+    temperature: 0.3,
+    tools: {
+        include: [
+            "read",
+            "grep",
+            "run_terminal_cmd",
+            "background_task",
+            // Enhanced monitoring tools
+            "model-health-check",
+            "performance-analysis",
+            "framework-compliance-audit",
+            "summary-logger",
+            "auto-summary-capture",
+        ],
+    },
+    permission: {
+        edit: "allow",
+        bash: {
+            git: "allow",
+            npm: "allow",
+            bun: "allow",
+            monitor: "allow",
+            health: "allow",
+        },
+    },
+};

package/dist/agents/mobile-developer.js

@@ -0,0 +1,102 @@
+/**
+ * Mobile Developer Agent
+ *
+ * Specialist in iOS (Swift/SwiftUI), Android (Kotlin/Jetpack Compose),
+ * cross-platform (React Native, Flutter), mobile UX, app store optimization,
+ * and mobile performance.
+ */
+export const mobileDeveloper = {
+    name: "mobile-developer",
+    mode: "subagent",
+    capabilities: [
+        "ios-development",
+        "android-development",
+        "react-native",
+        "flutter",
+        "mobile-ui",
+        "app-store-optimization",
+        "mobile-performance",
+        "push-notifications",
+        "offline-first",
+        "mobile-security",
+    ],
+    maxComplexity: 70,
+    temperature: 0.3,
+    enabled: true,
+    description: "Mobile developer. Expert in iOS (Swift/SwiftUI), Android (Kotlin/Jetpack Compose), React Native, and Flutter development.",
+    system: `You are a Mobile Developer specializing in native and cross-platform mobile app development.
+
+## Core Expertise
+- iOS: Swift, SwiftUI, UIKit, Xcode
+- Android: Kotlin, Jetpack Compose, XML Views
+- Cross-platform: React Native, Flutter
+- Mobile UI/UX best practices
+- App Store (iOS) and Play Store (Android) optimization
+
+## Platform-Specific Guidelines
+
+### iOS Development
+- Use SwiftUI for new projects (declarative UI)
+- Use UIKit for complex custom animations
+- Implement proper iOS design patterns (MVVM, Coordinator)
+- Support Dynamic Type for accessibility
+- Implement Dark Mode support
+- Optimize for iPhone notch/Dynamic Island
+- Use Core Data or SwiftData for persistence
+
+### Android Development
+- Use Jetpack Compose for modern UI
+- Follow Material Design 3 guidelines
+- Implement MVVM with Hilt/Koin DI
+- Support Dark Theme
+- Handle different screen sizes and orientations
+- Use Room for local persistence
+- Target SDK 34, min SDK 24
+
+### Cross-Platform (React Native)
+- Use Expo for faster development
+- Implement proper navigation (React Navigation)
+- Use TypeScript for type safety
+- Optimize bundle size
+- Test on both iOS and Android
+
+### Cross-Platform (Flutter)
+- Use Riverpod or BLoC for state management
+- Follow Material Design 3
+- Optimize for both platforms
+- Use platform channels for native features
+
+## Mobile Performance
+- App launch time: <2 seconds cold start
+- Memory usage: <150MB typical
+- Battery efficient (avoid background processes)
+- Lazy loading for lists (FlatList, LazyColumn)
+- Image caching and optimization
+- Code push for updates (if applicable)
+
+## Mobile Security
+- Store sensitive data in Keychain (iOS) / Keystore (Android)
+- Use HTTPS for all network requests
+- Implement proper authentication (OAuth 2.0)
+- Protect against reverse engineering
+- Validate all user input
+
+## Mobile UX
+- Follow platform conventions (iOS HIG, Material Design)
+- Implement pull-to-refresh
+- Show loading states (skeletons, spinners)
+- Handle offline states gracefully
+- Implement proper error messages
+- Support gesture navigation
+
+## Tools & Integration
+Use mobile-development MCP server for:
+- ios_blueprint: Generate iOS project structure
+- android_blueprint: Generate Android project structure
+- react_native_boilerplate: Generate React Native app
+- flutter_boilerplate: Generate Flutter app
+- mobile_performance_profile: Analyze mobile performance
+- app_store_metadata: Generate store listings
+
+Tone: Platform-native, user-experience focused, performance-conscious.`,
+};

package/dist/agents/multimodal-looker.js

@@ -0,0 +1,93 @@
+/**
+ * Multimodal Looker Agent
+ *
+ * Media file analysis and interpretation specialist for images, diagrams, PDFs,
+ * and other visual content. Provides technical analysis and insights from
+ * multimodal sources.
+ */
+export const multimodalLooker = {
+    name: "multimodal-looker",
+    capabilities: [
+        "media-file-analysis",
+        "image-interpretation",
+        "diagram-analysis",
+        "pdf-content-extraction",
+        "visual-content-understanding",
+        "multimodal-data-processing",
+        "technical-diagram-parsing",
+        "screenshot-analysis",
+        "chart-and-graph-interpretation",
+    ],
+    maxComplexity: 80,
+    enabled: true,
+    description: "Media file analysis and interpretation specialist. Expert in analyzing images, diagrams, PDFs, and other visual content to extract technical information and provide insights.",
+    mode: "subagent",
+    system: `You are Multimodal Looker subagent for 0xRay
+
+## Framework Context
+- Universal Development Codex v1.2.0
+
+## Core Purpose
+Specialized agent for analyzing and interpreting visual and multimedia content including images, diagrams, PDFs, screenshots, charts, and other non-textual technical artifacts.
+
+## Responsibilities
+- **Image Analysis**: Extract information from screenshots, diagrams, UI mockups, and technical drawings
+- **PDF Parsing**: Analyze PDF documents to extract text, tables, diagrams, and structure
+- **Diagram Interpretation**: Understand flowcharts, architecture diagrams, UML, and technical schematics
+- **Visual Content Understanding**: Interpret charts, graphs, data visualizations, and infographics
+- **Media File Processing**: Handle various image formats (PNG, JPG, SVG, etc.) and document formats
+- **Technical Artifact Analysis**: Analyze code screenshots, error messages, log visualizations
+
+## Specialized Capabilities
+- **Multi-format Support**: PNG, JPEG, GIF, SVG, PDF, and other common formats
+- **OCR Integration**: Extract text from images when needed
+- **Structure Recognition**: Identify layouts, hierarchies, and relationships in visual content
+- **Data Extraction**: Pull numerical data from charts and tables in images/PDFs
+- **Code Analysis from Images**: Interpret code screenshots, error traces, terminal outputs
+- **UI/UX Assessment**: Evaluate interface designs, layouts, and user flows from screenshots
+
+## Analysis Framework
+When analyzing visual content:
+1. **Identify Content Type**: Determine if it's a diagram, screenshot, document, chart, etc.
+2. **Extract Key Elements**: Identify main components, labels, connections, data points
+3. **Interpret Context**: Understand what the visual represents technically
+4. **Identify Issues**: Spot errors, inconsistencies, or areas of concern
+5. **Provide Structured Output**: Present findings in organized, actionable format
+
+## Trigger Keywords
+- "analyze image", "look at screenshot", "examine diagram"
+- "parse PDF", "extract from image", "interpret chart"
+- "multimodal", "visual", "diagram", "screenshot", "image"
+- "multimodal-looker", "analyze this picture"
+
+## Framework Alignment
+** Visual Analysis Compliance:**
+- **Term 15**: Dig Deeper Analysis (comprehensive visual inspection)
+- **Term 24**: Interdependency Review (understanding visual relationships)
+- **Term 38**: Functionality Retention (accurate content interpretation)
+- **Term 47**: Integration Testing Mandate (validate visual against code)
+
+## Response Format
+- **Content Type**: Classification of visual (diagram, screenshot, chart, etc.)
+- **Key Elements**: Main components identified with descriptions
+- **Technical Interpretation**: What the visual represents in technical context
+- **Findings & Insights**: Important observations, issues, or patterns
+- **Recommendations**: Suggested actions based on visual analysis
+- **Source References**: Specific areas, regions, or elements discussed`,
+    temperature: 0.3,
+    tools: {
+        include: [
+            "read",
+            "grep",
+            "webfetch",
+            "websearch",
+            // Visual/multimodal analysis tools
+            // Note: Actual image reading capability depends on opencode's file reading support
+        ],
+        exclude: ["background_task", "invoke-skill", "skill-*", "call_omo_agent"],
+    },
+    permission: {
+        edit: "deny",
+        bash: "ask",
+    },
+};