strray-ai 1.22.68 → 1.22.69

package/dist/processors/implementations/console-log-guard-processor.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Console Log Guard Processor
+ *
+ * Enforces codex term #33: Console Log Guard.
+ * Scans code for forbidden console.log/warn/error/info/debug usage,
+ * ensuring all logging goes through frameworkLogger instead.
+ *
+ * @version 1.0.0
+ * @since 2026-03-28
+ */
+import type { PreValidateContext, ProcessorExecutionResult } from "../processor-types.js";
+export interface ConsoleLogViolation {
+    line: number;
+    type: "log" | "warn" | "error" | "info" | "debug";
+    matched: string;
+}
+export declare class ConsoleLogGuardProcessor {
+    /**
+     * Scan code content for forbidden console method calls.
+     * Returns violations with line numbers.
+     */
+    checkCode(content: string, filePath?: string): ConsoleLogViolation[];
+    /**
+     * Determine if a file path points to a test file.
+     */
+    isTestFile(filePath: string): boolean;
+    /**
+     * Remove single-line (//) and multi-line comments from source code.
+     * Preserves line structure so line numbers remain valid.
+     */
+    stripComments(content: string): string;
+}
+export declare function runConsoleLogGuard(context: PreValidateContext): Promise<ProcessorExecutionResult>;

package/dist/processors/implementations/coverage-analysis-processor.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Coverage Analysis Processor
+ *
+ * Analyzes test coverage for modified files and reports coverage gaps.
+ *
+ * @module processors/implementations
+ * @version 1.0.0
+ */
+import { PostProcessor } from "../processor-interfaces.js";
+import { ProcessorContext } from "../processor-types.js";
+export declare class CoverageAnalysisProcessor extends PostProcessor {
+    readonly name = "coverageAnalysis";
+    readonly priority = 45;
+    protected run(context: ProcessorContext): Promise<unknown>;
+    private analyzeCoverage;
+    private findRelatedTestFiles;
+    private countSourceLines;
+    private countTestLines;
+}
+export declare const coverageAnalysisProcessor: CoverageAnalysisProcessor;

package/dist/processors/implementations/error-boundary-processor.d.ts

@@ -0,0 +1,7 @@
+import { PreProcessor } from "../processor-interfaces.js";
+import type { ProcessorContext, ProcessorResult } from "../processor-types.js";
+export declare class ErrorBoundaryProcessor extends PreProcessor {
+    readonly name = "errorBoundary";
+    readonly priority = 5;
+    protected run(context: ProcessorContext): Promise<ProcessorResult>;
+}

package/dist/processors/implementations/inference-improvement-processor.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Inference Improvement Coordinator
+ *
+ * Lightweight processor that coordinates the agent-based inference workflow.
+ * The actual analysis is done by collaborating agents (researcher, code-analyzer,
+ * architect, code-reviewer, enforcer) - this processor prepares context and triggers.
+ *
+ * @module processors/implementations
+ */
+import { PostProcessor } from "../processor-interfaces.js";
+export declare class InferenceImprovementProcessor extends PostProcessor {
+    readonly name = "inferenceImprovement";
+    readonly priority = 5;
+    private readonly reflectionsDir;
+    private readonly logsDir;
+    private readonly reportsDir;
+    private readonly workflowDir;
+    private readonly inferenceEnabled;
+    private readonly patternMatchingEnabled;
+    private readonly patternMatchingThreshold;
+    constructor();
+    private loadInferenceConfig;
+    protected run(context: unknown): Promise<unknown>;
+    private prepareWorkflowContext;
+    private findReflections;
+    private findLogs;
+    private findReports;
+    private saveWorkflowContext;
+    private generateAgentPrompts;
+    private generateResearcherPrompt;
+    private generateCodeAnalyzerPrompt;
+    private generateArchitectPrompt;
+    private generateCodeReviewerPrompt;
+    private generateEnforcerPrompt;
+    private triggerAgentWorkflow;
+}

package/dist/processors/implementations/log-protection-processor.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Log Protection Processor
+ *
+ * Prevents deletion of critical inference log files that are essential
+ * for the tuning engines and pattern learning system.
+ *
+ * Protected files:
+ * - routing-outcomes.json (routing analytics - NEVER delete)
+ * - activity.log (framework activity - NEVER delete)
+ * - strray-plugin-*.log (plugin logs)
+ *
+ * Archival flow is ALLOWED:
+ * - framework-activity-*.log.gz (archived/compressed logs)
+ * - Copy operations to create new archive files
+ *
+ * @module processors/implementations
+ * @version 1.1.0
+ */
+import { PreProcessor } from "../processor-interfaces.js";
+import { ProcessorContext } from "../processor-types.js";
+export declare class LogProtectionProcessor extends PreProcessor {
+    readonly name = "logProtection";
+    readonly priority = 10;
+    protected run(context: ProcessorContext): Promise<unknown>;
+    private isDeleteOperation;
+    private isArchiveCleanup;
+    private getActiveLogFile;
+    private getOperation;
+}
+export declare const logProtectionProcessor: LogProtectionProcessor;

package/dist/processors/implementations/nudge-processor.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Nudge Processor - Integrates Nudge Watchdog with processor system
+ *
+ * Post-processor that monitors agent actions and triggers nudges
+ * when stuck patterns are detected.
+ *
+ * @module processors/implementations
+ * @version 1.0.0
+ */
+import { PostProcessor } from "../processor-interfaces.js";
+import { ProcessorContext, ProcessorResult } from "../processor-types.js";
+export declare class NudgeProcessor extends PostProcessor {
+    readonly name = "nudge";
+    readonly priority = 100;
+    private nudgeEnabled;
+    constructor();
+    private loadConfig;
+    protected run(context: ProcessorContext): Promise<unknown>;
+    private detectMostUrgentNudge;
+}
+export declare const nudgeProcessor: NudgeProcessor;
+export declare function executeNudgeProcessor(context: ProcessorContext): Promise<ProcessorResult>;

package/dist/processors/implementations/performance-budget-processor.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Performance Budget Processor
+ *
+ * Enforces codex term #28: Performance Budgets.
+ * Checks code content against configurable size, function-length, nesting-depth,
+ * and parameter-count budgets. Returns structured violation lists.
+ *
+ * @version 1.0.0
+ * @since 2026-03-28
+ */
+import type { PreValidateContext, ProcessorExecutionResult } from "../processor-types.js";
+export type PerformanceViolationType = "fileTooLarge" | "functionTooLong" | "nestingTooDeep" | "tooManyParameters";
+export interface PerformanceViolation {
+    type: PerformanceViolationType;
+    filePath: string;
+    line?: number;
+    message: string;
+    actual: number;
+    limit: number;
+}
+export interface PerformanceBudgetConfig {
+    maxFileSizeBytes: number;
+    maxFunctionLines: number;
+    maxNestingDepth: number;
+    maxParameters: number;
+}
+export declare const DEFAULT_PERFORMANCE_BUDGET: PerformanceBudgetConfig;
+export declare class PerformanceBudgetProcessor {
+    private readonly config;
+    constructor(config?: Partial<PerformanceBudgetConfig>);
+    /**
+     * Check a file against all budget rules.
+     */
+    checkFile(filePath: string, content: string): PerformanceViolation[];
+    /**
+     * Analyse every function body in `content` and check complexity budgets.
+     */
+    checkFunctionComplexity(content: string): PerformanceViolation[];
+    /**
+     * Regex-based extraction of named functions / methods / arrow functions.
+     * Does NOT require a full AST – keeps the processor zero-dependency.
+     */
+    private extractFunctions;
+    /**
+     * Measure the maximum nesting depth by tracking control-flow keywords
+     * (if / for / while / switch / try) inside the function body.
+     */
+    private measureMaxNesting;
+}
+export declare function runPerformanceBudgetCheck(context: PreValidateContext): Promise<ProcessorExecutionResult>;

package/dist/processors/implementations/postprocessor-chain-validator.d.ts

@@ -0,0 +1,46 @@
+/**
+ * PostProcessor Chain Validator
+ *
+ * Validates postprocessor execution chain integrity.
+ * Checks that all registered postprocessors executed without errors,
+ * validates priority ordering, and detects skipped or crashed processors.
+ *
+ * @version 1.0.0
+ * @since 2026-03-28
+ */
+import type { PostValidateContext, ProcessorExecutionResult } from "../processor-types.js";
+export interface ChainValidationResult {
+    valid: boolean;
+    issues: ChainIssue[];
+}
+export interface ChainIssue {
+    severity: "error" | "warning";
+    processorName: string;
+    message: string;
+}
+export interface ChainReport {
+    totalProcessors: number;
+    successful: number;
+    failed: number;
+    skipped: number;
+    issues: ChainIssue[];
+    averageDuration: number;
+    executedInPriorityOrder: boolean;
+}
+export declare class PostProcessorChainValidator {
+    private chainReport;
+    /**
+     * Validate the postprocessor execution chain.
+     */
+    validateChain(results: Array<{
+        name: string;
+        success: boolean;
+        duration: number;
+        priority?: number;
+    }>): ChainValidationResult;
+    /**
+     * Get the chain report from the most recent validation.
+     */
+    getChainReport(): ChainReport;
+}
+export declare function runPostProcessorChainValidation(context: PostValidateContext): Promise<ProcessorExecutionResult>;

package/dist/processors/implementations/pre-validate-processor.d.ts

@@ -0,0 +1,7 @@
+import { PreProcessor } from "../processor-interfaces.js";
+import type { ProcessorContext } from "../processor-types.js";
+export declare class PreValidateProcessor extends PreProcessor {
+    readonly name = "preValidate";
+    readonly priority = 1;
+    protected run(context: ProcessorContext): Promise<Record<string, unknown>>;
+}

package/dist/processors/implementations/publish-preflight-processor.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Publish Preflight Processor
+ *
+ * Post-processor that validates documentation completeness before publishing.
+ * Ensures README.md, AGENTS.md, and reflection documents are up-to-date
+ * before allowing npm publish.
+ *
+ * Configuration is read from .strray/features.json
+ *
+ * @processor_type post
+ * @priority 10 (runs early after post-processing starts)
+ * @blocking true (blocks publish on violations)
+ *
+ * @version 1.0.0
+ * @framework 0xRay 1.15.41
+ */
+import { PostProcessor } from "../processor-interfaces.js";
+import { ProcessorContext, ProcessorResult } from "../processor-types.js";
+export interface PreflightResult {
+    compliant: boolean;
+    checks: PreflightCheck[];
+    summary: string;
+}
+export interface PreflightCheck {
+    name: string;
+    passed: boolean;
+    message: string;
+    required: boolean;
+}
+export declare class PublishPreflightProcessor extends PostProcessor {
+    readonly name = "publishPreflight";
+    readonly priority = 10;
+    private config;
+    constructor();
+    private loadConfig;
+    protected run(context: ProcessorContext): Promise<unknown>;
+    execute(context: ProcessorContext): Promise<ProcessorResult>;
+}

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

@@ -0,0 +1,7 @@
+import { PreProcessor } from "../processor-interfaces.js";
+import type { ProcessorContext } from "../processor-types.js";
+export declare class RefactoringLoggingProcessorWrapper extends PreProcessor {
+    readonly name = "refactoringLogging";
+    readonly priority = 8;
+    protected run(context: ProcessorContext): Promise<Record<string, unknown>>;
+}

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

@@ -0,0 +1,31 @@
+export 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;
+}
+export 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;
+}

package/dist/processors/implementations/regression-testing-processor.d.ts

@@ -0,0 +1,20 @@
+import { PostProcessor } from "../processor-interfaces.js";
+import type { ProcessorContext } from "../processor-types.js";
+interface RegressionResult {
+    regressions: number;
+    issues: RegressionIssue[];
+    baseline: string | null;
+    current: string | null;
+}
+interface RegressionIssue {
+    type: "new_failure" | "coverage_drop" | "performance_degradation";
+    description: string;
+    file?: string;
+}
+export declare class RegressionTestingProcessor extends PostProcessor {
+    readonly name = "regressionTesting";
+    readonly priority = 15;
+    protected run(context: ProcessorContext): Promise<RegressionResult>;
+    private getCurrentTestCount;
+}
+export {};

package/dist/processors/implementations/session-summary-processor.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Session Summary Post-Processor
+ *
+ * Generates emoji-formatted session summaries after tool execution.
+ * Uses features.json -> auto_reporting config for control.
+ *
+ * @version 1.0.0
+ * @since 2026-04-04
+ */
+import { PostProcessor, ProcessorContext } from "../processor-interfaces.js";
+export declare class SessionSummaryProcessor extends PostProcessor {
+    readonly name = "sessionSummary";
+    readonly priority = 15;
+    private config;
+    private sessionStartTime;
+    private agentActivities;
+    private toolCalls;
+    private operations;
+    constructor();
+    private loadConfig;
+    run(context: ProcessorContext): Promise<unknown>;
+    private shouldGenerateSummary;
+    private generateEmojiSummary;
+    private generateRecommendation;
+    private stripEmojis;
+}
+export default SessionSummaryProcessor;

package/dist/processors/implementations/spawn-governance-processor.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Spawn Governance Processor
+ *
+ * Enforces codex terms #52-57:
+ *  - #52 Agent Spawn Governance
+ *  - #53 Subagent Spawning Prevention
+ *  - #54 Concurrent Agent Limits
+ *  - #55 Emergency Memory Cleanup
+ *  - #56 Infinite Spawn Pattern Detection
+ *  - #57 Spawn Rate Limiting
+ *
+ * @version 1.0.0
+ * @since 2026-03-28
+ */
+export interface SpawnGovernanceConfig {
+    maxConcurrent: number;
+    rateLimitWindowMs: number;
+    maxSpawnsPerWindow: number;
+    memoryThreshold: number;
+    infiniteSpawnThreshold: number;
+    infiniteSpawnWindowMs: number;
+}
+export declare class SpawnGovernanceProcessor {
+    static readonly DEFAULT_MAX_CONCURRENT = 5;
+    static readonly DEFAULT_RATE_LIMIT_WINDOW_MS = 10000;
+    static readonly DEFAULT_MAX_SPAWNS_PER_WINDOW = 10;
+    static readonly DEFAULT_MEMORY_THRESHOLD = 0.8;
+    private readonly config;
+    private activeSpawns;
+    private spawnTimestamps;
+    private agentSpawnTimestamps;
+    private blockedCount;
+    private subagentDepth;
+    constructor(config?: Partial<SpawnGovernanceConfig>);
+    checkSpawnAllowed(agentName: string): {
+        allowed: boolean;
+        reason?: string;
+    };
+    recordSpawn(agentName: string): void;
+    recordSpawnComplete(agentName: string): void;
+    getMetrics(): {
+        activeSpawns: number;
+        recentSpawns: number;
+        blockedSpawns: number;
+        memoryUsage: number;
+    };
+    emergencyCleanup(): void;
+    setSubagentDepth(agentName: string, depth: number): void;
+    private purgeOldTimestamps;
+    private getMemoryUsageRatio;
+}
+export declare function resetGovernanceProcessor(): void;
+export declare function runSpawnGovernance(context: any): Promise<{
+    success: boolean;
+    allowed: boolean;
+    reason?: string;
+    metrics: ReturnType<SpawnGovernanceProcessor["getMetrics"]>;
+}>;

package/dist/processors/implementations/state-validation-processor.d.ts

@@ -0,0 +1,11 @@
+import { PostProcessor } from "../processor-interfaces.js";
+import type { ProcessorContext } from "../processor-types.js";
+import type { ProcessorDependency } from "../processor-interfaces.js";
+export declare class StateValidationProcessor extends PostProcessor {
+    readonly name = "stateValidation";
+    readonly priority = 12;
+    static readonly dependencies: ProcessorDependency[];
+    private stateManager;
+    constructor(stateManager?: any);
+    protected run(_context: ProcessorContext): Promise<Record<string, boolean>>;
+}

package/dist/processors/implementations/storytelling-trigger-processor.d.ts

@@ -0,0 +1,42 @@
+import { PostProcessor } from "../processor-interfaces.js";
+import { ProcessorContext } from "../processor-types.js";
+export declare class StorytellingTriggerProcessor extends PostProcessor {
+    readonly name = "storytelling-trigger";
+    readonly priority = 5;
+    private config;
+    private reflectionsDir;
+    private deepReflectionsDir;
+    constructor();
+    private loadConfig;
+    private resolveConfigPath;
+    protected run(context: ProcessorContext): Promise<unknown>;
+    private runInferenceCycle;
+    private reflectOnCommits;
+    private reflectOnRelease;
+    private synthesizeReflection;
+    private detectPatterns;
+    private detectSemanticPatterns;
+    private extractDecisions;
+    private synthesizeInferences;
+    private getCommitsBetween;
+    private getRecentCommits;
+    private summarizeCommits;
+    private getLastTag;
+    private getFileCommitHash;
+    private getMostRecentReflectionFile;
+    private git;
+    static suggestStoryType(context: {
+        commitCount?: number;
+        fileCount?: number;
+        sessionDuration?: number;
+        isPublishing?: boolean;
+    }): "reflection" | "saga" | "journey" | "narrative";
+    static getStoryTypeMeta(storyType: string): {
+        location: string;
+        minWords: number;
+        idealWords: number;
+        framework: string;
+        template: string;
+    };
+}
+export default StorytellingTriggerProcessor;

package/dist/processors/implementations/test-auto-creation-processor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Test Auto-Creation Processor
+ *
+ * Automatically generates test files when new source files are created.
+ * Supports multiple languages: TypeScript, JavaScript, Python, Go, Rust, Java, C#
+ * Uses direct skill calls (no MCP overhead) for instant test generation.
+ *
+ * @version 1.1.0
+ * @since 2026-02-15
+ */
+export declare const testAutoCreationProcessor: {
+    name: string;
+    priority: number;
+    enabled: boolean;
+    execute(context: any): Promise<any>;
+};
+export default testAutoCreationProcessor;

package/dist/processors/implementations/test-execution-processor.d.ts

@@ -0,0 +1,11 @@
+import { PreProcessor } from "../processor-interfaces.js";
+import type { ProcessorContext } from "../processor-types.js";
+export declare class TestExecutionProcessor extends PreProcessor {
+    readonly name = "testExecution";
+    readonly priority = 10;
+    protected run(context: ProcessorContext): Promise<Record<string, unknown>>;
+    private executeTypeScriptTests;
+    private executeGenericTests;
+    private runTestCommand;
+    private parseTestOutput;
+}

package/dist/processors/implementations/typescript-compilation-processor.d.ts

@@ -0,0 +1,38 @@
+/**
+ * TypeScript Compilation Processor
+ *
+ * Runs `tsc --noEmit` to catch type errors before writes land.
+ * Parses TypeScript error lines from stderr and returns structured results.
+ * Gracefully skips when no tsconfig.json exists.
+ *
+ * @version 1.0.0
+ * @since 2026-03-28
+ */
+export interface TypeScriptCompilationResult {
+    success: boolean;
+    errors: string[];
+    duration: number;
+    fileCount: number;
+    errorCount?: number;
+    skipped?: boolean;
+    reason?: string;
+}
+/**
+ * Parse TypeScript error lines from stderr output.
+ * Filters for lines containing "error TS" which is the standard TypeScript error format.
+ */
+export declare function parseTypeScriptErrors(stderr: string): string[];
+/**
+ * Run TypeScript compilation check (tsc --noEmit).
+ *
+ * @param cwd - Working directory for the command (defaults to process.cwd())
+ * @param timeout - Maximum execution time in milliseconds (default 30000)
+ * @returns Structured result with success status, errors, and timing
+ */
+export declare function runTypeScriptCompilation(cwd?: string, timeout?: number): TypeScriptCompilationResult;
+export declare const typescriptCompilationProcessor: {
+    name: string;
+    priority: number;
+    enabled: boolean;
+    execute(context: Record<string, unknown>): Promise<TypeScriptCompilationResult>;
+};