0xray 2.1.2 → 2.1.3

package/dist/postprocessor/triggers/GitHookTrigger.js

@@ -368,17 +368,17 @@ fi
           const result = await validator.validate();
 
           if (result.warnings.length > 0) {
-            await frameworkLogger.log('-git-hook-trigger', '-result-warnings-length-warning-s-found-', 'info', { message: '⚠️ ' + result.warnings.length + ' warning(s) found:' });
-            result.warnings.forEach(w => await frameworkLogger.log('-git-hook-trigger', '-w-', 'info', { message: '   ' + w) });
+            await frameworkLogger.log('git-hook-trigger', 'validation-warnings', 'info', { message: '⚠️ ' + result.warnings.length + ' warning(s) found:' });
+            result.warnings.forEach(w => await frameworkLogger.log('git-hook-trigger', 'warning-detail', 'info', { message: '   ' + w) });
           }
 
           if (!result.passed) {
-            await frameworkLogger.log('-git-hook-trigger', '-result-errors-length-error-s-found-', 'error', { message: '❌ ' + result.errors.length + ' error(s) found:' });
-            result.errors.forEach(e => await frameworkLogger.log('-git-hook-trigger', '-e-', 'info', { message: '   ' + e) });
+            await frameworkLogger.log('git-hook-trigger', 'validation-errors', 'error', { message: '❌ ' + result.errors.length + ' error(s) found:' });
+            result.errors.forEach(e => await frameworkLogger.log('git-hook-trigger', 'error-detail', 'info', { message: '   ' + e) });
             process.exit(1);
           }
 
-          await frameworkLogger.log('-git-hook-trigger', '-post-commit-validation-passed-in-result-duration-', 'success', { message: '✅ Post-commit: Validation passed in ' + result.duration + 'ms' });
+          await frameworkLogger.log('git-hook-trigger', 'post-commit-validation-passed', 'success', { message: '✅ Post-commit: Validation passed in ' + result.duration + 'ms' });
         } catch (error) {
           await frameworkLogger.log('git-hook-trigger', 'post-commit-validation-failed', 'error', { error: error instanceof Error ? error.message : String(error) });
           process.exit(1);
@@ -397,8 +397,8 @@ fi
       (async () => {
         try {
           // Use dynamic import that works in both dev and consumer
-          const basePath = process.env.STRRAY_BASE_PATH || '.';
-          const distPath = process.env.STRRAY_DIST_PATH || 'dist';
+          const basePath = process.env.XRAY_BASE_PATH || '.';
+          const distPath = process.env.XRAY_DIST_PATH || 'dist';
           // First archive logs (compress and rotate) before cleanup
           const { archiveLogFiles } = await import(basePath + '/' + distPath + '/postprocessor/triggers/GitHookTrigger.js');
           const archiveResult = await archiveLogFiles({
@@ -411,7 +411,7 @@ fi
             excludePatterns: []
           });
           if (archiveResult.archived > 0) {
-            await frameworkLogger.log('-git-hook-trigger', '-archived-log-files-', 'info', { message: \`📦 Archived \${archiveResult.archived} log files\` });
+            await frameworkLogger.log('git-hook-trigger', 'archived-log-files', 'info', { message: \`📦 Archived \${archiveResult.archived} log files\` });
           }
 
           // Then cleanup old files
@@ -457,7 +457,7 @@ fi
             enabled: true
           });
           if (result.cleaned > 0) {
-            await frameworkLogger.log('-git-hook-trigger', '-cleaned-result-cleaned-old-log-files-', 'info', { message: '🧹 Cleaned ' + result.cleaned + ' old log files' });
+            await frameworkLogger.log('git-hook-trigger', 'cleaned-old-log-files', 'info', { message: '🧹 Cleaned ' + result.cleaned + ' old log files' });
           }
           if (result.errors.length > 0) {
             await frameworkLogger.log('git-hook-trigger', 'log-cleanup-errors', 'error', { errors: result.errors });
@@ -484,8 +484,8 @@ fi
       node -e "
       (async () => {
         try {
-          const basePath = process.env.STRRAY_BASE_PATH || '.';
-          const distPath = process.env.STRRAY_DIST_PATH || 'dist';
+          const basePath = process.env.XRAY_BASE_PATH || '.';
+          const distPath = process.env.XRAY_DIST_PATH || 'dist';
           const { HookMetricsCollector } = await import(basePath + '/' + distPath + '/postprocessor/validation/HookMetricsCollector.js');
           const collector = new HookMetricsCollector();
           collector.recordMetrics('post-push', \${DURATION_MS}, \${EXIT_CODE});

package/dist/processors/implementations/refactoring-logging-processor-wrapper.d.ts

@@ -1,7 +1,39 @@
 import { PreProcessor } from "../processor-interfaces.js";
 import type { ProcessorContext } from "../processor-types.js";
+interface RefactoringContext {
+    agentName: string;
+    task: {
+        id?: string;
+        description?: string;
+        operationType?: string;
+    };
+    startTime: number;
+    complexityScore?: number;
+    changes?: Array<{
+        description?: string;
+        type?: string;
+    }>;
+    files?: string[];
+    metrics?: Record<string, unknown>;
+    operationType?: string;
+}
+interface RefactoringLogResult {
+    logged: boolean;
+    success: boolean;
+    message: string;
+    error?: string;
+}
+export declare class RefactoringLoggingProcessor {
+    private logPath;
+    constructor();
+    private ensureLogDirectory;
+    execute(context: RefactoringContext): Promise<RefactoringLogResult>;
+    private createLogEntry;
+    private appendToLog;
+}
 export declare class RefactoringLoggingProcessorWrapper extends PreProcessor {
     readonly name = "refactoringLogging";
     readonly priority = 8;
     protected run(context: ProcessorContext): Promise<Record<string, unknown>>;
 }
+export {};

package/dist/processors/implementations/refactoring-logging-processor-wrapper.js

@@ -1,11 +1,105 @@
 import { PreProcessor } from "../processor-interfaces.js";
 import { frameworkLogger } from "../../core/framework-logger.js";
+import * as fs from "fs";
+import * as path from "path";
+export class RefactoringLoggingProcessor {
+    logPath;
+    constructor() {
+        this.logPath = path.join(process.cwd(), "logs", "agents", "refactoring-log.md");
+        this.ensureLogDirectory();
+    }
+    ensureLogDirectory() {
+        const logDir = path.dirname(this.logPath);
+        if (!fs.existsSync(logDir)) {
+            fs.mkdirSync(logDir, { recursive: true });
+        }
+    }
+    async execute(context) {
+        try {
+            if (context.agentName &&
+                context.task &&
+                typeof context.startTime === "number") {
+                const logEntry = this.createLogEntry(context);
+                await this.appendToLog(logEntry);
+                return {
+                    logged: true,
+                    success: true,
+                    message: "Agent refactoring completion logged successfully",
+                };
+            }
+            return {
+                logged: false,
+                success: true,
+                message: "Not an agent task completion context",
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            await frameworkLogger.log("refactoring-logging-processor", "-refactoring-logging-failed-error-instanceof-error-", "error", { message: `Refactoring logging failed: ${errorMessage}` });
+            return {
+                logged: false,
+                success: false,
+                message: `Refactoring logging failed: ${errorMessage}`,
+                error: errorMessage,
+            };
+        }
+    }
+    createLogEntry(context) {
+        const timestamp = new Date().toISOString();
+        const duration = Date.now() - context.startTime;
+        let logEntry = `## Refactoring Operation - ${timestamp}\n\n`;
+        logEntry += `**Agent:** ${context.agentName}\n`;
+        logEntry += `**Task:** ${context.task.description || context.task.id || "Unknown"}\n`;
+        logEntry += `**Duration:** ${duration}ms\n`;
+        logEntry += `**Operation Type:** ${context.task.operationType || context.operationType || "refactor"}\n`;
+        if (context.complexityScore) {
+            logEntry += `**Complexity Score:** ${context.complexityScore}\n`;
+        }
+        if (context.changes && Array.isArray(context.changes)) {
+            logEntry += `\n**Changes Made:**\n`;
+            context.changes.forEach((change, index) => {
+                logEntry += `${index + 1}. ${change.description || change.type || "Unknown change"}\n`;
+            });
+        }
+        if (context.files && Array.isArray(context.files)) {
+            logEntry += `\n**Files Modified:**\n`;
+            context.files.forEach((file) => {
+                logEntry += `- ${file}\n`;
+            });
+        }
+        if (context.metrics) {
+            logEntry += `\n**Metrics:**\n`;
+            Object.entries(context.metrics).forEach(([key, value]) => {
+                logEntry += `- ${key}: ${value}\n`;
+            });
+        }
+        logEntry += `\n---\n\n`;
+        return logEntry;
+    }
+    async appendToLog(entry) {
+        try {
+            if (!fs.existsSync(this.logPath)) {
+                let header = `# 0xRay Framework Refactoring Log\n\n`;
+                header += `This log tracks all refactoring operations performed by 0xRay agents.\n\n`;
+                header += `Generated on: ${new Date().toISOString()}\n\n`;
+                header += `---\n\n`;
+                fs.writeFileSync(this.logPath, header, "utf8");
+            }
+            fs.appendFileSync(this.logPath, entry, "utf8");
+            await frameworkLogger.log("refactoring-logging-processor", "-refactoring-operation-logged-successfully-", "info", { message: "Refactoring operation logged successfully" });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            await frameworkLogger.log("refactoring-logging-processor", "-failed-to-append-to-refactoring-log-error-instanceof-", "error", { message: `Failed to append to refactoring log: ${errorMessage}` });
+            throw error;
+        }
+    }
+}
 export class RefactoringLoggingProcessorWrapper extends PreProcessor {
     name = "refactoringLogging";
     priority = 8;
     async run(context) {
         try {
-            const { RefactoringLoggingProcessor } = await import("./refactoring-logging-processor.js");
             const processor = new RefactoringLoggingProcessor();
             if (context.agentName &&
                 context.task &&