mcp-decisive
Version:
MCP server for WRAP decision-making framework with structured output
87 lines • 4.22 kB
JavaScript
import { ok, err } from 'neverthrow';
import { IssueText, ContextText, ConstraintText } from '../term/issue-definition.js';
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// Implementation Section
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// Business rule: Validate issue definition request
const validateDefineRequest = (request) => {
const issueResult = IssueText.create(request.issue);
const contextResult = ContextText.create(request.context);
const constraintsResult = ConstraintText.create(request.constraints);
// Collect all validation errors
const allErrors = [];
if (issueResult.isErr()) {
allErrors.push(...issueResult.error);
}
if (contextResult.isErr()) {
allErrors.push(...contextResult.error);
}
if (constraintsResult.isErr()) {
allErrors.push(...constraintsResult.error);
}
if (allErrors.length > 0) {
return err({
type: 'ValidationFailed',
validationErrors: allErrors
});
}
// All validations passed - safe to unwrap
if (issueResult.isOk() && contextResult.isOk() && constraintsResult.isOk()) {
return ok({
issue: issueResult.value,
context: contextResult.value,
constraints: constraintsResult.value
});
}
// This should never happen since we already collected all errors above
throw new Error('Unexpected validation state');
};
// Command implementation using functional composition
const defineIssueCommand = (request) => validateDefineRequest(request)
.andThen(validated => {
// Create the issue definition entity
const issueDefinition = {
issue: validated.issue,
context: validated.context,
constraints: validated.constraints
};
// Return the event
const event = {
type: 'IssueDefinitionCreated',
issueDefinition
};
return ok(event);
});
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// Error Handling Utilities
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
const IssueDefinitionErrorHandler = {
// Smart constructor for validation errors
validationFailed: (validationErrors) => ({
type: 'ValidationFailed',
validationErrors
}),
// Convert errors to user-friendly messages
toString: (error) => {
switch (error.type) {
case 'ValidationFailed':
return `Validation failed: ${error.validationErrors.map(e => e.message).join(', ')}`;
default:
return `Unknown error type`;
}
}
};
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// Public API - Expose only what's needed
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
/**
* Issue Definition Aggregate - The public interface for issue definition commands
*
* @command defineIssue - Create a new issue definition
* @utility toErrorMessage - Convert errors to user-friendly strings
*/
export const IssueDefinitionAggregate = {
defineIssue: defineIssueCommand,
toErrorMessage: IssueDefinitionErrorHandler.toString,
};
//# sourceMappingURL=define-issue.js.map