@cccarv82/freya 2.3.13 → 2.5.0

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

@@ -1,44 +1,34 @@
 const fs = require('fs');
 const path = require('path');
 
-const { safeParseToMs } = require('./lib/date-utils');
-const { safeReadJson, quarantineCorruptedFile } = require('./lib/fs-utils');
+const DataManager = require('./lib/DataManager');
 
-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 DATA_DIR = path.join(__dirname, '../data');
+const LOGS_DIR = path.join(__dirname, '../logs/daily');
 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;
-}
+const dm = new DataManager(DATA_DIR, LOGS_DIR);
 
 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 now = new Date();
+        const start = new Date(now);
+        start.setHours(0, 0, 0, 0); // Today 00:00
 
-        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;
-        }
+        // Custom logic for "ontem" (completed in the last 24h)
+        const ms24h = now.getTime() - (24 * 60 * 60 * 1000);
+        const { tasks, pending } = dm.getTasks(new Date(ms24h), now); // Not using the strict start boundary for recently completed
 
         let summary = "";
 
         // 1. Ontem (Completed < 24h)
-        const completedRecently = json.tasks.filter(t => t.status === "COMPLETED" && isRecentlyCompleted(t.completedAt));
+        const completedRecently = tasks.filter(t => {
+            if (t.status !== 'COMPLETED') return false;
+            const ms = dm.getCreatedAt(t) || Date.parse(t.completedAt || t.completed_at || ''); // Use native since no safeParse helper here
+            if (!Number.isFinite(ms)) return false;
+            return ms >= ms24h && ms <= now.getTime();
+        });
+
         summary += "**Ontem:** ";
         if (completedRecently.length > 0) {
             summary += completedRecently.map(t => t.description).join(", ");
@@ -48,52 +38,29 @@ function generateDailySummary() {
         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(", ");
+        if (pending.length > 0) {
+            summary += pending.map(t => t.description).join(", ");
         } else {
             summary += "Nothing planned";
         }
         summary += "\n";
 
-        // 3. Bloqueios (from blocker-log.json)
+        // 3. Bloqueios
+        const { open } = dm.getBlockers(start, now);
         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(", ");
-                }
-            }
+        if (open.length > 0) {
+            blockersLine = open.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 time = new Date().toTimeString().slice(0, 8).replace(/:/g, '');
+            const date = now.toISOString().slice(0, 10);
+            const time = now.toTimeString().slice(0, 8).replace(/:/g, '');
             const outPath = path.join(REPORT_DIR, `daily-${date}-${time}.md`);
             fs.writeFileSync(outPath, `# Daily Summary — ${date}\n\n${summary}\n`, 'utf8');
         } catch (e) {

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

@@ -9,23 +9,15 @@
 const fs = require('fs');
 const path = require('path');
 
-const { toIsoDate, isWithinRange, safeParseToMs } = require('./lib/date-utils');
-const { safeReadJson, quarantineCorruptedFile } = require('./lib/fs-utils');
+const { toIsoDate, safeParseToMs } = require('./lib/date-utils');
+const DataManager = require('./lib/DataManager');
 
 // --- 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');
-const BLOCKERS_FILE = path.join(DATA_DIR, 'blockers/blocker-log.json');
 
-const RESOLVED_STATUSES = new Set(['RESOLVED', 'CLOSED', 'DONE', 'FIXED']);
-const SEVERITY_ORDER = {
-    CRITICAL: 0,
-    HIGH: 1,
-    MEDIUM: 2,
-    LOW: 3
-};
+const dm = new DataManager(DATA_DIR, LOGS_DIR);
 
 // --- Helpers ---
 function getDateRange(period) {
@@ -53,114 +45,6 @@ function ensureDir(dir) {
     }
 }
 
-// --- 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;
-}
-
 function summarizeLogContent(content, maxLines = 3, maxChars = 280) {
     if (!content) return null;
     const lines = content
@@ -184,23 +68,6 @@ function summarizeLogContent(content, maxLines = 3, maxChars = 280) {
     return summary;
 }
 
-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 getBlockerTitle(blocker) {
     return (
         blocker.title ||
@@ -212,96 +79,18 @@ function getBlockerTitle(blocker) {
     );
 }
 
-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 loadBlockers() {
-    if (!fs.existsSync(BLOCKERS_FILE)) return [];
-    const result = safeReadJson(BLOCKERS_FILE);
-    if (!result.ok) {
-        const relativePath = path.relative(DATA_DIR, BLOCKERS_FILE);
-        if (result.error.type === 'parse') {
-            quarantineCorruptedFile(BLOCKERS_FILE, result.error.message);
-            console.warn(`⚠️ [${relativePath}] JSON parse failed; quarantined to _corrupted.`);
-        } else {
-            console.error(`Error reading blockers: ${result.error.message}`);
-        }
-        return [];
-    }
-    return Array.isArray(result.json.blockers) ? result.json.blockers : [];
-}
-
-function getBlockers(start, end) {
-    const blockers = loadBlockers();
-    const open = blockers.filter(isOpen);
-    open.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 createdA = getCreatedAt(a);
-        const createdB = getCreatedAt(b);
-        const msA = Number.isFinite(createdA) ? createdA : Number.MAX_SAFE_INTEGER;
-        const msB = Number.isFinite(createdB) ? createdB : Number.MAX_SAFE_INTEGER;
-        return msA - msB;
-    });
-
-    const openedRecent = blockers.filter(blocker => isWithinRange(getCreatedAt(blocker), start, end));
-    const resolvedRecent = blockers.filter(blocker => isWithinRange(getResolvedAt(blocker), start, end));
-
-    return { open, openedRecent, resolvedRecent };
-}
-
 // --- 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);
-    const blockers = getBlockers(start, end);
+    const tasks = dm.getTasks(start, end);
+    const projects = dm.getProjectUpdates(start, end);
+    const logs = dm.getDailyLogs(start, end);
+    const blockers = dm.getBlockers(start, end);
 
     let md = `# Relatório de Status Profissional - ${dateStr}\n`;
     md += `**Período:** ${formatDate(start)} a ${formatDate(end)}\n\n`;
@@ -346,9 +135,9 @@ function generateReport(period) {
         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 += `### ${p.client} / ${p.project}\n`;
+            md += `**Status Atual:** ${p.currentStatus}\n`;
+            if (p.events && p.events.length > 0) {
                 md += `**Atualizações Recentes:**\n`;
                 p.events.forEach(e => {
                     const typeIcon = e.type === 'Blocker' ? '🔴' : '🔹';
@@ -367,8 +156,8 @@ function generateReport(period) {
         md += `**Em aberto:**\n`;
         blockers.open.forEach(blocker => {
             const title = getBlockerTitle(blocker);
-            const severity = normalizeSeverity(blocker);
-            const createdAt = getCreatedAt(blocker);
+            const severity = dm.normalizeSeverity(blocker);
+            const createdAt = dm.getCreatedAt(blocker);
             const createdDate = Number.isFinite(createdAt) ? toIsoDate(createdAt) : 'Unknown';
             const project = blocker.project || blocker.projectName || blocker.projectSlug;
             const client = blocker.client || blocker.clientName || blocker.clientSlug;
@@ -386,7 +175,7 @@ function generateReport(period) {
         md += `\n**Resolvidos no período:**\n`;
         blockers.resolvedRecent.forEach(blocker => {
             const title = getBlockerTitle(blocker);
-            const resolvedAt = getResolvedAt(blocker);
+            const resolvedAt = dm.getResolvedAt(blocker);
             const resolvedDate = Number.isFinite(resolvedAt) ? toIsoDate(resolvedAt) : 'Unknown';
             md += `- ${title} (Resolvido: ${resolvedDate})\n`;
         });

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

@@ -1,63 +1,24 @@
 const fs = require('fs');
 const path = require('path');
 
-const { toIsoDate, safeParseToMs, isWithinRange } = require('./lib/date-utils');
-const { safeReadJson, quarantineCorruptedFile } = require('./lib/fs-utils');
+const { toIsoDate, safeParseToMs } = require('./lib/date-utils');
+const DataManager = require('./lib/DataManager');
 
 const DATA_DIR = path.join(__dirname, '../data');
+const LOGS_DIR = path.join(__dirname, '../logs/daily');
 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 };
+const dm = new DataManager(DATA_DIR, LOGS_DIR);
 
 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);
 
@@ -67,40 +28,15 @@ function generate() {
   start.setDate(now.getDate() - 7);
 
   const reportDate = toIsoDate(now);
-const reportTime = (() => { const d = new Date(); const hh = String(d.getHours()).padStart(2,'0'); const mm = String(d.getMinutes()).padStart(2,'0'); const ss = String(d.getSeconds()).padStart(2,'0'); return `${hh}${mm}${ss}`; })();
-
-  const taskLog = readJsonOrQuarantine(TASKS_FILE, { schemaVersion: 1, tasks: [] });
-  const blockersLog = readJsonOrQuarantine(BLOCKERS_FILE, { schemaVersion: 1, blockers: [] });
+  const reportTime = (() => { const d = new Date(); const hh = String(d.getHours()).padStart(2, '0'); const mm = String(d.getMinutes()).padStart(2, '0'); const ss = String(d.getSeconds()).padStart(2, '0'); return `${hh}${mm}${ss}`; })();
 
-  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 { completed: completedTasks, pending: pendingDoNow } = dm.getTasks(start, end);
+  const { open: activeBlockers, blockers } = dm.getBlockers(start, end);
 
   const upcomingDueBlockers = blockers.filter(b => {
-    const st = String(b.status || '').toUpperCase();
+    const st = dm.normalizeStatus(b);
     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);
@@ -109,25 +45,7 @@ const reportTime = (() => { const d = new Date(); const hh = String(d.getHours()
     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
-    });
-  }
+  const projectsWithUpdates = dm.getProjectUpdates(start, end);
 
   // Markdown
   let md = `# Scrum Master Weekly Report — ${reportDate}\n`;

package/templates/base/scripts/index/build-index.js

@@ -0,0 +1,13 @@
+const path = require('path');
+const { buildIndex } = require('../lib/index-utils');
+
+function main() {
+  const workspaceDir = process.cwd();
+  const result = buildIndex(workspaceDir);
+  const rel = path.relative(workspaceDir, result.indexPath).replace(/\\/g, '/');
+  console.log(`Index rebuilt: ${rel}`);
+  console.log(`Files: ${result.fileCount}`);
+  console.log(`Keys: ${result.keyCount}`);
+}
+
+main();

package/templates/base/scripts/index/update-index.js

@@ -0,0 +1,15 @@
+const path = require('path');
+const { updateIndex } = require('../lib/index-utils');
+
+function main() {
+  const workspaceDir = process.cwd();
+  const result = updateIndex(workspaceDir);
+  const rel = path.relative(workspaceDir, result.indexPath).replace(/\\/g, '/');
+  console.log(`Index updated: ${rel}`);
+  console.log(`Files: ${result.fileCount}`);
+  console.log(`Keys: ${result.keyCount}`);
+  if (typeof result.changed === 'number') console.log(`Changed: ${result.changed}`);
+  if (typeof result.removed === 'number') console.log(`Removed: ${result.removed}`);
+}
+
+main();

package/templates/base/scripts/lib/DataLayer.js

@@ -0,0 +1,92 @@
+const Database = require('better-sqlite3');
+const path = require('path');
+const fs = require('fs');
+
+class DataLayer {
+  constructor(dbPath = null) {
+    if (!dbPath) {
+      const dataDir = path.join(__dirname, '..', '..', 'data');
+      if (!fs.existsSync(dataDir)) {
+        fs.mkdirSync(dataDir, { recursive: true });
+      }
+      dbPath = path.join(dataDir, 'freya.sqlite');
+    }
+    this.db = new Database(dbPath, { verbose: console.log });
+    this.initSchema();
+  }
+
+  initSchema() {
+    // Enable Write-Ahead Logging for better concurrent performance
+    this.db.pragma('journal_mode = WAL');
+
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS projects (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        slug TEXT UNIQUE NOT NULL,
+        client TEXT,
+        name TEXT,
+        is_active BOOLEAN DEFAULT 1,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS project_status_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        project_id INTEGER NOT NULL,
+        status_text TEXT NOT NULL,
+        date DATETIME DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (project_id) REFERENCES projects (id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY, /* UUID */
+        project_slug TEXT, /* Can be null, or match projects.slug */
+        description TEXT NOT NULL,
+        category TEXT NOT NULL, /* DO_NOW, SCHEDULE, DELEGATE, IGNORE */
+        status TEXT NOT NULL, /* PENDING, COMPLETED, ARCHIVED */
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        completed_at DATETIME,
+        metadata TEXT /* JSON string for extra fields like priority, streamSlug */
+      );
+
+      CREATE TABLE IF NOT EXISTS blockers (
+        id TEXT PRIMARY KEY, /* UUID */
+        project_slug TEXT,
+        title TEXT NOT NULL,
+        severity TEXT NOT NULL, /* CRITICAL, HIGH, MEDIUM, LOW */
+        status TEXT NOT NULL, /* OPEN, MITIGATING, RESOLVED, ARCHIVED */
+        owner TEXT,
+        next_action TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        resolved_at DATETIME,
+        metadata TEXT /* JSON string */
+      );
+
+      CREATE TABLE IF NOT EXISTS daily_logs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        date TEXT UNIQUE NOT NULL, /* YYYY-MM-DD */
+        raw_markdown TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS document_embeddings (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        reference_type TEXT NOT NULL, /* 'daily_log', 'task', 'blocker' */
+        reference_id TEXT NOT NULL, 
+        chunk_index INTEGER DEFAULT 0,
+        text_chunk TEXT NOT NULL,
+        embedding BLOB NOT NULL, /* Stored as Buffer of Float32Array */
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+    `);
+  }
+
+  // Helper close method
+  close() {
+    this.db.close();
+  }
+}
+
+// Export a singleton instance by default, or the class for testing
+const defaultInstance = new DataLayer();
+module.exports = { defaultInstance, DataLayer };