0xray 3.0.11 → 3.0.14

package/dist/orchestrator/universal-librarian-consultation.js

@@ -0,0 +1,216 @@
+/**
+ * Universal Librarian Consultation System
+ * Ensures researcher is involved in all major system actions for documentation and versioning
+ */
+import { frameworkLogger } from "../core/framework-logger.js";
+import { resolveConfigPath } from "../core/config-paths.js";
+export class UniversalLibrarianConsultation {
+    ruleEnforcer;
+    constructor(ruleEnforcer) {
+        this.ruleEnforcer = ruleEnforcer;
+    }
+    /**
+     * Pre-action consultation - must be called before any major system action
+     */
+    async consultBeforeAction(action) {
+        await frameworkLogger.log("universal-librarian-consultation", "pre-action-consultation-started", "info", {
+            actionType: action.type,
+            scope: action.scope,
+            complexity: action.complexity,
+        });
+        // Prevent recursive consultation loops (researcher operations triggering more researcher consultations)
+        if (this.isLibrarianOperation(action)) {
+            await frameworkLogger.log("universal-librarian-consultation", "pre-action-consultation-skipped", "info", {
+                reason: "researcher operation detected - skipping to prevent recursion",
+                actionType: action.type,
+                scope: action.scope,
+            });
+            return {
+                approved: true,
+                documentationImpact: "none",
+                versionUpdates: [],
+                recommendations: [],
+                pairProgrammingRequired: false,
+            };
+        }
+        const documentationImpact = this.assessDocumentationImpact(action);
+        const versionUpdates = await this.determineVersionUpdates(action);
+        const pairProgrammingRequired = this.requiresPairProgramming(action);
+        const recommendations = this.generateRecommendations(action, documentationImpact);
+        const approved = action.complexity !== "critical" || documentationImpact !== "critical";
+        const result = {
+            approved,
+            documentationImpact,
+            versionUpdates,
+            recommendations,
+            pairProgrammingRequired,
+        };
+        await frameworkLogger.log("universal-librarian-consultation", "pre-action-consultation-completed", approved ? "success" : "error", {
+            approved,
+            documentationImpact,
+            versionUpdatesCount: versionUpdates.length,
+            pairProgrammingRequired,
+        });
+        return result;
+    }
+    /**
+     * Post-action consultation - must be called after any major system action
+     */
+    async consultAfterAction(action, result) {
+        await frameworkLogger.log("universal-librarian-consultation", "post-action-consultation-started", "info", {
+            actionType: action.type,
+            scope: action.scope,
+            result: result ? "success" : "failure",
+        });
+        await this.updateDocumentation(action, result);
+        await this.updateVersions(action, result);
+        await this.validateDocumentationIntegrity(action);
+        await frameworkLogger.log("universal-librarian-consultation", "post-action-consultation-completed", "success", {
+            actionType: action.type,
+            scope: action.scope,
+            documentationUpdated: true,
+            versionsUpdated: true,
+        });
+    }
+    /**
+     * Check if this action is related to researcher operations (to prevent recursion)
+     */
+    isLibrarianOperation(action) {
+        return (action.scope === "documentation" ||
+            (action.type === "rule-modification" &&
+                action.description.includes("researcher")) ||
+            action.metadata?.triggeredBy === "researcher" ||
+            action.description.includes("researcher consultation"));
+    }
+    /**
+     * Assess documentation impact of the action
+     */
+    assessDocumentationImpact(action) {
+        if (action.scope === "documentation") {
+            return action.complexity === "critical" ? "critical" : "major";
+        }
+        if (action.scope === "framework" && action.complexity === "high") {
+            return "major";
+        }
+        if (action.scope === "agent" || action.scope === "tool") {
+            return action.complexity === "low" ? "minor" : "major";
+        }
+        if (action.scope === "configuration" && action.complexity === "high") {
+            return "major";
+        }
+        return "none";
+    }
+    /**
+     * Determine what version updates are needed
+     */
+    async determineVersionUpdates(action) {
+        const updates = [];
+        if (action.type === "rule-modification" || action.scope === "framework") {
+            const codexPath = resolveConfigPath("codex.json") || "codex.json";
+            updates.push({
+                file: codexPath,
+                field: "version",
+                oldVersion: "1.1.1",
+                newVersion: "1.1.2",
+                reason: `Updated for ${action.type}: ${action.description}`,
+            });
+        }
+        if (action.complexity === "critical") {
+            updates.push({
+                file: "package.json",
+                field: "version",
+                oldVersion: "1.1.1",
+                newVersion: "1.1.2",
+                reason: `Major ${action.scope} changes: ${action.description}`,
+            });
+        }
+        return updates;
+    }
+    /**
+     * Check if pair programming with researcher is required
+     */
+    requiresPairProgramming(action) {
+        return (action.complexity === "critical" ||
+            action.scope === "framework" ||
+            action.type === "architectural-change" ||
+            action.type === "rule-modification");
+    }
+    /**
+     * Generate recommendations for the action
+     */
+    generateRecommendations(action, documentationImpact) {
+        const recommendations = [];
+        if (documentationImpact === "major" || documentationImpact === "critical") {
+            recommendations.push("Update architecture documentation");
+            recommendations.push("Update API documentation if interfaces changed");
+            recommendations.push("Update README.md with new capabilities");
+        }
+        if (action.type === "rule-modification") {
+            recommendations.push("Ensure rule mappings are updated in agent-delegator");
+            recommendations.push("Update AGENTS.md with any new enforceable rules");
+        }
+        if (action.scope === "agent") {
+            recommendations.push("Update agent capability documentation");
+            recommendations.push("Verify agent tool mappings are complete");
+        }
+        if (action.complexity === "critical") {
+            recommendations.push("Consider updating version to indicate breaking changes");
+            recommendations.push("Update changelog with major changes");
+        }
+        return recommendations;
+    }
+    /**
+     * Update documentation after action completion
+     */
+    async updateDocumentation(action, _result) {
+        await frameworkLogger.log("universal-librarian-consultation", "documentation-update-triggered", "info", {
+            actionType: action.type,
+            scope: action.scope,
+            filesToUpdate: this.determineDocumentationFiles(action),
+        });
+    }
+    /**
+     * Update versions after action completion
+     */
+    async updateVersions(action, _result) {
+        await frameworkLogger.log("universal-librarian-consultation", "version-update-triggered", "info", {
+            actionType: action.type,
+            scope: action.scope,
+            versionUpdates: await this.determineVersionUpdates(action),
+        });
+    }
+    /**
+     * Validate documentation integrity
+     */
+    async validateDocumentationIntegrity(action) {
+        await frameworkLogger.log("universal-librarian-consultation", "documentation-integrity-validation", "info", {
+            actionType: action.type,
+            scope: action.scope,
+            validationPerformed: true,
+        });
+    }
+    /**
+     * Determine which documentation files need updating
+     */
+    determineDocumentationFiles(action) {
+        const files = [];
+        if (action.scope === "framework") {
+            files.push("README.md", "docs/ARCHITECTURE.md", "AGENTS.md");
+        }
+        if (action.scope === "agent") {
+            files.push("AGENTS.md", "docs/agent-capabilities.md");
+        }
+        if (action.scope === "tool") {
+            files.push("docs/tool-integration.md");
+        }
+        if (action.type === "rule-modification") {
+            files.push("AGENTS.md", "docs/rule-enforcement.md");
+        }
+        if (action.type === "architectural-change") {
+            files.push("docs/ARCHITECTURE.md", "docs/architectural-decisions.md");
+        }
+        return files;
+    }
+}
+// Export singleton instance
+export const universalLibrarianConsultation = new UniversalLibrarianConsultation(null);

package/dist/orchestrator/universal-registry-bridge.js

@@ -0,0 +1,247 @@
+/**
+ * Universal Registry Bridge
+ *
+ * Connects 0xRay to external agent registries.
+ * Enables dynamic agent configuration loading from external sources.
+ *
+ * @version 1.0.0
+ * @since 2026-02-14
+ */
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { resolve, dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { frameworkLogger } from "../core/framework-logger.js";
+import { getConfigDir } from "../core/config-paths.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export class UniversalRegistryBridge {
+    registries;
+    cacheDir;
+    autoRefresh;
+    cache = new Map();
+    logger = frameworkLogger;
+    constructor(options) {
+        this.registries = options.registries || [];
+        this.cacheDir =
+            options.cacheDir || join(getConfigDir(), "registry-cache");
+        this.autoRefresh = options.autoRefresh ?? true;
+    }
+    /**
+     * Load agents from all configured registries
+     */
+    async loadAgents() {
+        const allAgents = [];
+        for (const registry of this.registries) {
+            try {
+                const agents = await this.fetchFromRegistry(registry);
+                allAgents.push(...agents);
+                this.logger.log("universal-registry-bridge", `Loaded ${agents.length} agents from ${registry.type} registry: ${registry.location}`, "info");
+            }
+            catch (error) {
+                this.logger.log("universal-registry-bridge", `Failed to load from registry ${registry.location}: ${error}`, "info");
+            }
+        }
+        return allAgents;
+    }
+    /**
+     * Fetch agents from a specific registry
+     */
+    async fetchFromRegistry(registry) {
+        // Check cache first
+        const cacheKey = `${registry.type}:${registry.location}`;
+        const cached = this.cache.get(cacheKey);
+        if (cached && !this.autoRefresh) {
+            return cached;
+        }
+        let agents;
+        switch (registry.type) {
+            case "file":
+                agents = await this.loadFromFile(registry.location);
+                break;
+            case "http":
+                agents = await this.loadFromHttp(registry.location);
+                break;
+            case "npm":
+                agents = await this.loadFromNpm(registry.location);
+                break;
+            default:
+                this.logger.log("universal-registry-bridge", `Unknown registry type: ${registry.type}`, "info");
+                return [];
+        }
+        this.cache.set(cacheKey, agents);
+        return agents;
+    }
+    /**
+     * Load agents from a local file
+     */
+    async loadFromFile(location) {
+        const filePath = resolve(location);
+        if (!existsSync(filePath)) {
+            throw new Error(`Registry file not found: ${filePath}`);
+        }
+        const content = await readFile(filePath, "utf-8");
+        const ext = location.toLowerCase();
+        if (ext.endsWith(".json")) {
+            return JSON.parse(content);
+        }
+        else if (ext.endsWith(".yaml") || ext.endsWith(".yml")) {
+            // Simple YAML parser for agent definitions
+            return this.parseYamlAgents(content);
+        }
+        throw new Error(`Unsupported file format: ${location}`);
+    }
+    /**
+     * Simple YAML parser for agent definitions
+     * Handles basic agent registry format
+     */
+    parseYamlAgents(content) {
+        const agents = [];
+        const lines = content.split("\n");
+        let currentAgent = null;
+        let inAgent = false;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith("agents:")) {
+                continue;
+            }
+            // Check for new agent entry (name: xxx)
+            const nameMatch = trimmed.match(/^-\s*name:\s*(.+)$/);
+            if (nameMatch && nameMatch[1]) {
+                if (inAgent && currentAgent) {
+                    agents.push(currentAgent);
+                }
+                currentAgent = {
+                    name: nameMatch[1].trim(),
+                    description: "",
+                    version: "1.22.67",
+                };
+                inAgent = true;
+                continue;
+            }
+            if (inAgent && currentAgent) {
+                const descMatch = trimmed.match(/^description:\s*(.+)$/);
+                if (descMatch && descMatch[1]) {
+                    currentAgent.description = descMatch[1].trim();
+                    continue;
+                }
+                const versionMatch = trimmed.match(/^version:\s*(.+)$/);
+                if (versionMatch && versionMatch[1]) {
+                    currentAgent.version = versionMatch[1].trim();
+                    continue;
+                }
+            }
+        }
+        // Push last agent
+        if (inAgent && currentAgent) {
+            agents.push(currentAgent);
+        }
+        return agents;
+    }
+    /**
+     * Load agents from HTTP endpoint
+     */
+    async loadFromHttp(location) {
+        try {
+            const response = await fetch(location);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch from ${location}: ${error}`);
+        }
+    }
+    /**
+     * Load agents from npm package
+     */
+    async loadFromNpm(packageName) {
+        try {
+            const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
+            if (!response.ok) {
+                throw new Error(`npm API error: ${response.status}`);
+            }
+            const pkg = await response.json();
+            // Look for agent definitions in package exports
+            if (pkg.stringray?.agents) {
+                return pkg.stringray.agents;
+            }
+            return [];
+        }
+        catch (error) {
+            throw new Error(`Failed to load npm package ${packageName}: ${error}`);
+        }
+    }
+    /**
+     * Convert registry definition to AgentConfig
+     */
+    toAgentConfig(registryDef) {
+        return {
+            name: registryDef.name,
+            description: registryDef.description,
+            capabilities: registryDef.capabilities || [],
+        };
+    }
+    /**
+     * Get cached agents from a specific registry
+     */
+    getCached(registryType, location) {
+        return this.cache.get(`${registryType}:${location}`);
+    }
+    /**
+     * Clear the cache
+     */
+    clearCache() {
+        this.cache.clear();
+        this.logger.log("universal-registry-bridge", "Registry cache cleared", "info");
+    }
+    /**
+     * Add a new registry dynamically
+     */
+    addRegistry(registry) {
+        this.registries.push(registry);
+        this.logger.log("universal-registry-bridge", `Added registry: ${registry.type}:${registry.location}`, "info");
+    }
+    /**
+     * Get all configured registries
+     */
+    getRegistries() {
+        return [...this.registries];
+    }
+}
+/**
+ * Create a bridge from integration config
+ */
+export async function createRegistryBridge(configPath) {
+    const defaultPath = resolve(process.cwd(), ".stringray/integration/registries.json");
+    const path = configPath || defaultPath;
+    let registries = [];
+    if (existsSync(path)) {
+        try {
+            const content = await readFile(path, "utf-8");
+            const config = JSON.parse(content);
+            registries = config.registries || [];
+        }
+        catch (error) {
+            frameworkLogger.log("universal-registry-bridge", `Failed to load registry config from ${path}: ${error}`, "info");
+        }
+    }
+    return new UniversalRegistryBridge({
+        registries,
+        autoRefresh: true,
+    });
+}
+/**
+ * Default bridge instance for quick access
+ */
+let defaultBridge = null;
+export function getDefaultBridge() {
+    if (!defaultBridge) {
+        defaultBridge = new UniversalRegistryBridge({
+            registries: [],
+            autoRefresh: false,
+        });
+    }
+    return defaultBridge;
+}