0xray 2.0.0 → 2.1.0

package/dist/agents/frontend-engineer.d.ts

@@ -0,0 +1,8 @@
+import type { AgentConfig } from "./types.js";
+/**
+ * Frontend Engineer Agent
+ *
+ * Specialist in React, Vue, Angular, responsive design, accessibility,
+ * performance optimization, and modern UI/UX implementation.
+ */
+export declare const frontendEngineer: AgentConfig;

package/dist/agents/frontend-ui-ux-engineer.d.ts

@@ -0,0 +1,8 @@
+import type { AgentConfig } from "./types.js";
+/**
+ * Frontend UI/UX Engineer Agent
+ *
+ * Specialist in UI/UX design, user experience, visual design,
+ * accessibility, and frontend implementation.
+ */
+export declare const frontendUiUxEngineer: AgentConfig;

package/dist/agents/growth-strategist.d.ts

@@ -0,0 +1,8 @@
+import { AgentConfig } from "./types.js";
+/**
+ * Growth Strategist Agent
+ *
+ * Strategic marketing specialist for product positioning, campaign strategy,
+ * market analysis, and integrated marketing communications.
+ */
+export declare const growthStrategist: AgentConfig;

package/dist/agents/index.d.ts

@@ -0,0 +1,24 @@
+import type { AgentConfig } from "./types.js";
+import { architect } from "./architect.js";
+import { bugTriageSpecialist } from "./bug-triage-specialist.js";
+import { codeReviewer } from "./code-reviewer.js";
+import { securityAuditor } from "./security-auditor.js";
+import { refactorer } from "./refactorer.js";
+import { testingLead } from "./testing-lead.js";
+import { logMonitor } from "./log-monitor.js";
+import { researcher } from "./researcher.js";
+import { codeAnalyzer } from "./code-analyzer.js";
+import { backendEngineer } from "./backend-engineer.js";
+import { contentCreator } from "./content-creator.js";
+import { databaseEngineer } from "./database-engineer.js";
+import { devopsEngineer } from "./devops-engineer.js";
+import { frontendEngineer } from "./frontend-engineer.js";
+import { frontendUiUxEngineer } from "./frontend-ui-ux-engineer.js";
+import { growthStrategist } from "./growth-strategist.js";
+import { mobileDeveloper } from "./mobile-developer.js";
+import { performanceEngineer } from "./performance-engineer.js";
+import { seoConsultant } from "./seo-consultant.js";
+import { strategist } from "./strategist.js";
+import { techWriter } from "./tech-writer.js";
+export declare const builtinAgents: Record<string, AgentConfig>;
+export { architect, bugTriageSpecialist, codeReviewer, securityAuditor, refactorer, testingLead, logMonitor, researcher, codeAnalyzer, backendEngineer, contentCreator, databaseEngineer, devopsEngineer, frontendEngineer, frontendUiUxEngineer, growthStrategist, mobileDeveloper, performanceEngineer, seoConsultant, strategist, techWriter, };

package/dist/agents/librarian-agents-updater.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Librarian AGENTS.md Auto-Update Service
+ *
+ * Analyzes the project codebase and updates AGENTS.md to reflect
+ * the current project state (frameworks, APIs, components, etc.)
+ */
+export declare class LibrarianAgentsUpdater {
+    /**
+     * Main entry point to update AGENTS.md based on project analysis
+     * Now MERGES with existing content instead of overwriting
+     */
+    updateAgentsMd(projectRoot?: string): Promise<void>;
+    /**
+     * Generate only the auto-generated sections with markers
+     */
+    private generateAutoGeneratedContent;
+    /**
+     * Merge auto-generated content with existing AGENTS.md
+     * Preserves all manual sections outside the markers
+     */
+    private mergeAgentsMd;
+    private analyzeProject;
+    private detectProjectInfo;
+    private detectFrameworks;
+    private detectLanguages;
+    private detectAPIs;
+    private detectComponents;
+    private generateAgentsMd;
+}
+export declare const librarianAgentsUpdater: LibrarianAgentsUpdater;

package/dist/agents/log-monitor.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfig } from "./types.js";
+export declare const logMonitor: AgentConfig;

package/dist/agents/mobile-developer.d.ts

@@ -0,0 +1,9 @@
+import type { AgentConfig } from "./types.js";
+/**
+ * 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 declare const mobileDeveloper: AgentConfig;

package/dist/agents/multimodal-looker.d.ts

@@ -0,0 +1,9 @@
+import { AgentConfig } from "./types.js";
+/**
+ * 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 declare const multimodalLooker: AgentConfig;

package/dist/agents/performance-engineer.d.ts

@@ -0,0 +1,8 @@
+import type { AgentConfig } from "./types.js";
+/**
+ * Performance Engineer Agent
+ *
+ * Specialist in application performance optimization, profiling, benchmarking,
+ * resource optimization, and performance testing.
+ */
+export declare const performanceEngineer: AgentConfig;

package/dist/agents/refactorer.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfig } from "./types.js";
+export declare const refactorer: AgentConfig;

package/dist/agents/registry.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 interface AgentRegistryEntry {
+    name: string;
+    description: string;
+    capabilities: string[];
+    capacity: number;
+    specialties: string[];
+    mode: "primary" | "subagent";
+    maxComplexity: number;
+    concurrentTasks: number;
+    status: "active" | "inactive";
+    performance: number;
+    expertise: string;
+}
+export declare const AGENT_REGISTRY: Record<string, AgentRegistryEntry>;
+export declare function getActiveAgents(): string[];
+export declare function getAgentEntry(name: string): AgentRegistryEntry | undefined;
+export declare function isAllowedAgent(name: string): boolean;
+export declare function getAgentCapabilities(name: string): string[];
+export declare function validateRegistryConsistency(): {
+    valid: boolean;
+    errors: string[];
+};

package/dist/agents/researcher.d.ts

@@ -0,0 +1,2 @@
+import { AgentConfig } from "./types.js";
+export declare const researcher: AgentConfig;

package/dist/agents/security-auditor.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfig } from "./types.js";
+export declare const securityAuditor: AgentConfig;

package/dist/agents/seo-consultant.d.ts

@@ -0,0 +1,8 @@
+import { AgentConfig } from "./types.js";
+/**
+ * SEO Consultant Agent
+ *
+ * Technical SEO optimization specialist for code, content, and technical infrastructure.
+ * Focuses on technical SEO, schema markup, robots.txt, Core Web Vitals, and AI search optimization.
+ */
+export declare const seoConsultant: AgentConfig;

package/dist/agents/strategist.d.ts

@@ -0,0 +1,7 @@
+import { AgentConfig } from "./types.js";
+/**
+ * Strategist Agent
+ *
+ * Strategic guidance and complex problem-solving specialist.
+ */
+export declare const strategist: AgentConfig;

package/dist/agents/tech-writer.d.ts

@@ -0,0 +1,8 @@
+import type { AgentConfig } from "./types.js";
+/**
+ * Tech Writer Agent
+ *
+ * Specialist in technical documentation, API docs, README files,
+ * architectural decision records, and developer experience.
+ */
+export declare const techWriter: AgentConfig;

package/dist/agents/testing-lead.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfig } from "./types.js";
+export declare const testingLead: AgentConfig;

package/dist/agents/types.d.ts

@@ -0,0 +1,45 @@
+export interface ToolConfig {
+    include?: string[];
+    exclude?: string[];
+    [key: string]: unknown;
+}
+export interface PermissionConfig {
+    edit?: "ask" | "allow" | "deny";
+    bash?: "ask" | "allow" | "deny" | {
+        [command: string]: "ask" | "allow" | "deny";
+    };
+    webfetch?: "ask" | "allow" | "deny";
+    [key: string]: unknown;
+}
+export interface TaskDefinition {
+    id: string;
+    type: string;
+    description: string;
+    complexity: number;
+    priority: "high" | "medium" | "low";
+    createdAt: Date;
+    assignedAgent?: string;
+    status: "pending" | "running" | "completed" | "failed";
+    result?: unknown;
+    error?: string;
+    dependencies?: string[];
+    subagentType?: string;
+}
+export interface AgentConfig {
+    name: string;
+    model?: string;
+    description: string;
+    mode: "primary" | "subagent" | "all";
+    system: string;
+    temperature?: number;
+    top_p?: number;
+    tools?: ToolConfig;
+    permission?: PermissionConfig;
+    prompt?: string;
+    prompt_append?: string;
+    disable?: boolean;
+    color?: string;
+    capabilities: string[];
+    maxComplexity: number;
+    enabled: boolean;
+}

package/dist/analytics/consent-manager.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Consent Manager for 0xRay Central Analytics
+ *
+ * Manages user consent for analytics data submission with granular
+ * control over what categories can be shared.
+ *
+ * @version 1.0.0
+ * @since 2026-03-06
+ */
+export interface ConsentConfiguration {
+    analyticsEnabled: boolean;
+    consentDate: Date;
+    consentVersion: string;
+    lastOptOut: Date | undefined;
+    categories: {
+        reflections: boolean;
+        logs: boolean;
+        metrics: boolean;
+        patterns: boolean;
+    };
+    projectId: string;
+}
+export interface ConsentCategory {
+    name: string;
+    description: string;
+    enabled: boolean;
+}
+export declare class ConsentManager {
+    private configPath;
+    private config;
+    private submissionQueue;
+    constructor(configPath?: string | undefined);
+    /**
+     * Initialize consent manager - load existing config or create default
+     */
+    initialize(): Promise<ConsentConfiguration>;
+    /**
+     * Enable analytics (opt-in)
+     */
+    enableConsent(categories?: string[]): Promise<void>;
+    /**
+     * Disable analytics (opt-out)
+     */
+    disableConsent(): Promise<void>;
+    /**
+     * Check if submission is allowed for a category
+     */
+    canSubmit(category: string): boolean;
+    /**
+     * Get current consent status
+     */
+    getStatus(): Promise<ConsentConfiguration>;
+    /**
+     * Enable specific category
+     */
+    enableCategory(category: string): Promise<void>;
+    /**
+     * Disable specific category
+     */
+    disableCategory(category: string): Promise<void>;
+    /**
+     * Get all categories with their status
+     */
+    getCategories(): ConsentCategory[];
+    /**
+     * Generate anonymous project ID
+     */
+    private generateProjectId;
+    /**
+     * Create default disabled configuration
+     */
+    private createDefaultConfig;
+    /**
+     * Load configuration from file
+     */
+    private loadConfig;
+    /**
+     * Save configuration to file
+     */
+    private saveConfig;
+    /**
+     * Clear submission queue
+     */
+    private clearSubmissionQueue;
+    /**
+     * Add item to submission queue
+     */
+    queueSubmission(data: unknown): Promise<void>;
+    /**
+     * Save submission queue to file
+     */
+    private saveSubmissionQueue;
+}

package/dist/analytics/emerging-pattern-detector.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Emerging Pattern Detector for P9 - ADAPTIVE_PATTERN_LEARNING
+ *
+ * Discovers new routing patterns from recent task requests,
+ * identifies emergent behaviors, and suggests new pattern candidates.
+ *
+ * @version 1.0.0
+ * @since 2026-03-05
+ */
+import type { EmergentPattern } from "../core/kernel-patterns.js";
+import type { RoutingOutcome } from "../delegation/config/types.js";
+export interface ClusterResult {
+    clusterId: string;
+    patterns: string[];
+    frequency: number;
+    keywords: string[];
+    suggestedAgents: string[];
+    suggestedSkills: string[];
+    confidence: number;
+}
+export interface PatternDiscoveryResult {
+    emergentPatterns: EmergentPattern[];
+    clusters: ClusterResult[];
+    recommendations: string[];
+}
+export declare class EmergingPatternDetector {
+    private readonly minFrequencyThreshold;
+    private readonly minConfidenceThreshold;
+    private readonly clusterSimilarityThreshold;
+    private readonly maxClusters;
+    private readonly stopWords;
+    /**
+     * Extract meaningful keywords from task description
+     */
+    private extractKeywords;
+    /**
+     * Calculate Jaccard similarity between two keyword sets
+     */
+    private calculateSimilarity;
+    /**
+     * Cluster similar task descriptions
+     */
+    private clusterTasks;
+    /**
+     * Detect emergent patterns from recent routing outcomes
+     */
+    detectEmergingPatterns(outcomes: RoutingOutcome[]): PatternDiscoveryResult;
+    /**
+     * Check if a specific pattern is emerging
+     */
+    isPatternEmerging(pattern: string, recentOutcomes: RoutingOutcome[], historicalBaseline: number): {
+        emerging: boolean;
+        trend: 'increasing' | 'decreasing' | 'stable';
+        confidence: number;
+    };
+    /**
+     * Get suggested keyword mappings from emergent patterns
+     */
+    suggestKeywordMappings(emergentPatterns: EmergentPattern[]): Array<{
+        keywords: string[];
+        suggestedAgent: string;
+        suggestedSkill: string;
+        confidence: number;
+        reason: string;
+    }>;
+}
+export declare const emergingPatternDetector: EmergingPatternDetector;

package/dist/analytics/pattern-learning-engine.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Pattern Learning Engine for P9 - ADAPTIVE_PATTERN_LEARNING
+ *
+ * Learns from performance data, generates adaptive modifications,
+ * and creates self-improving pattern definitions.
+ *
+ * @version 1.0.0
+ * @since 2026-03-05
+ */
+import type { PatternUpdate } from "../core/kernel-patterns.js";
+export interface LearningResult {
+    newPatterns: PatternUpdate[];
+    modifiedPatterns: PatternUpdate[];
+    removedPatterns: PatternUpdate[];
+    thresholdUpdates: PatternUpdate[];
+    recommendations: string[];
+}
+export interface AdaptiveLearningConfig {
+    enableAutoAddition: boolean;
+    enableAutoRemoval: boolean;
+    enableThresholdCalibration: boolean;
+    minConfidenceForAddition: number;
+    minSuccessRateForAddition: number;
+    maxPatterns: number;
+}
+export declare class PatternLearningEngine {
+    private config;
+    private learningHistory;
+    private readonly maxHistory;
+    constructor(config?: Partial<AdaptiveLearningConfig>);
+    /**
+     * Main learning function - analyzes data and generates adaptive modifications
+     */
+    learnFromData(outcomes: Array<{
+        taskId: string;
+        taskDescription: string;
+        routedAgent: string;
+        routedSkill: string;
+        confidence: number;
+        success: boolean;
+    }>, existingMappings: Array<{
+        keywords: string[];
+        skill: string;
+        agent: string;
+        confidence: number;
+    }>): LearningResult;
+    /**
+     * Generate pattern modifications based on performance
+     */
+    private generatePatternModifications;
+    /**
+     * Generate patterns for removal based on poor performance
+     */
+    private generatePatternRemovals;
+    /**
+     * Generate adaptive threshold updates
+     */
+    private generateThresholdUpdates;
+    /**
+     * Generate new pattern suggestions from emergent patterns
+     */
+    private generateNewPatterns;
+    /**
+     * Generate recommendations based on learning results
+     */
+    private generateRecommendations;
+    /**
+     * Get learning history
+     */
+    getLearningHistory(): LearningResult[];
+    /**
+     * Update configuration
+     */
+    updateConfig(newConfig: Partial<AdaptiveLearningConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): AdaptiveLearningConfig;
+}
+export declare const patternLearningEngine: PatternLearningEngine;

package/dist/analytics/pattern-performance-tracker.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Pattern Performance Tracker for P9 - ADAPTIVE_PATTERN_LEARNING
+ *
+ * Monitors pattern effectiveness over time, detects pattern drift,
+ * and provides metrics for adaptive kernel modifications.
+ *
+ * @version 1.0.0
+ * @since 2026-03-05
+ */
+import type { AdaptiveThresholds } from "../core/kernel-patterns.js";
+export interface PatternMetrics {
+    patternId: string;
+    totalUsages: number;
+    successfulUsages: number;
+    failedUsages: number;
+    successRate: number;
+    avgConfidence: number;
+    avgResponseTime: number;
+    lastUpdated: Date;
+    timeSeries: Array<{
+        timestamp: Date;
+        successRate: number;
+        avgConfidence: number;
+        usageCount: number;
+    }>;
+}
+export interface PatternDriftAnalysis {
+    drifted: boolean;
+    patternId: string;
+    currentMetrics: PatternMetrics;
+    historicalBaseline: PatternMetrics;
+    driftMagnitude: number;
+    driftDirection: 'increasing' | 'decreasing' | 'unstable';
+    confidence: number;
+    recommendedAction: string;
+}
+export interface SystemPerformanceSummary {
+    overallSuccessRate: number;
+    overallAvgConfidence: number;
+    totalPatternsTracked: number;
+    patternsWithDrift: string[];
+    patternsNeedingAttention: string[];
+    recommendations: string[];
+}
+export declare class PatternPerformanceTracker {
+    private patternMetrics;
+    private readonly maxTimeSeriesPoints;
+    private readonly driftThreshold;
+    private readonly minSamplesForDrift;
+    private readonly baselineWindowSize;
+    /**
+     * Track performance metrics for a pattern
+     */
+    trackPatternPerformance(patternId: string, outcome: {
+        success: boolean;
+        confidence: number;
+        responseTime?: number;
+        complexity?: number;
+    }): void;
+    /**
+     * Detect if a pattern has drifted from its historical baseline
+     */
+    detectPatternDrift(patternId: string): PatternDriftAnalysis | null;
+    /**
+     * Get all pattern drift analyses
+     */
+    getAllDriftAnalyses(): PatternDriftAnalysis[];
+    /**
+     * Calculate adaptive confidence thresholds based on performance
+     */
+    calculateAdaptiveThresholds(): AdaptiveThresholds;
+    /**
+     * Get system performance summary
+     */
+    getSystemPerformanceSummary(): SystemPerformanceSummary;
+    /**
+     * Get metrics for a specific pattern
+     */
+    getPatternMetrics(patternId: string): PatternMetrics | null;
+    /**
+     * Get all tracked patterns
+     */
+    getAllPatternMetrics(): PatternMetrics[];
+    /**
+     * Clear all metrics (for testing or reset)
+     */
+    clear(): void;
+    /**
+     * Save metrics to disk for persistence
+     */
+    saveToDisk(): void;
+    /**
+     * Load metrics from disk
+     */
+    loadFromDisk(): void;
+}
+export declare const patternPerformanceTracker: PatternPerformanceTracker;

package/dist/analytics/predictive-analytics.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Predictive Analytics for Optimal Agent Routing
+ *
+ * Predicts the best agent to route a task to based on historical
+ * success rates using simple keyword overlap scoring.
+ *
+ * @version 1.0.0
+ */
+export interface RoutingPrediction {
+    agent: string;
+    confidence: number;
+    historicalSuccessRate: number;
+    sampleSize: number;
+    /** Risk level based on confidence and success probability */
+    riskLevel?: "low" | "medium" | "high";
+    /** Estimated task duration in milliseconds */
+    estimatedDuration?: number;
+    /** Agent performance metrics used for prediction */
+    agentMetrics?: AgentPerformanceSummary;
+}
+export interface AgentPerformanceSummary {
+    totalTasks: number;
+    successfulTasks: number;
+    failedTasks: number;
+    averageExecutionTime: number;
+    successRate: number;
+    recentPerformance: number[];
+    taskTypeBreakdown: Record<string, {
+        count: number;
+        successRate: number;
+    }>;
+}
+export type RiskLevel = "low" | "medium" | "high";
+export interface PredictiveAnalytics {
+    predict(taskDescription: string): Promise<RoutingPrediction | null>;
+    predictOptimalAgent(): Promise<RoutingPrediction | null>;
+    /** Synchronous prediction using in-memory data (no disk reload). */
+    predictSync(taskDescription: string): RoutingPrediction | null;
+    [key: string]: any;
+}
+export declare const predictiveAnalytics: PredictiveAnalytics;