import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

const llm = new ChatOpenAI({ temperature: 0.7 });

// Goal Status
const GoalStatus = {
  PENDING: 'pending',
  ACTIVE: 'active',
  COMPLETED: 'completed',
  BLOCKED: 'blocked',
  CANCELLED: 'cancelled',
};

// Priority Levels
const Priority = {
  LOW: 1,
  MEDIUM: 5,
  HIGH: 10,
  CRITICAL: 20,
};

// Goal Item
class Goal {
  constructor(config) {
    this.id = `goal_${Date.now()}`;
    this.title = config.title;
    this.description = config.description;
    this.status = GoalStatus.PENDING;

    // SMART criteria
    this.specific = config.specific || '';
    this.measurable = config.measurable || {}; // { target: number, unit: string }
    this.achievable = config.achievable || true;
    this.relevant = config.relevant || '';
    this.timeBound = config.timeBound || null; // { deadline: Date, duration: number }

    this.priority = config.priority || Priority.MEDIUM;
    this.category = config.category || 'general';

    this.subGoals = [];
    this.progress = 0;
    this.metrics = [];

    this.createdAt = Date.now();
    this.updatedAt = Date.now();
    this.completedAt = null;
  }

  // Add sub-goal
  addSubGoal(subGoal) {
    this.subGoals.push(subGoal);
    this.updatedAt = Date.now();
  }

  // Update progress
  updateProgress(progress) {
    this.progress = Math.min(100, Math.max(0, progress));
    this.updatedAt = Date.now();

    if (this.progress === 100) {
      this.status = GoalStatus.COMPLETED;
      this.completedAt = Date.now();
    }
  }

  // Check if goal is on track
  isOnTrack() {
    if (!this.timeBound || !this.timeBound.deadline) return true;

    const now = Date.now();
    const deadline = new Date(this.timeBound.deadline).getTime();
    const timeRemaining = deadline - now;

    // If more than 80% time elapsed but less than 50% progress
    const totalDuration = deadline - this.createdAt;
    const timeElapsed = now - this.createdAt;
    const progressRatio = this.progress / 100;

    return timeElapsed / totalDuration >= progressRatio - 0.2;
  }

  // Get status summary
  getSummary() {
    return {
      id: this.id,
      title: this.title,
      status: this.status,
      progress: `${this.progress}%`,
      priority: this.priority,
      onTrack: this.isOnTrack(),
      subGoals: this.subGoals.length,
      deadline: this.timeBound?.deadline,
    };
  }
}

// Goal Manager
class GoalManager {
  constructor() {
    this.goals = new Map();
    this.listeners = new Map();
  }

  // Create goal with validation
  createGoal(config) {
    // Validate SMART criteria
    const validation = this.validateGoal(config);
    if (!validation.valid) {
      console.warn(`[Goal] Warning: ${validation.warnings.join(', ')}`);
    }

    const goal = new Goal(config);
    goal.status = GoalStatus.ACTIVE;
    this.goals.set(goal.id, goal);

    console.log(`[Goal] Created goal: ${goal.title}`);
    return goal;
  }

  // Validate goal meets SMART criteria
  validateGoal(config) {
    const warnings = [];

    if (!config.specific) warnings.push('Goal is not specific');
    if (!config.measurable) warnings.push('Goal is not measurable');
    if (!config.achievable) warnings.push('Goal may not be achievable');
    if (!config.relevant) warnings.push('Goal relevance not defined');
    if (!config.timeBound) warnings.push('Goal has no deadline');

    return {
      valid: warnings.length === 0,
      warnings,
    };
  }

  // Get goal by ID
  getGoal(id) {
    return this.goals.get(id);
  }

  // Get all goals
  getAllGoals() {
    return Array.from(this.goals.values());
  }

  // Get goals by status
  getGoalsByStatus(status) {
    return this.getAllGoals().filter((g) => g.status === status);
  }

  // Get goals by category
  getGoalsByCategory(category) {
    return this.getAllGoals().filter((g) => g.category === category);
  }

  // Get on-track goals
  getOnTrackGoals() {
    return this.getAllGoals().filter((g) => g.isOnTrack());
  }

  // Subscribe to goal changes
  subscribe(goalId, listener) {
    if (!this.listeners.has(goalId)) {
      this.listeners.set(goalId, []);
    }
    this.listeners.get(goalId).push(listener);
  }

  // Notify listeners
  notifyListeners(goalId, event, data) {
    const listeners = this.listeners.get(goalId);
    if (listeners) {
      listeners.forEach((listener) => listener(event, data));
    }
  }
}

// Usage
const goalManager = GoalManager();

// Create goals
const goal1 = goalManager.createGoal({
  title: 'Learn Machine Learning',
  description: 'Master machine learning fundamentals and apply them to projects',
  specific: 'Complete ML courses and build 3 projects',
  measurable: { target: 3, unit: 'projects' },
  achievable: true,
  relevant: 'Career advancement in AI',
  timeBound: { deadline: '2024-12-31', duration: 180 },
  priority: Priority.HIGH,
  category: 'learning',
});

const goal2 = goalManager.createGoal({
  title: 'Increase Sales',
  description: 'Boost Q4 sales performance',
  specific: 'Increase monthly sales by 20%',
  measurable: { target: 20, unit: 'percent' },
  achievable: true,
  relevant: 'Company growth',
  timeBound: { deadline: '2024-12-31', duration: 90 },
  priority: Priority.CRITICAL,
  category: 'business',
});

// Add sub-goals
goal1.addSubGoal({ title: "Complete Andrew Ng's ML Course", completed: true });
goal1.addSubGoal({ title: 'Build image classifier project', completed: false });
goal1.addSubGoal({ title: 'Build NLP sentiment analyzer', completed: false });

// Update progress
goal1.updateProgress(33);

// Get summary
console.log('\nGoal Summary:');
console.log(goal1.getSummary());

console.log('\nAll Goals:');
goalManager.getAllGoals().forEach((g) => {
  console.log(`- ${g.title}: ${g.progress}% (${g.status})`);
});

console.log('\nOn Track Goals:');
goalManager.getOnTrackGoals().forEach((g) => {
  console.log(`- ${g.title}`);
});

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

const llm = new ChatOpenAI({ temperature: 0.7 });

// Metric Types
const MetricType = {
  PERCENTAGE: 'percentage',
  COUNT: 'count',
  TIME: 'time',
  CUSTOM: 'custom',
};

// Progress Metric
class Metric {
  constructor(name, type, value, target, unit = '') {
    this.name = name;
    this.type = type;
    this.value = value;
    this.target = target;
    this.unit = unit;
    this.history = [];
    this.recordedAt = Date.now();
  }

  // Update value
  update(value) {
    this.history.push({
      value: this.value,
      timestamp: this.recordedAt,
    });
    this.value = value;
    this.recordedAt = Date.now();
  }

  // Get completion percentage
  getCompletion() {
    if (this.target === 0) return 0;
    return Math.min(100, (this.value / this.target) * 100);
  }

  // Check if on track
  isOnTrack() {
    const completion = this.getCompletion();
    return completion >= 50; // Expecting at least 50% completion
  }
}

// Progress Monitor
class ProgressMonitor {
  constructor() {
    this.goals = new Map();
    this.metrics = new Map();
    this.alerts = [];
  }

  // Track progress for a goal
  trackGoal(goalId, metrics) {
    this.goals.set(goalId, {
      metrics: metrics.map((m) => new Metric(m.name, m.type, m.value, m.target, m.unit)),
      startTime: Date.now(),
      lastUpdate: Date.now(),
    });

    console.log(`[Monitor] Tracking goal ${goalId} with ${metrics.length} metrics`);
  }

  // Add metric to goal
  addMetric(goalId, metric) {
    const goal = this.goals.get(goalId);
    if (!goal) {
      console.warn(`[Monitor] Goal ${goalId} not found`);
      return;
    }

    goal.metrics.push(
      new Metric(metric.name, metric.type, metric.value, metric.target, metric.unit),
    );
    goal.lastUpdate = Date.now();
  }

  // Update metric value
  updateMetric(goalId, metricName, value) {
    const goal = this.goals.get(goalId);
    if (!goal) return;

    const metric = goal.metrics.find((m) => m.name === metricName);
    if (metric) {
      metric.update(value);
      this.checkAlerts(goalId, metric);
    }
  }

  // Check for alerts
  checkAlerts(goalId, metric) {
    const completion = metric.getCompletion();

    if (metric.isOnTrack() === false) {
      const alert = {
        goalId,
        metric: metric.name,
        type: 'warning',
        message: `${metric.name} is behind target: ${completion.toFixed(1)}%`,
        timestamp: Date.now(),
      };
      this.alerts.push(alert);
      console.log(`[Monitor] ALERT: ${alert.message}`);
    }
  }

  // Get progress report
  getProgressReport(goalId) {
    const goal = this.goals.get(goalId);
    if (!goal) return null;

    const metrics = goal.metrics.map((m) => ({
      name: m.name,
      value: m.value,
      target: m.target,
      completion: `${m.getCompletion().toFixed(1)}%`,
      onTrack: m.isOnTrack(),
    }));

    const overallProgress = metrics.reduce((sum, m) => sum + m.completion, 0) / metrics.length;

    return {
      goalId,
      overallProgress: `${overallProgress.toFixed(1)}%`,
      metrics,
      alerts: this.alerts.filter((a) => a.goalId === goalId),
      lastUpdate: goal.lastUpdate,
    };
  }

  // Get all alerts
  getAlerts() {
    return this.alerts;
  }

  // Clear alerts
  clearAlerts(goalId = null) {
    if (goalId) {
      this.alerts = this.alerts.filter((a) => a.goalId !== goalId);
    } else {
      this.alerts = [];
    }
  }

  // Generate progress summary using LLM
  async generateSummary(goalId) {
    const report = this.getProgressReport(goalId);
    if (!report) return 'Goal not found';

    const prompt = ChatPromptTemplate.fromTemplate(
      `Generate a progress summary for this goal:

Progress: {progress}
Metrics: {metrics}
Alerts: {alerts}

Provide a brief summary:`,
    );

    const chain = prompt.pipe(llm).pipe(new StringOutputParser());
    return chain.invoke({
      progress: report.overallProgress,
      metrics: JSON.stringify(report.metrics),
      alerts: report.alerts.length > 0 ? JSON.stringify(report.alerts) : 'No alerts',
    });
  }
}

// Usage
const monitor = new ProgressMonitor();

// Track goal with metrics
monitor.trackGoal('goal_1', [
  { name: 'tasks_completed', type: MetricType.COUNT, value: 5, target: 10, unit: 'tasks' },
  { name: 'time_spent', type: MetricType.TIME, value: 20, target: 40, unit: 'hours' },
  { name: 'quality_score', type: MetricType.PERCENTAGE, value: 75, target: 100, unit: '%' },
]);

// Update metrics
monitor.updateMetric('goal_1', 'tasks_completed', 7);
monitor.updateMetric('goal_1', 'time_spent', 25);

// Get progress report
console.log('\n--- Progress Report ---');
console.log(monitor.getProgressReport('goal_1'));

// Get alerts
console.log('\n--- Alerts ---');
console.log(monitor.getAlerts());

// Generate LLM summary
async function demoSummary() {
  const summary = await monitor.generateSummary('goal_1');
  console.log('\n--- LLM Summary ---');
  console.log(summary);
}

demoSummary();

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

const llm = new ChatOpenAI({ temperature: 0.7 });

// Refinement Reasons
const RefinementReason = {
  USER_FEEDBACK: 'user_feedback',
  PROGRESS_SLOW: 'progress_slow',
  RESOURCE_CHANGE: 'resource_change',
  NEW_INFORMATION: 'new_information',
  ENVIRONMENT_CHANGE: 'environment_change',
};

// Goal Revision
class GoalRevision {
  constructor(goalId, reason, oldValue, newValue) {
    this.id = `revision_${Date.now()}`;
    this.goalId = goalId;
    this.reason = reason;
    this.oldValue = oldValue;
    this.newValue = newValue;
    this.timestamp = Date.now();
  }
}

// Goal Refiner
class GoalRefiner {
  constructor() {
    this.goals = new Map();
    this.revisions = [];
  }

  // Load existing goal
  loadGoal(goal) {
    this.goals.set(goal.id, goal);
  }

  // Refine goal based on feedback
  async refineGoal(goalId, newSpecs, reason) {
    const goal = this.goals.get(goalId);
    if (!goal) {
      throw new Error(`Goal ${goalId} not found`);
    }

    // Store revision history
    const revision = new GoalRevision(
      goalId,
      reason,
      {
        target: goal.measurable?.target,
        deadline: goal.timeBound?.deadline,
        priority: goal.priority,
      },
      newSpecs,
    );
    this.revisions.push(revision);

    // Apply refinements
    if (newSpecs.target !== undefined) {
      goal.measurable.target = newSpecs.target;
    }
    if (newSpecs.deadline !== undefined) {
      goal.timeBound.deadline = newSpecs.deadline;
    }
    if (newSpecs.priority !== undefined) {
      goal.priority = newSpecs.priority;
    }
    if (newSpecs.description !== undefined) {
      goal.description = newSpecs.description;
    }

    goal.updatedAt = Date.now();

    console.log(`[Refiner] Goal ${goal.title} refined: ${reason}`);
    return goal;
  }

  // Auto-refine based on progress
  async autoRefine(goalId) {
    const goal = this.goals.get(goalId);
    if (!goal) return null;

    // Calculate if goal needs adjustment
    const progressRatio = goal.progress / 100;
    const now = Date.now();
    const deadline = goal.timeBound?.deadline ? new Date(goal.timeBound.deadline).getTime() : null;

    if (!deadline) return null;

    const timeElapsed = now - goal.createdAt;
    const totalDuration = deadline - goal.createdAt;
    const timeRatio = timeElapsed / totalDuration;

    // If progress is significantly behind time
    if (progressRatio < timeRatio - 0.2) {
      console.log(`[Refiner] Auto-refining goal: progress behind schedule`);

      // Suggest new deadline
      const newDeadline = new Date(goal.createdAt + timeElapsed / progressRatio);
      const newSpecs = {
        deadline: newDeadline.toISOString().split('T')[0],
      };

      return await this.refineGoal(goalId, newSpecs, RefinementReason.PROGRESS_SLOW);
    }

    return null;
  }

  // Use LLM to suggest refinements
  async suggestRefinements(goalId, context) {
    const goal = this.goals.get(goalId);
    if (!goal) return null;

    const prompt = ChatPromptTemplate.fromTemplate(
      `Analyze this goal and suggest refinements based on the context:

Goal: {title}
Description: {description}
Current Progress: {progress}%
Target: {target} {unit}
Deadline: {deadline}

Context: {context}

Suggest:
1. Is the target achievable?
2. Should the deadline be adjusted?
3. Any other recommendations?

Respond in JSON format:
{
  "targetAdjustment": "increase/decrease/same",
  "deadlineAdjustment": "extend/shorten/same",
  "recommendations": ["rec1", "rec2"]
}`,
    );

    const chain = prompt.pipe(llm).pipe(new StringOutputParser());

    try {
      const response = await chain.invoke({
        title: goal.title,
        description: goal.description,
        progress: goal.progress,
        target: goal.measurable?.target || 'N/A',
        unit: goal.measurable?.unit || '',
        deadline: goal.timeBound?.deadline || 'N/A',
        context,
      });

      return JSON.parse(response);
    } catch (e) {
      console.log('[Refiner] LLM suggestion failed:', e.message);
      return null;
    }
  }

  // Get revision history
  getRevisionHistory(goalId) {
    return this.revisions.filter((r) => r.goalId === goalId);
  }

  // Rollback to previous revision
  async rollback(goalId) {
    const revisions = this.getRevisionHistory(goalId);
    if (revisions.length === 0) return null;

    const lastRevision = revisions[revisions.length - 1];
    const goal = this.goals.get(goalId);

    if (goal && lastRevision) {
      goal.measurable.target = lastRevision.oldValue.target;
      goal.timeBound.deadline = lastRevision.oldValue.deadline;
      goal.priority = lastRevision.oldValue.priority;
      goal.updatedAt = Date.now();

      console.log(`[Refiner] Rolled back goal to previous revision`);
      return goal;
    }

    return null;
  }
}

// Usage
async function demoRefinement() {
  const refiner = new GoalRefiner();

  // Create and load a goal
  const goal = new Goal({
    title: 'Launch Mobile App',
    description: 'Launch a new mobile app to the app store',
    specific: 'Release version 1.0 with core features',
    measurable: { target: 100, unit: '%' },
    achievable: true,
    relevant: 'Company expansion',
    timeBound: { deadline: '2024-06-30', duration: 180 },
  });

  goal.updateProgress(30); // Only 30% after 60% of time
  refiner.loadGoal(goal);

  // Manual refinement
  console.log('\n--- Manual Refinement ---');
  await refiner.refineGoal(
    goal.id,
    {
      deadline: '2024-08-31',
    },
    RefinementReason.PROGRESS_SLOW,
  );

  // LLM-based suggestions
  console.log('\n--- LLM Suggestions ---');
  const suggestions = await refiner.suggestRefinements(
    goal.id,
    'User feedback indicates feature scope is too large',
  );
  console.log(suggestions);

  // Revision history
  console.log('\n--- Revision History ---');
  console.log(refiner.getRevisionHistory(goal.id));
}

demoRefinement();

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

const llm = new ChatOpenAI({ temperature: 0.7 });

// Task Status
const TaskStatus = {
  PENDING: 'pending',
  IN_PROGRESS: 'in_progress',
  COMPLETED: 'completed',
  BLOCKED: 'blocked',
};

// Project Task
class Task {
  constructor(config) {
    this.id = `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
    this.title = config.title;
    this.description = config.description;
    this.status = TaskStatus.PENDING;
    this.assignee = config.assignee || null;
    this.priority = config.priority || Priority.MEDIUM;
    this.goalId = config.goalId || null;
    this.dependencies = config.dependencies || [];
    this.estimatedHours = config.estimatedHours || 0;
    this.actualHours = 0;
    this.subtasks = [];
    this.createdAt = Date.now();
    this.completedAt = null;
  }

  start() {
    this.status = TaskStatus.IN_PROGRESS;
  }

  complete() {
    this.status = TaskStatus.COMPLETED;
    this.completedAt = Date.now();
  }

  block() {
    this.status = TaskStatus.BLOCKED;
  }

  addSubtask(subtask) {
    this.subtasks.push({
      id: `subtask_${Date.now()}`,
      title: subtask,
      completed: false,
    });
  }

  completeSubtask(subtaskId) {
    const subtask = this.subtasks.find((s) => s.id === subtaskId);
    if (subtask) {
      subtask.completed = true;
    }
  }

  getProgress() {
    if (this.subtasks.length === 0) {
      return this.status === TaskStatus.COMPLETED ? 100 : 0;
    }
    const completed = this.subtasks.filter((s) => s.completed).length;
    return Math.round((completed / this.subtasks.length) * 100);
  }
}

// Project Manager with Goals
class ProjectManager {
  constructor() {
    this.goals = new GoalManager();
    this.tasks = new Map();
    this.resources = new Map();
  }

  // Create project with goals and tasks
  createProject(config) {
    const { goals, tasks } = config;

    // Create goals
    const createdGoals = goals.map((g) => this.goals.createGoal(g));

    // Create tasks linked to goals
    const createdTasks = tasks.map((t) => {
      const task = new Task({
        ...t,
        goalId: t.goalId || createdGoals[0]?.id,
      });
      this.tasks.set(task.id, task);
      return task;
    });

    console.log(
      `[Project] Created project with ${createdGoals.length} goals and ${createdTasks.length} tasks`,
    );
    return { goals: createdGoals, tasks: createdTasks };
  }

  // Get task by ID
  getTask(taskId) {
    return this.tasks.get(taskId);
  }

  // Get tasks by goal
  getTasksByGoal(goalId) {
    return Array.from(this.tasks.values()).filter((t) => t.goalId === goalId);
  }

  // Get task progress for a goal
  getGoalProgress(goalId) {
    const tasks = this.getTasksByGoal(goalId);
    if (tasks.length === 0) return 0;

    const totalProgress = tasks.reduce((sum, t) => sum + t.getProgress(), 0);
    return Math.round(totalProgress / tasks.length);
  }

  // Update goal progress based on tasks
  syncGoalProgress(goalId) {
    const tasks = this.getTasksByGoal(goalId);
    const progress = this.getGoalProgress(goalId);

    const goal = this.goals.getGoal(goalId);
    if (goal) {
      goal.updateProgress(progress);
    }

    return progress;
  }

  // Get project status
  getProjectStatus() {
    const allTasks = Array.from(this.tasks.values());
    const completed = allTasks.filter((t) => t.status === TaskStatus.COMPLETED).length;
    const blocked = allTasks.filter((t) => t.status === TaskStatus.BLOCKED).length;
    const inProgress = allTasks.filter((t) => t.status === TaskStatus.IN_PROGRESS).length;

    const allGoals = this.goals.getAllGoals();
    const goalsOnTrack = this.goals.getOnTrackGoals().length;

    return {
      tasks: {
        total: allTasks.length,
        completed,
        blocked,
        inProgress,
        completionRate: `${Math.round((completed / allTasks.length) * 100)}%`,
      },
      goals: {
        total: allGoals.length,
        onTrack: goalsOnTrack,
        atRisk: allGoals.length - goalsOnTrack,
      },
    };
  }

  // Identify blocked tasks
  getBlockedTasks() {
    return Array.from(this.tasks.values()).filter((t) => t.status === TaskStatus.BLOCKED);
  }

  // Find critical path
  getCriticalPath(goalId) {
    const tasks = this.getTasksByGoal(goalId);

    // Simple critical path: longest chain of dependent tasks
    const taskMap = new Map(tasks.map((t) => [t.id, t]));
    const inDegree = new Map();

    tasks.forEach((t) => {
      inDegree.set(t.id, t.dependencies.length);
    });

    const criticalPath = [];
    let current = tasks.find((t) => inDegree.get(t.id) === 0);

    while (current) {
      criticalPath.push(current);
      current.dependencies.forEach((depId) => {
        inDegree.set(depId, inDegree.get(depId) - 1);
      });
      current = tasks.find((t) => inDegree.get(t.id) === 0 && !criticalPath.includes(t));
    }

    return criticalPath;
  }

  // Generate project report
  async generateReport() {
    const status = this.getProjectStatus();
    const blocked = this.getBlockedTasks();

    const prompt = ChatPromptTemplate.fromTemplate(
      `Generate a project status report:

Task Status: {taskStatus}
Blocked Tasks: {blocked}

Goals On Track: {goalsOnTrack}
Goals At Risk: {goalsAtRisk}

Provide a summary and recommendations:`,
    );

    const chain = prompt.pipe(llm).pipe(new StringOutputParser());

    return chain.invoke({
      taskStatus: JSON.stringify(status.tasks),
      blocked: blocked.map((t) => t.title).join(', ') || 'None',
      goalsOnTrack: status.goals.onTrack,
      goalsAtRisk: status.goals.atRisk,
    });
  }
}

// Usage
async function demoProject() {
  const project = new ProjectManager();

  // Create project
  const { goals, tasks } = project.createProject({
    goals: [
      {
        title: 'Launch MVP',
        description: 'Launch minimum viable product',
        specific: 'Complete core features and beta testing',
        measurable: { target: 100, unit: '%' },
        achievable: true,
        relevant: 'Business growth',
        timeBound: { deadline: '2024-12-31', duration: 180 },
        priority: Priority.HIGH,
        category: 'product',
      },
    ],
    tasks: [
      {
        title: 'Design UI/UX',
        description: 'Create user interface designs',
        priority: Priority.HIGH,
        estimatedHours: 40,
        subtasks: ['Wireframes', 'Visual design', 'Prototypes'],
      },
      {
        title: 'Backend Development',
        description: 'Build API and database',
        priority: Priority.HIGH,
        estimatedHours: 80,
        dependencies: [],
        subtasks: ['Database schema', 'API endpoints', 'Authentication'],
      },
      {
        title: 'Frontend Development',
        description: 'Build user interface',
        priority: Priority.HIGH,
        estimatedHours: 60,
        dependencies: ['task_1'], // Depends on Design
        subtasks: ['Components', 'State management', 'Integration'],
      },
      {
        title: 'Testing',
        description: 'Test the application',
        priority: Priority.MEDIUM,
        estimatedHours: 30,
        dependencies: ['task_2', 'task_3'],
        subtasks: ['Unit tests', 'Integration tests', 'User testing'],
      },
    ],
  });

  // Simulate task progress
  const task1 = project.getTask(tasks[0].id);
  task1.start();
  task1.completeSubtask(task1.subtasks[0].id);
  task1.complete();

  // Sync progress to goal
  project.syncGoalProgress(goals[0].id);

  // Get project status
  console.log('\n--- Project Status ---');
  console.log(project.getProjectStatus());

  // Get blocked tasks
  console.log('\n--- Blocked Tasks ---');
  console.log(project.getBlockedTasks());

  // Generate report
  console.log('\n--- Project Report ---');
  const report = await project.generateReport();
  console.log(report);
}

demoProject();

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

const llm = new ChatOpenAI({ temperature: 0.7 });

// Habit Types
const HabitType = {
  DAILY: 'daily',
  WEEKLY: 'weekly',
  ONE_TIME: 'one_time',
};

// Habit Tracker
class Habit {
  constructor(config) {
    this.id = `habit_${Date.now()}`;
    this.name = config.name;
    this.type = config.type || HabitType.DAILY;
    this.target = config.target || 1;
    this.unit = config.unit || 'times';
    this.streak = 0;
    this.longestStreak = 0;
    this.completions = [];
    this.createdAt = Date.now();
  }

  // Log completion
  complete(date = new Date()) {
    const completionDate = date.toISOString().split('T')[0];

    // Check if already completed today
    const alreadyCompleted = this.completions.some((c) => c.date === completionDate);

    if (!alreadyCompleted) {
      this.completions.push({
        date: completionDate,
        timestamp: Date.now(),
      });

      // Update streak
      this.updateStreak();
    }
  }

  // Update streak
  updateStreak() {
    const sortedDates = this.completions
      .map((c) => c.date)
      .sort()
      .reverse();

    if (sortedDates.length === 0) {
      this.streak = 0;
      return;
    }

    const today = new Date().toISOString().split('T')[0];
    const yesterday = new Date(Date.now() - 86400000).toISOString().split('T')[0];

    if (sortedDates[0] === today || sortedDates[0] === yesterday) {
      // Count consecutive days
      let currentStreak = 1;
      for (let i = 1; i < sortedDates.length; i++) {
        const prevDate = new Date(sortedDates[i - 1]);
        const currDate = new Date(sortedDates[i]);
        const diff = (prevDate - currDate) / 86400000;

        if (diff === 1) {
          currentStreak++;
        } else {
          break;
        }
      }
      this.streak = currentStreak;
      this.longestStreak = Math.max(this.longestStreak, this.streak);
    } else {
      this.streak = 0;
    }
  }

  // Get completion rate
  getCompletionRate(days = 30) {
    const startDate = new Date();
    startDate.setDate(startDate.getDate() - days);

    const relevantCompletions = this.completions.filter((c) => new Date(c.date) >= startDate);

    return (relevantCompletions.length / days) * 100;
  }

  // Get stats
  getStats() {
    return {
      name: this.name,
      currentStreak: this.streak,
      longestStreak: this.longestStreak,
      totalCompletions: this.completions.length,
      completionRate: `${this.getCompletionRate().toFixed(1)}%`,
    };
  }
}

// Personal Productivity System
class ProductivityTracker {
  constructor() {
    this.habits = new Map();
    this.goals = new GoalManager();
    this.dailyLogs = [];
  }

  // Add habit
  addHabit(config) {
    const habit = new Habit(config);
    this.habits.set(habit.id, habit);
    console.log(`[Tracker] Added habit: ${habit.name}`);
    return habit;
  }

  // Complete habit
  completeHabit(habitId, date = new Date()) {
    const habit = this.habits.get(habitId);
    if (habit) {
      habit.complete(date);
      this.logActivity('habit_completed', { habitId, date: date.toISOString() });
    }
  }

  // Create personal goal
  createGoal(config) {
    return this.goals.createGoal({
      ...config,
      category: 'personal',
    });
  }

  // Log daily activity
  logActivity(type, data) {
    this.dailyLogs.push({
      type,
      data,
      timestamp: Date.now(),
    });
  }

  // Get today's summary
  getTodaySummary() {
    const today = new Date().toISOString().split('T')[0];
    const todayLogs = this.dailyLogs.filter(
      (l) => new Date(l.timestamp).toISOString().split('T')[0] === today,
    );

    const habitsCompleted = todayLogs.filter((l) => l.type === 'habit_completed').length;
    const totalHabits = this.habits.size;

    return {
      date: today,
      habitsCompleted,
      totalHabits,
      completionRate: `${((habitsCompleted / totalHabits) * 100).toFixed(1)}%`,
      activities: todayLogs.length,
    };
  }

  // Get weekly progress
  getWeeklyProgress() {
    const progress = [];

    for (let i = 6; i >= 0; i--) {
      const date = new Date();
      date.setDate(date.getDate() - i);
      const dateStr = date.toISOString().split('T')[0];

      const dayLogs = this.dailyLogs.filter(
        (l) => new Date(l.timestamp).toISOString().split('T')[0] === dateStr,
      );

      const habitsCompleted = dayLogs.filter((l) => l.type === 'habit_completed').length;

      progress.push({
        date: dateStr,
        habitsCompleted,
        completionRate: `${((habitsCompleted / this.habits.size) * 100).toFixed(1)}%`,
      });
    }

    return progress;
  }

  // Get habit stats
  getHabitStats(habitId) {
    const habit = this.habits.get(habitId);
    return habit ? habit.getStats() : null;
  }

  // Get all habit stats
  getAllHabitStats() {
    return Array.from(this.habits.values()).map((h) => h.getStats());
  }

  // Generate productivity insights
  async generateInsights() {
    const summary = this.getTodaySummary();
    const weeklyProgress = this.getWeeklyProgress();
    const habitStats = this.getAllHabitStats();

    const bestHabit = habitStats.reduce((best, current) =>
      current.currentStreak > best.currentStreak ? current : best,
    );

    const prompt = ChatPromptTemplate.fromTemplate(
      `Generate productivity insights:

Today's Summary: {summary}
Weekly Progress: {weeklyProgress}
Best Performing Habit: {bestHabit}

Provide insights and recommendations:`,
    );

    const chain = prompt.pipe(llm).pipe(new StringOutputParser());

    return chain.invoke({
      summary: JSON.stringify(summary),
      weeklyProgress: JSON.stringify(weeklyProgress),
      bestHabit: JSON.stringify(bestHabit),
    });
  }

  // Get achievement badges
  getBadges() {
    const badges = [];
    const habits = Array.from(this.habits.values());

    habits.forEach((habit) => {
      if (habit.streak >= 7) badges.push({ name: 'Week Warrior', habit: habit.name });
      if (habit.streak >= 30) badges.push({ name: 'Month Master', habit: habit.name });
      if (habit.longestStreak >= 100) badges.push({ name: 'Century Club', habit: habit.name });
    });

    return badges;
  }
}

// Usage
async function demoProductivity() {
  const tracker = new ProductivityTracker();

  // Add habits
  const habit1 = tracker.addHabit({
    name: 'Morning Exercise',
    type: HabitType.DAILY,
    target: 1,
    unit: 'session',
  });

  const habit2 = tracker.addHabit({
    name: 'Read 30 minutes',
    type: HabitType.DAILY,
    target: 1,
    unit: 'times',
  });

  const habit3 = tracker.addHabit({
    name: 'Learn new skill',
    type: HabitType.WEEKLY,
    target: 3,
    unit: 'times',
  });

  // Create personal goal
  tracker.createGoal({
    title: 'Get Fit in 2024',
    description: 'Improve physical fitness through daily exercise',
    specific: 'Exercise for 30 minutes daily',
    measurable: { target: 365, unit: 'days' },
    achievable: true,
    relevant: 'Health and wellbeing',
    timeBound: { deadline: '2024-12-31', duration: 365 },
    priority: Priority.HIGH,
    category: 'health',
  });

  // Simulate completions
  for (let i = 0; i < 5; i++) {
    const date = new Date();
    date.setDate(date.getDate() - i);
    tracker.completeHabit(habit1.id, date);
  }

  tracker.completeHabit(habit2.id);

  // Get summaries
  console.log("\n--- Today's Summary ---");
  console.log(tracker.getTodaySummary());

  console.log('\n--- Weekly Progress ---');
  console.log(tracker.getWeeklyProgress());

  console.log('\n--- Habit Stats ---');
  console.log(tracker.getAllHabitStats());

  console.log('\n--- Badges ---');
  console.log(tracker.getBadges());

  // Generate insights
  console.log('\n--- AI Insights ---');
  const insights = await tracker.generateInsights();
  console.log(insights);
}

demoProductivity();