@flowdot.ai/daemon 1.0.0

package/dist/goals/GoalValidator.js

@@ -0,0 +1,657 @@
+import { isGoalPriority, isApprovalMode, isTaskType, isMemoryType, isMemorySource, isFeedbackQuality, isValidGoalHash, } from './types.js';
+import { ValidationError } from './errors.js';
+export const DEFAULT_GOAL_VALIDATION_CONSTRAINTS = {
+    maxNameLength: 255,
+    minNameLength: 1,
+    maxDescriptionLength: 5000,
+    maxTitleLength: 255,
+    minTitleLength: 1,
+    maxMemoryContentLength: 2000,
+    minMemoryContentLength: 1,
+    maxMetaGoalDescriptionLength: 1000,
+    minMetaGoalDescriptionLength: 1,
+    maxMetaGoalPriority: 100,
+    minMetaGoalPriority: 0,
+    maxFeedbackCommentLength: 1000,
+    maxDependencies: 50,
+    namePattern: /^[a-zA-Z0-9][a-zA-Z0-9\s_-]*$/,
+};
+export class GoalValidator {
+    constraints;
+    constructor(constraints = {}) {
+        this.constraints = { ...DEFAULT_GOAL_VALIDATION_CONSTRAINTS, ...constraints };
+    }
+    validateCreateGoalInput(input) {
+        const result = this.validateCreateGoalInputSafe(input);
+        if (!result.valid) {
+            throw new ValidationError('Goal validation failed', this.issuesToRecord(result.errors));
+        }
+    }
+    validateCreateGoalInputSafe(input) {
+        const errors = [];
+        if (!input.name) {
+            errors.push({ field: 'name', message: 'Name is required' });
+        }
+        else {
+            this.validateName(input.name, errors);
+        }
+        if (input.description !== undefined) {
+            this.validateDescription(input.description, errors);
+        }
+        if (input.priority !== undefined && !isGoalPriority(input.priority)) {
+            errors.push({
+                field: 'priority',
+                message: 'Priority must be one of: high, medium, low',
+                value: input.priority,
+            });
+        }
+        if (input.approvalMode !== undefined && !isApprovalMode(input.approvalMode)) {
+            errors.push({
+                field: 'approvalMode',
+                message: 'Approval mode must be one of: full, category, trusted',
+                value: input.approvalMode,
+            });
+        }
+        if (input.deadline !== undefined) {
+            this.validateDateString(input.deadline, 'deadline', errors);
+        }
+        if (input.parentHash !== undefined && !isValidGoalHash(input.parentHash)) {
+            errors.push({
+                field: 'parentHash',
+                message: 'Invalid parent goal hash',
+                value: input.parentHash,
+            });
+        }
+        if (input.dependsOn !== undefined) {
+            this.validateDependencies(input.dependsOn, errors);
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    validateUpdateGoalInput(input) {
+        const result = this.validateUpdateGoalInputSafe(input);
+        if (!result.valid) {
+            throw new ValidationError('Goal update validation failed', this.issuesToRecord(result.errors));
+        }
+    }
+    validateUpdateGoalInputSafe(input) {
+        const errors = [];
+        const hasAnyField = input.name !== undefined ||
+            input.description !== undefined ||
+            input.priority !== undefined ||
+            input.approvalMode !== undefined ||
+            input.deadline !== undefined ||
+            input.restrictions !== undefined ||
+            input.schedule !== undefined ||
+            input.notificationPreferences !== undefined ||
+            input.reviewSchedule !== undefined ||
+            input.dependsOn !== undefined;
+        if (!hasAnyField) {
+            errors.push({ field: '_root', message: 'At least one field must be provided for update' });
+        }
+        if (input.name !== undefined) {
+            this.validateName(input.name, errors);
+        }
+        if (input.description !== undefined) {
+            this.validateDescription(input.description, errors);
+        }
+        if (input.priority !== undefined && !isGoalPriority(input.priority)) {
+            errors.push({
+                field: 'priority',
+                message: 'Priority must be one of: high, medium, low',
+                value: input.priority,
+            });
+        }
+        if (input.approvalMode !== undefined && !isApprovalMode(input.approvalMode)) {
+            errors.push({
+                field: 'approvalMode',
+                message: 'Approval mode must be one of: full, category, trusted',
+                value: input.approvalMode,
+            });
+        }
+        if (input.deadline !== undefined) {
+            this.validateDateString(input.deadline, 'deadline', errors);
+        }
+        if (input.dependsOn !== undefined) {
+            this.validateDependencies(input.dependsOn, errors);
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    validateCreateMilestoneInput(input) {
+        const result = this.validateCreateMilestoneInputSafe(input);
+        if (!result.valid) {
+            throw new ValidationError('Milestone validation failed', this.issuesToRecord(result.errors));
+        }
+    }
+    validateCreateMilestoneInputSafe(input) {
+        const errors = [];
+        if (!input.title) {
+            errors.push({ field: 'title', message: 'Title is required' });
+        }
+        else {
+            this.validateTitle(input.title, errors);
+        }
+        if (input.description !== undefined) {
+            this.validateDescription(input.description, errors);
+        }
+        if (input.targetDate !== undefined) {
+            this.validateDateString(input.targetDate, 'targetDate', errors);
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    validateUpdateMilestoneInput(input) {
+        const result = this.validateUpdateMilestoneInputSafe(input);
+        if (!result.valid) {
+            throw new ValidationError('Milestone update validation failed', this.issuesToRecord(result.errors));
+        }
+    }
+    validateUpdateMilestoneInputSafe(input) {
+        const errors = [];
+        const hasAnyField = input.title !== undefined ||
+            input.description !== undefined ||
+            input.targetDate !== undefined;
+        if (!hasAnyField) {
+            errors.push({ field: '_root', message: 'At least one field must be provided for update' });
+        }
+        if (input.title !== undefined) {
+            this.validateTitle(input.title, errors);
+        }
+        if (input.description !== undefined) {
+            this.validateDescription(input.description, errors);
+        }
+        if (input.targetDate !== undefined) {
+            this.validateDateString(input.targetDate, 'targetDate', errors);
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    validateCreateTaskInput(input) {
+        const result = this.validateCreateTaskInputSafe(input);
+        if (!result.valid) {
+            throw new ValidationError('Task validation failed', this.issuesToRecord(result.errors));
+        }
+    }
+    validateCreateTaskInputSafe(input) {
+        const errors = [];
+        if (!input.title) {
+            errors.push({ field: 'title', message: 'Title is required' });
+        }
+        else {
+            this.validateTitle(input.title, errors);
+        }
+        if (input.description !== undefined) {
+            this.validateDescription(input.description, errors);
+        }
+        if (input.taskType !== undefined && !isTaskType(input.taskType)) {
+            errors.push({
+                field: 'taskType',
+                message: 'Task type must be one of: research, draft, code, execute, recipe, loop, notify',
+                value: input.taskType,
+            });
+        }
+        if (input.scheduledFor !== undefined) {
+            this.validateDateString(input.scheduledFor, 'scheduledFor', errors);
+        }
+        if (input.milestoneId !== undefined && typeof input.milestoneId !== 'number') {
+            errors.push({
+                field: 'milestoneId',
+                message: 'Milestone ID must be a number',
+                value: input.milestoneId,
+            });
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    validateUpdateTaskInput(input) {
+        const result = this.validateUpdateTaskInputSafe(input);
+        if (!result.valid) {
+            throw new ValidationError('Task update validation failed', this.issuesToRecord(result.errors));
+        }
+    }
+    validateUpdateTaskInputSafe(input) {
+        const errors = [];
+        const hasAnyField = input.title !== undefined ||
+            input.description !== undefined ||
+            input.taskType !== undefined ||
+            input.permissionCategory !== undefined ||
+            input.scheduledFor !== undefined ||
+            input.milestoneId !== undefined;
+        if (!hasAnyField) {
+            errors.push({ field: '_root', message: 'At least one field must be provided for update' });
+        }
+        if (input.title !== undefined) {
+            this.validateTitle(input.title, errors);
+        }
+        if (input.description !== undefined) {
+            this.validateDescription(input.description, errors);
+        }
+        if (input.taskType !== undefined && !isTaskType(input.taskType)) {
+            errors.push({
+                field: 'taskType',
+                message: 'Task type must be one of: research, draft, code, execute, recipe, loop, notify',
+                value: input.taskType,
+            });
+        }
+        if (input.scheduledFor !== undefined) {
+            this.validateDateString(input.scheduledFor, 'scheduledFor', errors);
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    validateTaskFeedbackInput(input) {
+        const result = this.validateTaskFeedbackInputSafe(input);
+        if (!result.valid) {
+            throw new ValidationError('Task feedback validation failed', this.issuesToRecord(result.errors));
+        }
+    }
+    validateTaskFeedbackInputSafe(input) {
+        const errors = [];
+        if (!isFeedbackQuality(input.quality)) {
+            errors.push({
+                field: 'quality',
+                message: 'Quality must be one of: high, medium, low',
+                value: input.quality,
+            });
+        }
+        if (input.comment !== undefined) {
+            if (typeof input.comment !== 'string') {
+                errors.push({
+                    field: 'comment',
+                    message: 'Comment must be a string',
+                    value: input.comment,
+                });
+            }
+            else if (input.comment.length > this.constraints.maxFeedbackCommentLength) {
+                errors.push({
+                    field: 'comment',
+                    message: `Comment must be at most ${this.constraints.maxFeedbackCommentLength} characters`,
+                    value: input.comment.length,
+                });
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    validateCreateMemoryInput(input) {
+        const result = this.validateCreateMemoryInputSafe(input);
+        if (!result.valid) {
+            throw new ValidationError('Memory validation failed', this.issuesToRecord(result.errors));
+        }
+    }
+    validateCreateMemoryInputSafe(input) {
+        const errors = [];
+        if (!input.content) {
+            errors.push({ field: 'content', message: 'Content is required' });
+        }
+        else {
+            this.validateMemoryContent(input.content, errors);
+        }
+        if (input.memoryType !== undefined && !isMemoryType(input.memoryType)) {
+            errors.push({
+                field: 'memoryType',
+                message: 'Memory type must be one of: conversation, decision, learning',
+                value: input.memoryType,
+            });
+        }
+        if (input.source !== undefined && !isMemorySource(input.source)) {
+            errors.push({
+                field: 'source',
+                message: 'Source must be one of: manual, auto',
+                value: input.source,
+            });
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    validateUpdateMemoryInput(input) {
+        const result = this.validateUpdateMemoryInputSafe(input);
+        if (!result.valid) {
+            throw new ValidationError('Memory update validation failed', this.issuesToRecord(result.errors));
+        }
+    }
+    validateUpdateMemoryInputSafe(input) {
+        const errors = [];
+        const hasAnyField = input.content !== undefined ||
+            input.memoryType !== undefined ||
+            input.isEnabled !== undefined;
+        if (!hasAnyField) {
+            errors.push({ field: '_root', message: 'At least one field must be provided for update' });
+        }
+        if (input.content !== undefined) {
+            this.validateMemoryContent(input.content, errors);
+        }
+        if (input.memoryType !== undefined && !isMemoryType(input.memoryType)) {
+            errors.push({
+                field: 'memoryType',
+                message: 'Memory type must be one of: conversation, decision, learning',
+                value: input.memoryType,
+            });
+        }
+        if (input.isEnabled !== undefined && typeof input.isEnabled !== 'boolean') {
+            errors.push({
+                field: 'isEnabled',
+                message: 'isEnabled must be a boolean',
+                value: input.isEnabled,
+            });
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    validateCreateMetaGoalInput(input) {
+        const result = this.validateCreateMetaGoalInputSafe(input);
+        if (!result.valid) {
+            throw new ValidationError('Meta-goal validation failed', this.issuesToRecord(result.errors));
+        }
+    }
+    validateCreateMetaGoalInputSafe(input) {
+        const errors = [];
+        if (!input.description) {
+            errors.push({ field: 'description', message: 'Description is required' });
+        }
+        else {
+            this.validateMetaGoalDescription(input.description, errors);
+        }
+        if (input.priority !== undefined) {
+            this.validateMetaGoalPriority(input.priority, errors);
+        }
+        if (input.scope !== undefined) {
+            this.validateMetaGoalScope(input.scope, errors);
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    validateUpdateMetaGoalInput(input) {
+        const result = this.validateUpdateMetaGoalInputSafe(input);
+        if (!result.valid) {
+            throw new ValidationError('Meta-goal update validation failed', this.issuesToRecord(result.errors));
+        }
+    }
+    validateUpdateMetaGoalInputSafe(input) {
+        const errors = [];
+        const hasAnyField = input.description !== undefined ||
+            input.priority !== undefined ||
+            input.scope !== undefined ||
+            input.isActive !== undefined;
+        if (!hasAnyField) {
+            errors.push({ field: '_root', message: 'At least one field must be provided for update' });
+        }
+        if (input.description !== undefined) {
+            this.validateMetaGoalDescription(input.description, errors);
+        }
+        if (input.priority !== undefined) {
+            this.validateMetaGoalPriority(input.priority, errors);
+        }
+        if (input.scope !== undefined) {
+            this.validateMetaGoalScope(input.scope, errors);
+        }
+        if (input.isActive !== undefined && typeof input.isActive !== 'boolean') {
+            errors.push({
+                field: 'isActive',
+                message: 'isActive must be a boolean',
+                value: input.isActive,
+            });
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    validateGoalHash(hash) {
+        if (!isValidGoalHash(hash)) {
+            throw new ValidationError('Invalid goal hash', {
+                hash: ['Goal hash must be a non-empty string'],
+            });
+        }
+    }
+    validateName(name, errors) {
+        if (name.length < this.constraints.minNameLength) {
+            errors.push({
+                field: 'name',
+                message: `Name must be at least ${this.constraints.minNameLength} character(s)`,
+                value: name.length,
+            });
+        }
+        else if (name.length > this.constraints.maxNameLength) {
+            errors.push({
+                field: 'name',
+                message: `Name must be at most ${this.constraints.maxNameLength} characters`,
+                value: name.length,
+            });
+        }
+        else if (!this.constraints.namePattern.test(name)) {
+            errors.push({
+                field: 'name',
+                message: 'Name must start with alphanumeric and contain only alphanumeric characters, spaces, underscores, or hyphens',
+                value: name,
+            });
+        }
+    }
+    validateTitle(title, errors) {
+        if (title.length < this.constraints.minTitleLength) {
+            errors.push({
+                field: 'title',
+                message: `Title must be at least ${this.constraints.minTitleLength} character(s)`,
+                value: title.length,
+            });
+        }
+        else if (title.length > this.constraints.maxTitleLength) {
+            errors.push({
+                field: 'title',
+                message: `Title must be at most ${this.constraints.maxTitleLength} characters`,
+                value: title.length,
+            });
+        }
+    }
+    validateDescription(description, errors) {
+        if (typeof description !== 'string') {
+            errors.push({
+                field: 'description',
+                message: 'Description must be a string',
+                value: typeof description,
+            });
+        }
+        else if (description.length > this.constraints.maxDescriptionLength) {
+            errors.push({
+                field: 'description',
+                message: `Description must be at most ${this.constraints.maxDescriptionLength} characters`,
+                value: description.length,
+            });
+        }
+    }
+    validateMemoryContent(content, errors) {
+        if (typeof content !== 'string') {
+            errors.push({
+                field: 'content',
+                message: 'Content must be a string',
+                value: typeof content,
+            });
+        }
+        else if (content.length < this.constraints.minMemoryContentLength) {
+            errors.push({
+                field: 'content',
+                message: `Content must be at least ${this.constraints.minMemoryContentLength} character(s)`,
+                value: content.length,
+            });
+        }
+        else if (content.length > this.constraints.maxMemoryContentLength) {
+            errors.push({
+                field: 'content',
+                message: `Content must be at most ${this.constraints.maxMemoryContentLength} characters`,
+                value: content.length,
+            });
+        }
+    }
+    validateMetaGoalDescription(description, errors) {
+        if (typeof description !== 'string') {
+            errors.push({
+                field: 'description',
+                message: 'Description must be a string',
+                value: typeof description,
+            });
+        }
+        else if (description.length < this.constraints.minMetaGoalDescriptionLength) {
+            errors.push({
+                field: 'description',
+                message: `Description must be at least ${this.constraints.minMetaGoalDescriptionLength} character(s)`,
+                value: description.length,
+            });
+        }
+        else if (description.length > this.constraints.maxMetaGoalDescriptionLength) {
+            errors.push({
+                field: 'description',
+                message: `Description must be at most ${this.constraints.maxMetaGoalDescriptionLength} characters`,
+                value: description.length,
+            });
+        }
+    }
+    validateMetaGoalPriority(priority, errors) {
+        if (typeof priority !== 'number') {
+            errors.push({
+                field: 'priority',
+                message: 'Priority must be a number',
+                value: typeof priority,
+            });
+        }
+        else if (priority < this.constraints.minMetaGoalPriority) {
+            errors.push({
+                field: 'priority',
+                message: `Priority must be at least ${this.constraints.minMetaGoalPriority}`,
+                value: priority,
+            });
+        }
+        else if (priority > this.constraints.maxMetaGoalPriority) {
+            errors.push({
+                field: 'priority',
+                message: `Priority must be at most ${this.constraints.maxMetaGoalPriority}`,
+                value: priority,
+            });
+        }
+    }
+    validateMetaGoalScope(scope, errors) {
+        if (scope !== 'all' && !Array.isArray(scope)) {
+            errors.push({
+                field: 'scope',
+                message: 'Scope must be "all" or an array of goal hashes',
+                value: scope,
+            });
+        }
+        else if (Array.isArray(scope)) {
+            for (let i = 0; i < scope.length; i++) {
+                if (!isValidGoalHash(scope[i])) {
+                    errors.push({
+                        field: `scope[${i}]`,
+                        message: 'Invalid goal hash in scope',
+                        value: scope[i],
+                    });
+                }
+            }
+        }
+    }
+    validateDateString(dateStr, field, errors) {
+        if (typeof dateStr !== 'string') {
+            errors.push({
+                field,
+                message: `${field} must be a string`,
+                value: typeof dateStr,
+            });
+            return;
+        }
+        const date = new Date(dateStr);
+        if (isNaN(date.getTime())) {
+            errors.push({
+                field,
+                message: `${field} must be a valid date string (ISO 8601 format)`,
+                value: dateStr,
+            });
+        }
+    }
+    validateDependencies(deps, errors) {
+        if (!Array.isArray(deps)) {
+            errors.push({
+                field: 'dependsOn',
+                message: 'Dependencies must be an array of goal hashes',
+                value: deps,
+            });
+            return;
+        }
+        if (deps.length > this.constraints.maxDependencies) {
+            errors.push({
+                field: 'dependsOn',
+                message: `Cannot have more than ${this.constraints.maxDependencies} dependencies`,
+                value: deps.length,
+            });
+        }
+        for (let i = 0; i < deps.length; i++) {
+            if (!isValidGoalHash(deps[i])) {
+                errors.push({
+                    field: `dependsOn[${i}]`,
+                    message: 'Invalid goal hash in dependencies',
+                    value: deps[i],
+                });
+            }
+        }
+    }
+    issuesToRecord(issues) {
+        const record = {};
+        for (const issue of issues) {
+            if (!record[issue.field]) {
+                record[issue.field] = [];
+            }
+            record[issue.field].push(issue.message);
+        }
+        return record;
+    }
+}
+export function createGoalValidator(constraints = {}) {
+    return new GoalValidator(constraints);
+}
+export function validateCreateGoalInput(input) {
+    const validator = new GoalValidator();
+    validator.validateCreateGoalInput(input);
+}
+export function validateUpdateGoalInput(input) {
+    const validator = new GoalValidator();
+    validator.validateUpdateGoalInput(input);
+}
+export function validateCreateTaskInput(input) {
+    const validator = new GoalValidator();
+    validator.validateCreateTaskInput(input);
+}
+export function validateCreateMilestoneInput(input) {
+    const validator = new GoalValidator();
+    validator.validateCreateMilestoneInput(input);
+}
+export function validateCreateMemoryInput(input) {
+    const validator = new GoalValidator();
+    validator.validateCreateMemoryInput(input);
+}
+export function validateCreateMetaGoalInput(input) {
+    const validator = new GoalValidator();
+    validator.validateCreateMetaGoalInput(input);
+}
+export function validateGoalHash(hash) {
+    const validator = new GoalValidator();
+    validator.validateGoalHash(hash);
+}