@cccarv82/freya 1.0.45 → 1.0.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cccarv82/freya",
-  "version": "1.0.45",
+  "version": "1.0.46",
   "description": "Personal AI Assistant with local-first persistence",
   "scripts": {
     "health": "node scripts/validate-data.js",
@@ -24,6 +24,7 @@
   "files": [
     "bin",
     "cli",
+    "scripts",
     "templates",
     ".agent"
   ],

package/scripts/export-obsidian.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+function exists(p) {
+  try { fs.accessSync(p); return true; } catch { return false; }
+}
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+function readJsonOrDefault(p, def) {
+  try {
+    if (!exists(p)) return def;
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return def;
+  }
+}
+
+function slugifyFileName(s) {
+  return String(s || '')
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9\-_/ ]+/g, '')
+    .replace(/[\s]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^[-/]+|[-/]+$/g, '')
+    .slice(0, 80) || 'note';
+}
+
+function yamlEscape(v) {
+  const s = String(v == null ? '' : v);
+  // quote always for safety
+  return JSON.stringify(s);
+}
+
+function fmtTags(tags) {
+  const uniq = Array.from(new Set(tags.filter(Boolean)));
+  return '[' + uniq.map((t) => yamlEscape(t)).join(', ') + ']';
+}
+
+function writeNote(baseDir, relPathNoExt, md) {
+  const outPath = path.join(baseDir, relPathNoExt + '.md');
+  ensureDir(path.dirname(outPath));
+  fs.writeFileSync(outPath, md, 'utf8');
+  return outPath;
+}
+
+function main() {
+  const workspaceDir = path.resolve(process.cwd());
+
+  const blockersFile = path.join(workspaceDir, 'data', 'blockers', 'blocker-log.json');
+  const tasksFile = path.join(workspaceDir, 'data', 'tasks', 'task-log.json');
+
+  const blockersLog = readJsonOrDefault(blockersFile, { schemaVersion: 1, blockers: [] });
+  const tasksLog = readJsonOrDefault(tasksFile, { schemaVersion: 1, tasks: [] });
+
+  const blockers = Array.isArray(blockersLog.blockers) ? blockersLog.blockers : [];
+  const tasks = Array.isArray(tasksLog.tasks) ? tasksLog.tasks : [];
+
+  const notesRoot = path.join(workspaceDir, 'docs', 'notes');
+  ensureDir(notesRoot);
+
+  const created = [];
+
+  // Export OPEN blockers as incident notes
+  for (const b of blockers) {
+    if (!b || typeof b !== 'object') continue;
+    const status = String(b.status || '').toUpperCase();
+    if (status !== 'OPEN' && status !== 'MITIGATING') continue;
+
+    const title = String(b.title || '').trim();
+    if (!title) continue;
+
+    const projectSlug = String(b.projectSlug || '').trim();
+    const sev = String(b.severity || '').toUpperCase();
+
+    const tags = [];
+    if (projectSlug) projectSlug.split('/').forEach((p) => tags.push(p));
+    if (sev) tags.push(sev.toLowerCase());
+    tags.push('blocker');
+
+    const relBase = projectSlug ? path.join('incidents', projectSlug) : path.join('incidents', 'unclassified');
+    const fileBase = slugifyFileName(title);
+    const relPath = path.join(relBase, fileBase);
+
+    const md = [
+      '---',
+      `type: ${yamlEscape('incident')}`,
+      `id: ${yamlEscape(b.id || '')}`,
+      `title: ${yamlEscape(title)}`,
+      `status: ${yamlEscape(status)}`,
+      `severity: ${yamlEscape(sev || '')}`,
+      `projectSlug: ${yamlEscape(projectSlug)}`,
+      `createdAt: ${yamlEscape(b.createdAt || '')}`,
+      `tags: ${fmtTags(tags.map((t) => '#' + String(t).replace(/^#/, '')))}`,
+      '---',
+      '',
+      `# ${title}`,
+      '',
+      b.description ? `## Context\n${String(b.description).trim()}\n` : '',
+      b.nextAction ? `## Next action\n${String(b.nextAction).trim()}\n` : '',
+      '',
+      '## Links',
+      '- Related reports: see `docs/reports/`',
+      '- Related tasks: see `data/tasks/task-log.json`',
+      ''
+    ].filter(Boolean).join('\n');
+
+    const out = writeNote(notesRoot, relPath, md);
+    created.push(out);
+  }
+
+  // Export a daily index note (lightweight)
+  const today = new Date().toISOString().slice(0, 10);
+  const dailyNote = [
+    '---',
+    `type: ${yamlEscape('daily-index')}`,
+    `date: ${yamlEscape(today)}`,
+    '---',
+    '',
+    `# Daily Index ${today}`,
+    '',
+    '## Open blockers',
+    ...blockers
+      .filter((b) => b && (String(b.status || '').toUpperCase() === 'OPEN' || String(b.status || '').toUpperCase() === 'MITIGATING'))
+      .slice(0, 20)
+      .map((b) => {
+        const ps = b.projectSlug ? ` [${b.projectSlug}]` : '';
+        return `- ${String(b.title || '').trim()}${ps}`;
+      }),
+    '',
+    '## DO_NOW tasks',
+    ...tasks
+      .filter((t) => t && String(t.status || '').toUpperCase() === 'PENDING' && String(t.category || '') === 'DO_NOW')
+      .slice(0, 20)
+      .map((t) => {
+        const ps = t.projectSlug ? ` [${t.projectSlug}]` : '';
+        return `- [ ] ${String(t.description || '').trim()}${ps}`;
+      }),
+    ''
+  ].join('\n');
+
+  const dailyOut = writeNote(notesRoot, path.join('daily', today), dailyNote);
+  created.push(dailyOut);
+
+  process.stdout.write(JSON.stringify({ ok: true, created: created.map((p) => path.relative(workspaceDir, p).replace(/\\/g, '/')) }, null, 2) + '\n');
+}
+
+main();

package/scripts/generate-blockers-report.js

@@ -0,0 +1,215 @@
+const fs = require('fs');
+const path = require('path');
+
+const { toIsoDate, safeParseToMs, isWithinRange } = require('./lib/date-utils');
+
+const BLOCKERS_FILE = path.join(__dirname, '../data/blockers/blocker-log.json');
+const REPORT_DIR = path.join(__dirname, '../docs/reports');
+
+const SEVERITY_ORDER = {
+  CRITICAL: 0,
+  HIGH: 1,
+  MEDIUM: 2,
+  LOW: 3,
+};
+
+const RESOLVED_STATUSES = new Set(['RESOLVED', 'CLOSED', 'DONE', 'FIXED']);
+
+function normalizeStatus(blocker) {
+  const raw = blocker.status || blocker.state || blocker.currentStatus;
+  if (!raw) return 'UNKNOWN';
+  return String(raw).trim().toUpperCase();
+}
+
+function normalizeSeverity(blocker) {
+  const raw = blocker.severity || blocker.priority || blocker.level;
+  if (!raw) return 'UNSPECIFIED';
+  const value = String(raw).trim().toUpperCase();
+  if (value.includes('CRIT')) return 'CRITICAL';
+  if (value.includes('HIGH')) return 'HIGH';
+  if (value.includes('MED')) return 'MEDIUM';
+  if (value.includes('LOW')) return 'LOW';
+  return value;
+}
+
+function getCreatedAt(blocker) {
+  const candidates = [
+    blocker.createdAt,
+    blocker.created_at,
+    blocker.openedAt,
+    blocker.opened_at,
+    blocker.reportedAt,
+    blocker.reported_at,
+    blocker.date,
+    blocker.loggedAt,
+  ];
+  for (const value of candidates) {
+    const ms = safeParseToMs(value);
+    if (Number.isFinite(ms)) return ms;
+  }
+  return NaN;
+}
+
+function getResolvedAt(blocker) {
+  const candidates = [
+    blocker.resolvedAt,
+    blocker.resolved_at,
+    blocker.closedAt,
+    blocker.closed_at,
+    blocker.completedAt,
+  ];
+  for (const value of candidates) {
+    const ms = safeParseToMs(value);
+    if (Number.isFinite(ms)) return ms;
+  }
+  return NaN;
+}
+
+function isOpen(blocker) {
+  const status = normalizeStatus(blocker);
+  if (RESOLVED_STATUSES.has(status)) return false;
+  const resolvedAt = getResolvedAt(blocker);
+  return !Number.isFinite(resolvedAt);
+}
+
+function getBlockerTitle(blocker) {
+  return (
+    blocker.title ||
+    blocker.summary ||
+    blocker.description ||
+    blocker.content ||
+    blocker.text ||
+    'Untitled blocker'
+  );
+}
+
+function formatAgeDays(createdMs, nowMs) {
+  if (!Number.isFinite(createdMs)) return null;
+  const ageMs = Math.max(0, nowMs - createdMs);
+  return Math.floor(ageMs / (24 * 60 * 60 * 1000));
+}
+
+function ensureReportDir() {
+  if (!fs.existsSync(REPORT_DIR)) {
+    fs.mkdirSync(REPORT_DIR, { recursive: true });
+  }
+}
+
+function loadBlockers() {
+  if (!fs.existsSync(BLOCKERS_FILE)) {
+    return [];
+  }
+  try {
+    const raw = fs.readFileSync(BLOCKERS_FILE, 'utf8');
+    const data = JSON.parse(raw);
+    return Array.isArray(data.blockers) ? data.blockers : [];
+  } catch (err) {
+    console.error(`Error reading blockers file: ${err.message}`);
+    return [];
+  }
+}
+
+function generateReport() {
+  const now = new Date();
+  const nowMs = now.getTime();
+  const reportDate = toIsoDate(now);
+  const blockers = loadBlockers();
+
+  const statusCounts = new Map();
+  blockers.forEach(blocker => {
+    const status = normalizeStatus(blocker);
+    statusCounts.set(status, (statusCounts.get(status) || 0) + 1);
+  });
+
+  const openBlockers = blockers.filter(isOpen);
+  openBlockers.sort((a, b) => {
+    const severityA = normalizeSeverity(a);
+    const severityB = normalizeSeverity(b);
+    const rankA = SEVERITY_ORDER[severityA] ?? 99;
+    const rankB = SEVERITY_ORDER[severityB] ?? 99;
+    if (rankA !== rankB) return rankA - rankB;
+    const ageA = getCreatedAt(a);
+    const ageB = getCreatedAt(b);
+    const msA = Number.isFinite(ageA) ? ageA : Number.MAX_SAFE_INTEGER;
+    const msB = Number.isFinite(ageB) ? ageB : Number.MAX_SAFE_INTEGER;
+    return msA - msB;
+  });
+
+  const sevenDaysAgo = new Date(nowMs - 7 * 24 * 60 * 60 * 1000);
+  const resolvedRecent = blockers.filter(blocker => {
+    const resolvedAt = getResolvedAt(blocker);
+    if (!Number.isFinite(resolvedAt)) return false;
+    return isWithinRange(resolvedAt, sevenDaysAgo, now);
+  });
+  resolvedRecent.sort((a, b) => {
+    const msA = getResolvedAt(a);
+    const msB = getResolvedAt(b);
+    return msB - msA;
+  });
+
+  let report = `# Blockers Report - ${reportDate}\n\n`;
+  report += '## Summary\n';
+  report += `- Total blockers: ${blockers.length}\n`;
+  if (statusCounts.size === 0) {
+    report += '- Status counts: None\n\n';
+  } else {
+    report += '- Status counts:\n';
+    const statuses = Array.from(statusCounts.keys()).sort();
+    statuses.forEach(status => {
+      report += `  - ${status}: ${statusCounts.get(status)}\n`;
+    });
+    report += '\n';
+  }
+
+  report += '## Open Blockers\n';
+  if (openBlockers.length === 0) {
+    report += 'None.\n\n';
+  } else {
+    openBlockers.forEach(blocker => {
+      const title = getBlockerTitle(blocker);
+      const status = normalizeStatus(blocker);
+      const severity = normalizeSeverity(blocker);
+      const createdMs = getCreatedAt(blocker);
+      const createdDate = Number.isFinite(createdMs) ? toIsoDate(createdMs) : 'Unknown';
+      const ageDays = formatAgeDays(createdMs, nowMs);
+      const project = blocker.project || blocker.projectName || blocker.projectSlug;
+      const client = blocker.client || blocker.clientName || blocker.clientSlug;
+      const metaParts = [
+        `Status: ${status}`,
+        project ? `Project: ${project}` : null,
+        client ? `Client: ${client}` : null,
+        `Created: ${createdDate}`,
+        ageDays === null ? null : `Age: ${ageDays}d`,
+      ].filter(Boolean);
+      report += `- [${severity}] ${title} (${metaParts.join('; ')})\n`;
+    });
+    report += '\n';
+  }
+
+  report += '## Resolved Blockers (Last 7 Days)\n';
+  if (resolvedRecent.length === 0) {
+    report += 'None.\n';
+  } else {
+    resolvedRecent.forEach(blocker => {
+      const title = getBlockerTitle(blocker);
+      const severity = normalizeSeverity(blocker);
+      const resolvedMs = getResolvedAt(blocker);
+      const resolvedDate = Number.isFinite(resolvedMs) ? toIsoDate(resolvedMs) : 'Unknown';
+      const project = blocker.project || blocker.projectName || blocker.projectSlug;
+      const client = blocker.client || blocker.clientName || blocker.clientSlug;
+      const metaParts = [
+        project ? `Project: ${project}` : null,
+        client ? `Client: ${client}` : null,
+        `Resolved: ${resolvedDate}`,
+      ].filter(Boolean);
+      report += `- [${severity}] ${title} (${metaParts.join('; ')})\n`;
+    });
+  }
+
+  ensureReportDir();
+  const outputPath = path.join(REPORT_DIR, `blockers-${reportDate}.md`);
+  fs.writeFileSync(outputPath, report);
+  console.log(report);
+}
+
+generateReport();

package/scripts/generate-daily-summary.js

@@ -0,0 +1,107 @@
+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');
+const REPORT_DIR = path.join(__dirname, '../docs/reports');
+
+// --- 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);
+
+        // Write report file for UI (optional, but helps preview/history)
+        try {
+            fs.mkdirSync(REPORT_DIR, { recursive: true });
+            const date = new Date().toISOString().slice(0, 10);
+            const outPath = path.join(REPORT_DIR, `daily-${date}.md`);
+            fs.writeFileSync(outPath, `# Daily Summary — ${date}\n\n${summary}\n`, 'utf8');
+        } catch (e) {
+            // non-fatal
+        }
+
+    } catch (err) {
+        console.error("Error generating daily:", err.message);
+    }
+}
+
+generateDailySummary();