0xray 3.0.14 → 3.1.0

package/dist/index.js

@@ -4,17 +4,17 @@
  * This is the main entry point for the 0xRay framework.
  * It exports the core initialization function and key components.
  */
-export { StringRayOrchestrator } from "./orchestrator/orchestrator.js";
-export { StringRayStateManager } from "./state/index.js";
+export { XrayOrchestrator, StringRayOrchestrator } from "./orchestrator/orchestrator.js";
+export { XrayStateManager, StringRayStateManager } from "./state/index.js";
 export { AgentDelegator } from "./delegation/index.js";
 export { frameworkLogger } from "./core/framework-logger.js";
 export { BUILTIN_CODEX } from "./core/codex-formatter.js";
-import { defaultStringRayConfig } from "./core/index.js";
-export { defaultStringRayConfig };
+import { defaultXrayConfig } from "./core/index.js";
+export { defaultXrayConfig, defaultXrayConfig as defaultStringRayConfig };
 export { OpenClawIntegration, initializeOpenClawIntegration, getOpenClawIntegration, shutdownOpenClawIntegration } from "./integrations/openclaw/index.js";
 // Main initialization function
-export function initializeStringRay(config = {}) {
-    const mergedConfig = { ...defaultStringRayConfig, ...config };
+export function initializeXray(config = {}) {
+    const mergedConfig = { ...defaultXrayConfig, ...config };
     // Return a standardized initialization result
     return {
         success: true,
@@ -22,3 +22,5 @@ export function initializeStringRay(config = {}) {
         message: "0xRay framework initialized successfully",
     };
 }
+// Backward compat alias
+export { initializeXray as initializeStringRay };

package/dist/inference/deploy-verifier.js

@@ -43,7 +43,7 @@ export class DeployVerifier {
         if (!packCheck.passed) {
             return this.result(false, version, tarballPath, installDir, checks, startTime);
         }
-        installDir = fs.mkdtempSync(path.join(os.tmpdir(), "strray-deploy-verify-"));
+        installDir = fs.mkdtempSync(path.join(os.tmpdir(), "xray-deploy-verify-"));
         const installCheck = this.runCheck("npm-install-fresh", () => {
             this.exec(`npm install ${tarballPath} --no-save`, installDir, 60000);
             return "Fresh install succeeded";

package/dist/inference/inference-cycle.js

@@ -3,7 +3,7 @@ import * as path from "path";
 import { shouldTriggerCycle, accumulateCorpus } from "./inference-accumulator.js";
 import { DeployVerifier } from "./deploy-verifier.js";
 import { VotingCoordinator } from "../delegation/voting-coordinator.js";
-import { StringRayStateManager } from "../state/state-manager.js";
+import { XrayStateManager } from "../state/state-manager.js";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { getGovernanceIntegration } from "../integrations/governance/index.js";
 import { featuresConfigLoader } from "../core/features-config.js";
@@ -50,7 +50,7 @@ export class InferenceCycle {
     constructor(projectRoot, agentInvoker, options) {
         this.projectRoot = projectRoot || process.cwd();
         this.inferenceDir = path.join(this.projectRoot, "docs", "inference");
-        this.stateDir = path.join(this.projectRoot, ".strray", "inference");
+        this.stateDir = path.join(this.projectRoot, ".xray", "inference");
         this.agentInvoker = agentInvoker ?? null;
         this.options = options ?? {};
     }
@@ -353,7 +353,7 @@ export class InferenceCycle {
             ``,
             `1. Read the relevant source files`,
             `2. Add the missing guard, validation, or edge case handling`,
-            `3. If this is a codex rule, add the term to .opencode/strray/codex.json`,
+            `3. If this is a codex rule, add the term to .opencode/xray/codex.json`,
             `4. Make minimal, surgical changes`,
         ].join("\n");
         try {
@@ -922,7 +922,7 @@ Respond with EXACTLY one of:
             fs.mkdirSync(this.stateDir, { recursive: true });
         }
         const stateFile = path.join(this.stateDir, "governance-state.json");
-        const stateManager = new StringRayStateManager();
+        const stateManager = new XrayStateManager();
         if (fs.existsSync(stateFile)) {
             try {
                 const data = JSON.parse(fs.readFileSync(stateFile, "utf-8"));
@@ -975,10 +975,10 @@ Respond with EXACTLY one of:
         return texts.join("\n").trim();
     }
     resolveOpencodeRoot() {
-        // Use the provider-agnostic config path resolver (prefers .strray/, falls back to .opencode/strray/)
+        // Use the provider-agnostic config path resolver (prefers .xray/, falls back to .opencode/xray/)
         const configDir = getConfigDir(this.projectRoot);
-        // If we resolved to a .strray or custom dir, use its parent as the "root"
-        if (configDir.includes(".strray") || configDir.includes("strray")) {
+        // If we resolved to a .xray or custom dir, use its parent as the "root"
+        if (configDir.includes(".xray") || configDir.includes("xray")) {
             return path.dirname(configDir);
         }
         // Legacy fallback

package/dist/integrations/hermes-agent/__init__.py

@@ -1,4 +1,4 @@
-"""StringRay Hermes Plugin — full framework pipeline integration.
+"""Xray Hermes Plugin — full framework pipeline integration.
 
 Mirrors the OpenCode xray-codex-injection.ts behavior:
   1. Captures ALL tool calls and logs to disk
@@ -29,24 +29,24 @@ except ImportError:
     schemas = importlib.import_module("schemas")
     tools = importlib.import_module("tools")
 
-logger = logging.getLogger("strray-hermes")
+logger = logging.getLogger("xray-hermes")
 
 # ── Paths ─────────────────────────────────────────────────────
 
 PLUGIN_DIR = Path(__file__).resolve().parent
 BRIDGE_PATH = PLUGIN_DIR / "bridge.mjs"
 
-# Project root: find the StringRay project directory
+# Project root: find the Xray project directory
 # The plugin lives at ~/.hermes/plugins/ which is NOT inside any project tree,
 # so walking up from PLUGIN_DIR will never find the project. Instead:
-#   1. Check STRRAY_PROJECT_ROOT env var (explicit override)
-#   2. Walk up from cwd looking for node_modules/0xray or strray-ai (consumer install)
+#   1. Check XRAY_PROJECT_ROOT env var (explicit override)
+#   2. Walk up from cwd looking for node_modules/0xray (consumer install)
         ...
         # node_modules/0xray — consumer install marker
-        if (d / "node_modules" / "0xray" / "package.json").exists() or (d / "node_modules" / "strray-ai" / "package.json").exists():
+        if (d / "node_modules" / "0xray" / "package.json").exists() or (d / "node_modules" / "0xray" / "package.json").exists():
             return d
-        # .opencode/strray — dev repo marker
-        if (d / ".opencode" / "strray" / "features.json").exists():
+        # .opencode/xray — dev repo marker
+        if (d / ".opencode" / "xray" / "features.json").exists():
             return d
         # package.json but not home dir
         if d != home and (d / "package.json").exists():
@@ -79,20 +79,20 @@ _TOOL_AGENT_MAP = {
     "delegate_task": ("orchestrator",  "delegation"),
 }
 
-# Tools where StringRay has a better alternative
+# Tools where Xray has a better alternative
 # terminal: only nudge when the command looks lint/security/search related
-_BETTER_WITH_STRRAY = {
-    "search_files": "Use mcp_strray_researcher_search_codebase for code pattern searches",
+_BETTER_WITH_XRAY = {
+    "search_files": "Use mcp_xray_researcher_search_codebase for code pattern searches",
 }
 
 # Patterns that suggest the terminal command should use an MCP tool instead
 _TERMINAL_NUDGE_PATTERNS = {
-    "grep": "Use mcp_strray_researcher_search_codebase instead of grep",
-    "rg ": "Use mcp_strray_researcher_search_codebase instead of ripgrep",
-    "eslint": "Use mcp_strray_lint_lint instead of raw eslint",
-    "npx eslint": "Use mcp_strray_lint_lint instead of raw eslint",
-    "npm audit": "Use mcp_strray_security_scan_security_scan instead of npm audit",
-    "yarn audit": "Use mcp_strray_security_scan_security_scan instead of yarn audit",
+    "grep": "Use mcp_xray_researcher_search_codebase instead of grep",
+    "rg ": "Use mcp_xray_researcher_search_codebase instead of ripgrep",
+    "eslint": "Use mcp_xray_lint_lint instead of raw eslint",
+    "npx eslint": "Use mcp_xray_lint_lint instead of raw eslint",
+    "npm audit": "Use mcp_xray_security_scan_security_scan instead of npm audit",
+    "yarn audit": "Use mcp_xray_security_scan_security_scan instead of yarn audit",
     "find ": "Use search_files(target='files') instead of find",
     "sed ": "Use patch tool instead of sed",
     "awk ": "Use patch tool instead of awk",
@@ -108,7 +108,7 @@ _session_stats = {
     "session_id": None,
     "code_operations": 0,
     "total_tool_calls": 0,
-    "strray_mcp_calls": 0,
+    "xray_mcp_calls": 0,
     "native_tool_calls": 0,
     "quality_gate_runs": 0,
     "quality_gate_blocks": 0,
@@ -184,8 +184,8 @@ def _call_bridge(command: dict, timeout: int = 10) -> dict:
 
 # ── Hook: pre_tool_call ───────────────────────────────────────
 
-def _is_strray_mcp(tool_name: str) -> bool:
-    return tool_name.startswith("mcp_strray_")
+def _is_xray_mcp(tool_name: str) -> bool:
+    return tool_name.startswith("mcp_xray_")
 
 
 def _on_pre_tool_call(tool_name: str, args: dict, task_id: str, **kwargs):
@@ -195,17 +195,17 @@ def _on_pre_tool_call(tool_name: str, args: dict, task_id: str, **kwargs):
       1. Track stats
       2. Log tool-start event to disk
       3. For code-producing tools: run quality gate + pre-processors via bridge
-      4. For non-code tools: nudge if StringRay alternative exists
+      4. For non-code tools: nudge if Xray alternative exists
     """
     _session_stats["total_tool_calls"] += 1
 
     # Log start event
     _log_tool_event("start", tool_name, args)
 
-    # StringRay MCP tools — track but don't interfere
-    if _is_strray_mcp(tool_name):
-        _session_stats["strray_mcp_calls"] += 1
-        _log_to_file("activity.log", f"[quality-gate] SKIP (strray-mcp): {tool_name}")
+    # Xray MCP tools — track but don't interfere
+    if _is_xray_mcp(tool_name):
+        _session_stats["xray_mcp_calls"] += 1
+        _log_to_file("activity.log", f"[quality-gate] SKIP [xray-mcp]: {tool_name}")
         return
 
     # delegate_task: snapshot working tree so post_hook can validate changes
@@ -252,7 +252,7 @@ def _on_pre_tool_call(tool_name: str, args: dict, task_id: str, **kwargs):
                 _log_to_file("activity.log",
                     f"[quality-gate] BLOCKED: tool={tool_name} violations={violation_msg}")
                 logger.warning(
-                    "[strray] Quality gate BLOCKED %s: %s",
+                    "[xray] Quality gate BLOCKED %s: %s",
                     tool_name, violation_msg,
                 )
             else:
@@ -277,10 +277,10 @@ def _on_pre_tool_call(tool_name: str, args: dict, task_id: str, **kwargs):
                 f"[bridge] ERROR in pre-process: {bridge_result.get('error', 'unknown')}")
         return
 
-    # Non-code tools: nudge for StringRay alternatives
-    if tool_name in _BETTER_WITH_STRRAY:
-        tip = _BETTER_WITH_STRRAY[tool_name]
-        logger.info("[strray] Tip: %s — %s", tool_name, tip)
+    # Non-code tools: nudge for Xray alternatives
+    if tool_name in _BETTER_WITH_XRAY:
+        tip = _BETTER_WITH_XRAY[tool_name]
+        logger.info("[xray] Tip: %s — %s", tool_name, tip)
         _log_to_file("activity.log",
             f"[nudge] {tool_name}: {tip}")
 
@@ -290,7 +290,7 @@ def _on_pre_tool_call(tool_name: str, args: dict, task_id: str, **kwargs):
         if isinstance(cmd, str):
             for pattern, tip in _TERMINAL_NUDGE_PATTERNS.items():
                 if pattern in cmd:
-                    logger.info("[strray] Tip: %s — %s", tool_name, tip)
+                    logger.info("[xray] Tip: %s — %s", tool_name, tip)
                     _log_to_file("activity.log",
                         f"[nudge] {tool_name}: {tip}")
                     break
@@ -378,14 +378,14 @@ def _on_post_tool_call(tool_name: str, args: dict, result, task_id: str, **kwarg
     if calls - _last_tune_tool_call_count >= _INFERENCE_TUNE_INTERVAL:
         _last_tune_tool_call_count = calls
         logger.info(
-            "[strray] Triggering inference tuning cycle (tool call #%d)", calls
+            "[xray] Triggering inference tuning cycle (tool call #%d)", calls
         )
         _log_to_file("activity.log",
             f"[inference-tune] auto-cycle at tool call #{calls}")
         try:
             _run_inference_tune()
         except Exception as e:
-            logger.warning("[strray] Inference tuning failed: %s", e)
+            logger.warning("[xray] Inference tuning failed: %s", e)
 
 
 # ── Hook: session_start ───────────────────────────────────────
@@ -394,7 +394,7 @@ def _on_session_start(session_id: str, platform: str, **kwargs):
     """Fires when a new session starts. Resets stats, logs to disk."""
     _session_stats["started_at"] = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
     _session_stats["session_id"] = session_id
-    for key in ("code_operations", "total_tool_calls", "strray_mcp_calls",
+    for key in ("code_operations", "total_tool_calls", "xray_mcp_calls",
                 "native_tool_calls", "quality_gate_runs", "quality_gate_blocks",
                 "pre_processor_runs", "post_processor_runs",
                 "bridge_calls", "bridge_errors",
@@ -406,23 +406,23 @@ def _on_session_start(session_id: str, platform: str, **kwargs):
     _ensure_log_dir()
     _log_to_file("activity.log",
         f"[session-start] session={session_id} platform={platform}")
-    logger.info("[strray] Session %s started on %s", session_id, platform)
+    logger.info("[xray] Session %s started on %s", session_id, platform)
 
 
 # ── Slash command ─────────────────────────────────────────────
 
-def _strray_command(args: str) -> str:
-    """Slash command handler: /strray [status|stats|help]"""
+def _xray_command(args: str) -> str:
+    """Slash command handler: /xray [status|stats|help]"""
     cmd = (args or "status").strip().lower()
 
     if cmd == "stats":
         return (
-            f"StringRay Session Stats\n"
+            f"Xray Session Stats\n"
             f"  Session: {_session_stats['session_id'] or 'N/A'}\n"
             f"  Started: {_session_stats['started_at'] or 'N/A'}\n"
             f"  Tool calls: {_session_stats['total_tool_calls']}\n"
             f"  Code operations: {_session_stats['code_operations']}\n"
-            f"  StringRay MCP: {_session_stats['strray_mcp_calls']}\n"
+            f"  Xray MCP: {_session_stats['xray_mcp_calls']}\n"
             f"  Native tools: {_session_stats['native_tool_calls']}\n"
             f"  Quality gate runs: {_session_stats['quality_gate_runs']}\n"
             f"  Quality gate blocks: {_session_stats['quality_gate_blocks']}\n"
@@ -437,19 +437,19 @@ def _strray_command(args: str) -> str:
 
     if cmd == "help":
         return (
-            "StringRay Commands:\n"
-            "  /strray status — Plugin and framework health\n"
-            "  /strray stats  — Session pipeline statistics\n"
-            "  /strray help   — This message"
+            "Xray Commands:\n"
+            "  /xray status — Plugin and framework health\n"
+            "  /xray stats  — Session pipeline statistics\n"
+            "  /xray help   — This message"
         )
 
     # Default: status (calls bridge health)
     bridge_result = _call_bridge({"command": "health"}, timeout=10)
     if "error" in bridge_result:
-        return f"StringRay plugin loaded. Bridge: {bridge_result['error']}"
+        return f"Xray plugin loaded. Bridge: {bridge_result['error']}"
 
     return (
-        f"StringRay Hermes Plugin Status\n"
+        f"Xray Hermes Plugin Status\n"
         f"  Framework: {bridge_result.get('framework', 'unknown')}\n"
         f"  Version: {bridge_result.get('version', 'unknown')}\n"
         f"  Quality Gate: {'ready' if bridge_result.get('components', {}).get('qualityGate') else 'not loaded'}\n"
@@ -518,13 +518,13 @@ def _record_tool_outcome(tool_name: str, args: dict, success: bool):
         with open(_OUTCOMES_PATH, "w") as f:
             json.dump(outcomes, f, indent=2)
     except Exception as e:
-        logger.debug("[strray] outcome recording failed: %s", e)
+        logger.debug("[xray] outcome recording failed: %s", e)
 
 
 # ── Inference tuning (auto-calibration) ────────────────────────
 
 def _run_inference_tune():
-    """Shell out to strray-ai inference:tuner --run-once.
+    """Shell out to 0xray inference:tuner --run-once.
 
     Runs in a background thread so it doesn't block the tool call pipeline.
     The tuner reads routing outcomes, runs the analytics pipeline, and
@@ -560,7 +560,7 @@ def _run_inference_tune():
 # ── Registration ──────────────────────────────────────────────
 
 # ── Subagent (delegate_task) enforcement ────────────────────
-# Subagents bypass all StringRay hooks because they run in isolated
+# Subagents bypass all Xray hooks because they run in isolated
 # contexts. We enforce by snapshotting the working tree before dispatch
 # and validating all changed files after return.
 
@@ -647,7 +647,7 @@ def _validate_subagent_changes(task_id: str, **kwargs):
                 f"[subagent-validate] BLOCKED: {rel_path} "
                 f"violations={'; '.join(str(v) for v in violations[:3])}")
             logger.warning(
-                "[strray] Subagent BLOCKED %s: %s",
+                "[xray] Subagent BLOCKED %s: %s",
                 rel_path, violations[:3],
             )
         else:
@@ -659,28 +659,28 @@ def register(ctx):
     """Wire schemas to handlers and register lifecycle hooks."""
     # ── Register tools ────────────────────────────────────────
     ctx.register_tool(
-        name="strray_validate",
-        toolset="strray-hermes",
-        schema=schemas.STRRAY_VALIDATE,
-        handler=tools.strray_validate,
+        name="xray_validate",
+        toolset="xray-hermes",
+        schema=schemas.XRAY_VALIDATE,
+        handler=tools.xray_validate,
     )
     ctx.register_tool(
-        name="strray_codex_check",
-        toolset="strray-hermes",
-        schema=schemas.STRRAY_CODEX_CHECK,
-        handler=tools.strray_codex_check,
+        name="xray_codex_check",
+        toolset="xray-hermes",
+        schema=schemas.XRAY_CODEX_CHECK,
+        handler=tools.xray_codex_check,
     )
     ctx.register_tool(
-        name="strray_health",
-        toolset="strray-hermes",
-        schema=schemas.STRRAY_HEALTH,
-        handler=tools.strray_health,
+        name="xray_health",
+        toolset="xray-hermes",
+        schema=schemas.XRAY_HEALTH,
+        handler=tools.xray_health,
     )
     ctx.register_tool(
-        name="strray_hooks",
-        toolset="strray-hermes",
-        schema=schemas.STRRAY_HOOKS,
-        handler=tools.strray_hooks,
+        name="xray_hooks",
+        toolset="xray-hermes",
+        schema=schemas.XRAY_HOOKS,
+        handler=tools.xray_hooks,
     )
 
     # ── Register hooks ────────────────────────────────────────
@@ -691,28 +691,28 @@ def register(ctx):
     try:
         ctx.register_hook("on_session_start", _on_session_start)
     except (AttributeError, TypeError):
-        logger.debug("[strray] on_session_start hook not yet available")
+        logger.debug("[xray] on_session_start hook not yet available")
 
     # ── Register slash command ────────────────────────────────
     try:
         ctx.register_command(
-            name="strray",
-            handler=_strray_command,
-            description="StringRay status, stats, hooks, and enforcement info",
+            name="xray",
+            handler=_xray_command,
+            description="Xray status, stats, hooks, and enforcement info",
             args_hint="[status|stats|help]",
             aliases=("sr",),
         )
     except (AttributeError, TypeError):
-        logger.debug("[strray] Slash command registration not yet available")
+        logger.debug("[xray] Slash command registration not yet available")
 
     # ── Bootstrap ─────────────────────────────────────────────
     _ensure_log_dir()
     _log_to_file("activity.log",
-        f"[plugin-loaded] StringRay Hermes Plugin v2.2 — "
+        f"[plugin-loaded] Xray Hermes Plugin v2.2 — "
         f"4 tools, 2 hooks, subagent enforcement, bridge={BRIDGE_PATH.exists()}")
 
     logger.info(
-        "[strray] Plugin v2.2 loaded: 4 tools, 2 hooks, "
+        "[xray] Plugin v2.2 loaded: 4 tools, 2 hooks, "
         "subagent enforcement active, bridge=%s",
         BRIDGE_PATH.exists(),
     )

package/dist/integrations/hermes-agent/after-install.md

@@ -1,4 +1,4 @@
-# StringRay Hermes Plugin Installed
+# Xray Hermes Plugin Installed
 
 **Restart your Hermes session** for the plugin to take effect.
 
@@ -6,10 +6,10 @@
 
 | Component | Description |
 |-----------|-------------|
-| `strray_validate` | Pre-commit validation with quality gates |
-| `strray_codex_check` | Code review against 60 Codex error-prevention rules |
-| `strray_health` | Framework health check |
-| `strray_hooks` | Git hooks management (install, uninstall, list, status) |
+| `xray_validate` | Pre-commit validation with quality gates |
+| `xray_codex_check` | Code review against 60 Codex error-prevention rules |
+| `xray_health` | Framework health check |
+| `xray_hooks` | Git hooks management (install, uninstall, list, status) |
 | `pre_tool_call` hook | Quality gates + nudges before every tool call |
 | `post_tool_call` hook | Post-processors after every tool call |
 
@@ -27,24 +27,24 @@ The plugin can install git hooks for automated validation:
 ### Install Hooks
 
 ```
-/strray hooks install
+/xray hooks install
 ```
 
 Or use the tool directly:
 ```
-strray_hooks(action="install")
+xray_hooks(action="install")
 ```
 
 ### Check Hook Status
 
 ```
-/strray hooks status
+/xray hooks status
 ```
 
 ### Uninstall Hooks
 
 ```
-/strray hooks uninstall
+/xray hooks uninstall
 ```
 
 ## Quick Test
@@ -52,20 +52,20 @@ strray_hooks(action="install")
 After restarting Hermes, try:
 
 ```
-/strray status
-/strray stats
+/xray status
+/xray stats
 ```
 
-Or use the tools directly — `strray_health` will confirm the bridge is connected.
+Or use the tools directly — `xray_health` will confirm the bridge is connected.
 
 ## MCP Servers
 
-The plugin works alongside StringRay's MCP servers (if configured in your
+The plugin works alongside Xray's MCP servers (if configured in your
 Hermes config). The plugin's native tools provide offline/offline-first
 validation, while MCP servers offer deeper framework integration.
 
 ## Files
 
-The plugin lives at `~/.hermes/plugins/strray-hermes/`. It is auto-updated
+The plugin lives at `~/.hermes/plugins/xray-hermes/`. It is auto-updated
 when you run `npm install` or `npm update` in a project with `0xray`
 as a dependency.