@flowdot.ai/daemon 1.0.0

package/dist/goals/MilestoneBreaker.d.ts

@@ -0,0 +1,74 @@
+import { EventEmitter } from 'node:events';
+import type { Goal, Milestone, CreateMilestoneInput, Logger } from './types.js';
+import { GoalError } from './errors.js';
+export type MilestoneLLMFunction = (prompt: string, options?: {
+    modelTier?: string;
+    maxTokens?: number;
+    temperature?: number;
+}) => Promise<string>;
+export interface MilestoneSuggestion {
+    readonly title: string;
+    readonly description: string;
+    readonly order: number;
+    readonly targetDate?: string;
+    readonly reasoning: string;
+    readonly effortPercent?: number;
+    readonly deliverables?: string[];
+    readonly dependsOn?: string[];
+}
+export interface MilestoneBreakdownResult {
+    readonly suggestions: MilestoneSuggestion[];
+    readonly strategySummary: string;
+    readonly warnings: string[];
+    readonly criticalPath?: string[];
+    readonly metadata: {
+        readonly generatedAt: string;
+        readonly modelTier: string;
+        readonly promptTokens?: number;
+        readonly responseTokens?: number;
+    };
+}
+export interface MilestoneBreakdownOptions {
+    readonly maxMilestones?: number;
+    readonly existingMilestones?: Milestone[];
+    readonly additionalContext?: string;
+    readonly modelTier?: string;
+    readonly includeReasoning?: boolean;
+    readonly hoursPerWeek?: number;
+}
+export interface MilestoneBreakerOptions {
+    readonly llmFunction: MilestoneLLMFunction;
+    readonly defaultModelTier?: string;
+    readonly defaultMaxMilestones?: number;
+    readonly logger?: Logger;
+}
+export interface MilestoneBreakerEvents {
+    breakdownStarted: [goalHash: string, options: MilestoneBreakdownOptions];
+    breakdownCompleted: [goalHash: string, result: MilestoneBreakdownResult];
+    breakdownFailed: [goalHash: string, error: Error];
+    milestoneSuggested: [goalHash: string, suggestion: MilestoneSuggestion];
+}
+export declare class MilestoneBreakdownError extends GoalError {
+    constructor(message: string, cause?: Error);
+}
+export declare class MilestoneBreaker extends EventEmitter<MilestoneBreakerEvents> {
+    private readonly llmFunction;
+    private readonly defaultModelTier;
+    private readonly defaultMaxMilestones;
+    private readonly logger;
+    constructor(options: MilestoneBreakerOptions);
+    breakdownGoal(goal: Goal, options?: MilestoneBreakdownOptions): Promise<MilestoneBreakdownResult>;
+    suggestAdditionalMilestones(goal: Goal, existingMilestones: Milestone[], count?: number): Promise<MilestoneSuggestion[]>;
+    analyzeOrder(goal: Goal, milestones: Milestone[]): Promise<{
+        suggestedOrder: number[];
+        reasoning: string;
+        dependencies: Map<number, number[]>;
+    }>;
+    suggestionToInput(suggestion: MilestoneSuggestion): CreateMilestoneInput;
+    private buildBreakdownPrompt;
+    private parseBreakdownResponse;
+    private validateSuggestion;
+    private cleanJsonResponse;
+    private parseRelativeDate;
+}
+export declare function createMilestoneBreaker(options: MilestoneBreakerOptions): MilestoneBreaker;

package/dist/goals/MilestoneBreaker.js

@@ -0,0 +1,348 @@
+import { EventEmitter } from 'node:events';
+import { GoalError } from './errors.js';
+const DEFAULT_MAX_MILESTONES = 7;
+const DEFAULT_MODEL_TIER = 'standard';
+const noopLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+export class MilestoneBreakdownError extends GoalError {
+    constructor(message, cause) {
+        super('MILESTONE_BREAKDOWN_ERROR', message, cause ? { cause } : {});
+    }
+}
+export class MilestoneBreaker extends EventEmitter {
+    llmFunction;
+    defaultModelTier;
+    defaultMaxMilestones;
+    logger;
+    constructor(options) {
+        super();
+        this.llmFunction = options.llmFunction;
+        this.defaultModelTier = options.defaultModelTier ?? DEFAULT_MODEL_TIER;
+        this.defaultMaxMilestones = options.defaultMaxMilestones ?? DEFAULT_MAX_MILESTONES;
+        this.logger = options.logger ?? noopLogger;
+    }
+    async breakdownGoal(goal, options = {}) {
+        const maxMilestones = options.maxMilestones ?? this.defaultMaxMilestones;
+        const modelTier = options.modelTier ?? this.defaultModelTier;
+        this.logger.info('MILESTONE_BREAKER', 'Breaking down goal', {
+            goalHash: goal.hash,
+            goalName: goal.name,
+            maxMilestones,
+        });
+        this.emit('breakdownStarted', goal.hash, options);
+        try {
+            const prompt = this.buildBreakdownPrompt(goal, options);
+            const response = await this.llmFunction(prompt, {
+                modelTier,
+                maxTokens: 3000,
+                temperature: 0.7,
+            });
+            const result = this.parseBreakdownResponse(response, goal, options);
+            for (const suggestion of result.suggestions) {
+                this.emit('milestoneSuggested', goal.hash, suggestion);
+            }
+            this.logger.info('MILESTONE_BREAKER', 'Breakdown completed', {
+                goalHash: goal.hash,
+                milestoneCount: result.suggestions.length,
+            });
+            this.emit('breakdownCompleted', goal.hash, result);
+            return result;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            this.logger.error('MILESTONE_BREAKER', 'Breakdown failed', {
+                goalHash: goal.hash,
+                error: error.message,
+            });
+            this.emit('breakdownFailed', goal.hash, error);
+            throw new MilestoneBreakdownError(`Failed to break down goal: ${error.message}`, error);
+        }
+    }
+    async suggestAdditionalMilestones(goal, existingMilestones, count = 2) {
+        const result = await this.breakdownGoal(goal, {
+            existingMilestones,
+            maxMilestones: count,
+            additionalContext: `
+The goal already has ${existingMilestones.length} milestones.
+Only suggest ${count} additional milestones that would help achieve the goal.
+Do not duplicate existing milestones.
+Focus on gaps or missing steps.
+`,
+        });
+        return result.suggestions;
+    }
+    async analyzeOrder(goal, milestones) {
+        const prompt = `Analyze the order of these milestones for the goal "${goal.name}".
+
+Goal: ${goal.name}
+Description: ${goal.description ?? 'No description'}
+
+Current Milestones (in order):
+${milestones.map((m, i) => `${i + 1}. ${m.title}: ${m.description ?? ''}`).join('\n')}
+
+Provide a JSON response with:
+{
+  "suggestedOrder": [array of milestone indices in optimal order, 1-based],
+  "reasoning": "explanation of why this order is better",
+  "dependencies": {
+    "milestone_index": [indices this depends on]
+  }
+}
+
+Consider:
+1. Logical progression (prerequisites before dependent tasks)
+2. Risk reduction (validate risky assumptions early)
+3. Value delivery (get feedback on valuable parts early)
+
+Respond ONLY with valid JSON.`;
+        const response = await this.llmFunction(prompt, {
+            modelTier: this.defaultModelTier,
+            maxTokens: 1000,
+            temperature: 0.5,
+        });
+        try {
+            const cleanResponse = this.cleanJsonResponse(response);
+            const parsed = JSON.parse(cleanResponse);
+            const dependencies = new Map();
+            if (parsed.dependencies && typeof parsed.dependencies === 'object') {
+                for (const [key, value] of Object.entries(parsed.dependencies)) {
+                    const idx = parseInt(key, 10);
+                    if (!isNaN(idx) && Array.isArray(value)) {
+                        dependencies.set(idx, value.filter((v) => typeof v === 'number'));
+                    }
+                }
+            }
+            return {
+                suggestedOrder: Array.isArray(parsed.suggestedOrder)
+                    ? parsed.suggestedOrder.filter((n) => typeof n === 'number')
+                    : milestones.map((_, i) => i + 1),
+                reasoning: typeof parsed.reasoning === 'string'
+                    ? parsed.reasoning
+                    : 'No reasoning provided',
+                dependencies,
+            };
+        }
+        catch {
+            return {
+                suggestedOrder: milestones.map((_, i) => i + 1),
+                reasoning: 'Could not analyze order',
+                dependencies: new Map(),
+            };
+        }
+    }
+    suggestionToInput(suggestion) {
+        return {
+            title: suggestion.title,
+            description: suggestion.description,
+            targetDate: suggestion.targetDate
+                ? this.parseRelativeDate(suggestion.targetDate)
+                : undefined,
+        };
+    }
+    buildBreakdownPrompt(goal, options) {
+        const maxMilestones = options.maxMilestones ?? this.defaultMaxMilestones;
+        let existingContext = '';
+        if (options.existingMilestones && options.existingMilestones.length > 0) {
+            existingContext = '\n## Existing Milestones\n';
+            for (const m of options.existingMilestones) {
+                const status = m.completedAt ? '✓ COMPLETED' : 'PENDING';
+                existingContext += `- [${status}] ${m.title}`;
+                if (m.description)
+                    existingContext += `: ${m.description}`;
+                existingContext += '\n';
+            }
+            existingContext +=
+                '\nDo not duplicate existing milestones. Build on completed work.\n';
+        }
+        let timeContext = '';
+        if (options.hoursPerWeek) {
+            timeContext = `\nUser has approximately ${options.hoursPerWeek} hours per week available for this goal.\n`;
+        }
+        return `You are a project planning assistant. Break down the following goal into milestones.
+
+# Goal
+Name: ${goal.name}
+Description: ${goal.description ?? 'No description provided'}
+Priority: ${goal.priority}
+Current Progress: ${goal.progress ?? 0}%
+Target Date: ${goal.deadline ?? 'No target date set'}
+${existingContext}${timeContext}
+${options.additionalContext ?? ''}
+
+# Instructions
+Generate up to ${maxMilestones} milestones that will help achieve this goal.
+
+## Output Format
+Respond with a JSON object containing:
+{
+  "strategySummary": "Brief overview of the milestone strategy",
+  "suggestions": [
+    {
+      "title": "Clear, concise milestone title",
+      "description": "What needs to be accomplished in this milestone",
+      "order": 1,
+      "targetDate": "relative like '2 weeks' or ISO date",
+      "reasoning": "Why this milestone is important",
+      "effortPercent": 15,
+      "deliverables": ["key deliverable 1", "key deliverable 2"],
+      "dependsOn": ["title of milestone this depends on"]
+    }
+  ],
+  "warnings": ["Any concerns or notes"],
+  "criticalPath": ["milestone titles that are on critical path"]
+}
+
+Guidelines for milestones:
+1. Each milestone should be a significant checkpoint
+2. Milestones should be measurable (clear completion criteria)
+3. Order milestones logically (dependencies first)
+4. Space out target dates reasonably
+5. Consider the goal's priority and target date
+6. First milestone should be achievable quickly (build momentum)
+7. Include validation/testing milestones if appropriate
+
+Respond ONLY with valid JSON, no markdown code blocks or other text.`;
+    }
+    parseBreakdownResponse(response, goal, options) {
+        try {
+            const cleanResponse = this.cleanJsonResponse(response);
+            const parsed = JSON.parse(cleanResponse);
+            const suggestions = [];
+            if (Array.isArray(parsed.suggestions)) {
+                for (let i = 0; i < parsed.suggestions.length; i++) {
+                    const suggestion = this.validateSuggestion(parsed.suggestions[i], i);
+                    if (suggestion) {
+                        suggestions.push(suggestion);
+                    }
+                }
+            }
+            return {
+                suggestions,
+                strategySummary: parsed.strategySummary ?? 'Milestone breakdown generated',
+                warnings: Array.isArray(parsed.warnings) ? parsed.warnings : [],
+                criticalPath: Array.isArray(parsed.criticalPath)
+                    ? parsed.criticalPath.filter((t) => typeof t === 'string')
+                    : undefined,
+                metadata: {
+                    generatedAt: new Date().toISOString(),
+                    modelTier: options.modelTier ?? this.defaultModelTier,
+                },
+            };
+        }
+        catch (err) {
+            this.logger.error('MILESTONE_BREAKER', 'Failed to parse response', {
+                response: response.substring(0, 500),
+                error: err instanceof Error ? err.message : String(err),
+            });
+            throw new MilestoneBreakdownError(`Failed to parse milestone breakdown response: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    validateSuggestion(raw, index) {
+        if (!raw || typeof raw !== 'object') {
+            return null;
+        }
+        const s = raw;
+        const title = typeof s.title === 'string' ? s.title.trim() : '';
+        if (!title) {
+            this.logger.warn('MILESTONE_BREAKER', 'Invalid suggestion - no title', {
+                index,
+            });
+            return null;
+        }
+        const description = typeof s.description === 'string' ? s.description.trim() : '';
+        const order = typeof s.order === 'number' ? Math.max(1, Math.round(s.order)) : index + 1;
+        return {
+            title,
+            description,
+            order,
+            targetDate: typeof s.targetDate === 'string' ? s.targetDate : undefined,
+            reasoning: typeof s.reasoning === 'string' ? s.reasoning : '',
+            effortPercent: typeof s.effortPercent === 'number'
+                ? Math.max(0, Math.min(100, s.effortPercent))
+                : undefined,
+            deliverables: Array.isArray(s.deliverables)
+                ? s.deliverables.filter((d) => typeof d === 'string')
+                : undefined,
+            dependsOn: Array.isArray(s.dependsOn)
+                ? s.dependsOn.filter((d) => typeof d === 'string')
+                : undefined,
+        };
+    }
+    cleanJsonResponse(response) {
+        let clean = response.trim();
+        if (clean.startsWith('```json')) {
+            clean = clean.slice(7);
+        }
+        else if (clean.startsWith('```')) {
+            clean = clean.slice(3);
+        }
+        if (clean.endsWith('```')) {
+            clean = clean.slice(0, -3);
+        }
+        return clean.trim();
+    }
+    parseRelativeDate(dateStr) {
+        if (/^\d{4}-\d{2}-\d{2}/.test(dateStr)) {
+            return dateStr;
+        }
+        const now = new Date();
+        const lower = dateStr.toLowerCase().trim();
+        const patterns = [
+            {
+                regex: /^(\d+)\s*days?$/,
+                fn: (m) => {
+                    const d = new Date(now);
+                    d.setDate(d.getDate() + parseInt(m[1], 10));
+                    return d;
+                },
+            },
+            {
+                regex: /^(\d+)\s*weeks?$/,
+                fn: (m) => {
+                    const d = new Date(now);
+                    d.setDate(d.getDate() + parseInt(m[1], 10) * 7);
+                    return d;
+                },
+            },
+            {
+                regex: /^(\d+)\s*months?$/,
+                fn: (m) => {
+                    const d = new Date(now);
+                    d.setMonth(d.getMonth() + parseInt(m[1], 10));
+                    return d;
+                },
+            },
+            {
+                regex: /^end\s*of\s*week$/,
+                fn: () => {
+                    const d = new Date(now);
+                    d.setDate(d.getDate() + (7 - d.getDay()));
+                    return d;
+                },
+            },
+            {
+                regex: /^end\s*of\s*month$/,
+                fn: () => {
+                    const d = new Date(now);
+                    d.setMonth(d.getMonth() + 1, 0);
+                    return d;
+                },
+            },
+        ];
+        for (const { regex, fn } of patterns) {
+            const match = lower.match(regex);
+            if (match) {
+                return fn(match).toISOString().split('T')[0];
+            }
+        }
+        this.logger.debug('MILESTONE_BREAKER', 'Could not parse date', { dateStr });
+        return undefined;
+    }
+}
+export function createMilestoneBreaker(options) {
+    return new MilestoneBreaker(options);
+}

package/dist/goals/PermissionBridge.d.ts

@@ -0,0 +1,109 @@
+import { EventEmitter } from 'node:events';
+import type { GoalHash, ApprovalMode, Logger } from './types.js';
+import { GoalError } from './errors.js';
+import type { PermissionCategory, PermissionCheckResult, ExecutionContext } from './TaskExecutor.js';
+export type PermissionDecision = 'allow' | 'deny' | 'ask';
+export interface PermissionRule {
+    readonly category: PermissionCategory;
+    readonly decision: PermissionDecision;
+    readonly pattern?: string;
+    readonly scope: 'session' | 'permanent';
+    readonly expiresAt?: Date;
+    readonly createdAt: Date;
+}
+export interface StoredPermission {
+    readonly category: PermissionCategory;
+    readonly pattern: string | null;
+    readonly decision: PermissionDecision;
+    readonly scope: 'session' | 'permanent';
+    readonly createdAt: string;
+    readonly expiresAt: string | null;
+}
+export interface PermissionCheckOptions {
+    readonly path?: string;
+    readonly command?: string;
+    readonly domain?: string;
+    readonly useCache?: boolean;
+}
+export interface PermissionAuditEntry {
+    readonly timestamp: Date;
+    readonly goalHash: GoalHash;
+    readonly taskId: number;
+    readonly category: PermissionCategory;
+    readonly decision: PermissionDecision;
+    readonly approvalRequested: boolean;
+    readonly approvalGranted?: boolean;
+    readonly target?: string;
+}
+export interface PermissionBridgeOptions {
+    readonly logger?: Logger;
+    readonly defaultApprovalMode?: ApprovalMode;
+    readonly cacheTtlMs?: number;
+    readonly maxCacheEntries?: number;
+    readonly enableAudit?: boolean;
+    readonly maxAuditEntries?: number;
+    readonly permissionsProvider?: () => Promise<StoredPermission[]>;
+}
+export interface PermissionBridgeEvents {
+    'permission-checked': [PermissionCheckResult, ExecutionContext];
+    'permission-granted': [PermissionCheckResult, ExecutionContext];
+    'permission-denied': [PermissionCheckResult, ExecutionContext];
+    'approval-required': [ExecutionContext];
+    'audit-logged': [PermissionAuditEntry];
+    'cache-hit': [{
+        category: PermissionCategory;
+        decision: PermissionDecision;
+    }];
+    'cache-miss': [{
+        category: PermissionCategory;
+    }];
+    'error': [Error];
+}
+export declare class PermissionBridgeError extends GoalError {
+    constructor(message: string, cause?: Error);
+}
+export declare class PermissionBridge extends EventEmitter<PermissionBridgeEvents> {
+    private readonly logger;
+    private readonly defaultApprovalMode;
+    private readonly cacheTtlMs;
+    private readonly maxCacheEntries;
+    private readonly enableAudit;
+    private readonly maxAuditEntries;
+    private readonly permissionsProvider?;
+    private readonly cache;
+    private readonly auditLog;
+    private readonly sessionPermissions;
+    constructor(options?: PermissionBridgeOptions);
+    checkPermission(category: PermissionCategory, context: ExecutionContext, options?: PermissionCheckOptions): Promise<PermissionCheckResult>;
+    recordDecision(category: PermissionCategory, decision: PermissionDecision, options?: PermissionCheckOptions & {
+        scope?: 'session' | 'permanent';
+    }): void;
+    logAudit(context: ExecutionContext, category: PermissionCategory, decision: PermissionDecision, approvalRequested: boolean, approvalGranted?: boolean, target?: string): void;
+    private checkGoalRestrictions;
+    private isDangerous;
+    private applyApprovalMode;
+    private checkCache;
+    private cacheDecision;
+    private getCacheKey;
+    clearCache(): void;
+    private checkStoredPermissions;
+    private checkSessionPermissions;
+    private matchesPattern;
+    private createResult;
+    private createResultFromCached;
+    getAuditLog(filters?: {
+        goalHash?: GoalHash;
+        taskId?: number;
+        category?: PermissionCategory;
+        since?: Date;
+        limit?: number;
+    }): PermissionAuditEntry[];
+    clearAuditLog(): void;
+    clearSessionPermissions(): void;
+    getCacheStats(): {
+        cacheSize: number;
+        sessionPermissions: number;
+        auditEntries: number;
+    };
+}
+export declare function createPermissionBridge(options?: PermissionBridgeOptions): PermissionBridge;