0xray 2.0.1 → 2.1.1

package/dist/skills/xray-orchestrator/index.js

@@ -0,0 +1,224 @@
+/**
+ * xray Orchestrator Skill
+ *
+ * OpenClaw skill that provides xray orchestration commands.
+ *
+ * @version 1.0.0
+ * @since 2026-03-14
+ */
+const API_BASE = process.env.XRAY_API_URL || 'http://localhost:18431';
+const API_KEY = process.env.XRAY_API_KEY;
+function parseArgs(input) {
+    const parts = input.trim().split(/\s+/);
+    const command = parts[0] || '';
+    const args = {};
+    for (const part of parts.slice(1)) {
+        if (part.startsWith('--')) {
+            const key = part.slice(2);
+            args[key] = true;
+        }
+        else if (part.includes(':')) {
+            const colonIdx = part.indexOf(':');
+            const key = part.slice(0, colonIdx);
+            const value = part.slice(colonIdx + 1);
+            if (key && value)
+                args[key] = value;
+        }
+        else if (!args._) {
+            args._ = [];
+            args._.push(part);
+        }
+        else {
+            args._.push(part);
+        }
+    }
+    return { command, args };
+}
+async function callAPI(endpoint, data) {
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (API_KEY) {
+        headers['Authorization'] = `Bearer ${API_KEY}`;
+    }
+    const response = await fetch(`${API_BASE}${endpoint}`, {
+        method: data ? 'POST' : 'GET',
+        headers,
+        body: data ? JSON.stringify(data) : null,
+    });
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+        throw new Error(error.error || `HTTP ${response.status}`);
+    }
+    return response.json();
+}
+export async function handleSkill(input) {
+    const { command, args } = parseArgs(input);
+    try {
+        switch (command.toLowerCase()) {
+            // xray primary
+            case 'xray':
+            case 'xray-status':
+                return await handleStatus();
+            case 'xray-analyze':
+                return await handleAnalyze(args);
+            case 'xray-code':
+                return await handleCodeReview(args);
+            case 'xray-file':
+                return await handleFileRead(args);
+            case 'xray-exec':
+                return await handleExec(args);
+            case 'xray-help':
+                return handleHelp(args._);
+            default:
+                return formatHelp();
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `❌ Error: ${message}`;
+    }
+}
+async function handleStatus() {
+    const health = await callAPI('/health');
+    return `🤖 xray Status
+
+• Status: ${health.status}
+• Version: ${health.version}
+• Uptime: ${formatUptime(health.uptime)}
+
+Use /xray-help for available commands.`;
+}
+async function handleAnalyze(args) {
+    const filePath = args._?.[0];
+    if (!filePath) {
+        return '❌ Usage: /xray-analyze <file-path>';
+    }
+    const result = await callAPI('/api/agent/invoke', {
+        command: 'analyze',
+        args: { filePath },
+    });
+    if (!result.success) {
+        return `❌ Analysis failed: ${result.error}`;
+    }
+    return `✅ Analysis complete for ${filePath}\n\n${JSON.stringify(result.result, null, 2)}`;
+}
+async function handleCodeReview(args) {
+    const filePath = args._?.[0];
+    const fix = args.fix === true;
+    if (!filePath) {
+        return '❌ Usage: /xray-code <file-path> [--fix]';
+    }
+    const result = await callAPI('/api/agent/invoke', {
+        command: 'code-review',
+        args: { filePath, fix },
+    });
+    if (!result.success) {
+        return `❌ Code review failed: ${result.error}`;
+    }
+    return `✅ Code review complete for ${filePath}\n\n${JSON.stringify(result.result, null, 2)}`;
+}
+async function handleFileRead(args) {
+    const rest = args._;
+    const filePath = rest?.[0];
+    const range = rest?.[1];
+    if (!filePath) {
+        return '❌ Usage: /xray-file <file-path> [line-start:line-end]';
+    }
+    let lineRange;
+    if (range?.includes(':')) {
+        const [rawStart, rawEnd] = range.split(':');
+        lineRange = {};
+        if (rawStart)
+            lineRange.start = Number(rawStart);
+        if (rawEnd)
+            lineRange.end = Number(rawEnd);
+    }
+    const result = await callAPI('/api/agent/invoke', {
+        command: 'read',
+        args: { filePath, ...lineRange },
+    });
+    if (!result.success) {
+        return `❌ File read failed: ${result.error}`;
+    }
+    return `📄 ${filePath}\n\`\`\`\n${result.result}\n\`\`\``;
+}
+async function handleExec(args) {
+    const command = args._?.[0];
+    if (!command) {
+        return '❌ Usage: /xray-exec <command>';
+    }
+    const result = await callAPI('/api/agent/invoke', {
+        command: 'exec',
+        args: { command },
+    });
+    if (!result.success) {
+        return `❌ Execution failed: ${result.error}`;
+    }
+    return `✅ Command executed\n\n${JSON.stringify(result.result, null, 2)}`;
+}
+function handleHelp(command) {
+    if (command) {
+        switch (command) {
+            case 'xray-analyze':
+                return `📖 /xray-analyze <file-path>
+
+Analyze code in a file.
+
+Example: /xray-analyze src/index.ts`;
+            case 'xray-code':
+                return `📖 /xray-code <file-path> [--fix]
+
+Perform code review on a file.
+Use --fix to attempt automatic fixes.
+
+Example: /xray-code src/utils/helper.ts
+Example: /xray-code src/utils/helper.ts --fix`;
+            case 'xray-file':
+                return `📖 /xray-file <file-path> [line-start:line-end]
+
+Read a file.
+Optionally specify line range.
+
+Example: /xray-file src/index.ts
+Example: /xray-file src/index.ts 1:50`;
+            case 'xray-exec':
+                return `📖 /xray-exec <command>
+
+Execute an arbitrary command.
+
+Example: /xray-exec list files src/`;
+            default:
+                return `Unknown command: ${command}`;
+        }
+    }
+    return formatHelp();
+}
+function formatHelp() {
+    return `🤖 xray Orchestrator
+
+Available Commands:
+• /xray - Show status
+• /xray-analyze <file> - Analyze code
+• /xray-code <file> [--fix] - Code review
+• /xray-file <file> [lines] - Read file
+• /xray-exec <command> - Execute command
+• /xray-help [command] - Show help
+
+Use /xray-help <command> for detailed usage.`;
+}
+function formatUptime(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0)
+        return `${days}d ${hours % 24}h`;
+    if (hours > 0)
+        return `${hours}h ${minutes % 60}m`;
+    if (minutes > 0)
+        return `${minutes}m`;
+    return `${seconds}s`;
+}
+// Export for OpenClaw
+export default { handleSkill };

package/dist/state/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./state-manager.js";
 export * from "./context-providers.js";
 export * from "./state-types.js";
-export { StringRayStateManager } from "./state-manager.js";
+export { XrayStateManager } from "./state-manager.js";
+export { XrayStateManager as StringRayStateManager } from "./state-manager.js";

package/dist/state/index.js

@@ -4,4 +4,5 @@ export * from "./state-manager.js";
 export * from "./context-providers.js";
 export * from "./state-types.js";
 // Re-export commonly used state utilities
-export { StringRayStateManager } from "./state-manager.js";
+export { XrayStateManager } from "./state-manager.js";
+export { XrayStateManager as StringRayStateManager } from "./state-manager.js";

package/dist/state/state-manager.d.ts

@@ -3,7 +3,7 @@ export interface StateManager {
     set: <T>(key: string, value: T) => void;
     clear: (key: string) => void;
 }
-export declare class StringRayStateManager implements StateManager {
+export declare class XrayStateManager implements StateManager {
     private store;
     private persistencePath;
     private persistenceEnabled;
@@ -39,4 +39,4 @@ export declare class StringRayStateManager implements StateManager {
         value2: unknown;
     }): unknown;
 }
-export { StringRayStateManager as StrRayStateManager };
+export { XrayStateManager as StringRayStateManager, XrayStateManager as StrRayStateManager };

package/dist/state/state-manager.js

@@ -1,6 +1,6 @@
 import { frameworkLogger } from "../core/framework-logger.js";
 import { resolveStateFilePath } from "../core/config-paths.js";
-export class StringRayStateManager {
+export class XrayStateManager {
     store = new Map();
     persistencePath;
     persistenceEnabled;
@@ -190,7 +190,7 @@ export class StringRayStateManager {
     }
     // Enterprise features for advanced state management
     getStateVersion() {
-        return StringRayStateManager.VERSION || "1.1.1";
+        return XrayStateManager.VERSION || "1.1.1";
     }
     getAuditLog() {
         return []; // Simplified implementation for testing
@@ -204,5 +204,6 @@ export class StringRayStateManager {
         return conflict.value2; // Prefer the second value as newer
     }
 }
-// Export alias for scripts expecting StrRayStateManager (backward compatibility)
-export { StringRayStateManager as StrRayStateManager };
+// Export alias for scripts expecting XrayStateManager
+// Backward compat: StringRayStateManager and StrRayStateManager aliases
+export { XrayStateManager as StringRayStateManager, XrayStateManager as StrRayStateManager };

package/dist/utils/import-resolver.js

@@ -77,7 +77,7 @@ export class ImportResolver {
     detectInstalled() {
         return (this.currentDir.includes("/node_modules/") ||
             this.currentDir.includes("\\node_modules\\") ||
-            (this.currentDir.includes("strray") &&
+            (this.currentDir.includes("xray") &&
                 !this.currentDir.includes(this.projectRoot)));
     }
     detectTesting() {

package/dist/utils/path-resolver.js

@@ -52,7 +52,7 @@ export class PathResolver {
     detectBuilt() {
         return (this.currentDir.includes("/dist/") ||
             this.currentDir.includes("\\dist\\") ||
-            (this.currentDir.includes("strray") && !this.detectDevelopment()));
+            (this.currentDir.includes("xray") && !this.detectDevelopment()));
     }
     /**
      * Detect if we're running in installed package environment
@@ -60,7 +60,7 @@ export class PathResolver {
     detectInstalled() {
         return (this.currentDir.includes("/node_modules/") ||
             this.currentDir.includes("\\node_modules\\") ||
-            (this.currentDir.includes("strray") && this.detectBuilt()));
+            (this.currentDir.includes("xray") && this.detectBuilt()));
     }
     /**
      * Resolve agent import path for current environment

package/dist/utils/token-manager.js

@@ -3,7 +3,7 @@ import * as path from "path";
 import { resolveConfigPath } from "../core/config-paths.js";
 export class TokenManager {
     config;
-    constructor(configPath = resolveConfigPath("config.json") || path.join(process.cwd(), ".strray", "config.json")) {
+    constructor(configPath = resolveConfigPath("config.json") || path.join(process.cwd(), ".xray", "config.json")) {
         this.config = this.loadConfig(configPath);
     }
     loadConfig(configPath) {

package/dist/validation/estimation-validator.js

@@ -12,7 +12,7 @@ import { frameworkLogger } from '../core/framework-logger.js';
 export class EstimationValidator {
     estimations = new Map();
     calibrations = new Map();
-    STORAGE_KEY = 'strray-estimations';
+    STORAGE_KEY = 'xray-estimations';
     constructor() {
         this.loadFromStorage();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0xray",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "description": "Multi-agent orchestration and Codex governance for OpenCode, Hermes, Grok Build, and OpenClaw",
   "readme": "README.md",
   "license": "MIT",
@@ -120,7 +120,6 @@
     "scripts/mjs/test-mcp-functionality.mjs",
     "scripts/mjs/validate-mcp-connectivity.cjs",
     "scripts/mjs/validate-postinstall-config.mjs",
-    "scripts/validate-stringray-comprehensive.js",
     "src/opencode/",
     "src/opencode/AGENTS-consumer.md",
     "src/opencode/codex.codex",
@@ -149,6 +148,7 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.4",
+    "0xray": "^2.0.1",
     "commander": "^11.1.0",
     "express": "^5.2.1",
     "jsonwebtoken": "^9.0.3",

package/scripts/hooks/pre-command

@@ -1,5 +1,5 @@
 #!/bin/bash
-# Pre-Command Hook for StringRay
+# Pre-Command Hook for 0xRay
 # 
 # Checks context window usage before each command.
 # If context is at 95%+ (configurable), auto-generates a reflection.

package/scripts/hooks/run-hook.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * StringRay Git Hook Runner
+ * 0xRay Git Hook Runner
  *
  * Called by git hooks (pre-commit, post-commit, pre-push, post-push)
  * to perform validation, logging, and monitoring.
@@ -565,6 +565,6 @@ handler()
   })
   .catch((err) => {
     logError(`Hook crashed: ${err.message}`);
-    console.error(`StringRay hook error: ${err.message}`);
+    console.error(`0xRay hook error: ${err.message}`);
     process.exit(1);
   });

package/scripts/node/auto-reflection-generator.mjs

@@ -107,9 +107,9 @@ function getChangedFiles(count = 20) {
 }
 
 function loadConfig() {
-  // Primary: .opencode/xray/ YML SSOT. Min legacy fallbacks for .opencode/strray/ + .strray/ (transitional consumer compat; documented per Term 61)
+  // Primary: .opencode/xray/ YML SSOT. Min legacy fallbacks (transitional consumer compat; documented per Term 61)
   const configPath = join(process.cwd(), ".opencode", "xray", "features.json");
-  const fallbackPath = join(process.cwd(), ".opencode", "strray", "features.json");
+  const fallbackPath = join(process.cwd(), ".opencode", "xray", "features.json");
   const legacyPath = join(process.cwd(), ".strray", "features.json");
   
   for (const p of [configPath, fallbackPath, legacyPath]) {

package/scripts/node/postinstall.cjs

@@ -46,7 +46,7 @@ if (resolvedPackage !== resolvedTarget) {
     const xrayRoot = targetDir;
 
     execSync(
-      `grok mcp add xray-governance --command node --args "${govServer}" --env "STRRAY_FORCE_MCP_GOVERNANCE=true" --env "XRAY_ROOT=${xrayRoot}"`,
+      `grok mcp add xray-governance --command node --args "${govServer}" --env "XRAY_FORCE_MCP_GOVERNANCE=true" --env "XRAY_ROOT=${xrayRoot}"`,
       { stdio: 'pipe' }
     );
     structuredLog('postinstall', 'Registered xray-governance with Grok CLI', 'info');

package/scripts/node/pre-publish-guard.js

@@ -165,16 +165,22 @@ function checkVersionManagerRan() {
   const vmContent = fs.readFileSync(vmPath, 'utf-8');
   
   // Check that files have been updated (look for recent timestamps or version)
-  const { resolveConfigPath } = require('../helpers/resolve-config-path.cjs');
-  const featuresPath = resolveConfigPath('features.json', rootDir);
-  const features = JSON.parse(fs.readFileSync(featuresPath, 'utf-8'));
-  
-  // Version manager should have updated version fields
-  if (!features.version && !features.xray_version) {
-    warnings.push('features.json may not have been synced by version manager');
-    log('features.json may need version sync', 'warn');
-  } else {
-    log('Version manager appears to have run', 'success');
+  try {
+    const { resolveConfigPath } = require('../helpers/resolve-config-path.cjs');
+    const featuresPath = resolveConfigPath('features.json', rootDir);
+    if (fs.existsSync(featuresPath)) {
+      const features = JSON.parse(fs.readFileSync(featuresPath, 'utf-8'));
+      if (!features.version && !features.xray_version) {
+        warnings.push('features.json may not have been synced by version manager');
+        log('features.json may need version sync', 'warn');
+      } else {
+        log('Version manager appears to have run', 'success');
+      }
+    } else {
+      log('features.json not found — skipping check (non-blocking)', 'warn');
+    }
+  } catch (e) {
+    log('Could not check features.json — non-blocking', 'warn');
   }
   
   return true;

package/scripts/node/release.js

@@ -63,7 +63,7 @@ function main() {
   if (bumpType === "major" || bumpType === "minor") parts[2] = 0;
   const nextVersion = parts.join(".");
 
-  console.log(`\n${BOLD}${BLUE}🚀 xray Release${RESET}`);
+  console.log(`\n${BOLD}${BLUE}🚀 0xray Release${RESET}`);
   console.log(`${BOLD}  ${currentVersion} → ${nextVersion} (${bumpType})${RESET}\n`);
 
   if (dryRun) {
@@ -123,20 +123,20 @@ function main() {
     console.log(`${BLUE}▸ Publishing to npm${RESET}`);
     try {
       execSync("npm publish --access public", { cwd: rootDir, stdio: "inherit" });
-      console.log(`${GREEN}  ✓ Published xray@${nextVersion}${RESET}`);
+      console.log(`${GREEN}  ✓ Published 0xray@${nextVersion}${RESET}`);
     } catch (e) {
       const errMsg = (e.stderr?.toString() || "") + (e.message || "");
       if (errMsg.includes("previously published")) {
-        console.log(`${GREEN}  ✓ Already published xray@${nextVersion}${RESET}`);
+        console.log(`${GREEN}  ✓ Already published 0xray@${nextVersion}${RESET}`);
       } else {
         console.log(`${RED}  ✗ Publish failed. Trying with --ignore-scripts...${RESET}`);
         try {
           execSync("npm publish --access public --ignore-scripts", { cwd: rootDir, stdio: "pipe", encoding: "utf-8" });
-          console.log(`${GREEN}  ✓ Published xray@${nextVersion} (ignore-scripts)${RESET}`);
+          console.log(`${GREEN}  ✓ Published 0xray@${nextVersion} (ignore-scripts)${RESET}`);
         } catch (e2) {
           const errMsg2 = (e2.stderr?.toString() || "") + (e2.message || "");
           if (errMsg2.includes("previously published")) {
-            console.log(`${GREEN}  ✓ Already published xray@${nextVersion}${RESET}`);
+            console.log(`${GREEN}  ✓ Already published 0xray@${nextVersion}${RESET}`);
           } else {
             console.log(`${RED}  ✗ Publish failed: ${errMsg2.slice(0, 200)}${RESET}`);
             process.exit(1);
@@ -153,7 +153,7 @@ function main() {
     }
   }
 
-  console.log(`\n${BOLD}${GREEN}✅ Released xray@${nextVersion}${RESET}\n`);
+  console.log(`\n${BOLD}${GREEN}✅ Released 0xray@${nextVersion}${RESET}\n`);
 }
 
 main();

package/scripts/node/release.mjs

@@ -98,19 +98,19 @@ async function main() {
   // This removes the brittle "must be exactly one ahead" problem.
   let publishedVersion;
   try {
-    publishedVersion = execSync('npm view xray version', { encoding: 'utf-8' }).trim();
+    publishedVersion = execSync('npm view 0xray version', { encoding: 'utf-8' }).trim();
     console.log(`📌 Latest published on npm: ${publishedVersion}`);
   } catch {
-    publishedVersion = '0.0.0';
-    console.log('⚠️  Could not fetch published version from npm (using 0.0.0)');
+    publishedVersion = null;
+    console.log('⚠️  Could not fetch published version from npm — will use local version');
   }
 
-  const targetVersion = bumpVersion(publishedVersion, releaseType);
-  console.log(`📌 Target version (computed from registry): ${targetVersion}`);
+  const baseVersion = publishedVersion || getCurrentVersion();
+  const targetVersion = bumpVersion(baseVersion, releaseType);
+  console.log(`📌 Target version (computed from ${publishedVersion ? 'registry' : 'local'}): ${targetVersion}`);
   console.log(`📌 Release type: ${releaseType}`);
 
-  // Safety: if local is somehow ahead of what we computed, warn but continue
-  if (currentVersion !== targetVersion) {
+  if (publishedVersion && currentVersion !== targetVersion) {
     console.log(`⚠️  Local version (${currentVersion}) differs from computed target. Using computed target ${targetVersion}.`);
   }
 
@@ -154,13 +154,13 @@ async function main() {
   
   // Step 5: Push
   console.log('\n📦 Step 5: Pushing to origin...');
-  runCommand('git push origin master', 'Failed to push to origin');
+  runCommand('git push origin main', 'Failed to push to origin');
   runCommand(`git push origin v${newVersion}`, 'Failed to push tag');
 
   // Step 6: Publish to npm
   console.log('\n📦 Step 6: Publishing to npm...');
-  runCommand('npm publish --access public', 'npm publish failed');
-  console.log(`✅ Published xray@${newVersion} to npm`);
+  runCommand('npm publish --access public --ignore-scripts', 'npm publish failed');
+  console.log(`✅ Published 0xray@${newVersion} to npm`);
 
   console.log('\n╔════════════════════════════════════════════════════════╗');
   console.log('║        ✅ Release Complete!                            ║');
@@ -190,7 +190,7 @@ async function main() {
 {EMOJI} {feature - consumer benefit}
 {EMOJI} {feature - consumer benefit}
 \`\`\`
-npm install xray@latest
+npm install 0xray@latest
 \`\`\`
 What xray is: {one sentence positioning}
 #xray #AIOps #DevTools #SelfHealing #NPM`;

package/scripts/node/universal-version-manager.js

@@ -155,7 +155,7 @@ const detectedCodex = detectCodexInfo();
 const OFFICIAL_VERSIONS = {
   // Framework version
   framework: {
-    version: "2.0.1",
+    version: "2.1.1",
       displayName: "xray: Self-Healing AI Governance OS",
       lastUpdated: "2026-06-08",
     // Counts (auto-calculated, but can be overridden)
@@ -403,7 +403,7 @@ const UPDATE_PATTERNS = [
       pattern: /xray AI v[0-9]+\.[0-9]+\.[0-9]+/g,
       replacement: `xray AI v${OFFICIAL_VERSIONS.framework.version}`,
     },
-    // Footer bare version (e.g., "**Version**: 2.0.0")
+    // Footer bare version (e.g., "**Version**: 2.0.1")
     {
       pattern: /\*\*Version\*\*:\s*[0-9]+\.[0-9]+\.[0-9]+/g,
       replacement: `**Version**: ${OFFICIAL_VERSIONS.framework.version}`,

package/scripts/node/version-manager.mjs

@@ -308,7 +308,7 @@ function updateAgentsMd(counts) {
   
   // Legacy header count update (min compat for old consumer AGENTS.md files only; xray v2 YML SSOT primary)
   agentsMd = agentsMd.replace(
-    /0xRay\s*2\.0\s*-\s*\d+\s+Agents|StringRay\s*-\s*\d+\s+Agents/,
+    /0xRay\s*2\.0\s*-\s*\d+\s+Agents|xray\s*v2\s*-\s*\d+\s+Agents/,
     `xray v2 - ${counts.agents} Agents`
   );
   

package/src/integrations/grok/plugin/0xray/.mcp.json

@@ -1,13 +1,13 @@
 {
   "mcpServers": {
-    "strray-governance": {
+    "xray-governance": {
       "command": "npx",
       "args": ["-y", "0xray", "mcp", "governance"],
       "env": {
-        "STRRAY_FORCE_MCP_GOVERNANCE": "true"
+        "XRAY_FORCE_MCP_GOVERNANCE": "true"
       }
     },
-    "strray-skills": {
+    "xray-skills": {
       "command": "npx",
       "args": ["-y", "0xray", "mcp", "skills"]
     }

package/src/integrations/grok/plugin/0xray/hooks/hooks.json

@@ -8,7 +8,7 @@
             "type": "command",
             "command": "node",
             "args": [
-              "${STRRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/pre-tool-use.js"
+              "${XRAY_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/pre-tool-use.js"
             ],
             "timeout": 30000
           }
@@ -21,7 +21,7 @@
           {
             "type": "command",
             "command": "echo",
-            "args": ["[0xRay] Grok session started with StringRay governance enabled"]
+            "args": ["[0xRay] Grok session started with 0xRay governance enabled"]
           }
         ]
       }

package/src/mcps/architect-tools.server.ts

@@ -35,13 +35,13 @@ interface FileNode {
   extension: string;
 }
 
-class StringRayArchitectToolsServer {
+class XrayArchitectToolsServer {
   private server: Server;
 
   constructor() {
     this.server = new Server(
       {
-        name: "architect-tools", version: "2.0.0",
+        name: "architect-tools", version: "2.0.1",
       },
       {
         capabilities: {
@@ -336,8 +336,8 @@ class StringRayArchitectToolsServer {
 }
 
 if (import.meta.url === `file://${process.argv[1]}`) {
-  const server = new StringRayArchitectToolsServer();
+  const server = new XrayArchitectToolsServer();
   server.run().catch((error) => frameworkLogger.log("mcps/architect-tools", "run", "error", { error: String(error) }));
 }
 
-export default StringRayArchitectToolsServer;
+export default XrayArchitectToolsServer;

package/src/mcps/auto-format.server.ts

@@ -34,13 +34,13 @@ interface FormatResults {
   changes: Record<string, string[]>;
 }
 
-class StringRayAutoFormatServer {
+class XrayAutoFormatServer {
   private server: Server;
 
   constructor() {
     this.server = new Server(
       {
-        name: "auto-format", version: "2.0.0",
+        name: "auto-format", version: "2.0.1",
       },
       {
         capabilities: {
@@ -522,8 +522,8 @@ ${checkResults.details.map((d) => `• ${d}`).join("\n")}
 
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-  const server = new StringRayAutoFormatServer();
+  const server = new XrayAutoFormatServer();
   server.run().catch((error) => frameworkLogger.log("mcps/auto-format", "run", "error", { error: String(error) }));
 }
 
-export { StringRayAutoFormatServer };
+export { XrayAutoFormatServer };