gthinking 1.3.0 → 2.1.1

package/dist/planning.js

@@ -1,886 +0,0 @@
-"use strict";
-/**
- * Planning Module
- * Task decomposition, prioritization, resource allocation, and progress tracking
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.planningEngine = exports.PlanningEngine = void 0;
-const types_1 = require("./types");
-const events_1 = require("events");
-class TaskDecompositionEngine {
-    constructor() {
-        this.decompositionRules = [
-            {
-                pattern: /build|create|develop|implement/i,
-                subtasks: [
-                    'Research and requirements gathering',
-                    'Design and architecture',
-                    'Implementation',
-                    'Testing and validation',
-                    'Deployment'
-                ],
-                dependencies: [[], ['0'], ['1'], ['2'], ['3']]
-            },
-            {
-                pattern: /analyze|research|investigate/i,
-                subtasks: [
-                    'Define scope and objectives',
-                    'Gather existing data',
-                    'Conduct analysis',
-                    'Document findings',
-                    'Present recommendations'
-                ],
-                dependencies: [[], ['0'], ['1'], ['2'], ['3']]
-            },
-            {
-                pattern: /optimize|improve|enhance/i,
-                subtasks: [
-                    'Current state assessment',
-                    'Identify improvement areas',
-                    'Design improvements',
-                    'Implement changes',
-                    'Measure results'
-                ],
-                dependencies: [[], ['0'], ['1'], ['2'], ['3']]
-            }
-        ];
-    }
-    decompose(goal) {
-        // Find matching decomposition rule
-        for (const rule of this.decompositionRules) {
-            if (rule.pattern.test(goal)) {
-                return {
-                    subtasks: rule.subtasks,
-                    dependencies: rule.dependencies
-                };
-            }
-        }
-        // Default decomposition
-        return {
-            subtasks: [
-                'Understand requirements',
-                'Plan approach',
-                'Execute plan',
-                'Review and validate'
-            ],
-            dependencies: [[], ['0'], ['1'], ['2']]
-        };
-    }
-    estimateComplexity(task) {
-        // Estimate complexity based on keywords
-        const complexityIndicators = [
-            { keywords: ['complex', 'difficult', 'challenging', 'advanced'], weight: 0.9 },
-            { keywords: ['simple', 'easy', 'basic', 'straightforward'], weight: 0.3 },
-            { keywords: ['research', 'analysis', 'investigation'], weight: 0.7 },
-            { keywords: ['implement', 'build', 'develop'], weight: 0.8 }
-        ];
-        const taskLower = task.toLowerCase();
-        let complexity = 0.5; // Default
-        complexityIndicators.forEach(indicator => {
-            if (indicator.keywords.some(kw => taskLower.includes(kw))) {
-                complexity = indicator.weight;
-            }
-        });
-        // Adjust based on task length (longer tasks tend to be more complex)
-        const wordCount = task.split(/\s+/).length;
-        complexity += Math.min(0.2, wordCount * 0.01);
-        return Math.min(1, complexity);
-    }
-    estimateDuration(task, complexity) {
-        // Duration in minutes
-        const baseDuration = 30;
-        const complexityMultiplier = 1 + complexity * 4; // 1x to 5x
-        return Math.round(baseDuration * complexityMultiplier);
-    }
-}
-class PrioritizationEngine {
-    constructor() {
-        this.weights = {
-            urgency: 0.25,
-            importance: 0.3,
-            effort: 0.2,
-            risk: 0.15,
-            dependencies: 0.1
-        };
-    }
-    prioritize(tasks) {
-        const scoredTasks = tasks.map(task => ({
-            task,
-            score: this.calculatePriorityScore(task)
-        }));
-        return scoredTasks
-            .sort((a, b) => b.score - a.score)
-            .map(({ task }) => task);
-    }
-    calculatePriorityScore(task) {
-        const criteria = this.assessCriteria(task);
-        // Calculate weighted score
-        let score = 0;
-        score += criteria.urgency * this.weights.urgency;
-        score += criteria.importance * this.weights.importance;
-        score += (1 - criteria.effort) * this.weights.effort; // Lower effort = higher priority
-        score += (1 - criteria.risk) * this.weights.risk; // Lower risk = higher priority
-        score += (1 - criteria.dependencies) * this.weights.dependencies; // Fewer deps = higher priority
-        return score;
-    }
-    assessCriteria(task) {
-        return {
-            urgency: this.assessUrgency(task),
-            importance: this.assessImportance(task),
-            effort: this.assessEffort(task),
-            risk: this.assessRisk(task),
-            dependencies: this.assessDependencies(task)
-        };
-    }
-    assessUrgency(task) {
-        const urgencyKeywords = ['urgent', 'asap', 'immediate', 'critical', 'deadline'];
-        const taskText = `${task.title} ${task.description}`.toLowerCase();
-        if (task.priority === types_1.Priority.CRITICAL)
-            return 1;
-        if (task.priority === types_1.Priority.HIGH)
-            return 0.8;
-        const matches = urgencyKeywords.filter(kw => taskText.includes(kw)).length;
-        return Math.min(1, matches * 0.3 + (task.priority === types_1.Priority.MEDIUM ? 0.3 : task.priority === types_1.Priority.LOW ? 0.2 : 0.1));
-    }
-    assessImportance(task) {
-        const importanceKeywords = ['essential', 'crucial', 'key', 'important', 'core'];
-        const taskText = `${task.title} ${task.description}`.toLowerCase();
-        if (task.tags.includes('critical'))
-            return 1;
-        const matches = importanceKeywords.filter(kw => taskText.includes(kw)).length;
-        return Math.min(1, matches * 0.25 + 0.3);
-    }
-    assessEffort(task) {
-        // Normalize estimated duration (assuming max 8 hours)
-        return Math.min(1, task.estimatedDuration / 480);
-    }
-    assessRisk(task) {
-        const riskKeywords = ['risk', 'uncertain', 'unknown', 'complex', 'difficult'];
-        const taskText = `${task.title} ${task.description}`.toLowerCase();
-        const matches = riskKeywords.filter(kw => taskText.includes(kw)).length;
-        return Math.min(1, matches * 0.3);
-    }
-    assessDependencies(task) {
-        return Math.min(1, task.dependencies.length / 5);
-    }
-    /**
-     * Calculate critical path
-     */
-    calculateCriticalPath(tasks) {
-        const taskMap = new Map(tasks.map(t => [t.id, t]));
-        const visited = new Set();
-        const path = [];
-        const visit = (taskId, currentPath = []) => {
-            if (visited.has(taskId))
-                return 0;
-            if (currentPath.includes(taskId))
-                return 0; // Cycle detected
-            const task = taskMap.get(taskId);
-            if (!task)
-                return 0;
-            let maxPathDuration = task.estimatedDuration;
-            for (const depId of task.dependencies) {
-                const depDuration = visit(depId, [...currentPath, taskId]);
-                maxPathDuration = Math.max(maxPathDuration, task.estimatedDuration + depDuration);
-            }
-            visited.add(taskId);
-            path.push(taskId);
-            return maxPathDuration;
-        };
-        // Find the longest path
-        let maxDuration = 0;
-        let criticalPath = [];
-        for (const task of tasks) {
-            visited.clear();
-            path.length = 0;
-            const duration = visit(task.id);
-            if (duration > maxDuration) {
-                maxDuration = duration;
-                criticalPath = [...path];
-            }
-        }
-        return criticalPath;
-    }
-}
-// ============================================================================
-// RESOURCE ALLOCATOR
-// ============================================================================
-class ResourceAllocator {
-    constructor() {
-        this.resources = new Map();
-    }
-    addResource(resource) {
-        this.resources.set(resource.id, resource);
-    }
-    allocate(tasks) {
-        const allocation = new Map();
-        const resourceAvailability = new Map();
-        // Initialize availability
-        this.resources.forEach((resource, id) => {
-            resourceAvailability.set(id, resource.availability);
-        });
-        // Allocate resources to tasks
-        for (const task of tasks) {
-            const suitableResources = this.findSuitableResources(task);
-            const allocated = [];
-            for (const resource of suitableResources) {
-                const available = resourceAvailability.get(resource.id) || 0;
-                if (available > 0) {
-                    allocated.push(resource.id);
-                    resourceAvailability.set(resource.id, available - 1);
-                }
-            }
-            allocation.set(task.id, allocated);
-        }
-        return allocation;
-    }
-    findSuitableResources(task) {
-        return Array.from(this.resources.values())
-            .filter(resource => {
-            // Check if resource skills match task requirements
-            if (task.tags.length > 0 && resource.skills) {
-                return task.tags.some(tag => resource.skills.some(skill => skill.toLowerCase().includes(tag.toLowerCase()) ||
-                    tag.toLowerCase().includes(skill.toLowerCase())));
-            }
-            return true;
-        })
-            .sort((a, b) => b.availability - a.availability);
-    }
-    checkOverallocation() {
-        const overallocations = [];
-        this.resources.forEach((resource, id) => {
-            if (resource.availability < 0) {
-                overallocations.push({
-                    resourceId: id,
-                    overallocation: Math.abs(resource.availability)
-                });
-            }
-        });
-        return overallocations;
-    }
-    getResourceUtilization() {
-        const utilization = new Map();
-        this.resources.forEach((resource, id) => {
-            // Calculate utilization (simplified)
-            utilization.set(id, 1 - resource.availability);
-        });
-        return utilization;
-    }
-}
-// ============================================================================
-// PROGRESS TRACKER
-// ============================================================================
-class ProgressTracker {
-    constructor() {
-        this.taskHistory = new Map();
-    }
-    recordProgress(taskId, status, progress) {
-        if (!this.taskHistory.has(taskId)) {
-            this.taskHistory.set(taskId, []);
-        }
-        this.taskHistory.get(taskId).push({
-            timestamp: new Date(),
-            status,
-            progress: Math.min(100, Math.max(0, progress))
-        });
-    }
-    getProgress(taskId) {
-        const history = this.taskHistory.get(taskId);
-        if (!history || history.length === 0)
-            return 0;
-        return history[history.length - 1].progress;
-    }
-    calculateVelocity(taskId) {
-        const history = this.taskHistory.get(taskId);
-        if (!history || history.length < 2)
-            return 0;
-        const first = history[0];
-        const last = history[history.length - 1];
-        const timeDiff = last.timestamp.getTime() - first.timestamp.getTime();
-        const progressDiff = last.progress - first.progress;
-        return timeDiff > 0 ? (progressDiff / timeDiff) * 3600000 : 0; // Progress per hour
-    }
-    predictCompletion(taskId, totalWork) {
-        const velocity = this.calculateVelocity(taskId);
-        const currentProgress = this.getProgress(taskId);
-        if (velocity <= 0 || currentProgress >= 100)
-            return null;
-        const remainingWork = totalWork * (1 - currentProgress / 100);
-        const hoursRemaining = remainingWork / velocity;
-        return new Date(Date.now() + hoursRemaining * 3600000);
-    }
-    getProgressTrend(taskId) {
-        const history = this.taskHistory.get(taskId);
-        if (!history || history.length < 3)
-            return 'stable';
-        const recent = history.slice(-3);
-        const velocities = [];
-        for (let i = 1; i < recent.length; i++) {
-            const timeDiff = recent[i].timestamp.getTime() - recent[i - 1].timestamp.getTime();
-            const progressDiff = recent[i].progress - recent[i - 1].progress;
-            velocities.push(timeDiff > 0 ? progressDiff / timeDiff : 0);
-        }
-        const avgVelocity = velocities.reduce((a, b) => a + b, 0) / velocities.length;
-        const firstVelocity = velocities[0];
-        if (avgVelocity > firstVelocity * 1.2)
-            return 'improving';
-        if (avgVelocity < firstVelocity * 0.8)
-            return 'declining';
-        return 'stable';
-    }
-}
-// ============================================================================
-// RISK ANALYZER
-// ============================================================================
-class RiskAnalyzer {
-    constructor() {
-        this.knownRisks = new Map();
-    }
-    analyzeRisks(tasks, resources) {
-        const risks = [];
-        // Analyze task-related risks
-        tasks.forEach(task => {
-            const taskRisks = this.identifyTaskRisks(task);
-            risks.push(...taskRisks);
-        });
-        // Analyze resource-related risks
-        const resourceRisks = this.identifyResourceRisks(tasks, resources);
-        risks.push(...resourceRisks);
-        // Analyze schedule-related risks
-        const scheduleRisks = this.identifyScheduleRisks(tasks);
-        risks.push(...scheduleRisks);
-        // Sort by risk score (probability * impact)
-        return risks
-            .map(risk => ({ ...risk, riskScore: risk.probability * risk.impact }))
-            .sort((a, b) => b.riskScore - a.riskScore);
-    }
-    identifyTaskRisks(task) {
-        const risks = [];
-        // Complexity risk
-        if (task.estimatedDuration > 240) { // > 4 hours
-            risks.push({
-                id: `risk_complexity_${task.id}`,
-                description: `Task "${task.title}" is complex and may take longer than estimated`,
-                probability: 0.6,
-                impact: 0.7,
-                mitigation: 'Break down into smaller subtasks',
-                status: 'identified'
-            });
-        }
-        // Dependency risk
-        if (task.dependencies.length > 3) {
-            risks.push({
-                id: `risk_deps_${task.id}`,
-                description: `Task "${task.title}" has many dependencies`,
-                probability: 0.5,
-                impact: 0.6,
-                mitigation: 'Monitor dependencies closely and have backup plans',
-                status: 'identified'
-            });
-        }
-        // Uncertainty risk
-        const uncertaintyKeywords = ['unclear', 'unknown', 'uncertain', 'tbd', 'tba'];
-        const taskText = `${task.title} ${task.description}`.toLowerCase();
-        if (uncertaintyKeywords.some(kw => taskText.includes(kw))) {
-            risks.push({
-                id: `risk_uncertainty_${task.id}`,
-                description: `Task "${task.title}" has unclear requirements`,
-                probability: 0.7,
-                impact: 0.5,
-                mitigation: 'Clarify requirements before starting',
-                status: 'identified'
-            });
-        }
-        return risks;
-    }
-    identifyResourceRisks(tasks, resources) {
-        const risks = [];
-        // Resource availability risk
-        const totalAvailability = resources.reduce((sum, r) => sum + r.availability, 0);
-        const totalWork = tasks.reduce((sum, t) => sum + t.estimatedDuration, 0);
-        if (totalWork > totalAvailability * 480) { // Assuming 8 hours per availability unit
-            risks.push({
-                id: 'risk_resource_availability',
-                description: 'Insufficient resources for planned work',
-                probability: 0.8,
-                impact: 0.9,
-                mitigation: 'Add more resources or extend timeline',
-                status: 'identified'
-            });
-        }
-        return risks;
-    }
-    identifyScheduleRisks(tasks) {
-        const risks = [];
-        // Check for tight schedules
-        const criticalTasks = tasks.filter(t => t.priority === types_1.Priority.CRITICAL);
-        if (criticalTasks.length > tasks.length * 0.3) {
-            risks.push({
-                id: 'risk_tight_schedule',
-                description: 'Too many critical tasks may lead to schedule slip',
-                probability: 0.6,
-                impact: 0.7,
-                mitigation: 'Re-prioritize and stagger critical tasks',
-                status: 'identified'
-            });
-        }
-        return risks;
-    }
-    updateRiskStatus(riskId, status) {
-        const risk = this.knownRisks.get(riskId);
-        if (risk) {
-            risk.status = status;
-        }
-    }
-}
-// ============================================================================
-// MAIN PLANNING ENGINE
-// ============================================================================
-class PlanningEngine extends events_1.EventEmitter {
-    constructor() {
-        super();
-        this.plans = new Map();
-        this.decompositionEngine = new TaskDecompositionEngine();
-        this.prioritizationEngine = new PrioritizationEngine();
-        this.resourceAllocator = new ResourceAllocator();
-        this.progressTracker = new ProgressTracker();
-        this.riskAnalyzer = new RiskAnalyzer();
-    }
-    /**
-     * Dynamically determine the required thinking stages based on the query
-     */
-    determineThinkingStages(query) {
-        const stages = [];
-        const lowerQuery = query.toLowerCase();
-        // Always include Analysis and Synthesis
-        stages.push(types_1.ThinkingStage.ANALYSIS);
-        // Search needed?
-        if (lowerQuery.includes('search') ||
-            lowerQuery.includes('find') ||
-            lowerQuery.includes('what is') ||
-            lowerQuery.includes('latest') ||
-            lowerQuery.includes('research')) {
-            stages.push(types_1.ThinkingStage.SEARCH);
-        }
-        // Reasoning needed? (Default to yes for most queries unless very simple)
-        if (lowerQuery.includes('why') ||
-            lowerQuery.includes('how') ||
-            lowerQuery.includes('compare') ||
-            lowerQuery.includes('analyze') ||
-            lowerQuery.includes('reason') ||
-            stages.length === 1 // If only analysis so far, add reasoning
-        ) {
-            stages.push(types_1.ThinkingStage.REASONING);
-        }
-        // Creativity needed?
-        if (lowerQuery.includes('create') ||
-            lowerQuery.includes('idea') ||
-            lowerQuery.includes('brainstorm') ||
-            lowerQuery.includes('innovate') ||
-            lowerQuery.includes('design') ||
-            lowerQuery.includes('generate')) {
-            stages.push(types_1.ThinkingStage.CREATIVITY);
-        }
-        // Planning needed?
-        if (lowerQuery.includes('plan') ||
-            lowerQuery.includes('roadmap') ||
-            lowerQuery.includes('schedule') ||
-            lowerQuery.includes('timeline') ||
-            lowerQuery.includes('project') ||
-            lowerQuery.includes('steps to')) {
-            stages.push(types_1.ThinkingStage.PLANNING);
-        }
-        // Ensure logical order
-        const orderedStages = [];
-        if (stages.includes(types_1.ThinkingStage.SEARCH))
-            orderedStages.push(types_1.ThinkingStage.SEARCH);
-        if (stages.includes(types_1.ThinkingStage.ANALYSIS))
-            orderedStages.push(types_1.ThinkingStage.ANALYSIS);
-        if (stages.includes(types_1.ThinkingStage.REASONING))
-            orderedStages.push(types_1.ThinkingStage.REASONING);
-        // Learning is usually implicit/config-based, but we can add it if context is key
-        // stages.push(ThinkingStage.LEARNING); 
-        if (stages.includes(types_1.ThinkingStage.PLANNING))
-            orderedStages.push(types_1.ThinkingStage.PLANNING);
-        if (stages.includes(types_1.ThinkingStage.CREATIVITY))
-            orderedStages.push(types_1.ThinkingStage.CREATIVITY);
-        // Always synthesis at the end
-        orderedStages.push(types_1.ThinkingStage.SYNTHESIS);
-        return orderedStages;
-    }
-    /**
-     * Create a comprehensive plan
-     */
-    createPlan(goal, options = {}) {
-        const planId = this.generateId();
-        const createdAt = new Date();
-        this.emit('planning_start', {
-            id: planId,
-            stage: types_1.ThinkingStage.PLANNING,
-            timestamp: createdAt,
-            data: { goal }
-        });
-        // Decompose goal into tasks
-        const { subtasks, dependencies } = this.decompositionEngine.decompose(goal);
-        // Create tasks
-        const tasks = subtasks.map((description, index) => {
-            const complexity = this.decompositionEngine.estimateComplexity(description);
-            const duration = this.decompositionEngine.estimateDuration(description, complexity);
-            return {
-                id: `task_${planId}_${index}`,
-                title: description,
-                description,
-                priority: this.inferPriority(description, index),
-                status: types_1.TaskStatus.PENDING,
-                estimatedDuration: duration,
-                dependencies: dependencies[index].map(i => `task_${planId}_${i}`),
-                subtasks: [],
-                tags: []
-            };
-        });
-        // Prioritize tasks
-        const prioritizedTasks = this.prioritizationEngine.prioritize(tasks);
-        // Add resources if provided
-        if (options.resources) {
-            options.resources.forEach(r => this.resourceAllocator.addResource(r));
-        }
-        // Allocate resources
-        const resourceAllocation = this.resourceAllocator.allocate(prioritizedTasks);
-        // Assign resources to tasks
-        prioritizedTasks.forEach(task => {
-            const allocated = resourceAllocation.get(task.id) || [];
-            if (allocated.length > 0) {
-                task.assignedTo = allocated[0];
-            }
-        });
-        // Create milestones
-        const milestones = this.createMilestones(prioritizedTasks, goal);
-        // Create timeline
-        const timeline = this.createTimeline(prioritizedTasks, milestones, options.deadline);
-        // Analyze risks
-        const risks = this.riskAnalyzer.analyzeRisks(prioritizedTasks, options.resources || []);
-        const plan = {
-            id: planId,
-            goal,
-            tasks: prioritizedTasks,
-            milestones,
-            resources: options.resources || [],
-            timeline,
-            status: types_1.TaskStatus.PENDING,
-            createdAt,
-            updatedAt: createdAt
-        };
-        this.plans.set(planId, plan);
-        this.emit('planning_complete', {
-            id: planId,
-            stage: types_1.ThinkingStage.PLANNING,
-            timestamp: new Date(),
-            data: {
-                plan,
-                taskCount: tasks.length,
-                riskCount: risks.length
-            }
-        });
-        return plan;
-    }
-    /**
-     * Update task progress
-     */
-    updateTaskProgress(planId, taskId, progress, status) {
-        const plan = this.plans.get(planId);
-        if (!plan)
-            throw new Error(`Plan ${planId} not found`);
-        const task = plan.tasks.find(t => t.id === taskId);
-        if (!task)
-            throw new Error(`Task ${taskId} not found`);
-        const newStatus = status || (progress >= 100 ? types_1.TaskStatus.COMPLETED : progress > 0 ? types_1.TaskStatus.IN_PROGRESS : types_1.TaskStatus.PENDING);
-        task.status = newStatus;
-        if (newStatus === types_1.TaskStatus.COMPLETED) {
-            task.endTime = new Date();
-        }
-        else if (newStatus === types_1.TaskStatus.IN_PROGRESS && !task.startTime) {
-            task.startTime = new Date();
-        }
-        this.progressTracker.recordProgress(taskId, newStatus, progress);
-        // Update plan status
-        this.updatePlanStatus(plan);
-        plan.updatedAt = new Date();
-        this.emit('task_progress', {
-            id: taskId,
-            stage: types_1.ThinkingStage.PLANNING,
-            timestamp: new Date(),
-            data: { planId, taskId, progress, status: newStatus }
-        });
-    }
-    /**
-     * Generate progress report
-     */
-    generateProgressReport(planId) {
-        const plan = this.plans.get(planId);
-        if (!plan)
-            throw new Error(`Plan ${planId} not found`);
-        const completedTasks = plan.tasks.filter(t => t.status === types_1.TaskStatus.COMPLETED).length;
-        const totalTasks = plan.tasks.length;
-        const overallProgress = totalTasks > 0 ? (completedTasks / totalTasks) * 100 : 0;
-        // Calculate if on track
-        const onTrack = this.isOnTrack(plan);
-        // Get risks
-        const risks = this.riskAnalyzer.analyzeRisks(plan.tasks, plan.resources);
-        // Determine next actions
-        const nextActions = this.determineNextActions(plan);
-        return {
-            planId,
-            timestamp: new Date(),
-            overallProgress,
-            completedTasks,
-            totalTasks,
-            onTrack,
-            risks,
-            nextActions
-        };
-    }
-    /**
-     * Adjust plan based on changes
-     */
-    adjustPlan(planId, changes) {
-        const plan = this.plans.get(planId);
-        if (!plan)
-            throw new Error(`Plan ${planId} not found`);
-        // Add new tasks
-        if (changes.addTasks) {
-            const newTasks = changes.addTasks.map((task, index) => ({
-                ...task,
-                id: `task_${planId}_new_${Date.now()}_${index}`
-            }));
-            plan.tasks.push(...newTasks);
-        }
-        // Remove tasks
-        if (changes.removeTasks) {
-            plan.tasks = plan.tasks.filter(t => !changes.removeTasks.includes(t.id));
-        }
-        // Update tasks
-        if (changes.updateTasks) {
-            changes.updateTasks.forEach(update => {
-                const task = plan.tasks.find(t => t.id === update.id);
-                if (task) {
-                    Object.assign(task, update);
-                }
-            });
-        }
-        // Re-prioritize
-        plan.tasks = this.prioritizationEngine.prioritize(plan.tasks);
-        // Update timeline if new deadline
-        if (changes.newDeadline) {
-            plan.timeline.endDate = changes.newDeadline;
-        }
-        plan.updatedAt = new Date();
-        this.emit('plan_adjusted', {
-            id: planId,
-            stage: types_1.ThinkingStage.PLANNING,
-            timestamp: new Date(),
-            data: { changes }
-        });
-        return plan;
-    }
-    /**
-     * Get plan by ID
-     */
-    getPlan(planId) {
-        return this.plans.get(planId);
-    }
-    /**
-     * Get all plans
-     */
-    getAllPlans() {
-        return Array.from(this.plans.values());
-    }
-    // Private helper methods
-    generateId() {
-        return `plan_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    }
-    inferPriority(description, index) {
-        const lower = description.toLowerCase();
-        if (lower.includes('critical') || lower.includes('urgent'))
-            return types_1.Priority.CRITICAL;
-        if (lower.includes('important') || lower.includes('key'))
-            return types_1.Priority.HIGH;
-        if (index < 2)
-            return types_1.Priority.HIGH; // First tasks are usually important
-        if (lower.includes('optional') || lower.includes('nice to have'))
-            return types_1.Priority.LOW;
-        return types_1.Priority.MEDIUM;
-    }
-    createMilestones(tasks, goal) {
-        const milestones = [];
-        const totalTasks = tasks.length;
-        if (totalTasks >= 3) {
-            milestones.push({
-                id: `milestone_${Date.now()}_1`,
-                title: 'Phase 1 Complete',
-                description: 'Initial phase completed',
-                criteria: [`Complete ${Math.ceil(totalTasks * 0.25)} tasks`],
-                status: types_1.TaskStatus.PENDING
-            });
-        }
-        if (totalTasks >= 5) {
-            milestones.push({
-                id: `milestone_${Date.now()}_2`,
-                title: 'Halfway Point',
-                description: '50% of tasks completed',
-                criteria: [`Complete ${Math.ceil(totalTasks * 0.5)} tasks`],
-                status: types_1.TaskStatus.PENDING
-            });
-        }
-        milestones.push({
-            id: `milestone_${Date.now()}_final`,
-            title: 'Goal Achieved',
-            description: goal,
-            criteria: ['All tasks completed'],
-            status: types_1.TaskStatus.PENDING
-        });
-        return milestones;
-    }
-    createTimeline(tasks, milestones, deadline) {
-        const startDate = new Date();
-        const criticalPath = this.prioritizationEngine.calculateCriticalPath(tasks);
-        // Calculate end date based on tasks
-        const totalDuration = tasks.reduce((sum, t) => sum + t.estimatedDuration, 0);
-        const calculatedEndDate = new Date(startDate.getTime() + totalDuration * 60000);
-        const endDate = deadline || calculatedEndDate;
-        // Create phases
-        const phases = this.createPhases(tasks);
-        return {
-            startDate,
-            endDate,
-            phases,
-            criticalPath,
-            buffer: deadline ?
-                (deadline.getTime() - calculatedEndDate.getTime()) / 60000 :
-                totalDuration * 0.2 // 20% buffer
-        };
-    }
-    createPhases(tasks) {
-        const phases = [];
-        const phaseNames = ['Planning', 'Execution', 'Review'];
-        const tasksPerPhase = Math.ceil(tasks.length / phaseNames.length);
-        let currentDate = new Date();
-        phaseNames.forEach((name, index) => {
-            const phaseTasks = tasks.slice(index * tasksPerPhase, (index + 1) * tasksPerPhase);
-            const phaseDuration = phaseTasks.reduce((sum, t) => sum + t.estimatedDuration, 0);
-            const phase = {
-                id: `phase_${Date.now()}_${index}`,
-                name,
-                startDate: new Date(currentDate),
-                endDate: new Date(currentDate.getTime() + phaseDuration * 60000),
-                tasks: phaseTasks.map(t => t.id),
-                dependencies: index > 0 ? [`phase_${Date.now()}_${index - 1}`] : []
-            };
-            phases.push(phase);
-            currentDate = phase.endDate;
-        });
-        return phases;
-    }
-    updatePlanStatus(plan) {
-        const completed = plan.tasks.filter(t => t.status === types_1.TaskStatus.COMPLETED).length;
-        const inProgress = plan.tasks.filter(t => t.status === types_1.TaskStatus.IN_PROGRESS).length;
-        const failed = plan.tasks.filter(t => t.status === types_1.TaskStatus.FAILED).length;
-        if (failed > 0 && failed > plan.tasks.length * 0.3) {
-            plan.status = types_1.TaskStatus.FAILED;
-        }
-        else if (completed === plan.tasks.length) {
-            plan.status = types_1.TaskStatus.COMPLETED;
-        }
-        else if (inProgress > 0 || completed > 0) {
-            plan.status = types_1.TaskStatus.IN_PROGRESS;
-        }
-    }
-    isOnTrack(plan) {
-        if (!plan.timeline.endDate)
-            return true;
-        const elapsed = Date.now() - plan.timeline.startDate.getTime();
-        const total = plan.timeline.endDate.getTime() - plan.timeline.startDate.getTime();
-        const expectedProgress = elapsed / total;
-        const completedTasks = plan.tasks.filter(t => t.status === types_1.TaskStatus.COMPLETED).length;
-        const actualProgress = completedTasks / plan.tasks.length;
-        return actualProgress >= expectedProgress * 0.8; // Allow 20% slack
-    }
-    determineNextActions(plan) {
-        const actions = [];
-        // Find pending tasks with no incomplete dependencies
-        const readyTasks = plan.tasks.filter(t => {
-            if (t.status !== types_1.TaskStatus.PENDING)
-                return false;
-            return t.dependencies.every(depId => plan.tasks.find(t => t.id === depId)?.status === types_1.TaskStatus.COMPLETED);
-        });
-        if (readyTasks.length > 0) {
-            actions.push(`Start task: ${readyTasks[0].title}`);
-        }
-        // Check for at-risk tasks
-        const inProgressTasks = plan.tasks.filter(t => t.status === types_1.TaskStatus.IN_PROGRESS);
-        inProgressTasks.forEach(task => {
-            const trend = this.progressTracker.getProgressTrend(task.id);
-            if (trend === 'declining') {
-                actions.push(`Review task: ${task.title} (progress declining)`);
-            }
-        });
-        return actions;
-    }
-}
-exports.PlanningEngine = PlanningEngine;
-// ============================================================================
-// EXPORT SINGLETON INSTANCE
-// ============================================================================
-exports.planningEngine = new PlanningEngine();
-// ============================================================================
-// EXAMPLE USAGE
-// ============================================================================
-/*
-// Create a plan
-const plan = planningEngine.createPlan(
-  'Build a scalable microservices architecture with AI capabilities',
-  {
-    resources: [
-      {
-        id: 'dev1',
-        type: 'human',
-        name: 'Senior Developer',
-        availability: 0.8,
-        skills: ['backend', 'microservices', 'typescript']
-      },
-      {
-        id: 'dev2',
-        type: 'human',
-        name: 'ML Engineer',
-        availability: 0.6,
-        skills: ['machine_learning', 'python', 'tensorflow']
-      }
-    ],
-    deadline: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000) // 30 days
-  }
-);
-
-// Update task progress
-planningEngine.updateTaskProgress(plan.id, plan.tasks[0].id, 50, TaskStatus.IN_PROGRESS);
-planningEngine.updateTaskProgress(plan.id, plan.tasks[0].id, 100, TaskStatus.COMPLETED);
-
-// Generate progress report
-const report = planningEngine.generateProgressReport(plan.id);
-console.log(`Progress: ${report.overallProgress}%`);
-console.log(`On track: ${report.onTrack}`);
-console.log(`Next actions: ${report.nextActions.join(', ')}`);
-
-// Adjust plan
-const adjustedPlan = planningEngine.adjustPlan(plan.id, {
-  addTasks: [{
-    title: 'Security audit',
-    description: 'Perform security review',
-    priority: Priority.HIGH,
-    status: TaskStatus.PENDING,
-    estimatedDuration: 120,
-    dependencies: [],
-    subtasks: [],
-    tags: ['security']
-  }]
-});
-*/
-//# sourceMappingURL=planning.js.map