0xray 4.0.13 → 4.0.15

package/dist/enforcement/validators/validator-registry.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Validator Registry
+ *
+ * Central registry for all validator instances. Provides lookup by rule ID
+ * and category filtering capabilities.
+ *
+ * @module validators/validator-registry
+ */
+import { IValidator, IValidatorRegistry, RuleCategory } from "../types.js";
+/**
+ * Implementation of the validator registry.
+ * Manages validator instances in a Map for O(1) lookup by rule ID.
+ * Auto-registers all validators on construction for facade simplicity.
+ *
+ * @example
+ * ```typescript
+ * const registry = new ValidatorRegistry();
+ * const validator = registry.getValidator('no-duplicate-code')!;
+ * const result = await validator.validate(context);
+ * ```
+ */
+export declare class ValidatorRegistry implements IValidatorRegistry {
+    /** Internal map storing validators by rule ID */
+    private validators;
+    /**
+     * Creates a new ValidatorRegistry and auto-registers all validators.
+     */
+    constructor();
+    /**
+     * Auto-register all validators.
+     * Called automatically on construction.
+     */
+    private registerAllValidators;
+    /**
+     * Register a validator instance.
+     * The validator is keyed by its ruleId property.
+     *
+     * @param validator - The validator instance to register
+     * @throws Error if a validator for this ruleId already exists
+     */
+    register(validator: IValidator): void;
+    /**
+     * Get a validator by rule ID.
+     *
+     * @param ruleId - The rule ID to look up
+     * @returns The validator instance or undefined if not found
+     */
+    getValidator(ruleId: string): IValidator | undefined;
+    /**
+     * Get all validators for a specific category.
+     *
+     * @param category - The category to filter by
+     * @returns Array of validators in that category
+     */
+    getValidatorsByCategory(category: RuleCategory): IValidator[];
+    /**
+     * Get all registered validators.
+     *
+     * @returns Array of all registered validators
+     */
+    getAllValidators(): IValidator[];
+    /**
+     * Check if a validator exists for a rule ID.
+     *
+     * @param ruleId - The rule ID to check
+     * @returns True if a validator exists, false otherwise
+     */
+    hasValidator(ruleId: string): boolean;
+    /**
+     * Remove a validator from the registry.
+     *
+     * @param ruleId - The rule ID of the validator to remove
+     * @returns True if a validator was removed, false if not found
+     */
+    unregister(ruleId: string): boolean;
+    /**
+     * Clear all validators from the registry.
+     */
+    clear(): void;
+    /**
+     * Get the count of registered validators.
+     *
+     * @returns Number of registered validators
+     */
+    getCount(): number;
+}
+/**
+ * Singleton instance of the validator registry.
+ * Use this for global validator management.
+ */
+export declare const globalValidatorRegistry: ValidatorRegistry;

package/dist/enforcement/validators/validator-registry.js

@@ -0,0 +1,149 @@
+/**
+ * Validator Registry
+ *
+ * Central registry for all validator instances. Provides lookup by rule ID
+ * and category filtering capabilities.
+ *
+ * @module validators/validator-registry
+ */
+import { NoDuplicateCodeValidator, ContextAnalysisIntegrationValidator, MemoryOptimizationValidator, DocumentationRequiredValidator, NoOverEngineeringValidator, CleanDebugLogsValidator, ConsoleLogUsageValidator, } from "./code-quality-validators.js";
+import { InputValidationValidator, SecurityByDesignValidator, } from "./security-validators.js";
+import { TestsRequiredValidator, TestCoverageValidator, ContinuousIntegrationValidator, TestFailureReportingValidator, PerformanceRegressionReportingValidator, SecurityVulnerabilityReportingValidator, } from "./testing-validators.js";
+import { DependencyManagementValidator, SrcDistIntegrityValidator, ImportConsistencyValidator, ModuleSystemConsistencyValidator, ErrorResolutionValidator, LoopSafetyValidator, StateManagementPatternsValidator, SingleResponsibilityValidator, DeploymentSafetyValidator, MultiAgentEnsembleValidator, SubstrateExternalizationValidator, FrameworkSelfValidationValidator, EmergentImprovementValidator, } from "./architecture-validators.js";
+/**
+ * Implementation of the validator registry.
+ * Manages validator instances in a Map for O(1) lookup by rule ID.
+ * Auto-registers all validators on construction for facade simplicity.
+ *
+ * @example
+ * ```typescript
+ * const registry = new ValidatorRegistry();
+ * const validator = registry.getValidator('no-duplicate-code')!;
+ * const result = await validator.validate(context);
+ * ```
+ */
+export class ValidatorRegistry {
+    /** Internal map storing validators by rule ID */
+    validators = new Map();
+    /**
+     * Creates a new ValidatorRegistry and auto-registers all validators.
+     */
+    constructor() {
+        this.registerAllValidators();
+    }
+    /**
+     * Auto-register all validators.
+     * Called automatically on construction.
+     */
+    registerAllValidators() {
+        // Code Quality Validators
+        this.register(new NoDuplicateCodeValidator());
+        this.register(new ContextAnalysisIntegrationValidator());
+        this.register(new MemoryOptimizationValidator());
+        this.register(new DocumentationRequiredValidator());
+        this.register(new NoOverEngineeringValidator());
+        this.register(new CleanDebugLogsValidator());
+        this.register(new ConsoleLogUsageValidator());
+        // Security Validators
+        this.register(new InputValidationValidator());
+        this.register(new SecurityByDesignValidator());
+        // Testing Validators
+        this.register(new TestsRequiredValidator());
+        this.register(new TestCoverageValidator());
+        this.register(new ContinuousIntegrationValidator());
+        this.register(new TestFailureReportingValidator());
+        // Architecture Validators
+        this.register(new DependencyManagementValidator());
+        this.register(new SrcDistIntegrityValidator());
+        this.register(new ImportConsistencyValidator());
+        this.register(new ModuleSystemConsistencyValidator());
+        this.register(new ErrorResolutionValidator());
+        this.register(new LoopSafetyValidator());
+        this.register(new StateManagementPatternsValidator());
+        this.register(new SingleResponsibilityValidator());
+        this.register(new DeploymentSafetyValidator());
+        this.register(new MultiAgentEnsembleValidator());
+        this.register(new SubstrateExternalizationValidator());
+        this.register(new FrameworkSelfValidationValidator());
+        this.register(new EmergentImprovementValidator());
+        // Reporting Validators
+        this.register(new PerformanceRegressionReportingValidator());
+        this.register(new SecurityVulnerabilityReportingValidator());
+    }
+    /**
+     * Register a validator instance.
+     * The validator is keyed by its ruleId property.
+     *
+     * @param validator - The validator instance to register
+     * @throws Error if a validator for this ruleId already exists
+     */
+    register(validator) {
+        if (this.validators.has(validator.ruleId)) {
+            throw new Error(`Validator for rule '${validator.ruleId}' is already registered`);
+        }
+        this.validators.set(validator.ruleId, validator);
+    }
+    /**
+     * Get a validator by rule ID.
+     *
+     * @param ruleId - The rule ID to look up
+     * @returns The validator instance or undefined if not found
+     */
+    getValidator(ruleId) {
+        return this.validators.get(ruleId);
+    }
+    /**
+     * Get all validators for a specific category.
+     *
+     * @param category - The category to filter by
+     * @returns Array of validators in that category
+     */
+    getValidatorsByCategory(category) {
+        return Array.from(this.validators.values()).filter((validator) => validator.category === category);
+    }
+    /**
+     * Get all registered validators.
+     *
+     * @returns Array of all registered validators
+     */
+    getAllValidators() {
+        return Array.from(this.validators.values());
+    }
+    /**
+     * Check if a validator exists for a rule ID.
+     *
+     * @param ruleId - The rule ID to check
+     * @returns True if a validator exists, false otherwise
+     */
+    hasValidator(ruleId) {
+        return this.validators.has(ruleId);
+    }
+    /**
+     * Remove a validator from the registry.
+     *
+     * @param ruleId - The rule ID of the validator to remove
+     * @returns True if a validator was removed, false if not found
+     */
+    unregister(ruleId) {
+        return this.validators.delete(ruleId);
+    }
+    /**
+     * Clear all validators from the registry.
+     */
+    clear() {
+        this.validators.clear();
+    }
+    /**
+     * Get the count of registered validators.
+     *
+     * @returns Number of registered validators
+     */
+    getCount() {
+        return this.validators.size;
+    }
+}
+/**
+ * Singleton instance of the validator registry.
+ * Use this for global validator management.
+ */
+export const globalValidatorRegistry = new ValidatorRegistry();

package/dist/execution/opencode-cli-invoker.d.ts

@@ -0,0 +1,8 @@
+/**
+ * OpenCode CLI Invoker (thin execution helper)
+ *
+ * Thin OpenCode fallback path under the three-subsystem Engine.
+ * Owned by Autonomous Engine. All direct child_process and agent spawn execution here.
+ * InferenceCycle is pure sensing + proposal + governance orchestration.
+ */
+export declare function invokeViaOpencode(agentName: string, prompt: string, projectRoot?: string): Promise<string>;

package/dist/execution/opencode-cli-invoker.js

@@ -0,0 +1,173 @@
+/**
+ * OpenCode CLI Invoker (thin execution helper)
+ *
+ * Thin OpenCode fallback path under the three-subsystem Engine.
+ * Owned by Autonomous Engine. All direct child_process and agent spawn execution here.
+ * InferenceCycle is pure sensing + proposal + governance orchestration.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { execSync, spawn } from "child_process";
+import { frameworkLogger } from "../core/framework-logger.js";
+import { getAgentSpawn } from "../core/features-config.js";
+import { spawnGate } from "../core/agent-spawn-gate.js";
+import { agentSpawnGovernor } from "../orchestrator/agent-spawn-governor.js";
+import { getConfigDir } from "../core/config-paths.js";
+// Module-level cache for opencode availability check
+let opencodeAvailable = null;
+export async function invokeViaOpencode(agentName, prompt, projectRoot = process.cwd()) {
+    // In pure MCP mode we must never reach here
+    if (process.env.XRAY_FORCE_MCP_GOVERNANCE === "true") {
+        throw new Error(`[PURE MCP] invokeViaOpencode called for "${agentName}" — this path is forbidden.`);
+    }
+    // GATE: Centralized spawn gate — blocks all agent spawning by default
+    spawnGate.assertAllowed("opencode-cli-invoker");
+    // BLOCKED: Never spawn real opencode processes during tests — causes
+    // runaway agent processes and non-deterministic test behavior.
+    if (process.env.NODE_ENV === "test" || process.env.VITEST) {
+        throw new Error(`Agent spawning is disabled in test environment. ` +
+            `Agent "${agentName}" cannot be spawned during tests.`);
+    }
+    // GOVERNED: Auto-spawning of OpenCode agents is now protected by the
+    // AgentSpawnGovernor singleton and the agent_spawn feature flag.
+    const spawnConfig = getAgentSpawn();
+    if (!spawnConfig?.enabled) {
+        throw new Error(`Auto-spawning of OpenCode agents is disabled. ` +
+            `Agent "${agentName}" cannot be spawned automatically. ` +
+            `Set agent_spawn.enabled=true in features.json to re-enable.`);
+    }
+    // Authorize spawn via the singleton governor
+    const auth = await agentSpawnGovernor.authorizeSpawn({
+        agentType: agentName,
+        operation: "inference-cycle-invoke",
+    });
+    if (!auth.authorized) {
+        throw new Error(`Spawn denied by governance for "${agentName}": ${auth.reason}`);
+    }
+    const trackingId = auth.trackingId;
+    if (opencodeAvailable === null) {
+        try {
+            execSync("which opencode", { stdio: "pipe", timeout: 3000 });
+            opencodeAvailable = true;
+        }
+        catch {
+            opencodeAvailable = false;
+        }
+    }
+    if (!opencodeAvailable) {
+        if (trackingId)
+            await agentSpawnGovernor.failSpawn(trackingId, new Error("opencode CLI not available"));
+        throw new Error("opencode CLI is not available in PATH");
+    }
+    // Resolve the actual opencode project root (where .opencode/ config lives)
+    const opencodeRoot = resolveOpencodeRoot(projectRoot);
+    frameworkLogger.log("inference-cycle", "opencode-spawn-start", "info", {
+        agentName,
+        trackingId,
+        opencodeRoot,
+    });
+    // getExecutionCoordinator/execution-planner removed per v2 cleanup — warning log only
+    frameworkLogger.log('execution', 'opencode-invocation-mediation-skipped', 'warning', {
+        reason: 'execution-planner removed (opencode invocation continues via fallback)',
+        agentName,
+    });
+    return new Promise((resolve, reject) => {
+        const timeout = agentName === "architect" ? 300000 : 120000;
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                child.kill("SIGKILL");
+                if (trackingId) {
+                    agentSpawnGovernor.failSpawn(trackingId, new Error(`opencode ${agentName} timed out`)).catch(() => { });
+                }
+                reject(new Error(`opencode ${agentName} timed out`));
+            }
+        }, timeout);
+        const child = spawn("opencode", ["run", "--agent", agentName, "--message", prompt, "--format", "json"], {
+            cwd: opencodeRoot,
+            env: { ...process.env, NODE_ENV: "production", OPENCODE_MCP_CONFIG: "./node_modules/0xray/opencode.json" },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        child.stdout?.on("data", (d) => {
+            stdout += d.toString();
+        });
+        child.stderr?.on("data", () => {
+            /* ignore */
+        });
+        child.on("close", async (code) => {
+            clearTimeout(timer);
+            if (settled)
+                return;
+            settled = true;
+            if (code === 0 && stdout.trim()) {
+                if (trackingId) {
+                    await agentSpawnGovernor.completeSpawn(trackingId, true).catch(() => { });
+                }
+                frameworkLogger.log("inference-cycle", "opencode-spawn-success", "info", { agentName, trackingId });
+                const textResponse = extractTextFromNdjson(stdout.trim());
+                if (textResponse) {
+                    resolve(textResponse);
+                }
+                else {
+                    resolve(stdout.trim());
+                }
+            }
+            else {
+                const error = new Error(`${agentName} exited ${code}`);
+                if (trackingId) {
+                    await agentSpawnGovernor.failSpawn(trackingId, error).catch(() => { });
+                }
+                frameworkLogger.log("inference-cycle", "opencode-spawn-failed", "error", { agentName, trackingId, code });
+                reject(error);
+            }
+        });
+        child.on("error", async (err) => {
+            clearTimeout(timer);
+            if (!settled) {
+                settled = true;
+                if (trackingId) {
+                    await agentSpawnGovernor.failSpawn(trackingId, err).catch(() => { });
+                }
+                frameworkLogger.log("inference-cycle", "opencode-spawn-error", "error", { agentName, trackingId, error: err.message });
+                reject(err);
+            }
+        });
+    });
+}
+function extractTextFromNdjson(output) {
+    const texts = [];
+    for (const line of output.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const obj = JSON.parse(trimmed);
+            if (obj.type === "text" && obj.part?.text) {
+                texts.push(obj.part.text);
+            }
+        }
+        catch {
+            // skip non-JSON lines
+        }
+    }
+    return texts.join("\n").trim();
+}
+function resolveOpencodeRoot(projectRoot) {
+    const configDir = getConfigDir(projectRoot);
+    let dir = projectRoot;
+    for (let i = 0; i < 10; i++) {
+        if (fs.existsSync(path.join(dir, ".opencode")))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    const cwd = process.cwd();
+    if (fs.existsSync(path.join(cwd, ".opencode")))
+        return cwd;
+    return projectRoot;
+}
+// OpenCode execution owned by Autonomous Engine (thin fallback).

package/dist/execution/proposal-applier.d.ts

@@ -0,0 +1,24 @@
+import type { InferenceProposal } from "../inference/inference-cycle.js";
+export interface ApplyResult {
+    proposalId: string;
+    success: boolean;
+    filesChanged?: string[];
+    details?: string[];
+    error?: string;
+}
+export type CodeChangeCallback = (proposal: InferenceProposal) => Promise<boolean>;
+export type ReviewCallback = (proposal: InferenceProposal, prUrl: string) => Promise<"go" | "no-go" | "modify">;
+export declare class ProposalApplier {
+    private projectRoot;
+    private codeChangeCallback?;
+    private reviewCallback?;
+    constructor(projectRoot?: string, codeChangeCallback?: CodeChangeCallback | undefined, reviewCallback?: ReviewCallback | undefined);
+    applyProposals(proposals: InferenceProposal[]): Promise<ApplyResult[]>;
+    private applyProposal;
+    private applyCodification;
+    private isInsideGitRepo;
+    private getAppliedMarkerPath;
+    private recordAppliedProposal;
+    private createPR;
+}
+export declare const proposalApplier: ProposalApplier;