@cccarv82/freya 1.0.3

package/templates/base/scripts/lib/date-utils.js

@@ -0,0 +1,37 @@
+// scripts/lib/date-utils.js
+// Small, dependency-free helpers to keep date handling consistent.
+
+function toIsoDate(date) {
+  return new Date(date).toISOString().slice(0, 10);
+}
+
+function safeParseToMs(value) {
+  if (!value) return NaN;
+  if (typeof value === 'number') return value;
+
+  // Handle common case: YYYY-MM-DD (from filenames)
+  if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+    // Interpret as UTC midnight for consistency.
+    return Date.parse(`${value}T00:00:00.000Z`);
+  }
+
+  // Prefer explicit UTC if missing timezone.
+  // If string already contains Z or an offset (+/-HH:MM), keep as-is.
+  if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T/.test(value) && !/[zZ]|[+-]\d{2}:?\d{2}$/.test(value)) {
+    return Date.parse(`${value}Z`);
+  }
+
+  return Date.parse(value);
+}
+
+function isWithinRange(dateValue, start, end) {
+  const ms = safeParseToMs(dateValue);
+  if (!Number.isFinite(ms)) return false;
+  return ms >= start.getTime() && ms <= end.getTime();
+}
+
+module.exports = {
+  toIsoDate,
+  safeParseToMs,
+  isWithinRange,
+};

package/templates/base/scripts/lib/fs-utils.js

@@ -0,0 +1,61 @@
+const fs = require('fs');
+const path = require('path');
+
+function safeReadJson(filePath) {
+  let content;
+  try {
+    content = fs.readFileSync(filePath, 'utf8');
+  } catch (error) {
+    return { ok: false, error: { type: 'read', message: error.message, cause: error } };
+  }
+
+  try {
+    const json = JSON.parse(content);
+    return { ok: true, json };
+  } catch (error) {
+    return { ok: false, error: { type: 'parse', message: error.message, cause: error } };
+  }
+}
+
+function timestampForFilename(date = new Date()) {
+  return date.toISOString().replace(/[:.]/g, '-');
+}
+
+function quarantineCorruptedFile(filePath, reason) {
+  const dir = path.dirname(filePath);
+  const corruptedDir = path.join(dir, '_corrupted');
+  if (!fs.existsSync(corruptedDir)) {
+    fs.mkdirSync(corruptedDir, { recursive: true });
+  }
+
+  const parsed = path.parse(filePath);
+  const timestamp = timestampForFilename();
+  const quarantinedName = `${parsed.name}-${timestamp}${parsed.ext}`;
+  const quarantinedPath = path.join(corruptedDir, quarantinedName);
+
+  try {
+    fs.renameSync(filePath, quarantinedPath);
+  } catch (error) {
+    fs.copyFileSync(filePath, quarantinedPath);
+    fs.unlinkSync(filePath);
+  }
+
+  const notePath = `${quarantinedPath}.md`;
+  const note = [
+    '# Quarantined JSON',
+    '',
+    `- Original: ${filePath}`,
+    `- Quarantined: ${quarantinedPath}`,
+    `- Timestamp: ${new Date().toISOString()}`,
+    `- Reason: ${reason || 'Unknown JSON parse error'}`
+  ].join('\n');
+
+  fs.writeFileSync(notePath, note, 'utf8');
+
+  return { quarantinedPath, notePath };
+}
+
+module.exports = {
+  safeReadJson,
+  quarantineCorruptedFile
+};

package/templates/base/scripts/migrate-data.js

@@ -0,0 +1,80 @@
+const fs = require('fs');
+const path = require('path');
+
+const { safeReadJson, quarantineCorruptedFile } = require('./lib/fs-utils');
+
+const DATA_DIR = process.env.DATA_DIR
+  ? path.resolve(process.env.DATA_DIR)
+  : path.join(__dirname, '../data');
+
+const KNOWN_FILES = [
+  { relPath: path.join('tasks', 'task-log.json'), label: 'tasks/task-log.json' },
+  { relPath: path.join('career', 'career-log.json'), label: 'career/career-log.json' },
+  { relPath: path.join('blockers', 'blocker-log.json'), label: 'blockers/blocker-log.json' }
+];
+
+function atomicWriteJson(filePath, json) {
+  const dir = path.dirname(filePath);
+  const tmpName = `.${path.basename(filePath)}.tmp-${process.pid}-${Date.now()}`;
+  const tmpPath = path.join(dir, tmpName);
+  fs.writeFileSync(tmpPath, JSON.stringify(json, null, 2), 'utf8');
+  fs.renameSync(tmpPath, filePath);
+}
+
+function migrateFile(filePath, label, summary) {
+  if (!fs.existsSync(filePath)) {
+    summary.missing.push(label);
+    return;
+  }
+
+  const res = safeReadJson(filePath);
+  if (!res.ok) {
+    if (res.error.type === 'parse') {
+      quarantineCorruptedFile(filePath, res.error.message);
+      summary.quarantined.push(label);
+    } else {
+      summary.skipped.push(label);
+    }
+    return;
+  }
+
+  const json = res.json;
+  if (!json || typeof json !== 'object' || Array.isArray(json)) {
+    summary.skipped.push(label);
+    return;
+  }
+
+  if (json.schemaVersion === undefined) {
+    json.schemaVersion = 1;
+    atomicWriteJson(filePath, json);
+    summary.updated.push(label);
+  } else {
+    summary.already.push(label);
+  }
+}
+
+function run() {
+  const summary = {
+    updated: [],
+    already: [],
+    missing: [],
+    quarantined: [],
+    skipped: []
+  };
+
+  KNOWN_FILES.forEach(({ relPath, label }) => {
+    const filePath = path.join(DATA_DIR, relPath);
+    migrateFile(filePath, label, summary);
+  });
+
+  const parts = [];
+  parts.push(`updated ${summary.updated.length}`);
+  if (summary.updated.length) parts.push(`updated files: ${summary.updated.join(', ')}`);
+  if (summary.quarantined.length) parts.push(`quarantined ${summary.quarantined.length}`);
+  if (summary.missing.length) parts.push(`missing ${summary.missing.length}`);
+  if (summary.skipped.length) parts.push(`skipped ${summary.skipped.length}`);
+
+  console.log(`Migration summary: ${parts.join('; ')}`);
+}
+
+run();

package/templates/base/scripts/validate-data.js

@@ -0,0 +1,206 @@
+const fs = require('fs');
+const path = require('path');
+
+const { safeReadJson, quarantineCorruptedFile } = require('./lib/fs-utils');
+
+const DATA_DIR = path.join(__dirname, '../data');
+
+// --- Validation Helpers ---
+
+function validateTaskLog(json, file) {
+  const errors = [];
+  if (json.schemaVersion !== undefined && typeof json.schemaVersion !== 'number') {
+    errors.push("Root must have numeric 'schemaVersion' when present.");
+  }
+  if (!Array.isArray(json.tasks)) {
+    errors.push(`Root must have 'tasks' array.`);
+    return errors;
+  }
+
+  json.tasks.forEach((task, index) => {
+    if (!task.id) errors.push(`Task[${index}] missing 'id'.`);
+    if (!task.description) errors.push(`Task[${index}] missing 'description'.`);
+    if (!task.category) errors.push(`Task[${index}] missing 'category'.`);
+    if (!task.status) errors.push(`Task[${index}] missing 'status'.`);
+    if (!task.createdAt) errors.push(`Task[${index}] missing 'createdAt'.`);
+
+    const validCategories = ['DO_NOW', 'SCHEDULE', 'DELEGATE', 'IGNORE'];
+    if (task.category && !validCategories.includes(task.category)) {
+        errors.push(`Task[${index}] invalid category '${task.category}'.`);
+    }
+
+    const validStatuses = ['PENDING', 'COMPLETED', 'ARCHIVED'];
+    if (task.status && !validStatuses.includes(task.status)) {
+        errors.push(`Task[${index}] invalid status '${task.status}'.`);
+    }
+  });
+
+  return errors;
+}
+
+function validateCareerLog(json, file) {
+  const errors = [];
+  if (json.schemaVersion !== undefined && typeof json.schemaVersion !== 'number') {
+    errors.push("Root must have numeric 'schemaVersion' when present.");
+  }
+  if (!Array.isArray(json.entries)) {
+    errors.push(`Root must have 'entries' array.`);
+    return errors;
+  }
+
+  json.entries.forEach((entry, index) => {
+    if (!entry.id) errors.push(`Entry[${index}] missing 'id'.`);
+    if (!entry.date) errors.push(`Entry[${index}] missing 'date'.`);
+    if (!entry.type) errors.push(`Entry[${index}] missing 'type'.`);
+    if (!entry.description) errors.push(`Entry[${index}] missing 'description'.`);
+
+    const validTypes = ['Achievement', 'Feedback', 'Certification', 'Goal'];
+    if (entry.type && !validTypes.includes(entry.type)) {
+        errors.push(`Entry[${index}] invalid type '${entry.type}'.`);
+    }
+  });
+
+  return errors;
+}
+
+function validateProjectStatus(json, file) {
+  const errors = [];
+  const requiredFields = ['client', 'project', 'active', 'currentStatus', 'lastUpdated', 'history'];
+  
+  requiredFields.forEach(field => {
+      if (json[field] === undefined) errors.push(`Missing field '${field}'.`);
+  });
+
+  if (Array.isArray(json.history)) {
+      json.history.forEach((item, index) => {
+          if (!item.date) errors.push(`History[${index}] missing 'date'.`);
+          if (!item.type) errors.push(`History[${index}] missing 'type'.`);
+          if (!item.content) errors.push(`History[${index}] missing 'content'.`);
+      });
+  } else if (json.history !== undefined) {
+      errors.push(`'history' must be an array.`);
+  }
+
+  return errors;
+}
+
+function validateBlockerLog(json, file) {
+  const errors = [];
+  if (typeof json.schemaVersion !== 'number') {
+    errors.push("Root must have numeric 'schemaVersion'.");
+  }
+  if (!Array.isArray(json.blockers)) {
+    errors.push("Root must have 'blockers' array.");
+    return errors;
+  }
+
+  const validStatuses = ['OPEN', 'MITIGATING', 'RESOLVED'];
+  const validSeverities = ['LOW', 'MEDIUM', 'HIGH', 'CRITICAL'];
+
+  json.blockers.forEach((b, i) => {
+    const prefix = `Blocker[${i}]`;
+    if (!b.id) errors.push(`${prefix} missing 'id'.`);
+    if (!b.title) errors.push(`${prefix} missing 'title'.`);
+    if (!b.description) errors.push(`${prefix} missing 'description'.`);
+    if (!b.createdAt) errors.push(`${prefix} missing 'createdAt'.`);
+    if (!b.status) errors.push(`${prefix} missing 'status'.`);
+    if (!b.severity) errors.push(`${prefix} missing 'severity'.`);
+
+    if (b.status && !validStatuses.includes(String(b.status).toUpperCase())) {
+      errors.push(`${prefix} invalid status '${b.status}'.`);
+    }
+    if (b.severity && !validSeverities.includes(String(b.severity).toUpperCase())) {
+      errors.push(`${prefix} invalid severity '${b.severity}'.`);
+    }
+  });
+
+  return errors;
+}
+
+// --- Main Logic ---
+
+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()) {
+      if (file === '_corrupted') {
+        return;
+      }
+      walk(filePath, fileList);
+    } else {
+      if (path.extname(file) === '.json') {
+        fileList.push(filePath);
+      }
+    }
+  });
+  return fileList;
+}
+
+function validateData() {
+  console.log('🔍 Starting validation...');
+  try {
+    if (!fs.existsSync(DATA_DIR)) {
+      console.error('❌ Data directory not found:', DATA_DIR);
+      process.exit(1);
+    }
+
+    const files = walk(DATA_DIR);
+    console.log(`Found ${files.length} json files.`);
+    
+    let errorCount = 0;
+
+    files.forEach(file => {
+        const relativePath = path.relative(DATA_DIR, file);
+        const result = safeReadJson(file);
+        if (!result.ok) {
+            if (result.error.type === 'parse') {
+                quarantineCorruptedFile(file, result.error.message);
+                console.warn(`⚠️ [${relativePath}] JSON parse failed; quarantined to _corrupted.`);
+            } else {
+                console.error(`❌ [${relativePath}] Read failed: ${result.error.message}`);
+            }
+            errorCount++;
+            return;
+        }
+
+        const json = result.json;
+
+        let fileErrors = [];
+
+        // Route validation based on filename/path
+        if (file.endsWith('task-log.json')) {
+            fileErrors = validateTaskLog(json, relativePath);
+        } else if (file.endsWith('career-log.json')) {
+            fileErrors = validateCareerLog(json, relativePath);
+        } else if (file.endsWith('status.json')) {
+            fileErrors = validateProjectStatus(json, relativePath);
+        } else if (file.endsWith('blocker-log.json')) {
+            fileErrors = validateBlockerLog(json, relativePath);
+        } else {
+            // Optional: warn about unknown files, or ignore
+            // console.warn(`⚠️ [${relativePath}] Unknown JSON file type. Skipping schema validation.`);
+        }
+
+        if (fileErrors.length > 0) {
+            console.error(`❌ [${relativePath}] Validation failed:`);
+            fileErrors.forEach(e => console.error(`   - ${e}`));
+            errorCount++;
+        }
+    });
+
+    if (errorCount === 0) {
+        console.log('✅ All systems operational');
+    } else {
+        console.error(`❌ Validation completed with errors in ${errorCount} file(s).`);
+        process.exit(1);
+    }
+
+  } catch (err) {
+    console.error('❌ Fatal error:', err);
+    process.exit(1);
+  }
+}
+
+validateData();