0xray 2.0.0

package/dist/core/system-prompt-generator.js

@@ -0,0 +1,265 @@
+/**
+ * 0xRay Lean System Prompt Generator
+ *
+ * Generates optimized, token-efficient system prompts by implementing
+ * selective injection and smart compression strategies.
+ *
+ * @version 1.0.0
+ * @since 2026-03-03
+ */
+import { StringRayContextLoader } from "./context-loader.js";
+import { validateContext, preventSystemPromptBloat } from "./context-validator.js";
+import fs from "fs";
+import path from "path";
+/**
+ * Get the current framework version from package.json
+ */
+function getFrameworkVersion() {
+    try {
+        const packageJsonPath = path.join(process.cwd(), "package.json");
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+        return packageJson.version || "1.4.6";
+    }
+    catch {
+        return "1.4.6";
+    }
+}
+/**
+ * Essential codex terms (blocking enforcement only)
+ */
+const ESSENTIAL_TERMS = [
+    {
+        number: 1,
+        title: "Progressive Prod-Ready Code",
+        description: "All code must be production-ready from the first commit."
+    },
+    {
+        number: 2,
+        title: "No Patches/Boiler/Stubs/Bridge Code",
+        description: "Prohibit temporary patches and boilerplate code."
+    },
+    {
+        number: 7,
+        title: "Resolve All Errors (90% Runtime Prevention)",
+        description: "Zero-tolerance for unresolved errors.",
+        zeroTolerance: true,
+        enforcementLevel: "blocking"
+    },
+    {
+        number: 8,
+        title: "Prevent Infinite Loops",
+        description: "Guarantee termination in all iterative processes.",
+        zeroTolerance: true,
+        enforcementLevel: "blocking"
+    },
+    {
+        number: 11,
+        title: "Type Safety First",
+        description: "Never use `any`, `@ts-ignore`, or `@ts-expect-error`.",
+        zeroTolerance: true,
+        enforcementLevel: "blocking"
+    },
+    {
+        number: 5,
+        title: "Surgical Changes Only",
+        description: "Read first. Understand context. Fix root cause only. Minimal changes. Never refactor unless asked.",
+        zeroTolerance: false,
+        enforcementLevel: "critical"
+    }
+];
+/**
+ * Rules for code-writing agents (surgical changes)
+ */
+const SURGICAL_CHANGE_RULES = `
+## Surgical Change Rules (Code Writers)
+When writing or fixing code:
+1. READ the entire file before making any changes
+2. UNDERSTAND the existing code - trace logic, understand patterns
+3. FIX only the root cause - never rewrite working code
+4. PRESERVE existing functionality - never simplify logic
+5. If a fix is complex: mark as TODO with explanation, do not skip
+6. ALWAYS attempt to fix - never simplify to "make it work"
+7. Tests: attempt fix first, only skip if truly blocked, return to later
+
+## Test Fixing Rules
+When fixing tests:
+1. NEVER simplify tests to make them pass
+2. If test is wrong: fix the code, not the test
+3. If blocked: add TODO comment, return to later
+4. Only skip tests with explicit TODO and reason
+`;
+/**
+ * Lean welcome banner (minimal version)
+ */
+function getLeanWelcomeBanner() {
+    const version = getFrameworkVersion();
+    return `0xRay Framework v${version} - AI Orchestration Engine
+
+🔧 Core: enforcer, architect, orchestrator, code-reviewer, refactorer, testing-lead
+📚 Codex: 5 Essential Terms (99.6% Error Prevention Target)
+🎯 Goal: Progressive, production-ready development workflow
+
+`;
+}
+/**
+ * Format critical codex terms for injection
+ */
+function formatEssentialTerms() {
+    const parts = ["## Essential 0xRay Rules (Blocking Enforcement)"];
+    for (const term of ESSENTIAL_TERMS) {
+        const termNum = term.number;
+        const zeroTolBadge = term.zeroTolerance ? " ⚠️ ZERO TOLERANCE" : " 🟡 High Priority";
+        parts.push(`\n**${termNum}. ${term.title}** ${zeroTolBadge}\n${term.description}`);
+    }
+    parts.push("\n🔗 Key: config dir (codex, config, agents docs) — resolved via config-paths");
+    return parts.join("");
+}
+/**
+ * Generate optimized system prompt with bloat prevention
+ */
+export async function generateLeanSystemPrompt(config = {}) {
+    const { showWelcomeBanner = true, showCodexContext = false, // Disabled by default for token efficiency
+    enableTokenOptimization = true, maxTokenBudget = 8192, // Increased token budget
+    showCriticalTermsOnly = true, showEssentialLinks = true } = config;
+    let systemPrompt = "";
+    // 1. Welcome banner (minimal if enabled)
+    if (showWelcomeBanner) {
+        const banner = getLeanWelcomeBanner();
+        if (banner.length < maxTokenBudget * 0.2) { // 20% of budget
+            systemPrompt += banner;
+        }
+    }
+    // 2. Critical terms only (major token savings)
+    if (showCriticalTermsOnly) {
+        const essentialTerms = formatEssentialTerms();
+        if ((systemPrompt.length + essentialTerms.length) < maxTokenBudget * 0.6) { // 60% of budget
+            systemPrompt += essentialTerms;
+        }
+    }
+    // 3. Full codex context only if explicitly enabled and within budget
+    let finalPrompt = systemPrompt;
+    if (showCodexContext && enableTokenOptimization) {
+        try {
+            const contextLoader = StringRayContextLoader.getInstance();
+            const loadResult = await contextLoader.loadCodexContext(process.cwd());
+            if (loadResult.success && loadResult.context) {
+                const codexSummary = generateCodexSummary(loadResult.context, maxTokenBudget);
+                // Combine and validate total prompt
+                const combinedPrompt = `${systemPrompt}\n\n${codexSummary}`;
+                const validation = validateContext(combinedPrompt, {
+                    maxTotalPromptLength: maxTokenBudget * 2,
+                    enableCompression: true,
+                    preventDuplicateContent: true
+                });
+                if (validation.isValid) {
+                    finalPrompt = combinedPrompt;
+                }
+                else {
+                    // Use optimized version if validation fails
+                    finalPrompt = validation.optimizedContent || combinedPrompt;
+                }
+            }
+        }
+        catch (error) {
+            // Silent fallback - prompt generation should not break
+            finalPrompt = systemPrompt;
+        }
+    }
+    else {
+        finalPrompt = systemPrompt;
+    }
+    // 4. Apply bloat prevention to final prompt
+    let safePrompt = preventSystemPromptBloat(finalPrompt);
+    // 5. Essential links if space permits
+    if (showEssentialLinks && safePrompt.length < 1500) {
+        safePrompt += "\n📖 Documentation: config dir | AGENTS.md\n";
+    }
+    // Final validation and fallback
+    if (safePrompt.length < 100) {
+        return generateMinimalFallbackPrompt();
+    }
+    return safePrompt;
+}
+/**
+ * Generate compressed codex summary
+ */
+function generateCodexSummary(context, maxTokens) {
+    const parts = ["\n## 0xRay Codex Summary"];
+    // Add just the most essential metadata
+    parts.push(`\nVersion: ${context.version}`);
+    parts.push(`Terms: ${context.terms?.size || 0} total`);
+    parts.push(`Last Updated: ${context.lastUpdated}`);
+    // Only add validation criteria if space permits
+    if (context.validationCriteria && parts.join("").length < maxTokens * 0.8) {
+        parts.push(`\n📋 Validation: ${Object.entries(context.validationCriteria).filter(([_, v]) => v).length}/${Object.keys(context.validationCriteria).length} criteria met`);
+    }
+    return parts.join("");
+}
+/**
+ * Absolute minimal fallback prompt
+ */
+function generateMinimalFallbackPrompt() {
+    return `0xRay Framework v${getFrameworkVersion()}
+Essential: Production-ready code, zero-tolerance errors, type safety
+📖: config dir (resolved via config-paths) | AGENTS.md
+`;
+}
+/**
+ * Smart context injection based on available tokens
+ */
+export function injectContextIntelligently(basePrompt, additionalContext, maxTokens = 4000) {
+    const availableTokens = maxTokens - basePrompt.length;
+    if (availableTokens <= 0) {
+        return basePrompt; // No room for additional context
+    }
+    // Compress additional context if needed
+    if (additionalContext.length > availableTokens) {
+        additionalContext = compressContext(additionalContext, availableTokens * 0.8);
+    }
+    return basePrompt + "\n\n" + additionalContext;
+}
+/**
+ * Context compression utilities
+ */
+function compressContext(context, targetLength) {
+    if (context.length <= targetLength)
+        return context;
+    // Simple compression: remove whitespace, keep first lines
+    const lines = context.split('\n').filter(line => line.trim());
+    const compressed = [];
+    let currentLength = 0;
+    for (const line of lines) {
+        if (currentLength + line.length <= targetLength) {
+            compressed.push(line);
+            currentLength += line.length;
+        }
+        else {
+            break;
+        }
+    }
+    return compressed.join('\n') + '\n... (truncated)';
+}
+/**
+ * System prompt validation
+ */
+export function validateSystemPrompt(prompt) {
+    const warnings = [];
+    const maxLength = 8000; // Safety limit
+    if (prompt.length > maxLength) {
+        warnings.push(`Prompt exceeds maximum length: ${prompt.length} > ${maxLength}`);
+    }
+    if (prompt.length < 200) {
+        warnings.push('Prompt may be too short for effective operation');
+    }
+    // Check for problematic patterns
+    if (prompt.includes('══════════')) {
+        warnings.push('ASCII art detected - consuming excessive tokens');
+    }
+    if (prompt.includes('v1.6.22') && prompt.includes('v1.2.25')) {
+        warnings.push('Duplicate context blocks detected');
+    }
+    return {
+        valid: warnings.length === 0,
+        warnings
+    };
+}

package/dist/core/trace-context.js

@@ -0,0 +1,33 @@
+// src/core/trace-context.ts
+// Centralized trace propagation
+let currentTrace = null;
+function generateId() {
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    return Date.now().toString(36) + Math.random().toString(36).substring(2);
+}
+export function startTrace(operation, metadata) {
+    const trace = {
+        traceId: generateId(),
+        operation,
+        governanceApproved: false,
+        startTime: Date.now(),
+        metadata: metadata || {}
+    };
+    currentTrace = trace;
+    return trace;
+}
+export function getCurrentTrace() {
+    return currentTrace;
+}
+export function endTrace(approved = true) {
+    if (currentTrace)
+        currentTrace.governanceApproved = approved;
+    currentTrace = null;
+}
+export function propagateTrace(childOperation) {
+    if (!currentTrace)
+        return null;
+    return { ...currentTrace, parentId: currentTrace.traceId, operation: childOperation, startTime: Date.now() };
+}

package/dist/core/xray-activation.js

@@ -0,0 +1,134 @@
+/**
+ * Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .strray fallbacks).
+ */
+import { frameworkLogger } from "../core/framework-logger.js";
+import { ensureCriticalComponents } from "../architect/architectural-integrity.js";
+import { validateRegistryConsistency } from "../agents/registry.js";
+export const defaultStringRayConfig = {
+    enableOrchestrator: true,
+    enableBootOrchestrator: true,
+    enableStateManagement: true,
+    enableHooks: true,
+    enableCodexInjection: true,
+    enableProcessors: true,
+    enablePostProcessor: true,
+};
+export async function activateStringRayFramework(config = {}) {
+    const jobId = `activation-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+    const activationConfig = { ...defaultStringRayConfig, ...config };
+    // Banner display moved to init.sh execution in plugin
+    // Framework activation proceeds quietly
+    frameworkLogger.log("stringray-activation", "beginning xray framework activation", "info", { jobId, ...activationConfig });
+    const registryValidation = validateRegistryConsistency();
+    if (!registryValidation.valid) {
+        frameworkLogger.log("stringray-activation", "registry-validation-failed", "warning", { errors: registryValidation.errors });
+    }
+    try {
+        if (activationConfig.enableCodexInjection) {
+            await activateCodexInjection(jobId);
+        }
+        if (activationConfig.enableHooks) {
+            await activateHooks(jobId);
+        }
+        if (activationConfig.enableOrchestrator) {
+            await activateOrchestrator(jobId);
+        }
+        if (activationConfig.enableBootOrchestrator) {
+            await activateBootOrchestrator(jobId);
+        }
+        if (activationConfig.enableStateManagement) {
+            await activateStateManagement(jobId);
+        }
+        if (activationConfig.enableProcessors) {
+            await activateProcessors(jobId);
+        }
+        if (activationConfig.enablePostProcessor) {
+            await activatePostProcessor(jobId);
+        }
+        // Ensure architectural integrity - critical components must always be active
+        await ensureCriticalComponents();
+        // Loading display moved to init.sh for dramatic line-by-line presentation
+        frameworkLogger.log("stringray-activation", "xray framework activation completed successfully", "success", { jobId });
+    }
+    catch (error) {
+        await frameworkLogger.log("stringray-activation", "framework-activation-failed", "error", { jobId, error: String(error) });
+        throw error;
+    }
+}
+async function activateCodexInjection(jobId) {
+    frameworkLogger.log("stringray-activation", "activating codex injection", "info", { jobId });
+    const { createStringRayCodexInjectorHook } = await import("./codex-injector.js");
+    const hook = createStringRayCodexInjectorHook();
+    globalThis.strRayHooks = globalThis.strRayHooks || [];
+    globalThis.strRayHooks.push(hook);
+    frameworkLogger.log("stringray-activation", "codex injection activated", "success", { jobId, hookName: hook.name });
+}
+async function activateHooks(jobId) {
+    try {
+        frameworkLogger.log("stringray-activation", "activating xray hooks", "info", { jobId });
+        // Create and register the Codex injector hook
+        const { createStringRayCodexInjectorHook } = await import("./codex-injector");
+        const hook = createStringRayCodexInjectorHook();
+        // Store hook globally for OpenCode to pick up
+        globalThis.strRayHooks = globalThis.strRayHooks || [];
+        globalThis.strRayHooks.push(hook);
+        frameworkLogger.log("stringray-activation", "xray hooks activated", "success", {
+            jobId,
+            hookName: hook.name,
+            hooksRegistered: globalThis.strRayHooks.length
+        });
+    }
+    catch (error) {
+        await frameworkLogger.log("stringray-activation", "hooks activation failed", "error", { jobId, error: String(error) });
+    }
+}
+async function activateBootOrchestrator(jobId) {
+    frameworkLogger.log("stringray-activation", "activating boot orchestrator", "info", { jobId });
+    const { bootOrchestrator } = await import("./boot-orchestrator");
+    await bootOrchestrator.executeBootSequence();
+    frameworkLogger.log("stringray-activation", "boot orchestrator activated", "success", { jobId });
+}
+async function activateStateManagement(jobId) {
+    frameworkLogger.log("stringray-activation", "activating state management", "info", { jobId });
+    const { StringRayStateManager } = await import("../state/state-manager");
+    const stateManager = new StringRayStateManager();
+    // Store the state manager instance globally for framework use
+    globalThis.strRayStateManager = stateManager;
+    frameworkLogger.log("stringray-activation", "state management activated", "success", { jobId });
+}
+async function activateOrchestrator(jobId) {
+    frameworkLogger.log("stringray-activation", "activating xray orchestrator", "info", { jobId });
+    const { strRayOrchestrator } = await import("./orchestrator");
+    // Also activate the multi-agent orchestration coordinator
+    const { multiAgentOrchestrationCoordinator } = await import("../orchestrator/multi-agent-orchestration-coordinator");
+    frameworkLogger.log("stringray-activation", "xray orchestrator and multi-agent coordination activated", "success", { jobId });
+}
+async function activateProcessors(jobId) {
+    frameworkLogger.log("stringray-activation", "activating processor pipeline", "info", { jobId });
+    const { ProcessorManager } = await import("../processors/processor-manager");
+    const { StringRayStateManager } = await import("../state/state-manager");
+    const stateManager = new StringRayStateManager();
+    const processorManager = new ProcessorManager(stateManager);
+    // Store the processor manager instance globally for framework use
+    globalThis.strRayProcessorManager = processorManager;
+    frameworkLogger.log("stringray-activation", "processor pipeline activated", "success", { jobId });
+}
+async function activatePostProcessor(jobId) {
+    frameworkLogger.log("stringray-activation", "activating post-processor system", "info", { jobId });
+    const { PostProcessor } = await import("../postprocessor/PostProcessor");
+    // Get existing state manager (should be initialized by boot orchestrator)
+    const stateManager = globalThis.strRayStateManager;
+    if (!stateManager) {
+        throw new Error("State manager not initialized - boot orchestrator must run first");
+    }
+    const postProcessor = new PostProcessor(stateManager, null, {});
+    globalThis.strRayPostProcessor = postProcessor;
+    frameworkLogger.log("stringray-activation", "post-processor system activated", "success", { jobId });
+    const { pathResolver } = await import("../utils/path-resolver.js");
+    globalThis.strRayPathResolver = pathResolver;
+    frameworkLogger.log("stringray-activation", "path resolver activated", "success", { jobId });
+    const { CodexInjector } = await import("./codex-injector.js");
+    const codexInjector = new CodexInjector();
+    globalThis.strRayCodexInjector = codexInjector;
+    frameworkLogger.log("stringray-activation", "codex injector activated", "success", { jobId });
+}