@cccarv82/freya 1.0.3

package/templates/base/scripts/generate-daily-summary.js

@@ -0,0 +1,96 @@
+const fs = require('fs');
+const path = require('path');
+
+const { safeParseToMs } = require('./lib/date-utils');
+const { safeReadJson, quarantineCorruptedFile } = require('./lib/fs-utils');
+
+const TASK_LOG_PATH = path.join(__dirname, '../data/tasks/task-log.json');
+const BLOCKERS_LOG_PATH = path.join(__dirname, '../data/blockers/blocker-log.json');
+
+// --- Helper Logic ---
+const now = new Date();
+const oneDay = 24 * 60 * 60 * 1000;
+
+function isRecentlyCompleted(dateStr) {
+    const ms = safeParseToMs(dateStr);
+    if (!Number.isFinite(ms)) return false;
+    const diff = now.getTime() - ms;
+    // Consider "Yesterday" as anything completed in the last 24 hours for daily sync purposes
+    return diff >= 0 && diff <= oneDay;
+}
+
+function generateDailySummary() {
+    try {
+        if (!fs.existsSync(TASK_LOG_PATH)) {
+            console.log("**Ontem:** No task log found.\n**Hoje:** Set up task log.\n**Bloqueios:** None");
+            return;
+        }
+
+        const content = fs.readFileSync(TASK_LOG_PATH, 'utf8');
+        const json = JSON.parse(content);
+        
+        if (!json.tasks) {
+            console.log("**Ontem:** Invalid task log.\n**Hoje:** Fix task log.\n**Bloqueios:** None");
+            return;
+        }
+
+        let summary = "";
+
+        // 1. Ontem (Completed < 24h)
+        const completedRecently = json.tasks.filter(t => t.status === "COMPLETED" && isRecentlyCompleted(t.completedAt));
+        summary += "**Ontem:** ";
+        if (completedRecently.length > 0) {
+            summary += completedRecently.map(t => t.description).join(", ");
+        } else {
+            summary += "Nothing recorded";
+        }
+        summary += "\n";
+
+        // 2. Hoje (DO_NOW + PENDING)
+        const doNow = json.tasks.filter(t => t.status === "PENDING" && t.category === "DO_NOW");
+        summary += "**Hoje:** ";
+        if (doNow.length > 0) {
+            summary += doNow.map(t => t.description).join(", ");
+        } else {
+            summary += "Nothing planned";
+        }
+        summary += "\n";
+
+        // 3. Bloqueios (from blocker-log.json)
+        let blockersLine = "None";
+        if (fs.existsSync(BLOCKERS_LOG_PATH)) {
+            const res = safeReadJson(BLOCKERS_LOG_PATH);
+            if (!res.ok) {
+                if (res.error.type === 'parse') {
+                    quarantineCorruptedFile(BLOCKERS_LOG_PATH, res.error.message);
+                }
+            } else {
+                const blockers = (res.json.blockers || []).filter(b => {
+                    const st = (b.status || '').toUpperCase();
+                    return st === 'OPEN' || st === 'MITIGATING';
+                });
+                const sevOrder = { CRITICAL: 0, HIGH: 1, MEDIUM: 2, LOW: 3 };
+                blockers.sort((a, b) => {
+                    const sa = sevOrder[(a.severity || '').toUpperCase()] ?? 99;
+                    const sb = sevOrder[(b.severity || '').toUpperCase()] ?? 99;
+                    if (sa !== sb) return sa - sb;
+                    const ta = safeParseToMs(a.createdAt) || 0;
+                    const tb = safeParseToMs(b.createdAt) || 0;
+                    return ta - tb; // older first
+                });
+                if (blockers.length > 0) {
+                    blockersLine = blockers.slice(0, 3).map(b => b.title || b.description || b.id).join(", ");
+                }
+            }
+        }
+
+        summary += `**Bloqueios:** ${blockersLine}`;
+
+        console.log(summary);
+
+    } catch (err) {
+        console.error("Error generating daily:", err.message);
+    }
+}
+
+generateDailySummary();

package/templates/base/scripts/generate-executive-report.js

@@ -0,0 +1,240 @@
+/**
+ * generate-executive-report.js
+ * Generates a professional Markdown status report (Daily/Weekly)
+ * aggregating Tasks, Project Updates, and Daily Logs.
+ * 
+ * Usage: node scripts/generate-executive-report.js --period [daily|weekly]
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { toIsoDate, isWithinRange } = require('./lib/date-utils');
+const { safeReadJson, quarantineCorruptedFile } = require('./lib/fs-utils');
+
+// --- Configuration ---
+const DATA_DIR = path.join(__dirname, '../data');
+const LOGS_DIR = path.join(__dirname, '../logs/daily');
+const OUTPUT_DIR = path.join(__dirname, '../docs/reports');
+const TASKS_FILE = path.join(DATA_DIR, 'tasks/task-log.json');
+
+// --- Helpers ---
+function getDateRange(period) {
+    const today = new Date();
+    const end = new Date(today);
+    const start = new Date(today);
+
+    if (period === 'weekly') {
+        // Last 7 days
+        start.setDate(today.getDate() - 7);
+    } else {
+        // Daily: Start of today (00:00 local time) to now.
+        start.setHours(0, 0, 0, 0);
+    }
+    return { start, end };
+}
+
+function formatDate(date) {
+    return toIsoDate(date);
+}
+
+function ensureDir(dir) {
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+
+// --- Data Fetching ---
+
+function getTasks(start, end) {
+    if (!fs.existsSync(TASKS_FILE)) return { completed: [], pending: [], blockers: [] };
+    
+    const result = safeReadJson(TASKS_FILE);
+    if (!result.ok) {
+        const relativePath = path.relative(DATA_DIR, TASKS_FILE);
+        if (result.error.type === 'parse') {
+            quarantineCorruptedFile(TASKS_FILE, result.error.message);
+            console.warn(`⚠️ [${relativePath}] JSON parse failed; quarantined to _corrupted.`);
+        } else {
+            console.error(`Error reading tasks: ${result.error.message}`);
+        }
+        return { completed: [], pending: [] };
+    }
+
+    const tasks = result.json.tasks || [];
+
+    const completed = tasks.filter(t => {
+        if (t.status !== 'COMPLETED' || !t.completedAt) return false;
+        return isWithinRange(t.completedAt, start, end);
+    });
+
+    const pending = tasks.filter(t => t.status === 'PENDING' && t.category === 'DO_NOW');
+    
+    // "Blockers" could be tasks tagged as such or implicit in status? 
+    // For now, we don't have explicit blocker task type, but we can look for high priority or specific keywords if we wanted.
+    // Let's stick to simple PENDING DO_NOW for Next Steps.
+    
+    return { completed, pending };
+}
+
+function getProjectUpdates(start, end) {
+    const clientsDir = path.join(DATA_DIR, 'Clients');
+    if (!fs.existsSync(clientsDir)) return [];
+
+    const updates = [];
+
+    function scan(dir) {
+        const files = fs.readdirSync(dir);
+        for (const file of files) {
+            const fullPath = path.join(dir, file);
+            const stat = fs.statSync(fullPath);
+
+            if (stat.isDirectory()) {
+                if (file === '_corrupted') {
+                    continue;
+                }
+                scan(fullPath);
+            } else if (file === 'status.json') {
+                const result = safeReadJson(fullPath);
+                if (!result.ok) {
+                    const relativePath = path.relative(DATA_DIR, fullPath);
+                    if (result.error.type === 'parse') {
+                        quarantineCorruptedFile(fullPath, result.error.message);
+                        console.warn(`⚠️ [${relativePath}] JSON parse failed; quarantined to _corrupted.`);
+                    } else {
+                        console.error(`Error reading ${relativePath}: ${result.error.message}`);
+                    }
+                    continue;
+                }
+
+                const project = result.json;
+                
+                // Filter history
+                const recentEvents = (project.history || []).filter(h => {
+                    return isWithinRange(h.date || h.timestamp, start, end); // Support both formats if they vary
+                });
+
+                if (recentEvents.length > 0 || project.currentStatus) {
+                    updates.push({
+                        name: project.project || path.basename(path.dirname(fullPath)),
+                        client: project.client || path.basename(path.dirname(path.dirname(fullPath))),
+                        status: project.currentStatus,
+                        events: recentEvents
+                    });
+                }
+            }
+        }
+    }
+
+    scan(clientsDir);
+    return updates;
+}
+
+function getDailyLogs(start, end) {
+    if (!fs.existsSync(LOGS_DIR)) return [];
+
+    const relevantLogs = [];
+    const files = fs.readdirSync(LOGS_DIR);
+
+    for (const file of files) {
+        if (!file.endsWith('.md')) continue;
+        const dateStr = file.replace('.md', '');
+        // The filenames are YYYY-MM-DD. Compare as ISO dates to avoid timezone parsing drift.
+        const startIso = formatDate(start);
+        const endIso = formatDate(end);
+        if (dateStr >= startIso && dateStr <= endIso) {
+            try {
+                const content = fs.readFileSync(path.join(LOGS_DIR, file), 'utf8');
+                relevantLogs.push({ date: dateStr, content });
+            } catch (e) {}
+        }
+    }
+    return relevantLogs;
+}
+
+// --- Report Generation ---
+
+function generateReport(period) {
+    const { start, end } = getDateRange(period);
+    const dateStr = formatDate(new Date());
+    
+    console.log(`Generating ${period} report for ${formatDate(start)} to ${formatDate(end)}...`);
+
+    const tasks = getTasks(start, end);
+    const projects = getProjectUpdates(start, end);
+    // const logs = getDailyLogs(start, end); // Maybe too verbose to include raw logs, let's stick to summarized data
+
+    let md = `# Relatório de Status Profissional - ${dateStr}\n`;
+    md += `**Período:** ${formatDate(start)} a ${formatDate(end)}\n\n`;
+
+    // 1. Resumo Executivo (Placeholder logic)
+    md += `## 📋 Resumo Executivo\n`;
+    const totalDone = tasks.completed.length;
+    const activeProjects = projects.length;
+    md += `Neste período, foram concluídas **${totalDone}** entregas focais. Atualmente há **${activeProjects}** projetos com atualizações recentes.\n\n`;
+
+    // 2. Principais Entregas
+    md += `## ✅ Principais Entregas\n`;
+    if (tasks.completed.length === 0) {
+        md += `*Nenhuma entrega registrada no período.*\n`;
+    } else {
+        tasks.completed.forEach(t => {
+            const projectTag = t.projectSlug ? `\`[${t.projectSlug}]\`` : '';
+            md += `- ${projectTag} ${t.description}\n`;
+        });
+    }
+    md += `\n`;
+
+    // 3. Status dos Projetos
+    md += `## 🏗️ Status dos Projetos\n`;
+    if (projects.length === 0) {
+        md += `*Sem atualizações de projeto recentes.*\n`;
+    } else {
+        projects.forEach(p => {
+            md += `### ${p.client} / ${p.name}\n`;
+            md += `**Status Atual:** ${p.status}\n`;
+            if (p.events.length > 0) {
+                md += `**Atualizações Recentes:**\n`;
+                p.events.forEach(e => {
+                    const typeIcon = e.type === 'Blocker' ? '🔴' : '🔹';
+                    md += `- ${typeIcon} [${e.date}] ${e.content}\n`;
+                });
+            }
+            md += `\n`;
+        });
+    }
+
+    // 4. Próximos Passos
+    md += `## 🚀 Próximos Passos\n`;
+    if (tasks.pending.length === 0) {
+        md += `*Sem itens prioritários na fila.*\n`;
+    } else {
+        tasks.pending.forEach(t => {
+            const projectTag = t.projectSlug ? `\`[${t.projectSlug}]\`` : '';
+            md += `- [ ] ${projectTag} ${t.description}\n`;
+        });
+    }
+    md += `\n`;
+
+    // Save
+    ensureDir(OUTPUT_DIR);
+    const filename = `report-${period}-${dateStr}.md`;
+    const outputPath = path.join(OUTPUT_DIR, filename);
+    fs.writeFileSync(outputPath, md, 'utf8');
+
+    console.log(`Report generated successfully: ${outputPath}`);
+    console.log(`\n--- SUMMARY PREVIEW ---\n`);
+    console.log(md.substring(0, 500) + "...");
+}
+
+// --- Main ---
+const args = process.argv.slice(2);
+const periodIdx = args.indexOf('--period');
+const period = periodIdx !== -1 ? args[periodIdx + 1] : 'daily';
+
+if (!['daily', 'weekly'].includes(period)) {
+    console.error("Invalid period. Use 'daily' or 'weekly'.");
+    process.exit(1);
+}
+
+generateReport(period);

package/templates/base/scripts/generate-sm-weekly-report.js

@@ -0,0 +1,207 @@
+const fs = require('fs');
+const path = require('path');
+
+const { toIsoDate, safeParseToMs, isWithinRange } = require('./lib/date-utils');
+const { safeReadJson, quarantineCorruptedFile } = require('./lib/fs-utils');
+
+const DATA_DIR = path.join(__dirname, '../data');
+const REPORT_DIR = path.join(__dirname, '../docs/reports');
+
+const TASKS_FILE = path.join(DATA_DIR, 'tasks/task-log.json');
+const BLOCKERS_FILE = path.join(DATA_DIR, 'blockers/blocker-log.json');
+const CLIENTS_DIR = path.join(DATA_DIR, 'Clients');
+
+const SEV_ORDER = { CRITICAL: 0, HIGH: 1, MEDIUM: 2, LOW: 3 };
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function readJsonOrQuarantine(filePath, fallback) {
+  if (!fs.existsSync(filePath)) return fallback;
+  const res = safeReadJson(filePath);
+  if (!res.ok) {
+    if (res.error.type === 'parse') {
+      quarantineCorruptedFile(filePath, res.error.message);
+      console.warn(`⚠️ JSON parse failed; quarantined: ${filePath}`);
+    } else {
+      console.warn(`⚠️ JSON read failed: ${filePath}: ${res.error.message}`);
+    }
+    return fallback;
+  }
+  return res.json;
+}
+
+function daysBetweenMs(aMs, bMs) {
+  const diff = Math.max(0, bMs - aMs);
+  return Math.floor(diff / (24 * 60 * 60 * 1000));
+}
+
+function scanProjectStatusFiles() {
+  const results = [];
+  if (!fs.existsSync(CLIENTS_DIR)) return results;
+
+  const clients = fs.readdirSync(CLIENTS_DIR);
+  for (const clientSlug of clients) {
+    const clientPath = path.join(CLIENTS_DIR, clientSlug);
+    if (!fs.statSync(clientPath).isDirectory()) continue;
+
+    const projects = fs.readdirSync(clientPath);
+    for (const projectSlug of projects) {
+      const projectPath = path.join(clientPath, projectSlug);
+      if (!fs.statSync(projectPath).isDirectory()) continue;
+
+      const statusPath = path.join(projectPath, 'status.json');
+      if (fs.existsSync(statusPath)) results.push(statusPath);
+    }
+  }
+  return results;
+}
+
+function generate() {
+  ensureDir(REPORT_DIR);
+
+  const now = new Date();
+  const end = now;
+  const start = new Date(now);
+  start.setDate(now.getDate() - 7);
+
+  const reportDate = toIsoDate(now);
+
+  const taskLog = readJsonOrQuarantine(TASKS_FILE, { schemaVersion: 1, tasks: [] });
+  const blockersLog = readJsonOrQuarantine(BLOCKERS_FILE, { schemaVersion: 1, blockers: [] });
+
+  const tasks = taskLog.tasks || [];
+  const blockers = blockersLog.blockers || [];
+
+  const completedTasks = tasks.filter(t => {
+    if (t.status !== 'COMPLETED') return false;
+    return isWithinRange(t.completedAt || t.completed_at, start, end);
+  });
+
+  const pendingDoNow = tasks.filter(t => t.status === 'PENDING' && t.category === 'DO_NOW');
+
+  const activeBlockers = blockers.filter(b => {
+    const st = String(b.status || '').toUpperCase();
+    return st === 'OPEN' || st === 'MITIGATING';
+  });
+
+  activeBlockers.sort((a, b) => {
+    const sa = SEV_ORDER[String(a.severity || '').toUpperCase()] ?? 99;
+    const sb = SEV_ORDER[String(b.severity || '').toUpperCase()] ?? 99;
+    if (sa !== sb) return sa - sb;
+    const ta = safeParseToMs(a.createdAt) || 0;
+    const tb = safeParseToMs(b.createdAt) || 0;
+    return ta - tb; // older first
+  });
+
+  const upcomingDueBlockers = blockers.filter(b => {
+    const st = String(b.status || '').toUpperCase();
+    if (st !== 'OPEN') return false;
+    if (!b.dueDate) return false;
+    // dueDate is an ISO date; treat as UTC midnight
+    const dueMs = safeParseToMs(String(b.dueDate));
+    if (!Number.isFinite(dueMs)) return false;
+    const due = new Date(dueMs);
+    const soonEnd = new Date(now);
+    soonEnd.setDate(now.getDate() + 7);
+    return due >= now && due <= soonEnd;
+  });
+
+  // Projects
+  const statusFiles = scanProjectStatusFiles();
+  const projectsWithUpdates = [];
+
+  for (const statusPath of statusFiles) {
+    const proj = readJsonOrQuarantine(statusPath, null);
+    if (!proj) continue;
+
+    const history = Array.isArray(proj.history) ? proj.history : [];
+    const recent = history.filter(h => isWithinRange(h.date || h.timestamp, start, end));
+    if (recent.length === 0) continue;
+
+    projectsWithUpdates.push({
+      client: proj.client || path.basename(path.dirname(path.dirname(statusPath))),
+      project: proj.project || path.basename(path.dirname(statusPath)),
+      currentStatus: proj.currentStatus,
+      recent
+    });
+  }
+
+  // Markdown
+  let md = `# Scrum Master Weekly Report — ${reportDate}\n`;
+  md += `**Período:** ${toIsoDate(start)} a ${toIsoDate(end)}\n\n`;
+
+  md += `## Summary\n`;
+  md += `- Completed tasks (7d): **${completedTasks.length}**\n`;
+  md += `- Active blockers (OPEN/MITIGATING): **${activeBlockers.length}**\n`;
+  md += `- Projects updated (7d): **${projectsWithUpdates.length}**\n\n`;
+
+  md += `## Wins\n`;
+  if (completedTasks.length === 0) {
+    md += `No completed tasks recorded in the last 7 days.\n\n`;
+  } else {
+    completedTasks.forEach(t => {
+      md += `- ${t.description}\n`;
+    });
+    md += `\n`;
+  }
+
+  md += `## Blockers & Risks\n`;
+  if (activeBlockers.length === 0) {
+    md += `None.\n\n`;
+  } else {
+    activeBlockers.forEach(b => {
+      const createdMs = safeParseToMs(b.createdAt) || Date.now();
+      const agingDays = daysBetweenMs(createdMs, Date.now());
+      const sev = String(b.severity || '').toUpperCase();
+      const st = String(b.status || '').toUpperCase();
+      const owner = b.owner ? `; owner: ${b.owner}` : '';
+      const proj = b.projectSlug ? `; project: ${b.projectSlug}` : '';
+      const next = b.nextAction ? `; next: ${b.nextAction}` : '';
+      md += `- [${sev}/${st}] ${b.title} (aging: ${agingDays}d${owner}${proj}${next})\n`;
+    });
+    md += `\n`;
+  }
+
+  md += `## Project Updates\n`;
+  if (projectsWithUpdates.length === 0) {
+    md += `No project updates found in the last 7 days.\n\n`;
+  } else {
+    projectsWithUpdates.forEach(p => {
+      md += `### ${p.client} / ${p.project}\n`;
+      if (p.currentStatus) md += `**Status:** ${p.currentStatus}\n`;
+      p.recent.forEach(e => {
+        md += `- [${e.date || e.timestamp}] ${e.content || ''}\n`;
+      });
+      md += `\n`;
+    });
+  }
+
+  md += `## Next Week Focus\n`;
+  if (pendingDoNow.length === 0 && upcomingDueBlockers.length === 0) {
+    md += `No DO_NOW tasks or due-soon blockers found.\n`;
+  } else {
+    if (pendingDoNow.length > 0) {
+      md += `### DO_NOW Tasks\n`;
+      pendingDoNow.forEach(t => {
+        md += `- [ ] ${t.description}\n`;
+      });
+      md += `\n`;
+    }
+    if (upcomingDueBlockers.length > 0) {
+      md += `### Blockers due soon (next 7 days)\n`;
+      upcomingDueBlockers.forEach(b => {
+        md += `- [${String(b.severity || '').toUpperCase()}] ${b.title} (due: ${b.dueDate})\n`;
+      });
+      md += `\n`;
+    }
+  }
+
+  const outPath = path.join(REPORT_DIR, `sm-weekly-${reportDate}.md`);
+  fs.writeFileSync(outPath, md, 'utf8');
+  console.log(md);
+  console.log(`\nSaved: ${outPath}`);
+}
+
+generate();

package/templates/base/scripts/generate-weekly-report.js

@@ -0,0 +1,134 @@
+const fs = require('fs');
+const path = require('path');
+
+const { toIsoDate, isWithinRange } = require('./lib/date-utils');
+
+const DATA_DIR = path.join(__dirname, '../data');
+const REPORT_DIR = path.join(__dirname, '../docs/reports');
+
+// Ensure output dir exists
+if (!fs.existsSync(REPORT_DIR)) {
+    fs.mkdirSync(REPORT_DIR, { recursive: true });
+}
+
+// --- Date Logic ---
+const now = new Date();
+const oneDay = 24 * 60 * 60 * 1000;
+
+function isWithinWeek(dateStr) {
+    const sevenDaysAgo = new Date(now.getTime() - (7 * oneDay));
+    return isWithinRange(dateStr, sevenDaysAgo, now);
+}
+
+function getFormattedDate() {
+    return toIsoDate(now);
+}
+
+// --- File Walking ---
+function walk(dir, fileList = []) {
+    const files = fs.readdirSync(dir);
+    files.forEach(file => {
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+            walk(filePath, fileList);
+        } else {
+            if (path.extname(file) === '.json') {
+                fileList.push(filePath);
+            }
+        }
+    });
+    return fileList;
+}
+
+// --- Aggregation ---
+function generateWeeklyReport() {
+    const files = walk(DATA_DIR);
+    
+    const projects = [];
+    let taskLog = { schemaVersion: 1, tasks: [] };
+    let careerLog = { entries: [] };
+
+    // 1. Collect Data
+    files.forEach(file => {
+        try {
+            const content = fs.readFileSync(file, 'utf8');
+            const json = JSON.parse(content);
+
+            if (file.endsWith('task-log.json')) {
+                taskLog = json;
+            } else if (file.endsWith('career-log.json')) {
+                careerLog = json;
+            } else if (file.endsWith('status.json')) {
+                projects.push(json);
+            }
+        } catch (err) {
+            console.error(`Error reading ${file}: ${err.message}`);
+        }
+    });
+
+    // 2. Generate Content
+    const reportDate = getFormattedDate();
+    let report = `# Weekly Report - ${reportDate}\n\n`;
+
+    // Projects
+    report += "## 🚀 Project Updates\n";
+    let hasProjectUpdates = false;
+    projects.forEach(p => {
+        if (p.history && Array.isArray(p.history)) {
+            const recentUpdates = p.history.filter(h => isWithinWeek(h.date));
+            if (recentUpdates.length > 0) {
+                hasProjectUpdates = true;
+                report += `### ${p.client} - ${p.project}\n`;
+                recentUpdates.forEach(u => {
+                    const dateStr = u.date ? u.date.split('T')[0] : 'Unknown Date';
+                    report += `- **${dateStr}**: ${u.content}\n`;
+                });
+                report += "\n";
+            }
+        }
+    });
+    if (!hasProjectUpdates) report += "No project updates recorded this week.\n\n";
+
+    // Tasks
+    report += "## ✅ Completed Tasks\n";
+    if (taskLog.tasks && Array.isArray(taskLog.tasks)) {
+        const recentTasks = taskLog.tasks.filter(t => t.status === "COMPLETED" && isWithinWeek(t.completedAt));
+        if (recentTasks.length > 0) {
+            recentTasks.forEach(t => {
+                report += `- ${t.description}\n`;
+            });
+        } else {
+            report += "No tasks completed this week.\n";
+        }
+    } else {
+        report += "No task log found.\n";
+    }
+    report += "\n";
+
+    // Career
+    report += "## 🌟 Career Highlights\n";
+    if (careerLog.entries && Array.isArray(careerLog.entries)) {
+        const recentCareer = careerLog.entries.filter(e => isWithinWeek(e.date));
+        if (recentCareer.length > 0) {
+            recentCareer.forEach(e => {
+                report += `- **[${e.type}]**: ${e.description}\n`;
+            });
+        } else {
+            report += "No career updates this week.\n";
+        }
+    } else {
+        report += "No career log found.\n";
+    }
+
+    // 3. Save and Output
+    const outputPath = path.join(REPORT_DIR, `weekly-${reportDate}.md`);
+    fs.writeFileSync(outputPath, report);
+    
+    console.log(`✅ Report generated at: ${outputPath}`);
+    console.log("---------------------------------------------------");
+    console.log(report);
+    console.log("---------------------------------------------------");
+}
+
+generateWeeklyReport();