agentxchain 2.96.1 → 2.97.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxchain",
-  "version": "2.96.1",
+  "version": "2.97.0",
   "description": "CLI for AgentXchain — governed multi-agent software delivery",
   "type": "module",
   "bin": {

package/src/commands/replay-export.js

@@ -17,6 +17,190 @@ import { createBridgeServer } from '../lib/dashboard/bridge-server.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
+function restoreExportFiles(root, files, scopeLabel) {
+  if (!files || typeof files !== 'object') {
+    throw new Error(`${scopeLabel} is missing a valid files object.`);
+  }
+
+  let restored = 0;
+  for (const [relPath, entry] of Object.entries(files)) {
+    const absPath = join(root, relPath);
+    mkdirSync(dirname(absPath), { recursive: true });
+
+    if (typeof entry === 'string') {
+      writeFileSync(absPath, entry);
+      restored++;
+      continue;
+    }
+
+    if (!entry || typeof entry !== 'object' || typeof entry.content_base64 !== 'string') {
+      throw new Error(`${scopeLabel} entry "${relPath}" must provide content_base64.`);
+    }
+
+    writeFileSync(absPath, Buffer.from(entry.content_base64, 'base64'));
+    restored++;
+  }
+
+  return restored;
+}
+
+function restoreCoordinatorRepos(tempRoot, repos) {
+  if (!repos || typeof repos !== 'object') {
+    return 0;
+  }
+
+  let restored = 0;
+  for (const [repoId, repoEntry] of Object.entries(repos)) {
+    if (!repoEntry || repoEntry.ok === false) {
+      continue;
+    }
+
+    if (typeof repoEntry.path !== 'string' || !repoEntry.path.trim()) {
+      throw new Error(`Coordinator repo "${repoId}" is marked ok but has no path.`);
+    }
+
+    const nestedFiles = repoEntry.export?.files;
+    if (!nestedFiles || typeof nestedFiles !== 'object') {
+      throw new Error(`Coordinator repo "${repoId}" is marked ok but has no nested export.files.`);
+    }
+
+    const repoRoot = join(tempRoot, repoEntry.path);
+    mkdirSync(repoRoot, { recursive: true });
+    restored += restoreExportFiles(repoRoot, nestedFiles, `repos.${repoId}.export.files`);
+  }
+
+  return restored;
+}
+
+function readEmbeddedJsonEntry(entry, label) {
+  if (!entry || typeof entry !== 'object') {
+    throw new Error(`${label} is not a valid export file entry.`);
+  }
+
+  if (entry.data && typeof entry.data === 'object') {
+    return entry.data;
+  }
+
+  if (typeof entry.content_base64 !== 'string' || !entry.content_base64) {
+    throw new Error(`${label} must provide content_base64.`);
+  }
+
+  try {
+    return JSON.parse(Buffer.from(entry.content_base64, 'base64').toString('utf8'));
+  } catch (err) {
+    throw new Error(`${label} contains invalid JSON: ${err.message}`);
+  }
+}
+
+function getCoordinatorReplayPhases(exportData) {
+  const coordinatorConfig = exportData?.config
+    || readEmbeddedJsonEntry(exportData?.files?.['agentxchain-multi.json'], 'files["agentxchain-multi.json"]');
+  const routingPhases = Object.keys(coordinatorConfig?.routing || {});
+  if (routingPhases.length > 0) {
+    return routingPhases;
+  }
+
+  const phases = [];
+  for (const workstreamId of Object.keys(coordinatorConfig?.workstreams || {})) {
+    const phase = coordinatorConfig.workstreams?.[workstreamId]?.phase;
+    if (phase && !phases.includes(phase)) {
+      phases.push(phase);
+    }
+  }
+
+  return phases.length > 0 ? phases : ['planning'];
+}
+
+function restoreFailedCoordinatorRepoStubs(tempRoot, exportData) {
+  if (!exportData?.repos || typeof exportData.repos !== 'object') {
+    return 0;
+  }
+
+  const phases = getCoordinatorReplayPhases(exportData);
+  const coordinatorState = exportData?.files?.['.agentxchain/multirepo/state.json']
+    ? readEmbeddedJsonEntry(exportData.files['.agentxchain/multirepo/state.json'], 'files[".agentxchain/multirepo/state.json"]')
+    : null;
+
+  let restored = 0;
+  for (const [repoId, repoEntry] of Object.entries(exportData.repos)) {
+    if (!repoEntry || repoEntry.ok !== false) {
+      continue;
+    }
+
+    if (typeof repoEntry.path !== 'string' || !repoEntry.path.trim()) {
+      throw new Error(`Coordinator repo "${repoId}" failed export but has no path.`);
+    }
+
+    const repoRoot = join(tempRoot, repoEntry.path);
+    const promptPath = '.agentxchain/prompts/replay.md';
+    const repoRun = coordinatorState?.repo_runs?.[repoId] || {};
+    const defaultPhase = repoRun.phase || phases[0] || 'planning';
+    const routing = Object.fromEntries(
+      phases.map((phase) => [
+        phase,
+        {
+          entry_role: 'replay',
+          allowed_next_roles: ['replay', 'human'],
+        },
+      ]),
+    );
+    const config = {
+      schema_version: '1.0',
+      template: 'generic',
+      project: {
+        id: `${repoId}-replay-placeholder`,
+        name: `${repoId} Replay Placeholder`,
+      },
+      roles: {
+        replay: {
+          title: 'Replay Placeholder',
+          mandate: 'Preserve coordinator replay continuity when nested repo export is unavailable.',
+          write_authority: 'review_only',
+          runtime: 'replay-placeholder',
+        },
+      },
+      runtimes: {
+        'replay-placeholder': { type: 'manual' },
+      },
+      routing,
+      gates: {},
+      prompts: {
+        replay: promptPath,
+      },
+      rules: {
+        challenge_required: true,
+        max_turn_retries: 2,
+        max_deadlock_cycles: 2,
+      },
+    };
+    const state = {
+      schema_version: '1.1',
+      run_id: repoRun.run_id || null,
+      status: repoRun.status || 'blocked',
+      phase: defaultPhase,
+      active_turns: {},
+      turn_sequence: 0,
+      retained_turns: {},
+      budget_reservations: {},
+      phase_gate_status: {},
+    };
+
+    mkdirSync(join(repoRoot, '.agentxchain', 'prompts'), { recursive: true });
+    writeFileSync(join(repoRoot, 'agentxchain.json'), `${JSON.stringify(config, null, 2)}\n`);
+    writeFileSync(join(repoRoot, '.agentxchain', 'state.json'), `${JSON.stringify(state, null, 2)}\n`);
+    writeFileSync(join(repoRoot, '.agentxchain', 'history.jsonl'), '');
+    writeFileSync(join(repoRoot, '.agentxchain', 'events.jsonl'), '');
+    writeFileSync(join(repoRoot, '.agentxchain', 'decision-ledger.jsonl'), '');
+    writeFileSync(
+      join(repoRoot, promptPath),
+      '# Replay Placeholder\n\nThis repo export was unavailable in the coordinator artifact. Replay restores a placeholder so coordinator dashboards remain readable.\n',
+    );
+    restored += 6;
+  }
+
+  return restored;
+}
+
 export async function replayExportCommand(exportFile, opts = {}) {
   if (!exportFile) {
     console.error(chalk.red('Usage: agentxchain replay export <export-file>'));
@@ -51,21 +235,22 @@ export async function replayExportCommand(exportFile, opts = {}) {
     mkdirSync(tempRoot, { recursive: true });
     mkdirSync(tempAgentxchainDir, { recursive: true });
 
-    // Write all embedded files from the export
-    let fileCount = 0;
-    for (const [relPath, content] of Object.entries(exportData.files)) {
-      const absPath = join(tempRoot, relPath);
-      mkdirSync(dirname(absPath), { recursive: true });
-      writeFileSync(absPath, typeof content === 'string' ? content : JSON.stringify(content, null, 2));
-      fileCount++;
+    // Restore the real exported bytes for top-level files.
+    let fileCount = restoreExportFiles(tempRoot, exportData.files, 'files');
+
+    // Coordinator exports also need successful nested child repo exports
+    // rehydrated under their declared repo paths for dashboard replay.
+    if (exportData.export_kind === 'agentxchain_coordinator_export') {
+      fileCount += restoreCoordinatorRepos(tempRoot, exportData.repos);
+      fileCount += restoreFailedCoordinatorRepoStubs(tempRoot, exportData);
     }
 
     // Ensure agentxchain.json exists (needed by some dashboard endpoints)
     const configPath = join(tempRoot, 'agentxchain.json');
-    if (!existsSync(configPath)) {
+    if (exportData.export_kind !== 'agentxchain_coordinator_export' && !existsSync(configPath)) {
       // Synthesize a minimal config from export summary
       const minimalConfig = {
-        protocol_version: exportData.summary?.protocol_version || 6,
+        protocol_version: exportData.summary?.protocol_version || null,
         protocol_mode: 'governed',
         version: 4,
         project: { name: exportData.summary?.project_name || 'replay-export' },
@@ -153,6 +338,10 @@ export async function replayExportCommand(exportFile, opts = {}) {
       console.error(chalk.red(`Port ${opts.port || 3847} is already in use. Try --port <number>.`));
       process.exit(1);
     }
+    if (err instanceof Error) {
+      console.error(chalk.red(err.message));
+      process.exit(2);
+    }
     throw err;
   }
 }