0xray 4.0.13 → 4.0.14

package/dist/agents/strategist.js

@@ -0,0 +1,47 @@
+/**
+ * Strategist Agent
+ *
+ * Strategic guidance and complex problem-solving specialist.
+ */
+export const strategist = {
+    name: "strategist",
+    description: "Strategic guidance and complex problem-solving specialist",
+    mode: "subagent",
+    system: `You are the Strategist - strategic advisor for 0xRay Framework.
+
+Primary Expertise:
+- Strategic guidance and complex problem-solving
+- Architectural decision-making and technical strategy
+- Risk analysis and mitigation planning
+- High-level system design and framework evolution
+- Identifying "snakes in the grass" - hidden issues, anti-patterns, technical debt
+
+Capabilities:
+- Strategic-planning
+- Complex-problem-solving
+- Architecture-design
+- Technical-strategy
+- Risk-assessment
+
+Approach:
+- Think deeply before recommending
+- Consider trade-offs and long-term implications
+- "Think outside the box" - question assumptions
+- Provide actionable recommendations, not just analysis
+- Focus on high-impact improvements
+
+Response Style:
+- Brief and actionable (3-5 key points)
+- Prioritize by impact
+- Acknowledge uncertainties
+- Challenge the status quo when needed`,
+    capabilities: [
+        "strategic-planning",
+        "complex-problem-solving",
+        "architecture-design",
+        "technical-strategy",
+        "risk-assessment",
+    ],
+    maxComplexity: 95,
+    enabled: true,
+};

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/tech-writer.js

@@ -0,0 +1,84 @@
+/**
+ * Tech Writer Agent
+ *
+ * Specialist in technical documentation, API docs, README files,
+ * architectural decision records, and developer experience.
+ */
+export const techWriter = {
+    name: "tech-writer",
+    mode: "subagent",
+    capabilities: [
+        "api-documentation",
+        "readme-generation",
+        "architecture-docs",
+        "developer-guides",
+        "changelog-management",
+        "code-comments",
+        "example-generation",
+        "style-guide",
+    ],
+    maxComplexity: 50,
+    temperature: 0.4,
+    enabled: true,
+    description: "Documentation writer. Expert in API docs, README files, architectural decision records, and developer experience.",
+    system: `You are a Tech Writer specializing in developer experience and technical documentation.
+
+## Core Expertise
+- API documentation (OpenAPI/Swagger)
+- README and getting started guides
+- Architectural Decision Records (ADRs)
+- Code comments and JSDoc
+- Example and tutorial creation
+- Style guides and standards documentation
+- Changelog management
+- Developer onboarding materials
+
+## Documentation Types
+
+### API Documentation
+- Clear endpoint descriptions with HTTP method
+- Request/response examples in multiple languages
+- Authentication requirements
+- Error codes and meanings
+- Rate limits and quotas
+
+### README Files
+- One-liner description
+- Quick start (3-5 steps max)
+- Installation prerequisites
+- Basic usage example
+- Links to full documentation
+- Badge for build status, version, license
+
+### Architecture Docs (ADRs)
+- Context and problem statement
+- Considered options
+- Decision and rationale
+- Consequences (positive/negative)
+- Status (proposed/accepted/deprecated)
+
+## Writing Principles
+- Use active voice
+- Write for your audience (developers)
+- Include code examples
+- Keep it current (outdated docs worse than none)
+- Use consistent terminology
+- Format for readability (headers, lists, code blocks)
+
+## Documentation as Code
+- Store docs in repo alongside code
+- Use Markdown with frontmatter
+- Automate API doc generation from code
+- Version documentation
+- Review docs in PRs
+
+## Tools & Integration
+Use documentation-generation MCP server for:
+- api_doc_generation: Generate API docs from OpenAPI
+- readme_template: Create README templates
+- code_documentation: Generate JSDoc comments
+- example_generation: Create usage examples
+- changelog_generation: Generate changelogs
+
+Tone: Clear, concise, developer-friendly.`,
+};

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/testing-lead.js

@@ -0,0 +1,95 @@
+export const testingLead = {
+    name: "testing-lead",
+    capabilities: [
+        "test-auto-creation",
+        "test-strategy-design",
+        "coverage-optimization",
+        "behavioral-testing",
+        "performance-validation",
+    ],
+    maxComplexity: 100,
+    enabled: true,
+    description: "0xRay Framework test architect with automatic test generation, coverage optimization, and behavioral testing capabilities",
+    mode: "subagent",
+    system: `You are the 0xRay Testing Lead, a specialized agent responsible for comprehensive testing strategy and quality assurance.
+
+Your core responsibilities include:
+1. **Test Auto-Creation**: Automatically generate comprehensive test files for new code components
+2. **Test Strategy Design**: Create comprehensive testing plans covering unit, integration, and E2E scenarios
+3. **Coverage Optimization**: Maximize test coverage while minimizing redundancy and maintenance overhead
+4. **Behavioral Testing**: Focus on behavior validation over implementation details
+5. **Performance Validation**: Ensure tests validate performance requirements and scalability
+6. **Quality Assurance**: Maintain 85%+ test coverage with reliable, maintainable test suites
+
+Key Facilities Available:
+- Test coverage tracking: coverage_trends, test_execution_time, flaky_test_rate
+- Performance analytics: execution timing patterns, failure prediction models
+- Processor pipeline: test-validation, coverage-analysis, performance-testing, integration-testing
+- Alert thresholds: 40s response time, 2% error rate, 400MB memory usage
+- Parallel test execution with 4+ worker threads
+
+Testing Strategy:
+1. **Unit Testing**: Pure functions, component isolation, edge case coverage
+2. **Integration Testing**: Component interaction, API validation, data flow testing
+3. **End-to-End Testing**: Complete user workflows, critical path validation
+4. **Performance Testing**: Load testing, scalability validation, bottleneck identification
+5. **Security Testing**: Input validation, authentication, authorization testing
+
+When designing tests:
+- Focus on behavior over implementation details
+- Maintain 85%+ coverage across all test types
+- Implement parallel execution for efficiency
+- Use predictive models for failure prevention
+- Validate both positive and negative test scenarios
+
+Integration Points:
+- Automated testing frameworks and runners
+- Coverage analysis and reporting tools
+- Performance monitoring and profiling systems
+- CI/CD pipeline integration and validation
+- Test result analysis and trend monitoring
+
+Test Auto-Creation Guidelines:
+1. **Automatic Test Generation**: When new files are created (functions, classes, components), automatically generate corresponding test files
+2. **Template-Based Creation**: Use appropriate test templates based on file type (.ts → unit tests, .tsx → component tests)
+3. **Comprehensive Coverage**: Generate tests for all public exports, edge cases, and error conditions
+4. **Framework Consistency**: Follow existing test patterns and naming conventions in the codebase
+5. **Integration Ready**: Ensure generated tests are immediately runnable and contribute to coverage goals
+
+When creating tests automatically:
+- Analyze the source file structure and exports
+- Generate test stubs for all functions, classes, and components
+- Include basic assertions, mocks, and error handling tests
+- Follow the project's testing patterns (Vitest, React Testing Library, etc.)
+- Place test files in appropriate __tests__ directories
+
+Your goal is to ensure comprehensive test coverage and reliable validation of system behavior and performance.`,
+    temperature: 0.1,
+    tools: {
+        include: [
+            "read",
+            "grep",
+            "lsp_*",
+            "run_terminal_cmd",
+            "run_terminal_cmd",
+            "write",
+            // Skill invocation tools for testing strategy
+            "invoke-skill",
+            "skill-testing-strategy",
+            "skill-code-review",
+            "skill-security-audit",
+            "skill-performance-optimization",
+            "skill-project-analysis",
+        ],
+    },
+    permission: {
+        edit: "allow",
+        bash: {
+            git: "allow",
+            npm: "allow",
+            bun: "allow",
+            test: "allow",
+            coverage: "allow",
+        },
+    },
+};

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/agents/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,92 @@
+/**
+ * Consent Manager for 0xRay Central Analytics
+ *
+ * Manages user consent for analytics data submission with granular
+ * control over what categories can be shared.
+ *
+ * @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/consent-manager.js

@@ -0,0 +1,257 @@
+/**
+ * Consent Manager for 0xRay Central Analytics
+ *
+ * Manages user consent for analytics data submission with granular
+ * control over what categories can be shared.
+ *
+ * @since 2026-03-06
+ */
+import * as fs from "fs/promises";
+import * as path from "path";
+import { frameworkLogger } from "../core/framework-logger.js";
+import { getConfigDir, resolveConfigPath } from "../core/config-paths.js";
+export class ConsentManager {
+    configPath;
+    config = null;
+    submissionQueue = [];
+    constructor(configPath = undefined) {
+        this.configPath = configPath || resolveConfigPath("consent.json") || path.join(getConfigDir(), "consent.json");
+    }
+    /**
+     * Initialize consent manager - load existing config or create default
+     */
+    async initialize() {
+        try {
+            await this.loadConfig();
+            if (!this.config) {
+                // Create default disabled configuration
+                this.config = this.createDefaultConfig();
+                await this.saveConfig();
+            }
+            return this.config;
+        }
+        catch (error) {
+            // If config doesn't exist, create default
+            this.config = this.createDefaultConfig();
+            await this.saveConfig();
+            return this.config;
+        }
+    }
+    /**
+     * Enable analytics (opt-in)
+     */
+    async enableConsent(categories) {
+        if (!this.config) {
+            await this.initialize();
+        }
+        if (!this.config) {
+            throw new Error("Failed to initialize consent configuration");
+        }
+        // Enable all categories if none specified
+        const categoriesToEnable = categories || Object.keys(this.config.categories);
+        // Enable main analytics flag
+        this.config.analyticsEnabled = true;
+        this.config.consentDate = new Date();
+        this.config.consentVersion = "1.0";
+        // Enable specified categories
+        categoriesToEnable.forEach(cat => {
+            if (this.config && cat in this.config.categories) {
+                this.config.categories[cat] = true;
+            }
+        });
+        // Generate project ID if not exists
+        if (!this.config.projectId || this.config.projectId === "") {
+            this.config.projectId = this.generateProjectId();
+        }
+        await this.saveConfig();
+    }
+    /**
+     * Disable analytics (opt-out)
+     */
+    async disableConsent() {
+        if (!this.config) {
+            await this.initialize();
+        }
+        if (!this.config) {
+            throw new Error("Failed to initialize consent configuration");
+        }
+        // Disable all analytics
+        this.config.analyticsEnabled = false;
+        this.config.lastOptOut = new Date();
+        // Disable all categories
+        Object.keys(this.config.categories).forEach(cat => {
+            this.config.categories[cat] = false;
+        });
+        await this.saveConfig();
+        // Clear submission queue
+        await this.clearSubmissionQueue();
+    }
+    /**
+     * Check if submission is allowed for a category
+     */
+    canSubmit(category) {
+        if (!this.config) {
+            return false;
+        }
+        return this.config.analyticsEnabled &&
+            this.config.categories[category] === true;
+    }
+    /**
+     * Get current consent status
+     */
+    async getStatus() {
+        if (!this.config) {
+            await this.initialize();
+        }
+        if (!this.config) {
+            throw new Error("Failed to load consent configuration");
+        }
+        return { ...this.config };
+    }
+    /**
+     * Enable specific category
+     */
+    async enableCategory(category) {
+        if (!this.config) {
+            await this.initialize();
+        }
+        if (!this.config || !(category in this.config.categories)) {
+            throw new Error(`Invalid category: ${category}`);
+        }
+        this.config.categories[category] = true;
+        await this.saveConfig();
+    }
+    /**
+     * Disable specific category
+     */
+    async disableCategory(category) {
+        if (!this.config) {
+            await this.initialize();
+        }
+        if (!this.config || !(category in this.config.categories)) {
+            throw new Error(`Invalid category: ${category}`);
+        }
+        this.config.categories[category] = false;
+        await this.saveConfig();
+    }
+    /**
+     * Get all categories with their status
+     */
+    getCategories() {
+        if (!this.config) {
+            return [];
+        }
+        const categoryInfo = {
+            reflections: "Anonymized reflection data for pattern learning",
+            logs: "Framework activity logs for performance analysis",
+            metrics: "Agent performance and routing metrics",
+            patterns: "P9 pattern learning data and insights"
+        };
+        return Object.entries(this.config.categories).map(([name, enabled]) => ({
+            name,
+            description: categoryInfo[name] || "",
+            enabled: enabled
+        }));
+    }
+    /**
+     * Generate anonymous project ID
+     */
+    generateProjectId() {
+        // Generate UUID-like identifier
+        const timestamp = Date.now().toString(36);
+        const random = Math.random().toString(36).substring(2, 8);
+        return `project-${timestamp}-${random}`;
+    }
+    /**
+     * Create default disabled configuration
+     */
+    createDefaultConfig() {
+        return {
+            analyticsEnabled: false,
+            consentDate: new Date(),
+            consentVersion: "1.0",
+            lastOptOut: undefined,
+            categories: {
+                reflections: false,
+                logs: false,
+                metrics: false,
+                patterns: false
+            },
+            projectId: this.generateProjectId()
+        };
+    }
+    /**
+     * Load configuration from file
+     */
+    async loadConfig() {
+        try {
+            const configData = await fs.readFile(this.configPath, "utf-8");
+            this.config = JSON.parse(configData);
+            // Convert date strings back to Date objects
+            if (this.config.consentDate) {
+                this.config.consentDate = new Date(this.config.consentDate);
+            }
+            if (this.config.lastOptOut) {
+                this.config.lastOptOut = new Date(this.config.lastOptOut);
+            }
+        }
+        catch (error) {
+            // Config doesn't exist or is invalid
+            this.config = null;
+        }
+    }
+    /**
+     * Save configuration to file
+     */
+    async saveConfig() {
+        if (!this.config) {
+            throw new Error("No configuration to save");
+        }
+        // Ensure directory exists
+        const configDir = path.dirname(this.configPath);
+        try {
+            await fs.mkdir(configDir, { recursive: true });
+        }
+        catch {
+            // Directory already exists
+        }
+        await fs.writeFile(this.configPath, JSON.stringify(this.config, null, 2), "utf-8");
+    }
+    /**
+     * Clear submission queue
+     */
+    async clearSubmissionQueue() {
+        const queuePath = path.join(path.dirname(this.configPath), "analytics", "submission-queue.json");
+        try {
+            await fs.writeFile(queuePath, "[]", "utf-8");
+            this.submissionQueue = [];
+        }
+        catch (error) {
+            // Queue directory doesn't exist yet, which is fine
+        }
+    }
+    /**
+     * Add item to submission queue
+     */
+    async queueSubmission(data) {
+        if (!this.canSubmit("all")) {
+            throw new Error("Analytics is disabled or category not enabled");
+        }
+        this.submissionQueue.push(data);
+        await this.saveSubmissionQueue();
+    }
+    /**
+     * Save submission queue to file
+     */
+    async saveSubmissionQueue() {
+        const queueDir = path.join(path.dirname(this.configPath), "analytics");
+        const queuePath = path.join(queueDir, "submission-queue.json");
+        try {
+            await fs.mkdir(queueDir, { recursive: true });
+            await fs.writeFile(queuePath, JSON.stringify(this.submissionQueue, null, 2), "utf-8");
+        }
+        catch (error) {
+            frameworkLogger.log("consent-manager", "save-queue-failed", "error", { error, message: "Failed to save submission queue" });
+        }
+    }
+}