0xray 2.0.1 → 2.1.1

package/src/skills/xray-orchestrator/index.ts

@@ -0,0 +1,268 @@
+/**
+ * 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;
+
+interface ParsedArgs extends Record<string, unknown> {
+  _?: string[];
+}
+
+function parseArgs(input: string): { command: string; args: ParsedArgs } {
+  const parts = input.trim().split(/\s+/);
+  const command = parts[0] || '';
+  const args: ParsedArgs = {};
+
+  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: string, data?: Record<string, unknown>): Promise<Record<string, unknown>> {
+  const headers: Record<string, string> = {
+    '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: string): Promise<string> {
+  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._ as string | undefined);
+
+      default:
+        return formatHelp();
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return `❌ Error: ${message}`;
+  }
+}
+
+async function handleStatus(): Promise<string> {
+  const health = await callAPI('/health') as { status: string; version: string; uptime: number };
+
+  return `🤖 xray Status
+
+• Status: ${health.status}
+• Version: ${health.version}
+• Uptime: ${formatUptime(health.uptime)}
+
+Use /xray-help for available commands.`;
+}
+
+async function handleAnalyze(args: Record<string, unknown>): Promise<string> {
+  const filePath = (args._ as string[])?.[0];
+
+  if (!filePath) {
+    return '❌ Usage: /xray-analyze <file-path>';
+  }
+
+  const result = await callAPI('/api/agent/invoke', {
+    command: 'analyze',
+    args: { filePath },
+  }) as { success: boolean; result?: unknown; error?: string };
+
+  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: Record<string, unknown>): Promise<string> {
+  const filePath = (args._ as string[])?.[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 },
+  }) as { success: boolean; result?: unknown; error?: string };
+
+  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: Record<string, unknown>): Promise<string> {
+  const rest = args._ as string[] | undefined;
+  const filePath = rest?.[0];
+  const range = rest?.[1];
+
+  if (!filePath) {
+    return '❌ Usage: /xray-file <file-path> [line-start:line-end]';
+  }
+
+  let lineRange: { start?: number; end?: number } | undefined;
+  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 },
+  }) as { success: boolean; result?: unknown; error?: string };
+
+  if (!result.success) {
+    return `❌ File read failed: ${result.error}`;
+  }
+
+  return `📄 ${filePath}\n\`\`\`\n${result.result}\n\`\`\``;
+}
+
+async function handleExec(args: Record<string, unknown>): Promise<string> {
+  const command = (args._ as string[])?.[0];
+
+  if (!command) {
+    return '❌ Usage: /xray-exec <command>';
+  }
+
+  const result = await callAPI('/api/agent/invoke', {
+    command: 'exec',
+    args: { command },
+  }) as { success: boolean; result?: unknown; error?: string };
+
+  if (!result.success) {
+    return `❌ Execution failed: ${result.error}`;
+  }
+
+  return `✅ Command executed\n\n${JSON.stringify(result.result, null, 2)}`;
+}
+
+function handleHelp(command?: string): string {
+  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(): string {
+  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: number): string {
+  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 };