@cccarv82/freya 2.3.13 → 2.4.1

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

@@ -0,0 +1,183 @@
+const fs = require('fs');
+const path = require('path');
+
+const ID_PATTERNS = [
+  /\bPTI\d{4,}-\d+\b/gi,
+  /\bINC\d+\b/gi,
+  /\bCHG\d+\b/gi
+];
+
+const TEXT_EXTS = new Set(['.md', '.txt', '.log', '.json', '.yaml', '.yml']);
+
+function extractIdTokens(query) {
+  const tokens = new Set();
+  const q = String(query || '');
+  for (const re of ID_PATTERNS) {
+    const matches = q.match(re);
+    if (matches) {
+      for (const m of matches) tokens.add(m.toUpperCase());
+    }
+  }
+  return Array.from(tokens);
+}
+
+function tokenizeQuery(query) {
+  const tokens = [];
+  const q = String(query || '');
+  const re = /[A-Za-z0-9_-]{2,}/g;
+  let m;
+  while ((m = re.exec(q)) !== null) {
+    tokens.push(m[0]);
+  }
+  return tokens;
+}
+
+function listFilesRecursive(dir, files = []) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return files;
+  }
+  for (const ent of entries) {
+    const full = path.join(dir, ent.name);
+    if (ent.isDirectory()) {
+      listFilesRecursive(full, files);
+    } else if (ent.isFile()) {
+      const ext = path.extname(ent.name).toLowerCase();
+      if (TEXT_EXTS.has(ext)) files.push(full);
+    }
+  }
+  return files;
+}
+
+function toDateString(ms) {
+  try {
+    const d = new Date(ms);
+    if (Number.isNaN(d.getTime())) return '';
+    const y = String(d.getFullYear());
+    const m = String(d.getMonth() + 1).padStart(2, '0');
+    const day = String(d.getDate()).padStart(2, '0');
+    return `${y}-${m}-${day}`;
+  } catch {
+    return '';
+  }
+}
+
+function inferDateFromPath(filePath, mtimeMs) {
+  const m = String(filePath).match(/\b(\d{4}-\d{2}-\d{2})\b/);
+  if (m && m[1]) return m[1];
+  return toDateString(mtimeMs);
+}
+
+function findFirstMatchIndex(textLower, needles) {
+  let best = -1;
+  for (const needle of needles) {
+    if (!needle) continue;
+    const idx = textLower.indexOf(needle);
+    if (idx !== -1 && (best === -1 || idx < best)) best = idx;
+  }
+  return best;
+}
+
+function buildSnippet(text, index, length) {
+  if (index < 0) {
+    const clean = String(text || '').replace(/\s+/g, ' ').trim();
+    return clean.length > 220 ? clean.slice(0, 220) + '…' : clean;
+  }
+  const raw = String(text || '');
+  const start = Math.max(0, index - 80);
+  const end = Math.min(raw.length, index + length + 120);
+  let snippet = raw.slice(start, end).replace(/\s+/g, ' ').trim();
+  if (start > 0) snippet = '…' + snippet;
+  if (end < raw.length) snippet = snippet + '…';
+  return snippet;
+}
+
+function scoreText(textLower, queryLower, tokensLower, idTokensLower) {
+  let score = 0;
+  if (queryLower && textLower.includes(queryLower)) score += 10;
+  for (const t of tokensLower) {
+    if (!t) continue;
+    if (textLower.includes(t)) score += 2;
+  }
+  for (const id of idTokensLower) {
+    if (!id) continue;
+    if (textLower.includes(id)) score += 100;
+  }
+  return score;
+}
+
+function searchWorkspace(workspaceDir, query, opts = {}) {
+  const q = String(query || '').trim();
+  if (!q) return [];
+
+  const limit = Math.max(1, Math.min(20, Number(opts.limit || 8)));
+  const maxSize = Math.max(1024, Number(opts.maxSize || 2 * 1024 * 1024));
+
+  const targetDirs = [
+    path.join(workspaceDir, 'logs', 'daily'),
+    path.join(workspaceDir, 'data', 'tasks'),
+    path.join(workspaceDir, 'data', 'Clients'),
+    path.join(workspaceDir, 'docs', 'reports')
+  ];
+
+  const idTokens = extractIdTokens(q);
+  const tokens = tokenizeQuery(q);
+  const tokensLower = tokens.map((t) => t.toLowerCase());
+  const idTokensLower = idTokens.map((t) => t.toLowerCase());
+  const queryLower = q.toLowerCase();
+
+  const results = [];
+  for (const dir of targetDirs) {
+    if (!fs.existsSync(dir)) continue;
+    const files = listFilesRecursive(dir, []);
+    for (const file of files) {
+      let st;
+      try {
+        st = fs.statSync(file);
+      } catch {
+        continue;
+      }
+      if (!st.isFile() || st.size > maxSize) continue;
+      let text;
+      try {
+        text = fs.readFileSync(file, 'utf8');
+      } catch {
+        continue;
+      }
+      if (!text || text.includes('\u0000')) continue;
+      const textLower = text.toLowerCase();
+      const score = scoreText(textLower, queryLower, tokensLower, idTokensLower);
+      if (score <= 0) continue;
+
+      const needles = [];
+      if (queryLower) needles.push(queryLower);
+      for (const t of tokensLower) needles.push(t);
+      for (const id of idTokensLower) needles.push(id);
+      const idx = findFirstMatchIndex(textLower, needles);
+      const snippet = buildSnippet(text, idx, queryLower.length || 12);
+      const relPath = path.relative(workspaceDir, file).replace(/\\/g, '/');
+      const date = inferDateFromPath(relPath, st.mtimeMs);
+
+      results.push({
+        file: relPath,
+        date,
+        score,
+        snippet
+      });
+    }
+  }
+
+  results.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return String(b.date || '').localeCompare(String(a.date || ''));
+  });
+
+  return results.slice(0, limit);
+}
+
+module.exports = {
+  extractIdTokens,
+  searchWorkspace
+};

package/templates/base/scripts/migrate-v1-v2.js

@@ -0,0 +1,184 @@
+const fs = require('fs');
+const path = require('path');
+const { defaultInstance: dl } = require('./lib/DataLayer');
+const DataManager = require('./lib/DataManager');
+
+const dataDir = path.join(__dirname, '..', 'data');
+const logsDir = path.join(__dirname, '..', 'logs', 'daily');
+
+console.log('--- Iniciando Migração V1 (JSON) para V2 (SQLite) ---');
+
+function migrateTasks() {
+    console.log('Migrando Tasks...');
+    const dm = new DataManager(dataDir, logsDir);
+    const tasks = dm.getTasksRaw();
+    const stmt = dl.db.prepare(`
+    INSERT OR IGNORE INTO tasks 
+    (id, project_slug, description, category, status, created_at, completed_at, metadata)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+
+    let count = 0;
+    // Tasks has: PENDING, COMPLETED, ARCHIVED
+    const processList = (list) => {
+        for (const t of list) {
+            const meta = { priority: t.priority, streamSlug: t.streamSlug };
+            stmt.run(
+                t.id,
+                t.projectSlug || null,
+                t.description,
+                t.category,
+                t.status,
+                t.createdAt || new Date().toISOString(),
+                t.completedAt || null,
+                JSON.stringify(meta)
+            );
+            count++;
+        }
+    };
+
+    const pending = tasks.filter(t => t.status === 'PENDING');
+    const completed = tasks.filter(t => t.status === 'COMPLETED');
+    const archived = tasks.filter(t => t.status === 'ARCHIVED');
+
+    processList(pending);
+    processList(completed);
+    processList(archived);
+
+    console.log(`✅ ${count} tasks migradas.`);
+}
+
+function migrateBlockers() {
+    console.log('Migrando Blockers...');
+    const dm = new DataManager(dataDir, logsDir);
+    const blockers = dm.getBlockersRaw();
+    const stmt = dl.db.prepare(`
+    INSERT OR IGNORE INTO blockers 
+    (id, project_slug, title, severity, status, owner, next_action, created_at, resolved_at, metadata)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+
+    let count = 0;
+    const processList = (list) => {
+        for (const b of list) {
+            const meta = { streamSlug: b.streamSlug };
+            stmt.run(
+                b.id,
+                b.projectSlug || null,
+                b.title,
+                b.severity || 'MEDIUM',
+                b.status || 'OPEN',
+                b.owner || null,
+                b.nextAction || null,
+                b.createdAt || new Date().toISOString(),
+                b.resolvedAt || null,
+                JSON.stringify(meta)
+            );
+            count++;
+        }
+    };
+
+    const open = blockers.filter(b => b.status === 'OPEN' || b.status === 'MITIGATING');
+    const resolved = blockers.filter(b => b.status === 'RESOLVED' || b.status === 'CLOSED');
+
+    processList(open);
+    processList(resolved);
+
+    console.log(`✅ ${count} blockers migrados.`);
+}
+
+function migrateProjects() {
+    console.log('Migrando Projetos...');
+    const clientsDir = path.join(dataDir, 'Clients');
+    if (!fs.existsSync(clientsDir)) return;
+
+    const insertProj = dl.db.prepare(`
+    INSERT OR IGNORE INTO projects (slug, client, name, is_active)
+    VALUES (?, ?, ?, ?)
+  `);
+
+    const getProjId = dl.db.prepare("SELECT id FROM projects WHERE slug = ?");
+
+    const insertHist = dl.db.prepare(`
+    INSERT INTO project_status_history (project_id, status_text, date)
+    VALUES (?, ?, ?)
+  `);
+
+    let pCount = 0;
+    let hCount = 0;
+
+    for (const clientSlug of fs.readdirSync(clientsDir)) {
+        const clientPath = path.join(clientsDir, clientSlug);
+        if (!fs.statSync(clientPath).isDirectory()) continue;
+
+        for (const projectSlug of fs.readdirSync(clientPath)) {
+            const projectPath = path.join(clientPath, projectSlug);
+            if (!fs.statSync(projectPath).isDirectory()) continue;
+
+            const statusPath = path.join(projectPath, 'status.json');
+            if (!fs.existsSync(statusPath)) continue;
+
+            let pData;
+            try {
+                pData = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
+            } catch (e) { continue; }
+
+            const fullSlug = `${clientSlug}-${projectSlug}`;
+            const isActive = pData.active !== false ? 1 : 0;
+
+            insertProj.run(fullSlug, pData.client || clientSlug, pData.project || projectSlug, isActive);
+            pCount++;
+
+            const pRow = getProjId.get(fullSlug);
+            if (pRow && pData.history && Array.isArray(pData.history)) {
+                for (const log of pData.history) {
+                    let content = '';
+                    let date = new Date().toISOString();
+                    if (typeof log === 'string') {
+                        content = log;
+                    } else if (typeof log === 'object') {
+                        content = log.content || log.summary || JSON.stringify(log);
+                        date = log.date || date;
+                    }
+                    insertHist.run(pRow.id, content, date);
+                    hCount++;
+                }
+            }
+        }
+    }
+
+    console.log(`✅ ${pCount} projetos migrados, com ${hCount} atualizações de status.`);
+}
+
+function migrateLogs() {
+    console.log('Migrando Logs Diários...');
+    if (!fs.existsSync(logsDir)) {
+        console.log('Nenhum diretório de log encontrado.');
+        return;
+    }
+    const files = fs.readdirSync(logsDir).filter(f => f.endsWith('.md'));
+    const stmt = dl.db.prepare(`
+    INSERT OR IGNORE INTO daily_logs (date, raw_markdown)
+    VALUES (?, ?)
+  `);
+
+    let count = 0;
+    for (const file of files) {
+        const date = file.replace('.md', '');
+        const content = fs.readFileSync(path.join(logsDir, file), 'utf8');
+        stmt.run(date, content);
+        count++;
+    }
+    console.log(`✅ ${count} logs diários migrados.`);
+}
+
+// Transaction wrapper
+dl.db.transaction(() => {
+    migrateProjects();
+    migrateTasks();
+    migrateBlockers();
+    migrateLogs();
+})();
+
+console.log('--- Migração concluída com sucesso! ---');
+dl.close();

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

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 
 const { safeReadJson, quarantineCorruptedFile } = require('./lib/fs-utils');
+const SCHEMA = require('./lib/schema');
 
 const DATA_DIR = path.join(__dirname, '../data');
 
@@ -24,14 +25,14 @@ function validateTaskLog(json, file) {
     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'];
+    const validCategories = SCHEMA.TASK.CATEGORIES;
     if (task.category && !validCategories.includes(task.category)) {
-        errors.push(`Task[${index}] invalid category '${task.category}'.`);
+      errors.push(`Task[${index}] invalid category '${task.category}'.`);
     }
 
-    const validStatuses = ['PENDING', 'COMPLETED', 'ARCHIVED'];
+    const validStatuses = SCHEMA.TASK.STATUSES;
     if (task.status && !validStatuses.includes(task.status)) {
-        errors.push(`Task[${index}] invalid status '${task.status}'.`);
+      errors.push(`Task[${index}] invalid status '${task.status}'.`);
     }
   });
 
@@ -54,9 +55,9 @@ function validateCareerLog(json, file) {
     if (!entry.type) errors.push(`Entry[${index}] missing 'type'.`);
     if (!entry.description) errors.push(`Entry[${index}] missing 'description'.`);
 
-    const validTypes = ['Achievement', 'Feedback', 'Certification', 'Goal'];
+    const validTypes = SCHEMA.CAREER.TYPES;
     if (entry.type && !validTypes.includes(entry.type)) {
-        errors.push(`Entry[${index}] invalid type '${entry.type}'.`);
+      errors.push(`Entry[${index}] invalid type '${entry.type}'.`);
     }
   });
 
@@ -66,19 +67,19 @@ function validateCareerLog(json, file) {
 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 (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'.`);
-      });
+    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.`);
+    errors.push(`'history' must be an array.`);
   }
 
   return errors;
@@ -94,8 +95,8 @@ function validateBlockerLog(json, file) {
     return errors;
   }
 
-  const validStatuses = ['OPEN', 'MITIGATING', 'RESOLVED'];
-  const validSeverities = ['LOW', 'MEDIUM', 'HIGH', 'CRITICAL'];
+  const validStatuses = SCHEMA.BLOCKER.STATUSES;
+  const validSeverities = SCHEMA.BLOCKER.SEVERITIES;
 
   json.blockers.forEach((b, i) => {
     const prefix = `Blocker[${i}]`;
@@ -148,53 +149,49 @@ function validateData() {
 
     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 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;
+      const json = result.json;
 
-        let fileErrors = [];
+      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.`);
-        }
+      // Route validation based on filename/path
+      if (file.endsWith('career-log.json')) {
+        fileErrors = validateCareerLog(json, relativePath);
+      } else if (file.endsWith('task-log.json') || file.endsWith('status.json') || file.endsWith('blocker-log.json')) {
+        // Obsoleted by SQLite, ignore
+      } 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 (fileErrors.length > 0) {
+        console.error(`❌ [${relativePath}] Validation failed:`);
+        fileErrors.forEach(e => console.error(`   - ${e}`));
+        errorCount++;
+      }
     });
 
     if (errorCount === 0) {
-        console.log('✅ All systems operational');
+      console.log('✅ All systems operational');
     } else {
-        console.error(`❌ Validation completed with errors in ${errorCount} file(s).`);
-        process.exit(1);
+      console.error(`❌ Validation completed with errors in ${errorCount} file(s).`);
+      process.exit(1);
     }
 
   } catch (err) {

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

@@ -7,6 +7,7 @@ const DATA_DIR = path.join(ROOT, 'data');
 const DOCS_DIR = path.join(ROOT, 'docs');
 const CLIENTS_DIR = path.join(DATA_DIR, 'Clients');
 
+const { defaultInstance: dl } = require('./lib/DataLayer');
 const errors = [];
 
 function exists(p) {
@@ -70,52 +71,29 @@ function validateDailyLogs() {
 }
 
 function collectProjectSlugs() {
-  if (!exists(CLIENTS_DIR)) return [];
-  const slugs = [];
-  const files = walk(CLIENTS_DIR).filter((f) => f.endsWith('status.json'));
-  for (const file of files) {
-    const rel = path.relative(CLIENTS_DIR, path.dirname(file));
-    if (!rel) continue;
-    const slug = rel.split(path.sep).join('/').toLowerCase();
-    slugs.push(slug);
-  }
-  return Array.from(new Set(slugs));
+  return dl.db.prepare('SELECT slug FROM projects WHERE is_active = 1').all().map(p => p.slug.toLowerCase());
 }
 
 function validateProjectStatusHistory() {
-  if (!exists(CLIENTS_DIR)) return;
-  const files = walk(CLIENTS_DIR).filter((f) => f.endsWith('status.json'));
-  for (const file of files) {
-    const raw = readFileSafe(file);
-    if (!raw) continue;
-    try {
-      const json = JSON.parse(raw);
-      if (!Array.isArray(json.history)) {
-        errors.push(`status.json must include history array: ${path.relative(ROOT, file)}`);
-      }
-    } catch (e) {
-      errors.push(`Invalid JSON in status.json: ${path.relative(ROOT, file)}`);
-    }
+  const projects = dl.db.prepare('SELECT id, name FROM projects').all();
+  for (const p of projects) {
+    const historyCount = dl.db.prepare('SELECT count(*) as count FROM project_status_history WHERE project_id = ?').get(p.id).count;
+    // We don't strictly enforce history to exist for brand new projects, but if we did:
+    // if (historyCount === 0) errors.push(`Project missing status history: ${p.name}`);
   }
 }
 
 function validateTaskProjectSlugs() {
   const slugs = collectProjectSlugs();
-  if (!slugs.length) return; // no known slugs -> skip
-
-  const taskFile = path.join(DATA_DIR, 'tasks', 'task-log.json');
-  if (!exists(taskFile)) return;
+  if (!slugs.length) return;
 
-  let json;
-  try { json = JSON.parse(readFileSafe(taskFile) || '{}'); } catch { return; }
-  const tasks = Array.isArray(json.tasks) ? json.tasks : [];
+  const tasks = dl.db.prepare('SELECT id, description, project_slug FROM tasks').all();
 
   for (const task of tasks) {
-    if (!task || typeof task !== 'object') continue;
     const desc = String(task.description || '').toLowerCase();
     if (!desc) continue;
     const mentioned = slugs.find((slug) => desc.includes(slug));
-    if (mentioned && !task.projectSlug) {
+    if (mentioned && !task.project_slug) {
       errors.push(`Task missing projectSlug for mentioned project (${mentioned}): ${task.id || task.description}`);
     }
   }