gthinking 1.0.0

package/dist/planning.js

@@ -0,0 +1,824 @@
+"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();
+    }
+    /**
+     * 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