@arka-labs/nemesis 1.2.0

package/src/commands/odm.js

@@ -0,0 +1,329 @@
+import { initOdm, listOdm, inspectOdm, setOdmStatus, assignOdm } from '../../lib/core/odm.js';
+import { readRegistry, getLanes } from '../../lib/core/registry.js';
+import { askText, askConfirm } from '../../lib/ui/prompt.js';
+import { interactiveMenu } from '../../lib/ui/menu.js';
+import { renderTable } from '../../lib/ui/table.js';
+import { formatOutput } from '../../lib/ui/format.js';
+import { style } from '../../lib/ui/colors.js';
+import { ensureProject, pickFromList, nextId, BACK_ITEM, HOME_ITEM } from './_helpers.js';
+import { getOdmFlowmapPhase } from '../../lib/core/flowmap/cli-helpers.js';
+import { getCurrentState } from '../../lib/core/flowmap/api.js';
+import { STEP_METADATA } from '../../lib/core/flowmap/machine.js';
+
+const HELP = `
+nemesis odm — Ordres de Mission
+
+Usage: nemesis odm <subcommand> [options]
+
+Subcommands:
+  init [id]                    Cree un OdM
+  list                         Liste les OdMs
+  inspect [id]                 Affiche le contenu complet d'un OdM + CR associes
+  set-status <id> <status>     Change le statut d'un OdM
+  assign <id> <agent>          Assigne un OdM a un agent
+
+Options:
+  -h, --help        Aide
+`;
+
+export async function handler({ args, flags, config }) {
+  if (flags.help || args.includes('--help') || args.includes('-h')) {
+    console.log(HELP);
+    return;
+  }
+
+  let sub = args[0];
+  let subArgs = args.slice(1);
+
+  if (!sub) {
+    sub = await interactiveMenu([
+      { label: 'list',       value: 'list',       description: 'Liste les OdMs' },
+      { label: 'init',       value: 'init',       description: 'Cree un OdM' },
+      { label: 'inspect',    value: 'inspect',    description: 'Affiche le contenu d\'un OdM' },
+      { label: 'set-status', value: 'set-status', description: 'Change le statut d\'un OdM' },
+      { label: 'assign',     value: 'assign',     description: 'Assigne un OdM a un agent' },
+      BACK_ITEM,
+      HOME_ITEM,
+    ], { title: 'nemesis odm' });
+    if (!sub || sub === '__back__') return '__back__';
+    if (sub === '__home__') return '__home__';
+    subArgs = [];
+  }
+
+  switch (sub) {
+    case 'init':
+      return handleInit(subArgs, flags, config);
+    case 'list':
+      return handleList(flags, config);
+    case 'inspect':
+      return handleInspect(subArgs, flags, config);
+    case 'set-status':
+      return handleSetStatus(subArgs, flags, config);
+    case 'assign':
+      return handleAssign(subArgs, flags, config);
+    default:
+      console.error(`Sous-commande inconnue : ${sub}`);
+      console.log(HELP);
+  }
+}
+
+async function handleInit(args, flags, config) {
+  const project = await ensureProject(config, flags);
+  if (!project) return;
+
+  // Auto-generate ID if not provided
+  let id = args[0];
+  if (!id) {
+    const existing = listOdm(project.hcm_dir);
+    const prefix = `ODM-${project.id}`;
+    const suggested = nextId(prefix, existing.map(o => o.id));
+    id = await askText('ID de l\'OdM', suggested);
+  }
+  if (!id) return;
+
+  const title = await askText('Titre');
+
+  // Assignee from registry
+  let assignedTo = '';
+  const registry = readRegistry(project.hcm_dir);
+  const lanes = registry ? getLanes(registry) : [];
+
+  if (lanes.length > 0) {
+    const assigneeItems = [
+      ...lanes.map(l => ({ label: `${l.name || l.id} (${l.role})`, value: l.id })),
+      { label: style.dim('(non assigne)'), value: '' },
+    ];
+    assignedTo = await interactiveMenu(assigneeItems, {
+      title: 'Assigne a',
+    });
+    if (assignedTo === null) assignedTo = '';
+  } else {
+    console.log(`\n  ${style.yellow('\u26A0')} Equipe vide — l'OdM sera non assigne.`);
+    console.log(`  ${style.dim('Ajoutez un agent apres : nemesis team add')}\n`);
+  }
+
+  // Priority via interactive menu
+  const priority = await interactiveMenu([
+    { label: 'HAUTE',   value: 'HAUTE' },
+    { label: 'MOYENNE', value: 'MOYENNE' },
+    { label: 'BASSE',   value: 'BASSE' },
+  ], { title: 'Priorite' });
+  if (!priority) return;
+
+  const result = initOdm(id, {
+    title, assignedTo, priority, root: config.cwd, projectId: project.id,
+  });
+
+  console.log(`\n  ${style.green('\u2713')} OdM cree : ${style.bold(id)}`);
+  console.log(`  ${style.dim('\u2192')} ${result.filepath.replace(config.cwd + '/', '')}`);
+
+  // Next steps
+  console.log(`\n  ${style.bold('Prochaines etapes')} :`);
+  console.log('  1. Completez le cadrage (scope, steps, rejection_criteria)');
+  if (!assignedTo) {
+    console.log(`  2. Assignez a un agent : ${style.dim('nemesis team add')}`);
+  } else {
+    console.log(`  2. L'agent ${style.bold(assignedTo)} peut demarrer l'execution`);
+  }
+  console.log('');
+
+  // Loop — propose to create another
+  const another = await askConfirm('Creer un autre OdM ?', false);
+  if (another) return handleInit([], flags, config);
+}
+
+async function handleList(flags, config) {
+  const project = await ensureProject(config, flags);
+  if (!project) return;
+
+  const odms = listOdm(project.hcm_dir);
+
+  if (flags.format === 'json') {
+    console.log(formatOutput(odms, 'json'));
+    return;
+  }
+
+  if (odms.length === 0) {
+    console.log(`\n  ${style.dim('Aucun OdM.')}`);
+    const doCreate = await askConfirm('Creer un OdM maintenant ?', true);
+    if (doCreate) {
+      return handleInit([], flags, config);
+    }
+    console.log('');
+    return;
+  }
+
+  // Enrich with FLOWMAP phase (mission_id from full OdM data)
+  const enriched = odms.map(o => {
+    let phase = '';
+    try {
+      const full = inspectOdm(o.id, project.hcm_dir);
+      phase = getOdmFlowmapPhase(full.odm.odm_meta, config.cwd) || '';
+    } catch { /* no-op */ }
+    return { ...o, flowmapPhase: phase };
+  });
+
+  console.log('');
+  console.log(renderTable(
+    [
+      { key: 'id', label: 'ID' },
+      { key: 'title', label: 'Titre' },
+      { key: 'assignee', label: 'Assigne' },
+      { key: 'priority', label: 'Priorite' },
+      { key: 'status', label: 'Status' },
+      { key: 'flowmapPhase', label: 'Phase' },
+    ],
+    enriched,
+  ));
+  console.log('');
+}
+
+async function handleInspect(args, flags, config) {
+  const project = await ensureProject(config, flags);
+  if (!project) return;
+
+  let id = args[0];
+
+  // If no ID → picker from existing OdMs
+  if (!id) {
+    const odms = listOdm(project.hcm_dir);
+    if (odms.length === 0) {
+      console.log(`\n  ${style.dim('Aucun OdM a inspecter.')}`);
+      const doCreate = await askConfirm('Creer un OdM maintenant ?', true);
+      if (doCreate) return handleInit([], flags, config);
+      return;
+    }
+    id = await pickFromList(odms, {
+      title: 'Quel OdM inspecter ?',
+      labelFn: (o) => `${o.id} — ${o.title || style.dim('(sans titre)')} [${o.status}]`,
+    });
+    if (!id) return;
+  }
+
+  const result = inspectOdm(id, project.hcm_dir);
+
+  if (flags.format === 'json') {
+    console.log(formatOutput(result, 'json'));
+    return;
+  }
+
+  console.log(`\n  ${style.bold('OdM')} : ${style.nemesisAccent(id)}`);
+  const meta = result.odm.odm_meta || {};
+  console.log(`  Status     : ${meta.status || '?'}`);
+  console.log(`  Priorite   : ${meta.priority || '?'}`);
+  console.log(`  Assigne a  : ${meta.assigned_to?.actor_id || style.dim('(non assigne)')}`);
+  console.log(`  Titre      : ${result.odm.odm_payload?.cadrage?.title || '?'}`);
+
+  // FLOWMAP position
+  if (meta.mission_id) {
+    const fmState = getCurrentState(meta.mission_id, { root: config.cwd });
+    if (fmState) {
+      const fmMeta = STEP_METADATA[fmState.value];
+      if (fmMeta) {
+        console.log(`  FLOWMAP    : ${fmState.value} [${fmMeta.phase}] ${fmMeta.label}`);
+      }
+    }
+  }
+
+  if (result.associatedCrs.length > 0) {
+    console.log('\n  CR associes :');
+    console.log(renderTable(
+      [
+        { key: 'id', label: 'CR' },
+        { key: 'title', label: 'Titre' },
+        { key: 'status', label: 'Status' },
+        { key: 'date', label: 'Date' },
+      ],
+      result.associatedCrs,
+    ));
+  } else {
+    console.log(`\n  CR associes : ${style.dim('(aucun)')}`);
+  }
+  console.log('');
+}
+
+async function handleSetStatus(args, flags, config) {
+  const project = await ensureProject(config, flags);
+  if (!project) return;
+
+  let id = args[0];
+  let newStatus = args[1];
+
+  // If no ID → picker from existing OdMs
+  if (!id) {
+    const odms = listOdm(project.hcm_dir);
+    if (odms.length === 0) {
+      console.log(`\n  ${style.dim('Aucun OdM.')}\n`);
+      return;
+    }
+    id = await pickFromList(odms, {
+      title: 'Quel OdM ?',
+      labelFn: (o) => `${o.id} — ${o.title || style.dim('(sans titre)')} [${o.status}]`,
+    });
+    if (!id) return;
+  }
+
+  if (!newStatus) {
+    const statusChoices = [
+      { label: 'READY_TO_DISPATCH', value: 'READY_TO_DISPATCH', description: 'Pret pour l\'orchestrateur' },
+      { label: 'ASSIGNED',          value: 'ASSIGNED',          description: 'Assigne a un agent' },
+      { label: 'DISPATCHING',       value: 'DISPATCHING',       description: 'En cours de dispatch' },
+    ];
+    newStatus = await interactiveMenu(statusChoices, { title: 'Nouveau statut' });
+    if (!newStatus) return;
+  }
+
+  try {
+    const result = setOdmStatus(id, newStatus, project.hcm_dir);
+    console.log(`\n  ${style.green('\u2713')} ${style.bold(id)} : ${result.oldStatus} → ${style.nemesisAccent(result.newStatus)}\n`);
+  } catch (err) {
+    console.log(`\n  ${style.red('\u2717')} ${err.message}\n`);
+  }
+}
+
+async function handleAssign(args, flags, config) {
+  const project = await ensureProject(config, flags);
+  if (!project) return;
+
+  let id = args[0];
+  let agentId = args[1];
+
+  // If no ID → picker
+  if (!id) {
+    const odms = listOdm(project.hcm_dir);
+    if (odms.length === 0) {
+      console.log(`\n  ${style.dim('Aucun OdM.')}\n`);
+      return;
+    }
+    id = await pickFromList(odms, {
+      title: 'Quel OdM assigner ?',
+      labelFn: (o) => `${o.id} — ${o.title || style.dim('(sans titre)')} [${o.status}]`,
+    });
+    if (!id) return;
+  }
+
+  // If no agent → picker from registry
+  if (!agentId) {
+    const registry = readRegistry(project.hcm_dir);
+    const lanes = registry ? getLanes(registry) : [];
+    if (lanes.length === 0) {
+      console.log(`\n  ${style.dim('Aucun agent enregistre.')}\n`);
+      return;
+    }
+    agentId = await interactiveMenu(
+      lanes.map(l => ({
+        label: `${l.name || l.id} (${l.role})`,
+        value: l.id,
+      })),
+      { title: 'Assigner a' },
+    );
+    if (!agentId) return;
+  }
+
+  try {
+    const result = assignOdm(id, agentId, project.hcm_dir);
+    console.log(`\n  ${style.green('\u2713')} ${style.bold(id)} assigne a ${style.nemesisAccent(result.assignedTo)}\n`);
+  } catch (err) {
+    console.log(`\n  ${style.red('\u2717')} ${err.message}\n`);
+  }
+}

package/src/commands/orch.js

@@ -0,0 +1,68 @@
+/**
+ * nemesis orch — Orchestration dashboard.
+ * Monitors dispatches, escalations, and deliveries via filesystem polling.
+ * L1 only — zero agent modification.
+ */
+
+import { style } from '../../lib/ui/colors.js';
+import { startDashboard, renderDashboard } from '../../lib/ui/dashboard.js';
+
+const HELP = `
+nemesis orch — Dashboard orchestration
+
+Usage: nemesis orch [options]
+
+Affiche l'etat courant des dispatches, escalades et livraisons.
+Rafraichissement automatique toutes les 2s.
+
+Options:
+  --once              Afficher une fois et quitter
+  --interval <ms>     Intervalle de polling (default: 2000)
+  -h, --help          Aide
+`;
+
+export async function handler({ args, flags, config }) {
+  if (flags.help || args.includes('--help') || args.includes('-h')) {
+    console.log(HELP);
+    return;
+  }
+
+  const root = config.cwd;
+  const once = args.includes('--once');
+
+  if (once || flags.format === 'json') {
+    // Single render
+    if (flags.format === 'json') {
+      const { detectState } = await import('../../lib/ui/dashboard.js');
+      const data = detectState(root);
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      console.log(renderDashboard(root));
+    }
+    return;
+  }
+
+  // Parse --interval
+  let interval = 2000;
+  const intervalIdx = args.indexOf('--interval');
+  if (intervalIdx !== -1 && args[intervalIdx + 1]) {
+    const parsed = parseInt(args[intervalIdx + 1], 10);
+    if (!isNaN(parsed) && parsed >= 500) interval = parsed;
+  }
+
+  console.log(`  ${style.dim('Dashboard orchestration — q pour quitter')}\n`);
+
+  const _dashboard = startDashboard(root, { pollInterval: interval });
+
+  // Keep process alive until dashboard stops
+  await new Promise(resolve => {
+    const check = setInterval(() => {
+      // Dashboard will call process.exit on quit
+    }, 1000);
+
+    process.on('beforeExit', () => {
+      clearInterval(check);
+      resolve();
+    });
+  });
+}

package/src/commands/project.js

@@ -0,0 +1,123 @@
+import { getProjectStatus } from '../../lib/core/project.js';
+import { readRegistry, getLanes, getPM } from '../../lib/core/registry.js';
+import { renderTable } from '../../lib/ui/table.js';
+import { formatOutput } from '../../lib/ui/format.js';
+import { style } from '../../lib/ui/colors.js';
+import { ensureProject } from './_helpers.js';
+import { getFlowmapSummary } from '../../lib/core/flowmap/cli-helpers.js';
+
+const HELP = `
+nemesis project — Vue projet
+
+Usage: nemesis project <subcommand>
+
+Subcommands:
+  status            Vue synthetique de l'etat du projet
+  init              Alias de "nemesis init"
+
+Options:
+  -h, --help        Aide
+`;
+
+export async function handler({ args, flags, config }) {
+  if (flags.help || args.includes('--help') || args.includes('-h')) {
+    console.log(HELP);
+    return;
+  }
+
+  const sub = args[0] || 'status';
+
+  switch (sub) {
+    case 'status':
+      return handleStatus(flags, config);
+    case 'init': {
+      const initMod = await import('./init.js');
+      return initMod.handler({ args: args.slice(1), flags, config });
+    }
+    default:
+      console.error(`Sous-commande inconnue : ${sub}`);
+      console.log(HELP);
+  }
+}
+
+async function handleStatus(flags, config) {
+  const project = await ensureProject(config, flags);
+  if (!project) return;
+
+  const status = getProjectStatus(project.hcm_dir);
+  const registry = readRegistry(project.hcm_dir);
+  const lanes = registry ? getLanes(registry) : [];
+  const pm = registry ? getPM(registry) : null;
+
+  const flowmapEntries = getFlowmapSummary(config.cwd);
+
+  if (flags.format === 'json') {
+    const flowmap = flowmapEntries.map(e => ({
+      missionId: e.missionId, state: e.state, phase: e.phase, who: e.who, step: e.state,
+    }));
+    console.log(formatOutput({ project, status, team: { pm, agents: lanes }, flowmap }, 'json'));
+    return;
+  }
+
+  console.log(`\n  ${style.bold('Projet')} : ${style.nemesisAccent(project.id)}`);
+  console.log(`  ${style.bold('Status')} : ${project.status || 'ACTIVE'}`);
+  console.log(`  ${style.bold('Equipe')} : ${lanes.length + 1} membres (1 PM, ${lanes.length} agents)\n`);
+
+  // OdMs table
+  if (status.odms.length > 0) {
+    console.log(`  ${style.bold('OdMs')} :`);
+    console.log(renderTable(
+      [
+        { key: 'id', label: 'OdM' },
+        { key: 'status', label: 'Status' },
+        { key: 'assignee', label: 'Assigne a' },
+        { key: 'priority', label: 'Priorite' },
+      ],
+      status.odms,
+    ));
+  } else {
+    console.log(`  OdMs : ${style.dim('(aucun)')}`);
+  }
+
+  // FLOWMAP
+  if (flowmapEntries.length > 0) {
+    console.log(`  ${style.bold('FLOWMAP')} :`);
+    console.log(renderTable(
+      [
+        { key: 'missionId', label: 'Mission' },
+        { key: 'phase', label: 'Phase' },
+        { key: 'state', label: 'Etape' },
+        { key: 'who', label: 'Qui' },
+      ],
+      flowmapEntries,
+    ));
+  } else {
+    console.log(`  Missions actives : ${style.dim('(aucune)')}`);
+  }
+
+  console.log('');
+
+  // Decisions
+  if (status.decisions.length > 0) {
+    console.log('  Decisions recentes :');
+    for (const dec of status.decisions.slice(-5)) {
+      console.log(`  - ${dec.id} : ${dec.title} (${dec.status})`);
+    }
+  } else {
+    console.log(`  Decisions recentes : ${style.dim('(aucune)')}`);
+  }
+
+  console.log('');
+
+  // CRs
+  if (status.crs.length > 0) {
+    console.log('  Derniers depots :');
+    for (const cr of status.crs.slice(-5)) {
+      console.log(`  - ${cr.id} (${cr.date || cr.status})`);
+    }
+  } else {
+    console.log(`  Derniers depots : ${style.dim('(aucun)')}`);
+  }
+
+  console.log('');
+}

package/src/commands/run.js

@@ -0,0 +1,123 @@
+import { spawn } from 'node:child_process';
+import { readRegistry, getLanes } from '../../lib/core/registry.js';
+import { createStreamBox } from '../../lib/ui/streambox.js';
+import { titledBox } from '../../lib/ui/box.js';
+import { style } from '../../lib/ui/colors.js';
+import { ensureProject, getFlag } from './_helpers.js';
+
+const HELP = `
+nemesis run — Reprendre une session agent
+
+Usage: nemesis run agent:<NAME> [options]
+
+Options:
+  --p <prompt>     Envoyer un prompt direct (non-interactif)
+  -h, --help       Aide
+`;
+
+export async function handler({ args, flags, config }) {
+  if (flags.help || args.includes('--help') || args.includes('-h')) {
+    console.log(HELP);
+    return;
+  }
+
+  const project = await ensureProject(config, flags);
+  if (!project) return;
+
+  // Parse agent:<NAME>
+  const agentArg = args[0];
+  if (!agentArg || !agentArg.startsWith('agent:')) {
+    console.error(`\n  ${style.red('Usage')}: nemesis run agent:<NAME>\n`);
+    return;
+  }
+  const agentName = agentArg.slice('agent:'.length);
+  if (!agentName) {
+    console.error(`\n  ${style.red('Nom d\'agent manquant')} apres agent:\n`);
+    return;
+  }
+
+  // Lookup registry
+  const registry = readRegistry(project.hcm_dir);
+  if (!registry) {
+    console.error(`\n  ${style.red('Registry introuvable.')} Lancez ${style.bold('nemesis init')} d'abord.\n`);
+    return;
+  }
+
+  const lanes = getLanes(registry);
+  const lane = lanes.find(l => l.id === agentName || l.name === agentName);
+  if (!lane) {
+    console.error(`\n  ${style.red('Agent inconnu')} : ${agentName}`);
+    console.error(`  Agents disponibles : ${lanes.map(l => l.id).join(', ') || style.dim('(aucun)')}`);
+    console.error(`  Utilisez ${style.bold('nemesis team add')} pour onboard un agent.\n`);
+    return;
+  }
+
+  if (!lane.session_id) {
+    console.error(`\n  ${style.red('Pas de session')} pour ${agentName}.`);
+    console.error(`  Lancez d'abord ${style.bold('nemesis team add')} pour onboarder l'agent.\n`);
+    return;
+  }
+
+  const prompt = getFlag(args, '--p');
+
+  if (prompt) {
+    // Prompt direct — stream-json output
+    console.log(`\n  ${style.bold('Prompt direct')} → ${style.nemesisAccent(agentName)}\n`);
+    const box = createStreamBox(4);
+
+    try {
+      const child = spawn('claude', [
+        '--resume', lane.session_id,
+        '-p', prompt,
+        '--output-format', 'stream-json',
+        '--verbose',
+        '--dangerously-skip-permissions',
+      ], { stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env } });
+
+      let finalResult = '';
+
+      child.stdout.on('data', (chunk) => {
+        for (const raw of chunk.toString().split('\n')) {
+          if (!raw.trim()) continue;
+          try {
+            const evt = JSON.parse(raw);
+            if (evt.type === 'assistant' && evt.message?.content) {
+              for (const block of evt.message.content) {
+                if (block.type === 'text' && block.text) {
+                  for (const tl of block.text.split('\n').filter(Boolean)) {
+                    box.push(style.dim(tl));
+                  }
+                }
+              }
+            }
+            if (evt.type === 'result') {
+              finalResult = evt.result || '';
+            }
+          } catch { /* ignore */ }
+        }
+      });
+
+      await new Promise((resolve) => child.on('close', resolve));
+      box.clear();
+
+      if (finalResult) {
+        const lines = finalResult.split('\n');
+        console.log(titledBox('Reponse', lines, { border: style.nemesisAccent }));
+        console.log('');
+      }
+    } catch (err) {
+      console.error(`\n  ${style.red('Erreur')}: ${err.message}\n`);
+    }
+  } else {
+    // Interactive mode — inherit stdio
+    console.log(`\n  ${style.bold('Session interactive')} → ${style.nemesisAccent(agentName)}`);
+    console.log(`  ${style.dim('Session ID')}: ${lane.session_id}\n`);
+
+    const child = spawn('claude', ['--resume', lane.session_id, '--dangerously-skip-permissions'], {
+      stdio: 'inherit',
+      env: { ...process.env },
+    });
+
+    await new Promise((resolve) => child.on('close', resolve));
+  }
+}