0xray 2.0.0

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

@@ -0,0 +1,253 @@
+"""Tool handlers — code that runs when the LLM calls each tool.
+
+v2.0: Now uses the Node.js bridge for real framework integration.
+Falls back to CLI (npx 0xray) when bridge is unavailable.
+            ["npx", "0xray"] + args,
+        return json.dumps({"error": "0xray not found. Run: npm install -g 0xray"})
+    except subprocess.TimeoutExpired:
+        return json.dumps({"error": f"Command timed out after {timeout}s"})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+# ── Tool: strray_validate ─────────────────────────────────────
+
+def strray_validate(args: dict, **kwargs) -> str:
+    """Run pre-commit validation on files using the framework.
+
+    Uses bridge for real quality gate + processor pipeline.
+    Falls back to CLI if bridge unavailable.
+    """
+    files = args.get("files", [])
+    operation = args.get("operation", "commit")
+
+    if not files:
+        return json.dumps({"error": "No files specified for validation"})
+
+    # Try bridge first (real framework integration)
+    bridge_result = _bridge_call({
+        "command": "validate",
+        "files": files,
+        "operation": operation,
+    }, timeout=30)
+
+    if "error" not in bridge_result:
+        return json.dumps({
+            "status": "passed" if bridge_result.get("passed") else "violations",
+            "operation": operation,
+            "files_checked": len(files),
+            "file_results": bridge_result.get("fileResults", []),
+            "via": "bridge",
+        })
+
+    # Fallback to CLI
+    result = json.loads(_run_strray(["validate"], timeout=30))
+    if "error" in result:
+        return json.dumps(result)
+
+    return json.dumps({
+        "status": "ok" if result.get("status") == "ok" else "validation_issues",
+        "operation": operation,
+        "files_checked": len(files),
+        "output": result.get("output", ""),
+        "via": "cli",
+    })
+
+
+# ── Tool: strray_codex_check ──────────────────────────────────
+
+def strray_codex_check(args: dict, **kwargs) -> str:
+    """Check code against StringRay codex rules.
+
+    Uses bridge for real quality gate codex checks.
+    Falls back to CLI if bridge unavailable.
+    """
+    code = args.get("code")
+    operation = args.get("operation", "create")
+    focus_areas = args.get("focus_areas", [])
+
+    # Use 'is not None' to correctly handle empty string
+    if code is not None:
+        # Try bridge for real codex checking
+        bridge_result = _bridge_call({
+            "command": "codex-check",
+            "code": code,
+            "focusAreas": focus_areas,
+        }, timeout=15)
+
+        if "error" not in bridge_result:
+            return json.dumps({
+                "status": "passed" if bridge_result.get("passed") else "violations",
+                "operation": operation,
+                "focus_areas": focus_areas or "all",
+                "code_length": len(code),
+                "violations": bridge_result.get("violations", []),
+                "checks": bridge_result.get("checks", []),
+                "via": "bridge",
+            })
+
+        # Bridge unavailable — fall back to static analysis
+        return json.dumps({
+            "status": "checked",
+            "operation": operation,
+            "focus_areas": focus_areas or "all",
+            "code_length": len(code),
+            "note": "Bridge unavailable — basic analysis only. "
+                   "Full codex validation available via MCP: mcp_strray_enforcer_codex_enforcement",
+            "via": "static",
+        })
+
+    # No code provided — check framework health
+    bridge_result = _bridge_call({"command": "health"}, timeout=10)
+    if "error" not in bridge_result:
+        return json.dumps({
+            "status": "ok",
+            "framework": bridge_result.get("framework"),
+            "version": bridge_result.get("version"),
+            "components": bridge_result.get("components"),
+            "note": "Pass 'code' parameter for actual codex validation",
+            "via": "bridge",
+        })
+
+    result = json.loads(_run_strray(["health"], timeout=15))
+    if "error" in result:
+        return json.dumps(result)
+
+    return json.dumps({
+        "status": "ok",
+        "health_output": result.get("output", ""),
+        "note": "Pass 'code' parameter for actual codex validation",
+        "via": "cli",
+    })
+
+
+# ── Tool: strray_health ───────────────────────────────────────
+
+def strray_health(args: dict, **kwargs) -> str:
+    """Check StringRay framework health via bridge.
+
+    Returns framework status, loaded components, version.
+    """
+    bridge_result = _bridge_call({"command": "health"}, timeout=10)
+    if "error" not in bridge_result:
+        return json.dumps({
+            "status": "ok",
+            "framework": bridge_result.get("framework"),
+            "version": bridge_result.get("version"),
+            "project_root": bridge_result.get("projectRoot"),
+            "components": bridge_result.get("components"),
+            "node_version": bridge_result.get("nodeVersion"),
+            "via": "bridge",
+        })
+
+    # Fallback to CLI
+    return _run_strray(["health"], timeout=15)
+
+
+# ── Tool: strray_hooks ───────────────────────────────────────
+
+def strray_hooks(args: dict, **kwargs) -> str:
+    """Manage StringRay git hooks.
+
+    Actions: install, uninstall, list, status
+    Uses bridge for hook management when available.
+    Falls back to direct file-based management when bridge unavailable.
+    """
+    action = args.get("action", "list")
+    hooks = args.get("hooks", ["pre-commit", "post-commit", "pre-push", "post-push"])
+
+    # Try bridge first
+    bridge_result = _bridge_call({
+        "command": "hooks",
+        "action": action,
+        "hooks": hooks,
+    }, timeout=15)
+
+    if "error" not in bridge_result:
+        return json.dumps({
+            "status": "ok",
+            "action": action,
+            "hooks": hooks,
+            "result": bridge_result,
+            "via": "bridge",
+        })
+
+    # Fallback: direct file-based hook management
+    git_hooks_dir = Path(_get_project_root()) / ".git" / "hooks"
+    strray_hooks_dir = Path(_get_project_root()) / "hooks"
+
+    if not git_hooks_dir.exists():
+        return json.dumps({"error": "Not a git repository", "via": "fallback"})
+
+    if action in ("list", "status"):
+        result = {"managed": [], "missing": [], "external": [], "stale": []}
+        for hook_name in hooks:
+            git_hook = git_hooks_dir / hook_name
+            strray_hook = strray_hooks_dir / hook_name
+            if not git_hook.exists():
+                result["missing"].append(hook_name)
+            else:
+                try:
+                    content = git_hook.read_text()[:500]
+                    if "StringRay" in content or "strray" in content or "run-hook.js" in content:
+                        result["managed"].append(hook_name)
+                    else:
+                        result["external"].append(hook_name)
+                except OSError:
+                    result["external"].append(hook_name)
+            if not strray_hook.exists():
+                result["stale"].append(hook_name)
+        return json.dumps({"status": "ok", "action": action, **result, "via": "fallback"})
+
+    if action == "install":
+        installed = []
+        skipped = []
+        for hook_name in hooks:
+            src = strray_hooks_dir / hook_name
+            dst = git_hooks_dir / hook_name
+            if not src.exists():
+                skipped.append(hook_name)
+                continue
+            try:
+                if dst.exists():
+                    try:
+                        content = dst.read_text()[:500]
+                        if "StringRay" not in content and "strray" not in content:
+                            dst.rename(dst.with_suffix(".strray-backup"))
+                        else:
+                            dst.unlink()
+                    except OSError:
+                        pass
+                try:
+                    rel = os.path.relpath(str(src), str(git_hooks_dir))
+                    os.symlink(rel, dst)
+                except OSError:
+                    shutil.copy2(src, dst)
+                installed.append(hook_name)
+            except OSError:
+                pass
+        return json.dumps({"status": "ok", "action": "install", "installed": installed, "skipped": skipped, "via": "fallback"})
+
+    if action == "uninstall":
+        removed = []
+        restored = []
+        for hook_name in hooks:
+            dst = git_hooks_dir / hook_name
+            backup = dst.with_suffix(".strray-backup")
+            if not dst.exists():
+                continue
+            try:
+                content = dst.read_text()[:500]
+                is_strray = "StringRay" in content or "strray" in content or "run-hook.js" in content
+                if is_strray or dst.is_symlink():
+                    dst.unlink()
+                    if backup.exists():
+                        shutil.move(str(backup), str(dst))
+                        restored.append(hook_name)
+                    else:
+                        removed.append(hook_name)
+            except OSError:
+                pass
+        return json.dumps({"status": "ok", "action": "uninstall", "removed": removed, "restored": restored, "via": "fallback"})
+
+    return json.dumps({"error": f"Unknown action: {action}", "via": "fallback"})

package/dist/integrations/openclaw/README.md

@@ -0,0 +1,134 @@
+# OpenClaw Integration
+
+StringRay integration for OpenClaw - a self-hosted AI gateway that connects messaging platforms to AI coding agents.
+
+## Overview
+
+This integration allows StringRay to:
+- Connect to OpenClaw Gateway via WebSocket
+- Expose StringRay capabilities through OpenClaw skills
+- Send tool execution events to OpenClaw for real-time tracking
+- Receive commands from OpenClaw channels (WhatsApp, Telegram, Discord, etc.)
+
+## Architecture
+
+```
+┌──────────────┐     ┌──────────────┐     ┌──────────────┐
+│   User       │────▶│  OpenClaw    │────▶│   StringRay   │
+│  (WhatsApp,  │     │   Gateway    │     │    Skills    │
+│  Discord,    │     │              │     │              │
+│  Telegram)   │◀────│              │◀────│              │
+└──────────────┘     └──────────────┘     └──────────────┘
+                           │
+                           ▼
+                   ┌──────────────┐
+                   │  WebSocket   │
+                   │   Client     │
+                   └──────────────┘
+```
+
+## Installation
+
+### 1. Install Dependencies
+
+```bash
+npm install ws
+```
+
+### 2. Configure OpenClaw
+
+Create `.strray/config/openclaw.json`:
+
+```json
+{
+  "gatewayUrl": "ws://127.0.0.1:18789",
+  "authToken": "your-auth-token",
+  "deviceId": "your-device-id",
+  "apiServer": {
+    "enabled": true,
+    "port": 18431,
+    "host": "127.0.0.1",
+    "apiKey": "your-api-key"
+  },
+  "hooks": {
+    "enabled": true
+  },
+  "enabled": true
+}
+```
+
+### 3. Install OpenClaw Skills
+
+Copy skills to your OpenClaw skills directory:
+
+```bash
+cp -r skills/* ~/.openclaw/skills/
+```
+
+## Usage
+
+### Initialize Integration
+
+```typescript
+import { initializeOpenClawIntegration } from './src/integrations/openclaw/index.js';
+
+const integration = await initializeOpenClawIntegration();
+
+// Or with custom agent invoker
+const integration = await initializeOpenClawIntegration('/path/to/config.json', myAgentInvoker);
+```
+
+### Using OpenClaw Commands
+
+After installation, use these commands in any OpenClaw channel:
+
+- `/strray` - Show status
+- `/strray-analyze <file>` - Analyze code
+- `/strray-code <file>` - Code review
+- `/strray-file <file>` - Read file
+- `/strray-exec <command>` - Execute command
+
+## Configuration
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `gatewayUrl` | string | `ws://127.0.0.1:18789` | OpenClaw WebSocket URL |
+| `authToken` | string | - | Authentication token |
+| `deviceId` | string | - | Device ID for pairing |
+| `apiServer.enabled` | boolean | `true` | Enable HTTP API server |
+| `apiServer.port` | number | `18431` | API server port |
+| `apiServer.host` | string | `127.0.0.1` | API server host |
+| `apiServer.apiKey` | string | - | API key for auth |
+| `hooks.enabled` | boolean | `true` | Enable tool hooks |
+| `autoReconnect` | boolean | `true` | Auto reconnect |
+| `enabled` | boolean | `true` | Enable integration |
+
+## API Server
+
+The integration exposes a local HTTP API on port 18431:
+
+- `GET /health` - Health check
+- `POST /api/agent/invoke` - Invoke agent
+- `GET /api/agent/status` - Agent status
+
+## Skills
+
+### stringray-orchestrator
+
+Main skill providing StringRay commands:
+
+```markdown
+/strray                    - Show status
+/strray-analyze <file>    - Analyze code
+/strray-code <file>       - Code review
+/strray-file <file>       - Read file
+/strray-exec <command>    - Execute command
+```
+
+## Documentation
+
+See `docs/research/openclaw/` for detailed documentation.
+
+## License
+
+MIT