oxe-cc 1.11.0 → 1.14.0

package/bin/lib/oxe-event-bus.cjs

@@ -0,0 +1,118 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+/**
+ * OXE Event Bus
+ *
+ * Wrapper sobre o runtime event bus para emitir eventos em OXE-EVENTS.ndjson.
+ * Compatível com o schema OxeEvent definido em packages/runtime/src/events/envelope.ts.
+ *
+ * Uso:
+ *   const bus = require('./oxe-event-bus.cjs');
+ *   bus.emit(projectRoot, 'RunStarted', { mode: 'agent', objective: '...' }, { session_id, run_id });
+ */
+
+const EVENTS_FILE = 'OXE-EVENTS.ndjson';
+
+function emit(projectRoot, eventType, payload = {}, context = {}) {
+  const event = {
+    id: crypto.randomUUID ? crypto.randomUUID() : crypto.randomBytes(16).toString('hex'),
+    type: eventType,
+    timestamp: new Date().toISOString(),
+    session_id: context.session_id || null,
+    run_id: context.run_id || null,
+    work_item_id: context.work_item_id || null,
+    attempt_id: context.attempt_id || null,
+    causation_id: context.causation_id || null,
+    correlation_id: context.correlation_id || null,
+    payload,
+  };
+
+  const eventsPath = path.join(projectRoot, '.oxe', EVENTS_FILE);
+
+  try {
+    fs.mkdirSync(path.dirname(eventsPath), { recursive: true });
+    fs.appendFileSync(eventsPath, JSON.stringify(event) + '\n', 'utf8');
+  } catch {
+    // non-fatal: event emission should never break the main flow
+  }
+
+  return event;
+}
+
+function emitRunStarted(projectRoot, runId, sessionId, mode, objective, persona) {
+  return emit(projectRoot, 'RunStarted', { mode, objective, persona }, { run_id: runId, session_id: sessionId });
+}
+
+function emitWorkItemCompleted(projectRoot, runId, sessionId, taskId, filesChanged) {
+  return emit(projectRoot, 'WorkItemCompleted', { task_id: taskId, files_changed: filesChanged || [] }, { run_id: runId, session_id: sessionId, work_item_id: taskId });
+}
+
+function emitWorkItemBlocked(projectRoot, runId, sessionId, taskId, reason) {
+  return emit(projectRoot, 'WorkItemBlocked', { task_id: taskId, reason }, { run_id: runId, session_id: sessionId, work_item_id: taskId });
+}
+
+function emitRunCompleted(projectRoot, runId, sessionId, status, summary) {
+  return emit(projectRoot, 'RunCompleted', { status, ...summary }, { run_id: runId, session_id: sessionId });
+}
+
+function emitGateRequested(projectRoot, runId, sessionId, gateId, condition, type) {
+  return emit(projectRoot, 'GateRequested', { gate_id: gateId, condition, type }, { run_id: runId, session_id: sessionId });
+}
+
+function emitGateResolved(projectRoot, runId, sessionId, gateId, resolution, actor) {
+  return emit(projectRoot, 'GateResolved', { gate_id: gateId, resolution, actor }, { run_id: runId, session_id: sessionId });
+}
+
+function emitLessonPromoted(projectRoot, runId, lessonId, frequency, impact) {
+  return emit(projectRoot, 'LessonPromoted', { lesson_id: lessonId, frequency, impact }, { run_id: runId });
+}
+
+function emitRetroPublished(projectRoot, runId, lessonsAdded, lessonsUpdated) {
+  return emit(projectRoot, 'RetroPublished', { run_id: runId, lessons_added: lessonsAdded, lessons_updated: lessonsUpdated }, { run_id: runId });
+}
+
+function readEvents(projectRoot, filters = {}) {
+  const eventsPath = path.join(projectRoot, '.oxe', EVENTS_FILE);
+
+  if (!fs.existsSync(eventsPath)) {
+    return [];
+  }
+
+  try {
+    const lines = fs.readFileSync(eventsPath, 'utf8').split('\n').filter(Boolean);
+    let events = lines.map(line => {
+      try { return JSON.parse(line); } catch { return null; }
+    }).filter(Boolean);
+
+    if (filters.run_id) {
+      events = events.filter(e => e.run_id === filters.run_id);
+    }
+    if (filters.type) {
+      events = events.filter(e => e.type === filters.type);
+    }
+    if (filters.since) {
+      events = events.filter(e => e.timestamp >= filters.since);
+    }
+
+    return events;
+  } catch {
+    return [];
+  }
+}
+
+module.exports = {
+  emit,
+  emitRunStarted,
+  emitWorkItemCompleted,
+  emitWorkItemBlocked,
+  emitRunCompleted,
+  emitGateRequested,
+  emitGateResolved,
+  emitLessonPromoted,
+  emitRetroPublished,
+  readEvents,
+};

package/bin/lib/oxe-memory-kernel.cjs

@@ -0,0 +1,188 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * OXE Memory Kernel
+ *
+ * Recupera memória relevante ao objetivo atual lendo as 4 camadas de memória do OXE
+ * na ordem definida por buildMemoryLayers() (oxe-operational.cjs:2364):
+ *   1. runtime_state  → .oxe/STATE.md
+ *   2. session_memory → .oxe/<session>/SESSION.md
+ *   3. project_memory → .oxe/memory/REPO-MEMORY.md
+ *   4. lessons        → .oxe/global/LESSONS.md
+ *   5. observations   → .oxe/OBSERVATIONS.md
+ *
+ * Retorna um context pack filtrado por intent_tags e phase.
+ */
+
+function readFileSafe(filePath) {
+  try {
+    if (fs.existsSync(filePath)) {
+      return fs.readFileSync(filePath, 'utf8');
+    }
+  } catch {
+    // non-fatal
+  }
+  return null;
+}
+
+function extractRelevantFragments(content, intentTags, phase) {
+  if (!content) return [];
+
+  const lines = content.split('\n');
+  const fragments = [];
+  let currentSection = null;
+  let currentLines = [];
+  let currentScore = 0;
+
+  const scoreFragment = (text) => {
+    let score = 0;
+    for (const tag of intentTags) {
+      if (text.toLowerCase().includes(tag.toLowerCase())) score += 3;
+    }
+    if (text.includes('Impacto: alto') || text.includes('impact: high')) score += 2;
+    if (text.includes('Frequência: 3') || text.includes('Frequência: 4') || text.includes('Frequência: 5')) score += 2;
+    if (text.includes(phase)) score += 2;
+    if (text.includes('Frequência: 2')) score += 1;
+    if (text.includes('Status: ativo') || text.includes('status: active')) score += 1;
+    return score;
+  };
+
+  for (const line of lines) {
+    if (line.startsWith('## ') || line.startsWith('### ')) {
+      if (currentSection && currentLines.length > 0 && currentScore > 0) {
+        fragments.push({ section: currentSection, content: currentLines.join('\n'), score: currentScore });
+      }
+      currentSection = line.trim();
+      currentLines = [line];
+      currentScore = 0;
+    } else {
+      currentLines.push(line);
+      currentScore = Math.max(currentScore, scoreFragment(line));
+    }
+  }
+
+  if (currentSection && currentLines.length > 0 && currentScore > 0) {
+    fragments.push({ section: currentSection, content: currentLines.join('\n'), score: currentScore });
+  }
+
+  return fragments.sort((a, b) => b.score - a.score).slice(0, 10);
+}
+
+function retrieveMemory(projectRoot, intentTags, phase, objective) {
+  const layers = {
+    runtime_state: null,
+    session_memory: null,
+    project_memory: null,
+    lessons: null,
+    observations: null,
+  };
+
+  // Layer 1: runtime_state
+  layers.runtime_state = readFileSafe(path.join(projectRoot, '.oxe', 'STATE.md'));
+
+  // Layer 2: session_memory (read active session from STATE.md)
+  if (layers.runtime_state) {
+    const sessionMatch = layers.runtime_state.match(/active_session:\s*(.+)/);
+    if (sessionMatch && sessionMatch[1].trim() !== '—') {
+      const sessionPath = sessionMatch[1].trim();
+      layers.session_memory = readFileSafe(path.join(projectRoot, sessionPath, 'SESSION.md'))
+        || readFileSafe(path.join(projectRoot, '.oxe', sessionPath, 'SESSION.md'));
+    }
+  }
+
+  // Layer 3: project_memory
+  layers.project_memory = readFileSafe(path.join(projectRoot, '.oxe', 'memory', 'REPO-MEMORY.md'));
+
+  // Layer 4: lessons
+  layers.lessons = readFileSafe(path.join(projectRoot, '.oxe', 'global', 'LESSONS.md'));
+
+  // Layer 5: observations
+  layers.observations = readFileSafe(path.join(projectRoot, '.oxe', 'OBSERVATIONS.md'));
+
+  // Extract relevant fragments from each layer
+  const contextParts = [];
+
+  if (layers.runtime_state) {
+    contextParts.push(`### Estado Atual\n${layers.runtime_state.split('\n').slice(0, 20).join('\n')}`);
+  }
+
+  if (layers.project_memory) {
+    const frags = extractRelevantFragments(layers.project_memory, intentTags, phase);
+    if (frags.length > 0) {
+      contextParts.push(`### Memória do Projeto\n${frags.map(f => f.content).join('\n\n')}`);
+    }
+  }
+
+  if (layers.lessons) {
+    const frags = extractRelevantFragments(layers.lessons, intentTags, phase);
+    const activeFrags = frags.filter(f => f.content.includes('Status: ativo'));
+    if (activeFrags.length > 0) {
+      contextParts.push(`### Lições Aplicáveis\n${activeFrags.map(f => f.content).join('\n\n')}`);
+    }
+  }
+
+  if (layers.session_memory) {
+    contextParts.push(`### Contexto da Sessão\n${layers.session_memory.split('\n').slice(0, 30).join('\n')}`);
+  }
+
+  if (layers.observations) {
+    const pendingObs = layers.observations.split('\n\n').filter(block =>
+      block.includes('Status: pendente') &&
+      (block.includes('all') || intentTags.some(tag => block.toLowerCase().includes(tag)))
+    );
+    if (pendingObs.length > 0) {
+      contextParts.push(`### Observações Pendentes\n${pendingObs.join('\n\n')}`);
+    }
+  }
+
+  const hasMemory = contextParts.length > 1; // more than just state
+  const contextPack = [
+    `## Contexto de Memória — ${phase} / ${new Date().toISOString()}`,
+    `**Objetivo:** ${objective}`,
+    `**Intent Tags:** ${intentTags.join(', ')}`,
+    `**Fontes:** ${Object.entries(layers).filter(([, v]) => v).map(([k]) => k).join(', ')}`,
+    '',
+    ...contextParts,
+  ].join('\n');
+
+  return { contextPack, hasMemory, layers: Object.keys(layers).filter(k => layers[k]) };
+}
+
+function saveContextPack(projectRoot, contextPack, mode, phase) {
+  let outPath;
+
+  if (mode === 'agent') {
+    outPath = path.join(projectRoot, '.oxe', 'agent', 'MEMORY-INJECTIONS.md');
+  } else {
+    outPath = path.join(projectRoot, '.oxe', 'swarm', 'DECISIONS.md');
+  }
+
+  try {
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+
+    // For DECISIONS.md (swarm), prepend a section header
+    if (mode === 'swarm' && fs.existsSync(outPath)) {
+      const existing = fs.readFileSync(outPath, 'utf8');
+      if (!existing.includes('## Contexto de Memória')) {
+        fs.writeFileSync(outPath, existing + '\n\n' + contextPack, 'utf8');
+      }
+    } else {
+      fs.writeFileSync(outPath, contextPack, 'utf8');
+    }
+
+    // Also save snapshot in retrieved/
+    const retrievedDir = path.join(projectRoot, '.oxe', 'memory', 'retrieved');
+    fs.mkdirSync(retrievedDir, { recursive: true });
+    fs.writeFileSync(path.join(retrievedDir, `${phase}.md`), contextPack, 'utf8');
+  } catch {
+    // non-fatal
+  }
+}
+
+module.exports = {
+  retrieveMemory,
+  saveContextPack,
+};

package/bin/lib/oxe-project-health.cjs

@@ -2730,6 +2730,79 @@ function buildHealthReport(target) {
   };
 }
 
+/**
+ * Compact, stable projection of `buildHealthReport` for host integrations
+ * (IDEs, OXESpace). Versioned independently via `oxeSummarySchema` so a host
+ * can depend on a small, cheap payload instead of parsing the full ~100KB
+ * status. Pure — pass in a report from `buildHealthReport`.
+ * @param {ReturnType<typeof buildHealthReport>} report
+ */
+function buildStatusSummary(report) {
+  const next = (report && report.next) || {};
+  const gaps = Array.isArray(report && report.criticalExecutionGaps) ? report.criticalExecutionGaps.length : 0;
+  const planWarn = report && report.planSelfEvaluation && Array.isArray(report.planSelfEvaluation.warnings)
+    ? report.planSelfEvaluation.warnings.length
+    : 0;
+  return {
+    oxeSummarySchema: 1,
+    workspaceMode: (report && report.workspaceMode) || 'oxe_project',
+    phase: (report && report.phase) || null,
+    healthStatus: (report && report.healthStatus) || null,
+    activeSession: (report && report.activeSession) || null,
+    nextStep: next.step || null,
+    cursorCmd: next.cursorCmd || null,
+    reason: next.reason || null,
+    eventsCount: report && report.eventsSummary && typeof report.eventsSummary.total === 'number' ? report.eventsSummary.total : 0,
+    warningsCount: gaps + planWarn,
+  };
+}
+
+/**
+ * Per-agent OXE skills/integration status for a workspace. Lets a host detect
+ * when an agent lacks the `/oxe-*` skills BEFORE launching it — directly
+ * addresses the "Failed to load N skills" failure seen in agent CLIs. Reuses
+ * the tested copilot/codex integration reports plus a filesystem check of the
+ * Copilot CLI skills home (~/.copilot/skills).
+ * @param {string} target
+ */
+function agentSkillsReport(target) {
+  const agents = [];
+
+  const cp = copilotIntegrationReport(target);
+  agents.push({
+    agent: 'copilot-vscode',
+    detected: cp.detected,
+    skillsInstalled: cp.promptSource === 'workspace',
+    skillsPath: cp.workspace.promptsDir,
+    status: cp.status,
+    issues: cp.warnings || [],
+  });
+
+  const cx = codexIntegrationReport(target);
+  agents.push({
+    agent: 'codex',
+    detected: cx.detected,
+    skillsInstalled: Boolean(cx.skillsReady),
+    skillsPath: cx.skillsRoot,
+    status: cx.status,
+    issues: cx.warnings || [],
+  });
+
+  const cliSkillsRoot = path.join(copilotLegacyHome(), 'skills');
+  const cliSkillDirs = listOxeSkillDirs(cliSkillsRoot);
+  const cliInstalled = cliSkillDirs.length > 0;
+  agents.push({
+    agent: 'copilot-cli',
+    detected: cliInstalled,
+    skillsInstalled: cliInstalled,
+    skillsPath: cliSkillsRoot,
+    status: cliInstalled ? 'healthy' : 'not_installed',
+    issues: cliInstalled ? [] : ['Skills OXE ausentes em ~/.copilot/skills — rode `oxe install --copilot-cli` e depois `/skills reload`'],
+  });
+
+  return agents;
+}
+
 module.exports = {
   ALLOWED_CONFIG_KEYS,
   EXECUTION_PROFILES,
@@ -2775,6 +2848,8 @@ module.exports = {
   shouldSuppressExecutionWorkspaceGates,
   suggestNextStep,
   buildHealthReport,
+  buildStatusSummary,
+  agentSkillsReport,
   buildExecutionRationality: rationality.buildExecutionRationality,
   oxePaths,
   scopedOxePaths,

package/bin/lib/oxe-skill-loader.cjs

@@ -0,0 +1,131 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * OXE Skill Loader
+ *
+ * Resolve skills/personas por ID seguindo a ordem de precedência:
+ *   1. projeto: .oxe/skills/active/<id>.md
+ *   2. capabilities: .oxe/capabilities/<id>/SKILL.md
+ *   3. global: oxe/personas/<id>.md
+ *
+ * Retorna o conteúdo do skill/persona ou null se não encontrado.
+ */
+
+function resolveSkillPath(skillId, projectRoot) {
+  const candidates = [
+    path.join(projectRoot, '.oxe', 'skills', 'active', `${skillId}.md`),
+    path.join(projectRoot, '.oxe', 'capabilities', skillId, 'SKILL.md'),
+    path.join(projectRoot, 'oxe', 'personas', `${skillId}.md`),
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+function loadSkill(skillId, projectRoot) {
+  const skillPath = resolveSkillPath(skillId, projectRoot);
+  if (!skillPath) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(skillPath, 'utf8');
+    return { id: skillId, path: skillPath, content };
+  } catch {
+    return null;
+  }
+}
+
+function listSkills(projectRoot) {
+  const skills = { active: [], proposed: [], archived: [], global: [] };
+
+  const activeDir = path.join(projectRoot, '.oxe', 'skills', 'active');
+  const proposedDir = path.join(projectRoot, '.oxe', 'skills', 'proposed');
+  const archivedDir = path.join(projectRoot, '.oxe', 'skills', 'archived');
+  const globalDir = path.join(projectRoot, 'oxe', 'personas');
+
+  for (const [key, dir] of Object.entries({ active: activeDir, proposed: proposedDir, archived: archivedDir, global: globalDir })) {
+    if (fs.existsSync(dir)) {
+      skills[key] = fs.readdirSync(dir)
+        .filter(f => f.endsWith('.md'))
+        .map(f => f.replace('.md', ''));
+    }
+  }
+
+  return skills;
+}
+
+/**
+ * Seleciona personas aplicáveis a partir de intent_tags.
+ * Retorna lista de {id, persona_path, content} ordenada por prioridade.
+ */
+function selectPersonasForIntent(intentTags, projectRoot) {
+  const tagToPersona = {
+    backend:  { primary: 'executor', secondary: 'architect' },
+    frontend: { primary: 'ui-specialist', secondary: 'executor' },
+    storage:  { primary: 'db-specialist', secondary: 'architect' },
+    auth:     { primary: 'architect', secondary: 'executor' },
+    infra:    { primary: 'architect', secondary: null },
+    test:     { primary: 'executor', secondary: 'verifier' },
+    docs:     { primary: 'executor', secondary: null },
+    config:   { primary: 'executor', secondary: null },
+    research: { primary: 'researcher', secondary: null },
+    debug:    { primary: 'debugger', secondary: null },
+  };
+
+  const selected = new Map();
+
+  for (const tag of intentTags) {
+    const mapping = tagToPersona[tag];
+    if (!mapping) continue;
+    if (mapping.primary && !selected.has(mapping.primary)) {
+      selected.set(mapping.primary, 'primary');
+    }
+    if (mapping.secondary && !selected.has(mapping.secondary)) {
+      selected.set(mapping.secondary, 'secondary');
+    }
+  }
+
+  const result = [];
+  for (const [id, priority] of selected) {
+    const skill = loadSkill(id, projectRoot);
+    if (skill) {
+      result.push({ ...skill, priority });
+    }
+  }
+
+  return result;
+}
+
+function recordSkillsLoaded(skills, sessionDir) {
+  const record = {
+    loaded_at: new Date().toISOString(),
+    skills: skills.map(s => ({ id: s.id, path: s.path, priority: s.priority || 'explicit' })),
+  };
+
+  const outPath = path.join(sessionDir, 'SKILLS-LOADED.json');
+  try {
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, JSON.stringify(record, null, 2), 'utf8');
+  } catch {
+    // non-fatal
+  }
+
+  return record;
+}
+
+module.exports = {
+  loadSkill,
+  listSkills,
+  resolveSkillPath,
+  selectPersonasForIntent,
+  recordSkillsLoaded,
+};