0xray 4.0.35 → 4.0.37

package/dist/cli/suit-pulse.js

@@ -0,0 +1,270 @@
+/**
+ * One line from streams the suit already writes.
+ * Not a doctor, not a second memory.
+ */
+import { createRequire } from "node:module";
+import { closeSync, existsSync, openSync, readFileSync, readSync, statSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const require = createRequire(import.meta.url);
+const ACTIVITY_LINE = /^\S+\s+(?:\[[^\]]*\]\s+)?\[[^\]]+\]\s+(\S+)\s+-\s+\S+(?:\s+\|\s+(\{.*\}))?\s*$/;
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function rawText(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+}
+function textField(value) {
+    const text = rawText(value);
+    return text ? text.toLowerCase() : null;
+}
+function readVersion(pkgPath) {
+    if (!existsSync(pkgPath))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(pkgPath, "utf8"));
+        const version = asRecord(parsed)?.version;
+        return typeof version === "string" && version.trim() ? version.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Directory named by the fastened Grok hook, or null when the file names none. */
+function hookLaunchDir(root) {
+    const file = join(root, ".grok", "plugins", "0xray", "hooks", "hooks.json");
+    if (!existsSync(file))
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+    const pre = asRecord(asRecord(parsed)?.hooks)?.PreToolUse;
+    if (!Array.isArray(pre))
+        return null;
+    for (const group of pre) {
+        const hooks = asRecord(group)?.hooks;
+        if (!Array.isArray(hooks))
+            continue;
+        for (const hook of hooks) {
+            const body = asRecord(hook);
+            if (!body)
+                continue;
+            const envPath = rawText(asRecord(body.env)?.XRAY_AI_PATH);
+            const fromEnv = envPath ? packageDir(envPath) : null;
+            if (fromEnv)
+                return fromEnv;
+            const blobs = [];
+            if (typeof body.command === "string")
+                blobs.push(body.command);
+            if (Array.isArray(body.args)) {
+                for (const arg of body.args) {
+                    if (typeof arg === "string")
+                        blobs.push(arg);
+                }
+            }
+            for (const blob of blobs) {
+                const found = packageDirFromText(blob);
+                if (found)
+                    return found;
+            }
+        }
+    }
+    return null;
+}
+function packageDir(spec) {
+    if (!spec.startsWith("/") || spec.includes("$"))
+        return null;
+    const marker = "/node_modules/0xray";
+    const at = spec.indexOf(marker);
+    if (at >= 0)
+        return spec.slice(0, at + marker.length);
+    return spec;
+}
+function packageDirFromText(text) {
+    const matches = text.match(/\/[^\s"']+/g);
+    if (!matches)
+        return null;
+    for (const match of matches) {
+        const dir = packageDir(match);
+        if (dir)
+            return dir;
+    }
+    return null;
+}
+function resolveWornDir(root, opts) {
+    if (opts.wornDir)
+        return opts.wornDir;
+    const hooked = hookLaunchDir(root);
+    if (hooked)
+        return hooked;
+    const local = join(root, "node_modules", "0xray");
+    return existsSync(local) ? local : null;
+}
+function readWorn(root, opts) {
+    const directory = resolveWornDir(root, opts);
+    if (!directory || !existsSync(directory))
+        return null;
+    const version = readVersion(join(directory, "package.json"));
+    if (!version)
+        return null;
+    return { version, directory };
+}
+function repertoireVersion(root) {
+    return readVersion(join(root, "node_modules", "@0xray", "repertoire", "package.json"));
+}
+function repertoireIndex(root) {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        join(root, "node_modules", "@0xray", "repertoire", "dist", "index.js"),
+        join(root, "vendor", "@0xray", "repertoire", "dist", "index.js"),
+        join(root, "node_modules", "0xray", "vendor", "@0xray", "repertoire", "dist", "index.js"),
+        join(here, "..", "..", "vendor", "@0xray", "repertoire", "dist", "index.js"),
+        join(here, "..", "..", "..", "vendor", "@0xray", "repertoire", "dist", "index.js"),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+/** Whole seconds since InferenceState.lastRun. A missing or null run is none. */
+function secondsSinceLastRun(lastRun, now) {
+    if (typeof lastRun !== "string")
+        return null;
+    const parsed = Date.parse(lastRun);
+    if (!Number.isFinite(parsed))
+        return null;
+    return Math.max(0, Math.floor((now - parsed) / 1000));
+}
+function inferenceAge(root, now) {
+    const index = repertoireIndex(root);
+    if (!index)
+        return null;
+    const file = join(root, ".xray", "state", "repertoire", "inference-state.json");
+    try {
+        const loaded = require(index);
+        const Manager = loaded.InferenceStateManager;
+        if (typeof Manager !== "function")
+            return null;
+        const state = asRecord(new Manager(file).load());
+        return secondsSinceLastRun(state?.lastRun, now);
+    }
+    catch {
+        return null;
+    }
+}
+function readTail(file, maxBytes = 65536) {
+    const size = statSync(file).size;
+    const start = Math.max(0, size - maxBytes);
+    const fd = openSync(file, "r");
+    try {
+        const buf = Buffer.alloc(size - start);
+        readSync(fd, buf, 0, buf.length, start);
+        let text = buf.toString("utf8");
+        if (start > 0) {
+            const cut = text.indexOf("\n");
+            if (cut >= 0)
+                text = text.slice(cut + 1);
+        }
+        return text;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function parseActivityLine(line) {
+    const match = ACTIVITY_LINE.exec(line.trim());
+    const action = match?.[1];
+    if (!action)
+        return null;
+    const decision = action.toLowerCase();
+    let gate = null;
+    let tool = null;
+    const detailsJson = match?.[2];
+    if (detailsJson) {
+        try {
+            const details = asRecord(JSON.parse(detailsJson));
+            gate = textField(details?.gate);
+            tool = textField(details?.tool);
+        }
+        catch {
+            /* the action still stands */
+        }
+    }
+    return { gate, decision, tool };
+}
+function lastActivity(root) {
+    const file = join(root, "logs", "framework", "activity.log");
+    if (!existsSync(file))
+        return null;
+    let text = "";
+    try {
+        text = readTail(file);
+    }
+    catch {
+        return null;
+    }
+    const lines = text.split("\n");
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+        const line = lines[i]?.trim();
+        if (!line)
+            continue;
+        const parsed = parseActivityLine(line);
+        if (parsed)
+            return parsed;
+    }
+    return null;
+}
+/** absent → none. Same shape as the goggles read pass. */
+function lensState(root) {
+    const file = join(root, ".xray", "state", "goggles-lens-pass.json");
+    if (!existsSync(file))
+        return "none";
+    try {
+        const data = asRecord(JSON.parse(readFileSync(file, "utf8")));
+        if (!data || data.read !== true)
+            return "none";
+        return data.spent === true ? "spent" : "armed";
+    }
+    catch {
+        return "none";
+    }
+}
+/** node_modules/0xray/package.json. Seat doctor already owns mill+inspect. */
+function plantPresent(root) {
+    return existsSync(join(root, "node_modules", "0xray", "package.json"));
+}
+function activityToken(activity) {
+    if (!activity)
+        return "none";
+    const parts = [activity.gate, activity.decision, activity.tool].filter((part) => Boolean(part));
+    return parts.length ? parts.join(":") : "none";
+}
+export function readSuitPulse(root, opts = {}) {
+    const now = opts.now ?? Date.now();
+    const worn = readWorn(root, opts);
+    const repertoire = repertoireVersion(root);
+    const inferenceSeconds = inferenceAge(root, now);
+    const activity = lastActivity(root);
+    const lens = lensState(root);
+    const plant = plantPresent(root);
+    const head = worn ? `WORN ${worn.version}` : "BARE";
+    const line = [
+        head,
+        `repertoire ${repertoire ?? "missing"}`,
+        `inference ${inferenceSeconds === null ? "none" : `${inferenceSeconds}s`}`,
+        `activity ${activityToken(activity)}`,
+        `lens ${lens}`,
+        `plant ${plant ? "yes" : "no"}`,
+    ].join(" ");
+    return { worn, repertoire, inferenceSeconds, activity, lens, plant, line };
+}

package/dist/delegation/agent-delegator.d.ts

@@ -101,10 +101,12 @@ export declare class AgentDelegator {
     private agentMetrics;
     /** Minimum confidence for a learned mapping to override hardcoded routing. */
     private static readonly MAPPING_CONFIDENCE_THRESHOLD;
+    /** Parsed routing file. Identity is path, mtime, size, and a hash of the bytes. */
+    private routingMappingsCache;
     constructor(stateManager: XrayStateManager, configLoader: typeof xrayConfigLoader);
     /**
-     * Load routing-mappings.json from disk (fresh each call — picks up tuner writes).
-     * Same path resolution as inference-tuner.ts.
+     * Load routing-mappings.json. First file among .xray/, xray/, then cwd.
+     * Same path, mtime, and size still re-reads when the bytes change.
      */
     private loadRoutingMappings;
     /**

package/dist/delegation/agent-delegator.js

@@ -8,6 +8,7 @@
  *
  * @since 2026-01-07
  */
+import { createHash } from "crypto";
 import * as fs from "fs";
 import * as path from "path";
 import * as nodePath from "path";
@@ -31,6 +32,8 @@ export class AgentDelegator {
     agentMetrics;
     /** Minimum confidence for a learned mapping to override hardcoded routing. */
     static MAPPING_CONFIDENCE_THRESHOLD = 0.7;
+    /** Parsed routing file. Identity is path, mtime, size, and a hash of the bytes. */
+    routingMappingsCache = null;
     constructor(stateManager, configLoader) {
         this.stateManager = stateManager;
         this.configLoader = configLoader;
@@ -39,43 +42,57 @@ export class AgentDelegator {
         this.agentMetrics = initializeAgentMetrics(stateManager);
     }
     /**
-     * Load routing-mappings.json from disk (fresh each call — picks up tuner writes).
-     * Same path resolution as inference-tuner.ts.
+     * Load routing-mappings.json. First file among .xray/, xray/, then cwd.
+     * Same path, mtime, and size still re-reads when the bytes change.
      */
     loadRoutingMappings() {
         const candidates = [
             path.resolve(process.cwd(), ".xray/routing-mappings.json"),
             path.resolve(process.cwd(), "xray/routing-mappings.json"),
-            path.resolve(process.cwd(), ".xray/routing-mappings.json"),
             path.resolve(process.cwd(), "routing-mappings.json"),
         ];
-        for (const p of candidates) {
+        for (const candidate of candidates) {
             try {
-                if (fs.existsSync(p)) {
-                    const data = fs.readFileSync(p, "utf-8");
-                    const parsed = JSON.parse(data);
-                    if (!Array.isArray(parsed))
-                        continue;
-                    const valid = [];
-                    for (const entry of parsed) {
-                        if (entry.autoGenerated === true) {
-                            frameworkLogger.log("agent-delegator", "routing-filtered", "warning", {
-                                reason: "autoGenerated flag",
-                                agent: entry.agent,
-                            });
-                            continue;
-                        }
-                        if (entry.agent && !isAllowedAgent(entry.agent)) {
-                            frameworkLogger.log("agent-delegator", "routing-filtered", "warning", {
-                                reason: "agent not in registry",
-                                agent: entry.agent,
-                            });
-                            continue;
-                        }
+                const stat = fs.statSync(candidate);
+                if (!stat.isFile())
+                    continue;
+                const bytes = fs.readFileSync(candidate);
+                const hash = createHash("sha256").update(bytes).digest("hex");
+                const key = `${candidate}\0${stat.mtimeMs}\0${stat.size}\0${hash}`;
+                if (this.routingMappingsCache?.key === key) {
+                    return this.routingMappingsCache.mappings;
+                }
+                const parsed = JSON.parse(bytes.toString("utf-8"));
+                if (!Array.isArray(parsed))
+                    continue;
+                const valid = [];
+                for (const entry of parsed) {
+                    if (entry === null || entry === undefined) {
+                        throw new TypeError("routing mapping entry is not an object");
+                    }
+                    if (typeof entry !== "object") {
                         valid.push(entry);
+                        continue;
+                    }
+                    const record = entry;
+                    if (record.autoGenerated === true) {
+                        frameworkLogger.log("agent-delegator", "routing-filtered", "warning", {
+                            reason: "autoGenerated flag",
+                            agent: record.agent,
+                        });
+                        continue;
+                    }
+                    if (record.agent && !isAllowedAgent(record.agent)) {
+                        frameworkLogger.log("agent-delegator", "routing-filtered", "warning", {
+                            reason: "agent not in registry",
+                            agent: record.agent,
+                        });
+                        continue;
                     }
-                    return valid;
+                    valid.push(record);
                 }
+                this.routingMappingsCache = { key, mappings: valid };
+                return valid;
             }
             catch {
                 // try next candidate
@@ -422,9 +439,10 @@ export class AgentDelegator {
      * Record analysis results for learning system
      */
     recordAnalysisForLearning(request, analysis) {
+        const outcomes = [];
         for (const agentName of analysis.agents) {
             const agentDetail = analysis.agentDetails.find(a => a.name === agentName);
-            routingOutcomeTracker.recordOutcome({
+            outcomes.push({
                 taskId: request.sessionId || `analysis-${Date.now()}`,
                 taskDescription: request.description,
                 routedAgent: agentName,
@@ -433,6 +451,7 @@ export class AgentDelegator {
                 success: true,
             });
         }
+        routingOutcomeTracker.recordOutcomes(outcomes);
     }
     determineConflictResolution(metrics, complexityScore) {
         if (complexityScore.level === "enterprise" ||

package/dist/delegation/agent-expertise.js

@@ -144,8 +144,9 @@ export function getVotingWeight(agentName) {
     const level = getAgentExpertiseLevel(agentName);
     return level * 10;
 }
+const EXPERTISE_ROSTER = Object.values(AGENT_EXPERTISE_LEVELS);
 export function getAgentsWithExpertiseDomain(domain) {
-    return Object.values(AGENT_EXPERTISE_LEVELS).filter((agent) => agent.domain === domain || agent.specialties.some((s) => domain.includes(s)));
+    return EXPERTISE_ROSTER.filter((agent) => agent.domain === domain || agent.specialties.some((s) => domain.includes(s)));
 }
 export function getTopExpertsForDomain(domain, count = 3) {
     const domainExperts = getAgentsWithExpertiseDomain(domain);

package/dist/delegation/analytics/outcome-tracker.d.ts

@@ -48,6 +48,12 @@ export declare class RoutingOutcomeTracker {
      * @param outcome The outcome to record (timestamp will be added)
      */
     recordOutcome(outcome: Omit<RoutingOutcome, 'timestamp'>): void;
+    /**
+     * Record several outcomes and stringify the buffer once.
+     * Same retained rows as calling recordOutcome per item.
+     */
+    recordOutcomes(outcomes: Array<Omit<RoutingOutcome, 'timestamp'>>): void;
+    private appendOutcome;
     /**
      * Update an existing outcome by taskId
      * @param taskId The task ID to update

package/dist/delegation/analytics/outcome-tracker.js

@@ -109,13 +109,27 @@ export class RoutingOutcomeTracker {
     recordOutcome(outcome) {
         if (!this.maxOutcomes)
             return;
+        this.appendOutcome(outcome);
+        // Persist to disk immediately (not debounced for better tracking during tests/CI)
+        this.saveToDisk();
+    }
+    /**
+     * Record several outcomes and stringify the buffer once.
+     * Same retained rows as calling recordOutcome per item.
+     */
+    recordOutcomes(outcomes) {
+        if (!this.maxOutcomes || outcomes.length === 0)
+            return;
+        for (const outcome of outcomes) {
+            this.appendOutcome(outcome);
+        }
+        this.saveToDisk();
+    }
+    appendOutcome(outcome) {
         this.outcomes.push({ ...outcome, timestamp: new Date() });
-        // Keep only recent outcomes (circular buffer)
         if (this.outcomes.length > this.maxOutcomes) {
             this.outcomes = this.outcomes.slice(-this.maxOutcomes);
         }
-        // Persist to disk immediately (not debounced for better tracking during tests/CI)
-        this.saveToDisk();
     }
     /**
      * Update an existing outcome by taskId

package/dist/delegation/ast-code-parser.d.ts

@@ -102,6 +102,9 @@ export interface CodeMetrics {
 export declare class ASTCodeParser {
     private astGrepPath;
     private astGrepAvailable;
+    private compiledPatterns;
+    private newlineFor;
+    private newlineStarts;
     private patterns;
     constructor(astGrepPath?: string);
     /**
@@ -167,6 +170,8 @@ export declare class ASTCodeParser {
     private calculateCyclomaticComplexity;
     private calculateCognitiveComplexity;
     private calculateMaxNesting;
+    private newlineIndex;
+    private lineNumberAt;
     private getLineNumber;
     private calculateMaintainabilityIndex;
     private findDuplicateImports;

package/dist/delegation/ast-code-parser.js

@@ -10,9 +10,22 @@ import * as fs from "fs";
 import * as path from "path";
 import { execSync } from "child_process";
 import { frameworkLogger } from "../core/framework-logger.js";
+const CONTROL_FLOW_RE = /\b(?:if|else|for|while|do|switch|case|catch)\b/g;
+const AMP_RE = /\b&&\b/g;
+const QMARK_RE = /\b\?\b/g;
+function countPattern(re, content) {
+    re.lastIndex = 0;
+    let count = 0;
+    while (re.exec(content) !== null)
+        count++;
+    return count;
+}
 export class ASTCodeParser {
     astGrepPath = null;
     astGrepAvailable = false;
+    compiledPatterns = new Map();
+    newlineFor = null;
+    newlineStarts = null;
     patterns = [
         // TypeScript/JavaScript patterns - direct regex for fallback
         {
@@ -403,9 +416,12 @@ export class ASTCodeParser {
      * Regex-based pattern matching (fallback when ast-grep not available)
      */
     regexBasedMatching(content, pattern) {
-        // For fallback, patterns are already regex strings
-        const regexPattern = pattern;
-        const regex = new RegExp(regexPattern, "g");
+        let regex = this.compiledPatterns.get(pattern);
+        if (!regex) {
+            regex = new RegExp(pattern, "g");
+            this.compiledPatterns.set(pattern, regex);
+        }
+        regex.lastIndex = 0;
         const matches = [];
         let match;
         while ((match = regex.exec(content)) !== null) {
@@ -720,28 +736,7 @@ export class ASTCodeParser {
         });
     }
     calculateFunctionComplexity(content) {
-        let complexity = 1; // Base complexity
-        // +1 for each control flow statement
-        const controlFlowKeywords = [
-            "if",
-            "else",
-            "for",
-            "while",
-            "do",
-            "switch",
-            "case",
-            "catch",
-        ];
-        for (const keyword of controlFlowKeywords) {
-            if (!keyword)
-                continue; // Skip empty keywords
-            const regex = new RegExp(`\\b${keyword}\\b`, "g");
-            const matches = content.match(regex);
-            if (matches) {
-                complexity += matches.length;
-            }
-        }
-        return complexity;
+        return 1 + countPattern(CONTROL_FLOW_RE, content);
     }
     parseImportNames(importStr) {
         if (!importStr.trim())
@@ -780,28 +775,13 @@ export class ASTCodeParser {
         return "variable";
     }
     calculateCyclomaticComplexity(content) {
-        let complexity = 1;
-        const patterns = [
-            "if",
-            "else",
-            "for",
-            "while",
-            "do",
-            "switch",
-            "case",
-            "catch",
-            "&&",
-            "||",
-            "\\?",
-        ];
-        for (const pattern of patterns) {
-            const regex = new RegExp(`\\b${pattern}\\b`, "g");
-            const matches = content.match(regex);
-            if (matches) {
-                complexity += matches.length;
-            }
-        }
-        return complexity;
+        // `||` is interpolated into `\b||\b`, an empty alternation: one match per index.
+        return (1 +
+            countPattern(CONTROL_FLOW_RE, content) +
+            countPattern(AMP_RE, content) +
+            content.length +
+            1 +
+            countPattern(QMARK_RE, content));
     }
     calculateCognitiveComplexity(functions) {
         return functions.reduce((sum, func) => sum + func.complexity, 0);
@@ -839,8 +819,33 @@ export class ASTCodeParser {
         }
         return maxNesting;
     }
+    newlineIndex(content) {
+        if (this.newlineFor === content && this.newlineStarts)
+            return this.newlineStarts;
+        const starts = [0];
+        for (let i = 0; i < content.length; i++) {
+            if (content.charCodeAt(i) === 10)
+                starts.push(i + 1);
+        }
+        this.newlineFor = content;
+        this.newlineStarts = starts;
+        return starts;
+    }
+    lineNumberAt(starts, index) {
+        let lo = 0;
+        let hi = starts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            const start = starts[mid];
+            if (start !== undefined && start <= index)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return lo + 1;
+    }
     getLineNumber(content, index) {
-        return content.substring(0, index).split("\n").length;
+        return this.lineNumberAt(this.newlineIndex(content), index);
     }
     calculateMaintainabilityIndex(structure, linesOfCode) {
         // Simplified maintainability index calculation

package/dist/delegation/codebase-context-analyzer.d.ts

@@ -71,6 +71,8 @@ export interface CodebaseAnalysisCacheData {
     exports: string[];
     content?: string;
     lastModified?: Date;
+    size?: number;
+    contentHash?: string;
     timestamp: number;
 }
 export declare class CodebaseContextAnalyzer {
@@ -148,16 +150,10 @@ export declare class CodebaseContextAnalyzer {
      * Identify potential risks and issues
      */
     private identifyRisks;
-    private isModuleDirectory;
+    private isModuleNames;
     private isConfigFile;
     private classifyModule;
     private findEntryPoint;
-    private hasFramework;
-    private detectMVCPattern;
-    private detectRepositoryPattern;
-    private detectObserverPattern;
-    private detectFactoryPattern;
-    private hasMicroservicesIndicators;
     private isEntryPoint;
     private detectCircularDependencies;
 }