0xray 3.0.12 → 3.1.0

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("xray") && !this.detectDevelopment()));
+            (this.currentDir.includes("strray") && !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("xray") && this.detectBuilt()));
+            (this.currentDir.includes("strray") && this.detectBuilt()));
     }
     /**
      * Resolve agent import path for current environment
@@ -110,4 +110,3 @@ export class PathResolver {
 }
 // Export singleton instance
 export const pathResolver = PathResolver.getInstance();
-//# sourceMappingURL=path-resolver.js.map

package/dist/utils/shutdown-handler.js

@@ -73,4 +73,3 @@ export function createGracefulShutdown(options) {
     setTimeout(checkParent, 2000);
     return { cleanup, stop };
 }
-//# sourceMappingURL=shutdown-handler.js.map

package/dist/utils/task-graph.js

@@ -104,4 +104,3 @@ export function resolveConflicts(conflicts, strategy) {
         expertiseScore: bestConflict.expertiseScore || 0,
     };
 }
-//# sourceMappingURL=task-graph.js.map

package/dist/utils/test-template-generator.js

@@ -0,0 +1,178 @@
+/**
+ * Test Template Generator for 0xRay Framework
+ *
+ * Automatically generates test templates for different file types
+ * to ensure consistent test coverage and structure.
+ */
+import { frameworkLogger } from "../core/framework-logger.js";
+import fs from "fs";
+/**
+ * Generate a test template based on file type and structure
+ */
+export function generateTestTemplate(options) {
+    const { filePath, componentName, exports = [], isReact = false, isTypeScript = false, } = options;
+    const fileName = filePath
+        .split("/")
+        .pop()
+        ?.replace(/\.(ts|tsx|js|jsx)$/, "") || "Unknown";
+    const testFileName = `${fileName}.test.${isTypeScript ? "ts" : "js"}${isReact ? "x" : ""}`;
+    if (isReact) {
+        return generateReactTestTemplate(fileName, componentName || fileName, isTypeScript);
+    }
+    return generateUnitTestTemplate(fileName, exports, isTypeScript);
+}
+/**
+ * Generate React component test template
+ */
+function generateReactTestTemplate(fileName, componentName, isTypeScript) {
+    const typeAnnotation = isTypeScript ? ": RenderResult" : "";
+    const typeImport = isTypeScript ? ", RenderResult" : "";
+    return `import { render, screen } from '@testing-library/react';
+import { expect, describe, it${typeImport} } from '${isTypeScript ? "vitest" : "jest"}';
+import { ${componentName} } from './${fileName}';
+
+describe('${componentName}', () => {
+  it('should render successfully', () => {
+    const { container }${typeAnnotation} = render(<${componentName} />);
+    expect(container).toBeInTheDocument();
+  });
+
+  it('should render with default props', () => {
+    render(<${componentName} />);
+    // Add specific assertions based on component behavior
+    expect(screen.getByRole('generic')).toBeInTheDocument();
+  });
+
+  // Add more test cases based on component props and behavior
+  // it('should handle prop changes', () => {
+  //   const { rerender } = render(<${componentName} prop="value" />);
+  //   expect(screen.getByText('value')).toBeInTheDocument();
+  //
+  //   rerender(<${componentName} prop="newValue" />);
+  //   expect(screen.getByText('newValue')).toBeInTheDocument();
+  // });
+
+  // Add accessibility tests
+  it('should be accessible', () => {
+    const { container } = render(<${componentName} />);
+    expect(container).toBeAccessible();
+  });
+});
+`;
+}
+/**
+ * Generate unit test template for utility functions/classes
+ */
+function generateUnitTestTemplate(fileName, exports, isTypeScript) {
+    const describeBlocks = exports
+        .map((exportName) => {
+        if (exportName.match(/^[A-Z]/)) {
+            // Class export
+            return generateClassTestTemplate(exportName);
+        }
+        else {
+            // Function export
+            return generateFunctionTestTemplate(exportName);
+        }
+    })
+        .join("\n\n");
+    return `import { expect, describe, it } from '${isTypeScript ? "vitest" : "jest"}';
+${exports.length > 0 ? `import { ${exports.join(", ")} } from './${fileName}';` : `// import functions from './${fileName}'`}
+
+${describeBlocks}
+
+describe('${fileName}', () => {
+  // Add general module tests here
+  it('should export expected functions', () => {
+    ${exports.length > 0 ? exports.map((exp) => `expect(typeof ${exp}).toBe('function');`).join("\n    ") : "// Add export tests"}
+  });
+});
+`;
+}
+/**
+ * Generate test template for a class
+ */
+function generateClassTestTemplate(className) {
+    return `describe('${className}', () => {
+  let instance: ${className};
+
+  beforeEach(() => {
+    // instance = new ${className}();
+  });
+
+  it('should create instance successfully', () => {
+    // expect(instance).toBeInstanceOf(${className});
+    expect(true).toBe(true); // Placeholder test
+  });
+
+  // Add method tests
+  // it('should have expected methods', () => {
+  //   expect(typeof instance.methodName).toBe('function');
+  // });
+
+  // Add property tests
+  // it('should have expected properties', () => {
+  //   expect(instance.propertyName).toBeDefined();
+  // });
+});`;
+}
+/**
+ * Generate test template for a function
+ */
+function generateFunctionTestTemplate(functionName) {
+    return `describe('${functionName}', () => {
+  it('should be a function', () => {
+    expect(typeof ${functionName}).toBe('function');
+  });
+
+  it('should handle basic input', () => {
+    // const result = ${functionName}(/* test input */);
+    // expect(result).toBe(/* expected output */);
+    expect(true).toBe(true); // Placeholder test
+  });
+
+  it('should handle edge cases', () => {
+    // Test null, undefined, empty inputs
+    // expect(() => ${functionName}(null)).toThrow();
+    expect(true).toBe(true); // Placeholder test
+  });
+
+  // Add more specific test cases based on function behavior
+});`;
+}
+/**
+ * Analyze a source file to extract exports for test generation
+ */
+export function analyzeSourceFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        const exports = [];
+        const isReact = /\b(React|jsx?|tsx?)\b/.test(content) ||
+            filePath.endsWith(".tsx") ||
+            filePath.endsWith(".jsx");
+        const isTypeScript = filePath.endsWith(".ts") || filePath.endsWith(".tsx");
+        // Extract named exports
+        const exportMatches = content.match(/export\s+(?:const|function|class|let|var)\s+(\w+)/g);
+        if (exportMatches) {
+            exportMatches.forEach((match) => {
+                const nameMatch = match.match(/(?:const|function|class|let|var)\s+(\w+)/);
+                if (nameMatch && nameMatch[1] && !exports.includes(nameMatch[1])) {
+                    exports.push(nameMatch[1]);
+                }
+            });
+        }
+        // Extract default export if no named exports found
+        if (exports.length === 0 && /export\s+default/.test(content)) {
+            const fileName = filePath
+                .split("/")
+                .pop()
+                ?.replace(/\.(ts|tsx|js|jsx)$/, "") || "Component";
+            exports.push(fileName.charAt(0).toUpperCase() + fileName.slice(1));
+        }
+        return { exports, isReact, isTypeScript };
+    }
+    catch (error) {
+        frameworkLogger.log("test-template-generator", "analyze-file", "error", { error, message: `Error analyzing ${filePath}:` });
+        return { exports: [], isReact: false, isTypeScript: false };
+    }
+}

package/dist/utils/token-manager.js

@@ -0,0 +1,163 @@
+import * as fs from "fs";
+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(), ".xray", "config.json")) {
+        this.config = this.loadConfig(configPath);
+    }
+    loadConfig(configPath) {
+        try {
+            const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            return (config.token_management || {
+                maxPromptTokens: 20000,
+                warningThreshold: 15000,
+                modelLimits: {},
+                contextPruning: {
+                    enabled: true,
+                    aggressivePruning: true,
+                    preserveCriticalContext: true,
+                },
+            });
+        }
+        catch (error) {
+            // Fallback defaults if config loading fails
+            return {
+                maxPromptTokens: 20000,
+                warningThreshold: 15000,
+                modelLimits: {},
+                contextPruning: {
+                    enabled: true,
+                    aggressivePruning: true,
+                    preserveCriticalContext: true,
+                },
+            };
+        }
+    }
+    /**
+     * Estimate token count for text (rough approximation)
+     * Uses 4 characters per token as a conservative estimate
+     */
+    estimateTokens(text) {
+        return Math.ceil(text.length / 4);
+    }
+    /**
+     * Check if prompt exceeds limits
+     */
+    checkLimits(prompt, modelName) {
+        const currentTokens = this.estimateTokens(prompt);
+        const maxTokens = modelName
+            ? this.config.modelLimits[modelName] || this.config.maxPromptTokens
+            : this.config.maxPromptTokens;
+        const withinLimit = currentTokens <= maxTokens;
+        const needsPruning = currentTokens > this.config.maxPromptTokens;
+        const warning = currentTokens > this.config.warningThreshold;
+        return {
+            withinLimit,
+            currentTokens,
+            maxTokens,
+            needsPruning,
+            warning,
+        };
+    }
+    /**
+     * Prune context to fit within token limits
+     */
+    pruneContext(context, targetTokens = this.config.maxPromptTokens) {
+        if (!this.config.contextPruning.enabled) {
+            return context;
+        }
+        const currentTokens = this.estimateTokens(context);
+        if (currentTokens <= targetTokens) {
+            return context; // No pruning needed
+        }
+        // Preserve critical sections (AGENTS.md header, codex terms, etc.)
+        const criticalSections = this.extractCriticalSections(context);
+        const criticalTokens = this.estimateTokens(criticalSections.join("\n"));
+        // Calculate available tokens for non-critical content
+        const availableTokens = Math.max(targetTokens - criticalTokens, targetTokens * 0.3); // Reserve at least 30%
+        const nonCriticalContent = this.extractNonCriticalContent(context);
+        const prunedNonCritical = this.pruneNonCriticalContent(nonCriticalContent, availableTokens);
+        return `${criticalSections.join("\n")}\n\n${prunedNonCritical}`;
+    }
+    extractCriticalSections(context) {
+        const lines = context.split("\n");
+        const criticalSections = [];
+        // Always preserve codex terms and framework overview
+        const codexSection = this.extractSection(lines, "Universal Development Codex");
+        const frameworkSection = this.extractSection(lines, "0xRay Framework");
+        if (codexSection)
+            criticalSections.push(codexSection);
+        if (frameworkSection)
+            criticalSections.push(frameworkSection);
+        return criticalSections;
+    }
+    extractSection(lines, sectionTitle) {
+        const startIndex = lines.findIndex((line) => line.includes(sectionTitle));
+        if (startIndex === -1)
+            return null;
+        let endIndex = lines.length;
+        for (let i = startIndex + 1; i < lines.length; i++) {
+            const currentLine = lines[i];
+            if (currentLine &&
+                currentLine.startsWith("#") &&
+                currentLine !== lines[startIndex]) {
+                endIndex = i;
+                break;
+            }
+        }
+        return lines.slice(startIndex, endIndex).join("\n");
+    }
+    extractNonCriticalContent(context) {
+        const criticalSections = this.extractCriticalSections(context);
+        let result = context;
+        for (const section of criticalSections) {
+            result = result.replace(section, "");
+        }
+        return result.trim();
+    }
+    pruneNonCriticalContent(content, maxTokens) {
+        const lines = content.split("\n");
+        const result = [];
+        let currentTokens = 0;
+        for (const line of lines) {
+            const lineTokens = this.estimateTokens(line);
+            if (currentTokens + lineTokens <= maxTokens) {
+                result.push(line);
+                currentTokens += lineTokens;
+            }
+            else {
+                // Truncate line if too long
+                if (lineTokens > maxTokens * 0.1) {
+                    // If single line is >10% of limit
+                    const maxChars = maxTokens * 4 * 0.1; // Convert tokens to chars
+                    result.push(line.substring(0, maxChars) + "...[truncated]");
+                }
+                break;
+            }
+        }
+        return result.join("\n");
+    }
+    /**
+     * Generate warning message for token limits
+     */
+    generateWarning(limitCheck) {
+        if (limitCheck.withinLimit && !limitCheck.warning)
+            return "";
+        const messages = [];
+        if (limitCheck.warning) {
+            messages.push(`⚠️  Token usage warning: ${limitCheck.currentTokens.toLocaleString()} tokens (${((limitCheck.currentTokens / limitCheck.maxTokens) * 100).toFixed(1)}% of limit)`);
+        }
+        if (!limitCheck.withinLimit) {
+            messages.push(`🚨 Token limit exceeded: ${limitCheck.currentTokens.toLocaleString()} > ${limitCheck.maxTokens.toLocaleString()} tokens`);
+            messages.push("Context will be automatically pruned to fit within limits.");
+        }
+        return messages.join("\n");
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+}

package/dist/validation/estimation-validator.js

@@ -239,4 +239,3 @@ export function trackEstimate(taskId, description, category, estimatedMinutes) {
         return descriptor;
     };
 }
-//# sourceMappingURL=estimation-validator.js.map

package/dist/validation/report-content-validator.js

@@ -216,4 +216,3 @@ export class ReportContentValidator {
         this.reportPatterns[category].push(pattern);
     }
 }
-//# sourceMappingURL=report-content-validator.js.map

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "0xray",
-  "version": "3.0.12",
+  "version": "3.1.0",
   "description": "Multi-agent orchestration and Codex governance for OpenCode, Hermes, Grok Build, and OpenClaw",
+  "readme": "README.md",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/0xRayAI/xray.git"
+    "url": "https://github.com/0xRayAI/xray.git"
   },
   "homepage": "https://github.com/0xRayAI/xray#readme",
   "bugs": {
@@ -34,25 +35,13 @@
     "plugin-system"
   ],
   "type": "module",
-  "main": "./dist/plugin/xray-codex-injection.js",
-  "types": "./dist/plugin/xray-codex-injection.d.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
-    "./integration": {
-      "import": "./dist/integrations/enforcement-gate.js",
-      "types": "./dist/integrations/enforcement-gate.d.ts"
-    },
-    "./public": {
-      "import": "./dist/public/index.js",
-      "types": "./dist/public/index.d.ts"
-    },
-    "./nucleus": {
-      "import": "./dist/nucleus/index.js",
-      "types": "./dist/nucleus/index.d.ts"
-    },
     "./nucleus/*": {
       "import": "./dist/nucleus/*.js",
       "types": "./dist/nucleus/*.d.ts"
@@ -70,25 +59,22 @@
     "prepublishOnly": "npm run prepare-consumer && npm run build:all && find dist -name '*.d.ts' -o -name '*.d.ts.map' -o -name '*.js.map' | xargs rm -f",
     "version:bump": "node scripts/node/version-manager.mjs",
     "version": "node scripts/node/version-manager.mjs",
-    "postinstall": "node scripts/node/postinstall.cjs",
-    "prepare": "npm run build",
     "prebuild": "rm -rf dist tsconfig.tsbuildinfo tsconfig.*.tsbuildinfo",
-    "build": "tsc && tsc -p tsconfig.full.json 2>/dev/null || true && mkdir -p dist/public dist/scripts && cp -r public/* dist/public/ && cp scripts/hooks/pre-command dist/scripts/ && cp scripts/hooks/pre-command.mjs dist/scripts/ && cp README.md AGENTS.md CHANGELOG.md LICENSE dist/ && find src -name '*.mjs' ! -path '*/__tests__/*' | while read f; do tgt=\"dist/${f#src/}\"; mkdir -p \"$(dirname $tgt)\"; cp \"$f\" \"$tgt\"; done && find dist -name '*.d.ts' -path '*/__tests__/*' -delete; find dist -name '*.js' -path '*/__tests__/*' -delete; for dir in skills integrations mcps; do find src/$dir -type f ! -name '*.ts' ! -path '*/.pytest_cache/*' | while read f; do tgt=\"dist/${f#src/}\"; mkdir -p \"$(dirname $tgt)\"; cp \"$f\" \"$tgt\"; done; done && mkdir -p dist/plugin && (find dist/plugin -name '*codex-injection*.js' -exec cp {} dist/plugin/xray-codex-injection.js \\; 2>/dev/null || true) && cp -r src/opencode/ .opencode/ && mkdir -p .opencode/plugin && cp dist/plugin/xray-codex-injection.js .opencode/plugin/ && echo 'build artifacts in .opencode/xray/ removed — runtime reads from xray/ directly'",
+    "build": "tsc && mkdir -p dist/public dist/scripts && cp -r public/* dist/public/ && cp scripts/hooks/pre-command dist/scripts/ && cp scripts/hooks/pre-command.mjs dist/scripts/ && cp README.md AGENTS.md CHANGELOG.md LICENSE dist/ && find src -name '*.mjs' ! -path '*/__tests__/*' | while read f; do tgt=\"dist/${f#src/}\"; mkdir -p \"$(dirname $tgt)\"; cp \"$f\" \"$tgt\"; done && for dir in skills integrations mcps; do find src/$dir -type f ! -name '*.ts' ! -path '*/.pytest_cache/*' | while read f; do tgt=\"dist/${f#src/}\"; mkdir -p \"$(dirname $tgt)\"; cp \"$f\" \"$tgt\"; done; done && mkdir -p dist/plugin && (find dist/plugin -name '*codex-injection*.js' -exec cp {} dist/plugin/xray-codex-injection.js \\; 2>/dev/null || true) && cp -r src/opencode/ .opencode/ && rm -rf .opencode/xray 2>/dev/null; mkdir -p .opencode/xray && cp xray/codex.json .opencode/xray/codex.json 2>/dev/null || true",
     "build:all": "npm run build",
     "ci-install": "npm ci",
     "clean": "rm -rf dist tsconfig.tsbuildinfo tsconfig.*.tsbuildinfo",
     "test": "vitest run",
     "test:batch": "npm test",
     "test:unit": "npm test -- src/__tests__/unit/config-loader.test.ts src/__tests__/unit/state-manager.test.ts src/__tests__/unit/state-manager-persistence.test.ts src/__tests__/unit/context-loader.test.ts src/__tests__/unit/pattern-analyzer.test.ts src/__tests__/unit/complexity-calibrator.test.ts",
-    "test:core-framework": "npm test -- src/__tests__/unit/ast-code-parser.test.ts src/__tests__/unit/v2-deletion-protection.test.ts",
-    "test:security": "npm test -- src/__tests__/unit/security/security-hardener.test.ts src/__tests__/unit/security/security-headers.test.ts",
+    "test:core-framework": "npm test -- src/__tests__/unit/self-direction-activation.test.ts src/__tests__/unit/ast-code-parser.test.ts src/__tests__/unit/v2-deletion-protection.test.ts",
+    "test:security": "npm test -- src/__tests__/unit/security/security-hardener.test.ts src/__tests__/unit/security/security-headers.test.ts src/__tests__/unit/security/security-auditor.test.ts",
     "test:performance": "npm test -- src/__tests__/unit/monitoring.test.ts src/__tests__/unit/benchmark.test.ts src/__tests__/unit/analytics.test.ts",
-    "test:session-management": "npm test -- src/__tests__/unit/session-state-manager.test.ts src/__tests__/unit/session-migration-logic.test.ts",
+    "test:session-management": "npm test -- src/__tests__/unit/session-state-manager.test.ts src/__tests__/unit/session-security-validator.test.ts src/__tests__/unit/session-coordination-validator.test.ts src/__tests__/unit/session-migration-validator.test.ts src/__tests__/unit/session-migration-logic.test.ts",
     "test:code-analysis": "npm test -- src/__tests__/unit/codebase-context-analyzer.test.ts src/__tests__/unit/dependency-graph-builder.test.ts src/__tests__/unit/rule-enforcer.test.ts src/__tests__/unit/codex-parser.test.ts src/__tests__/unit/codex-injector.test.ts",
     "test:processors": "npm test -- src/__tests__/unit/processor-activation.test.ts src/__tests__/unit/typescript-compilation-processor.test.ts",
     "test:miscellaneous": "npm test -- src/__tests__/unit/blocked-test.test.ts",
     "test:quick": "npm test -- src/__tests__/integration/boot-orchestrator.integration.test.ts src/__tests__/unit/config-loader.test.ts src/__tests__/unit/state-manager.test.ts",
-    "analyze:size": "find src -name '*.ts' ! -path '*/__tests__/*' ! -path '*/node_modules/*' | xargs wc -l | sort -rn | awk '{if(NR==1)print \"Total source LOC: \" $1; else if($1>1000)print $0}' && echo '' && echo 'Files 600-1000 LOC:' && find src -name '*.ts' ! -path '*/__tests__/*' ! -path '*/node_modules/*' | xargs wc -l | sort -rn | awk '$1>600 && $1<=1000' && echo '' && echo 'Source file count:' && find src -name '*.ts' ! -path '*/__tests__/*' ! -path '*/node_modules/*' | wc -l",
     "test:comprehensive": "npm run typecheck && npm run test:unit && npm run test:core-framework && npm run test:security && npm run test:performance && npm run test:session-management && npm run test:code-analysis && npm run test:processors && npm run test:miscellaneous",
     "test:integration-all": "npm test -- src/__tests__/integration/",
     "test:performance-all": "npm test -- src/__tests__/performance/ src/__tests__/unit/performance-system.test.ts src/__tests__/unit/benchmark.test.ts src/__tests__/unit/analytics.test.ts",
@@ -97,6 +83,7 @@
     "test:root": "npm test -- src/__tests__/integration/server.test.ts src/__tests__/framework-enforcement-integration.test.ts",
     "test:pipelines": "node src/__tests__/pipeline/run-all-pipelines.mjs",
     "test:full-suite": "npm run typecheck && npm run test:integration-all && npm run test:performance-all && npm run test:infrastructure && npm run test:root",
+    "postinstall": "node scripts/node/postinstall.cjs",
     "setup-dev": "node scripts/node/setup-dev.cjs",
     "prepare-consumer": "node scripts/node/prepare-consumer.cjs",
     "typecheck": "tsc --noEmit",
@@ -109,8 +96,7 @@
     "test:e2e": "node scripts/node/validate-mcp-connectivity.js && node scripts/node/validate-external-processes.js",
     "validate": "echo \"[xray] Use 'npm test' or 'npm run test:comprehensive'.\"",
     "validate:quick": "npm run validate",
-    "verify:consumer": "bash scripts/verify-consumer.sh",
-    "debug:inference": "XRAY_DEV_PATH=dist node dist/cli/index.js inference:run --force",
+    "debug:inference:force": "STRRAY_FORCE_MCP_GOVERNANCE=true XRAY_DEV_PATH=dist node dist/cli/index.js inference:run --force",
     "validate:full": "npm run validate",
     "test:unified": "node scripts/test/test-unified-framework.mjs",
     "test:consumer": "node scripts/test/test-consumer-readiness.cjs",
@@ -124,10 +110,10 @@
     "enforce:versions": "bash scripts/node/enforce-version-compliance.sh",
     "version:sync": "node scripts/node/universal-version-manager.js",
     "preversion": "npm run version:sync",
-    "release": "node scripts/node/release.mjs patch",
+    "release": "node scripts/node/release.js",
     "release:minor": "node scripts/node/release.mjs minor",
     "release:major": "node scripts/node/release.mjs major",
-    "release:dry": "node scripts/node/release.mjs --dry-run",
+    "release:dry": "node scripts/node/release.js --dry-run",
     "pre-publish-guard": "node scripts/node/pre-publish-guard.js",
     "safe-publish": "npm run prepare-consumer && npm run build",
     "publish": "npm run pre-publish-guard && npm run safe-publish",
@@ -152,35 +138,30 @@
     "src/integrations/grok/plugin/0xray/",
     "src/skills/",
     "src/mcps/",
-    "xray/",
     ".opencode/agents/",
     ".opencode/commands/",
     ".opencode/hooks/",
     ".opencode/skills/",
-    ".opencode/integrations/",
     ".opencode/init.sh",
     ".opencode/workflows/",
     ".opencode/codex.codex",
     ".opencode/enforcer-config.json",
-    ".opencode/plugin/",
-    ".mcp.json",
-    ".plugin/",
     "opencode.json",
     "README.md",
     "AGENTS.md",
-    "LICENSE",
-    "LICENSE.claude-seo",
-    "LICENSE.antigravity"
+    "LICENSE"
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.4",
     "commander": "^11.1.0",
     "express": "^5.2.1",
+    "jsonwebtoken": "^9.0.3",
     "ws": "^8.16.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
     "@types/express": "^5.0.0",
+    "@types/jsonwebtoken": "^9.0.7",
     "@types/node": "^22.10.2",
     "@types/ws": "^8.5.13",
     "@typescript-eslint/eslint-plugin": "^8.18.0",
@@ -190,11 +171,5 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.7.2",
     "vitest": "^4.1.8"
-  },
-  "directories": {
-    "doc": "docs",
-    "example": "examples",
-    "test": "tests"
-  },
-  "author": ""
+  }
 }

package/scripts/hooks/pre-command

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