oxe-cc 1.7.0 → 1.8.3

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

@@ -809,19 +809,52 @@ function copilotLegacyHome() {
   return path.join(os.homedir(), '.copilot');
 }
 
-function copilotLegacyPaths() {
-  const root = copilotLegacyHome();
-  return {
-    root,
-    promptsDir: path.join(root, 'prompts'),
-    instructions: path.join(root, 'copilot-instructions.md'),
-  };
-}
-
-/**
- * @param {string} filePath
- */
-function readJsonFileSafe(filePath) {
+function copilotLegacyPaths() {
+  const root = copilotLegacyHome();
+  return {
+    root,
+    promptsDir: path.join(root, 'prompts'),
+    instructions: path.join(root, 'copilot-instructions.md'),
+  };
+}
+
+function expandHomePath(value) {
+  if (typeof value !== 'string') return value;
+  if (value === '~') return os.homedir();
+  if (value.startsWith('~/') || value.startsWith('~\\')) return path.join(os.homedir(), value.slice(2));
+  return value;
+}
+
+function codexHome() {
+  if (process.env.CODEX_HOME) return path.resolve(expandHomePath(process.env.CODEX_HOME));
+  return path.join(os.homedir(), '.codex');
+}
+
+function codexIntegrationPaths() {
+  const root = codexHome();
+  return {
+    root,
+    promptsDir: path.join(root, 'prompts'),
+    skillsRoot: path.join(os.homedir(), '.agents', 'skills'),
+  };
+}
+
+/**
+ * @param {string} target
+ */
+function codexWorkspacePaths(target) {
+  const root = path.resolve(target);
+  return {
+    root,
+    promptsDir: path.join(root, '.codex', 'prompts'),
+    skillsRoot: path.join(root, '.agents', 'skills'),
+  };
+}
+
+/**
+ * @param {string} filePath
+ */
+function readJsonFileSafe(filePath) {
   if (!fs.existsSync(filePath)) return { ok: false, data: null, error: null };
   try {
     return { ok: true, data: JSON.parse(fs.readFileSync(filePath, 'utf8')), error: null };
@@ -1087,11 +1120,21 @@ function summarizeRecoveryState(target, activeSession, activeRun, verificationAr
   };
 }
 
-function summarizeEnterpriseRuntime(target, activeRun, activeSession, config) {
-  const pendingGates = readExecutionGates(target, activeSession);
-  const auditSummary = summarizeAuditTrail(target, activeRun && activeRun.run_id ? activeRun.run_id : null);
-  const runtimeMode = operational.buildRuntimeModeStatus(activeRun);
-  const providerCatalog = operational.buildRuntimeProviderCatalog(target);
+function summarizeEnterpriseRuntime(target, activeRun, activeSession, config) {
+  const pendingGates = readExecutionGates(target, activeSession);
+  const auditSummary = summarizeAuditTrail(target, activeRun && activeRun.run_id ? activeRun.run_id : null);
+  const runtimeModeBase = operational.buildRuntimeModeStatus(activeRun);
+  const providerCatalog = operational.buildRuntimeProviderCatalog(target);
+  const enterprisePackageAvailable = Boolean(providerCatalog && providerCatalog.available);
+  const runtimeMode = enterprisePackageAvailable && runtimeModeBase.enterprise_available === false
+    ? {
+        ...runtimeModeBase,
+        enterprise_available: true,
+        reason: runtimeModeBase.reason === 'Nenhum ACTIVE-RUN encontrado para o escopo atual.'
+          ? 'Runtime enterprise disponível no pacote, mas ainda sem ACTIVE-RUN canónico neste escopo.'
+          : 'Runtime enterprise disponível no pacote; a run atual ainda não materializou artefatos canónicos.',
+      }
+    : runtimeModeBase;
   if (!activeRun || !activeRun.run_id) {
     return {
       runtimeMode,
@@ -1270,19 +1313,45 @@ function summarizeEnterpriseRuntime(target, activeRun, activeSession, config) {
  * @param {string} dir
  * @returns {string[]}
  */
-function listOxePromptFiles(dir) {
-  if (!fs.existsSync(dir)) return [];
-  return fs
-    .readdirSync(dir, { withFileTypes: true })
-    .filter((entry) => entry.isFile() && /^oxe-.*\.prompt\.md$/i.test(entry.name))
+function listOxePromptFiles(dir) {
+  if (!fs.existsSync(dir)) return [];
+  return fs
+    .readdirSync(dir, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && /^oxe-.*\.prompt\.md$/i.test(entry.name))
     .map((entry) => path.join(dir, entry.name))
-    .sort();
-}
-
-/**
- * @param {string} filePath
- * @returns {boolean}
- */
+    .sort();
+}
+
+/**
+ * @param {string} dir
+ * @returns {string[]}
+ */
+function listOxeCodexPromptFiles(dir) {
+  if (!fs.existsSync(dir)) return [];
+  return fs
+    .readdirSync(dir, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && (entry.name === 'oxe.md' || /^oxe-.*\.md$/i.test(entry.name)))
+    .map((entry) => path.join(dir, entry.name))
+    .sort();
+}
+
+/**
+ * @param {string} root
+ * @returns {string[]}
+ */
+function listOxeSkillDirs(root) {
+  if (!fs.existsSync(root)) return [];
+  return fs
+    .readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && /^oxe($|-)/i.test(entry.name) && fs.existsSync(path.join(root, entry.name, 'SKILL.md')))
+    .map((entry) => path.join(root, entry.name))
+    .sort();
+}
+
+/**
+ * @param {string} filePath
+ * @returns {boolean}
+ */
 function hasOxeInstructionBlock(filePath) {
   if (!fs.existsSync(filePath)) return false;
   const text = fs.readFileSync(filePath, 'utf8');
@@ -1430,13 +1499,95 @@ function copilotIntegrationReport(target) {
     },
     manifest,
     warnings,
-  };
-}
-
-/**
- * Valida o arquivo plan-agents.json (se existir) e retorna avisos.
- * @param {string} target
- * @returns {string[]}
+  };
+}
+
+/**
+ * @param {string} target
+ */
+function codexIntegrationReport(target) {
+  const workspace = codexWorkspacePaths(target);
+  const globalPaths = codexIntegrationPaths();
+  const workspacePromptFiles = listOxeCodexPromptFiles(workspace.promptsDir);
+  const workspaceSkillDirs = listOxeSkillDirs(workspace.skillsRoot);
+  const globalPromptFiles = listOxeCodexPromptFiles(globalPaths.promptsDir);
+  const globalSkillDirs = listOxeSkillDirs(globalPaths.skillsRoot);
+  const workspaceDetected = workspacePromptFiles.length > 0 || workspaceSkillDirs.length > 0;
+  const globalDetected = globalPromptFiles.length > 0 || globalSkillDirs.length > 0;
+  const promptFiles = workspaceDetected ? workspacePromptFiles : globalPromptFiles;
+  const skillDirs = workspaceDetected ? workspaceSkillDirs : globalSkillDirs;
+  const promptNames = promptFiles.map((filePath) => path.basename(filePath));
+  const skillNames = skillDirs.map((dirPath) => path.basename(dirPath));
+  const promptPathWarnings = [];
+  for (const filePath of promptFiles) {
+    for (const warning of promptWorkflowPathWarnings(filePath, target)) promptPathWarnings.push(warning);
+  }
+
+  /** @type {string[]} */
+  const warnings = [];
+  const detected = workspaceDetected || globalDetected;
+  const promptSource = workspaceDetected ? 'workspace' : globalDetected ? 'global' : 'missing';
+  const commandsReady = promptNames.includes('oxe.md');
+  const skillsReady = skillNames.includes('oxe');
+  if (!workspaceDetected && globalDetected) {
+    warnings.push('Codex OXE foi encontrado apenas no ambiente global do usuário; este projeto não tem integração local instalada.');
+  }
+  if (detected && promptFiles.length === 0) {
+    warnings.push('Codex tem skills OXE instaladas, mas o diretório de prompts ativo não contém prompts OXE; a barra / não listará /oxe.');
+  }
+  if (promptFiles.length > 0 && !commandsReady) {
+    warnings.push('Codex prompts OXE existem, mas o entrypoint principal oxe.md está ausente.');
+  }
+  if (skillDirs.length > 0 && !skillsReady) {
+    warnings.push('Codex skills OXE existem, mas o skill raiz oxe está ausente.');
+  }
+  if (promptFiles.length > 0 && skillDirs.length === 0) {
+    warnings.push('Codex prompts OXE existem, mas ~/.agents/skills não contém skills OXE; recursos especializados podem não aparecer.');
+  }
+  for (const warning of promptPathWarnings) warnings.push(warning);
+
+  let status = 'not_installed';
+  if (commandsReady && skillsReady && promptPathWarnings.length === 0) {
+    status = warnings.length ? 'warning' : 'healthy';
+  } else if (detected) {
+    status = commandsReady ? 'warning' : 'broken';
+  }
+
+  return {
+    status,
+    detected,
+    commandsReady,
+    skillsReady,
+    promptSource,
+    root: workspaceDetected ? workspace.root : globalPaths.root,
+    promptsDir: workspaceDetected ? workspace.promptsDir : globalPaths.promptsDir,
+    skillsRoot: workspaceDetected ? workspace.skillsRoot : globalPaths.skillsRoot,
+    promptFiles,
+    skillDirs,
+    workspace: {
+      root: workspace.root,
+      promptsDir: workspace.promptsDir,
+      skillsRoot: workspace.skillsRoot,
+      promptFiles: workspacePromptFiles,
+      skillDirs: workspaceSkillDirs,
+      detected: workspaceDetected,
+    },
+    global: {
+      root: globalPaths.root,
+      promptsDir: globalPaths.promptsDir,
+      skillsRoot: globalPaths.skillsRoot,
+      promptFiles: globalPromptFiles,
+      skillDirs: globalSkillDirs,
+      detected: globalDetected,
+    },
+    warnings,
+  };
+}
+
+/**
+ * Valida o arquivo plan-agents.json (se existir) e retorna avisos.
+ * @param {string} target
+ * @returns {string[]}
  */
 function planAgentsWarnings(target) {
   const p = oxePaths(target);
@@ -1925,12 +2076,21 @@ function suggestNextStep(target, cfg = {}) {
     };
   }
 
+  if (!mapsComplete && !has(p.quick) && !has(p.spec) && !has(p.plan)) {
+    return {
+      step: 'oxe',
+      cursorCmd: '/oxe',
+      reason: 'Projeto recém-inicializado e sem SPEC/PLAN — use a entrada universal para começar o fluxo e escolher o primeiro scan.',
+      artifacts: ['.oxe/STATE.md', '.oxe/codebase/'],
+    };
+  }
+
   if (!mapsComplete && !has(p.quick)) {
-    return {
-      step: 'scan',
-      cursorCmd: '/oxe-scan',
-      reason: 'Mapas do codebase incompletos e sem QUICK.md — atualize o contexto com scan',
-      artifacts: ['.oxe/codebase/'],
+    return {
+      step: 'scan',
+      cursorCmd: '/oxe-scan',
+      reason: 'Mapas do codebase incompletos e sem QUICK.md — atualize o contexto com scan',
+      artifacts: ['.oxe/codebase/'],
     };
   }
 
@@ -2221,10 +2381,12 @@ function buildHealthReport(target) {
     ...planAgentsWarnings(target),
   ];
   const planWarn = suppressExecutionWorkspaceGates ? [] : executionPlanWarn;
-  const sessionWarn = sessionWarnings(target, activeSession);
+  const sessionWarn = sessionWarnings(target, activeSession);
   const installWarn = installationCompletenessWarnings(target);
   const copilot = copilotIntegrationReport(target);
   const copilotWarn = copilot.warnings;
+  const codex = codexIntegrationReport(target);
+  const codexWarn = codex.warnings;
   const reviewWarn = suppressExecutionWorkspaceGates ? [] : planReviewWarnings(stateText, p);
   const planSelfEvaluation = {
     ...parsedPlanSelfEvaluation,
@@ -2418,10 +2580,11 @@ function buildHealthReport(target) {
     planWarningCount +
     capabilityWarn.length +
     investigationWarn.length +
-    sessionWarn.length +
-    installWarn.length +
-    copilotWarn.length +
-    contextWarn.length +
+    sessionWarn.length +
+    installWarn.length +
+    copilotWarn.length +
+    codexWarn.length +
+    contextWarn.length +
     semanticsWarn.length +
     (azureReport ? azureReport.warnings.length : 0) +
     (sumWarn ? 1 : 0);
@@ -2450,9 +2613,11 @@ function buildHealthReport(target) {
     installWarn,
     copilotWarn,
     contextWarn,
-    semanticsWarn,
-    copilot,
-    summaryGapWarn: sumWarn,
+    semanticsWarn,
+    copilot,
+    codexWarn,
+    codex,
+    summaryGapWarn: sumWarn,
     specWarn,
     planWarn,
     planSelfEvaluation,
@@ -2532,9 +2697,11 @@ module.exports = {
   parsePlanReviewStatus,
   isStaleScan,
   isStaleLessons,
-  copilotWorkspacePaths,
-  copilotLegacyPaths,
+  copilotWorkspacePaths,
+  copilotLegacyPaths,
   copilotIntegrationReport,
+  codexIntegrationPaths,
+  codexIntegrationReport,
   normalizePlanConfidenceThreshold,
   isExecutablePlanConfidence,
   hasExecutablePlanSelfEvaluation,

package/bin/lib/oxe-rationality.cjs

@@ -350,14 +350,16 @@ function buildExecutionRationality(paths = {}) {
   const implementationPack = summarizeImplementationPack(paths.implementationPackJson || null, planTasks);
   const referenceAnchors = summarizeReferenceAnchors(paths.referenceAnchors || null, externalRefs);
   const fixturePack = summarizeFixturePack(paths.fixturePackJson || null, planTasks, implementationPack);
-  const criticalExecutionGaps = Array.from(
-    new Set([
-      ...implementationPack.criticalGaps,
-      ...referenceAnchors.criticalGaps,
-      ...fixturePack.criticalGaps,
-    ])
-  );
   const applicable = Boolean(paths.plan && fs.existsSync(paths.plan));
+  const criticalExecutionGaps = applicable
+    ? Array.from(
+      new Set([
+        ...implementationPack.criticalGaps,
+        ...referenceAnchors.criticalGaps,
+        ...fixturePack.criticalGaps,
+      ])
+    )
+    : [];
   return {
     applicable,
     planTaskCount: planTasks.length,