codecrucible-synth
Version:
Production-Ready AI Development Platform with Multi-Voice Synthesis, Smithery MCP Integration, Enterprise Security, and Zero-Timeout Reliability
294 lines • 9.43 kB
JavaScript
/**
* Request Domain Entity
* Pure business logic for processing requests
*
* Living Spiral Council Applied:
* - Domain-driven design with immutable request entities
* - Business rules for request validation and prioritization
* - No external dependencies or infrastructure concerns
*/
import { RequestPriority } from '../value-objects/voice-values.js';
/**
* Processing Request Entity
*/
export class ProcessingRequest {
_id;
_content;
_type;
_priority;
_context;
_constraints;
_timestamp;
_status;
constructor(id, content, type, priority, context, constraints) {
this.validateInputs(id, content);
this._id = id;
this._content = content;
this._type = type;
this._priority = priority;
this._context = context;
this._constraints = constraints;
this._timestamp = new Date();
this._status = RequestStatus.PENDING;
}
// Getters
get id() {
return this._id;
}
get content() {
return this._content;
}
get type() {
return this._type;
}
get priority() {
return this._priority;
}
get context() {
return this._context;
}
get constraints() {
return this._constraints;
}
get timestamp() {
return new Date(this._timestamp);
}
get status() {
return this._status;
}
// Business methods
/**
* Start processing this request
*/
startProcessing() {
if (this._status !== RequestStatus.PENDING) {
throw new Error(`Cannot start processing request in ${this._status} status`);
}
const newRequest = this.clone();
newRequest._status = RequestStatus.PROCESSING;
return newRequest;
}
/**
* Complete this request successfully
*/
complete() {
if (this._status !== RequestStatus.PROCESSING) {
throw new Error(`Cannot complete request in ${this._status} status`);
}
const newRequest = this.clone();
newRequest._status = RequestStatus.COMPLETED;
return newRequest;
}
/**
* Mark this request as failed
*/
fail(error) {
if (this._status === RequestStatus.COMPLETED) {
throw new Error('Cannot fail a completed request');
}
const newRequest = this.clone();
newRequest._status = RequestStatus.FAILED;
return newRequest;
}
/**
* Cancel this request
*/
cancel() {
if (this._status === RequestStatus.COMPLETED) {
throw new Error('Cannot cancel a completed request');
}
const newRequest = this.clone();
newRequest._status = RequestStatus.CANCELLED;
return newRequest;
}
/**
* Check if this request requires specific capabilities
*/
requiresCapabilities() {
const capabilities = [];
switch (this._type) {
case RequestType.CODE_GENERATION:
capabilities.push('code-generation', 'syntax-validation');
break;
case RequestType.CODE_ANALYSIS:
capabilities.push('code-analysis', 'pattern-recognition');
break;
case RequestType.ARCHITECTURE_DESIGN:
capabilities.push('system-design', 'architecture-planning');
break;
case RequestType.DOCUMENTATION:
capabilities.push('documentation', 'technical-writing');
break;
case RequestType.OPTIMIZATION:
capabilities.push('performance-analysis', 'optimization');
break;
case RequestType.REVIEW:
capabilities.push('code-review', 'quality-assessment');
break;
}
// Add context-specific capabilities
if (this._context.languages && this._context.languages.length > 0) {
this._context.languages.forEach(lang => {
capabilities.push(`${lang.toLowerCase()}-programming`);
});
}
return capabilities;
}
/**
* Calculate processing complexity score
*/
calculateComplexity() {
let complexity = 0.1; // Base complexity
// Content length factor (30%)
const contentComplexity = Math.min(this._content.length / 10000, 1.0);
complexity += contentComplexity * 0.3;
// Type complexity factor (40%)
const typeComplexity = this.getTypeComplexity();
complexity += typeComplexity * 0.4;
// Context complexity factor (30%)
const contextComplexity = this.getContextComplexity();
complexity += contextComplexity * 0.3;
return Math.min(1.0, complexity);
}
/**
* Estimate processing time in milliseconds
*/
estimateProcessingTime() {
const baseTime = 1000; // 1 second base
const complexity = this.calculateComplexity();
const priorityMultiplier = this.getPriorityMultiplier();
return baseTime * (1 + complexity * 3) * priorityMultiplier;
}
/**
* Get request configuration
*/
toConfig() {
return {
id: this._id,
content: this._content,
type: this._type,
priority: this._priority.value,
context: this._context,
constraints: this._constraints,
timestamp: this._timestamp.toISOString(),
status: this._status,
};
}
/**
* Create request from configuration
*/
static fromConfig(config) {
const request = new ProcessingRequest(config.id, config.content, config.type, RequestPriority.create(config.priority), config.context, config.constraints);
request._status = config.status;
return request;
}
// Private helper methods
clone() {
const cloned = new ProcessingRequest(this._id, this._content, this._type, this._priority, this._context, this._constraints);
cloned._status = this._status;
return cloned;
}
getTypeComplexity() {
switch (this._type) {
case RequestType.CODE_GENERATION:
return 0.8;
case RequestType.ARCHITECTURE_DESIGN:
return 1.0;
case RequestType.CODE_ANALYSIS:
return 0.6;
case RequestType.OPTIMIZATION:
return 0.7;
case RequestType.REVIEW:
return 0.5;
case RequestType.DOCUMENTATION:
return 0.4;
default:
return 0.5;
}
}
getContextComplexity() {
let complexity = 0;
if (this._context.languages) {
complexity += this._context.languages.length * 0.1;
}
if (this._context.frameworks) {
complexity += this._context.frameworks.length * 0.1;
}
if (this._context.projectSize && this._context.projectSize > 1000) {
complexity += 0.3;
}
return Math.min(1.0, complexity);
}
getPriorityMultiplier() {
switch (this._priority.value) {
case 'low':
return 1.5;
case 'medium':
return 1.0;
case 'high':
return 0.8;
case 'critical':
return 0.6;
default:
return 1.0;
}
}
validateInputs(id, content) {
if (!id || id.trim().length === 0) {
throw new Error('Request ID cannot be empty');
}
if (!content || content.trim().length === 0) {
throw new Error('Request content cannot be empty');
}
if (content.length > 100000) {
throw new Error('Request content cannot exceed 100,000 characters');
}
}
}
/**
* Request Type Enumeration
*/
export var RequestType;
(function (RequestType) {
RequestType["CODE_GENERATION"] = "code-generation";
RequestType["CODE_ANALYSIS"] = "code-analysis";
RequestType["ARCHITECTURE_DESIGN"] = "architecture-design";
RequestType["DOCUMENTATION"] = "documentation";
RequestType["OPTIMIZATION"] = "optimization";
RequestType["REVIEW"] = "review";
})(RequestType || (RequestType = {}));
/**
* Request Status Enumeration
*/
export var RequestStatus;
(function (RequestStatus) {
RequestStatus["PENDING"] = "pending";
RequestStatus["PROCESSING"] = "processing";
RequestStatus["COMPLETED"] = "completed";
RequestStatus["FAILED"] = "failed";
RequestStatus["CANCELLED"] = "cancelled";
})(RequestStatus || (RequestStatus = {}));
/**
* Request Factory
*/
export class RequestFactory {
/**
* Create a code generation request
*/
static createCodeGeneration(id, content, priority, context) {
return new ProcessingRequest(id, content, RequestType.CODE_GENERATION, priority, context, {});
}
/**
* Create a code analysis request
*/
static createCodeAnalysis(id, content, priority, context) {
return new ProcessingRequest(id, content, RequestType.CODE_ANALYSIS, priority, context, {});
}
/**
* Create an architecture design request
*/
static createArchitectureDesign(id, content, priority, context) {
return new ProcessingRequest(id, content, RequestType.ARCHITECTURE_DESIGN, priority, context, {});
}
}
//# sourceMappingURL=request.js.map