0xray 2.1.1 → 2.1.3

package/src/mcps/state-manager.server.ts

@@ -4,16 +4,11 @@
  * Advanced state management with persistence, synchronization, and conflict resolution
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  type CallToolResult,
-} from "@modelcontextprotocol/sdk/types.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import fs from "fs";
 import path from "path";
 import { frameworkLogger, generateJobId } from "../core/framework-logger.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface GetStateArgs {
   key: string;
@@ -62,23 +57,130 @@ interface ValidationResult {
 
 type StateValue = string | number | boolean | object | null | undefined;
 
-class StrRayStateManagerServer {
-  private server: Server;
+class StrRayStateManagerServer extends XrayKnowledgeSkillBase {
   private state: Map<string, unknown> = new Map();
   private stateFile: string;
   private backups: Map<string, unknown> = new Map();
 
   constructor() {
-    this.server = new Server(
+    super("state-manager", "2.0.1");
+
+    this.tools = [
       {
-        name: "state-manager", version: "2.0.1",
+        name: "get-state",
+        description:
+          "Get state value by key with type safety and validation",
+        inputSchema: {
+          type: "object",
+          properties: {
+            key: { type: "string" },
+            defaultValue: {
+              oneOf: [
+                { type: "string" },
+                { type: "number" },
+                { type: "boolean" },
+                { type: "object" },
+                { type: "array" },
+              ],
+            },
+            validate: { type: "boolean", default: true },
+          },
+          required: ["key"],
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        name: "set-state",
+        description:
+          "Set state value by key with conflict resolution and persistence",
+        inputSchema: {
+          type: "object",
+          properties: {
+            key: { type: "string" },
+            value: {
+              oneOf: [
+                { type: "string" },
+                { type: "number" },
+                { type: "boolean" },
+                { type: "object" },
+                { type: "array" },
+              ],
+            },
+            persist: { type: "boolean", default: true },
+            backup: { type: "boolean", default: false },
+          },
+          required: ["key", "value"],
         },
       },
-    );
+      {
+        name: "delete-state",
+        description:
+          "Delete state value by key with cleanup and validation",
+        inputSchema: {
+          type: "object",
+          properties: {
+            key: { type: "string" },
+            force: { type: "boolean", default: false },
+          },
+          required: ["key"],
+        },
+      },
+      {
+        name: "list-state",
+        description: "List all state keys with filtering and metadata",
+        inputSchema: {
+          type: "object",
+          properties: {
+            prefix: { type: "string" },
+            includeValues: { type: "boolean", default: false },
+            limit: { type: "number", default: 100 },
+          },
+        },
+      },
+      {
+        name: "backup-state",
+        description: "Create backup of current state or specific keys",
+        inputSchema: {
+          type: "object",
+          properties: {
+            keys: { type: "array", items: { type: "string" } },
+            name: { type: "string" },
+          },
+        },
+      },
+      {
+        name: "restore-state",
+        description: "Restore state from backup",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            keys: { type: "array", items: { type: "string" } },
+          },
+          required: ["name"],
+        },
+      },
+      {
+        name: "validate-state",
+        description: "Validate state integrity and consistency",
+        inputSchema: {
+          type: "object",
+          properties: {
+            deep: { type: "boolean", default: false },
+            repair: { type: "boolean", default: false },
+          },
+        },
+      },
+    ];
+
+    this.handlers = {
+      "get-state": async (args) => this.handleGetState(args as unknown as GetStateArgs),
+      "set-state": async (args) => this.handleSetState(args as unknown as SetStateArgs),
+      "delete-state": async (args) => this.handleDeleteState(args as unknown as DeleteStateArgs),
+      "list-state": async (args) => this.handleListState(args as unknown as ListStateArgs),
+      "backup-state": async (args) => this.handleBackupState(args as unknown as BackupStateArgs),
+      "restore-state": async (args) => this.handleRestoreState(args as unknown as RestoreStateArgs),
+      "validate-state": async (args) => this.handleValidateState(args as unknown as ValidateStateArgs),
+    };
 
     this.stateFile = path.join(
       process.cwd(),
@@ -151,153 +253,6 @@ class StrRayStateManagerServer {
     }
   }
 
-  private setupToolHandlers() {
-    // List available tools
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "get-state",
-            description:
-              "Get state value by key with type safety and validation",
-            inputSchema: {
-              type: "object",
-              properties: {
-                key: { type: "string" },
-                defaultValue: {
-                  oneOf: [
-                    { type: "string" },
-                    { type: "number" },
-                    { type: "boolean" },
-                    { type: "object" },
-                    { type: "array" },
-                  ],
-                },
-                validate: { type: "boolean", default: true },
-              },
-              required: ["key"],
-            },
-          },
-          {
-            name: "set-state",
-            description:
-              "Set state value by key with conflict resolution and persistence",
-            inputSchema: {
-              type: "object",
-              properties: {
-                key: { type: "string" },
-                value: {
-                  oneOf: [
-                    { type: "string" },
-                    { type: "number" },
-                    { type: "boolean" },
-                    { type: "object" },
-                    { type: "array" },
-                  ],
-                },
-                persist: { type: "boolean", default: true },
-                backup: { type: "boolean", default: false },
-              },
-              required: ["key", "value"],
-            },
-          },
-          {
-            name: "delete-state",
-            description:
-              "Delete state value by key with cleanup and validation",
-            inputSchema: {
-              type: "object",
-              properties: {
-                key: { type: "string" },
-                force: { type: "boolean", default: false },
-              },
-              required: ["key"],
-            },
-          },
-          {
-            name: "list-state",
-            description: "List all state keys with filtering and metadata",
-            inputSchema: {
-              type: "object",
-              properties: {
-                prefix: { type: "string" },
-                includeValues: { type: "boolean", default: false },
-                limit: { type: "number", default: 100 },
-              },
-            },
-          },
-          {
-            name: "backup-state",
-            description: "Create backup of current state or specific keys",
-            inputSchema: {
-              type: "object",
-              properties: {
-                keys: { type: "array", items: { type: "string" } },
-                name: { type: "string" },
-              },
-            },
-          },
-          {
-            name: "restore-state",
-            description: "Restore state from backup",
-            inputSchema: {
-              type: "object",
-              properties: {
-                name: { type: "string" },
-                keys: { type: "array", items: { type: "string" } },
-              },
-              required: ["name"],
-            },
-          },
-          {
-            name: "validate-state",
-            description: "Validate state integrity and consistency",
-            inputSchema: {
-              type: "object",
-              properties: {
-                deep: { type: "boolean", default: false },
-                repair: { type: "boolean", default: false },
-              },
-            },
-          },
-        ],
-      };
-    });
-
-    // Handle tool calls
-    this.server.setRequestHandler(CallToolRequestSchema, async (request): Promise<CallToolResult> => {
-      try {
-        const { name, arguments: args } = request.params;
-
-        switch (name) {
-          case "get-state":
-            return await this.handleGetState(args as unknown as GetStateArgs);
-          case "set-state":
-            return await this.handleSetState(args as unknown as SetStateArgs);
-          case "delete-state":
-            return await this.handleDeleteState(args as unknown as DeleteStateArgs);
-          case "list-state":
-            return await this.handleListState(args as unknown as ListStateArgs);
-          case "backup-state":
-            return await this.handleBackupState(args as unknown as BackupStateArgs);
-          case "restore-state":
-            return await this.handleRestoreState(args as unknown as RestoreStateArgs);
-          case "validate-state":
-            return await this.handleValidateState(args as unknown as ValidateStateArgs);
-          default:
-            throw new Error(`Unknown tool: ${name}`);
-        }
-      } catch (error) {
-        return {
-          content: [{
-            type: "text" as const,
-            text: `Error handling tool '${request.params.name}': ${error instanceof Error ? error.message : String(error)}`,
-          }],
-        };
-      }
-    });
-  }
-
   private async handleGetState(args: GetStateArgs): Promise<CallToolResult> {
     const key = args.key;
     const defaultValue = args.defaultValue;
@@ -753,25 +708,12 @@ ${results.repairedKeys.length > 0 ? `**Repaired Keys:**\n${results.repairedKeys.
     return dependents;
   }
 
-  async run() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    const jobId = generateJobId("mcp-state-manager-start");
-    frameworkLogger.log(
-      "mcps/state-manager",
-      "start",
-      "success",
-      {},
-      undefined,
-      jobId,
-    );
-  }
 }
 
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
   const server = new StrRayStateManagerServer();
-  server.run().catch((error) => frameworkLogger.log("mcps/state-manager", "run", "error", { error: String(error) }));
+  server.run("state-manager").catch((error) => frameworkLogger.log("mcps/state-manager", "run", "error", { error: String(error) }));
 }
 
 export { StrRayStateManagerServer };

package/src/opencode/codex.codex

@@ -1,5 +1,5 @@
 {
-  "version": "2.0.1",
+  "version": "2.1.1",
   "terms": [
      1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68
   ],

package/src/opencode/commands/dependency-audit.md

@@ -69,7 +69,7 @@ Comprehensive dependency analysis and security audit for all project dependencie
   "vulnerabilities": [
     {
       "package": "lodash",
-      "version": "2.0.1",
+      "version": "2.1.1",
       "severity": "high",
       "cve": "CVE-2021-23337",
       "description": "Command injection vulnerability"
@@ -85,14 +85,14 @@ Security-focused format for CI/CD integration:
 
 ```json
 {
-  "version": "2.0.1",
+  "version": "2.1.1",
   "$schema": "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
   "runs": [
     {
       "tool": {
         "driver": {
           "name": "Dependency Audit",
-          "version": "2.0.1"
+          "version": "2.1.1"
         }
       },
       "results": [...]

package/src/opencode/enforcer-config.json

@@ -1,6 +1,6 @@
 {
   "framework": "xray 2.0",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "description": "Codex-compliant framework configuration for Credible UI project",
   "thresholds": {
     "bundleSize": {
@@ -220,7 +220,7 @@
       }
     },
     "codex": {
-      "version": "2.0.1",
+      "version": "2.1.1",
       "terms": [
         1,
         2,

package/src/skills/registry.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.0.1",
+  "version": "2.1.1",
   "description": "0xRay Skills Registry - recommended skill sources for consumers",
   "sources": [
     {

package/xray/agents_template.md

@@ -0,0 +1,109 @@
+# StringRay AI v1.15.1 – Agent Context & Universal Development Codex
+
+**Framework Version**: 1.14.0  
+**Codex Version**: 1.7.5 (condensed)  
+**Last Updated**: 2026-03-23  
+**Purpose**: Systematic error prevention and production-ready AI-assisted development
+
+## 🎯 CRITICAL RULES – ZERO TOLERANCE (MANDATORY)
+
+1. **Full File Reading Before Edit**  
+   ALWAYS read the ENTIRE file using the `read` tool before ANY edit, refactor, or write.  
+   Understand complete structure, imports, dependencies, and context.  
+   Partial/contextual edits are strictly forbidden.
+
+2. **Verify Changes Actually Applied**  
+   After every edit/write: use `read` to confirm the exact changes are present.  
+   Check for regressions and unintended modifications.  
+   NEVER declare success without observable verification.
+
+3. **Command & Tool Output Review**  
+   Immediately review ALL command/tool outputs.  
+   Identify errors, warnings, or anomalies.  
+   Add TODO for course correction if issues found.  
+   Do not proceed until critical problems are resolved.
+
+4. **No False Success Claims**  
+   Only report "completed", "edited", or "fixed" after verification steps confirm success.  
+   Prohibited: assuming success, subjective "looks correct", skipping checks for "trivial" changes.
+
+5. **Surgical & Progressive Fixes**  
+   Fix root causes minimally – no patches, stubs, or over-engineering.  
+   All code must be production-ready from first commit.
+
+6. **Error & Loop Prevention**  
+   Resolve all errors before continuing (90%+ runtime prevention target).  
+   Every loop/async must have clear termination/timeout.
+
+7. **Type Safety & Immutability First**  
+   No `any`, `@ts-ignore`. Prefer immutable patterns and early returns/guards.
+
+8. **DRY, YAGNI, Separation of Concerns**  
+   No duplication. No unnecessary features. One responsibility per module/function.
+
+9. **Test & Performance Awareness**  
+   >85% behavioral coverage target. Respect bundle <2MB, FCP <2s budgets.
+
+10. **Security & Input Validation**  
+    Validate/sanitize all inputs. Security by design.
+
+## Core Codex Terms (Top 20 – Enforced)
+
+1. Progressive production-ready code  
+2. No patches/stubs/bridge code  
+3. Avoid over-engineering  
+4. Fit-for-purpose prod-level code  
+5. Surgical root-cause fixes  
+6. Batched introspection cycles  
+7. Resolve all errors (90% prevention)  
+8. Prevent infinite loops/timeouts  
+9. Shared global state / single source of truth  
+10. Type safety first (no `any`)  
+11. Early returns & guard clauses  
+12. Error boundaries & graceful degradation  
+13. Immutability preferred  
+14. Separation of concerns  
+15. DRY – eliminate duplication  
+16. YAGNI – no speculative features  
+17. Meaningful, self-documenting names  
+18. Small, focused functions (<30 lines ideal)  
+19. Consistent style (linter enforced)  
+20. Test coverage >85% (behavioral focus)
+
+## Agent Capabilities Matrix
+
+| Agent                     | Role                              | Complexity | Key Tools                              | Strategy          |
+|---------------------------|-----------------------------------|------------|----------------------------------------|-------------------|
+| enforcer                  | Codex & error prevention          | All        | read, grep, lsp_*, bash                | Block violations  |
+| orchestrator              | Workflow coordination             | Enterprise | read, grep, call_omo_agent, session_*  | Consensus         |
+| architect                 | Design & decisions                | High       | read, grep, lsp_*, background_task     | Expert priority   |
+| bug-triage-specialist     | Error investigation & fixes       | Debug      | read, grep, ast_grep_*                 | Majority vote     |
+| code-reviewer             | Quality & standards               | Changes    | read, grep, lsp_diagnostics            | Expert priority   |
+| security-auditor          | Vulnerabilities & compliance      | Security   | read, grep, grep_app_searchGitHub      | Block critical    |
+| refactorer                | Debt & consolidation              | Refactor   | read, grep, lsp_rename, ast_grep_*     | Majority vote     |
+| testing-lead              | Testing strategy & coverage       | Tests      | read, grep, lsp_*                      | Expert priority   |
+| storyteller               | Narrative deep reflections       | Narrative  | read, grep, write                      | Expert priority   |
+| researcher                | Codebase exploration              | Research   | read, grep, codesearch, websearch       | Expert priority   |
+
+## Complexity Routing Summary
+
+Score = (files×2 + change/10 + deps×3 + duration/10) × operation_weight × risk_mult  
+- Operation weights: debug 2.0, refactor 1.8, analyze 1.5, modify 1.2, others 1.0  
+- Risk multipliers: critical 1.6, high 1.3, medium 1.0, low 0.8  
+Thresholds:  
+- ≤15 → single agent  
+- 16–50 → multi-agent possible  
+- 51+ → orchestrator-led
+
+## Operational Guidelines
+
+- Evaluate complexity before execution  
+- Always verify: read full file → apply change → read again → confirm no regressions  
+- Use `call_omo_agent` or `task()` for delegation  
+- Log JobId for traceability  
+- Enforce codex compliance on every operation
+
+**Codex Enforcement**: All actions validated against these rules. Violations block progress until resolved.  
+**Target**: 99.6% systematic error prevention through verification-first behavior.
+
+(End of file - total 105 lines)