@flowdot.ai/daemon 1.0.0

package/dist/goals/GoalCache.d.ts

@@ -0,0 +1,65 @@
+import { EventEmitter } from 'node:events';
+import type { Goal, GoalHash, Milestone, Task, GoalMemory, MetaGoal, Logger } from './types.js';
+export interface CacheStats {
+    readonly hits: number;
+    readonly misses: number;
+    readonly entries: number;
+    readonly hitRatio: number;
+    readonly evictions: number;
+    readonly expirations: number;
+}
+export interface GoalCacheOptions {
+    readonly ttlMs?: number;
+    readonly maxEntries?: number;
+    readonly logger?: Logger;
+}
+export interface GoalCacheEvents {
+    eviction: [type: CacheType, key: string];
+    expiration: [type: CacheType, key: string];
+    cleared: [type?: CacheType];
+}
+export type CacheType = 'goal' | 'milestone' | 'task' | 'memory' | 'metaGoal';
+export declare class GoalCache extends EventEmitter<GoalCacheEvents> {
+    private readonly ttlMs;
+    private readonly maxEntries;
+    private readonly logger;
+    private readonly goals;
+    private readonly goalLists;
+    private readonly milestones;
+    private readonly tasks;
+    private readonly memories;
+    private readonly metaGoals;
+    private readonly pendingTasks;
+    private stats;
+    constructor(options?: GoalCacheOptions);
+    getGoal(hash: GoalHash): Goal | null;
+    getGoalOrThrow(hash: GoalHash): Goal;
+    setGoal(goal: Goal): void;
+    getGoalList(key?: string): Goal[] | null;
+    setGoalList(goals: Goal[], key?: string): void;
+    invalidateGoal(hash: GoalHash): void;
+    invalidateAllGoals(): void;
+    getMilestones(goalHash: GoalHash): Milestone[] | null;
+    setMilestones(goalHash: GoalHash, milestones: Milestone[]): void;
+    invalidateMilestones(goalHash: GoalHash): void;
+    getTasks(goalHash: GoalHash): Task[] | null;
+    setTasks(goalHash: GoalHash, tasks: Task[]): void;
+    invalidateTasks(goalHash: GoalHash): void;
+    invalidateAllTasks(): void;
+    getMemories(goalHash: GoalHash): GoalMemory[] | null;
+    setMemories(goalHash: GoalHash, memories: GoalMemory[]): void;
+    invalidateMemories(goalHash: GoalHash): void;
+    getMetaGoals(key?: string): MetaGoal[] | null;
+    setMetaGoals(metaGoals: MetaGoal[], key?: string): void;
+    invalidateMetaGoals(): void;
+    clearAll(): void;
+    getStats(): CacheStats;
+    resetStats(): void;
+    getTotalEntries(): number;
+    pruneExpired(): number;
+    private getFromCache;
+    private setInCache;
+    private evictLRU;
+    private pruneExpiredFromMap;
+}
+export declare function createGoalCache(options?: GoalCacheOptions): GoalCache;

package/dist/goals/GoalCache.js

@@ -0,0 +1,243 @@
+import { EventEmitter } from 'node:events';
+import { CacheMissError } from './errors.js';
+const DEFAULT_TTL_MS = 5 * 60 * 1000;
+const DEFAULT_MAX_ENTRIES = 1000;
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+export class GoalCache extends EventEmitter {
+    ttlMs;
+    maxEntries;
+    logger;
+    goals;
+    goalLists;
+    milestones;
+    tasks;
+    memories;
+    metaGoals;
+    pendingTasks;
+    stats = {
+        hits: 0,
+        misses: 0,
+        evictions: 0,
+        expirations: 0,
+    };
+    constructor(options = {}) {
+        super();
+        this.ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+        this.maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+        this.logger = options.logger ?? noopLogger;
+        this.goals = new Map();
+        this.goalLists = new Map();
+        this.milestones = new Map();
+        this.tasks = new Map();
+        this.memories = new Map();
+        this.metaGoals = new Map();
+        this.pendingTasks = null;
+        this.logger.debug('GOAL_CACHE', 'Cache initialized', {
+            ttlMs: this.ttlMs,
+            maxEntries: this.maxEntries,
+        });
+    }
+    getGoal(hash) {
+        return this.getFromCache(this.goals, hash, 'goal');
+    }
+    getGoalOrThrow(hash) {
+        const goal = this.getGoal(hash);
+        if (!goal) {
+            throw new CacheMissError(`goal:${hash}`);
+        }
+        return goal;
+    }
+    setGoal(goal) {
+        this.setInCache(this.goals, goal.hash, goal, 'goal');
+        this.logger.debug('GOAL_CACHE', 'Cached goal', { hash: goal.hash, name: goal.name });
+    }
+    getGoalList(key = 'default') {
+        return this.getFromCache(this.goalLists, key, 'goal');
+    }
+    setGoalList(goals, key = 'default') {
+        this.setInCache(this.goalLists, key, goals, 'goal');
+        for (const goal of goals) {
+            this.setGoal(goal);
+        }
+        this.logger.debug('GOAL_CACHE', 'Cached goal list', { key, count: goals.length });
+    }
+    invalidateGoal(hash) {
+        this.goals.delete(hash);
+        this.goalLists.clear();
+        this.logger.debug('GOAL_CACHE', 'Invalidated goal', { hash });
+    }
+    invalidateAllGoals() {
+        this.goals.clear();
+        this.goalLists.clear();
+        this.logger.debug('GOAL_CACHE', 'Invalidated all goals');
+        this.emit('cleared', 'goal');
+    }
+    getMilestones(goalHash) {
+        return this.getFromCache(this.milestones, goalHash, 'milestone');
+    }
+    setMilestones(goalHash, milestones) {
+        this.setInCache(this.milestones, goalHash, milestones, 'milestone');
+        this.logger.debug('GOAL_CACHE', 'Cached milestones', { goalHash, count: milestones.length });
+    }
+    invalidateMilestones(goalHash) {
+        this.milestones.delete(goalHash);
+        this.logger.debug('GOAL_CACHE', 'Invalidated milestones', { goalHash });
+    }
+    getTasks(goalHash) {
+        return this.getFromCache(this.tasks, goalHash, 'task');
+    }
+    setTasks(goalHash, tasks) {
+        this.setInCache(this.tasks, goalHash, tasks, 'task');
+        this.logger.debug('GOAL_CACHE', 'Cached tasks', { goalHash, count: tasks.length });
+    }
+    invalidateTasks(goalHash) {
+        this.tasks.delete(goalHash);
+        this.logger.debug('GOAL_CACHE', 'Invalidated tasks', { goalHash });
+    }
+    invalidateAllTasks() {
+        this.tasks.clear();
+        this.logger.debug('GOAL_CACHE', 'Invalidated all tasks');
+        this.emit('cleared', 'task');
+    }
+    getMemories(goalHash) {
+        return this.getFromCache(this.memories, goalHash, 'memory');
+    }
+    setMemories(goalHash, memories) {
+        this.setInCache(this.memories, goalHash, memories, 'memory');
+        this.logger.debug('GOAL_CACHE', 'Cached memories', { goalHash, count: memories.length });
+    }
+    invalidateMemories(goalHash) {
+        this.memories.delete(goalHash);
+        this.logger.debug('GOAL_CACHE', 'Invalidated memories', { goalHash });
+    }
+    getMetaGoals(key = 'all') {
+        return this.getFromCache(this.metaGoals, key, 'metaGoal');
+    }
+    setMetaGoals(metaGoals, key = 'all') {
+        this.setInCache(this.metaGoals, key, metaGoals, 'metaGoal');
+        this.logger.debug('GOAL_CACHE', 'Cached meta-goals', { key, count: metaGoals.length });
+    }
+    invalidateMetaGoals() {
+        this.metaGoals.clear();
+        this.logger.debug('GOAL_CACHE', 'Invalidated meta-goals');
+        this.emit('cleared', 'metaGoal');
+    }
+    clearAll() {
+        this.goals.clear();
+        this.goalLists.clear();
+        this.milestones.clear();
+        this.tasks.clear();
+        this.memories.clear();
+        this.metaGoals.clear();
+        this.logger.info('GOAL_CACHE', 'Cleared all caches');
+        this.emit('cleared');
+    }
+    getStats() {
+        const totalRequests = this.stats.hits + this.stats.misses;
+        return {
+            hits: this.stats.hits,
+            misses: this.stats.misses,
+            entries: this.getTotalEntries(),
+            hitRatio: totalRequests > 0 ? this.stats.hits / totalRequests : 0,
+            evictions: this.stats.evictions,
+            expirations: this.stats.expirations,
+        };
+    }
+    resetStats() {
+        this.stats = {
+            hits: 0,
+            misses: 0,
+            evictions: 0,
+            expirations: 0,
+        };
+        this.logger.debug('GOAL_CACHE', 'Statistics reset');
+    }
+    getTotalEntries() {
+        return (this.goals.size +
+            this.goalLists.size +
+            this.milestones.size +
+            this.tasks.size +
+            this.memories.size +
+            this.metaGoals.size);
+    }
+    pruneExpired() {
+        const now = Date.now();
+        let pruned = 0;
+        pruned += this.pruneExpiredFromMap(this.goals, 'goal', now);
+        pruned += this.pruneExpiredFromMap(this.goalLists, 'goal', now);
+        pruned += this.pruneExpiredFromMap(this.milestones, 'milestone', now);
+        pruned += this.pruneExpiredFromMap(this.tasks, 'task', now);
+        pruned += this.pruneExpiredFromMap(this.memories, 'memory', now);
+        pruned += this.pruneExpiredFromMap(this.metaGoals, 'metaGoal', now);
+        if (pruned > 0) {
+            this.logger.debug('GOAL_CACHE', 'Pruned expired entries', { count: pruned });
+        }
+        return pruned;
+    }
+    getFromCache(cache, key, type) {
+        const entry = cache.get(key);
+        if (!entry) {
+            this.stats.misses++;
+            return null;
+        }
+        const now = Date.now();
+        if (entry.expiresAt < now) {
+            cache.delete(key);
+            this.stats.misses++;
+            this.stats.expirations++;
+            this.emit('expiration', type, key);
+            return null;
+        }
+        entry.lastAccessedAt = now;
+        this.stats.hits++;
+        return entry.value;
+    }
+    setInCache(cache, key, value, type) {
+        if (cache.size >= this.maxEntries) {
+            this.evictLRU(cache, type);
+        }
+        const now = Date.now();
+        cache.set(key, {
+            value,
+            expiresAt: now + this.ttlMs,
+            createdAt: now,
+            lastAccessedAt: now,
+        });
+    }
+    evictLRU(cache, type) {
+        let oldestKey = null;
+        let oldestTime = Infinity;
+        for (const [key, entry] of cache) {
+            if (entry.lastAccessedAt < oldestTime) {
+                oldestTime = entry.lastAccessedAt;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            cache.delete(oldestKey);
+            this.stats.evictions++;
+            this.emit('eviction', type, oldestKey);
+            this.logger.debug('GOAL_CACHE', 'Evicted LRU entry', { type, key: oldestKey });
+        }
+    }
+    pruneExpiredFromMap(cache, type, now) {
+        let pruned = 0;
+        for (const [key, entry] of cache) {
+            if (entry.expiresAt < now) {
+                cache.delete(key);
+                this.stats.expirations++;
+                this.emit('expiration', type, key);
+                pruned++;
+            }
+        }
+        return pruned;
+    }
+}
+export function createGoalCache(options = {}) {
+    return new GoalCache(options);
+}

package/dist/goals/GoalCommsHandler.d.ts

@@ -0,0 +1,150 @@
+import { EventEmitter } from 'node:events';
+import type { Goal, GoalHash, Task, TaskStatus, GoalStatus, Logger } from './types.js';
+import { GoalError } from './errors.js';
+export type GoalNotificationSubtype = 'tasks_generated' | 'milestone_reached' | 'review_due' | 'goal_completed' | 'goal_paused' | 'goal_resumed' | 'task_approved' | 'task_denied' | 'task_completed' | 'task_failed' | 'daily_summary';
+export type ApprovalResponse = 'approve' | 'deny' | 'skip' | 'later' | 'timeout';
+export type ViewAction = 'list' | 'show' | 'tasks' | 'progress' | 'summary';
+export interface GoalNotification {
+    readonly type: 'goal_notification';
+    readonly subtype: GoalNotificationSubtype;
+    readonly goalHash: GoalHash;
+    readonly goalName: string;
+    readonly message: string;
+    readonly details?: Record<string, unknown>;
+    readonly timestamp: Date;
+}
+export interface GoalApprovalRequest {
+    readonly type: 'goal_task_approval';
+    readonly requestId: string;
+    readonly goalHash: GoalHash;
+    readonly goalName: string;
+    readonly taskId: number;
+    readonly taskTitle: string;
+    readonly taskDescription: string | null;
+    readonly taskType: string;
+    readonly permissionRequired: string;
+    readonly options: ApprovalResponse[];
+    readonly expiresAt: Date;
+    readonly timestamp: Date;
+}
+export interface GoalViewRequest {
+    readonly type: 'goal_view';
+    readonly requestId: string;
+    readonly action: ViewAction;
+    readonly goalHash?: GoalHash;
+    readonly filters?: {
+        status?: GoalStatus;
+        taskStatus?: TaskStatus;
+    };
+    readonly userId: number;
+    readonly timestamp: Date;
+}
+export interface GoalViewResponse {
+    readonly type: 'goal_view_response';
+    readonly requestId: string;
+    readonly action: ViewAction;
+    readonly data: Goal | Goal[] | Task[] | ProgressSummary | null;
+    readonly message: string;
+    readonly success: boolean;
+    readonly error?: string;
+    readonly timestamp: Date;
+}
+export interface GoalModificationRedirect {
+    readonly type: 'goal_modification_redirect';
+    readonly requestedAction: string;
+    readonly cliCommand: string;
+    readonly message: string;
+    readonly timestamp: Date;
+}
+export interface ProgressSummary {
+    readonly goalHash: GoalHash;
+    readonly goalName: string;
+    readonly progress: number;
+    readonly status: GoalStatus;
+    readonly milestones: {
+        total: number;
+        completed: number;
+    };
+    readonly tasks: {
+        total: number;
+        completed: number;
+        pending: number;
+        failed: number;
+    };
+    readonly daysSinceActivity: number;
+    readonly deadline?: Date;
+    readonly daysUntilDeadline?: number;
+}
+export type CommsSendFunction = (payload: GoalNotification | GoalApprovalRequest | GoalViewResponse | GoalModificationRedirect) => Promise<void>;
+export type ApprovalResponseHandler = (requestId: string, response: ApprovalResponse, userId: number) => Promise<void>;
+export interface GoalCommsHandlerOptions {
+    readonly logger?: Logger;
+    readonly sendFunction?: CommsSendFunction;
+    readonly approvalExpiryMs?: number;
+    readonly includeDetails?: boolean;
+    readonly maxMessageLength?: number;
+}
+export interface GoalCommsHandlerEvents {
+    'notification-sent': [GoalNotification];
+    'approval-sent': [GoalApprovalRequest];
+    'approval-received': [{
+        requestId: string;
+        response: ApprovalResponse;
+        userId: number;
+    }];
+    'view-request': [GoalViewRequest];
+    'view-response-sent': [GoalViewResponse];
+    'modification-redirected': [GoalModificationRedirect];
+    'error': [Error];
+}
+export declare class GoalCommsError extends GoalError {
+    constructor(message: string, cause?: Error);
+}
+export declare class ApprovalTimeoutError extends GoalError {
+    readonly requestId: string;
+    readonly taskId: number;
+    constructor(requestId: string, taskId: number);
+}
+export declare class GoalCommsHandler extends EventEmitter<GoalCommsHandlerEvents> {
+    private readonly logger;
+    private readonly sendFunction?;
+    private readonly approvalExpiryMs;
+    private readonly includeDetails;
+    private readonly maxMessageLength;
+    private readonly pendingApprovals;
+    constructor(options?: GoalCommsHandlerOptions);
+    sendNotification(subtype: GoalNotificationSubtype, goal: Goal, message: string, details?: Record<string, unknown>): Promise<void>;
+    notifyTasksGenerated(goal: Goal, taskCount: number): Promise<void>;
+    notifyMilestoneReached(goal: Goal, milestoneTitle: string, completedCount: number, totalCount: number): Promise<void>;
+    notifyReviewDue(goal: Goal): Promise<void>;
+    notifyGoalCompleted(goal: Goal): Promise<void>;
+    notifyTaskCompleted(goal: Goal, task: Task): Promise<void>;
+    notifyTaskFailed(goal: Goal, task: Task, error: string): Promise<void>;
+    notifyDailySummary(goals: Goal[], completedTasks: number, pendingTasks: number): Promise<void>;
+    requestApproval(goal: Goal, task: Task, permissionRequired: string): Promise<ApprovalResponse>;
+    handleApprovalResponse(requestId: string, response: ApprovalResponse, userId: number): void;
+    cancelApprovalRequest(requestId: string): boolean;
+    getPendingApprovals(): GoalApprovalRequest[];
+    handleViewRequest(request: GoalViewRequest, dataProvider: {
+        getGoal: (hash: GoalHash) => Promise<Goal | null>;
+        listGoals: (filters?: {
+            status?: GoalStatus;
+        }) => Promise<Goal[]>;
+        listTasks: (goalHash: GoalHash, filters?: {
+            status?: TaskStatus;
+        }) => Promise<Task[]>;
+        getProgress: (hash: GoalHash) => Promise<ProgressSummary | null>;
+    }): Promise<GoalViewResponse>;
+    private createViewResponse;
+    isModificationAction(action: string): boolean;
+    createModificationRedirect(requestedAction: string, goalHash?: GoalHash): GoalModificationRedirect;
+    private getCliCommand;
+    formatGoalSummary(goal: Goal): string;
+    formatTaskSummary(task: Task): string;
+    formatProgressSummary(progress: ProgressSummary): string;
+    private send;
+    private generateRequestId;
+    private truncate;
+    dispose(): void;
+}
+export declare function createGoalCommsHandler(options?: GoalCommsHandlerOptions): GoalCommsHandler;