@flowdot.ai/daemon 1.0.0

package/dist/goals/errors.js

@@ -0,0 +1,299 @@
+export class GoalError extends Error {
+    code;
+    context;
+    timestamp;
+    constructor(code, message, context = {}) {
+        super(message);
+        this.name = 'GoalError';
+        this.code = code;
+        this.context = context;
+        this.timestamp = new Date();
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            context: this.context,
+            timestamp: this.timestamp.toISOString(),
+            stack: this.stack,
+        };
+    }
+    toLogString() {
+        const contextStr = Object.keys(this.context).length > 0
+            ? ` Context: ${JSON.stringify(this.context)}`
+            : '';
+        return `[${this.code}] ${this.message}${contextStr}`;
+    }
+}
+export class GoalNotFoundError extends GoalError {
+    constructor(identifier, identifierType = 'hash') {
+        super('GOAL_NOT_FOUND', `Goal not found: ${identifier}`, { identifier, identifierType });
+        this.name = 'GoalNotFoundError';
+    }
+}
+export class GoalAlreadyExistsError extends GoalError {
+    constructor(name) {
+        super('GOAL_ALREADY_EXISTS', `Goal already exists with name: ${name}`, { name });
+        this.name = 'GoalAlreadyExistsError';
+    }
+}
+export class GoalInvalidStatusError extends GoalError {
+    constructor(goalHash, currentStatus, operation, allowedStatuses) {
+        super('GOAL_INVALID_STATUS', `Cannot ${operation} goal in "${currentStatus}" status. Allowed: ${allowedStatuses.join(', ')}`, { goalHash, currentStatus, operation, allowedStatuses });
+        this.name = 'GoalInvalidStatusError';
+    }
+}
+export class GoalBlockedError extends GoalError {
+    constructor(goalHash, blockedBy) {
+        super('GOAL_BLOCKED', `Goal is blocked by incomplete dependencies: ${blockedBy.join(', ')}`, { goalHash, blockedBy });
+        this.name = 'GoalBlockedError';
+    }
+}
+export class GoalDependencyNotFoundError extends GoalError {
+    constructor(goalHash, dependencyHash) {
+        super('GOAL_DEPENDENCY_NOT_FOUND', `Dependency goal not found: ${dependencyHash}`, { goalHash, dependencyHash });
+        this.name = 'GoalDependencyNotFoundError';
+    }
+}
+export class GoalCircularDependencyError extends GoalError {
+    constructor(goalHash, cycle) {
+        super('GOAL_CIRCULAR_DEPENDENCY', `Circular dependency detected: ${cycle.join(' -> ')}`, { goalHash, cycle });
+        this.name = 'GoalCircularDependencyError';
+    }
+}
+export class MilestoneNotFoundError extends GoalError {
+    constructor(goalHash, milestoneId) {
+        super('MILESTONE_NOT_FOUND', `Milestone not found: ${milestoneId}`, { goalHash, milestoneId });
+        this.name = 'MilestoneNotFoundError';
+    }
+}
+export class MilestoneAlreadyCompleteError extends GoalError {
+    constructor(goalHash, milestoneId) {
+        super('MILESTONE_ALREADY_COMPLETE', `Milestone is already complete: ${milestoneId}`, { goalHash, milestoneId });
+        this.name = 'MilestoneAlreadyCompleteError';
+    }
+}
+export class TaskNotFoundError extends GoalError {
+    constructor(goalHash, taskId) {
+        super('TASK_NOT_FOUND', `Task not found: ${taskId}`, { goalHash, taskId });
+        this.name = 'TaskNotFoundError';
+    }
+}
+export class TaskInvalidStatusError extends GoalError {
+    constructor(taskId, currentStatus, operation, allowedStatuses) {
+        super('TASK_INVALID_STATUS', `Cannot ${operation} task in "${currentStatus}" status. Allowed: ${allowedStatuses.join(', ')}`, { taskId, currentStatus, operation, allowedStatuses });
+        this.name = 'TaskInvalidStatusError';
+    }
+}
+export class TaskExecutionError extends GoalError {
+    constructor(taskId, cause, originalError) {
+        super('TASK_EXECUTION_ERROR', `Task execution failed: ${cause}`, {
+            taskId,
+            cause,
+            originalError: originalError?.message,
+            originalStack: originalError?.stack,
+        });
+        this.name = 'TaskExecutionError';
+        if (originalError) {
+            this.cause = originalError;
+        }
+    }
+}
+export class TaskExecutionTimeoutError extends GoalError {
+    constructor(taskId, timeoutMs) {
+        super('TASK_EXECUTION_TIMEOUT', `Task execution timed out after ${formatDuration(timeoutMs)}`, { taskId, timeoutMs });
+        this.name = 'TaskExecutionTimeoutError';
+    }
+}
+export class TaskApprovalRequiredError extends GoalError {
+    constructor(taskId, permissionCategory) {
+        super('TASK_APPROVAL_REQUIRED', `Task requires approval before execution`, { taskId, permissionCategory });
+        this.name = 'TaskApprovalRequiredError';
+    }
+}
+export class TaskSanitizationFailedError extends GoalError {
+    constructor(taskId, reason) {
+        super('TASK_SANITIZATION_FAILED', `Task sanitization failed: ${reason}`, { taskId, reason });
+        this.name = 'TaskSanitizationFailedError';
+    }
+}
+export class MemoryNotFoundError extends GoalError {
+    constructor(goalHash, memoryId) {
+        super('MEMORY_NOT_FOUND', `Memory not found: ${memoryId}`, { goalHash, memoryId });
+        this.name = 'MemoryNotFoundError';
+    }
+}
+export class MemoryContentTooLongError extends GoalError {
+    constructor(contentLength, maxLength) {
+        super('MEMORY_CONTENT_TOO_LONG', `Memory content exceeds maximum length (${contentLength} > ${maxLength})`, { contentLength, maxLength });
+        this.name = 'MemoryContentTooLongError';
+    }
+}
+export class MetaGoalNotFoundError extends GoalError {
+    constructor(metaGoalId) {
+        super('META_GOAL_NOT_FOUND', `Meta-goal not found: ${metaGoalId}`, { metaGoalId });
+        this.name = 'MetaGoalNotFoundError';
+    }
+}
+export class MetaGoalConstraintViolatedError extends GoalError {
+    constructor(metaGoalId, description, violation) {
+        super('META_GOAL_CONSTRAINT_VIOLATED', `Meta-goal constraint violated: ${violation}`, { metaGoalId, description, violation });
+        this.name = 'MetaGoalConstraintViolatedError';
+    }
+}
+export class ApiRequestFailedError extends GoalError {
+    constructor(endpoint, method, statusCode, reason) {
+        super('API_REQUEST_FAILED', `API request failed: ${method} ${endpoint} - ${reason}`, { endpoint, method, statusCode, reason });
+        this.name = 'ApiRequestFailedError';
+    }
+}
+export class ApiAuthenticationFailedError extends GoalError {
+    constructor(reason) {
+        super('API_AUTHENTICATION_FAILED', `API authentication failed: ${reason}`, { reason });
+        this.name = 'ApiAuthenticationFailedError';
+    }
+}
+export class ApiRateLimitedError extends GoalError {
+    constructor(retryAfter) {
+        super('API_RATE_LIMITED', `API rate limit exceeded${retryAfter ? `. Retry after ${retryAfter}s` : ''}`, { retryAfter });
+        this.name = 'ApiRateLimitedError';
+    }
+}
+export class ApiResponseInvalidError extends GoalError {
+    constructor(endpoint, reason) {
+        super('API_RESPONSE_INVALID', `Invalid API response from ${endpoint}: ${reason}`, { endpoint, reason });
+        this.name = 'ApiResponseInvalidError';
+    }
+}
+export class ApiNetworkError extends GoalError {
+    constructor(endpoint, reason, originalError) {
+        super('API_NETWORK_ERROR', `Network error connecting to ${endpoint}: ${reason}`, {
+            endpoint,
+            reason,
+            originalError: originalError?.message,
+        });
+        this.name = 'ApiNetworkError';
+        if (originalError) {
+            this.cause = originalError;
+        }
+    }
+}
+export class ApiTimeoutError extends GoalError {
+    constructor(endpoint, timeoutMs) {
+        super('API_TIMEOUT', `API request to ${endpoint} timed out after ${formatDuration(timeoutMs)}`, { endpoint, timeoutMs });
+        this.name = 'ApiTimeoutError';
+    }
+}
+export class ValidationError extends GoalError {
+    errors;
+    constructor(fieldOrMessage, valueOrErrors, reason) {
+        if (reason !== undefined) {
+            super('VALIDATION_ERROR', `Validation failed for "${fieldOrMessage}": ${reason}`, { field: fieldOrMessage, value: valueOrErrors, reason });
+        }
+        else {
+            super('VALIDATION_ERROR', fieldOrMessage, { errors: valueOrErrors });
+            this.errors = valueOrErrors;
+        }
+        this.name = 'ValidationError';
+    }
+}
+export class InvalidInputError extends GoalError {
+    constructor(input, reason) {
+        super('INVALID_INPUT', `Invalid input "${input}": ${reason}`, { input, reason });
+        this.name = 'InvalidInputError';
+    }
+}
+export class InvalidGoalNameError extends GoalError {
+    constructor(name, reason) {
+        super('INVALID_GOAL_NAME', `Invalid goal name "${name}": ${reason}`, { name, reason });
+        this.name = 'InvalidGoalNameError';
+    }
+}
+export class InvalidTaskTypeError extends GoalError {
+    constructor(taskType) {
+        super('INVALID_TASK_TYPE', `Invalid task type: ${taskType}`, { taskType });
+        this.name = 'InvalidTaskTypeError';
+    }
+}
+export class CacheError extends GoalError {
+    constructor(message, context = {}) {
+        super('CACHE_ERROR', message, context);
+        this.name = 'CacheError';
+    }
+}
+export class CacheMissError extends GoalError {
+    constructor(key) {
+        super('CACHE_MISS', `Cache miss for key: ${key}`, { key });
+        this.name = 'CacheMissError';
+    }
+}
+export class CacheStaleError extends GoalError {
+    constructor(key, age, maxAge) {
+        super('CACHE_STALE', `Cache entry for "${key}" is stale (age: ${age}ms, max: ${maxAge}ms)`, { key, age, maxAge });
+        this.name = 'CacheStaleError';
+    }
+}
+export class ManagerNotInitializedError extends GoalError {
+    constructor() {
+        super('MANAGER_NOT_INITIALIZED', 'Goal manager has not been initialized', {});
+        this.name = 'ManagerNotInitializedError';
+    }
+}
+export class ManagerError extends GoalError {
+    constructor(message, context = {}) {
+        super('MANAGER_ERROR', message, context);
+        this.name = 'ManagerError';
+    }
+}
+function formatDuration(ms) {
+    if (ms < 1000) {
+        return `${ms}ms`;
+    }
+    if (ms < 60000) {
+        return `${Math.round(ms / 1000)}s`;
+    }
+    if (ms < 3600000) {
+        return `${Math.round(ms / 60000)}m`;
+    }
+    if (ms < 86400000) {
+        return `${Math.round(ms / 3600000)}h`;
+    }
+    return `${Math.round(ms / 86400000)}d`;
+}
+export function isGoalError(error) {
+    return error instanceof GoalError;
+}
+export function hasErrorCode(error, code) {
+    return isGoalError(error) && error.code === code;
+}
+export function wrapError(error, code, message) {
+    if (isGoalError(error)) {
+        return error;
+    }
+    const originalError = error instanceof Error ? error : new Error(String(error));
+    const goalError = new GoalError(code, message, {
+        originalError: originalError.message,
+        originalStack: originalError.stack,
+    });
+    goalError.cause = originalError;
+    return goalError;
+}
+export function isNotFoundError(error) {
+    return (hasErrorCode(error, 'GOAL_NOT_FOUND') ||
+        hasErrorCode(error, 'TASK_NOT_FOUND') ||
+        hasErrorCode(error, 'MILESTONE_NOT_FOUND') ||
+        hasErrorCode(error, 'MEMORY_NOT_FOUND') ||
+        hasErrorCode(error, 'META_GOAL_NOT_FOUND'));
+}
+export function isApiError(error) {
+    return (hasErrorCode(error, 'API_REQUEST_FAILED') ||
+        hasErrorCode(error, 'API_AUTHENTICATION_FAILED') ||
+        hasErrorCode(error, 'API_RATE_LIMITED') ||
+        hasErrorCode(error, 'API_RESPONSE_INVALID') ||
+        hasErrorCode(error, 'API_NETWORK_ERROR') ||
+        hasErrorCode(error, 'API_TIMEOUT'));
+}

package/dist/goals/index.d.ts

@@ -0,0 +1,24 @@
+export type { GoalHash, MilestoneId, TaskId, MemoryId, MetaGoalId, GoalStatus, GoalPriority, TaskType, TaskStatus, ApprovalMode, MemoryCategory, ConstraintType, Goal, Milestone, Task, GoalMemory, MetaGoal, MetaGoalConstraint, CreateGoalInput, UpdateGoalInput, CreateMilestoneInput, UpdateMilestoneInput, CreateTaskInput, UpdateTaskInput, CreateMemoryInput, UpdateMemoryInput, CreateMetaGoalInput, UpdateMetaGoalInput, TaskFeedbackInput, TaskFailInput, ListOptions, ListTasksOptions, Logger, } from './types.js';
+export { isValidGoalHash, isGoalStatus, isGoalPriority, isTaskType, isTaskStatus, isApprovalMode, isMemoryType, isMemorySource, isFeedbackQuality, isActionType, serializeGoal, deserializeGoal, deserializeMilestone, deserializeTask, deserializeMemory, deserializeGoalMemory, deserializeMetaGoal, deserializeGoalActionLog, type SerializedGoalActionLog, TASK_TYPES, canGoalTransitionTo, isTerminalGoalStatus, canTaskTransitionTo, isTerminalTaskStatus, } from './types.js';
+export { type GoalErrorCode, GoalError, GoalNotFoundError, GoalAlreadyExistsError, GoalInvalidStatusError, GoalBlockedError, GoalDependencyNotFoundError, GoalCircularDependencyError, MilestoneNotFoundError, MilestoneAlreadyCompleteError, TaskNotFoundError, TaskInvalidStatusError, TaskExecutionError, TaskExecutionTimeoutError, TaskApprovalRequiredError, TaskSanitizationFailedError, MemoryNotFoundError, MemoryContentTooLongError, MetaGoalNotFoundError, MetaGoalConstraintViolatedError, ApiRequestFailedError, ApiAuthenticationFailedError, ApiRateLimitedError, ApiResponseInvalidError, ApiNetworkError, ApiTimeoutError, ValidationError, InvalidInputError, InvalidGoalNameError, InvalidTaskTypeError, CacheError, CacheMissError, CacheStaleError, ManagerNotInitializedError, ManagerError, isGoalError, hasErrorCode, wrapError, isNotFoundError, isApiError, } from './errors.js';
+export { GoalApiClient, createGoalApiClient, type GoalApiClientOptions, type TokenProvider, type PaginatedResponse, type ApiListOptions, } from './GoalApiClient.js';
+export { GoalValidator, createGoalValidator, DEFAULT_GOAL_VALIDATION_CONSTRAINTS, type GoalValidationConstraints, } from './GoalValidator.js';
+export { GoalCache, createGoalCache, type GoalCacheOptions, type GoalCacheEvents, type CacheStats, type CacheType, } from './GoalCache.js';
+export { GoalManager, createGoalManager, type GoalManagerOptions, type GoalManagerEvents, } from './GoalManager.js';
+export { TaskGenerator, createTaskGenerator, type TaskGeneratorLLMFunction, type TaskGeneratorOptions, type TaskGeneratorEvents, type TaskSuggestion, type TaskGenerationOptions, type TaskGenerationResult, } from './TaskGenerator.js';
+export { TaskSanitizer, createTaskSanitizer, type TaskSanitizerOptions, type SanitizationResult, type PathValidationResult, type SecurityIssue, } from './TaskSanitizer.js';
+export { MilestoneBreaker, createMilestoneBreaker, type MilestoneLLMFunction, type MilestoneBreakerOptions, type MilestoneBreakerEvents, type MilestoneSuggestion, type MilestoneBreakdownOptions, type MilestoneBreakdownResult, } from './MilestoneBreaker.js';
+export { TaskQueue, createTaskQueue, type TaskQueueOptions, type TaskQueueEvents, type QueuedTask, type TaskFilterOptions, type TaskQueueStats, } from './TaskQueue.js';
+export { DependencyResolver, createDependencyResolver, getTransitiveDependencies, getTransitiveDependents, calculateCriticalPath, type DependencyResolverOptions, type DependencyNode, type GoalResolutionResult, type TaskDependencyNode, } from './DependencyResolver.js';
+export { MetaGoalEnforcer, createMetaGoalEnforcer, metaGoalAppliesToGoal, sortMetaGoalsByPriority, getBlockingMetaGoalsForType, summarizeConstraints, type MetaGoalLLMFunction, type MetaGoalEnforcerOptions, type MetaGoalEnforcerEvents, type ConstraintViolation, type EnforcementResult, type ParsedConstraint, type ConstraintType as MetaGoalConstraintType, type ConstraintTarget, } from './MetaGoalEnforcer.js';
+export { GoalCommsHandler, createGoalCommsHandler, type GoalCommsHandlerOptions, type GoalCommsHandlerEvents, type GoalNotificationSubtype, type ApprovalResponse, type ViewAction, type GoalNotification, type GoalApprovalRequest, type GoalViewRequest, type GoalViewResponse, type GoalModificationRedirect, type ProgressSummary, type CommsSendFunction, type ApprovalResponseHandler, } from './GoalCommsHandler.js';
+export { TaskExecutor, createTaskExecutor, type TaskExecutorOptions, type TaskExecutorEvents, type PermissionCategory, type ExecutionContext, type TaskExecutionHandler, type ExecutionResult, type ApprovalRequestFunction, type ApprovalResult, } from './TaskExecutor.js';
+export { PermissionBridge, createPermissionBridge, type PermissionBridgeOptions, type PermissionBridgeEvents, type PermissionDecision, type PermissionCheckOptions, type PermissionAuditEntry, type StoredPermission, type PermissionRule, } from './PermissionBridge.js';
+export { ErrorRecovery, createErrorRecovery, type ErrorRecoveryOptions, type ErrorRecoveryEvents, type RecoveryStrategy, type ErrorCategory, type Checkpoint, type CheckpointState, type RecoveryAction, type RecoveryResult, type ErrorAnalysis, } from './ErrorRecovery.js';
+export { ProgressTracker, createProgressTracker, type ProgressTrackerOptions, type ProgressTrackerEvents, type GoalProgress, type MilestoneProgress, type TaskStats, type VelocityMetrics, type ProgressSnapshot, type TaskCompletionRecord, } from './ProgressTracker.js';
+export { GoalReporter, createGoalReporter, type GoalReporterOptions, type GoalReporterEvents, type ReportFormat, type ReportDetailLevel, type ReportSection, type ProgressReport, type ReportPeriod, type ReportSectionContent, type ReportMetadata, type ReportOptions, type ActionItem, type RiskAssessment, } from './GoalReporter.js';
+export { ReviewScheduler, createReviewScheduler, type ReviewSchedulerOptions, type ReviewSchedulerEvents, type ReviewFrequency, type ReviewType, type ScheduledReview, type ReviewScheduleConfig, type ReviewTrigger, type ReviewResult, } from './ReviewScheduler.js';
+export { TaskFeedback, createTaskFeedback, type TaskFeedbackOptions, type TaskFeedbackEvents, type FeedbackRating, type FeedbackCategory, type FeedbackSentiment, type TaskFeedbackEntry, type FeedbackStatistics, type IssuePattern, type FeedbackTrend, type FeedbackQueryOptions, type FeedbackInput, type ImprovementSuggestion, } from './TaskFeedback.js';
+export { GoalExporter, createGoalExporter, EXPORT_FORMAT_VERSION, type GoalExporterOptions, type GoalExporterEvents, type ExportType, type ExportScope, type ExportOptions, type ExportedGoal, type ExportedMilestone, type ExportedTask, type ExportedMemory, type ExportedMetaGoal, type ExportManifest, type ExportPackage, type ExportResult, type ExportDataProvider, } from './GoalExporter.js';
+export { GoalImporter, createGoalImporter, type GoalImporterOptions, type GoalImporterEvents, type ImportMode, type ConflictResolution, type ImportOptions, type ImportConflict, type ImportValidation, type ImportMapping, type ImportResult, type ImportDataWriter, } from './GoalImporter.js';
+export { GoalScheduler, createGoalScheduler, type GoalSchedulerOptions, type GoalSchedulerEvents, type ScheduledGoal, type GetDueGoalsFunction, type MarkGoalStartedFunction, type MarkGoalCompletedFunction, type ExecuteGoalFunction, } from './GoalScheduler.js';

package/dist/goals/index.js

@@ -0,0 +1,23 @@
+export { isValidGoalHash, isGoalStatus, isGoalPriority, isTaskType, isTaskStatus, isApprovalMode, isMemoryType, isMemorySource, isFeedbackQuality, isActionType, serializeGoal, deserializeGoal, deserializeMilestone, deserializeTask, deserializeMemory, deserializeGoalMemory, deserializeMetaGoal, deserializeGoalActionLog, TASK_TYPES, canGoalTransitionTo, isTerminalGoalStatus, canTaskTransitionTo, isTerminalTaskStatus, } from './types.js';
+export { GoalError, GoalNotFoundError, GoalAlreadyExistsError, GoalInvalidStatusError, GoalBlockedError, GoalDependencyNotFoundError, GoalCircularDependencyError, MilestoneNotFoundError, MilestoneAlreadyCompleteError, TaskNotFoundError, TaskInvalidStatusError, TaskExecutionError, TaskExecutionTimeoutError, TaskApprovalRequiredError, TaskSanitizationFailedError, MemoryNotFoundError, MemoryContentTooLongError, MetaGoalNotFoundError, MetaGoalConstraintViolatedError, ApiRequestFailedError, ApiAuthenticationFailedError, ApiRateLimitedError, ApiResponseInvalidError, ApiNetworkError, ApiTimeoutError, ValidationError, InvalidInputError, InvalidGoalNameError, InvalidTaskTypeError, CacheError, CacheMissError, CacheStaleError, ManagerNotInitializedError, ManagerError, isGoalError, hasErrorCode, wrapError, isNotFoundError, isApiError, } from './errors.js';
+export { GoalApiClient, createGoalApiClient, } from './GoalApiClient.js';
+export { GoalValidator, createGoalValidator, DEFAULT_GOAL_VALIDATION_CONSTRAINTS, } from './GoalValidator.js';
+export { GoalCache, createGoalCache, } from './GoalCache.js';
+export { GoalManager, createGoalManager, } from './GoalManager.js';
+export { TaskGenerator, createTaskGenerator, } from './TaskGenerator.js';
+export { TaskSanitizer, createTaskSanitizer, } from './TaskSanitizer.js';
+export { MilestoneBreaker, createMilestoneBreaker, } from './MilestoneBreaker.js';
+export { TaskQueue, createTaskQueue, } from './TaskQueue.js';
+export { DependencyResolver, createDependencyResolver, getTransitiveDependencies, getTransitiveDependents, calculateCriticalPath, } from './DependencyResolver.js';
+export { MetaGoalEnforcer, createMetaGoalEnforcer, metaGoalAppliesToGoal, sortMetaGoalsByPriority, getBlockingMetaGoalsForType, summarizeConstraints, } from './MetaGoalEnforcer.js';
+export { GoalCommsHandler, createGoalCommsHandler, } from './GoalCommsHandler.js';
+export { TaskExecutor, createTaskExecutor, } from './TaskExecutor.js';
+export { PermissionBridge, createPermissionBridge, } from './PermissionBridge.js';
+export { ErrorRecovery, createErrorRecovery, } from './ErrorRecovery.js';
+export { ProgressTracker, createProgressTracker, } from './ProgressTracker.js';
+export { GoalReporter, createGoalReporter, } from './GoalReporter.js';
+export { ReviewScheduler, createReviewScheduler, } from './ReviewScheduler.js';
+export { TaskFeedback, createTaskFeedback, } from './TaskFeedback.js';
+export { GoalExporter, createGoalExporter, EXPORT_FORMAT_VERSION, } from './GoalExporter.js';
+export { GoalImporter, createGoalImporter, } from './GoalImporter.js';
+export { GoalScheduler, createGoalScheduler, } from './GoalScheduler.js';