watcher.js

// ============================================================
// watcher.js — Codex SPU Path & Status Watcher
// ============================================================
require("dotenv").config();

const chokidar     = require("chokidar");
const fs           = require("fs");
const path         = require("path");
const matter       = require("gray-matter");
const { globSync } = require("glob");
const config       = require("./config");
const github       = require("./github");

// ─── Verificación crítica de CODEX_ROOT ───────────────────────
// dotenvx a veces inyecta comillas literales en el valor
const CODEX_ROOT = (config.CODEX_ROOT || "").replace(/^["']|["']$/g, "").trim();

if (!CODEX_ROOT) {
  console.error("❌ CODEX_ROOT no está definido en .env");
  process.exit(1);
}

try {
  const stat = fs.statSync(CODEX_ROOT);
  if (!stat.isDirectory()) throw new Error("No es un directorio");
} catch (e) {
  console.error(`❌ No se puede acceder a CODEX_ROOT: ${CODEX_ROOT}`);
  console.error(`   Error: ${e.message}`);
  process.exit(1);
}

// ─── Utilidades ───────────────────────────────────────────────

function toRelativePath(absolutePath) {
  return "/" + path.relative(CODEX_ROOT, absolutePath).replace(/\\/g, "/");
}

function readMarkdown(filePath) {
  const raw = fs.readFileSync(filePath, "utf8");
  const parsed = matter(raw);
  return { data: parsed.data, content: parsed.content, raw };
}

function writeMarkdown(filePath, data, content) {
  fs.writeFileSync(filePath, matter.stringify(content, data), "utf8");
}

function getAllMarkdownFiles() {
  const ignore = config.IGNORED_FOLDERS.map(f => `**/${f}/**`);
  return globSync("**/*.md", { cwd: CODEX_ROOT, absolute: true, ignore });
}

function toWatchRelative(inputPath) {
  const relativePath = path.isAbsolute(inputPath)
    ? path.relative(CODEX_ROOT, inputPath)
    : inputPath;
  return relativePath.replace(/\\/g, "/");
}

function isIgnoredFolderPath(inputPath) {
  const rel = toWatchRelative(inputPath);
  return config.IGNORED_FOLDERS.some(folder => (
    rel === folder ||
    rel.startsWith(`${folder}/`) ||
    rel.includes(`/${folder}/`)
  ));
}

function isMarkdownPath(inputPath) {
  return toWatchRelative(inputPath).toLowerCase().endsWith(".md");
}

function getStageFromPath(absolutePath) {
  const rel = path.relative(CODEX_ROOT, absolutePath).replace(/\\/g, "/");
  const parts = rel.split("/");
  if (parts[0] === config.PIPELINE_ROOT && parts.length >= 3) {
    return parts[1].replace(/^\d+_/, "");
  }
  return null;
}

function getFilename(absolutePath) {
  return path.basename(absolutePath, ".md");
}

// ─── Sesión ───────────────────────────────────────────────────

const session = {
  startTime: new Date(),
  moves:     [],
  created:   [],
  errors:    [],
};

function logMove(file, from, to, refsUpdated, githubAction) {
  session.moves.push({ file, from, to, refsUpdated, githubAction, timestamp: new Date() });
}
function logCreated(file, stage, issueUrl) {
  session.created.push({ file, stage, issueUrl, timestamp: new Date() });
}
function logError(msg) {
  session.errors.push({ msg, timestamp: new Date() });
  console.warn(`  ⚠️  ${msg}`);
}

function printSessionReport() {
  const end      = new Date();
  const mins     = Math.round((end - session.startTime) / 60000);
  const duration = mins < 1 ? "menos de 1 min" : `${mins} min`;

  console.log("\n" + "═".repeat(58));
  console.log("📊 REPORTE DE SESIÓN — Codex SPU");
  console.log("═".repeat(58));
  console.log(`  🕐 Inicio:   ${session.startTime.toLocaleTimeString("es-ES")}`);
  console.log(`  🕐 Fin:      ${end.toLocaleTimeString("es-ES")}`);
  console.log(`  ⏱️  Duración: ${duration}`);
  console.log("─".repeat(58));

  if (session.created.length > 0) {
    console.log(`\n  🆕 Archivos añadidos al pipeline: ${session.created.length}`);
    for (const c of session.created) {
      const t = c.timestamp.toLocaleTimeString("es-ES");
      console.log(`\n  [${t}] 📄 ${c.file}  →  ${c.stage}`);
      if (c.issueUrl) console.log(`           🐙 ${c.issueUrl}`);
    }
  }

  if (session.moves.length > 0) {
    console.log(`\n  🔄 Archivos movidos: ${session.moves.length}`);
    for (const m of session.moves) {
      const t = m.timestamp.toLocaleTimeString("es-ES");
      console.log(`\n  [${t}] 📄 ${m.file}`);
      console.log(`           ${m.from}`);
      console.log(`        → ${m.to}`);
      if (m.refsUpdated > 0) console.log(`           📝 ${m.refsUpdated} referencia(s) actualizada(s)`);
      if (m.githubAction)    console.log(`           🐙 ${m.githubAction}`);
    }
  }

  if (session.created.length === 0 && session.moves.length === 0) {
    console.log("\n  ℹ️  No se movió ni creó ningún archivo durante esta sesión.");
  }

  if (session.errors.length > 0) {
    console.log(`\n  ❌ Errores (${session.errors.length}):`);
    for (const e of session.errors) {
      const t = e.timestamp.toLocaleTimeString("es-ES");
      console.log(`     [${t}] ${e.msg}`);
    }
  }

  console.log("\n" + "═".repeat(58));
  console.log("  Systema Vivens — Semper Plus Ultra");
  console.log("═".repeat(58) + "\n");
}

// ─── Lógica de actualización ──────────────────────────────────

function updateFrontmatter(absolutePath, newStage) {
  const { data, content } = readMarkdown(absolutePath);
  const newRelative = toRelativePath(absolutePath);
  let changed = false;

  if (data[config.PATH_FIELD] !== newRelative) {
    console.log(`  📝 Path: ${data[config.PATH_FIELD]} → ${newRelative}`);
    data[config.PATH_FIELD] = newRelative;
    changed = true;
  }

  if (newStage) {
    const cleanStage = newStage.replace(/^\d+_/, "");
    if (data[config.STATUS_FIELD] !== cleanStage) {
      console.log(`  📝 Status: ${data[config.STATUS_FIELD]} → ${cleanStage}`);
      data[config.STATUS_FIELD] = cleanStage;
      changed = true;
    }
  }

  if (changed) {
    writeMarkdown(absolutePath, data, content);
    console.log(`  💾 Guardado.`);
  } else {
    console.log(`  ℹ️  Sin cambios en frontmatter.`);
  }

  return data;
}

function setGithubUrl(absolutePath, url) {
  const { data, content } = readMarkdown(absolutePath);
  data[config.GITHUB_URL_FIELD] = url;
  writeMarkdown(absolutePath, data, content);
}

function updateReferencesInAllFiles(oldRelative, newRelative, skipPath) {
  if (!oldRelative) return 0;
  const allFiles = getAllMarkdownFiles();
  let count = 0;
  for (const filePath of allFiles) {
    if (filePath === skipPath) continue;
    try {
      const raw     = fs.readFileSync(filePath, "utf8");
      const escaped = oldRelative.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
      if (!new RegExp(escaped).test(raw)) continue;
      fs.writeFileSync(filePath, raw.replace(new RegExp(escaped, "g"), newRelative), "utf8");
      console.log(`  ✅ Ref actualizada en: ${toRelativePath(filePath)}`);
      count++;
    } catch (err) {
      logError(`Ref update failed en ${filePath}: ${err.message}`);
    }
  }
  return count;
}

// ─── Watcher ──────────────────────────────────────────────────

console.log("🧠 Codex SPU Watcher arrancando...");
console.log(`📂 Vigilando: ${CODEX_ROOT}`);
console.log(`🔄 Modo: polling (compatible con Windows)`);
console.log("─".repeat(50));

const knownPaths    = new Map();
const MOVE_WINDOW_MS = 8000;
const recentlyDeleted = new Map();
const recentlyAdded   = new Map();

const watcher = chokidar.watch(".", {
  cwd:           CODEX_ROOT,
  ignored:       (watchPath, stats) => {
    if (isIgnoredFolderPath(watchPath)) return true;
    return stats?.isFile() ? !isMarkdownPath(watchPath) : false;
  },
  persistent:    true,
  ignoreInitial: false,
  // usePolling es necesario en Windows para detectar moves del Explorador
  usePolling:    true,
  interval:      800,
  awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 },
});

// Mantener el proceso vivo explícitamente (necesario en Windows con polling)
const keepAlive = setInterval(() => {}, 60000);

// ── Arranque: registra archivos existentes ────────────────────
watcher.on("add", (relativePath) => {
  if (watcher._codexReady) return;
  const absolutePath = path.join(CODEX_ROOT, relativePath);
  try {
    const { data } = readMarkdown(absolutePath);
    const rel   = toRelativePath(absolutePath);
    const stage = getStageFromPath(absolutePath);
    knownPaths.set(absolutePath, { relativePath: data[config.PATH_FIELD] || rel, stage });
    if (config.VERBOSE) console.log(`  👁️  ${rel}`);
  } catch { /* ignorar */ }
});

// ── Procesador central de MOVE ────────────────────────────────
async function processMoveEvent(addedAbs, addedInfo, deletedAbs, deletedInfo) {
  const { newRelative, newStage, filename } = addedInfo;
  const { oldRelativePath } = deletedInfo;

  console.log(`\n🔄 Movido: ${filename}`);
  console.log(`  DE:   ${oldRelativePath}`);
  console.log(`  A:    ${newRelative}`);

  const data = updateFrontmatter(addedAbs, newStage);
  console.log(`  ✅ path + status actualizados${newStage ? ` → ${newStage}` : ""}`);

  const refs = updateReferencesInAllFiles(oldRelativePath, newRelative, addedAbs);
  if (refs === 0) console.log("  ℹ️  Sin referencias en otros archivos");

  let githubAction = null;
  if (newStage) {
    try {
      if (data[config.GITHUB_URL_FIELD]) {
        await github.moveItemByFilename(filename, newStage);
        githubAction = `columna "${newStage}" actualizada en GitHub`;
      } else {
        console.log(`  🚀 Importando a GitHub: creando nueva Issue...`);
        const { issueUrl } = await github.createIssueAndAddToProject(filename, newStage);
        setGithubUrl(addedAbs, issueUrl);
        githubAction = `Issue creada e importada a "${newStage}"`;
      }
      console.log(`  ✅ 🐙 ${githubAction}`);
    } catch (err) {
      logError(`GitHub sync fallido para "${filename}": ${err.message}`);
    }
  }

  logMove(filename, oldRelativePath, newRelative, refs, githubAction);
  knownPaths.set(addedAbs, { relativePath: newRelative, stage: newStage });
  console.log("─".repeat(50));
}

// ── Procesador de archivo nuevo real ─────────────────────────
async function processNewFile(absolutePath, newRelative, newStage, filename) {
  knownPaths.set(absolutePath, { relativePath: newRelative, stage: newStage });
  if (!newStage) return;

  console.log(`\n📥 Detectado en pipeline: ${filename} [${newStage}]`);

  const { data } = readMarkdown(absolutePath);
  updateFrontmatter(absolutePath, newStage);

  if (data[config.GITHUB_URL_FIELD]) {
    console.log(`  ℹ️  Ya tiene Issue: ${data[config.GITHUB_URL_FIELD]}`);
    try {
      await github.moveItemByFilename(filename, newStage);
      console.log(`  ✅ 🐙 Posición actualizada en GitHub Projects`);
    } catch (err) {
      logError(`No se pudo sincronizar: ${err.message}`);
    }
  } else {
    console.log(`  🚀 Creando Issue en GitHub...`);
    try {
      const { issueUrl } = await github.createIssueAndAddToProject(filename, newStage);
      setGithubUrl(absolutePath, issueUrl);
      console.log(`  ✅ 🐙 Issue creada: ${issueUrl}`);
      logCreated(filename, newStage, issueUrl);
    } catch (err) {
      logError(`GitHub issue fallida para "${filename}": ${err.message}`);
    }
  }
  console.log("─".repeat(50));
}

// ── Evento: archivo eliminado ─────────────────────────────────
watcher.on("unlink", async (relativePath) => {
  const absolutePath = path.join(CODEX_ROOT, relativePath);
  const known    = knownPaths.get(absolutePath);
  const basename = path.basename(absolutePath);

  const deletedInfo = {
    oldRelativePath: known?.relativePath || toRelativePath(absolutePath),
    oldStage:        known?.stage || null,
    timestamp:       Date.now(),
  };

  knownPaths.delete(absolutePath);

  // ¿Ya llegó el add antes? (chokidar con polling puede invertir el orden)
  let matchedAdd = null;
  for (const [addedAbs, info] of recentlyAdded.entries()) {
    if (path.basename(addedAbs) === basename && (Date.now() - info.timestamp) < MOVE_WINDOW_MS) {
      matchedAdd = { addedAbs, ...info };
      recentlyAdded.delete(addedAbs);
      break;
    }
  }

  if (matchedAdd) {
    await processMoveEvent(matchedAdd.addedAbs, matchedAdd, absolutePath, deletedInfo);
  } else {
    recentlyDeleted.set(absolutePath, deletedInfo);
    setTimeout(() => recentlyDeleted.delete(absolutePath), MOVE_WINDOW_MS + 500);
  }
});

// ── Evento: archivo nuevo (post-arranque) ─────────────────────
watcher.on("add", async (relativePath) => {
  if (!watcher._codexReady) return;

  const absolutePath = path.join(CODEX_ROOT, relativePath);
  const newRelative  = toRelativePath(absolutePath);
  const newStage     = getStageFromPath(absolutePath);
  const filename     = getFilename(absolutePath);
  const basename     = path.basename(absolutePath);

  // ¿Ya llegó el unlink antes? (orden normal)
  let matchedOld = null;
  for (const [oldAbs, info] of recentlyDeleted.entries()) {
    if (path.basename(oldAbs) === basename && (Date.now() - info.timestamp) < MOVE_WINDOW_MS) {
      matchedOld = { oldAbsolute: oldAbs, ...info };
      recentlyDeleted.delete(oldAbs);
      break;
    }
  }

  if (matchedOld) {
    await processMoveEvent(
      absolutePath,
      { newRelative, newStage, filename, timestamp: Date.now() },
      matchedOld.oldAbsolute,
      matchedOld
    );
    return;
  }

  // Guardamos y esperamos si llega el unlink
  const addedInfo = { newRelative, newStage, filename, timestamp: Date.now() };
  recentlyAdded.set(absolutePath, addedInfo);

  setTimeout(async () => {
    if (!recentlyAdded.has(absolutePath)) return;
    recentlyAdded.delete(absolutePath);
    await processNewFile(absolutePath, newRelative, newStage, filename);
  }, MOVE_WINDOW_MS);
});

// ── Listo ─────────────────────────────────────────────────────
watcher.on("ready", () => {
  watcher._codexReady = true;
  console.log(`\n✅ Watcher listo. ${knownPaths.size} archivos registrados.`);
  console.log("👂 Escuchando cambios... (Ctrl+C para ver reporte y salir)\n");
});

watcher.on("error", err => console.error("❌ Error en watcher:", err));

// ── Ctrl+C → reporte ──────────────────────────────────────────
process.on("SIGINT", () => {
  clearInterval(keepAlive);
  watcher.close();
  printSessionReport();
  process.exit(0);
});