oxe-cc 0.7.1 → 0.9.0

package/bin/lib/oxe-operational.cjs

@@ -647,6 +647,110 @@ function applyRuntimeAction(projectRoot, activeSession, input = {}) {
   return saved;
 }
 
+/**
+ * Reconstrói a timeline de eventos de OXE-EVENTS.ndjson com deltas entre transições.
+ * @param {string} projectRoot
+ * @param {string|null} activeSession
+ * @param {{ fromEventId?: string, runId?: string, waveId?: number, limit?: number, writeReport?: boolean }} [options]
+ */
+function replayEvents(projectRoot, activeSession, options = {}) {
+  let events = readEvents(projectRoot, activeSession);
+
+  if (options.runId) {
+    events = events.filter((e) => e.run_id === options.runId);
+  }
+  if (options.fromEventId) {
+    const idx = events.findIndex((e) => e.event_id === options.fromEventId);
+    if (idx >= 0) events = events.slice(idx);
+  }
+  if (options.waveId != null) {
+    const waveTag = `wave-${options.waveId}`;
+    events = events.filter((e) => e.wave_id === waveTag || String(e.wave_id) === String(options.waveId));
+  }
+  if (options.limit && options.limit > 0) {
+    events = events.slice(0, options.limit);
+  }
+
+  // Ordenar por timestamp
+  events.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+
+  // Calcular deltas
+  for (let i = 0; i < events.length; i++) {
+    if (i === 0) {
+      events[i]._delta_ms = 0;
+    } else {
+      const prev = new Date(events[i - 1].timestamp).getTime();
+      const curr = new Date(events[i].timestamp).getTime();
+      events[i]._delta_ms = curr - prev;
+    }
+  }
+
+  const firstTs = events.length ? new Date(events[0].timestamp).getTime() : null;
+  const lastTs = events.length ? new Date(events[events.length - 1].timestamp).getTime() : null;
+  const duration_ms = firstTs != null && lastTs != null ? lastTs - firstTs : null;
+
+  const waveIds = [...new Set(
+    events
+      .filter((e) => e.wave_id != null)
+      .map((e) => {
+        const m = String(e.wave_id).match(/^wave-(\d+)$/);
+        return m ? Number(m[1]) : null;
+      })
+      .filter((n) => n != null)
+  )].sort((a, b) => a - b);
+
+  const taskSequence = [...new Set(events.filter((e) => e.task_id).map((e) => e.task_id))];
+  const checkpointSequence = events
+    .filter((e) => String(e.type).includes('checkpoint'))
+    .map((e) => e.event_id);
+  const failureEvents = events.filter((e) =>
+    String(e.type).includes('fail') || String(e.type).includes('error')
+  );
+
+  const report = {
+    events,
+    totalEvents: events.length,
+    duration_ms,
+    runId: options.runId || (events.length ? events[0].run_id : null),
+    waveIds,
+    taskSequence,
+    checkpointSequence,
+    failureEvents,
+  };
+
+  if (options.writeReport) {
+    const p = operationalPaths(projectRoot, activeSession);
+    const scopeRoot = path.dirname(p.events);
+    const reportPath = path.join(scopeRoot, 'REPLAY-SESSION.md');
+    const lines = [
+      '# OXE — Replay Session',
+      '',
+      `- **Data:** ${new Date().toISOString().slice(0, 10)}`,
+      `- **Run:** ${report.runId || '—'}`,
+      `- **Total eventos:** ${report.totalEvents}`,
+      `- **Duração:** ${report.duration_ms != null ? `${(report.duration_ms / 1000).toFixed(1)}s` : '—'}`,
+      `- **Ondas:** ${report.waveIds.join(', ') || '—'}`,
+      `- **Tarefas:** ${report.taskSequence.join(', ') || '—'}`,
+      `- **Falhas:** ${report.failureEvents.length}`,
+      '',
+      '## Timeline',
+      '',
+      '| # | Tipo | Wave | Task | Delta | Timestamp |',
+      '|---|------|------|------|-------|-----------|',
+    ];
+    for (let i = 0; i < events.length; i++) {
+      const e = events[i];
+      const delta = i > 0 ? `+${(e._delta_ms / 1000).toFixed(1)}s` : '—';
+      lines.push(`| ${i + 1} | ${e.type} | ${e.wave_id || '—'} | ${e.task_id || '—'} | ${delta} | ${e.timestamp} |`);
+    }
+    ensureDirForFile(reportPath);
+    fs.writeFileSync(reportPath, lines.join('\n') + '\n', 'utf8');
+    report._reportPath = reportPath;
+  }
+
+  return report;
+}
+
 module.exports = {
   VALID_RUN_STATUSES,
   VALID_APPROVAL_POLICIES,
@@ -667,4 +771,5 @@ module.exports = {
   buildMemoryLayers,
   buildOperationalGraph,
   applyRuntimeAction,
+  replayEvents,
 };

package/bin/lib/oxe-plugins.cjs

@@ -99,6 +99,35 @@ function loadPlugins(projectRoot) {
     }
   }
 
+  // Carregar plugins de sources externas (config.json → plugins[])
+  const configPath = path.join(projectRoot, '.oxe', 'config.json');
+  if (fs.existsSync(configPath)) {
+    try {
+      const cfg = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      if (Array.isArray(cfg.plugins)) {
+        const { resolved, errors: srcErrors } = resolvePluginSources(projectRoot, cfg.plugins);
+        for (const se of srcErrors) {
+          errors.push({ file: se.source, error: se.error });
+        }
+        for (const absPath of resolved) {
+          try {
+            // eslint-disable-next-line no-undef
+            const mod = require(absPath);
+            if (mod && typeof mod === 'object' && typeof mod.name === 'string' && mod.hooks && typeof mod.hooks === 'object') {
+              if (!plugins.some((existing) => existing.name === mod.name)) {
+                plugins.push(mod);
+              }
+            } else {
+              errors.push({ file: absPath, error: 'Plugin externo não tem name (string) ou hooks (objeto) válidos' });
+            }
+          } catch (e) {
+            errors.push({ file: absPath, error: String(e) });
+          }
+        }
+      }
+    } catch { /* ignore config parse errors — validados em outro lugar */ }
+  }
+
   return { plugins, errors };
 }
 
@@ -218,9 +247,95 @@ Ver documentação completa: \`oxe/templates/PLUGINS.md\` (no pacote npm).
   }
 }
 
+/**
+ * Resolve sources de plugins definidas no config.json.
+ * Suporta: "path:./file.cjs", "./relative.cjs" (atalho), "npm:<pkg>".
+ * @param {string} projectRoot
+ * @param {Array<string | { source: string, version?: string }>} pluginsSources
+ * @returns {{ resolved: string[], errors: Array<{ source: string, error: string }> }}
+ */
+function resolvePluginSources(projectRoot, pluginsSources) {
+  const resolved = [];
+  const errors = [];
+  if (!Array.isArray(pluginsSources)) return { resolved, errors };
+
+  for (const entry of pluginsSources) {
+    // Legado: string simples (nome de arquivo local)
+    if (typeof entry === 'string') {
+      const abs = path.resolve(projectRoot, '.oxe', 'plugins', entry);
+      if (fs.existsSync(abs)) {
+        resolved.push(abs);
+      } else {
+        errors.push({ source: entry, error: `arquivo não encontrado: ${abs}` });
+      }
+      continue;
+    }
+    if (!entry || typeof entry !== 'object' || !entry.source) {
+      errors.push({ source: String(entry), error: 'entrada inválida — esperado { source: string }' });
+      continue;
+    }
+    const src = String(entry.source);
+
+    if (src.startsWith('path:') || src.startsWith('./') || src.startsWith('../')) {
+      const rel = src.startsWith('path:') ? src.slice(5) : src;
+      const abs = path.resolve(projectRoot, rel);
+      if (!fs.existsSync(abs)) {
+        errors.push({ source: src, error: `arquivo não encontrado: ${abs}` });
+      } else {
+        resolved.push(abs);
+      }
+    } else if (src.startsWith('npm:')) {
+      const pkg = src.slice(4);
+      const npmDir = path.join(projectRoot, '.oxe', 'plugins', '_npm', 'node_modules', pkg);
+      if (!fs.existsSync(npmDir)) {
+        errors.push({
+          source: src,
+          error: `pacote não instalado. Execute: npx oxe-cc plugins install ${src}`,
+        });
+      } else {
+        try {
+          const pkgJsonPath = path.join(npmDir, 'package.json');
+          const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+          const main = pkgJson.main || 'index.js';
+          resolved.push(path.join(npmDir, main));
+        } catch (e) {
+          errors.push({ source: src, error: `falha ao resolver main do pacote: ${e.message}` });
+        }
+      }
+    } else {
+      errors.push({ source: src, error: 'prefixo desconhecido — use "path:" ou "npm:"' });
+    }
+  }
+  return { resolved, errors };
+}
+
+/**
+ * Instala um plugin npm em .oxe/plugins/_npm/.
+ * @param {string} projectRoot
+ * @param {string} pkgName
+ * @param {string} [version]
+ * @returns {{ ok: boolean, path: string, error: string }}
+ */
+function installNpmPlugin(projectRoot, pkgName, version) {
+  const npmDir = path.join(projectRoot, '.oxe', 'plugins', '_npm');
+  try {
+    if (!fs.existsSync(npmDir)) {
+      fs.mkdirSync(npmDir, { recursive: true });
+    }
+    const spec = version ? `${pkgName}@${version}` : pkgName;
+    const { execSync } = require('child_process');
+    execSync(`npm install --prefix "${npmDir}" ${spec}`, { stdio: 'pipe', timeout: 60000 });
+    return { ok: true, path: path.join(npmDir, 'node_modules', pkgName), error: '' };
+  } catch (e) {
+    return { ok: false, path: '', error: e.message || String(e) };
+  }
+}
+
 module.exports = {
   loadPlugins,
   runHook,
   validatePlugins,
   initPluginsDir,
+  resolvePluginSources,
+  installNpmPlugin,
 };